// Copyright (C) 2018 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package apex import ( "fmt" "path/filepath" "sort" "strings" "github.com/google/blueprint" "github.com/google/blueprint/bootstrap" "github.com/google/blueprint/proptools" "android/soong/android" "android/soong/bpf" "android/soong/cc" prebuilt_etc "android/soong/etc" "android/soong/java" "android/soong/python" "android/soong/sh" ) const ( imageApexSuffix = ".apex" zipApexSuffix = ".zipapex" flattenedSuffix = ".flattened" imageApexType = "image" zipApexType = "zip" flattenedApexType = "flattened" ext4FsType = "ext4" f2fsFsType = "f2fs" ) type dependencyTag struct { blueprint.BaseDependencyTag name string // determines if the dependent will be part of the APEX payload payload bool } var ( sharedLibTag = dependencyTag{name: "sharedLib", payload: true} jniLibTag = dependencyTag{name: "jniLib", payload: true} executableTag = dependencyTag{name: "executable", payload: true} javaLibTag = dependencyTag{name: "javaLib", payload: true} prebuiltTag = dependencyTag{name: "prebuilt", payload: true} testTag = dependencyTag{name: "test", payload: true} keyTag = dependencyTag{name: "key"} certificateTag = dependencyTag{name: "certificate"} usesTag = dependencyTag{name: "uses"} androidAppTag = dependencyTag{name: "androidApp", payload: true} rroTag = dependencyTag{name: "rro", payload: true} bpfTag = dependencyTag{name: "bpf", payload: true} testForTag = dependencyTag{name: "test for"} apexAvailBaseline = makeApexAvailableBaseline() inverseApexAvailBaseline = invertApexBaseline(apexAvailBaseline) ) // Transform the map of apex -> modules to module -> apexes. func invertApexBaseline(m map[string][]string) map[string][]string { r := make(map[string][]string) for apex, modules := range m { for _, module := range modules { r[module] = append(r[module], apex) } } return r } // Retrieve the baseline of apexes to which the supplied module belongs. func BaselineApexAvailable(moduleName string) []string { return inverseApexAvailBaseline[normalizeModuleName(moduleName)] } // This is a map from apex to modules, which overrides the // apex_available setting for that particular module to make // it available for the apex regardless of its setting. // TODO(b/147364041): remove this func makeApexAvailableBaseline() map[string][]string { // The "Module separator"s below are employed to minimize merge conflicts. m := make(map[string][]string) // // Module separator // m["com.android.appsearch"] = []string{ "icing-java-proto-lite", "libprotobuf-java-lite", } // // Module separator // m["com.android.bluetooth.updatable"] = []string{ "android.hardware.audio.common@5.0", "android.hardware.bluetooth.a2dp@1.0", "android.hardware.bluetooth.audio@2.0", "android.hardware.bluetooth@1.0", "android.hardware.bluetooth@1.1", "android.hardware.graphics.bufferqueue@1.0", "android.hardware.graphics.bufferqueue@2.0", "android.hardware.graphics.common@1.0", "android.hardware.graphics.common@1.1", "android.hardware.graphics.common@1.2", "android.hardware.media@1.0", "android.hidl.safe_union@1.0", "android.hidl.token@1.0", "android.hidl.token@1.0-utils", "avrcp-target-service", "avrcp_headers", "bluetooth-protos-lite", "bluetooth.mapsapi", "com.android.vcard", "dnsresolver_aidl_interface-V2-java", "ipmemorystore-aidl-interfaces-V5-java", "ipmemorystore-aidl-interfaces-java", "internal_include_headers", "lib-bt-packets", "lib-bt-packets-avrcp", "lib-bt-packets-base", "libFraunhoferAAC", "libaudio-a2dp-hw-utils", "libaudio-hearing-aid-hw-utils", "libbinder_headers", "libbluetooth", "libbluetooth-types", "libbluetooth-types-header", "libbluetooth_gd", "libbluetooth_headers", "libbluetooth_jni", "libbt-audio-hal-interface", "libbt-bta", "libbt-common", "libbt-hci", "libbt-platform-protos-lite", "libbt-protos-lite", "libbt-sbc-decoder", "libbt-sbc-encoder", "libbt-stack", "libbt-utils", "libbtcore", "libbtdevice", "libbte", "libbtif", "libchrome", "libevent", "libfmq", "libg722codec", "libgui_headers", "libmedia_headers", "libmodpb64", "libosi", "libstagefright_foundation_headers", "libstagefright_headers", "libstatslog", "libstatssocket", "libtinyxml2", "libudrv-uipc", "libz", "media_plugin_headers", "net-utils-services-common", "netd_aidl_interface-unstable-java", "netd_event_listener_interface-java", "netlink-client", "networkstack-client", "sap-api-java-static", "services.net", } // // Module separator // m["com.android.cellbroadcast"] = []string{"CellBroadcastApp", "CellBroadcastServiceModule"} // // Module separator // m["com.android.extservices"] = []string{ "error_prone_annotations", "ExtServices-core", "ExtServices", "libtextclassifier-java", "libz_current", "textclassifier-statsd", "TextClassifierNotificationLibNoManifest", "TextClassifierServiceLibNoManifest", } // // Module separator // m["com.android.neuralnetworks"] = []string{ "android.hardware.neuralnetworks@1.0", "android.hardware.neuralnetworks@1.1", "android.hardware.neuralnetworks@1.2", "android.hardware.neuralnetworks@1.3", "android.hidl.allocator@1.0", "android.hidl.memory.token@1.0", "android.hidl.memory@1.0", "android.hidl.safe_union@1.0", "libarect", "libbuildversion", "libmath", "libprocpartition", "libsync", } // // Module separator // m["com.android.media"] = []string{ "android.frameworks.bufferhub@1.0", "android.hardware.cas.native@1.0", "android.hardware.cas@1.0", "android.hardware.configstore-utils", "android.hardware.configstore@1.0", "android.hardware.configstore@1.1", "android.hardware.graphics.allocator@2.0", "android.hardware.graphics.allocator@3.0", "android.hardware.graphics.bufferqueue@1.0", "android.hardware.graphics.bufferqueue@2.0", "android.hardware.graphics.common@1.0", "android.hardware.graphics.common@1.1", "android.hardware.graphics.common@1.2", "android.hardware.graphics.mapper@2.0", "android.hardware.graphics.mapper@2.1", "android.hardware.graphics.mapper@3.0", "android.hardware.media.omx@1.0", "android.hardware.media@1.0", "android.hidl.allocator@1.0", "android.hidl.memory.token@1.0", "android.hidl.memory@1.0", "android.hidl.token@1.0", "android.hidl.token@1.0-utils", "bionic_libc_platform_headers", "exoplayer2-extractor", "exoplayer2-extractor-annotation-stubs", "gl_headers", "jsr305", "libEGL", "libEGL_blobCache", "libEGL_getProcAddress", "libFLAC", "libFLAC-config", "libFLAC-headers", "libGLESv2", "libaacextractor", "libamrextractor", "libarect", "libaudio_system_headers", "libaudioclient", "libaudioclient_headers", "libaudiofoundation", "libaudiofoundation_headers", "libaudiomanager", "libaudiopolicy", "libaudioutils", "libaudioutils_fixedfft", "libbinder_headers", "libbluetooth-types-header", "libbufferhub", "libbufferhub_headers", "libbufferhubqueue", "libc_malloc_debug_backtrace", "libcamera_client", "libcamera_metadata", "libdvr_headers", "libexpat", "libfifo", "libflacextractor", "libgrallocusage", "libgraphicsenv", "libgui", "libgui_headers", "libhardware_headers", "libinput", "liblzma", "libmath", "libmedia", "libmedia_codeclist", "libmedia_headers", "libmedia_helper", "libmedia_helper_headers", "libmedia_midiiowrapper", "libmedia_omx", "libmediautils", "libmidiextractor", "libmkvextractor", "libmp3extractor", "libmp4extractor", "libmpeg2extractor", "libnativebase_headers", "libnativewindow_headers", "libnblog", "liboggextractor", "libpackagelistparser", "libpdx", "libpdx_default_transport", "libpdx_headers", "libpdx_uds", "libprocinfo", "libspeexresampler", "libspeexresampler", "libstagefright_esds", "libstagefright_flacdec", "libstagefright_flacdec", "libstagefright_foundation", "libstagefright_foundation_headers", "libstagefright_foundation_without_imemory", "libstagefright_headers", "libstagefright_id3", "libstagefright_metadatautils", "libstagefright_mpeg2extractor", "libstagefright_mpeg2support", "libsync", "libui", "libui_headers", "libunwindstack", "libvibrator", "libvorbisidec", "libwavextractor", "libwebm", "media_ndk_headers", "media_plugin_headers", "updatable-media", } // // Module separator // m["com.android.media.swcodec"] = []string{ "android.frameworks.bufferhub@1.0", "android.hardware.common-ndk_platform", "android.hardware.configstore-utils", "android.hardware.configstore@1.0", "android.hardware.configstore@1.1", "android.hardware.graphics.allocator@2.0", "android.hardware.graphics.allocator@3.0", "android.hardware.graphics.allocator@4.0", "android.hardware.graphics.bufferqueue@1.0", "android.hardware.graphics.bufferqueue@2.0", "android.hardware.graphics.common-ndk_platform", "android.hardware.graphics.common@1.0", "android.hardware.graphics.common@1.1", "android.hardware.graphics.common@1.2", "android.hardware.graphics.mapper@2.0", "android.hardware.graphics.mapper@2.1", "android.hardware.graphics.mapper@3.0", "android.hardware.graphics.mapper@4.0", "android.hardware.media.bufferpool@2.0", "android.hardware.media.c2@1.0", "android.hardware.media.c2@1.1", "android.hardware.media.omx@1.0", "android.hardware.media@1.0", "android.hardware.media@1.0", "android.hidl.memory.token@1.0", "android.hidl.memory@1.0", "android.hidl.safe_union@1.0", "android.hidl.token@1.0", "android.hidl.token@1.0-utils", "libEGL", "libFLAC", "libFLAC-config", "libFLAC-headers", "libFraunhoferAAC", "libLibGuiProperties", "libarect", "libaudio_system_headers", "libaudioutils", "libaudioutils", "libaudioutils_fixedfft", "libavcdec", "libavcenc", "libavservices_minijail", "libavservices_minijail", "libbinder_headers", "libbinderthreadstateutils", "libbluetooth-types-header", "libbufferhub_headers", "libcodec2", "libcodec2_headers", "libcodec2_hidl@1.0", "libcodec2_hidl@1.1", "libcodec2_internal", "libcodec2_soft_aacdec", "libcodec2_soft_aacenc", "libcodec2_soft_amrnbdec", "libcodec2_soft_amrnbenc", "libcodec2_soft_amrwbdec", "libcodec2_soft_amrwbenc", "libcodec2_soft_av1dec_gav1", "libcodec2_soft_avcdec", "libcodec2_soft_avcenc", "libcodec2_soft_common", "libcodec2_soft_flacdec", "libcodec2_soft_flacenc", "libcodec2_soft_g711alawdec", "libcodec2_soft_g711mlawdec", "libcodec2_soft_gsmdec", "libcodec2_soft_h263dec", "libcodec2_soft_h263enc", "libcodec2_soft_hevcdec", "libcodec2_soft_hevcenc", "libcodec2_soft_mp3dec", "libcodec2_soft_mpeg2dec", "libcodec2_soft_mpeg4dec", "libcodec2_soft_mpeg4enc", "libcodec2_soft_opusdec", "libcodec2_soft_opusenc", "libcodec2_soft_rawdec", "libcodec2_soft_vorbisdec", "libcodec2_soft_vp8dec", "libcodec2_soft_vp8enc", "libcodec2_soft_vp9dec", "libcodec2_soft_vp9enc", "libcodec2_vndk", "libdvr_headers", "libfmq", "libfmq", "libgav1", "libgralloctypes", "libgrallocusage", "libgraphicsenv", "libgsm", "libgui_bufferqueue_static", "libgui_headers", "libhardware", "libhardware_headers", "libhevcdec", "libhevcenc", "libion", "libjpeg", "liblzma", "libmath", "libmedia_codecserviceregistrant", "libmedia_headers", "libmpeg2dec", "libnativebase_headers", "libnativewindow_headers", "libpdx_headers", "libscudo_wrapper", "libsfplugin_ccodec_utils", "libspeexresampler", "libstagefright_amrnb_common", "libstagefright_amrnbdec", "libstagefright_amrnbenc", "libstagefright_amrwbdec", "libstagefright_amrwbenc", "libstagefright_bufferpool@2.0.1", "libstagefright_bufferqueue_helper", "libstagefright_enc_common", "libstagefright_flacdec", "libstagefright_foundation", "libstagefright_foundation_headers", "libstagefright_headers", "libstagefright_m4vh263dec", "libstagefright_m4vh263enc", "libstagefright_mp3dec", "libsync", "libui", "libui_headers", "libunwindstack", "libvorbisidec", "libvpx", "libyuv", "libyuv_static", "media_ndk_headers", "media_plugin_headers", "mediaswcodec", } // // Module separator // m["com.android.mediaprovider"] = []string{ "MediaProvider", "MediaProviderGoogle", "fmtlib_ndk", "libbase_ndk", "libfuse", "libfuse_jni", } // // Module separator // m["com.android.permission"] = []string{ "car-ui-lib", "iconloader", "kotlin-annotations", "kotlin-stdlib", "kotlin-stdlib-jdk7", "kotlin-stdlib-jdk8", "kotlinx-coroutines-android", "kotlinx-coroutines-android-nodeps", "kotlinx-coroutines-core", "kotlinx-coroutines-core-nodeps", "permissioncontroller-statsd", "GooglePermissionController", "PermissionController", "SettingsLibActionBarShadow", "SettingsLibAppPreference", "SettingsLibBarChartPreference", "SettingsLibLayoutPreference", "SettingsLibProgressBar", "SettingsLibSearchWidget", "SettingsLibSettingsTheme", "SettingsLibRestrictedLockUtils", "SettingsLibHelpUtils", } // // Module separator // m["com.android.runtime"] = []string{ "bionic_libc_platform_headers", "libarm-optimized-routines-math", "libc_aeabi", "libc_bionic", "libc_bionic_ndk", "libc_bootstrap", "libc_common", "libc_common_shared", "libc_common_static", "libc_dns", "libc_dynamic_dispatch", "libc_fortify", "libc_freebsd", "libc_freebsd_large_stack", "libc_gdtoa", "libc_init_dynamic", "libc_init_static", "libc_jemalloc_wrapper", "libc_netbsd", "libc_nomalloc", "libc_nopthread", "libc_openbsd", "libc_openbsd_large_stack", "libc_openbsd_ndk", "libc_pthread", "libc_static_dispatch", "libc_syscalls", "libc_tzcode", "libc_unwind_static", "libdebuggerd", "libdebuggerd_common_headers", "libdebuggerd_handler_core", "libdebuggerd_handler_fallback", "libdl_static", "libjemalloc5", "liblinker_main", "liblinker_malloc", "liblz4", "liblzma", "libprocinfo", "libpropertyinfoparser", "libscudo", "libstdc++", "libsystemproperties", "libtombstoned_client_static", "libunwindstack", "libz", "libziparchive", } // // Module separator // m["com.android.tethering"] = []string{ "android.hardware.tetheroffload.config-V1.0-java", "android.hardware.tetheroffload.control-V1.0-java", "android.hidl.base-V1.0-java", "libcgrouprc", "libcgrouprc_format", "libtetherutilsjni", "libvndksupport", "net-utils-framework-common", "netd_aidl_interface-V3-java", "netlink-client", "networkstack-aidl-interfaces-java", "tethering-aidl-interfaces-java", "TetheringApiCurrentLib", } // // Module separator // m["com.android.wifi"] = []string{ "PlatformProperties", "android.hardware.wifi-V1.0-java", "android.hardware.wifi-V1.0-java-constants", "android.hardware.wifi-V1.1-java", "android.hardware.wifi-V1.2-java", "android.hardware.wifi-V1.3-java", "android.hardware.wifi-V1.4-java", "android.hardware.wifi.hostapd-V1.0-java", "android.hardware.wifi.hostapd-V1.1-java", "android.hardware.wifi.hostapd-V1.2-java", "android.hardware.wifi.supplicant-V1.0-java", "android.hardware.wifi.supplicant-V1.1-java", "android.hardware.wifi.supplicant-V1.2-java", "android.hardware.wifi.supplicant-V1.3-java", "android.hidl.base-V1.0-java", "android.hidl.manager-V1.0-java", "android.hidl.manager-V1.1-java", "android.hidl.manager-V1.2-java", "bouncycastle-unbundled", "dnsresolver_aidl_interface-V2-java", "error_prone_annotations", "framework-wifi-pre-jarjar", "framework-wifi-util-lib", "ipmemorystore-aidl-interfaces-V3-java", "ipmemorystore-aidl-interfaces-java", "ksoap2", "libnanohttpd", "libwifi-jni", "net-utils-services-common", "netd_aidl_interface-V2-java", "netd_aidl_interface-unstable-java", "netd_event_listener_interface-java", "netlink-client", "networkstack-client", "services.net", "wifi-lite-protos", "wifi-nano-protos", "wifi-service-pre-jarjar", "wifi-service-resources", } // // Module separator // m["com.android.sdkext"] = []string{ "fmtlib_ndk", "libbase_ndk", "libprotobuf-cpp-lite-ndk", } // // Module separator // m["com.android.os.statsd"] = []string{ "libstatssocket", } // // Module separator // m[android.AvailableToAnyApex] = []string{ // TODO(b/156996905) Set apex_available/min_sdk_version for androidx/extras support libraries "androidx", "androidx-constraintlayout_constraintlayout", "androidx-constraintlayout_constraintlayout-nodeps", "androidx-constraintlayout_constraintlayout-solver", "androidx-constraintlayout_constraintlayout-solver-nodeps", "com.google.android.material_material", "com.google.android.material_material-nodeps", "libatomic", "libclang_rt", "libgcc_stripped", "libprofile-clang-extras", "libprofile-clang-extras_ndk", "libprofile-extras", "libprofile-extras_ndk", "libunwind_llvm", } return m } // DO NOT EDIT! These are the package prefixes that are exempted from being AOT'ed by ART. // Adding code to the bootclasspath in new packages will cause issues on module update. func qModulesPackages() map[string][]string { return map[string][]string{ "com.android.conscrypt": []string{ "android.net.ssl", "com.android.org.conscrypt", }, "com.android.media": []string{ "android.media", }, } } // DO NOT EDIT! These are the package prefixes that are exempted from being AOT'ed by ART. // Adding code to the bootclasspath in new packages will cause issues on module update. func rModulesPackages() map[string][]string { return map[string][]string{ "com.android.mediaprovider": []string{ "android.provider", }, "com.android.permission": []string{ "android.permission", "android.app.role", "com.android.permission", "com.android.role", }, "com.android.sdkext": []string{ "android.os.ext", }, "com.android.os.statsd": []string{ "android.app", "android.os", "android.util", "com.android.internal.statsd", "com.android.server.stats", }, "com.android.wifi": []string{ "com.android.server.wifi", "com.android.wifi.x", "android.hardware.wifi", "android.net.wifi", }, "com.android.tethering": []string{ "android.net", }, } } func init() { android.RegisterModuleType("apex", BundleFactory) android.RegisterModuleType("apex_test", testApexBundleFactory) android.RegisterModuleType("apex_vndk", vndkApexBundleFactory) android.RegisterModuleType("apex_defaults", defaultsFactory) android.RegisterModuleType("prebuilt_apex", PrebuiltFactory) android.RegisterModuleType("override_apex", overrideApexFactory) android.RegisterModuleType("apex_set", apexSetFactory) android.PreDepsMutators(RegisterPreDepsMutators) android.PostDepsMutators(RegisterPostDepsMutators) android.AddNeverAllowRules(createApexPermittedPackagesRules(qModulesPackages())...) android.AddNeverAllowRules(createApexPermittedPackagesRules(rModulesPackages())...) } func createApexPermittedPackagesRules(modules_packages map[string][]string) []android.Rule { rules := make([]android.Rule, 0, len(modules_packages)) for module_name, module_packages := range modules_packages { permitted_packages_rule := android.NeverAllow(). BootclasspathJar(). With("apex_available", module_name). WithMatcher("permitted_packages", android.NotInList(module_packages)). Because("jars that are part of the " + module_name + " module may only allow these packages: " + strings.Join(module_packages, ",") + ". Please jarjar or move code around.") rules = append(rules, permitted_packages_rule) } return rules } func RegisterPreDepsMutators(ctx android.RegisterMutatorsContext) { ctx.TopDown("apex_vndk", apexVndkMutator).Parallel() ctx.BottomUp("apex_vndk_deps", apexVndkDepsMutator).Parallel() } func RegisterPostDepsMutators(ctx android.RegisterMutatorsContext) { ctx.TopDown("apex_deps", apexDepsMutator).Parallel() ctx.BottomUp("apex_unique", apexUniqueVariationsMutator).Parallel() ctx.BottomUp("apex_test_for_deps", apexTestForDepsMutator).Parallel() ctx.BottomUp("apex_test_for", apexTestForMutator).Parallel() ctx.BottomUp("apex", apexMutator).Parallel() ctx.BottomUp("apex_directly_in_any", apexDirectlyInAnyMutator).Parallel() ctx.BottomUp("apex_flattened", apexFlattenedMutator).Parallel() ctx.BottomUp("apex_uses", apexUsesMutator).Parallel() ctx.BottomUp("mark_platform_availability", markPlatformAvailability).Parallel() } // Mark the direct and transitive dependencies of apex bundles so that they // can be built for the apex bundles. func apexDepsMutator(mctx android.TopDownMutatorContext) { if !mctx.Module().Enabled() { return } a, ok := mctx.Module().(*apexBundle) if !ok || a.vndkApex { return } useVndk := a.SocSpecific() || a.DeviceSpecific() || (a.ProductSpecific() && mctx.Config().EnforceProductPartitionInterface()) excludeVndkLibs := useVndk && proptools.Bool(a.properties.Use_vndk_as_stable) if !useVndk && proptools.Bool(a.properties.Use_vndk_as_stable) { mctx.PropertyErrorf("use_vndk_as_stable", "not supported for system/system_ext APEXes") return } contents := make(map[string]android.ApexMembership) continueApexDepsWalk := func(child, parent android.Module) bool { am, ok := child.(android.ApexModule) if !ok || !am.CanHaveApexVariants() { return false } if !parent.(android.DepIsInSameApex).DepIsInSameApex(mctx, child) { return false } if excludeVndkLibs { if c, ok := child.(*cc.Module); ok && c.IsVndk() { return false } } return true } mctx.WalkDeps(func(child, parent android.Module) bool { if !continueApexDepsWalk(child, parent) { return false } depName := mctx.OtherModuleName(child) // If the parent is apexBundle, this child is directly depended. _, directDep := parent.(*apexBundle) contents[depName] = contents[depName].Add(directDep) return true }) apexContents := android.NewApexContents(mctx.ModuleName(), contents) mctx.SetProvider(ApexBundleInfoProvider, ApexBundleInfo{ Contents: apexContents, }) apexInfo := android.ApexInfo{ ApexVariationName: mctx.ModuleName(), MinSdkVersionStr: a.minSdkVersion(mctx).String(), RequiredSdks: a.RequiredSdks(), Updatable: a.Updatable(), InApexes: []string{mctx.ModuleName()}, ApexContents: []*android.ApexContents{apexContents}, } mctx.WalkDeps(func(child, parent android.Module) bool { if !continueApexDepsWalk(child, parent) { return false } child.(android.ApexModule).BuildForApex(apexInfo) return true }) } func apexUniqueVariationsMutator(mctx android.BottomUpMutatorContext) { if !mctx.Module().Enabled() { return } if am, ok := mctx.Module().(android.ApexModule); ok { // Check if any dependencies use unique apex variations. If so, use unique apex variations // for this module. android.UpdateUniqueApexVariationsForDeps(mctx, am) } } func apexTestForDepsMutator(mctx android.BottomUpMutatorContext) { if !mctx.Module().Enabled() { return } // Check if this module is a test for an apex. If so, add a dependency on the apex // in order to retrieve its contents later. if am, ok := mctx.Module().(android.ApexModule); ok { if testFor := am.TestFor(); len(testFor) > 0 { mctx.AddFarVariationDependencies([]blueprint.Variation{ {Mutator: "os", Variation: am.Target().OsVariation()}, {"arch", "common"}, }, testForTag, testFor...) } } } func apexTestForMutator(mctx android.BottomUpMutatorContext) { if !mctx.Module().Enabled() { return } if _, ok := mctx.Module().(android.ApexModule); ok { var contents []*android.ApexContents for _, testFor := range mctx.GetDirectDepsWithTag(testForTag) { abInfo := mctx.OtherModuleProvider(testFor, ApexBundleInfoProvider).(ApexBundleInfo) contents = append(contents, abInfo.Contents) } mctx.SetProvider(android.ApexTestForInfoProvider, android.ApexTestForInfo{ ApexContents: contents, }) } } // mark if a module cannot be available to platform. A module cannot be available // to platform if 1) it is explicitly marked as not available (i.e. "//apex_available:platform" // is absent) or 2) it depends on another module that isn't (or can't be) available to platform func markPlatformAvailability(mctx android.BottomUpMutatorContext) { // Host and recovery are not considered as platform if mctx.Host() || mctx.Module().InstallInRecovery() { return } if am, ok := mctx.Module().(android.ApexModule); ok { availableToPlatform := am.AvailableFor(android.AvailableToPlatform) // If any of the dep is not available to platform, this module is also considered // as being not available to platform even if it has "//apex_available:platform" mctx.VisitDirectDeps(func(child android.Module) { if !am.DepIsInSameApex(mctx, child) { // if the dependency crosses apex boundary, don't consider it return } if dep, ok := child.(android.ApexModule); ok && dep.NotAvailableForPlatform() { availableToPlatform = false // TODO(b/154889534) trigger an error when 'am' has "//apex_available:platform" } }) // Exception 1: stub libraries and native bridge libraries are always available to platform if cc, ok := mctx.Module().(*cc.Module); ok && (cc.IsStubs() || cc.Target().NativeBridge == android.NativeBridgeEnabled) { availableToPlatform = true } // Exception 2: bootstrap bionic libraries are also always available to platform if cc.InstallToBootstrap(mctx.ModuleName(), mctx.Config()) { availableToPlatform = true } if !availableToPlatform { am.SetNotAvailableForPlatform() } } } // If a module in an APEX depends on a module from an SDK then it needs an APEX // specific variant created for it. Refer to sdk.sdkDepsReplaceMutator. func inAnySdk(module android.Module) bool { if sa, ok := module.(android.SdkAware); ok { return sa.IsInAnySdk() } return false } // Create apex variations if a module is included in APEX(s). func apexMutator(mctx android.BottomUpMutatorContext) { if !mctx.Module().Enabled() { return } if am, ok := mctx.Module().(android.ApexModule); ok && am.CanHaveApexVariants() { android.CreateApexVariations(mctx, am) } else if a, ok := mctx.Module().(*apexBundle); ok && !a.vndkApex { // apex bundle itself is mutated so that it and its modules have same // apex variant. apexBundleName := mctx.ModuleName() mctx.CreateVariations(apexBundleName) } else if o, ok := mctx.Module().(*OverrideApex); ok { apexBundleName := o.GetOverriddenModuleName() if apexBundleName == "" { mctx.ModuleErrorf("base property is not set") return } mctx.CreateVariations(apexBundleName) } } func apexDirectlyInAnyMutator(mctx android.BottomUpMutatorContext) { if !mctx.Module().Enabled() { return } if am, ok := mctx.Module().(android.ApexModule); ok { android.UpdateDirectlyInAnyApex(mctx, am) } } func apexFlattenedMutator(mctx android.BottomUpMutatorContext) { if !mctx.Module().Enabled() { return } if ab, ok := mctx.Module().(*apexBundle); ok { var variants []string switch proptools.StringDefault(ab.properties.Payload_type, "image") { case "image": variants = append(variants, imageApexType, flattenedApexType) case "zip": variants = append(variants, zipApexType) case "both": variants = append(variants, imageApexType, zipApexType, flattenedApexType) default: mctx.PropertyErrorf("type", "%q is not one of \"image\", \"zip\", or \"both\".", *ab.properties.Payload_type) return } modules := mctx.CreateLocalVariations(variants...) for i, v := range variants { switch v { case imageApexType: modules[i].(*apexBundle).properties.ApexType = imageApex case zipApexType: modules[i].(*apexBundle).properties.ApexType = zipApex case flattenedApexType: modules[i].(*apexBundle).properties.ApexType = flattenedApex if !mctx.Config().FlattenApex() && ab.Platform() { modules[i].(*apexBundle).MakeAsSystemExt() } } } } else if _, ok := mctx.Module().(*OverrideApex); ok { mctx.CreateVariations(imageApexType, flattenedApexType) } } func apexUsesMutator(mctx android.BottomUpMutatorContext) { if ab, ok := mctx.Module().(*apexBundle); ok { mctx.AddFarVariationDependencies(nil, usesTag, ab.properties.Uses...) } } var ( useVendorAllowListKey = android.NewOnceKey("useVendorAllowList") ) // useVendorAllowList returns the list of APEXes which are allowed to use_vendor. // When use_vendor is used, native modules are built with __ANDROID_VNDK__ and __ANDROID_APEX__, // which may cause compatibility issues. (e.g. libbinder) // Even though libbinder restricts its availability via 'apex_available' property and relies on // yet another macro __ANDROID_APEX___, we restrict usage of "use_vendor:" from other APEX modules // to avoid similar problems. func useVendorAllowList(config android.Config) []string { return config.Once(useVendorAllowListKey, func() interface{} { return []string{ // swcodec uses "vendor" variants for smaller size "com.android.media.swcodec", "test_com.android.media.swcodec", } }).([]string) } // setUseVendorAllowListForTest overrides useVendorAllowList and must be // called before the first call to useVendorAllowList() func setUseVendorAllowListForTest(config android.Config, allowList []string) { config.Once(useVendorAllowListKey, func() interface{} { return allowList }) } type ApexNativeDependencies struct { // List of native libraries Native_shared_libs []string // List of JNI libraries Jni_libs []string // List of native executables Binaries []string // List of native tests Tests []string } type apexMultilibProperties struct { // Native dependencies whose compile_multilib is "first" First ApexNativeDependencies // Native dependencies whose compile_multilib is "both" Both ApexNativeDependencies // Native dependencies whose compile_multilib is "prefer32" Prefer32 ApexNativeDependencies // Native dependencies whose compile_multilib is "32" Lib32 ApexNativeDependencies // Native dependencies whose compile_multilib is "64" Lib64 ApexNativeDependencies } type apexBundleProperties struct { // Json manifest file describing meta info of this APEX bundle. Default: // "apex_manifest.json" Manifest *string `android:"path"` // AndroidManifest.xml file used for the zip container of this APEX bundle. // If unspecified, a default one is automatically generated. AndroidManifest *string `android:"path"` // Canonical name of the APEX bundle. Used to determine the path to the activated APEX on // device (/apex/). // If unspecified, defaults to the value of name. Apex_name *string // Determines the file contexts file for setting security context to each file in this APEX bundle. // For platform APEXes, this should points to a file under /system/sepolicy // Default: /system/sepolicy/apex/_file_contexts. File_contexts *string `android:"path"` ApexNativeDependencies // List of java libraries that are embedded inside this APEX bundle Java_libs []string // List of prebuilt files that are embedded inside this APEX bundle Prebuilts []string // List of BPF programs inside APEX Bpfs []string // Name of the apex_key module that provides the private key to sign APEX Key *string // The type of APEX to build. Controls what the APEX payload is. Either // 'image', 'zip' or 'both'. Default: 'image'. Payload_type *string // The name of a certificate in the default certificate directory, blank to use the default product certificate, // or an android_app_certificate module name in the form ":module". Certificate *string // Whether this APEX is installable to one of the partitions. Default: true. Installable *bool // For native libraries and binaries, use the vendor variant instead of the core (platform) variant. // Default is false. Use_vendor *bool // For telling the apex to ignore special handling for system libraries such as bionic. Default is false. Ignore_system_library_special_case *bool Multilib apexMultilibProperties // List of sanitizer names that this APEX is enabled for SanitizerNames []string `blueprint:"mutated"` PreventInstall bool `blueprint:"mutated"` HideFromMake bool `blueprint:"mutated"` // Indicates this APEX provides C++ shared libaries to other APEXes. Default: false. Provide_cpp_shared_libs *bool // List of providing APEXes' names so that this APEX can depend on provided shared libraries. Uses []string // package format of this apex variant; could be non-flattened, flattened, or zip. // imageApex, zipApex or flattened ApexType apexPackaging `blueprint:"mutated"` // List of SDKs that are used to build this APEX. A reference to an SDK should be either // `name#version` or `name` which is an alias for `name#current`. If left empty, `platform#current` // is implied. This value affects all modules included in this APEX. In other words, they are // also built with the SDKs specified here. Uses_sdks []string // Whenever apex_payload.img of the APEX should include dm-verity hashtree. // Should be only used in tests#. Test_only_no_hashtree *bool // Whenever apex_payload.img of the APEX should not be dm-verity signed. // Should be only used in tests#. Test_only_unsigned_payload *bool IsCoverageVariant bool `blueprint:"mutated"` // Whether this APEX is considered updatable or not. When set to true, this will enforce additional // rules for making sure that the APEX is truly updatable. // - To be updatable, min_sdk_version should be set as well // This will also disable the size optimizations like symlinking to the system libs. // Default is false. Updatable *bool // The minimum SDK version that this apex must be compatibile with. Min_sdk_version *string // If set true, VNDK libs are considered as stable libs and are not included in this apex. // Should be only used in non-system apexes (e.g. vendor: true). // Default is false. Use_vndk_as_stable *bool // The type of filesystem to use for an image apex. Either 'ext4' or 'f2fs'. // Default 'ext4'. Payload_fs_type *string } type ApexBundleInfo struct { Contents *android.ApexContents } var ApexBundleInfoProvider = blueprint.NewMutatorProvider(ApexBundleInfo{}, "apex_deps") type apexTargetBundleProperties struct { Target struct { // Multilib properties only for android. Android struct { Multilib apexMultilibProperties } // Multilib properties only for host. Host struct { Multilib apexMultilibProperties } // Multilib properties only for host linux_bionic. Linux_bionic struct { Multilib apexMultilibProperties } // Multilib properties only for host linux_glibc. Linux_glibc struct { Multilib apexMultilibProperties } } } type overridableProperties struct { // List of APKs to package inside APEX Apps []string // List of runtime resource overlays (RROs) inside APEX Rros []string // Names of modules to be overridden. Listed modules can only be other binaries // (in Make or Soong). // This does not completely prevent installation of the overridden binaries, but if both // binaries would be installed by default (in PRODUCT_PACKAGES) the other binary will be removed // from PRODUCT_PACKAGES. Overrides []string // Logging Parent value Logging_parent string // Apex Container Package Name. // Override value for attribute package:name in AndroidManifest.xml Package_name string // A txt file containing list of files that are allowed to be included in this APEX. Allowed_files *string `android:"path"` } type apexPackaging int const ( imageApex apexPackaging = iota zipApex flattenedApex ) // The suffix for the output "file", not the module func (a apexPackaging) suffix() string { switch a { case imageApex: return imageApexSuffix case zipApex: return zipApexSuffix default: panic(fmt.Errorf("unknown APEX type %d", a)) } } func (a apexPackaging) name() string { switch a { case imageApex: return imageApexType case zipApex: return zipApexType default: panic(fmt.Errorf("unknown APEX type %d", a)) } } type apexFileClass int const ( etc apexFileClass = iota nativeSharedLib nativeExecutable shBinary pyBinary goBinary javaSharedLib nativeTest app appSet ) func (class apexFileClass) NameInMake() string { switch class { case etc: return "ETC" case nativeSharedLib: return "SHARED_LIBRARIES" case nativeExecutable, shBinary, pyBinary, goBinary: return "EXECUTABLES" case javaSharedLib: return "JAVA_LIBRARIES" case nativeTest: return "NATIVE_TESTS" case app, appSet: // b/142537672 Why isn't this APP? We want to have full control over // the paths and file names of the apk file under the flattend APEX. // If this is set to APP, then the paths and file names are modified // by the Make build system. For example, it is installed to // /system/apex//app//./ instead of // /system/apex//app/ because the build system automatically // appends module name (which is . to the path. return "ETC" default: panic(fmt.Errorf("unknown class %d", class)) } } // apexFile represents a file in an APEX bundle type apexFile struct { builtFile android.Path stem string // Module name of `module` in AndroidMk. Note the generated AndroidMk module for // apexFile is named something like .[] androidMkModuleName string installDir string class apexFileClass module android.Module // list of symlinks that will be created in installDir that point to this apexFile symlinks []string dataPaths []android.DataPath transitiveDep bool moduleDir string requiredModuleNames []string targetRequiredModuleNames []string hostRequiredModuleNames []string jacocoReportClassesFile android.Path // only for javalibs and apps lintDepSets java.LintDepSets // only for javalibs and apps certificate java.Certificate // only for apps overriddenPackageName string // only for apps isJniLib bool noticeFiles android.Paths } func newApexFile(ctx android.BaseModuleContext, builtFile android.Path, androidMkModuleName string, installDir string, class apexFileClass, module android.Module) apexFile { ret := apexFile{ builtFile: builtFile, androidMkModuleName: androidMkModuleName, installDir: installDir, class: class, module: module, } if module != nil { ret.moduleDir = ctx.OtherModuleDir(module) ret.requiredModuleNames = module.RequiredModuleNames() ret.targetRequiredModuleNames = module.TargetRequiredModuleNames() ret.hostRequiredModuleNames = module.HostRequiredModuleNames() ret.noticeFiles = module.NoticeFiles() } return ret } func (af *apexFile) Ok() bool { return af.builtFile != nil && af.builtFile.String() != "" } func (af *apexFile) apexRelativePath(path string) string { return filepath.Join(af.installDir, path) } // Path() returns path of this apex file relative to the APEX root func (af *apexFile) Path() string { return af.apexRelativePath(af.Stem()) } func (af *apexFile) Stem() string { if af.stem != "" { return af.stem } return af.builtFile.Base() } // SymlinkPaths() returns paths of the symlinks (if any) relative to the APEX root func (af *apexFile) SymlinkPaths() []string { var ret []string for _, symlink := range af.symlinks { ret = append(ret, af.apexRelativePath(symlink)) } return ret } func (af *apexFile) AvailableToPlatform() bool { if af.module == nil { return false } if am, ok := af.module.(android.ApexModule); ok { return am.AvailableFor(android.AvailableToPlatform) } return false } type fsType int const ( ext4 fsType = iota f2fs ) func (f fsType) string() string { switch f { case ext4: return ext4FsType case f2fs: return f2fsFsType default: panic(fmt.Errorf("unknown APEX payload type %d", f)) } } type apexBundle struct { android.ModuleBase android.DefaultableModuleBase android.OverridableModuleBase android.SdkBase properties apexBundleProperties targetProperties apexTargetBundleProperties overridableProperties overridableProperties // specific to apex_vndk modules vndkProperties apexVndkProperties bundleModuleFile android.WritablePath outputFile android.WritablePath installDir android.InstallPath prebuiltFileToDelete string public_key_file android.Path private_key_file android.Path container_certificate_file android.Path container_private_key_file android.Path fileContexts android.WritablePath // list of files to be included in this apex filesInfo []apexFile // list of module names that should be installed along with this APEX requiredDeps []string // list of module names that this APEX is including (to be shown via *-deps-info target) android.ApexBundleDepsInfo testApex bool vndkApex bool artApex bool primaryApexType bool manifestJsonOut android.WritablePath manifestPbOut android.WritablePath // list of commands to create symlinks for backward compatibility. // these commands will be attached as LOCAL_POST_INSTALL_CMD to // apex package itself(for unflattened build) or apex_manifest(for flattened build) // so that compat symlinks are always installed regardless of TARGET_FLATTEN_APEX setting. compatSymlinks []string // Suffix of module name in Android.mk // ".flattened", ".apex", ".zipapex", or "" suffix string installedFilesFile android.WritablePath // Whether to create symlink to the system file instead of having a file // inside the apex or not linkToSystemLib bool // Struct holding the merged notice file paths in different formats mergedNotices android.NoticeOutputs // Optional list of lint report zip files for apexes that contain java or app modules lintReports android.Paths payloadFsType fsType } func addDependenciesForNativeModules(ctx android.BottomUpMutatorContext, nativeModules ApexNativeDependencies, target android.Target, imageVariation string) { // Use *FarVariation* to be able to depend on modules having // conflicting variations with this module. This is required since // arch variant of an APEX bundle is 'common' but it is 'arm' or 'arm64' // for native shared libs. binVariations := target.Variations() libVariations := append(target.Variations(), blueprint.Variation{Mutator: "link", Variation: "shared"}) if ctx.Device() { binVariations = append(binVariations, blueprint.Variation{Mutator: "image", Variation: imageVariation}) libVariations = append(libVariations, blueprint.Variation{Mutator: "image", Variation: imageVariation}, blueprint.Variation{Mutator: "version", Variation: ""}) // "" is the non-stub variant } ctx.AddFarVariationDependencies(libVariations, sharedLibTag, nativeModules.Native_shared_libs...) ctx.AddFarVariationDependencies(libVariations, jniLibTag, nativeModules.Jni_libs...) ctx.AddFarVariationDependencies(binVariations, executableTag, nativeModules.Binaries...) ctx.AddFarVariationDependencies(binVariations, testTag, nativeModules.Tests...) } func (a *apexBundle) combineProperties(ctx android.BottomUpMutatorContext) { if ctx.Os().Class == android.Device { proptools.AppendProperties(&a.properties.Multilib, &a.targetProperties.Target.Android.Multilib, nil) } else { proptools.AppendProperties(&a.properties.Multilib, &a.targetProperties.Target.Host.Multilib, nil) if ctx.Os().Bionic() { proptools.AppendProperties(&a.properties.Multilib, &a.targetProperties.Target.Linux_bionic.Multilib, nil) } else { proptools.AppendProperties(&a.properties.Multilib, &a.targetProperties.Target.Linux_glibc.Multilib, nil) } } } func (a *apexBundle) DepsMutator(ctx android.BottomUpMutatorContext) { if proptools.Bool(a.properties.Use_vendor) && !android.InList(a.Name(), useVendorAllowList(ctx.Config())) { ctx.PropertyErrorf("use_vendor", "not allowed to set use_vendor: true") } targets := ctx.MultiTargets() config := ctx.DeviceConfig() imageVariation := a.getImageVariation(ctx) a.combineProperties(ctx) has32BitTarget := false for _, target := range targets { if target.Arch.ArchType.Multilib == "lib32" { has32BitTarget = true } } for i, target := range targets { if target.HostCross { // Don't include artifats for the host cross targets because there is no way // for us to run those artifacts natively on host continue } // When multilib.* is omitted for native_shared_libs/jni_libs/tests, it implies // multilib.both addDependenciesForNativeModules(ctx, ApexNativeDependencies{ Native_shared_libs: a.properties.Native_shared_libs, Tests: a.properties.Tests, Jni_libs: a.properties.Jni_libs, Binaries: nil, }, target, imageVariation) // Add native modules targetting both ABIs addDependenciesForNativeModules(ctx, a.properties.Multilib.Both, target, imageVariation) isPrimaryAbi := i == 0 if isPrimaryAbi { // When multilib.* is omitted for binaries, it implies // multilib.first addDependenciesForNativeModules(ctx, ApexNativeDependencies{ Native_shared_libs: nil, Tests: nil, Jni_libs: nil, Binaries: a.properties.Binaries, }, target, imageVariation) // Add native modules targetting the first ABI addDependenciesForNativeModules(ctx, a.properties.Multilib.First, target, imageVariation) } switch target.Arch.ArchType.Multilib { case "lib32": // Add native modules targetting 32-bit ABI addDependenciesForNativeModules(ctx, a.properties.Multilib.Lib32, target, imageVariation) addDependenciesForNativeModules(ctx, a.properties.Multilib.Prefer32, target, imageVariation) case "lib64": // Add native modules targetting 64-bit ABI addDependenciesForNativeModules(ctx, a.properties.Multilib.Lib64, target, imageVariation) if !has32BitTarget { addDependenciesForNativeModules(ctx, a.properties.Multilib.Prefer32, target, imageVariation) } } } // For prebuilt_etc, use the first variant (64 on 64/32bit device, // 32 on 32bit device) regardless of the TARGET_PREFER_* setting. // b/144532908 archForPrebuiltEtc := config.Arches()[0] for _, arch := range config.Arches() { // Prefer 64-bit arch if there is any if arch.ArchType.Multilib == "lib64" { archForPrebuiltEtc = arch break } } ctx.AddFarVariationDependencies([]blueprint.Variation{ {Mutator: "os", Variation: ctx.Os().String()}, {Mutator: "arch", Variation: archForPrebuiltEtc.String()}, }, prebuiltTag, a.properties.Prebuilts...) ctx.AddFarVariationDependencies(ctx.Config().AndroidCommonTarget.Variations(), javaLibTag, a.properties.Java_libs...) ctx.AddFarVariationDependencies(ctx.Config().AndroidCommonTarget.Variations(), bpfTag, a.properties.Bpfs...) // With EMMA_INSTRUMENT_FRAMEWORK=true the ART boot image includes jacoco library. if a.artApex && ctx.Config().IsEnvTrue("EMMA_INSTRUMENT_FRAMEWORK") { ctx.AddFarVariationDependencies(ctx.Config().AndroidCommonTarget.Variations(), javaLibTag, "jacocoagent") } if String(a.properties.Key) == "" { ctx.ModuleErrorf("key is missing") return } ctx.AddDependency(ctx.Module(), keyTag, String(a.properties.Key)) cert := android.SrcIsModule(a.getCertString(ctx)) if cert != "" { ctx.AddDependency(ctx.Module(), certificateTag, cert) } // TODO(jiyong): ensure that all apexes are with non-empty uses_sdks if len(a.properties.Uses_sdks) > 0 { sdkRefs := []android.SdkRef{} for _, str := range a.properties.Uses_sdks { parsed := android.ParseSdkRef(ctx, str, "uses_sdks") sdkRefs = append(sdkRefs, parsed) } a.BuildWithSdks(sdkRefs) } } func (a *apexBundle) OverridablePropertiesDepsMutator(ctx android.BottomUpMutatorContext) { if a.overridableProperties.Allowed_files != nil { android.ExtractSourceDeps(ctx, a.overridableProperties.Allowed_files) } ctx.AddFarVariationDependencies(ctx.Config().AndroidCommonTarget.Variations(), androidAppTag, a.overridableProperties.Apps...) ctx.AddFarVariationDependencies(ctx.Config().AndroidCommonTarget.Variations(), rroTag, a.overridableProperties.Rros...) } func (a *apexBundle) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool { // direct deps of an APEX bundle are all part of the APEX bundle return true } func (a *apexBundle) getCertString(ctx android.BaseModuleContext) string { moduleName := ctx.ModuleName() // VNDK APEXes share the same certificate. To avoid adding a new VNDK version to the OVERRIDE_* list, // we check with the pseudo module name to see if its certificate is overridden. if a.vndkApex { moduleName = vndkApexName } certificate, overridden := ctx.DeviceConfig().OverrideCertificateFor(moduleName) if overridden { return ":" + certificate } return String(a.properties.Certificate) } func (a *apexBundle) OutputFiles(tag string) (android.Paths, error) { switch tag { case "": return android.Paths{a.outputFile}, nil default: return nil, fmt.Errorf("unsupported module reference tag %q", tag) } } func (a *apexBundle) installable() bool { return !a.properties.PreventInstall && (a.properties.Installable == nil || proptools.Bool(a.properties.Installable)) } func (a *apexBundle) testOnlyShouldSkipHashtreeGeneration() bool { return proptools.Bool(a.properties.Test_only_no_hashtree) } func (a *apexBundle) testOnlyShouldSkipPayloadSign() bool { return proptools.Bool(a.properties.Test_only_unsigned_payload) } func (a *apexBundle) getImageVariation(ctx android.BottomUpMutatorContext) string { deviceConfig := ctx.DeviceConfig() if a.vndkApex { return cc.VendorVariationPrefix + a.vndkVersion(deviceConfig) } var prefix string var vndkVersion string if deviceConfig.VndkVersion() != "" { if proptools.Bool(a.properties.Use_vendor) { prefix = cc.VendorVariationPrefix vndkVersion = deviceConfig.PlatformVndkVersion() } else if a.SocSpecific() || a.DeviceSpecific() { prefix = cc.VendorVariationPrefix vndkVersion = deviceConfig.VndkVersion() } else if a.ProductSpecific() { prefix = cc.ProductVariationPrefix vndkVersion = deviceConfig.ProductVndkVersion() } } if vndkVersion == "current" { vndkVersion = deviceConfig.PlatformVndkVersion() } if vndkVersion != "" { return prefix + vndkVersion } return android.CoreVariation } func (a *apexBundle) EnableSanitizer(sanitizerName string) { if !android.InList(sanitizerName, a.properties.SanitizerNames) { a.properties.SanitizerNames = append(a.properties.SanitizerNames, sanitizerName) } } func (a *apexBundle) IsSanitizerEnabled(ctx android.BaseModuleContext, sanitizerName string) bool { if android.InList(sanitizerName, a.properties.SanitizerNames) { return true } // Then follow the global setting globalSanitizerNames := []string{} if a.Host() { globalSanitizerNames = ctx.Config().SanitizeHost() } else { arches := ctx.Config().SanitizeDeviceArch() if len(arches) == 0 || android.InList(a.Arch().ArchType.Name, arches) { globalSanitizerNames = ctx.Config().SanitizeDevice() } } return android.InList(sanitizerName, globalSanitizerNames) } func (a *apexBundle) AddSanitizerDependencies(ctx android.BottomUpMutatorContext, sanitizerName string) { if ctx.Device() && sanitizerName == "hwaddress" && strings.HasPrefix(a.Name(), "com.android.runtime") { for _, target := range ctx.MultiTargets() { if target.Arch.ArchType.Multilib == "lib64" { ctx.AddFarVariationDependencies(append(target.Variations(), []blueprint.Variation{ {Mutator: "image", Variation: a.getImageVariation(ctx)}, {Mutator: "link", Variation: "shared"}, {Mutator: "version", Variation: ""}, // "" is the non-stub variant }...), sharedLibTag, "libclang_rt.hwasan-aarch64-android") break } } } } var _ cc.Coverage = (*apexBundle)(nil) func (a *apexBundle) IsNativeCoverageNeeded(ctx android.BaseModuleContext) bool { return ctx.Device() && ctx.DeviceConfig().NativeCoverageEnabled() } func (a *apexBundle) PreventInstall() { a.properties.PreventInstall = true } func (a *apexBundle) HideFromMake() { a.properties.HideFromMake = true } func (a *apexBundle) MarkAsCoverageVariant(coverage bool) { a.properties.IsCoverageVariant = coverage } func (a *apexBundle) EnableCoverageIfNeeded() {} // TODO(jiyong) move apexFileFor* close to the apexFile type definition func apexFileForNativeLibrary(ctx android.BaseModuleContext, ccMod *cc.Module, handleSpecialLibs bool) apexFile { // Decide the APEX-local directory by the multilib of the library // In the future, we may query this to the module. var dirInApex string switch ccMod.Arch().ArchType.Multilib { case "lib32": dirInApex = "lib" case "lib64": dirInApex = "lib64" } if ccMod.Target().NativeBridge == android.NativeBridgeEnabled { dirInApex = filepath.Join(dirInApex, ccMod.Target().NativeBridgeRelativePath) } dirInApex = filepath.Join(dirInApex, ccMod.RelativeInstallPath()) if handleSpecialLibs && cc.InstallToBootstrap(ccMod.BaseModuleName(), ctx.Config()) { // Special case for Bionic libs and other libs installed with them. This is // to prevent those libs from being included in the search path // /apex/com.android.runtime/${LIB}. This exclusion is required because // those libs in the Runtime APEX are available via the legacy paths in // /system/lib/. By the init process, the libs in the APEX are bind-mounted // to the legacy paths and thus will be loaded into the default linker // namespace (aka "platform" namespace). If the libs are directly in // /apex/com.android.runtime/${LIB} then the same libs will be loaded again // into the runtime linker namespace, which will result in double loading of // them, which isn't supported. dirInApex = filepath.Join(dirInApex, "bionic") } fileToCopy := ccMod.OutputFile().Path() androidMkModuleName := ccMod.BaseModuleName() + ccMod.Properties.SubName return newApexFile(ctx, fileToCopy, androidMkModuleName, dirInApex, nativeSharedLib, ccMod) } func apexFileForExecutable(ctx android.BaseModuleContext, cc *cc.Module) apexFile { dirInApex := "bin" if cc.Target().NativeBridge == android.NativeBridgeEnabled { dirInApex = filepath.Join(dirInApex, cc.Target().NativeBridgeRelativePath) } dirInApex = filepath.Join(dirInApex, cc.RelativeInstallPath()) fileToCopy := cc.OutputFile().Path() androidMkModuleName := cc.BaseModuleName() + cc.Properties.SubName af := newApexFile(ctx, fileToCopy, androidMkModuleName, dirInApex, nativeExecutable, cc) af.symlinks = cc.Symlinks() af.dataPaths = cc.DataPaths() return af } func apexFileForPyBinary(ctx android.BaseModuleContext, py *python.Module) apexFile { dirInApex := "bin" fileToCopy := py.HostToolPath().Path() return newApexFile(ctx, fileToCopy, py.BaseModuleName(), dirInApex, pyBinary, py) } func apexFileForGoBinary(ctx android.BaseModuleContext, depName string, gb bootstrap.GoBinaryTool) apexFile { dirInApex := "bin" s, err := filepath.Rel(android.PathForOutput(ctx).String(), gb.InstallPath()) if err != nil { ctx.ModuleErrorf("Unable to use compiled binary at %s", gb.InstallPath()) return apexFile{} } fileToCopy := android.PathForOutput(ctx, s) // NB: Since go binaries are static we don't need the module for anything here, which is // good since the go tool is a blueprint.Module not an android.Module like we would // normally use. return newApexFile(ctx, fileToCopy, depName, dirInApex, goBinary, nil) } func apexFileForShBinary(ctx android.BaseModuleContext, sh *sh.ShBinary) apexFile { dirInApex := filepath.Join("bin", sh.SubDir()) fileToCopy := sh.OutputFile() af := newApexFile(ctx, fileToCopy, sh.BaseModuleName(), dirInApex, shBinary, sh) af.symlinks = sh.Symlinks() return af } type javaModule interface { android.Module BaseModuleName() string DexJarBuildPath() android.Path JacocoReportClassesFile() android.Path LintDepSets() java.LintDepSets Stem() string } var _ javaModule = (*java.Library)(nil) var _ javaModule = (*java.SdkLibrary)(nil) var _ javaModule = (*java.DexImport)(nil) var _ javaModule = (*java.SdkLibraryImport)(nil) func apexFileForJavaLibrary(ctx android.BaseModuleContext, module javaModule) apexFile { dirInApex := "javalib" fileToCopy := module.DexJarBuildPath() af := newApexFile(ctx, fileToCopy, module.BaseModuleName(), dirInApex, javaSharedLib, module) af.jacocoReportClassesFile = module.JacocoReportClassesFile() af.lintDepSets = module.LintDepSets() af.stem = module.Stem() + ".jar" return af } func apexFileForPrebuiltEtc(ctx android.BaseModuleContext, prebuilt prebuilt_etc.PrebuiltEtcModule, depName string) apexFile { dirInApex := filepath.Join(prebuilt.BaseDir(), prebuilt.SubDir()) fileToCopy := prebuilt.OutputFile() return newApexFile(ctx, fileToCopy, depName, dirInApex, etc, prebuilt) } func apexFileForCompatConfig(ctx android.BaseModuleContext, config java.PlatformCompatConfigIntf, depName string) apexFile { dirInApex := filepath.Join("etc", config.SubDir()) fileToCopy := config.CompatConfig() return newApexFile(ctx, fileToCopy, depName, dirInApex, etc, config) } func apexFileForAndroidApp(ctx android.BaseModuleContext, aapp interface { android.Module Privileged() bool InstallApkName() string OutputFile() android.Path JacocoReportClassesFile() android.Path Certificate() java.Certificate BaseModuleName() string }) apexFile { appDir := "app" if aapp.Privileged() { appDir = "priv-app" } dirInApex := filepath.Join(appDir, aapp.InstallApkName()) fileToCopy := aapp.OutputFile() af := newApexFile(ctx, fileToCopy, aapp.BaseModuleName(), dirInApex, app, aapp) af.jacocoReportClassesFile = aapp.JacocoReportClassesFile() af.certificate = aapp.Certificate() if app, ok := aapp.(interface { OverriddenManifestPackageName() string }); ok { af.overriddenPackageName = app.OverriddenManifestPackageName() } return af } func apexFileForRuntimeResourceOverlay(ctx android.BaseModuleContext, rro java.RuntimeResourceOverlayModule) apexFile { rroDir := "overlay" dirInApex := filepath.Join(rroDir, rro.Theme()) fileToCopy := rro.OutputFile() af := newApexFile(ctx, fileToCopy, rro.Name(), dirInApex, app, rro) af.certificate = rro.Certificate() if a, ok := rro.(interface { OverriddenManifestPackageName() string }); ok { af.overriddenPackageName = a.OverriddenManifestPackageName() } return af } func apexFileForBpfProgram(ctx android.BaseModuleContext, builtFile android.Path, bpfProgram bpf.BpfModule) apexFile { dirInApex := filepath.Join("etc", "bpf") return newApexFile(ctx, builtFile, builtFile.Base(), dirInApex, etc, bpfProgram) } // Context "decorator", overriding the InstallBypassMake method to always reply `true`. type flattenedApexContext struct { android.ModuleContext } func (c *flattenedApexContext) InstallBypassMake() bool { return true } // Visit dependencies that contributes to the payload of this APEX func (a *apexBundle) WalkPayloadDeps(ctx android.ModuleContext, do android.PayloadDepsCallback) { ctx.WalkDeps(func(child, parent android.Module) bool { am, ok := child.(android.ApexModule) if !ok || !am.CanHaveApexVariants() { return false } childApexInfo := ctx.OtherModuleProvider(child, android.ApexInfoProvider).(android.ApexInfo) dt := ctx.OtherModuleDependencyTag(child) if _, ok := dt.(android.ExcludeFromApexContentsTag); ok { return false } // Check for the direct dependencies that contribute to the payload if adt, ok := dt.(dependencyTag); ok { if adt.payload { return do(ctx, parent, am, false /* externalDep */) } // As soon as the dependency graph crosses the APEX boundary, don't go further. return false } // Check for the indirect dependencies if it is considered as part of the APEX if android.InList(ctx.ModuleName(), childApexInfo.InApexes) { return do(ctx, parent, am, false /* externalDep */) } return do(ctx, parent, am, true /* externalDep */) }) } func (a *apexBundle) minSdkVersion(ctx android.BaseModuleContext) android.ApiLevel { ver := proptools.String(a.properties.Min_sdk_version) if ver == "" { return android.FutureApiLevel } apiLevel, err := android.ApiLevelFromUser(ctx, ver) if err != nil { ctx.PropertyErrorf("min_sdk_version", "%s", err.Error()) return android.NoneApiLevel } if apiLevel.IsPreview() { // All codenames should build against "current". return android.FutureApiLevel } return apiLevel } func (a *apexBundle) Updatable() bool { return proptools.Bool(a.properties.Updatable) } var _ android.ApexBundleDepsInfoIntf = (*apexBundle)(nil) // Ensures that the dependencies are marked as available for this APEX func (a *apexBundle) checkApexAvailability(ctx android.ModuleContext) { // Let's be practical. Availability for test, host, and the VNDK apex isn't important if ctx.Host() || a.testApex || a.vndkApex { return } // Because APEXes targeting other than system/system_ext partitions // can't set apex_available, we skip checks for these APEXes if a.SocSpecific() || a.DeviceSpecific() || (a.ProductSpecific() && ctx.Config().EnforceProductPartitionInterface()) { return } // Coverage build adds additional dependencies for the coverage-only runtime libraries. // Requiring them and their transitive depencies with apex_available is not right // because they just add noise. if ctx.Config().IsEnvTrue("EMMA_INSTRUMENT") || a.IsNativeCoverageNeeded(ctx) { return } a.WalkPayloadDeps(ctx, func(ctx android.ModuleContext, from blueprint.Module, to android.ApexModule, externalDep bool) bool { if externalDep { // As soon as the dependency graph crosses the APEX boundary, don't go further. return false } apexName := ctx.ModuleName() fromName := ctx.OtherModuleName(from) toName := ctx.OtherModuleName(to) // If `to` is not actually in the same APEX as `from` then it does not need apex_available and neither // do any of its dependencies. if am, ok := from.(android.DepIsInSameApex); ok && !am.DepIsInSameApex(ctx, to) { // As soon as the dependency graph crosses the APEX boundary, don't go further. return false } if to.AvailableFor(apexName) || baselineApexAvailable(apexName, toName) { return true } ctx.ModuleErrorf("%q requires %q that doesn't list the APEX under 'apex_available'. Dependency path:%s", fromName, toName, ctx.GetPathString(true)) // Visit this module's dependencies to check and report any issues with their availability. return true }) } func (a *apexBundle) checkUpdatable(ctx android.ModuleContext) { if a.Updatable() { if String(a.properties.Min_sdk_version) == "" { ctx.PropertyErrorf("updatable", "updatable APEXes should set min_sdk_version as well") } a.checkJavaStableSdkVersion(ctx) } } func (a *apexBundle) checkMinSdkVersion(ctx android.ModuleContext) { if a.testApex || a.vndkApex { return } // Meaningless to check min_sdk_version when building use_vendor modules against non-Trebleized targets if proptools.Bool(a.properties.Use_vendor) && ctx.DeviceConfig().VndkVersion() == "" { return } // apexBundle::minSdkVersion reports its own errors. minSdkVersion := a.minSdkVersion(ctx) android.CheckMinSdkVersion(a, ctx, minSdkVersion) } // Ensures that a lib providing stub isn't statically linked func (a *apexBundle) checkStaticLinkingToStubLibraries(ctx android.ModuleContext) { // Practically, we only care about regular APEXes on the device. if ctx.Host() || a.testApex || a.vndkApex { return } abInfo := ctx.Provider(ApexBundleInfoProvider).(ApexBundleInfo) a.WalkPayloadDeps(ctx, func(ctx android.ModuleContext, from blueprint.Module, to android.ApexModule, externalDep bool) bool { if ccm, ok := to.(*cc.Module); ok { apexName := ctx.ModuleName() fromName := ctx.OtherModuleName(from) toName := ctx.OtherModuleName(to) // If `to` is not actually in the same APEX as `from` then it does not need apex_available and neither // do any of its dependencies. if am, ok := from.(android.DepIsInSameApex); ok && !am.DepIsInSameApex(ctx, to) { // As soon as the dependency graph crosses the APEX boundary, don't go further. return false } // The dynamic linker and crash_dump tool in the runtime APEX is the only exception to this rule. // It can't make the static dependencies dynamic because it can't // do the dynamic linking for itself. if apexName == "com.android.runtime" && (fromName == "linker" || fromName == "crash_dump") { return false } isStubLibraryFromOtherApex := ccm.HasStubsVariants() && !abInfo.Contents.DirectlyInApex(toName) if isStubLibraryFromOtherApex && !externalDep { ctx.ModuleErrorf("%q required by %q is a native library providing stub. "+ "It shouldn't be included in this APEX via static linking. Dependency path: %s", to.String(), fromName, ctx.GetPathString(false)) } } return true }) } func (a *apexBundle) GenerateAndroidBuildActions(ctx android.ModuleContext) { buildFlattenedAsDefault := ctx.Config().FlattenApex() && !ctx.Config().UnbundledBuildApps() switch a.properties.ApexType { case imageApex: if buildFlattenedAsDefault { a.suffix = imageApexSuffix } else { a.suffix = "" a.primaryApexType = true if ctx.Config().InstallExtraFlattenedApexes() { a.requiredDeps = append(a.requiredDeps, a.Name()+flattenedSuffix) } } case zipApex: if proptools.String(a.properties.Payload_type) == "zip" { a.suffix = "" a.primaryApexType = true } else { a.suffix = zipApexSuffix } case flattenedApex: if buildFlattenedAsDefault { a.suffix = "" a.primaryApexType = true } else { a.suffix = flattenedSuffix } } if len(a.properties.Tests) > 0 && !a.testApex { ctx.PropertyErrorf("tests", "property not allowed in apex module type") return } a.checkApexAvailability(ctx) a.checkUpdatable(ctx) a.checkMinSdkVersion(ctx) a.checkStaticLinkingToStubLibraries(ctx) handleSpecialLibs := !android.Bool(a.properties.Ignore_system_library_special_case) // native lib dependencies var provideNativeLibs []string var requireNativeLibs []string // Check if "uses" requirements are met with dependent apexBundles var providedNativeSharedLibs []string useVendor := proptools.Bool(a.properties.Use_vendor) ctx.VisitDirectDepsBlueprint(func(m blueprint.Module) { if ctx.OtherModuleDependencyTag(m) != usesTag { return } otherName := ctx.OtherModuleName(m) other, ok := m.(*apexBundle) if !ok { ctx.PropertyErrorf("uses", "%q is not a provider", otherName) return } if proptools.Bool(other.properties.Use_vendor) != useVendor { ctx.PropertyErrorf("use_vendor", "%q has different value of use_vendor", otherName) return } if !proptools.Bool(other.properties.Provide_cpp_shared_libs) { ctx.PropertyErrorf("uses", "%q does not provide native_shared_libs", otherName) return } providedNativeSharedLibs = append(providedNativeSharedLibs, other.properties.Native_shared_libs...) }) var filesInfo []apexFile // TODO(jiyong) do this using WalkPayloadDeps ctx.WalkDepsBlueprint(func(child, parent blueprint.Module) bool { depTag := ctx.OtherModuleDependencyTag(child) if _, ok := depTag.(android.ExcludeFromApexContentsTag); ok { return false } depName := ctx.OtherModuleName(child) if _, isDirectDep := parent.(*apexBundle); isDirectDep { switch depTag { case sharedLibTag, jniLibTag: isJniLib := depTag == jniLibTag if c, ok := child.(*cc.Module); ok { fi := apexFileForNativeLibrary(ctx, c, handleSpecialLibs) fi.isJniLib = isJniLib filesInfo = append(filesInfo, fi) // Collect the list of stub-providing libs except: // - VNDK libs are only for vendors // - bootstrap bionic libs are treated as provided by system if c.HasStubsVariants() && !a.vndkApex && !cc.InstallToBootstrap(c.BaseModuleName(), ctx.Config()) { provideNativeLibs = append(provideNativeLibs, fi.Stem()) } return true // track transitive dependencies } else { propertyName := "native_shared_libs" if isJniLib { propertyName = "jni_libs" } ctx.PropertyErrorf(propertyName, "%q is not a cc_library or cc_library_shared module", depName) } case executableTag: if cc, ok := child.(*cc.Module); ok { filesInfo = append(filesInfo, apexFileForExecutable(ctx, cc)) return true // track transitive dependencies } else if sh, ok := child.(*sh.ShBinary); ok { filesInfo = append(filesInfo, apexFileForShBinary(ctx, sh)) } else if py, ok := child.(*python.Module); ok && py.HostToolPath().Valid() { filesInfo = append(filesInfo, apexFileForPyBinary(ctx, py)) } else if gb, ok := child.(bootstrap.GoBinaryTool); ok && a.Host() { filesInfo = append(filesInfo, apexFileForGoBinary(ctx, depName, gb)) } else { ctx.PropertyErrorf("binaries", "%q is neither cc_binary, (embedded) py_binary, (host) blueprint_go_binary, (host) bootstrap_go_binary, nor sh_binary", depName) } case javaLibTag: switch child.(type) { case *java.Library, *java.SdkLibrary, *java.DexImport, *java.SdkLibraryImport: af := apexFileForJavaLibrary(ctx, child.(javaModule)) if !af.Ok() { ctx.PropertyErrorf("java_libs", "%q is not configured to be compiled into dex", depName) return false } filesInfo = append(filesInfo, af) return true // track transitive dependencies default: ctx.PropertyErrorf("java_libs", "%q of type %q is not supported", depName, ctx.OtherModuleType(child)) } case androidAppTag: if ap, ok := child.(*java.AndroidApp); ok { filesInfo = append(filesInfo, apexFileForAndroidApp(ctx, ap)) return true // track transitive dependencies } else if ap, ok := child.(*java.AndroidAppImport); ok { filesInfo = append(filesInfo, apexFileForAndroidApp(ctx, ap)) } else if ap, ok := child.(*java.AndroidTestHelperApp); ok { filesInfo = append(filesInfo, apexFileForAndroidApp(ctx, ap)) } else if ap, ok := child.(*java.AndroidAppSet); ok { appDir := "app" if ap.Privileged() { appDir = "priv-app" } af := newApexFile(ctx, ap.OutputFile(), ap.BaseModuleName(), filepath.Join(appDir, ap.BaseModuleName()), appSet, ap) af.certificate = java.PresignedCertificate filesInfo = append(filesInfo, af) } else { ctx.PropertyErrorf("apps", "%q is not an android_app module", depName) } case rroTag: if rro, ok := child.(java.RuntimeResourceOverlayModule); ok { filesInfo = append(filesInfo, apexFileForRuntimeResourceOverlay(ctx, rro)) } else { ctx.PropertyErrorf("rros", "%q is not an runtime_resource_overlay module", depName) } case bpfTag: if bpfProgram, ok := child.(bpf.BpfModule); ok { filesToCopy, _ := bpfProgram.OutputFiles("") for _, bpfFile := range filesToCopy { filesInfo = append(filesInfo, apexFileForBpfProgram(ctx, bpfFile, bpfProgram)) } } else { ctx.PropertyErrorf("bpfs", "%q is not a bpf module", depName) } case prebuiltTag: if prebuilt, ok := child.(prebuilt_etc.PrebuiltEtcModule); ok { filesInfo = append(filesInfo, apexFileForPrebuiltEtc(ctx, prebuilt, depName)) } else if prebuilt, ok := child.(java.PlatformCompatConfigIntf); ok { filesInfo = append(filesInfo, apexFileForCompatConfig(ctx, prebuilt, depName)) } else { ctx.PropertyErrorf("prebuilts", "%q is not a prebuilt_etc and not a platform_compat_config module", depName) } case testTag: if ccTest, ok := child.(*cc.Module); ok { if ccTest.IsTestPerSrcAllTestsVariation() { // Multiple-output test module (where `test_per_src: true`). // // `ccTest` is the "" ("all tests") variation of a `test_per_src` module. // We do not add this variation to `filesInfo`, as it has no output; // however, we do add the other variations of this module as indirect // dependencies (see below). } else { // Single-output test module (where `test_per_src: false`). af := apexFileForExecutable(ctx, ccTest) af.class = nativeTest filesInfo = append(filesInfo, af) } return true // track transitive dependencies } else { ctx.PropertyErrorf("tests", "%q is not a cc module", depName) } case keyTag: if key, ok := child.(*apexKey); ok { a.private_key_file = key.private_key_file a.public_key_file = key.public_key_file } else { ctx.PropertyErrorf("key", "%q is not an apex_key module", depName) } return false case certificateTag: if dep, ok := child.(*java.AndroidAppCertificate); ok { a.container_certificate_file = dep.Certificate.Pem a.container_private_key_file = dep.Certificate.Key } else { ctx.ModuleErrorf("certificate dependency %q must be an android_app_certificate module", depName) } case android.PrebuiltDepTag: // If the prebuilt is force disabled, remember to delete the prebuilt file // that might have been installed in the previous builds if prebuilt, ok := child.(prebuilt); ok && prebuilt.isForceDisabled() { a.prebuiltFileToDelete = prebuilt.InstallFilename() } } } else if !a.vndkApex { // indirect dependencies if am, ok := child.(android.ApexModule); ok { // We cannot use a switch statement on `depTag` here as the checked // tags used below are private (e.g. `cc.sharedDepTag`). if cc.IsSharedDepTag(depTag) || cc.IsRuntimeDepTag(depTag) { if cc, ok := child.(*cc.Module); ok { if android.InList(cc.Name(), providedNativeSharedLibs) { // If we're using a shared library which is provided from other APEX, // don't include it in this APEX return false } if cc.UseVndk() && proptools.Bool(a.properties.Use_vndk_as_stable) && cc.IsVndk() { requireNativeLibs = append(requireNativeLibs, ":vndk") return false } af := apexFileForNativeLibrary(ctx, cc, handleSpecialLibs) af.transitiveDep = true abInfo := ctx.Provider(ApexBundleInfoProvider).(ApexBundleInfo) if !a.Host() && !abInfo.Contents.DirectlyInApex(depName) && (cc.IsStubs() || cc.HasStubsVariants()) { // If the dependency is a stubs lib, don't include it in this APEX, // but make sure that the lib is installed on the device. // In case no APEX is having the lib, the lib is installed to the system // partition. // // Always include if we are a host-apex however since those won't have any // system libraries. if !am.DirectlyInAnyApex() { // we need a module name for Make name := cc.ImplementationModuleName(ctx) if !proptools.Bool(a.properties.Use_vendor) { // we don't use subName(.vendor) for a "use_vendor: true" apex // which is supposed to be installed in /system name += cc.Properties.SubName } if !android.InList(name, a.requiredDeps) { a.requiredDeps = append(a.requiredDeps, name) } } requireNativeLibs = append(requireNativeLibs, af.Stem()) // Don't track further return false } filesInfo = append(filesInfo, af) return true // track transitive dependencies } } else if cc.IsTestPerSrcDepTag(depTag) { if cc, ok := child.(*cc.Module); ok { af := apexFileForExecutable(ctx, cc) // Handle modules created as `test_per_src` variations of a single test module: // use the name of the generated test binary (`fileToCopy`) instead of the name // of the original test module (`depName`, shared by all `test_per_src` // variations of that module). af.androidMkModuleName = filepath.Base(af.builtFile.String()) // these are not considered transitive dep af.transitiveDep = false filesInfo = append(filesInfo, af) return true // track transitive dependencies } } else if java.IsJniDepTag(depTag) { // Because APK-in-APEX embeds jni_libs transitively, we don't need to track transitive deps return false } else if java.IsXmlPermissionsFileDepTag(depTag) { if prebuilt, ok := child.(prebuilt_etc.PrebuiltEtcModule); ok { filesInfo = append(filesInfo, apexFileForPrebuiltEtc(ctx, prebuilt, depName)) } } else if _, ok := depTag.(android.CopyDirectlyInAnyApexTag); ok { // nothing } else if am.CanHaveApexVariants() && am.IsInstallableToApex() { ctx.ModuleErrorf("unexpected tag %s for indirect dependency %q", android.PrettyPrintTag(depTag), depName) } } } return false }) // Specific to the ART apex: dexpreopt artifacts for libcore Java libraries. // Build rules are generated by the dexpreopt singleton, and here we access build artifacts // via the global boot image config. if a.artApex { for arch, files := range java.DexpreoptedArtApexJars(ctx) { dirInApex := filepath.Join("javalib", arch.String()) for _, f := range files { localModule := "javalib_" + arch.String() + "_" + filepath.Base(f.String()) af := newApexFile(ctx, f, localModule, dirInApex, etc, nil) filesInfo = append(filesInfo, af) } } } if a.private_key_file == nil { ctx.PropertyErrorf("key", "private_key for %q could not be found", String(a.properties.Key)) return } // remove duplicates in filesInfo removeDup := func(filesInfo []apexFile) []apexFile { encountered := make(map[string]apexFile) for _, f := range filesInfo { dest := filepath.Join(f.installDir, f.builtFile.Base()) if e, ok := encountered[dest]; !ok { encountered[dest] = f } else { // If a module is directly included and also transitively depended on // consider it as directly included. e.transitiveDep = e.transitiveDep && f.transitiveDep encountered[dest] = e } } var result []apexFile for _, v := range encountered { result = append(result, v) } return result } filesInfo = removeDup(filesInfo) // to have consistent build rules sort.Slice(filesInfo, func(i, j int) bool { return filesInfo[i].builtFile.String() < filesInfo[j].builtFile.String() }) a.installDir = android.PathForModuleInstall(ctx, "apex") a.filesInfo = filesInfo switch proptools.StringDefault(a.properties.Payload_fs_type, ext4FsType) { case ext4FsType: a.payloadFsType = ext4 case f2fsFsType: a.payloadFsType = f2fs default: ctx.PropertyErrorf("payload_fs_type", "%q is not a valid filesystem for apex [ext4, f2fs]", *a.properties.Payload_fs_type) } // Optimization. If we are building bundled APEX, for the files that are gathered due to the // transitive dependencies, don't place them inside the APEX, but place a symlink pointing // the same library in the system partition, thus effectively sharing the same libraries // across the APEX boundary. For unbundled APEX, all the gathered files are actually placed // in the APEX. a.linkToSystemLib = !ctx.Config().UnbundledBuild() && a.installable() && !proptools.Bool(a.properties.Use_vendor) // APEXes targeting other than system/system_ext partitions use vendor/product variants. // So we can't link them to /system/lib libs which are core variants. if a.SocSpecific() || a.DeviceSpecific() || (a.ProductSpecific() && ctx.Config().EnforceProductPartitionInterface()) { a.linkToSystemLib = false } // We don't need the optimization for updatable APEXes, as it might give false signal // to the system health when the APEXes are still bundled (b/149805758) if a.Updatable() && a.properties.ApexType == imageApex { a.linkToSystemLib = false } // We also don't want the optimization for host APEXes, because it doesn't make sense. if ctx.Host() { a.linkToSystemLib = false } // prepare apex_manifest.json a.buildManifest(ctx, provideNativeLibs, requireNativeLibs) a.buildFileContexts(ctx) a.setCertificateAndPrivateKey(ctx) if a.properties.ApexType == flattenedApex { a.buildFlattenedApex(ctx) } else { a.buildUnflattenedApex(ctx) } a.compatSymlinks = makeCompatSymlinks(a.BaseModuleName(), ctx) a.buildApexDependencyInfo(ctx) a.buildLintReports(ctx) } // Enforce that Java deps of the apex are using stable SDKs to compile func (a *apexBundle) checkJavaStableSdkVersion(ctx android.ModuleContext) { // Visit direct deps only. As long as we guarantee top-level deps are using // stable SDKs, java's checkLinkType guarantees correct usage for transitive deps ctx.VisitDirectDepsBlueprint(func(module blueprint.Module) { tag := ctx.OtherModuleDependencyTag(module) switch tag { case javaLibTag, androidAppTag: if m, ok := module.(interface{ CheckStableSdkVersion() error }); ok { if err := m.CheckStableSdkVersion(); err != nil { ctx.ModuleErrorf("cannot depend on \"%v\": %v", ctx.OtherModuleName(module), err) } } } }) } func baselineApexAvailable(apex, moduleName string) bool { key := apex moduleName = normalizeModuleName(moduleName) if val, ok := apexAvailBaseline[key]; ok && android.InList(moduleName, val) { return true } key = android.AvailableToAnyApex if val, ok := apexAvailBaseline[key]; ok && android.InList(moduleName, val) { return true } return false } func normalizeModuleName(moduleName string) string { // Prebuilt modules (e.g. java_import, etc.) have "prebuilt_" prefix added by the build // system. Trim the prefix for the check since they are confusing moduleName = strings.TrimPrefix(moduleName, "prebuilt_") if strings.HasPrefix(moduleName, "libclang_rt.") { // This module has many arch variants that depend on the product being built. // We don't want to list them all moduleName = "libclang_rt" } if strings.HasPrefix(moduleName, "androidx.") { // TODO(b/156996905) Set apex_available/min_sdk_version for androidx support libraries moduleName = "androidx" } return moduleName } func newApexBundle() *apexBundle { module := &apexBundle{} module.AddProperties(&module.properties) module.AddProperties(&module.targetProperties) module.AddProperties(&module.overridableProperties) android.InitAndroidMultiTargetsArchModule(module, android.HostAndDeviceSupported, android.MultilibCommon) android.InitDefaultableModule(module) android.InitSdkAwareModule(module) android.InitOverridableModule(module, &module.overridableProperties.Overrides) return module } func ApexBundleFactory(testApex bool, artApex bool) android.Module { bundle := newApexBundle() bundle.testApex = testApex bundle.artApex = artApex return bundle } // apex_test is an APEX for testing. The difference from the ordinary apex module type is that // certain compatibility checks such as apex_available are not done for apex_test. func testApexBundleFactory() android.Module { bundle := newApexBundle() bundle.testApex = true return bundle } // apex packages other modules into an APEX file which is a packaging format for system-level // components like binaries, shared libraries, etc. func BundleFactory() android.Module { return newApexBundle() } // // Defaults // type Defaults struct { android.ModuleBase android.DefaultsModuleBase } func defaultsFactory() android.Module { return DefaultsFactory() } func DefaultsFactory(props ...interface{}) android.Module { module := &Defaults{} module.AddProperties(props...) module.AddProperties( &apexBundleProperties{}, &apexTargetBundleProperties{}, &overridableProperties{}, ) android.InitDefaultsModule(module) return module } // // OverrideApex // type OverrideApex struct { android.ModuleBase android.OverrideModuleBase } func (o *OverrideApex) GenerateAndroidBuildActions(ctx android.ModuleContext) { // All the overrides happen in the base module. } // override_apex is used to create an apex module based on another apex module // by overriding some of its properties. func overrideApexFactory() android.Module { m := &OverrideApex{} m.AddProperties(&overridableProperties{}) android.InitAndroidMultiTargetsArchModule(m, android.DeviceSupported, android.MultilibCommon) android.InitOverrideModule(m) return m }