| // Copyright 2018 Google Inc. All rights reserved. |
| // |
| // 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 android |
| |
| import ( |
| "fmt" |
| "sort" |
| "strconv" |
| "strings" |
| "sync" |
| |
| "github.com/google/blueprint" |
| ) |
| |
| const ( |
| SdkVersion_Android10 = 29 |
| ) |
| |
| type ApexInfo struct { |
| // Name of the apex variant that this module is mutated into |
| ApexName string |
| |
| MinSdkVersion int |
| Updatable bool |
| } |
| |
| // Extracted from ApexModule to make it easier to define custom subsets of the |
| // ApexModule interface and improve code navigation within the IDE. |
| type DepIsInSameApex interface { |
| // DepIsInSameApex tests if the other module 'dep' is installed to the same |
| // APEX as this module |
| DepIsInSameApex(ctx BaseModuleContext, dep Module) bool |
| } |
| |
| // ApexModule is the interface that a module type is expected to implement if |
| // the module has to be built differently depending on whether the module |
| // is destined for an apex or not (installed to one of the regular partitions). |
| // |
| // Native shared libraries are one such module type; when it is built for an |
| // APEX, it should depend only on stable interfaces such as NDK, stable AIDL, |
| // or C APIs from other APEXs. |
| // |
| // A module implementing this interface will be mutated into multiple |
| // variations by apex.apexMutator if it is directly or indirectly included |
| // in one or more APEXs. Specifically, if a module is included in apex.foo and |
| // apex.bar then three apex variants are created: platform, apex.foo and |
| // apex.bar. The platform variant is for the regular partitions |
| // (e.g., /system or /vendor, etc.) while the other two are for the APEXs, |
| // respectively. |
| type ApexModule interface { |
| Module |
| DepIsInSameApex |
| |
| apexModuleBase() *ApexModuleBase |
| |
| // Marks that this module should be built for the specified APEX. |
| // Call this before apex.apexMutator is run. |
| BuildForApex(apex ApexInfo) |
| |
| // Returns the APEXes that this module will be built for |
| ApexVariations() []ApexInfo |
| |
| // Returns the name of APEX that this module will be built for. Empty string |
| // is returned when 'IsForPlatform() == true'. Note that a module can be |
| // included in multiple APEXes, in which case, the module is mutated into |
| // multiple modules each of which for an APEX. This method returns the |
| // name of the APEX that a variant module is for. |
| // Call this after apex.apexMutator is run. |
| ApexName() string |
| |
| // Tests whether this module will be built for the platform or not. |
| // This is a shortcut for ApexName() == "" |
| IsForPlatform() bool |
| |
| // Tests if this module could have APEX variants. APEX variants are |
| // created only for the modules that returns true here. This is useful |
| // for not creating APEX variants for certain types of shared libraries |
| // such as NDK stubs. |
| CanHaveApexVariants() bool |
| |
| // Tests if this module can be installed to APEX as a file. For example, |
| // this would return true for shared libs while return false for static |
| // libs. |
| IsInstallableToApex() bool |
| |
| // Mutate this module into one or more variants each of which is built |
| // for an APEX marked via BuildForApex(). |
| CreateApexVariations(mctx BottomUpMutatorContext) []Module |
| |
| // Tests if this module is available for the specified APEX or ":platform" |
| AvailableFor(what string) bool |
| |
| // Return true if this module is not available to platform (i.e. apex_available |
| // property doesn't have "//apex_available:platform"), or shouldn't be available |
| // to platform, which is the case when this module depends on other module that |
| // isn't available to platform. |
| NotAvailableForPlatform() bool |
| |
| // Mark that this module is not available to platform. Set by the |
| // check-platform-availability mutator in the apex package. |
| SetNotAvailableForPlatform() |
| |
| // Returns the highest version which is <= maxSdkVersion. |
| // For example, with maxSdkVersion is 10 and versionList is [9,11] |
| // it returns 9 as string |
| ChooseSdkVersion(versionList []string, maxSdkVersion int) (string, error) |
| |
| // Tests if the module comes from an updatable APEX. |
| Updatable() bool |
| |
| // List of APEXes that this module tests. The module has access to |
| // the private part of the listed APEXes even when it is not included in the |
| // APEXes. |
| TestFor() []string |
| |
| // Returns nil if this module supports sdkVersion |
| // Otherwise, returns error with reason |
| ShouldSupportSdkVersion(ctx BaseModuleContext, sdkVersion int) error |
| } |
| |
| type ApexProperties struct { |
| // Availability of this module in APEXes. Only the listed APEXes can contain |
| // this module. If the module has stubs then other APEXes and the platform may |
| // access it through them (subject to visibility). |
| // |
| // "//apex_available:anyapex" is a pseudo APEX name that matches to any APEX. |
| // "//apex_available:platform" refers to non-APEX partitions like "system.img". |
| // "com.android.gki.*" matches any APEX module name with the prefix "com.android.gki.". |
| // Default is ["//apex_available:platform"]. |
| Apex_available []string |
| |
| Info ApexInfo `blueprint:"mutated"` |
| |
| NotAvailableForPlatform bool `blueprint:"mutated"` |
| } |
| |
| // Marker interface that identifies dependencies that are excluded from APEX |
| // contents. |
| type ExcludeFromApexContentsTag interface { |
| blueprint.DependencyTag |
| |
| // Method that differentiates this interface from others. |
| ExcludeFromApexContents() |
| } |
| |
| // Provides default implementation for the ApexModule interface. APEX-aware |
| // modules are expected to include this struct and call InitApexModule(). |
| type ApexModuleBase struct { |
| ApexProperties ApexProperties |
| |
| canHaveApexVariants bool |
| |
| apexVariationsLock sync.Mutex // protects apexVariations during parallel apexDepsMutator |
| apexVariations []ApexInfo |
| } |
| |
| func (m *ApexModuleBase) apexModuleBase() *ApexModuleBase { |
| return m |
| } |
| |
| func (m *ApexModuleBase) ApexAvailable() []string { |
| return m.ApexProperties.Apex_available |
| } |
| |
| func (m *ApexModuleBase) TestFor() []string { |
| // To be implemented by concrete types inheriting ApexModuleBase |
| return nil |
| } |
| |
| func (m *ApexModuleBase) BuildForApex(apex ApexInfo) { |
| m.apexVariationsLock.Lock() |
| defer m.apexVariationsLock.Unlock() |
| for _, v := range m.apexVariations { |
| if v.ApexName == apex.ApexName { |
| return |
| } |
| } |
| m.apexVariations = append(m.apexVariations, apex) |
| } |
| |
| func (m *ApexModuleBase) ApexVariations() []ApexInfo { |
| return m.apexVariations |
| } |
| |
| func (m *ApexModuleBase) ApexName() string { |
| return m.ApexProperties.Info.ApexName |
| } |
| |
| func (m *ApexModuleBase) IsForPlatform() bool { |
| return m.ApexProperties.Info.ApexName == "" |
| } |
| |
| func (m *ApexModuleBase) CanHaveApexVariants() bool { |
| return m.canHaveApexVariants |
| } |
| |
| func (m *ApexModuleBase) IsInstallableToApex() bool { |
| // should be overriden if needed |
| return false |
| } |
| |
| const ( |
| AvailableToPlatform = "//apex_available:platform" |
| AvailableToAnyApex = "//apex_available:anyapex" |
| AvailableToGkiApex = "com.android.gki.*" |
| ) |
| |
| func CheckAvailableForApex(what string, apex_available []string) bool { |
| if len(apex_available) == 0 { |
| // apex_available defaults to ["//apex_available:platform"], |
| // which means 'available to the platform but no apexes'. |
| return what == AvailableToPlatform |
| } |
| return InList(what, apex_available) || |
| (what != AvailableToPlatform && InList(AvailableToAnyApex, apex_available)) || |
| (strings.HasPrefix(what, "com.android.gki.") && InList(AvailableToGkiApex, apex_available)) |
| } |
| |
| func (m *ApexModuleBase) AvailableFor(what string) bool { |
| return CheckAvailableForApex(what, m.ApexProperties.Apex_available) |
| } |
| |
| func (m *ApexModuleBase) NotAvailableForPlatform() bool { |
| return m.ApexProperties.NotAvailableForPlatform |
| } |
| |
| func (m *ApexModuleBase) SetNotAvailableForPlatform() { |
| m.ApexProperties.NotAvailableForPlatform = true |
| } |
| |
| func (m *ApexModuleBase) DepIsInSameApex(ctx BaseModuleContext, dep Module) bool { |
| // By default, if there is a dependency from A to B, we try to include both in the same APEX, |
| // unless B is explicitly from outside of the APEX (i.e. a stubs lib). Thus, returning true. |
| // This is overridden by some module types like apex.ApexBundle, cc.Module, java.Module, etc. |
| return true |
| } |
| |
| func (m *ApexModuleBase) ChooseSdkVersion(versionList []string, maxSdkVersion int) (string, error) { |
| for i := range versionList { |
| ver, _ := strconv.Atoi(versionList[len(versionList)-i-1]) |
| if ver <= maxSdkVersion { |
| return versionList[len(versionList)-i-1], nil |
| } |
| } |
| return "", fmt.Errorf("not found a version(<=%d) in versionList: %v", maxSdkVersion, versionList) |
| } |
| |
| func (m *ApexModuleBase) checkApexAvailableProperty(mctx BaseModuleContext) { |
| for _, n := range m.ApexProperties.Apex_available { |
| if n == AvailableToPlatform || n == AvailableToAnyApex || n == AvailableToGkiApex { |
| continue |
| } |
| if !mctx.OtherModuleExists(n) && !mctx.Config().AllowMissingDependencies() { |
| mctx.PropertyErrorf("apex_available", "%q is not a valid module name", n) |
| } |
| } |
| } |
| |
| func (m *ApexModuleBase) Updatable() bool { |
| return m.ApexProperties.Info.Updatable |
| } |
| |
| type byApexName []ApexInfo |
| |
| func (a byApexName) Len() int { return len(a) } |
| func (a byApexName) Swap(i, j int) { a[i], a[j] = a[j], a[i] } |
| func (a byApexName) Less(i, j int) bool { return a[i].ApexName < a[j].ApexName } |
| |
| func (m *ApexModuleBase) CreateApexVariations(mctx BottomUpMutatorContext) []Module { |
| if len(m.apexVariations) > 0 { |
| m.checkApexAvailableProperty(mctx) |
| |
| sort.Sort(byApexName(m.apexVariations)) |
| variations := []string{} |
| variations = append(variations, "") // Original variation for platform |
| for _, apex := range m.apexVariations { |
| variations = append(variations, apex.ApexName) |
| } |
| |
| defaultVariation := "" |
| mctx.SetDefaultDependencyVariation(&defaultVariation) |
| |
| modules := mctx.CreateVariations(variations...) |
| for i, mod := range modules { |
| platformVariation := i == 0 |
| if platformVariation && !mctx.Host() && !mod.(ApexModule).AvailableFor(AvailableToPlatform) { |
| mod.SkipInstall() |
| } |
| if !platformVariation { |
| mod.(ApexModule).apexModuleBase().ApexProperties.Info = m.apexVariations[i-1] |
| } |
| } |
| return modules |
| } |
| return nil |
| } |
| |
| var apexData OncePer |
| var apexNamesMapMutex sync.Mutex |
| var apexNamesKey = NewOnceKey("apexNames") |
| |
| // This structure maintains the global mapping in between modules and APEXes. |
| // Examples: |
| // |
| // apexNamesMap()["foo"]["bar"] == true: module foo is directly depended on by APEX bar |
| // apexNamesMap()["foo"]["bar"] == false: module foo is indirectly depended on by APEX bar |
| // apexNamesMap()["foo"]["bar"] doesn't exist: foo is not built for APEX bar |
| func apexNamesMap() map[string]map[string]bool { |
| return apexData.Once(apexNamesKey, func() interface{} { |
| return make(map[string]map[string]bool) |
| }).(map[string]map[string]bool) |
| } |
| |
| // Update the map to mark that a module named moduleName is directly or indirectly |
| // depended on by the specified APEXes. Directly depending means that a module |
| // is explicitly listed in the build definition of the APEX via properties like |
| // native_shared_libs, java_libs, etc. |
| func UpdateApexDependency(apex ApexInfo, moduleName string, directDep bool) { |
| apexNamesMapMutex.Lock() |
| defer apexNamesMapMutex.Unlock() |
| apexesForModule, ok := apexNamesMap()[moduleName] |
| if !ok { |
| apexesForModule = make(map[string]bool) |
| apexNamesMap()[moduleName] = apexesForModule |
| } |
| apexesForModule[apex.ApexName] = apexesForModule[apex.ApexName] || directDep |
| } |
| |
| // TODO(b/146393795): remove this when b/146393795 is fixed |
| func ClearApexDependency() { |
| m := apexNamesMap() |
| for k := range m { |
| delete(m, k) |
| } |
| } |
| |
| // Tests whether a module named moduleName is directly depended on by an APEX |
| // named apexName. |
| func DirectlyInApex(apexName string, moduleName string) bool { |
| apexNamesMapMutex.Lock() |
| defer apexNamesMapMutex.Unlock() |
| if apexNames, ok := apexNamesMap()[moduleName]; ok { |
| return apexNames[apexName] |
| } |
| return false |
| } |
| |
| type hostContext interface { |
| Host() bool |
| } |
| |
| // Tests whether a module named moduleName is directly depended on by any APEX. |
| func DirectlyInAnyApex(ctx hostContext, moduleName string) bool { |
| if ctx.Host() { |
| // Host has no APEX. |
| return false |
| } |
| apexNamesMapMutex.Lock() |
| defer apexNamesMapMutex.Unlock() |
| if apexNames, ok := apexNamesMap()[moduleName]; ok { |
| for an := range apexNames { |
| if apexNames[an] { |
| return true |
| } |
| } |
| } |
| return false |
| } |
| |
| // Tests whether a module named module is depended on (including both |
| // direct and indirect dependencies) by any APEX. |
| func InAnyApex(moduleName string) bool { |
| apexNamesMapMutex.Lock() |
| defer apexNamesMapMutex.Unlock() |
| apexNames, ok := apexNamesMap()[moduleName] |
| return ok && len(apexNames) > 0 |
| } |
| |
| func GetApexesForModule(moduleName string) []string { |
| ret := []string{} |
| apexNamesMapMutex.Lock() |
| defer apexNamesMapMutex.Unlock() |
| if apexNames, ok := apexNamesMap()[moduleName]; ok { |
| for an := range apexNames { |
| ret = append(ret, an) |
| } |
| } |
| return ret |
| } |
| |
| func InitApexModule(m ApexModule) { |
| base := m.apexModuleBase() |
| base.canHaveApexVariants = true |
| |
| m.AddProperties(&base.ApexProperties) |
| } |
| |
| // A dependency info for a single ApexModule, either direct or transitive. |
| type ApexModuleDepInfo struct { |
| // Name of the dependency |
| To string |
| // List of dependencies To belongs to. Includes APEX itself, if a direct dependency. |
| From []string |
| // Whether the dependency belongs to the final compiled APEX. |
| IsExternal bool |
| // min_sdk_version of the ApexModule |
| MinSdkVersion string |
| } |
| |
| // A map of a dependency name to its ApexModuleDepInfo |
| type DepNameToDepInfoMap map[string]ApexModuleDepInfo |
| |
| type ApexBundleDepsInfo struct { |
| flatListPath OutputPath |
| fullListPath OutputPath |
| } |
| |
| type ApexBundleDepsInfoIntf interface { |
| Updatable() bool |
| FlatListPath() Path |
| FullListPath() Path |
| } |
| |
| func (d *ApexBundleDepsInfo) FlatListPath() Path { |
| return d.flatListPath |
| } |
| |
| func (d *ApexBundleDepsInfo) FullListPath() Path { |
| return d.fullListPath |
| } |
| |
| // Generate two module out files: |
| // 1. FullList with transitive deps and their parents in the dep graph |
| // 2. FlatList with a flat list of transitive deps |
| func (d *ApexBundleDepsInfo) BuildDepsInfoLists(ctx ModuleContext, minSdkVersion string, depInfos DepNameToDepInfoMap) { |
| var fullContent strings.Builder |
| var flatContent strings.Builder |
| |
| fmt.Fprintf(&flatContent, "%s(minSdkVersion:%s):\\n", ctx.ModuleName(), minSdkVersion) |
| for _, key := range FirstUniqueStrings(SortedStringKeys(depInfos)) { |
| info := depInfos[key] |
| toName := fmt.Sprintf("%s(minSdkVersion:%s)", info.To, info.MinSdkVersion) |
| if info.IsExternal { |
| toName = toName + " (external)" |
| } |
| fmt.Fprintf(&fullContent, "%s <- %s\\n", toName, strings.Join(SortedUniqueStrings(info.From), ", ")) |
| fmt.Fprintf(&flatContent, " %s\\n", toName) |
| } |
| |
| d.fullListPath = PathForModuleOut(ctx, "depsinfo", "fulllist.txt").OutputPath |
| ctx.Build(pctx, BuildParams{ |
| Rule: WriteFile, |
| Description: "Full Dependency Info", |
| Output: d.fullListPath, |
| Args: map[string]string{ |
| "content": fullContent.String(), |
| }, |
| }) |
| |
| d.flatListPath = PathForModuleOut(ctx, "depsinfo", "flatlist.txt").OutputPath |
| ctx.Build(pctx, BuildParams{ |
| Rule: WriteFile, |
| Description: "Flat Dependency Info", |
| Output: d.flatListPath, |
| Args: map[string]string{ |
| "content": flatContent.String(), |
| }, |
| }) |
| } |
| |
| // TODO(b/158059172): remove minSdkVersion allowlist |
| var minSdkVersionAllowlist = map[string]int{ |
| "adbd": 30, |
| "android.net.ipsec.ike": 30, |
| "androidx-constraintlayout_constraintlayout-solver": 30, |
| "androidx.annotation_annotation": 28, |
| "androidx.arch.core_core-common": 28, |
| "androidx.collection_collection": 28, |
| "androidx.lifecycle_lifecycle-common": 28, |
| "apache-commons-compress": 29, |
| "bouncycastle_ike_digests": 30, |
| "brotli-java": 29, |
| "captiveportal-lib": 28, |
| "flatbuffer_headers": 30, |
| "framework-permission": 30, |
| "framework-statsd": 30, |
| "gemmlowp_headers": 30, |
| "ike-internals": 30, |
| "kotlinx-coroutines-android": 28, |
| "kotlinx-coroutines-core": 28, |
| "libadb_crypto": 30, |
| "libadb_pairing_auth": 30, |
| "libadb_pairing_connection": 30, |
| "libadb_pairing_server": 30, |
| "libadb_protos": 30, |
| "libadb_tls_connection": 30, |
| "libadbconnection_client": 30, |
| "libadbconnection_server": 30, |
| "libadbd_core": 30, |
| "libadbd_services": 30, |
| "libadbd": 30, |
| "libapp_processes_protos_lite": 30, |
| "libasyncio": 30, |
| "libbrotli": 30, |
| "libbuildversion": 30, |
| "libcrypto_static": 30, |
| "libcrypto_utils": 30, |
| "libdiagnose_usb": 30, |
| "libeigen": 30, |
| "liblz4": 30, |
| "libmdnssd": 30, |
| "libneuralnetworks_common": 30, |
| "libneuralnetworks_headers": 30, |
| "libneuralnetworks": 30, |
| "libprocpartition": 30, |
| "libprotobuf-java-lite": 30, |
| "libprotoutil": 30, |
| "libqemu_pipe": 30, |
| "libstats_jni": 30, |
| "libstatslog_statsd": 30, |
| "libstatsmetadata": 30, |
| "libstatspull": 30, |
| "libstatssocket": 30, |
| "libsync": 30, |
| "libtextclassifier_hash_headers": 30, |
| "libtextclassifier_hash_static": 30, |
| "libtflite_kernel_utils": 30, |
| "libwatchdog": 29, |
| "libzstd": 30, |
| "metrics-constants-protos": 28, |
| "net-utils-framework-common": 29, |
| "permissioncontroller-statsd": 28, |
| "philox_random_headers": 30, |
| "philox_random": 30, |
| "service-permission": 30, |
| "service-statsd": 30, |
| "statsd-aidl-ndk_platform": 30, |
| "statsd": 30, |
| "tensorflow_headers": 30, |
| "xz-java": 29, |
| } |
| |
| // Function called while walking an APEX's payload dependencies. |
| // |
| // Return true if the `to` module should be visited, false otherwise. |
| type PayloadDepsCallback func(ctx ModuleContext, from blueprint.Module, to ApexModule, externalDep bool) bool |
| |
| // UpdatableModule represents updatable APEX/APK |
| type UpdatableModule interface { |
| Module |
| WalkPayloadDeps(ctx ModuleContext, do PayloadDepsCallback) |
| } |
| |
| // CheckMinSdkVersion checks if every dependency of an updatable module sets min_sdk_version accordingly |
| func CheckMinSdkVersion(m UpdatableModule, ctx ModuleContext, minSdkVersion int) { |
| // do not enforce min_sdk_version for host |
| if ctx.Host() { |
| return |
| } |
| |
| // do not enforce for coverage build |
| if ctx.Config().IsEnvTrue("EMMA_INSTRUMENT") || ctx.DeviceConfig().NativeCoverageEnabled() || ctx.DeviceConfig().ClangCoverageEnabled() { |
| return |
| } |
| |
| // do not enforce deps.min_sdk_version if APEX/APK doesn't set min_sdk_version or |
| // min_sdk_version is not finalized (e.g. current or codenames) |
| if minSdkVersion == FutureApiLevel { |
| return |
| } |
| |
| m.WalkPayloadDeps(ctx, func(ctx ModuleContext, from blueprint.Module, to ApexModule, externalDep bool) bool { |
| if externalDep { |
| // external deps are outside the payload boundary, which is "stable" interface. |
| // We don't have to check min_sdk_version for external dependencies. |
| return false |
| } |
| if am, ok := from.(DepIsInSameApex); ok && !am.DepIsInSameApex(ctx, to) { |
| return false |
| } |
| if err := to.ShouldSupportSdkVersion(ctx, minSdkVersion); err != nil { |
| toName := ctx.OtherModuleName(to) |
| if ver, ok := minSdkVersionAllowlist[toName]; !ok || ver > minSdkVersion { |
| ctx.OtherModuleErrorf(to, "should support min_sdk_version(%v) for %q: %v. Dependency path: %s", |
| minSdkVersion, ctx.ModuleName(), err.Error(), ctx.GetPathString(false)) |
| return false |
| } |
| } |
| return true |
| }) |
| } |
