| // Copyright 2020 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 java |
| |
| // This file contains the module implementations for runtime_resource_overlay and |
| // override_runtime_resource_overlay. |
| |
| import "android/soong/android" |
| |
| func init() { |
| RegisterRuntimeResourceOverlayBuildComponents(android.InitRegistrationContext) |
| } |
| |
| func RegisterRuntimeResourceOverlayBuildComponents(ctx android.RegistrationContext) { |
| ctx.RegisterModuleType("runtime_resource_overlay", RuntimeResourceOverlayFactory) |
| ctx.RegisterModuleType("override_runtime_resource_overlay", OverrideRuntimeResourceOverlayModuleFactory) |
| } |
| |
| type RuntimeResourceOverlay struct { |
| android.ModuleBase |
| android.DefaultableModuleBase |
| android.OverridableModuleBase |
| aapt |
| |
| properties RuntimeResourceOverlayProperties |
| overridableProperties OverridableRuntimeResourceOverlayProperties |
| |
| certificate Certificate |
| |
| outputFile android.Path |
| installDir android.InstallPath |
| } |
| |
| type RuntimeResourceOverlayProperties struct { |
| // the name of a certificate in the default certificate directory or an android_app_certificate |
| // module name in the form ":module". |
| Certificate *string |
| |
| // Name of the signing certificate lineage file. |
| Lineage *string |
| |
| // For overriding the --rotation-min-sdk-version property of apksig |
| RotationMinSdkVersion *string |
| |
| // optional theme name. If specified, the overlay package will be applied |
| // only when the ro.boot.vendor.overlay.theme system property is set to the same value. |
| Theme *string |
| |
| // If not blank, set to the version of the sdk to compile against. This |
| // can be either an API version (e.g. "29" for API level 29 AKA Android 10) |
| // or special subsets of the current platform, for example "none", "current", |
| // "core", "system", "test". See build/soong/java/sdk.go for the full and |
| // up-to-date list of possible values. |
| // Defaults to compiling against the current platform. |
| Sdk_version *string |
| |
| // if not blank, set the minimum version of the sdk that the compiled artifacts will run against. |
| // Defaults to sdk_version if not set. |
| Min_sdk_version *string |
| |
| // list of android_library modules whose resources are extracted and linked against statically |
| Static_libs []string |
| |
| // list of android_app modules whose resources are extracted and linked against |
| Resource_libs []string |
| |
| // Names of modules to be overridden. Listed modules can only be other overlays |
| // (in Make or Soong). |
| // This does not completely prevent installation of the overridden overlays, but if both |
| // overlays would be installed by default (in PRODUCT_PACKAGES) the other overlay will be removed |
| // from PRODUCT_PACKAGES. |
| Overrides []string |
| } |
| |
| // RuntimeResourceOverlayModule interface is used by the apex package to gather information from |
| // a RuntimeResourceOverlay module. |
| type RuntimeResourceOverlayModule interface { |
| android.Module |
| OutputFile() android.Path |
| Certificate() Certificate |
| Theme() string |
| } |
| |
| // RRO's partition logic is different from the partition logic of other modules defined in soong/android/paths.go |
| // The default partition for RRO is "/product" and not "/system" |
| func rroPartition(ctx android.ModuleContext) string { |
| var partition string |
| if ctx.DeviceSpecific() { |
| partition = ctx.DeviceConfig().OdmPath() |
| } else if ctx.SocSpecific() { |
| partition = ctx.DeviceConfig().VendorPath() |
| } else if ctx.SystemExtSpecific() { |
| partition = ctx.DeviceConfig().SystemExtPath() |
| } else { |
| partition = ctx.DeviceConfig().ProductPath() |
| } |
| return partition |
| } |
| |
| func (r *RuntimeResourceOverlay) DepsMutator(ctx android.BottomUpMutatorContext) { |
| sdkDep := decodeSdkDep(ctx, android.SdkContext(r)) |
| if sdkDep.hasFrameworkLibs() { |
| r.aapt.deps(ctx, sdkDep) |
| } |
| |
| cert := android.SrcIsModule(String(r.properties.Certificate)) |
| if cert != "" { |
| ctx.AddDependency(ctx.Module(), certificateTag, cert) |
| } |
| |
| ctx.AddVariationDependencies(nil, staticLibTag, r.properties.Static_libs...) |
| ctx.AddVariationDependencies(nil, libTag, r.properties.Resource_libs...) |
| } |
| |
| func (r *RuntimeResourceOverlay) GenerateAndroidBuildActions(ctx android.ModuleContext) { |
| // Compile and link resources |
| r.aapt.hasNoCode = true |
| // Do not remove resources without default values nor dedupe resource configurations with the same value |
| aaptLinkFlags := []string{"--no-resource-deduping", "--no-resource-removal"} |
| // Allow the override of "package name" and "overlay target package name" |
| manifestPackageName, overridden := ctx.DeviceConfig().OverrideManifestPackageNameFor(ctx.ModuleName()) |
| if overridden || r.overridableProperties.Package_name != nil { |
| // The product override variable has a priority over the package_name property. |
| if !overridden { |
| manifestPackageName = *r.overridableProperties.Package_name |
| } |
| aaptLinkFlags = append(aaptLinkFlags, generateAaptRenamePackageFlags(manifestPackageName, false)...) |
| } |
| if r.overridableProperties.Target_package_name != nil { |
| aaptLinkFlags = append(aaptLinkFlags, |
| "--rename-overlay-target-package "+*r.overridableProperties.Target_package_name) |
| } |
| if r.overridableProperties.Category != nil { |
| aaptLinkFlags = append(aaptLinkFlags, |
| "--rename-overlay-category "+*r.overridableProperties.Category) |
| } |
| r.aapt.buildActions(ctx, r, nil, nil, false, aaptLinkFlags...) |
| |
| // Sign the built package |
| _, _, certificates := collectAppDeps(ctx, r, false, false) |
| r.certificate, certificates = processMainCert(r.ModuleBase, String(r.properties.Certificate), certificates, ctx) |
| signed := android.PathForModuleOut(ctx, "signed", r.Name()+".apk") |
| var lineageFile android.Path |
| if lineage := String(r.properties.Lineage); lineage != "" { |
| lineageFile = android.PathForModuleSrc(ctx, lineage) |
| } |
| |
| rotationMinSdkVersion := String(r.properties.RotationMinSdkVersion) |
| |
| SignAppPackage(ctx, signed, r.aapt.exportPackage, certificates, nil, lineageFile, rotationMinSdkVersion) |
| |
| r.outputFile = signed |
| partition := rroPartition(ctx) |
| r.installDir = android.PathForModuleInPartitionInstall(ctx, partition, "overlay", String(r.properties.Theme)) |
| ctx.InstallFile(r.installDir, r.outputFile.Base(), r.outputFile) |
| } |
| |
| func (r *RuntimeResourceOverlay) SdkVersion(ctx android.EarlyModuleContext) android.SdkSpec { |
| return android.SdkSpecFrom(ctx, String(r.properties.Sdk_version)) |
| } |
| |
| func (r *RuntimeResourceOverlay) SystemModules() string { |
| return "" |
| } |
| |
| func (r *RuntimeResourceOverlay) MinSdkVersion(ctx android.EarlyModuleContext) android.ApiLevel { |
| if r.properties.Min_sdk_version != nil { |
| return android.ApiLevelFrom(ctx, *r.properties.Min_sdk_version) |
| } |
| return r.SdkVersion(ctx).ApiLevel |
| } |
| |
| func (r *RuntimeResourceOverlay) ReplaceMaxSdkVersionPlaceholder(ctx android.EarlyModuleContext) android.ApiLevel { |
| return android.SdkSpecPrivate.ApiLevel |
| } |
| |
| func (r *RuntimeResourceOverlay) TargetSdkVersion(ctx android.EarlyModuleContext) android.ApiLevel { |
| return r.SdkVersion(ctx).ApiLevel |
| } |
| |
| func (r *RuntimeResourceOverlay) Certificate() Certificate { |
| return r.certificate |
| } |
| |
| func (r *RuntimeResourceOverlay) OutputFile() android.Path { |
| return r.outputFile |
| } |
| |
| func (r *RuntimeResourceOverlay) Theme() string { |
| return String(r.properties.Theme) |
| } |
| |
| // runtime_resource_overlay generates a resource-only apk file that can overlay application and |
| // system resources at run time. |
| func RuntimeResourceOverlayFactory() android.Module { |
| module := &RuntimeResourceOverlay{} |
| module.AddProperties( |
| &module.properties, |
| &module.aaptProperties, |
| &module.overridableProperties) |
| |
| android.InitAndroidMultiTargetsArchModule(module, android.DeviceSupported, android.MultilibCommon) |
| android.InitDefaultableModule(module) |
| android.InitOverridableModule(module, &module.properties.Overrides) |
| return module |
| } |
| |
| // runtime_resource_overlay properties that can be overridden by override_runtime_resource_overlay |
| type OverridableRuntimeResourceOverlayProperties struct { |
| // the package name of this app. The package name in the manifest file is used if one was not given. |
| Package_name *string |
| |
| // the target package name of this overlay app. The target package name in the manifest file is used if one was not given. |
| Target_package_name *string |
| |
| // the rro category of this overlay. The category in the manifest file is used if one was not given. |
| Category *string |
| } |
| |
| type OverrideRuntimeResourceOverlay struct { |
| android.ModuleBase |
| android.OverrideModuleBase |
| } |
| |
| func (i *OverrideRuntimeResourceOverlay) GenerateAndroidBuildActions(_ android.ModuleContext) { |
| // All the overrides happen in the base module. |
| // TODO(jungjw): Check the base module type. |
| } |
| |
| // override_runtime_resource_overlay is used to create a module based on another |
| // runtime_resource_overlay module by overriding some of its properties. |
| func OverrideRuntimeResourceOverlayModuleFactory() android.Module { |
| m := &OverrideRuntimeResourceOverlay{} |
| m.AddProperties(&OverridableRuntimeResourceOverlayProperties{}) |
| |
| android.InitAndroidMultiTargetsArchModule(m, android.DeviceSupported, android.MultilibCommon) |
| android.InitOverrideModule(m) |
| return m |
| } |