blob: 5c87b201385981dda7de9906c16be5bfeb74813c [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"
Ulya Trafimovich31e444e2020-08-14 17:32:16 +010024 "android/soong/dexpreopt"
Jaewoong Jung9befb0c2020-01-18 10:33:43 -080025
Colin Crossfabb6082018-02-20 17:22:23 -080026 "github.com/google/blueprint"
Colin Crossa97c5d32018-03-28 14:58:31 -070027 "github.com/google/blueprint/proptools"
Colin Crossfabb6082018-02-20 17:22:23 -080028)
29
Colin Crossa97c5d32018-03-28 14:58:31 -070030type AndroidLibraryDependency interface {
Colin Crossa97c5d32018-03-28 14:58:31 -070031 ExportPackage() android.Path
Colin Cross89c31582018-04-30 15:55:11 -070032 ExportedProguardFlagFiles() android.Paths
Anton Hansson53c88442019-03-18 15:53:16 +000033 ExportedRRODirs() []rroDir
Colin Cross66f78822018-05-02 12:58:28 -070034 ExportedStaticPackages() android.Paths
Colin Cross90c25c62019-04-19 16:22:57 -070035 ExportedManifests() android.Paths
Jaewoong Jung6431ca72020-01-15 14:15:10 -080036 ExportedAssets() android.OptionalPath
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
Colin Crossa97c5d32018-03-28 14:58:31 -070069 // list of directories relative to the Blueprints file containing assets.
Colin Cross0ddae7f2019-02-07 15:30:01 -080070 // Defaults to ["assets"] if a directory called assets exists. Set to []
71 // to disable the default.
Colin Crossa97c5d32018-03-28 14:58:31 -070072 Asset_dirs []string
73
74 // list of directories relative to the Blueprints file containing
Colin Cross0ddae7f2019-02-07 15:30:01 -080075 // Android resources. Defaults to ["res"] if a directory called res exists.
76 // Set to [] to disable the default.
Colin Crossa97c5d32018-03-28 14:58:31 -070077 Resource_dirs []string
78
Colin Crossa592e3e2019-02-19 16:59:53 -080079 // list of zip files containing Android resources.
Colin Cross27b922f2019-03-04 22:35:41 -080080 Resource_zips []string `android:"path"`
Colin Crossa592e3e2019-02-19 16:59:53 -080081
Colin Crossa97c5d32018-03-28 14:58:31 -070082 // path to AndroidManifest.xml. If unset, defaults to "AndroidManifest.xml".
Colin Cross27b922f2019-03-04 22:35:41 -080083 Manifest *string `android:"path"`
changho.shinb5432b72019-08-08 18:37:17 +090084
85 // paths to additional manifest files to merge with main manifest.
86 Additional_manifests []string `android:"path"`
Sasha Smundak541056c2019-10-28 15:50:06 -070087
88 // do not include AndroidManifest from dependent libraries
89 Dont_merge_manifests *bool
Jaewoong Jungc779cd42020-10-06 18:56:10 -070090
91 // true if RRO is enforced for any of the dependent modules
92 RROEnforcedForDependent bool `blueprint:"mutated"`
Colin Crossa97c5d32018-03-28 14:58:31 -070093}
94
95type aapt struct {
Colin Cross90c25c62019-04-19 16:22:57 -070096 aaptSrcJar android.Path
97 exportPackage android.Path
98 manifestPath android.Path
99 transitiveManifestPaths android.Paths
100 proguardOptionsFile android.Path
101 rroDirs []rroDir
102 rTxt android.Path
103 extraAaptPackagesFile android.Path
104 mergedManifestFile android.Path
Jaewoong Jung5b425e22019-06-17 17:40:56 -0700105 noticeFile android.OptionalPath
Jaewoong Jung6431ca72020-01-15 14:15:10 -0800106 assetPackage android.OptionalPath
Colin Cross90c25c62019-04-19 16:22:57 -0700107 isLibrary bool
Sasha Smundak6ad77252019-05-01 13:16:22 -0700108 useEmbeddedNativeLibs bool
Colin Cross90c25c62019-04-19 16:22:57 -0700109 useEmbeddedDex bool
110 usesNonSdkApis bool
Jaewoong Jungc27ab662019-05-30 15:51:14 -0700111 hasNoCode bool
Baligh Uddin5b16dfb2020-02-11 17:27:19 -0800112 LoggingParent string
Colin Cross014489c2020-06-02 20:09:13 -0700113 resourceFiles android.Paths
Colin Crossa97c5d32018-03-28 14:58:31 -0700114
Colin Crosse560c4a2019-03-19 16:03:11 -0700115 splitNames []string
116 splits []split
117
Colin Crossa97c5d32018-03-28 14:58:31 -0700118 aaptProperties aaptProperties
119}
120
Colin Crosse560c4a2019-03-19 16:03:11 -0700121type split struct {
122 name string
123 suffix string
124 path android.Path
125}
126
Jaewoong Jungc779cd42020-10-06 18:56:10 -0700127// Propagate RRO enforcement flag to static lib dependencies transitively.
128func propagateRROEnforcementMutator(ctx android.TopDownMutatorContext) {
129 m := ctx.Module()
130 if d, ok := m.(AndroidLibraryDependency); ok && d.IsRROEnforced(ctx) {
131 ctx.VisitDirectDepsWithTag(staticLibTag, func(d android.Module) {
132 if a, ok := d.(AndroidLibraryDependency); ok {
133 a.SetRROEnforcedForDependent(true)
134 }
135 })
136 }
137}
138
Colin Crossa97c5d32018-03-28 14:58:31 -0700139func (a *aapt) ExportPackage() android.Path {
140 return a.exportPackage
141}
142
Anton Hansson53c88442019-03-18 15:53:16 +0000143func (a *aapt) ExportedRRODirs() []rroDir {
Colin Crossc1c37552019-01-31 11:42:41 -0800144 return a.rroDirs
145}
146
Colin Cross90c25c62019-04-19 16:22:57 -0700147func (a *aapt) ExportedManifests() android.Paths {
148 return a.transitiveManifestPaths
Colin Crossc1c37552019-01-31 11:42:41 -0800149}
150
Jaewoong Jung6431ca72020-01-15 14:15:10 -0800151func (a *aapt) ExportedAssets() android.OptionalPath {
152 return a.assetPackage
153}
154
Jaewoong Jungc779cd42020-10-06 18:56:10 -0700155func (a *aapt) SetRROEnforcedForDependent(enforce bool) {
156 a.aaptProperties.RROEnforcedForDependent = enforce
157}
158
159func (a *aapt) IsRROEnforced(ctx android.BaseModuleContext) bool {
160 // True if RRO is enforced for this module or...
161 return ctx.Config().EnforceRROForModule(ctx.ModuleName()) ||
Jeongik Chacee5ba92021-02-19 12:11:51 +0900162 // if RRO is enforced for any of its dependents.
163 a.aaptProperties.RROEnforcedForDependent
Jaewoong Jungc779cd42020-10-06 18:56:10 -0700164}
165
Jiyong Parkf1691d22021-03-29 20:11:58 +0900166func (a *aapt) aapt2Flags(ctx android.ModuleContext, sdkContext android.SdkContext,
Colin Crossa0ba2f52019-06-22 12:59:27 -0700167 manifestPath android.Path) (compileFlags, linkFlags []string, linkDeps android.Paths,
168 resDirs, overlayDirs []globbedResourceDir, rroDirs []rroDir, resZips android.Paths) {
Colin Crossa97c5d32018-03-28 14:58:31 -0700169
Jaewoong Jung3aff5782020-02-11 07:54:35 -0800170 hasVersionCode := android.PrefixInList(a.aaptProperties.Aaptflags, "--version-code")
171 hasVersionName := android.PrefixInList(a.aaptProperties.Aaptflags, "--version-name")
Colin Crossa97c5d32018-03-28 14:58:31 -0700172
Colin Crossa97c5d32018-03-28 14:58:31 -0700173 // Flags specified in Android.bp
174 linkFlags = append(linkFlags, a.aaptProperties.Aaptflags...)
175
176 linkFlags = append(linkFlags, "--no-static-lib-packages")
177
178 // Find implicit or explicit asset and resource dirs
179 assetDirs := android.PathsWithOptionalDefaultForModuleSrc(ctx, a.aaptProperties.Asset_dirs, "assets")
180 resourceDirs := android.PathsWithOptionalDefaultForModuleSrc(ctx, a.aaptProperties.Resource_dirs, "res")
Colin Cross8a497952019-03-05 22:25:09 -0800181 resourceZips := android.PathsForModuleSrc(ctx, a.aaptProperties.Resource_zips)
Colin Crossa97c5d32018-03-28 14:58:31 -0700182
Colin Crossa97c5d32018-03-28 14:58:31 -0700183 // Glob directories into lists of paths
184 for _, dir := range resourceDirs {
185 resDirs = append(resDirs, globbedResourceDir{
186 dir: dir,
187 files: androidResourceGlob(ctx, dir),
188 })
Jaewoong Jungc779cd42020-10-06 18:56:10 -0700189 resOverlayDirs, resRRODirs := overlayResourceGlob(ctx, a, dir)
Colin Crossa97c5d32018-03-28 14:58:31 -0700190 overlayDirs = append(overlayDirs, resOverlayDirs...)
191 rroDirs = append(rroDirs, resRRODirs...)
192 }
193
Colin Crossc20dc852020-11-10 12:27:45 -0800194 var assetDeps android.Paths
195 for i, dir := range assetDirs {
196 // Add a dependency on every file in the asset directory. This ensures the aapt2
197 // rule will be rerun if one of the files in the asset directory is modified.
198 assetDeps = append(assetDeps, androidResourceGlob(ctx, dir)...)
199
200 // Add a dependency on a file that contains a list of all the files in the asset directory.
201 // This ensures the aapt2 rule will be run if a file is removed from the asset directory,
202 // or a file is added whose timestamp is older than the output of aapt2.
203 assetFileListFile := android.PathForModuleOut(ctx, "asset_dir_globs", strconv.Itoa(i)+".glob")
204 androidResourceGlobList(ctx, dir, assetFileListFile)
205 assetDeps = append(assetDeps, assetFileListFile)
Colin Crossa97c5d32018-03-28 14:58:31 -0700206 }
207
Jaewoong Jung5b425e22019-06-17 17:40:56 -0700208 assetDirStrings := assetDirs.Strings()
209 if a.noticeFile.Valid() {
210 assetDirStrings = append(assetDirStrings, filepath.Dir(a.noticeFile.Path().String()))
Colin Crossc20dc852020-11-10 12:27:45 -0800211 assetDeps = append(assetDeps, a.noticeFile.Path())
Jaewoong Jung5b425e22019-06-17 17:40:56 -0700212 }
213
Colin Crossa97c5d32018-03-28 14:58:31 -0700214 linkFlags = append(linkFlags, "--manifest "+manifestPath.String())
215 linkDeps = append(linkDeps, manifestPath)
216
Jaewoong Jung5b425e22019-06-17 17:40:56 -0700217 linkFlags = append(linkFlags, android.JoinWithPrefix(assetDirStrings, "-A "))
Colin Crossc20dc852020-11-10 12:27:45 -0800218 linkDeps = append(linkDeps, assetDeps...)
Colin Crossa97c5d32018-03-28 14:58:31 -0700219
Colin Crossa97c5d32018-03-28 14:58:31 -0700220 // SDK version flags
Jiyong Park92315372021-04-02 08:45:46 +0900221 minSdkVersion, err := sdkContext.MinSdkVersion(ctx).EffectiveVersionString(ctx)
Jiyong Park6a927c42020-01-21 02:03:43 +0900222 if err != nil {
223 ctx.ModuleErrorf("invalid minSdkVersion: %s", err)
224 }
Colin Crossa97c5d32018-03-28 14:58:31 -0700225
Colin Cross83bb3162018-06-25 15:48:06 -0700226 linkFlags = append(linkFlags, "--min-sdk-version "+minSdkVersion)
227 linkFlags = append(linkFlags, "--target-sdk-version "+minSdkVersion)
Colin Crossa97c5d32018-03-28 14:58:31 -0700228
Colin Crossa97c5d32018-03-28 14:58:31 -0700229 // Version code
230 if !hasVersionCode {
Dan Albert4f378d72020-07-23 17:32:15 -0700231 linkFlags = append(linkFlags, "--version-code", ctx.Config().PlatformSdkVersion().String())
Colin Crossa97c5d32018-03-28 14:58:31 -0700232 }
233
234 if !hasVersionName {
Colin Cross402d5e02018-04-25 14:54:06 -0700235 var versionName string
236 if ctx.ModuleName() == "framework-res" {
237 // Some builds set AppsDefaultVersionName() to include the build number ("O-123456"). aapt2 copies the
238 // version name of framework-res into app manifests as compileSdkVersionCodename, which confuses things
Colin Crossbfd347d2018-05-09 11:11:35 -0700239 // if it contains the build number. Use the PlatformVersionName instead.
240 versionName = ctx.Config().PlatformVersionName()
Colin Cross402d5e02018-04-25 14:54:06 -0700241 } else {
242 versionName = ctx.Config().AppsDefaultVersionName()
243 }
Colin Cross0b9f31f2019-02-28 11:00:01 -0800244 versionName = proptools.NinjaEscape(versionName)
Colin Crossa97c5d32018-03-28 14:58:31 -0700245 linkFlags = append(linkFlags, "--version-name ", versionName)
246 }
247
Colin Crossa0ba2f52019-06-22 12:59:27 -0700248 linkFlags, compileFlags = android.FilterList(linkFlags, []string{"--legacy"})
249
250 // Always set --pseudo-localize, it will be stripped out later for release
251 // builds that don't want it.
252 compileFlags = append(compileFlags, "--pseudo-localize")
253
254 return compileFlags, linkFlags, linkDeps, resDirs, overlayDirs, rroDirs, resourceZips
Colin Crossa97c5d32018-03-28 14:58:31 -0700255}
256
Paul Duffin250e6192019-06-07 10:44:37 +0100257func (a *aapt) deps(ctx android.BottomUpMutatorContext, sdkDep sdkDep) {
Colin Cross42308aa2018-11-14 21:44:17 -0800258 if sdkDep.frameworkResModule != "" {
259 ctx.AddVariationDependencies(nil, frameworkResTag, sdkDep.frameworkResModule)
Colin Crossa97c5d32018-03-28 14:58:31 -0700260 }
261}
262
Jaewoong Jung6431ca72020-01-15 14:15:10 -0800263var extractAssetsRule = pctx.AndroidStaticRule("extractAssets",
264 blueprint.RuleParams{
265 Command: `${config.Zip2ZipCmd} -i ${in} -o ${out} "assets/**/*"`,
266 CommandDeps: []string{"${config.Zip2ZipCmd}"},
267 })
268
Jiyong Parkf1691d22021-03-29 20:11:58 +0900269func (a *aapt) buildActions(ctx android.ModuleContext, sdkContext android.SdkContext,
Paul Duffin06530572022-02-03 17:54:15 +0000270 classLoaderContexts dexpreopt.ClassLoaderContextMap, excludedLibs []string,
271 extraLinkFlags ...string) {
Colin Cross5446e882019-05-22 10:46:27 -0700272
Ulya Trafimovich18554242020-11-03 15:55:11 +0000273 transitiveStaticLibs, transitiveStaticLibManifests, staticRRODirs, assetPackages, libDeps, libFlags :=
Ulya Trafimovichb23d28c2020-10-08 12:53:58 +0100274 aaptLibs(ctx, sdkContext, classLoaderContexts)
Ulya Trafimovich31e444e2020-08-14 17:32:16 +0100275
Paul Duffin06530572022-02-03 17:54:15 +0000276 // Exclude any libraries from the supplied list.
277 classLoaderContexts = classLoaderContexts.ExcludeLibs(excludedLibs)
278
Colin Cross31656952018-05-24 16:11:20 -0700279 // App manifest file
280 manifestFile := proptools.StringDefault(a.aaptProperties.Manifest, "AndroidManifest.xml")
281 manifestSrcPath := android.PathForModuleSrc(ctx, manifestFile)
282
Gurpreet Singh7deabfa2022-02-10 13:28:35 +0000283 manifestPath := ManifestFixer(ctx, manifestSrcPath, ManifestFixerParams{
Gurpreet Singh75d65f32022-01-24 17:44:05 +0000284 SdkContext: sdkContext,
285 ClassLoaderContexts: classLoaderContexts,
286 IsLibrary: a.isLibrary,
287 UseEmbeddedNativeLibs: a.useEmbeddedNativeLibs,
288 UsesNonSdkApis: a.usesNonSdkApis,
289 UseEmbeddedDex: a.useEmbeddedDex,
290 HasNoCode: a.hasNoCode,
Gurpreet Singh75d65f32022-01-24 17:44:05 +0000291 LoggingParent: a.LoggingParent,
292 })
Colin Cross90c25c62019-04-19 16:22:57 -0700293
Luca Stefanifd898822019-09-10 22:13:31 +0200294 // Add additional manifest files to transitive manifests.
295 additionalManifests := android.PathsForModuleSrc(ctx, a.aaptProperties.Additional_manifests)
296 a.transitiveManifestPaths = append(android.Paths{manifestPath}, additionalManifests...)
297 a.transitiveManifestPaths = append(a.transitiveManifestPaths, transitiveStaticLibManifests...)
Colin Cross90c25c62019-04-19 16:22:57 -0700298
Sasha Smundak541056c2019-10-28 15:50:06 -0700299 if len(a.transitiveManifestPaths) > 1 && !Bool(a.aaptProperties.Dont_merge_manifests) {
Luca Stefanifd898822019-09-10 22:13:31 +0200300 a.mergedManifestFile = manifestMerger(ctx, a.transitiveManifestPaths[0], a.transitiveManifestPaths[1:], a.isLibrary)
Colin Cross90c25c62019-04-19 16:22:57 -0700301 if !a.isLibrary {
302 // Only use the merged manifest for applications. For libraries, the transitive closure of manifests
303 // will be propagated to the final application and merged there. The merged manifest for libraries is
304 // only passed to Make, which can't handle transitive dependencies.
305 manifestPath = a.mergedManifestFile
306 }
307 } else {
308 a.mergedManifestFile = manifestPath
309 }
Colin Cross31656952018-05-24 16:11:20 -0700310
Colin Crossa0ba2f52019-06-22 12:59:27 -0700311 compileFlags, linkFlags, linkDeps, resDirs, overlayDirs, rroDirs, resZips := a.aapt2Flags(ctx, sdkContext, manifestPath)
Colin Cross31656952018-05-24 16:11:20 -0700312
Colin Crossc1c37552019-01-31 11:42:41 -0800313 rroDirs = append(rroDirs, staticRRODirs...)
Colin Cross31656952018-05-24 16:11:20 -0700314 linkFlags = append(linkFlags, libFlags...)
315 linkDeps = append(linkDeps, libDeps...)
Colin Crossa97c5d32018-03-28 14:58:31 -0700316 linkFlags = append(linkFlags, extraLinkFlags...)
Colin Cross1b6a3cf2018-07-24 14:51:30 -0700317 if a.isLibrary {
318 linkFlags = append(linkFlags, "--static-lib")
319 }
Colin Crossa97c5d32018-03-28 14:58:31 -0700320
321 packageRes := android.PathForModuleOut(ctx, "package-res.apk")
Jiyong Parkb7c639e2019-08-19 14:56:02 +0900322 // the subdir "android" is required to be filtered by package names
323 srcJar := android.PathForModuleGen(ctx, "android", "R.srcjar")
Colin Crossa97c5d32018-03-28 14:58:31 -0700324 proguardOptionsFile := android.PathForModuleGen(ctx, "proguard.options")
325 rTxt := android.PathForModuleOut(ctx, "R.txt")
Colin Cross66f78822018-05-02 12:58:28 -0700326 // This file isn't used by Soong, but is generated for exporting
327 extraPackages := android.PathForModuleOut(ctx, "extra_packages")
Colin Crossa97c5d32018-03-28 14:58:31 -0700328
Colin Cross4aaa84a2018-08-21 15:14:37 -0700329 var compiledResDirs []android.Paths
Colin Crossa97c5d32018-03-28 14:58:31 -0700330 for _, dir := range resDirs {
Colin Cross014489c2020-06-02 20:09:13 -0700331 a.resourceFiles = append(a.resourceFiles, dir.files...)
Colin Crossa0ba2f52019-06-22 12:59:27 -0700332 compiledResDirs = append(compiledResDirs, aapt2Compile(ctx, dir.dir, dir.files, compileFlags).Paths())
Colin Crossa97c5d32018-03-28 14:58:31 -0700333 }
Colin Cross4aaa84a2018-08-21 15:14:37 -0700334
Colin Crossa592e3e2019-02-19 16:59:53 -0800335 for i, zip := range resZips {
336 flata := android.PathForModuleOut(ctx, fmt.Sprintf("reszip.%d.flata", i))
Colin Crossa0ba2f52019-06-22 12:59:27 -0700337 aapt2CompileZip(ctx, flata, zip, "", compileFlags)
Colin Crossa592e3e2019-02-19 16:59:53 -0800338 compiledResDirs = append(compiledResDirs, android.Paths{flata})
339 }
340
Colin Cross4aaa84a2018-08-21 15:14:37 -0700341 var compiledRes, compiledOverlay android.Paths
342
343 compiledOverlay = append(compiledOverlay, transitiveStaticLibs...)
344
Colin Crossbec85302019-02-13 13:15:46 -0800345 if len(transitiveStaticLibs) > 0 {
Colin Cross4aaa84a2018-08-21 15:14:37 -0700346 // If we are using static android libraries, every source file becomes an overlay.
347 // This is to emulate old AAPT behavior which simulated library support.
348 for _, compiledResDir := range compiledResDirs {
349 compiledOverlay = append(compiledOverlay, compiledResDir...)
350 }
Colin Crossbec85302019-02-13 13:15:46 -0800351 } else if a.isLibrary {
352 // Otherwise, for a static library we treat all the resources equally with no overlay.
353 for _, compiledResDir := range compiledResDirs {
354 compiledRes = append(compiledRes, compiledResDir...)
355 }
Colin Cross4aaa84a2018-08-21 15:14:37 -0700356 } else if len(compiledResDirs) > 0 {
357 // Without static libraries, the first directory is our directory, which can then be
358 // overlaid by the rest.
359 compiledRes = append(compiledRes, compiledResDirs[0]...)
360 for _, compiledResDir := range compiledResDirs[1:] {
361 compiledOverlay = append(compiledOverlay, compiledResDir...)
362 }
363 }
364
Colin Crossa97c5d32018-03-28 14:58:31 -0700365 for _, dir := range overlayDirs {
Colin Crossa0ba2f52019-06-22 12:59:27 -0700366 compiledOverlay = append(compiledOverlay, aapt2Compile(ctx, dir.dir, dir.files, compileFlags).Paths()...)
Colin Crossa97c5d32018-03-28 14:58:31 -0700367 }
368
Colin Crosse560c4a2019-03-19 16:03:11 -0700369 var splitPackages android.WritablePaths
370 var splits []split
371
372 for _, s := range a.splitNames {
373 suffix := strings.Replace(s, ",", "_", -1)
374 path := android.PathForModuleOut(ctx, "package_"+suffix+".apk")
375 linkFlags = append(linkFlags, "--split", path.String()+":"+s)
376 splitPackages = append(splitPackages, path)
377 splits = append(splits, split{
378 name: s,
379 suffix: suffix,
380 path: path,
381 })
382 }
383
Colin Cross66f78822018-05-02 12:58:28 -0700384 aapt2Link(ctx, packageRes, srcJar, proguardOptionsFile, rTxt, extraPackages,
Jaewoong Jung6431ca72020-01-15 14:15:10 -0800385 linkFlags, linkDeps, compiledRes, compiledOverlay, assetPackages, splitPackages)
386
387 // Extract assets from the resource package output so that they can be used later in aapt2link
388 // for modules that depend on this one.
Jaewoong Jung3aff5782020-02-11 07:54:35 -0800389 if android.PrefixInList(linkFlags, "-A ") || len(assetPackages) > 0 {
Jaewoong Jung6431ca72020-01-15 14:15:10 -0800390 assets := android.PathForModuleOut(ctx, "assets.zip")
391 ctx.Build(pctx, android.BuildParams{
392 Rule: extractAssetsRule,
393 Input: packageRes,
394 Output: assets,
395 Description: "extract assets from built resource file",
396 })
397 a.assetPackage = android.OptionalPathForPath(assets)
398 }
Colin Crossa97c5d32018-03-28 14:58:31 -0700399
400 a.aaptSrcJar = srcJar
401 a.exportPackage = packageRes
402 a.manifestPath = manifestPath
403 a.proguardOptionsFile = proguardOptionsFile
404 a.rroDirs = rroDirs
Colin Cross66f78822018-05-02 12:58:28 -0700405 a.extraAaptPackagesFile = extraPackages
Colin Crossa97c5d32018-03-28 14:58:31 -0700406 a.rTxt = rTxt
Colin Crosse560c4a2019-03-19 16:03:11 -0700407 a.splits = splits
Colin Crossa97c5d32018-03-28 14:58:31 -0700408}
409
410// aaptLibs collects libraries from dependencies and sdk_version and converts them into paths
Jiyong Parkf1691d22021-03-29 20:11:58 +0900411func aaptLibs(ctx android.ModuleContext, sdkContext android.SdkContext, classLoaderContexts dexpreopt.ClassLoaderContextMap) (
Ulya Trafimovich18554242020-11-03 15:55:11 +0000412 transitiveStaticLibs, transitiveStaticLibManifests android.Paths, staticRRODirs []rroDir, assets, deps android.Paths, flags []string) {
Colin Cross66f78822018-05-02 12:58:28 -0700413
Colin Crossa97c5d32018-03-28 14:58:31 -0700414 var sharedLibs android.Paths
415
Ulya Trafimovichb23d28c2020-10-08 12:53:58 +0100416 if classLoaderContexts == nil {
Ulya Trafimovich18554242020-11-03 15:55:11 +0000417 // Not all callers need to compute class loader context, those who don't just pass nil.
418 // Create a temporary class loader context here (it will be computed, but not used).
Ulya Trafimovichb23d28c2020-10-08 12:53:58 +0100419 classLoaderContexts = make(dexpreopt.ClassLoaderContextMap)
Ulya Trafimovich18554242020-11-03 15:55:11 +0000420 }
421
Colin Cross83bb3162018-06-25 15:48:06 -0700422 sdkDep := decodeSdkDep(ctx, sdkContext)
Colin Crossa97c5d32018-03-28 14:58:31 -0700423 if sdkDep.useFiles {
Colin Cross86a60ae2018-05-29 14:44:55 -0700424 sharedLibs = append(sharedLibs, sdkDep.jars...)
Colin Crossa97c5d32018-03-28 14:58:31 -0700425 }
426
427 ctx.VisitDirectDeps(func(module android.Module) {
Ulya Trafimovich65b03192020-12-03 16:50:22 +0000428 depTag := ctx.OtherModuleDependencyTag(module)
Ulya Trafimovich18554242020-11-03 15:55:11 +0000429
Colin Crossa97c5d32018-03-28 14:58:31 -0700430 var exportPackage android.Path
Colin Cross66f78822018-05-02 12:58:28 -0700431 aarDep, _ := module.(AndroidLibraryDependency)
432 if aarDep != nil {
Colin Crossa97c5d32018-03-28 14:58:31 -0700433 exportPackage = aarDep.ExportPackage()
434 }
435
Ulya Trafimovich65b03192020-12-03 16:50:22 +0000436 switch depTag {
Colin Cross4b964c02018-10-15 16:18:06 -0700437 case instrumentationForTag:
438 // Nothing, instrumentationForTag is treated as libTag for javac but not for aapt2.
Colin Cross5446e882019-05-22 10:46:27 -0700439 case libTag:
440 if exportPackage != nil {
441 sharedLibs = append(sharedLibs, exportPackage)
442 }
Colin Cross5446e882019-05-22 10:46:27 -0700443 case frameworkResTag:
Colin Crossa97c5d32018-03-28 14:58:31 -0700444 if exportPackage != nil {
445 sharedLibs = append(sharedLibs, exportPackage)
446 }
447 case staticLibTag:
448 if exportPackage != nil {
Colin Cross66f78822018-05-02 12:58:28 -0700449 transitiveStaticLibs = append(transitiveStaticLibs, aarDep.ExportedStaticPackages()...)
Colin Crossbec85302019-02-13 13:15:46 -0800450 transitiveStaticLibs = append(transitiveStaticLibs, exportPackage)
Colin Cross90c25c62019-04-19 16:22:57 -0700451 transitiveStaticLibManifests = append(transitiveStaticLibManifests, aarDep.ExportedManifests()...)
Jaewoong Jung6431ca72020-01-15 14:15:10 -0800452 if aarDep.ExportedAssets().Valid() {
453 assets = append(assets, aarDep.ExportedAssets().Path())
454 }
Anton Hansson53c88442019-03-18 15:53:16 +0000455
Jeongik Chacee5ba92021-02-19 12:11:51 +0900456 outer:
457 for _, d := range aarDep.ExportedRRODirs() {
458 for _, e := range staticRRODirs {
459 if d.path == e.path {
460 continue outer
Anton Hansson53c88442019-03-18 15:53:16 +0000461 }
462 }
Jeongik Chacee5ba92021-02-19 12:11:51 +0900463 staticRRODirs = append(staticRRODirs, d)
Anton Hansson53c88442019-03-18 15:53:16 +0000464 }
Colin Crossa97c5d32018-03-28 14:58:31 -0700465 }
466 }
Ulya Trafimovich18554242020-11-03 15:55:11 +0000467
Ulya Trafimovich88bb6f62020-12-16 16:16:11 +0000468 addCLCFromDep(ctx, module, classLoaderContexts)
Colin Crossa97c5d32018-03-28 14:58:31 -0700469 })
470
471 deps = append(deps, sharedLibs...)
Colin Cross66f78822018-05-02 12:58:28 -0700472 deps = append(deps, transitiveStaticLibs...)
Colin Crossa97c5d32018-03-28 14:58:31 -0700473
Colin Cross66f78822018-05-02 12:58:28 -0700474 if len(transitiveStaticLibs) > 0 {
Colin Crossa97c5d32018-03-28 14:58:31 -0700475 flags = append(flags, "--auto-add-overlay")
476 }
477
478 for _, sharedLib := range sharedLibs {
479 flags = append(flags, "-I "+sharedLib.String())
480 }
481
Colin Cross66f78822018-05-02 12:58:28 -0700482 transitiveStaticLibs = android.FirstUniquePaths(transitiveStaticLibs)
Colin Cross90c25c62019-04-19 16:22:57 -0700483 transitiveStaticLibManifests = android.FirstUniquePaths(transitiveStaticLibManifests)
Colin Cross66f78822018-05-02 12:58:28 -0700484
Ulya Trafimovich18554242020-11-03 15:55:11 +0000485 return transitiveStaticLibs, transitiveStaticLibManifests, staticRRODirs, assets, deps, flags
Colin Crossa97c5d32018-03-28 14:58:31 -0700486}
487
488type AndroidLibrary struct {
489 Library
490 aapt
491
492 androidLibraryProperties androidLibraryProperties
493
494 aarFile android.WritablePath
Colin Cross89c31582018-04-30 15:55:11 -0700495
496 exportedProguardFlagFiles android.Paths
Colin Cross66f78822018-05-02 12:58:28 -0700497 exportedStaticPackages android.Paths
Colin Cross89c31582018-04-30 15:55:11 -0700498}
499
Saeid Farivar Asanjan1fca3012021-09-14 18:40:19 +0000500var _ android.OutputFileProducer = (*AndroidLibrary)(nil)
501
502// For OutputFileProducer interface
503func (a *AndroidLibrary) OutputFiles(tag string) (android.Paths, error) {
504 switch tag {
505 case ".aar":
506 return []android.Path{a.aarFile}, nil
507 default:
508 return a.Library.OutputFiles(tag)
509 }
510}
511
Colin Cross89c31582018-04-30 15:55:11 -0700512func (a *AndroidLibrary) ExportedProguardFlagFiles() android.Paths {
513 return a.exportedProguardFlagFiles
Colin Crossa97c5d32018-03-28 14:58:31 -0700514}
515
Colin Cross66f78822018-05-02 12:58:28 -0700516func (a *AndroidLibrary) ExportedStaticPackages() android.Paths {
517 return a.exportedStaticPackages
518}
519
Colin Crossa97c5d32018-03-28 14:58:31 -0700520var _ AndroidLibraryDependency = (*AndroidLibrary)(nil)
521
522func (a *AndroidLibrary) DepsMutator(ctx android.BottomUpMutatorContext) {
523 a.Module.deps(ctx)
Jiyong Parkf1691d22021-03-29 20:11:58 +0900524 sdkDep := decodeSdkDep(ctx, android.SdkContext(a))
Paul Duffin250e6192019-06-07 10:44:37 +0100525 if sdkDep.hasFrameworkLibs() {
526 a.aapt.deps(ctx, sdkDep)
Colin Crossa97c5d32018-03-28 14:58:31 -0700527 }
Ulya Trafimovich42c7f0d2021-08-17 16:20:29 +0100528 a.usesLibrary.deps(ctx, sdkDep.hasFrameworkLibs())
Colin Crossa97c5d32018-03-28 14:58:31 -0700529}
530
531func (a *AndroidLibrary) GenerateAndroidBuildActions(ctx android.ModuleContext) {
Colin Crosse4246ab2019-02-05 21:55:21 -0800532 a.aapt.isLibrary = true
Ulya Trafimovich42c7f0d2021-08-17 16:20:29 +0100533 a.classLoaderContexts = a.usesLibrary.classLoaderContextForUsesLibDeps(ctx)
Paul Duffin06530572022-02-03 17:54:15 +0000534 a.aapt.buildActions(ctx, android.SdkContext(a), a.classLoaderContexts, nil)
Colin Crossa97c5d32018-03-28 14:58:31 -0700535
Colin Cross56a83212020-09-15 18:30:11 -0700536 a.hideApexVariantFromMake = !ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).IsForPlatform()
537
Colin Crossa97c5d32018-03-28 14:58:31 -0700538 ctx.CheckbuildFile(a.proguardOptionsFile)
539 ctx.CheckbuildFile(a.exportPackage)
540 ctx.CheckbuildFile(a.aaptSrcJar)
541
542 // apps manifests are handled by aapt, don't let Module see them
543 a.properties.Manifest = nil
544
Colin Cross014489c2020-06-02 20:09:13 -0700545 a.linter.mergedManifest = a.aapt.mergedManifestFile
546 a.linter.manifest = a.aapt.manifestPath
547 a.linter.resources = a.aapt.resourceFiles
548
Colin Crossa97c5d32018-03-28 14:58:31 -0700549 a.Module.extraProguardFlagFiles = append(a.Module.extraProguardFlagFiles,
550 a.proguardOptionsFile)
551
552 a.Module.compile(ctx, a.aaptSrcJar)
553
Colin Crossf57c5782019-01-25 13:20:38 -0800554 a.aarFile = android.PathForModuleOut(ctx, ctx.ModuleName()+".aar")
Colin Crossa97c5d32018-03-28 14:58:31 -0700555 var res android.Paths
556 if a.androidLibraryProperties.BuildAAR {
557 BuildAAR(ctx, a.aarFile, a.outputFile, a.manifestPath, a.rTxt, res)
558 ctx.CheckbuildFile(a.aarFile)
559 }
Colin Cross89c31582018-04-30 15:55:11 -0700560
Cole Faust9a631312020-10-22 21:05:24 +0000561 a.exportedProguardFlagFiles = append(a.exportedProguardFlagFiles,
562 android.PathsForModuleSrc(ctx, a.dexProperties.Optimize.Proguard_flags_files)...)
Colin Cross89c31582018-04-30 15:55:11 -0700563 ctx.VisitDirectDeps(func(m android.Module) {
564 if lib, ok := m.(AndroidLibraryDependency); ok && ctx.OtherModuleDependencyTag(m) == staticLibTag {
565 a.exportedProguardFlagFiles = append(a.exportedProguardFlagFiles, lib.ExportedProguardFlagFiles()...)
Colin Cross66f78822018-05-02 12:58:28 -0700566 a.exportedStaticPackages = append(a.exportedStaticPackages, lib.ExportPackage())
567 a.exportedStaticPackages = append(a.exportedStaticPackages, lib.ExportedStaticPackages()...)
Colin Cross89c31582018-04-30 15:55:11 -0700568 }
569 })
570
571 a.exportedProguardFlagFiles = android.FirstUniquePaths(a.exportedProguardFlagFiles)
Colin Cross66f78822018-05-02 12:58:28 -0700572 a.exportedStaticPackages = android.FirstUniquePaths(a.exportedStaticPackages)
Sam Delmerico82602492022-06-10 17:05:42 +0000573
574 prebuiltJniPackages := android.Paths{}
575 ctx.VisitDirectDeps(func(module android.Module) {
576 if info, ok := ctx.OtherModuleProvider(module, JniPackageProvider).(JniPackageInfo); ok {
577 prebuiltJniPackages = append(prebuiltJniPackages, info.JniPackages...)
578 }
579 })
580 if len(prebuiltJniPackages) > 0 {
581 ctx.SetProvider(JniPackageProvider, JniPackageInfo{
582 JniPackages: prebuiltJniPackages,
583 })
584 }
Colin Crossa97c5d32018-03-28 14:58:31 -0700585}
586
Colin Cross1b16b0e2019-02-12 14:41:32 -0800587// android_library builds and links sources into a `.jar` file for the device along with Android resources.
588//
589// An android_library has a single variant that produces a `.jar` file containing `.class` files that were
Sam Delmerico82602492022-06-10 17:05:42 +0000590// compiled against the device bootclasspath, along with a `package-res.apk` file containing Android resources compiled
Colin Cross1b16b0e2019-02-12 14:41:32 -0800591// with aapt2. This module is not suitable for installing on a device, but can be used as a `static_libs` dependency of
592// an android_app module.
Colin Crossa97c5d32018-03-28 14:58:31 -0700593func AndroidLibraryFactory() android.Module {
594 module := &AndroidLibrary{}
595
Colin Crossce6734e2020-06-15 16:09:53 -0700596 module.Module.addHostAndDeviceProperties()
Colin Crossa97c5d32018-03-28 14:58:31 -0700597 module.AddProperties(
Colin Crossa97c5d32018-03-28 14:58:31 -0700598 &module.aaptProperties,
599 &module.androidLibraryProperties)
600
601 module.androidLibraryProperties.BuildAAR = true
Colin Cross014489c2020-06-02 20:09:13 -0700602 module.Module.linter.library = true
Colin Crossa97c5d32018-03-28 14:58:31 -0700603
Jooyung Hanacc7bbe2020-05-20 09:06:00 +0900604 android.InitApexModule(module)
Colin Cross48de9a42018-10-02 13:53:33 -0700605 InitJavaModule(module, android.DeviceSupported)
Colin Crossa97c5d32018-03-28 14:58:31 -0700606 return module
607}
608
Colin Crossfabb6082018-02-20 17:22:23 -0800609//
610// AAR (android library) prebuilts
611//
Colin Crossfabb6082018-02-20 17:22:23 -0800612
Vinh Trance0781f2022-04-13 01:30:44 +0000613// Properties for android_library_import
Colin Crossfabb6082018-02-20 17:22:23 -0800614type AARImportProperties struct {
Vinh Trance0781f2022-04-13 01:30:44 +0000615 // ARR (android library prebuilt) filepath. Exactly one ARR is required.
Colin Cross27b922f2019-03-04 22:35:41 -0800616 Aars []string `android:"path"`
Vinh Trance0781f2022-04-13 01:30:44 +0000617 // If not blank, set to the version of the sdk to compile against.
618 // Defaults to private.
619 // Values are of one of the following forms:
620 // 1) numerical API level, "current", "none", or "core_platform"
621 // 2) An SDK kind with an API level: "<sdk kind>_<API level>"
622 // See build/soong/android/sdk_version.go for the complete and up to date list of SDK kinds.
623 // If the SDK kind is empty, it will be set to public
624 Sdk_version *string
625 // If not blank, set the minimum version of the sdk that the compiled artifacts will run against.
626 // Defaults to sdk_version if not set. See sdk_version for possible values.
Colin Cross479884c2018-07-10 13:39:30 -0700627 Min_sdk_version *string
Vinh Trance0781f2022-04-13 01:30:44 +0000628 // List of java static libraries that the included ARR (android library prebuilts) has dependencies to.
Colin Crossa97c5d32018-03-28 14:58:31 -0700629 Static_libs []string
Vinh Trance0781f2022-04-13 01:30:44 +0000630 // List of java libraries that the included ARR (android library prebuilts) has dependencies to.
631 Libs []string
632 // If set to true, run Jetifier against .aar file. Defaults to false.
Colin Cross1001a792019-03-21 22:21:39 -0700633 Jetifier *bool
Sam Delmerico82602492022-06-10 17:05:42 +0000634 // If true, extract JNI libs from AAR archive. These libs will be accessible to android_app modules and
635 // will be passed transitively through android_libraries to an android_app.
636 //TODO(b/241138093) evaluate whether we can have this flag default to true for Bazel conversion
637 Extract_jni *bool
Colin Crossfabb6082018-02-20 17:22:23 -0800638}
639
640type AARImport struct {
641 android.ModuleBase
Colin Cross48de9a42018-10-02 13:53:33 -0700642 android.DefaultableModuleBase
Jooyung Hanacc7bbe2020-05-20 09:06:00 +0900643 android.ApexModuleBase
Colin Crossfabb6082018-02-20 17:22:23 -0800644 prebuilt android.Prebuilt
645
Jooyung Hanacc7bbe2020-05-20 09:06:00 +0900646 // Functionality common to Module and Import.
647 embeddableInModuleAndImport
648
Colin Crossfabb6082018-02-20 17:22:23 -0800649 properties AARImportProperties
650
Colin Cross66f78822018-05-02 12:58:28 -0700651 classpathFile android.WritablePath
652 proguardFlags android.WritablePath
653 exportPackage android.WritablePath
654 extraAaptPackagesFile android.WritablePath
Colin Cross10f7c4a2018-05-23 10:59:28 -0700655 manifest android.WritablePath
Michael Rosenfeld5ad15572021-12-03 13:25:10 -0800656 assetsPackage android.WritablePath
Colin Cross66f78822018-05-02 12:58:28 -0700657
658 exportedStaticPackages android.Paths
Colin Cross56a83212020-09-15 18:30:11 -0700659
660 hideApexVariantFromMake bool
Saeid Farivar Asanjanf0436962020-10-05 19:09:09 +0000661
Sam Delmerico82602492022-06-10 17:05:42 +0000662 aarPath android.Path
663 jniPackages android.Paths
Jiyong Park92315372021-04-02 08:45:46 +0900664
665 sdkVersion android.SdkSpec
666 minSdkVersion android.SdkSpec
Saeid Farivar Asanjanf0436962020-10-05 19:09:09 +0000667}
668
669var _ android.OutputFileProducer = (*AARImport)(nil)
670
671// For OutputFileProducer interface
672func (a *AARImport) OutputFiles(tag string) (android.Paths, error) {
673 switch tag {
674 case ".aar":
675 return []android.Path{a.aarPath}, nil
676 case "":
677 return []android.Path{a.classpathFile}, nil
678 default:
679 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
680 }
Colin Crossfabb6082018-02-20 17:22:23 -0800681}
682
Jiyong Park92315372021-04-02 08:45:46 +0900683func (a *AARImport) SdkVersion(ctx android.EarlyModuleContext) android.SdkSpec {
684 return android.SdkSpecFrom(ctx, String(a.properties.Sdk_version))
Colin Cross83bb3162018-06-25 15:48:06 -0700685}
686
Jiyong Parkf1691d22021-03-29 20:11:58 +0900687func (a *AARImport) SystemModules() string {
Paul Duffine25c6442019-10-11 13:50:28 +0100688 return ""
689}
690
Jiyong Park92315372021-04-02 08:45:46 +0900691func (a *AARImport) MinSdkVersion(ctx android.EarlyModuleContext) android.SdkSpec {
Colin Cross479884c2018-07-10 13:39:30 -0700692 if a.properties.Min_sdk_version != nil {
Jiyong Park92315372021-04-02 08:45:46 +0900693 return android.SdkSpecFrom(ctx, *a.properties.Min_sdk_version)
Colin Cross479884c2018-07-10 13:39:30 -0700694 }
Jiyong Park92315372021-04-02 08:45:46 +0900695 return a.SdkVersion(ctx)
Colin Cross83bb3162018-06-25 15:48:06 -0700696}
697
William Loh5a082f92022-05-17 20:21:50 +0000698func (a *AARImport) ReplaceMaxSdkVersionPlaceholder(ctx android.EarlyModuleContext) android.SdkSpec {
699 return android.SdkSpecFrom(ctx, "")
700}
701
Jiyong Park92315372021-04-02 08:45:46 +0900702func (a *AARImport) TargetSdkVersion(ctx android.EarlyModuleContext) android.SdkSpec {
703 return a.SdkVersion(ctx)
Dan Willemsen419290a2018-10-31 15:28:47 -0700704}
705
Colin Cross1e743852019-10-28 11:37:20 -0700706func (a *AARImport) javaVersion() string {
707 return ""
708}
709
Colin Crossa97c5d32018-03-28 14:58:31 -0700710var _ AndroidLibraryDependency = (*AARImport)(nil)
711
712func (a *AARImport) ExportPackage() android.Path {
713 return a.exportPackage
714}
715
Colin Cross89c31582018-04-30 15:55:11 -0700716func (a *AARImport) ExportedProguardFlagFiles() android.Paths {
717 return android.Paths{a.proguardFlags}
718}
719
Anton Hansson53c88442019-03-18 15:53:16 +0000720func (a *AARImport) ExportedRRODirs() []rroDir {
Colin Crossc1c37552019-01-31 11:42:41 -0800721 return nil
722}
723
Colin Cross66f78822018-05-02 12:58:28 -0700724func (a *AARImport) ExportedStaticPackages() android.Paths {
725 return a.exportedStaticPackages
726}
727
Colin Cross90c25c62019-04-19 16:22:57 -0700728func (a *AARImport) ExportedManifests() android.Paths {
729 return android.Paths{a.manifest}
Colin Cross31656952018-05-24 16:11:20 -0700730}
731
Jaewoong Jung6431ca72020-01-15 14:15:10 -0800732func (a *AARImport) ExportedAssets() android.OptionalPath {
Michael Rosenfeld5ad15572021-12-03 13:25:10 -0800733 return android.OptionalPathForPath(a.assetsPackage)
Jaewoong Jung6431ca72020-01-15 14:15:10 -0800734}
735
Jaewoong Jungc779cd42020-10-06 18:56:10 -0700736// RRO enforcement is not available on aar_import since its RRO dirs are not
737// exported.
738func (a *AARImport) SetRROEnforcedForDependent(enforce bool) {
739}
740
741// RRO enforcement is not available on aar_import since its RRO dirs are not
742// exported.
743func (a *AARImport) IsRROEnforced(ctx android.BaseModuleContext) bool {
744 return false
745}
746
Colin Crossfabb6082018-02-20 17:22:23 -0800747func (a *AARImport) Prebuilt() *android.Prebuilt {
748 return &a.prebuilt
749}
750
751func (a *AARImport) Name() string {
752 return a.prebuilt.Name(a.ModuleBase.Name())
753}
754
Jiyong Park618922e2020-01-08 13:35:43 +0900755func (a *AARImport) JacocoReportClassesFile() android.Path {
756 return nil
757}
758
Colin Crossfabb6082018-02-20 17:22:23 -0800759func (a *AARImport) DepsMutator(ctx android.BottomUpMutatorContext) {
Jeongik Cha816a23a2020-07-08 01:09:23 +0900760 if !ctx.Config().AlwaysUsePrebuiltSdks() {
Jiyong Parkf1691d22021-03-29 20:11:58 +0900761 sdkDep := decodeSdkDep(ctx, android.SdkContext(a))
Colin Crossa97c5d32018-03-28 14:58:31 -0700762 if sdkDep.useModule && sdkDep.frameworkResModule != "" {
Colin Cross42d48b72018-08-29 14:10:52 -0700763 ctx.AddVariationDependencies(nil, frameworkResTag, sdkDep.frameworkResModule)
Colin Crossfabb6082018-02-20 17:22:23 -0800764 }
765 }
Colin Crossa97c5d32018-03-28 14:58:31 -0700766
Colin Cross42d48b72018-08-29 14:10:52 -0700767 ctx.AddVariationDependencies(nil, libTag, a.properties.Libs...)
768 ctx.AddVariationDependencies(nil, staticLibTag, a.properties.Static_libs...)
Colin Crossfabb6082018-02-20 17:22:23 -0800769}
770
Sam Delmerico82602492022-06-10 17:05:42 +0000771type JniPackageInfo struct {
772 // List of zip files containing JNI libraries
773 // Zip files should have directory structure jni/<arch>/*.so
774 JniPackages android.Paths
775}
776
777var JniPackageProvider = blueprint.NewProvider(JniPackageInfo{})
778
779// Unzip an AAR and extract the JNI libs for $archString.
780var extractJNI = pctx.AndroidStaticRule("extractJNI",
781 blueprint.RuleParams{
782 Command: `rm -rf $out $outDir && touch $out && ` +
783 `unzip -qoDD -d $outDir $in "jni/${archString}/*" && ` +
784 `jni_files=$$(find $outDir/jni -type f) && ` +
785 // print error message if there are no JNI libs for this arch
786 `[ -n "$$jni_files" ] || (echo "ERROR: no JNI libs found for arch ${archString}" && exit 1) && ` +
787 `${config.SoongZipCmd} -o $out -P 'lib/${archString}' ` +
788 `-C $outDir/jni/${archString} $$(echo $$jni_files | xargs -n1 printf " -f %s")`,
789 CommandDeps: []string{"${config.SoongZipCmd}"},
790 },
791 "outDir", "archString")
792
Colin Crossfabb6082018-02-20 17:22:23 -0800793// 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 -0700794// 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 -0800795var unzipAAR = pctx.AndroidStaticRule("unzipAAR",
796 blueprint.RuleParams{
Dan Willemsen304cfec2019-05-28 14:49:06 -0700797 Command: `rm -rf $outDir && mkdir -p $outDir && ` +
Colin Cross205e9112020-08-06 13:20:17 -0700798 `unzip -qoDD -d $outDir $in && rm -rf $outDir/res && touch $out && ` +
Michael Rosenfeld5ad15572021-12-03 13:25:10 -0800799 `${config.Zip2ZipCmd} -i $in -o $assetsPackage 'assets/**/*' && ` +
Colin Cross205e9112020-08-06 13:20:17 -0700800 `${config.MergeZipsCmd} $combinedClassesJar $$(ls $outDir/classes.jar 2> /dev/null) $$(ls $outDir/libs/*.jar 2> /dev/null)`,
Michael Rosenfeld5ad15572021-12-03 13:25:10 -0800801 CommandDeps: []string{"${config.MergeZipsCmd}", "${config.Zip2ZipCmd}"},
Colin Crossfabb6082018-02-20 17:22:23 -0800802 },
Michael Rosenfeld5ad15572021-12-03 13:25:10 -0800803 "outDir", "combinedClassesJar", "assetsPackage")
Colin Crossfabb6082018-02-20 17:22:23 -0800804
805func (a *AARImport) GenerateAndroidBuildActions(ctx android.ModuleContext) {
806 if len(a.properties.Aars) != 1 {
807 ctx.PropertyErrorf("aars", "exactly one aar is required")
808 return
809 }
810
Jiyong Park92315372021-04-02 08:45:46 +0900811 a.sdkVersion = a.SdkVersion(ctx)
812 a.minSdkVersion = a.MinSdkVersion(ctx)
813
Colin Cross56a83212020-09-15 18:30:11 -0700814 a.hideApexVariantFromMake = !ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).IsForPlatform()
815
Nan Zhang4c819fb2018-08-27 18:31:46 -0700816 aarName := ctx.ModuleName() + ".aar"
Saeid Farivar Asanjanf0436962020-10-05 19:09:09 +0000817 a.aarPath = android.PathForModuleSrc(ctx, a.properties.Aars[0])
818
Colin Cross1001a792019-03-21 22:21:39 -0700819 if Bool(a.properties.Jetifier) {
Saeid Farivar Asanjanf0436962020-10-05 19:09:09 +0000820 inputFile := a.aarPath
821 a.aarPath = android.PathForModuleOut(ctx, "jetifier", aarName)
822 TransformJetifier(ctx, a.aarPath.(android.WritablePath), inputFile)
Nan Zhang4c819fb2018-08-27 18:31:46 -0700823 }
Colin Crossfabb6082018-02-20 17:22:23 -0800824
825 extractedAARDir := android.PathForModuleOut(ctx, "aar")
Colin Cross205e9112020-08-06 13:20:17 -0700826 a.classpathFile = extractedAARDir.Join(ctx, "classes-combined.jar")
Colin Crossfabb6082018-02-20 17:22:23 -0800827 a.proguardFlags = extractedAARDir.Join(ctx, "proguard.txt")
Colin Cross10f7c4a2018-05-23 10:59:28 -0700828 a.manifest = extractedAARDir.Join(ctx, "AndroidManifest.xml")
Michael Rosenfeld5ad15572021-12-03 13:25:10 -0800829 a.assetsPackage = android.PathForModuleOut(ctx, "assets.zip")
Colin Crossfabb6082018-02-20 17:22:23 -0800830
831 ctx.Build(pctx, android.BuildParams{
832 Rule: unzipAAR,
Saeid Farivar Asanjanf0436962020-10-05 19:09:09 +0000833 Input: a.aarPath,
Michael Rosenfeld5ad15572021-12-03 13:25:10 -0800834 Outputs: android.WritablePaths{a.classpathFile, a.proguardFlags, a.manifest, a.assetsPackage},
Colin Crossfabb6082018-02-20 17:22:23 -0800835 Description: "unzip AAR",
836 Args: map[string]string{
Colin Cross205e9112020-08-06 13:20:17 -0700837 "outDir": extractedAARDir.String(),
838 "combinedClassesJar": a.classpathFile.String(),
Michael Rosenfeld5ad15572021-12-03 13:25:10 -0800839 "assetsPackage": a.assetsPackage.String(),
Colin Crossfabb6082018-02-20 17:22:23 -0800840 },
841 })
842
Colin Crossa0ba2f52019-06-22 12:59:27 -0700843 // Always set --pseudo-localize, it will be stripped out later for release
844 // builds that don't want it.
845 compileFlags := []string{"--pseudo-localize"}
Colin Crossfabb6082018-02-20 17:22:23 -0800846 compiledResDir := android.PathForModuleOut(ctx, "flat-res")
Colin Crossfabb6082018-02-20 17:22:23 -0800847 flata := compiledResDir.Join(ctx, "gen_res.flata")
Saeid Farivar Asanjanf0436962020-10-05 19:09:09 +0000848 aapt2CompileZip(ctx, flata, a.aarPath, "res", compileFlags)
Colin Crossfabb6082018-02-20 17:22:23 -0800849
850 a.exportPackage = android.PathForModuleOut(ctx, "package-res.apk")
Jiyong Parkb7c639e2019-08-19 14:56:02 +0900851 // the subdir "android" is required to be filtered by package names
852 srcJar := android.PathForModuleGen(ctx, "android", "R.srcjar")
Colin Crossfabb6082018-02-20 17:22:23 -0800853 proguardOptionsFile := android.PathForModuleGen(ctx, "proguard.options")
Colin Crossa97c5d32018-03-28 14:58:31 -0700854 rTxt := android.PathForModuleOut(ctx, "R.txt")
Colin Cross66f78822018-05-02 12:58:28 -0700855 a.extraAaptPackagesFile = android.PathForModuleOut(ctx, "extra_packages")
Colin Crossfabb6082018-02-20 17:22:23 -0800856
857 var linkDeps android.Paths
858
859 linkFlags := []string{
860 "--static-lib",
861 "--no-static-lib-packages",
862 "--auto-add-overlay",
863 }
864
Colin Cross10f7c4a2018-05-23 10:59:28 -0700865 linkFlags = append(linkFlags, "--manifest "+a.manifest.String())
866 linkDeps = append(linkDeps, a.manifest)
Colin Crossfabb6082018-02-20 17:22:23 -0800867
Ulya Trafimovich18554242020-11-03 15:55:11 +0000868 transitiveStaticLibs, staticLibManifests, staticRRODirs, transitiveAssets, libDeps, libFlags :=
Jiyong Parkf1691d22021-03-29 20:11:58 +0900869 aaptLibs(ctx, android.SdkContext(a), nil)
Colin Cross31656952018-05-24 16:11:20 -0700870
871 _ = staticLibManifests
Colin Crossc1c37552019-01-31 11:42:41 -0800872 _ = staticRRODirs
Colin Crossfabb6082018-02-20 17:22:23 -0800873
Colin Crossa97c5d32018-03-28 14:58:31 -0700874 linkDeps = append(linkDeps, libDeps...)
875 linkFlags = append(linkFlags, libFlags...)
Colin Crossfabb6082018-02-20 17:22:23 -0800876
Colin Cross66f78822018-05-02 12:58:28 -0700877 overlayRes := append(android.Paths{flata}, transitiveStaticLibs...)
Colin Crossfabb6082018-02-20 17:22:23 -0800878
Colin Cross66f78822018-05-02 12:58:28 -0700879 aapt2Link(ctx, a.exportPackage, srcJar, proguardOptionsFile, rTxt, a.extraAaptPackagesFile,
Jaewoong Jung6431ca72020-01-15 14:15:10 -0800880 linkFlags, linkDeps, nil, overlayRes, transitiveAssets, nil)
Colin Crossfabb6082018-02-20 17:22:23 -0800881
Michael Rosenfeld5ad15572021-12-03 13:25:10 -0800882 // Merge this import's assets with its dependencies' assets (if there are any).
883 if len(transitiveAssets) > 0 {
884 mergedAssets := android.PathForModuleOut(ctx, "merged-assets.zip")
885 inputZips := append(android.Paths{a.assetsPackage}, transitiveAssets...)
886 ctx.Build(pctx, android.BuildParams{
887 Rule: mergeAssetsRule,
888 Inputs: inputZips,
889 Output: mergedAssets,
890 Description: "merge assets from dependencies and self",
891 })
892 a.assetsPackage = mergedAssets
893 }
894
Colin Crossdcf71b22021-02-01 13:59:03 -0800895 ctx.SetProvider(JavaInfoProvider, JavaInfo{
896 HeaderJars: android.PathsIfNonNil(a.classpathFile),
897 ImplementationAndResourcesJars: android.PathsIfNonNil(a.classpathFile),
898 ImplementationJars: android.PathsIfNonNil(a.classpathFile),
899 })
Sam Delmerico82602492022-06-10 17:05:42 +0000900
901 if proptools.Bool(a.properties.Extract_jni) {
902 for _, t := range ctx.MultiTargets() {
903 arch := t.Arch.Abi[0]
904 path := android.PathForModuleOut(ctx, arch+"_jni.zip")
905 a.jniPackages = append(a.jniPackages, path)
906
907 outDir := android.PathForModuleOut(ctx, "aarForJni")
908 aarPath := android.PathForModuleSrc(ctx, a.properties.Aars[0])
909 ctx.Build(pctx, android.BuildParams{
910 Rule: extractJNI,
911 Input: aarPath,
912 Outputs: android.WritablePaths{path},
913 Description: "extract JNI from AAR",
914 Args: map[string]string{
915 "outDir": outDir.String(),
916 "archString": arch,
917 },
918 })
919 }
920
921 ctx.SetProvider(JniPackageProvider, JniPackageInfo{
922 JniPackages: a.jniPackages,
923 })
924 }
Colin Crossdcf71b22021-02-01 13:59:03 -0800925}
Colin Crossfabb6082018-02-20 17:22:23 -0800926
927func (a *AARImport) HeaderJars() android.Paths {
928 return android.Paths{a.classpathFile}
929}
930
Colin Cross331a1212018-08-15 20:40:52 -0700931func (a *AARImport) ImplementationAndResourcesJars() android.Paths {
932 return android.Paths{a.classpathFile}
933}
934
Ulyana Trafimovich5539e7b2020-06-04 14:08:17 +0000935func (a *AARImport) DexJarBuildPath() android.Path {
Colin Crossf24a22a2019-01-31 14:12:44 -0800936 return nil
937}
938
Ulya Trafimovich9f3052c2020-06-09 14:31:19 +0100939func (a *AARImport) DexJarInstallPath() android.Path {
940 return nil
941}
942
Ulya Trafimovichb23d28c2020-10-08 12:53:58 +0100943func (a *AARImport) ClassLoaderContexts() dexpreopt.ClassLoaderContextMap {
Jiyong Park1be96912018-05-28 18:02:19 +0900944 return nil
945}
946
Jiyong Park45bf82e2020-12-15 22:29:02 +0900947var _ android.ApexModule = (*AARImport)(nil)
948
949// Implements android.ApexModule
Jooyung Hanacc7bbe2020-05-20 09:06:00 +0900950func (a *AARImport) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
951 return a.depIsInSameApex(ctx, dep)
952}
953
Jiyong Park45bf82e2020-12-15 22:29:02 +0900954// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -0700955func (g *AARImport) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
956 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +0900957 return nil
958}
959
Sam Delmericoaf8bb702022-07-25 15:39:32 -0400960var _ android.PrebuiltInterface = (*AARImport)(nil)
Colin Crossfabb6082018-02-20 17:22:23 -0800961
Colin Cross1b16b0e2019-02-12 14:41:32 -0800962// android_library_import imports an `.aar` file into the build graph as if it was built with android_library.
963//
964// This module is not suitable for installing on a device, but can be used as a `static_libs` dependency of
965// an android_app module.
Colin Crossfabb6082018-02-20 17:22:23 -0800966func AARImportFactory() android.Module {
967 module := &AARImport{}
968
969 module.AddProperties(&module.properties)
970
971 android.InitPrebuiltModule(module, &module.properties.Aars)
Jooyung Hanacc7bbe2020-05-20 09:06:00 +0900972 android.InitApexModule(module)
Sam Delmerico82602492022-06-10 17:05:42 +0000973 InitJavaModuleMultiTargets(module, android.DeviceSupported)
Colin Crossfabb6082018-02-20 17:22:23 -0800974 return module
975}