Java tutorial
/* * 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(); } }