| /* |
| * Copyright (C) 2012 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.builder.core |
| |
| import com.android.builder.internal.BaseConfigImpl |
| import com.android.builder.model.ApiVersion |
| import com.android.builder.model.BaseConfig |
| import com.android.builder.model.ProductFlavor |
| import com.android.builder.model.SigningConfig |
| import com.google.common.base.MoreObjects |
| import com.google.common.base.Strings |
| import com.google.common.collect.ImmutableList |
| import com.google.common.collect.ImmutableMap |
| import com.google.common.collect.Maps |
| import com.google.common.collect.Sets |
| |
| /** |
| * Builder-level implementation of ProductFlavor. |
| * |
| * |
| * This is also used to describe the default configuration of all builds, even those that do not |
| * contain any flavors. |
| * |
| */ |
| @Deprecated("This is deprecated, use DSL objects directly.") |
| abstract class AbstractProductFlavor( |
| private val name: String |
| ) : BaseConfigImpl(), ProductFlavor { |
| |
| override fun getName(): String = name |
| |
| override var dimension: String? = null |
| |
| // For kotlin script source compatibility. |
| @Deprecated("Replaced with the dimension property", replaceWith = ReplaceWith("dimension(dimension)")) |
| fun setDimension(dimension: String?): Void? { |
| this.dimension = dimension |
| return null |
| } |
| |
| open fun dimension(dimension: String?) { |
| this.dimension = dimension |
| } |
| |
| override var applicationId: String? = null |
| |
| open fun setApplicationId(applicationId: String?): ProductFlavor { |
| this.applicationId = applicationId |
| return this |
| } |
| |
| open fun applicationId(applicationId: String?) { |
| this.applicationId = applicationId |
| } |
| |
| /** |
| * Implemented as a separate property to make versionCode read-only in MergedFlavor, |
| * but still allow [mergeWithHigherPriorityFlavor] to set it. |
| */ |
| private var _versionCode: Int? = null |
| |
| override var versionCode: Int? |
| get() = _versionCode |
| set(value) { _versionCode = value } |
| |
| open fun setVersionCode(versionCode: Int?): ProductFlavor { |
| this.versionCode = versionCode |
| return this |
| } |
| |
| open fun versionCode(versionCode: Int?) { |
| this.versionCode = versionCode |
| } |
| |
| /** |
| * Implemented as a separate property to make versionName read-only in MergedFlavor, |
| * but still allow [mergeWithHigherPriorityFlavor] to set it. |
| */ |
| private var _versionName: String? = null |
| |
| override var versionName: String? |
| get() = _versionName |
| set(value) { _versionName = value } |
| |
| open fun setVersionName(versionName: String?): ProductFlavor { |
| this.versionName = versionName |
| return this |
| } |
| |
| open fun versionName(versionName: String?) { |
| this.versionName = versionName |
| } |
| |
| fun setMinSdkVersion(minSdkVersion: ApiVersion?): ProductFlavor { |
| this.minSdkVersion = minSdkVersion |
| return this |
| } |
| |
| /** Min SDK version. */ |
| override var minSdkVersion: ApiVersion? = null |
| |
| /** Target SDK version. */ |
| override var targetSdkVersion: ApiVersion? = null |
| |
| /** Sets the targetSdkVersion to the given value. */ |
| fun setTargetSdkVersion(targetSdkVersion: ApiVersion?): ProductFlavor { |
| this.targetSdkVersion = targetSdkVersion |
| return this |
| } |
| |
| override var maxSdkVersion: Int? = null |
| |
| fun setMaxSdkVersion(maxSdkVersion: Int?): ProductFlavor { |
| this.maxSdkVersion = maxSdkVersion |
| return this |
| } |
| |
| override var renderscriptTargetApi: Int? = null |
| |
| override var renderscriptSupportModeEnabled: Boolean? = null |
| |
| fun setRenderscriptSupportModeEnabled(renderscriptSupportMode: Boolean?): ProductFlavor { |
| renderscriptSupportModeBlasEnabled = renderscriptSupportMode |
| return this |
| } |
| |
| open fun renderscriptSupportModeEnabled(renderscriptSupportModeEnabled: Boolean?) { |
| this.renderscriptSupportModeEnabled = renderscriptSupportModeEnabled |
| } |
| |
| override var renderscriptSupportModeBlasEnabled: Boolean? = null |
| |
| fun setRenderscriptSupportModeBlasEnabled(renderscriptSupportModeBlas: Boolean?): ProductFlavor { |
| this.renderscriptSupportModeBlasEnabled = renderscriptSupportModeBlas |
| return this |
| } |
| |
| open fun renderscriptSupportModeBlasEnabled(renderscriptSupportModeBlas: Boolean?) { |
| this.renderscriptSupportModeBlasEnabled = renderscriptSupportModeBlas |
| } |
| |
| override var renderscriptNdkModeEnabled: Boolean? = null |
| |
| fun setRenderscriptNdkModeEnabled(renderscriptNdkMode: Boolean?): ProductFlavor { |
| this.renderscriptNdkModeEnabled = renderscriptNdkMode |
| return this |
| } |
| |
| open fun renderscriptNdkModeEnabled(renderscriptNdkModeEnabled: Boolean?) { |
| this.renderscriptNdkModeEnabled = renderscriptNdkModeEnabled |
| } |
| |
| override var testApplicationId: String? = null |
| |
| fun setTestApplicationId(applicationId: String?): ProductFlavor { |
| testApplicationId = applicationId |
| return this |
| } |
| |
| open fun testApplicationId(applicationId: String?) { |
| testApplicationId = applicationId |
| } |
| |
| override var testInstrumentationRunner: String? = null |
| |
| fun setTestInstrumentationRunner(testInstrumentationRunner: String?): ProductFlavor { |
| this.testInstrumentationRunner = testInstrumentationRunner |
| return this |
| } |
| |
| open fun testInstrumentationRunner(testInstrumentationRunner: String?) { |
| this.testInstrumentationRunner = testInstrumentationRunner |
| } |
| |
| override val testInstrumentationRunnerArguments: MutableMap<String, String> = Maps.newHashMap() |
| |
| fun setTestInstrumentationRunnerArguments( |
| testInstrumentationRunnerArguments: MutableMap<String, String> |
| ): ProductFlavor { |
| this.testInstrumentationRunnerArguments.clear() |
| this.testInstrumentationRunnerArguments.putAll(testInstrumentationRunnerArguments) |
| return this |
| } |
| |
| override var testHandleProfiling: Boolean? = null |
| |
| fun setTestHandleProfiling(handleProfiling: Boolean): ProductFlavor { |
| testHandleProfiling = handleProfiling |
| return this |
| } |
| |
| override var testFunctionalTest: Boolean? = null |
| |
| fun setTestFunctionalTest(functionalTest: Boolean): ProductFlavor { |
| testFunctionalTest = functionalTest |
| return this |
| } |
| |
| private var _signingConfig: SigningConfig? = null |
| |
| /** Signing config used by this product flavor. e.g.: `signingConfig = signingConfigs.myConfig` */ |
| override val signingConfig: SigningConfig? |
| get() = _signingConfig |
| |
| fun setSigningConfig(signingConfig: SigningConfig?): ProductFlavor { |
| _signingConfig = signingConfig |
| return this |
| } |
| |
| /** |
| * Options to configure the build-time support for `vector` drawables. |
| */ |
| abstract override val vectorDrawables: DefaultVectorDrawablesOptions |
| |
| override var wearAppUnbundled: Boolean? = null |
| |
| override val resourceConfigurations: MutableSet<String> = Sets.newHashSet() |
| |
| /** |
| * Adds a res config filter (for instance 'hdpi') |
| */ |
| fun addResourceConfiguration(configuration: String) { |
| resourceConfigurations.add(configuration) |
| } |
| |
| /** |
| * Adds a res config filter (for instance 'hdpi') |
| */ |
| fun addResourceConfigurations(vararg configurations: String) { |
| resourceConfigurations.addAll(listOf(*configurations)) |
| } |
| |
| /** |
| * Adds a res config filter (for instance 'hdpi') |
| */ |
| fun addResourceConfigurations(configurations: Collection<String>) { |
| resourceConfigurations.addAll(configurations) |
| } |
| |
| /** Class representing a request with fallbacks. */ |
| class DimensionRequest(val requested: String, val fallbacks: ImmutableList<String>) { |
| fun getFallbacks(): List<String> = fallbacks |
| } |
| |
| /** map of dimension -> request */ |
| private var missingDimensionSelections: MutableMap<String, DimensionRequest>? = null |
| |
| /** |
| * Specifies a flavor that the plugin should try to use from a given dimension in a dependency. |
| * |
| * Android plugin 3.0.0 and higher try to match each variant of your module with the same one |
| * from its dependencies. For example, consider if both your app and its dependencies include a |
| * "tier" [flavor dimension](/studio/build/build-variants.html#flavor-dimensions), |
| * with flavors "free" and "paid". When you build a "freeDebug" version of your app, the plugin |
| * tries to match it with "freeDebug" versions of the local library modules the app depends on. |
| * |
| * However, there may be situations in which **a library dependency includes a flavor |
| * dimension that your app does not**. For example, consider if a library dependency includes |
| * flavors for a "minApi" dimension, but your app includes flavors for only the "tier" |
| * dimension. So, when you want to build the "freeDebug" version of your app, the plugin doesn't |
| * know whether to use the "minApi23Debug" or "minApi18Debug" version of the dependency, and |
| * you'll see an error message similar to the following: |
| * |
| * ``` |
| * Error:Failed to resolve: Could not resolve project :mylibrary. |
| * Required by: |
| * project :app |
| * ``` |
| * |
| * In this type of situation, use `missingDimensionStrategy` in the |
| * [`defaultConfig`](com.android.build.gradle.internal.dsl.DefaultConfig.html) |
| * block to specify the default flavor the plugin should select from each missing |
| * dimension, as shown in the sample below. You can also override your selection in the |
| * [`productFlavors`](com.android.build.gradle.internal.dsl.ProductFlavor.html) |
| * block, so each flavor can specify a different matching strategy for a missing dimension. |
| * (Tip: you can also use this property if you simply want to change the matching strategy for a |
| * dimension that exists in both the app and its dependencies.) |
| * |
| * ``` |
| * // In the app's build.gradle file. |
| * android { |
| * defaultConfig { |
| * // Specifies a flavor that the plugin should try to use from |
| * // a given dimension. The following tells the plugin that, when encountering |
| * // a dependency that includes a "minApi" dimension, it should select the |
| * // "minApi18" flavor. |
| * missingDimensionStrategy 'minApi', 'minApi18' |
| * // You should specify a missingDimensionStrategy property for each |
| * // dimension that exists in a local dependency but not in your app. |
| * missingDimensionStrategy 'abi', 'x86' |
| * } |
| * flavorDimensions 'tier' |
| * productFlavors { |
| * free { |
| * dimension 'tier' |
| * // You can override the default selection at the product flavor |
| * // level by configuring another missingDimensionStrategy property |
| * // for the "minApi" dimension. |
| * missingDimensionStrategy 'minApi', 'minApi23' |
| * } |
| * paid { } |
| * } |
| * } |
| * ``` |
| */ |
| fun missingDimensionStrategy(dimension: String, requestedValue: String) { |
| missingDimensionStrategy(dimension, ImmutableList.of(requestedValue)) |
| } |
| |
| /** |
| * Specifies a sorted list of flavors that the plugin should try to use from a given dimension |
| * in a dependency. |
| * |
| * |
| * Android plugin 3.0.0 and higher try to match each variant of your module with the same one |
| * from its dependencies. For example, consider if both your app and its dependencies include a |
| * "tier" [flavor dimension](/studio/build/build-variants.html#flavor-dimensions), |
| * with flavors "free" and "paid". When you build a "freeDebug" version of your app, the plugin |
| * tries to match it with "freeDebug" versions of the local library modules the app depends on. |
| * |
| * |
| * However, there may be situations in which **a library dependency includes a flavor |
| * dimension that your app does not**. For example, consider if a library dependency includes |
| * flavors for a "minApi" dimension, but your app includes flavors for only the "tier" |
| * dimension. So, when you want to build the "freeDebug" version of your app, the plugin doesn't |
| * know whether to use the "minApi23Debug" or "minApi18Debug" version of the dependency, and |
| * you'll see an error message similar to the following: |
| * |
| * ``` |
| * Error:Failed to resolve: Could not resolve project :mylibrary. |
| * Required by: |
| * project :app |
| * ``` |
| * |
| * |
| * In this type of situation, use `missingDimensionStrategy` in the |
| * [`defaultConfig`](com.android.build.gradle.internal.dsl.DefaultConfig.html) |
| * block to specify the default flavor the plugin should select from each missing |
| * dimension, as shown in the sample below. You can also override your selection in the |
| * [`productFlavors`](com.android.build.gradle.internal.dsl.ProductFlavor.html) |
| * block, so each flavor can specify a different matching strategy for a missing dimension. |
| * (Tip: you can also use this property if you simply want to change the matching strategy for a |
| * dimension that exists in both the app and its dependencies.) |
| * |
| * ``` |
| * // In the app's build.gradle file. |
| * android { |
| * defaultConfig { |
| * // Specifies a flavor that the plugin should try to use from |
| * // a given dimension. The following tells the plugin that, when encountering |
| * // a dependency that includes a "minApi" dimension, it should select the |
| * // "minApi18" flavor. |
| * missingDimensionStrategy 'minApi', 'minApi18' |
| * // You should specify a missingDimensionStrategy property for each |
| * // dimension that exists in a local dependency but not in your app. |
| * missingDimensionStrategy 'abi', 'x86' |
| * } |
| * flavorDimensions 'tier' |
| * productFlavors { |
| * free { |
| * dimension 'tier' |
| * // You can override the default selection at the product flavor |
| * // level by configuring another missingDimensionStrategy property |
| * // for the "minApi" dimension. |
| * missingDimensionStrategy 'minApi', 'minApi23' |
| * } |
| * paid { } |
| * } |
| * } |
| * ``` |
| */ |
| fun missingDimensionStrategy(dimension: String, vararg requestedValues: String) { |
| missingDimensionStrategy(dimension, ImmutableList.copyOf(requestedValues)) |
| } |
| |
| /** |
| * Specifies a sorted list of flavors that the plugin should try to use from a given dimension |
| * in a dependency. |
| * |
| * |
| * Android plugin 3.0.0 and higher try to match each variant of your module with the same one |
| * from its dependencies. For example, consider if both your app and its dependencies include a |
| * "tier" [flavor dimension](/studio/build/build-variants.html#flavor-dimensions), |
| * with flavors "free" and "paid". When you build a "freeDebug" version of your app, the plugin |
| * tries to match it with "freeDebug" versions of the local library modules the app depends on. |
| * |
| * |
| * However, there may be situations in which **a library dependency includes a flavor |
| * dimension that your app does not**. For example, consider if a library dependency includes |
| * flavors for a "minApi" dimension, but your app includes flavors for only the "tier" |
| * dimension. So, when you want to build the "freeDebug" version of your app, the plugin doesn't |
| * know whether to use the "minApi23Debug" or "minApi18Debug" version of the dependency, and |
| * you'll see an error message similar to the following: |
| * |
| * ``` |
| * Error:Failed to resolve: Could not resolve project :mylibrary. |
| * Required by: |
| * project :app |
| * ``` |
| * |
| * In this type of situation, use `missingDimensionStrategy` in the |
| * [`defaultConfig`](com.android.build.gradle.internal.dsl.DefaultConfig.html) |
| * block to specify the default flavor the plugin should select from each missing |
| * dimension, as shown in the sample below. You can also override your selection in the |
| * [`productFlavors`](com.android.build.gradle.internal.dsl.ProductFlavor.html) |
| * block, so each flavor can specify a different matching strategy for a missing dimension. |
| * (Tip: you can also use this property if you simply want to change the matching strategy for a |
| * dimension that exists in both the app and its dependencies.) |
| * |
| * ``` |
| * // In the app's build.gradle file. |
| * android { |
| * defaultConfig { |
| * // Specifies a flavor that the plugin should try to use from |
| * // a given dimension. The following tells the plugin that, when encountering |
| * // a dependency that includes a "minApi" dimension, it should select the |
| * // "minApi18" flavor. |
| * missingDimensionStrategy 'minApi', 'minApi18' |
| * // You should specify a missingDimensionStrategy property for each |
| * // dimension that exists in a local dependency but not in your app. |
| * missingDimensionStrategy 'abi', 'x86' |
| * } |
| * flavorDimensions 'tier' |
| * productFlavors { |
| * free { |
| * dimension 'tier' |
| * // You can override the default selection at the product flavor |
| * // level by configuring another missingDimensionStrategy property |
| * // for the "minApi" dimension. |
| * missingDimensionStrategy 'minApi', 'minApi23' |
| * } |
| * paid { } |
| * } |
| * } |
| * ``` |
| */ |
| fun missingDimensionStrategy(dimension: String, requestedValues: List<String>) { |
| if (requestedValues.isEmpty()) { |
| throw RuntimeException("List of requested values cannot be empty") |
| } |
| val selection = computeRequestedAndFallBacks(requestedValues) |
| if (missingDimensionSelections == null) { |
| missingDimensionSelections = Maps.newHashMap() |
| } |
| missingDimensionSelections!![dimension] = selection |
| } |
| |
| /** |
| * Computes the requested value and the fallback list from the list of values provided in the |
| * DSL |
| * |
| * @param requestedValues the values provided in the DSL |
| * @return a DimensionRequest with the main requested value and the fallbacks. |
| */ |
| protected open fun computeRequestedAndFallBacks(requestedValues: List<String>): DimensionRequest { // default implementation is that the fallback's first item is the requested item. |
| return DimensionRequest( |
| requestedValues[0], |
| ImmutableList.copyOf(requestedValues.subList(1, requestedValues.size))) |
| } |
| |
| val missingDimensionStrategies: Map<String, DimensionRequest> |
| get() = missingDimensionSelections ?: ImmutableMap.of() |
| |
| /** |
| * Merges a higher-priority flavor (overlay) on top of this one. |
| * |
| * |
| * The behavior is that if a value is present in the overlay, then it is used, otherwise we |
| * use the existing value. |
| * |
| * @param overlay the higher-priority flavor to apply to this flavor |
| */ |
| protected fun mergeWithHigherPriorityFlavor(overlay: ProductFlavor) { |
| minSdkVersion = chooseNotNull(overlay.minSdkVersion, minSdkVersion) |
| targetSdkVersion = chooseNotNull(overlay.targetSdkVersion, targetSdkVersion) |
| maxSdkVersion = chooseNotNull(overlay.maxSdkVersion, maxSdkVersion) |
| renderscriptTargetApi = chooseNotNull(overlay.renderscriptTargetApi, renderscriptTargetApi) |
| renderscriptSupportModeEnabled = chooseNotNull( |
| overlay.renderscriptSupportModeEnabled, |
| renderscriptSupportModeEnabled) |
| renderscriptSupportModeBlasEnabled = chooseNotNull( |
| overlay.renderscriptSupportModeBlasEnabled, |
| renderscriptSupportModeBlasEnabled) |
| renderscriptNdkModeEnabled = chooseNotNull(overlay.renderscriptNdkModeEnabled, renderscriptNdkModeEnabled) |
| _versionCode = chooseNotNull(overlay.versionCode, versionCode) |
| _versionName = chooseNotNull(overlay.versionName, versionName) |
| versionNameSuffix = mergeVersionNameSuffix(overlay.versionNameSuffix, versionNameSuffix) |
| applicationIdSuffix = mergeApplicationIdSuffix( |
| overlay.applicationIdSuffix, applicationIdSuffix) |
| testApplicationId = chooseNotNull(overlay.testApplicationId, |
| testApplicationId |
| ) |
| testInstrumentationRunner = chooseNotNull(overlay.testInstrumentationRunner, |
| testInstrumentationRunner |
| ) |
| testInstrumentationRunnerArguments.putAll(overlay.testInstrumentationRunnerArguments) |
| testHandleProfiling = chooseNotNull(overlay.testHandleProfiling, |
| testHandleProfiling |
| ) |
| testFunctionalTest = chooseNotNull(overlay.testFunctionalTest, testFunctionalTest) |
| // should this be a copy instead? |
| _signingConfig = chooseNotNull(overlay.signingConfig, signingConfig) |
| wearAppUnbundled = chooseNotNull(overlay.wearAppUnbundled, |
| wearAppUnbundled |
| ) |
| addResourceConfigurations(overlay.resourceConfigurations) |
| addManifestPlaceholders(overlay.manifestPlaceholders) |
| addResValues(overlay.resValues) |
| addBuildConfigFields(overlay.buildConfigFields) |
| multiDexEnabled = chooseNotNull(overlay.multiDexEnabled, multiDexEnabled) |
| multiDexKeepFile = chooseNotNull(overlay.multiDexKeepFile, multiDexKeepFile) |
| multiDexKeepProguard = chooseNotNull(overlay.multiDexKeepProguard, multiDexKeepProguard) |
| vectorDrawables |
| .setGeneratedDensities( |
| chooseNotNull( |
| overlay.vectorDrawables.generatedDensities, |
| vectorDrawables.generatedDensities)) |
| vectorDrawables.useSupportLibrary = chooseNotNull( |
| overlay.vectorDrawables.useSupportLibrary, |
| vectorDrawables.useSupportLibrary) |
| if (overlay is AbstractProductFlavor) { |
| if (missingDimensionSelections == null) { |
| missingDimensionSelections = Maps.newHashMap() |
| } |
| missingDimensionSelections!!.putAll( |
| overlay.missingDimensionStrategies) |
| } |
| // no need to merge missingDimensionStrategies, it's not queried from the merged flavor. |
| // TODO this should all be clean up with the new variant DSL/API in 3.1 |
| } |
| |
| protected fun cloneFrom(flavor: ProductFlavor) { // nothing to do |
| } |
| |
| override fun _initWith(that: BaseConfig) { |
| super._initWith(that) |
| if (that is ProductFlavor) { |
| val thatProductFlavor = that |
| dimension = thatProductFlavor.dimension |
| minSdkVersion = thatProductFlavor.minSdkVersion |
| targetSdkVersion = thatProductFlavor.targetSdkVersion |
| maxSdkVersion = thatProductFlavor.maxSdkVersion |
| renderscriptTargetApi = thatProductFlavor.renderscriptTargetApi |
| renderscriptSupportModeEnabled = thatProductFlavor.renderscriptSupportModeEnabled |
| renderscriptSupportModeBlasEnabled = thatProductFlavor.renderscriptSupportModeBlasEnabled |
| renderscriptNdkModeEnabled = thatProductFlavor.renderscriptNdkModeEnabled |
| _versionCode = thatProductFlavor.versionCode |
| _versionName = thatProductFlavor.versionName |
| versionNameSuffix = thatProductFlavor.versionNameSuffix |
| testApplicationId = thatProductFlavor.testApplicationId |
| testInstrumentationRunner = thatProductFlavor.testInstrumentationRunner |
| testInstrumentationRunnerArguments.clear() |
| testInstrumentationRunnerArguments.putAll(thatProductFlavor.testInstrumentationRunnerArguments) |
| testHandleProfiling = thatProductFlavor.testHandleProfiling |
| testFunctionalTest = thatProductFlavor.testFunctionalTest |
| // should this be a copy instead? |
| _signingConfig = thatProductFlavor.signingConfig |
| wearAppUnbundled = thatProductFlavor.wearAppUnbundled |
| addResourceConfigurations(thatProductFlavor.resourceConfigurations) |
| addManifestPlaceholders(thatProductFlavor.manifestPlaceholders) |
| addResValues(thatProductFlavor.resValues) |
| addBuildConfigFields(thatProductFlavor.buildConfigFields) |
| multiDexEnabled = thatProductFlavor.multiDexEnabled |
| multiDexKeepFile = thatProductFlavor.multiDexKeepFile |
| multiDexKeepProguard = thatProductFlavor.multiDexKeepProguard |
| } |
| if (that is AbstractProductFlavor) { |
| // the objects inside the map are immutable, so it's fine to keep them. |
| missingDimensionSelections = Maps.newHashMap(that.missingDimensionStrategies) |
| } |
| } |
| |
| override fun toString(): String { |
| return MoreObjects.toStringHelper(this) |
| .add("name", name) |
| .add("dimension", dimension) |
| .add("minSdkVersion", minSdkVersion) |
| .add("targetSdkVersion", targetSdkVersion) |
| .add("renderscriptTargetApi", renderscriptTargetApi) |
| .add("renderscriptSupportModeEnabled", renderscriptSupportModeEnabled) |
| .add("renderscriptSupportModeBlasEnabled", renderscriptSupportModeBlasEnabled) |
| .add("renderscriptNdkModeEnabled", renderscriptNdkModeEnabled) |
| .add("versionCode", versionCode) |
| .add("versionName", versionName) |
| .add("applicationId", applicationId) |
| .add("testApplicationId", testApplicationId) |
| .add("testInstrumentationRunner", |
| testInstrumentationRunner |
| ) |
| .add("testInstrumentationRunnerArguments", |
| testInstrumentationRunnerArguments |
| ) |
| .add("testHandleProfiling", testHandleProfiling) |
| .add("testFunctionalTest", testFunctionalTest) |
| .add("signingConfig", signingConfig) |
| .add("resConfig", resourceConfigurations) |
| .add("buildConfigFields", buildConfigFields) |
| .add("resValues", resValues) |
| .add("proguardFiles", proguardFiles) |
| .add("consumerProguardFiles", consumerProguardFiles) |
| .add("manifestPlaceholders", manifestPlaceholders) |
| .add("wearAppUnbundled", wearAppUnbundled) |
| .toString() |
| } |
| |
| companion object { |
| private const val serialVersionUID = 1L |
| protected fun <T> chooseNotNull(overlay: T?, base: T): T { |
| return overlay ?: base |
| } |
| |
| @JvmStatic |
| fun mergeApplicationIdSuffix(overlay: String?, base: String?): String { |
| return Strings.nullToEmpty(joinWithSeparator(overlay, base, '.')) |
| } |
| |
| @JvmStatic |
| fun mergeVersionNameSuffix(overlay: String?, base: String?): String { |
| return Strings.nullToEmpty(joinWithSeparator(overlay, base, null)) |
| } |
| |
| private fun joinWithSeparator( |
| overlay: String?, |
| base: String?, |
| separator: Char? |
| ): String? { |
| return if (!Strings.isNullOrEmpty(overlay)) { |
| val baseSuffix = chooseNotNull<String?>(base, "") |
| if (separator == null || overlay!![0] == separator) { |
| baseSuffix + overlay |
| } else { |
| baseSuffix + separator + overlay |
| } |
| } else { |
| base |
| } |
| } |
| } |
| } |
