/*
* 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;
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.internal.MergedNdkConfig;
import com.android.builder.internal.StringHelper;
import com.android.builder.model.ClassField;
import com.android.builder.model.NdkConfig;
import com.android.builder.model.ProductFlavor;
import com.android.builder.model.SigningConfig;
import com.android.builder.model.SourceProvider;
import com.android.builder.testing.TestData;
import com.android.ide.common.res2.AssetSet;
import com.android.ide.common.res2.ResourceSet;
import com.google.common.collect.Lists;
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.Set;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;
/**
* A Variant configuration.
*/
public class VariantConfiguration implements TestData {
private static 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 DefaultProductFlavor mDefaultConfig;
@NonNull
private final SourceProvider mDefaultSourceProvider;
@NonNull
private final DefaultBuildType mBuildType;
/** SourceProvider for the BuildType. Can be null */
@Nullable
private final SourceProvider mBuildTypeSourceProvider;
private final List<String> mFlavorDimensionNames = Lists.newArrayList();
private final List<DefaultProductFlavor> mFlavorConfigs = 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 Type mType;
/** Optional tested config in case type is Type#TEST */
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;
private DefaultProductFlavor mMergedFlavor;
private final MergedNdkConfig mMergedNdkConfig = new MergedNdkConfig();
private final Set<JarDependency> mJars = 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.
* 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();
public static enum Type {
DEFAULT, LIBRARY, TEST
}
/**
* 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 sManifestParser.getPackage(manifestFile);
}
/**
* Creates the configuration with the base source sets.
*
* This creates a config with a {@link Type#DEFAULT} type.
*
* @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. Required.
*/
public VariantConfiguration(
@NonNull DefaultProductFlavor defaultConfig,
@NonNull SourceProvider defaultSourceProvider,
@NonNull DefaultBuildType buildType,
@Nullable SourceProvider buildTypeSourceProvider) {
this(
defaultConfig, defaultSourceProvider,
buildType, buildTypeSourceProvider,
Type.DEFAULT, null /*testedConfig*/);
}
/**
* Creates the configuration with the base source sets for a given {@link Type}.
*
* @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.
*/
public VariantConfiguration(
@NonNull DefaultProductFlavor defaultConfig,
@NonNull SourceProvider defaultSourceProvider,
@NonNull DefaultBuildType buildType,
@Nullable SourceProvider buildTypeSourceProvider,
@NonNull Type type) {
this(
defaultConfig, defaultSourceProvider,
buildType, buildTypeSourceProvider,
type, null /*testedConfig*/);
}
/**
* 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.TEST
*/
public VariantConfiguration(
@NonNull DefaultProductFlavor defaultConfig,
@NonNull SourceProvider defaultSourceProvider,
@NonNull DefaultBuildType buildType,
@Nullable SourceProvider buildTypeSourceProvider,
@NonNull Type type,
@Nullable VariantConfiguration testedConfig) {
mDefaultConfig = checkNotNull(defaultConfig);
mDefaultSourceProvider = checkNotNull(defaultSourceProvider);
mBuildType = checkNotNull(buildType);
mBuildTypeSourceProvider = buildTypeSourceProvider;
mType = checkNotNull(type);
mTestedConfig = testedConfig;
checkState(mType != Type.TEST || mTestedConfig != null);
mMergedFlavor = mDefaultConfig;
computeNdkConfig();
if (testedConfig != null &&
testedConfig.mType == Type.LIBRARY &&
testedConfig.mOutput != null) {
mDirectLibraries.add(testedConfig.mOutput);
}
validate();
}
/**
* 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 == Type.TEST) {
sb.append("Test");
}
mFullName = sb.toString();
}
return mFullName;
}
/**
* 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 (mFlavorConfigs.isEmpty()) {
mFlavorName = "";
} else {
StringBuilder sb = new StringBuilder();
boolean first = true;
for (DefaultProductFlavor flavor : mFlavorConfigs) {
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 (!mFlavorConfigs.isEmpty()) {
for (ProductFlavor pf : mFlavorConfigs) {
sb.append(pf.getName()).append('-');
}
}
sb.append(mBuildType.getName());
if (mType == Type.TEST) {
sb.append('-').append("test");
}
mBaseName = sb.toString();
}
return mBaseName;
}
/**
* 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
*/
@NonNull
public String getDirName() {
if (mDirName == null) {
StringBuilder sb = new StringBuilder();
if (mType == Type.TEST) {
sb.append("test/");
}
if (!mFlavorConfigs.isEmpty()) {
for (DefaultProductFlavor flavor : mFlavorConfigs) {
sb.append(flavor.getName());
}
sb.append('/').append(mBuildType.getName());
} else {
sb.append(mBuildType.getName());
}
mDirName = sb.toString();
}
return mDirName;
}
/**
* 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 (mFlavorConfigs.isEmpty()) {
return Collections.emptyList();
}
List<String> names;
int count = mFlavorConfigs.size();
if (count > 1) {
names = Lists.newArrayListWithCapacity(count * 2);
for (int i = 0 ; i < count ; i++) {
names.add(mFlavorConfigs.get(i).getName());
names.add(mFlavorDimensionNames.get(i));
}
} else {
names = Collections.singletonList(mFlavorConfigs.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 DefaultProductFlavor productFlavor,
@NonNull SourceProvider sourceProvider,
@NonNull String dimensionName) {
mFlavorConfigs.add(productFlavor);
mFlavorSourceProviders.add(sourceProvider);
mFlavorDimensionNames.add(dimensionName);
mMergedFlavor = productFlavor.mergeOver(mMergedFlavor);
computeNdkConfig();
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;
}
private void computeNdkConfig() {
mMergedNdkConfig.reset();
if (mDefaultConfig.getNdkConfig() != null) {
mMergedNdkConfig.append(mDefaultConfig.getNdkConfig());
}
for (int i = mFlavorConfigs.size() - 1 ; i >= 0 ; i--) {
NdkConfig ndkConfig = mFlavorConfigs.get(i).getNdkConfig();
if (ndkConfig != null) {
mMergedNdkConfig.append(ndkConfig);
}
}
if (mBuildType.getNdkConfig() != null && mType != Type.TEST) {
mMergedNdkConfig.append(mBuildType.getNdkConfig());
}
}
/**
* Sets the dependencies
*
* @param container a DependencyContainer.
* @return the config object
*/
@NonNull
public VariantConfiguration setDependencies(@NonNull DependencyContainer container) {
mDirectLibraries.addAll(container.getAndroidDependencies());
mJars.addAll(container.getJarDependencies());
mJars.addAll(container.getLocalDependencies());
resolveIndirectLibraryDependencies(mDirectLibraries, mFlatLibraries);
for (LibraryDependency libraryDependency : mFlatLibraries) {
mJars.addAll(libraryDependency.getLocalDependencies());
}
return this;
}
/**
* Returns the list of jar dependencies
* @return a non null collection of Jar dependencies.
*/
@NonNull
public Collection<JarDependency> getJars() {
return mJars;
}
/**
* 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;
}
@NonNull
public DefaultProductFlavor getDefaultConfig() {
return mDefaultConfig;
}
@NonNull
public SourceProvider getDefaultSourceSet() {
return mDefaultSourceProvider;
}
@NonNull
public DefaultProductFlavor getMergedFlavor() {
return mMergedFlavor;
}
@NonNull
public DefaultBuildType getBuildType() {
return mBuildType;
}
/**
* The SourceProvider for the BuildType. Can be null.
*/
@Nullable
public SourceProvider getBuildTypeSourceSet() {
return mBuildTypeSourceProvider;
}
public boolean hasFlavors() {
return !mFlavorConfigs.isEmpty();
}
@NonNull
public List<DefaultProductFlavor> getFlavorConfigs() {
return mFlavorConfigs;
}
/**
* 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;
}
public boolean hasLibraries() {
return !mDirectLibraries.isEmpty();
}
/**
* 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 Type 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
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 package name before any overrides from flavors.
* If the variant is a test variant, then the package name is the one coming from the
* configuration of the tested variant, and this call is similar to #getPackageName()
* @return the package name
*/
@Nullable
public String getOriginalPackageName() {
if (mType == VariantConfiguration.Type.TEST) {
return getPackageName();
}
return getPackageFromManifest();
}
/**
* Returns the package name 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 package
*/
@Override
@NonNull
public String getPackageName() {
String packageName;
if (mType == Type.TEST) {
assert mTestedConfig != null;
packageName = mMergedFlavor.getTestPackageName();
if (packageName == null) {
String testedPackage = mTestedConfig.getPackageName();
packageName = testedPackage + ".test";
}
} else {
// first get package override.
packageName = getPackageOverride();
// if it's null, this means we just need the default package
// from the manifest since both flavor and build type do nothing.
if (packageName == null) {
packageName = getPackageFromManifest();
}
}
if (packageName == null) {
throw new RuntimeException("Failed get query package name for " + getFullName());
}
return packageName;
}
@Override
@Nullable
public String getTestedPackageName() {
if (mType == Type.TEST) {
assert mTestedConfig != null;
if (mTestedConfig.mType == Type.LIBRARY) {
return getPackageName();
} else {
return mTestedConfig.getPackageName();
}
}
return null;
}
/**
* Returns the package override values coming from the Product Flavor and/or the Build Type.
* If the package is not overridden then this returns null.
*
* @return the package override or null
*/
@Nullable
public String getPackageOverride() {
String packageName = mMergedFlavor.getPackageName();
String packageSuffix = mBuildType.getPackageNameSuffix();
if (packageSuffix != null && packageSuffix.length() > 0) {
if (packageName == null) {
packageName = getPackageFromManifest();
}
if (packageSuffix.charAt(0) == '.') {
packageName = packageName + packageSuffix;
} else {
packageName = packageName + '.' + packageSuffix;
}
}
return packageName;
}
/**
* 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 (versionSuffix != null && versionSuffix.length() > 0) {
if (versionName == null) {
if (mType != Type.TEST) {
versionName = getVersionNameFromManifest();
} else {
versionName = "";
}
}
versionName = 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();
if (versionCode == -1 && mType != Type.TEST) {
versionCode = getVersionCodeFromManifest();
}
return versionCode;
}
private final static String DEFAULT_TEST_RUNNER = "android.test.InstrumentationTestRunner";
private final static Boolean DEFAULT_HANDLE_PROFILING = false;
private final static 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
*/
@Override
@NonNull
public String getInstrumentationRunner() {
VariantConfiguration config = this;
if (mType == Type.TEST) {
config = getTestedConfig();
}
String runner = config.mMergedFlavor.getTestInstrumentationRunner();
return runner != null ? runner : DEFAULT_TEST_RUNNER;
}
/**
* 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
*/
@Override
@NonNull
public Boolean getHandleProfiling() {
VariantConfiguration config = this;
if (mType == Type.TEST) {
config = getTestedConfig();
}
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
*/
@Override
@NonNull
public Boolean getFunctionalTest() {
VariantConfiguration config = this;
if (mType == Type.TEST) {
config = getTestedConfig();
}
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() {
assert mType != Type.TEST;
File manifestLocation = mDefaultSourceProvider.getManifestFile();
return sManifestParser.getPackage(manifestLocation);
}
/**
* 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
*/
@Override
public int getMinSdkVersion() {
if (mTestedConfig != null) {
return mTestedConfig.getMinSdkVersion();
}
int minSdkVersion = mMergedFlavor.getMinSdkVersion();
if (minSdkVersion == -1) {
// read it from the main manifest
File manifestLocation = mDefaultSourceProvider.getManifestFile();
minSdkVersion = 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
*/
public int getTargetSdkVersion() {
if (mTestedConfig != null) {
return mTestedConfig.getTargetSdkVersion();
}
int targetSdkVersion = mMergedFlavor.getTargetSdkVersion();
if (targetSdkVersion == -1) {
// read it from the main manifest
File manifestLocation = mDefaultSourceProvider.getManifestFile();
targetSdkVersion = 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;
}
@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 generatedResFolder the generated res folder typically the output of the renderscript
* compilation
* @param includeDependencies whether to include in the result the resources of the dependencies
*
* @return a list ResourceSet.
*/
@NonNull
public List<ResourceSet> getResourceSets(@Nullable File generatedResFolder,
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);
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();
ResourceSet resourceSet = new ResourceSet(BuilderConstants.MAIN);
resourceSet.addSources(mainResDirs);
if (generatedResFolder != null) {
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(mFlavorConfigs.get(n).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(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();
AssetSet assetSet = new AssetSet(BuilderConstants.MAIN);
assetSet.addSources(mainResDirs);
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(mFlavorConfigs.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<File> sourceList = Lists.newArrayList();
sourceList.addAll(mDefaultSourceProvider.getRenderscriptDirectories());
if (mType != Type.TEST && mBuildTypeSourceProvider != null) {
sourceList.addAll(mBuildTypeSourceProvider.getRenderscriptDirectories());
}
if (hasFlavors()) {
for (SourceProvider flavorSourceSet : mFlavorSourceProviders) {
sourceList.addAll(flavorSourceSet.getRenderscriptDirectories());
}
}
if (mMultiFlavorSourceProvider != null) {
sourceList.addAll(mMultiFlavorSourceProvider.getRenderscriptDirectories());
}
if (mVariantSourceProvider != null) {
sourceList.addAll(mVariantSourceProvider.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<File> sourceList = Lists.newArrayList();
sourceList.addAll(mDefaultSourceProvider.getAidlDirectories());
if (mType != Type.TEST && mBuildTypeSourceProvider != null) {
sourceList.addAll(mBuildTypeSourceProvider.getAidlDirectories());
}
if (hasFlavors()) {
for (SourceProvider flavorSourceSet : mFlavorSourceProviders) {
sourceList.addAll(flavorSourceSet.getAidlDirectories());
}
}
if (mMultiFlavorSourceProvider != null) {
sourceList.addAll(mMultiFlavorSourceProvider.getAidlDirectories());
}
if (mVariantSourceProvider != null) {
sourceList.addAll(mVariantSourceProvider.getAidlDirectories());
}
return sourceList;
}
@NonNull
public List<File> getJniSourceList() {
List<File> sourceList = Lists.newArrayList();
sourceList.addAll(mDefaultSourceProvider.getJniDirectories());
if (mType != Type.TEST && mBuildTypeSourceProvider != null) {
sourceList.addAll(mBuildTypeSourceProvider.getJniDirectories());
}
if (hasFlavors()) {
for (SourceProvider flavorSourceSet : mFlavorSourceProviders) {
sourceList.addAll(flavorSourceSet.getJniDirectories());
}
}
if (mMultiFlavorSourceProvider != null) {
sourceList.addAll(mMultiFlavorSourceProvider.getJniDirectories());
}
if (mVariantSourceProvider != null) {
sourceList.addAll(mVariantSourceProvider.getJniDirectories());
}
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.newHashSet();
for (LibraryDependency lib : mFlatLibraries) {
classpath.add(lib.getJarFile());
for (File jarFile : lib.getLocalJars()) {
classpath.add(jarFile);
}
}
for (JarDependency jar : mJars) {
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 List<File> getPackagedJars() {
Set<File> jars = Sets.newHashSetWithExpectedSize(mJars.size() + mFlatLibraries.size());
for (JarDependency jar : mJars) {
File jarFile = jar.getJarFile();
if (jar.isPackaged() && jarFile.exists()) {
jars.add(jarFile);
}
}
for (LibraryDependency libraryDependency : mFlatLibraries) {
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);
}
/**
* 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();
Set<String> usedFieldNames = Sets.newHashSet();
List<ClassField> list = mBuildType.getBuildConfigFields();
if (!list.isEmpty()) {
fullList.add("Fields from build type: " + mBuildType.getName());
for (ClassField f : list) {
usedFieldNames.add(f.getName());
fullList.add(f);
}
}
for (DefaultProductFlavor flavor : mFlavorConfigs) {
list = flavor.getBuildConfigFields();
if (!list.isEmpty()) {
fullList.add("Fields from product flavor: " + flavor.getName());
for (ClassField f : list) {
String name = f.getName();
if (!usedFieldNames.contains(name)) {
usedFieldNames.add(f.getName());
fullList.add(f);
}
}
}
}
list = mDefaultConfig.getBuildConfigFields();
if (!list.isEmpty()) {
fullList.add("Fields from default config.");
for (ClassField f : list) {
String name = f.getName();
if (!usedFieldNames.contains(name)) {
usedFieldNames.add(f.getName());
fullList.add(f);
}
}
}
return fullList;
}
@Nullable
public SigningConfig getSigningConfig() {
SigningConfig signingConfig = mBuildType.getSigningConfig();
if (signingConfig != null) {
return signingConfig;
}
return mMergedFlavor.getSigningConfig();
}
public boolean isSigningReady() {
SigningConfig signingConfig = getSigningConfig();
return signingConfig != null && signingConfig.isSigningReady();
}
@NonNull
public List<Object> getProguardFiles(boolean includeLibraries) {
List<Object> fullList = Lists.newArrayList();
// add the config files from the build type, main config and flavors
fullList.addAll(mDefaultConfig.getProguardFiles());
fullList.addAll(mBuildType.getProguardFiles());
for (DefaultProductFlavor flavor : mFlavorConfigs) {
fullList.addAll(flavor.getProguardFiles());
}
// 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;
}
@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 (DefaultProductFlavor flavor : mFlavorConfigs) {
fullList.addAll(flavor.getConsumerProguardFiles());
}
return fullList;
}
protected void validate() {
if (mType != Type.TEST) {
File manifest = mDefaultSourceProvider.getManifestFile();
if (!manifest.isFile()) {
throw new IllegalArgumentException(
"Main Manifest missing from " + manifest.getAbsolutePath());
}
}
}
@NonNull
public NdkConfig getNdkConfig() {
return mMergedNdkConfig;
}
@Nullable
@Override
public Set<String> getSupportedAbis() {
if (mMergedNdkConfig != null) {
return mMergedNdkConfig.getAbiFilters();
}
return null;
}
}