blob: f7c5c13de28a9b4d16341968cae994053193bf54 [file] [log] [blame]
Colin Crossfabb6082018-02-20 17:22:23 -08001// Copyright 2018 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 (
Cole Faust6265120c2024-09-05 16:27:56 -070018 "crypto/sha256"
Colin Crossa592e3e2019-02-19 16:59:53 -080019 "fmt"
Jaewoong Jung5b425e22019-06-17 17:40:56 -070020 "path/filepath"
Colin Cross312634e2023-11-21 15:13:56 -080021 "slices"
Colin Crossa97c5d32018-03-28 14:58:31 -070022 "strings"
Colin Crossfabb6082018-02-20 17:22:23 -080023
Jaewoong Jung9befb0c2020-01-18 10:33:43 -080024 "android/soong/android"
Ulya Trafimovich31e444e2020-08-14 17:32:16 +010025 "android/soong/dexpreopt"
Jihoon Kangfe914ed2024-02-12 22:49:21 +000026
Colin Crossfabb6082018-02-20 17:22:23 -080027 "github.com/google/blueprint"
Colin Crossa14fb6a2024-10-23 16:57:06 -070028 "github.com/google/blueprint/depset"
Colin Crossa97c5d32018-03-28 14:58:31 -070029 "github.com/google/blueprint/proptools"
Colin Crossfabb6082018-02-20 17:22:23 -080030)
31
Colin Crossa97c5d32018-03-28 14:58:31 -070032type AndroidLibraryDependency interface {
Colin Crossa97c5d32018-03-28 14:58:31 -070033 ExportPackage() android.Path
Colin Crossa14fb6a2024-10-23 16:57:06 -070034 ResourcesNodeDepSet() depset.DepSet[*resourcesNode]
35 RRODirsDepSet() depset.DepSet[rroDir]
36 ManifestsDepSet() depset.DepSet[android.Path]
Jaewoong Jungc779cd42020-10-06 18:56:10 -070037 SetRROEnforcedForDependent(enforce bool)
38 IsRROEnforced(ctx android.BaseModuleContext) bool
Colin Crossa97c5d32018-03-28 14:58:31 -070039}
40
41func init() {
Paul Duffinf9b1da02019-12-18 19:51:55 +000042 RegisterAARBuildComponents(android.InitRegistrationContext)
43}
44
45func RegisterAARBuildComponents(ctx android.RegistrationContext) {
46 ctx.RegisterModuleType("android_library_import", AARImportFactory)
47 ctx.RegisterModuleType("android_library", AndroidLibraryFactory)
Paul Duffin04ba70d2021-03-22 13:56:43 +000048 ctx.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
Colin Crossc4441622024-09-18 14:55:49 -070049 ctx.Transition("propagate_rro_enforcement", &propagateRROEnforcementTransitionMutator{})
Paul Duffin04ba70d2021-03-22 13:56:43 +000050 })
Colin Crossa97c5d32018-03-28 14:58:31 -070051}
52
53//
54// AAR (android library)
55//
56
57type androidLibraryProperties struct {
58 BuildAAR bool `blueprint:"mutated"`
59}
60
61type aaptProperties struct {
62 // flags passed to aapt when creating the apk
63 Aaptflags []string
64
Dan Willemsen72be5902018-10-24 20:24:57 -070065 // include all resource configurations, not just the product-configured
66 // ones.
67 Aapt_include_all_resources *bool
68
Jiakai Zhangba82e282023-10-13 18:08:59 +010069 // list of files to use as assets.
70 Assets []string `android:"path"`
71
Colin Crossa97c5d32018-03-28 14:58:31 -070072 // list of directories relative to the Blueprints file containing assets.
Colin Cross0ddae7f2019-02-07 15:30:01 -080073 // Defaults to ["assets"] if a directory called assets exists. Set to []
74 // to disable the default.
Colin Crossa97c5d32018-03-28 14:58:31 -070075 Asset_dirs []string
76
77 // list of directories relative to the Blueprints file containing
Colin Cross0ddae7f2019-02-07 15:30:01 -080078 // Android resources. Defaults to ["res"] if a directory called res exists.
79 // Set to [] to disable the default.
Cole Faust5b989772024-11-06 11:03:16 -080080 Resource_dirs proptools.Configurable[[]string] `android:"path"`
Colin Crossa97c5d32018-03-28 14:58:31 -070081
Colin Crossa592e3e2019-02-19 16:59:53 -080082 // list of zip files containing Android resources.
Colin Cross27b922f2019-03-04 22:35:41 -080083 Resource_zips []string `android:"path"`
Colin Crossa592e3e2019-02-19 16:59:53 -080084
Colin Crossa97c5d32018-03-28 14:58:31 -070085 // path to AndroidManifest.xml. If unset, defaults to "AndroidManifest.xml".
Colin Cross27b922f2019-03-04 22:35:41 -080086 Manifest *string `android:"path"`
changho.shinb5432b72019-08-08 18:37:17 +090087
88 // paths to additional manifest files to merge with main manifest.
89 Additional_manifests []string `android:"path"`
Sasha Smundak541056c2019-10-28 15:50:06 -070090
91 // do not include AndroidManifest from dependent libraries
92 Dont_merge_manifests *bool
Jaewoong Jungc779cd42020-10-06 18:56:10 -070093
Colin Cross4eae06d2023-06-20 22:40:02 -070094 // If use_resource_processor is set, use Bazel's resource processor instead of aapt2 to generate R.class files.
95 // The resource processor produces more optimal R.class files that only list resources in the package of the
96 // library that provided them, as opposed to aapt2 which produces R.java files for every package containing
97 // every resource. Using the resource processor can provide significant build time speedups, but requires
98 // fixing the module to use the correct package to reference each resource, and to avoid having any other
99 // libraries in the tree that use the same package name. Defaults to false, but will default to true in the
100 // future.
101 Use_resource_processor *bool
102
Jaewoong Jungc779cd42020-10-06 18:56:10 -0700103 // true if RRO is enforced for any of the dependent modules
104 RROEnforcedForDependent bool `blueprint:"mutated"`
Inseob Kim34dc4cd2023-11-07 13:37:14 +0900105
106 // Filter only specified product and ignore other products
107 Filter_product *string `blueprint:"mutated"`
Jihoon Kang9049c272024-03-19 21:57:36 +0000108
109 // Names of aconfig_declarations modules that specify aconfig flags that the module depends on.
110 Flags_packages []string
Colin Crossa97c5d32018-03-28 14:58:31 -0700111}
112
113type aapt struct {
Colin Cross312634e2023-11-21 15:13:56 -0800114 aaptSrcJar android.Path
115 transitiveAaptRJars android.Paths
116 transitiveAaptResourcePackagesFile android.Path
117 exportPackage android.Path
118 manifestPath android.Path
119 proguardOptionsFile android.Path
120 rTxt android.Path
121 rJar android.Path
122 extraAaptPackagesFile android.Path
123 mergedManifestFile android.Path
124 noticeFile android.OptionalPath
125 assetPackage android.OptionalPath
126 isLibrary bool
127 defaultManifestVersion string
128 useEmbeddedNativeLibs bool
129 useEmbeddedDex bool
130 usesNonSdkApis bool
131 hasNoCode bool
132 LoggingParent string
133 resourceFiles android.Paths
Colin Crossa97c5d32018-03-28 14:58:31 -0700134
Colin Crosse560c4a2019-03-19 16:03:11 -0700135 splitNames []string
136 splits []split
137
Colin Crossa97c5d32018-03-28 14:58:31 -0700138 aaptProperties aaptProperties
Colin Crossab8d1382023-07-14 17:23:41 +0000139
Colin Crossa14fb6a2024-10-23 16:57:06 -0700140 resourcesNodesDepSet depset.DepSet[*resourcesNode]
141 rroDirsDepSet depset.DepSet[rroDir]
142 manifestsDepSet depset.DepSet[android.Path]
Alix96ea88452023-08-31 15:48:23 +0000143
144 manifestValues struct {
145 applicationId string
146 }
Colin Crossa97c5d32018-03-28 14:58:31 -0700147}
148
Colin Crosse560c4a2019-03-19 16:03:11 -0700149type split struct {
150 name string
151 suffix string
152 path android.Path
153}
154
Colin Crossc4441622024-09-18 14:55:49 -0700155// Propagate RRO enforcement flag to static lib dependencies transitively. If EnforceRROGlobally is set then
156// all modules will use the "" variant. If specific modules have RRO enforced, then modules (usually apps) with
157// RRO enabled will use the "" variation for themselves, but use the "rro" variant of direct and transitive static
158// android_library dependencies.
159type propagateRROEnforcementTransitionMutator struct{}
160
161func (p propagateRROEnforcementTransitionMutator) Split(ctx android.BaseModuleContext) []string {
162 // Never split modules, apps with or without RRO enabled use the "" variant, static android_library dependencies
163 // will use create the "rro" variant from incoming tranisitons.
164 return []string{""}
165}
166
167func (p propagateRROEnforcementTransitionMutator) OutgoingTransition(ctx android.OutgoingTransitionContext, sourceVariation string) string {
168 // Non-static dependencies are not involved in RRO and always use the empty variant.
169 if ctx.DepTag() != staticLibTag {
170 return ""
171 }
172
Jaewoong Jungc779cd42020-10-06 18:56:10 -0700173 m := ctx.Module()
Colin Crossc4441622024-09-18 14:55:49 -0700174 if _, ok := m.(AndroidLibraryDependency); ok {
175 // If RRO is enforced globally don't bother using "rro" variants, the empty variant will have RRO enabled.
176 if ctx.Config().EnforceRROGlobally() {
177 return ""
178 }
179
180 // If RRO is enabled for this module use the "rro" variants of static dependencies. IncomingTransition will
181 // rewrite this back to "" if the dependency is not an android_library.
182 if ctx.Config().EnforceRROForModule(ctx.Module().Name()) {
183 return "rro"
184 }
185 }
186
187 return sourceVariation
188}
189
190func (p propagateRROEnforcementTransitionMutator) IncomingTransition(ctx android.IncomingTransitionContext, incomingVariation string) string {
191 // Propagate the "rro" variant to android_library modules, but use the empty variant for everything else.
192 if incomingVariation == "rro" {
193 m := ctx.Module()
194 if _, ok := m.(AndroidLibraryDependency); ok {
195 return "rro"
196 }
197 return ""
198 }
199
200 return ""
201}
202
203func (p propagateRROEnforcementTransitionMutator) Mutate(ctx android.BottomUpMutatorContext, variation string) {
204 m := ctx.Module()
205 if d, ok := m.(AndroidLibraryDependency); ok {
206 if variation == "rro" {
207 // This is the "rro" variant of a module that has both variants, mark this one as RRO enabled and
208 // hide it from make to avoid collisions with the non-RRO empty variant.
209 d.SetRROEnforcedForDependent(true)
210 m.HideFromMake()
211 } else if ctx.Config().EnforceRROGlobally() {
212 // RRO is enabled globally, mark it enabled for this module, but there is only one variant so no
213 // need to hide it from make.
214 d.SetRROEnforcedForDependent(true)
215 }
Jaewoong Jungc779cd42020-10-06 18:56:10 -0700216 }
217}
218
Colin Cross8f1b0332024-01-25 13:39:06 -0800219func (a *aapt) useResourceProcessorBusyBox(ctx android.BaseModuleContext) bool {
Colin Crosseee4ab12024-03-27 11:54:10 -0700220 return BoolDefault(a.aaptProperties.Use_resource_processor, ctx.Config().UseResourceProcessorByDefault()) &&
221 // TODO(b/331641946): remove this when ResourceProcessorBusyBox supports generating shared libraries.
Spandan Dasa62d9562024-08-06 00:13:31 +0000222 !slices.Contains(a.aaptProperties.Aaptflags, "--shared-lib") &&
223 // Use the legacy resource processor in kythe builds.
224 // The legacy resource processor creates an R.srcjar, which kythe can use for generating crossrefs.
225 // TODO(b/354854007): Re-enable BusyBox in kythe builds
226 !ctx.Config().EmitXrefRules()
Colin Cross4eae06d2023-06-20 22:40:02 -0700227}
228
Inseob Kim34dc4cd2023-11-07 13:37:14 +0900229func (a *aapt) filterProduct() string {
230 return String(a.aaptProperties.Filter_product)
231}
232
Colin Crossa97c5d32018-03-28 14:58:31 -0700233func (a *aapt) ExportPackage() android.Path {
234 return a.exportPackage
235}
Colin Crossa14fb6a2024-10-23 16:57:06 -0700236func (a *aapt) ResourcesNodeDepSet() depset.DepSet[*resourcesNode] {
Colin Crossab8d1382023-07-14 17:23:41 +0000237 return a.resourcesNodesDepSet
Colin Crossc1c37552019-01-31 11:42:41 -0800238}
239
Colin Crossa14fb6a2024-10-23 16:57:06 -0700240func (a *aapt) RRODirsDepSet() depset.DepSet[rroDir] {
Colin Crossab8d1382023-07-14 17:23:41 +0000241 return a.rroDirsDepSet
Colin Crossc1c37552019-01-31 11:42:41 -0800242}
243
Colin Crossa14fb6a2024-10-23 16:57:06 -0700244func (a *aapt) ManifestsDepSet() depset.DepSet[android.Path] {
Colin Crossab8d1382023-07-14 17:23:41 +0000245 return a.manifestsDepSet
Jaewoong Jung6431ca72020-01-15 14:15:10 -0800246}
247
Jaewoong Jungc779cd42020-10-06 18:56:10 -0700248func (a *aapt) SetRROEnforcedForDependent(enforce bool) {
249 a.aaptProperties.RROEnforcedForDependent = enforce
250}
251
252func (a *aapt) IsRROEnforced(ctx android.BaseModuleContext) bool {
253 // True if RRO is enforced for this module or...
254 return ctx.Config().EnforceRROForModule(ctx.ModuleName()) ||
Jeongik Chacee5ba92021-02-19 12:11:51 +0900255 // if RRO is enforced for any of its dependents.
256 a.aaptProperties.RROEnforcedForDependent
Jaewoong Jungc779cd42020-10-06 18:56:10 -0700257}
258
Jiyong Parkf1691d22021-03-29 20:11:58 +0900259func (a *aapt) aapt2Flags(ctx android.ModuleContext, sdkContext android.SdkContext,
Spandan Das82229552024-12-06 01:38:45 +0000260 manifestPath android.Path, doNotIncludeAssetDirImplicitly bool) (compileFlags, linkFlags []string, linkDeps android.Paths,
Colin Crossa0ba2f52019-06-22 12:59:27 -0700261 resDirs, overlayDirs []globbedResourceDir, rroDirs []rroDir, resZips android.Paths) {
Colin Crossa97c5d32018-03-28 14:58:31 -0700262
Jaewoong Jung3aff5782020-02-11 07:54:35 -0800263 hasVersionCode := android.PrefixInList(a.aaptProperties.Aaptflags, "--version-code")
264 hasVersionName := android.PrefixInList(a.aaptProperties.Aaptflags, "--version-name")
Colin Crossa97c5d32018-03-28 14:58:31 -0700265
Colin Crossa97c5d32018-03-28 14:58:31 -0700266 // Flags specified in Android.bp
267 linkFlags = append(linkFlags, a.aaptProperties.Aaptflags...)
268
Eric Miao40eab202023-03-30 16:57:17 +0000269 linkFlags = append(linkFlags, "--enable-compact-entries")
Colin Crossa97c5d32018-03-28 14:58:31 -0700270
271 // Find implicit or explicit asset and resource dirs
Jiakai Zhangba82e282023-10-13 18:08:59 +0100272 assets := android.PathsRelativeToModuleSourceDir(android.SourceInput{
273 Context: ctx,
274 Paths: a.aaptProperties.Assets,
275 IncludeDirs: false,
276 })
Spandan Das82229552024-12-06 01:38:45 +0000277 var assetDirs android.Paths
278 if doNotIncludeAssetDirImplicitly {
279 assetDirs = android.PathsForModuleSrc(ctx, a.aaptProperties.Asset_dirs)
280 } else {
281 assetDirs = android.PathsWithOptionalDefaultForModuleSrc(ctx, a.aaptProperties.Asset_dirs, "assets")
282 }
Cole Faust5b989772024-11-06 11:03:16 -0800283 resourceDirs := android.PathsWithOptionalDefaultForModuleSrc(ctx, a.aaptProperties.Resource_dirs.GetOrDefault(ctx, nil), "res")
Colin Cross8a497952019-03-05 22:25:09 -0800284 resourceZips := android.PathsForModuleSrc(ctx, a.aaptProperties.Resource_zips)
Colin Crossa97c5d32018-03-28 14:58:31 -0700285
Colin Crossa97c5d32018-03-28 14:58:31 -0700286 // Glob directories into lists of paths
287 for _, dir := range resourceDirs {
288 resDirs = append(resDirs, globbedResourceDir{
289 dir: dir,
290 files: androidResourceGlob(ctx, dir),
291 })
Jaewoong Jungc779cd42020-10-06 18:56:10 -0700292 resOverlayDirs, resRRODirs := overlayResourceGlob(ctx, a, dir)
Colin Crossa97c5d32018-03-28 14:58:31 -0700293 overlayDirs = append(overlayDirs, resOverlayDirs...)
294 rroDirs = append(rroDirs, resRRODirs...)
295 }
296
Cole Faust6265120c2024-09-05 16:27:56 -0700297 assetDirsHasher := sha256.New()
Colin Crossc20dc852020-11-10 12:27:45 -0800298 var assetDeps android.Paths
Cole Faust6265120c2024-09-05 16:27:56 -0700299 for _, dir := range assetDirs {
Colin Crossc20dc852020-11-10 12:27:45 -0800300 // Add a dependency on every file in the asset directory. This ensures the aapt2
301 // rule will be rerun if one of the files in the asset directory is modified.
Cole Faust6265120c2024-09-05 16:27:56 -0700302 dirContents := androidResourceGlob(ctx, dir)
303 assetDeps = append(assetDeps, dirContents...)
Colin Crossc20dc852020-11-10 12:27:45 -0800304
Cole Faust6265120c2024-09-05 16:27:56 -0700305 // Add a hash of all the files in the asset directory to the command line.
Colin Crossc20dc852020-11-10 12:27:45 -0800306 // This ensures the aapt2 rule will be run if a file is removed from the asset directory,
307 // or a file is added whose timestamp is older than the output of aapt2.
Cole Faust6265120c2024-09-05 16:27:56 -0700308 for _, path := range dirContents.Strings() {
309 assetDirsHasher.Write([]byte(path))
310 }
Colin Crossa97c5d32018-03-28 14:58:31 -0700311 }
312
Jaewoong Jung5b425e22019-06-17 17:40:56 -0700313 assetDirStrings := assetDirs.Strings()
314 if a.noticeFile.Valid() {
315 assetDirStrings = append(assetDirStrings, filepath.Dir(a.noticeFile.Path().String()))
Colin Crossc20dc852020-11-10 12:27:45 -0800316 assetDeps = append(assetDeps, a.noticeFile.Path())
Jaewoong Jung5b425e22019-06-17 17:40:56 -0700317 }
Jiakai Zhangba82e282023-10-13 18:08:59 +0100318 if len(assets) > 0 {
319 // aapt2 doesn't support adding individual asset files. Create a temp directory to hold asset
320 // files and pass it to aapt2.
321 tmpAssetDir := android.PathForModuleOut(ctx, "tmp_asset_dir")
322
323 rule := android.NewRuleBuilder(pctx, ctx)
324 rule.Command().
325 Text("rm -rf").Text(tmpAssetDir.String()).
326 Text("&&").
327 Text("mkdir -p").Text(tmpAssetDir.String())
328
329 for _, asset := range assets {
330 output := tmpAssetDir.Join(ctx, asset.Rel())
331 assetDeps = append(assetDeps, output)
332 rule.Command().Text("mkdir -p").Text(filepath.Dir(output.String()))
333 rule.Command().Text("cp").Input(asset).Output(output)
334 }
335
336 rule.Build("tmp_asset_dir", "tmp_asset_dir")
337
338 assetDirStrings = append(assetDirStrings, tmpAssetDir.String())
339 }
Jaewoong Jung5b425e22019-06-17 17:40:56 -0700340
Colin Crossa97c5d32018-03-28 14:58:31 -0700341 linkFlags = append(linkFlags, "--manifest "+manifestPath.String())
342 linkDeps = append(linkDeps, manifestPath)
343
Jaewoong Jung5b425e22019-06-17 17:40:56 -0700344 linkFlags = append(linkFlags, android.JoinWithPrefix(assetDirStrings, "-A "))
Cole Faust6265120c2024-09-05 16:27:56 -0700345 linkFlags = append(linkFlags, fmt.Sprintf("$$(: %x)", assetDirsHasher.Sum(nil)))
Colin Crossc20dc852020-11-10 12:27:45 -0800346 linkDeps = append(linkDeps, assetDeps...)
Colin Crossa97c5d32018-03-28 14:58:31 -0700347
Spandan Das50885c02023-02-23 21:31:33 +0000348 // Returns the effective version for {min|target}_sdk_version
Spandan Das8c9ae7e2023-03-03 21:20:36 +0000349 effectiveVersionString := func(sdkVersion android.SdkSpec, minSdkVersion android.ApiLevel) string {
Spandan Das50885c02023-02-23 21:31:33 +0000350 // If {min|target}_sdk_version is current, use sdk_version to determine the effective level
351 // This is necessary for vendor modules.
352 // The effective version does not _only_ depend on {min|target}_sdk_version(level),
353 // but also on the sdk_version (kind+level)
Spandan Das8c9ae7e2023-03-03 21:20:36 +0000354 if minSdkVersion.IsCurrent() {
Spandan Das50885c02023-02-23 21:31:33 +0000355 ret, err := sdkVersion.EffectiveVersionString(ctx)
356 if err != nil {
357 ctx.ModuleErrorf("invalid sdk_version: %s", err)
358 }
359 return ret
360 }
361 ret, err := minSdkVersion.EffectiveVersionString(ctx)
362 if err != nil {
363 ctx.ModuleErrorf("invalid min_sdk_version: %s", err)
364 }
365 return ret
Jiyong Park6a927c42020-01-21 02:03:43 +0900366 }
Spandan Das50885c02023-02-23 21:31:33 +0000367 // SDK version flags
368 sdkVersion := sdkContext.SdkVersion(ctx)
369 minSdkVersion := effectiveVersionString(sdkVersion, sdkContext.MinSdkVersion(ctx))
Colin Crossa97c5d32018-03-28 14:58:31 -0700370
Colin Cross83bb3162018-06-25 15:48:06 -0700371 linkFlags = append(linkFlags, "--min-sdk-version "+minSdkVersion)
Spandan Das6450b552023-02-23 19:27:07 +0000372 // Use minSdkVersion for target-sdk-version, even if `target_sdk_version` is set
373 // This behavior has been copied from Make.
Colin Cross83bb3162018-06-25 15:48:06 -0700374 linkFlags = append(linkFlags, "--target-sdk-version "+minSdkVersion)
Colin Crossa97c5d32018-03-28 14:58:31 -0700375
Colin Crossa97c5d32018-03-28 14:58:31 -0700376 // Version code
377 if !hasVersionCode {
Dan Albert4f378d72020-07-23 17:32:15 -0700378 linkFlags = append(linkFlags, "--version-code", ctx.Config().PlatformSdkVersion().String())
Colin Crossa97c5d32018-03-28 14:58:31 -0700379 }
380
381 if !hasVersionName {
Colin Cross402d5e02018-04-25 14:54:06 -0700382 var versionName string
383 if ctx.ModuleName() == "framework-res" {
384 // Some builds set AppsDefaultVersionName() to include the build number ("O-123456"). aapt2 copies the
385 // version name of framework-res into app manifests as compileSdkVersionCodename, which confuses things
Colin Crossbfd347d2018-05-09 11:11:35 -0700386 // if it contains the build number. Use the PlatformVersionName instead.
387 versionName = ctx.Config().PlatformVersionName()
Colin Cross402d5e02018-04-25 14:54:06 -0700388 } else {
389 versionName = ctx.Config().AppsDefaultVersionName()
390 }
Colin Cross0b9f31f2019-02-28 11:00:01 -0800391 versionName = proptools.NinjaEscape(versionName)
Colin Crossa97c5d32018-03-28 14:58:31 -0700392 linkFlags = append(linkFlags, "--version-name ", versionName)
393 }
Yurii Zubrytskyi3afd7952024-10-29 18:09:44 -0700394 // Split the flags by prefix, as --png-compression-level has the "=value" suffix.
395 linkFlags, compileFlags = android.FilterListByPrefix(linkFlags,
396 []string{"--legacy", "--png-compression-level"})
Colin Crossa0ba2f52019-06-22 12:59:27 -0700397
398 // Always set --pseudo-localize, it will be stripped out later for release
399 // builds that don't want it.
400 compileFlags = append(compileFlags, "--pseudo-localize")
401
402 return compileFlags, linkFlags, linkDeps, resDirs, overlayDirs, rroDirs, resourceZips
Colin Crossa97c5d32018-03-28 14:58:31 -0700403}
404
Paul Duffin250e6192019-06-07 10:44:37 +0100405func (a *aapt) deps(ctx android.BottomUpMutatorContext, sdkDep sdkDep) {
Colin Cross42308aa2018-11-14 21:44:17 -0800406 if sdkDep.frameworkResModule != "" {
407 ctx.AddVariationDependencies(nil, frameworkResTag, sdkDep.frameworkResModule)
Colin Crossa97c5d32018-03-28 14:58:31 -0700408 }
409}
410
Jaewoong Jung6431ca72020-01-15 14:15:10 -0800411var extractAssetsRule = pctx.AndroidStaticRule("extractAssets",
412 blueprint.RuleParams{
413 Command: `${config.Zip2ZipCmd} -i ${in} -o ${out} "assets/**/*"`,
414 CommandDeps: []string{"${config.Zip2ZipCmd}"},
415 })
416
Alixf7a10272023-09-27 16:47:56 +0000417type aaptBuildActionOptions struct {
418 sdkContext android.SdkContext
419 classLoaderContexts dexpreopt.ClassLoaderContextMap
420 excludedLibs []string
421 enforceDefaultTargetSdkVersion bool
Rico Winda2fa2632024-03-13 13:09:17 +0100422 forceNonFinalResourceIDs bool
Alixf7a10272023-09-27 16:47:56 +0000423 extraLinkFlags []string
Jihoon Kang84b25892023-12-01 22:01:06 +0000424 aconfigTextFiles android.Paths
Jiakai Zhang36937082024-04-15 11:15:50 +0000425 usesLibrary *usesLibrary
Spandan Dase2f98da2024-11-18 19:22:39 +0000426 // If rroDirs is provided, it will be used to generate package-res.apk
427 rroDirs *android.Paths
428 // If manifestForAapt is not nil, it will be used for aapt instead of the default source manifest.
429 manifestForAapt android.Path
430}
431
432func filterRRO(rroDirsDepSet depset.DepSet[rroDir], filter overlayType) android.Paths {
433 var paths android.Paths
434 seen := make(map[android.Path]bool)
435 for _, d := range rroDirsDepSet.ToList() {
436 if d.overlayType == filter {
437 if seen[d.path] {
438 continue
439 }
440 seen[d.path] = true
441 paths = append(paths, d.path)
442 }
443 }
444 return paths
Alixf7a10272023-09-27 16:47:56 +0000445}
446
447func (a *aapt) buildActions(ctx android.ModuleContext, opts aaptBuildActionOptions) {
Colin Cross5446e882019-05-22 10:46:27 -0700448
Colin Cross8676c8c2023-10-12 15:58:57 -0700449 staticResourcesNodesDepSet, sharedResourcesNodesDepSet, staticRRODirsDepSet, staticManifestsDepSet, sharedExportPackages, libFlags :=
Jiakai Zhang36937082024-04-15 11:15:50 +0000450 aaptLibs(ctx, opts.sdkContext, opts.classLoaderContexts, opts.usesLibrary)
Ulya Trafimovich31e444e2020-08-14 17:32:16 +0100451
Paul Duffin06530572022-02-03 17:54:15 +0000452 // Exclude any libraries from the supplied list.
Alixf7a10272023-09-27 16:47:56 +0000453 opts.classLoaderContexts = opts.classLoaderContexts.ExcludeLibs(opts.excludedLibs)
Paul Duffin06530572022-02-03 17:54:15 +0000454
Colin Cross31656952018-05-24 16:11:20 -0700455 // App manifest file
Spandan Dase2f98da2024-11-18 19:22:39 +0000456 var manifestFilePath android.Path
457 if opts.manifestForAapt != nil {
458 manifestFilePath = opts.manifestForAapt
459 } else {
460 manifestFile := proptools.StringDefault(a.aaptProperties.Manifest, "AndroidManifest.xml")
461 manifestFilePath = android.PathForModuleSrc(ctx, manifestFile)
462 }
Colin Cross31656952018-05-24 16:11:20 -0700463
Spandan Dase2f98da2024-11-18 19:22:39 +0000464 manifestPath := ManifestFixer(ctx, manifestFilePath, ManifestFixerParams{
Alixf7a10272023-09-27 16:47:56 +0000465 SdkContext: opts.sdkContext,
466 ClassLoaderContexts: opts.classLoaderContexts,
Harshit Mahajan5b8b7302022-06-10 11:24:05 +0000467 IsLibrary: a.isLibrary,
468 DefaultManifestVersion: a.defaultManifestVersion,
469 UseEmbeddedNativeLibs: a.useEmbeddedNativeLibs,
470 UsesNonSdkApis: a.usesNonSdkApis,
471 UseEmbeddedDex: a.useEmbeddedDex,
472 HasNoCode: a.hasNoCode,
473 LoggingParent: a.LoggingParent,
Alixf7a10272023-09-27 16:47:56 +0000474 EnforceDefaultTargetSdkVersion: opts.enforceDefaultTargetSdkVersion,
Gurpreet Singh75d65f32022-01-24 17:44:05 +0000475 })
Colin Cross90c25c62019-04-19 16:22:57 -0700476
Colin Crossab8d1382023-07-14 17:23:41 +0000477 staticDeps := transitiveAarDeps(staticResourcesNodesDepSet.ToList())
Colin Cross8676c8c2023-10-12 15:58:57 -0700478 sharedDeps := transitiveAarDeps(sharedResourcesNodesDepSet.ToList())
Colin Crossab8d1382023-07-14 17:23:41 +0000479
Luca Stefanifd898822019-09-10 22:13:31 +0200480 // Add additional manifest files to transitive manifests.
481 additionalManifests := android.PathsForModuleSrc(ctx, a.aaptProperties.Additional_manifests)
Colin Crossab8d1382023-07-14 17:23:41 +0000482 transitiveManifestPaths := append(android.Paths{manifestPath}, additionalManifests...)
Colin Crossab8d1382023-07-14 17:23:41 +0000483 transitiveManifestPaths = append(transitiveManifestPaths, staticManifestsDepSet.ToList()...)
Colin Cross90c25c62019-04-19 16:22:57 -0700484
Colin Crossab8d1382023-07-14 17:23:41 +0000485 if len(transitiveManifestPaths) > 1 && !Bool(a.aaptProperties.Dont_merge_manifests) {
Alixf7a10272023-09-27 16:47:56 +0000486 manifestMergerParams := ManifestMergerParams{
487 staticLibManifests: transitiveManifestPaths[1:],
Alix96ea88452023-08-31 15:48:23 +0000488 isLibrary: a.isLibrary,
489 packageName: a.manifestValues.applicationId,
490 }
Alixf7a10272023-09-27 16:47:56 +0000491 a.mergedManifestFile = manifestMerger(ctx, transitiveManifestPaths[0], manifestMergerParams)
Colin Crossa6182ab2024-08-21 10:47:44 -0700492 ctx.CheckbuildFile(a.mergedManifestFile)
Colin Cross90c25c62019-04-19 16:22:57 -0700493 if !a.isLibrary {
494 // Only use the merged manifest for applications. For libraries, the transitive closure of manifests
495 // will be propagated to the final application and merged there. The merged manifest for libraries is
496 // only passed to Make, which can't handle transitive dependencies.
497 manifestPath = a.mergedManifestFile
498 }
499 } else {
500 a.mergedManifestFile = manifestPath
501 }
Colin Cross31656952018-05-24 16:11:20 -0700502
Spandan Das82229552024-12-06 01:38:45 +0000503 // do not include assets in autogenerated RRO.
504 compileFlags, linkFlags, linkDeps, resDirs, overlayDirs, rroDirs, resZips := a.aapt2Flags(ctx, opts.sdkContext, manifestPath, opts.rroDirs != nil)
Colin Cross31656952018-05-24 16:11:20 -0700505
Spandan Dase2f98da2024-11-18 19:22:39 +0000506 a.rroDirsDepSet = depset.NewBuilder[rroDir](depset.TOPOLOGICAL).
507 Direct(rroDirs...).
508 Transitive(staticRRODirsDepSet).Build()
509
Colin Cross31656952018-05-24 16:11:20 -0700510 linkFlags = append(linkFlags, libFlags...)
Colin Cross8676c8c2023-10-12 15:58:57 -0700511 linkDeps = append(linkDeps, sharedExportPackages...)
Colin Crossab8d1382023-07-14 17:23:41 +0000512 linkDeps = append(linkDeps, staticDeps.resPackages()...)
Alixf7a10272023-09-27 16:47:56 +0000513 linkFlags = append(linkFlags, opts.extraLinkFlags...)
Colin Cross1b6a3cf2018-07-24 14:51:30 -0700514 if a.isLibrary {
515 linkFlags = append(linkFlags, "--static-lib")
516 }
Rico Wind7152e822024-04-19 08:14:15 +0200517 if opts.forceNonFinalResourceIDs {
518 linkFlags = append(linkFlags, "--non-final-ids")
519 }
Colin Crossa97c5d32018-03-28 14:58:31 -0700520
Colin Cross7c4dc5d2024-02-13 14:29:45 -0800521 linkFlags = append(linkFlags, "--no-static-lib-packages")
Spandan Das457e5062024-10-05 01:00:34 +0000522 if a.isLibrary {
523 // Pass --merge-only to skip resource references validation until the final
524 // app link step when when all static libraries are present.
Colin Cross4eae06d2023-06-20 22:40:02 -0700525 linkFlags = append(linkFlags, "--merge-only")
Colin Cross4eae06d2023-06-20 22:40:02 -0700526 }
527
Colin Crossa97c5d32018-03-28 14:58:31 -0700528 packageRes := android.PathForModuleOut(ctx, "package-res.apk")
Colin Crossa97c5d32018-03-28 14:58:31 -0700529 proguardOptionsFile := android.PathForModuleGen(ctx, "proguard.options")
530 rTxt := android.PathForModuleOut(ctx, "R.txt")
Colin Cross66f78822018-05-02 12:58:28 -0700531 // This file isn't used by Soong, but is generated for exporting
532 extraPackages := android.PathForModuleOut(ctx, "extra_packages")
Colin Cross4eae06d2023-06-20 22:40:02 -0700533 var transitiveRJars android.Paths
Colin Crossf3b7bad2023-08-02 15:49:00 -0700534 var srcJar android.WritablePath
Colin Crossa97c5d32018-03-28 14:58:31 -0700535
Colin Cross4aaa84a2018-08-21 15:14:37 -0700536 var compiledResDirs []android.Paths
Colin Crossa97c5d32018-03-28 14:58:31 -0700537 for _, dir := range resDirs {
Colin Cross014489c2020-06-02 20:09:13 -0700538 a.resourceFiles = append(a.resourceFiles, dir.files...)
Jihoon Kang98ea8362024-07-16 18:20:03 +0000539 compiledResDirs = append(compiledResDirs, aapt2Compile(ctx, dir.dir, dir.files,
540 compileFlags, a.filterProduct(), opts.aconfigTextFiles).Paths())
Colin Crossa97c5d32018-03-28 14:58:31 -0700541 }
Colin Cross4aaa84a2018-08-21 15:14:37 -0700542
Colin Crossa592e3e2019-02-19 16:59:53 -0800543 for i, zip := range resZips {
544 flata := android.PathForModuleOut(ctx, fmt.Sprintf("reszip.%d.flata", i))
Colin Crossa0ba2f52019-06-22 12:59:27 -0700545 aapt2CompileZip(ctx, flata, zip, "", compileFlags)
Colin Crossa592e3e2019-02-19 16:59:53 -0800546 compiledResDirs = append(compiledResDirs, android.Paths{flata})
547 }
548
Colin Cross4aaa84a2018-08-21 15:14:37 -0700549 var compiledRes, compiledOverlay android.Paths
550
Colin Crossab8d1382023-07-14 17:23:41 +0000551 // AAPT2 overlays are in lowest to highest priority order, reverse the topological order
552 // of transitiveStaticLibs.
553 transitiveStaticLibs := android.ReversePaths(staticDeps.resPackages())
554
Colin Cross8f1b0332024-01-25 13:39:06 -0800555 if a.isLibrary && a.useResourceProcessorBusyBox(ctx) {
Colin Cross4eae06d2023-06-20 22:40:02 -0700556 // When building an android_library with ResourceProcessorBusyBox enabled treat static library dependencies
557 // as imports. The resources from dependencies will not be merged into this module's package-res.apk, and
558 // instead modules depending on this module will reference package-res.apk from all transitive static
559 // dependencies.
Colin Cross1d3f5902024-03-05 11:51:54 -0800560 for _, sharedDep := range sharedDeps {
561 if sharedDep.usedResourceProcessor {
562 transitiveRJars = append(transitiveRJars, sharedDep.rJar)
563 }
564 }
Colin Cross4eae06d2023-06-20 22:40:02 -0700565 for _, staticDep := range staticDeps {
566 linkDeps = append(linkDeps, staticDep.resPackage)
567 linkFlags = append(linkFlags, "-I "+staticDep.resPackage.String())
568 if staticDep.usedResourceProcessor {
569 transitiveRJars = append(transitiveRJars, staticDep.rJar)
570 }
571 }
572 } else {
573 // When building an app or building a library without ResourceProcessorBusyBox enabled all static
574 // dependencies are compiled into this module's package-res.apk as overlays.
575 compiledOverlay = append(compiledOverlay, transitiveStaticLibs...)
576 }
Colin Cross4aaa84a2018-08-21 15:14:37 -0700577
Colin Crossbec85302019-02-13 13:15:46 -0800578 if len(transitiveStaticLibs) > 0 {
Colin Cross4aaa84a2018-08-21 15:14:37 -0700579 // If we are using static android libraries, every source file becomes an overlay.
580 // This is to emulate old AAPT behavior which simulated library support.
581 for _, compiledResDir := range compiledResDirs {
582 compiledOverlay = append(compiledOverlay, compiledResDir...)
583 }
Colin Crossbec85302019-02-13 13:15:46 -0800584 } else if a.isLibrary {
585 // Otherwise, for a static library we treat all the resources equally with no overlay.
586 for _, compiledResDir := range compiledResDirs {
587 compiledRes = append(compiledRes, compiledResDir...)
588 }
Colin Cross4aaa84a2018-08-21 15:14:37 -0700589 } else if len(compiledResDirs) > 0 {
590 // Without static libraries, the first directory is our directory, which can then be
591 // overlaid by the rest.
592 compiledRes = append(compiledRes, compiledResDirs[0]...)
593 for _, compiledResDir := range compiledResDirs[1:] {
594 compiledOverlay = append(compiledOverlay, compiledResDir...)
595 }
596 }
597
Spandan Dase2f98da2024-11-18 19:22:39 +0000598 var compiledRro, compiledRroOverlay android.Paths
599 if opts.rroDirs != nil {
600 compiledRro, compiledRroOverlay = a.compileResInDir(ctx, *opts.rroDirs, compileFlags, opts.aconfigTextFiles)
Spandan Dasde588a32024-12-03 22:52:24 +0000601 } else {
602 // RRO enforcement is done based on module name. Compile the overlayDirs only if rroDirs is nil.
603 // This ensures that the autogenerated RROs do not compile the overlay dirs twice.
604 for _, dir := range overlayDirs {
605 compiledOverlay = append(compiledOverlay, aapt2Compile(ctx, dir.dir, dir.files,
606 compileFlags, a.filterProduct(), opts.aconfigTextFiles).Paths()...)
607 }
Spandan Dase2f98da2024-11-18 19:22:39 +0000608 }
609
Colin Crosse560c4a2019-03-19 16:03:11 -0700610 var splitPackages android.WritablePaths
611 var splits []split
612
613 for _, s := range a.splitNames {
614 suffix := strings.Replace(s, ",", "_", -1)
615 path := android.PathForModuleOut(ctx, "package_"+suffix+".apk")
616 linkFlags = append(linkFlags, "--split", path.String()+":"+s)
617 splitPackages = append(splitPackages, path)
618 splits = append(splits, split{
619 name: s,
620 suffix: suffix,
621 path: path,
622 })
623 }
624
Colin Cross8f1b0332024-01-25 13:39:06 -0800625 if !a.useResourceProcessorBusyBox(ctx) {
Colin Crossf3b7bad2023-08-02 15:49:00 -0700626 // the subdir "android" is required to be filtered by package names
627 srcJar = android.PathForModuleGen(ctx, "android", "R.srcjar")
628 }
629
Colin Crossab8d1382023-07-14 17:23:41 +0000630 // No need to specify assets from dependencies to aapt2Link for libraries, all transitive assets will be
631 // provided to the final app aapt2Link step.
632 var transitiveAssets android.Paths
633 if !a.isLibrary {
634 transitiveAssets = android.ReverseSliceInPlace(staticDeps.assets())
635 }
Spandan Dase2f98da2024-11-18 19:22:39 +0000636 if opts.rroDirs == nil { // link resources and overlay
637 aapt2Link(ctx, packageRes, srcJar, proguardOptionsFile, rTxt,
638 linkFlags, linkDeps, compiledRes, compiledOverlay, transitiveAssets, splitPackages,
639 opts.aconfigTextFiles)
640 ctx.CheckbuildFile(packageRes)
641 } else { // link autogenerated rro
642 if len(compiledRro) == 0 {
643 return
644 }
645 aapt2Link(ctx, packageRes, srcJar, proguardOptionsFile, rTxt,
646 linkFlags, linkDeps, compiledRro, compiledRroOverlay, nil, nil,
647 opts.aconfigTextFiles)
648 ctx.CheckbuildFile(packageRes)
649 }
Colin Crossa6182ab2024-08-21 10:47:44 -0700650
Jaewoong Jung6431ca72020-01-15 14:15:10 -0800651 // Extract assets from the resource package output so that they can be used later in aapt2link
652 // for modules that depend on this one.
Colin Crossab8d1382023-07-14 17:23:41 +0000653 if android.PrefixInList(linkFlags, "-A ") {
Jaewoong Jung6431ca72020-01-15 14:15:10 -0800654 assets := android.PathForModuleOut(ctx, "assets.zip")
655 ctx.Build(pctx, android.BuildParams{
656 Rule: extractAssetsRule,
657 Input: packageRes,
658 Output: assets,
659 Description: "extract assets from built resource file",
660 })
661 a.assetPackage = android.OptionalPathForPath(assets)
662 }
Colin Crossa97c5d32018-03-28 14:58:31 -0700663
Colin Cross8f1b0332024-01-25 13:39:06 -0800664 if a.useResourceProcessorBusyBox(ctx) {
Colin Cross4eae06d2023-06-20 22:40:02 -0700665 rJar := android.PathForModuleOut(ctx, "busybox/R.jar")
Rico Winda2fa2632024-03-13 13:09:17 +0100666 resourceProcessorBusyBoxGenerateBinaryR(ctx, rTxt, a.mergedManifestFile, rJar, staticDeps, a.isLibrary, a.aaptProperties.Aaptflags,
667 opts.forceNonFinalResourceIDs)
Colin Crossf3b7bad2023-08-02 15:49:00 -0700668 aapt2ExtractExtraPackages(ctx, extraPackages, rJar)
Colin Cross4eae06d2023-06-20 22:40:02 -0700669 transitiveRJars = append(transitiveRJars, rJar)
670 a.rJar = rJar
Colin Crossf3b7bad2023-08-02 15:49:00 -0700671 } else {
672 aapt2ExtractExtraPackages(ctx, extraPackages, srcJar)
Colin Cross4eae06d2023-06-20 22:40:02 -0700673 }
674
Colin Cross312634e2023-11-21 15:13:56 -0800675 transitiveAaptResourcePackages := staticDeps.resPackages().Strings()
676 transitiveAaptResourcePackages = slices.DeleteFunc(transitiveAaptResourcePackages, func(p string) bool {
677 return p == packageRes.String()
678 })
679 transitiveAaptResourcePackagesFile := android.PathForModuleOut(ctx, "transitive-res-packages")
680 android.WriteFileRule(ctx, transitiveAaptResourcePackagesFile, strings.Join(transitiveAaptResourcePackages, "\n"))
681
Colin Cross1d3f5902024-03-05 11:51:54 -0800682 // Reverse the list of R.jar files so that the current module comes first, and direct dependencies come before
683 // transitive dependencies.
684 transitiveRJars = android.ReversePaths(transitiveRJars)
685
Colin Crossa97c5d32018-03-28 14:58:31 -0700686 a.aaptSrcJar = srcJar
Colin Cross4eae06d2023-06-20 22:40:02 -0700687 a.transitiveAaptRJars = transitiveRJars
Colin Cross312634e2023-11-21 15:13:56 -0800688 a.transitiveAaptResourcePackagesFile = transitiveAaptResourcePackagesFile
Colin Crossa97c5d32018-03-28 14:58:31 -0700689 a.exportPackage = packageRes
690 a.manifestPath = manifestPath
691 a.proguardOptionsFile = proguardOptionsFile
Colin Cross66f78822018-05-02 12:58:28 -0700692 a.extraAaptPackagesFile = extraPackages
Colin Crossa97c5d32018-03-28 14:58:31 -0700693 a.rTxt = rTxt
Colin Crosse560c4a2019-03-19 16:03:11 -0700694 a.splits = splits
Colin Crossa14fb6a2024-10-23 16:57:06 -0700695 a.resourcesNodesDepSet = depset.NewBuilder[*resourcesNode](depset.TOPOLOGICAL).
Colin Crossab8d1382023-07-14 17:23:41 +0000696 Direct(&resourcesNode{
697 resPackage: a.exportPackage,
698 manifest: a.manifestPath,
699 additionalManifests: additionalManifests,
Colin Cross4eae06d2023-06-20 22:40:02 -0700700 rTxt: a.rTxt,
701 rJar: a.rJar,
Colin Crossab8d1382023-07-14 17:23:41 +0000702 assets: a.assetPackage,
Colin Cross4eae06d2023-06-20 22:40:02 -0700703
Colin Cross8f1b0332024-01-25 13:39:06 -0800704 usedResourceProcessor: a.useResourceProcessorBusyBox(ctx),
Colin Crossab8d1382023-07-14 17:23:41 +0000705 }).
706 Transitive(staticResourcesNodesDepSet).Build()
Colin Crossa14fb6a2024-10-23 16:57:06 -0700707 a.manifestsDepSet = depset.NewBuilder[android.Path](depset.TOPOLOGICAL).
Colin Crossab8d1382023-07-14 17:23:41 +0000708 Direct(a.manifestPath).
709 DirectSlice(additionalManifests).
710 Transitive(staticManifestsDepSet).Build()
711}
712
Spandan Dase2f98da2024-11-18 19:22:39 +0000713// comileResInDir finds the resource files in dirs by globbing and then compiles them using aapt2
714// returns the file paths of compiled resources
715// dirs[0] is used as compileRes
716// dirs[1:] is used as compileOverlay
717func (a *aapt) compileResInDir(ctx android.ModuleContext, dirs android.Paths, compileFlags []string, aconfig android.Paths) (android.Paths, android.Paths) {
718 filesInDir := func(dir android.Path) android.Paths {
719 files, err := ctx.GlobWithDeps(filepath.Join(dir.String(), "**/*"), androidResourceIgnoreFilenames)
720 if err != nil {
721 ctx.ModuleErrorf("failed to glob overlay resource dir %q: %s", dir, err.Error())
722 return nil
723 }
724 var filePaths android.Paths
725 for _, file := range files {
726 if strings.HasSuffix(file, "/") {
727 continue // ignore directories
728 }
729 filePaths = append(filePaths, android.PathForSource(ctx, file))
730 }
731 return filePaths
732 }
733
734 var compiledRes, compiledOverlay android.Paths
735 if len(dirs) == 0 {
736 return nil, nil
737 }
738 compiledRes = append(compiledRes, aapt2Compile(ctx, dirs[0], filesInDir(dirs[0]), compileFlags, a.filterProduct(), aconfig).Paths()...)
739 if len(dirs) > 0 {
740 for _, dir := range dirs[1:] {
741 compiledOverlay = append(compiledOverlay, aapt2Compile(ctx, dir, filesInDir(dir), compileFlags, a.filterProduct(), aconfig).Paths()...)
742 }
743 }
744 return compiledRes, compiledOverlay
745}
746
Colin Cross4eae06d2023-06-20 22:40:02 -0700747var resourceProcessorBusyBox = pctx.AndroidStaticRule("resourceProcessorBusyBox",
748 blueprint.RuleParams{
749 Command: "${config.JavaCmd} -cp ${config.ResourceProcessorBusyBox} " +
750 "com.google.devtools.build.android.ResourceProcessorBusyBox --tool=GENERATE_BINARY_R -- @${out}.args && " +
751 "if cmp -s ${out}.tmp ${out} ; then rm ${out}.tmp ; else mv ${out}.tmp ${out}; fi",
752 CommandDeps: []string{"${config.ResourceProcessorBusyBox}"},
753 Rspfile: "${out}.args",
754 RspfileContent: "--primaryRTxt ${rTxt} --primaryManifest ${manifest} --classJarOutput ${out}.tmp ${args}",
755 Restat: true,
756 }, "rTxt", "manifest", "args")
757
758// resourceProcessorBusyBoxGenerateBinaryR converts the R.txt file produced by aapt2 into R.class files
759// using Bazel's ResourceProcessorBusyBox tool, which is faster than compiling the R.java files and
760// supports producing classes for static dependencies that only include resources from that dependency.
761func resourceProcessorBusyBoxGenerateBinaryR(ctx android.ModuleContext, rTxt, manifest android.Path,
Rico Winda2fa2632024-03-13 13:09:17 +0100762 rJar android.WritablePath, transitiveDeps transitiveAarDeps, isLibrary bool, aaptFlags []string,
763 forceNonFinalIds bool) {
Colin Cross4eae06d2023-06-20 22:40:02 -0700764
765 var args []string
766 var deps android.Paths
767
768 if !isLibrary {
769 // When compiling an app, pass all R.txt and AndroidManifest.xml from transitive static library dependencies
770 // to ResourceProcessorBusyBox so that it can regenerate R.class files with the final resource IDs for each
771 // package.
772 args, deps = transitiveDeps.resourceProcessorDeps()
Rico Winda2fa2632024-03-13 13:09:17 +0100773 if forceNonFinalIds {
774 args = append(args, "--finalFields=false")
775 }
Colin Cross4eae06d2023-06-20 22:40:02 -0700776 } else {
777 // When compiling a library don't pass any dependencies as it only needs to generate an R.class file for this
778 // library. Pass --finalFields=false so that the R.class file contains non-final fields so they don't get
779 // inlined into the library before the final IDs are assigned during app compilation.
780 args = append(args, "--finalFields=false")
781 }
782
Colin Crossd3f7d1a2024-01-03 19:42:25 -0800783 for i, arg := range aaptFlags {
784 const AAPT_CUSTOM_PACKAGE = "--custom-package"
785 if strings.HasPrefix(arg, AAPT_CUSTOM_PACKAGE) {
786 pkg := strings.TrimSpace(strings.TrimPrefix(arg, AAPT_CUSTOM_PACKAGE))
787 if pkg == "" && i+1 < len(aaptFlags) {
788 pkg = aaptFlags[i+1]
789 }
790 args = append(args, "--packageForR "+pkg)
791 }
792 }
793
Colin Cross4eae06d2023-06-20 22:40:02 -0700794 deps = append(deps, rTxt, manifest)
795
796 ctx.Build(pctx, android.BuildParams{
797 Rule: resourceProcessorBusyBox,
798 Output: rJar,
799 Implicits: deps,
800 Description: "ResourceProcessorBusyBox",
801 Args: map[string]string{
802 "rTxt": rTxt.String(),
803 "manifest": manifest.String(),
804 "args": strings.Join(args, " "),
805 },
806 })
807}
808
Colin Crossab8d1382023-07-14 17:23:41 +0000809type resourcesNode struct {
810 resPackage android.Path
811 manifest android.Path
812 additionalManifests android.Paths
Colin Cross4eae06d2023-06-20 22:40:02 -0700813 rTxt android.Path
814 rJar android.Path
Colin Crossab8d1382023-07-14 17:23:41 +0000815 assets android.OptionalPath
Colin Cross4eae06d2023-06-20 22:40:02 -0700816
817 usedResourceProcessor bool
Colin Crossab8d1382023-07-14 17:23:41 +0000818}
819
820type transitiveAarDeps []*resourcesNode
821
822func (t transitiveAarDeps) resPackages() android.Paths {
Colin Cross4eae06d2023-06-20 22:40:02 -0700823 paths := make(android.Paths, 0, len(t))
Colin Crossab8d1382023-07-14 17:23:41 +0000824 for _, dep := range t {
825 paths = append(paths, dep.resPackage)
826 }
Colin Cross4eae06d2023-06-20 22:40:02 -0700827 return paths
Colin Crossab8d1382023-07-14 17:23:41 +0000828}
829
830func (t transitiveAarDeps) manifests() android.Paths {
Colin Cross4eae06d2023-06-20 22:40:02 -0700831 paths := make(android.Paths, 0, len(t))
Colin Crossab8d1382023-07-14 17:23:41 +0000832 for _, dep := range t {
833 paths = append(paths, dep.manifest)
834 paths = append(paths, dep.additionalManifests...)
835 }
Colin Cross4eae06d2023-06-20 22:40:02 -0700836 return paths
837}
838
839func (t transitiveAarDeps) resourceProcessorDeps() (args []string, deps android.Paths) {
840 for _, dep := range t {
841 args = append(args, "--library="+dep.rTxt.String()+","+dep.manifest.String())
842 deps = append(deps, dep.rTxt, dep.manifest)
843 }
844 return args, deps
Colin Crossab8d1382023-07-14 17:23:41 +0000845}
846
847func (t transitiveAarDeps) assets() android.Paths {
Colin Cross4eae06d2023-06-20 22:40:02 -0700848 paths := make(android.Paths, 0, len(t))
Colin Crossab8d1382023-07-14 17:23:41 +0000849 for _, dep := range t {
850 if dep.assets.Valid() {
851 paths = append(paths, dep.assets.Path())
852 }
853 }
854 return paths
Colin Crossa97c5d32018-03-28 14:58:31 -0700855}
856
857// aaptLibs collects libraries from dependencies and sdk_version and converts them into paths
Jiakai Zhang36937082024-04-15 11:15:50 +0000858func aaptLibs(ctx android.ModuleContext, sdkContext android.SdkContext,
859 classLoaderContexts dexpreopt.ClassLoaderContextMap, usesLibrary *usesLibrary) (
Colin Crossa14fb6a2024-10-23 16:57:06 -0700860 staticResourcesNodes, sharedResourcesNodes depset.DepSet[*resourcesNode], staticRRODirs depset.DepSet[rroDir],
861 staticManifests depset.DepSet[android.Path], sharedLibs android.Paths, flags []string) {
Colin Crossa97c5d32018-03-28 14:58:31 -0700862
Ulya Trafimovichb23d28c2020-10-08 12:53:58 +0100863 if classLoaderContexts == nil {
Ulya Trafimovich18554242020-11-03 15:55:11 +0000864 // Not all callers need to compute class loader context, those who don't just pass nil.
865 // Create a temporary class loader context here (it will be computed, but not used).
Ulya Trafimovichb23d28c2020-10-08 12:53:58 +0100866 classLoaderContexts = make(dexpreopt.ClassLoaderContextMap)
Ulya Trafimovich18554242020-11-03 15:55:11 +0000867 }
868
Colin Cross83bb3162018-06-25 15:48:06 -0700869 sdkDep := decodeSdkDep(ctx, sdkContext)
Colin Crossa97c5d32018-03-28 14:58:31 -0700870 if sdkDep.useFiles {
Colin Cross86a60ae2018-05-29 14:44:55 -0700871 sharedLibs = append(sharedLibs, sdkDep.jars...)
Colin Crossa97c5d32018-03-28 14:58:31 -0700872 }
873
Colin Crossa14fb6a2024-10-23 16:57:06 -0700874 var staticResourcesNodeDepSets []depset.DepSet[*resourcesNode]
875 var sharedResourcesNodeDepSets []depset.DepSet[*resourcesNode]
876 rroDirsDepSetBuilder := depset.NewBuilder[rroDir](depset.TOPOLOGICAL)
877 manifestsDepSetBuilder := depset.NewBuilder[android.Path](depset.TOPOLOGICAL)
Colin Crossab8d1382023-07-14 17:23:41 +0000878
Yu Liu460cf372025-01-10 00:34:06 +0000879 ctx.VisitDirectDepsProxy(func(module android.ModuleProxy) {
Ulya Trafimovich65b03192020-12-03 16:50:22 +0000880 depTag := ctx.OtherModuleDependencyTag(module)
Ulya Trafimovich18554242020-11-03 15:55:11 +0000881
Colin Crossa97c5d32018-03-28 14:58:31 -0700882 var exportPackage android.Path
Yu Liu460cf372025-01-10 00:34:06 +0000883 var aarDep *AndroidLibraryDependencyInfo
884 javaInfo, ok := android.OtherModuleProvider(ctx, module, JavaInfoProvider)
885 if ok && javaInfo.AndroidLibraryDependencyInfo != nil {
886 aarDep = javaInfo.AndroidLibraryDependencyInfo
887 exportPackage = aarDep.ExportPackage
Colin Crossa97c5d32018-03-28 14:58:31 -0700888 }
889
Ulya Trafimovich65b03192020-12-03 16:50:22 +0000890 switch depTag {
Colin Cross4b964c02018-10-15 16:18:06 -0700891 case instrumentationForTag:
892 // Nothing, instrumentationForTag is treated as libTag for javac but not for aapt2.
Spandan Dase2f98da2024-11-18 19:22:39 +0000893 case sdkLibTag, libTag, rroDepTag:
Colin Cross5446e882019-05-22 10:46:27 -0700894 if exportPackage != nil {
Yu Liu460cf372025-01-10 00:34:06 +0000895 sharedResourcesNodeDepSets = append(sharedResourcesNodeDepSets, aarDep.ResourcesNodeDepSet)
Colin Cross5446e882019-05-22 10:46:27 -0700896 sharedLibs = append(sharedLibs, exportPackage)
897 }
Colin Cross5446e882019-05-22 10:46:27 -0700898 case frameworkResTag:
Colin Crossa97c5d32018-03-28 14:58:31 -0700899 if exportPackage != nil {
900 sharedLibs = append(sharedLibs, exportPackage)
901 }
902 case staticLibTag:
903 if exportPackage != nil {
Yu Liu460cf372025-01-10 00:34:06 +0000904 staticResourcesNodeDepSets = append(staticResourcesNodeDepSets, aarDep.ResourcesNodeDepSet)
905 rroDirsDepSetBuilder.Transitive(aarDep.RRODirsDepSet)
906 manifestsDepSetBuilder.Transitive(aarDep.ManifestsDepSet)
Colin Crossa97c5d32018-03-28 14:58:31 -0700907 }
908 }
Ulya Trafimovich18554242020-11-03 15:55:11 +0000909
Ulya Trafimovich88bb6f62020-12-16 16:16:11 +0000910 addCLCFromDep(ctx, module, classLoaderContexts)
Jiakai Zhang36937082024-04-15 11:15:50 +0000911 if usesLibrary != nil {
912 addMissingOptionalUsesLibsFromDep(ctx, module, usesLibrary)
913 }
Colin Crossa97c5d32018-03-28 14:58:31 -0700914 })
915
Colin Crossab8d1382023-07-14 17:23:41 +0000916 // AAPT2 overlays are in lowest to highest priority order, the topological order will be reversed later.
917 // Reverse the dependency order now going into the depset so that it comes out in order after the second
918 // reverse later.
919 // NOTE: this is legacy and probably incorrect behavior, for most other cases (e.g. conflicting classes in
920 // dependencies) the highest priority dependency is listed first, but for resources the highest priority
Colin Cross9055e212024-03-23 04:43:41 +0000921 // dependency has to be listed last. This is also inconsistent with the way manifests from the same
922 // transitive dependencies are merged.
Colin Crossa14fb6a2024-10-23 16:57:06 -0700923 staticResourcesNodes = depset.New(depset.TOPOLOGICAL, nil,
Colin Cross8676c8c2023-10-12 15:58:57 -0700924 android.ReverseSliceInPlace(staticResourcesNodeDepSets))
Colin Crossa14fb6a2024-10-23 16:57:06 -0700925 sharedResourcesNodes = depset.New(depset.TOPOLOGICAL, nil,
Colin Cross8676c8c2023-10-12 15:58:57 -0700926 android.ReverseSliceInPlace(sharedResourcesNodeDepSets))
Colin Crossa97c5d32018-03-28 14:58:31 -0700927
Colin Crossab8d1382023-07-14 17:23:41 +0000928 staticRRODirs = rroDirsDepSetBuilder.Build()
929 staticManifests = manifestsDepSetBuilder.Build()
930
931 if len(staticResourcesNodes.ToList()) > 0 {
Colin Crossa97c5d32018-03-28 14:58:31 -0700932 flags = append(flags, "--auto-add-overlay")
933 }
934
935 for _, sharedLib := range sharedLibs {
936 flags = append(flags, "-I "+sharedLib.String())
937 }
938
Colin Cross8676c8c2023-10-12 15:58:57 -0700939 return staticResourcesNodes, sharedResourcesNodes, staticRRODirs, staticManifests, sharedLibs, flags
Colin Crossa97c5d32018-03-28 14:58:31 -0700940}
941
Yu Liuc0a36302025-01-10 22:26:01 +0000942type AndroidLibraryInfo struct {
943 // Empty for now
944}
945
946var AndroidLibraryInfoProvider = blueprint.NewProvider[AndroidLibraryInfo]()
947
Colin Crossa97c5d32018-03-28 14:58:31 -0700948type AndroidLibrary struct {
949 Library
950 aapt
951
952 androidLibraryProperties androidLibraryProperties
953
954 aarFile android.WritablePath
Colin Cross89c31582018-04-30 15:55:11 -0700955}
956
Colin Crossa97c5d32018-03-28 14:58:31 -0700957var _ AndroidLibraryDependency = (*AndroidLibrary)(nil)
958
959func (a *AndroidLibrary) DepsMutator(ctx android.BottomUpMutatorContext) {
Jiakai Zhangf98da192024-04-15 11:15:41 +0000960 a.usesLibrary.deps(ctx, false)
Colin Crossa97c5d32018-03-28 14:58:31 -0700961 a.Module.deps(ctx)
Jiyong Parkf1691d22021-03-29 20:11:58 +0900962 sdkDep := decodeSdkDep(ctx, android.SdkContext(a))
Paul Duffin250e6192019-06-07 10:44:37 +0100963 if sdkDep.hasFrameworkLibs() {
964 a.aapt.deps(ctx, sdkDep)
Colin Crossa97c5d32018-03-28 14:58:31 -0700965 }
Jihoon Kang9049c272024-03-19 21:57:36 +0000966
967 for _, aconfig_declaration := range a.aaptProperties.Flags_packages {
968 ctx.AddDependency(ctx.Module(), aconfigDeclarationTag, aconfig_declaration)
969 }
Colin Crossa97c5d32018-03-28 14:58:31 -0700970}
971
972func (a *AndroidLibrary) GenerateAndroidBuildActions(ctx android.ModuleContext) {
Colin Crosse4246ab2019-02-05 21:55:21 -0800973 a.aapt.isLibrary = true
Ulya Trafimovich42c7f0d2021-08-17 16:20:29 +0100974 a.classLoaderContexts = a.usesLibrary.classLoaderContextForUsesLibDeps(ctx)
Spandan Das0727ba72024-02-13 16:37:43 +0000975 if a.usesLibrary.shouldDisableDexpreopt {
976 a.dexpreopter.disableDexpreopt()
977 }
Jihoon Kang9aef7772024-06-14 23:45:06 +0000978 aconfigTextFilePaths := getAconfigFilePaths(ctx)
Alixf7a10272023-09-27 16:47:56 +0000979 a.aapt.buildActions(ctx,
980 aaptBuildActionOptions{
981 sdkContext: android.SdkContext(a),
982 classLoaderContexts: a.classLoaderContexts,
983 enforceDefaultTargetSdkVersion: false,
Jihoon Kang9aef7772024-06-14 23:45:06 +0000984 aconfigTextFiles: aconfigTextFilePaths,
Jiakai Zhang36937082024-04-15 11:15:50 +0000985 usesLibrary: &a.usesLibrary,
Alixf7a10272023-09-27 16:47:56 +0000986 },
987 )
Colin Crossa97c5d32018-03-28 14:58:31 -0700988
Colin Crossff694a82023-12-13 15:54:49 -0800989 apexInfo, _ := android.ModuleProvider(ctx, android.ApexInfoProvider)
990 a.hideApexVariantFromMake = !apexInfo.IsForPlatform()
Colin Cross56a83212020-09-15 18:30:11 -0700991
yangbill2af0b6e2024-03-15 09:29:29 +0000992 a.stem = proptools.StringDefault(a.overridableProperties.Stem, ctx.ModuleName())
Jihoon Kang1bfb6f22023-07-01 00:13:47 +0000993
Colin Cross4eae06d2023-06-20 22:40:02 -0700994 ctx.CheckbuildFile(a.aapt.proguardOptionsFile)
995 ctx.CheckbuildFile(a.aapt.exportPackage)
Colin Cross8f1b0332024-01-25 13:39:06 -0800996 if a.useResourceProcessorBusyBox(ctx) {
Colin Cross4eae06d2023-06-20 22:40:02 -0700997 ctx.CheckbuildFile(a.aapt.rJar)
Colin Crossf3b7bad2023-08-02 15:49:00 -0700998 } else {
999 ctx.CheckbuildFile(a.aapt.aaptSrcJar)
Colin Cross4eae06d2023-06-20 22:40:02 -07001000 }
Colin Crossa97c5d32018-03-28 14:58:31 -07001001
1002 // apps manifests are handled by aapt, don't let Module see them
1003 a.properties.Manifest = nil
1004
Colin Cross014489c2020-06-02 20:09:13 -07001005 a.linter.mergedManifest = a.aapt.mergedManifestFile
1006 a.linter.manifest = a.aapt.manifestPath
1007 a.linter.resources = a.aapt.resourceFiles
1008
Sam Delmericoc8e040c2023-10-31 17:27:02 +00001009 proguardSpecInfo := a.collectProguardSpecInfo(ctx)
Colin Cross40213022023-12-13 15:19:49 -08001010 android.SetProvider(ctx, ProguardSpecInfoProvider, proguardSpecInfo)
Colin Cross312634e2023-11-21 15:13:56 -08001011 exportedProguardFlagsFiles := proguardSpecInfo.ProguardFlagsFiles.ToList()
1012 a.extraProguardFlagsFiles = append(a.extraProguardFlagsFiles, exportedProguardFlagsFiles...)
1013 a.extraProguardFlagsFiles = append(a.extraProguardFlagsFiles, a.proguardOptionsFile)
1014
1015 combinedExportedProguardFlagFile := android.PathForModuleOut(ctx, "export_proguard_flags")
1016 writeCombinedProguardFlagsFile(ctx, combinedExportedProguardFlagFile, exportedProguardFlagsFiles)
1017 a.combinedExportedProguardFlagsFile = combinedExportedProguardFlagFile
Colin Crossa97c5d32018-03-28 14:58:31 -07001018
Colin Cross4eae06d2023-06-20 22:40:02 -07001019 var extraSrcJars android.Paths
1020 var extraCombinedJars android.Paths
1021 var extraClasspathJars android.Paths
Colin Cross8f1b0332024-01-25 13:39:06 -08001022 if a.useResourceProcessorBusyBox(ctx) {
Colin Cross4eae06d2023-06-20 22:40:02 -07001023 // When building a library with ResourceProcessorBusyBox enabled ResourceProcessorBusyBox for this
1024 // library and each of the transitive static android_library dependencies has already created an
1025 // R.class file for the appropriate package. Add all of those R.class files to the classpath.
1026 extraClasspathJars = a.transitiveAaptRJars
1027 } else {
1028 // When building a library without ResourceProcessorBusyBox the aapt2 rule creates R.srcjar containing
1029 // R.java files for the library's package and the packages from all transitive static android_library
1030 // dependencies. Compile the srcjar alongside the rest of the sources.
1031 extraSrcJars = android.Paths{a.aapt.aaptSrcJar}
1032 }
1033
Yu Liu460cf372025-01-10 00:34:06 +00001034 javaInfo := a.Module.compile(ctx, extraSrcJars, extraClasspathJars, extraCombinedJars, nil)
Colin Crossa97c5d32018-03-28 14:58:31 -07001035
Colin Crossf57c5782019-01-25 13:20:38 -08001036 a.aarFile = android.PathForModuleOut(ctx, ctx.ModuleName()+".aar")
Colin Crossa97c5d32018-03-28 14:58:31 -07001037 var res android.Paths
1038 if a.androidLibraryProperties.BuildAAR {
1039 BuildAAR(ctx, a.aarFile, a.outputFile, a.manifestPath, a.rTxt, res)
Colin Crossa97c5d32018-03-28 14:58:31 -07001040 }
Colin Cross89c31582018-04-30 15:55:11 -07001041
Sam Delmerico82602492022-06-10 17:05:42 +00001042 prebuiltJniPackages := android.Paths{}
Yu Liucbb50c22025-01-15 20:57:49 +00001043 ctx.VisitDirectDepsProxy(func(module android.ModuleProxy) {
Colin Cross313aa542023-12-13 13:47:44 -08001044 if info, ok := android.OtherModuleProvider(ctx, module, JniPackageProvider); ok {
Sam Delmerico82602492022-06-10 17:05:42 +00001045 prebuiltJniPackages = append(prebuiltJniPackages, info.JniPackages...)
1046 }
1047 })
1048 if len(prebuiltJniPackages) > 0 {
Colin Cross40213022023-12-13 15:19:49 -08001049 android.SetProvider(ctx, JniPackageProvider, JniPackageInfo{
Sam Delmerico82602492022-06-10 17:05:42 +00001050 JniPackages: prebuiltJniPackages,
1051 })
1052 }
Jihoon Kang9aef7772024-06-14 23:45:06 +00001053
1054 android.SetProvider(ctx, FlagsPackagesProvider, FlagsPackages{
1055 AconfigTextFiles: aconfigTextFilePaths,
1056 })
mrziwang9f7b9f42024-07-10 12:18:06 -07001057
Yu Liu42f69972024-12-13 22:46:12 +00001058 android.SetProvider(ctx, AndroidLibraryInfoProvider, AndroidLibraryInfo{})
1059
Yu Liu460cf372025-01-10 00:34:06 +00001060 if javaInfo != nil {
1061 setExtraJavaInfo(ctx, a, javaInfo)
1062 android.SetProvider(ctx, JavaInfoProvider, javaInfo)
1063 }
1064
mrziwang9f7b9f42024-07-10 12:18:06 -07001065 a.setOutputFiles(ctx)
Wei Li986fe742025-01-30 15:14:42 -08001066
1067 buildComplianceMetadata(ctx)
mrziwang9f7b9f42024-07-10 12:18:06 -07001068}
1069
1070func (a *AndroidLibrary) setOutputFiles(ctx android.ModuleContext) {
1071 ctx.SetOutputFiles([]android.Path{a.aarFile}, ".aar")
1072 setOutputFiles(ctx, a.Library.Module)
Colin Crossa97c5d32018-03-28 14:58:31 -07001073}
1074
Cole Faustb36d31d2024-08-27 16:04:28 -07001075func (a *AndroidLibrary) IDEInfo(ctx android.BaseModuleContext, dpInfo *android.IdeInfo) {
1076 a.Library.IDEInfo(ctx, dpInfo)
1077 a.aapt.IDEInfo(ctx, dpInfo)
Colin Cross95b53b82023-10-17 13:21:02 -07001078}
1079
Cole Faustb36d31d2024-08-27 16:04:28 -07001080func (a *aapt) IDEInfo(ctx android.BaseModuleContext, dpInfo *android.IdeInfo) {
Colin Cross8f1b0332024-01-25 13:39:06 -08001081 if a.rJar != nil {
Colin Cross95b53b82023-10-17 13:21:02 -07001082 dpInfo.Jars = append(dpInfo.Jars, a.rJar.String())
1083 }
1084}
1085
Colin Cross1b16b0e2019-02-12 14:41:32 -08001086// android_library builds and links sources into a `.jar` file for the device along with Android resources.
1087//
1088// An android_library has a single variant that produces a `.jar` file containing `.class` files that were
Sam Delmerico82602492022-06-10 17:05:42 +00001089// compiled against the device bootclasspath, along with a `package-res.apk` file containing Android resources compiled
Colin Cross1b16b0e2019-02-12 14:41:32 -08001090// with aapt2. This module is not suitable for installing on a device, but can be used as a `static_libs` dependency of
1091// an android_app module.
Colin Crossa97c5d32018-03-28 14:58:31 -07001092func AndroidLibraryFactory() android.Module {
1093 module := &AndroidLibrary{}
1094
Colin Crossce6734e2020-06-15 16:09:53 -07001095 module.Module.addHostAndDeviceProperties()
Colin Crossa97c5d32018-03-28 14:58:31 -07001096 module.AddProperties(
Colin Crossa97c5d32018-03-28 14:58:31 -07001097 &module.aaptProperties,
Ronald Braunsteincdc66f42024-04-12 11:23:19 -07001098 &module.androidLibraryProperties,
1099 &module.sourceProperties)
Colin Crossa97c5d32018-03-28 14:58:31 -07001100
1101 module.androidLibraryProperties.BuildAAR = true
Colin Cross014489c2020-06-02 20:09:13 -07001102 module.Module.linter.library = true
Colin Crossa97c5d32018-03-28 14:58:31 -07001103
Jooyung Hanacc7bbe2020-05-20 09:06:00 +09001104 android.InitApexModule(module)
Colin Cross48de9a42018-10-02 13:53:33 -07001105 InitJavaModule(module, android.DeviceSupported)
Colin Crossa97c5d32018-03-28 14:58:31 -07001106 return module
1107}
1108
Colin Crossfabb6082018-02-20 17:22:23 -08001109//
1110// AAR (android library) prebuilts
1111//
Colin Crossfabb6082018-02-20 17:22:23 -08001112
Vinh Trance0781f2022-04-13 01:30:44 +00001113// Properties for android_library_import
Colin Crossfabb6082018-02-20 17:22:23 -08001114type AARImportProperties struct {
Vinh Trance0781f2022-04-13 01:30:44 +00001115 // ARR (android library prebuilt) filepath. Exactly one ARR is required.
Colin Cross27b922f2019-03-04 22:35:41 -08001116 Aars []string `android:"path"`
Vinh Trance0781f2022-04-13 01:30:44 +00001117 // If not blank, set to the version of the sdk to compile against.
1118 // Defaults to private.
1119 // Values are of one of the following forms:
1120 // 1) numerical API level, "current", "none", or "core_platform"
1121 // 2) An SDK kind with an API level: "<sdk kind>_<API level>"
1122 // See build/soong/android/sdk_version.go for the complete and up to date list of SDK kinds.
1123 // If the SDK kind is empty, it will be set to public
1124 Sdk_version *string
1125 // If not blank, set the minimum version of the sdk that the compiled artifacts will run against.
1126 // Defaults to sdk_version if not set. See sdk_version for possible values.
Colin Cross479884c2018-07-10 13:39:30 -07001127 Min_sdk_version *string
Vinh Trance0781f2022-04-13 01:30:44 +00001128 // List of java static libraries that the included ARR (android library prebuilts) has dependencies to.
Cole Faustb7493472024-08-28 11:55:52 -07001129 Static_libs proptools.Configurable[[]string]
Vinh Trance0781f2022-04-13 01:30:44 +00001130 // List of java libraries that the included ARR (android library prebuilts) has dependencies to.
1131 Libs []string
1132 // If set to true, run Jetifier against .aar file. Defaults to false.
Colin Cross1001a792019-03-21 22:21:39 -07001133 Jetifier *bool
Sam Delmerico82602492022-06-10 17:05:42 +00001134 // If true, extract JNI libs from AAR archive. These libs will be accessible to android_app modules and
1135 // will be passed transitively through android_libraries to an android_app.
1136 //TODO(b/241138093) evaluate whether we can have this flag default to true for Bazel conversion
1137 Extract_jni *bool
Colin Cross21ed4692024-04-24 20:23:38 +00001138
1139 // If set, overrides the manifest extracted from the AAR with the provided path.
1140 Manifest *string `android:"path"`
Colin Crossfabb6082018-02-20 17:22:23 -08001141}
1142
1143type AARImport struct {
1144 android.ModuleBase
Colin Cross48de9a42018-10-02 13:53:33 -07001145 android.DefaultableModuleBase
Jooyung Hanacc7bbe2020-05-20 09:06:00 +09001146 android.ApexModuleBase
Colin Crossfabb6082018-02-20 17:22:23 -08001147 prebuilt android.Prebuilt
1148
Jooyung Hanacc7bbe2020-05-20 09:06:00 +09001149 // Functionality common to Module and Import.
1150 embeddableInModuleAndImport
1151
Colin Cross9ffaf282024-08-12 13:50:09 -07001152 providesTransitiveHeaderJarsForR8
Sam Delmerico9f9c0a22022-11-29 11:19:37 -05001153
Colin Crossfabb6082018-02-20 17:22:23 -08001154 properties AARImportProperties
1155
Colin Cross7707b242024-07-26 12:02:36 -07001156 headerJarFile android.Path
1157 implementationJarFile android.Path
1158 implementationAndResourcesJarFile android.Path
1159 proguardFlags android.Path
1160 exportPackage android.Path
Colin Cross312634e2023-11-21 15:13:56 -08001161 transitiveAaptResourcePackagesFile android.Path
Colin Cross7707b242024-07-26 12:02:36 -07001162 extraAaptPackagesFile android.Path
Colin Cross21ed4692024-04-24 20:23:38 +00001163 manifest android.Path
Colin Cross7707b242024-07-26 12:02:36 -07001164 assetsPackage android.Path
1165 rTxt android.Path
1166 rJar android.Path
Colin Cross66f78822018-05-02 12:58:28 -07001167
Colin Crossa14fb6a2024-10-23 16:57:06 -07001168 resourcesNodesDepSet depset.DepSet[*resourcesNode]
1169 manifestsDepSet depset.DepSet[android.Path]
Colin Cross56a83212020-09-15 18:30:11 -07001170
1171 hideApexVariantFromMake bool
Saeid Farivar Asanjanf0436962020-10-05 19:09:09 +00001172
Sam Delmerico82602492022-06-10 17:05:42 +00001173 aarPath android.Path
1174 jniPackages android.Paths
Jiyong Park92315372021-04-02 08:45:46 +09001175
1176 sdkVersion android.SdkSpec
Spandan Das8c9ae7e2023-03-03 21:20:36 +00001177 minSdkVersion android.ApiLevel
LaMont Jonesafe7baf2024-01-09 22:47:39 +00001178
Colin Cross9055e212024-03-23 04:43:41 +00001179 usesLibrary
1180 classLoaderContexts dexpreopt.ClassLoaderContextMap
Saeid Farivar Asanjanf0436962020-10-05 19:09:09 +00001181}
1182
Jiyong Park92315372021-04-02 08:45:46 +09001183func (a *AARImport) SdkVersion(ctx android.EarlyModuleContext) android.SdkSpec {
1184 return android.SdkSpecFrom(ctx, String(a.properties.Sdk_version))
Colin Cross83bb3162018-06-25 15:48:06 -07001185}
1186
Jiyong Parkf1691d22021-03-29 20:11:58 +09001187func (a *AARImport) SystemModules() string {
Paul Duffine25c6442019-10-11 13:50:28 +01001188 return ""
1189}
1190
Spandan Das8c9ae7e2023-03-03 21:20:36 +00001191func (a *AARImport) MinSdkVersion(ctx android.EarlyModuleContext) android.ApiLevel {
Colin Cross479884c2018-07-10 13:39:30 -07001192 if a.properties.Min_sdk_version != nil {
Spandan Das8c9ae7e2023-03-03 21:20:36 +00001193 return android.ApiLevelFrom(ctx, *a.properties.Min_sdk_version)
Colin Cross479884c2018-07-10 13:39:30 -07001194 }
Spandan Das8c9ae7e2023-03-03 21:20:36 +00001195 return a.SdkVersion(ctx).ApiLevel
Colin Cross83bb3162018-06-25 15:48:06 -07001196}
1197
Spandan Dasa26eda72023-03-02 00:56:06 +00001198func (a *AARImport) ReplaceMaxSdkVersionPlaceholder(ctx android.EarlyModuleContext) android.ApiLevel {
1199 return android.SdkSpecFrom(ctx, "").ApiLevel
William Loh5a082f92022-05-17 20:21:50 +00001200}
1201
Spandan Dasca70fc42023-03-01 23:38:49 +00001202func (a *AARImport) TargetSdkVersion(ctx android.EarlyModuleContext) android.ApiLevel {
1203 return a.SdkVersion(ctx).ApiLevel
Dan Willemsen419290a2018-10-31 15:28:47 -07001204}
1205
Colin Cross1e743852019-10-28 11:37:20 -07001206func (a *AARImport) javaVersion() string {
1207 return ""
1208}
1209
Colin Crossa97c5d32018-03-28 14:58:31 -07001210var _ AndroidLibraryDependency = (*AARImport)(nil)
1211
1212func (a *AARImport) ExportPackage() android.Path {
1213 return a.exportPackage
1214}
Colin Crossa14fb6a2024-10-23 16:57:06 -07001215func (a *AARImport) ResourcesNodeDepSet() depset.DepSet[*resourcesNode] {
Colin Crossab8d1382023-07-14 17:23:41 +00001216 return a.resourcesNodesDepSet
Colin Crossc1c37552019-01-31 11:42:41 -08001217}
1218
Colin Crossa14fb6a2024-10-23 16:57:06 -07001219func (a *AARImport) RRODirsDepSet() depset.DepSet[rroDir] {
1220 return depset.New[rroDir](depset.TOPOLOGICAL, nil, nil)
Colin Cross66f78822018-05-02 12:58:28 -07001221}
1222
Colin Crossa14fb6a2024-10-23 16:57:06 -07001223func (a *AARImport) ManifestsDepSet() depset.DepSet[android.Path] {
Colin Crossab8d1382023-07-14 17:23:41 +00001224 return a.manifestsDepSet
Jaewoong Jung6431ca72020-01-15 14:15:10 -08001225}
1226
Jaewoong Jungc779cd42020-10-06 18:56:10 -07001227// RRO enforcement is not available on aar_import since its RRO dirs are not
1228// exported.
1229func (a *AARImport) SetRROEnforcedForDependent(enforce bool) {
1230}
1231
1232// RRO enforcement is not available on aar_import since its RRO dirs are not
1233// exported.
1234func (a *AARImport) IsRROEnforced(ctx android.BaseModuleContext) bool {
1235 return false
1236}
1237
Colin Crossfabb6082018-02-20 17:22:23 -08001238func (a *AARImport) Prebuilt() *android.Prebuilt {
1239 return &a.prebuilt
1240}
1241
1242func (a *AARImport) Name() string {
1243 return a.prebuilt.Name(a.ModuleBase.Name())
1244}
1245
Jiyong Park618922e2020-01-08 13:35:43 +09001246func (a *AARImport) JacocoReportClassesFile() android.Path {
1247 return nil
1248}
1249
Colin Crossfabb6082018-02-20 17:22:23 -08001250func (a *AARImport) DepsMutator(ctx android.BottomUpMutatorContext) {
Jeongik Cha816a23a2020-07-08 01:09:23 +09001251 if !ctx.Config().AlwaysUsePrebuiltSdks() {
Jiyong Parkf1691d22021-03-29 20:11:58 +09001252 sdkDep := decodeSdkDep(ctx, android.SdkContext(a))
Colin Crossa97c5d32018-03-28 14:58:31 -07001253 if sdkDep.useModule && sdkDep.frameworkResModule != "" {
Colin Cross42d48b72018-08-29 14:10:52 -07001254 ctx.AddVariationDependencies(nil, frameworkResTag, sdkDep.frameworkResModule)
Colin Crossfabb6082018-02-20 17:22:23 -08001255 }
1256 }
Colin Crossa97c5d32018-03-28 14:58:31 -07001257
Colin Cross42d48b72018-08-29 14:10:52 -07001258 ctx.AddVariationDependencies(nil, libTag, a.properties.Libs...)
Cole Faustb7493472024-08-28 11:55:52 -07001259 ctx.AddVariationDependencies(nil, staticLibTag, a.properties.Static_libs.GetOrDefault(ctx, nil)...)
Colin Cross9055e212024-03-23 04:43:41 +00001260
1261 a.usesLibrary.deps(ctx, false)
Colin Crossfabb6082018-02-20 17:22:23 -08001262}
1263
Sam Delmerico82602492022-06-10 17:05:42 +00001264type JniPackageInfo struct {
1265 // List of zip files containing JNI libraries
1266 // Zip files should have directory structure jni/<arch>/*.so
1267 JniPackages android.Paths
1268}
1269
Colin Crossbc7d76c2023-12-12 16:39:03 -08001270var JniPackageProvider = blueprint.NewProvider[JniPackageInfo]()
Sam Delmerico82602492022-06-10 17:05:42 +00001271
1272// Unzip an AAR and extract the JNI libs for $archString.
1273var extractJNI = pctx.AndroidStaticRule("extractJNI",
1274 blueprint.RuleParams{
1275 Command: `rm -rf $out $outDir && touch $out && ` +
1276 `unzip -qoDD -d $outDir $in "jni/${archString}/*" && ` +
1277 `jni_files=$$(find $outDir/jni -type f) && ` +
1278 // print error message if there are no JNI libs for this arch
1279 `[ -n "$$jni_files" ] || (echo "ERROR: no JNI libs found for arch ${archString}" && exit 1) && ` +
Sam Delmerico80ee45c2023-06-22 15:36:02 -04001280 `${config.SoongZipCmd} -o $out -L 0 -P 'lib/${archString}' ` +
Sam Delmerico82602492022-06-10 17:05:42 +00001281 `-C $outDir/jni/${archString} $$(echo $$jni_files | xargs -n1 printf " -f %s")`,
1282 CommandDeps: []string{"${config.SoongZipCmd}"},
1283 },
1284 "outDir", "archString")
1285
Colin Crossfabb6082018-02-20 17:22:23 -08001286// Unzip an AAR into its constituent files and directories. Any files in Outputs that don't exist in the AAR will be
Dan Willemsen304cfec2019-05-28 14:49:06 -07001287// touched to create an empty file. The res directory is not extracted, as it will be extracted in its own rule.
Colin Crossfabb6082018-02-20 17:22:23 -08001288var unzipAAR = pctx.AndroidStaticRule("unzipAAR",
1289 blueprint.RuleParams{
Dan Willemsen304cfec2019-05-28 14:49:06 -07001290 Command: `rm -rf $outDir && mkdir -p $outDir && ` +
Colin Cross205e9112020-08-06 13:20:17 -07001291 `unzip -qoDD -d $outDir $in && rm -rf $outDir/res && touch $out && ` +
Michael Rosenfeld5ad15572021-12-03 13:25:10 -08001292 `${config.Zip2ZipCmd} -i $in -o $assetsPackage 'assets/**/*' && ` +
Colin Cross205e9112020-08-06 13:20:17 -07001293 `${config.MergeZipsCmd} $combinedClassesJar $$(ls $outDir/classes.jar 2> /dev/null) $$(ls $outDir/libs/*.jar 2> /dev/null)`,
Michael Rosenfeld5ad15572021-12-03 13:25:10 -08001294 CommandDeps: []string{"${config.MergeZipsCmd}", "${config.Zip2ZipCmd}"},
Colin Crossfabb6082018-02-20 17:22:23 -08001295 },
Michael Rosenfeld5ad15572021-12-03 13:25:10 -08001296 "outDir", "combinedClassesJar", "assetsPackage")
Colin Crossfabb6082018-02-20 17:22:23 -08001297
1298func (a *AARImport) GenerateAndroidBuildActions(ctx android.ModuleContext) {
1299 if len(a.properties.Aars) != 1 {
1300 ctx.PropertyErrorf("aars", "exactly one aar is required")
1301 return
1302 }
1303
Jiyong Park92315372021-04-02 08:45:46 +09001304 a.sdkVersion = a.SdkVersion(ctx)
1305 a.minSdkVersion = a.MinSdkVersion(ctx)
1306
Colin Crossff694a82023-12-13 15:54:49 -08001307 apexInfo, _ := android.ModuleProvider(ctx, android.ApexInfoProvider)
1308 a.hideApexVariantFromMake = !apexInfo.IsForPlatform()
Colin Cross56a83212020-09-15 18:30:11 -07001309
Nan Zhang4c819fb2018-08-27 18:31:46 -07001310 aarName := ctx.ModuleName() + ".aar"
Saeid Farivar Asanjanf0436962020-10-05 19:09:09 +00001311 a.aarPath = android.PathForModuleSrc(ctx, a.properties.Aars[0])
1312
Colin Cross1001a792019-03-21 22:21:39 -07001313 if Bool(a.properties.Jetifier) {
Saeid Farivar Asanjanf0436962020-10-05 19:09:09 +00001314 inputFile := a.aarPath
Colin Cross77965d92024-08-15 17:11:08 -07001315 jetifierPath := android.PathForModuleOut(ctx, "jetifier", aarName)
1316 TransformJetifier(ctx, jetifierPath, inputFile)
1317 a.aarPath = jetifierPath
Nan Zhang4c819fb2018-08-27 18:31:46 -07001318 }
Colin Crossfabb6082018-02-20 17:22:23 -08001319
Colin Cross607bbd62024-04-12 13:44:45 -07001320 jarName := ctx.ModuleName() + ".jar"
Colin Crossfabb6082018-02-20 17:22:23 -08001321 extractedAARDir := android.PathForModuleOut(ctx, "aar")
Colin Cross607bbd62024-04-12 13:44:45 -07001322 classpathFile := extractedAARDir.Join(ctx, jarName)
Colin Cross21ed4692024-04-24 20:23:38 +00001323
1324 extractedManifest := extractedAARDir.Join(ctx, "AndroidManifest.xml")
1325 providedManifest := android.OptionalPathForModuleSrc(ctx, a.properties.Manifest)
1326 if providedManifest.Valid() {
1327 a.manifest = providedManifest.Path()
1328 } else {
1329 a.manifest = extractedManifest
1330 }
1331
Colin Cross7707b242024-07-26 12:02:36 -07001332 rTxt := extractedAARDir.Join(ctx, "R.txt")
1333 assetsPackage := android.PathForModuleOut(ctx, "assets.zip")
1334 proguardFlags := extractedAARDir.Join(ctx, "proguard.txt")
Colin Crosscde55342024-03-27 14:11:51 -07001335 transitiveProguardFlags, transitiveUnconditionalExportedFlags := collectDepProguardSpecInfo(ctx)
Colin Cross40213022023-12-13 15:19:49 -08001336 android.SetProvider(ctx, ProguardSpecInfoProvider, ProguardSpecInfo{
Colin Crossa14fb6a2024-10-23 16:57:06 -07001337 ProguardFlagsFiles: depset.New[android.Path](
1338 depset.POSTORDER,
Colin Cross7707b242024-07-26 12:02:36 -07001339 android.Paths{proguardFlags},
Colin Crosscde55342024-03-27 14:11:51 -07001340 transitiveProguardFlags,
1341 ),
Colin Crossa14fb6a2024-10-23 16:57:06 -07001342 UnconditionallyExportedProguardFlags: depset.New[android.Path](
1343 depset.POSTORDER,
Sam Delmerico95d70942023-08-02 18:00:35 -04001344 nil,
Colin Crosscde55342024-03-27 14:11:51 -07001345 transitiveUnconditionalExportedFlags,
Sam Delmerico95d70942023-08-02 18:00:35 -04001346 ),
1347 })
Colin Crossfabb6082018-02-20 17:22:23 -08001348
1349 ctx.Build(pctx, android.BuildParams{
1350 Rule: unzipAAR,
Saeid Farivar Asanjanf0436962020-10-05 19:09:09 +00001351 Input: a.aarPath,
Colin Cross7707b242024-07-26 12:02:36 -07001352 Outputs: android.WritablePaths{classpathFile, proguardFlags, extractedManifest, assetsPackage, rTxt},
Colin Crossfabb6082018-02-20 17:22:23 -08001353 Description: "unzip AAR",
1354 Args: map[string]string{
Colin Cross205e9112020-08-06 13:20:17 -07001355 "outDir": extractedAARDir.String(),
Colin Cross9055e212024-03-23 04:43:41 +00001356 "combinedClassesJar": classpathFile.String(),
Colin Cross7707b242024-07-26 12:02:36 -07001357 "assetsPackage": assetsPackage.String(),
Colin Crossfabb6082018-02-20 17:22:23 -08001358 },
1359 })
1360
Colin Cross7707b242024-07-26 12:02:36 -07001361 a.proguardFlags = proguardFlags
1362 a.assetsPackage = assetsPackage
1363 a.rTxt = rTxt
1364
Colin Crossa0ba2f52019-06-22 12:59:27 -07001365 // Always set --pseudo-localize, it will be stripped out later for release
1366 // builds that don't want it.
1367 compileFlags := []string{"--pseudo-localize"}
Colin Crossfabb6082018-02-20 17:22:23 -08001368 compiledResDir := android.PathForModuleOut(ctx, "flat-res")
Colin Crossfabb6082018-02-20 17:22:23 -08001369 flata := compiledResDir.Join(ctx, "gen_res.flata")
Saeid Farivar Asanjanf0436962020-10-05 19:09:09 +00001370 aapt2CompileZip(ctx, flata, a.aarPath, "res", compileFlags)
Colin Crossfabb6082018-02-20 17:22:23 -08001371
Colin Cross7707b242024-07-26 12:02:36 -07001372 exportPackage := android.PathForModuleOut(ctx, "package-res.apk")
Colin Crossfabb6082018-02-20 17:22:23 -08001373 proguardOptionsFile := android.PathForModuleGen(ctx, "proguard.options")
Colin Crossbb77d8e2024-02-15 14:43:47 -08001374 aaptRTxt := android.PathForModuleOut(ctx, "R.txt")
Colin Cross7707b242024-07-26 12:02:36 -07001375 extraAaptPackagesFile := android.PathForModuleOut(ctx, "extra_packages")
Colin Crossfabb6082018-02-20 17:22:23 -08001376
1377 var linkDeps android.Paths
1378
1379 linkFlags := []string{
1380 "--static-lib",
Colin Cross4eae06d2023-06-20 22:40:02 -07001381 "--merge-only",
Colin Crossfabb6082018-02-20 17:22:23 -08001382 "--auto-add-overlay",
Colin Cross7c4dc5d2024-02-13 14:29:45 -08001383 "--no-static-lib-packages",
Colin Crossfabb6082018-02-20 17:22:23 -08001384 }
1385
Colin Cross10f7c4a2018-05-23 10:59:28 -07001386 linkFlags = append(linkFlags, "--manifest "+a.manifest.String())
1387 linkDeps = append(linkDeps, a.manifest)
Colin Crossfabb6082018-02-20 17:22:23 -08001388
Colin Cross8676c8c2023-10-12 15:58:57 -07001389 staticResourcesNodesDepSet, sharedResourcesNodesDepSet, staticRRODirsDepSet, staticManifestsDepSet, sharedLibs, libFlags :=
Jiakai Zhang36937082024-04-15 11:15:50 +00001390 aaptLibs(ctx, android.SdkContext(a), nil, nil)
Colin Cross31656952018-05-24 16:11:20 -07001391
Colin Cross8676c8c2023-10-12 15:58:57 -07001392 _ = sharedResourcesNodesDepSet
Colin Crossab8d1382023-07-14 17:23:41 +00001393 _ = staticRRODirsDepSet
Colin Cross8676c8c2023-10-12 15:58:57 -07001394
Colin Crossab8d1382023-07-14 17:23:41 +00001395 staticDeps := transitiveAarDeps(staticResourcesNodesDepSet.ToList())
Colin Crossfabb6082018-02-20 17:22:23 -08001396
Colin Crossab8d1382023-07-14 17:23:41 +00001397 linkDeps = append(linkDeps, sharedLibs...)
Colin Cross4eae06d2023-06-20 22:40:02 -07001398 linkDeps = append(linkDeps, staticDeps.resPackages()...)
Colin Crossa97c5d32018-03-28 14:58:31 -07001399 linkFlags = append(linkFlags, libFlags...)
Colin Crossfabb6082018-02-20 17:22:23 -08001400
Colin Cross4eae06d2023-06-20 22:40:02 -07001401 overlayRes := android.Paths{flata}
1402
1403 // Treat static library dependencies of static libraries as imports.
1404 transitiveStaticLibs := staticDeps.resPackages()
1405 linkDeps = append(linkDeps, transitiveStaticLibs...)
1406 for _, staticLib := range transitiveStaticLibs {
1407 linkFlags = append(linkFlags, "-I "+staticLib.String())
1408 }
Colin Crossfabb6082018-02-20 17:22:23 -08001409
Colin Crossab8d1382023-07-14 17:23:41 +00001410 transitiveAssets := android.ReverseSliceInPlace(staticDeps.assets())
Colin Cross7707b242024-07-26 12:02:36 -07001411 aapt2Link(ctx, exportPackage, nil, proguardOptionsFile, aaptRTxt,
Jihoon Kang84b25892023-12-01 22:01:06 +00001412 linkFlags, linkDeps, nil, overlayRes, transitiveAssets, nil, nil)
Colin Crossa6182ab2024-08-21 10:47:44 -07001413 ctx.CheckbuildFile(exportPackage)
Colin Cross7707b242024-07-26 12:02:36 -07001414 a.exportPackage = exportPackage
Colin Crossfabb6082018-02-20 17:22:23 -08001415
Colin Cross7707b242024-07-26 12:02:36 -07001416 rJar := android.PathForModuleOut(ctx, "busybox/R.jar")
1417 resourceProcessorBusyBoxGenerateBinaryR(ctx, a.rTxt, a.manifest, rJar, nil, true, nil, false)
Colin Crossa6182ab2024-08-21 10:47:44 -07001418 ctx.CheckbuildFile(rJar)
Colin Cross7707b242024-07-26 12:02:36 -07001419 a.rJar = rJar
Colin Cross4eae06d2023-06-20 22:40:02 -07001420
Colin Cross7707b242024-07-26 12:02:36 -07001421 aapt2ExtractExtraPackages(ctx, extraAaptPackagesFile, a.rJar)
1422 a.extraAaptPackagesFile = extraAaptPackagesFile
Colin Crossf3b7bad2023-08-02 15:49:00 -07001423
Colin Crossa14fb6a2024-10-23 16:57:06 -07001424 resourcesNodesDepSetBuilder := depset.NewBuilder[*resourcesNode](depset.TOPOLOGICAL)
Colin Crossab8d1382023-07-14 17:23:41 +00001425 resourcesNodesDepSetBuilder.Direct(&resourcesNode{
1426 resPackage: a.exportPackage,
1427 manifest: a.manifest,
Colin Cross4eae06d2023-06-20 22:40:02 -07001428 rTxt: a.rTxt,
1429 rJar: a.rJar,
Colin Crossab8d1382023-07-14 17:23:41 +00001430 assets: android.OptionalPathForPath(a.assetsPackage),
Colin Cross4eae06d2023-06-20 22:40:02 -07001431
1432 usedResourceProcessor: true,
Colin Crossab8d1382023-07-14 17:23:41 +00001433 })
1434 resourcesNodesDepSetBuilder.Transitive(staticResourcesNodesDepSet)
1435 a.resourcesNodesDepSet = resourcesNodesDepSetBuilder.Build()
1436
Colin Crossa14fb6a2024-10-23 16:57:06 -07001437 manifestDepSetBuilder := depset.NewBuilder[android.Path](depset.TOPOLOGICAL).Direct(a.manifest)
Colin Cross9055e212024-03-23 04:43:41 +00001438 manifestDepSetBuilder.Transitive(staticManifestsDepSet)
Colin Crossab8d1382023-07-14 17:23:41 +00001439 a.manifestsDepSet = manifestDepSetBuilder.Build()
Michael Rosenfeld5ad15572021-12-03 13:25:10 -08001440
Colin Cross312634e2023-11-21 15:13:56 -08001441 transitiveAaptResourcePackages := staticDeps.resPackages().Strings()
1442 transitiveAaptResourcePackages = slices.DeleteFunc(transitiveAaptResourcePackages, func(p string) bool {
1443 return p == a.exportPackage.String()
1444 })
1445 transitiveAaptResourcePackagesFile := android.PathForModuleOut(ctx, "transitive-res-packages")
1446 android.WriteFileRule(ctx, transitiveAaptResourcePackagesFile, strings.Join(transitiveAaptResourcePackages, "\n"))
1447 a.transitiveAaptResourcePackagesFile = transitiveAaptResourcePackagesFile
Colin Cross4eae06d2023-06-20 22:40:02 -07001448
Colin Cross9ffaf282024-08-12 13:50:09 -07001449 a.collectTransitiveHeaderJarsForR8(ctx)
Colin Cross9055e212024-03-23 04:43:41 +00001450
1451 a.classLoaderContexts = a.usesLibrary.classLoaderContextForUsesLibDeps(ctx)
1452
1453 var staticJars android.Paths
1454 var staticHeaderJars android.Paths
Colin Cross607bbd62024-04-12 13:44:45 -07001455 var staticResourceJars android.Paths
Colin Crossa14fb6a2024-10-23 16:57:06 -07001456 var transitiveStaticLibsHeaderJars []depset.DepSet[android.Path]
1457 var transitiveStaticLibsImplementationJars []depset.DepSet[android.Path]
1458 var transitiveStaticLibsResourceJars []depset.DepSet[android.Path]
Colin Crossc9b4f6b2024-07-26 15:25:46 -07001459
Yu Liu39f5fb32025-01-13 23:52:19 +00001460 ctx.VisitDirectDepsProxy(func(module android.ModuleProxy) {
Colin Cross9055e212024-03-23 04:43:41 +00001461 if dep, ok := android.OtherModuleProvider(ctx, module, JavaInfoProvider); ok {
1462 tag := ctx.OtherModuleDependencyTag(module)
1463 switch tag {
1464 case staticLibTag:
1465 staticJars = append(staticJars, dep.ImplementationJars...)
1466 staticHeaderJars = append(staticHeaderJars, dep.HeaderJars...)
Colin Cross607bbd62024-04-12 13:44:45 -07001467 staticResourceJars = append(staticResourceJars, dep.ResourceJars...)
Colin Crossa14fb6a2024-10-23 16:57:06 -07001468 transitiveStaticLibsHeaderJars = append(transitiveStaticLibsHeaderJars, dep.TransitiveStaticLibsHeaderJars)
1469 transitiveStaticLibsImplementationJars = append(transitiveStaticLibsImplementationJars, dep.TransitiveStaticLibsImplementationJars)
1470 transitiveStaticLibsResourceJars = append(transitiveStaticLibsResourceJars, dep.TransitiveStaticLibsResourceJars)
Colin Cross9055e212024-03-23 04:43:41 +00001471 }
1472 }
1473 addCLCFromDep(ctx, module, a.classLoaderContexts)
Jiakai Zhang36937082024-04-15 11:15:50 +00001474 addMissingOptionalUsesLibsFromDep(ctx, module, &a.usesLibrary)
Colin Cross9055e212024-03-23 04:43:41 +00001475 })
1476
Colin Crossa14fb6a2024-10-23 16:57:06 -07001477 completeStaticLibsHeaderJars := depset.New(depset.PREORDER, android.Paths{classpathFile}, transitiveStaticLibsHeaderJars)
1478 completeStaticLibsImplementationJars := depset.New(depset.PREORDER, android.Paths{classpathFile}, transitiveStaticLibsImplementationJars)
1479 completeStaticLibsResourceJars := depset.New(depset.PREORDER, nil, transitiveStaticLibsResourceJars)
Colin Crossc9b4f6b2024-07-26 15:25:46 -07001480
Colin Cross77965d92024-08-15 17:11:08 -07001481 var implementationJarFile android.Path
Colin Crossc9b4f6b2024-07-26 15:25:46 -07001482 var combineJars android.Paths
1483 if ctx.Config().UseTransitiveJarsInClasspath() {
1484 combineJars = completeStaticLibsImplementationJars.ToList()
1485 } else {
1486 combineJars = append(android.Paths{classpathFile}, staticJars...)
1487 }
1488
1489 if len(combineJars) > 1 {
1490 implementationJarOutputPath := android.PathForModuleOut(ctx, "combined", jarName)
1491 TransformJarsToJar(ctx, implementationJarOutputPath, "combine", combineJars, android.OptionalPath{}, false, nil, nil)
1492 implementationJarFile = implementationJarOutputPath
Colin Cross9055e212024-03-23 04:43:41 +00001493 } else {
Colin Cross28ac2ff2024-04-02 12:21:34 -07001494 implementationJarFile = classpathFile
Colin Cross9055e212024-03-23 04:43:41 +00001495 }
1496
Colin Cross607bbd62024-04-12 13:44:45 -07001497 var resourceJarFile android.Path
Colin Crossc9b4f6b2024-07-26 15:25:46 -07001498 var resourceJars android.Paths
1499 if ctx.Config().UseTransitiveJarsInClasspath() {
1500 resourceJars = completeStaticLibsResourceJars.ToList()
1501 } else {
1502 resourceJars = staticResourceJars
1503 }
1504 if len(resourceJars) > 1 {
Colin Cross607bbd62024-04-12 13:44:45 -07001505 combinedJar := android.PathForModuleOut(ctx, "res-combined", jarName)
Colin Crossc9b4f6b2024-07-26 15:25:46 -07001506 TransformJarsToJar(ctx, combinedJar, "for resources", resourceJars, android.OptionalPath{},
Colin Cross607bbd62024-04-12 13:44:45 -07001507 false, nil, nil)
1508 resourceJarFile = combinedJar
Colin Crossc9b4f6b2024-07-26 15:25:46 -07001509 } else if len(resourceJars) == 1 {
1510 resourceJarFile = resourceJars[0]
Colin Cross607bbd62024-04-12 13:44:45 -07001511 }
1512
1513 // merge implementation jar with resources if necessary
Colin Crossc9b4f6b2024-07-26 15:25:46 -07001514 var implementationAndResourcesJars android.Paths
1515 if ctx.Config().UseTransitiveJarsInClasspath() {
1516 implementationAndResourcesJars = append(slices.Clone(resourceJars), combineJars...)
1517 } else {
1518 implementationAndResourcesJars = android.PathsIfNonNil(resourceJarFile, implementationJarFile)
1519 }
1520 var implementationAndResourcesJar android.Path
1521 if len(implementationAndResourcesJars) > 1 {
Colin Cross77965d92024-08-15 17:11:08 -07001522 combinedJar := android.PathForModuleOut(ctx, "withres", jarName)
Colin Crossc9b4f6b2024-07-26 15:25:46 -07001523 TransformJarsToJar(ctx, combinedJar, "for resources", implementationAndResourcesJars, android.OptionalPath{},
Colin Cross607bbd62024-04-12 13:44:45 -07001524 false, nil, nil)
1525 implementationAndResourcesJar = combinedJar
Colin Crossc9b4f6b2024-07-26 15:25:46 -07001526 } else {
1527 implementationAndResourcesJar = implementationAndResourcesJars[0]
Colin Cross607bbd62024-04-12 13:44:45 -07001528 }
1529
1530 a.implementationJarFile = implementationJarFile
Colin Cross28ac2ff2024-04-02 12:21:34 -07001531 // Save the output file with no relative path so that it doesn't end up in a subdirectory when used as a resource
Colin Cross607bbd62024-04-12 13:44:45 -07001532 a.implementationAndResourcesJarFile = implementationAndResourcesJar.WithoutRel()
Colin Cross28ac2ff2024-04-02 12:21:34 -07001533
Colin Crossc9b4f6b2024-07-26 15:25:46 -07001534 var headerJars android.Paths
1535 if ctx.Config().UseTransitiveJarsInClasspath() {
1536 headerJars = completeStaticLibsHeaderJars.ToList()
1537 } else {
1538 headerJars = append(android.Paths{classpathFile}, staticHeaderJars...)
1539 }
1540 if len(headerJars) > 1 {
Colin Cross7707b242024-07-26 12:02:36 -07001541 headerJarFile := android.PathForModuleOut(ctx, "turbine-combined", jarName)
Colin Crossc9b4f6b2024-07-26 15:25:46 -07001542 TransformJarsToJar(ctx, headerJarFile, "combine header jars", headerJars, android.OptionalPath{}, false, nil, nil)
Colin Cross7707b242024-07-26 12:02:36 -07001543 a.headerJarFile = headerJarFile
Colin Cross9055e212024-03-23 04:43:41 +00001544 } else {
Colin Crossc9b4f6b2024-07-26 15:25:46 -07001545 a.headerJarFile = headerJars[0]
Colin Cross9055e212024-03-23 04:43:41 +00001546 }
1547
Colin Crossc9b4f6b2024-07-26 15:25:46 -07001548 if ctx.Config().UseTransitiveJarsInClasspath() {
1549 ctx.CheckbuildFile(classpathFile)
1550 } else {
1551 ctx.CheckbuildFile(a.headerJarFile)
1552 ctx.CheckbuildFile(a.implementationJarFile)
1553 }
Colin Crossa6182ab2024-08-21 10:47:44 -07001554
Yu Liu460cf372025-01-10 00:34:06 +00001555 javaInfo := &JavaInfo{
Colin Crossc9b4f6b2024-07-26 15:25:46 -07001556 HeaderJars: android.PathsIfNonNil(a.headerJarFile),
1557 LocalHeaderJars: android.PathsIfNonNil(classpathFile),
1558 TransitiveStaticLibsHeaderJars: completeStaticLibsHeaderJars,
1559 TransitiveStaticLibsImplementationJars: completeStaticLibsImplementationJars,
1560 TransitiveStaticLibsResourceJars: completeStaticLibsResourceJars,
1561 ResourceJars: android.PathsIfNonNil(resourceJarFile),
1562 TransitiveLibsHeaderJarsForR8: a.transitiveLibsHeaderJarsForR8,
1563 TransitiveStaticLibsHeaderJarsForR8: a.transitiveStaticLibsHeaderJarsForR8,
1564 ImplementationAndResourcesJars: android.PathsIfNonNil(a.implementationAndResourcesJarFile),
1565 ImplementationJars: android.PathsIfNonNil(a.implementationJarFile),
1566 StubsLinkType: Implementation,
Joe Onorato6fe59eb2023-07-16 13:20:33 -07001567 // TransitiveAconfigFiles: // TODO(b/289117800): LOCAL_ACONFIG_FILES for prebuilts
Yu Liu460cf372025-01-10 00:34:06 +00001568 }
1569 setExtraJavaInfo(ctx, a, javaInfo)
1570 android.SetProvider(ctx, JavaInfoProvider, javaInfo)
Sam Delmerico82602492022-06-10 17:05:42 +00001571
1572 if proptools.Bool(a.properties.Extract_jni) {
1573 for _, t := range ctx.MultiTargets() {
1574 arch := t.Arch.Abi[0]
1575 path := android.PathForModuleOut(ctx, arch+"_jni.zip")
1576 a.jniPackages = append(a.jniPackages, path)
1577
1578 outDir := android.PathForModuleOut(ctx, "aarForJni")
1579 aarPath := android.PathForModuleSrc(ctx, a.properties.Aars[0])
1580 ctx.Build(pctx, android.BuildParams{
1581 Rule: extractJNI,
1582 Input: aarPath,
1583 Outputs: android.WritablePaths{path},
1584 Description: "extract JNI from AAR",
1585 Args: map[string]string{
1586 "outDir": outDir.String(),
1587 "archString": arch,
1588 },
1589 })
1590 }
Sam Delmerico82602492022-06-10 17:05:42 +00001591 }
Colin Crosse8eeec92023-12-14 14:50:05 -08001592
Colin Cross40213022023-12-13 15:19:49 -08001593 android.SetProvider(ctx, JniPackageProvider, JniPackageInfo{
Colin Crosse8eeec92023-12-14 14:50:05 -08001594 JniPackages: a.jniPackages,
1595 })
mrziwang68786d82024-07-09 10:41:55 -07001596
1597 ctx.SetOutputFiles([]android.Path{a.implementationAndResourcesJarFile}, "")
1598 ctx.SetOutputFiles([]android.Path{a.aarPath}, ".aar")
Wei Li986fe742025-01-30 15:14:42 -08001599
1600 buildComplianceMetadata(ctx)
Colin Crossdcf71b22021-02-01 13:59:03 -08001601}
Colin Crossfabb6082018-02-20 17:22:23 -08001602
1603func (a *AARImport) HeaderJars() android.Paths {
Colin Cross9055e212024-03-23 04:43:41 +00001604 return android.Paths{a.headerJarFile}
Colin Crossfabb6082018-02-20 17:22:23 -08001605}
1606
Colin Cross331a1212018-08-15 20:40:52 -07001607func (a *AARImport) ImplementationAndResourcesJars() android.Paths {
Colin Cross607bbd62024-04-12 13:44:45 -07001608 return android.Paths{a.implementationAndResourcesJarFile}
Colin Cross331a1212018-08-15 20:40:52 -07001609}
1610
Colin Cross9055e212024-03-23 04:43:41 +00001611func (a *AARImport) DexJarBuildPath(ctx android.ModuleErrorfContext) OptionalDexJarPath {
1612 return OptionalDexJarPath{}
Colin Crossf24a22a2019-01-31 14:12:44 -08001613}
1614
Ulya Trafimovich9f3052c2020-06-09 14:31:19 +01001615func (a *AARImport) DexJarInstallPath() android.Path {
1616 return nil
1617}
1618
Ulya Trafimovichb23d28c2020-10-08 12:53:58 +01001619func (a *AARImport) ClassLoaderContexts() dexpreopt.ClassLoaderContextMap {
Colin Cross9055e212024-03-23 04:43:41 +00001620 return a.classLoaderContexts
Jiyong Park1be96912018-05-28 18:02:19 +09001621}
1622
Colin Cross9055e212024-03-23 04:43:41 +00001623var _ UsesLibraryDependency = (*AARImport)(nil)
1624
Jiyong Park45bf82e2020-12-15 22:29:02 +09001625var _ android.ApexModule = (*AARImport)(nil)
1626
1627// Implements android.ApexModule
Yu Liuf1806032025-02-07 00:23:34 +00001628func (m *AARImport) GetDepInSameApexChecker() android.DepInSameApexChecker {
1629 return AARImportDepInSameApexChecker{}
1630}
1631
1632type AARImportDepInSameApexChecker struct {
1633 android.BaseDepInSameApexChecker
1634}
1635
1636func (m AARImportDepInSameApexChecker) OutgoingDepIsInSameApex(tag blueprint.DependencyTag) bool {
1637 return depIsInSameApex(tag)
Jooyung Hanacc7bbe2020-05-20 09:06:00 +09001638}
1639
Jiyong Park45bf82e2020-12-15 22:29:02 +09001640// Implements android.ApexModule
Yu Liudf0b8392025-02-12 18:27:03 +00001641func (a *AARImport) MinSdkVersionSupported(ctx android.BaseModuleContext) android.ApiLevel {
1642 return android.MinApiLevel
Jooyung Han749dc692020-04-15 11:03:39 +09001643}
1644
Sam Delmericoaf8bb702022-07-25 15:39:32 -04001645var _ android.PrebuiltInterface = (*AARImport)(nil)
Colin Crossfabb6082018-02-20 17:22:23 -08001646
Jiakai Zhangf98da192024-04-15 11:15:41 +00001647func (a *AARImport) UsesLibrary() *usesLibrary {
1648 return &a.usesLibrary
1649}
1650
1651var _ ModuleWithUsesLibrary = (*AARImport)(nil)
1652
Colin Cross1b16b0e2019-02-12 14:41:32 -08001653// android_library_import imports an `.aar` file into the build graph as if it was built with android_library.
1654//
1655// This module is not suitable for installing on a device, but can be used as a `static_libs` dependency of
1656// an android_app module.
Colin Crossfabb6082018-02-20 17:22:23 -08001657func AARImportFactory() android.Module {
1658 module := &AARImport{}
1659
Colin Cross9055e212024-03-23 04:43:41 +00001660 module.AddProperties(
1661 &module.properties,
1662 &module.usesLibrary.usesLibraryProperties,
1663 )
Colin Crossfabb6082018-02-20 17:22:23 -08001664
1665 android.InitPrebuiltModule(module, &module.properties.Aars)
Jooyung Hanacc7bbe2020-05-20 09:06:00 +09001666 android.InitApexModule(module)
Sam Delmerico82602492022-06-10 17:05:42 +00001667 InitJavaModuleMultiTargets(module, android.DeviceSupported)
Colin Crossfabb6082018-02-20 17:22:23 -08001668 return module
1669}
Spandan Dasb08bf772024-08-07 21:55:42 +00001670
Cole Faustb36d31d2024-08-27 16:04:28 -07001671func (a *AARImport) IDEInfo(ctx android.BaseModuleContext, dpInfo *android.IdeInfo) {
Spandan Das65bfc292025-01-02 22:55:56 +00001672 dpInfo.Jars = append(dpInfo.Jars, a.implementationJarFile.String(), a.rJar.String())
Spandan Dasb08bf772024-08-07 21:55:42 +00001673}