blob: 0fa3b2a2fff8848a56fbada40a866429fe33938f [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
15package apex
16
17import (
18 "fmt"
Jooyung Han54aca7b2019-11-20 02:26:02 +090019 "path"
Jiyong Park48ca7dc2018-10-10 14:01:00 +090020 "path/filepath"
Jiyong Parkab3ceb32018-10-10 14:05:29 +090021 "sort"
Jiyong Park48ca7dc2018-10-10 14:01:00 +090022 "strings"
Jooyung Han344d5432019-08-23 11:17:39 +090023 "sync"
Jiyong Park48ca7dc2018-10-10 14:01:00 +090024
25 "android/soong/android"
26 "android/soong/cc"
27 "android/soong/java"
Alex Light778127a2019-02-27 14:19:50 -080028 "android/soong/python"
Jiyong Park48ca7dc2018-10-10 14:01:00 +090029
30 "github.com/google/blueprint"
Alex Light778127a2019-02-27 14:19:50 -080031 "github.com/google/blueprint/bootstrap"
Jiyong Park48ca7dc2018-10-10 14:01:00 +090032 "github.com/google/blueprint/proptools"
33)
34
Jooyung Han72bd2f82019-10-23 16:46:38 +090035const (
36 imageApexSuffix = ".apex"
37 zipApexSuffix = ".zipapex"
Sundong Ahnabb64432019-10-22 13:58:29 +090038 flattenedSuffix = ".flattened"
Alex Light5098a612018-11-29 17:12:15 -080039
Sundong Ahnabb64432019-10-22 13:58:29 +090040 imageApexType = "image"
41 zipApexType = "zip"
42 flattenedApexType = "flattened"
Jooyung Han72bd2f82019-10-23 16:46:38 +090043)
Jiyong Park48ca7dc2018-10-10 14:01:00 +090044
45type dependencyTag struct {
46 blueprint.BaseDependencyTag
47 name string
48}
49
50var (
Jiyong Parkc00cbd92018-10-30 21:20:05 +090051 sharedLibTag = dependencyTag{name: "sharedLib"}
52 executableTag = dependencyTag{name: "executable"}
53 javaLibTag = dependencyTag{name: "javaLib"}
54 prebuiltTag = dependencyTag{name: "prebuilt"}
Roland Levillain630846d2019-06-26 12:48:34 +010055 testTag = dependencyTag{name: "test"}
Jiyong Parkc00cbd92018-10-30 21:20:05 +090056 keyTag = dependencyTag{name: "key"}
57 certificateTag = dependencyTag{name: "certificate"}
Jooyung Han5c998b92019-06-27 11:30:33 +090058 usesTag = dependencyTag{name: "uses"}
Sundong Ahne1f05aa2019-08-27 13:55:42 +090059 androidAppTag = dependencyTag{name: "androidApp"}
Jiyong Park48ca7dc2018-10-10 14:01:00 +090060)
61
62func init() {
Jiyong Parkd1063c12019-07-17 20:08:41 +090063 android.RegisterModuleType("apex", BundleFactory)
Alex Light0851b882019-02-07 13:20:53 -080064 android.RegisterModuleType("apex_test", testApexBundleFactory)
Jooyung Han344d5432019-08-23 11:17:39 +090065 android.RegisterModuleType("apex_vndk", vndkApexBundleFactory)
Jiyong Park30ca9372019-02-07 16:27:23 +090066 android.RegisterModuleType("apex_defaults", defaultsFactory)
Jaewoong Jung939ebd52019-03-26 15:07:36 -070067 android.RegisterModuleType("prebuilt_apex", PrebuiltFactory)
Jiyong Park5d790c32019-11-15 18:40:32 +090068 android.RegisterModuleType("override_apex", overrideApexFactory)
Jiyong Park48ca7dc2018-10-10 14:01:00 +090069
Jooyung Han31c470b2019-10-18 16:26:59 +090070 android.PreDepsMutators(RegisterPreDepsMutators)
Jiyong Parkd1063c12019-07-17 20:08:41 +090071 android.PostDepsMutators(RegisterPostDepsMutators)
Jooyung Han7a78a922019-10-08 21:59:58 +090072
73 android.RegisterMakeVarsProvider(pctx, func(ctx android.MakeVarsContext) {
74 apexFileContextsInfos := apexFileContextsInfos(ctx.Config())
75 sort.Strings(*apexFileContextsInfos)
76 ctx.Strict("APEX_FILE_CONTEXTS_INFOS", strings.Join(*apexFileContextsInfos, " "))
77 })
Jiyong Parkd1063c12019-07-17 20:08:41 +090078}
79
Jooyung Han31c470b2019-10-18 16:26:59 +090080func RegisterPreDepsMutators(ctx android.RegisterMutatorsContext) {
81 ctx.TopDown("apex_vndk", apexVndkMutator).Parallel()
82 ctx.BottomUp("apex_vndk_deps", apexVndkDepsMutator).Parallel()
83}
84
Jiyong Parkd1063c12019-07-17 20:08:41 +090085func RegisterPostDepsMutators(ctx android.RegisterMutatorsContext) {
Jiyong Parka308ea12019-11-15 10:38:39 +090086 ctx.BottomUp("apex_deps", apexDepsMutator)
Jiyong Parkd1063c12019-07-17 20:08:41 +090087 ctx.BottomUp("apex", apexMutator).Parallel()
88 ctx.BottomUp("apex_flattened", apexFlattenedMutator).Parallel()
89 ctx.BottomUp("apex_uses", apexUsesMutator).Parallel()
Jiyong Park48ca7dc2018-10-10 14:01:00 +090090}
91
Jiyong Park48ca7dc2018-10-10 14:01:00 +090092// Mark the direct and transitive dependencies of apex bundles so that they
93// can be built for the apex bundles.
Jiyong Parka308ea12019-11-15 10:38:39 +090094func apexDepsMutator(mctx android.BottomUpMutatorContext) {
Alex Lightf98087f2019-02-04 14:45:06 -080095 if a, ok := mctx.Module().(*apexBundle); ok {
Colin Crossa4925902018-11-16 11:36:28 -080096 apexBundleName := mctx.ModuleName()
Jiyong Park48ca7dc2018-10-10 14:01:00 +090097 mctx.WalkDeps(func(child, parent android.Module) bool {
Jiyong Park0ddfcd12018-12-11 01:35:25 +090098 depName := mctx.OtherModuleName(child)
99 // If the parent is apexBundle, this child is directly depended.
100 _, directDep := parent.(*apexBundle)
Alex Light0851b882019-02-07 13:20:53 -0800101 if a.installable() && !a.testApex {
Alex Lightf98087f2019-02-04 14:45:06 -0800102 // TODO(b/123892969): Workaround for not having any way to annotate test-apexs
103 // non-installable apex's cannot be installed and so should not prevent libraries from being
104 // installed to the system.
105 android.UpdateApexDependency(apexBundleName, depName, directDep)
106 }
Jiyong Park0ddfcd12018-12-11 01:35:25 +0900107
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900108 if am, ok := child.(android.ApexModule); ok && am.CanHaveApexVariants() {
Jiyong Park0ddfcd12018-12-11 01:35:25 +0900109 am.BuildForApex(apexBundleName)
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900110 return true
111 } else {
112 return false
113 }
114 })
115 }
116}
117
118// Create apex variations if a module is included in APEX(s).
119func apexMutator(mctx android.BottomUpMutatorContext) {
120 if am, ok := mctx.Module().(android.ApexModule); ok && am.CanHaveApexVariants() {
Jiyong Park0ddfcd12018-12-11 01:35:25 +0900121 am.CreateApexVariations(mctx)
Jooyung Han54aca7b2019-11-20 02:26:02 +0900122 } else if _, ok := mctx.Module().(*apexBundle); ok {
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900123 // apex bundle itself is mutated so that it and its modules have same
124 // apex variant.
125 apexBundleName := mctx.ModuleName()
126 mctx.CreateVariations(apexBundleName)
Jiyong Park5d790c32019-11-15 18:40:32 +0900127 } else if o, ok := mctx.Module().(*OverrideApex); ok {
128 apexBundleName := o.GetOverriddenModuleName()
129 if apexBundleName == "" {
130 mctx.ModuleErrorf("base property is not set")
131 return
132 }
133 mctx.CreateVariations(apexBundleName)
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900134 }
Jiyong Park5d790c32019-11-15 18:40:32 +0900135
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900136}
Sundong Ahne9b55722019-09-06 17:37:42 +0900137
Jooyung Han7a78a922019-10-08 21:59:58 +0900138var (
139 apexFileContextsInfosKey = android.NewOnceKey("apexFileContextsInfosKey")
140 apexFileContextsInfosMutex sync.Mutex
141)
142
143func apexFileContextsInfos(config android.Config) *[]string {
144 return config.Once(apexFileContextsInfosKey, func() interface{} {
145 return &[]string{}
146 }).(*[]string)
147}
148
Jooyung Han54aca7b2019-11-20 02:26:02 +0900149func addFlattenedFileContextsInfos(ctx android.BaseModuleContext, fileContextsInfo string) {
Jooyung Han7a78a922019-10-08 21:59:58 +0900150 apexFileContextsInfosMutex.Lock()
151 defer apexFileContextsInfosMutex.Unlock()
152 apexFileContextsInfos := apexFileContextsInfos(ctx.Config())
Jooyung Han54aca7b2019-11-20 02:26:02 +0900153 *apexFileContextsInfos = append(*apexFileContextsInfos, fileContextsInfo)
Jooyung Han7a78a922019-10-08 21:59:58 +0900154}
155
Sundong Ahne9b55722019-09-06 17:37:42 +0900156func apexFlattenedMutator(mctx android.BottomUpMutatorContext) {
Sundong Ahne8fb7242019-09-17 13:50:45 +0900157 if ab, ok := mctx.Module().(*apexBundle); ok {
Sundong Ahnabb64432019-10-22 13:58:29 +0900158 var variants []string
159 switch proptools.StringDefault(ab.properties.Payload_type, "image") {
160 case "image":
161 variants = append(variants, imageApexType, flattenedApexType)
162 case "zip":
163 variants = append(variants, zipApexType)
164 case "both":
165 variants = append(variants, imageApexType, zipApexType, flattenedApexType)
166 default:
Sundong Ahnd95aa2d2019-10-08 19:34:03 +0900167 mctx.PropertyErrorf("type", "%q is not one of \"image\", \"zip\", or \"both\".", *ab.properties.Payload_type)
Sundong Ahnabb64432019-10-22 13:58:29 +0900168 return
169 }
170
171 modules := mctx.CreateLocalVariations(variants...)
172
173 for i, v := range variants {
174 switch v {
175 case imageApexType:
176 modules[i].(*apexBundle).properties.ApexType = imageApex
177 case zipApexType:
178 modules[i].(*apexBundle).properties.ApexType = zipApex
179 case flattenedApexType:
180 modules[i].(*apexBundle).properties.ApexType = flattenedApex
Jooyung Han91df2082019-11-20 01:49:42 +0900181 if !mctx.Config().FlattenApex() && ab.Platform() {
Sundong Ahnd95aa2d2019-10-08 19:34:03 +0900182 modules[i].(*apexBundle).MakeAsSystemExt()
183 }
Sundong Ahnabb64432019-10-22 13:58:29 +0900184 }
Sundong Ahne9b55722019-09-06 17:37:42 +0900185 }
Jiyong Park5d790c32019-11-15 18:40:32 +0900186 } else if _, ok := mctx.Module().(*OverrideApex); ok {
187 mctx.CreateVariations(imageApexType, flattenedApexType)
Sundong Ahne9b55722019-09-06 17:37:42 +0900188 }
189}
190
Jooyung Han5c998b92019-06-27 11:30:33 +0900191func apexUsesMutator(mctx android.BottomUpMutatorContext) {
192 if ab, ok := mctx.Module().(*apexBundle); ok {
193 mctx.AddFarVariationDependencies(nil, usesTag, ab.properties.Uses...)
194 }
195}
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900196
Jooyung Handc782442019-11-01 03:14:38 +0900197var (
198 useVendorWhitelistKey = android.NewOnceKey("useVendorWhitelist")
199)
200
201// useVendorWhitelist returns the list of APEXes which are allowed to use_vendor.
202// When use_vendor is used, native modules are built with __ANDROID_VNDK__ and __ANDROID_APEX__,
203// which may cause compatibility issues. (e.g. libbinder)
204// Even though libbinder restricts its availability via 'apex_available' property and relies on
205// yet another macro __ANDROID_APEX_<NAME>__, we restrict usage of "use_vendor:" from other APEX modules
206// to avoid similar problems.
207func useVendorWhitelist(config android.Config) []string {
208 return config.Once(useVendorWhitelistKey, func() interface{} {
209 return []string{
210 // swcodec uses "vendor" variants for smaller size
211 "com.android.media.swcodec",
212 "test_com.android.media.swcodec",
213 }
214 }).([]string)
215}
216
217// setUseVendorWhitelistForTest overrides useVendorWhitelist and must be
218// called before the first call to useVendorWhitelist()
219func setUseVendorWhitelistForTest(config android.Config, whitelist []string) {
220 config.Once(useVendorWhitelistKey, func() interface{} {
221 return whitelist
222 })
223}
224
Alex Light9670d332019-01-29 18:07:33 -0800225type apexNativeDependencies struct {
226 // List of native libraries
227 Native_shared_libs []string
Jooyung Han344d5432019-08-23 11:17:39 +0900228
Alex Light9670d332019-01-29 18:07:33 -0800229 // List of native executables
230 Binaries []string
Jooyung Han344d5432019-08-23 11:17:39 +0900231
Roland Levillain630846d2019-06-26 12:48:34 +0100232 // List of native tests
233 Tests []string
Alex Light9670d332019-01-29 18:07:33 -0800234}
Jooyung Han344d5432019-08-23 11:17:39 +0900235
Alex Light9670d332019-01-29 18:07:33 -0800236type apexMultilibProperties struct {
237 // Native dependencies whose compile_multilib is "first"
238 First apexNativeDependencies
239
240 // Native dependencies whose compile_multilib is "both"
241 Both apexNativeDependencies
242
243 // Native dependencies whose compile_multilib is "prefer32"
244 Prefer32 apexNativeDependencies
245
246 // Native dependencies whose compile_multilib is "32"
247 Lib32 apexNativeDependencies
248
249 // Native dependencies whose compile_multilib is "64"
250 Lib64 apexNativeDependencies
251}
252
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900253type apexBundleProperties struct {
254 // Json manifest file describing meta info of this APEX bundle. Default:
Dario Freni4abb1dc2018-11-20 18:04:58 +0000255 // "apex_manifest.json"
Colin Cross27b922f2019-03-04 22:35:41 -0800256 Manifest *string `android:"path"`
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900257
Jiyong Park40e26a22019-02-08 02:53:06 +0900258 // AndroidManifest.xml file used for the zip container of this APEX bundle.
259 // If unspecified, a default one is automatically generated.
Colin Cross27b922f2019-03-04 22:35:41 -0800260 AndroidManifest *string `android:"path"`
Jiyong Park40e26a22019-02-08 02:53:06 +0900261
Roland Levillain411c5842019-09-19 16:37:20 +0100262 // Canonical name of the APEX bundle. Used to determine the path to the activated APEX on
263 // device (/apex/<apex_name>).
264 // If unspecified, defaults to the value of name.
Jiyong Park05e70dd2019-03-18 14:26:32 +0900265 Apex_name *string
266
Jiyong Parkd0a65ba2018-11-10 06:37:15 +0900267 // Determines the file contexts file for setting security context to each file in this APEX bundle.
Jooyung Han54aca7b2019-11-20 02:26:02 +0900268 // For platform APEXes, this should points to a file under /system/sepolicy
269 // Default: /system/sepolicy/apex/<module_name>_file_contexts.
270 File_contexts *string `android:"path"`
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900271
272 // List of native shared libs that are embedded inside this APEX bundle
273 Native_shared_libs []string
274
Roland Levillain630846d2019-06-26 12:48:34 +0100275 // List of executables that are embedded inside this APEX bundle
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900276 Binaries []string
277
278 // List of java libraries that are embedded inside this APEX bundle
279 Java_libs []string
280
281 // List of prebuilt files that are embedded inside this APEX bundle
282 Prebuilts []string
Jiyong Parkff1458f2018-10-12 21:49:38 +0900283
Roland Levillain630846d2019-06-26 12:48:34 +0100284 // List of tests that are embedded inside this APEX bundle
285 Tests []string
286
Jiyong Parkff1458f2018-10-12 21:49:38 +0900287 // Name of the apex_key module that provides the private key to sign APEX
288 Key *string
Jiyong Park397e55e2018-10-24 21:09:55 +0900289
Alex Light5098a612018-11-29 17:12:15 -0800290 // The type of APEX to build. Controls what the APEX payload is. Either
291 // 'image', 'zip' or 'both'. Default: 'image'.
292 Payload_type *string
293
Jiyong Parkc00cbd92018-10-30 21:20:05 +0900294 // The name of a certificate in the default certificate directory, blank to use the default product certificate,
295 // or an android_app_certificate module name in the form ":module".
296 Certificate *string
297
Jiyong Park92c0f9c2018-12-13 23:14:57 +0900298 // Whether this APEX is installable to one of the partitions. Default: true.
299 Installable *bool
300
Jiyong Parkda6eb592018-12-19 17:12:36 +0900301 // For native libraries and binaries, use the vendor variant instead of the core (platform) variant.
302 // Default is false.
303 Use_vendor *bool
304
Alex Lightfc0bd7c2019-01-29 18:31:59 -0800305 // For telling the apex to ignore special handling for system libraries such as bionic. Default is false.
306 Ignore_system_library_special_case *bool
307
Alex Light9670d332019-01-29 18:07:33 -0800308 Multilib apexMultilibProperties
Jiyong Park235e67c2019-02-09 11:50:56 +0900309
Jiyong Parkf97782b2019-02-13 20:28:58 +0900310 // List of sanitizer names that this APEX is enabled for
311 SanitizerNames []string `blueprint:"mutated"`
Jooyung Han5c998b92019-06-27 11:30:33 +0900312
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900313 PreventInstall bool `blueprint:"mutated"`
314
315 HideFromMake bool `blueprint:"mutated"`
316
Jooyung Han5c998b92019-06-27 11:30:33 +0900317 // Indicates this APEX provides C++ shared libaries to other APEXes. Default: false.
318 Provide_cpp_shared_libs *bool
319
320 // List of providing APEXes' names so that this APEX can depend on provided shared libraries.
321 Uses []string
Nikita Ioffe5d5ae762019-08-31 14:38:05 +0100322
323 // A txt file containing list of files that are whitelisted to be included in this APEX.
324 Whitelisted_files *string
Sundong Ahne1f05aa2019-08-27 13:55:42 +0900325
Sundong Ahnabb64432019-10-22 13:58:29 +0900326 // package format of this apex variant; could be non-flattened, flattened, or zip.
327 // imageApex, zipApex or flattened
328 ApexType apexPackaging `blueprint:"mutated"`
Sundong Ahne8fb7242019-09-17 13:50:45 +0900329
Jiyong Parkd1063c12019-07-17 20:08:41 +0900330 // List of SDKs that are used to build this APEX. A reference to an SDK should be either
331 // `name#version` or `name` which is an alias for `name#current`. If left empty, `platform#current`
332 // is implied. This value affects all modules included in this APEX. In other words, they are
333 // also built with the SDKs specified here.
334 Uses_sdks []string
Jiyong Park5d790c32019-11-15 18:40:32 +0900335
336 // Names of modules to be overridden. Listed modules can only be other binaries
337 // (in Make or Soong).
338 // This does not completely prevent installation of the overridden binaries, but if both
339 // binaries would be installed by default (in PRODUCT_PACKAGES) the other binary will be removed
340 // from PRODUCT_PACKAGES.
341 Overrides []string
Nikita Ioffec72b5dd2019-12-07 17:30:22 +0000342
343 // Whenever apex_payload.img of the APEX should include dm-verity hashtree.
344 // Should be only used in tests#.
345 Test_only_no_hashtree *bool
Jooyung Han214bf372019-11-12 13:03:50 +0900346
347 // Whether this APEX should support Android10. Default is false. If this is set true, then apex_manifest.json is bundled as well
348 // because Android10 requires legacy apex_manifest.json instead of apex_manifest.pb
349 Legacy_android10_support *bool
Alex Light9670d332019-01-29 18:07:33 -0800350}
351
352type apexTargetBundleProperties struct {
353 Target struct {
354 // Multilib properties only for android.
355 Android struct {
356 Multilib apexMultilibProperties
Jiyong Park397e55e2018-10-24 21:09:55 +0900357 }
Jooyung Han344d5432019-08-23 11:17:39 +0900358
Alex Light9670d332019-01-29 18:07:33 -0800359 // Multilib properties only for host.
360 Host struct {
361 Multilib apexMultilibProperties
Jiyong Park397e55e2018-10-24 21:09:55 +0900362 }
Jooyung Han344d5432019-08-23 11:17:39 +0900363
Alex Light9670d332019-01-29 18:07:33 -0800364 // Multilib properties only for host linux_bionic.
365 Linux_bionic struct {
366 Multilib apexMultilibProperties
Jiyong Park397e55e2018-10-24 21:09:55 +0900367 }
Jooyung Han344d5432019-08-23 11:17:39 +0900368
Alex Light9670d332019-01-29 18:07:33 -0800369 // Multilib properties only for host linux_glibc.
370 Linux_glibc struct {
371 Multilib apexMultilibProperties
Jiyong Park397e55e2018-10-24 21:09:55 +0900372 }
373 }
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900374}
375
Jiyong Park5d790c32019-11-15 18:40:32 +0900376type overridableProperties struct {
377 // List of APKs to package inside APEX
378 Apps []string
379}
380
Alex Light5098a612018-11-29 17:12:15 -0800381type apexPackaging int
382
383const (
384 imageApex apexPackaging = iota
385 zipApex
Sundong Ahnabb64432019-10-22 13:58:29 +0900386 flattenedApex
Alex Light5098a612018-11-29 17:12:15 -0800387)
388
Sundong Ahnabb64432019-10-22 13:58:29 +0900389// The suffix for the output "file", not the module
Alex Light5098a612018-11-29 17:12:15 -0800390func (a apexPackaging) suffix() string {
391 switch a {
392 case imageApex:
393 return imageApexSuffix
394 case zipApex:
395 return zipApexSuffix
Alex Light5098a612018-11-29 17:12:15 -0800396 default:
Roland Levillain4644b222019-07-31 14:09:17 +0100397 panic(fmt.Errorf("unknown APEX type %d", a))
Alex Light5098a612018-11-29 17:12:15 -0800398 }
399}
400
401func (a apexPackaging) name() string {
402 switch a {
403 case imageApex:
404 return imageApexType
405 case zipApex:
406 return zipApexType
Alex Light5098a612018-11-29 17:12:15 -0800407 default:
Roland Levillain4644b222019-07-31 14:09:17 +0100408 panic(fmt.Errorf("unknown APEX type %d", a))
Alex Light5098a612018-11-29 17:12:15 -0800409 }
410}
411
Jiyong Parkf653b052019-11-18 15:39:01 +0900412type apexFileClass int
413
414const (
415 etc apexFileClass = iota
416 nativeSharedLib
417 nativeExecutable
418 shBinary
419 pyBinary
420 goBinary
421 javaSharedLib
422 nativeTest
423 app
424)
425
Jiyong Park8fd61922018-11-08 02:50:25 +0900426func (class apexFileClass) NameInMake() string {
427 switch class {
428 case etc:
429 return "ETC"
430 case nativeSharedLib:
431 return "SHARED_LIBRARIES"
Alex Light778127a2019-02-27 14:19:50 -0800432 case nativeExecutable, shBinary, pyBinary, goBinary:
Jiyong Park8fd61922018-11-08 02:50:25 +0900433 return "EXECUTABLES"
434 case javaSharedLib:
435 return "JAVA_LIBRARIES"
Roland Levillain630846d2019-06-26 12:48:34 +0100436 case nativeTest:
437 return "NATIVE_TESTS"
Sundong Ahne1f05aa2019-08-27 13:55:42 +0900438 case app:
Jiyong Parkf383f7c2019-10-11 20:46:25 +0900439 // b/142537672 Why isn't this APP? We want to have full control over
440 // the paths and file names of the apk file under the flattend APEX.
441 // If this is set to APP, then the paths and file names are modified
442 // by the Make build system. For example, it is installed to
443 // /system/apex/<apexname>/app/<Appname>/<apexname>.<Appname>/ instead of
444 // /system/apex/<apexname>/app/<Appname> because the build system automatically
445 // appends module name (which is <apexname>.<Appname> to the path.
446 return "ETC"
Jiyong Park8fd61922018-11-08 02:50:25 +0900447 default:
Roland Levillain4644b222019-07-31 14:09:17 +0100448 panic(fmt.Errorf("unknown class %d", class))
Jiyong Park8fd61922018-11-08 02:50:25 +0900449 }
450}
451
Jiyong Parkf653b052019-11-18 15:39:01 +0900452// apexFile represents a file in an APEX bundle
Jiyong Park8fd61922018-11-08 02:50:25 +0900453type apexFile struct {
454 builtFile android.Path
455 moduleName string
Jiyong Park8fd61922018-11-08 02:50:25 +0900456 installDir string
457 class apexFileClass
Jiyong Parka8894842018-12-19 17:36:39 +0900458 module android.Module
Jiyong Parkf653b052019-11-18 15:39:01 +0900459 // list of symlinks that will be created in installDir that point to this apexFile
460 symlinks []string
461 transitiveDep bool
462}
463
464func newApexFile(builtFile android.Path, moduleName string, installDir string, class apexFileClass, module android.Module) apexFile {
465 return apexFile{
466 builtFile: builtFile,
467 moduleName: moduleName,
468 installDir: installDir,
469 class: class,
470 module: module,
471 }
472}
473
474func (af *apexFile) Ok() bool {
475 return af.builtFile != nil || af.builtFile.String() == ""
Jiyong Park8fd61922018-11-08 02:50:25 +0900476}
477
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900478type apexBundle struct {
479 android.ModuleBase
480 android.DefaultableModuleBase
Jiyong Park5d790c32019-11-15 18:40:32 +0900481 android.OverridableModuleBase
Jiyong Parkd1063c12019-07-17 20:08:41 +0900482 android.SdkBase
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900483
Jiyong Park5d790c32019-11-15 18:40:32 +0900484 properties apexBundleProperties
485 targetProperties apexTargetBundleProperties
486 vndkProperties apexVndkProperties
487 overridableProperties overridableProperties
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900488
Colin Crossa4925902018-11-16 11:36:28 -0800489 bundleModuleFile android.WritablePath
Sundong Ahnabb64432019-10-22 13:58:29 +0900490 outputFile android.WritablePath
Colin Cross70dda7e2019-10-01 22:05:35 -0700491 installDir android.InstallPath
Jiyong Park8fd61922018-11-08 02:50:25 +0900492
Jiyong Park03b68dd2019-07-26 23:20:40 +0900493 prebuiltFileToDelete string
494
Jiyong Park42cca6c2019-04-01 11:15:50 +0900495 public_key_file android.Path
496 private_key_file android.Path
Jiyong Park0ca3ce82019-02-18 15:25:04 +0900497
498 container_certificate_file android.Path
499 container_private_key_file android.Path
500
Jooyung Han54aca7b2019-11-20 02:26:02 +0900501 fileContexts android.Path
502
Jiyong Park8fd61922018-11-08 02:50:25 +0900503 // list of files to be included in this apex
504 filesInfo []apexFile
505
Jiyong Parkac2bacd2019-02-20 21:49:26 +0900506 // list of module names that this APEX is depending on
507 externalDeps []string
508
Sundong Ahnabb64432019-10-22 13:58:29 +0900509 testApex bool
510 vndkApex bool
Ulyana Trafimovichde534412019-11-08 10:51:01 +0000511 artApex bool
Sundong Ahnabb64432019-10-22 13:58:29 +0900512 primaryApexType bool
Jooyung Hane1633032019-08-01 17:41:43 +0900513
Jooyung Han214bf372019-11-12 13:03:50 +0900514 manifestJsonOut android.WritablePath
515 manifestPbOut android.WritablePath
Jooyung Han72bd2f82019-10-23 16:46:38 +0900516
517 // list of commands to create symlinks for backward compatibility
518 // these commands will be attached as LOCAL_POST_INSTALL_CMD to
519 // apex package itself(for unflattened build) or apex_manifest.json(for flattened build)
520 // so that compat symlinks are always installed regardless of TARGET_FLATTEN_APEX setting.
521 compatSymlinks []string
Sundong Ahnabb64432019-10-22 13:58:29 +0900522
523 // Suffix of module name in Android.mk
524 // ".flattened", ".apex", ".zipapex", or ""
525 suffix string
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900526}
527
Jiyong Park397e55e2018-10-24 21:09:55 +0900528func addDependenciesForNativeModules(ctx android.BottomUpMutatorContext,
Roland Levillain630846d2019-06-26 12:48:34 +0100529 native_shared_libs []string, binaries []string, tests []string,
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700530 target android.Target, imageVariation string) {
Jiyong Park397e55e2018-10-24 21:09:55 +0900531 // Use *FarVariation* to be able to depend on modules having
532 // conflicting variations with this module. This is required since
533 // arch variant of an APEX bundle is 'common' but it is 'arm' or 'arm64'
534 // for native shared libs.
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700535 ctx.AddFarVariationDependencies(append(target.Variations(), []blueprint.Variation{
Jiyong Parkda6eb592018-12-19 17:12:36 +0900536 {Mutator: "image", Variation: imageVariation},
Jiyong Park397e55e2018-10-24 21:09:55 +0900537 {Mutator: "link", Variation: "shared"},
Jiyong Park28d395a2018-12-07 22:42:47 +0900538 {Mutator: "version", Variation: ""}, // "" is the non-stub variant
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700539 }...), sharedLibTag, native_shared_libs...)
Jiyong Park397e55e2018-10-24 21:09:55 +0900540
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700541 ctx.AddFarVariationDependencies(append(target.Variations(),
542 blueprint.Variation{Mutator: "image", Variation: imageVariation}),
543 executableTag, binaries...)
Roland Levillain630846d2019-06-26 12:48:34 +0100544
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700545 ctx.AddFarVariationDependencies(append(target.Variations(), []blueprint.Variation{
Roland Levillain630846d2019-06-26 12:48:34 +0100546 {Mutator: "image", Variation: imageVariation},
Roland Levillain9b5fde92019-06-28 15:41:19 +0100547 {Mutator: "test_per_src", Variation: ""}, // "" is the all-tests variant
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700548 }...), testTag, tests...)
Jiyong Park397e55e2018-10-24 21:09:55 +0900549}
550
Alex Light9670d332019-01-29 18:07:33 -0800551func (a *apexBundle) combineProperties(ctx android.BottomUpMutatorContext) {
552 if ctx.Os().Class == android.Device {
553 proptools.AppendProperties(&a.properties.Multilib, &a.targetProperties.Target.Android.Multilib, nil)
554 } else {
555 proptools.AppendProperties(&a.properties.Multilib, &a.targetProperties.Target.Host.Multilib, nil)
556 if ctx.Os().Bionic() {
557 proptools.AppendProperties(&a.properties.Multilib, &a.targetProperties.Target.Linux_bionic.Multilib, nil)
558 } else {
559 proptools.AppendProperties(&a.properties.Multilib, &a.targetProperties.Target.Linux_glibc.Multilib, nil)
560 }
561 }
562}
563
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900564func (a *apexBundle) DepsMutator(ctx android.BottomUpMutatorContext) {
Jooyung Handc782442019-11-01 03:14:38 +0900565 if proptools.Bool(a.properties.Use_vendor) && !android.InList(a.Name(), useVendorWhitelist(ctx.Config())) {
566 ctx.PropertyErrorf("use_vendor", "not allowed to set use_vendor: true")
567 }
568
Jiyong Park397e55e2018-10-24 21:09:55 +0900569 targets := ctx.MultiTargets()
Jiyong Park7c1dc612019-01-05 11:15:24 +0900570 config := ctx.DeviceConfig()
Alex Light9670d332019-01-29 18:07:33 -0800571
572 a.combineProperties(ctx)
573
Jiyong Park397e55e2018-10-24 21:09:55 +0900574 has32BitTarget := false
575 for _, target := range targets {
576 if target.Arch.ArchType.Multilib == "lib32" {
577 has32BitTarget = true
578 }
579 }
580 for i, target := range targets {
581 // When multilib.* is omitted for native_shared_libs, it implies
582 // multilib.both.
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700583 ctx.AddFarVariationDependencies(append(target.Variations(), []blueprint.Variation{
Jiyong Park7c1dc612019-01-05 11:15:24 +0900584 {Mutator: "image", Variation: a.getImageVariation(config)},
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900585 {Mutator: "link", Variation: "shared"},
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700586 }...), sharedLibTag, a.properties.Native_shared_libs...)
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900587
Roland Levillain630846d2019-06-26 12:48:34 +0100588 // When multilib.* is omitted for tests, it implies
589 // multilib.both.
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700590 ctx.AddFarVariationDependencies(append(target.Variations(), []blueprint.Variation{
Roland Levillain630846d2019-06-26 12:48:34 +0100591 {Mutator: "image", Variation: a.getImageVariation(config)},
Roland Levillain9b5fde92019-06-28 15:41:19 +0100592 {Mutator: "test_per_src", Variation: ""}, // "" is the all-tests variant
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700593 }...), testTag, a.properties.Tests...)
Roland Levillain630846d2019-06-26 12:48:34 +0100594
Jiyong Park397e55e2018-10-24 21:09:55 +0900595 // Add native modules targetting both ABIs
596 addDependenciesForNativeModules(ctx,
597 a.properties.Multilib.Both.Native_shared_libs,
Roland Levillain630846d2019-06-26 12:48:34 +0100598 a.properties.Multilib.Both.Binaries,
599 a.properties.Multilib.Both.Tests,
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700600 target,
Jiyong Park7c1dc612019-01-05 11:15:24 +0900601 a.getImageVariation(config))
Jiyong Park397e55e2018-10-24 21:09:55 +0900602
Alex Light3d673592019-01-18 14:37:31 -0800603 isPrimaryAbi := i == 0
604 if isPrimaryAbi {
Jiyong Park397e55e2018-10-24 21:09:55 +0900605 // When multilib.* is omitted for binaries, it implies
606 // multilib.first.
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700607 ctx.AddFarVariationDependencies(append(target.Variations(),
608 blueprint.Variation{Mutator: "image", Variation: a.getImageVariation(config)}),
609 executableTag, a.properties.Binaries...)
Jiyong Park397e55e2018-10-24 21:09:55 +0900610
611 // Add native modules targetting the first ABI
612 addDependenciesForNativeModules(ctx,
613 a.properties.Multilib.First.Native_shared_libs,
Roland Levillain630846d2019-06-26 12:48:34 +0100614 a.properties.Multilib.First.Binaries,
615 a.properties.Multilib.First.Tests,
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700616 target,
Jiyong Park7c1dc612019-01-05 11:15:24 +0900617 a.getImageVariation(config))
Jiyong Park397e55e2018-10-24 21:09:55 +0900618 }
619
620 switch target.Arch.ArchType.Multilib {
621 case "lib32":
622 // Add native modules targetting 32-bit ABI
623 addDependenciesForNativeModules(ctx,
624 a.properties.Multilib.Lib32.Native_shared_libs,
Roland Levillain630846d2019-06-26 12:48:34 +0100625 a.properties.Multilib.Lib32.Binaries,
626 a.properties.Multilib.Lib32.Tests,
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700627 target,
Jiyong Park7c1dc612019-01-05 11:15:24 +0900628 a.getImageVariation(config))
Jiyong Park397e55e2018-10-24 21:09:55 +0900629
630 addDependenciesForNativeModules(ctx,
631 a.properties.Multilib.Prefer32.Native_shared_libs,
Roland Levillain630846d2019-06-26 12:48:34 +0100632 a.properties.Multilib.Prefer32.Binaries,
633 a.properties.Multilib.Prefer32.Tests,
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700634 target,
Jiyong Park7c1dc612019-01-05 11:15:24 +0900635 a.getImageVariation(config))
Jiyong Park397e55e2018-10-24 21:09:55 +0900636 case "lib64":
637 // Add native modules targetting 64-bit ABI
638 addDependenciesForNativeModules(ctx,
639 a.properties.Multilib.Lib64.Native_shared_libs,
Roland Levillain630846d2019-06-26 12:48:34 +0100640 a.properties.Multilib.Lib64.Binaries,
641 a.properties.Multilib.Lib64.Tests,
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700642 target,
Jiyong Park7c1dc612019-01-05 11:15:24 +0900643 a.getImageVariation(config))
Jiyong Park397e55e2018-10-24 21:09:55 +0900644
645 if !has32BitTarget {
646 addDependenciesForNativeModules(ctx,
647 a.properties.Multilib.Prefer32.Native_shared_libs,
Roland Levillain630846d2019-06-26 12:48:34 +0100648 a.properties.Multilib.Prefer32.Binaries,
649 a.properties.Multilib.Prefer32.Tests,
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700650 target,
Jiyong Park7c1dc612019-01-05 11:15:24 +0900651 a.getImageVariation(config))
Jiyong Park397e55e2018-10-24 21:09:55 +0900652 }
Peter Collingbourne3478bb22019-04-24 14:41:12 -0700653
654 if strings.HasPrefix(ctx.ModuleName(), "com.android.runtime") && target.Os.Class == android.Device {
655 for _, sanitizer := range ctx.Config().SanitizeDevice() {
656 if sanitizer == "hwaddress" {
657 addDependenciesForNativeModules(ctx,
658 []string{"libclang_rt.hwasan-aarch64-android"},
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700659 nil, nil, target, a.getImageVariation(config))
Peter Collingbourne3478bb22019-04-24 14:41:12 -0700660 break
661 }
662 }
663 }
Jiyong Park397e55e2018-10-24 21:09:55 +0900664 }
665
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900666 }
667
Jiyong Parkce6aadc2019-11-20 13:58:28 +0900668 // For prebuilt_etc, use the first variant (64 on 64/32bit device,
669 // 32 on 32bit device) regardless of the TARGET_PREFER_* setting.
670 // b/144532908
671 archForPrebuiltEtc := config.Arches()[0]
672 for _, arch := range config.Arches() {
673 // Prefer 64-bit arch if there is any
674 if arch.ArchType.Multilib == "lib64" {
675 archForPrebuiltEtc = arch
676 break
677 }
678 }
679 ctx.AddFarVariationDependencies([]blueprint.Variation{
680 {Mutator: "os", Variation: ctx.Os().String()},
681 {Mutator: "arch", Variation: archForPrebuiltEtc.String()},
682 }, prebuiltTag, a.properties.Prebuilts...)
683
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700684 ctx.AddFarVariationDependencies(ctx.Config().AndroidCommonTarget.Variations(),
685 javaLibTag, a.properties.Java_libs...)
Jiyong Parkff1458f2018-10-12 21:49:38 +0900686
Jiyong Park23c52b02019-02-02 13:13:47 +0900687 if String(a.properties.Key) == "" {
688 ctx.ModuleErrorf("key is missing")
689 return
690 }
691 ctx.AddDependency(ctx.Module(), keyTag, String(a.properties.Key))
Jiyong Parkc00cbd92018-10-30 21:20:05 +0900692
Jiyong Parkb2742fd2019-02-11 11:38:15 +0900693 cert := android.SrcIsModule(a.getCertString(ctx))
Jiyong Park23c52b02019-02-02 13:13:47 +0900694 if cert != "" {
695 ctx.AddDependency(ctx.Module(), certificateTag, cert)
Jiyong Parkc00cbd92018-10-30 21:20:05 +0900696 }
Jiyong Parkd1063c12019-07-17 20:08:41 +0900697
698 // TODO(jiyong): ensure that all apexes are with non-empty uses_sdks
699 if len(a.properties.Uses_sdks) > 0 {
700 sdkRefs := []android.SdkRef{}
701 for _, str := range a.properties.Uses_sdks {
702 parsed := android.ParseSdkRef(ctx, str, "uses_sdks")
703 sdkRefs = append(sdkRefs, parsed)
704 }
705 a.BuildWithSdks(sdkRefs)
706 }
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900707}
708
Jiyong Park5d790c32019-11-15 18:40:32 +0900709func (a *apexBundle) OverridablePropertiesDepsMutator(ctx android.BottomUpMutatorContext) {
710 ctx.AddFarVariationDependencies(ctx.Config().AndroidCommonTarget.Variations(),
711 androidAppTag, a.overridableProperties.Apps...)
712}
713
Jiyong Parka7bc8ad2019-10-15 15:20:07 +0900714func (a *apexBundle) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
715 // direct deps of an APEX bundle are all part of the APEX bundle
716 return true
717}
718
Colin Cross0ea8ba82019-06-06 14:33:29 -0700719func (a *apexBundle) getCertString(ctx android.BaseModuleContext) string {
Jiyong Parkb2742fd2019-02-11 11:38:15 +0900720 certificate, overridden := ctx.DeviceConfig().OverrideCertificateFor(ctx.ModuleName())
721 if overridden {
Jaewoong Jungacb6db32019-02-28 16:22:30 +0000722 return ":" + certificate
Jiyong Parkb2742fd2019-02-11 11:38:15 +0900723 }
724 return String(a.properties.Certificate)
725}
726
Colin Cross41955e82019-05-29 14:40:35 -0700727func (a *apexBundle) OutputFiles(tag string) (android.Paths, error) {
728 switch tag {
729 case "":
Sundong Ahnabb64432019-10-22 13:58:29 +0900730 return android.Paths{a.outputFile}, nil
Colin Cross41955e82019-05-29 14:40:35 -0700731 default:
732 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
Jiyong Park5a832022018-12-20 09:54:35 +0900733 }
Jiyong Park74e240b2018-11-27 21:27:08 +0900734}
735
Jiyong Park92c0f9c2018-12-13 23:14:57 +0900736func (a *apexBundle) installable() bool {
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900737 return !a.properties.PreventInstall && (a.properties.Installable == nil || proptools.Bool(a.properties.Installable))
Jiyong Park92c0f9c2018-12-13 23:14:57 +0900738}
739
Nikita Ioffec72b5dd2019-12-07 17:30:22 +0000740func (a *apexBundle) testOnlyShouldSkipHashtreeGeneration() bool {
741 return proptools.Bool(a.properties.Test_only_no_hashtree)
742}
743
Jiyong Park7c1dc612019-01-05 11:15:24 +0900744func (a *apexBundle) getImageVariation(config android.DeviceConfig) string {
Jooyung Han31c470b2019-10-18 16:26:59 +0900745 if a.vndkApex {
Colin Cross7228ecd2019-11-18 16:00:16 -0800746 return cc.VendorVariationPrefix + a.vndkVersion(config)
Jooyung Han31c470b2019-10-18 16:26:59 +0900747 }
Jiyong Park7c1dc612019-01-05 11:15:24 +0900748 if config.VndkVersion() != "" && proptools.Bool(a.properties.Use_vendor) {
Colin Cross7228ecd2019-11-18 16:00:16 -0800749 return cc.VendorVariationPrefix + config.PlatformVndkVersion()
Jiyong Parkda6eb592018-12-19 17:12:36 +0900750 } else {
Colin Cross7228ecd2019-11-18 16:00:16 -0800751 return android.CoreVariation
Jiyong Parkda6eb592018-12-19 17:12:36 +0900752 }
753}
754
Jiyong Parkf97782b2019-02-13 20:28:58 +0900755func (a *apexBundle) EnableSanitizer(sanitizerName string) {
756 if !android.InList(sanitizerName, a.properties.SanitizerNames) {
757 a.properties.SanitizerNames = append(a.properties.SanitizerNames, sanitizerName)
758 }
759}
760
Jiyong Park388ef3f2019-01-28 19:47:32 +0900761func (a *apexBundle) IsSanitizerEnabled(ctx android.BaseModuleContext, sanitizerName string) bool {
Jiyong Parkf97782b2019-02-13 20:28:58 +0900762 if android.InList(sanitizerName, a.properties.SanitizerNames) {
763 return true
Jiyong Park235e67c2019-02-09 11:50:56 +0900764 }
765
766 // Then follow the global setting
Jiyong Park388ef3f2019-01-28 19:47:32 +0900767 globalSanitizerNames := []string{}
768 if a.Host() {
769 globalSanitizerNames = ctx.Config().SanitizeHost()
770 } else {
771 arches := ctx.Config().SanitizeDeviceArch()
772 if len(arches) == 0 || android.InList(a.Arch().ArchType.Name, arches) {
773 globalSanitizerNames = ctx.Config().SanitizeDevice()
774 }
775 }
776 return android.InList(sanitizerName, globalSanitizerNames)
Jiyong Park379de2f2018-12-19 02:47:14 +0900777}
778
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900779func (a *apexBundle) IsNativeCoverageNeeded(ctx android.BaseModuleContext) bool {
780 return ctx.Device() && ctx.DeviceConfig().NativeCoverageEnabled()
781}
782
783func (a *apexBundle) PreventInstall() {
784 a.properties.PreventInstall = true
785}
786
787func (a *apexBundle) HideFromMake() {
788 a.properties.HideFromMake = true
789}
790
Jiyong Parkf653b052019-11-18 15:39:01 +0900791// TODO(jiyong) move apexFileFor* close to the apexFile type definition
792func apexFileForNativeLibrary(ccMod *cc.Module, config android.Config, handleSpecialLibs bool) apexFile {
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900793 // Decide the APEX-local directory by the multilib of the library
794 // In the future, we may query this to the module.
Jiyong Parkf653b052019-11-18 15:39:01 +0900795 var dirInApex string
Martin Stjernholm279de572019-09-10 23:18:20 +0100796 switch ccMod.Arch().ArchType.Multilib {
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900797 case "lib32":
798 dirInApex = "lib"
799 case "lib64":
800 dirInApex = "lib64"
801 }
Martin Stjernholm279de572019-09-10 23:18:20 +0100802 dirInApex = filepath.Join(dirInApex, ccMod.RelativeInstallPath())
Colin Cross3b19f5d2019-09-17 14:45:31 -0700803 if ccMod.Target().NativeBridge == android.NativeBridgeEnabled {
Martin Stjernholm279de572019-09-10 23:18:20 +0100804 dirInApex = filepath.Join(dirInApex, ccMod.Target().NativeBridgeRelativePath)
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900805 }
Martin Stjernholm279de572019-09-10 23:18:20 +0100806 if handleSpecialLibs && cc.InstallToBootstrap(ccMod.BaseModuleName(), config) {
807 // Special case for Bionic libs and other libs installed with them. This is
808 // to prevent those libs from being included in the search path
809 // /apex/com.android.runtime/${LIB}. This exclusion is required because
810 // those libs in the Runtime APEX are available via the legacy paths in
811 // /system/lib/. By the init process, the libs in the APEX are bind-mounted
812 // to the legacy paths and thus will be loaded into the default linker
813 // namespace (aka "platform" namespace). If the libs are directly in
814 // /apex/com.android.runtime/${LIB} then the same libs will be loaded again
815 // into the runtime linker namespace, which will result in double loading of
816 // them, which isn't supported.
817 dirInApex = filepath.Join(dirInApex, "bionic")
Jiyong Parkb0788572018-12-20 22:10:17 +0900818 }
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900819
Jiyong Parkf653b052019-11-18 15:39:01 +0900820 fileToCopy := ccMod.OutputFile().Path()
821 return newApexFile(fileToCopy, ccMod.Name(), dirInApex, nativeSharedLib, ccMod)
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900822}
823
Jiyong Parkf653b052019-11-18 15:39:01 +0900824func apexFileForExecutable(cc *cc.Module) apexFile {
825 dirInApex := filepath.Join("bin", cc.RelativeInstallPath())
Colin Cross3b19f5d2019-09-17 14:45:31 -0700826 if cc.Target().NativeBridge == android.NativeBridgeEnabled {
dimitry8d6dde82019-07-11 10:23:53 +0200827 dirInApex = filepath.Join(dirInApex, cc.Target().NativeBridgeRelativePath)
Jiyong Parkacbf6c72019-07-09 16:19:16 +0900828 }
Jiyong Parkf653b052019-11-18 15:39:01 +0900829 fileToCopy := cc.OutputFile().Path()
830 af := newApexFile(fileToCopy, cc.Name(), dirInApex, nativeExecutable, cc)
831 af.symlinks = cc.Symlinks()
832 return af
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900833}
834
Jiyong Parkf653b052019-11-18 15:39:01 +0900835func apexFileForPyBinary(py *python.Module) apexFile {
836 dirInApex := "bin"
837 fileToCopy := py.HostToolPath().Path()
838 return newApexFile(fileToCopy, py.Name(), dirInApex, pyBinary, py)
Alex Light778127a2019-02-27 14:19:50 -0800839}
Jiyong Parkf653b052019-11-18 15:39:01 +0900840func apexFileForGoBinary(ctx android.ModuleContext, depName string, gb bootstrap.GoBinaryTool) apexFile {
841 dirInApex := "bin"
Alex Light778127a2019-02-27 14:19:50 -0800842 s, err := filepath.Rel(android.PathForOutput(ctx).String(), gb.InstallPath())
843 if err != nil {
844 ctx.ModuleErrorf("Unable to use compiled binary at %s", gb.InstallPath())
Jiyong Parkf653b052019-11-18 15:39:01 +0900845 return apexFile{}
Alex Light778127a2019-02-27 14:19:50 -0800846 }
Jiyong Parkf653b052019-11-18 15:39:01 +0900847 fileToCopy := android.PathForOutput(ctx, s)
848 // NB: Since go binaries are static we don't need the module for anything here, which is
849 // good since the go tool is a blueprint.Module not an android.Module like we would
850 // normally use.
851 return newApexFile(fileToCopy, depName, dirInApex, goBinary, nil)
Alex Light778127a2019-02-27 14:19:50 -0800852}
853
Jiyong Parkf653b052019-11-18 15:39:01 +0900854func apexFileForShBinary(sh *android.ShBinary) apexFile {
855 dirInApex := filepath.Join("bin", sh.SubDir())
856 fileToCopy := sh.OutputFile()
857 af := newApexFile(fileToCopy, sh.Name(), dirInApex, shBinary, sh)
858 af.symlinks = sh.Symlinks()
859 return af
Jiyong Park04480cf2019-02-06 00:16:29 +0900860}
861
Jiyong Parkf653b052019-11-18 15:39:01 +0900862func apexFileForJavaLibrary(java *java.Library) apexFile {
863 dirInApex := "javalib"
864 fileToCopy := java.DexJarFile()
865 return newApexFile(fileToCopy, java.Name(), dirInApex, javaSharedLib, java)
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900866}
867
Jiyong Parkf653b052019-11-18 15:39:01 +0900868func apexFileForPrebuiltJavaLibrary(java *java.Import) apexFile {
869 dirInApex := "javalib"
Jiyong Park9e6c2422019-08-09 20:39:45 +0900870 // The output is only one, but for some reason, ImplementationJars returns Paths, not Path
871 implJars := java.ImplementationJars()
872 if len(implJars) != 1 {
873 panic(fmt.Errorf("java.ImplementationJars() must return single Path, but got: %s",
874 strings.Join(implJars.Strings(), ", ")))
875 }
Jiyong Parkf653b052019-11-18 15:39:01 +0900876 fileToCopy := implJars[0]
877 return newApexFile(fileToCopy, java.Name(), dirInApex, javaSharedLib, java)
Jiyong Park9e6c2422019-08-09 20:39:45 +0900878}
879
Jiyong Parkf653b052019-11-18 15:39:01 +0900880func apexFileForPrebuiltEtc(prebuilt android.PrebuiltEtcModule, depName string) apexFile {
881 dirInApex := filepath.Join("etc", prebuilt.SubDir())
882 fileToCopy := prebuilt.OutputFile()
883 return newApexFile(fileToCopy, depName, dirInApex, etc, prebuilt)
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900884}
885
Jiyong Parkf653b052019-11-18 15:39:01 +0900886func apexFileForAndroidApp(aapp interface {
887 android.Module
888 Privileged() bool
889 OutputFile() android.Path
890}, pkgName string) apexFile {
Jiyong Parkf7487312019-10-17 12:54:30 +0900891 appDir := "app"
Jiyong Parkf653b052019-11-18 15:39:01 +0900892 if aapp.Privileged() {
Jiyong Parkf7487312019-10-17 12:54:30 +0900893 appDir = "priv-app"
894 }
Jiyong Parkf653b052019-11-18 15:39:01 +0900895 dirInApex := filepath.Join(appDir, pkgName)
896 fileToCopy := aapp.OutputFile()
897 return newApexFile(fileToCopy, aapp.Name(), dirInApex, app, aapp)
Dario Frenicde2a032019-10-27 00:29:22 +0100898}
899
Roland Levillain935639d2019-08-13 14:55:28 +0100900// Context "decorator", overriding the InstallBypassMake method to always reply `true`.
901type flattenedApexContext struct {
902 android.ModuleContext
903}
904
905func (c *flattenedApexContext) InstallBypassMake() bool {
906 return true
907}
908
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900909func (a *apexBundle) GenerateAndroidBuildActions(ctx android.ModuleContext) {
Sundong Ahnabb64432019-10-22 13:58:29 +0900910 buildFlattenedAsDefault := ctx.Config().FlattenApex() && !ctx.Config().UnbundledBuild()
911 switch a.properties.ApexType {
912 case imageApex:
913 if buildFlattenedAsDefault {
914 a.suffix = imageApexSuffix
915 } else {
916 a.suffix = ""
917 a.primaryApexType = true
918 }
919 case zipApex:
920 if proptools.String(a.properties.Payload_type) == "zip" {
921 a.suffix = ""
922 a.primaryApexType = true
923 } else {
924 a.suffix = zipApexSuffix
925 }
926 case flattenedApex:
927 if buildFlattenedAsDefault {
928 a.suffix = ""
929 a.primaryApexType = true
930 } else {
931 a.suffix = flattenedSuffix
932 }
Alex Light5098a612018-11-29 17:12:15 -0800933 }
934
Roland Levillain630846d2019-06-26 12:48:34 +0100935 if len(a.properties.Tests) > 0 && !a.testApex {
936 ctx.PropertyErrorf("tests", "property not allowed in apex module type")
937 return
938 }
939
Alex Lightfc0bd7c2019-01-29 18:31:59 -0800940 handleSpecialLibs := !android.Bool(a.properties.Ignore_system_library_special_case)
941
Jooyung Hane1633032019-08-01 17:41:43 +0900942 // native lib dependencies
943 var provideNativeLibs []string
944 var requireNativeLibs []string
945
Jooyung Han5c998b92019-06-27 11:30:33 +0900946 // Check if "uses" requirements are met with dependent apexBundles
947 var providedNativeSharedLibs []string
948 useVendor := proptools.Bool(a.properties.Use_vendor)
949 ctx.VisitDirectDepsBlueprint(func(m blueprint.Module) {
950 if ctx.OtherModuleDependencyTag(m) != usesTag {
951 return
952 }
953 otherName := ctx.OtherModuleName(m)
954 other, ok := m.(*apexBundle)
955 if !ok {
956 ctx.PropertyErrorf("uses", "%q is not a provider", otherName)
957 return
958 }
959 if proptools.Bool(other.properties.Use_vendor) != useVendor {
960 ctx.PropertyErrorf("use_vendor", "%q has different value of use_vendor", otherName)
961 return
962 }
963 if !proptools.Bool(other.properties.Provide_cpp_shared_libs) {
964 ctx.PropertyErrorf("uses", "%q does not provide native_shared_libs", otherName)
965 return
966 }
967 providedNativeSharedLibs = append(providedNativeSharedLibs, other.properties.Native_shared_libs...)
968 })
969
Jiyong Parkf653b052019-11-18 15:39:01 +0900970 var filesInfo []apexFile
Alex Light778127a2019-02-27 14:19:50 -0800971 ctx.WalkDepsBlueprint(func(child, parent blueprint.Module) bool {
Roland Levillainf89cd092019-07-29 16:22:59 +0100972 depTag := ctx.OtherModuleDependencyTag(child)
973 depName := ctx.OtherModuleName(child)
Jiyong Parkf653b052019-11-18 15:39:01 +0900974 if _, isDirectDep := parent.(*apexBundle); isDirectDep {
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900975 switch depTag {
976 case sharedLibTag:
977 if cc, ok := child.(*cc.Module); ok {
Jooyung Hane1633032019-08-01 17:41:43 +0900978 if cc.HasStubsVariants() {
979 provideNativeLibs = append(provideNativeLibs, cc.OutputFile().Path().Base())
980 }
Jiyong Parkf653b052019-11-18 15:39:01 +0900981 filesInfo = append(filesInfo, apexFileForNativeLibrary(cc, ctx.Config(), handleSpecialLibs))
982 return true // track transitive dependencies
Jiyong Parkff1458f2018-10-12 21:49:38 +0900983 } else {
984 ctx.PropertyErrorf("native_shared_libs", "%q is not a cc_library or cc_library_shared module", depName)
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900985 }
986 case executableTag:
987 if cc, ok := child.(*cc.Module); ok {
Jiyong Parkf653b052019-11-18 15:39:01 +0900988 filesInfo = append(filesInfo, apexFileForExecutable(cc))
989 return true // track transitive dependencies
Jiyong Park04480cf2019-02-06 00:16:29 +0900990 } else if sh, ok := child.(*android.ShBinary); ok {
Jiyong Parkf653b052019-11-18 15:39:01 +0900991 filesInfo = append(filesInfo, apexFileForShBinary(sh))
Alex Light778127a2019-02-27 14:19:50 -0800992 } else if py, ok := child.(*python.Module); ok && py.HostToolPath().Valid() {
Jiyong Parkf653b052019-11-18 15:39:01 +0900993 filesInfo = append(filesInfo, apexFileForPyBinary(py))
Alex Light778127a2019-02-27 14:19:50 -0800994 } else if gb, ok := child.(bootstrap.GoBinaryTool); ok && a.Host() {
Jiyong Parkf653b052019-11-18 15:39:01 +0900995 filesInfo = append(filesInfo, apexFileForGoBinary(ctx, depName, gb))
Jiyong Parkff1458f2018-10-12 21:49:38 +0900996 } else {
Alex Light778127a2019-02-27 14:19:50 -0800997 ctx.PropertyErrorf("binaries", "%q is neither cc_binary, (embedded) py_binary, (host) blueprint_go_binary, (host) bootstrap_go_binary, nor sh_binary", depName)
Jiyong Park48ca7dc2018-10-10 14:01:00 +0900998 }
999 case javaLibTag:
Jiyong Park9e6c2422019-08-09 20:39:45 +09001000 if javaLib, ok := child.(*java.Library); ok {
Jiyong Parkf653b052019-11-18 15:39:01 +09001001 af := apexFileForJavaLibrary(javaLib)
1002 if !af.Ok() {
Jiyong Park8fd61922018-11-08 02:50:25 +09001003 ctx.PropertyErrorf("java_libs", "%q is not configured to be compiled into dex", depName)
1004 } else {
Jiyong Parkf653b052019-11-18 15:39:01 +09001005 filesInfo = append(filesInfo, af)
1006 return true // track transitive dependencies
Jiyong Park9e6c2422019-08-09 20:39:45 +09001007 }
Jiyong Park9e6c2422019-08-09 20:39:45 +09001008 } else if javaLib, ok := child.(*java.Import); ok {
Jiyong Parkf653b052019-11-18 15:39:01 +09001009 af := apexFileForPrebuiltJavaLibrary(javaLib)
1010 if !af.Ok() {
Jiyong Park9e6c2422019-08-09 20:39:45 +09001011 ctx.PropertyErrorf("java_libs", "%q does not have a jar output", depName)
1012 } else {
Jiyong Parkf653b052019-11-18 15:39:01 +09001013 filesInfo = append(filesInfo, af)
Jiyong Park8fd61922018-11-08 02:50:25 +09001014 }
Jiyong Parkff1458f2018-10-12 21:49:38 +09001015 } else {
Jiyong Park9e6c2422019-08-09 20:39:45 +09001016 ctx.PropertyErrorf("java_libs", "%q of type %q is not supported", depName, ctx.OtherModuleType(child))
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001017 }
Jiyong Parkf653b052019-11-18 15:39:01 +09001018 case androidAppTag:
1019 pkgName := ctx.DeviceConfig().OverridePackageNameFor(depName)
1020 if ap, ok := child.(*java.AndroidApp); ok {
1021 filesInfo = append(filesInfo, apexFileForAndroidApp(ap, pkgName))
1022 return true // track transitive dependencies
1023 } else if ap, ok := child.(*java.AndroidAppImport); ok {
1024 filesInfo = append(filesInfo, apexFileForAndroidApp(ap, pkgName))
1025 } else {
1026 ctx.PropertyErrorf("apps", "%q is not an android_app module", depName)
1027 }
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001028 case prebuiltTag:
Jooyung Han39edb6c2019-11-06 16:53:07 +09001029 if prebuilt, ok := child.(android.PrebuiltEtcModule); ok {
Jiyong Parkf653b052019-11-18 15:39:01 +09001030 filesInfo = append(filesInfo, apexFileForPrebuiltEtc(prebuilt, depName))
Jiyong Parkff1458f2018-10-12 21:49:38 +09001031 } else {
1032 ctx.PropertyErrorf("prebuilts", "%q is not a prebuilt_etc module", depName)
1033 }
Roland Levillain630846d2019-06-26 12:48:34 +01001034 case testTag:
Roland Levillainf89cd092019-07-29 16:22:59 +01001035 if ccTest, ok := child.(*cc.Module); ok {
1036 if ccTest.IsTestPerSrcAllTestsVariation() {
1037 // Multiple-output test module (where `test_per_src: true`).
1038 //
1039 // `ccTest` is the "" ("all tests") variation of a `test_per_src` module.
1040 // We do not add this variation to `filesInfo`, as it has no output;
1041 // however, we do add the other variations of this module as indirect
1042 // dependencies (see below).
1043 return true
Roland Levillain9b5fde92019-06-28 15:41:19 +01001044 } else {
Roland Levillainf89cd092019-07-29 16:22:59 +01001045 // Single-output test module (where `test_per_src: false`).
Jiyong Parkf653b052019-11-18 15:39:01 +09001046 af := apexFileForExecutable(ccTest)
1047 af.class = nativeTest
1048 filesInfo = append(filesInfo, af)
Roland Levillain9b5fde92019-06-28 15:41:19 +01001049 }
Roland Levillain630846d2019-06-26 12:48:34 +01001050 } else {
1051 ctx.PropertyErrorf("tests", "%q is not a cc module", depName)
1052 }
Jiyong Parkff1458f2018-10-12 21:49:38 +09001053 case keyTag:
1054 if key, ok := child.(*apexKey); ok {
Jiyong Park0ca3ce82019-02-18 15:25:04 +09001055 a.private_key_file = key.private_key_file
1056 a.public_key_file = key.public_key_file
Jiyong Parkff1458f2018-10-12 21:49:38 +09001057 } else {
1058 ctx.PropertyErrorf("key", "%q is not an apex_key module", depName)
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001059 }
Jiyong Parkf653b052019-11-18 15:39:01 +09001060 return false
Jiyong Parkc00cbd92018-10-30 21:20:05 +09001061 case certificateTag:
1062 if dep, ok := child.(*java.AndroidAppCertificate); ok {
Jiyong Park0ca3ce82019-02-18 15:25:04 +09001063 a.container_certificate_file = dep.Certificate.Pem
1064 a.container_private_key_file = dep.Certificate.Key
Jiyong Parkc00cbd92018-10-30 21:20:05 +09001065 } else {
1066 ctx.ModuleErrorf("certificate dependency %q must be an android_app_certificate module", depName)
1067 }
Jiyong Park03b68dd2019-07-26 23:20:40 +09001068 case android.PrebuiltDepTag:
1069 // If the prebuilt is force disabled, remember to delete the prebuilt file
1070 // that might have been installed in the previous builds
1071 if prebuilt, ok := child.(*Prebuilt); ok && prebuilt.isForceDisabled() {
1072 a.prebuiltFileToDelete = prebuilt.InstallFilename()
1073 }
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001074 }
Jooyung Han8aee2042019-10-29 05:08:31 +09001075 } else if !a.vndkApex {
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001076 // indirect dependencies
Jooyung Han9c80bae2019-08-20 17:30:57 +09001077 if am, ok := child.(android.ApexModule); ok {
Roland Levillainf89cd092019-07-29 16:22:59 +01001078 // We cannot use a switch statement on `depTag` here as the checked
1079 // tags used below are private (e.g. `cc.sharedDepTag`).
Jiyong Park52cd06f2019-11-11 10:14:32 +09001080 if cc.IsSharedDepTag(depTag) || cc.IsRuntimeDepTag(depTag) {
Roland Levillainf89cd092019-07-29 16:22:59 +01001081 if cc, ok := child.(*cc.Module); ok {
1082 if android.InList(cc.Name(), providedNativeSharedLibs) {
1083 // If we're using a shared library which is provided from other APEX,
1084 // don't include it in this APEX
1085 return false
Jiyong Parkac2bacd2019-02-20 21:49:26 +09001086 }
Roland Levillainf89cd092019-07-29 16:22:59 +01001087 if !a.Host() && (cc.IsStubs() || cc.HasStubsVariants()) {
1088 // If the dependency is a stubs lib, don't include it in this APEX,
1089 // but make sure that the lib is installed on the device.
1090 // In case no APEX is having the lib, the lib is installed to the system
1091 // partition.
1092 //
1093 // Always include if we are a host-apex however since those won't have any
1094 // system libraries.
1095 if !android.DirectlyInAnyApex(ctx, cc.Name()) && !android.InList(cc.Name(), a.externalDeps) {
1096 a.externalDeps = append(a.externalDeps, cc.Name())
1097 }
Jooyung Hane1633032019-08-01 17:41:43 +09001098 requireNativeLibs = append(requireNativeLibs, cc.OutputFile().Path().Base())
Roland Levillainf89cd092019-07-29 16:22:59 +01001099 // Don't track further
1100 return false
1101 }
Jiyong Parkf653b052019-11-18 15:39:01 +09001102 af := apexFileForNativeLibrary(cc, ctx.Config(), handleSpecialLibs)
1103 af.transitiveDep = true
1104 filesInfo = append(filesInfo, af)
1105 return true // track transitive dependencies
Jiyong Park25fc6a92018-11-18 18:02:45 +09001106 }
Roland Levillainf89cd092019-07-29 16:22:59 +01001107 } else if cc.IsTestPerSrcDepTag(depTag) {
1108 if cc, ok := child.(*cc.Module); ok {
Jiyong Parkf653b052019-11-18 15:39:01 +09001109 af := apexFileForExecutable(cc)
Roland Levillainf89cd092019-07-29 16:22:59 +01001110 // Handle modules created as `test_per_src` variations of a single test module:
1111 // use the name of the generated test binary (`fileToCopy`) instead of the name
1112 // of the original test module (`depName`, shared by all `test_per_src`
1113 // variations of that module).
Jiyong Parkf653b052019-11-18 15:39:01 +09001114 af.moduleName = filepath.Base(af.builtFile.String())
1115 af.transitiveDep = true
1116 filesInfo = append(filesInfo, af)
1117 return true // track transitive dependencies
Roland Levillainf89cd092019-07-29 16:22:59 +01001118 }
Jiyong Park52cd06f2019-11-11 10:14:32 +09001119 } else if java.IsJniDepTag(depTag) {
1120 // Do nothing for JNI dep. JNI libraries are always embedded in APK-in-APEX.
Jiyong Parkf653b052019-11-18 15:39:01 +09001121 return true
Jooyung Han9c80bae2019-08-20 17:30:57 +09001122 } else if am.CanHaveApexVariants() && am.IsInstallableToApex() {
Roland Levillainf89cd092019-07-29 16:22:59 +01001123 ctx.ModuleErrorf("unexpected tag %q for indirect dependency %q", depTag, depName)
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001124 }
1125 }
1126 }
1127 return false
1128 })
1129
Ulyana Trafimovichde534412019-11-08 10:51:01 +00001130 // Specific to the ART apex: dexpreopt artifacts for libcore Java libraries.
1131 // Build rules are generated by the dexpreopt singleton, and here we access build artifacts
1132 // via the global boot image config.
1133 if a.artApex {
1134 for arch, files := range java.DexpreoptedArtApexJars(ctx) {
1135 dirInApex := filepath.Join("javalib", arch.String())
1136 for _, f := range files {
1137 localModule := "javalib_" + arch.String() + "_" + filepath.Base(f.String())
Jiyong Parkf653b052019-11-18 15:39:01 +09001138 af := newApexFile(f, localModule, dirInApex, etc, nil)
1139 filesInfo = append(filesInfo, af)
Ulyana Trafimovichde534412019-11-08 10:51:01 +00001140 }
1141 }
1142 }
1143
Jiyong Park0ca3ce82019-02-18 15:25:04 +09001144 if a.private_key_file == nil {
Jiyong Parkfa0a3732018-11-09 05:52:26 +09001145 ctx.PropertyErrorf("key", "private_key for %q could not be found", String(a.properties.Key))
1146 return
1147 }
1148
Jiyong Park8fd61922018-11-08 02:50:25 +09001149 // remove duplicates in filesInfo
1150 removeDup := func(filesInfo []apexFile) []apexFile {
Jooyung Han344d5432019-08-23 11:17:39 +09001151 encountered := make(map[string]bool)
Jiyong Park8fd61922018-11-08 02:50:25 +09001152 result := []apexFile{}
1153 for _, f := range filesInfo {
Jooyung Han344d5432019-08-23 11:17:39 +09001154 dest := filepath.Join(f.installDir, f.builtFile.Base())
1155 if !encountered[dest] {
1156 encountered[dest] = true
Jiyong Park8fd61922018-11-08 02:50:25 +09001157 result = append(result, f)
1158 }
1159 }
1160 return result
1161 }
1162 filesInfo = removeDup(filesInfo)
1163
1164 // to have consistent build rules
1165 sort.Slice(filesInfo, func(i, j int) bool {
1166 return filesInfo[i].builtFile.String() < filesInfo[j].builtFile.String()
1167 })
1168
Jiyong Park127b40b2019-09-30 16:04:35 +09001169 // check apex_available requirements
Jiyong Park3814f4d2019-12-02 13:08:53 +09001170 if !ctx.Host() && !a.testApex {
Jiyong Park583a2262019-10-08 20:55:38 +09001171 for _, fi := range filesInfo {
1172 if am, ok := fi.module.(android.ApexModule); ok {
1173 if !am.AvailableFor(ctx.ModuleName()) {
1174 ctx.ModuleErrorf("requires %q that is not available for the APEX", fi.module.Name())
Jiyong Park3814f4d2019-12-02 13:08:53 +09001175 // don't stop so that we can report other violations in the same run
Jiyong Park583a2262019-10-08 20:55:38 +09001176 }
Jiyong Park127b40b2019-09-30 16:04:35 +09001177 }
1178 }
1179 }
1180
Jiyong Park8fd61922018-11-08 02:50:25 +09001181 // prepend the name of this APEX to the module names. These names will be the names of
1182 // modules that will be defined if the APEX is flattened.
1183 for i := range filesInfo {
Jaewoong Jung1670ca02019-11-22 14:50:42 -08001184 filesInfo[i].moduleName = filesInfo[i].moduleName + "." + a.Name() + a.suffix
Jiyong Park8fd61922018-11-08 02:50:25 +09001185 }
1186
Jiyong Park8fd61922018-11-08 02:50:25 +09001187 a.installDir = android.PathForModuleInstall(ctx, "apex")
1188 a.filesInfo = filesInfo
Alex Light5098a612018-11-29 17:12:15 -08001189
Jooyung Han54aca7b2019-11-20 02:26:02 +09001190 if a.properties.ApexType != zipApex {
1191 if a.properties.File_contexts == nil {
1192 a.fileContexts = android.PathForSource(ctx, "system/sepolicy/apex", ctx.ModuleName()+"-file_contexts")
1193 } else {
1194 a.fileContexts = android.PathForModuleSrc(ctx, *a.properties.File_contexts)
1195 if a.Platform() {
1196 if matched, err := path.Match("system/sepolicy/**/*", a.fileContexts.String()); err != nil || !matched {
1197 ctx.PropertyErrorf("file_contexts", "should be under system/sepolicy, but %q", a.fileContexts)
1198 }
1199 }
1200 }
1201 if !android.ExistentPathForSource(ctx, a.fileContexts.String()).Valid() {
1202 ctx.PropertyErrorf("file_contexts", "cannot find file_contexts file: %q", a.fileContexts)
1203 return
1204 }
1205 }
1206
Jooyung Hand15aa1f2019-09-27 00:38:03 +09001207 // prepare apex_manifest.json
Jooyung Han01a3ee22019-11-02 02:52:25 +09001208 a.buildManifest(ctx, provideNativeLibs, requireNativeLibs)
1209
1210 a.setCertificateAndPrivateKey(ctx)
1211 if a.properties.ApexType == flattenedApex {
1212 a.buildFlattenedApex(ctx)
1213 } else {
1214 a.buildUnflattenedApex(ctx)
1215 }
1216
Jaewoong Jung1670ca02019-11-22 14:50:42 -08001217 apexName := proptools.StringDefault(a.properties.Apex_name, a.Name())
Jooyung Han01a3ee22019-11-02 02:52:25 +09001218 a.compatSymlinks = makeCompatSymlinks(apexName, ctx)
1219}
1220
Jooyung Han344d5432019-08-23 11:17:39 +09001221func newApexBundle() *apexBundle {
Sundong Ahnabb64432019-10-22 13:58:29 +09001222 module := &apexBundle{}
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001223 module.AddProperties(&module.properties)
Alex Light9670d332019-01-29 18:07:33 -08001224 module.AddProperties(&module.targetProperties)
Jiyong Park5d790c32019-11-15 18:40:32 +09001225 module.AddProperties(&module.overridableProperties)
Alex Light5098a612018-11-29 17:12:15 -08001226 module.Prefer32(func(ctx android.BaseModuleContext, base *android.ModuleBase, class android.OsClass) bool {
Jiyong Park397e55e2018-10-24 21:09:55 +09001227 return class == android.Device && ctx.Config().DevicePrefer32BitExecutables()
1228 })
Alex Light5098a612018-11-29 17:12:15 -08001229 android.InitAndroidMultiTargetsArchModule(module, android.HostAndDeviceSupported, android.MultilibCommon)
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001230 android.InitDefaultableModule(module)
Jiyong Parkd1063c12019-07-17 20:08:41 +09001231 android.InitSdkAwareModule(module)
Jiyong Park5d790c32019-11-15 18:40:32 +09001232 android.InitOverridableModule(module, &module.properties.Overrides)
Jiyong Park48ca7dc2018-10-10 14:01:00 +09001233 return module
1234}
Jiyong Park30ca9372019-02-07 16:27:23 +09001235
Ulyana Trafimovichde534412019-11-08 10:51:01 +00001236func ApexBundleFactory(testApex bool, artApex bool) android.Module {
Jooyung Han344d5432019-08-23 11:17:39 +09001237 bundle := newApexBundle()
1238 bundle.testApex = testApex
Ulyana Trafimovichde534412019-11-08 10:51:01 +00001239 bundle.artApex = artApex
Jooyung Han344d5432019-08-23 11:17:39 +09001240 return bundle
1241}
1242
1243func testApexBundleFactory() android.Module {
1244 bundle := newApexBundle()
1245 bundle.testApex = true
1246 return bundle
1247}
1248
Jiyong Parkd1063c12019-07-17 20:08:41 +09001249func BundleFactory() android.Module {
Jooyung Han344d5432019-08-23 11:17:39 +09001250 return newApexBundle()
1251}
1252
Jiyong Park30ca9372019-02-07 16:27:23 +09001253//
1254// Defaults
1255//
1256type Defaults struct {
1257 android.ModuleBase
1258 android.DefaultsModuleBase
1259}
1260
Jiyong Park30ca9372019-02-07 16:27:23 +09001261func defaultsFactory() android.Module {
1262 return DefaultsFactory()
1263}
1264
1265func DefaultsFactory(props ...interface{}) android.Module {
1266 module := &Defaults{}
1267
1268 module.AddProperties(props...)
1269 module.AddProperties(
1270 &apexBundleProperties{},
1271 &apexTargetBundleProperties{},
1272 )
1273
1274 android.InitDefaultsModule(module)
1275 return module
1276}
Jiyong Park5d790c32019-11-15 18:40:32 +09001277
1278//
1279// OverrideApex
1280//
1281type OverrideApex struct {
1282 android.ModuleBase
1283 android.OverrideModuleBase
1284}
1285
1286func (o *OverrideApex) GenerateAndroidBuildActions(ctx android.ModuleContext) {
1287 // All the overrides happen in the base module.
1288}
1289
1290// override_apex is used to create an apex module based on another apex module
1291// by overriding some of its properties.
1292func overrideApexFactory() android.Module {
1293 m := &OverrideApex{}
1294 m.AddProperties(&overridableProperties{})
1295
1296 android.InitAndroidMultiTargetsArchModule(m, android.DeviceSupported, android.MultilibCommon)
1297 android.InitOverrideModule(m)
1298 return m
1299}