1// Copyright 2020 Google Inc. All rights reserved. 2// 3// Licensed under the Apache License, Version 2.0 (the "License"); 4// you may not use this file except in compliance with the License. 5// You may obtain a copy of the License at 6// 7// http://www.apache.org/licenses/LICENSE-2.0 8// 9// Unless required by applicable law or agreed to in writing, software 10// distributed under the License is distributed on an "AS IS" BASIS, 11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12// See the License for the specific language governing permissions and 13// limitations under the License. 14 15package java 16 17// This file contains the module implementations for runtime_resource_overlay and 18// override_runtime_resource_overlay. 19 20import "android/soong/android" 21 22func init() { 23 RegisterRuntimeResourceOverlayBuildComponents(android.InitRegistrationContext) 24} 25 26func RegisterRuntimeResourceOverlayBuildComponents(ctx android.RegistrationContext) { 27 ctx.RegisterModuleType("runtime_resource_overlay", RuntimeResourceOverlayFactory) 28 ctx.RegisterModuleType("override_runtime_resource_overlay", OverrideRuntimeResourceOverlayModuleFactory) 29} 30 31type RuntimeResourceOverlay struct { 32 android.ModuleBase 33 android.DefaultableModuleBase 34 android.OverridableModuleBase 35 aapt 36 37 properties RuntimeResourceOverlayProperties 38 overridableProperties OverridableRuntimeResourceOverlayProperties 39 40 certificate Certificate 41 42 outputFile android.Path 43 installDir android.InstallPath 44} 45 46type RuntimeResourceOverlayProperties struct { 47 // the name of a certificate in the default certificate directory or an android_app_certificate 48 // module name in the form ":module". 49 Certificate *string 50 51 // Name of the signing certificate lineage file. 52 Lineage *string 53 54 // For overriding the --rotation-min-sdk-version property of apksig 55 RotationMinSdkVersion *string 56 57 // optional theme name. If specified, the overlay package will be applied 58 // only when the ro.boot.vendor.overlay.theme system property is set to the same value. 59 Theme *string 60 61 // If not blank, set to the version of the sdk to compile against. This 62 // can be either an API version (e.g. "29" for API level 29 AKA Android 10) 63 // or special subsets of the current platform, for example "none", "current", 64 // "core", "system", "test". See build/soong/java/sdk.go for the full and 65 // up-to-date list of possible values. 66 // Defaults to compiling against the current platform. 67 Sdk_version *string 68 69 // if not blank, set the minimum version of the sdk that the compiled artifacts will run against. 70 // Defaults to sdk_version if not set. 71 Min_sdk_version *string 72 73 // list of android_library modules whose resources are extracted and linked against statically 74 Static_libs []string 75 76 // list of android_app modules whose resources are extracted and linked against 77 Resource_libs []string 78 79 // Names of modules to be overridden. Listed modules can only be other overlays 80 // (in Make or Soong). 81 // This does not completely prevent installation of the overridden overlays, but if both 82 // overlays would be installed by default (in PRODUCT_PACKAGES) the other overlay will be removed 83 // from PRODUCT_PACKAGES. 84 Overrides []string 85} 86 87// RuntimeResourceOverlayModule interface is used by the apex package to gather information from 88// a RuntimeResourceOverlay module. 89type RuntimeResourceOverlayModule interface { 90 android.Module 91 OutputFile() android.Path 92 Certificate() Certificate 93 Theme() string 94} 95 96// RRO's partition logic is different from the partition logic of other modules defined in soong/android/paths.go 97// The default partition for RRO is "/product" and not "/system" 98func rroPartition(ctx android.ModuleContext) string { 99 var partition string 100 if ctx.DeviceSpecific() { 101 partition = ctx.DeviceConfig().OdmPath() 102 } else if ctx.SocSpecific() { 103 partition = ctx.DeviceConfig().VendorPath() 104 } else if ctx.SystemExtSpecific() { 105 partition = ctx.DeviceConfig().SystemExtPath() 106 } else { 107 partition = ctx.DeviceConfig().ProductPath() 108 } 109 return partition 110} 111 112func (r *RuntimeResourceOverlay) DepsMutator(ctx android.BottomUpMutatorContext) { 113 sdkDep := decodeSdkDep(ctx, android.SdkContext(r)) 114 if sdkDep.hasFrameworkLibs() { 115 r.aapt.deps(ctx, sdkDep) 116 } 117 118 cert := android.SrcIsModule(String(r.properties.Certificate)) 119 if cert != "" { 120 ctx.AddDependency(ctx.Module(), certificateTag, cert) 121 } 122 123 ctx.AddVariationDependencies(nil, staticLibTag, r.properties.Static_libs...) 124 ctx.AddVariationDependencies(nil, libTag, r.properties.Resource_libs...) 125} 126 127func (r *RuntimeResourceOverlay) GenerateAndroidBuildActions(ctx android.ModuleContext) { 128 // Compile and link resources 129 r.aapt.hasNoCode = true 130 // Do not remove resources without default values nor dedupe resource configurations with the same value 131 aaptLinkFlags := []string{"--no-resource-deduping", "--no-resource-removal"} 132 // Allow the override of "package name" and "overlay target package name" 133 manifestPackageName, overridden := ctx.DeviceConfig().OverrideManifestPackageNameFor(ctx.ModuleName()) 134 if overridden || r.overridableProperties.Package_name != nil { 135 // The product override variable has a priority over the package_name property. 136 if !overridden { 137 manifestPackageName = *r.overridableProperties.Package_name 138 } 139 aaptLinkFlags = append(aaptLinkFlags, generateAaptRenamePackageFlags(manifestPackageName, false)...) 140 } 141 if r.overridableProperties.Target_package_name != nil { 142 aaptLinkFlags = append(aaptLinkFlags, 143 "--rename-overlay-target-package "+*r.overridableProperties.Target_package_name) 144 } 145 if r.overridableProperties.Category != nil { 146 aaptLinkFlags = append(aaptLinkFlags, 147 "--rename-overlay-category "+*r.overridableProperties.Category) 148 } 149 r.aapt.buildActions(ctx, r, nil, nil, false, aaptLinkFlags...) 150 151 // Sign the built package 152 _, _, certificates := collectAppDeps(ctx, r, false, false) 153 r.certificate, certificates = processMainCert(r.ModuleBase, String(r.properties.Certificate), certificates, ctx) 154 signed := android.PathForModuleOut(ctx, "signed", r.Name()+".apk") 155 var lineageFile android.Path 156 if lineage := String(r.properties.Lineage); lineage != "" { 157 lineageFile = android.PathForModuleSrc(ctx, lineage) 158 } 159 160 rotationMinSdkVersion := String(r.properties.RotationMinSdkVersion) 161 162 SignAppPackage(ctx, signed, r.aapt.exportPackage, certificates, nil, lineageFile, rotationMinSdkVersion) 163 164 r.outputFile = signed 165 partition := rroPartition(ctx) 166 r.installDir = android.PathForModuleInPartitionInstall(ctx, partition, "overlay", String(r.properties.Theme)) 167 ctx.InstallFile(r.installDir, r.outputFile.Base(), r.outputFile) 168} 169 170func (r *RuntimeResourceOverlay) SdkVersion(ctx android.EarlyModuleContext) android.SdkSpec { 171 return android.SdkSpecFrom(ctx, String(r.properties.Sdk_version)) 172} 173 174func (r *RuntimeResourceOverlay) SystemModules() string { 175 return "" 176} 177 178func (r *RuntimeResourceOverlay) MinSdkVersion(ctx android.EarlyModuleContext) android.ApiLevel { 179 if r.properties.Min_sdk_version != nil { 180 return android.ApiLevelFrom(ctx, *r.properties.Min_sdk_version) 181 } 182 return r.SdkVersion(ctx).ApiLevel 183} 184 185func (r *RuntimeResourceOverlay) ReplaceMaxSdkVersionPlaceholder(ctx android.EarlyModuleContext) android.ApiLevel { 186 return android.SdkSpecPrivate.ApiLevel 187} 188 189func (r *RuntimeResourceOverlay) TargetSdkVersion(ctx android.EarlyModuleContext) android.ApiLevel { 190 return r.SdkVersion(ctx).ApiLevel 191} 192 193func (r *RuntimeResourceOverlay) Certificate() Certificate { 194 return r.certificate 195} 196 197func (r *RuntimeResourceOverlay) OutputFile() android.Path { 198 return r.outputFile 199} 200 201func (r *RuntimeResourceOverlay) Theme() string { 202 return String(r.properties.Theme) 203} 204 205// runtime_resource_overlay generates a resource-only apk file that can overlay application and 206// system resources at run time. 207func RuntimeResourceOverlayFactory() android.Module { 208 module := &RuntimeResourceOverlay{} 209 module.AddProperties( 210 &module.properties, 211 &module.aaptProperties, 212 &module.overridableProperties) 213 214 android.InitAndroidMultiTargetsArchModule(module, android.DeviceSupported, android.MultilibCommon) 215 android.InitDefaultableModule(module) 216 android.InitOverridableModule(module, &module.properties.Overrides) 217 return module 218} 219 220// runtime_resource_overlay properties that can be overridden by override_runtime_resource_overlay 221type OverridableRuntimeResourceOverlayProperties struct { 222 // the package name of this app. The package name in the manifest file is used if one was not given. 223 Package_name *string 224 225 // the target package name of this overlay app. The target package name in the manifest file is used if one was not given. 226 Target_package_name *string 227 228 // the rro category of this overlay. The category in the manifest file is used if one was not given. 229 Category *string 230} 231 232type OverrideRuntimeResourceOverlay struct { 233 android.ModuleBase 234 android.OverrideModuleBase 235} 236 237func (i *OverrideRuntimeResourceOverlay) GenerateAndroidBuildActions(_ android.ModuleContext) { 238 // All the overrides happen in the base module. 239 // TODO(jungjw): Check the base module type. 240} 241 242// override_runtime_resource_overlay is used to create a module based on another 243// runtime_resource_overlay module by overriding some of its properties. 244func OverrideRuntimeResourceOverlayModuleFactory() android.Module { 245 m := &OverrideRuntimeResourceOverlay{} 246 m.AddProperties(&OverridableRuntimeResourceOverlayProperties{}) 247 248 android.InitAndroidMultiTargetsArchModule(m, android.DeviceSupported, android.MultilibCommon) 249 android.InitOverrideModule(m) 250 return m 251} 252