blob: a5cf0fd70e6b852aef7a4e45d62417781eb65ceb [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 Parkdbd710c2021-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,
Ulya Trafimovichb23d28c2020-10-08 12:53:58 +0100270 classLoaderContexts dexpreopt.ClassLoaderContextMap, extraLinkFlags ...string) {
Colin Cross5446e882019-05-22 10:46:27 -0700271
Ulya Trafimovich18554242020-11-03 15:55:11 +0000272 transitiveStaticLibs, transitiveStaticLibManifests, staticRRODirs, assetPackages, libDeps, libFlags :=
Ulya Trafimovichb23d28c2020-10-08 12:53:58 +0100273 aaptLibs(ctx, sdkContext, classLoaderContexts)
Ulya Trafimovich31e444e2020-08-14 17:32:16 +0100274
Colin Cross31656952018-05-24 16:11:20 -0700275 // App manifest file
276 manifestFile := proptools.StringDefault(a.aaptProperties.Manifest, "AndroidManifest.xml")
277 manifestSrcPath := android.PathForModuleSrc(ctx, manifestFile)
278
Ulya Trafimovichb23d28c2020-10-08 12:53:58 +0100279 manifestPath := manifestFixer(ctx, manifestSrcPath, sdkContext, classLoaderContexts,
Baligh Uddin5b16dfb2020-02-11 17:27:19 -0800280 a.isLibrary, a.useEmbeddedNativeLibs, a.usesNonSdkApis, a.useEmbeddedDex, a.hasNoCode,
281 a.LoggingParent)
Colin Cross90c25c62019-04-19 16:22:57 -0700282
Luca Stefanifd898822019-09-10 22:13:31 +0200283 // Add additional manifest files to transitive manifests.
284 additionalManifests := android.PathsForModuleSrc(ctx, a.aaptProperties.Additional_manifests)
285 a.transitiveManifestPaths = append(android.Paths{manifestPath}, additionalManifests...)
286 a.transitiveManifestPaths = append(a.transitiveManifestPaths, transitiveStaticLibManifests...)
Colin Cross90c25c62019-04-19 16:22:57 -0700287
Sasha Smundak541056c2019-10-28 15:50:06 -0700288 if len(a.transitiveManifestPaths) > 1 && !Bool(a.aaptProperties.Dont_merge_manifests) {
Luca Stefanifd898822019-09-10 22:13:31 +0200289 a.mergedManifestFile = manifestMerger(ctx, a.transitiveManifestPaths[0], a.transitiveManifestPaths[1:], a.isLibrary)
Colin Cross90c25c62019-04-19 16:22:57 -0700290 if !a.isLibrary {
291 // Only use the merged manifest for applications. For libraries, the transitive closure of manifests
292 // will be propagated to the final application and merged there. The merged manifest for libraries is
293 // only passed to Make, which can't handle transitive dependencies.
294 manifestPath = a.mergedManifestFile
295 }
296 } else {
297 a.mergedManifestFile = manifestPath
298 }
Colin Cross31656952018-05-24 16:11:20 -0700299
Colin Crossa0ba2f52019-06-22 12:59:27 -0700300 compileFlags, linkFlags, linkDeps, resDirs, overlayDirs, rroDirs, resZips := a.aapt2Flags(ctx, sdkContext, manifestPath)
Colin Cross31656952018-05-24 16:11:20 -0700301
Colin Crossc1c37552019-01-31 11:42:41 -0800302 rroDirs = append(rroDirs, staticRRODirs...)
Colin Cross31656952018-05-24 16:11:20 -0700303 linkFlags = append(linkFlags, libFlags...)
304 linkDeps = append(linkDeps, libDeps...)
Colin Crossa97c5d32018-03-28 14:58:31 -0700305 linkFlags = append(linkFlags, extraLinkFlags...)
Colin Cross1b6a3cf2018-07-24 14:51:30 -0700306 if a.isLibrary {
307 linkFlags = append(linkFlags, "--static-lib")
308 }
Colin Crossa97c5d32018-03-28 14:58:31 -0700309
310 packageRes := android.PathForModuleOut(ctx, "package-res.apk")
Jiyong Parkb7c639e2019-08-19 14:56:02 +0900311 // the subdir "android" is required to be filtered by package names
312 srcJar := android.PathForModuleGen(ctx, "android", "R.srcjar")
Colin Crossa97c5d32018-03-28 14:58:31 -0700313 proguardOptionsFile := android.PathForModuleGen(ctx, "proguard.options")
314 rTxt := android.PathForModuleOut(ctx, "R.txt")
Colin Cross66f78822018-05-02 12:58:28 -0700315 // This file isn't used by Soong, but is generated for exporting
316 extraPackages := android.PathForModuleOut(ctx, "extra_packages")
Colin Crossa97c5d32018-03-28 14:58:31 -0700317
Colin Cross4aaa84a2018-08-21 15:14:37 -0700318 var compiledResDirs []android.Paths
Colin Crossa97c5d32018-03-28 14:58:31 -0700319 for _, dir := range resDirs {
Colin Cross014489c2020-06-02 20:09:13 -0700320 a.resourceFiles = append(a.resourceFiles, dir.files...)
Colin Crossa0ba2f52019-06-22 12:59:27 -0700321 compiledResDirs = append(compiledResDirs, aapt2Compile(ctx, dir.dir, dir.files, compileFlags).Paths())
Colin Crossa97c5d32018-03-28 14:58:31 -0700322 }
Colin Cross4aaa84a2018-08-21 15:14:37 -0700323
Colin Crossa592e3e2019-02-19 16:59:53 -0800324 for i, zip := range resZips {
325 flata := android.PathForModuleOut(ctx, fmt.Sprintf("reszip.%d.flata", i))
Colin Crossa0ba2f52019-06-22 12:59:27 -0700326 aapt2CompileZip(ctx, flata, zip, "", compileFlags)
Colin Crossa592e3e2019-02-19 16:59:53 -0800327 compiledResDirs = append(compiledResDirs, android.Paths{flata})
328 }
329
Colin Cross4aaa84a2018-08-21 15:14:37 -0700330 var compiledRes, compiledOverlay android.Paths
331
332 compiledOverlay = append(compiledOverlay, transitiveStaticLibs...)
333
Colin Crossbec85302019-02-13 13:15:46 -0800334 if len(transitiveStaticLibs) > 0 {
Colin Cross4aaa84a2018-08-21 15:14:37 -0700335 // If we are using static android libraries, every source file becomes an overlay.
336 // This is to emulate old AAPT behavior which simulated library support.
337 for _, compiledResDir := range compiledResDirs {
338 compiledOverlay = append(compiledOverlay, compiledResDir...)
339 }
Colin Crossbec85302019-02-13 13:15:46 -0800340 } else if a.isLibrary {
341 // Otherwise, for a static library we treat all the resources equally with no overlay.
342 for _, compiledResDir := range compiledResDirs {
343 compiledRes = append(compiledRes, compiledResDir...)
344 }
Colin Cross4aaa84a2018-08-21 15:14:37 -0700345 } else if len(compiledResDirs) > 0 {
346 // Without static libraries, the first directory is our directory, which can then be
347 // overlaid by the rest.
348 compiledRes = append(compiledRes, compiledResDirs[0]...)
349 for _, compiledResDir := range compiledResDirs[1:] {
350 compiledOverlay = append(compiledOverlay, compiledResDir...)
351 }
352 }
353
Colin Crossa97c5d32018-03-28 14:58:31 -0700354 for _, dir := range overlayDirs {
Colin Crossa0ba2f52019-06-22 12:59:27 -0700355 compiledOverlay = append(compiledOverlay, aapt2Compile(ctx, dir.dir, dir.files, compileFlags).Paths()...)
Colin Crossa97c5d32018-03-28 14:58:31 -0700356 }
357
Colin Crosse560c4a2019-03-19 16:03:11 -0700358 var splitPackages android.WritablePaths
359 var splits []split
360
361 for _, s := range a.splitNames {
362 suffix := strings.Replace(s, ",", "_", -1)
363 path := android.PathForModuleOut(ctx, "package_"+suffix+".apk")
364 linkFlags = append(linkFlags, "--split", path.String()+":"+s)
365 splitPackages = append(splitPackages, path)
366 splits = append(splits, split{
367 name: s,
368 suffix: suffix,
369 path: path,
370 })
371 }
372
Colin Cross66f78822018-05-02 12:58:28 -0700373 aapt2Link(ctx, packageRes, srcJar, proguardOptionsFile, rTxt, extraPackages,
Jaewoong Jung6431ca72020-01-15 14:15:10 -0800374 linkFlags, linkDeps, compiledRes, compiledOverlay, assetPackages, splitPackages)
375
376 // Extract assets from the resource package output so that they can be used later in aapt2link
377 // for modules that depend on this one.
Jaewoong Jung3aff5782020-02-11 07:54:35 -0800378 if android.PrefixInList(linkFlags, "-A ") || len(assetPackages) > 0 {
Jaewoong Jung6431ca72020-01-15 14:15:10 -0800379 assets := android.PathForModuleOut(ctx, "assets.zip")
380 ctx.Build(pctx, android.BuildParams{
381 Rule: extractAssetsRule,
382 Input: packageRes,
383 Output: assets,
384 Description: "extract assets from built resource file",
385 })
386 a.assetPackage = android.OptionalPathForPath(assets)
387 }
Colin Crossa97c5d32018-03-28 14:58:31 -0700388
389 a.aaptSrcJar = srcJar
390 a.exportPackage = packageRes
391 a.manifestPath = manifestPath
392 a.proguardOptionsFile = proguardOptionsFile
393 a.rroDirs = rroDirs
Colin Cross66f78822018-05-02 12:58:28 -0700394 a.extraAaptPackagesFile = extraPackages
Colin Crossa97c5d32018-03-28 14:58:31 -0700395 a.rTxt = rTxt
Colin Crosse560c4a2019-03-19 16:03:11 -0700396 a.splits = splits
Colin Crossa97c5d32018-03-28 14:58:31 -0700397}
398
399// aaptLibs collects libraries from dependencies and sdk_version and converts them into paths
Jiyong Parkf1691d22021-03-29 20:11:58 +0900400func aaptLibs(ctx android.ModuleContext, sdkContext android.SdkContext, classLoaderContexts dexpreopt.ClassLoaderContextMap) (
Ulya Trafimovich18554242020-11-03 15:55:11 +0000401 transitiveStaticLibs, transitiveStaticLibManifests android.Paths, staticRRODirs []rroDir, assets, deps android.Paths, flags []string) {
Colin Cross66f78822018-05-02 12:58:28 -0700402
Colin Crossa97c5d32018-03-28 14:58:31 -0700403 var sharedLibs android.Paths
404
Ulya Trafimovichb23d28c2020-10-08 12:53:58 +0100405 if classLoaderContexts == nil {
Ulya Trafimovich18554242020-11-03 15:55:11 +0000406 // Not all callers need to compute class loader context, those who don't just pass nil.
407 // Create a temporary class loader context here (it will be computed, but not used).
Ulya Trafimovichb23d28c2020-10-08 12:53:58 +0100408 classLoaderContexts = make(dexpreopt.ClassLoaderContextMap)
Ulya Trafimovich18554242020-11-03 15:55:11 +0000409 }
410
Colin Cross83bb3162018-06-25 15:48:06 -0700411 sdkDep := decodeSdkDep(ctx, sdkContext)
Colin Crossa97c5d32018-03-28 14:58:31 -0700412 if sdkDep.useFiles {
Colin Cross86a60ae2018-05-29 14:44:55 -0700413 sharedLibs = append(sharedLibs, sdkDep.jars...)
Colin Crossa97c5d32018-03-28 14:58:31 -0700414 }
415
416 ctx.VisitDirectDeps(func(module android.Module) {
Ulya Trafimovich65b03192020-12-03 16:50:22 +0000417 depTag := ctx.OtherModuleDependencyTag(module)
Ulya Trafimovich18554242020-11-03 15:55:11 +0000418
Colin Crossa97c5d32018-03-28 14:58:31 -0700419 var exportPackage android.Path
Colin Cross66f78822018-05-02 12:58:28 -0700420 aarDep, _ := module.(AndroidLibraryDependency)
421 if aarDep != nil {
Colin Crossa97c5d32018-03-28 14:58:31 -0700422 exportPackage = aarDep.ExportPackage()
423 }
424
Ulya Trafimovich65b03192020-12-03 16:50:22 +0000425 switch depTag {
Colin Cross4b964c02018-10-15 16:18:06 -0700426 case instrumentationForTag:
427 // Nothing, instrumentationForTag is treated as libTag for javac but not for aapt2.
Colin Cross5446e882019-05-22 10:46:27 -0700428 case libTag:
429 if exportPackage != nil {
430 sharedLibs = append(sharedLibs, exportPackage)
431 }
Colin Cross5446e882019-05-22 10:46:27 -0700432 case frameworkResTag:
Colin Crossa97c5d32018-03-28 14:58:31 -0700433 if exportPackage != nil {
434 sharedLibs = append(sharedLibs, exportPackage)
435 }
436 case staticLibTag:
437 if exportPackage != nil {
Colin Cross66f78822018-05-02 12:58:28 -0700438 transitiveStaticLibs = append(transitiveStaticLibs, aarDep.ExportedStaticPackages()...)
Colin Crossbec85302019-02-13 13:15:46 -0800439 transitiveStaticLibs = append(transitiveStaticLibs, exportPackage)
Colin Cross90c25c62019-04-19 16:22:57 -0700440 transitiveStaticLibManifests = append(transitiveStaticLibManifests, aarDep.ExportedManifests()...)
Jaewoong Jung6431ca72020-01-15 14:15:10 -0800441 if aarDep.ExportedAssets().Valid() {
442 assets = append(assets, aarDep.ExportedAssets().Path())
443 }
Anton Hansson53c88442019-03-18 15:53:16 +0000444
Jeongik Chacee5ba92021-02-19 12:11:51 +0900445 outer:
446 for _, d := range aarDep.ExportedRRODirs() {
447 for _, e := range staticRRODirs {
448 if d.path == e.path {
449 continue outer
Anton Hansson53c88442019-03-18 15:53:16 +0000450 }
451 }
Jeongik Chacee5ba92021-02-19 12:11:51 +0900452 staticRRODirs = append(staticRRODirs, d)
Anton Hansson53c88442019-03-18 15:53:16 +0000453 }
Colin Crossa97c5d32018-03-28 14:58:31 -0700454 }
455 }
Ulya Trafimovich18554242020-11-03 15:55:11 +0000456
Ulya Trafimovich88bb6f62020-12-16 16:16:11 +0000457 addCLCFromDep(ctx, module, classLoaderContexts)
Colin Crossa97c5d32018-03-28 14:58:31 -0700458 })
459
460 deps = append(deps, sharedLibs...)
Colin Cross66f78822018-05-02 12:58:28 -0700461 deps = append(deps, transitiveStaticLibs...)
Colin Crossa97c5d32018-03-28 14:58:31 -0700462
Colin Cross66f78822018-05-02 12:58:28 -0700463 if len(transitiveStaticLibs) > 0 {
Colin Crossa97c5d32018-03-28 14:58:31 -0700464 flags = append(flags, "--auto-add-overlay")
465 }
466
467 for _, sharedLib := range sharedLibs {
468 flags = append(flags, "-I "+sharedLib.String())
469 }
470
Colin Cross66f78822018-05-02 12:58:28 -0700471 transitiveStaticLibs = android.FirstUniquePaths(transitiveStaticLibs)
Colin Cross90c25c62019-04-19 16:22:57 -0700472 transitiveStaticLibManifests = android.FirstUniquePaths(transitiveStaticLibManifests)
Colin Cross66f78822018-05-02 12:58:28 -0700473
Ulya Trafimovich18554242020-11-03 15:55:11 +0000474 return transitiveStaticLibs, transitiveStaticLibManifests, staticRRODirs, assets, deps, flags
Colin Crossa97c5d32018-03-28 14:58:31 -0700475}
476
477type AndroidLibrary struct {
478 Library
479 aapt
480
481 androidLibraryProperties androidLibraryProperties
482
483 aarFile android.WritablePath
Colin Cross89c31582018-04-30 15:55:11 -0700484
485 exportedProguardFlagFiles android.Paths
Colin Cross66f78822018-05-02 12:58:28 -0700486 exportedStaticPackages android.Paths
Colin Cross89c31582018-04-30 15:55:11 -0700487}
488
Saeid Farivar Asanjanbee62712021-09-14 18:40:19 +0000489var _ android.OutputFileProducer = (*AndroidLibrary)(nil)
490
491// For OutputFileProducer interface
492func (a *AndroidLibrary) OutputFiles(tag string) (android.Paths, error) {
493 switch tag {
494 case ".aar":
495 return []android.Path{a.aarFile}, nil
496 default:
497 return a.Library.OutputFiles(tag)
498 }
499}
500
Colin Cross89c31582018-04-30 15:55:11 -0700501func (a *AndroidLibrary) ExportedProguardFlagFiles() android.Paths {
502 return a.exportedProguardFlagFiles
Colin Crossa97c5d32018-03-28 14:58:31 -0700503}
504
Colin Cross66f78822018-05-02 12:58:28 -0700505func (a *AndroidLibrary) ExportedStaticPackages() android.Paths {
506 return a.exportedStaticPackages
507}
508
Colin Crossa97c5d32018-03-28 14:58:31 -0700509var _ AndroidLibraryDependency = (*AndroidLibrary)(nil)
510
511func (a *AndroidLibrary) DepsMutator(ctx android.BottomUpMutatorContext) {
512 a.Module.deps(ctx)
Jiyong Parkf1691d22021-03-29 20:11:58 +0900513 sdkDep := decodeSdkDep(ctx, android.SdkContext(a))
Paul Duffin250e6192019-06-07 10:44:37 +0100514 if sdkDep.hasFrameworkLibs() {
515 a.aapt.deps(ctx, sdkDep)
Colin Crossa97c5d32018-03-28 14:58:31 -0700516 }
517}
518
519func (a *AndroidLibrary) GenerateAndroidBuildActions(ctx android.ModuleContext) {
Colin Crosse4246ab2019-02-05 21:55:21 -0800520 a.aapt.isLibrary = true
Ulya Trafimovichb23d28c2020-10-08 12:53:58 +0100521 a.classLoaderContexts = make(dexpreopt.ClassLoaderContextMap)
Jiyong Parkf1691d22021-03-29 20:11:58 +0900522 a.aapt.buildActions(ctx, android.SdkContext(a), a.classLoaderContexts)
Colin Crossa97c5d32018-03-28 14:58:31 -0700523
Colin Cross56a83212020-09-15 18:30:11 -0700524 a.hideApexVariantFromMake = !ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).IsForPlatform()
525
Colin Crossa97c5d32018-03-28 14:58:31 -0700526 ctx.CheckbuildFile(a.proguardOptionsFile)
527 ctx.CheckbuildFile(a.exportPackage)
528 ctx.CheckbuildFile(a.aaptSrcJar)
529
530 // apps manifests are handled by aapt, don't let Module see them
531 a.properties.Manifest = nil
532
Colin Cross014489c2020-06-02 20:09:13 -0700533 a.linter.mergedManifest = a.aapt.mergedManifestFile
534 a.linter.manifest = a.aapt.manifestPath
535 a.linter.resources = a.aapt.resourceFiles
536
Colin Crossa97c5d32018-03-28 14:58:31 -0700537 a.Module.extraProguardFlagFiles = append(a.Module.extraProguardFlagFiles,
538 a.proguardOptionsFile)
539
540 a.Module.compile(ctx, a.aaptSrcJar)
541
Colin Crossf57c5782019-01-25 13:20:38 -0800542 a.aarFile = android.PathForModuleOut(ctx, ctx.ModuleName()+".aar")
Colin Crossa97c5d32018-03-28 14:58:31 -0700543 var res android.Paths
544 if a.androidLibraryProperties.BuildAAR {
545 BuildAAR(ctx, a.aarFile, a.outputFile, a.manifestPath, a.rTxt, res)
546 ctx.CheckbuildFile(a.aarFile)
547 }
Colin Cross89c31582018-04-30 15:55:11 -0700548
Cole Faust9a631312020-10-22 21:05:24 +0000549 a.exportedProguardFlagFiles = append(a.exportedProguardFlagFiles,
550 android.PathsForModuleSrc(ctx, a.dexProperties.Optimize.Proguard_flags_files)...)
Colin Cross89c31582018-04-30 15:55:11 -0700551 ctx.VisitDirectDeps(func(m android.Module) {
552 if lib, ok := m.(AndroidLibraryDependency); ok && ctx.OtherModuleDependencyTag(m) == staticLibTag {
553 a.exportedProguardFlagFiles = append(a.exportedProguardFlagFiles, lib.ExportedProguardFlagFiles()...)
Colin Cross66f78822018-05-02 12:58:28 -0700554 a.exportedStaticPackages = append(a.exportedStaticPackages, lib.ExportPackage())
555 a.exportedStaticPackages = append(a.exportedStaticPackages, lib.ExportedStaticPackages()...)
Colin Cross89c31582018-04-30 15:55:11 -0700556 }
557 })
558
559 a.exportedProguardFlagFiles = android.FirstUniquePaths(a.exportedProguardFlagFiles)
Colin Cross66f78822018-05-02 12:58:28 -0700560 a.exportedStaticPackages = android.FirstUniquePaths(a.exportedStaticPackages)
Colin Crossa97c5d32018-03-28 14:58:31 -0700561}
562
Colin Cross1b16b0e2019-02-12 14:41:32 -0800563// android_library builds and links sources into a `.jar` file for the device along with Android resources.
564//
565// An android_library has a single variant that produces a `.jar` file containing `.class` files that were
566// compiled against the device bootclasspath, along with a `package-res.apk` file containing Android resources compiled
567// with aapt2. This module is not suitable for installing on a device, but can be used as a `static_libs` dependency of
568// an android_app module.
Colin Crossa97c5d32018-03-28 14:58:31 -0700569func AndroidLibraryFactory() android.Module {
570 module := &AndroidLibrary{}
571
Colin Crossce6734e2020-06-15 16:09:53 -0700572 module.Module.addHostAndDeviceProperties()
Colin Crossa97c5d32018-03-28 14:58:31 -0700573 module.AddProperties(
Colin Crossa97c5d32018-03-28 14:58:31 -0700574 &module.aaptProperties,
575 &module.androidLibraryProperties)
576
577 module.androidLibraryProperties.BuildAAR = true
Colin Cross014489c2020-06-02 20:09:13 -0700578 module.Module.linter.library = true
Colin Crossa97c5d32018-03-28 14:58:31 -0700579
Jooyung Hanacc7bbe2020-05-20 09:06:00 +0900580 android.InitApexModule(module)
Colin Cross48de9a42018-10-02 13:53:33 -0700581 InitJavaModule(module, android.DeviceSupported)
Colin Crossa97c5d32018-03-28 14:58:31 -0700582 return module
583}
584
Colin Crossfabb6082018-02-20 17:22:23 -0800585//
586// AAR (android library) prebuilts
587//
Colin Crossfabb6082018-02-20 17:22:23 -0800588
589type AARImportProperties struct {
Colin Cross27b922f2019-03-04 22:35:41 -0800590 Aars []string `android:"path"`
Colin Crossfabb6082018-02-20 17:22:23 -0800591
Colin Cross479884c2018-07-10 13:39:30 -0700592 Sdk_version *string
593 Min_sdk_version *string
Colin Crossa97c5d32018-03-28 14:58:31 -0700594
595 Static_libs []string
596 Libs []string
Nan Zhang4c819fb2018-08-27 18:31:46 -0700597
598 // if set to true, run Jetifier against .aar file. Defaults to false.
Colin Cross1001a792019-03-21 22:21:39 -0700599 Jetifier *bool
Colin Crossfabb6082018-02-20 17:22:23 -0800600}
601
602type AARImport struct {
603 android.ModuleBase
Colin Cross48de9a42018-10-02 13:53:33 -0700604 android.DefaultableModuleBase
Jooyung Hanacc7bbe2020-05-20 09:06:00 +0900605 android.ApexModuleBase
Colin Crossfabb6082018-02-20 17:22:23 -0800606 prebuilt android.Prebuilt
607
Jooyung Hanacc7bbe2020-05-20 09:06:00 +0900608 // Functionality common to Module and Import.
609 embeddableInModuleAndImport
610
Colin Crossfabb6082018-02-20 17:22:23 -0800611 properties AARImportProperties
612
Colin Cross66f78822018-05-02 12:58:28 -0700613 classpathFile android.WritablePath
614 proguardFlags android.WritablePath
615 exportPackage android.WritablePath
616 extraAaptPackagesFile android.WritablePath
Colin Cross10f7c4a2018-05-23 10:59:28 -0700617 manifest android.WritablePath
Colin Cross66f78822018-05-02 12:58:28 -0700618
619 exportedStaticPackages android.Paths
Colin Cross56a83212020-09-15 18:30:11 -0700620
621 hideApexVariantFromMake bool
Saeid Farivar Asanjanf0436962020-10-05 19:09:09 +0000622
623 aarPath android.Path
Jiyong Parkdbd710c2021-04-02 08:45:46 +0900624
625 sdkVersion android.SdkSpec
626 minSdkVersion android.SdkSpec
Saeid Farivar Asanjanf0436962020-10-05 19:09:09 +0000627}
628
629var _ android.OutputFileProducer = (*AARImport)(nil)
630
631// For OutputFileProducer interface
632func (a *AARImport) OutputFiles(tag string) (android.Paths, error) {
633 switch tag {
634 case ".aar":
635 return []android.Path{a.aarPath}, nil
636 case "":
637 return []android.Path{a.classpathFile}, nil
638 default:
639 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
640 }
Colin Crossfabb6082018-02-20 17:22:23 -0800641}
642
Jiyong Parkdbd710c2021-04-02 08:45:46 +0900643func (a *AARImport) SdkVersion(ctx android.EarlyModuleContext) android.SdkSpec {
644 return android.SdkSpecFrom(ctx, String(a.properties.Sdk_version))
Colin Cross83bb3162018-06-25 15:48:06 -0700645}
646
Jiyong Parkf1691d22021-03-29 20:11:58 +0900647func (a *AARImport) SystemModules() string {
Paul Duffine25c6442019-10-11 13:50:28 +0100648 return ""
649}
650
Jiyong Parkdbd710c2021-04-02 08:45:46 +0900651func (a *AARImport) MinSdkVersion(ctx android.EarlyModuleContext) android.SdkSpec {
Colin Cross479884c2018-07-10 13:39:30 -0700652 if a.properties.Min_sdk_version != nil {
Jiyong Parkdbd710c2021-04-02 08:45:46 +0900653 return android.SdkSpecFrom(ctx, *a.properties.Min_sdk_version)
Colin Cross479884c2018-07-10 13:39:30 -0700654 }
Jiyong Parkdbd710c2021-04-02 08:45:46 +0900655 return a.SdkVersion(ctx)
Colin Cross83bb3162018-06-25 15:48:06 -0700656}
657
Jiyong Parkdbd710c2021-04-02 08:45:46 +0900658func (a *AARImport) TargetSdkVersion(ctx android.EarlyModuleContext) android.SdkSpec {
659 return a.SdkVersion(ctx)
Dan Willemsen419290a2018-10-31 15:28:47 -0700660}
661
Colin Cross1e743852019-10-28 11:37:20 -0700662func (a *AARImport) javaVersion() string {
663 return ""
664}
665
Colin Crossa97c5d32018-03-28 14:58:31 -0700666var _ AndroidLibraryDependency = (*AARImport)(nil)
667
668func (a *AARImport) ExportPackage() android.Path {
669 return a.exportPackage
670}
671
Colin Cross89c31582018-04-30 15:55:11 -0700672func (a *AARImport) ExportedProguardFlagFiles() android.Paths {
673 return android.Paths{a.proguardFlags}
674}
675
Anton Hansson53c88442019-03-18 15:53:16 +0000676func (a *AARImport) ExportedRRODirs() []rroDir {
Colin Crossc1c37552019-01-31 11:42:41 -0800677 return nil
678}
679
Colin Cross66f78822018-05-02 12:58:28 -0700680func (a *AARImport) ExportedStaticPackages() android.Paths {
681 return a.exportedStaticPackages
682}
683
Colin Cross90c25c62019-04-19 16:22:57 -0700684func (a *AARImport) ExportedManifests() android.Paths {
685 return android.Paths{a.manifest}
Colin Cross31656952018-05-24 16:11:20 -0700686}
687
Jaewoong Jung6431ca72020-01-15 14:15:10 -0800688// TODO(jungjw): Decide whether we want to implement this.
689func (a *AARImport) ExportedAssets() android.OptionalPath {
690 return android.OptionalPath{}
691}
692
Jaewoong Jungc779cd42020-10-06 18:56:10 -0700693// RRO enforcement is not available on aar_import since its RRO dirs are not
694// exported.
695func (a *AARImport) SetRROEnforcedForDependent(enforce bool) {
696}
697
698// RRO enforcement is not available on aar_import since its RRO dirs are not
699// exported.
700func (a *AARImport) IsRROEnforced(ctx android.BaseModuleContext) bool {
701 return false
702}
703
Colin Crossfabb6082018-02-20 17:22:23 -0800704func (a *AARImport) Prebuilt() *android.Prebuilt {
705 return &a.prebuilt
706}
707
708func (a *AARImport) Name() string {
709 return a.prebuilt.Name(a.ModuleBase.Name())
710}
711
Jiyong Park618922e2020-01-08 13:35:43 +0900712func (a *AARImport) JacocoReportClassesFile() android.Path {
713 return nil
714}
715
Colin Crossfabb6082018-02-20 17:22:23 -0800716func (a *AARImport) DepsMutator(ctx android.BottomUpMutatorContext) {
Jeongik Cha816a23a2020-07-08 01:09:23 +0900717 if !ctx.Config().AlwaysUsePrebuiltSdks() {
Jiyong Parkf1691d22021-03-29 20:11:58 +0900718 sdkDep := decodeSdkDep(ctx, android.SdkContext(a))
Colin Crossa97c5d32018-03-28 14:58:31 -0700719 if sdkDep.useModule && sdkDep.frameworkResModule != "" {
Colin Cross42d48b72018-08-29 14:10:52 -0700720 ctx.AddVariationDependencies(nil, frameworkResTag, sdkDep.frameworkResModule)
Colin Crossfabb6082018-02-20 17:22:23 -0800721 }
722 }
Colin Crossa97c5d32018-03-28 14:58:31 -0700723
Colin Cross42d48b72018-08-29 14:10:52 -0700724 ctx.AddVariationDependencies(nil, libTag, a.properties.Libs...)
725 ctx.AddVariationDependencies(nil, staticLibTag, a.properties.Static_libs...)
Colin Crossfabb6082018-02-20 17:22:23 -0800726}
727
728// 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 -0700729// 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 -0800730var unzipAAR = pctx.AndroidStaticRule("unzipAAR",
731 blueprint.RuleParams{
Dan Willemsen304cfec2019-05-28 14:49:06 -0700732 Command: `rm -rf $outDir && mkdir -p $outDir && ` +
Colin Cross205e9112020-08-06 13:20:17 -0700733 `unzip -qoDD -d $outDir $in && rm -rf $outDir/res && touch $out && ` +
734 `${config.MergeZipsCmd} $combinedClassesJar $$(ls $outDir/classes.jar 2> /dev/null) $$(ls $outDir/libs/*.jar 2> /dev/null)`,
735 CommandDeps: []string{"${config.MergeZipsCmd}"},
Colin Crossfabb6082018-02-20 17:22:23 -0800736 },
Colin Cross205e9112020-08-06 13:20:17 -0700737 "outDir", "combinedClassesJar")
Colin Crossfabb6082018-02-20 17:22:23 -0800738
739func (a *AARImport) GenerateAndroidBuildActions(ctx android.ModuleContext) {
740 if len(a.properties.Aars) != 1 {
741 ctx.PropertyErrorf("aars", "exactly one aar is required")
742 return
743 }
744
Jiyong Parkdbd710c2021-04-02 08:45:46 +0900745 a.sdkVersion = a.SdkVersion(ctx)
746 a.minSdkVersion = a.MinSdkVersion(ctx)
747
Colin Cross56a83212020-09-15 18:30:11 -0700748 a.hideApexVariantFromMake = !ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).IsForPlatform()
749
Nan Zhang4c819fb2018-08-27 18:31:46 -0700750 aarName := ctx.ModuleName() + ".aar"
Saeid Farivar Asanjanf0436962020-10-05 19:09:09 +0000751 a.aarPath = android.PathForModuleSrc(ctx, a.properties.Aars[0])
752
Colin Cross1001a792019-03-21 22:21:39 -0700753 if Bool(a.properties.Jetifier) {
Saeid Farivar Asanjanf0436962020-10-05 19:09:09 +0000754 inputFile := a.aarPath
755 a.aarPath = android.PathForModuleOut(ctx, "jetifier", aarName)
756 TransformJetifier(ctx, a.aarPath.(android.WritablePath), inputFile)
Nan Zhang4c819fb2018-08-27 18:31:46 -0700757 }
Colin Crossfabb6082018-02-20 17:22:23 -0800758
759 extractedAARDir := android.PathForModuleOut(ctx, "aar")
Colin Cross205e9112020-08-06 13:20:17 -0700760 a.classpathFile = extractedAARDir.Join(ctx, "classes-combined.jar")
Colin Crossfabb6082018-02-20 17:22:23 -0800761 a.proguardFlags = extractedAARDir.Join(ctx, "proguard.txt")
Colin Cross10f7c4a2018-05-23 10:59:28 -0700762 a.manifest = extractedAARDir.Join(ctx, "AndroidManifest.xml")
Colin Crossfabb6082018-02-20 17:22:23 -0800763
764 ctx.Build(pctx, android.BuildParams{
765 Rule: unzipAAR,
Saeid Farivar Asanjanf0436962020-10-05 19:09:09 +0000766 Input: a.aarPath,
Colin Cross10f7c4a2018-05-23 10:59:28 -0700767 Outputs: android.WritablePaths{a.classpathFile, a.proguardFlags, a.manifest},
Colin Crossfabb6082018-02-20 17:22:23 -0800768 Description: "unzip AAR",
769 Args: map[string]string{
Colin Cross205e9112020-08-06 13:20:17 -0700770 "outDir": extractedAARDir.String(),
771 "combinedClassesJar": a.classpathFile.String(),
Colin Crossfabb6082018-02-20 17:22:23 -0800772 },
773 })
774
Colin Crossa0ba2f52019-06-22 12:59:27 -0700775 // Always set --pseudo-localize, it will be stripped out later for release
776 // builds that don't want it.
777 compileFlags := []string{"--pseudo-localize"}
Colin Crossfabb6082018-02-20 17:22:23 -0800778 compiledResDir := android.PathForModuleOut(ctx, "flat-res")
Colin Crossfabb6082018-02-20 17:22:23 -0800779 flata := compiledResDir.Join(ctx, "gen_res.flata")
Saeid Farivar Asanjanf0436962020-10-05 19:09:09 +0000780 aapt2CompileZip(ctx, flata, a.aarPath, "res", compileFlags)
Colin Crossfabb6082018-02-20 17:22:23 -0800781
782 a.exportPackage = android.PathForModuleOut(ctx, "package-res.apk")
Jiyong Parkb7c639e2019-08-19 14:56:02 +0900783 // the subdir "android" is required to be filtered by package names
784 srcJar := android.PathForModuleGen(ctx, "android", "R.srcjar")
Colin Crossfabb6082018-02-20 17:22:23 -0800785 proguardOptionsFile := android.PathForModuleGen(ctx, "proguard.options")
Colin Crossa97c5d32018-03-28 14:58:31 -0700786 rTxt := android.PathForModuleOut(ctx, "R.txt")
Colin Cross66f78822018-05-02 12:58:28 -0700787 a.extraAaptPackagesFile = android.PathForModuleOut(ctx, "extra_packages")
Colin Crossfabb6082018-02-20 17:22:23 -0800788
789 var linkDeps android.Paths
790
791 linkFlags := []string{
792 "--static-lib",
793 "--no-static-lib-packages",
794 "--auto-add-overlay",
795 }
796
Colin Cross10f7c4a2018-05-23 10:59:28 -0700797 linkFlags = append(linkFlags, "--manifest "+a.manifest.String())
798 linkDeps = append(linkDeps, a.manifest)
Colin Crossfabb6082018-02-20 17:22:23 -0800799
Ulya Trafimovich18554242020-11-03 15:55:11 +0000800 transitiveStaticLibs, staticLibManifests, staticRRODirs, transitiveAssets, libDeps, libFlags :=
Jiyong Parkf1691d22021-03-29 20:11:58 +0900801 aaptLibs(ctx, android.SdkContext(a), nil)
Colin Cross31656952018-05-24 16:11:20 -0700802
803 _ = staticLibManifests
Colin Crossc1c37552019-01-31 11:42:41 -0800804 _ = staticRRODirs
Colin Crossfabb6082018-02-20 17:22:23 -0800805
Colin Crossa97c5d32018-03-28 14:58:31 -0700806 linkDeps = append(linkDeps, libDeps...)
807 linkFlags = append(linkFlags, libFlags...)
Colin Crossfabb6082018-02-20 17:22:23 -0800808
Colin Cross66f78822018-05-02 12:58:28 -0700809 overlayRes := append(android.Paths{flata}, transitiveStaticLibs...)
Colin Crossfabb6082018-02-20 17:22:23 -0800810
Colin Cross66f78822018-05-02 12:58:28 -0700811 aapt2Link(ctx, a.exportPackage, srcJar, proguardOptionsFile, rTxt, a.extraAaptPackagesFile,
Jaewoong Jung6431ca72020-01-15 14:15:10 -0800812 linkFlags, linkDeps, nil, overlayRes, transitiveAssets, nil)
Colin Crossfabb6082018-02-20 17:22:23 -0800813
Colin Crossdcf71b22021-02-01 13:59:03 -0800814 ctx.SetProvider(JavaInfoProvider, JavaInfo{
815 HeaderJars: android.PathsIfNonNil(a.classpathFile),
816 ImplementationAndResourcesJars: android.PathsIfNonNil(a.classpathFile),
817 ImplementationJars: android.PathsIfNonNil(a.classpathFile),
818 })
819}
Colin Crossfabb6082018-02-20 17:22:23 -0800820
821func (a *AARImport) HeaderJars() android.Paths {
822 return android.Paths{a.classpathFile}
823}
824
Colin Cross331a1212018-08-15 20:40:52 -0700825func (a *AARImport) ImplementationAndResourcesJars() android.Paths {
826 return android.Paths{a.classpathFile}
827}
828
Ulyana Trafimovich5539e7b2020-06-04 14:08:17 +0000829func (a *AARImport) DexJarBuildPath() android.Path {
Colin Crossf24a22a2019-01-31 14:12:44 -0800830 return nil
831}
832
Ulya Trafimovich9f3052c2020-06-09 14:31:19 +0100833func (a *AARImport) DexJarInstallPath() android.Path {
834 return nil
835}
836
Ulya Trafimovichb23d28c2020-10-08 12:53:58 +0100837func (a *AARImport) ClassLoaderContexts() dexpreopt.ClassLoaderContextMap {
Jiyong Park1be96912018-05-28 18:02:19 +0900838 return nil
839}
840
Jiyong Park45bf82e2020-12-15 22:29:02 +0900841var _ android.ApexModule = (*AARImport)(nil)
842
843// Implements android.ApexModule
Jooyung Hanacc7bbe2020-05-20 09:06:00 +0900844func (a *AARImport) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
845 return a.depIsInSameApex(ctx, dep)
846}
847
Jiyong Park45bf82e2020-12-15 22:29:02 +0900848// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -0700849func (g *AARImport) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
850 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +0900851 return nil
852}
853
Colin Crossfabb6082018-02-20 17:22:23 -0800854var _ android.PrebuiltInterface = (*Import)(nil)
855
Colin Cross1b16b0e2019-02-12 14:41:32 -0800856// android_library_import imports an `.aar` file into the build graph as if it was built with android_library.
857//
858// This module is not suitable for installing on a device, but can be used as a `static_libs` dependency of
859// an android_app module.
Colin Crossfabb6082018-02-20 17:22:23 -0800860func AARImportFactory() android.Module {
861 module := &AARImport{}
862
863 module.AddProperties(&module.properties)
864
865 android.InitPrebuiltModule(module, &module.properties.Aars)
Jooyung Hanacc7bbe2020-05-20 09:06:00 +0900866 android.InitApexModule(module)
Colin Cross48de9a42018-10-02 13:53:33 -0700867 InitJavaModule(module, android.DeviceSupported)
Colin Crossfabb6082018-02-20 17:22:23 -0800868 return module
869}