/*
* 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 static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;
import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.annotations.VisibleForTesting;
import com.android.builder.dependency.DependencyContainer;
import com.android.builder.dependency.JarDependency;
import com.android.builder.dependency.LibraryDependency;
import com.android.builder.model.ApiVersion;
import com.android.builder.model.BuildType;
import com.android.builder.model.ClassField;
import com.android.builder.model.ProductFlavor;
import com.android.builder.model.SigningConfig;
import com.android.builder.model.SourceProvider;
import com.android.ide.common.res2.AssetSet;
import com.android.ide.common.res2.ResourceSet;
import com.android.utils.StringHelper;
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import java.io.File;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* A Variant configuration.
*
* Variants are made from the combination of:
*
* - a build type (base interface BuildType), and its associated sources.
* - a default configuration (base interface ProductFlavor), and its associated sources.
* - a optional list of product flavors (base interface ProductFlavor) and their associated sources.
* - dependencies (both jar and aar).
*
* @param <T> the type used for the Build Type.
* @param <D> the type used for the default config
* @param <F> the type used for the product flavors.
*/
public class VariantConfiguration<T extends BuildType, D extends ProductFlavor, F extends ProductFlavor> {
// per variant, as is caches some manifest data specific to this variant.
private final ManifestParser sManifestParser = new DefaultManifestParser();
/**
* Full, unique name of the variant in camel case, including BuildType and Flavors (and Test)
*/
private String mFullName;
/**
* Flavor Name of the variant, including all flavors in camel case (starting with a lower
* case).
*/
private String mFlavorName;
/**
* Full, unique name of the variant, including BuildType, flavors and test, dash separated.
* (similar to full name but with dashes)
*/
private String mBaseName;
/**
* 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.
*
*/
private String mDirName;
@NonNull
private final D mDefaultConfig;
@NonNull
private final SourceProvider mDefaultSourceProvider;
@NonNull
private final T mBuildType;
/** SourceProvider for the BuildType. Can be null */
@Nullable
private final SourceProvider mBuildTypeSourceProvider;
private final List<String> mFlavorDimensionNames = Lists.newArrayList();
private final List<F> mFlavors = Lists.newArrayList();
private final List<SourceProvider> mFlavorSourceProviders = Lists.newArrayList();
/** Variant specific source provider, may be null */
@Nullable
private SourceProvider mVariantSourceProvider;
/** MultiFlavors specific source provider, may be null */
@Nullable
private SourceProvider mMultiFlavorSourceProvider;
@NonNull
private final VariantType mType;
/**
* Optional tested config in case this variant is used for testing another variant.
*
* @see VariantType#isForTesting()
*/
private final VariantConfiguration mTestedConfig;
/**
* An optional output that is only valid if the type is Type#LIBRARY so that the test
* for the library can use the library as if it was a normal dependency.
*/
private LibraryDependency mOutput;
@NonNull
private ProductFlavor mMergedFlavor;
/**
* External/Jar dependencies.
*/
private final Set<JarDependency> mExternalJars = Sets.newHashSet();
/**
* Local Jar dependencies.
*/
private final Set<JarDependency> mLocalJars = Sets.newHashSet();
/**
* List of direct library dependencies. Each object defines its own dependencies.
*/
private final List<LibraryDependency> mDirectLibraries = Lists.newArrayList();
/**
* List of all library dependencies in a flat list.
*
* <p>The order is based on the order needed to call aapt: earlier libraries override resources
* of latter ones.
*/
private final List<LibraryDependency> mFlatLibraries = Lists.newArrayList();
/**
* Variant-specific build Config fields.
*/
private final Map<String, ClassField> mBuildConfigFields = Maps.newTreeMap();
/**
* Variant-specific res values.
*/
private final Map<String, ClassField> mResValues = Maps.newTreeMap();
/**
* Signing Override to be used instead of any signing config provided by Build Type or
* Product Flavors.
*/
private final SigningConfig mSigningConfigOverride;
/**
* Parses the manifest file and return the package name.
* @param manifestFile the manifest file
* @return the package name found or null
*/
@Nullable
public static String getManifestPackage(@NonNull File manifestFile) {
return new DefaultManifestParser().getPackage(manifestFile);
}
/**
* Creates the configuration with the base source sets for a given {@link VariantType}. Meant
* for non-testing variants.
*
* @param defaultConfig the default configuration. Required.
* @param defaultSourceProvider the default source provider. Required
* @param buildType the build type for this variant. Required.
* @param buildTypeSourceProvider the source provider for the build type.
* @param type the type of the project.
* @param signingConfigOverride an optional Signing override to be used for signing.
*/
public VariantConfiguration(
@NonNull D defaultConfig,
@NonNull SourceProvider defaultSourceProvider,
@NonNull T buildType,
@Nullable SourceProvider buildTypeSourceProvider,
@NonNull VariantType type,
@Nullable SigningConfig signingConfigOverride) {
this(
defaultConfig, defaultSourceProvider,
buildType, buildTypeSourceProvider,
type, null /*testedConfig*/, signingConfigOverride);
}
/**
* Creates the configuration with the base source sets, and an optional tested variant.
*
* @param defaultConfig the default configuration. Required.
* @param defaultSourceProvider the default source provider. Required
* @param buildType the build type for this variant. Required.
* @param buildTypeSourceProvider the source provider for the build type.
* @param type the type of the project.
* @param testedConfig the reference to the tested project. Required if type is Type.ANDROID_TEST
* @param signingConfigOverride an optional Signing override to be used for signing.
*/
public VariantConfiguration(
@NonNull D defaultConfig,
@NonNull SourceProvider defaultSourceProvider,
@NonNull T buildType,
@Nullable SourceProvider buildTypeSourceProvider,
@NonNull VariantType type,
@Nullable VariantConfiguration testedConfig,
@Nullable SigningConfig signingConfigOverride) {
checkNotNull(defaultConfig);
checkNotNull(defaultSourceProvider);
checkNotNull(buildType);
checkNotNull(type);
checkArgument(
!type.isForTesting() || testedConfig != null,
"You have to specify the tested variant for this variant type.");
checkArgument(
type.isForTesting() || testedConfig == null,
"This variant type doesn't need a tested variant.");
mDefaultConfig = checkNotNull(defaultConfig);
mDefaultSourceProvider = checkNotNull(defaultSourceProvider);
mBuildType = checkNotNull(buildType);
mBuildTypeSourceProvider = buildTypeSourceProvider;
mType = checkNotNull(type);
mTestedConfig = testedConfig;
mSigningConfigOverride = signingConfigOverride;
mMergedFlavor = DefaultProductFlavor.clone(mDefaultConfig);
}
/**
* Returns the full, unique name of the variant in camel case (starting with a lower case),
* including BuildType, Flavors and Test (if applicable).
*
* @return the name of the variant
*/
@NonNull
public String getFullName() {
if (mFullName == null) {
StringBuilder sb = new StringBuilder();
String flavorName = getFlavorName();
if (!flavorName.isEmpty()) {
sb.append(flavorName);
sb.append(StringHelper.capitalize(mBuildType.getName()));
} else {
sb.append(mBuildType.getName());
}
if (mType.isForTesting()) {
sb.append(mType.getSuffix());
}
mFullName = sb.toString();
}
return mFullName;
}
/**
* 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.
*/
@NonNull
public String computeFullNameWithSplits(@NonNull String splitName) {
StringBuilder sb = new StringBuilder();
String flavorName = getFlavorName();
if (!flavorName.isEmpty()) {
sb.append(flavorName);
sb.append(StringHelper.capitalize(splitName));
} else {
sb.append(splitName);
}
sb.append(StringHelper.capitalize(mBuildType.getName()));
if (mType.isForTesting()) {
sb.append(mType.getSuffix());
}
return sb.toString();
}
/**
* Returns the flavor name of the variant, including all flavors in camel case (starting
* with a lower case). If the variant has no flavor, then an empty string is returned.
*
* @return the flavor name or an empty string.
*/
@NonNull
public String getFlavorName() {
if (mFlavorName == null) {
if (mFlavors.isEmpty()) {
mFlavorName = "";
} else {
StringBuilder sb = new StringBuilder();
boolean first = true;
for (F flavor : mFlavors) {
sb.append(first ? flavor.getName() : StringHelper.capitalize(flavor.getName()));
first = false;
}
mFlavorName = sb.toString();
}
}
return mFlavorName;
}
/**
* 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
*/
@NonNull
public String getBaseName() {
if (mBaseName == null) {
StringBuilder sb = new StringBuilder();
if (!mFlavors.isEmpty()) {
for (ProductFlavor pf : mFlavors) {
sb.append(pf.getName()).append('-');
}
}
sb.append(mBuildType.getName());
if (mType.isForTesting()) {
sb.append('-').append(mType.getPrefix());
}
mBaseName = sb.toString();
}
return mBaseName;
}
/**
* 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.
*/
@NonNull
public String computeBaseNameWithSplits(@NonNull String splitName) {
StringBuilder sb = new StringBuilder();
if (!mFlavors.isEmpty()) {
for (ProductFlavor pf : mFlavors) {
sb.append(pf.getName()).append('-');
}
}
sb.append(splitName).append('-');
sb.append(mBuildType.getName());
if (mType.isForTesting()) {
sb.append('-').append(mType.getPrefix());
}
return sb.toString();
}
/**
* Returns a unique directory name (can include multiple folders) for the variant,
* based on build type, flavor and test.
*
* <p>This always uses forward slashes ('/') as separator on all platform.
*
* @return the directory name for the variant
*/
@NonNull
public String getDirName() {
if (mDirName == null) {
StringBuilder sb = new StringBuilder();
if (mType.isForTesting()) {
sb.append(mType.getPrefix()).append("/");
}
if (!mFlavors.isEmpty()) {
boolean first = true;
for (F flavor : mFlavors) {
sb.append(first ? flavor.getName() : StringHelper.capitalize(flavor.getName()));
first = false;
}
sb.append('/').append(mBuildType.getName());
} else {
sb.append(mBuildType.getName());
}
mDirName = sb.toString();
}
return mDirName;
}
/**
* Returns a unique directory name (can include multiple folders) for the variant,
* based on build type, flavor and test, and splits.
*
* <p>This always uses forward slashes ('/') as separator on all platform.
*
* @return the directory name for the variant
*/
@NonNull
public String computeDirNameWithSplits(@NonNull String... splitNames) {
StringBuilder sb = new StringBuilder();
if (mType.isForTesting()) {
sb.append(mType.getPrefix()).append("/");
}
if (!mFlavors.isEmpty()) {
for (F flavor : mFlavors) {
sb.append(flavor.getName());
}
sb.append('/');
}
for (String splitName : splitNames) {
if (splitName != null) {
sb.append(splitName).append('/');
}
}
sb.append(mBuildType.getName());
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.
*/
@NonNull
public List<String> getFlavorNamesWithDimensionNames() {
if (mFlavors.isEmpty()) {
return Collections.emptyList();
}
List<String> names;
int count = mFlavors.size();
if (count > 1) {
names = Lists.newArrayListWithCapacity(count * 2);
for (int i = 0 ; i < count ; i++) {
names.add(mFlavors.get(i).getName());
names.add(mFlavorDimensionNames.get(i));
}
} else {
names = Collections.singletonList(mFlavors.get(0).getName());
}
return names;
}
/**
* Add a new configured ProductFlavor.
*
* If multiple flavors are added, the priority follows the order they are added when it
* comes to resolving Android resources overlays (ie earlier added flavors supersedes
* latter added ones).
*
* @param productFlavor the configured product flavor
* @param sourceProvider the source provider for the product flavor
* @param dimensionName the name of the dimension associated with the flavor
*
* @return the config object
*/
@NonNull
public VariantConfiguration addProductFlavor(
@NonNull F productFlavor,
@NonNull SourceProvider sourceProvider,
@NonNull String dimensionName) {
mFlavors.add(productFlavor);
mFlavorSourceProviders.add(sourceProvider);
mFlavorDimensionNames.add(dimensionName);
mMergedFlavor = DefaultProductFlavor.mergeFlavors(mMergedFlavor, productFlavor);
return this;
}
/**
* Sets the variant-specific source provider.
* @param sourceProvider the source provider for the product flavor
*
* @return the config object
*/
public VariantConfiguration setVariantSourceProvider(@Nullable SourceProvider sourceProvider) {
mVariantSourceProvider = sourceProvider;
return this;
}
/**
* Sets the variant-specific source provider.
* @param sourceProvider the source provider for the product flavor
*
* @return the config object
*/
public VariantConfiguration setMultiFlavorSourceProvider(@Nullable SourceProvider sourceProvider) {
mMultiFlavorSourceProvider = sourceProvider;
return this;
}
/**
* Returns the variant specific source provider
* @return the source provider or null if none has been provided.
*/
@Nullable
public SourceProvider getVariantSourceProvider() {
return mVariantSourceProvider;
}
@Nullable
public SourceProvider getMultiFlavorSourceProvider() {
return mMultiFlavorSourceProvider;
}
/**
* Sets the dependencies
*
* @param container a DependencyContainer.
* @return the config object
*/
@NonNull
public VariantConfiguration setDependencies(@NonNull DependencyContainer container) {
// Output of mTestedConfig will not be initialized until the tasks for the tested config are
// created. If library output has never been added to mDirectLibraries, checked the output
// of the mTestedConfig to see if the tasks are now created.
if (mTestedConfig != null &&
mTestedConfig.mType == VariantType.LIBRARY &&
mTestedConfig.mOutput != null &&
!mDirectLibraries.contains(mTestedConfig.mOutput)) {
mDirectLibraries.add(mTestedConfig.mOutput);
}
mDirectLibraries.addAll(container.getAndroidDependencies());
mExternalJars.addAll(container.getJarDependencies());
mLocalJars.addAll(container.getLocalDependencies());
resolveIndirectLibraryDependencies(mDirectLibraries, mFlatLibraries);
return this;
}
/**
* Returns the list of external/module jar dependencies
* @return a non null collection of Jar dependencies.
*/
@NonNull
public Collection<JarDependency> getExternalJarDependencies() {
return mExternalJars;
}
/**
* Returns the list of local jar dependencies
* @return a non null collection of Jar dependencies.
*/
@NonNull
public Collection<JarDependency> getLocalJarDependencies() {
return mLocalJars;
}
/**
* Sets the output of this variant. This is required when the variant is a library so that
* the variant that tests this library can properly include the tested library in its own
* package.
*
* @param output the output of the library as an LibraryDependency that will provides the
* location of all the created items.
* @return the config object
*/
@NonNull
public VariantConfiguration setOutput(LibraryDependency output) {
mOutput = output;
return this;
}
/**
* Returns the {@link LibraryDependency} that this library variant produces. Used so that
* related test variants can use it as a dependency. Returns null if this is not a library
* variant.
*
* @see #mOutput
*/
@Nullable
public LibraryDependency getOutput() {
return mOutput;
}
@NonNull
public D getDefaultConfig() {
return mDefaultConfig;
}
@NonNull
public SourceProvider getDefaultSourceSet() {
return mDefaultSourceProvider;
}
@NonNull
public ProductFlavor getMergedFlavor() {
return mMergedFlavor;
}
@NonNull
public T getBuildType() {
return mBuildType;
}
/**
* The SourceProvider for the BuildType. Can be null.
*/
@Nullable
public SourceProvider getBuildTypeSourceSet() {
return mBuildTypeSourceProvider;
}
public boolean hasFlavors() {
return !mFlavors.isEmpty();
}
/**
* Returns the product flavors. Items earlier in the list override later items.
*/
@NonNull
public List<F> getProductFlavors() {
return mFlavors;
}
/**
* Returns the list of SourceProviders for the flavors.
*
* The list is ordered from higher priority to lower priority.
*
* @return the list of Source Providers for the flavors. Never null.
*/
@NonNull
public List<SourceProvider> getFlavorSourceProviders() {
return mFlavorSourceProviders;
}
/**
* Returns the direct library dependencies
*/
@NonNull
public List<LibraryDependency> getDirectLibraries() {
return mDirectLibraries;
}
/**
* Returns all the library dependencies, direct and transitive.
*/
@NonNull
public List<LibraryDependency> getAllLibraries() {
return mFlatLibraries;
}
@NonNull
public VariantType getType() {
return mType;
}
@Nullable
public VariantConfiguration getTestedConfig() {
return mTestedConfig;
}
/**
* Resolves a given list of libraries, finds out if they depend on other libraries, and
* returns a flat list of all the direct and indirect dependencies in the proper order (first
* is higher priority when calling aapt).
* @param directDependencies the libraries to resolve
* @param outFlatDependencies where to store all the libraries.
*/
@VisibleForTesting
static void resolveIndirectLibraryDependencies(List<LibraryDependency> directDependencies,
List<LibraryDependency> outFlatDependencies) {
if (directDependencies == null) {
return;
}
// loop in the inverse order to resolve dependencies on the libraries, so that if a library
// is required by two higher level libraries it can be inserted in the correct place
for (int i = directDependencies.size() - 1 ; i >= 0 ; i--) {
LibraryDependency library = directDependencies.get(i);
// get its libraries
Collection<LibraryDependency> dependencies = library.getDependencies();
List<LibraryDependency> depList = Lists.newArrayList(dependencies);
// resolve the dependencies for those libraries
resolveIndirectLibraryDependencies(depList, outFlatDependencies);
// and add the current one (if needed) in front (higher priority)
if (!outFlatDependencies.contains(library)) {
outFlatDependencies.add(0, library);
}
}
}
/**
* Returns the original application ID before any overrides from flavors.
* If the variant is a test variant, then the application ID is the one coming from the
* configuration of the tested variant, and this call is similar to {@link #getApplicationId()}
* @return the original application ID
*/
@Nullable
public String getOriginalApplicationId() {
if (mType.isForTesting()) {
return getApplicationId();
}
return getPackageFromManifest();
}
/**
* 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
*/
@NonNull
public String getApplicationId() {
String id;
if (mType.isForTesting()) {
checkState(mTestedConfig != null);
id = mMergedFlavor.getTestApplicationId();
String testedPackage = mTestedConfig.getApplicationId();
if (id == null) {
id = testedPackage + ".test";
} else {
if (id.equals(testedPackage)) {
throw new RuntimeException(String.format("Application and test application id "
+ "cannot be the same: both are '%s' for %s",
id, getFullName()));
}
}
} else {
// first get package override.
id = getIdOverride();
// if it's null, this means we just need the default package
// from the manifest since both flavor and build type do nothing.
if (id == null) {
id = getPackageFromManifest();
}
}
if (id == null) {
throw new RuntimeException("Failed to get application id for " + getFullName());
}
return id;
}
@Nullable
public String getTestedApplicationId() {
if (mType.isForTesting()) {
checkState(mTestedConfig != null);
if (mTestedConfig.mType == VariantType.LIBRARY) {
return getApplicationId();
} else {
return mTestedConfig.getApplicationId();
}
}
return null;
}
/**
* Returns the application id override value coming from the Product Flavor and/or the
* Build Type. If the package/id is not overridden then this returns null.
*
* @return the id override or null
*/
@Nullable
public String getIdOverride() {
String idName = mMergedFlavor.getApplicationId();
String idSuffix = mBuildType.getApplicationIdSuffix();
if (idSuffix != null && !idSuffix.isEmpty()) {
if (idName == null) {
idName = getPackageFromManifest();
}
if (idSuffix.charAt(0) == '.') {
idName = idName + idSuffix;
} else {
idName = idName + '.' + idSuffix;
}
}
return idName;
}
/**
* Returns the version name for this variant. This could be coming from the manifest or
* could be overridden through the product flavors, and can have a suffix specified by
* the build type.
*
* @return the version name
*/
@Nullable
public String getVersionName() {
String versionName = mMergedFlavor.getVersionName();
String versionSuffix = mBuildType.getVersionNameSuffix();
if (versionName == null && !mType.isForTesting()) {
versionName = getVersionNameFromManifest();
}
if (versionSuffix != null && !versionSuffix.isEmpty()) {
versionName = Strings.nullToEmpty(versionName) + versionSuffix;
}
return versionName;
}
/**
* Returns the version code for this variant. This could be coming from the manifest or
* could be overridden through the product flavors, and can have a suffix specified by
* the build type.
*
* @return the version code or -1 if there was non defined.
*/
public int getVersionCode() {
int versionCode = mMergedFlavor.getVersionCode() != null ?
mMergedFlavor.getVersionCode() : -1;
if (versionCode == -1 && !mType.isForTesting()) {
versionCode = getVersionCodeFromManifest();
}
return versionCode;
}
private static final String DEFAULT_TEST_RUNNER = "android.test.InstrumentationTestRunner";
private static final Boolean DEFAULT_HANDLE_PROFILING = false;
private static final Boolean DEFAULT_FUNCTIONAL_TEST = false;
/**
* Returns the instrumentationRunner to use to test this variant, or if the
* variant is a test, the one to use to test the tested variant.
* @return the instrumentation test runner name
*/
@NonNull
public String getInstrumentationRunner() {
VariantConfiguration config = this;
if (mType.isForTesting()) {
config = getTestedConfig();
checkState(config != null);
}
String runner = config.mMergedFlavor.getTestInstrumentationRunner();
return runner != null ? runner : 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
*/
@NonNull
public Map<String, String> getInstrumentationRunnerArguments() {
VariantConfiguration config = this;
if (mType.isForTesting()) {
config = getTestedConfig();
checkState(config != null);
}
return config.mMergedFlavor.getTestInstrumentationRunnerArguments();
}
/**
* Returns handleProfiling value to use to test this variant, or if the
* variant is a test, the one to use to test the tested variant.
* @return the handleProfiling value
*/
@NonNull
public Boolean getHandleProfiling() {
VariantConfiguration config = this;
if (mType.isForTesting()) {
config = getTestedConfig();
checkState(config != null);
}
Boolean handleProfiling = config.mMergedFlavor.getTestHandleProfiling();
return handleProfiling != null ? handleProfiling : DEFAULT_HANDLE_PROFILING;
}
/**
* Returns functionalTest value to use to test this variant, or if the
* variant is a test, the one to use to test the tested variant.
* @return the functionalTest value
*/
@NonNull
public Boolean getFunctionalTest() {
VariantConfiguration config = this;
if (mType.isForTesting()) {
config = getTestedConfig();
checkState(config != null);
}
Boolean functionalTest = config.mMergedFlavor.getTestFunctionalTest();
return functionalTest != null ? functionalTest : DEFAULT_FUNCTIONAL_TEST;
}
/**
* Reads the package name from the manifest. This is unmodified by the build type.
*/
@Nullable
public String getPackageFromManifest() {
checkState(!mType.isForTesting());
File manifestLocation = mDefaultSourceProvider.getManifestFile();
String packageName = sManifestParser.getPackage(manifestLocation);
if (packageName == null) {
throw new RuntimeException(String.format("Cannot read packageName from %1$s",
mDefaultSourceProvider.getManifestFile().getAbsolutePath()));
}
return packageName;
}
/**
* Reads the version name from the manifest.
*/
@Nullable
public String getVersionNameFromManifest() {
File manifestLocation = mDefaultSourceProvider.getManifestFile();
return sManifestParser.getVersionName(manifestLocation);
}
/**
* Reads the version code from the manifest.
*/
public int getVersionCodeFromManifest() {
File manifestLocation = mDefaultSourceProvider.getManifestFile();
return sManifestParser.getVersionCode(manifestLocation);
}
/**
* 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
*/
@NonNull
public ApiVersion getMinSdkVersion() {
if (mTestedConfig != null) {
return mTestedConfig.getMinSdkVersion();
}
ApiVersion minSdkVersion = mMergedFlavor.getMinSdkVersion();
if (minSdkVersion == null) {
// read it from the main manifest
File manifestLocation = mDefaultSourceProvider.getManifestFile();
minSdkVersion = DefaultApiVersion.create(
sManifestParser.getMinSdkVersion(manifestLocation));
}
return minSdkVersion;
}
/**
* 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
*/
@NonNull
public ApiVersion getTargetSdkVersion() {
if (mTestedConfig != null) {
return mTestedConfig.getTargetSdkVersion();
}
ApiVersion targetSdkVersion = mMergedFlavor.getTargetSdkVersion();
if (targetSdkVersion == null) {
// read it from the main manifest
File manifestLocation = mDefaultSourceProvider.getManifestFile();
targetSdkVersion = DefaultApiVersion.create(
sManifestParser.getTargetSdkVersion(manifestLocation));
}
return targetSdkVersion;
}
@Nullable
public File getMainManifest() {
File defaultManifest = mDefaultSourceProvider.getManifestFile();
// this could not exist in a test project.
if (defaultManifest.isFile()) {
return defaultManifest;
}
return null;
}
/**
* Returns a list of sorted SourceProvider in order of ascending order, meaning, the earlier
* items are meant to be overridden by later items.
*
* @return a list of source provider
*/
@NonNull
public List<SourceProvider> getSortedSourceProviders() {
List<SourceProvider> providers = Lists.newArrayList();
// first the default source provider
providers.add(mDefaultSourceProvider);
// the list of flavor must be reversed to use the right overlay order.
for (int n = mFlavorSourceProviders.size() - 1; n >= 0 ; n--) {
providers.add(mFlavorSourceProviders.get(n));
}
// multiflavor specific overrides flavor
if (mMultiFlavorSourceProvider != null) {
providers.add(mMultiFlavorSourceProvider);
}
// build type overrides flavors
if (mBuildTypeSourceProvider != null) {
providers.add(mBuildTypeSourceProvider);
}
// variant specific overrides all
if (mVariantSourceProvider != null) {
providers.add(mVariantSourceProvider);
}
return providers;
}
@NonNull
public List<File> getManifestOverlays() {
List<File> inputs = Lists.newArrayList();
if (mVariantSourceProvider != null) {
File variantLocation = mVariantSourceProvider.getManifestFile();
if (variantLocation.isFile()) {
inputs.add(variantLocation);
}
}
if (mBuildTypeSourceProvider != null) {
File typeLocation = mBuildTypeSourceProvider.getManifestFile();
if (typeLocation.isFile()) {
inputs.add(typeLocation);
}
}
if (mMultiFlavorSourceProvider != null) {
File variantLocation = mMultiFlavorSourceProvider.getManifestFile();
if (variantLocation.isFile()) {
inputs.add(variantLocation);
}
}
for (SourceProvider sourceProvider : mFlavorSourceProviders) {
File f = sourceProvider.getManifestFile();
if (f.isFile()) {
inputs.add(f);
}
}
return inputs;
}
/**
* Returns the dynamic list of {@link ResourceSet} based on the configuration, its dependencies,
* as well as tested config if applicable (test of a library).
*
* The list is ordered in ascending order of importance, meaning the first set is meant to be
* overridden by the 2nd one and so on. This is meant to facilitate usage of the list in a
* {@link com.android.ide.common.res2.ResourceMerger}.
*
* @param generatedResFolders a list of generated res folders
* @param includeDependencies whether to include in the result the resources of the dependencies
*
* @return a list ResourceSet.
*/
@NonNull
public List<ResourceSet> getResourceSets(@NonNull List<File> generatedResFolders,
boolean includeDependencies) {
List<ResourceSet> resourceSets = Lists.newArrayList();
// the list of dependency must be reversed to use the right overlay order.
if (includeDependencies) {
for (int n = mFlatLibraries.size() - 1 ; n >= 0 ; n--) {
LibraryDependency dependency = mFlatLibraries.get(n);
if (!dependency.isOptional()) {
File resFolder = dependency.getResFolder();
if (resFolder.isDirectory()) {
ResourceSet resourceSet = new ResourceSet(dependency.getFolder().getName());
resourceSet.addSource(resFolder);
resourceSets.add(resourceSet);
}
}
}
}
Collection<File> mainResDirs = mDefaultSourceProvider.getResDirectories();
// the main + generated res folders are in the same ResourceSet
ResourceSet resourceSet = new ResourceSet(BuilderConstants.MAIN);
resourceSet.addSources(mainResDirs);
if (!generatedResFolders.isEmpty()) {
for (File generatedResFolder : generatedResFolders) {
resourceSet.addSource(generatedResFolder);
}
}
resourceSets.add(resourceSet);
// the list of flavor must be reversed to use the right overlay order.
for (int n = mFlavorSourceProviders.size() - 1; n >= 0 ; n--) {
SourceProvider sourceProvider = mFlavorSourceProviders.get(n);
Collection<File> flavorResDirs = sourceProvider.getResDirectories();
// we need the same of the flavor config, but it's in a different list.
// This is fine as both list are parallel collections with the same number of items.
resourceSet = new ResourceSet(sourceProvider.getName());
resourceSet.addSources(flavorResDirs);
resourceSets.add(resourceSet);
}
// multiflavor specific overrides flavor
if (mMultiFlavorSourceProvider != null) {
Collection<File> variantResDirs = mMultiFlavorSourceProvider.getResDirectories();
resourceSet = new ResourceSet(getFlavorName());
resourceSet.addSources(variantResDirs);
resourceSets.add(resourceSet);
}
// build type overrides the flavors
if (mBuildTypeSourceProvider != null) {
Collection<File> typeResDirs = mBuildTypeSourceProvider.getResDirectories();
resourceSet = new ResourceSet(mBuildType.getName());
resourceSet.addSources(typeResDirs);
resourceSets.add(resourceSet);
}
// variant specific overrides all
if (mVariantSourceProvider != null) {
Collection<File> variantResDirs = mVariantSourceProvider.getResDirectories();
resourceSet = new ResourceSet(getFullName());
resourceSet.addSources(variantResDirs);
resourceSets.add(resourceSet);
}
return resourceSets;
}
/**
* Returns the dynamic list of {@link AssetSet} based on the configuration, its dependencies,
* as well as tested config if applicable (test of a library).
*
* The list is ordered in ascending order of importance, meaning the first set is meant to be
* overridden by the 2nd one and so on. This is meant to facilitate usage of the list in a
* {@link com.android.ide.common.res2.AssetMerger}.
*
* @return a list ResourceSet.
*/
@NonNull
public List<AssetSet> getAssetSets(@NonNull List<File> generatedResFolders,
boolean includeDependencies) {
List<AssetSet> assetSets = Lists.newArrayList();
if (includeDependencies) {
// the list of dependency must be reversed to use the right overlay order.
for (int n = mFlatLibraries.size() - 1 ; n >= 0 ; n--) {
LibraryDependency dependency = mFlatLibraries.get(n);
File assetFolder = dependency.getAssetsFolder();
if (assetFolder.isDirectory()) {
AssetSet assetSet = new AssetSet(dependency.getFolder().getName());
assetSet.addSource(assetFolder);
assetSets.add(assetSet);
}
}
}
Collection<File> mainResDirs = mDefaultSourceProvider.getAssetsDirectories();
// the main + generated asset folders are in the same AssetSet
AssetSet assetSet = new AssetSet(BuilderConstants.MAIN);
assetSet.addSources(mainResDirs);
if (!generatedResFolders.isEmpty()) {
for (File generatedResFolder : generatedResFolders) {
assetSet.addSource(generatedResFolder);
}
}
assetSets.add(assetSet);
// the list of flavor must be reversed to use the right overlay order.
for (int n = mFlavorSourceProviders.size() - 1; n >= 0 ; n--) {
SourceProvider sourceProvider = mFlavorSourceProviders.get(n);
Collection<File> flavorResDirs = sourceProvider.getAssetsDirectories();
// we need the same of the flavor config, but it's in a different list.
// This is fine as both list are parallel collections with the same number of items.
assetSet = new AssetSet(mFlavors.get(n).getName());
assetSet.addSources(flavorResDirs);
assetSets.add(assetSet);
}
// multiflavor specific overrides flavor
if (mMultiFlavorSourceProvider != null) {
Collection<File> variantResDirs = mMultiFlavorSourceProvider.getAssetsDirectories();
assetSet = new AssetSet(getFlavorName());
assetSet.addSources(variantResDirs);
assetSets.add(assetSet);
}
// build type overrides flavors
if (mBuildTypeSourceProvider != null) {
Collection<File> typeResDirs = mBuildTypeSourceProvider.getAssetsDirectories();
assetSet = new AssetSet(mBuildType.getName());
assetSet.addSources(typeResDirs);
assetSets.add(assetSet);
}
// variant specific overrides all
if (mVariantSourceProvider != null) {
Collection<File> variantResDirs = mVariantSourceProvider.getAssetsDirectories();
assetSet = new AssetSet(getFullName());
assetSet.addSources(variantResDirs);
assetSets.add(assetSet);
}
return assetSets;
}
@NonNull
public List<File> getLibraryJniFolders() {
List<File> list = Lists.newArrayListWithExpectedSize(mFlatLibraries.size());
for (int n = mFlatLibraries.size() - 1 ; n >= 0 ; n--) {
LibraryDependency dependency = mFlatLibraries.get(n);
File jniFolder = dependency.getJniFolder();
if (jniFolder.isDirectory()) {
list.add(jniFolder);
}
}
return list;
}
/**
* Returns all the renderscript import folder that are outside of the current project.
*/
@NonNull
public List<File> getRenderscriptImports() {
List<File> list = Lists.newArrayList();
for (LibraryDependency lib : mFlatLibraries) {
File rsLib = lib.getRenderscriptFolder();
if (rsLib.isDirectory()) {
list.add(rsLib);
}
}
return list;
}
/**
* Returns all the renderscript source folder from the main config, the flavors and the
* build type.
*
* @return a list of folders.
*/
@NonNull
public List<File> getRenderscriptSourceList() {
List<SourceProvider> providers = getSortedSourceProviders();
List<File> sourceList = Lists.newArrayListWithExpectedSize(providers.size());
for (SourceProvider provider : providers) {
sourceList.addAll(provider.getRenderscriptDirectories());
}
return sourceList;
}
/**
* Returns all the aidl import folder that are outside of the current project.
*/
@NonNull
public List<File> getAidlImports() {
List<File> list = Lists.newArrayList();
for (LibraryDependency lib : mFlatLibraries) {
File aidlLib = lib.getAidlFolder();
if (aidlLib.isDirectory()) {
list.add(aidlLib);
}
}
return list;
}
@NonNull
public List<File> getAidlSourceList() {
List<SourceProvider> providers = getSortedSourceProviders();
List<File> sourceList = Lists.newArrayListWithExpectedSize(providers.size());
for (SourceProvider provider : providers) {
sourceList.addAll(provider.getAidlDirectories());
}
return sourceList;
}
@NonNull
public List<File> getJniSourceList() {
List<SourceProvider> providers = getSortedSourceProviders();
List<File> sourceList = Lists.newArrayListWithExpectedSize(providers.size());
for (SourceProvider provider : providers) {
sourceList.addAll(provider.getCDirectories());
}
return sourceList;
}
@NonNull
public List<File> getJniLibsList() {
List<SourceProvider> providers = getSortedSourceProviders();
List<File> sourceList = Lists.newArrayListWithExpectedSize(providers.size());
for (SourceProvider provider : providers) {
sourceList.addAll(provider.getJniLibsDirectories());
}
return sourceList;
}
/**
* Returns the compile classpath for this config. If the config tests a library, this
* will include the classpath of the tested config
*
* @return a non null, but possibly empty set.
*/
@NonNull
public Set<File> getCompileClasspath() {
Set<File> classpath = Sets.newHashSetWithExpectedSize(
mExternalJars.size() + mLocalJars.size() + mFlatLibraries.size());
for (LibraryDependency lib : mFlatLibraries) {
classpath.add(lib.getJarFile());
for (File jarFile : lib.getLocalJars()) {
classpath.add(jarFile);
}
}
for (JarDependency jar : mExternalJars) {
if (jar.isCompiled()) {
classpath.add(jar.getJarFile());
}
}
for (JarDependency jar : mLocalJars) {
if (jar.isCompiled()) {
classpath.add(jar.getJarFile());
}
}
return classpath;
}
/**
* Returns the list of packaged jars for this config. If the config tests a library, this
* will include the jars of the tested config
*
* @return a non null, but possibly empty list.
*/
@NonNull
public Set<File> getPackagedJars() {
Set<File> jars = Sets.newHashSetWithExpectedSize(
mExternalJars.size() + mLocalJars.size() + mFlatLibraries.size());
for (JarDependency jar : mExternalJars) {
File jarFile = jar.getJarFile();
if (jar.isPackaged() && jarFile.exists()) {
jars.add(jarFile);
}
}
for (JarDependency jar : mLocalJars) {
File jarFile = jar.getJarFile();
if (jar.isPackaged() && jarFile.exists()) {
jars.add(jarFile);
}
}
for (LibraryDependency libraryDependency : mFlatLibraries) {
if (!libraryDependency.isOptional()) {
File libJar = libraryDependency.getJarFile();
if (libJar.exists()) {
jars.add(libJar);
}
for (File jarFile : libraryDependency.getLocalJars()) {
if (jarFile.isFile()) {
jars.add(jarFile);
}
}
}
}
return jars;
}
/**
* Returns the list of provided-only jars for this config.
*
* @return a non null, but possibly empty list.
*/
@NonNull
public List<File> getProvidedOnlyJars() {
Set<File> jars = Sets.newHashSetWithExpectedSize(mExternalJars.size() + mLocalJars.size());
for (JarDependency jar : mExternalJars) {
File jarFile = jar.getJarFile();
if (jar.isCompiled() && !jar.isPackaged() && jarFile.exists()) {
jars.add(jarFile);
}
}
for (JarDependency jar : mLocalJars) {
File jarFile = jar.getJarFile();
if (jar.isCompiled() && !jar.isPackaged() && jarFile.exists()) {
jars.add(jarFile);
}
}
for (LibraryDependency libraryDependency : mFlatLibraries) {
if (libraryDependency.isOptional()) {
File libJar = libraryDependency.getJarFile();
if (libJar.exists()) {
jars.add(libJar);
}
for (File jarFile : libraryDependency.getLocalJars()) {
if (jarFile.isFile()) {
jars.add(jarFile);
}
}
}
}
return Lists.newArrayList(jars);
}
/**
* 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
*/
public void addBuildConfigField(@NonNull String type, @NonNull String name, @NonNull String value) {
ClassField classField = AndroidBuilder.createClassField(type, name, value);
mBuildConfigFields.put(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
*/
public void addResValue(@NonNull String type, @NonNull String name, @NonNull String value) {
ClassField classField = AndroidBuilder.createClassField(type, name, value);
mResValues.put(name, classField);
}
/**
* Returns a list of items for the BuildConfig class.
*
* Items can be either fields (instance of {@link com.android.builder.model.ClassField})
* or comments (instance of String).
*
* @return a list of items.
*/
@NonNull
public List<Object> getBuildConfigItems() {
List<Object> fullList = Lists.newArrayList();
// 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.
Set<String> usedFieldNames = Sets.newHashSet();
Collection<ClassField> list = mBuildConfigFields.values();
if (!list.isEmpty()) {
fullList.add("Fields from the variant");
fillFieldList(fullList, usedFieldNames, list);
}
list = mBuildType.getBuildConfigFields().values();
if (!list.isEmpty()) {
fullList.add("Fields from build type: " + mBuildType.getName());
fillFieldList(fullList, usedFieldNames, list);
}
for (F flavor : mFlavors) {
list = flavor.getBuildConfigFields().values();
if (!list.isEmpty()) {
fullList.add("Fields from product flavor: " + flavor.getName());
fillFieldList(fullList, usedFieldNames, list);
}
}
list = mDefaultConfig.getBuildConfigFields().values();
if (!list.isEmpty()) {
fullList.add("Fields from default config.");
fillFieldList(fullList, usedFieldNames, list);
}
return fullList;
}
/**
* Return the merged build config fields for the variant.
*
* This is made of of the variant-specific fields overlayed on top of the build type ones,
* the flavors ones, and the default config ones.
*
* @return a map of merged fields
*/
@NonNull
public Map<String, ClassField> getMergedBuildConfigFields() {
Map<String, ClassField> mergedMap = Maps.newHashMap();
// start from the lowest priority and just add it all. Higher priority fields
// will replace lower priority ones.
mergedMap.putAll(mDefaultConfig.getBuildConfigFields());
for (int i = mFlavors.size() - 1; i >= 0 ; i--) {
mergedMap.putAll(mFlavors.get(i).getBuildConfigFields());
}
mergedMap.putAll(mBuildType.getBuildConfigFields());
mergedMap.putAll(mBuildConfigFields);
return mergedMap;
}
/**
* Return the merged res values for the variant.
*
* This is made of of the variant-specific fields overlayed on top of the build type ones,
* the flavors ones, and the default config ones.
*
* @return a map of merged fields
*/
@NonNull
public Map<String, ClassField> getMergedResValues() {
Map<String, ClassField> mergedMap = Maps.newHashMap();
// start from the lowest priority and just add it all. Higher priority fields
// will replace lower priority ones.
mergedMap.putAll(mDefaultConfig.getResValues());
for (int i = mFlavors.size() - 1; i >= 0 ; i--) {
mergedMap.putAll(mFlavors.get(i).getResValues());
}
mergedMap.putAll(mBuildType.getResValues());
mergedMap.putAll(mResValues);
return mergedMap;
}
/**
* 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 static void fillFieldList(
@NonNull List<Object> outList,
@NonNull Set<String> usedFieldNames,
@NonNull Collection<ClassField> list) {
for (ClassField f : list) {
String name = f.getName();
if (!usedFieldNames.contains(name)) {
usedFieldNames.add(f.getName());
outList.add(f);
}
}
}
/**
* Returns a list of generated resource values.
*
* Items can be either fields (instance of {@link com.android.builder.model.ClassField})
* or comments (instance of String).
*
* @return a list of items.
*/
@NonNull
public List<Object> getResValues() {
List<Object> fullList = Lists.newArrayList();
// 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.
Set<String> usedFieldNames = Sets.newHashSet();
Collection<ClassField> list = mResValues.values();
if (!list.isEmpty()) {
fullList.add("Values from the variant");
fillFieldList(fullList, usedFieldNames, list);
}
list = mBuildType.getResValues().values();
if (!list.isEmpty()) {
fullList.add("Values from build type: " + mBuildType.getName());
fillFieldList(fullList, usedFieldNames, list);
}
for (F flavor : mFlavors) {
list = flavor.getResValues().values();
if (!list.isEmpty()) {
fullList.add("Values from product flavor: " + flavor.getName());
fillFieldList(fullList, usedFieldNames, list);
}
}
list = mDefaultConfig.getResValues().values();
if (!list.isEmpty()) {
fullList.add("Values from default config.");
fillFieldList(fullList, usedFieldNames, list);
}
return fullList;
}
@Nullable
public SigningConfig getSigningConfig() {
if (mSigningConfigOverride != null) {
return mSigningConfigOverride;
}
SigningConfig signingConfig = mBuildType.getSigningConfig();
if (signingConfig != null) {
return signingConfig;
}
return mMergedFlavor.getSigningConfig();
}
public boolean isSigningReady() {
SigningConfig signingConfig = getSigningConfig();
return signingConfig != null && signingConfig.isSigningReady();
}
/**
* Returns the proguard config files coming from the project but also from the dependencies.
*
* Note that if the method is set to include config files coming from libraries, they will
* only be included if the aars have already been unzipped.
*
* @param includeLibraries whether to include the library dependencies.
* @return a non null list of proguard files.
*/
@NonNull
public List<File> getProguardFiles(boolean includeLibraries, List<File> defaultProguardConfig) {
List<File> fullList = Lists.newArrayList();
// add the config files from the build type, main config and flavors
fullList.addAll(mDefaultConfig.getProguardFiles());
fullList.addAll(mBuildType.getProguardFiles());
for (F flavor : mFlavors) {
fullList.addAll(flavor.getProguardFiles());
}
if (fullList.isEmpty()) {
fullList.addAll(defaultProguardConfig);
}
// now add the one coming from the library dependencies
if (includeLibraries) {
for (LibraryDependency libraryDependency : mFlatLibraries) {
File proguardRules = libraryDependency.getProguardRules();
if (proguardRules.exists()) {
fullList.add(proguardRules);
}
}
}
return fullList;
}
/**
* Returns the proguard config files to be used for the test APK.
*/
@NonNull
public List<File> getTestProguardFiles() {
List<File> fullList = Lists.newArrayList();
// add the config files from the build type, main config and flavors
fullList.addAll(mDefaultConfig.getTestProguardFiles());
fullList.addAll(mBuildType.getTestProguardFiles());
for (F flavor : mFlavors) {
fullList.addAll(flavor.getTestProguardFiles());
}
return fullList;
}
@NonNull
public List<Object> getConsumerProguardFiles() {
List<Object> fullList = Lists.newArrayList();
// add the config files from the build type, main config and flavors
fullList.addAll(mDefaultConfig.getConsumerProguardFiles());
fullList.addAll(mBuildType.getConsumerProguardFiles());
for (F flavor : mFlavors) {
fullList.addAll(flavor.getConsumerProguardFiles());
}
return fullList;
}
public boolean isTestCoverageEnabled() {
return mBuildType.isTestCoverageEnabled();
}
/**
* 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.
*/
@NonNull
public Map<String, Object> getManifestPlaceholders() {
Map<String, Object> mergedFlavorsPlaceholders = mMergedFlavor.getManifestPlaceholders();
// so far, blindly override the build type placeholders
mergedFlavorsPlaceholders.putAll(mBuildType.getManifestPlaceholders());
return mergedFlavorsPlaceholders;
}
public boolean isMultiDexEnabled() {
Boolean value = mBuildType.getMultiDexEnabled();
if (value != null) {
return value;
}
value = mMergedFlavor.getMultiDexEnabled();
if (value != null) {
return value;
}
return false;
}
public File getMultiDexKeepFile() {
File value = mBuildType.getMultiDexKeepFile();
if (value != null) {
return value;
}
value = mMergedFlavor.getMultiDexKeepFile();
if (value != null) {
return value;
}
return null;
}
public File getMultiDexKeepProguard() {
File value = mBuildType.getMultiDexKeepProguard();
if (value != null) {
return value;
}
value = mMergedFlavor.getMultiDexKeepProguard();
if (value != null) {
return value;
}
return null;
}
public boolean isLegacyMultiDexMode() {
return isMultiDexEnabled() && getMinSdkVersion().getApiLevel() < 21;
}
/**
* Returns the renderscript support mode.
*/
public boolean getRenderscriptSupportModeEnabled() {
Boolean value = mMergedFlavor.getRenderscriptSupportModeEnabled();
if (value != null) {
return value;
}
// default is false.
return false;
}
/**
* Returns the renderscript NDK mode.
*/
public boolean getRenderscriptNdkModeEnabled() {
Boolean value = mMergedFlavor.getRenderscriptNdkModeEnabled();
if (value != null) {
return value;
}
// default is false.
return false;
}
public Collection<File> getJarJarRuleFiles() {
ImmutableList.Builder<File> jarjarRuleFiles = ImmutableList.builder();
jarjarRuleFiles.addAll(getMergedFlavor().getJarJarRuleFiles());
jarjarRuleFiles.addAll(mBuildType.getJarJarRuleFiles());
return jarjarRuleFiles.build();
}
}