| /* |
| * Copyright (C) 2019 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 com.android.build.gradle.internal.core |
| |
| import com.android.build.api.component.ComponentIdentity |
| import com.android.build.api.variant.BuildConfigField |
| import com.android.build.api.variant.impl.ResValue |
| import com.android.build.gradle.ProguardFiles |
| import com.android.build.gradle.api.JavaCompileOptions |
| import com.android.build.gradle.internal.PostprocessingFeatures |
| import com.android.build.gradle.internal.ProguardFileType |
| import com.android.build.gradle.internal.core.MergedFlavor.Companion.mergeFlavors |
| import com.android.build.gradle.internal.dsl.BaseFlavor |
| import com.android.build.gradle.internal.dsl.BuildType |
| import com.android.build.gradle.internal.dsl.BuildType.PostProcessingConfiguration |
| import com.android.build.gradle.internal.dsl.CoreExternalNativeBuildOptions |
| import com.android.build.gradle.internal.dsl.DefaultConfig |
| import com.android.build.gradle.internal.dsl.ProductFlavor |
| import com.android.build.gradle.internal.dsl.SigningConfig |
| import com.android.build.gradle.internal.manifest.ManifestDataProvider |
| import com.android.build.gradle.internal.services.DslServices |
| import com.android.build.gradle.internal.services.VariantPropertiesApiServices |
| import com.android.build.gradle.internal.variant.DimensionCombination |
| import com.android.build.gradle.options.IntegerOption |
| import com.android.build.gradle.options.StringOption |
| import com.android.builder.core.AbstractProductFlavor |
| import com.android.builder.core.DefaultApiVersion |
| import com.android.builder.core.VariantType |
| import com.android.builder.dexing.DexingType |
| import com.android.builder.errors.IssueReporter |
| import com.android.builder.internal.ClassFieldImpl |
| import com.android.builder.model.ApiVersion |
| import com.android.builder.model.BaseConfig |
| import com.android.builder.model.ClassField |
| import com.android.builder.model.CodeShrinker |
| import com.android.builder.model.VectorDrawablesOptions |
| import com.android.sdklib.AndroidVersion |
| import com.android.utils.combineAsCamelCase |
| import com.google.common.base.Joiner |
| import com.google.common.collect.ImmutableList |
| import com.google.common.collect.ImmutableMap |
| import com.google.common.collect.ImmutableSet |
| import com.google.common.collect.Lists |
| import com.google.common.collect.Maps |
| import com.google.common.collect.Sets |
| import jdk.internal.org.objectweb.asm.Type |
| import org.gradle.api.file.DirectoryProperty |
| import org.gradle.api.provider.Property |
| import org.gradle.api.provider.Provider |
| import java.io.File |
| import java.lang.IllegalArgumentException |
| import java.util.ArrayList |
| import java.util.concurrent.Callable |
| |
| /** |
| * Represents a variant, initialized from the DSL object model (default config, build type, flavors) |
| * |
| * This class allows querying for the values set via the DSL model. |
| * |
| * Use [VariantBuilder] to instantiate. |
| * |
| */ |
| open class VariantDslInfoImpl internal constructor( |
| override val componentIdentity: ComponentIdentity, |
| override val variantType: VariantType, |
| private val defaultConfig: DefaultConfig, |
| /** |
| * Public because this is needed by the old Variant API. Nothing else should touch this. |
| */ |
| val buildTypeObj: BuildType, |
| /** The list of product flavors. Items earlier in the list override later items. */ |
| override val productFlavorList: List<ProductFlavor>, |
| private val signingConfigOverride: SigningConfig? = null, |
| private val testedVariantImpl: VariantDslInfoImpl? = null, |
| private val dataProvider: ManifestDataProvider, |
| @Deprecated("Only used for merged flavor") |
| private val dslServices: DslServices, |
| private val services: VariantPropertiesApiServices |
| ): VariantDslInfo, DimensionCombination { |
| |
| override val buildType: String? |
| get() = componentIdentity.buildType |
| override val productFlavors: List<Pair<String, String>> |
| get() = componentIdentity.productFlavors |
| |
| /** |
| * This should be mostly private and not used outside of this class. |
| * Unfortunately there are a few cases where this cannot happen. |
| * |
| * Still, DO NOT USE. You should mostly use [VariantDslInfo] which does not give access to this. |
| */ |
| val mergedFlavor: MergedFlavor by lazy { |
| mergeFlavors(defaultConfig, productFlavorList, applicationId, dslServices) |
| } |
| |
| /** Variant-specific build Config fields. */ |
| private val mBuildConfigFields: MutableMap<String, ClassField> = Maps.newTreeMap() |
| |
| /** Variant-specific res values. */ |
| private val mResValues: MutableMap<String, ClassField> = Maps.newTreeMap() |
| |
| /** |
| * Optional tested config in case this variant is used for testing another variant. |
| * |
| * @see VariantType.isTestComponent |
| */ |
| override val testedVariant: VariantDslInfo? |
| get() = testedVariantImpl |
| |
| private val mergedNdkConfig = MergedNdkConfig() |
| private val mergedExternalNativeBuildOptions = |
| MergedExternalNativeBuildOptions() |
| private val mergedJavaCompileOptions = MergedJavaCompileOptions(dslServices) |
| private val mergedAarMetadata = MergedAarMetadata() |
| |
| init { |
| mergeOptions() |
| } |
| |
| /** |
| * Returns a full name that includes the given splits name. |
| * |
| * @param splitName the split name |
| * @return a unique name made up of the variant and split names. |
| */ |
| override fun computeFullNameWithSplits(splitName: String): String { |
| return VariantBuilder.computeFullNameWithSplits( |
| componentIdentity, |
| variantType, |
| splitName |
| ) |
| } |
| |
| /** |
| * Returns the full, unique name of the variant, including BuildType, flavors and test, dash |
| * separated. (similar to full name but with dashes) |
| * |
| * @return the name of the variant |
| */ |
| override val baseName: String by lazy { |
| VariantBuilder.computeBaseName(this, variantType) |
| } |
| |
| /** |
| * Returns a base name that includes the given splits name. |
| * |
| * @param splitName the split name |
| * @return a unique name made up of the variant and split names. |
| */ |
| override fun computeBaseNameWithSplits(splitName: String): String { |
| val sb = StringBuilder() |
| if (productFlavorList.isNotEmpty()) { |
| for (pf in productFlavorList) { |
| sb.append(pf.name).append('-') |
| } |
| } |
| sb.append(splitName).append('-') |
| sb.append(buildTypeObj.name) |
| if (variantType.isTestComponent) { |
| sb.append('-').append(variantType.prefix) |
| } |
| return sb.toString() |
| } |
| |
| /** |
| * Returns a unique directory name (can include multiple folders) for the variant, based on |
| * build type, flavor and test. |
| * |
| * |
| * This always uses forward slashes ('/') as separator on all platform. |
| * |
| * @return the directory name for the variant |
| */ |
| override val dirName: String by lazy { |
| Joiner.on('/').join(directorySegments) |
| } |
| |
| /** |
| * Returns a unique directory name (can include multiple folders) for the variant, based on |
| * build type, flavor and test. |
| * |
| * @return the directory name for the variant |
| */ |
| override val directorySegments: Collection<String?> by lazy { |
| val builder = |
| ImmutableList.builder<String>() |
| if (variantType.isTestComponent) { |
| builder.add(variantType.prefix) |
| } |
| if (productFlavorList.isNotEmpty()) { |
| builder.add( |
| combineAsCamelCase( |
| productFlavorList, ProductFlavor::getName |
| ) |
| ) |
| } |
| builder.add(buildTypeObj.name) |
| builder.build() |
| } |
| |
| /** |
| * Returns a unique directory name (can include multiple folders) for the variant, based on |
| * build type, flavor and test, and splits. |
| * |
| * |
| * This always uses forward slashes ('/') as separator on all platform. |
| * |
| * @return the directory name for the variant |
| */ |
| override fun computeDirNameWithSplits(vararg splitNames: String): String { |
| val sb = StringBuilder() |
| if (variantType.isTestComponent) { |
| sb.append(variantType.prefix).append("/") |
| } |
| if (productFlavorList.isNotEmpty()) { |
| for (flavor in productFlavorList) { |
| sb.append(flavor.name) |
| } |
| sb.append('/') |
| } |
| for (splitName in splitNames) { |
| sb.append(splitName).append('/') |
| } |
| sb.append(buildTypeObj.name) |
| return sb.toString() |
| } |
| |
| /** |
| * Return the names of the applied flavors. |
| * |
| * |
| * The list contains the dimension names as well. |
| * |
| * @return the list, possibly empty if there are no flavors. |
| */ |
| override val flavorNamesWithDimensionNames: List<String> |
| get() { |
| if (productFlavorList.isEmpty()) { |
| return emptyList() |
| } |
| val names: List<String> |
| val count = productFlavorList.size |
| if (count > 1) { |
| names = |
| Lists.newArrayListWithCapacity(count * 2) |
| for (i in 0 until count) { |
| names.add(productFlavorList[i].name) |
| names.add(productFlavorList[i].dimension) |
| } |
| } else { |
| names = listOf(productFlavorList[0].name) |
| } |
| return names |
| } |
| |
| override fun hasFlavors(): Boolean { |
| return productFlavorList.isNotEmpty() |
| } |
| |
| // use lazy mechanism as this is referenced by other properties, like applicationId or itself |
| override val packageName: Provider<String> by lazy { |
| when { |
| // ------------- |
| // Special case for test components |
| // The package name is the tested component package name + .test |
| testedVariantImpl != null -> { |
| testedVariantImpl.packageName.map { |
| "$it.test" |
| } |
| } |
| |
| // ------------- |
| // Special case for separate test sub-projects |
| // if there is no manifest with no packageName but there is a testApplicationId |
| // then we use that. This allows the test project to not have a manifest if all |
| // is declared in the DSL. |
| variantType.isSeparateTestProject -> { |
| val testAppIdFromFlavors = |
| productFlavorList.asSequence().map { it.testApplicationId } |
| .firstOrNull { it != null } |
| ?: defaultConfig.testApplicationId |
| |
| dataProvider.manifestData.map { |
| it.packageName |
| ?: testAppIdFromFlavors |
| ?: throw RuntimeException("Package Name not found in ${dataProvider.manifestLocation}") |
| } |
| } |
| |
| // ------------- |
| // All other types of projects, just read from the manifest. |
| else -> { |
| dataProvider.manifestData.map { |
| it.packageName |
| ?: throw RuntimeException("Package Name not found in ${dataProvider.manifestLocation}") |
| } |
| } |
| } |
| } |
| |
| /** |
| * Returns the application ID for this variant. This could be coming from the manifest or could |
| * be overridden through the product flavors and/or the build type. |
| * |
| * @return the application ID |
| */ |
| override val applicationId: Property<String> = |
| services.newPropertyBackingDeprecatedApi( |
| String::class.java, |
| initApplicationId(), |
| "applicationId" |
| ) |
| |
| |
| private fun initApplicationId(): Provider<String> { |
| // ------------- |
| // Special case for test components and separate test sub-projects |
| if (variantType.isForTesting) { |
| // get first non null testAppId from flavors/default config |
| val testAppIdFromFlavors = |
| productFlavorList.asSequence().map { it.testApplicationId } |
| .firstOrNull { it != null } |
| ?: defaultConfig.testApplicationId |
| |
| return if (testAppIdFromFlavors == null) { |
| testedVariantImpl?.applicationId?.map { |
| "$it.test" |
| } ?: packageName |
| } else { |
| // needed to make nullability work in kotlinc |
| val finalTestAppIdFromFlavors: String = testAppIdFromFlavors |
| services.provider(Callable { finalTestAppIdFromFlavors }) |
| } |
| } |
| |
| // ------------- |
| // All other project types |
| |
| // get first non null appId from flavors/default config |
| val appIdFromFlavors = |
| productFlavorList.asSequence().map { it.applicationId }.firstOrNull { it != null } |
| ?: defaultConfig.applicationId |
| |
| return if (appIdFromFlavors == null) { |
| // No appId value set from DSL, rely on package name value from manifest. |
| // using map will allow us to keep task dependency should the manifest be generated |
| // or transformed via a task. |
| dataProvider.manifestData.map { |
| it.packageName?.let { pName -> |
| "$pName${computeApplicationIdSuffix()}" |
| } |
| ?: throw RuntimeException("Package Name not found in ${dataProvider.manifestLocation}") |
| } |
| } else { |
| // use value from flavors/defaultConfig |
| // needed to make nullability work in kotlinc |
| val finalAppIdFromFlavors: String = appIdFromFlavors |
| services.provider( |
| Callable { "$finalAppIdFromFlavors${computeApplicationIdSuffix()}" }) |
| } |
| } |
| |
| /** |
| * Combines all the appId suffixes into a single one. |
| * |
| * The suffixes are separated by '.' whether their first char is a '.' or not. |
| */ |
| private fun computeApplicationIdSuffix(): String { |
| // for the suffix we combine the suffix from all the flavors. However, we're going to |
| // want the higher priority one to be last. |
| val suffixes = mutableListOf<String>() |
| defaultConfig.applicationIdSuffix?.let { |
| suffixes.add(it) |
| } |
| |
| suffixes.addAll(productFlavorList.mapNotNull { it.applicationIdSuffix }) |
| |
| // then we add the build type after. |
| buildTypeObj.applicationIdSuffix?.let { |
| suffixes.add(it) |
| } |
| val nonEmptySuffixes = suffixes.filter { it.isNotEmpty() } |
| return if (nonEmptySuffixes.isNotEmpty()) { |
| ".${nonEmptySuffixes.joinToString(separator = ".", transform = { it.removePrefix(".") })}" |
| } else { |
| "" |
| } |
| } |
| |
| override val versionName: Provider<String?> |
| get() { |
| // This value is meaningless for tests |
| if (variantType.isForTesting) { |
| val callable: Callable<String?> = Callable { null } |
| return services.provider(callable) |
| } |
| |
| // TODO: figure out whether it's worth it to put all this inside a Provider to make it lazy. |
| val injectedVersionName = |
| services.projectOptions[StringOption.IDE_VERSION_NAME_OVERRIDE] |
| if (injectedVersionName != null) { |
| return services.provider(Callable { injectedVersionName }) |
| } |
| |
| // If the version name from the flavors is null, then we read from the manifest and combine |
| // with suffixes, unless it's a test at which point we just return. |
| // If the name is not-null, we just combine it with suffixes |
| val versionNameFromFlavors = |
| productFlavorList.asSequence().map { it.versionName }.firstOrNull { it != null } |
| ?: defaultConfig.versionName |
| |
| return if (versionNameFromFlavors == null) { |
| // rely on manifest value |
| // using map will allow us to keep task dependency should the manifest be generated or |
| // transformed via a task. |
| dataProvider.manifestData.map { |
| if (it.versionName == null) { |
| it.versionName |
| } else { |
| "${it.versionName}${computeVersionNameSuffix()}" |
| } |
| } |
| } else { |
| // use value from flavors |
| services.provider( |
| Callable { "$versionNameFromFlavors${computeVersionNameSuffix()}" }) |
| } |
| } |
| |
| private fun computeVersionNameSuffix(): String { |
| // for the suffix we combine the suffix from all the flavors. However, we're going to |
| // want the higher priority one to be last. |
| val suffixes = mutableListOf<String>() |
| defaultConfig.versionNameSuffix?.let { |
| suffixes.add(it) |
| } |
| |
| suffixes.addAll(productFlavorList.mapNotNull { it.versionNameSuffix }) |
| |
| // then we add the build type after. |
| buildTypeObj.versionNameSuffix?.let { |
| suffixes.add(it) |
| } |
| |
| return if (suffixes.isNotEmpty()) { |
| suffixes.joinToString(separator = "") |
| } else { |
| "" |
| } |
| } |
| |
| override val versionCode: Provider<Int?> |
| get() { |
| // This value is meaningless for tests |
| if (variantType.isForTesting) { |
| val callable: Callable<Int?> = Callable { null } |
| return services.provider(callable) |
| } |
| |
| // TODO: figure out whether it's worth it to put all this inside a Provider to make it lazy. |
| val injectedVersionCode = |
| services.projectOptions[IntegerOption.IDE_VERSION_CODE_OVERRIDE] |
| if (injectedVersionCode != null) { |
| return services.provider(Callable { injectedVersionCode }) |
| } |
| |
| // If the version code from the flavors is null, then we read from the manifest and combine |
| // with suffixes, unless it's a test at which point we just return. |
| // If the name is not-null, we just combine it with suffixes |
| val versionCodeFromFlavors = |
| productFlavorList.asSequence().map { it.versionCode }.firstOrNull { it != null } |
| ?: defaultConfig.versionCode |
| |
| return if (versionCodeFromFlavors == null) { |
| // rely on manifest value |
| // using map will allow us to keep task dependency should the manifest be generated or |
| // transformed via a task. |
| dataProvider.manifestData.map { it.versionCode } |
| } else { |
| // use value from flavors |
| services.provider(Callable { versionCodeFromFlavors }) |
| } |
| } |
| |
| override val instrumentationRunner: Provider<String> |
| get() { |
| if (!variantType.isForTesting) { |
| throw RuntimeException("instrumentationRunner is not available to non-test variant") |
| } |
| |
| // first check whether the DSL has the info |
| val fromFlavor = |
| productFlavorList.asSequence().map { it.testInstrumentationRunner } |
| .firstOrNull { it != null } |
| ?: defaultConfig.testInstrumentationRunner |
| |
| if (fromFlavor != null) { |
| val finalFromFlavor: String = fromFlavor |
| return services.provider(Callable { finalFromFlavor }) |
| } |
| |
| // else return the value from the Manifest |
| return dataProvider.manifestData.map { |
| it.instrumentationRunner |
| ?: if (isLegacyMultiDexMode) { |
| MULTIDEX_TEST_RUNNER |
| } else { |
| DEFAULT_TEST_RUNNER |
| } |
| } |
| } |
| |
| /** |
| * Returns the instrumentationRunner arguments to use to test this variant, or if the variant is |
| * a test, the ones to use to test the tested variant |
| */ |
| override val instrumentationRunnerArguments: Map<String, String> |
| get() { |
| val variantDslInfo: VariantDslInfoImpl = |
| if (variantType.isTestComponent) { |
| testedVariantImpl!! |
| } else { |
| this |
| } |
| return variantDslInfo.mergedFlavor.testInstrumentationRunnerArguments |
| } |
| |
| override val handleProfiling: Provider<Boolean> |
| get() { |
| if (!variantType.isForTesting) { |
| throw RuntimeException("handleProfiling is not available to non-test variant") |
| } |
| |
| // first check whether the DSL has the info |
| val fromFlavor = |
| productFlavorList.asSequence().map { it.testHandleProfiling } |
| .firstOrNull { it != null } |
| ?: defaultConfig.testHandleProfiling |
| |
| if (fromFlavor != null) { |
| val finalFromFlavor: Boolean = fromFlavor |
| return services.provider(Callable { finalFromFlavor }) |
| } |
| |
| // else return the value from the Manifest |
| return dataProvider.manifestData.map { it.handleProfiling ?: DEFAULT_HANDLE_PROFILING } |
| } |
| |
| override val functionalTest: Provider<Boolean> |
| get() { |
| if (!variantType.isForTesting) { |
| throw RuntimeException("functionalTest is not available to non-test variant") |
| } |
| |
| // first check whether the DSL has the info |
| val fromFlavor = |
| productFlavorList.asSequence().map { it.testFunctionalTest } |
| .firstOrNull { it != null } |
| ?: defaultConfig.testFunctionalTest |
| |
| if (fromFlavor != null) { |
| val finalFromFlavor: Boolean = fromFlavor |
| return services.provider(Callable { finalFromFlavor }) |
| } |
| |
| // else return the value from the Manifest |
| return dataProvider.manifestData.map { it.functionalTest ?: DEFAULT_FUNCTIONAL_TEST } |
| } |
| |
| override val testLabel: Provider<String?> |
| get() { |
| if (!variantType.isForTesting) { |
| throw RuntimeException("handleProfiling is not available to non-test variant") |
| } |
| |
| // there is actually no DSL value for this. |
| return dataProvider.manifestData.map { it.testLabel } |
| } |
| |
| val extractNativeLibs: Provider<Boolean?> |
| get() { |
| // there is actually no DSL value for this, also we should add one |
| // FIXME b/149770867 |
| return dataProvider.manifestData.map { it.extractNativeLibs } |
| } |
| |
| val useEmbeddedDex: Provider<Boolean?> |
| get() { |
| // there is actually no DSL value for this, also we should add one |
| // FIXME b/149770867 |
| return dataProvider.manifestData.map { it.useEmbeddedDex } |
| } |
| |
| /** |
| * Return the minSdkVersion for this variant. |
| * |
| * |
| * This uses both the value from the manifest (if present), and the override coming from the |
| * flavor(s) (if present). |
| * |
| * @return the minSdkVersion |
| */ |
| override val minSdkVersion: AndroidVersion |
| get() { |
| if (testedVariantImpl != null) { |
| return testedVariantImpl.minSdkVersion |
| } |
| // default to 1 for minSdkVersion. |
| val minSdkVersion = |
| mergedFlavor.minSdkVersion ?: DefaultApiVersion.create(Integer.valueOf(1)) |
| |
| return AndroidVersion( |
| minSdkVersion.apiLevel, |
| minSdkVersion.codename |
| ) |
| } |
| |
| override val maxSdkVersion: Int? |
| get() = mergedFlavor.maxSdkVersion |
| |
| /** |
| * Return the targetSdkVersion for this variant. |
| * |
| * |
| * This uses both the value from the manifest (if present), and the override coming from the |
| * flavor(s) (if present). |
| * |
| * @return the targetSdkVersion |
| */ |
| override val targetSdkVersion: ApiVersion |
| get() { |
| if (testedVariantImpl != null) { |
| return testedVariantImpl.targetSdkVersion |
| } |
| return mergedFlavor.targetSdkVersion |
| // default to -1 if not in build.gradle file. |
| ?: DefaultApiVersion.create(Integer.valueOf(-1)) |
| } |
| |
| override val renderscriptTarget: Int |
| get() { |
| val targetApi = mergedFlavor.renderscriptTargetApi ?: -1 |
| |
| // default to -1 if not in build.gradle file. |
| val minSdk = minSdkVersion.featureLevel |
| |
| return if (targetApi > minSdk) targetApi else minSdk |
| } |
| |
| override val isWearAppUnbundled: Boolean? |
| get() = mergedFlavor.wearAppUnbundled |
| |
| @Suppress("DEPRECATION") |
| override val missingDimensionStrategies: ImmutableMap<String, AbstractProductFlavor.DimensionRequest> |
| get() = ImmutableMap.copyOf(mergedFlavor.missingDimensionStrategies) |
| |
| override val resourceConfigurations: ImmutableSet<String> |
| get() = ImmutableSet.copyOf(mergedFlavor.resourceConfigurations) |
| |
| override val vectorDrawables: VectorDrawablesOptions |
| get() = mergedFlavor.vectorDrawables |
| |
| /** |
| * Adds a variant-specific BuildConfig field. |
| * |
| * @param type the type of the field |
| * @param name the name of the field |
| * @param value the value of the field |
| */ |
| override fun addBuildConfigField( |
| type: String, |
| name: String, |
| value: String |
| ) { |
| val classField: ClassField = ClassFieldImpl(type, name, value) |
| mBuildConfigFields[name] = classField |
| } |
| |
| /** |
| * Adds a variant-specific res value. |
| * |
| * @param type the type of the field |
| * @param name the name of the field |
| * @param value the value of the field |
| */ |
| override fun addResValue(type: String, name: String, value: String) { |
| val classField: ClassField = ClassFieldImpl(type, name, value) |
| mResValues[name] = classField |
| } // keep track of the names already added. This is because we show where the items |
| // come from so we cannot just put everything a map and let the new ones override the |
| // old ones. |
| |
| override fun getBuildConfigFields(): Map<String, BuildConfigField<out java.io.Serializable>> { |
| val buildConfigFieldsMap = |
| mutableMapOf<String, BuildConfigField<out java.io.Serializable>>() |
| |
| fun addToListIfNotAlreadyPresent(classField: ClassField, comment: String) { |
| if (!buildConfigFieldsMap.containsKey(classField.name)) { |
| buildConfigFieldsMap[classField.name] = |
| BuildConfigField(classField.type , classField.value, comment) |
| } |
| } |
| |
| mBuildConfigFields.values.forEach { classField -> |
| addToListIfNotAlreadyPresent(classField, "Field from the variant API") |
| } |
| |
| buildTypeObj.buildConfigFields.values.forEach { classField -> |
| addToListIfNotAlreadyPresent(classField, "Field from build type: ${buildTypeObj.name}") |
| } |
| |
| for (flavor in productFlavorList) { |
| flavor.buildConfigFields.values.forEach { classField -> |
| addToListIfNotAlreadyPresent( |
| classField, |
| "Field from product flavor: ${flavor.name}" |
| ) |
| } |
| } |
| defaultConfig.buildConfigFields.values.forEach { classField -> |
| addToListIfNotAlreadyPresent(classField, "Field from default config.") |
| } |
| return buildConfigFieldsMap |
| } |
| |
| /** |
| * Returns a list of generated resource values. |
| * |
| * |
| * Items can be either fields (instance of [com.android.builder.model.ClassField]) or |
| * comments (instance of String). |
| * |
| * @return a list of items. |
| */ |
| override fun getResValues(): Map<ResValue.Key, ResValue> { |
| val resValueFields = mutableMapOf<ResValue.Key, ResValue>() |
| |
| fun addToListIfNotAlreadyPresent(classField: ClassField, comment: String) { |
| val key = ResValue.Key(classField.type, classField.name) |
| if (!resValueFields.containsKey(key)) { |
| resValueFields[key] = ResValue( |
| value = classField.value, |
| comment = comment |
| ) |
| } |
| } |
| |
| mResValues.values.forEach { classField -> |
| addToListIfNotAlreadyPresent(classField, "Value from the variant") |
| } |
| |
| buildTypeObj.resValues.values.forEach { classField -> |
| addToListIfNotAlreadyPresent(classField, "Value from build type: ${buildTypeObj.name}") |
| } |
| |
| productFlavorList.forEach { flavor -> |
| flavor.resValues.values.forEach { classField -> |
| addToListIfNotAlreadyPresent( |
| classField, |
| "Value from product flavor: ${flavor.name}" |
| ) |
| } |
| } |
| |
| defaultConfig.resValues.values.forEach { classField -> |
| addToListIfNotAlreadyPresent(classField, "Value from default config.") |
| } |
| |
| return resValueFields |
| } |
| |
| override val signingConfig: SigningConfig? |
| get() { |
| if (variantType.isDynamicFeature) { |
| return null |
| } |
| if (signingConfigOverride != null) { |
| return signingConfigOverride |
| } |
| val signingConfig: SigningConfig? = buildTypeObj.signingConfig |
| // cast builder.SigningConfig to dsl.SigningConfig because MergedFlavor merges |
| // dsl.SigningConfig of ProductFlavor objects |
| return signingConfig ?: mergedFlavor.signingConfig as SigningConfig? |
| } |
| |
| override val isSigningReady: Boolean |
| get() { |
| val signingConfig = signingConfig |
| return signingConfig != null && signingConfig.isSigningReady |
| } |
| |
| override val isTestCoverageEnabled: Boolean |
| get() = buildTypeObj.isTestCoverageEnabled // so far, blindly override the build type placeholders |
| |
| /** |
| * Returns the merged manifest placeholders. All product flavors are merged first, then build |
| * type specific placeholders are added and potentially overrides product flavors values. |
| * |
| * @return the merged manifest placeholders for a build variant. |
| */ |
| override val manifestPlaceholders: Map<String, String> by lazy { |
| val mergedFlavorsPlaceholders: MutableMap<String, String> = mutableMapOf() |
| mergedFlavor.manifestPlaceholders.forEach { (key, value) -> |
| mergedFlavorsPlaceholders[key] = value.toString() |
| } |
| // so far, blindly override the build type placeholders |
| buildTypeObj.manifestPlaceholders.forEach { (key, value) -> |
| mergedFlavorsPlaceholders[key] = value.toString() |
| } |
| mergedFlavorsPlaceholders |
| } |
| |
| // Only require specific multidex opt-in for legacy multidex. |
| override val isMultiDexEnabled: Boolean |
| get() { |
| // Only require specific multidex opt-in for legacy multidex. |
| return buildTypeObj.multiDexEnabled |
| ?: mergedFlavor.multiDexEnabled |
| ?: (minSdkVersion.featureLevel >= 21) |
| } |
| |
| override val multiDexKeepFile: File? |
| get() { |
| var value = buildTypeObj.multiDexKeepFile |
| if (value != null) { |
| return value |
| } |
| value = mergedFlavor.multiDexKeepFile |
| return value |
| } |
| |
| override val multiDexKeepProguard: File? |
| get() { |
| var value = buildTypeObj.multiDexKeepProguard |
| if (value != null) { |
| return value |
| } |
| value = mergedFlavor.multiDexKeepProguard |
| return value |
| } |
| |
| override val isLegacyMultiDexMode: Boolean |
| get() = dexingType === DexingType.LEGACY_MULTIDEX |
| |
| // dynamic features can always be build in native multidex mode |
| override val dexingType: DexingType |
| get() = if (variantType.isDynamicFeature) { |
| if (buildTypeObj.multiDexEnabled != null || |
| mergedFlavor.multiDexEnabled != null |
| ) { |
| dslServices.issueReporter |
| .reportWarning( |
| IssueReporter.Type.GENERIC, |
| "Native multidex is always used for dynamic features. Please " + |
| "remove 'multiDexEnabled true|false' from your " + |
| "build.gradle file." |
| ) |
| } |
| // dynamic features can always be build in native multidex mode |
| DexingType.NATIVE_MULTIDEX |
| } else if (isMultiDexEnabled) { |
| if (minSdkVersion.featureLevel < 21) DexingType.LEGACY_MULTIDEX else DexingType.NATIVE_MULTIDEX |
| } else { |
| DexingType.MONO_DEX |
| } |
| |
| /** Returns the renderscript support mode. */ |
| override val renderscriptSupportModeEnabled: Boolean |
| get() = mergedFlavor.renderscriptSupportModeEnabled ?: false |
| |
| /** Returns the renderscript BLAS support mode. */ |
| override val renderscriptSupportModeBlasEnabled: Boolean |
| get() { |
| val value = mergedFlavor.renderscriptSupportModeBlasEnabled |
| return value ?: false |
| } |
| |
| /** Returns the renderscript NDK mode. */ |
| override val renderscriptNdkModeEnabled: Boolean |
| get() = mergedFlavor.renderscriptNdkModeEnabled ?: false |
| |
| /** Returns true if the variant output is a bundle. */ |
| override val isBundled: Boolean |
| get() = variantType.isAar // Consider runtime API passed from the IDE only if multi-dex is enabled and the app is debuggable. |
| |
| /** |
| * Returns the minimum SDK version for this variant, potentially overridden by a property passed |
| * by the IDE. |
| * |
| * @see .getMinSdkVersion |
| */ |
| override val minSdkVersionWithTargetDeviceApi: AndroidVersion |
| get() { |
| val targetApiLevel = dslServices.projectOptions[IntegerOption.IDE_TARGET_DEVICE_API] |
| return if (targetApiLevel != null && isMultiDexEnabled && buildTypeObj.isDebuggable) { |
| // Consider runtime API passed from the IDE only if multi-dex is enabled and the app is |
| // debuggable. |
| val minVersion: Int = |
| if (targetSdkVersion.apiLevel > 1) Integer.min( |
| targetSdkVersion.apiLevel, |
| targetApiLevel |
| ) else targetApiLevel |
| AndroidVersion(minVersion) |
| } else { |
| minSdkVersion |
| } |
| } |
| |
| /** |
| * Merge Gradle specific options from build types, product flavors and default config. |
| */ |
| private fun mergeOptions() { |
| computeMergedOptions( |
| mergedJavaCompileOptions, |
| { javaCompileOptions }, |
| { javaCompileOptions } |
| ) |
| computeMergedOptions( |
| mergedNdkConfig, |
| { ndkConfig }, |
| { ndkConfig } |
| ) |
| computeMergedOptions( |
| mergedExternalNativeBuildOptions, |
| { externalNativeBuildOptions }, |
| { externalNativeBuildOptions } |
| ) |
| computeMergedOptions( |
| mergedAarMetadata, |
| { aarMetadata }, |
| { aarMetadata } |
| ) |
| } |
| |
| override val ndkConfig: MergedNdkConfig |
| get() = mergedNdkConfig |
| |
| override val externalNativeBuildOptions: CoreExternalNativeBuildOptions |
| get() = mergedExternalNativeBuildOptions |
| |
| override val aarMetadata: MergedAarMetadata |
| get() = mergedAarMetadata |
| |
| /** |
| * Returns the ABI filters associated with the artifact, or empty set if there are no filters. |
| * |
| * If the list contains values, then the artifact only contains these ABIs and excludes |
| * others. |
| */ |
| override val supportedAbis: Set<String> |
| get() = if (variantType.isDynamicFeature) setOf() else mergedNdkConfig.abiFilters |
| |
| override fun gatherProguardFiles(type: ProguardFileType): List<File> { |
| val result: MutableList<File> = ArrayList(defaultConfig.getProguardFiles(type)) |
| for (flavor in productFlavorList) { |
| result.addAll(flavor.getProguardFiles(type)) |
| } |
| return result |
| } |
| |
| /** |
| * Merge a specific option in GradleVariantConfiguration. |
| * |
| * |
| * It is assumed that merged option type with a method to reset and append is created for the |
| * option being merged. |
| * |
| * |
| * The order of priority is BuildType, ProductFlavors, and default config. ProductFlavor |
| * added earlier has higher priority than ProductFlavor added later. |
| * |
| * @param mergedOption The merged option store in the GradleVariantConfiguration. |
| * @param getFlavorOption A Function to return the option from a ProductFlavor. |
| * @param getBuildTypeOption A Function to return the option from a BuildType. |
| * takes priority and overwrite option in the first input argument. |
| * @param <CoreOptionsT> The core type of the option being merge. |
| * @param <MergedOptionsT> The merge option type. |
| </MergedOptionsT></CoreOptionsT> */ |
| private fun <CoreOptionsT, MergedOptionsT : MergedOptions<CoreOptionsT>> computeMergedOptions( |
| mergedOption: MergedOptionsT, |
| getFlavorOption: BaseFlavor.() -> CoreOptionsT?, |
| getBuildTypeOption: BuildType.() -> CoreOptionsT? |
| ) { |
| mergedOption.reset() |
| |
| val defaultOption = defaultConfig.getFlavorOption() |
| if (defaultOption != null) { |
| mergedOption.append(defaultOption) |
| } |
| // reverse loop for proper order |
| for (i in productFlavorList.indices.reversed()) { |
| val flavorOption = productFlavorList[i].getFlavorOption() |
| if (flavorOption != null) { |
| mergedOption.append(flavorOption) |
| } |
| } |
| val buildTypeOption = buildTypeObj.getBuildTypeOption() |
| if (buildTypeOption != null) { |
| mergedOption.append(buildTypeOption) |
| } |
| } |
| |
| override val javaCompileOptions: JavaCompileOptions |
| get() = mergedJavaCompileOptions |
| |
| override fun createPostProcessingOptions(buildDirectory: DirectoryProperty) : PostProcessingOptions { |
| return if (buildTypeObj.postProcessingConfiguration == PostProcessingConfiguration.POSTPROCESSING_BLOCK) { |
| PostProcessingBlockOptions( |
| buildTypeObj.postprocessing, variantType.isTestComponent |
| ) |
| } else object : PostProcessingOptions { |
| override fun getProguardFiles(type: ProguardFileType): Collection<File> = |
| buildTypeObj.getProguardFiles(type) |
| |
| override fun getDefaultProguardFiles(): List<File> = |
| listOf( |
| ProguardFiles.getDefaultProguardFile( |
| ProguardFiles.ProguardFile.DONT_OPTIMIZE.fileName, |
| buildDirectory |
| ) |
| ) |
| |
| override fun getPostprocessingFeatures(): PostprocessingFeatures? = null |
| |
| override fun getCodeShrinker() = when { |
| !buildTypeObj.isMinifyEnabled -> null |
| buildTypeObj.isUseProguard == true -> CodeShrinker.PROGUARD |
| else -> CodeShrinker.R8 |
| } |
| |
| override fun resourcesShrinkingEnabled(): Boolean = buildTypeObj.isShrinkResources |
| } |
| } |
| |
| // add the lower priority one, to override them with the higher priority ones. |
| // cant use merge flavor as it's not a prop on the base class. |
| // reverse loop for proper order |
| override val defaultGlslcArgs: List<String> |
| get() { |
| val optionMap: MutableMap<String, String> = |
| Maps.newHashMap() |
| // add the lower priority one, to override them with the higher priority ones. |
| for (option in defaultConfig.shaders.glslcArgs) { |
| optionMap[getKey(option)] = option |
| } |
| // cant use merge flavor as it's not a prop on the base class. |
| // reverse loop for proper order |
| for (i in productFlavorList.indices.reversed()) { |
| for (option in productFlavorList[i].shaders.glslcArgs) { |
| optionMap[getKey(option)] = option |
| } |
| } |
| // then the build type |
| for (option in buildTypeObj.shaders.glslcArgs) { |
| optionMap[getKey(option)] = option |
| } |
| return Lists.newArrayList(optionMap.values) |
| } |
| |
| // first collect all possible keys. |
| override val scopedGlslcArgs: Map<String, List<String>> |
| get() { |
| val scopedArgs: MutableMap<String, List<String>> = |
| Maps.newHashMap() |
| // first collect all possible keys. |
| val keys = scopedGlslcKeys |
| for (key in keys) { // first add to a temp map to resolve overridden values |
| val optionMap: MutableMap<String, String> = |
| Maps.newHashMap() |
| // we're going to go from lower priority, to higher priority elements, and for each |
| // start with the non scoped version, and then add the scoped version. |
| // 1. default config, global. |
| for (option in defaultConfig.shaders.glslcArgs) { |
| optionMap[getKey(option)] = option |
| } |
| // 1b. default config, scoped. |
| for (option in defaultConfig.shaders.scopedGlslcArgs[key]) { |
| optionMap[getKey(option)] = option |
| } |
| // 2. the flavors. |
| // cant use merge flavor as it's not a prop on the base class. |
| // reverse loop for proper order |
| for (i in productFlavorList.indices.reversed()) { // global |
| for (option in productFlavorList[i].shaders.glslcArgs) { |
| optionMap[getKey(option)] = option |
| } |
| // scoped. |
| for (option in productFlavorList[i].shaders.scopedGlslcArgs[key]) { |
| optionMap[getKey(option)] = option |
| } |
| } |
| // 3. the build type, global |
| for (option in buildTypeObj.shaders.glslcArgs) { |
| optionMap[getKey(option)] = option |
| } |
| // 3b. the build type, scoped. |
| for (option in buildTypeObj.shaders.scopedGlslcArgs[key]) { |
| optionMap[getKey(option)] = option |
| } |
| // now add the full value list. |
| scopedArgs[key] = ImmutableList.copyOf(optionMap.values) |
| } |
| return scopedArgs |
| } |
| |
| private val scopedGlslcKeys: Set<String> |
| get() { |
| val keys: MutableSet<String> = |
| Sets.newHashSet() |
| keys.addAll(defaultConfig.shaders.scopedGlslcArgs.keySet()) |
| for (flavor in productFlavorList) { |
| keys.addAll(flavor.shaders.scopedGlslcArgs.keySet()) |
| } |
| keys.addAll(buildTypeObj.shaders.scopedGlslcArgs.keySet()) |
| return keys |
| } |
| |
| override val isDebuggable: Boolean |
| get() = buildTypeObj.isDebuggable |
| |
| override val isEmbedMicroApp: Boolean |
| get() = buildTypeObj.isEmbedMicroApp |
| |
| override val isPseudoLocalesEnabled: Boolean |
| get() = buildTypeObj.isPseudoLocalesEnabled |
| |
| override val isCrunchPngs: Boolean? |
| get() = buildTypeObj.isCrunchPngs |
| |
| @Suppress("OverridingDeprecatedMember", "DEPRECATION") |
| override val isCrunchPngsDefault: Boolean |
| get() = buildTypeObj.isCrunchPngsDefault |
| |
| override val isMinifyEnabled: Boolean |
| get() = buildTypeObj.isMinifyEnabled |
| |
| override val isRenderscriptDebuggable: Boolean |
| get() = buildTypeObj.isRenderscriptDebuggable |
| |
| override val renderscriptOptimLevel: Int |
| get() = buildTypeObj.renderscriptOptimLevel |
| |
| override val isJniDebuggable: Boolean |
| get() = buildTypeObj.isJniDebuggable |
| |
| companion object { |
| |
| private const val DEFAULT_TEST_RUNNER = "android.test.InstrumentationTestRunner" |
| private const val MULTIDEX_TEST_RUNNER = |
| "com.android.test.runner.MultiDexTestRunner" |
| private const val DEFAULT_HANDLE_PROFILING = false |
| private const val DEFAULT_FUNCTIONAL_TEST = false |
| |
| /** |
| * Fills a list of Object from a given list of ClassField only if the name isn't in a set. Each |
| * new item added adds its name to the list. |
| * |
| * @param outList the out list |
| * @param usedFieldNames the list of field names already in the list |
| * @param list the list to copy items from |
| */ |
| private fun fillFieldList( |
| outList: MutableList<Any>, |
| usedFieldNames: MutableSet<String>, |
| list: Collection<ClassField> |
| ) { |
| for (f in list) { |
| val name = f.name |
| if (!usedFieldNames.contains(name)) { |
| usedFieldNames.add(f.name) |
| outList.add(f) |
| } |
| } |
| } |
| |
| private fun getKey(fullOption: String): String { |
| val pos = fullOption.lastIndexOf('=') |
| return if (pos == -1) { |
| fullOption |
| } else fullOption.substring(0, pos) |
| } |
| } |
| } |
| |
| private fun BaseConfig.getProguardFiles(type: ProguardFileType): Collection<File> = when (type) { |
| ProguardFileType.EXPLICIT -> this.proguardFiles |
| ProguardFileType.TEST -> this.testProguardFiles |
| ProguardFileType.CONSUMER -> this.consumerProguardFiles |
| } |
