blob: 0e122425e3ac02eff3a0769bc4a91b9f9bfb2a11 [file] [log] [blame]
/*
* 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.compiling.DependencyFileProcessor;
import com.android.builder.dependency.ManifestDependency;
import com.android.builder.dependency.SymbolFileProvider;
import com.android.builder.internal.ClassFieldImpl;
import com.android.builder.internal.SymbolLoader;
import com.android.builder.internal.SymbolWriter;
import com.android.builder.internal.TestManifestGenerator;
import com.android.builder.internal.compiler.AidlProcessor;
import com.android.builder.internal.compiler.LeafFolderGatherer;
import com.android.builder.internal.compiler.RenderScriptProcessor;
import com.android.builder.internal.compiler.SourceSearcher;
import com.android.builder.internal.packaging.JavaResourceProcessor;
import com.android.builder.internal.packaging.Packager;
import com.android.builder.model.AaptOptions;
import com.android.builder.model.ClassField;
import com.android.builder.model.ProductFlavor;
import com.android.builder.model.SigningConfig;
import com.android.builder.packaging.DuplicateFileException;
import com.android.builder.packaging.PackagerException;
import com.android.builder.packaging.SealedPackageException;
import com.android.builder.packaging.SigningException;
import com.android.builder.signing.CertificateInfo;
import com.android.builder.signing.KeystoreHelper;
import com.android.builder.signing.KeytoolException;
import com.android.ide.common.internal.AaptRunner;
import com.android.ide.common.internal.CommandLineRunner;
import com.android.ide.common.internal.LoggedErrorException;
import com.android.manifmerger.ManifestMerger;
import com.android.manifmerger.MergerLog;
import com.android.sdklib.BuildToolInfo;
import com.android.sdklib.IAndroidTarget;
import com.android.sdklib.repository.FullRevision;
import com.android.utils.ILogger;
import com.android.utils.SdkUtils;
import com.google.common.base.Joiner;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Multimap;
import com.google.common.collect.Sets;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
/**
* This is the main builder class. It is given all the data to process the build (such as
* {@link DefaultProductFlavor}s, {@link DefaultBuildType} and dependencies) and use them when doing specific
* build steps.
*
* To use:
* create a builder with {@link #AndroidBuilder(SdkParser, String, ILogger, boolean)}
*
* then build steps can be done with
* {@link #processManifest(java.io.File, java.util.List, java.util.List, String, int, String, int, int, String)}
* {@link #processTestManifest(String, int, int, String, String, Boolean, Boolean, java.util.List, String)}
* {@link #processResources(java.io.File, java.io.File, java.io.File, java.util.List, String, String, String, String, String, com.android.builder.VariantConfiguration.Type, boolean, com.android.builder.model.AaptOptions)}
* {@link #compileAllAidlFiles(java.util.List, java.io.File, java.util.List, com.android.builder.compiling.DependencyFileProcessor)}
* {@link #convertByteCode(Iterable, Iterable, File, DexOptions, boolean)}
* {@link #packageApk(String, String, java.util.List, String, java.util.Collection, java.util.Set, boolean, com.android.builder.model.SigningConfig, String)}
*
* Java compilation is not handled but the builder provides the bootclasspath with
* {@link #getBootClasspath(SdkParser)}.
*/
public class AndroidBuilder {
private static final FullRevision MIN_BUILD_TOOLS_REV = new FullRevision(16, 0, 0);
private static final DependencyFileProcessor sNoOpDependencyFileProcessor = new DependencyFileProcessor() {
@Override
public boolean processFile(@NonNull File dependencyFile) {
return true;
}
};
private final SdkParser mSdkParser;
private final ILogger mLogger;
private final CommandLineRunner mCmdLineRunner;
private final boolean mVerboseExec;
private boolean mLibrary;
@NonNull
private final IAndroidTarget mTarget;
@NonNull
private final BuildToolInfo mBuildTools;
private String mCreatedBy;
/**
* Creates an AndroidBuilder
* <p/>
* This receives an {@link SdkParser} to provide the build with information about the SDK, as
* well as an {@link ILogger} to display output.
* <p/>
* <var>verboseExec</var> is needed on top of the ILogger due to remote exec tools not being
* able to output info and verbose messages separately.
*
* @param sdkParser the SdkParser
* @param logger the Logger
* @param verboseExec whether external tools are launched in verbose mode
*/
public AndroidBuilder(
@NonNull SdkParser sdkParser,
@Nullable String createdBy,
@NonNull ILogger logger,
boolean verboseExec) {
mCreatedBy = createdBy;
mSdkParser = checkNotNull(sdkParser);
mLogger = checkNotNull(logger);
mVerboseExec = verboseExec;
mCmdLineRunner = new CommandLineRunner(mLogger);
BuildToolInfo buildToolInfo = mSdkParser.getBuildTools();
FullRevision buildToolsRevision = buildToolInfo.getRevision();
if (buildToolsRevision.compareTo(MIN_BUILD_TOOLS_REV) < 0) {
throw new IllegalArgumentException(String.format(
"The SDK Build Tools revision (%1$s) is too low. Minimum required is %2$s",
buildToolsRevision, MIN_BUILD_TOOLS_REV));
}
mTarget = mSdkParser.getTarget();
mBuildTools = mSdkParser.getBuildTools();
}
@VisibleForTesting
AndroidBuilder(
@NonNull SdkParser sdkParser,
@NonNull CommandLineRunner cmdLineRunner,
@NonNull ILogger logger,
boolean verboseExec) {
mSdkParser = checkNotNull(sdkParser);
mCmdLineRunner = checkNotNull(cmdLineRunner);
mLogger = checkNotNull(logger);
mVerboseExec = verboseExec;
mTarget = mSdkParser.getTarget();
mBuildTools = mSdkParser.getBuildTools();
}
/**
* Helper method to get the boot classpath to be used during compilation.
*/
@NonNull
public static List<String> getBootClasspath(@NonNull SdkParser sdkParser) {
List<String> classpath = Lists.newArrayList();
IAndroidTarget target = sdkParser.getTarget();
classpath.addAll(target.getBootClasspath());
// add optional libraries if any
IAndroidTarget.IOptionalLibrary[] libs = target.getOptionalLibraries();
if (libs != null) {
for (IAndroidTarget.IOptionalLibrary lib : libs) {
classpath.add(lib.getJarPath());
}
}
// add annotations.jar if needed.
if (target.getVersion().getApiLevel() <= 15) {
classpath.add(sdkParser.getAnnotationsJar());
}
return classpath;
}
/** Sets whether this builder is currently used to build a library. Defaults to false. */
public AndroidBuilder setBuildingLibrary(boolean library) {
mLibrary = library;
return this;
}
/** Sets whether this builder is currently used to build a library */
public boolean isBuildingLibrary() {
return mLibrary;
}
/**
* 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(@NonNull VariantConfiguration variantConfiguration) {
Set<File> compileClasspath = variantConfiguration.getCompileClasspath();
ProductFlavor mergedFlavor = variantConfiguration.getMergedFlavor();
if (mergedFlavor.getRenderscriptSupportMode()) {
File renderScriptSupportJar = RenderScriptProcessor.getSupportJar(
mBuildTools.getLocation().getAbsolutePath());
Set<File> fullJars = Sets.newHashSetWithExpectedSize(compileClasspath.size() + 1);
fullJars.addAll(compileClasspath);
fullJars.add(renderScriptSupportJar);
compileClasspath = fullJars;
}
return compileClasspath;
}
/**
* 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(@NonNull VariantConfiguration variantConfiguration) {
List<File> packagedJars = variantConfiguration.getPackagedJars();
ProductFlavor mergedFlavor = variantConfiguration.getMergedFlavor();
if (mergedFlavor.getRenderscriptSupportMode()) {
File renderScriptSupportJar = RenderScriptProcessor.getSupportJar(
mBuildTools.getLocation().getAbsolutePath());
List<File> fullJars = Lists.newArrayListWithCapacity(packagedJars.size() + 1);
fullJars.addAll(packagedJars);
fullJars.add(renderScriptSupportJar);
packagedJars = fullJars;
}
return packagedJars;
}
@NonNull
public File getSupportNativeLibFolder() {
return RenderScriptProcessor.getSupportNativeLibFolder(
mBuildTools.getLocation().getAbsolutePath());
}
/**
* Returns an {@link AaptRunner} able to run aapt commands.
* @return an AaptRunner object
*/
@NonNull
public AaptRunner getAaptRunner() {
return new AaptRunner(
mBuildTools.getPath(BuildToolInfo.PathId.AAPT),
mCmdLineRunner);
}
@NonNull
public CommandLineRunner getCommandLineRunner() {
return mCmdLineRunner;
}
@NonNull
public static ClassField createClassField(@NonNull String type, @NonNull String name, @NonNull String value) {
return new ClassFieldImpl(type, name, value);
}
/**
* Merges all the manifests into a single manifest
*
* @param mainManifest The main manifest of the application.
* @param manifestOverlays manifest overlays coming from flavors and build types
* @param libraries the library dependency graph
* @param packageOverride a package name override. Can be null.
* @param versionCode a version code to inject in the manifest or -1 to do nothing.
* @param versionName a version name to inject in the manifest or null to do nothing.
* @param minSdkVersion a minSdkVersion to inject in the manifest or -1 to do nothing.
* @param targetSdkVersion a targetSdkVersion to inject in the manifest or -1 to do nothing.
* @param outManifestLocation the output location for the merged manifest
*
* @see com.android.builder.VariantConfiguration#getMainManifest()
* @see com.android.builder.VariantConfiguration#getManifestOverlays()
* @see com.android.builder.VariantConfiguration#getDirectLibraries()
* @see com.android.builder.VariantConfiguration#getMergedFlavor()
* @see DefaultProductFlavor#getVersionCode()
* @see DefaultProductFlavor#getVersionName()
* @see DefaultProductFlavor#getMinSdkVersion()
* @see DefaultProductFlavor#getTargetSdkVersion()
*/
public void processManifest(
@NonNull File mainManifest,
@NonNull List<File> manifestOverlays,
@NonNull List<? extends ManifestDependency> libraries,
String packageOverride,
int versionCode,
String versionName,
int minSdkVersion,
int targetSdkVersion,
@NonNull String outManifestLocation) {
checkNotNull(mainManifest, "mainManifest cannot be null.");
checkNotNull(manifestOverlays, "manifestOverlays cannot be null.");
checkNotNull(libraries, "libraries cannot be null.");
checkNotNull(outManifestLocation, "outManifestLocation cannot be null.");
try {
Map<String, String> attributeInjection = getAttributeInjectionMap(
versionCode, versionName, minSdkVersion, targetSdkVersion);
if (manifestOverlays.isEmpty() && libraries.isEmpty()) {
// if no manifest to merge, just copy to location, unless we have to inject
// attributes
if (attributeInjection.isEmpty() && packageOverride == null) {
SdkUtils.copyXmlWithSourceReference(mainManifest,
new File(outManifestLocation));
} else {
ManifestMerger merger = new ManifestMerger(MergerLog.wrapSdkLog(mLogger), null);
merger.setInsertSourceMarkers(isInsertSourceMarkers());
doMerge(merger, new File(outManifestLocation), mainManifest,
attributeInjection, packageOverride);
}
} else {
File outManifest = new File(outManifestLocation);
// first merge the app manifest.
if (!manifestOverlays.isEmpty()) {
File mainManifestOut = outManifest;
// if there is also libraries, put this in a temp file.
if (!libraries.isEmpty()) {
// TODO find better way of storing intermediary file?
mainManifestOut = File.createTempFile("manifestMerge", ".xml");
mainManifestOut.deleteOnExit();
}
ManifestMerger merger = new ManifestMerger(MergerLog.wrapSdkLog(mLogger), null);
merger.setInsertSourceMarkers(isInsertSourceMarkers());
doMerge(merger, mainManifestOut, mainManifest, manifestOverlays,
attributeInjection, packageOverride);
// now the main manifest is the newly merged one
mainManifest = mainManifestOut;
// and the attributes have been inject, no need to do it below
attributeInjection = null;
}
if (!libraries.isEmpty()) {
// recursively merge all manifests starting with the leaves and up toward the
// root (the app)
mergeLibraryManifests(mainManifest, libraries,
new File(outManifestLocation), attributeInjection, packageOverride);
}
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
/**
* Creates the manifest for a test variant
*
* @param testPackageName the package name of the test application
* @param minSdkVersion the minSdkVersion of the test application
* @param targetSdkVersion the targetSdkVersion of the test application
* @param testedPackageName the package name of the tested application
* @param instrumentationRunner the name of the instrumentation runner
* @param handleProfiling whether or not the Instrumentation object will turn profiling on and off
* @param functionalTest whether or not the Instrumentation class should run as a functional test
* @param libraries the library dependency graph
* @param outManifestLocation the output location for the merged manifest
*
* @see com.android.builder.VariantConfiguration#getPackageName()
* @see com.android.builder.VariantConfiguration#getTestedConfig()
* @see com.android.builder.VariantConfiguration#getMinSdkVersion()
* @see com.android.builder.VariantConfiguration#getTestedPackageName()
* @see com.android.builder.VariantConfiguration#getInstrumentationRunner()
* @see com.android.builder.VariantConfiguration#getHandleProfiling()
* @see com.android.builder.VariantConfiguration#getFunctionalTest()
* @see com.android.builder.VariantConfiguration#getDirectLibraries()
*/
public void processTestManifest(
@NonNull String testPackageName,
int minSdkVersion,
int targetSdkVersion,
@NonNull String testedPackageName,
@NonNull String instrumentationRunner,
@NonNull Boolean handleProfiling,
@NonNull Boolean functionalTest,
@NonNull List<? extends ManifestDependency> libraries,
@NonNull String outManifestLocation) {
checkNotNull(testPackageName, "testPackageName cannot be null.");
checkNotNull(testedPackageName, "testedPackageName cannot be null.");
checkNotNull(instrumentationRunner, "instrumentationRunner cannot be null.");
checkNotNull(handleProfiling, "handleProfiling cannot be null.");
checkNotNull(functionalTest, "functionalTest cannot be null.");
checkNotNull(libraries, "libraries cannot be null.");
checkNotNull(outManifestLocation, "outManifestLocation cannot be null.");
if (!libraries.isEmpty()) {
try {
// create the test manifest, merge the libraries in it
File generatedTestManifest = File.createTempFile("manifestMerge", ".xml");
generateTestManifest(
testPackageName,
minSdkVersion,
targetSdkVersion,
testedPackageName,
instrumentationRunner,
handleProfiling,
functionalTest,
generatedTestManifest.getAbsolutePath());
mergeLibraryManifests(
generatedTestManifest,
libraries,
new File(outManifestLocation),
null, null);
} catch (IOException e) {
throw new RuntimeException(e);
}
} else {
generateTestManifest(
testPackageName,
minSdkVersion,
targetSdkVersion,
testedPackageName,
instrumentationRunner,
handleProfiling,
functionalTest,
outManifestLocation);
}
}
private void generateTestManifest(
String testPackageName,
int minSdkVersion,
int targetSdkVersion,
String testedPackageName,
String instrumentationRunner,
Boolean handleProfiling,
Boolean functionalTest,
String outManifestLocation) {
TestManifestGenerator generator = new TestManifestGenerator(
outManifestLocation,
testPackageName,
minSdkVersion,
targetSdkVersion,
testedPackageName,
instrumentationRunner,
handleProfiling,
functionalTest);
try {
generator.generate();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
@NonNull
private Map<String, String> getAttributeInjectionMap(
int versionCode,
@Nullable String versionName,
int minSdkVersion,
int targetSdkVersion) {
Map<String, String> attributeInjection = Maps.newHashMap();
if (versionCode != -1) {
attributeInjection.put(
"/manifest|http://schemas.android.com/apk/res/android versionCode",
Integer.toString(versionCode));
}
if (versionName != null) {
attributeInjection.put(
"/manifest|http://schemas.android.com/apk/res/android versionName",
versionName);
}
if (minSdkVersion != -1) {
attributeInjection.put(
"/manifest/uses-sdk|http://schemas.android.com/apk/res/android minSdkVersion",
Integer.toString(minSdkVersion));
}
if (targetSdkVersion != -1) {
attributeInjection.put(
"/manifest/uses-sdk|http://schemas.android.com/apk/res/android targetSdkVersion",
Integer.toString(targetSdkVersion));
}
return attributeInjection;
}
/**
* Merges library manifests into a main manifest.
* @param mainManifest the main manifest
* @param directLibraries the libraries to merge
* @param outManifest the output file
* @throws IOException
*/
private void mergeLibraryManifests(
File mainManifest,
Iterable<? extends ManifestDependency> directLibraries,
File outManifest, Map<String, String> attributeInjection, String packageOverride)
throws IOException {
List<File> manifests = Lists.newArrayList();
for (ManifestDependency library : directLibraries) {
Collection<? extends ManifestDependency> subLibraries = library.getManifestDependencies();
if (subLibraries.isEmpty()) {
manifests.add(library.getManifest());
} else {
File mergeLibManifest = File.createTempFile("manifestMerge", ".xml");
mergeLibManifest.deleteOnExit();
// don't insert the attribute injection into libraries
mergeLibraryManifests(
library.getManifest(), subLibraries, mergeLibManifest, null, null);
manifests.add(mergeLibManifest);
}
}
ManifestMerger merger = new ManifestMerger(MergerLog.wrapSdkLog(mLogger), null);
merger.setInsertSourceMarkers(isInsertSourceMarkers());
doMerge(merger, outManifest, mainManifest, manifests, attributeInjection, packageOverride);
}
/**
* Returns whether we should insert source markers in generated files (such as
* XML resources and merged manifest files)
*
* @return true to generate source comments
*/
public boolean isInsertSourceMarkers() {
// In release library builds (generating AAR's) we don't want source comments.
// In other scenarios (e.g. during development) we do.
// TODO: Find out whether we're building in a release build type
boolean isRelease = false;
//noinspection ConstantConditions
return !(mLibrary && isRelease);
}
private void doMerge(ManifestMerger merger, File output, File input,
Map<String, String> injectionMap, String packageOverride) {
List<File> list = Collections.emptyList();
doMerge(merger, output, input, list, injectionMap, packageOverride);
}
private void doMerge(ManifestMerger merger, File output, File input, List<File> subManifests,
Map<String, String> injectionMap, String packageOverride) {
if (!merger.process(output, input,
subManifests.toArray(new File[subManifests.size()]),
injectionMap, packageOverride)) {
throw new RuntimeException("Manifest merging failed. See console for more info.");
}
}
/**
* Process the resources and generate R.java and/or the packaged resources.
*
* @param manifestFile the location of the manifest file
* @param resFolder the merged res folder
* @param assetsDir the merged asset folder
* @param libraries the flat list of libraries
* @param packageForR Package override to generate the R class in a different package.
* @param sourceOutputDir optional source folder to generate R.java
* @param resPackageOutput optional filepath for packaged resources
* @param proguardOutput optional filepath for proguard file to generate
* @param type the type of the variant being built
* @param debuggable whether the app is debuggable
* @param options the {@link com.android.builder.model.AaptOptions}
*
*
* @throws IOException
* @throws InterruptedException
* @throws LoggedErrorException
*/
public void processResources(
@NonNull File manifestFile,
@NonNull File resFolder,
@Nullable File assetsDir,
@NonNull List<? extends SymbolFileProvider> libraries,
@Nullable String packageForR,
@Nullable String sourceOutputDir,
@Nullable String symbolOutputDir,
@Nullable String resPackageOutput,
@Nullable String proguardOutput,
VariantConfiguration.Type type,
boolean debuggable,
@NonNull AaptOptions options,
@NonNull Collection<String> resourceConfigs)
throws IOException, InterruptedException, LoggedErrorException {
checkNotNull(manifestFile, "manifestFile cannot be null.");
checkNotNull(resFolder, "resFolder cannot be null.");
checkNotNull(libraries, "libraries cannot be null.");
checkNotNull(options, "options cannot be null.");
// if both output types are empty, then there's nothing to do and this is an error
checkArgument(sourceOutputDir != null || resPackageOutput != null,
"No output provided for aapt task");
// launch aapt: create the command line
ArrayList<String> command = Lists.newArrayList();
String aapt = mBuildTools.getPath(BuildToolInfo.PathId.AAPT);
if (aapt == null || !new File(aapt).isFile()) {
throw new IllegalStateException("aapt is missing");
}
command.add(aapt);
command.add("package");
if (mVerboseExec) {
command.add("-v");
}
command.add("-f");
command.add("--no-crunch");
// inputs
command.add("-I");
command.add(mTarget.getPath(IAndroidTarget.ANDROID_JAR));
command.add("-M");
command.add(manifestFile.getAbsolutePath());
if (resFolder.isDirectory()) {
command.add("-S");
command.add(resFolder.getAbsolutePath());
}
if (assetsDir != null && assetsDir.isDirectory()) {
command.add("-A");
command.add(assetsDir.getAbsolutePath());
}
// outputs
if (sourceOutputDir != null) {
command.add("-m");
command.add("-J");
command.add(sourceOutputDir);
}
if (resPackageOutput != null) {
command.add("-F");
command.add(resPackageOutput);
}
if (proguardOutput != null) {
command.add("-G");
command.add(proguardOutput);
}
// options controlled by build variants
if (debuggable) {
command.add("--debug-mode");
}
if (type == VariantConfiguration.Type.DEFAULT) {
if (packageForR != null) {
command.add("--custom-package");
command.add(packageForR);
mLogger.verbose("Custom package for R class: '%s'", packageForR);
}
}
// library specific options
if (type == VariantConfiguration.Type.LIBRARY) {
command.add("--non-constant-id");
}
// AAPT options
String ignoreAssets = options.getIgnoreAssets();
if (ignoreAssets != null) {
command.add("--ignore-assets");
command.add(ignoreAssets);
}
Collection<String> noCompressList = options.getNoCompress();
if (noCompressList != null) {
for (String noCompress : noCompressList) {
command.add("-0");
command.add(noCompress);
}
}
if (!resourceConfigs.isEmpty()) {
command.add("-c");
Joiner joiner = Joiner.on(',');
command.add(joiner.join(resourceConfigs));
}
if (symbolOutputDir != null &&
(type == VariantConfiguration.Type.LIBRARY || !libraries.isEmpty())) {
command.add("--output-text-symbols");
command.add(symbolOutputDir);
}
mCmdLineRunner.runCmdLine(command, null);
// now if the project has libraries, R needs to be created for each libraries,
// but only if the current project is not a library.
if (type != VariantConfiguration.Type.LIBRARY && !libraries.isEmpty()) {
SymbolLoader fullSymbolValues = null;
// First pass processing the libraries, collecting them by packageName,
// and ignoring the ones that have the same package name as the application
// (since that R class was already created).
String appPackageName = packageForR;
if (appPackageName == null) {
appPackageName = VariantConfiguration.getManifestPackage(manifestFile);
}
// list of all the symbol loaders per package names.
Multimap<String, SymbolLoader> libMap = ArrayListMultimap.create();
for (SymbolFileProvider lib : libraries) {
File rFile = lib.getSymbolFile();
// if the library has no resource, this file won't exist.
if (rFile.isFile()) {
String packageName = VariantConfiguration.getManifestPackage(lib.getManifest());
if (appPackageName.equals(packageName)) {
// ignore libraries that have the same package name as the app
continue;
}
// load the full values if that's not already been done.
// Doing it lazily allow us to support the case where there's no
// resources anywhere.
if (fullSymbolValues == null) {
fullSymbolValues = new SymbolLoader(new File(symbolOutputDir, "R.txt"),
mLogger);
fullSymbolValues.load();
}
SymbolLoader libSymbols = new SymbolLoader(rFile, mLogger);
libSymbols.load();
// store these symbols by associating them with the package name.
libMap.put(packageName, libSymbols);
}
}
// now loop on all the package name, merge all the symbols to write, and write them
for (String packageName : libMap.keySet()) {
Collection<SymbolLoader> symbols = libMap.get(packageName);
SymbolWriter writer = new SymbolWriter(sourceOutputDir, packageName,
fullSymbolValues);
for (SymbolLoader symbolLoader : symbols) {
writer.addSymbolsToWrite(symbolLoader);
}
writer.write();
}
}
}
/**
* Compiles all the aidl files found in the given source folders.
*
* @param sourceFolders all the source folders to find files to compile
* @param sourceOutputDir the output dir in which to generate the source code
* @param importFolders import folders
* @param dependencyFileProcessor the dependencyFileProcessor to record the dependencies
* of the compilation.
* @throws IOException
* @throws InterruptedException
* @throws LoggedErrorException
*/
public void compileAllAidlFiles(@NonNull List<File> sourceFolders,
@NonNull File sourceOutputDir,
@NonNull List<File> importFolders,
@Nullable DependencyFileProcessor dependencyFileProcessor)
throws IOException, InterruptedException, LoggedErrorException {
checkNotNull(sourceFolders, "sourceFolders cannot be null.");
checkNotNull(sourceOutputDir, "sourceOutputDir cannot be null.");
checkNotNull(importFolders, "importFolders cannot be null.");
String aidl = mBuildTools.getPath(BuildToolInfo.PathId.AIDL);
if (aidl == null || !new File(aidl).isFile()) {
throw new IllegalStateException("aidl is missing");
}
List<File> fullImportList = Lists.newArrayListWithCapacity(
sourceFolders.size() + importFolders.size());
fullImportList.addAll(sourceFolders);
fullImportList.addAll(importFolders);
AidlProcessor processor = new AidlProcessor(
aidl,
mTarget.getPath(IAndroidTarget.ANDROID_AIDL),
fullImportList,
sourceOutputDir,
dependencyFileProcessor != null ?
dependencyFileProcessor : sNoOpDependencyFileProcessor,
mCmdLineRunner);
SourceSearcher searcher = new SourceSearcher(sourceFolders, "aidl");
searcher.setUseExecutor(true);
searcher.search(processor);
}
/**
* Compiles the given aidl file.
*
* @param aidlFile the AIDL file to compile
* @param sourceOutputDir the output dir in which to generate the source code
* @param importFolders all the import folders, including the source folders.
* @param dependencyFileProcessor the dependencyFileProcessor to record the dependencies
* of the compilation.
* @throws IOException
* @throws InterruptedException
* @throws LoggedErrorException
*/
public void compileAidlFile(@NonNull File aidlFile,
@NonNull File sourceOutputDir,
@NonNull List<File> importFolders,
@Nullable DependencyFileProcessor dependencyFileProcessor)
throws IOException, InterruptedException, LoggedErrorException {
checkNotNull(aidlFile, "aidlFile cannot be null.");
checkNotNull(sourceOutputDir, "sourceOutputDir cannot be null.");
checkNotNull(importFolders, "importFolders cannot be null.");
String aidl = mBuildTools.getPath(BuildToolInfo.PathId.AIDL);
if (aidl == null || !new File(aidl).isFile()) {
throw new IllegalStateException("aidl is missing");
}
AidlProcessor processor = new AidlProcessor(
aidl,
mTarget.getPath(IAndroidTarget.ANDROID_AIDL),
importFolders,
sourceOutputDir,
dependencyFileProcessor != null ?
dependencyFileProcessor : sNoOpDependencyFileProcessor,
mCmdLineRunner);
processor.processFile(aidlFile);
}
/**
* Compiles all the renderscript files found in the given source folders.
*
* Right now this is the only way to compile them as the renderscript compiler requires all
* renderscript files to be passed for all compilation.
*
* Therefore whenever a renderscript file or header changes, all must be recompiled.
*
* @param sourceFolders all the source folders to find files to compile
* @param importFolders all the import folders.
* @param sourceOutputDir the output dir in which to generate the source code
* @param resOutputDir the output dir in which to generate the bitcode file
* @param targetApi the target api
* @param debugBuild whether the build is debug
* @param optimLevel the optimization level
*
* @throws IOException
* @throws InterruptedException
* @throws LoggedErrorException
*/
public void compileAllRenderscriptFiles(@NonNull List<File> sourceFolders,
@NonNull List<File> importFolders,
@NonNull File sourceOutputDir,
@NonNull File resOutputDir,
@NonNull File objOutputDir,
@NonNull File libOutputDir,
int targetApi,
boolean debugBuild,
int optimLevel,
boolean ndkMode,
boolean supportMode,
@Nullable Set<String> abiFilters)
throws IOException, InterruptedException, LoggedErrorException {
checkNotNull(sourceFolders, "sourceFolders cannot be null.");
checkNotNull(importFolders, "importFolders cannot be null.");
checkNotNull(sourceOutputDir, "sourceOutputDir cannot be null.");
checkNotNull(resOutputDir, "resOutputDir cannot be null.");
String renderscript = mBuildTools.getPath(BuildToolInfo.PathId.LLVM_RS_CC);
if (renderscript == null || !new File(renderscript).isFile()) {
throw new IllegalStateException("llvm-rs-cc is missing");
}
if (supportMode && mBuildTools.getRevision().compareTo(new FullRevision(18,1, 0)) == -1) {
throw new IllegalStateException(
"RenderScript Support Mode requires buildToolsVersion >= 18.1");
}
RenderScriptProcessor processor = new RenderScriptProcessor(
sourceFolders,
importFolders,
sourceOutputDir,
resOutputDir,
objOutputDir,
libOutputDir,
mBuildTools,
targetApi,
debugBuild,
optimLevel,
ndkMode,
supportMode,
abiFilters);
processor.build(mCmdLineRunner);
}
/**
* Computes and returns the leaf folders based on a given file extension.
*
* This looks through all the given root import folders, and recursively search for leaf
* folders containing files matching the given extensions. All the leaf folders are gathered
* and returned in the list.
*
* @param extension the extension to search for.
* @param importFolders an array of list of root folders.
* @return a list of leaf folder, never null.
*/
@NonNull
public List<File> getLeafFolders(@NonNull String extension, List<File>... importFolders) {
List<File> results = Lists.newArrayList();
if (importFolders != null) {
for (List<File> folders : importFolders) {
SourceSearcher searcher = new SourceSearcher(folders, extension);
searcher.setUseExecutor(false);
LeafFolderGatherer processor = new LeafFolderGatherer();
try {
searcher.search(processor);
} catch (InterruptedException e) {
// wont happen as we're not using the executor, and our processor
// doesn't throw those.
} catch (IOException e) {
// wont happen as we're not using the executor, and our processor
// doesn't throw those.
} catch (LoggedErrorException e) {
// wont happen as we're not using the executor, and our processor
// doesn't throw those.
}
results.addAll(processor.getFolders());
}
}
return results;
}
/**
* Converts the bytecode to Dalvik format
* @param inputs the input files
* @param preDexedLibraries the list of pre-dexed libraries
* @param outDexFile the location of the output classes.dex file
* @param dexOptions dex options
* @param incremental true if it should attempt incremental dex if applicable
*
* @throws IOException
* @throws InterruptedException
* @throws LoggedErrorException
*/
public void convertByteCode(
@NonNull Iterable<File> inputs,
@NonNull Iterable<File> preDexedLibraries,
@NonNull File outDexFile,
@NonNull DexOptions dexOptions,
boolean incremental) throws IOException, InterruptedException, LoggedErrorException {
checkNotNull(inputs, "inputs cannot be null.");
checkNotNull(preDexedLibraries, "preDexedLibraries cannot be null.");
checkNotNull(outDexFile, "outDexFile cannot be null.");
checkNotNull(dexOptions, "dexOptions cannot be null.");
// launch dx: create the command line
ArrayList<String> command = Lists.newArrayList();
String dx = mBuildTools.getPath(BuildToolInfo.PathId.DX);
if (dx == null || !new File(dx).isFile()) {
throw new IllegalStateException("dx is missing");
}
command.add(dx);
if (dexOptions.getJavaMaxHeapSize() != null) {
command.add("-JXmx" + dexOptions.getJavaMaxHeapSize());
}
command.add("--dex");
if (mVerboseExec) {
command.add("--verbose");
}
if (dexOptions.isCoreLibrary()) {
command.add("--core-library");
}
if (dexOptions.getJumboMode()) {
command.add("--force-jumbo");
}
if (incremental) {
command.add("--incremental");
command.add("--no-strict");
}
command.add("--output");
command.add(outDexFile.getAbsolutePath());
// clean up input list
List<String> inputList = Lists.newArrayList();
for (File f : inputs) {
if (f != null && f.exists()) {
inputList.add(f.getAbsolutePath());
}
}
if (!inputList.isEmpty()) {
mLogger.verbose("Dex inputs: " + inputList);
command.addAll(inputList);
}
// clean up and add library inputs.
List<String> libraryList = Lists.newArrayList();
for (File f : preDexedLibraries) {
if (f != null && f.exists()) {
libraryList.add(f.getAbsolutePath());
}
}
if (!libraryList.isEmpty()) {
mLogger.verbose("Dex pre-dexed inputs: " + libraryList);
command.addAll(libraryList);
}
mCmdLineRunner.runCmdLine(command, null);
}
/**
* Converts the bytecode to Dalvik format
* @param inputFile the input file
* @param outFile the location of the output classes.dex file
* @param dexOptions dex options
*
* @throws IOException
* @throws InterruptedException
* @throws LoggedErrorException
*/
public void preDexLibrary(
@NonNull File inputFile,
@NonNull File outFile,
@NonNull DexOptions dexOptions)
throws IOException, InterruptedException, LoggedErrorException {
checkNotNull(inputFile, "inputFile cannot be null.");
checkNotNull(outFile, "outFile cannot be null.");
checkNotNull(dexOptions, "dexOptions cannot be null.");
// launch dx: create the command line
ArrayList<String> command = Lists.newArrayList();
String dx = mBuildTools.getPath(BuildToolInfo.PathId.DX);
if (dx == null || !new File(dx).isFile()) {
throw new IllegalStateException("dx is missing");
}
command.add(dx);
if (dexOptions.getJavaMaxHeapSize() != null) {
command.add("-JXmx" + dexOptions.getJavaMaxHeapSize());
}
command.add("--dex");
if (mVerboseExec) {
command.add("--verbose");
}
if (dexOptions.isCoreLibrary()) {
command.add("--core-library");
}
if (dexOptions.getJumboMode()) {
command.add("--force-jumbo");
}
command.add("--output");
command.add(outFile.getAbsolutePath());
command.add(inputFile.getAbsolutePath());
mCmdLineRunner.runCmdLine(command, null);
}
/**
* Packages the apk.
*
* @param androidResPkgLocation the location of the packaged resource file
* @param classesDexLocation the location of the classes.dex file
* @param packagedJars the jars that are packaged (libraries + jar dependencies)
* @param javaResourcesLocation the processed Java resource folder
* @param jniLibsFolders the folders containing jni shared libraries
* @param abiFilters optional ABI filter
* @param jniDebugBuild whether the app should include jni debug data
* @param signingConfig the signing configuration
* @param outApkLocation location of the APK.
* @throws DuplicateFileException
* @throws FileNotFoundException if the store location was not found
* @throws KeytoolException
* @throws PackagerException
* @throws SigningException when the key cannot be read from the keystore
*
* @see com.android.builder.VariantConfiguration#getPackagedJars()
*/
public void packageApk(
@NonNull String androidResPkgLocation,
@NonNull String classesDexLocation,
@NonNull List<File> packagedJars,
@Nullable String javaResourcesLocation,
@Nullable Collection<File> jniLibsFolders,
@Nullable Set<String> abiFilters,
boolean jniDebugBuild,
@Nullable SigningConfig signingConfig,
@NonNull String outApkLocation) throws DuplicateFileException, FileNotFoundException,
KeytoolException, PackagerException, SigningException {
checkNotNull(androidResPkgLocation, "androidResPkgLocation cannot be null.");
checkNotNull(classesDexLocation, "classesDexLocation cannot be null.");
checkNotNull(outApkLocation, "outApkLocation cannot be null.");
CertificateInfo certificateInfo = null;
if (signingConfig != null && signingConfig.isSigningReady()) {
certificateInfo = KeystoreHelper.getCertificateInfo(signingConfig);
if (certificateInfo == null) {
throw new SigningException("Failed to read key from keystore");
}
}
try {
Packager packager = new Packager(
outApkLocation, androidResPkgLocation, classesDexLocation,
certificateInfo, mCreatedBy, mLogger);
packager.setJniDebugMode(jniDebugBuild);
// figure out conflicts!
JavaResourceProcessor resProcessor = new JavaResourceProcessor(packager);
if (javaResourcesLocation != null) {
resProcessor.addSourceFolder(javaResourcesLocation);
}
// add the resources from the jar files.
for (File jar : packagedJars) {
packager.addResourcesFromJar(jar);
}
// also add resources from library projects and jars
if (jniLibsFolders != null) {
for (File jniFolder : jniLibsFolders) {
packager.addNativeLibraries(jniFolder, abiFilters);
}
}
packager.sealApk();
} catch (SealedPackageException e) {
// shouldn't happen since we control the package from start to end.
throw new RuntimeException(e);
}
}
}