blob: c5e6710c0011ab62d596ed2f3697c3ccf3f0de24 [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 (
Colin Crossa592e3e2019-02-19 16:59:53 -080018 "fmt"
Jaewoong Jung5b425e22019-06-17 17:40:56 -070019 "path/filepath"
Colin Crossc20dc852020-11-10 12:27:45 -080020 "strconv"
Colin Crossa97c5d32018-03-28 14:58:31 -070021 "strings"
Colin Crossfabb6082018-02-20 17:22:23 -080022
Jaewoong Jung9befb0c2020-01-18 10:33:43 -080023 "android/soong/android"
Romain Jobredeauxc9b2bba2022-02-15 09:35:07 -050024 "android/soong/bazel"
Ulya Trafimovich31e444e2020-08-14 17:32:16 +010025 "android/soong/dexpreopt"
Romain Jobredeaux7a71e072023-08-16 17:39:12 -040026 "android/soong/ui/metrics/bp2build_metrics_proto"
Jaewoong Jung9befb0c2020-01-18 10:33:43 -080027
Colin Crossfabb6082018-02-20 17:22:23 -080028 "github.com/google/blueprint"
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 Crossab8d1382023-07-14 17:23:41 +000034 ResourcesNodeDepSet() *android.DepSet[*resourcesNode]
35 RRODirsDepSet() *android.DepSet[rroDir]
36 ManifestsDepSet() *android.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) {
49 ctx.TopDown("propagate_rro_enforcement", propagateRROEnforcementMutator).Parallel()
50 })
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.
Colin Crossa97c5d32018-03-28 14:58:31 -070080 Resource_dirs []string
81
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 Cross039d8df2023-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"`
Colin Crossa97c5d32018-03-28 14:58:31 -0700105}
106
107type aapt struct {
Colin Cross039d8df2023-06-20 22:40:02 -0700108 aaptSrcJar android.Path
109 transitiveAaptRJars android.Paths
110 transitiveAaptResourcePackages android.Paths
111 exportPackage android.Path
112 manifestPath android.Path
113 proguardOptionsFile android.Path
114 rTxt android.Path
115 rJar android.Path
116 extraAaptPackagesFile android.Path
117 mergedManifestFile android.Path
118 noticeFile android.OptionalPath
119 assetPackage android.OptionalPath
120 isLibrary bool
121 defaultManifestVersion string
122 useEmbeddedNativeLibs bool
123 useEmbeddedDex bool
124 usesNonSdkApis bool
125 hasNoCode bool
126 LoggingParent string
127 resourceFiles android.Paths
Colin Crossa97c5d32018-03-28 14:58:31 -0700128
Colin Crosse560c4a2019-03-19 16:03:11 -0700129 splitNames []string
130 splits []split
131
Colin Crossa97c5d32018-03-28 14:58:31 -0700132 aaptProperties aaptProperties
Colin Crossab8d1382023-07-14 17:23:41 +0000133
134 resourcesNodesDepSet *android.DepSet[*resourcesNode]
135 rroDirsDepSet *android.DepSet[rroDir]
136 manifestsDepSet *android.DepSet[android.Path]
Alix96ea88452023-08-31 15:48:23 +0000137
138 manifestValues struct {
139 applicationId string
140 }
Colin Crossa97c5d32018-03-28 14:58:31 -0700141}
142
Colin Crosse560c4a2019-03-19 16:03:11 -0700143type split struct {
144 name string
145 suffix string
146 path android.Path
147}
148
Jaewoong Jungc779cd42020-10-06 18:56:10 -0700149// Propagate RRO enforcement flag to static lib dependencies transitively.
150func propagateRROEnforcementMutator(ctx android.TopDownMutatorContext) {
151 m := ctx.Module()
152 if d, ok := m.(AndroidLibraryDependency); ok && d.IsRROEnforced(ctx) {
153 ctx.VisitDirectDepsWithTag(staticLibTag, func(d android.Module) {
154 if a, ok := d.(AndroidLibraryDependency); ok {
155 a.SetRROEnforcedForDependent(true)
156 }
157 })
158 }
159}
160
Colin Cross039d8df2023-06-20 22:40:02 -0700161func (a *aapt) useResourceProcessorBusyBox() bool {
162 return BoolDefault(a.aaptProperties.Use_resource_processor, false)
163}
164
Colin Crossa97c5d32018-03-28 14:58:31 -0700165func (a *aapt) ExportPackage() android.Path {
166 return a.exportPackage
167}
Colin Crossab8d1382023-07-14 17:23:41 +0000168func (a *aapt) ResourcesNodeDepSet() *android.DepSet[*resourcesNode] {
169 return a.resourcesNodesDepSet
Colin Crossc1c37552019-01-31 11:42:41 -0800170}
171
Colin Crossab8d1382023-07-14 17:23:41 +0000172func (a *aapt) RRODirsDepSet() *android.DepSet[rroDir] {
173 return a.rroDirsDepSet
Colin Crossc1c37552019-01-31 11:42:41 -0800174}
175
Colin Crossab8d1382023-07-14 17:23:41 +0000176func (a *aapt) ManifestsDepSet() *android.DepSet[android.Path] {
177 return a.manifestsDepSet
Jaewoong Jung6431ca72020-01-15 14:15:10 -0800178}
179
Jaewoong Jungc779cd42020-10-06 18:56:10 -0700180func (a *aapt) SetRROEnforcedForDependent(enforce bool) {
181 a.aaptProperties.RROEnforcedForDependent = enforce
182}
183
184func (a *aapt) IsRROEnforced(ctx android.BaseModuleContext) bool {
185 // True if RRO is enforced for this module or...
186 return ctx.Config().EnforceRROForModule(ctx.ModuleName()) ||
Jeongik Chacee5ba92021-02-19 12:11:51 +0900187 // if RRO is enforced for any of its dependents.
188 a.aaptProperties.RROEnforcedForDependent
Jaewoong Jungc779cd42020-10-06 18:56:10 -0700189}
190
Jiyong Parkf1691d22021-03-29 20:11:58 +0900191func (a *aapt) aapt2Flags(ctx android.ModuleContext, sdkContext android.SdkContext,
Colin Crossa0ba2f52019-06-22 12:59:27 -0700192 manifestPath android.Path) (compileFlags, linkFlags []string, linkDeps android.Paths,
193 resDirs, overlayDirs []globbedResourceDir, rroDirs []rroDir, resZips android.Paths) {
Colin Crossa97c5d32018-03-28 14:58:31 -0700194
Jaewoong Jung3aff5782020-02-11 07:54:35 -0800195 hasVersionCode := android.PrefixInList(a.aaptProperties.Aaptflags, "--version-code")
196 hasVersionName := android.PrefixInList(a.aaptProperties.Aaptflags, "--version-name")
Colin Crossa97c5d32018-03-28 14:58:31 -0700197
Colin Crossa97c5d32018-03-28 14:58:31 -0700198 // Flags specified in Android.bp
199 linkFlags = append(linkFlags, a.aaptProperties.Aaptflags...)
200
Eric Miao40eab202023-03-30 16:57:17 +0000201 linkFlags = append(linkFlags, "--enable-compact-entries")
Colin Crossa97c5d32018-03-28 14:58:31 -0700202
203 // Find implicit or explicit asset and resource dirs
Jiakai Zhangba82e282023-10-13 18:08:59 +0100204 assets := android.PathsRelativeToModuleSourceDir(android.SourceInput{
205 Context: ctx,
206 Paths: a.aaptProperties.Assets,
207 IncludeDirs: false,
208 })
Colin Crossa97c5d32018-03-28 14:58:31 -0700209 assetDirs := android.PathsWithOptionalDefaultForModuleSrc(ctx, a.aaptProperties.Asset_dirs, "assets")
210 resourceDirs := android.PathsWithOptionalDefaultForModuleSrc(ctx, a.aaptProperties.Resource_dirs, "res")
Colin Cross8a497952019-03-05 22:25:09 -0800211 resourceZips := android.PathsForModuleSrc(ctx, a.aaptProperties.Resource_zips)
Colin Crossa97c5d32018-03-28 14:58:31 -0700212
Colin Crossa97c5d32018-03-28 14:58:31 -0700213 // Glob directories into lists of paths
214 for _, dir := range resourceDirs {
215 resDirs = append(resDirs, globbedResourceDir{
216 dir: dir,
217 files: androidResourceGlob(ctx, dir),
218 })
Jaewoong Jungc779cd42020-10-06 18:56:10 -0700219 resOverlayDirs, resRRODirs := overlayResourceGlob(ctx, a, dir)
Colin Crossa97c5d32018-03-28 14:58:31 -0700220 overlayDirs = append(overlayDirs, resOverlayDirs...)
221 rroDirs = append(rroDirs, resRRODirs...)
222 }
223
Colin Crossc20dc852020-11-10 12:27:45 -0800224 var assetDeps android.Paths
225 for i, dir := range assetDirs {
226 // Add a dependency on every file in the asset directory. This ensures the aapt2
227 // rule will be rerun if one of the files in the asset directory is modified.
228 assetDeps = append(assetDeps, androidResourceGlob(ctx, dir)...)
229
230 // Add a dependency on a file that contains a list of all the files in the asset directory.
231 // This ensures the aapt2 rule will be run if a file is removed from the asset directory,
232 // or a file is added whose timestamp is older than the output of aapt2.
233 assetFileListFile := android.PathForModuleOut(ctx, "asset_dir_globs", strconv.Itoa(i)+".glob")
234 androidResourceGlobList(ctx, dir, assetFileListFile)
235 assetDeps = append(assetDeps, assetFileListFile)
Colin Crossa97c5d32018-03-28 14:58:31 -0700236 }
237
Jaewoong Jung5b425e22019-06-17 17:40:56 -0700238 assetDirStrings := assetDirs.Strings()
239 if a.noticeFile.Valid() {
240 assetDirStrings = append(assetDirStrings, filepath.Dir(a.noticeFile.Path().String()))
Colin Crossc20dc852020-11-10 12:27:45 -0800241 assetDeps = append(assetDeps, a.noticeFile.Path())
Jaewoong Jung5b425e22019-06-17 17:40:56 -0700242 }
Jiakai Zhangba82e282023-10-13 18:08:59 +0100243 if len(assets) > 0 {
244 // aapt2 doesn't support adding individual asset files. Create a temp directory to hold asset
245 // files and pass it to aapt2.
246 tmpAssetDir := android.PathForModuleOut(ctx, "tmp_asset_dir")
247
248 rule := android.NewRuleBuilder(pctx, ctx)
249 rule.Command().
250 Text("rm -rf").Text(tmpAssetDir.String()).
251 Text("&&").
252 Text("mkdir -p").Text(tmpAssetDir.String())
253
254 for _, asset := range assets {
255 output := tmpAssetDir.Join(ctx, asset.Rel())
256 assetDeps = append(assetDeps, output)
257 rule.Command().Text("mkdir -p").Text(filepath.Dir(output.String()))
258 rule.Command().Text("cp").Input(asset).Output(output)
259 }
260
261 rule.Build("tmp_asset_dir", "tmp_asset_dir")
262
263 assetDirStrings = append(assetDirStrings, tmpAssetDir.String())
264 }
Jaewoong Jung5b425e22019-06-17 17:40:56 -0700265
Colin Crossa97c5d32018-03-28 14:58:31 -0700266 linkFlags = append(linkFlags, "--manifest "+manifestPath.String())
267 linkDeps = append(linkDeps, manifestPath)
268
Jaewoong Jung5b425e22019-06-17 17:40:56 -0700269 linkFlags = append(linkFlags, android.JoinWithPrefix(assetDirStrings, "-A "))
Colin Crossc20dc852020-11-10 12:27:45 -0800270 linkDeps = append(linkDeps, assetDeps...)
Colin Crossa97c5d32018-03-28 14:58:31 -0700271
Spandan Das50885c02023-02-23 21:31:33 +0000272 // Returns the effective version for {min|target}_sdk_version
Spandan Das8c9ae7e2023-03-03 21:20:36 +0000273 effectiveVersionString := func(sdkVersion android.SdkSpec, minSdkVersion android.ApiLevel) string {
Spandan Das50885c02023-02-23 21:31:33 +0000274 // If {min|target}_sdk_version is current, use sdk_version to determine the effective level
275 // This is necessary for vendor modules.
276 // The effective version does not _only_ depend on {min|target}_sdk_version(level),
277 // but also on the sdk_version (kind+level)
Spandan Das8c9ae7e2023-03-03 21:20:36 +0000278 if minSdkVersion.IsCurrent() {
Spandan Das50885c02023-02-23 21:31:33 +0000279 ret, err := sdkVersion.EffectiveVersionString(ctx)
280 if err != nil {
281 ctx.ModuleErrorf("invalid sdk_version: %s", err)
282 }
283 return ret
284 }
285 ret, err := minSdkVersion.EffectiveVersionString(ctx)
286 if err != nil {
287 ctx.ModuleErrorf("invalid min_sdk_version: %s", err)
288 }
289 return ret
Jiyong Park6a927c42020-01-21 02:03:43 +0900290 }
Spandan Das50885c02023-02-23 21:31:33 +0000291 // SDK version flags
292 sdkVersion := sdkContext.SdkVersion(ctx)
293 minSdkVersion := effectiveVersionString(sdkVersion, sdkContext.MinSdkVersion(ctx))
Colin Crossa97c5d32018-03-28 14:58:31 -0700294
Colin Cross83bb3162018-06-25 15:48:06 -0700295 linkFlags = append(linkFlags, "--min-sdk-version "+minSdkVersion)
Spandan Das6450b552023-02-23 19:27:07 +0000296 // Use minSdkVersion for target-sdk-version, even if `target_sdk_version` is set
297 // This behavior has been copied from Make.
Colin Cross83bb3162018-06-25 15:48:06 -0700298 linkFlags = append(linkFlags, "--target-sdk-version "+minSdkVersion)
Colin Crossa97c5d32018-03-28 14:58:31 -0700299
Colin Crossa97c5d32018-03-28 14:58:31 -0700300 // Version code
301 if !hasVersionCode {
Dan Albert4f378d72020-07-23 17:32:15 -0700302 linkFlags = append(linkFlags, "--version-code", ctx.Config().PlatformSdkVersion().String())
Colin Crossa97c5d32018-03-28 14:58:31 -0700303 }
304
305 if !hasVersionName {
Colin Cross402d5e02018-04-25 14:54:06 -0700306 var versionName string
307 if ctx.ModuleName() == "framework-res" {
308 // Some builds set AppsDefaultVersionName() to include the build number ("O-123456"). aapt2 copies the
309 // version name of framework-res into app manifests as compileSdkVersionCodename, which confuses things
Colin Crossbfd347d2018-05-09 11:11:35 -0700310 // if it contains the build number. Use the PlatformVersionName instead.
311 versionName = ctx.Config().PlatformVersionName()
Colin Cross402d5e02018-04-25 14:54:06 -0700312 } else {
313 versionName = ctx.Config().AppsDefaultVersionName()
314 }
Colin Cross0b9f31f2019-02-28 11:00:01 -0800315 versionName = proptools.NinjaEscape(versionName)
Colin Crossa97c5d32018-03-28 14:58:31 -0700316 linkFlags = append(linkFlags, "--version-name ", versionName)
317 }
318
Colin Crossa0ba2f52019-06-22 12:59:27 -0700319 linkFlags, compileFlags = android.FilterList(linkFlags, []string{"--legacy"})
320
321 // Always set --pseudo-localize, it will be stripped out later for release
322 // builds that don't want it.
323 compileFlags = append(compileFlags, "--pseudo-localize")
324
325 return compileFlags, linkFlags, linkDeps, resDirs, overlayDirs, rroDirs, resourceZips
Colin Crossa97c5d32018-03-28 14:58:31 -0700326}
327
Paul Duffin250e6192019-06-07 10:44:37 +0100328func (a *aapt) deps(ctx android.BottomUpMutatorContext, sdkDep sdkDep) {
Colin Cross42308aa2018-11-14 21:44:17 -0800329 if sdkDep.frameworkResModule != "" {
330 ctx.AddVariationDependencies(nil, frameworkResTag, sdkDep.frameworkResModule)
Colin Crossa97c5d32018-03-28 14:58:31 -0700331 }
332}
333
Jaewoong Jung6431ca72020-01-15 14:15:10 -0800334var extractAssetsRule = pctx.AndroidStaticRule("extractAssets",
335 blueprint.RuleParams{
336 Command: `${config.Zip2ZipCmd} -i ${in} -o ${out} "assets/**/*"`,
337 CommandDeps: []string{"${config.Zip2ZipCmd}"},
338 })
339
Alixf7a10272023-09-27 16:47:56 +0000340type aaptBuildActionOptions struct {
341 sdkContext android.SdkContext
342 classLoaderContexts dexpreopt.ClassLoaderContextMap
343 excludedLibs []string
344 enforceDefaultTargetSdkVersion bool
345 extraLinkFlags []string
346}
347
348func (a *aapt) buildActions(ctx android.ModuleContext, opts aaptBuildActionOptions) {
Colin Cross5446e882019-05-22 10:46:27 -0700349
Colin Cross8676c8c2023-10-12 15:58:57 -0700350 staticResourcesNodesDepSet, sharedResourcesNodesDepSet, staticRRODirsDepSet, staticManifestsDepSet, sharedExportPackages, libFlags :=
Alixf7a10272023-09-27 16:47:56 +0000351 aaptLibs(ctx, opts.sdkContext, opts.classLoaderContexts)
Ulya Trafimovich31e444e2020-08-14 17:32:16 +0100352
Paul Duffin06530572022-02-03 17:54:15 +0000353 // Exclude any libraries from the supplied list.
Alixf7a10272023-09-27 16:47:56 +0000354 opts.classLoaderContexts = opts.classLoaderContexts.ExcludeLibs(opts.excludedLibs)
Paul Duffin06530572022-02-03 17:54:15 +0000355
Colin Cross31656952018-05-24 16:11:20 -0700356 // App manifest file
357 manifestFile := proptools.StringDefault(a.aaptProperties.Manifest, "AndroidManifest.xml")
358 manifestSrcPath := android.PathForModuleSrc(ctx, manifestFile)
359
Gurpreet Singh7deabfa2022-02-10 13:28:35 +0000360 manifestPath := ManifestFixer(ctx, manifestSrcPath, ManifestFixerParams{
Alixf7a10272023-09-27 16:47:56 +0000361 SdkContext: opts.sdkContext,
362 ClassLoaderContexts: opts.classLoaderContexts,
Harshit Mahajan5b8b7302022-06-10 11:24:05 +0000363 IsLibrary: a.isLibrary,
364 DefaultManifestVersion: a.defaultManifestVersion,
365 UseEmbeddedNativeLibs: a.useEmbeddedNativeLibs,
366 UsesNonSdkApis: a.usesNonSdkApis,
367 UseEmbeddedDex: a.useEmbeddedDex,
368 HasNoCode: a.hasNoCode,
369 LoggingParent: a.LoggingParent,
Alixf7a10272023-09-27 16:47:56 +0000370 EnforceDefaultTargetSdkVersion: opts.enforceDefaultTargetSdkVersion,
Gurpreet Singh75d65f32022-01-24 17:44:05 +0000371 })
Colin Cross90c25c62019-04-19 16:22:57 -0700372
Colin Crossab8d1382023-07-14 17:23:41 +0000373 staticDeps := transitiveAarDeps(staticResourcesNodesDepSet.ToList())
Colin Cross8676c8c2023-10-12 15:58:57 -0700374 sharedDeps := transitiveAarDeps(sharedResourcesNodesDepSet.ToList())
Colin Crossab8d1382023-07-14 17:23:41 +0000375
Luca Stefanifd898822019-09-10 22:13:31 +0200376 // Add additional manifest files to transitive manifests.
377 additionalManifests := android.PathsForModuleSrc(ctx, a.aaptProperties.Additional_manifests)
Colin Crossab8d1382023-07-14 17:23:41 +0000378 transitiveManifestPaths := append(android.Paths{manifestPath}, additionalManifests...)
379 // TODO(b/288358614): Soong has historically not merged manifests from dependencies of android_library_import
380 // modules. Merging manifests from dependencies could remove the need for pom2bp to generate the "-nodeps" copies
381 // of androidx libraries, but doing so triggers errors due to errors introduced by existing dependencies of
382 // android_library_import modules. If this is fixed, staticManifestsDepSet can be dropped completely in favor of
383 // staticResourcesNodesDepSet.manifests()
384 transitiveManifestPaths = append(transitiveManifestPaths, staticManifestsDepSet.ToList()...)
Colin Cross90c25c62019-04-19 16:22:57 -0700385
Colin Crossab8d1382023-07-14 17:23:41 +0000386 if len(transitiveManifestPaths) > 1 && !Bool(a.aaptProperties.Dont_merge_manifests) {
Alixf7a10272023-09-27 16:47:56 +0000387 manifestMergerParams := ManifestMergerParams{
388 staticLibManifests: transitiveManifestPaths[1:],
Alix96ea88452023-08-31 15:48:23 +0000389 isLibrary: a.isLibrary,
390 packageName: a.manifestValues.applicationId,
391 }
Alixf7a10272023-09-27 16:47:56 +0000392 a.mergedManifestFile = manifestMerger(ctx, transitiveManifestPaths[0], manifestMergerParams)
Colin Cross90c25c62019-04-19 16:22:57 -0700393 if !a.isLibrary {
394 // Only use the merged manifest for applications. For libraries, the transitive closure of manifests
395 // will be propagated to the final application and merged there. The merged manifest for libraries is
396 // only passed to Make, which can't handle transitive dependencies.
397 manifestPath = a.mergedManifestFile
398 }
399 } else {
400 a.mergedManifestFile = manifestPath
401 }
Colin Cross31656952018-05-24 16:11:20 -0700402
Alixf7a10272023-09-27 16:47:56 +0000403 compileFlags, linkFlags, linkDeps, resDirs, overlayDirs, rroDirs, resZips := a.aapt2Flags(ctx, opts.sdkContext, manifestPath)
Colin Cross31656952018-05-24 16:11:20 -0700404
405 linkFlags = append(linkFlags, libFlags...)
Colin Cross8676c8c2023-10-12 15:58:57 -0700406 linkDeps = append(linkDeps, sharedExportPackages...)
Colin Crossab8d1382023-07-14 17:23:41 +0000407 linkDeps = append(linkDeps, staticDeps.resPackages()...)
Alixf7a10272023-09-27 16:47:56 +0000408 linkFlags = append(linkFlags, opts.extraLinkFlags...)
Colin Cross1b6a3cf2018-07-24 14:51:30 -0700409 if a.isLibrary {
410 linkFlags = append(linkFlags, "--static-lib")
411 }
Colin Crossa97c5d32018-03-28 14:58:31 -0700412
Colin Cross039d8df2023-06-20 22:40:02 -0700413 if a.isLibrary && a.useResourceProcessorBusyBox() {
414 // When building an android_library using ResourceProcessorBusyBox the resources are merged into
415 // package-res.apk with --merge-only, but --no-static-lib-packages is not used so that R.txt only
416 // contains resources from this library.
417 linkFlags = append(linkFlags, "--merge-only")
418 } else {
419 // When building and app or when building an android_library without ResourceProcessorBusyBox
420 // --no-static-lib-packages is used to put all the resources into the app. If ResourceProcessorBusyBox
421 // is used then the app's R.txt will be post-processed along with the R.txt files from dependencies to
422 // sort resources into the right packages in R.class.
423 linkFlags = append(linkFlags, "--no-static-lib-packages")
424 }
425
Colin Crossa97c5d32018-03-28 14:58:31 -0700426 packageRes := android.PathForModuleOut(ctx, "package-res.apk")
Colin Crossa97c5d32018-03-28 14:58:31 -0700427 proguardOptionsFile := android.PathForModuleGen(ctx, "proguard.options")
428 rTxt := android.PathForModuleOut(ctx, "R.txt")
Colin Cross66f78822018-05-02 12:58:28 -0700429 // This file isn't used by Soong, but is generated for exporting
430 extraPackages := android.PathForModuleOut(ctx, "extra_packages")
Colin Cross039d8df2023-06-20 22:40:02 -0700431 var transitiveRJars android.Paths
Colin Crossf3b7bad2023-08-02 15:49:00 -0700432 var srcJar android.WritablePath
Colin Crossa97c5d32018-03-28 14:58:31 -0700433
Colin Cross4aaa84a2018-08-21 15:14:37 -0700434 var compiledResDirs []android.Paths
Colin Crossa97c5d32018-03-28 14:58:31 -0700435 for _, dir := range resDirs {
Colin Cross014489c2020-06-02 20:09:13 -0700436 a.resourceFiles = append(a.resourceFiles, dir.files...)
Colin Crossa0ba2f52019-06-22 12:59:27 -0700437 compiledResDirs = append(compiledResDirs, aapt2Compile(ctx, dir.dir, dir.files, compileFlags).Paths())
Colin Crossa97c5d32018-03-28 14:58:31 -0700438 }
Colin Cross4aaa84a2018-08-21 15:14:37 -0700439
Colin Crossa592e3e2019-02-19 16:59:53 -0800440 for i, zip := range resZips {
441 flata := android.PathForModuleOut(ctx, fmt.Sprintf("reszip.%d.flata", i))
Colin Crossa0ba2f52019-06-22 12:59:27 -0700442 aapt2CompileZip(ctx, flata, zip, "", compileFlags)
Colin Crossa592e3e2019-02-19 16:59:53 -0800443 compiledResDirs = append(compiledResDirs, android.Paths{flata})
444 }
445
Colin Cross4aaa84a2018-08-21 15:14:37 -0700446 var compiledRes, compiledOverlay android.Paths
447
Colin Crossab8d1382023-07-14 17:23:41 +0000448 // AAPT2 overlays are in lowest to highest priority order, reverse the topological order
449 // of transitiveStaticLibs.
450 transitiveStaticLibs := android.ReversePaths(staticDeps.resPackages())
451
Colin Cross039d8df2023-06-20 22:40:02 -0700452 if a.isLibrary && a.useResourceProcessorBusyBox() {
453 // When building an android_library with ResourceProcessorBusyBox enabled treat static library dependencies
454 // as imports. The resources from dependencies will not be merged into this module's package-res.apk, and
455 // instead modules depending on this module will reference package-res.apk from all transitive static
456 // dependencies.
457 for _, staticDep := range staticDeps {
458 linkDeps = append(linkDeps, staticDep.resPackage)
459 linkFlags = append(linkFlags, "-I "+staticDep.resPackage.String())
460 if staticDep.usedResourceProcessor {
461 transitiveRJars = append(transitiveRJars, staticDep.rJar)
462 }
463 }
Colin Cross8676c8c2023-10-12 15:58:57 -0700464 for _, sharedDep := range sharedDeps {
465 if sharedDep.usedResourceProcessor {
466 transitiveRJars = append(transitiveRJars, sharedDep.rJar)
467 }
468 }
Colin Cross039d8df2023-06-20 22:40:02 -0700469 } else {
470 // When building an app or building a library without ResourceProcessorBusyBox enabled all static
471 // dependencies are compiled into this module's package-res.apk as overlays.
472 compiledOverlay = append(compiledOverlay, transitiveStaticLibs...)
473 }
Colin Cross4aaa84a2018-08-21 15:14:37 -0700474
Colin Crossbec85302019-02-13 13:15:46 -0800475 if len(transitiveStaticLibs) > 0 {
Colin Cross4aaa84a2018-08-21 15:14:37 -0700476 // If we are using static android libraries, every source file becomes an overlay.
477 // This is to emulate old AAPT behavior which simulated library support.
478 for _, compiledResDir := range compiledResDirs {
479 compiledOverlay = append(compiledOverlay, compiledResDir...)
480 }
Colin Crossbec85302019-02-13 13:15:46 -0800481 } else if a.isLibrary {
482 // Otherwise, for a static library we treat all the resources equally with no overlay.
483 for _, compiledResDir := range compiledResDirs {
484 compiledRes = append(compiledRes, compiledResDir...)
485 }
Colin Cross4aaa84a2018-08-21 15:14:37 -0700486 } else if len(compiledResDirs) > 0 {
487 // Without static libraries, the first directory is our directory, which can then be
488 // overlaid by the rest.
489 compiledRes = append(compiledRes, compiledResDirs[0]...)
490 for _, compiledResDir := range compiledResDirs[1:] {
491 compiledOverlay = append(compiledOverlay, compiledResDir...)
492 }
493 }
494
Colin Crossa97c5d32018-03-28 14:58:31 -0700495 for _, dir := range overlayDirs {
Colin Crossa0ba2f52019-06-22 12:59:27 -0700496 compiledOverlay = append(compiledOverlay, aapt2Compile(ctx, dir.dir, dir.files, compileFlags).Paths()...)
Colin Crossa97c5d32018-03-28 14:58:31 -0700497 }
498
Colin Crosse560c4a2019-03-19 16:03:11 -0700499 var splitPackages android.WritablePaths
500 var splits []split
501
502 for _, s := range a.splitNames {
503 suffix := strings.Replace(s, ",", "_", -1)
504 path := android.PathForModuleOut(ctx, "package_"+suffix+".apk")
505 linkFlags = append(linkFlags, "--split", path.String()+":"+s)
506 splitPackages = append(splitPackages, path)
507 splits = append(splits, split{
508 name: s,
509 suffix: suffix,
510 path: path,
511 })
512 }
513
Colin Crossf3b7bad2023-08-02 15:49:00 -0700514 if !a.useResourceProcessorBusyBox() {
515 // the subdir "android" is required to be filtered by package names
516 srcJar = android.PathForModuleGen(ctx, "android", "R.srcjar")
517 }
518
Colin Crossab8d1382023-07-14 17:23:41 +0000519 // No need to specify assets from dependencies to aapt2Link for libraries, all transitive assets will be
520 // provided to the final app aapt2Link step.
521 var transitiveAssets android.Paths
522 if !a.isLibrary {
523 transitiveAssets = android.ReverseSliceInPlace(staticDeps.assets())
524 }
Colin Crossf3b7bad2023-08-02 15:49:00 -0700525 aapt2Link(ctx, packageRes, srcJar, proguardOptionsFile, rTxt,
Colin Crossab8d1382023-07-14 17:23:41 +0000526 linkFlags, linkDeps, compiledRes, compiledOverlay, transitiveAssets, splitPackages)
Jaewoong Jung6431ca72020-01-15 14:15:10 -0800527 // Extract assets from the resource package output so that they can be used later in aapt2link
528 // for modules that depend on this one.
Colin Crossab8d1382023-07-14 17:23:41 +0000529 if android.PrefixInList(linkFlags, "-A ") {
Jaewoong Jung6431ca72020-01-15 14:15:10 -0800530 assets := android.PathForModuleOut(ctx, "assets.zip")
531 ctx.Build(pctx, android.BuildParams{
532 Rule: extractAssetsRule,
533 Input: packageRes,
534 Output: assets,
535 Description: "extract assets from built resource file",
536 })
537 a.assetPackage = android.OptionalPathForPath(assets)
538 }
Colin Crossa97c5d32018-03-28 14:58:31 -0700539
Colin Cross039d8df2023-06-20 22:40:02 -0700540 if a.useResourceProcessorBusyBox() {
541 rJar := android.PathForModuleOut(ctx, "busybox/R.jar")
542 resourceProcessorBusyBoxGenerateBinaryR(ctx, rTxt, a.mergedManifestFile, rJar, staticDeps, a.isLibrary)
Colin Crossf3b7bad2023-08-02 15:49:00 -0700543 aapt2ExtractExtraPackages(ctx, extraPackages, rJar)
Colin Cross039d8df2023-06-20 22:40:02 -0700544 transitiveRJars = append(transitiveRJars, rJar)
545 a.rJar = rJar
Colin Crossf3b7bad2023-08-02 15:49:00 -0700546 } else {
547 aapt2ExtractExtraPackages(ctx, extraPackages, srcJar)
Colin Cross039d8df2023-06-20 22:40:02 -0700548 }
549
Colin Crossa97c5d32018-03-28 14:58:31 -0700550 a.aaptSrcJar = srcJar
Colin Cross039d8df2023-06-20 22:40:02 -0700551 a.transitiveAaptRJars = transitiveRJars
552 a.transitiveAaptResourcePackages = staticDeps.resPackages()
Colin Crossa97c5d32018-03-28 14:58:31 -0700553 a.exportPackage = packageRes
554 a.manifestPath = manifestPath
555 a.proguardOptionsFile = proguardOptionsFile
Colin Cross66f78822018-05-02 12:58:28 -0700556 a.extraAaptPackagesFile = extraPackages
Colin Crossa97c5d32018-03-28 14:58:31 -0700557 a.rTxt = rTxt
Colin Crosse560c4a2019-03-19 16:03:11 -0700558 a.splits = splits
Colin Crossab8d1382023-07-14 17:23:41 +0000559 a.resourcesNodesDepSet = android.NewDepSetBuilder[*resourcesNode](android.TOPOLOGICAL).
560 Direct(&resourcesNode{
561 resPackage: a.exportPackage,
562 manifest: a.manifestPath,
563 additionalManifests: additionalManifests,
Colin Cross039d8df2023-06-20 22:40:02 -0700564 rTxt: a.rTxt,
565 rJar: a.rJar,
Colin Crossab8d1382023-07-14 17:23:41 +0000566 assets: a.assetPackage,
Colin Cross039d8df2023-06-20 22:40:02 -0700567
568 usedResourceProcessor: a.useResourceProcessorBusyBox(),
Colin Crossab8d1382023-07-14 17:23:41 +0000569 }).
570 Transitive(staticResourcesNodesDepSet).Build()
571 a.rroDirsDepSet = android.NewDepSetBuilder[rroDir](android.TOPOLOGICAL).
572 Direct(rroDirs...).
573 Transitive(staticRRODirsDepSet).Build()
574 a.manifestsDepSet = android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL).
575 Direct(a.manifestPath).
576 DirectSlice(additionalManifests).
577 Transitive(staticManifestsDepSet).Build()
578}
579
Colin Cross039d8df2023-06-20 22:40:02 -0700580var resourceProcessorBusyBox = pctx.AndroidStaticRule("resourceProcessorBusyBox",
581 blueprint.RuleParams{
582 Command: "${config.JavaCmd} -cp ${config.ResourceProcessorBusyBox} " +
583 "com.google.devtools.build.android.ResourceProcessorBusyBox --tool=GENERATE_BINARY_R -- @${out}.args && " +
584 "if cmp -s ${out}.tmp ${out} ; then rm ${out}.tmp ; else mv ${out}.tmp ${out}; fi",
585 CommandDeps: []string{"${config.ResourceProcessorBusyBox}"},
586 Rspfile: "${out}.args",
587 RspfileContent: "--primaryRTxt ${rTxt} --primaryManifest ${manifest} --classJarOutput ${out}.tmp ${args}",
588 Restat: true,
589 }, "rTxt", "manifest", "args")
590
591// resourceProcessorBusyBoxGenerateBinaryR converts the R.txt file produced by aapt2 into R.class files
592// using Bazel's ResourceProcessorBusyBox tool, which is faster than compiling the R.java files and
593// supports producing classes for static dependencies that only include resources from that dependency.
594func resourceProcessorBusyBoxGenerateBinaryR(ctx android.ModuleContext, rTxt, manifest android.Path,
595 rJar android.WritablePath, transitiveDeps transitiveAarDeps, isLibrary bool) {
596
597 var args []string
598 var deps android.Paths
599
600 if !isLibrary {
601 // When compiling an app, pass all R.txt and AndroidManifest.xml from transitive static library dependencies
602 // to ResourceProcessorBusyBox so that it can regenerate R.class files with the final resource IDs for each
603 // package.
604 args, deps = transitiveDeps.resourceProcessorDeps()
605 } else {
606 // When compiling a library don't pass any dependencies as it only needs to generate an R.class file for this
607 // library. Pass --finalFields=false so that the R.class file contains non-final fields so they don't get
608 // inlined into the library before the final IDs are assigned during app compilation.
609 args = append(args, "--finalFields=false")
610 }
611
612 deps = append(deps, rTxt, manifest)
613
614 ctx.Build(pctx, android.BuildParams{
615 Rule: resourceProcessorBusyBox,
616 Output: rJar,
617 Implicits: deps,
618 Description: "ResourceProcessorBusyBox",
619 Args: map[string]string{
620 "rTxt": rTxt.String(),
621 "manifest": manifest.String(),
622 "args": strings.Join(args, " "),
623 },
624 })
625}
626
Colin Crossab8d1382023-07-14 17:23:41 +0000627type resourcesNode struct {
628 resPackage android.Path
629 manifest android.Path
630 additionalManifests android.Paths
Colin Cross039d8df2023-06-20 22:40:02 -0700631 rTxt android.Path
632 rJar android.Path
Colin Crossab8d1382023-07-14 17:23:41 +0000633 assets android.OptionalPath
Colin Cross039d8df2023-06-20 22:40:02 -0700634
635 usedResourceProcessor bool
Colin Crossab8d1382023-07-14 17:23:41 +0000636}
637
638type transitiveAarDeps []*resourcesNode
639
640func (t transitiveAarDeps) resPackages() android.Paths {
Colin Cross039d8df2023-06-20 22:40:02 -0700641 paths := make(android.Paths, 0, len(t))
Colin Crossab8d1382023-07-14 17:23:41 +0000642 for _, dep := range t {
643 paths = append(paths, dep.resPackage)
644 }
Colin Cross039d8df2023-06-20 22:40:02 -0700645 return paths
Colin Crossab8d1382023-07-14 17:23:41 +0000646}
647
648func (t transitiveAarDeps) manifests() android.Paths {
Colin Cross039d8df2023-06-20 22:40:02 -0700649 paths := make(android.Paths, 0, len(t))
Colin Crossab8d1382023-07-14 17:23:41 +0000650 for _, dep := range t {
651 paths = append(paths, dep.manifest)
652 paths = append(paths, dep.additionalManifests...)
653 }
Colin Cross039d8df2023-06-20 22:40:02 -0700654 return paths
655}
656
657func (t transitiveAarDeps) resourceProcessorDeps() (args []string, deps android.Paths) {
658 for _, dep := range t {
659 args = append(args, "--library="+dep.rTxt.String()+","+dep.manifest.String())
660 deps = append(deps, dep.rTxt, dep.manifest)
661 }
662 return args, deps
Colin Crossab8d1382023-07-14 17:23:41 +0000663}
664
665func (t transitiveAarDeps) assets() android.Paths {
Colin Cross039d8df2023-06-20 22:40:02 -0700666 paths := make(android.Paths, 0, len(t))
Colin Crossab8d1382023-07-14 17:23:41 +0000667 for _, dep := range t {
668 if dep.assets.Valid() {
669 paths = append(paths, dep.assets.Path())
670 }
671 }
672 return paths
Colin Crossa97c5d32018-03-28 14:58:31 -0700673}
674
675// aaptLibs collects libraries from dependencies and sdk_version and converts them into paths
Jiyong Parkf1691d22021-03-29 20:11:58 +0900676func aaptLibs(ctx android.ModuleContext, sdkContext android.SdkContext, classLoaderContexts dexpreopt.ClassLoaderContextMap) (
Colin Cross8676c8c2023-10-12 15:58:57 -0700677 staticResourcesNodes, sharedResourcesNodes *android.DepSet[*resourcesNode], staticRRODirs *android.DepSet[rroDir],
Colin Crossab8d1382023-07-14 17:23:41 +0000678 staticManifests *android.DepSet[android.Path], sharedLibs android.Paths, flags []string) {
Colin Crossa97c5d32018-03-28 14:58:31 -0700679
Ulya Trafimovichb23d28c2020-10-08 12:53:58 +0100680 if classLoaderContexts == nil {
Ulya Trafimovich18554242020-11-03 15:55:11 +0000681 // Not all callers need to compute class loader context, those who don't just pass nil.
682 // Create a temporary class loader context here (it will be computed, but not used).
Ulya Trafimovichb23d28c2020-10-08 12:53:58 +0100683 classLoaderContexts = make(dexpreopt.ClassLoaderContextMap)
Ulya Trafimovich18554242020-11-03 15:55:11 +0000684 }
685
Colin Cross83bb3162018-06-25 15:48:06 -0700686 sdkDep := decodeSdkDep(ctx, sdkContext)
Colin Crossa97c5d32018-03-28 14:58:31 -0700687 if sdkDep.useFiles {
Colin Cross86a60ae2018-05-29 14:44:55 -0700688 sharedLibs = append(sharedLibs, sdkDep.jars...)
Colin Crossa97c5d32018-03-28 14:58:31 -0700689 }
690
Colin Cross8676c8c2023-10-12 15:58:57 -0700691 var staticResourcesNodeDepSets []*android.DepSet[*resourcesNode]
692 var sharedResourcesNodeDepSets []*android.DepSet[*resourcesNode]
Colin Crossab8d1382023-07-14 17:23:41 +0000693 rroDirsDepSetBuilder := android.NewDepSetBuilder[rroDir](android.TOPOLOGICAL)
694 manifestsDepSetBuilder := android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL)
695
Colin Crossa97c5d32018-03-28 14:58:31 -0700696 ctx.VisitDirectDeps(func(module android.Module) {
Ulya Trafimovich65b03192020-12-03 16:50:22 +0000697 depTag := ctx.OtherModuleDependencyTag(module)
Ulya Trafimovich18554242020-11-03 15:55:11 +0000698
Colin Crossa97c5d32018-03-28 14:58:31 -0700699 var exportPackage android.Path
Colin Cross66f78822018-05-02 12:58:28 -0700700 aarDep, _ := module.(AndroidLibraryDependency)
701 if aarDep != nil {
Colin Crossa97c5d32018-03-28 14:58:31 -0700702 exportPackage = aarDep.ExportPackage()
703 }
704
Ulya Trafimovich65b03192020-12-03 16:50:22 +0000705 switch depTag {
Colin Cross4b964c02018-10-15 16:18:06 -0700706 case instrumentationForTag:
707 // Nothing, instrumentationForTag is treated as libTag for javac but not for aapt2.
Liz Kammeref28a4c2022-09-23 16:50:56 -0400708 case sdkLibTag, libTag:
Colin Cross5446e882019-05-22 10:46:27 -0700709 if exportPackage != nil {
Colin Cross8676c8c2023-10-12 15:58:57 -0700710 sharedResourcesNodeDepSets = append(sharedResourcesNodeDepSets, aarDep.ResourcesNodeDepSet())
Colin Cross5446e882019-05-22 10:46:27 -0700711 sharedLibs = append(sharedLibs, exportPackage)
712 }
Colin Cross5446e882019-05-22 10:46:27 -0700713 case frameworkResTag:
Colin Crossa97c5d32018-03-28 14:58:31 -0700714 if exportPackage != nil {
715 sharedLibs = append(sharedLibs, exportPackage)
716 }
717 case staticLibTag:
718 if exportPackage != nil {
Colin Cross8676c8c2023-10-12 15:58:57 -0700719 staticResourcesNodeDepSets = append(staticResourcesNodeDepSets, aarDep.ResourcesNodeDepSet())
Colin Crossab8d1382023-07-14 17:23:41 +0000720 rroDirsDepSetBuilder.Transitive(aarDep.RRODirsDepSet())
721 manifestsDepSetBuilder.Transitive(aarDep.ManifestsDepSet())
Colin Crossa97c5d32018-03-28 14:58:31 -0700722 }
723 }
Ulya Trafimovich18554242020-11-03 15:55:11 +0000724
Ulya Trafimovich88bb6f62020-12-16 16:16:11 +0000725 addCLCFromDep(ctx, module, classLoaderContexts)
Colin Crossa97c5d32018-03-28 14:58:31 -0700726 })
727
Colin Crossab8d1382023-07-14 17:23:41 +0000728 // AAPT2 overlays are in lowest to highest priority order, the topological order will be reversed later.
729 // Reverse the dependency order now going into the depset so that it comes out in order after the second
730 // reverse later.
731 // NOTE: this is legacy and probably incorrect behavior, for most other cases (e.g. conflicting classes in
732 // dependencies) the highest priority dependency is listed first, but for resources the highest priority
733 // dependency has to be listed last.
734 staticResourcesNodes = android.NewDepSet(android.TOPOLOGICAL, nil,
Colin Cross8676c8c2023-10-12 15:58:57 -0700735 android.ReverseSliceInPlace(staticResourcesNodeDepSets))
736 sharedResourcesNodes = android.NewDepSet(android.TOPOLOGICAL, nil,
737 android.ReverseSliceInPlace(sharedResourcesNodeDepSets))
Colin Crossa97c5d32018-03-28 14:58:31 -0700738
Colin Crossab8d1382023-07-14 17:23:41 +0000739 staticRRODirs = rroDirsDepSetBuilder.Build()
740 staticManifests = manifestsDepSetBuilder.Build()
741
742 if len(staticResourcesNodes.ToList()) > 0 {
Colin Crossa97c5d32018-03-28 14:58:31 -0700743 flags = append(flags, "--auto-add-overlay")
744 }
745
746 for _, sharedLib := range sharedLibs {
747 flags = append(flags, "-I "+sharedLib.String())
748 }
749
Colin Cross8676c8c2023-10-12 15:58:57 -0700750 return staticResourcesNodes, sharedResourcesNodes, staticRRODirs, staticManifests, sharedLibs, flags
Colin Crossa97c5d32018-03-28 14:58:31 -0700751}
752
753type AndroidLibrary struct {
754 Library
755 aapt
Romain Jobredeauxc9b2bba2022-02-15 09:35:07 -0500756 android.BazelModuleBase
Colin Crossa97c5d32018-03-28 14:58:31 -0700757
758 androidLibraryProperties androidLibraryProperties
759
760 aarFile android.WritablePath
Colin Cross89c31582018-04-30 15:55:11 -0700761}
762
Saeid Farivar Asanjan1fca3012021-09-14 18:40:19 +0000763var _ android.OutputFileProducer = (*AndroidLibrary)(nil)
764
765// For OutputFileProducer interface
766func (a *AndroidLibrary) OutputFiles(tag string) (android.Paths, error) {
767 switch tag {
768 case ".aar":
769 return []android.Path{a.aarFile}, nil
770 default:
771 return a.Library.OutputFiles(tag)
772 }
773}
774
Colin Crossa97c5d32018-03-28 14:58:31 -0700775var _ AndroidLibraryDependency = (*AndroidLibrary)(nil)
776
777func (a *AndroidLibrary) DepsMutator(ctx android.BottomUpMutatorContext) {
778 a.Module.deps(ctx)
Jiyong Parkf1691d22021-03-29 20:11:58 +0900779 sdkDep := decodeSdkDep(ctx, android.SdkContext(a))
Paul Duffin250e6192019-06-07 10:44:37 +0100780 if sdkDep.hasFrameworkLibs() {
781 a.aapt.deps(ctx, sdkDep)
Colin Crossa97c5d32018-03-28 14:58:31 -0700782 }
Colin Cross4a80a152022-12-21 21:51:52 -0800783 a.usesLibrary.deps(ctx, false)
Colin Crossa97c5d32018-03-28 14:58:31 -0700784}
785
786func (a *AndroidLibrary) GenerateAndroidBuildActions(ctx android.ModuleContext) {
Colin Crosse4246ab2019-02-05 21:55:21 -0800787 a.aapt.isLibrary = true
Ulya Trafimovich42c7f0d2021-08-17 16:20:29 +0100788 a.classLoaderContexts = a.usesLibrary.classLoaderContextForUsesLibDeps(ctx)
Alixf7a10272023-09-27 16:47:56 +0000789 a.aapt.buildActions(ctx,
790 aaptBuildActionOptions{
791 sdkContext: android.SdkContext(a),
792 classLoaderContexts: a.classLoaderContexts,
793 enforceDefaultTargetSdkVersion: false,
794 },
795 )
Colin Crossa97c5d32018-03-28 14:58:31 -0700796
Colin Cross56a83212020-09-15 18:30:11 -0700797 a.hideApexVariantFromMake = !ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).IsForPlatform()
798
Jihoon Kang1bfb6f22023-07-01 00:13:47 +0000799 a.stem = proptools.StringDefault(a.overridableDeviceProperties.Stem, ctx.ModuleName())
800
Colin Cross039d8df2023-06-20 22:40:02 -0700801 ctx.CheckbuildFile(a.aapt.proguardOptionsFile)
802 ctx.CheckbuildFile(a.aapt.exportPackage)
Colin Cross039d8df2023-06-20 22:40:02 -0700803 if a.useResourceProcessorBusyBox() {
804 ctx.CheckbuildFile(a.aapt.rJar)
Colin Crossf3b7bad2023-08-02 15:49:00 -0700805 } else {
806 ctx.CheckbuildFile(a.aapt.aaptSrcJar)
Colin Cross039d8df2023-06-20 22:40:02 -0700807 }
Colin Crossa97c5d32018-03-28 14:58:31 -0700808
809 // apps manifests are handled by aapt, don't let Module see them
810 a.properties.Manifest = nil
811
Colin Cross014489c2020-06-02 20:09:13 -0700812 a.linter.mergedManifest = a.aapt.mergedManifestFile
813 a.linter.manifest = a.aapt.manifestPath
814 a.linter.resources = a.aapt.resourceFiles
815
Sam Delmericoc8e040c2023-10-31 17:27:02 +0000816 proguardSpecInfo := a.collectProguardSpecInfo(ctx)
817 ctx.SetProvider(ProguardSpecInfoProvider, proguardSpecInfo)
818 a.exportedProguardFlagFiles = proguardSpecInfo.ProguardFlagsFiles.ToList()
819 a.extraProguardFlagFiles = append(a.extraProguardFlagFiles, a.exportedProguardFlagFiles...)
820 a.extraProguardFlagFiles = append(a.extraProguardFlagFiles, a.proguardOptionsFile)
Colin Crossa97c5d32018-03-28 14:58:31 -0700821
Colin Cross039d8df2023-06-20 22:40:02 -0700822 var extraSrcJars android.Paths
823 var extraCombinedJars android.Paths
824 var extraClasspathJars android.Paths
825 if a.useResourceProcessorBusyBox() {
826 // When building a library with ResourceProcessorBusyBox enabled ResourceProcessorBusyBox for this
827 // library and each of the transitive static android_library dependencies has already created an
828 // R.class file for the appropriate package. Add all of those R.class files to the classpath.
829 extraClasspathJars = a.transitiveAaptRJars
830 } else {
831 // When building a library without ResourceProcessorBusyBox the aapt2 rule creates R.srcjar containing
832 // R.java files for the library's package and the packages from all transitive static android_library
833 // dependencies. Compile the srcjar alongside the rest of the sources.
834 extraSrcJars = android.Paths{a.aapt.aaptSrcJar}
835 }
836
837 a.Module.compile(ctx, extraSrcJars, extraClasspathJars, extraCombinedJars)
Colin Crossa97c5d32018-03-28 14:58:31 -0700838
Colin Crossf57c5782019-01-25 13:20:38 -0800839 a.aarFile = android.PathForModuleOut(ctx, ctx.ModuleName()+".aar")
Colin Crossa97c5d32018-03-28 14:58:31 -0700840 var res android.Paths
841 if a.androidLibraryProperties.BuildAAR {
842 BuildAAR(ctx, a.aarFile, a.outputFile, a.manifestPath, a.rTxt, res)
843 ctx.CheckbuildFile(a.aarFile)
844 }
Colin Cross89c31582018-04-30 15:55:11 -0700845
Sam Delmerico82602492022-06-10 17:05:42 +0000846 prebuiltJniPackages := android.Paths{}
847 ctx.VisitDirectDeps(func(module android.Module) {
848 if info, ok := ctx.OtherModuleProvider(module, JniPackageProvider).(JniPackageInfo); ok {
849 prebuiltJniPackages = append(prebuiltJniPackages, info.JniPackages...)
850 }
851 })
852 if len(prebuiltJniPackages) > 0 {
853 ctx.SetProvider(JniPackageProvider, JniPackageInfo{
854 JniPackages: prebuiltJniPackages,
855 })
856 }
Colin Crossa97c5d32018-03-28 14:58:31 -0700857}
858
Colin Cross95b53b82023-10-17 13:21:02 -0700859func (a *AndroidLibrary) IDEInfo(dpInfo *android.IdeInfo) {
860 a.Library.IDEInfo(dpInfo)
861 a.aapt.IDEInfo(dpInfo)
862}
863
864func (a *aapt) IDEInfo(dpInfo *android.IdeInfo) {
865 if a.useResourceProcessorBusyBox() {
866 dpInfo.Jars = append(dpInfo.Jars, a.rJar.String())
867 }
868}
869
Colin Cross1b16b0e2019-02-12 14:41:32 -0800870// android_library builds and links sources into a `.jar` file for the device along with Android resources.
871//
872// An android_library has a single variant that produces a `.jar` file containing `.class` files that were
Sam Delmerico82602492022-06-10 17:05:42 +0000873// compiled against the device bootclasspath, along with a `package-res.apk` file containing Android resources compiled
Colin Cross1b16b0e2019-02-12 14:41:32 -0800874// with aapt2. This module is not suitable for installing on a device, but can be used as a `static_libs` dependency of
875// an android_app module.
Colin Crossa97c5d32018-03-28 14:58:31 -0700876func AndroidLibraryFactory() android.Module {
877 module := &AndroidLibrary{}
878
Colin Crossce6734e2020-06-15 16:09:53 -0700879 module.Module.addHostAndDeviceProperties()
Colin Crossa97c5d32018-03-28 14:58:31 -0700880 module.AddProperties(
Colin Crossa97c5d32018-03-28 14:58:31 -0700881 &module.aaptProperties,
882 &module.androidLibraryProperties)
883
884 module.androidLibraryProperties.BuildAAR = true
Colin Cross014489c2020-06-02 20:09:13 -0700885 module.Module.linter.library = true
Colin Crossa97c5d32018-03-28 14:58:31 -0700886
Jooyung Hanacc7bbe2020-05-20 09:06:00 +0900887 android.InitApexModule(module)
Colin Cross48de9a42018-10-02 13:53:33 -0700888 InitJavaModule(module, android.DeviceSupported)
Romain Jobredeauxc9b2bba2022-02-15 09:35:07 -0500889 android.InitBazelModule(module)
Colin Crossa97c5d32018-03-28 14:58:31 -0700890 return module
891}
892
Colin Crossfabb6082018-02-20 17:22:23 -0800893//
894// AAR (android library) prebuilts
895//
Colin Crossfabb6082018-02-20 17:22:23 -0800896
Vinh Trance0781f2022-04-13 01:30:44 +0000897// Properties for android_library_import
Colin Crossfabb6082018-02-20 17:22:23 -0800898type AARImportProperties struct {
Vinh Trance0781f2022-04-13 01:30:44 +0000899 // ARR (android library prebuilt) filepath. Exactly one ARR is required.
Colin Cross27b922f2019-03-04 22:35:41 -0800900 Aars []string `android:"path"`
Vinh Trance0781f2022-04-13 01:30:44 +0000901 // If not blank, set to the version of the sdk to compile against.
902 // Defaults to private.
903 // Values are of one of the following forms:
904 // 1) numerical API level, "current", "none", or "core_platform"
905 // 2) An SDK kind with an API level: "<sdk kind>_<API level>"
906 // See build/soong/android/sdk_version.go for the complete and up to date list of SDK kinds.
907 // If the SDK kind is empty, it will be set to public
908 Sdk_version *string
909 // If not blank, set the minimum version of the sdk that the compiled artifacts will run against.
910 // Defaults to sdk_version if not set. See sdk_version for possible values.
Colin Cross479884c2018-07-10 13:39:30 -0700911 Min_sdk_version *string
Vinh Trance0781f2022-04-13 01:30:44 +0000912 // List of java static libraries that the included ARR (android library prebuilts) has dependencies to.
Colin Crossa97c5d32018-03-28 14:58:31 -0700913 Static_libs []string
Vinh Trance0781f2022-04-13 01:30:44 +0000914 // List of java libraries that the included ARR (android library prebuilts) has dependencies to.
915 Libs []string
916 // If set to true, run Jetifier against .aar file. Defaults to false.
Colin Cross1001a792019-03-21 22:21:39 -0700917 Jetifier *bool
Sam Delmerico82602492022-06-10 17:05:42 +0000918 // If true, extract JNI libs from AAR archive. These libs will be accessible to android_app modules and
919 // will be passed transitively through android_libraries to an android_app.
920 //TODO(b/241138093) evaluate whether we can have this flag default to true for Bazel conversion
921 Extract_jni *bool
Colin Crossfabb6082018-02-20 17:22:23 -0800922}
923
924type AARImport struct {
925 android.ModuleBase
Colin Cross48de9a42018-10-02 13:53:33 -0700926 android.DefaultableModuleBase
Jooyung Hanacc7bbe2020-05-20 09:06:00 +0900927 android.ApexModuleBase
Romain Jobredeauxc9b2bba2022-02-15 09:35:07 -0500928 android.BazelModuleBase
Colin Crossfabb6082018-02-20 17:22:23 -0800929 prebuilt android.Prebuilt
930
Jooyung Hanacc7bbe2020-05-20 09:06:00 +0900931 // Functionality common to Module and Import.
932 embeddableInModuleAndImport
933
Sam Delmerico9f9c0a22022-11-29 11:19:37 -0500934 providesTransitiveHeaderJars
935
Colin Crossfabb6082018-02-20 17:22:23 -0800936 properties AARImportProperties
937
Colin Cross039d8df2023-06-20 22:40:02 -0700938 classpathFile android.WritablePath
939 proguardFlags android.WritablePath
940 exportPackage android.WritablePath
941 transitiveAaptResourcePackages android.Paths
942 extraAaptPackagesFile android.WritablePath
943 manifest android.WritablePath
944 assetsPackage android.WritablePath
945 rTxt android.WritablePath
946 rJar android.WritablePath
Colin Cross66f78822018-05-02 12:58:28 -0700947
Colin Crossab8d1382023-07-14 17:23:41 +0000948 resourcesNodesDepSet *android.DepSet[*resourcesNode]
949 manifestsDepSet *android.DepSet[android.Path]
Colin Cross56a83212020-09-15 18:30:11 -0700950
951 hideApexVariantFromMake bool
Saeid Farivar Asanjanf0436962020-10-05 19:09:09 +0000952
Sam Delmerico82602492022-06-10 17:05:42 +0000953 aarPath android.Path
954 jniPackages android.Paths
Jiyong Park92315372021-04-02 08:45:46 +0900955
956 sdkVersion android.SdkSpec
Spandan Das8c9ae7e2023-03-03 21:20:36 +0000957 minSdkVersion android.ApiLevel
Saeid Farivar Asanjanf0436962020-10-05 19:09:09 +0000958}
959
960var _ android.OutputFileProducer = (*AARImport)(nil)
961
962// For OutputFileProducer interface
963func (a *AARImport) OutputFiles(tag string) (android.Paths, error) {
964 switch tag {
965 case ".aar":
966 return []android.Path{a.aarPath}, nil
967 case "":
968 return []android.Path{a.classpathFile}, nil
969 default:
970 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
971 }
Colin Crossfabb6082018-02-20 17:22:23 -0800972}
973
Jiyong Park92315372021-04-02 08:45:46 +0900974func (a *AARImport) SdkVersion(ctx android.EarlyModuleContext) android.SdkSpec {
975 return android.SdkSpecFrom(ctx, String(a.properties.Sdk_version))
Colin Cross83bb3162018-06-25 15:48:06 -0700976}
977
Jiyong Parkf1691d22021-03-29 20:11:58 +0900978func (a *AARImport) SystemModules() string {
Paul Duffine25c6442019-10-11 13:50:28 +0100979 return ""
980}
981
Spandan Das8c9ae7e2023-03-03 21:20:36 +0000982func (a *AARImport) MinSdkVersion(ctx android.EarlyModuleContext) android.ApiLevel {
Colin Cross479884c2018-07-10 13:39:30 -0700983 if a.properties.Min_sdk_version != nil {
Spandan Das8c9ae7e2023-03-03 21:20:36 +0000984 return android.ApiLevelFrom(ctx, *a.properties.Min_sdk_version)
Colin Cross479884c2018-07-10 13:39:30 -0700985 }
Spandan Das8c9ae7e2023-03-03 21:20:36 +0000986 return a.SdkVersion(ctx).ApiLevel
Colin Cross83bb3162018-06-25 15:48:06 -0700987}
988
Spandan Dasa26eda72023-03-02 00:56:06 +0000989func (a *AARImport) ReplaceMaxSdkVersionPlaceholder(ctx android.EarlyModuleContext) android.ApiLevel {
990 return android.SdkSpecFrom(ctx, "").ApiLevel
William Loh5a082f92022-05-17 20:21:50 +0000991}
992
Spandan Dasca70fc42023-03-01 23:38:49 +0000993func (a *AARImport) TargetSdkVersion(ctx android.EarlyModuleContext) android.ApiLevel {
994 return a.SdkVersion(ctx).ApiLevel
Dan Willemsen419290a2018-10-31 15:28:47 -0700995}
996
Colin Cross1e743852019-10-28 11:37:20 -0700997func (a *AARImport) javaVersion() string {
998 return ""
999}
1000
Colin Crossa97c5d32018-03-28 14:58:31 -07001001var _ AndroidLibraryDependency = (*AARImport)(nil)
1002
1003func (a *AARImport) ExportPackage() android.Path {
1004 return a.exportPackage
1005}
Colin Crossab8d1382023-07-14 17:23:41 +00001006func (a *AARImport) ResourcesNodeDepSet() *android.DepSet[*resourcesNode] {
1007 return a.resourcesNodesDepSet
Colin Crossc1c37552019-01-31 11:42:41 -08001008}
1009
Colin Crossab8d1382023-07-14 17:23:41 +00001010func (a *AARImport) RRODirsDepSet() *android.DepSet[rroDir] {
1011 return android.NewDepSet[rroDir](android.TOPOLOGICAL, nil, nil)
Colin Cross66f78822018-05-02 12:58:28 -07001012}
1013
Colin Crossab8d1382023-07-14 17:23:41 +00001014func (a *AARImport) ManifestsDepSet() *android.DepSet[android.Path] {
1015 return a.manifestsDepSet
Jaewoong Jung6431ca72020-01-15 14:15:10 -08001016}
1017
Jaewoong Jungc779cd42020-10-06 18:56:10 -07001018// RRO enforcement is not available on aar_import since its RRO dirs are not
1019// exported.
1020func (a *AARImport) SetRROEnforcedForDependent(enforce bool) {
1021}
1022
1023// RRO enforcement is not available on aar_import since its RRO dirs are not
1024// exported.
1025func (a *AARImport) IsRROEnforced(ctx android.BaseModuleContext) bool {
1026 return false
1027}
1028
Colin Crossfabb6082018-02-20 17:22:23 -08001029func (a *AARImport) Prebuilt() *android.Prebuilt {
1030 return &a.prebuilt
1031}
1032
1033func (a *AARImport) Name() string {
1034 return a.prebuilt.Name(a.ModuleBase.Name())
1035}
1036
Jiyong Park618922e2020-01-08 13:35:43 +09001037func (a *AARImport) JacocoReportClassesFile() android.Path {
1038 return nil
1039}
1040
Colin Crossfabb6082018-02-20 17:22:23 -08001041func (a *AARImport) DepsMutator(ctx android.BottomUpMutatorContext) {
Jeongik Cha816a23a2020-07-08 01:09:23 +09001042 if !ctx.Config().AlwaysUsePrebuiltSdks() {
Jiyong Parkf1691d22021-03-29 20:11:58 +09001043 sdkDep := decodeSdkDep(ctx, android.SdkContext(a))
Colin Crossa97c5d32018-03-28 14:58:31 -07001044 if sdkDep.useModule && sdkDep.frameworkResModule != "" {
Colin Cross42d48b72018-08-29 14:10:52 -07001045 ctx.AddVariationDependencies(nil, frameworkResTag, sdkDep.frameworkResModule)
Colin Crossfabb6082018-02-20 17:22:23 -08001046 }
1047 }
Colin Crossa97c5d32018-03-28 14:58:31 -07001048
Colin Cross42d48b72018-08-29 14:10:52 -07001049 ctx.AddVariationDependencies(nil, libTag, a.properties.Libs...)
1050 ctx.AddVariationDependencies(nil, staticLibTag, a.properties.Static_libs...)
Colin Crossfabb6082018-02-20 17:22:23 -08001051}
1052
Sam Delmerico82602492022-06-10 17:05:42 +00001053type JniPackageInfo struct {
1054 // List of zip files containing JNI libraries
1055 // Zip files should have directory structure jni/<arch>/*.so
1056 JniPackages android.Paths
1057}
1058
1059var JniPackageProvider = blueprint.NewProvider(JniPackageInfo{})
1060
1061// Unzip an AAR and extract the JNI libs for $archString.
1062var extractJNI = pctx.AndroidStaticRule("extractJNI",
1063 blueprint.RuleParams{
1064 Command: `rm -rf $out $outDir && touch $out && ` +
1065 `unzip -qoDD -d $outDir $in "jni/${archString}/*" && ` +
1066 `jni_files=$$(find $outDir/jni -type f) && ` +
1067 // print error message if there are no JNI libs for this arch
1068 `[ -n "$$jni_files" ] || (echo "ERROR: no JNI libs found for arch ${archString}" && exit 1) && ` +
Sam Delmerico80ee45c2023-06-22 15:36:02 -04001069 `${config.SoongZipCmd} -o $out -L 0 -P 'lib/${archString}' ` +
Sam Delmerico82602492022-06-10 17:05:42 +00001070 `-C $outDir/jni/${archString} $$(echo $$jni_files | xargs -n1 printf " -f %s")`,
1071 CommandDeps: []string{"${config.SoongZipCmd}"},
1072 },
1073 "outDir", "archString")
1074
Colin Crossfabb6082018-02-20 17:22:23 -08001075// 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 -07001076// 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 -08001077var unzipAAR = pctx.AndroidStaticRule("unzipAAR",
1078 blueprint.RuleParams{
Dan Willemsen304cfec2019-05-28 14:49:06 -07001079 Command: `rm -rf $outDir && mkdir -p $outDir && ` +
Colin Cross205e9112020-08-06 13:20:17 -07001080 `unzip -qoDD -d $outDir $in && rm -rf $outDir/res && touch $out && ` +
Michael Rosenfeld5ad15572021-12-03 13:25:10 -08001081 `${config.Zip2ZipCmd} -i $in -o $assetsPackage 'assets/**/*' && ` +
Colin Cross205e9112020-08-06 13:20:17 -07001082 `${config.MergeZipsCmd} $combinedClassesJar $$(ls $outDir/classes.jar 2> /dev/null) $$(ls $outDir/libs/*.jar 2> /dev/null)`,
Michael Rosenfeld5ad15572021-12-03 13:25:10 -08001083 CommandDeps: []string{"${config.MergeZipsCmd}", "${config.Zip2ZipCmd}"},
Colin Crossfabb6082018-02-20 17:22:23 -08001084 },
Michael Rosenfeld5ad15572021-12-03 13:25:10 -08001085 "outDir", "combinedClassesJar", "assetsPackage")
Colin Crossfabb6082018-02-20 17:22:23 -08001086
1087func (a *AARImport) GenerateAndroidBuildActions(ctx android.ModuleContext) {
1088 if len(a.properties.Aars) != 1 {
1089 ctx.PropertyErrorf("aars", "exactly one aar is required")
1090 return
1091 }
1092
Jiyong Park92315372021-04-02 08:45:46 +09001093 a.sdkVersion = a.SdkVersion(ctx)
1094 a.minSdkVersion = a.MinSdkVersion(ctx)
1095
Colin Cross56a83212020-09-15 18:30:11 -07001096 a.hideApexVariantFromMake = !ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).IsForPlatform()
1097
Nan Zhang4c819fb2018-08-27 18:31:46 -07001098 aarName := ctx.ModuleName() + ".aar"
Saeid Farivar Asanjanf0436962020-10-05 19:09:09 +00001099 a.aarPath = android.PathForModuleSrc(ctx, a.properties.Aars[0])
1100
Colin Cross1001a792019-03-21 22:21:39 -07001101 if Bool(a.properties.Jetifier) {
Saeid Farivar Asanjanf0436962020-10-05 19:09:09 +00001102 inputFile := a.aarPath
1103 a.aarPath = android.PathForModuleOut(ctx, "jetifier", aarName)
1104 TransformJetifier(ctx, a.aarPath.(android.WritablePath), inputFile)
Nan Zhang4c819fb2018-08-27 18:31:46 -07001105 }
Colin Crossfabb6082018-02-20 17:22:23 -08001106
1107 extractedAARDir := android.PathForModuleOut(ctx, "aar")
Colin Cross205e9112020-08-06 13:20:17 -07001108 a.classpathFile = extractedAARDir.Join(ctx, "classes-combined.jar")
Colin Cross10f7c4a2018-05-23 10:59:28 -07001109 a.manifest = extractedAARDir.Join(ctx, "AndroidManifest.xml")
Colin Cross039d8df2023-06-20 22:40:02 -07001110 aarRTxt := extractedAARDir.Join(ctx, "R.txt")
Michael Rosenfeld5ad15572021-12-03 13:25:10 -08001111 a.assetsPackage = android.PathForModuleOut(ctx, "assets.zip")
Sam Delmerico95d70942023-08-02 18:00:35 -04001112 a.proguardFlags = extractedAARDir.Join(ctx, "proguard.txt")
1113 ctx.SetProvider(ProguardSpecInfoProvider, ProguardSpecInfo{
1114 ProguardFlagsFiles: android.NewDepSet[android.Path](
1115 android.POSTORDER,
1116 android.Paths{a.proguardFlags},
1117 nil,
1118 ),
1119 })
Colin Crossfabb6082018-02-20 17:22:23 -08001120
1121 ctx.Build(pctx, android.BuildParams{
1122 Rule: unzipAAR,
Saeid Farivar Asanjanf0436962020-10-05 19:09:09 +00001123 Input: a.aarPath,
Colin Cross039d8df2023-06-20 22:40:02 -07001124 Outputs: android.WritablePaths{a.classpathFile, a.proguardFlags, a.manifest, a.assetsPackage, aarRTxt},
Colin Crossfabb6082018-02-20 17:22:23 -08001125 Description: "unzip AAR",
1126 Args: map[string]string{
Colin Cross205e9112020-08-06 13:20:17 -07001127 "outDir": extractedAARDir.String(),
1128 "combinedClassesJar": a.classpathFile.String(),
Michael Rosenfeld5ad15572021-12-03 13:25:10 -08001129 "assetsPackage": a.assetsPackage.String(),
Colin Crossfabb6082018-02-20 17:22:23 -08001130 },
1131 })
1132
Colin Crossa0ba2f52019-06-22 12:59:27 -07001133 // Always set --pseudo-localize, it will be stripped out later for release
1134 // builds that don't want it.
1135 compileFlags := []string{"--pseudo-localize"}
Colin Crossfabb6082018-02-20 17:22:23 -08001136 compiledResDir := android.PathForModuleOut(ctx, "flat-res")
Colin Crossfabb6082018-02-20 17:22:23 -08001137 flata := compiledResDir.Join(ctx, "gen_res.flata")
Saeid Farivar Asanjanf0436962020-10-05 19:09:09 +00001138 aapt2CompileZip(ctx, flata, a.aarPath, "res", compileFlags)
Colin Crossfabb6082018-02-20 17:22:23 -08001139
1140 a.exportPackage = android.PathForModuleOut(ctx, "package-res.apk")
Colin Crossfabb6082018-02-20 17:22:23 -08001141 proguardOptionsFile := android.PathForModuleGen(ctx, "proguard.options")
Colin Cross039d8df2023-06-20 22:40:02 -07001142 a.rTxt = android.PathForModuleOut(ctx, "R.txt")
Colin Cross66f78822018-05-02 12:58:28 -07001143 a.extraAaptPackagesFile = android.PathForModuleOut(ctx, "extra_packages")
Colin Crossfabb6082018-02-20 17:22:23 -08001144
1145 var linkDeps android.Paths
1146
1147 linkFlags := []string{
1148 "--static-lib",
Colin Cross039d8df2023-06-20 22:40:02 -07001149 "--merge-only",
Colin Crossfabb6082018-02-20 17:22:23 -08001150 "--auto-add-overlay",
1151 }
1152
Colin Cross10f7c4a2018-05-23 10:59:28 -07001153 linkFlags = append(linkFlags, "--manifest "+a.manifest.String())
1154 linkDeps = append(linkDeps, a.manifest)
Colin Crossfabb6082018-02-20 17:22:23 -08001155
Colin Cross8676c8c2023-10-12 15:58:57 -07001156 staticResourcesNodesDepSet, sharedResourcesNodesDepSet, staticRRODirsDepSet, staticManifestsDepSet, sharedLibs, libFlags :=
Jiyong Parkf1691d22021-03-29 20:11:58 +09001157 aaptLibs(ctx, android.SdkContext(a), nil)
Colin Cross31656952018-05-24 16:11:20 -07001158
Colin Cross8676c8c2023-10-12 15:58:57 -07001159 _ = sharedResourcesNodesDepSet
Colin Crossab8d1382023-07-14 17:23:41 +00001160 _ = staticRRODirsDepSet
Colin Cross8676c8c2023-10-12 15:58:57 -07001161
Colin Crossab8d1382023-07-14 17:23:41 +00001162 staticDeps := transitiveAarDeps(staticResourcesNodesDepSet.ToList())
Colin Crossfabb6082018-02-20 17:22:23 -08001163
Colin Crossab8d1382023-07-14 17:23:41 +00001164 linkDeps = append(linkDeps, sharedLibs...)
Colin Cross039d8df2023-06-20 22:40:02 -07001165 linkDeps = append(linkDeps, staticDeps.resPackages()...)
Colin Crossa97c5d32018-03-28 14:58:31 -07001166 linkFlags = append(linkFlags, libFlags...)
Colin Crossfabb6082018-02-20 17:22:23 -08001167
Colin Cross039d8df2023-06-20 22:40:02 -07001168 overlayRes := android.Paths{flata}
1169
1170 // Treat static library dependencies of static libraries as imports.
1171 transitiveStaticLibs := staticDeps.resPackages()
1172 linkDeps = append(linkDeps, transitiveStaticLibs...)
1173 for _, staticLib := range transitiveStaticLibs {
1174 linkFlags = append(linkFlags, "-I "+staticLib.String())
1175 }
Colin Crossfabb6082018-02-20 17:22:23 -08001176
Colin Crossab8d1382023-07-14 17:23:41 +00001177 transitiveAssets := android.ReverseSliceInPlace(staticDeps.assets())
Colin Crossf3b7bad2023-08-02 15:49:00 -07001178 aapt2Link(ctx, a.exportPackage, nil, proguardOptionsFile, a.rTxt,
Jaewoong Jung6431ca72020-01-15 14:15:10 -08001179 linkFlags, linkDeps, nil, overlayRes, transitiveAssets, nil)
Colin Crossfabb6082018-02-20 17:22:23 -08001180
Colin Cross039d8df2023-06-20 22:40:02 -07001181 a.rJar = android.PathForModuleOut(ctx, "busybox/R.jar")
1182 resourceProcessorBusyBoxGenerateBinaryR(ctx, a.rTxt, a.manifest, a.rJar, nil, true)
1183
Colin Crossf3b7bad2023-08-02 15:49:00 -07001184 aapt2ExtractExtraPackages(ctx, a.extraAaptPackagesFile, a.rJar)
1185
Colin Crossab8d1382023-07-14 17:23:41 +00001186 resourcesNodesDepSetBuilder := android.NewDepSetBuilder[*resourcesNode](android.TOPOLOGICAL)
1187 resourcesNodesDepSetBuilder.Direct(&resourcesNode{
1188 resPackage: a.exportPackage,
1189 manifest: a.manifest,
Colin Cross039d8df2023-06-20 22:40:02 -07001190 rTxt: a.rTxt,
1191 rJar: a.rJar,
Colin Crossab8d1382023-07-14 17:23:41 +00001192 assets: android.OptionalPathForPath(a.assetsPackage),
Colin Cross039d8df2023-06-20 22:40:02 -07001193
1194 usedResourceProcessor: true,
Colin Crossab8d1382023-07-14 17:23:41 +00001195 })
1196 resourcesNodesDepSetBuilder.Transitive(staticResourcesNodesDepSet)
1197 a.resourcesNodesDepSet = resourcesNodesDepSetBuilder.Build()
1198
1199 manifestDepSetBuilder := android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL).Direct(a.manifest)
1200 // TODO(b/288358614): Soong has historically not merged manifests from dependencies of android_library_import
1201 // modules. Merging manifests from dependencies could remove the need for pom2bp to generate the "-nodeps" copies
1202 // of androidx libraries, but doing so triggers errors due to errors introduced by existing dependencies of
1203 // android_library_import modules. If this is fixed, AndroidLibraryDependency.ManifestsDepSet can be dropped
1204 // completely in favor of AndroidLibraryDependency.ResourceNodesDepSet.manifest
1205 //manifestDepSetBuilder.Transitive(transitiveStaticDeps.manifests)
1206 _ = staticManifestsDepSet
1207 a.manifestsDepSet = manifestDepSetBuilder.Build()
Michael Rosenfeld5ad15572021-12-03 13:25:10 -08001208
Colin Cross039d8df2023-06-20 22:40:02 -07001209 a.transitiveAaptResourcePackages = staticDeps.resPackages()
1210
Sam Delmerico9f9c0a22022-11-29 11:19:37 -05001211 a.collectTransitiveHeaderJars(ctx)
Colin Crossdcf71b22021-02-01 13:59:03 -08001212 ctx.SetProvider(JavaInfoProvider, JavaInfo{
1213 HeaderJars: android.PathsIfNonNil(a.classpathFile),
Sam Delmerico9f9c0a22022-11-29 11:19:37 -05001214 TransitiveLibsHeaderJars: a.transitiveLibsHeaderJars,
1215 TransitiveStaticLibsHeaderJars: a.transitiveStaticLibsHeaderJars,
Colin Crossdcf71b22021-02-01 13:59:03 -08001216 ImplementationAndResourcesJars: android.PathsIfNonNil(a.classpathFile),
1217 ImplementationJars: android.PathsIfNonNil(a.classpathFile),
Joe Onorato6fe59eb2023-07-16 13:20:33 -07001218 // TransitiveAconfigFiles: // TODO(b/289117800): LOCAL_ACONFIG_FILES for prebuilts
Colin Crossdcf71b22021-02-01 13:59:03 -08001219 })
Sam Delmerico82602492022-06-10 17:05:42 +00001220
1221 if proptools.Bool(a.properties.Extract_jni) {
1222 for _, t := range ctx.MultiTargets() {
1223 arch := t.Arch.Abi[0]
1224 path := android.PathForModuleOut(ctx, arch+"_jni.zip")
1225 a.jniPackages = append(a.jniPackages, path)
1226
1227 outDir := android.PathForModuleOut(ctx, "aarForJni")
1228 aarPath := android.PathForModuleSrc(ctx, a.properties.Aars[0])
1229 ctx.Build(pctx, android.BuildParams{
1230 Rule: extractJNI,
1231 Input: aarPath,
1232 Outputs: android.WritablePaths{path},
1233 Description: "extract JNI from AAR",
1234 Args: map[string]string{
1235 "outDir": outDir.String(),
1236 "archString": arch,
1237 },
1238 })
1239 }
1240
1241 ctx.SetProvider(JniPackageProvider, JniPackageInfo{
1242 JniPackages: a.jniPackages,
1243 })
1244 }
Colin Crossdcf71b22021-02-01 13:59:03 -08001245}
Colin Crossfabb6082018-02-20 17:22:23 -08001246
1247func (a *AARImport) HeaderJars() android.Paths {
1248 return android.Paths{a.classpathFile}
1249}
1250
Colin Cross331a1212018-08-15 20:40:52 -07001251func (a *AARImport) ImplementationAndResourcesJars() android.Paths {
1252 return android.Paths{a.classpathFile}
1253}
1254
Ulyana Trafimovich5539e7b2020-06-04 14:08:17 +00001255func (a *AARImport) DexJarBuildPath() android.Path {
Colin Crossf24a22a2019-01-31 14:12:44 -08001256 return nil
1257}
1258
Ulya Trafimovich9f3052c2020-06-09 14:31:19 +01001259func (a *AARImport) DexJarInstallPath() android.Path {
1260 return nil
1261}
1262
Ulya Trafimovichb23d28c2020-10-08 12:53:58 +01001263func (a *AARImport) ClassLoaderContexts() dexpreopt.ClassLoaderContextMap {
Jiyong Park1be96912018-05-28 18:02:19 +09001264 return nil
1265}
1266
Jiyong Park45bf82e2020-12-15 22:29:02 +09001267var _ android.ApexModule = (*AARImport)(nil)
1268
1269// Implements android.ApexModule
Jooyung Hanacc7bbe2020-05-20 09:06:00 +09001270func (a *AARImport) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
1271 return a.depIsInSameApex(ctx, dep)
1272}
1273
Jiyong Park45bf82e2020-12-15 22:29:02 +09001274// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07001275func (g *AARImport) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
1276 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09001277 return nil
1278}
1279
Sam Delmericoaf8bb702022-07-25 15:39:32 -04001280var _ android.PrebuiltInterface = (*AARImport)(nil)
Colin Crossfabb6082018-02-20 17:22:23 -08001281
Colin Cross1b16b0e2019-02-12 14:41:32 -08001282// android_library_import imports an `.aar` file into the build graph as if it was built with android_library.
1283//
1284// This module is not suitable for installing on a device, but can be used as a `static_libs` dependency of
1285// an android_app module.
Colin Crossfabb6082018-02-20 17:22:23 -08001286func AARImportFactory() android.Module {
1287 module := &AARImport{}
1288
1289 module.AddProperties(&module.properties)
1290
1291 android.InitPrebuiltModule(module, &module.properties.Aars)
Jooyung Hanacc7bbe2020-05-20 09:06:00 +09001292 android.InitApexModule(module)
Sam Delmerico82602492022-06-10 17:05:42 +00001293 InitJavaModuleMultiTargets(module, android.DeviceSupported)
Romain Jobredeauxc9b2bba2022-02-15 09:35:07 -05001294 android.InitBazelModule(module)
Colin Crossfabb6082018-02-20 17:22:23 -08001295 return module
1296}
Romain Jobredeauxc9b2bba2022-02-15 09:35:07 -05001297
1298type bazelAapt struct {
1299 Manifest bazel.Label
1300 Resource_files bazel.LabelListAttribute
Romain Jobredeaux9c06ef32023-08-21 18:05:29 -04001301 Resource_zips bazel.LabelListAttribute
Romain Jobredeaux7a71e072023-08-16 17:39:12 -04001302 Assets_dir bazel.StringAttribute
1303 Assets bazel.LabelListAttribute
Romain Jobredeauxc9b2bba2022-02-15 09:35:07 -05001304}
1305
1306type bazelAndroidLibrary struct {
1307 *javaLibraryAttributes
1308 *bazelAapt
1309}
1310
1311type bazelAndroidLibraryImport struct {
Romain Jobredeaux2eef2e12023-02-24 12:07:08 -05001312 Aar bazel.Label
1313 Deps bazel.LabelListAttribute
1314 Exports bazel.LabelListAttribute
1315 Sdk_version bazel.StringAttribute
Romain Jobredeauxc9b2bba2022-02-15 09:35:07 -05001316}
1317
Chris Parsons637458d2023-09-19 20:09:00 +00001318func (a *aapt) convertAaptAttrsWithBp2Build(ctx android.Bp2buildMutatorContext) (*bazelAapt, bool) {
Romain Jobredeauxc9b2bba2022-02-15 09:35:07 -05001319 manifest := proptools.StringDefault(a.aaptProperties.Manifest, "AndroidManifest.xml")
1320
1321 resourceFiles := bazel.LabelList{
1322 Includes: []bazel.Label{},
1323 }
1324 for _, dir := range android.PathsWithOptionalDefaultForModuleSrc(ctx, a.aaptProperties.Resource_dirs, "res") {
1325 files := android.RootToModuleRelativePaths(ctx, androidResourceGlob(ctx, dir))
1326 resourceFiles.Includes = append(resourceFiles.Includes, files...)
1327 }
Romain Jobredeaux7a71e072023-08-16 17:39:12 -04001328
1329 assetsDir := bazel.StringAttribute{}
1330 var assets bazel.LabelList
1331 for i, dir := range android.PathsWithOptionalDefaultForModuleSrc(ctx, a.aaptProperties.Asset_dirs, "assets") {
1332 if i > 0 {
1333 ctx.MarkBp2buildUnconvertible(bp2build_metrics_proto.UnconvertedReasonType_PROPERTY_UNSUPPORTED, "multiple asset_dirs")
1334 return &bazelAapt{}, false
1335 }
1336 // Assets_dirs are relative to the module dir when specified, but if the default in used in
1337 // PathsWithOptionalDefaultForModuleSrc, then dir is relative to the top.
1338 assetsRelDir, error := filepath.Rel(ctx.ModuleDir(), dir.Rel())
1339 if error != nil {
1340 assetsRelDir = dir.Rel()
1341 }
1342 assetsDir.Value = proptools.StringPtr(assetsRelDir)
1343 assets = bazel.MakeLabelList(android.RootToModuleRelativePaths(ctx, androidResourceGlob(ctx, dir)))
1344
1345 }
Romain Jobredeaux9c06ef32023-08-21 18:05:29 -04001346 var resourceZips bazel.LabelList
1347 if len(a.aaptProperties.Resource_zips) > 0 {
1348 if ctx.ModuleName() == "framework-res" {
1349 resourceZips = android.BazelLabelForModuleSrc(ctx, a.aaptProperties.Resource_zips)
1350 } else {
1351 //TODO: b/301593550 - Implement support for this
1352 ctx.MarkBp2buildUnconvertible(bp2build_metrics_proto.UnconvertedReasonType_PROPERTY_UNSUPPORTED, "resource_zips")
1353 return &bazelAapt{}, false
1354 }
1355 }
Romain Jobredeauxc9b2bba2022-02-15 09:35:07 -05001356 return &bazelAapt{
1357 android.BazelLabelForModuleSrcSingle(ctx, manifest),
1358 bazel.MakeLabelListAttribute(resourceFiles),
Romain Jobredeaux9c06ef32023-08-21 18:05:29 -04001359 bazel.MakeLabelListAttribute(resourceZips),
Romain Jobredeaux7a71e072023-08-16 17:39:12 -04001360 assetsDir,
1361 bazel.MakeLabelListAttribute(assets),
1362 }, true
Romain Jobredeauxc9b2bba2022-02-15 09:35:07 -05001363}
1364
Chris Parsons637458d2023-09-19 20:09:00 +00001365func (a *AARImport) ConvertWithBp2build(ctx android.Bp2buildMutatorContext) {
Romain Jobredeauxafc5d272023-09-21 11:07:30 -04001366 if len(a.properties.Aars) == 0 {
1367 ctx.MarkBp2buildUnconvertible(bp2build_metrics_proto.UnconvertedReasonType_PROPERTY_UNSUPPORTED, "aars can't be empty")
1368 return
1369 }
Romain Jobredeauxc9b2bba2022-02-15 09:35:07 -05001370 aars := android.BazelLabelForModuleSrcExcludes(ctx, a.properties.Aars, []string{})
1371 exportableStaticLibs := []string{}
1372 // TODO(b/240716882): investigate and handle static_libs deps that are not imports. They are not supported for export by Bazel.
1373 for _, depName := range a.properties.Static_libs {
1374 if dep, ok := ctx.ModuleFromName(depName); ok {
1375 switch dep.(type) {
1376 case *AARImport, *Import:
1377 exportableStaticLibs = append(exportableStaticLibs, depName)
1378 }
1379 }
1380 }
1381 name := android.RemoveOptionalPrebuiltPrefix(a.Name())
1382 deps := android.BazelLabelForModuleDeps(ctx, android.LastUniqueStrings(android.CopyOf(append(a.properties.Static_libs, a.properties.Libs...))))
1383 exports := android.BazelLabelForModuleDeps(ctx, android.LastUniqueStrings(exportableStaticLibs))
1384
1385 ctx.CreateBazelTargetModule(
1386 bazel.BazelTargetModuleProperties{
1387 Rule_class: "aar_import",
Alixa381cd12023-05-10 14:49:38 +00001388 Bzl_load_location: "//build/bazel/rules/android:aar_import.bzl",
Romain Jobredeauxc9b2bba2022-02-15 09:35:07 -05001389 },
1390 android.CommonAttributes{Name: name},
1391 &bazelAndroidLibraryImport{
Romain Jobredeaux2eef2e12023-02-24 12:07:08 -05001392 Aar: aars.Includes[0],
1393 Deps: bazel.MakeLabelListAttribute(deps),
1394 Exports: bazel.MakeLabelListAttribute(exports),
1395 Sdk_version: bazel.StringAttribute{Value: a.properties.Sdk_version},
Romain Jobredeauxc9b2bba2022-02-15 09:35:07 -05001396 },
1397 )
1398
Alix14101de2023-01-06 03:42:07 +00001399 neverlink := true
1400 ctx.CreateBazelTargetModule(
Alix32540022023-03-16 21:06:13 +00001401 AndroidLibraryBazelTargetModuleProperties(),
Alix14101de2023-01-06 03:42:07 +00001402 android.CommonAttributes{Name: name + "-neverlink"},
1403 &bazelAndroidLibrary{
1404 javaLibraryAttributes: &javaLibraryAttributes{
1405 Neverlink: bazel.BoolAttribute{Value: &neverlink},
1406 Exports: bazel.MakeSingleLabelListAttribute(bazel.Label{Label: ":" + name}),
Romain Jobredeaux2eef2e12023-02-24 12:07:08 -05001407 javaCommonAttributes: &javaCommonAttributes{
1408 Sdk_version: bazel.StringAttribute{Value: a.properties.Sdk_version},
1409 },
Alix14101de2023-01-06 03:42:07 +00001410 },
1411 },
1412 )
1413
Romain Jobredeauxc9b2bba2022-02-15 09:35:07 -05001414}
Alix32540022023-03-16 21:06:13 +00001415func AndroidLibraryBazelTargetModuleProperties() bazel.BazelTargetModuleProperties {
1416 return bazel.BazelTargetModuleProperties{
1417 Rule_class: "android_library",
Alixa381cd12023-05-10 14:49:38 +00001418 Bzl_load_location: "//build/bazel/rules/android:android_library.bzl",
Alix32540022023-03-16 21:06:13 +00001419 }
1420}
Romain Jobredeauxc9b2bba2022-02-15 09:35:07 -05001421
Chris Parsons637458d2023-09-19 20:09:00 +00001422func (a *AndroidLibrary) ConvertWithBp2build(ctx android.Bp2buildMutatorContext) {
Liz Kammer7f375862023-08-04 16:37:42 -04001423 commonAttrs, bp2buildInfo, supported := a.convertLibraryAttrsBp2Build(ctx)
1424 if !supported {
1425 return
1426 }
1427
Alix8062f4d2022-11-14 21:38:07 +00001428 depLabels := bp2buildInfo.DepLabels
Romain Jobredeauxc9b2bba2022-02-15 09:35:07 -05001429
1430 deps := depLabels.Deps
1431 if !commonAttrs.Srcs.IsEmpty() {
1432 deps.Append(depLabels.StaticDeps) // we should only append these if there are sources to use them
1433 } else if !depLabels.Deps.IsEmpty() {
Zi Wang10664792023-09-27 12:29:34 -07001434 // android_library does not accept deps when there are no srcs because
1435 // there is no compilation happening, but it accepts exports.
1436 // The non-empty deps here are unnecessary as deps on the android_library
1437 // since they aren't being propagated to any dependencies.
1438 // So we can drop deps here.
1439 deps = bazel.LabelListAttribute{}
Romain Jobredeauxc9b2bba2022-02-15 09:35:07 -05001440 }
Alix82fb94e2022-10-26 20:40:18 +00001441 name := a.Name()
Alix32540022023-03-16 21:06:13 +00001442 props := AndroidLibraryBazelTargetModuleProperties()
Alix82fb94e2022-10-26 20:40:18 +00001443
Romain Jobredeaux7a71e072023-08-16 17:39:12 -04001444 aaptAttrs, supported := a.convertAaptAttrsWithBp2Build(ctx)
1445 if !supported {
1446 return
1447 }
Alixee51bd62023-08-29 16:01:46 +00001448 if hasJavaResources := aaptAttrs.ConvertJavaResources(ctx, commonAttrs); hasJavaResources {
1449 return
1450 }
Romain Jobredeauxc9b2bba2022-02-15 09:35:07 -05001451 ctx.CreateBazelTargetModule(
Alix82fb94e2022-10-26 20:40:18 +00001452 props,
1453 android.CommonAttributes{Name: name},
Romain Jobredeauxc9b2bba2022-02-15 09:35:07 -05001454 &bazelAndroidLibrary{
1455 &javaLibraryAttributes{
1456 javaCommonAttributes: commonAttrs,
1457 Deps: deps,
1458 Exports: depLabels.StaticDeps,
1459 },
Romain Jobredeaux7a71e072023-08-16 17:39:12 -04001460 aaptAttrs,
Romain Jobredeauxc9b2bba2022-02-15 09:35:07 -05001461 },
1462 )
Alix82fb94e2022-10-26 20:40:18 +00001463
1464 neverlink := true
1465 ctx.CreateBazelTargetModule(
1466 props,
1467 android.CommonAttributes{Name: name + "-neverlink"},
1468 &bazelAndroidLibrary{
1469 javaLibraryAttributes: &javaLibraryAttributes{
1470 Neverlink: bazel.BoolAttribute{Value: &neverlink},
1471 Exports: bazel.MakeSingleLabelListAttribute(bazel.Label{Label: ":" + name}),
Romain Jobredeaux2eef2e12023-02-24 12:07:08 -05001472 javaCommonAttributes: &javaCommonAttributes{
1473 Sdk_version: bazel.StringAttribute{Value: a.deviceProperties.Sdk_version},
1474 Java_version: bazel.StringAttribute{Value: a.properties.Java_version},
1475 },
Alix82fb94e2022-10-26 20:40:18 +00001476 },
1477 },
1478 )
Romain Jobredeauxc9b2bba2022-02-15 09:35:07 -05001479}