1// Copyright 2019 Google Inc. All rights reserved. 2// 3// Licensed under the Apache License, Version 2.0 (the "License"); 4// you may not use this file except in compliance with the License. 5// You may obtain a copy of the License at 6// 7// http://www.apache.org/licenses/LICENSE-2.0 8// 9// Unless required by applicable law or agreed to in writing, software 10// distributed under the License is distributed on an "AS IS" BASIS, 11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12// See the License for the specific language governing permissions and 13// limitations under the License. 14 15package java 16 17import ( 18 "github.com/google/blueprint" 19 20 "android/soong/android" 21) 22 23var ( 24 hiddenAPIGenerateCSVRule = pctx.AndroidStaticRule("hiddenAPIGenerateCSV", blueprint.RuleParams{ 25 Command: "${config.Class2NonSdkList} --stub-api-flags ${stubAPIFlags} $in $outFlag $out", 26 CommandDeps: []string{"${config.Class2NonSdkList}"}, 27 }, "outFlag", "stubAPIFlags") 28 29 hiddenAPIGenerateIndexRule = pctx.AndroidStaticRule("hiddenAPIGenerateIndex", blueprint.RuleParams{ 30 Command: "${config.MergeCsvCommand} --zip_input --key_field signature --output=$out $in", 31 CommandDeps: []string{"${config.MergeCsvCommand}"}, 32 }) 33) 34 35type hiddenAPI struct { 36 // True if the module containing this structure contributes to the hiddenapi information or has 37 // that information encoded within it. 38 active bool 39 40 // The path to the dex jar that is in the boot class path. If this is unset then the associated 41 // module is not a boot jar, but could be one of the <x>-hiddenapi modules that provide additional 42 // annotations for the <x> boot dex jar but which do not actually provide a boot dex jar 43 // themselves. 44 // 45 // This must be the path to the unencoded dex jar as the encoded dex jar indirectly depends on 46 // this file so using the encoded dex jar here would result in a cycle in the ninja rules. 47 bootDexJarPath OptionalDexJarPath 48 bootDexJarPathErr error 49 50 // The paths to the classes jars that contain classes and class members annotated with 51 // the UnsupportedAppUsage annotation that need to be extracted as part of the hidden API 52 // processing. 53 classesJarPaths android.Paths 54 55 // The compressed state of the dex file being encoded. This is used to ensure that the encoded 56 // dex file has the same state. 57 uncompressDexState *bool 58} 59 60func (h *hiddenAPI) bootDexJar(ctx android.ModuleErrorfContext) OptionalDexJarPath { 61 if h.bootDexJarPathErr != nil { 62 ctx.ModuleErrorf(h.bootDexJarPathErr.Error()) 63 } 64 return h.bootDexJarPath 65} 66 67func (h *hiddenAPI) classesJars() android.Paths { 68 return h.classesJarPaths 69} 70 71func (h *hiddenAPI) uncompressDex() *bool { 72 return h.uncompressDexState 73} 74 75// hiddenAPIModule is the interface a module that embeds the hiddenAPI structure must implement. 76type hiddenAPIModule interface { 77 android.Module 78 hiddenAPIIntf 79 80 MinSdkVersion(ctx android.EarlyModuleContext) android.ApiLevel 81} 82 83type hiddenAPIIntf interface { 84 bootDexJar(ctx android.ModuleErrorfContext) OptionalDexJarPath 85 classesJars() android.Paths 86 uncompressDex() *bool 87} 88 89var _ hiddenAPIIntf = (*hiddenAPI)(nil) 90 91// Initialize the hiddenapi structure 92// 93// uncompressedDexState should be nil when the module is a prebuilt and so does not require hidden 94// API encoding. 95func (h *hiddenAPI) initHiddenAPI(ctx android.ModuleContext, dexJar OptionalDexJarPath, classesJar android.Path, uncompressedDexState *bool) { 96 97 // Save the classes jars even if this is not active as they may be used by modular hidden API 98 // processing. 99 classesJars := android.Paths{classesJar} 100 ctx.VisitDirectDepsWithTag(hiddenApiAnnotationsTag, func(dep android.Module) { 101 if javaInfo, ok := android.OtherModuleProvider(ctx, dep, JavaInfoProvider); ok { 102 classesJars = append(classesJars, javaInfo.ImplementationJars...) 103 } 104 }) 105 h.classesJarPaths = classesJars 106 107 // Save the unencoded dex jar so it can be used when generating the 108 // hiddenAPISingletonPathsStruct.stubFlags file. 109 h.bootDexJarPath = dexJar 110 111 h.uncompressDexState = uncompressedDexState 112 113 // If hiddenapi processing is disabled treat this as inactive. 114 if ctx.Config().DisableHiddenApiChecks() { 115 return 116 } 117 118 // The context module must implement hiddenAPIModule. 119 module := ctx.Module().(hiddenAPIModule) 120 121 // If the frameworks/base directories does not exist and no prebuilt hidden API flag files have 122 // been configured then it is not possible to do hidden API encoding. 123 if !ctx.Config().FrameworksBaseDirExists(ctx) && ctx.Config().PrebuiltHiddenApiDir(ctx) == "" { 124 return 125 } 126 127 // It is important that hiddenapi information is only gathered for/from modules that are actually 128 // on the boot jars list because the runtime only enforces access to the hidden API for the 129 // bootclassloader. If information is gathered for modules not on the list then that will cause 130 // failures in the CtsHiddenApiBlocklist... tests. 131 h.active = isModuleInBootClassPath(ctx, module) 132} 133 134// Store any error encountered during the initialization of hiddenapi structure (e.g. unflagged co-existing prebuilt apexes) 135func (h *hiddenAPI) initHiddenAPIError(err error) { 136 h.bootDexJarPathErr = err 137} 138 139func isModuleInBootClassPath(ctx android.BaseModuleContext, module android.Module) bool { 140 // Get the configured platform and apex boot jars. 141 nonApexBootJars := ctx.Config().NonApexBootJars() 142 apexBootJars := ctx.Config().ApexBootJars() 143 active := isModuleInConfiguredList(ctx, module, nonApexBootJars) || 144 isModuleInConfiguredList(ctx, module, apexBootJars) 145 return active 146} 147 148// hiddenAPIEncodeDex is called by any module that needs to encode dex files. 149// 150// It ignores any module that has not had initHiddenApi() called on it and which is not in the boot 151// jar list. In that case it simply returns the supplied dex jar path. 152// 153// Otherwise, it creates a copy of the supplied dex file into which it has encoded the hiddenapi 154// flags and returns this instead of the supplied dex jar. 155func (h *hiddenAPI) hiddenAPIEncodeDex(ctx android.ModuleContext, dexJar android.Path) android.Path { 156 157 if !h.active { 158 return dexJar 159 } 160 161 // A nil uncompressDexState prevents the dex file from being encoded. 162 if h.uncompressDexState == nil { 163 ctx.ModuleErrorf("cannot encode dex file %s when uncompressDexState is nil", dexJar) 164 } 165 uncompressDex := *h.uncompressDexState 166 167 // Create a copy of the dex jar which has been encoded with hiddenapi flags. 168 flagsCSV := hiddenAPISingletonPaths(ctx).flags 169 outputDir := android.PathForModuleOut(ctx, "hiddenapi").OutputPath 170 encodedDex := hiddenAPIEncodeDex(ctx, dexJar, flagsCSV, uncompressDex, android.NoneApiLevel, outputDir) 171 172 // Use the encoded dex jar from here onwards. 173 return encodedDex 174} 175 176// buildRuleToGenerateAnnotationFlags builds a ninja rule to generate the annotation-flags.csv file 177// from the classes jars and stub-flags.csv files. 178// 179// The annotation-flags.csv file contains mappings from Java signature to various flags derived from 180// annotations in the source, e.g. whether it is public or the sdk version above which it can no 181// longer be used. 182// 183// It is created by the Class2NonSdkList tool which processes the .class files in the class 184// implementation jar looking for UnsupportedAppUsage and CovariantReturnType annotations. The 185// tool also consumes the hiddenAPISingletonPathsStruct.stubFlags file in order to perform 186// consistency checks on the information in the annotations and to filter out bridge methods 187// that are already part of the public API. 188func buildRuleToGenerateAnnotationFlags(ctx android.ModuleContext, desc string, classesJars android.Paths, stubFlagsCSV android.Path, outputPath android.WritablePath) { 189 ctx.Build(pctx, android.BuildParams{ 190 Rule: hiddenAPIGenerateCSVRule, 191 Description: desc, 192 Inputs: classesJars, 193 Output: outputPath, 194 Implicit: stubFlagsCSV, 195 Args: map[string]string{ 196 "outFlag": "--write-flags-csv", 197 "stubAPIFlags": stubFlagsCSV.String(), 198 }, 199 }) 200} 201 202// buildRuleToGenerateMetadata builds a ninja rule to generate the metadata.csv file from 203// the classes jars and stub-flags.csv files. 204// 205// The metadata.csv file contains mappings from Java signature to the value of properties specified 206// on UnsupportedAppUsage annotations in the source. 207// 208// Like the annotation-flags.csv file this is also created by the Class2NonSdkList in the same way. 209// Although the two files could potentially be created in a single invocation of the 210// Class2NonSdkList at the moment they are created using their own invocation, with the behavior 211// being determined by the property that is used. 212func buildRuleToGenerateMetadata(ctx android.ModuleContext, desc string, classesJars android.Paths, stubFlagsCSV android.Path, metadataCSV android.WritablePath) { 213 ctx.Build(pctx, android.BuildParams{ 214 Rule: hiddenAPIGenerateCSVRule, 215 Description: desc, 216 Inputs: classesJars, 217 Output: metadataCSV, 218 Implicit: stubFlagsCSV, 219 Args: map[string]string{ 220 "outFlag": "--write-metadata-csv", 221 "stubAPIFlags": stubFlagsCSV.String(), 222 }, 223 }) 224} 225 226// buildRuleToGenerateIndex builds a ninja rule to generate the index.csv file from the classes 227// jars. 228// 229// The index.csv file contains mappings from Java signature to source location information. 230// 231// It is created by the merge_csv tool which processes the class implementation jar, extracting 232// all the files ending in .uau (which are CSV files) and merges them together. The .uau files are 233// created by the unsupported app usage annotation processor during compilation of the class 234// implementation jar. 235func buildRuleToGenerateIndex(ctx android.ModuleContext, desc string, classesJars android.Paths, indexCSV android.WritablePath) { 236 ctx.Build(pctx, android.BuildParams{ 237 Rule: hiddenAPIGenerateIndexRule, 238 Description: desc, 239 Inputs: classesJars, 240 Output: indexCSV, 241 }) 242} 243 244var hiddenAPIEncodeDexRule = pctx.AndroidStaticRule("hiddenAPIEncodeDex", blueprint.RuleParams{ 245 Command: `rm -rf $tmpDir && mkdir -p $tmpDir && mkdir $tmpDir/dex-input && mkdir $tmpDir/dex-output && 246 unzip -qoDD $in 'classes*.dex' -d $tmpDir/dex-input && 247 for INPUT_DEX in $$(find $tmpDir/dex-input -maxdepth 1 -name 'classes*.dex' | sort); do 248 echo "--input-dex=$${INPUT_DEX}"; 249 echo "--output-dex=$tmpDir/dex-output/$$(basename $${INPUT_DEX})"; 250 done | xargs ${config.HiddenAPI} encode --api-flags=$flagsCsv $hiddenapiFlags && 251 ${config.SoongZipCmd} $soongZipFlags -o $tmpDir/dex.jar -C $tmpDir/dex-output -f "$tmpDir/dex-output/classes*.dex" && 252 ${config.MergeZipsCmd} -j -D -zipToNotStrip $tmpDir/dex.jar -stripFile "classes*.dex" -stripFile "**/*.uau" $out $tmpDir/dex.jar $in`, 253 CommandDeps: []string{ 254 "${config.HiddenAPI}", 255 "${config.SoongZipCmd}", 256 "${config.MergeZipsCmd}", 257 }, 258}, "flagsCsv", "hiddenapiFlags", "tmpDir", "soongZipFlags") 259 260// hiddenAPIEncodeDex generates the build rule that will encode the supplied dex jar and place the 261// encoded dex jar in a file of the same name in the output directory. 262// 263// The encode dex rule requires unzipping, encoding and rezipping the classes.dex files along with 264// all the resources from the input jar. It also ensures that if it was uncompressed in the input 265// it stays uncompressed in the output. 266func hiddenAPIEncodeDex(ctx android.ModuleContext, dexInput, flagsCSV android.Path, uncompressDex bool, minSdkVersion android.ApiLevel, outputDir android.OutputPath) android.OutputPath { 267 268 // The output file has the same name as the input file and is in the output directory. 269 output := outputDir.Join(ctx, dexInput.Base()) 270 271 // Create a jar specific temporary directory in which to do the work just in case this is called 272 // with the same output directory for multiple modules. 273 tmpDir := outputDir.Join(ctx, dexInput.Base()+"-tmp") 274 275 // If the input is uncompressed then generate the output of the encode rule to an intermediate 276 // file as the final output will need further processing after encoding. 277 soongZipFlags := "" 278 encodeRuleOutput := output 279 if uncompressDex { 280 soongZipFlags = "-L 0" 281 encodeRuleOutput = outputDir.Join(ctx, "unaligned", dexInput.Base()) 282 } 283 284 // b/149353192: when a module is instrumented, jacoco adds synthetic members 285 // $jacocoData and $jacocoInit. Since they don't exist when building the hidden API flags, 286 // don't complain when we don't find hidden API flags for the synthetic members. 287 hiddenapiFlags := "" 288 if j, ok := ctx.Module().(interface { 289 shouldInstrument(android.BaseModuleContext) bool 290 }); ok && j.shouldInstrument(ctx) { 291 hiddenapiFlags = "--no-force-assign-all" 292 } 293 294 // If the library is targeted for Q and/or R then make sure that they do not 295 // have any S+ flags encoded as that will break the runtime. 296 minApiLevel := minSdkVersion 297 if !minApiLevel.IsNone() { 298 if minApiLevel.LessThanOrEqualTo(android.ApiLevelOrPanic(ctx, "R")) { 299 hiddenapiFlags = hiddenapiFlags + " --max-hiddenapi-level=max-target-r" 300 } 301 } 302 303 ctx.Build(pctx, android.BuildParams{ 304 Rule: hiddenAPIEncodeDexRule, 305 Description: "hiddenapi encode dex", 306 Input: dexInput, 307 Output: encodeRuleOutput, 308 Implicit: flagsCSV, 309 Args: map[string]string{ 310 "flagsCsv": flagsCSV.String(), 311 "tmpDir": tmpDir.String(), 312 "soongZipFlags": soongZipFlags, 313 "hiddenapiFlags": hiddenapiFlags, 314 }, 315 }) 316 317 if uncompressDex { 318 TransformZipAlign(ctx, output, encodeRuleOutput, nil) 319 } 320 321 return output 322} 323 324type hiddenApiAnnotationsDependencyTag struct { 325 blueprint.BaseDependencyTag 326 android.LicenseAnnotationSharedDependencyTag 327} 328 329// Tag used to mark dependencies on java_library instances that contains Java source files whose 330// sole purpose is to provide additional hiddenapi annotations. 331var hiddenApiAnnotationsTag hiddenApiAnnotationsDependencyTag 332 333// Mark this tag so dependencies that use it are excluded from APEX contents. 334func (t hiddenApiAnnotationsDependencyTag) ExcludeFromApexContents() {} 335 336var _ android.ExcludeFromApexContentsTag = hiddenApiAnnotationsTag 337