blob: 9e714ab21b244317f41d509c68d4337f9d5b3223 [file] [log] [blame]
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001// Copyright (C) 2018 The Android Open Source Project
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
Jiyong Parkc0ec6f92020-11-19 23:00:52 +090015// package apex implements build rules for creating the APEX files which are container for
16// lower-level system components. See https://source.android.com/devices/tech/ota/apex
Jiyong Park48ca7dc2018-10-10 14:01:00 +090017package apex
18
19import (
20 "fmt"
Jiyong Park48ca7dc2018-10-10 14:01:00 +090021 "path/filepath"
Jiyong Parkab3ceb32018-10-10 14:05:29 +090022 "sort"
Jiyong Park48ca7dc2018-10-10 14:01:00 +090023 "strings"
24
Jiyong Park48ca7dc2018-10-10 14:01:00 +090025 "github.com/google/blueprint"
Alex Light778127a2019-02-27 14:19:50 -080026 "github.com/google/blueprint/bootstrap"
Jiyong Park48ca7dc2018-10-10 14:01:00 +090027 "github.com/google/blueprint/proptools"
Jaewoong Jung4b79e982020-06-01 10:45:49 -070028
29 "android/soong/android"
markchien2f59ec92020-09-02 16:23:38 +080030 "android/soong/bpf"
Jaewoong Jung4b79e982020-06-01 10:45:49 -070031 "android/soong/cc"
32 prebuilt_etc "android/soong/etc"
Jiyong Park12a719c2021-01-07 15:31:24 +090033 "android/soong/filesystem"
Jaewoong Jung4b79e982020-06-01 10:45:49 -070034 "android/soong/java"
35 "android/soong/python"
Jiyong Park99644e92020-11-17 22:21:02 +090036 "android/soong/rust"
Jaewoong Jung4b79e982020-06-01 10:45:49 -070037 "android/soong/sh"
Jiyong Park48ca7dc2018-10-10 14:01:00 +090038)
39
Jiyong Park8e6d52f2020-11-19 14:37:47 +090040func init() {
Paul Duffin667893c2021-03-09 22:34:13 +000041 registerApexBuildComponents(android.InitRegistrationContext)
42}
Jiyong Park8e6d52f2020-11-19 14:37:47 +090043
Paul Duffin667893c2021-03-09 22:34:13 +000044func registerApexBuildComponents(ctx android.RegistrationContext) {
45 ctx.RegisterModuleType("apex", BundleFactory)
46 ctx.RegisterModuleType("apex_test", testApexBundleFactory)
47 ctx.RegisterModuleType("apex_vndk", vndkApexBundleFactory)
48 ctx.RegisterModuleType("apex_defaults", defaultsFactory)
49 ctx.RegisterModuleType("prebuilt_apex", PrebuiltFactory)
50 ctx.RegisterModuleType("override_apex", overrideApexFactory)
51 ctx.RegisterModuleType("apex_set", apexSetFactory)
52
Paul Duffin5dda3e32021-05-05 14:13:27 +010053 ctx.PreArchMutators(registerPreArchMutators)
Paul Duffin667893c2021-03-09 22:34:13 +000054 ctx.PreDepsMutators(RegisterPreDepsMutators)
55 ctx.PostDepsMutators(RegisterPostDepsMutators)
Jiyong Park8e6d52f2020-11-19 14:37:47 +090056}
57
Paul Duffin5dda3e32021-05-05 14:13:27 +010058func registerPreArchMutators(ctx android.RegisterMutatorsContext) {
59 ctx.TopDown("prebuilt_apex_module_creator", prebuiltApexModuleCreatorMutator).Parallel()
60}
61
Jiyong Park8e6d52f2020-11-19 14:37:47 +090062func RegisterPreDepsMutators(ctx android.RegisterMutatorsContext) {
63 ctx.TopDown("apex_vndk", apexVndkMutator).Parallel()
64 ctx.BottomUp("apex_vndk_deps", apexVndkDepsMutator).Parallel()
65}
66
67func RegisterPostDepsMutators(ctx android.RegisterMutatorsContext) {
Paul Duffin949abc02020-12-08 10:34:30 +000068 ctx.TopDown("apex_info", apexInfoMutator).Parallel()
Jiyong Park8e6d52f2020-11-19 14:37:47 +090069 ctx.BottomUp("apex_unique", apexUniqueVariationsMutator).Parallel()
70 ctx.BottomUp("apex_test_for_deps", apexTestForDepsMutator).Parallel()
71 ctx.BottomUp("apex_test_for", apexTestForMutator).Parallel()
Paul Duffin28bf7ee2021-05-12 16:41:35 +010072 // Run mark_platform_availability before the apexMutator as the apexMutator needs to know whether
73 // it should create a platform variant.
74 ctx.BottomUp("mark_platform_availability", markPlatformAvailability).Parallel()
Jiyong Park8e6d52f2020-11-19 14:37:47 +090075 ctx.BottomUp("apex", apexMutator).Parallel()
76 ctx.BottomUp("apex_directly_in_any", apexDirectlyInAnyMutator).Parallel()
77 ctx.BottomUp("apex_flattened", apexFlattenedMutator).Parallel()
Jiyong Park8e6d52f2020-11-19 14:37:47 +090078}
79
80type apexBundleProperties struct {
Jiyong Parkc0ec6f92020-11-19 23:00:52 +090081 // Json manifest file describing meta info of this APEX bundle. Refer to
82 // system/apex/proto/apex_manifest.proto for the schema. Default: "apex_manifest.json"
Jiyong Park8e6d52f2020-11-19 14:37:47 +090083 Manifest *string `android:"path"`
84
Jiyong Parkc0ec6f92020-11-19 23:00:52 +090085 // AndroidManifest.xml file used for the zip container of this APEX bundle. If unspecified,
86 // a default one is automatically generated.
Jiyong Park8e6d52f2020-11-19 14:37:47 +090087 AndroidManifest *string `android:"path"`
88
Jiyong Parkc0ec6f92020-11-19 23:00:52 +090089 // Canonical name of this APEX bundle. Used to determine the path to the activated APEX on
90 // device (/apex/<apex_name>). If unspecified, follows the name property.
Jiyong Park8e6d52f2020-11-19 14:37:47 +090091 Apex_name *string
92
Jiyong Parkc0ec6f92020-11-19 23:00:52 +090093 // Determines the file contexts file for setting the security contexts to files in this APEX
94 // bundle. For platform APEXes, this should points to a file under /system/sepolicy Default:
95 // /system/sepolicy/apex/<module_name>_file_contexts.
Jiyong Park8e6d52f2020-11-19 14:37:47 +090096 File_contexts *string `android:"path"`
97
98 ApexNativeDependencies
99
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900100 Multilib apexMultilibProperties
101
Paul Duffin4b64ba02021-03-29 11:02:53 +0100102 // List of bootclasspath fragments that are embedded inside this APEX bundle.
103 Bootclasspath_fragments []string
104
satayev333a1732021-05-17 21:35:26 +0100105 // List of systemserverclasspath fragments that are embedded inside this APEX bundle.
106 Systemserverclasspath_fragments []string
107
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900108 // List of java libraries that are embedded inside this APEX bundle.
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900109 Java_libs []string
110
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900111 // List of prebuilt files that are embedded inside this APEX bundle.
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900112 Prebuilts []string
113
Paul Duffin3abc1742021-03-15 19:32:23 +0000114 // List of platform_compat_config files that are embedded inside this APEX bundle.
115 Compat_configs []string
116
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900117 // List of BPF programs inside this APEX bundle.
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900118 Bpfs []string
119
Jiyong Park12a719c2021-01-07 15:31:24 +0900120 // List of filesystem images that are embedded inside this APEX bundle.
121 Filesystems []string
122
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900123 // The minimum SDK version that this APEX must support at minimum. This is usually set to
124 // the SDK version that the APEX was first introduced.
125 Min_sdk_version *string
126
127 // Whether this APEX is considered updatable or not. When set to true, this will enforce
128 // additional rules for making sure that the APEX is truly updatable. To be updatable,
129 // min_sdk_version should be set as well. This will also disable the size optimizations like
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +0000130 // symlinking to the system libs. Default is true.
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900131 Updatable *bool
132
133 // Whether this APEX is installable to one of the partitions like system, vendor, etc.
134 // Default: true.
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900135 Installable *bool
136
Mohammad Samiul Islam3cd005d2020-11-26 13:32:26 +0000137 // Whether this APEX can be compressed or not. Setting this property to false means this
138 // APEX will never be compressed. When set to true, APEX will be compressed if other
139 // conditions, e.g, target device needs to support APEX compression, are also fulfilled.
140 // Default: true.
141 Compressible *bool
142
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900143 // For native libraries and binaries, use the vendor variant instead of the core (platform)
144 // variant. Default is false. DO NOT use this for APEXes that are installed to the system or
145 // system_ext partition.
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900146 Use_vendor *bool
147
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900148 // If set true, VNDK libs are considered as stable libs and are not included in this APEX.
149 // Should be only used in non-system apexes (e.g. vendor: true). Default is false.
150 Use_vndk_as_stable *bool
151
152 // List of SDKs that are used to build this APEX. A reference to an SDK should be either
153 // `name#version` or `name` which is an alias for `name#current`. If left empty,
154 // `platform#current` is implied. This value affects all modules included in this APEX. In
155 // other words, they are also built with the SDKs specified here.
156 Uses_sdks []string
157
158 // The type of APEX to build. Controls what the APEX payload is. Either 'image', 'zip' or
159 // 'both'. When set to image, contents are stored in a filesystem image inside a zip
160 // container. When set to zip, contents are stored in a zip container directly. This type is
161 // mostly for host-side debugging. When set to both, the two types are both built. Default
162 // is 'image'.
163 Payload_type *string
164
165 // The type of filesystem to use when the payload_type is 'image'. Either 'ext4' or 'f2fs'.
166 // Default 'ext4'.
167 Payload_fs_type *string
168
169 // For telling the APEX to ignore special handling for system libraries such as bionic.
170 // Default is false.
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900171 Ignore_system_library_special_case *bool
172
Nikita Ioffe9d9960f2021-06-09 19:43:46 +0100173 // Whenever apex_payload.img of the APEX should include dm-verity hashtree.
174 // Default value is false.
175 // TODO(b/190621617): change default value to true.
176 Generate_hashtree *bool
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900177
178 // Whenever apex_payload.img of the APEX should not be dm-verity signed. Should be only
179 // used in tests.
180 Test_only_unsigned_payload *bool
181
Mohammad Samiul Islama8008f92020-12-22 10:47:50 +0000182 // Whenever apex should be compressed, regardless of product flag used. Should be only
183 // used in tests.
184 Test_only_force_compression *bool
185
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900186 IsCoverageVariant bool `blueprint:"mutated"`
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900187
188 // List of sanitizer names that this APEX is enabled for
189 SanitizerNames []string `blueprint:"mutated"`
190
191 PreventInstall bool `blueprint:"mutated"`
192
193 HideFromMake bool `blueprint:"mutated"`
194
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900195 // Internal package method for this APEX. When payload_type is image, this can be either
196 // imageApex or flattenedApex depending on Config.FlattenApex(). When payload_type is zip,
197 // this becomes zipApex.
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900198 ApexType apexPackaging `blueprint:"mutated"`
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900199}
200
201type ApexNativeDependencies struct {
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900202 // List of native libraries that are embedded inside this APEX.
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900203 Native_shared_libs []string
204
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900205 // List of JNI libraries that are embedded inside this APEX.
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900206 Jni_libs []string
207
Jiyong Park99644e92020-11-17 22:21:02 +0900208 // List of rust dyn libraries
209 Rust_dyn_libs []string
210
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900211 // List of native executables that are embedded inside this APEX.
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900212 Binaries []string
213
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900214 // List of native tests that are embedded inside this APEX.
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900215 Tests []string
Jiyong Park06711462021-02-15 17:54:43 +0900216
217 // List of filesystem images that are embedded inside this APEX bundle.
218 Filesystems []string
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900219}
220
221type apexMultilibProperties struct {
222 // Native dependencies whose compile_multilib is "first"
223 First ApexNativeDependencies
224
225 // Native dependencies whose compile_multilib is "both"
226 Both ApexNativeDependencies
227
228 // Native dependencies whose compile_multilib is "prefer32"
229 Prefer32 ApexNativeDependencies
230
231 // Native dependencies whose compile_multilib is "32"
232 Lib32 ApexNativeDependencies
233
234 // Native dependencies whose compile_multilib is "64"
235 Lib64 ApexNativeDependencies
236}
237
238type apexTargetBundleProperties struct {
239 Target struct {
240 // Multilib properties only for android.
241 Android struct {
242 Multilib apexMultilibProperties
243 }
244
245 // Multilib properties only for host.
246 Host struct {
247 Multilib apexMultilibProperties
248 }
249
250 // Multilib properties only for host linux_bionic.
251 Linux_bionic struct {
252 Multilib apexMultilibProperties
253 }
254
255 // Multilib properties only for host linux_glibc.
256 Linux_glibc struct {
257 Multilib apexMultilibProperties
258 }
259 }
260}
261
Jiyong Park59140302020-12-14 18:44:04 +0900262type apexArchBundleProperties struct {
263 Arch struct {
264 Arm struct {
265 ApexNativeDependencies
266 }
267 Arm64 struct {
268 ApexNativeDependencies
269 }
270 X86 struct {
271 ApexNativeDependencies
272 }
273 X86_64 struct {
274 ApexNativeDependencies
275 }
276 }
277}
278
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900279// These properties can be used in override_apex to override the corresponding properties in the
280// base apex.
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900281type overridableProperties struct {
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900282 // List of APKs that are embedded inside this APEX.
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900283 Apps []string
284
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900285 // List of runtime resource overlays (RROs) that are embedded inside this APEX.
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900286 Rros []string
287
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900288 // Names of modules to be overridden. Listed modules can only be other binaries (in Make or
289 // Soong). This does not completely prevent installation of the overridden binaries, but if
290 // both binaries would be installed by default (in PRODUCT_PACKAGES) the other binary will
291 // be removed from PRODUCT_PACKAGES.
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900292 Overrides []string
293
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900294 // Logging parent value.
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900295 Logging_parent string
296
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900297 // Apex Container package name. Override value for attribute package:name in
298 // AndroidManifest.xml
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900299 Package_name string
300
301 // A txt file containing list of files that are allowed to be included in this APEX.
302 Allowed_files *string `android:"path"`
Jaewoong Jung4cfdf7d2021-04-20 16:21:24 -0700303
304 // Name of the apex_key module that provides the private key to sign this APEX bundle.
305 Key *string
306
307 // Specifies the certificate and the private key to sign the zip container of this APEX. If
308 // this is "foo", foo.x509.pem and foo.pk8 under PRODUCT_DEFAULT_DEV_CERTIFICATE are used
309 // as the certificate and the private key, respectively. If this is ":module", then the
310 // certificate and the private key are provided from the android_app_certificate module
311 // named "module".
312 Certificate *string
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900313}
314
315type apexBundle struct {
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900316 // Inherited structs
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900317 android.ModuleBase
318 android.DefaultableModuleBase
319 android.OverridableModuleBase
320 android.SdkBase
321
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900322 // Properties
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900323 properties apexBundleProperties
324 targetProperties apexTargetBundleProperties
Jiyong Park59140302020-12-14 18:44:04 +0900325 archProperties apexArchBundleProperties
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900326 overridableProperties overridableProperties
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900327 vndkProperties apexVndkProperties // only for apex_vndk modules
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900328
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900329 ///////////////////////////////////////////////////////////////////////////////////////////
330 // Inputs
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900331
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900332 // Keys for apex_paylaod.img
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800333 publicKeyFile android.Path
334 privateKeyFile android.Path
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900335
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900336 // Cert/priv-key for the zip container
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800337 containerCertificateFile android.Path
338 containerPrivateKeyFile android.Path
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900339
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900340 // Flags for special variants of APEX
341 testApex bool
342 vndkApex bool
343 artApex bool
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900344
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900345 // Tells whether this variant of the APEX bundle is the primary one or not. Only the primary
346 // one gets installed to the device.
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900347 primaryApexType bool
348
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900349 // Suffix of module name in Android.mk ".flattened", ".apex", ".zipapex", or ""
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900350 suffix string
351
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900352 // File system type of apex_payload.img
353 payloadFsType fsType
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900354
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900355 // Whether to create symlink to the system file instead of having a file inside the apex or
356 // not
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900357 linkToSystemLib bool
358
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900359 // List of files to be included in this APEX. This is filled in the first part of
360 // GenerateAndroidBuildActions.
361 filesInfo []apexFile
362
363 // List of other module names that should be installed when this APEX gets installed.
364 requiredDeps []string
365
366 ///////////////////////////////////////////////////////////////////////////////////////////
367 // Outputs (final and intermediates)
368
369 // Processed apex manifest in JSONson format (for Q)
370 manifestJsonOut android.WritablePath
371
372 // Processed apex manifest in PB format (for R+)
373 manifestPbOut android.WritablePath
374
375 // Processed file_contexts files
376 fileContexts android.WritablePath
377
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900378 // Struct holding the merged notice file paths in different formats
379 mergedNotices android.NoticeOutputs
380
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900381 // The built APEX file. This is the main product.
382 outputFile android.WritablePath
383
384 // The built APEX file in app bundle format. This file is not directly installed to the
385 // device. For an APEX, multiple app bundles are created each of which is for a specific ABI
386 // like arm, arm64, x86, etc. Then they are processed again (outside of the Android build
387 // system) to be merged into a single app bundle file that Play accepts. See
388 // vendor/google/build/build_unbundled_mainline_module.sh for more detail.
389 bundleModuleFile android.WritablePath
390
391 // Target path to install this APEX. Usually out/target/product/<device>/<partition>/apex.
392 installDir android.InstallPath
393
394 // List of commands to create symlinks for backward compatibility. These commands will be
395 // attached as LOCAL_POST_INSTALL_CMD to apex package itself (for unflattened build) or
396 // apex_manifest (for flattened build) so that compat symlinks are always installed
397 // regardless of TARGET_FLATTEN_APEX setting.
398 compatSymlinks []string
399
400 // Text file having the list of individual files that are included in this APEX. Used for
401 // debugging purpose.
402 installedFilesFile android.WritablePath
403
404 // List of module names that this APEX is including (to be shown via *-deps-info target).
405 // Used for debugging purpose.
406 android.ApexBundleDepsInfo
407
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900408 // Optional list of lint report zip files for apexes that contain java or app modules
409 lintReports android.Paths
410
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900411 prebuiltFileToDelete string
sophiezc80a2b32020-11-12 16:39:19 +0000412
Mohammad Samiul Islam3cd005d2020-11-26 13:32:26 +0000413 isCompressed bool
414
sophiezc80a2b32020-11-12 16:39:19 +0000415 // Path of API coverage generate file
sophiez6bde0b52021-01-09 01:03:42 +0000416 apisUsedByModuleFile android.ModuleOutPath
417 apisBackedByModuleFile android.ModuleOutPath
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900418}
419
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900420// apexFileClass represents a type of file that can be included in APEX.
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900421type apexFileClass int
422
Jooyung Han72bd2f82019-10-23 16:46:38 +0900423const (
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900424 app apexFileClass = iota
425 appSet
426 etc
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900427 goBinary
428 javaSharedLib
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900429 nativeExecutable
430 nativeSharedLib
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900431 nativeTest
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900432 pyBinary
433 shBinary
Jooyung Han72bd2f82019-10-23 16:46:38 +0900434)
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900435
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900436// apexFile represents a file in an APEX bundle. This is created during the first half of
437// GenerateAndroidBuildActions by traversing the dependencies of the APEX. Then in the second half
438// of the function, this is used to create commands that copies the files into a staging directory,
439// where they are packaged into the APEX file. This struct is also used for creating Make modules
440// for each of the files in case when the APEX is flattened.
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900441type apexFile struct {
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900442 // buildFile is put in the installDir inside the APEX.
443 builtFile android.Path
444 noticeFiles android.Paths
445 installDir string
446 customStem string
447 symlinks []string // additional symlinks
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900448
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900449 // Info for Android.mk Module name of `module` in AndroidMk. Note the generated AndroidMk
450 // module for apexFile is named something like <AndroidMk module name>.<apex name>[<apex
451 // suffix>]
452 androidMkModuleName string // becomes LOCAL_MODULE
453 class apexFileClass // becomes LOCAL_MODULE_CLASS
454 moduleDir string // becomes LOCAL_PATH
455 requiredModuleNames []string // becomes LOCAL_REQUIRED_MODULES
456 targetRequiredModuleNames []string // becomes LOCAL_TARGET_REQUIRED_MODULES
457 hostRequiredModuleNames []string // becomes LOCAL_HOST_REQUIRED_MODULES
458 dataPaths []android.DataPath // becomes LOCAL_TEST_DATA
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900459
460 jacocoReportClassesFile android.Path // only for javalibs and apps
461 lintDepSets java.LintDepSets // only for javalibs and apps
462 certificate java.Certificate // only for apps
463 overriddenPackageName string // only for apps
464
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900465 transitiveDep bool
466 isJniLib bool
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900467
Jiyong Park57621b22021-01-20 20:33:11 +0900468 multilib string
469
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900470 // TODO(jiyong): remove this
471 module android.Module
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900472}
473
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900474// TODO(jiyong): shorten the arglist using an option struct
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900475func newApexFile(ctx android.BaseModuleContext, builtFile android.Path, androidMkModuleName string, installDir string, class apexFileClass, module android.Module) apexFile {
476 ret := apexFile{
477 builtFile: builtFile,
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900478 installDir: installDir,
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900479 androidMkModuleName: androidMkModuleName,
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900480 class: class,
481 module: module,
482 }
483 if module != nil {
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900484 ret.noticeFiles = module.NoticeFiles()
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900485 ret.moduleDir = ctx.OtherModuleDir(module)
486 ret.requiredModuleNames = module.RequiredModuleNames()
487 ret.targetRequiredModuleNames = module.TargetRequiredModuleNames()
488 ret.hostRequiredModuleNames = module.HostRequiredModuleNames()
Jiyong Park57621b22021-01-20 20:33:11 +0900489 ret.multilib = module.Target().Arch.ArchType.Multilib
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900490 }
491 return ret
492}
493
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900494func (af *apexFile) ok() bool {
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900495 return af.builtFile != nil && af.builtFile.String() != ""
496}
497
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900498// apexRelativePath returns the relative path of the given path from the install directory of this
499// apexFile.
500// TODO(jiyong): rename this
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900501func (af *apexFile) apexRelativePath(path string) string {
502 return filepath.Join(af.installDir, path)
503}
504
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900505// path returns path of this apex file relative to the APEX root
506func (af *apexFile) path() string {
507 return af.apexRelativePath(af.stem())
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900508}
509
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900510// stem returns the base filename of this apex file
511func (af *apexFile) stem() string {
512 if af.customStem != "" {
513 return af.customStem
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900514 }
515 return af.builtFile.Base()
516}
517
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900518// symlinkPaths returns paths of the symlinks (if any) relative to the APEX root
519func (af *apexFile) symlinkPaths() []string {
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900520 var ret []string
521 for _, symlink := range af.symlinks {
522 ret = append(ret, af.apexRelativePath(symlink))
523 }
524 return ret
525}
526
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900527// availableToPlatform tests whether this apexFile is from a module that can be installed to the
528// platform.
529func (af *apexFile) availableToPlatform() bool {
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900530 if af.module == nil {
531 return false
532 }
533 if am, ok := af.module.(android.ApexModule); ok {
534 return am.AvailableFor(android.AvailableToPlatform)
535 }
536 return false
537}
538
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900539////////////////////////////////////////////////////////////////////////////////////////////////////
540// Mutators
541//
542// Brief description about mutators for APEX. The following three mutators are the most important
543// ones.
544//
545// 1) DepsMutator: from the properties like native_shared_libs, java_libs, etc., modules are added
546// to the (direct) dependencies of this APEX bundle.
547//
Paul Duffin949abc02020-12-08 10:34:30 +0000548// 2) apexInfoMutator: this is a post-deps mutator, so runs after DepsMutator. Its goal is to
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900549// collect modules that are direct and transitive dependencies of each APEX bundle. The collected
550// modules are marked as being included in the APEX via BuildForApex().
551//
Paul Duffin949abc02020-12-08 10:34:30 +0000552// 3) apexMutator: this is a post-deps mutator that runs after apexInfoMutator. For each module that
553// are marked by the apexInfoMutator, apex variations are created using CreateApexVariations().
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900554
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900555type dependencyTag struct {
556 blueprint.BaseDependencyTag
557 name string
558
559 // Determines if the dependent will be part of the APEX payload. Can be false for the
560 // dependencies to the signing key module, etc.
561 payload bool
Paul Duffin8c535da2021-03-17 14:51:03 +0000562
563 // True if the dependent can only be a source module, false if a prebuilt module is a suitable
564 // replacement. This is needed because some prebuilt modules do not provide all the information
565 // needed by the apex.
566 sourceOnly bool
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900567}
568
Paul Duffin8c535da2021-03-17 14:51:03 +0000569func (d dependencyTag) ReplaceSourceWithPrebuilt() bool {
570 return !d.sourceOnly
571}
572
573var _ android.ReplaceSourceWithPrebuilt = &dependencyTag{}
574
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900575var (
Paul Duffin0b817782021-03-17 15:02:19 +0000576 androidAppTag = dependencyTag{name: "androidApp", payload: true}
577 bpfTag = dependencyTag{name: "bpf", payload: true}
578 certificateTag = dependencyTag{name: "certificate"}
579 executableTag = dependencyTag{name: "executable", payload: true}
580 fsTag = dependencyTag{name: "filesystem", payload: true}
Paul Duffin94f19632021-04-20 12:40:07 +0100581 bcpfTag = dependencyTag{name: "bootclasspathFragment", payload: true, sourceOnly: true}
satayev333a1732021-05-17 21:35:26 +0100582 sscpfTag = dependencyTag{name: "systemserverclasspathFragment", payload: true, sourceOnly: true}
Paul Duffin1b29e002021-03-16 15:06:54 +0000583 compatConfigTag = dependencyTag{name: "compatConfig", payload: true, sourceOnly: true}
Paul Duffin0b817782021-03-17 15:02:19 +0000584 javaLibTag = dependencyTag{name: "javaLib", payload: true}
585 jniLibTag = dependencyTag{name: "jniLib", payload: true}
586 keyTag = dependencyTag{name: "key"}
587 prebuiltTag = dependencyTag{name: "prebuilt", payload: true}
588 rroTag = dependencyTag{name: "rro", payload: true}
589 sharedLibTag = dependencyTag{name: "sharedLib", payload: true}
590 testForTag = dependencyTag{name: "test for"}
591 testTag = dependencyTag{name: "test", payload: true}
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900592)
593
594// TODO(jiyong): shorten this function signature
595func addDependenciesForNativeModules(ctx android.BottomUpMutatorContext, nativeModules ApexNativeDependencies, target android.Target, imageVariation string) {
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900596 binVariations := target.Variations()
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900597 libVariations := append(target.Variations(), blueprint.Variation{Mutator: "link", Variation: "shared"})
Jiyong Park99644e92020-11-17 22:21:02 +0900598 rustLibVariations := append(target.Variations(), blueprint.Variation{Mutator: "rust_libraries", Variation: "dylib"})
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900599
600 if ctx.Device() {
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900601 binVariations = append(binVariations, blueprint.Variation{Mutator: "image", Variation: imageVariation})
Jiyong Parkf2cc1b72020-12-09 00:20:45 +0900602 libVariations = append(libVariations, blueprint.Variation{Mutator: "image", Variation: imageVariation})
603 rustLibVariations = append(rustLibVariations, blueprint.Variation{Mutator: "image", Variation: imageVariation})
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900604 }
605
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900606 // Use *FarVariation* to be able to depend on modules having conflicting variations with
607 // this module. This is required since arch variant of an APEX bundle is 'common' but it is
608 // 'arm' or 'arm64' for native shared libs.
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900609 ctx.AddFarVariationDependencies(binVariations, executableTag, nativeModules.Binaries...)
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900610 ctx.AddFarVariationDependencies(binVariations, testTag, nativeModules.Tests...)
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900611 ctx.AddFarVariationDependencies(libVariations, jniLibTag, nativeModules.Jni_libs...)
612 ctx.AddFarVariationDependencies(libVariations, sharedLibTag, nativeModules.Native_shared_libs...)
Jiyong Park99644e92020-11-17 22:21:02 +0900613 ctx.AddFarVariationDependencies(rustLibVariations, sharedLibTag, nativeModules.Rust_dyn_libs...)
Jiyong Park06711462021-02-15 17:54:43 +0900614 ctx.AddFarVariationDependencies(target.Variations(), fsTag, nativeModules.Filesystems...)
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900615}
616
617func (a *apexBundle) combineProperties(ctx android.BottomUpMutatorContext) {
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900618 if ctx.Device() {
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900619 proptools.AppendProperties(&a.properties.Multilib, &a.targetProperties.Target.Android.Multilib, nil)
620 } else {
621 proptools.AppendProperties(&a.properties.Multilib, &a.targetProperties.Target.Host.Multilib, nil)
622 if ctx.Os().Bionic() {
623 proptools.AppendProperties(&a.properties.Multilib, &a.targetProperties.Target.Linux_bionic.Multilib, nil)
624 } else {
625 proptools.AppendProperties(&a.properties.Multilib, &a.targetProperties.Target.Linux_glibc.Multilib, nil)
626 }
627 }
628}
629
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900630// getImageVariation returns the image variant name for this apexBundle. In most cases, it's simply
631// android.CoreVariation, but gets complicated for the vendor APEXes and the VNDK APEX.
632func (a *apexBundle) getImageVariation(ctx android.BottomUpMutatorContext) string {
633 deviceConfig := ctx.DeviceConfig()
634 if a.vndkApex {
635 return cc.VendorVariationPrefix + a.vndkVersion(deviceConfig)
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900636 }
637
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900638 var prefix string
639 var vndkVersion string
640 if deviceConfig.VndkVersion() != "" {
641 if proptools.Bool(a.properties.Use_vendor) {
642 prefix = cc.VendorVariationPrefix
643 vndkVersion = deviceConfig.PlatformVndkVersion()
644 } else if a.SocSpecific() || a.DeviceSpecific() {
645 prefix = cc.VendorVariationPrefix
646 vndkVersion = deviceConfig.VndkVersion()
647 } else if a.ProductSpecific() {
648 prefix = cc.ProductVariationPrefix
649 vndkVersion = deviceConfig.ProductVndkVersion()
650 }
651 }
652 if vndkVersion == "current" {
653 vndkVersion = deviceConfig.PlatformVndkVersion()
654 }
655 if vndkVersion != "" {
656 return prefix + vndkVersion
657 }
658
659 return android.CoreVariation // The usual case
660}
661
662func (a *apexBundle) DepsMutator(ctx android.BottomUpMutatorContext) {
663 // TODO(jiyong): move this kind of checks to GenerateAndroidBuildActions?
664 checkUseVendorProperty(ctx, a)
665
666 // apexBundle is a multi-arch targets module. Arch variant of apexBundle is set to 'common'.
667 // arch-specific targets are enabled by the compile_multilib setting of the apex bundle. For
668 // each target os/architectures, appropriate dependencies are selected by their
669 // target.<os>.multilib.<type> groups and are added as (direct) dependencies.
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900670 targets := ctx.MultiTargets()
671 config := ctx.DeviceConfig()
672 imageVariation := a.getImageVariation(ctx)
673
674 a.combineProperties(ctx)
675
676 has32BitTarget := false
677 for _, target := range targets {
678 if target.Arch.ArchType.Multilib == "lib32" {
679 has32BitTarget = true
Paul Duffin7d74e7b2020-03-06 12:30:13 +0000680 }
681 }
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900682 for i, target := range targets {
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900683 // Don't include artifacts for the host cross targets because there is no way for us
684 // to run those artifacts natively on host
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900685 if target.HostCross {
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900686 continue
687 }
Paul Duffin7d74e7b2020-03-06 12:30:13 +0000688
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900689 var depsList []ApexNativeDependencies
Paul Duffin7d74e7b2020-03-06 12:30:13 +0000690
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900691 // Add native modules targeting both ABIs. When multilib.* is omitted for
692 // native_shared_libs/jni_libs/tests, it implies multilib.both
693 depsList = append(depsList, a.properties.Multilib.Both)
694 depsList = append(depsList, ApexNativeDependencies{
695 Native_shared_libs: a.properties.Native_shared_libs,
696 Tests: a.properties.Tests,
697 Jni_libs: a.properties.Jni_libs,
698 Binaries: nil,
699 })
Jooyung Hanacc7bbe2020-05-20 09:06:00 +0900700
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900701 // Add native modules targeting the first ABI When multilib.* is omitted for
702 // binaries, it implies multilib.first
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900703 isPrimaryAbi := i == 0
704 if isPrimaryAbi {
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900705 depsList = append(depsList, a.properties.Multilib.First)
706 depsList = append(depsList, ApexNativeDependencies{
707 Native_shared_libs: nil,
708 Tests: nil,
709 Jni_libs: nil,
710 Binaries: a.properties.Binaries,
711 })
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900712 }
713
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900714 // Add native modules targeting either 32-bit or 64-bit ABI
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900715 switch target.Arch.ArchType.Multilib {
716 case "lib32":
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900717 depsList = append(depsList, a.properties.Multilib.Lib32)
718 depsList = append(depsList, a.properties.Multilib.Prefer32)
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900719 case "lib64":
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900720 depsList = append(depsList, a.properties.Multilib.Lib64)
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900721 if !has32BitTarget {
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900722 depsList = append(depsList, a.properties.Multilib.Prefer32)
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900723 }
724 }
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900725
Jiyong Park59140302020-12-14 18:44:04 +0900726 // Add native modules targeting a specific arch variant
727 switch target.Arch.ArchType {
728 case android.Arm:
729 depsList = append(depsList, a.archProperties.Arch.Arm.ApexNativeDependencies)
730 case android.Arm64:
731 depsList = append(depsList, a.archProperties.Arch.Arm64.ApexNativeDependencies)
732 case android.X86:
733 depsList = append(depsList, a.archProperties.Arch.X86.ApexNativeDependencies)
734 case android.X86_64:
735 depsList = append(depsList, a.archProperties.Arch.X86_64.ApexNativeDependencies)
736 default:
737 panic(fmt.Errorf("unsupported arch %v\n", ctx.Arch().ArchType))
738 }
739
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900740 for _, d := range depsList {
741 addDependenciesForNativeModules(ctx, d, target, imageVariation)
742 }
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900743 }
744
Martin Stjernholmdf298b32021-05-21 20:57:29 +0100745 if prebuilts := a.properties.Prebuilts; len(prebuilts) > 0 {
746 // For prebuilt_etc, use the first variant (64 on 64/32bit device, 32 on 32bit device)
747 // regardless of the TARGET_PREFER_* setting. See b/144532908
748 archForPrebuiltEtc := config.Arches()[0]
749 for _, arch := range config.Arches() {
750 // Prefer 64-bit arch if there is any
751 if arch.ArchType.Multilib == "lib64" {
752 archForPrebuiltEtc = arch
753 break
754 }
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900755 }
Martin Stjernholmdf298b32021-05-21 20:57:29 +0100756 ctx.AddFarVariationDependencies([]blueprint.Variation{
757 {Mutator: "os", Variation: ctx.Os().String()},
758 {Mutator: "arch", Variation: archForPrebuiltEtc.String()},
759 }, prebuiltTag, prebuilts...)
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900760 }
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900761
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900762 // Common-arch dependencies come next
763 commonVariation := ctx.Config().AndroidCommonTarget.Variations()
Paul Duffin94f19632021-04-20 12:40:07 +0100764 ctx.AddFarVariationDependencies(commonVariation, bcpfTag, a.properties.Bootclasspath_fragments...)
satayev333a1732021-05-17 21:35:26 +0100765 ctx.AddFarVariationDependencies(commonVariation, sscpfTag, a.properties.Systemserverclasspath_fragments...)
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900766 ctx.AddFarVariationDependencies(commonVariation, javaLibTag, a.properties.Java_libs...)
767 ctx.AddFarVariationDependencies(commonVariation, bpfTag, a.properties.Bpfs...)
Jiyong Park12a719c2021-01-07 15:31:24 +0900768 ctx.AddFarVariationDependencies(commonVariation, fsTag, a.properties.Filesystems...)
Paul Duffin0b817782021-03-17 15:02:19 +0000769 ctx.AddFarVariationDependencies(commonVariation, compatConfigTag, a.properties.Compat_configs...)
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900770
Ulya Trafimovicha4a1c4e2021-01-15 18:40:04 +0000771 if a.artApex {
772 // With EMMA_INSTRUMENT_FRAMEWORK=true the ART boot image includes jacoco library.
773 if ctx.Config().IsEnvTrue("EMMA_INSTRUMENT_FRAMEWORK") {
774 ctx.AddFarVariationDependencies(commonVariation, javaLibTag, "jacocoagent")
775 }
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900776 }
777
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900778 // Marks that this APEX (in fact all the modules in it) has to be built with the given SDKs.
779 // This field currently isn't used.
780 // TODO(jiyong): consider dropping this feature
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900781 // TODO(jiyong): ensure that all apexes are with non-empty uses_sdks
782 if len(a.properties.Uses_sdks) > 0 {
783 sdkRefs := []android.SdkRef{}
784 for _, str := range a.properties.Uses_sdks {
785 parsed := android.ParseSdkRef(ctx, str, "uses_sdks")
786 sdkRefs = append(sdkRefs, parsed)
787 }
788 a.BuildWithSdks(sdkRefs)
Andrei Onea115e7e72020-06-05 21:14:03 +0100789 }
790}
791
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900792// DepsMutator for the overridden properties.
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900793func (a *apexBundle) OverridablePropertiesDepsMutator(ctx android.BottomUpMutatorContext) {
794 if a.overridableProperties.Allowed_files != nil {
795 android.ExtractSourceDeps(ctx, a.overridableProperties.Allowed_files)
Andrei Onea115e7e72020-06-05 21:14:03 +0100796 }
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900797
798 commonVariation := ctx.Config().AndroidCommonTarget.Variations()
799 ctx.AddFarVariationDependencies(commonVariation, androidAppTag, a.overridableProperties.Apps...)
800 ctx.AddFarVariationDependencies(commonVariation, rroTag, a.overridableProperties.Rros...)
Jaewoong Jung4cfdf7d2021-04-20 16:21:24 -0700801
802 // Dependencies for signing
803 if String(a.overridableProperties.Key) == "" {
804 ctx.PropertyErrorf("key", "missing")
805 return
806 }
807 ctx.AddDependency(ctx.Module(), keyTag, String(a.overridableProperties.Key))
808
809 cert := android.SrcIsModule(a.getCertString(ctx))
810 if cert != "" {
811 ctx.AddDependency(ctx.Module(), certificateTag, cert)
812 // empty cert is not an error. Cert and private keys will be directly found under
813 // PRODUCT_DEFAULT_DEV_CERTIFICATE
814 }
Andrei Onea115e7e72020-06-05 21:14:03 +0100815}
816
Jiyong Park8e6d52f2020-11-19 14:37:47 +0900817type ApexBundleInfo struct {
818 Contents *android.ApexContents
Andrei Onea115e7e72020-06-05 21:14:03 +0100819}
820
Paul Duffin949abc02020-12-08 10:34:30 +0000821var ApexBundleInfoProvider = blueprint.NewMutatorProvider(ApexBundleInfo{}, "apex_info")
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900822
Paul Duffina7d6a892020-12-07 17:39:59 +0000823var _ ApexInfoMutator = (*apexBundle)(nil)
824
825// ApexInfoMutator is responsible for collecting modules that need to have apex variants. They are
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900826// identified by doing a graph walk starting from an apexBundle. Basically, all the (direct and
827// indirect) dependencies are collected. But a few types of modules that shouldn't be included in
828// the apexBundle (e.g. stub libraries) are not collected. Note that a single module can be depended
829// on by multiple apexBundles. In that case, the module is collected for all of the apexBundles.
Paul Duffin949abc02020-12-08 10:34:30 +0000830//
831// For each dependency between an apex and an ApexModule an ApexInfo object describing the apex
832// is passed to that module's BuildForApex(ApexInfo) method which collates them all in a list.
833// The apexMutator uses that list to create module variants for the apexes to which it belongs.
834// The relationship between module variants and apexes is not one-to-one as variants will be
835// shared between compatible apexes.
Paul Duffina7d6a892020-12-07 17:39:59 +0000836func (a *apexBundle) ApexInfoMutator(mctx android.TopDownMutatorContext) {
Jooyung Handf78e212020-07-22 15:54:47 +0900837
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900838 // The VNDK APEX is special. For the APEX, the membership is described in a very different
839 // way. There is no dependency from the VNDK APEX to the VNDK libraries. Instead, VNDK
840 // libraries are self-identified by their vndk.enabled properties. There is no need to run
841 // this mutator for the APEX as nothing will be collected. So, let's return fast.
842 if a.vndkApex {
843 return
844 }
845
846 // Special casing for APEXes on non-system (e.g., vendor, odm, etc.) partitions. They are
847 // provided with a property named use_vndk_as_stable, which when set to true doesn't collect
848 // VNDK libraries as transitive dependencies. This option is useful for reducing the size of
849 // the non-system APEXes because the VNDK libraries won't be included (and duped) in the
850 // APEX, but shared across APEXes via the VNDK APEX.
Jooyung Handf78e212020-07-22 15:54:47 +0900851 useVndk := a.SocSpecific() || a.DeviceSpecific() || (a.ProductSpecific() && mctx.Config().EnforceProductPartitionInterface())
852 excludeVndkLibs := useVndk && proptools.Bool(a.properties.Use_vndk_as_stable)
853 if !useVndk && proptools.Bool(a.properties.Use_vndk_as_stable) {
854 mctx.PropertyErrorf("use_vndk_as_stable", "not supported for system/system_ext APEXes")
855 return
856 }
857
Colin Cross56a83212020-09-15 18:30:11 -0700858 continueApexDepsWalk := func(child, parent android.Module) bool {
Jooyung Han698dd9f2020-07-22 15:17:19 +0900859 am, ok := child.(android.ApexModule)
860 if !ok || !am.CanHaveApexVariants() {
861 return false
Jiyong Parkf760cae2020-02-12 07:53:12 +0900862 }
Paul Duffin573989d2021-03-17 13:25:29 +0000863 depTag := mctx.OtherModuleDependencyTag(child)
864
865 // Check to see if the tag always requires that the child module has an apex variant for every
866 // apex variant of the parent module. If it does not then it is still possible for something
867 // else, e.g. the DepIsInSameApex(...) method to decide that a variant is required.
868 if required, ok := depTag.(android.AlwaysRequireApexVariantTag); ok && required.AlwaysRequireApexVariant() {
869 return true
870 }
Paul Duffin4c3e8e22021-03-18 15:41:29 +0000871 if !android.IsDepInSameApex(mctx, parent, child) {
Jooyung Han698dd9f2020-07-22 15:17:19 +0900872 return false
873 }
Jooyung Handf78e212020-07-22 15:54:47 +0900874 if excludeVndkLibs {
875 if c, ok := child.(*cc.Module); ok && c.IsVndk() {
876 return false
877 }
878 }
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900879 // By default, all the transitive dependencies are collected, unless filtered out
880 // above.
Colin Cross56a83212020-09-15 18:30:11 -0700881 return true
882 }
883
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900884 // Records whether a certain module is included in this apexBundle via direct dependency or
885 // inndirect dependency.
886 contents := make(map[string]android.ApexMembership)
Colin Cross56a83212020-09-15 18:30:11 -0700887 mctx.WalkDeps(func(child, parent android.Module) bool {
888 if !continueApexDepsWalk(child, parent) {
889 return false
890 }
Jooyung Han698dd9f2020-07-22 15:17:19 +0900891 // If the parent is apexBundle, this child is directly depended.
892 _, directDep := parent.(*apexBundle)
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900893 depName := mctx.OtherModuleName(child)
Colin Cross56a83212020-09-15 18:30:11 -0700894 contents[depName] = contents[depName].Add(directDep)
895 return true
896 })
897
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900898 // The membership information is saved for later access
Jiyong Parke4758ed2020-11-18 01:34:22 +0900899 apexContents := android.NewApexContents(contents)
Colin Cross56a83212020-09-15 18:30:11 -0700900 mctx.SetProvider(ApexBundleInfoProvider, ApexBundleInfo{
901 Contents: apexContents,
902 })
903
Jooyung Haned124c32021-01-26 11:43:46 +0900904 minSdkVersion := a.minSdkVersion(mctx)
905 // When min_sdk_version is not set, the apex is built against FutureApiLevel.
906 if minSdkVersion.IsNone() {
907 minSdkVersion = android.FutureApiLevel
908 }
909
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900910 // This is the main part of this mutator. Mark the collected dependencies that they need to
911 // be built for this apexBundle.
Jiyong Park78349b52021-05-12 17:13:56 +0900912
913 // Note that there are many different names.
914 // ApexVariationName: this is the name of the apex variation
Colin Cross56a83212020-09-15 18:30:11 -0700915 apexInfo := android.ApexInfo{
Jiyong Park78349b52021-05-12 17:13:56 +0900916 ApexVariationName: mctx.ModuleName(), // could be com.android.foo
Jiyong Park4eab21d2021-04-15 15:17:54 +0900917 MinSdkVersion: minSdkVersion,
Colin Cross56a83212020-09-15 18:30:11 -0700918 RequiredSdks: a.RequiredSdks(),
919 Updatable: a.Updatable(),
Jiyong Park78349b52021-05-12 17:13:56 +0900920 InApexVariants: []string{mctx.ModuleName()}, // could be com.android.foo
921 InApexModules: []string{a.Name()}, // could be com.mycompany.android.foo
Colin Cross56a83212020-09-15 18:30:11 -0700922 ApexContents: []*android.ApexContents{apexContents},
923 }
Colin Cross56a83212020-09-15 18:30:11 -0700924 mctx.WalkDeps(func(child, parent android.Module) bool {
925 if !continueApexDepsWalk(child, parent) {
926 return false
927 }
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900928 child.(android.ApexModule).BuildForApex(apexInfo) // leave a mark!
Jooyung Han698dd9f2020-07-22 15:17:19 +0900929 return true
Jiyong Parkf760cae2020-02-12 07:53:12 +0900930 })
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900931}
932
Paul Duffina7d6a892020-12-07 17:39:59 +0000933type ApexInfoMutator interface {
934 // ApexInfoMutator implementations must call BuildForApex(ApexInfo) on any modules that are
935 // depended upon by an apex and which require an apex specific variant.
936 ApexInfoMutator(android.TopDownMutatorContext)
937}
938
939// apexInfoMutator delegates the work of identifying which modules need an ApexInfo and apex
940// specific variant to modules that support the ApexInfoMutator.
941func apexInfoMutator(mctx android.TopDownMutatorContext) {
942 if !mctx.Module().Enabled() {
943 return
944 }
945
946 if a, ok := mctx.Module().(ApexInfoMutator); ok {
947 a.ApexInfoMutator(mctx)
948 return
949 }
950}
951
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900952// apexUniqueVariationsMutator checks if any dependencies use unique apex variations. If so, use
953// unique apex variations for this module. See android/apex.go for more about unique apex variant.
954// TODO(jiyong): move this to android/apex.go?
Colin Crossaede88c2020-08-11 12:17:01 -0700955func apexUniqueVariationsMutator(mctx android.BottomUpMutatorContext) {
956 if !mctx.Module().Enabled() {
957 return
958 }
959 if am, ok := mctx.Module().(android.ApexModule); ok {
Colin Cross56a83212020-09-15 18:30:11 -0700960 android.UpdateUniqueApexVariationsForDeps(mctx, am)
961 }
962}
963
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900964// apexTestForDepsMutator checks if this module is a test for an apex. If so, add a dependency on
965// the apex in order to retrieve its contents later.
966// TODO(jiyong): move this to android/apex.go?
Colin Cross56a83212020-09-15 18:30:11 -0700967func apexTestForDepsMutator(mctx android.BottomUpMutatorContext) {
968 if !mctx.Module().Enabled() {
969 return
970 }
Colin Cross56a83212020-09-15 18:30:11 -0700971 if am, ok := mctx.Module().(android.ApexModule); ok {
972 if testFor := am.TestFor(); len(testFor) > 0 {
973 mctx.AddFarVariationDependencies([]blueprint.Variation{
974 {Mutator: "os", Variation: am.Target().OsVariation()},
975 {"arch", "common"},
976 }, testForTag, testFor...)
977 }
978 }
979}
980
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900981// TODO(jiyong): move this to android/apex.go?
Colin Cross56a83212020-09-15 18:30:11 -0700982func apexTestForMutator(mctx android.BottomUpMutatorContext) {
983 if !mctx.Module().Enabled() {
984 return
985 }
Colin Cross56a83212020-09-15 18:30:11 -0700986 if _, ok := mctx.Module().(android.ApexModule); ok {
987 var contents []*android.ApexContents
988 for _, testFor := range mctx.GetDirectDepsWithTag(testForTag) {
989 abInfo := mctx.OtherModuleProvider(testFor, ApexBundleInfoProvider).(ApexBundleInfo)
990 contents = append(contents, abInfo.Contents)
991 }
992 mctx.SetProvider(android.ApexTestForInfoProvider, android.ApexTestForInfo{
993 ApexContents: contents,
994 })
Colin Crossaede88c2020-08-11 12:17:01 -0700995 }
996}
997
Jiyong Parkc0ec6f92020-11-19 23:00:52 +0900998// markPlatformAvailability marks whether or not a module can be available to platform. A module
999// cannot be available to platform if 1) it is explicitly marked as not available (i.e.
1000// "//apex_available:platform" is absent) or 2) it depends on another module that isn't (or can't
1001// be) available to platform
1002// TODO(jiyong): move this to android/apex.go?
Jiyong Park89e850a2020-04-07 16:37:39 +09001003func markPlatformAvailability(mctx android.BottomUpMutatorContext) {
1004 // Host and recovery are not considered as platform
1005 if mctx.Host() || mctx.Module().InstallInRecovery() {
1006 return
1007 }
1008
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001009 am, ok := mctx.Module().(android.ApexModule)
1010 if !ok {
1011 return
1012 }
Jiyong Park89e850a2020-04-07 16:37:39 +09001013
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001014 availableToPlatform := am.AvailableFor(android.AvailableToPlatform)
Jiyong Park89e850a2020-04-07 16:37:39 +09001015
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001016 // If any of the dep is not available to platform, this module is also considered as being
1017 // not available to platform even if it has "//apex_available:platform"
1018 mctx.VisitDirectDeps(func(child android.Module) {
Paul Duffin4c3e8e22021-03-18 15:41:29 +00001019 if !android.IsDepInSameApex(mctx, am, child) {
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001020 // if the dependency crosses apex boundary, don't consider it
1021 return
Jiyong Park89e850a2020-04-07 16:37:39 +09001022 }
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001023 if dep, ok := child.(android.ApexModule); ok && dep.NotAvailableForPlatform() {
1024 availableToPlatform = false
1025 // TODO(b/154889534) trigger an error when 'am' has
1026 // "//apex_available:platform"
Jiyong Park89e850a2020-04-07 16:37:39 +09001027 }
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001028 })
Jiyong Park89e850a2020-04-07 16:37:39 +09001029
Paul Duffinb5769c12021-05-12 16:16:51 +01001030 // Exception 1: check to see if the module always requires it.
1031 if am.AlwaysRequiresPlatformApexVariant() {
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001032 availableToPlatform = true
1033 }
1034
1035 // Exception 2: bootstrap bionic libraries are also always available to platform
1036 if cc.InstallToBootstrap(mctx.ModuleName(), mctx.Config()) {
1037 availableToPlatform = true
1038 }
1039
1040 if !availableToPlatform {
1041 am.SetNotAvailableForPlatform()
Jiyong Park89e850a2020-04-07 16:37:39 +09001042 }
1043}
1044
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001045// apexMutator visits each module and creates apex variations if the module was marked in the
Paul Duffin949abc02020-12-08 10:34:30 +00001046// previous run of apexInfoMutator.
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001047func apexMutator(mctx android.BottomUpMutatorContext) {
Jooyung Han49f67012020-04-17 13:43:10 +09001048 if !mctx.Module().Enabled() {
1049 return
1050 }
Colin Cross56a83212020-09-15 18:30:11 -07001051
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001052 // This is the usual path.
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001053 if am, ok := mctx.Module().(android.ApexModule); ok && am.CanHaveApexVariants() {
Colin Cross56a83212020-09-15 18:30:11 -07001054 android.CreateApexVariations(mctx, am)
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001055 return
1056 }
1057
1058 // apexBundle itself is mutated so that it and its dependencies have the same apex variant.
1059 // TODO(jiyong): document the reason why the VNDK APEX is an exception here.
Paul Duffin6717d882021-06-15 19:09:41 +01001060 unprefixedModuleName := android.RemoveOptionalPrebuiltPrefix(mctx.ModuleName())
1061 if apexModuleTypeRequiresVariant(mctx.Module()) {
1062 apexBundleName := unprefixedModuleName
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001063 mctx.CreateVariations(apexBundleName)
Martin Stjernholmec009002021-03-27 15:18:31 +00001064 if strings.HasPrefix(apexBundleName, "com.android.art") {
1065 // Create an alias from the platform variant. This is done to make
1066 // test_for dependencies work for modules that are split by the APEX
1067 // mutator, since test_for dependencies always go to the platform variant.
1068 // This doesn't happen for normal APEXes that are disjunct, so only do
1069 // this for the overlapping ART APEXes.
1070 // TODO(b/183882457): Remove this if the test_for functionality is
1071 // refactored to depend on the proper APEX variants instead of platform.
1072 mctx.CreateAliasVariation("", apexBundleName)
1073 }
Jiyong Park5d790c32019-11-15 18:40:32 +09001074 } else if o, ok := mctx.Module().(*OverrideApex); ok {
1075 apexBundleName := o.GetOverriddenModuleName()
1076 if apexBundleName == "" {
1077 mctx.ModuleErrorf("base property is not set")
1078 return
1079 }
Paul Duffin6717d882021-06-15 19:09:41 +01001080 // Workaround the issue reported in b/191269918 by using the unprefixed module name of this
1081 // module as the default variation to use if dependencies of this module do not have the correct
1082 // apex variant name. This name matches the name used to create the variations of modules for
1083 // which apexModuleTypeRequiresVariant return true.
1084 // TODO(b/191269918): Remove this workaround.
1085 mctx.SetDefaultDependencyVariation(&unprefixedModuleName)
Jiyong Park5d790c32019-11-15 18:40:32 +09001086 mctx.CreateVariations(apexBundleName)
Martin Stjernholmec009002021-03-27 15:18:31 +00001087 if strings.HasPrefix(apexBundleName, "com.android.art") {
1088 // TODO(b/183882457): See note for CreateAliasVariation above.
1089 mctx.CreateAliasVariation("", apexBundleName)
1090 }
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001091 }
1092}
Sundong Ahne9b55722019-09-06 17:37:42 +09001093
Paul Duffin6717d882021-06-15 19:09:41 +01001094// apexModuleTypeRequiresVariant determines whether the module supplied requires an apex specific
1095// variant.
1096func apexModuleTypeRequiresVariant(module android.Module) bool {
1097 if a, ok := module.(*apexBundle); ok {
1098 return !a.vndkApex
1099 }
1100
1101 // Match apex_set and prebuilt_apex. Would also match apexBundle but that is handled specially
1102 // above.
1103 if _, ok := module.(ApexInfoMutator); ok {
1104 return true
1105 }
1106
1107 return false
1108}
1109
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001110// See android.UpdateDirectlyInAnyApex
1111// TODO(jiyong): move this to android/apex.go?
Colin Cross56a83212020-09-15 18:30:11 -07001112func apexDirectlyInAnyMutator(mctx android.BottomUpMutatorContext) {
1113 if !mctx.Module().Enabled() {
1114 return
1115 }
1116 if am, ok := mctx.Module().(android.ApexModule); ok {
1117 android.UpdateDirectlyInAnyApex(mctx, am)
1118 }
1119}
1120
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001121// apexPackaging represents a specific packaging method for an APEX.
Jiyong Park8e6d52f2020-11-19 14:37:47 +09001122type apexPackaging int
1123
1124const (
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001125 // imageApex is a packaging method where contents are included in a filesystem image which
1126 // is then included in a zip container. This is the most typical way of packaging.
Jiyong Park8e6d52f2020-11-19 14:37:47 +09001127 imageApex apexPackaging = iota
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001128
1129 // zipApex is a packaging method where contents are directly included in the zip container.
1130 // This is used for host-side testing - because the contents are easily accessible by
1131 // unzipping the container.
Jiyong Park8e6d52f2020-11-19 14:37:47 +09001132 zipApex
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001133
1134 // flattendApex is a packaging method where contents are not included in the APEX file, but
1135 // installed to /apex/<apexname> directory on the device. This packaging method is used for
1136 // old devices where the filesystem-based APEX file can't be supported.
Jiyong Park8e6d52f2020-11-19 14:37:47 +09001137 flattenedApex
1138)
1139
1140const (
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001141 // File extensions of an APEX for different packaging methods
Jiyong Park8e6d52f2020-11-19 14:37:47 +09001142 imageApexSuffix = ".apex"
1143 zipApexSuffix = ".zipapex"
1144 flattenedSuffix = ".flattened"
1145
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001146 // variant names each of which is for a packaging method
Jiyong Park8e6d52f2020-11-19 14:37:47 +09001147 imageApexType = "image"
1148 zipApexType = "zip"
1149 flattenedApexType = "flattened"
1150
1151 ext4FsType = "ext4"
1152 f2fsFsType = "f2fs"
1153)
1154
1155// The suffix for the output "file", not the module
1156func (a apexPackaging) suffix() string {
1157 switch a {
1158 case imageApex:
1159 return imageApexSuffix
1160 case zipApex:
1161 return zipApexSuffix
1162 default:
1163 panic(fmt.Errorf("unknown APEX type %d", a))
1164 }
1165}
1166
1167func (a apexPackaging) name() string {
1168 switch a {
1169 case imageApex:
1170 return imageApexType
1171 case zipApex:
1172 return zipApexType
1173 default:
1174 panic(fmt.Errorf("unknown APEX type %d", a))
1175 }
1176}
1177
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001178// apexFlattenedMutator creates one or more variations each of which is for a packaging method.
1179// TODO(jiyong): give a better name to this mutator
Sundong Ahne9b55722019-09-06 17:37:42 +09001180func apexFlattenedMutator(mctx android.BottomUpMutatorContext) {
Jooyung Han49f67012020-04-17 13:43:10 +09001181 if !mctx.Module().Enabled() {
1182 return
1183 }
Sundong Ahne8fb7242019-09-17 13:50:45 +09001184 if ab, ok := mctx.Module().(*apexBundle); ok {
Sundong Ahnabb64432019-10-22 13:58:29 +09001185 var variants []string
1186 switch proptools.StringDefault(ab.properties.Payload_type, "image") {
1187 case "image":
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001188 // This is the normal case. Note that both image and flattend APEXes are
1189 // created. The image type is installed to the system partition, while the
1190 // flattened APEX is (optionally) installed to the system_ext partition.
1191 // This is mostly for GSI which has to support wide range of devices. If GSI
1192 // is installed on a newer (APEX-capable) device, the image APEX in the
1193 // system will be used. However, if the same GSI is installed on an old
1194 // device which can't support image APEX, the flattened APEX in the
1195 // system_ext partion (which still is part of GSI) is used instead.
Sundong Ahnabb64432019-10-22 13:58:29 +09001196 variants = append(variants, imageApexType, flattenedApexType)
1197 case "zip":
1198 variants = append(variants, zipApexType)
1199 case "both":
1200 variants = append(variants, imageApexType, zipApexType, flattenedApexType)
1201 default:
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001202 mctx.PropertyErrorf("payload_type", "%q is not one of \"image\", \"zip\", or \"both\".", *ab.properties.Payload_type)
Sundong Ahnabb64432019-10-22 13:58:29 +09001203 return
1204 }
1205
1206 modules := mctx.CreateLocalVariations(variants...)
1207
1208 for i, v := range variants {
1209 switch v {
1210 case imageApexType:
1211 modules[i].(*apexBundle).properties.ApexType = imageApex
1212 case zipApexType:
1213 modules[i].(*apexBundle).properties.ApexType = zipApex
1214 case flattenedApexType:
1215 modules[i].(*apexBundle).properties.ApexType = flattenedApex
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001216 // See the comment above for why system_ext.
Jooyung Han91df2082019-11-20 01:49:42 +09001217 if !mctx.Config().FlattenApex() && ab.Platform() {
Sundong Ahnd95aa2d2019-10-08 19:34:03 +09001218 modules[i].(*apexBundle).MakeAsSystemExt()
1219 }
Sundong Ahnabb64432019-10-22 13:58:29 +09001220 }
Sundong Ahne9b55722019-09-06 17:37:42 +09001221 }
Jiyong Park5d790c32019-11-15 18:40:32 +09001222 } else if _, ok := mctx.Module().(*OverrideApex); ok {
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001223 // payload_type is forcibly overridden to "image"
1224 // TODO(jiyong): is this the right decision?
Jiyong Park5d790c32019-11-15 18:40:32 +09001225 mctx.CreateVariations(imageApexType, flattenedApexType)
Sundong Ahne9b55722019-09-06 17:37:42 +09001226 }
1227}
1228
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001229// checkUseVendorProperty checks if the use of `use_vendor` property is allowed for the given APEX.
1230// When use_vendor is used, native modules are built with __ANDROID_VNDK__ and __ANDROID_APEX__,
1231// which may cause compatibility issues. (e.g. libbinder) Even though libbinder restricts its
1232// availability via 'apex_available' property and relies on yet another macro
1233// __ANDROID_APEX_<NAME>__, we restrict usage of "use_vendor:" from other APEX modules to avoid
1234// similar problems.
1235func checkUseVendorProperty(ctx android.BottomUpMutatorContext, a *apexBundle) {
1236 if proptools.Bool(a.properties.Use_vendor) && !android.InList(a.Name(), useVendorAllowList(ctx.Config())) {
1237 ctx.PropertyErrorf("use_vendor", "not allowed to set use_vendor: true")
1238 }
1239}
1240
Jooyung Handc782442019-11-01 03:14:38 +09001241var (
Colin Cross440e0d02020-06-11 11:32:11 -07001242 useVendorAllowListKey = android.NewOnceKey("useVendorAllowList")
Jooyung Handc782442019-11-01 03:14:38 +09001243)
1244
Colin Cross440e0d02020-06-11 11:32:11 -07001245func useVendorAllowList(config android.Config) []string {
1246 return config.Once(useVendorAllowListKey, func() interface{} {
Jooyung Handc782442019-11-01 03:14:38 +09001247 return []string{
1248 // swcodec uses "vendor" variants for smaller size
1249 "com.android.media.swcodec",
1250 "test_com.android.media.swcodec",
1251 }
1252 }).([]string)
1253}
1254
Paul Duffin0a49fdc2021-03-08 11:28:25 +00001255// setUseVendorAllowListForTest returns a FixturePreparer that overrides useVendorAllowList and
1256// must be called before the first call to useVendorAllowList()
1257func setUseVendorAllowListForTest(allowList []string) android.FixturePreparer {
1258 return android.FixtureModifyConfig(func(config android.Config) {
1259 config.Once(useVendorAllowListKey, func() interface{} {
1260 return allowList
1261 })
Jooyung Handc782442019-11-01 03:14:38 +09001262 })
1263}
1264
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001265var _ android.DepIsInSameApex = (*apexBundle)(nil)
Theotime Combes4ba38c12020-06-12 12:46:59 +00001266
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001267// Implements android.DepInInSameApex
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09001268func (a *apexBundle) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
1269 // direct deps of an APEX bundle are all part of the APEX bundle
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001270 // TODO(jiyong): shouldn't we look into the payload field of the dependencyTag?
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09001271 return true
1272}
1273
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001274var _ android.OutputFileProducer = (*apexBundle)(nil)
1275
1276// Implements android.OutputFileProducer
1277func (a *apexBundle) OutputFiles(tag string) (android.Paths, error) {
1278 switch tag {
Paul Duffin74f05592020-11-25 16:37:46 +00001279 case "", android.DefaultDistTag:
1280 // This is the default dist path.
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001281 return android.Paths{a.outputFile}, nil
1282 default:
1283 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
1284 }
1285}
1286
1287var _ cc.Coverage = (*apexBundle)(nil)
1288
1289// Implements cc.Coverage
1290func (a *apexBundle) IsNativeCoverageNeeded(ctx android.BaseModuleContext) bool {
1291 return ctx.Device() && ctx.DeviceConfig().NativeCoverageEnabled()
1292}
1293
1294// Implements cc.Coverage
Ivan Lozanod7586b62021-04-01 09:49:36 -04001295func (a *apexBundle) SetPreventInstall() {
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001296 a.properties.PreventInstall = true
1297}
1298
1299// Implements cc.Coverage
1300func (a *apexBundle) HideFromMake() {
1301 a.properties.HideFromMake = true
Colin Crosse6a83e62020-12-17 18:22:34 -08001302 // This HideFromMake is shadowing the ModuleBase one, call through to it for now.
1303 // TODO(ccross): untangle these
1304 a.ModuleBase.HideFromMake()
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001305}
1306
1307// Implements cc.Coverage
1308func (a *apexBundle) MarkAsCoverageVariant(coverage bool) {
1309 a.properties.IsCoverageVariant = coverage
1310}
1311
1312// Implements cc.Coverage
1313func (a *apexBundle) EnableCoverageIfNeeded() {}
1314
1315var _ android.ApexBundleDepsInfoIntf = (*apexBundle)(nil)
1316
1317// Implements android.ApexBudleDepsInfoIntf
1318func (a *apexBundle) Updatable() bool {
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00001319 return proptools.BoolDefault(a.properties.Updatable, true)
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001320}
1321
1322// getCertString returns the name of the cert that should be used to sign this APEX. This is
1323// basically from the "certificate" property, but could be overridden by the device config.
Colin Cross0ea8ba82019-06-06 14:33:29 -07001324func (a *apexBundle) getCertString(ctx android.BaseModuleContext) string {
Jooyung Han27151d92019-12-16 17:45:32 +09001325 moduleName := ctx.ModuleName()
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001326 // VNDK APEXes share the same certificate. To avoid adding a new VNDK version to the
1327 // OVERRIDE_* list, we check with the pseudo module name to see if its certificate is
1328 // overridden.
Jooyung Han27151d92019-12-16 17:45:32 +09001329 if a.vndkApex {
1330 moduleName = vndkApexName
1331 }
1332 certificate, overridden := ctx.DeviceConfig().OverrideCertificateFor(moduleName)
Jiyong Parkb2742fd2019-02-11 11:38:15 +09001333 if overridden {
Jaewoong Jungacb6db32019-02-28 16:22:30 +00001334 return ":" + certificate
Jiyong Parkb2742fd2019-02-11 11:38:15 +09001335 }
Jaewoong Jung4cfdf7d2021-04-20 16:21:24 -07001336 return String(a.overridableProperties.Certificate)
Jiyong Parkb2742fd2019-02-11 11:38:15 +09001337}
1338
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001339// See the installable property
Jiyong Park92c0f9c2018-12-13 23:14:57 +09001340func (a *apexBundle) installable() bool {
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001341 return !a.properties.PreventInstall && (a.properties.Installable == nil || proptools.Bool(a.properties.Installable))
Jiyong Park92c0f9c2018-12-13 23:14:57 +09001342}
1343
Nikita Ioffe9d9960f2021-06-09 19:43:46 +01001344// See the generate_hashtree property
1345func (a *apexBundle) shouldGenerateHashtree() bool {
1346 return proptools.BoolDefault(a.properties.Generate_hashtree, false)
Nikita Ioffec72b5dd2019-12-07 17:30:22 +00001347}
1348
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001349// See the test_only_unsigned_payload property
Dario Frenica913392020-04-27 18:21:11 +01001350func (a *apexBundle) testOnlyShouldSkipPayloadSign() bool {
1351 return proptools.Bool(a.properties.Test_only_unsigned_payload)
1352}
1353
Mohammad Samiul Islama8008f92020-12-22 10:47:50 +00001354// See the test_only_force_compression property
1355func (a *apexBundle) testOnlyShouldForceCompression() bool {
1356 return proptools.Bool(a.properties.Test_only_force_compression)
1357}
1358
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001359// These functions are interfacing with cc/sanitizer.go. The entire APEX (along with all of its
1360// members) can be sanitized, either forcibly, or by the global configuration. For some of the
1361// sanitizers, extra dependencies can be forcibly added as well.
Jiyong Parkda6eb592018-12-19 17:12:36 +09001362
Jiyong Parkf97782b2019-02-13 20:28:58 +09001363func (a *apexBundle) EnableSanitizer(sanitizerName string) {
1364 if !android.InList(sanitizerName, a.properties.SanitizerNames) {
1365 a.properties.SanitizerNames = append(a.properties.SanitizerNames, sanitizerName)
1366 }
1367}
1368
Jiyong Park388ef3f2019-01-28 19:47:32 +09001369func (a *apexBundle) IsSanitizerEnabled(ctx android.BaseModuleContext, sanitizerName string) bool {
Jiyong Parkf97782b2019-02-13 20:28:58 +09001370 if android.InList(sanitizerName, a.properties.SanitizerNames) {
1371 return true
Jiyong Park235e67c2019-02-09 11:50:56 +09001372 }
1373
1374 // Then follow the global setting
Jiyong Park388ef3f2019-01-28 19:47:32 +09001375 globalSanitizerNames := []string{}
1376 if a.Host() {
1377 globalSanitizerNames = ctx.Config().SanitizeHost()
1378 } else {
1379 arches := ctx.Config().SanitizeDeviceArch()
1380 if len(arches) == 0 || android.InList(a.Arch().ArchType.Name, arches) {
1381 globalSanitizerNames = ctx.Config().SanitizeDevice()
1382 }
1383 }
1384 return android.InList(sanitizerName, globalSanitizerNames)
Jiyong Park379de2f2018-12-19 02:47:14 +09001385}
1386
Jooyung Han8ce8db92020-05-15 19:05:05 +09001387func (a *apexBundle) AddSanitizerDependencies(ctx android.BottomUpMutatorContext, sanitizerName string) {
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001388 // TODO(jiyong): move this info (the sanitizer name, the lib name, etc.) to cc/sanitize.go
1389 // Keep only the mechanism here.
Jooyung Han8ce8db92020-05-15 19:05:05 +09001390 if ctx.Device() && sanitizerName == "hwaddress" && strings.HasPrefix(a.Name(), "com.android.runtime") {
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001391 imageVariation := a.getImageVariation(ctx)
Jooyung Han8ce8db92020-05-15 19:05:05 +09001392 for _, target := range ctx.MultiTargets() {
1393 if target.Arch.ArchType.Multilib == "lib64" {
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001394 addDependenciesForNativeModules(ctx, ApexNativeDependencies{
1395 Native_shared_libs: []string{"libclang_rt.hwasan-aarch64-android"},
1396 Tests: nil,
1397 Jni_libs: nil,
1398 Binaries: nil,
1399 }, target, imageVariation)
Jooyung Han8ce8db92020-05-15 19:05:05 +09001400 break
1401 }
1402 }
1403 }
1404}
1405
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001406// apexFileFor<Type> functions below create an apexFile struct for a given Soong module. The
1407// returned apexFile saves information about the Soong module that will be used for creating the
1408// build rules.
Jiyong Park1833cef2019-12-13 13:28:36 +09001409func apexFileForNativeLibrary(ctx android.BaseModuleContext, ccMod *cc.Module, handleSpecialLibs bool) apexFile {
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001410 // Decide the APEX-local directory by the multilib of the library In the future, we may
1411 // query this to the module.
1412 // TODO(jiyong): use the new PackagingSpec
Jiyong Parkf653b052019-11-18 15:39:01 +09001413 var dirInApex string
Martin Stjernholm279de572019-09-10 23:18:20 +01001414 switch ccMod.Arch().ArchType.Multilib {
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001415 case "lib32":
1416 dirInApex = "lib"
1417 case "lib64":
1418 dirInApex = "lib64"
1419 }
Colin Cross3b19f5d2019-09-17 14:45:31 -07001420 if ccMod.Target().NativeBridge == android.NativeBridgeEnabled {
Martin Stjernholm279de572019-09-10 23:18:20 +01001421 dirInApex = filepath.Join(dirInApex, ccMod.Target().NativeBridgeRelativePath)
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001422 }
Jooyung Han35155c42020-02-06 17:33:20 +09001423 dirInApex = filepath.Join(dirInApex, ccMod.RelativeInstallPath())
Jiyong Park1833cef2019-12-13 13:28:36 +09001424 if handleSpecialLibs && cc.InstallToBootstrap(ccMod.BaseModuleName(), ctx.Config()) {
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001425 // Special case for Bionic libs and other libs installed with them. This is to
1426 // prevent those libs from being included in the search path
1427 // /apex/com.android.runtime/${LIB}. This exclusion is required because those libs
1428 // in the Runtime APEX are available via the legacy paths in /system/lib/. By the
1429 // init process, the libs in the APEX are bind-mounted to the legacy paths and thus
1430 // will be loaded into the default linker namespace (aka "platform" namespace). If
1431 // the libs are directly in /apex/com.android.runtime/${LIB} then the same libs will
1432 // be loaded again into the runtime linker namespace, which will result in double
1433 // loading of them, which isn't supported.
Martin Stjernholm279de572019-09-10 23:18:20 +01001434 dirInApex = filepath.Join(dirInApex, "bionic")
Jiyong Parkb0788572018-12-20 22:10:17 +09001435 }
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001436
Jiyong Parkf653b052019-11-18 15:39:01 +09001437 fileToCopy := ccMod.OutputFile().Path()
Yo Chiange8128052020-07-23 20:09:18 +08001438 androidMkModuleName := ccMod.BaseModuleName() + ccMod.Properties.SubName
1439 return newApexFile(ctx, fileToCopy, androidMkModuleName, dirInApex, nativeSharedLib, ccMod)
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001440}
1441
Jiyong Park1833cef2019-12-13 13:28:36 +09001442func apexFileForExecutable(ctx android.BaseModuleContext, cc *cc.Module) apexFile {
Jooyung Han35155c42020-02-06 17:33:20 +09001443 dirInApex := "bin"
Colin Cross3b19f5d2019-09-17 14:45:31 -07001444 if cc.Target().NativeBridge == android.NativeBridgeEnabled {
dimitry8d6dde82019-07-11 10:23:53 +02001445 dirInApex = filepath.Join(dirInApex, cc.Target().NativeBridgeRelativePath)
Jiyong Parkacbf6c72019-07-09 16:19:16 +09001446 }
Jooyung Han35155c42020-02-06 17:33:20 +09001447 dirInApex = filepath.Join(dirInApex, cc.RelativeInstallPath())
Jiyong Parkf653b052019-11-18 15:39:01 +09001448 fileToCopy := cc.OutputFile().Path()
Yo Chiange8128052020-07-23 20:09:18 +08001449 androidMkModuleName := cc.BaseModuleName() + cc.Properties.SubName
1450 af := newApexFile(ctx, fileToCopy, androidMkModuleName, dirInApex, nativeExecutable, cc)
Jiyong Parkf653b052019-11-18 15:39:01 +09001451 af.symlinks = cc.Symlinks()
Liz Kammer1c14a212020-05-12 15:26:55 -07001452 af.dataPaths = cc.DataPaths()
Jiyong Parkf653b052019-11-18 15:39:01 +09001453 return af
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001454}
1455
Jiyong Park99644e92020-11-17 22:21:02 +09001456func apexFileForRustExecutable(ctx android.BaseModuleContext, rustm *rust.Module) apexFile {
1457 dirInApex := "bin"
1458 if rustm.Target().NativeBridge == android.NativeBridgeEnabled {
1459 dirInApex = filepath.Join(dirInApex, rustm.Target().NativeBridgeRelativePath)
1460 }
1461 fileToCopy := rustm.OutputFile().Path()
1462 androidMkModuleName := rustm.BaseModuleName() + rustm.Properties.SubName
1463 af := newApexFile(ctx, fileToCopy, androidMkModuleName, dirInApex, nativeExecutable, rustm)
1464 return af
1465}
1466
1467func apexFileForRustLibrary(ctx android.BaseModuleContext, rustm *rust.Module) apexFile {
1468 // Decide the APEX-local directory by the multilib of the library
1469 // In the future, we may query this to the module.
1470 var dirInApex string
1471 switch rustm.Arch().ArchType.Multilib {
1472 case "lib32":
1473 dirInApex = "lib"
1474 case "lib64":
1475 dirInApex = "lib64"
1476 }
1477 if rustm.Target().NativeBridge == android.NativeBridgeEnabled {
1478 dirInApex = filepath.Join(dirInApex, rustm.Target().NativeBridgeRelativePath)
1479 }
1480 fileToCopy := rustm.OutputFile().Path()
1481 androidMkModuleName := rustm.BaseModuleName() + rustm.Properties.SubName
1482 return newApexFile(ctx, fileToCopy, androidMkModuleName, dirInApex, nativeSharedLib, rustm)
1483}
1484
Jiyong Park1833cef2019-12-13 13:28:36 +09001485func apexFileForPyBinary(ctx android.BaseModuleContext, py *python.Module) apexFile {
Jiyong Parkf653b052019-11-18 15:39:01 +09001486 dirInApex := "bin"
1487 fileToCopy := py.HostToolPath().Path()
Yo Chiange8128052020-07-23 20:09:18 +08001488 return newApexFile(ctx, fileToCopy, py.BaseModuleName(), dirInApex, pyBinary, py)
Alex Light778127a2019-02-27 14:19:50 -08001489}
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001490
Jiyong Park1833cef2019-12-13 13:28:36 +09001491func apexFileForGoBinary(ctx android.BaseModuleContext, depName string, gb bootstrap.GoBinaryTool) apexFile {
Jiyong Parkf653b052019-11-18 15:39:01 +09001492 dirInApex := "bin"
Alex Light778127a2019-02-27 14:19:50 -08001493 s, err := filepath.Rel(android.PathForOutput(ctx).String(), gb.InstallPath())
1494 if err != nil {
1495 ctx.ModuleErrorf("Unable to use compiled binary at %s", gb.InstallPath())
Jiyong Parkf653b052019-11-18 15:39:01 +09001496 return apexFile{}
Alex Light778127a2019-02-27 14:19:50 -08001497 }
Jiyong Parkf653b052019-11-18 15:39:01 +09001498 fileToCopy := android.PathForOutput(ctx, s)
1499 // NB: Since go binaries are static we don't need the module for anything here, which is
1500 // good since the go tool is a blueprint.Module not an android.Module like we would
1501 // normally use.
Jiyong Park1833cef2019-12-13 13:28:36 +09001502 return newApexFile(ctx, fileToCopy, depName, dirInApex, goBinary, nil)
Alex Light778127a2019-02-27 14:19:50 -08001503}
1504
Jaewoong Jung4b79e982020-06-01 10:45:49 -07001505func apexFileForShBinary(ctx android.BaseModuleContext, sh *sh.ShBinary) apexFile {
Jiyong Parkf653b052019-11-18 15:39:01 +09001506 dirInApex := filepath.Join("bin", sh.SubDir())
1507 fileToCopy := sh.OutputFile()
Yo Chiange8128052020-07-23 20:09:18 +08001508 af := newApexFile(ctx, fileToCopy, sh.BaseModuleName(), dirInApex, shBinary, sh)
Jiyong Parkf653b052019-11-18 15:39:01 +09001509 af.symlinks = sh.Symlinks()
1510 return af
Jiyong Park04480cf2019-02-06 00:16:29 +09001511}
1512
Jaewoong Jung4b79e982020-06-01 10:45:49 -07001513func apexFileForPrebuiltEtc(ctx android.BaseModuleContext, prebuilt prebuilt_etc.PrebuiltEtcModule, depName string) apexFile {
Jooyung Han0703fd82020-08-26 22:11:53 +09001514 dirInApex := filepath.Join(prebuilt.BaseDir(), prebuilt.SubDir())
Jiyong Parkf653b052019-11-18 15:39:01 +09001515 fileToCopy := prebuilt.OutputFile()
Jiyong Park1833cef2019-12-13 13:28:36 +09001516 return newApexFile(ctx, fileToCopy, depName, dirInApex, etc, prebuilt)
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001517}
1518
atrost6e126252020-01-27 17:01:16 +00001519func apexFileForCompatConfig(ctx android.BaseModuleContext, config java.PlatformCompatConfigIntf, depName string) apexFile {
1520 dirInApex := filepath.Join("etc", config.SubDir())
1521 fileToCopy := config.CompatConfig()
1522 return newApexFile(ctx, fileToCopy, depName, dirInApex, etc, config)
1523}
1524
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001525// javaModule is an interface to handle all Java modules (java_library, dex_import, etc) in the same
1526// way.
1527type javaModule interface {
1528 android.Module
1529 BaseModuleName() string
1530 DexJarBuildPath() android.Path
1531 JacocoReportClassesFile() android.Path
1532 LintDepSets() java.LintDepSets
1533 Stem() string
1534}
1535
1536var _ javaModule = (*java.Library)(nil)
Bill Peckhama41a6962021-01-11 10:58:54 -08001537var _ javaModule = (*java.Import)(nil)
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001538var _ javaModule = (*java.SdkLibrary)(nil)
1539var _ javaModule = (*java.DexImport)(nil)
1540var _ javaModule = (*java.SdkLibraryImport)(nil)
1541
Paul Duffin190fdef2021-04-26 10:33:59 +01001542// apexFileForJavaModule creates an apexFile for a java module's dex implementation jar.
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001543func apexFileForJavaModule(ctx android.BaseModuleContext, module javaModule) apexFile {
Paul Duffin190fdef2021-04-26 10:33:59 +01001544 return apexFileForJavaModuleWithFile(ctx, module, module.DexJarBuildPath())
1545}
1546
1547// apexFileForJavaModuleWithFile creates an apexFile for a java module with the supplied file.
1548func apexFileForJavaModuleWithFile(ctx android.BaseModuleContext, module javaModule, dexImplementationJar android.Path) apexFile {
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001549 dirInApex := "javalib"
Paul Duffin190fdef2021-04-26 10:33:59 +01001550 af := newApexFile(ctx, dexImplementationJar, module.BaseModuleName(), dirInApex, javaSharedLib, module)
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001551 af.jacocoReportClassesFile = module.JacocoReportClassesFile()
1552 af.lintDepSets = module.LintDepSets()
1553 af.customStem = module.Stem() + ".jar"
1554 return af
1555}
1556
1557// androidApp is an interface to handle all app modules (android_app, android_app_import, etc.) in
1558// the same way.
1559type androidApp interface {
Jiyong Parkf653b052019-11-18 15:39:01 +09001560 android.Module
1561 Privileged() bool
Jooyung Han39ee1192020-03-23 20:21:11 +09001562 InstallApkName() string
Jiyong Parkf653b052019-11-18 15:39:01 +09001563 OutputFile() android.Path
Jiyong Park618922e2020-01-08 13:35:43 +09001564 JacocoReportClassesFile() android.Path
Colin Cross503c1d02020-01-28 14:00:53 -08001565 Certificate() java.Certificate
Yo Chiange8128052020-07-23 20:09:18 +08001566 BaseModuleName() string
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001567}
1568
1569var _ androidApp = (*java.AndroidApp)(nil)
1570var _ androidApp = (*java.AndroidAppImport)(nil)
1571
1572func apexFileForAndroidApp(ctx android.BaseModuleContext, aapp androidApp) apexFile {
Jiyong Parkf7487312019-10-17 12:54:30 +09001573 appDir := "app"
Jiyong Parkf653b052019-11-18 15:39:01 +09001574 if aapp.Privileged() {
Jiyong Parkf7487312019-10-17 12:54:30 +09001575 appDir = "priv-app"
1576 }
Jooyung Han39ee1192020-03-23 20:21:11 +09001577 dirInApex := filepath.Join(appDir, aapp.InstallApkName())
Jiyong Parkf653b052019-11-18 15:39:01 +09001578 fileToCopy := aapp.OutputFile()
Yo Chiange8128052020-07-23 20:09:18 +08001579 af := newApexFile(ctx, fileToCopy, aapp.BaseModuleName(), dirInApex, app, aapp)
Jiyong Park618922e2020-01-08 13:35:43 +09001580 af.jacocoReportClassesFile = aapp.JacocoReportClassesFile()
Colin Cross503c1d02020-01-28 14:00:53 -08001581 af.certificate = aapp.Certificate()
Jiyong Parkcfaa1642020-02-28 16:51:07 +09001582
1583 if app, ok := aapp.(interface {
1584 OverriddenManifestPackageName() string
1585 }); ok {
1586 af.overriddenPackageName = app.OverriddenManifestPackageName()
1587 }
Jiyong Park618922e2020-01-08 13:35:43 +09001588 return af
Dario Frenicde2a032019-10-27 00:29:22 +01001589}
1590
Jiyong Park69aeba92020-04-24 21:16:36 +09001591func apexFileForRuntimeResourceOverlay(ctx android.BaseModuleContext, rro java.RuntimeResourceOverlayModule) apexFile {
1592 rroDir := "overlay"
1593 dirInApex := filepath.Join(rroDir, rro.Theme())
1594 fileToCopy := rro.OutputFile()
1595 af := newApexFile(ctx, fileToCopy, rro.Name(), dirInApex, app, rro)
1596 af.certificate = rro.Certificate()
1597
1598 if a, ok := rro.(interface {
1599 OverriddenManifestPackageName() string
1600 }); ok {
1601 af.overriddenPackageName = a.OverriddenManifestPackageName()
1602 }
1603 return af
1604}
1605
markchien2f59ec92020-09-02 16:23:38 +08001606func apexFileForBpfProgram(ctx android.BaseModuleContext, builtFile android.Path, bpfProgram bpf.BpfModule) apexFile {
1607 dirInApex := filepath.Join("etc", "bpf")
1608 return newApexFile(ctx, builtFile, builtFile.Base(), dirInApex, etc, bpfProgram)
1609}
1610
Jiyong Park12a719c2021-01-07 15:31:24 +09001611func apexFileForFilesystem(ctx android.BaseModuleContext, buildFile android.Path, fs filesystem.Filesystem) apexFile {
1612 dirInApex := filepath.Join("etc", "fs")
1613 return newApexFile(ctx, buildFile, buildFile.Base(), dirInApex, etc, fs)
1614}
1615
Paul Duffin064b70c2020-11-02 17:32:38 +00001616// WalkPayloadDeps visits dependencies that contributes to the payload of this APEX. For each of the
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001617// visited module, the `do` callback is executed. Returning true in the callback continues the visit
1618// to the child modules. Returning false makes the visit to continue in the sibling or the parent
1619// modules. This is used in check* functions below.
Jooyung Han749dc692020-04-15 11:03:39 +09001620func (a *apexBundle) WalkPayloadDeps(ctx android.ModuleContext, do android.PayloadDepsCallback) {
Paul Duffindf915ff2020-03-30 17:58:21 +01001621 ctx.WalkDeps(func(child, parent android.Module) bool {
Jiyong Park0f80c182020-01-31 02:49:53 +09001622 am, ok := child.(android.ApexModule)
1623 if !ok || !am.CanHaveApexVariants() {
1624 return false
1625 }
1626
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001627 // Filter-out unwanted depedendencies
1628 depTag := ctx.OtherModuleDependencyTag(child)
1629 if _, ok := depTag.(android.ExcludeFromApexContentsTag); ok {
1630 return false
1631 }
1632 if dt, ok := depTag.(dependencyTag); ok && !dt.payload {
Martin Stjernholm58c33f02020-07-06 22:56:01 +01001633 return false
1634 }
1635
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001636 ai := ctx.OtherModuleProvider(child, android.ApexInfoProvider).(android.ApexInfo)
Jiyong Parkab50b072021-05-12 17:13:56 +09001637 externalDep := !android.InList(ctx.ModuleName(), ai.InApexVariants)
Jiyong Park0f80c182020-01-31 02:49:53 +09001638
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001639 // Visit actually
1640 return do(ctx, parent, am, externalDep)
Jiyong Park0f80c182020-01-31 02:49:53 +09001641 })
1642}
1643
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001644// filesystem type of the apex_payload.img inside the APEX. Currently, ext4 and f2fs are supported.
1645type fsType int
Jooyung Han03b51852020-02-26 22:45:42 +09001646
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001647const (
1648 ext4 fsType = iota
1649 f2fs
1650)
Artur Satayev849f8442020-04-28 14:57:42 +01001651
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001652func (f fsType) string() string {
1653 switch f {
1654 case ext4:
1655 return ext4FsType
1656 case f2fs:
1657 return f2fsFsType
1658 default:
1659 panic(fmt.Errorf("unknown APEX payload type %d", f))
Jooyung Han548640b2020-04-27 12:10:30 +09001660 }
1661}
1662
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001663// Creates build rules for an APEX. It consists of the following major steps:
1664//
1665// 1) do some validity checks such as apex_available, min_sdk_version, etc.
1666// 2) traverse the dependency tree to collect apexFile structs from them.
1667// 3) some fields in apexBundle struct are configured
1668// 4) generate the build rules to create the APEX. This is mostly done in builder.go.
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001669func (a *apexBundle) GenerateAndroidBuildActions(ctx android.ModuleContext) {
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001670 ////////////////////////////////////////////////////////////////////////////////////////////
1671 // 1) do some validity checks such as apex_available, min_sdk_version, etc.
Jiyong Park0f80c182020-01-31 02:49:53 +09001672 a.checkApexAvailability(ctx)
Jooyung Han548640b2020-04-27 12:10:30 +09001673 a.checkUpdatable(ctx)
Jooyung Han749dc692020-04-15 11:03:39 +09001674 a.checkMinSdkVersion(ctx)
Jiyong Park7d95a512020-05-10 15:16:24 +09001675 a.checkStaticLinkingToStubLibraries(ctx)
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001676 if len(a.properties.Tests) > 0 && !a.testApex {
1677 ctx.PropertyErrorf("tests", "property allowed only in apex_test module type")
1678 return
1679 }
Jiyong Park678c8812020-02-07 17:25:49 +09001680
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001681 ////////////////////////////////////////////////////////////////////////////////////////////
1682 // 2) traverse the dependency tree to collect apexFile structs from them.
1683
1684 // all the files that will be included in this APEX
1685 var filesInfo []apexFile
Alex Lightfc0bd7c2019-01-29 18:31:59 -08001686
Jooyung Hane1633032019-08-01 17:41:43 +09001687 // native lib dependencies
1688 var provideNativeLibs []string
1689 var requireNativeLibs []string
1690
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001691 handleSpecialLibs := !android.Bool(a.properties.Ignore_system_library_special_case)
1692
1693 // TODO(jiyong): do this using WalkPayloadDeps
1694 // TODO(jiyong): make this clean!!!
Alex Light778127a2019-02-27 14:19:50 -08001695 ctx.WalkDepsBlueprint(func(child, parent blueprint.Module) bool {
Roland Levillainf89cd092019-07-29 16:22:59 +01001696 depTag := ctx.OtherModuleDependencyTag(child)
Paul Duffindddd5462020-04-07 15:25:44 +01001697 if _, ok := depTag.(android.ExcludeFromApexContentsTag); ok {
1698 return false
1699 }
Roland Levillainf89cd092019-07-29 16:22:59 +01001700 depName := ctx.OtherModuleName(child)
Jiyong Parkf653b052019-11-18 15:39:01 +09001701 if _, isDirectDep := parent.(*apexBundle); isDirectDep {
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001702 switch depTag {
Jooyung Han643adc42020-02-27 13:50:06 +09001703 case sharedLibTag, jniLibTag:
1704 isJniLib := depTag == jniLibTag
Jooyung Hanfaa2d5f2020-02-06 17:42:40 +09001705 if c, ok := child.(*cc.Module); ok {
Jooyung Han643adc42020-02-27 13:50:06 +09001706 fi := apexFileForNativeLibrary(ctx, c, handleSpecialLibs)
1707 fi.isJniLib = isJniLib
1708 filesInfo = append(filesInfo, fi)
Jooyung Han45a96772020-06-15 14:59:42 +09001709 // Collect the list of stub-providing libs except:
1710 // - VNDK libs are only for vendors
1711 // - bootstrap bionic libs are treated as provided by system
1712 if c.HasStubsVariants() && !a.vndkApex && !cc.InstallToBootstrap(c.BaseModuleName(), ctx.Config()) {
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001713 provideNativeLibs = append(provideNativeLibs, fi.stem())
Jiyong Parkf1493cc2020-05-29 21:29:20 +09001714 }
Jiyong Parkf653b052019-11-18 15:39:01 +09001715 return true // track transitive dependencies
Jiyong Parkf2cc1b72020-12-09 00:20:45 +09001716 } else if r, ok := child.(*rust.Module); ok {
1717 fi := apexFileForRustLibrary(ctx, r)
1718 filesInfo = append(filesInfo, fi)
Jiyong Parkff1458f2018-10-12 21:49:38 +09001719 } else {
Jooyung Han643adc42020-02-27 13:50:06 +09001720 propertyName := "native_shared_libs"
1721 if isJniLib {
1722 propertyName = "jni_libs"
1723 }
1724 ctx.PropertyErrorf(propertyName, "%q is not a cc_library or cc_library_shared module", depName)
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001725 }
1726 case executableTag:
1727 if cc, ok := child.(*cc.Module); ok {
Jiyong Park1833cef2019-12-13 13:28:36 +09001728 filesInfo = append(filesInfo, apexFileForExecutable(ctx, cc))
Jiyong Parkf653b052019-11-18 15:39:01 +09001729 return true // track transitive dependencies
Jaewoong Jung4b79e982020-06-01 10:45:49 -07001730 } else if sh, ok := child.(*sh.ShBinary); ok {
Jiyong Park1833cef2019-12-13 13:28:36 +09001731 filesInfo = append(filesInfo, apexFileForShBinary(ctx, sh))
Alex Light778127a2019-02-27 14:19:50 -08001732 } else if py, ok := child.(*python.Module); ok && py.HostToolPath().Valid() {
Jiyong Park1833cef2019-12-13 13:28:36 +09001733 filesInfo = append(filesInfo, apexFileForPyBinary(ctx, py))
Alex Light778127a2019-02-27 14:19:50 -08001734 } else if gb, ok := child.(bootstrap.GoBinaryTool); ok && a.Host() {
Jiyong Parkf653b052019-11-18 15:39:01 +09001735 filesInfo = append(filesInfo, apexFileForGoBinary(ctx, depName, gb))
Jiyong Park99644e92020-11-17 22:21:02 +09001736 } else if rust, ok := child.(*rust.Module); ok {
1737 filesInfo = append(filesInfo, apexFileForRustExecutable(ctx, rust))
1738 return true // track transitive dependencies
Jiyong Parkff1458f2018-10-12 21:49:38 +09001739 } else {
Jiyong Park99644e92020-11-17 22:21:02 +09001740 ctx.PropertyErrorf("binaries", "%q is neither cc_binary, rust_binary, (embedded) py_binary, (host) blueprint_go_binary, (host) bootstrap_go_binary, nor sh_binary", depName)
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001741 }
Paul Duffin94f19632021-04-20 12:40:07 +01001742 case bcpfTag:
Paul Duffina1d60252021-01-21 18:13:43 +00001743 {
Paul Duffin7771eba2021-04-23 14:25:28 +01001744 if _, ok := child.(*java.BootclasspathFragmentModule); !ok {
Paul Duffincc33ec82021-04-25 23:14:55 +01001745 ctx.PropertyErrorf("bootclasspath_fragments", "%q is not a bootclasspath_fragment module", depName)
Paul Duffina1d60252021-01-21 18:13:43 +00001746 return false
1747 }
Paul Duffin4d101b62021-03-24 15:42:20 +00001748
Paul Duffincc33ec82021-04-25 23:14:55 +01001749 filesToAdd := apexBootclasspathFragmentFiles(ctx, child)
1750 filesInfo = append(filesInfo, filesToAdd...)
Paul Duffin4d101b62021-03-24 15:42:20 +00001751 return true
Paul Duffina1d60252021-01-21 18:13:43 +00001752 }
satayev333a1732021-05-17 21:35:26 +01001753 case sscpfTag:
1754 {
1755 if _, ok := child.(*java.SystemServerClasspathModule); !ok {
1756 ctx.PropertyErrorf("systemserverclasspath_fragments", "%q is not a systemserverclasspath_fragment module", depName)
1757 return false
1758 }
1759 filesInfo = append(filesInfo, apexClasspathFragmentProtoFile(ctx, child))
1760 return true
1761 }
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001762 case javaLibTag:
Jiyong Park77acec62020-06-01 21:39:15 +09001763 switch child.(type) {
Bill Peckhama41a6962021-01-11 10:58:54 -08001764 case *java.Library, *java.SdkLibrary, *java.DexImport, *java.SdkLibraryImport, *java.Import:
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001765 af := apexFileForJavaModule(ctx, child.(javaModule))
1766 if !af.ok() {
Jooyung Han58f26ab2019-12-18 15:34:32 +09001767 ctx.PropertyErrorf("java_libs", "%q is not configured to be compiled into dex", depName)
1768 return false
1769 }
1770 filesInfo = append(filesInfo, af)
Jooyung Han58f26ab2019-12-18 15:34:32 +09001771 return true // track transitive dependencies
Jiyong Park77acec62020-06-01 21:39:15 +09001772 default:
Jiyong Park9e6c2422019-08-09 20:39:45 +09001773 ctx.PropertyErrorf("java_libs", "%q of type %q is not supported", depName, ctx.OtherModuleType(child))
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001774 }
Jiyong Parkf653b052019-11-18 15:39:01 +09001775 case androidAppTag:
Jiyong Parkf653b052019-11-18 15:39:01 +09001776 if ap, ok := child.(*java.AndroidApp); ok {
Jooyung Han39ee1192020-03-23 20:21:11 +09001777 filesInfo = append(filesInfo, apexFileForAndroidApp(ctx, ap))
Jiyong Parkf653b052019-11-18 15:39:01 +09001778 return true // track transitive dependencies
1779 } else if ap, ok := child.(*java.AndroidAppImport); ok {
Jooyung Han39ee1192020-03-23 20:21:11 +09001780 filesInfo = append(filesInfo, apexFileForAndroidApp(ctx, ap))
Dario Freni6f3937c2019-12-20 22:58:03 +00001781 } else if ap, ok := child.(*java.AndroidTestHelperApp); ok {
Jooyung Han39ee1192020-03-23 20:21:11 +09001782 filesInfo = append(filesInfo, apexFileForAndroidApp(ctx, ap))
Sasha Smundak18d98bc2020-05-27 16:36:07 -07001783 } else if ap, ok := child.(*java.AndroidAppSet); ok {
1784 appDir := "app"
1785 if ap.Privileged() {
1786 appDir = "priv-app"
1787 }
Yo Chiange8128052020-07-23 20:09:18 +08001788 af := newApexFile(ctx, ap.OutputFile(), ap.BaseModuleName(),
Sasha Smundak18d98bc2020-05-27 16:36:07 -07001789 filepath.Join(appDir, ap.BaseModuleName()), appSet, ap)
1790 af.certificate = java.PresignedCertificate
1791 filesInfo = append(filesInfo, af)
Jiyong Parkf653b052019-11-18 15:39:01 +09001792 } else {
1793 ctx.PropertyErrorf("apps", "%q is not an android_app module", depName)
1794 }
Jiyong Park69aeba92020-04-24 21:16:36 +09001795 case rroTag:
1796 if rro, ok := child.(java.RuntimeResourceOverlayModule); ok {
1797 filesInfo = append(filesInfo, apexFileForRuntimeResourceOverlay(ctx, rro))
1798 } else {
1799 ctx.PropertyErrorf("rros", "%q is not an runtime_resource_overlay module", depName)
1800 }
markchien2f59ec92020-09-02 16:23:38 +08001801 case bpfTag:
1802 if bpfProgram, ok := child.(bpf.BpfModule); ok {
1803 filesToCopy, _ := bpfProgram.OutputFiles("")
1804 for _, bpfFile := range filesToCopy {
1805 filesInfo = append(filesInfo, apexFileForBpfProgram(ctx, bpfFile, bpfProgram))
1806 }
1807 } else {
1808 ctx.PropertyErrorf("bpfs", "%q is not a bpf module", depName)
1809 }
Jiyong Park12a719c2021-01-07 15:31:24 +09001810 case fsTag:
1811 if fs, ok := child.(filesystem.Filesystem); ok {
1812 filesInfo = append(filesInfo, apexFileForFilesystem(ctx, fs.OutputPath(), fs))
1813 } else {
1814 ctx.PropertyErrorf("filesystems", "%q is not a filesystem module", depName)
1815 }
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001816 case prebuiltTag:
Jaewoong Jung4b79e982020-06-01 10:45:49 -07001817 if prebuilt, ok := child.(prebuilt_etc.PrebuiltEtcModule); ok {
Jiyong Park1833cef2019-12-13 13:28:36 +09001818 filesInfo = append(filesInfo, apexFileForPrebuiltEtc(ctx, prebuilt, depName))
Jiyong Parkff1458f2018-10-12 21:49:38 +09001819 } else {
Paul Duffin1bc21dc2021-03-15 19:43:17 +00001820 ctx.PropertyErrorf("prebuilts", "%q is not a prebuilt_etc module", depName)
Jiyong Parkff1458f2018-10-12 21:49:38 +09001821 }
Paul Duffin0b817782021-03-17 15:02:19 +00001822 case compatConfigTag:
Paul Duffin3abc1742021-03-15 19:32:23 +00001823 if compatConfig, ok := child.(java.PlatformCompatConfigIntf); ok {
1824 filesInfo = append(filesInfo, apexFileForCompatConfig(ctx, compatConfig, depName))
1825 } else {
1826 ctx.PropertyErrorf("compat_configs", "%q is not a platform_compat_config module", depName)
1827 }
Roland Levillain630846d2019-06-26 12:48:34 +01001828 case testTag:
Roland Levillainf89cd092019-07-29 16:22:59 +01001829 if ccTest, ok := child.(*cc.Module); ok {
1830 if ccTest.IsTestPerSrcAllTestsVariation() {
1831 // Multiple-output test module (where `test_per_src: true`).
1832 //
1833 // `ccTest` is the "" ("all tests") variation of a `test_per_src` module.
1834 // We do not add this variation to `filesInfo`, as it has no output;
1835 // however, we do add the other variations of this module as indirect
1836 // dependencies (see below).
Roland Levillain9b5fde92019-06-28 15:41:19 +01001837 } else {
Roland Levillainf89cd092019-07-29 16:22:59 +01001838 // Single-output test module (where `test_per_src: false`).
Jiyong Park1833cef2019-12-13 13:28:36 +09001839 af := apexFileForExecutable(ctx, ccTest)
Jiyong Parkf653b052019-11-18 15:39:01 +09001840 af.class = nativeTest
1841 filesInfo = append(filesInfo, af)
Roland Levillain9b5fde92019-06-28 15:41:19 +01001842 }
Jiyong Parkaf9539f2020-05-04 10:31:32 +09001843 return true // track transitive dependencies
Roland Levillain630846d2019-06-26 12:48:34 +01001844 } else {
1845 ctx.PropertyErrorf("tests", "%q is not a cc module", depName)
1846 }
Jiyong Parkff1458f2018-10-12 21:49:38 +09001847 case keyTag:
1848 if key, ok := child.(*apexKey); ok {
Jaewoong Jung18aefc12020-12-21 09:11:10 -08001849 a.privateKeyFile = key.privateKeyFile
1850 a.publicKeyFile = key.publicKeyFile
Jiyong Parkff1458f2018-10-12 21:49:38 +09001851 } else {
1852 ctx.PropertyErrorf("key", "%q is not an apex_key module", depName)
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001853 }
Jiyong Parkf653b052019-11-18 15:39:01 +09001854 return false
Jiyong Parkc00cbd92018-10-30 21:20:05 +09001855 case certificateTag:
1856 if dep, ok := child.(*java.AndroidAppCertificate); ok {
Jaewoong Jung18aefc12020-12-21 09:11:10 -08001857 a.containerCertificateFile = dep.Certificate.Pem
1858 a.containerPrivateKeyFile = dep.Certificate.Key
Jiyong Parkc00cbd92018-10-30 21:20:05 +09001859 } else {
1860 ctx.ModuleErrorf("certificate dependency %q must be an android_app_certificate module", depName)
1861 }
Jiyong Park03b68dd2019-07-26 23:20:40 +09001862 case android.PrebuiltDepTag:
1863 // If the prebuilt is force disabled, remember to delete the prebuilt file
1864 // that might have been installed in the previous builds
Jiyong Park10e926b2020-07-16 21:38:56 +09001865 if prebuilt, ok := child.(prebuilt); ok && prebuilt.isForceDisabled() {
Jiyong Park03b68dd2019-07-26 23:20:40 +09001866 a.prebuiltFileToDelete = prebuilt.InstallFilename()
1867 }
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001868 }
Jooyung Han8aee2042019-10-29 05:08:31 +09001869 } else if !a.vndkApex {
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001870 // indirect dependencies
Jooyung Han9c80bae2019-08-20 17:30:57 +09001871 if am, ok := child.(android.ApexModule); ok {
Roland Levillainf89cd092019-07-29 16:22:59 +01001872 // We cannot use a switch statement on `depTag` here as the checked
1873 // tags used below are private (e.g. `cc.sharedDepTag`).
Jiyong Park52cd06f2019-11-11 10:14:32 +09001874 if cc.IsSharedDepTag(depTag) || cc.IsRuntimeDepTag(depTag) {
Roland Levillainf89cd092019-07-29 16:22:59 +01001875 if cc, ok := child.(*cc.Module); ok {
Jooyung Handf78e212020-07-22 15:54:47 +09001876 if cc.UseVndk() && proptools.Bool(a.properties.Use_vndk_as_stable) && cc.IsVndk() {
Jooyung Han6c4cc9c2020-07-29 16:00:54 +09001877 requireNativeLibs = append(requireNativeLibs, ":vndk")
Jooyung Handf78e212020-07-22 15:54:47 +09001878 return false
1879 }
Jiyong Parkf1493cc2020-05-29 21:29:20 +09001880 af := apexFileForNativeLibrary(ctx, cc, handleSpecialLibs)
1881 af.transitiveDep = true
Martin Stjernholmf2635ec2020-12-16 01:01:59 +00001882
1883 // Always track transitive dependencies for host.
1884 if a.Host() {
1885 filesInfo = append(filesInfo, af)
1886 return true
1887 }
1888
Colin Cross56a83212020-09-15 18:30:11 -07001889 abInfo := ctx.Provider(ApexBundleInfoProvider).(ApexBundleInfo)
Martin Stjernholmf2635ec2020-12-16 01:01:59 +00001890 if !abInfo.Contents.DirectlyInApex(depName) && (cc.IsStubs() || cc.HasStubsVariants()) {
Roland Levillainf89cd092019-07-29 16:22:59 +01001891 // If the dependency is a stubs lib, don't include it in this APEX,
1892 // but make sure that the lib is installed on the device.
1893 // In case no APEX is having the lib, the lib is installed to the system
1894 // partition.
1895 //
1896 // Always include if we are a host-apex however since those won't have any
1897 // system libraries.
Colin Cross56a83212020-09-15 18:30:11 -07001898 if !am.DirectlyInAnyApex() {
Jooyung Hanefb184e2020-06-25 17:14:25 +09001899 // we need a module name for Make
Martin Stjernholm2856c662020-12-02 15:03:42 +00001900 name := cc.ImplementationModuleNameForMake(ctx)
Colin Cross0477b422020-10-13 18:43:54 -07001901
1902 if !proptools.Bool(a.properties.Use_vendor) {
Jooyung Hanefb184e2020-06-25 17:14:25 +09001903 // we don't use subName(.vendor) for a "use_vendor: true" apex
1904 // which is supposed to be installed in /system
Colin Cross0477b422020-10-13 18:43:54 -07001905 name += cc.Properties.SubName
Jooyung Hanefb184e2020-06-25 17:14:25 +09001906 }
1907 if !android.InList(name, a.requiredDeps) {
1908 a.requiredDeps = append(a.requiredDeps, name)
1909 }
Roland Levillainf89cd092019-07-29 16:22:59 +01001910 }
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09001911 requireNativeLibs = append(requireNativeLibs, af.stem())
Roland Levillainf89cd092019-07-29 16:22:59 +01001912 // Don't track further
1913 return false
1914 }
Jiyong Parke3867542020-12-03 17:28:25 +09001915
1916 // If the dep is not considered to be in the same
1917 // apex, don't add it to filesInfo so that it is not
1918 // included in this APEX.
1919 // TODO(jiyong): move this to at the top of the
1920 // else-if clause for the indirect dependencies.
1921 // Currently, that's impossible because we would
1922 // like to record requiredNativeLibs even when
Martin Stjernholmf2635ec2020-12-16 01:01:59 +00001923 // DepIsInSameAPex is false. We also shouldn't do
1924 // this for host.
Paul Duffin4c3e8e22021-03-18 15:41:29 +00001925 //
1926 // TODO(jiyong): explain why the same module is passed in twice.
1927 // Switching the first am to parent breaks lots of tests.
1928 if !android.IsDepInSameApex(ctx, am, am) {
Jiyong Parke3867542020-12-03 17:28:25 +09001929 return false
1930 }
1931
Jiyong Parkf653b052019-11-18 15:39:01 +09001932 filesInfo = append(filesInfo, af)
1933 return true // track transitive dependencies
Jiyong Parkf2cc1b72020-12-09 00:20:45 +09001934 } else if rm, ok := child.(*rust.Module); ok {
1935 af := apexFileForRustLibrary(ctx, rm)
1936 af.transitiveDep = true
1937 filesInfo = append(filesInfo, af)
1938 return true // track transitive dependencies
Jiyong Park25fc6a92018-11-18 18:02:45 +09001939 }
Roland Levillainf89cd092019-07-29 16:22:59 +01001940 } else if cc.IsTestPerSrcDepTag(depTag) {
1941 if cc, ok := child.(*cc.Module); ok {
Jiyong Park1833cef2019-12-13 13:28:36 +09001942 af := apexFileForExecutable(ctx, cc)
Roland Levillainf89cd092019-07-29 16:22:59 +01001943 // Handle modules created as `test_per_src` variations of a single test module:
1944 // use the name of the generated test binary (`fileToCopy`) instead of the name
1945 // of the original test module (`depName`, shared by all `test_per_src`
1946 // variations of that module).
Yo Chiange8128052020-07-23 20:09:18 +08001947 af.androidMkModuleName = filepath.Base(af.builtFile.String())
Jiyong Park7cd10e32020-01-14 09:22:18 +09001948 // these are not considered transitive dep
1949 af.transitiveDep = false
Jiyong Parkf653b052019-11-18 15:39:01 +09001950 filesInfo = append(filesInfo, af)
1951 return true // track transitive dependencies
Roland Levillainf89cd092019-07-29 16:22:59 +01001952 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09001953 } else if cc.IsHeaderDepTag(depTag) {
1954 // nothing
Jiyong Park52cd06f2019-11-11 10:14:32 +09001955 } else if java.IsJniDepTag(depTag) {
Jooyung Hanb7bebe22020-02-25 16:59:29 +09001956 // Because APK-in-APEX embeds jni_libs transitively, we don't need to track transitive deps
1957 return false
Jiyong Parke3833882020-02-17 17:28:10 +09001958 } else if java.IsXmlPermissionsFileDepTag(depTag) {
Jaewoong Jung4b79e982020-06-01 10:45:49 -07001959 if prebuilt, ok := child.(prebuilt_etc.PrebuiltEtcModule); ok {
Jiyong Parke3833882020-02-17 17:28:10 +09001960 filesInfo = append(filesInfo, apexFileForPrebuiltEtc(ctx, prebuilt, depName))
1961 }
Jiyong Park99644e92020-11-17 22:21:02 +09001962 } else if rust.IsDylibDepTag(depTag) {
1963 if rustm, ok := child.(*rust.Module); ok && rustm.IsInstallableToApex() {
1964 af := apexFileForRustLibrary(ctx, rustm)
1965 af.transitiveDep = true
1966 filesInfo = append(filesInfo, af)
1967 return true // track transitive dependencies
1968 }
Jiyong Park94e22fd2021-04-08 18:19:15 +09001969 } else if rust.IsRlibDepTag(depTag) {
1970 // Rlib is statically linked, but it might have shared lib
1971 // dependencies. Track them.
1972 return true
Paul Duffin65898052021-04-20 22:47:03 +01001973 } else if java.IsBootclasspathFragmentContentDepTag(depTag) {
Paul Duffin94f19632021-04-20 12:40:07 +01001974 // Add the contents of the bootclasspath fragment to the apex.
Paul Duffin4d101b62021-03-24 15:42:20 +00001975 switch child.(type) {
1976 case *java.Library, *java.SdkLibrary:
Paul Duffincc33ec82021-04-25 23:14:55 +01001977 javaModule := child.(javaModule)
Paul Duffin190fdef2021-04-26 10:33:59 +01001978 af := apexFileForBootclasspathFragmentContentModule(ctx, parent, javaModule)
Paul Duffin4d101b62021-03-24 15:42:20 +00001979 if !af.ok() {
Paul Duffin94f19632021-04-20 12:40:07 +01001980 ctx.PropertyErrorf("bootclasspath_fragments", "bootclasspath_fragment content %q is not configured to be compiled into dex", depName)
Paul Duffin4d101b62021-03-24 15:42:20 +00001981 return false
1982 }
1983 filesInfo = append(filesInfo, af)
1984 return true // track transitive dependencies
1985 default:
Paul Duffin94f19632021-04-20 12:40:07 +01001986 ctx.PropertyErrorf("bootclasspath_fragments", "bootclasspath_fragment content %q of type %q is not supported", depName, ctx.OtherModuleType(child))
Paul Duffin4d101b62021-03-24 15:42:20 +00001987 }
satayev333a1732021-05-17 21:35:26 +01001988 } else if java.IsSystemServerClasspathFragmentContentDepTag(depTag) {
1989 // Add the contents of the systemserverclasspath fragment to the apex.
1990 switch child.(type) {
1991 case *java.Library, *java.SdkLibrary:
1992 af := apexFileForJavaModule(ctx, child.(javaModule))
1993 filesInfo = append(filesInfo, af)
1994 return true // track transitive dependencies
1995 default:
1996 ctx.PropertyErrorf("systemserverclasspath_fragments", "systemserverclasspath_fragment content %q of type %q is not supported", depName, ctx.OtherModuleType(child))
1997 }
Colin Cross56a83212020-09-15 18:30:11 -07001998 } else if _, ok := depTag.(android.CopyDirectlyInAnyApexTag); ok {
1999 // nothing
Jooyung Han9c80bae2019-08-20 17:30:57 +09002000 } else if am.CanHaveApexVariants() && am.IsInstallableToApex() {
Jiyong Park1c7e9622020-05-07 16:12:13 +09002001 ctx.ModuleErrorf("unexpected tag %s for indirect dependency %q", android.PrettyPrintTag(depTag), depName)
Jiyong Park48ca7dc2018-10-10 14:01:00 +09002002 }
2003 }
2004 }
2005 return false
2006 })
Jaewoong Jung18aefc12020-12-21 09:11:10 -08002007 if a.privateKeyFile == nil {
Jaewoong Jung4cfdf7d2021-04-20 16:21:24 -07002008 ctx.PropertyErrorf("key", "private_key for %q could not be found", String(a.overridableProperties.Key))
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09002009 return
2010 }
Jiyong Park48ca7dc2018-10-10 14:01:00 +09002011
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09002012 // Remove duplicates in filesInfo
Jiyong Park8fd61922018-11-08 02:50:25 +09002013 removeDup := func(filesInfo []apexFile) []apexFile {
Jiyong Park7cd10e32020-01-14 09:22:18 +09002014 encountered := make(map[string]apexFile)
Jiyong Park8fd61922018-11-08 02:50:25 +09002015 for _, f := range filesInfo {
Jooyung Han344d5432019-08-23 11:17:39 +09002016 dest := filepath.Join(f.installDir, f.builtFile.Base())
Jiyong Park7cd10e32020-01-14 09:22:18 +09002017 if e, ok := encountered[dest]; !ok {
2018 encountered[dest] = f
2019 } else {
2020 // If a module is directly included and also transitively depended on
2021 // consider it as directly included.
2022 e.transitiveDep = e.transitiveDep && f.transitiveDep
2023 encountered[dest] = e
Jiyong Park8fd61922018-11-08 02:50:25 +09002024 }
2025 }
Jiyong Park7cd10e32020-01-14 09:22:18 +09002026 var result []apexFile
2027 for _, v := range encountered {
2028 result = append(result, v)
2029 }
Jiyong Park8fd61922018-11-08 02:50:25 +09002030 return result
2031 }
2032 filesInfo = removeDup(filesInfo)
2033
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09002034 // Sort to have consistent build rules
Jiyong Park8fd61922018-11-08 02:50:25 +09002035 sort.Slice(filesInfo, func(i, j int) bool {
Paul Duffin56060292021-05-15 19:34:05 +01002036 // Sort by destination path so as to ensure consistent ordering even if the source of the files
2037 // changes.
2038 return filesInfo[i].path() < filesInfo[j].path()
Jiyong Park8fd61922018-11-08 02:50:25 +09002039 })
2040
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09002041 ////////////////////////////////////////////////////////////////////////////////////////////
2042 // 3) some fields in apexBundle struct are configured
Jiyong Park8fd61922018-11-08 02:50:25 +09002043 a.installDir = android.PathForModuleInstall(ctx, "apex")
2044 a.filesInfo = filesInfo
Alex Light5098a612018-11-29 17:12:15 -08002045
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09002046 // Set suffix and primaryApexType depending on the ApexType
Martin Stjernholmcb3ff1e2021-05-25 00:28:27 +01002047 buildFlattenedAsDefault := ctx.Config().FlattenApex()
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09002048 switch a.properties.ApexType {
2049 case imageApex:
2050 if buildFlattenedAsDefault {
2051 a.suffix = imageApexSuffix
2052 } else {
2053 a.suffix = ""
2054 a.primaryApexType = true
2055
2056 if ctx.Config().InstallExtraFlattenedApexes() {
2057 a.requiredDeps = append(a.requiredDeps, a.Name()+flattenedSuffix)
2058 }
2059 }
2060 case zipApex:
2061 if proptools.String(a.properties.Payload_type) == "zip" {
2062 a.suffix = ""
2063 a.primaryApexType = true
2064 } else {
2065 a.suffix = zipApexSuffix
2066 }
2067 case flattenedApex:
2068 if buildFlattenedAsDefault {
2069 a.suffix = ""
2070 a.primaryApexType = true
2071 } else {
2072 a.suffix = flattenedSuffix
2073 }
2074 }
2075
Theotime Combes4ba38c12020-06-12 12:46:59 +00002076 switch proptools.StringDefault(a.properties.Payload_fs_type, ext4FsType) {
2077 case ext4FsType:
2078 a.payloadFsType = ext4
2079 case f2fsFsType:
2080 a.payloadFsType = f2fs
2081 default:
2082 ctx.PropertyErrorf("payload_fs_type", "%q is not a valid filesystem for apex [ext4, f2fs]", *a.properties.Payload_fs_type)
2083 }
2084
Jiyong Park7cd10e32020-01-14 09:22:18 +09002085 // Optimization. If we are building bundled APEX, for the files that are gathered due to the
2086 // transitive dependencies, don't place them inside the APEX, but place a symlink pointing
2087 // the same library in the system partition, thus effectively sharing the same libraries
2088 // across the APEX boundary. For unbundled APEX, all the gathered files are actually placed
2089 // in the APEX.
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09002090 a.linkToSystemLib = !ctx.Config().UnbundledBuild() && a.installable() && !proptools.Bool(a.properties.Use_vendor)
Jooyung Han54aca7b2019-11-20 02:26:02 +09002091
Jooyung Han85d61762020-06-24 23:50:26 +09002092 // APEXes targeting other than system/system_ext partitions use vendor/product variants.
2093 // So we can't link them to /system/lib libs which are core variants.
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09002094 if a.SocSpecific() || a.DeviceSpecific() || (a.ProductSpecific() && ctx.Config().EnforceProductPartitionInterface()) {
Jooyung Han85d61762020-06-24 23:50:26 +09002095 a.linkToSystemLib = false
2096 }
2097
Jiyong Park4da07972021-01-05 21:01:11 +09002098 forced := ctx.Config().ForceApexSymlinkOptimization()
2099
Jiyong Park9d677202020-02-19 16:29:35 +09002100 // We don't need the optimization for updatable APEXes, as it might give false signal
Jiyong Park4da07972021-01-05 21:01:11 +09002101 // to the system health when the APEXes are still bundled (b/149805758).
2102 if !forced && a.Updatable() && a.properties.ApexType == imageApex {
Jiyong Park9d677202020-02-19 16:29:35 +09002103 a.linkToSystemLib = false
2104 }
2105
Jiyong Park638d30e2020-02-26 18:27:19 +09002106 // We also don't want the optimization for host APEXes, because it doesn't make sense.
2107 if ctx.Host() {
2108 a.linkToSystemLib = false
2109 }
2110
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09002111 a.compatSymlinks = makeCompatSymlinks(a.BaseModuleName(), ctx)
2112
2113 ////////////////////////////////////////////////////////////////////////////////////////////
2114 // 4) generate the build rules to create the APEX. This is done in builder.go.
2115 a.buildManifest(ctx, provideNativeLibs, requireNativeLibs)
Jooyung Han01a3ee22019-11-02 02:52:25 +09002116 if a.properties.ApexType == flattenedApex {
2117 a.buildFlattenedApex(ctx)
2118 } else {
2119 a.buildUnflattenedApex(ctx)
2120 }
Jiyong Park956305c2020-01-09 12:32:06 +09002121 a.buildApexDependencyInfo(ctx)
Colin Cross08dca382020-07-21 20:31:17 -07002122 a.buildLintReports(ctx)
Jiyong Parkb81b9902020-11-24 19:51:18 +09002123
2124 // Append meta-files to the filesInfo list so that they are reflected in Android.mk as well.
2125 if a.installable() {
2126 // For flattened APEX, make sure that APEX manifest and apex_pubkey are also copied
2127 // along with other ordinary files. (Note that this is done by apexer for
2128 // non-flattened APEXes)
2129 a.filesInfo = append(a.filesInfo, newApexFile(ctx, a.manifestPbOut, "apex_manifest.pb", ".", etc, nil))
2130
2131 // Place the public key as apex_pubkey. This is also done by apexer for
2132 // non-flattened APEXes case.
2133 // TODO(jiyong): Why do we need this CP rule?
2134 copiedPubkey := android.PathForModuleOut(ctx, "apex_pubkey")
2135 ctx.Build(pctx, android.BuildParams{
2136 Rule: android.Cp,
Jaewoong Jung18aefc12020-12-21 09:11:10 -08002137 Input: a.publicKeyFile,
Jiyong Parkb81b9902020-11-24 19:51:18 +09002138 Output: copiedPubkey,
2139 })
2140 a.filesInfo = append(a.filesInfo, newApexFile(ctx, copiedPubkey, "apex_pubkey", ".", etc, nil))
2141 }
Jooyung Han01a3ee22019-11-02 02:52:25 +09002142}
2143
Paul Duffincc33ec82021-04-25 23:14:55 +01002144// apexBootclasspathFragmentFiles returns the list of apexFile structures defining the files that
2145// the bootclasspath_fragment contributes to the apex.
2146func apexBootclasspathFragmentFiles(ctx android.ModuleContext, module blueprint.Module) []apexFile {
2147 bootclasspathFragmentInfo := ctx.OtherModuleProvider(module, java.BootclasspathFragmentApexContentInfoProvider).(java.BootclasspathFragmentApexContentInfo)
2148 var filesToAdd []apexFile
2149
2150 // Add the boot image files, e.g. .art, .oat and .vdex files.
2151 for arch, files := range bootclasspathFragmentInfo.AndroidBootImageFilesByArchType() {
2152 dirInApex := filepath.Join("javalib", arch.String())
2153 for _, f := range files {
2154 androidMkModuleName := "javalib_" + arch.String() + "_" + filepath.Base(f.String())
2155 // TODO(b/177892522) - consider passing in the bootclasspath fragment module here instead of nil
2156 af := newApexFile(ctx, f, androidMkModuleName, dirInApex, etc, nil)
2157 filesToAdd = append(filesToAdd, af)
2158 }
2159 }
2160
satayev3db35472021-05-06 23:59:58 +01002161 // Add classpaths.proto config.
satayev14e49132021-05-17 21:03:07 +01002162 filesToAdd = append(filesToAdd, apexClasspathFragmentProtoFile(ctx, module))
satayev3db35472021-05-06 23:59:58 +01002163
Paul Duffincc33ec82021-04-25 23:14:55 +01002164 return filesToAdd
2165}
2166
satayev14e49132021-05-17 21:03:07 +01002167// apexClasspathFragmentProtoFile returns apexFile structure defining the classpath.proto config that
2168// the module contributes to the apex.
2169func apexClasspathFragmentProtoFile(ctx android.ModuleContext, module blueprint.Module) apexFile {
2170 fragmentInfo := ctx.OtherModuleProvider(module, java.ClasspathFragmentProtoContentInfoProvider).(java.ClasspathFragmentProtoContentInfo)
2171 classpathProtoOutput := fragmentInfo.ClasspathFragmentProtoOutput
2172 return newApexFile(ctx, classpathProtoOutput, classpathProtoOutput.Base(), fragmentInfo.ClasspathFragmentProtoInstallDir.Rel(), etc, nil)
2173}
2174
Paul Duffincc33ec82021-04-25 23:14:55 +01002175// apexFileForBootclasspathFragmentContentModule creates an apexFile for a bootclasspath_fragment
2176// content module, i.e. a library that is part of the bootclasspath.
Paul Duffin190fdef2021-04-26 10:33:59 +01002177func apexFileForBootclasspathFragmentContentModule(ctx android.ModuleContext, fragmentModule blueprint.Module, javaModule javaModule) apexFile {
2178 bootclasspathFragmentInfo := ctx.OtherModuleProvider(fragmentModule, java.BootclasspathFragmentApexContentInfoProvider).(java.BootclasspathFragmentApexContentInfo)
2179
2180 // Get the dexBootJar from the bootclasspath_fragment as that is responsible for performing the
2181 // hidden API encpding.
Paul Duffin1a8010a2021-05-15 12:39:23 +01002182 dexBootJar, err := bootclasspathFragmentInfo.DexBootJarPathForContentModule(javaModule)
2183 if err != nil {
2184 ctx.ModuleErrorf("%s", err)
2185 }
Paul Duffin190fdef2021-04-26 10:33:59 +01002186
2187 // Create an apexFile as for a normal java module but with the dex boot jar provided by the
2188 // bootclasspath_fragment.
2189 af := apexFileForJavaModuleWithFile(ctx, javaModule, dexBootJar)
2190 return af
Paul Duffincc33ec82021-04-25 23:14:55 +01002191}
2192
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09002193///////////////////////////////////////////////////////////////////////////////////////////////////
2194// Factory functions
2195//
2196
2197func newApexBundle() *apexBundle {
2198 module := &apexBundle{}
2199
2200 module.AddProperties(&module.properties)
2201 module.AddProperties(&module.targetProperties)
Jiyong Park59140302020-12-14 18:44:04 +09002202 module.AddProperties(&module.archProperties)
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09002203 module.AddProperties(&module.overridableProperties)
2204
2205 android.InitAndroidMultiTargetsArchModule(module, android.HostAndDeviceSupported, android.MultilibCommon)
2206 android.InitDefaultableModule(module)
2207 android.InitSdkAwareModule(module)
2208 android.InitOverridableModule(module, &module.overridableProperties.Overrides)
2209 return module
2210}
2211
2212func ApexBundleFactory(testApex bool, artApex bool) android.Module {
2213 bundle := newApexBundle()
2214 bundle.testApex = testApex
2215 bundle.artApex = artApex
2216 return bundle
2217}
2218
2219// apex_test is an APEX for testing. The difference from the ordinary apex module type is that
2220// certain compatibility checks such as apex_available are not done for apex_test.
2221func testApexBundleFactory() android.Module {
2222 bundle := newApexBundle()
2223 bundle.testApex = true
2224 return bundle
2225}
2226
2227// apex packages other modules into an APEX file which is a packaging format for system-level
2228// components like binaries, shared libraries, etc.
2229func BundleFactory() android.Module {
2230 return newApexBundle()
2231}
2232
2233type Defaults struct {
2234 android.ModuleBase
2235 android.DefaultsModuleBase
2236}
2237
2238// apex_defaults provides defaultable properties to other apex modules.
2239func defaultsFactory() android.Module {
2240 return DefaultsFactory()
2241}
2242
2243func DefaultsFactory(props ...interface{}) android.Module {
2244 module := &Defaults{}
2245
2246 module.AddProperties(props...)
2247 module.AddProperties(
2248 &apexBundleProperties{},
2249 &apexTargetBundleProperties{},
2250 &overridableProperties{},
2251 )
2252
2253 android.InitDefaultsModule(module)
2254 return module
2255}
2256
2257type OverrideApex struct {
2258 android.ModuleBase
2259 android.OverrideModuleBase
2260}
2261
2262func (o *OverrideApex) GenerateAndroidBuildActions(ctx android.ModuleContext) {
2263 // All the overrides happen in the base module.
2264}
2265
2266// override_apex is used to create an apex module based on another apex module by overriding some of
2267// its properties.
2268func overrideApexFactory() android.Module {
2269 m := &OverrideApex{}
2270
2271 m.AddProperties(&overridableProperties{})
2272
2273 android.InitAndroidMultiTargetsArchModule(m, android.DeviceSupported, android.MultilibCommon)
2274 android.InitOverrideModule(m)
2275 return m
2276}
2277
2278///////////////////////////////////////////////////////////////////////////////////////////////////
2279// Vality check routines
2280//
2281// These are called in at the very beginning of GenerateAndroidBuildActions to flag an error when
2282// certain conditions are not met.
2283//
2284// TODO(jiyong): move these checks to a separate go file.
2285
2286// Entures that min_sdk_version of the included modules are equal or less than the min_sdk_version
2287// of this apexBundle.
2288func (a *apexBundle) checkMinSdkVersion(ctx android.ModuleContext) {
2289 if a.testApex || a.vndkApex {
2290 return
2291 }
2292 // Meaningless to check min_sdk_version when building use_vendor modules against non-Trebleized targets
2293 if proptools.Bool(a.properties.Use_vendor) && ctx.DeviceConfig().VndkVersion() == "" {
2294 return
2295 }
2296 // apexBundle::minSdkVersion reports its own errors.
2297 minSdkVersion := a.minSdkVersion(ctx)
2298 android.CheckMinSdkVersion(a, ctx, minSdkVersion)
2299}
2300
2301func (a *apexBundle) minSdkVersion(ctx android.BaseModuleContext) android.ApiLevel {
2302 ver := proptools.String(a.properties.Min_sdk_version)
2303 if ver == "" {
Jooyung Haned124c32021-01-26 11:43:46 +09002304 return android.NoneApiLevel
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09002305 }
2306 apiLevel, err := android.ApiLevelFromUser(ctx, ver)
2307 if err != nil {
2308 ctx.PropertyErrorf("min_sdk_version", "%s", err.Error())
2309 return android.NoneApiLevel
2310 }
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09002311 return apiLevel
2312}
2313
2314// Ensures that a lib providing stub isn't statically linked
2315func (a *apexBundle) checkStaticLinkingToStubLibraries(ctx android.ModuleContext) {
2316 // Practically, we only care about regular APEXes on the device.
2317 if ctx.Host() || a.testApex || a.vndkApex {
2318 return
2319 }
2320
2321 abInfo := ctx.Provider(ApexBundleInfoProvider).(ApexBundleInfo)
2322
2323 a.WalkPayloadDeps(ctx, func(ctx android.ModuleContext, from blueprint.Module, to android.ApexModule, externalDep bool) bool {
2324 if ccm, ok := to.(*cc.Module); ok {
2325 apexName := ctx.ModuleName()
2326 fromName := ctx.OtherModuleName(from)
2327 toName := ctx.OtherModuleName(to)
2328
2329 // If `to` is not actually in the same APEX as `from` then it does not need
2330 // apex_available and neither do any of its dependencies.
Paul Duffin4c3e8e22021-03-18 15:41:29 +00002331 //
2332 // It is ok to call DepIsInSameApex() directly from within WalkPayloadDeps().
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09002333 if am, ok := from.(android.DepIsInSameApex); ok && !am.DepIsInSameApex(ctx, to) {
2334 // As soon as the dependency graph crosses the APEX boundary, don't go further.
2335 return false
2336 }
2337
2338 // The dynamic linker and crash_dump tool in the runtime APEX is the only
2339 // exception to this rule. It can't make the static dependencies dynamic
2340 // because it can't do the dynamic linking for itself.
Kiyoung Kim4098c7e2020-11-30 14:42:14 +09002341 // Same rule should be applied to linkerconfig, because it should be executed
2342 // only with static linked libraries before linker is available with ld.config.txt
2343 if apexName == "com.android.runtime" && (fromName == "linker" || fromName == "crash_dump" || fromName == "linkerconfig") {
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09002344 return false
2345 }
2346
2347 isStubLibraryFromOtherApex := ccm.HasStubsVariants() && !abInfo.Contents.DirectlyInApex(toName)
2348 if isStubLibraryFromOtherApex && !externalDep {
2349 ctx.ModuleErrorf("%q required by %q is a native library providing stub. "+
2350 "It shouldn't be included in this APEX via static linking. Dependency path: %s", to.String(), fromName, ctx.GetPathString(false))
2351 }
2352
2353 }
2354 return true
2355 })
2356}
2357
Artur Satayev8cf899a2020-04-15 17:29:42 +01002358// Enforce that Java deps of the apex are using stable SDKs to compile
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09002359func (a *apexBundle) checkUpdatable(ctx android.ModuleContext) {
2360 if a.Updatable() {
2361 if String(a.properties.Min_sdk_version) == "" {
2362 ctx.PropertyErrorf("updatable", "updatable APEXes should set min_sdk_version as well")
2363 }
2364 a.checkJavaStableSdkVersion(ctx)
2365 }
2366}
2367
Artur Satayev8cf899a2020-04-15 17:29:42 +01002368func (a *apexBundle) checkJavaStableSdkVersion(ctx android.ModuleContext) {
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09002369 // Visit direct deps only. As long as we guarantee top-level deps are using stable SDKs,
2370 // java's checkLinkType guarantees correct usage for transitive deps
Artur Satayev8cf899a2020-04-15 17:29:42 +01002371 ctx.VisitDirectDepsBlueprint(func(module blueprint.Module) {
2372 tag := ctx.OtherModuleDependencyTag(module)
2373 switch tag {
2374 case javaLibTag, androidAppTag:
Jiyong Park92315372021-04-02 08:45:46 +09002375 if m, ok := module.(interface {
2376 CheckStableSdkVersion(ctx android.BaseModuleContext) error
2377 }); ok {
2378 if err := m.CheckStableSdkVersion(ctx); err != nil {
Artur Satayev8cf899a2020-04-15 17:29:42 +01002379 ctx.ModuleErrorf("cannot depend on \"%v\": %v", ctx.OtherModuleName(module), err)
2380 }
2381 }
2382 }
2383 })
2384}
2385
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09002386// Ensures that the all the dependencies are marked as available for this APEX
2387func (a *apexBundle) checkApexAvailability(ctx android.ModuleContext) {
2388 // Let's be practical. Availability for test, host, and the VNDK apex isn't important
2389 if ctx.Host() || a.testApex || a.vndkApex {
2390 return
2391 }
2392
2393 // Because APEXes targeting other than system/system_ext partitions can't set
2394 // apex_available, we skip checks for these APEXes
2395 if a.SocSpecific() || a.DeviceSpecific() || (a.ProductSpecific() && ctx.Config().EnforceProductPartitionInterface()) {
2396 return
2397 }
2398
2399 // Coverage build adds additional dependencies for the coverage-only runtime libraries.
2400 // Requiring them and their transitive depencies with apex_available is not right
2401 // because they just add noise.
2402 if ctx.Config().IsEnvTrue("EMMA_INSTRUMENT") || a.IsNativeCoverageNeeded(ctx) {
2403 return
2404 }
2405
2406 a.WalkPayloadDeps(ctx, func(ctx android.ModuleContext, from blueprint.Module, to android.ApexModule, externalDep bool) bool {
2407 // As soon as the dependency graph crosses the APEX boundary, don't go further.
2408 if externalDep {
2409 return false
2410 }
2411
2412 apexName := ctx.ModuleName()
2413 fromName := ctx.OtherModuleName(from)
2414 toName := ctx.OtherModuleName(to)
2415
2416 // If `to` is not actually in the same APEX as `from` then it does not need
2417 // apex_available and neither do any of its dependencies.
Paul Duffin4c3e8e22021-03-18 15:41:29 +00002418 //
2419 // It is ok to call DepIsInSameApex() directly from within WalkPayloadDeps().
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09002420 if am, ok := from.(android.DepIsInSameApex); ok && !am.DepIsInSameApex(ctx, to) {
2421 // As soon as the dependency graph crosses the APEX boundary, don't go
2422 // further.
2423 return false
2424 }
2425
2426 if to.AvailableFor(apexName) || baselineApexAvailable(apexName, toName) {
2427 return true
2428 }
Jiyong Park767dbd92021-03-04 13:03:10 +09002429 ctx.ModuleErrorf("%q requires %q that doesn't list the APEX under 'apex_available'."+
2430 "\n\nDependency path:%s\n\n"+
2431 "Consider adding %q to 'apex_available' property of %q",
2432 fromName, toName, ctx.GetPathString(true), apexName, toName)
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09002433 // Visit this module's dependencies to check and report any issues with their availability.
2434 return true
2435 })
2436}
2437
2438var (
2439 apexAvailBaseline = makeApexAvailableBaseline()
2440 inverseApexAvailBaseline = invertApexBaseline(apexAvailBaseline)
2441)
2442
Colin Cross440e0d02020-06-11 11:32:11 -07002443func baselineApexAvailable(apex, moduleName string) bool {
Anton Hanssoneec79eb2020-01-10 15:12:39 +00002444 key := apex
Paul Duffin7d74e7b2020-03-06 12:30:13 +00002445 moduleName = normalizeModuleName(moduleName)
2446
Colin Cross440e0d02020-06-11 11:32:11 -07002447 if val, ok := apexAvailBaseline[key]; ok && android.InList(moduleName, val) {
Paul Duffin7d74e7b2020-03-06 12:30:13 +00002448 return true
2449 }
2450
2451 key = android.AvailableToAnyApex
Colin Cross440e0d02020-06-11 11:32:11 -07002452 if val, ok := apexAvailBaseline[key]; ok && android.InList(moduleName, val) {
Paul Duffin7d74e7b2020-03-06 12:30:13 +00002453 return true
2454 }
2455
2456 return false
2457}
2458
2459func normalizeModuleName(moduleName string) string {
Jiyong Park0f80c182020-01-31 02:49:53 +09002460 // Prebuilt modules (e.g. java_import, etc.) have "prebuilt_" prefix added by the build
2461 // system. Trim the prefix for the check since they are confusing
Paul Duffind23c7262020-12-11 18:13:08 +00002462 moduleName = android.RemoveOptionalPrebuiltPrefix(moduleName)
Jiyong Park0f80c182020-01-31 02:49:53 +09002463 if strings.HasPrefix(moduleName, "libclang_rt.") {
2464 // This module has many arch variants that depend on the product being built.
2465 // We don't want to list them all
2466 moduleName = "libclang_rt"
Anton Hanssoneec79eb2020-01-10 15:12:39 +00002467 }
Jooyung Hanacc7bbe2020-05-20 09:06:00 +09002468 if strings.HasPrefix(moduleName, "androidx.") {
2469 // TODO(b/156996905) Set apex_available/min_sdk_version for androidx support libraries
2470 moduleName = "androidx"
2471 }
Paul Duffin7d74e7b2020-03-06 12:30:13 +00002472 return moduleName
Anton Hanssoneec79eb2020-01-10 15:12:39 +00002473}
2474
Jiyong Park8e6d52f2020-11-19 14:37:47 +09002475// Transform the map of apex -> modules to module -> apexes.
2476func invertApexBaseline(m map[string][]string) map[string][]string {
2477 r := make(map[string][]string)
2478 for apex, modules := range m {
2479 for _, module := range modules {
2480 r[module] = append(r[module], apex)
2481 }
2482 }
2483 return r
2484}
2485
2486// Retrieve the baseline of apexes to which the supplied module belongs.
2487func BaselineApexAvailable(moduleName string) []string {
2488 return inverseApexAvailBaseline[normalizeModuleName(moduleName)]
2489}
2490
Jiyong Parkc0ec6f92020-11-19 23:00:52 +09002491// This is a map from apex to modules, which overrides the apex_available setting for that
2492// particular module to make it available for the apex regardless of its setting.
Jiyong Park8e6d52f2020-11-19 14:37:47 +09002493// TODO(b/147364041): remove this
2494func makeApexAvailableBaseline() map[string][]string {
2495 // The "Module separator"s below are employed to minimize merge conflicts.
2496 m := make(map[string][]string)
2497 //
2498 // Module separator
2499 //
2500 m["com.android.appsearch"] = []string{
2501 "icing-java-proto-lite",
2502 "libprotobuf-java-lite",
2503 }
2504 //
2505 // Module separator
2506 //
2507 m["com.android.bluetooth.updatable"] = []string{
2508 "android.hardware.audio.common@5.0",
2509 "android.hardware.bluetooth.a2dp@1.0",
2510 "android.hardware.bluetooth.audio@2.0",
2511 "android.hardware.bluetooth@1.0",
2512 "android.hardware.bluetooth@1.1",
2513 "android.hardware.graphics.bufferqueue@1.0",
2514 "android.hardware.graphics.bufferqueue@2.0",
2515 "android.hardware.graphics.common@1.0",
2516 "android.hardware.graphics.common@1.1",
2517 "android.hardware.graphics.common@1.2",
2518 "android.hardware.media@1.0",
2519 "android.hidl.safe_union@1.0",
2520 "android.hidl.token@1.0",
2521 "android.hidl.token@1.0-utils",
2522 "avrcp-target-service",
2523 "avrcp_headers",
2524 "bluetooth-protos-lite",
2525 "bluetooth.mapsapi",
2526 "com.android.vcard",
2527 "dnsresolver_aidl_interface-V2-java",
2528 "ipmemorystore-aidl-interfaces-V5-java",
2529 "ipmemorystore-aidl-interfaces-java",
2530 "internal_include_headers",
2531 "lib-bt-packets",
2532 "lib-bt-packets-avrcp",
2533 "lib-bt-packets-base",
2534 "libFraunhoferAAC",
2535 "libaudio-a2dp-hw-utils",
2536 "libaudio-hearing-aid-hw-utils",
Jiyong Park8e6d52f2020-11-19 14:37:47 +09002537 "libbluetooth",
2538 "libbluetooth-types",
2539 "libbluetooth-types-header",
2540 "libbluetooth_gd",
2541 "libbluetooth_headers",
2542 "libbluetooth_jni",
2543 "libbt-audio-hal-interface",
2544 "libbt-bta",
2545 "libbt-common",
2546 "libbt-hci",
2547 "libbt-platform-protos-lite",
2548 "libbt-protos-lite",
2549 "libbt-sbc-decoder",
2550 "libbt-sbc-encoder",
2551 "libbt-stack",
2552 "libbt-utils",
2553 "libbtcore",
2554 "libbtdevice",
2555 "libbte",
2556 "libbtif",
2557 "libchrome",
2558 "libevent",
2559 "libfmq",
2560 "libg722codec",
2561 "libgui_headers",
2562 "libmedia_headers",
2563 "libmodpb64",
2564 "libosi",
2565 "libstagefright_foundation_headers",
2566 "libstagefright_headers",
2567 "libstatslog",
2568 "libstatssocket",
2569 "libtinyxml2",
2570 "libudrv-uipc",
2571 "libz",
2572 "media_plugin_headers",
2573 "net-utils-services-common",
2574 "netd_aidl_interface-unstable-java",
2575 "netd_event_listener_interface-java",
2576 "netlink-client",
2577 "networkstack-client",
2578 "sap-api-java-static",
2579 "services.net",
2580 }
2581 //
2582 // Module separator
2583 //
2584 m["com.android.cellbroadcast"] = []string{"CellBroadcastApp", "CellBroadcastServiceModule"}
2585 //
2586 // Module separator
2587 //
2588 m["com.android.extservices"] = []string{
2589 "error_prone_annotations",
2590 "ExtServices-core",
2591 "ExtServices",
2592 "libtextclassifier-java",
2593 "libz_current",
2594 "textclassifier-statsd",
2595 "TextClassifierNotificationLibNoManifest",
2596 "TextClassifierServiceLibNoManifest",
2597 }
2598 //
2599 // Module separator
2600 //
2601 m["com.android.neuralnetworks"] = []string{
2602 "android.hardware.neuralnetworks@1.0",
2603 "android.hardware.neuralnetworks@1.1",
2604 "android.hardware.neuralnetworks@1.2",
2605 "android.hardware.neuralnetworks@1.3",
2606 "android.hidl.allocator@1.0",
2607 "android.hidl.memory.token@1.0",
2608 "android.hidl.memory@1.0",
2609 "android.hidl.safe_union@1.0",
2610 "libarect",
2611 "libbuildversion",
2612 "libmath",
2613 "libprocpartition",
2614 "libsync",
2615 }
2616 //
2617 // Module separator
2618 //
2619 m["com.android.media"] = []string{
2620 "android.frameworks.bufferhub@1.0",
2621 "android.hardware.cas.native@1.0",
2622 "android.hardware.cas@1.0",
2623 "android.hardware.configstore-utils",
2624 "android.hardware.configstore@1.0",
2625 "android.hardware.configstore@1.1",
2626 "android.hardware.graphics.allocator@2.0",
2627 "android.hardware.graphics.allocator@3.0",
2628 "android.hardware.graphics.bufferqueue@1.0",
2629 "android.hardware.graphics.bufferqueue@2.0",
2630 "android.hardware.graphics.common@1.0",
2631 "android.hardware.graphics.common@1.1",
2632 "android.hardware.graphics.common@1.2",
2633 "android.hardware.graphics.mapper@2.0",
2634 "android.hardware.graphics.mapper@2.1",
2635 "android.hardware.graphics.mapper@3.0",
2636 "android.hardware.media.omx@1.0",
2637 "android.hardware.media@1.0",
2638 "android.hidl.allocator@1.0",
2639 "android.hidl.memory.token@1.0",
2640 "android.hidl.memory@1.0",
2641 "android.hidl.token@1.0",
2642 "android.hidl.token@1.0-utils",
2643 "bionic_libc_platform_headers",
2644 "exoplayer2-extractor",
2645 "exoplayer2-extractor-annotation-stubs",
2646 "gl_headers",
2647 "jsr305",
2648 "libEGL",
2649 "libEGL_blobCache",
2650 "libEGL_getProcAddress",
2651 "libFLAC",
2652 "libFLAC-config",
2653 "libFLAC-headers",
2654 "libGLESv2",
2655 "libaacextractor",
2656 "libamrextractor",
2657 "libarect",
2658 "libaudio_system_headers",
2659 "libaudioclient",
2660 "libaudioclient_headers",
2661 "libaudiofoundation",
2662 "libaudiofoundation_headers",
2663 "libaudiomanager",
2664 "libaudiopolicy",
2665 "libaudioutils",
2666 "libaudioutils_fixedfft",
Jiyong Park8e6d52f2020-11-19 14:37:47 +09002667 "libbluetooth-types-header",
2668 "libbufferhub",
2669 "libbufferhub_headers",
2670 "libbufferhubqueue",
2671 "libc_malloc_debug_backtrace",
2672 "libcamera_client",
2673 "libcamera_metadata",
2674 "libdvr_headers",
2675 "libexpat",
2676 "libfifo",
2677 "libflacextractor",
2678 "libgrallocusage",
2679 "libgraphicsenv",
2680 "libgui",
2681 "libgui_headers",
2682 "libhardware_headers",
2683 "libinput",
2684 "liblzma",
2685 "libmath",
2686 "libmedia",
2687 "libmedia_codeclist",
2688 "libmedia_headers",
2689 "libmedia_helper",
2690 "libmedia_helper_headers",
2691 "libmedia_midiiowrapper",
2692 "libmedia_omx",
2693 "libmediautils",
2694 "libmidiextractor",
2695 "libmkvextractor",
2696 "libmp3extractor",
2697 "libmp4extractor",
2698 "libmpeg2extractor",
2699 "libnativebase_headers",
2700 "libnativewindow_headers",
2701 "libnblog",
2702 "liboggextractor",
2703 "libpackagelistparser",
2704 "libpdx",
2705 "libpdx_default_transport",
2706 "libpdx_headers",
2707 "libpdx_uds",
2708 "libprocinfo",
2709 "libspeexresampler",
2710 "libspeexresampler",
2711 "libstagefright_esds",
2712 "libstagefright_flacdec",
2713 "libstagefright_flacdec",
2714 "libstagefright_foundation",
2715 "libstagefright_foundation_headers",
2716 "libstagefright_foundation_without_imemory",
2717 "libstagefright_headers",
2718 "libstagefright_id3",
2719 "libstagefright_metadatautils",
2720 "libstagefright_mpeg2extractor",
2721 "libstagefright_mpeg2support",
2722 "libsync",
2723 "libui",
2724 "libui_headers",
2725 "libunwindstack",
2726 "libvibrator",
2727 "libvorbisidec",
2728 "libwavextractor",
2729 "libwebm",
2730 "media_ndk_headers",
2731 "media_plugin_headers",
2732 "updatable-media",
2733 }
2734 //
2735 // Module separator
2736 //
2737 m["com.android.media.swcodec"] = []string{
2738 "android.frameworks.bufferhub@1.0",
2739 "android.hardware.common-ndk_platform",
2740 "android.hardware.configstore-utils",
2741 "android.hardware.configstore@1.0",
2742 "android.hardware.configstore@1.1",
2743 "android.hardware.graphics.allocator@2.0",
2744 "android.hardware.graphics.allocator@3.0",
2745 "android.hardware.graphics.allocator@4.0",
2746 "android.hardware.graphics.bufferqueue@1.0",
2747 "android.hardware.graphics.bufferqueue@2.0",
2748 "android.hardware.graphics.common-ndk_platform",
2749 "android.hardware.graphics.common@1.0",
2750 "android.hardware.graphics.common@1.1",
2751 "android.hardware.graphics.common@1.2",
2752 "android.hardware.graphics.mapper@2.0",
2753 "android.hardware.graphics.mapper@2.1",
2754 "android.hardware.graphics.mapper@3.0",
2755 "android.hardware.graphics.mapper@4.0",
2756 "android.hardware.media.bufferpool@2.0",
2757 "android.hardware.media.c2@1.0",
2758 "android.hardware.media.c2@1.1",
2759 "android.hardware.media.omx@1.0",
2760 "android.hardware.media@1.0",
2761 "android.hardware.media@1.0",
2762 "android.hidl.memory.token@1.0",
2763 "android.hidl.memory@1.0",
2764 "android.hidl.safe_union@1.0",
2765 "android.hidl.token@1.0",
2766 "android.hidl.token@1.0-utils",
2767 "libEGL",
2768 "libFLAC",
2769 "libFLAC-config",
2770 "libFLAC-headers",
2771 "libFraunhoferAAC",
2772 "libLibGuiProperties",
2773 "libarect",
2774 "libaudio_system_headers",
2775 "libaudioutils",
2776 "libaudioutils",
2777 "libaudioutils_fixedfft",
2778 "libavcdec",
2779 "libavcenc",
2780 "libavservices_minijail",
2781 "libavservices_minijail",
Jiyong Park8e6d52f2020-11-19 14:37:47 +09002782 "libbinderthreadstateutils",
2783 "libbluetooth-types-header",
2784 "libbufferhub_headers",
2785 "libcodec2",
2786 "libcodec2_headers",
2787 "libcodec2_hidl@1.0",
2788 "libcodec2_hidl@1.1",
2789 "libcodec2_internal",
2790 "libcodec2_soft_aacdec",
2791 "libcodec2_soft_aacenc",
2792 "libcodec2_soft_amrnbdec",
2793 "libcodec2_soft_amrnbenc",
2794 "libcodec2_soft_amrwbdec",
2795 "libcodec2_soft_amrwbenc",
2796 "libcodec2_soft_av1dec_gav1",
2797 "libcodec2_soft_avcdec",
2798 "libcodec2_soft_avcenc",
2799 "libcodec2_soft_common",
2800 "libcodec2_soft_flacdec",
2801 "libcodec2_soft_flacenc",
2802 "libcodec2_soft_g711alawdec",
2803 "libcodec2_soft_g711mlawdec",
2804 "libcodec2_soft_gsmdec",
2805 "libcodec2_soft_h263dec",
2806 "libcodec2_soft_h263enc",
2807 "libcodec2_soft_hevcdec",
2808 "libcodec2_soft_hevcenc",
2809 "libcodec2_soft_mp3dec",
2810 "libcodec2_soft_mpeg2dec",
2811 "libcodec2_soft_mpeg4dec",
2812 "libcodec2_soft_mpeg4enc",
2813 "libcodec2_soft_opusdec",
2814 "libcodec2_soft_opusenc",
2815 "libcodec2_soft_rawdec",
2816 "libcodec2_soft_vorbisdec",
2817 "libcodec2_soft_vp8dec",
2818 "libcodec2_soft_vp8enc",
2819 "libcodec2_soft_vp9dec",
2820 "libcodec2_soft_vp9enc",
2821 "libcodec2_vndk",
2822 "libdvr_headers",
2823 "libfmq",
2824 "libfmq",
2825 "libgav1",
2826 "libgralloctypes",
2827 "libgrallocusage",
2828 "libgraphicsenv",
2829 "libgsm",
2830 "libgui_bufferqueue_static",
2831 "libgui_headers",
2832 "libhardware",
2833 "libhardware_headers",
2834 "libhevcdec",
2835 "libhevcenc",
2836 "libion",
2837 "libjpeg",
2838 "liblzma",
2839 "libmath",
2840 "libmedia_codecserviceregistrant",
2841 "libmedia_headers",
2842 "libmpeg2dec",
2843 "libnativebase_headers",
2844 "libnativewindow_headers",
2845 "libpdx_headers",
2846 "libscudo_wrapper",
2847 "libsfplugin_ccodec_utils",
2848 "libspeexresampler",
2849 "libstagefright_amrnb_common",
2850 "libstagefright_amrnbdec",
2851 "libstagefright_amrnbenc",
2852 "libstagefright_amrwbdec",
2853 "libstagefright_amrwbenc",
2854 "libstagefright_bufferpool@2.0.1",
2855 "libstagefright_bufferqueue_helper",
2856 "libstagefright_enc_common",
2857 "libstagefright_flacdec",
2858 "libstagefright_foundation",
2859 "libstagefright_foundation_headers",
2860 "libstagefright_headers",
2861 "libstagefright_m4vh263dec",
2862 "libstagefright_m4vh263enc",
2863 "libstagefright_mp3dec",
2864 "libsync",
2865 "libui",
2866 "libui_headers",
2867 "libunwindstack",
2868 "libvorbisidec",
2869 "libvpx",
2870 "libyuv",
2871 "libyuv_static",
2872 "media_ndk_headers",
2873 "media_plugin_headers",
2874 "mediaswcodec",
2875 }
2876 //
2877 // Module separator
2878 //
2879 m["com.android.mediaprovider"] = []string{
2880 "MediaProvider",
2881 "MediaProviderGoogle",
2882 "fmtlib_ndk",
2883 "libbase_ndk",
2884 "libfuse",
2885 "libfuse_jni",
2886 }
2887 //
2888 // Module separator
2889 //
2890 m["com.android.permission"] = []string{
2891 "car-ui-lib",
2892 "iconloader",
2893 "kotlin-annotations",
2894 "kotlin-stdlib",
2895 "kotlin-stdlib-jdk7",
2896 "kotlin-stdlib-jdk8",
2897 "kotlinx-coroutines-android",
2898 "kotlinx-coroutines-android-nodeps",
2899 "kotlinx-coroutines-core",
2900 "kotlinx-coroutines-core-nodeps",
2901 "permissioncontroller-statsd",
2902 "GooglePermissionController",
2903 "PermissionController",
2904 "SettingsLibActionBarShadow",
2905 "SettingsLibAppPreference",
2906 "SettingsLibBarChartPreference",
2907 "SettingsLibLayoutPreference",
2908 "SettingsLibProgressBar",
2909 "SettingsLibSearchWidget",
2910 "SettingsLibSettingsTheme",
2911 "SettingsLibRestrictedLockUtils",
2912 "SettingsLibHelpUtils",
2913 }
2914 //
2915 // Module separator
2916 //
2917 m["com.android.runtime"] = []string{
2918 "bionic_libc_platform_headers",
2919 "libarm-optimized-routines-math",
2920 "libc_aeabi",
2921 "libc_bionic",
2922 "libc_bionic_ndk",
2923 "libc_bootstrap",
2924 "libc_common",
2925 "libc_common_shared",
2926 "libc_common_static",
2927 "libc_dns",
2928 "libc_dynamic_dispatch",
2929 "libc_fortify",
2930 "libc_freebsd",
2931 "libc_freebsd_large_stack",
2932 "libc_gdtoa",
2933 "libc_init_dynamic",
2934 "libc_init_static",
2935 "libc_jemalloc_wrapper",
2936 "libc_netbsd",
2937 "libc_nomalloc",
2938 "libc_nopthread",
2939 "libc_openbsd",
2940 "libc_openbsd_large_stack",
2941 "libc_openbsd_ndk",
2942 "libc_pthread",
2943 "libc_static_dispatch",
2944 "libc_syscalls",
2945 "libc_tzcode",
2946 "libc_unwind_static",
2947 "libdebuggerd",
2948 "libdebuggerd_common_headers",
2949 "libdebuggerd_handler_core",
2950 "libdebuggerd_handler_fallback",
2951 "libdl_static",
2952 "libjemalloc5",
2953 "liblinker_main",
2954 "liblinker_malloc",
2955 "liblz4",
2956 "liblzma",
2957 "libprocinfo",
2958 "libpropertyinfoparser",
2959 "libscudo",
2960 "libstdc++",
2961 "libsystemproperties",
2962 "libtombstoned_client_static",
2963 "libunwindstack",
2964 "libz",
2965 "libziparchive",
2966 }
2967 //
2968 // Module separator
2969 //
2970 m["com.android.tethering"] = []string{
2971 "android.hardware.tetheroffload.config-V1.0-java",
2972 "android.hardware.tetheroffload.control-V1.0-java",
2973 "android.hidl.base-V1.0-java",
2974 "libcgrouprc",
2975 "libcgrouprc_format",
2976 "libtetherutilsjni",
2977 "libvndksupport",
2978 "net-utils-framework-common",
2979 "netd_aidl_interface-V3-java",
2980 "netlink-client",
2981 "networkstack-aidl-interfaces-java",
2982 "tethering-aidl-interfaces-java",
2983 "TetheringApiCurrentLib",
2984 }
2985 //
2986 // Module separator
2987 //
2988 m["com.android.wifi"] = []string{
2989 "PlatformProperties",
2990 "android.hardware.wifi-V1.0-java",
2991 "android.hardware.wifi-V1.0-java-constants",
2992 "android.hardware.wifi-V1.1-java",
2993 "android.hardware.wifi-V1.2-java",
2994 "android.hardware.wifi-V1.3-java",
2995 "android.hardware.wifi-V1.4-java",
2996 "android.hardware.wifi.hostapd-V1.0-java",
2997 "android.hardware.wifi.hostapd-V1.1-java",
2998 "android.hardware.wifi.hostapd-V1.2-java",
2999 "android.hardware.wifi.supplicant-V1.0-java",
3000 "android.hardware.wifi.supplicant-V1.1-java",
3001 "android.hardware.wifi.supplicant-V1.2-java",
3002 "android.hardware.wifi.supplicant-V1.3-java",
3003 "android.hidl.base-V1.0-java",
3004 "android.hidl.manager-V1.0-java",
3005 "android.hidl.manager-V1.1-java",
3006 "android.hidl.manager-V1.2-java",
3007 "bouncycastle-unbundled",
3008 "dnsresolver_aidl_interface-V2-java",
3009 "error_prone_annotations",
3010 "framework-wifi-pre-jarjar",
3011 "framework-wifi-util-lib",
3012 "ipmemorystore-aidl-interfaces-V3-java",
3013 "ipmemorystore-aidl-interfaces-java",
3014 "ksoap2",
3015 "libnanohttpd",
3016 "libwifi-jni",
3017 "net-utils-services-common",
3018 "netd_aidl_interface-V2-java",
3019 "netd_aidl_interface-unstable-java",
3020 "netd_event_listener_interface-java",
3021 "netlink-client",
3022 "networkstack-client",
3023 "services.net",
3024 "wifi-lite-protos",
3025 "wifi-nano-protos",
3026 "wifi-service-pre-jarjar",
3027 "wifi-service-resources",
3028 }
3029 //
3030 // Module separator
3031 //
Jiyong Park8e6d52f2020-11-19 14:37:47 +09003032 m["com.android.os.statsd"] = []string{
3033 "libstatssocket",
3034 }
3035 //
3036 // Module separator
3037 //
3038 m[android.AvailableToAnyApex] = []string{
3039 // TODO(b/156996905) Set apex_available/min_sdk_version for androidx/extras support libraries
3040 "androidx",
3041 "androidx-constraintlayout_constraintlayout",
3042 "androidx-constraintlayout_constraintlayout-nodeps",
3043 "androidx-constraintlayout_constraintlayout-solver",
3044 "androidx-constraintlayout_constraintlayout-solver-nodeps",
3045 "com.google.android.material_material",
3046 "com.google.android.material_material-nodeps",
3047
Jiyong Park8e6d52f2020-11-19 14:37:47 +09003048 "libclang_rt",
Jiyong Park8e6d52f2020-11-19 14:37:47 +09003049 "libprofile-clang-extras",
3050 "libprofile-clang-extras_ndk",
3051 "libprofile-extras",
3052 "libprofile-extras_ndk",
Ryan Prichardb35a85e2021-01-13 19:18:53 -08003053 "libunwind",
Jiyong Park8e6d52f2020-11-19 14:37:47 +09003054 }
3055 return m
3056}
3057
3058func init() {
3059 android.AddNeverAllowRules(createApexPermittedPackagesRules(qModulesPackages())...)
3060 android.AddNeverAllowRules(createApexPermittedPackagesRules(rModulesPackages())...)
3061}
3062
3063func createApexPermittedPackagesRules(modules_packages map[string][]string) []android.Rule {
3064 rules := make([]android.Rule, 0, len(modules_packages))
3065 for module_name, module_packages := range modules_packages {
Jaewoong Jung18aefc12020-12-21 09:11:10 -08003066 permittedPackagesRule := android.NeverAllow().
Jiyong Park8e6d52f2020-11-19 14:37:47 +09003067 BootclasspathJar().
3068 With("apex_available", module_name).
3069 WithMatcher("permitted_packages", android.NotInList(module_packages)).
3070 Because("jars that are part of the " + module_name +
3071 " module may only allow these packages: " + strings.Join(module_packages, ",") +
3072 ". Please jarjar or move code around.")
Jaewoong Jung18aefc12020-12-21 09:11:10 -08003073 rules = append(rules, permittedPackagesRule)
Jiyong Park8e6d52f2020-11-19 14:37:47 +09003074 }
3075 return rules
3076}
3077
3078// DO NOT EDIT! These are the package prefixes that are exempted from being AOT'ed by ART.
3079// Adding code to the bootclasspath in new packages will cause issues on module update.
3080func qModulesPackages() map[string][]string {
3081 return map[string][]string{
3082 "com.android.conscrypt": []string{
3083 "android.net.ssl",
3084 "com.android.org.conscrypt",
3085 },
3086 "com.android.media": []string{
3087 "android.media",
3088 },
3089 }
3090}
3091
3092// DO NOT EDIT! These are the package prefixes that are exempted from being AOT'ed by ART.
3093// Adding code to the bootclasspath in new packages will cause issues on module update.
3094func rModulesPackages() map[string][]string {
3095 return map[string][]string{
3096 "com.android.mediaprovider": []string{
3097 "android.provider",
3098 },
3099 "com.android.permission": []string{
3100 "android.permission",
3101 "android.app.role",
3102 "com.android.permission",
3103 "com.android.role",
3104 },
3105 "com.android.sdkext": []string{
3106 "android.os.ext",
3107 },
3108 "com.android.os.statsd": []string{
3109 "android.app",
3110 "android.os",
3111 "android.util",
3112 "com.android.internal.statsd",
3113 "com.android.server.stats",
3114 },
3115 "com.android.wifi": []string{
3116 "com.android.server.wifi",
3117 "com.android.wifi.x",
3118 "android.hardware.wifi",
3119 "android.net.wifi",
3120 },
3121 "com.android.tethering": []string{
3122 "android.net",
3123 },
3124 }
3125}