| /* |
| * Copyright (C) 2010 The Android Open Source Project |
| * |
| * Licensed under the Eclipse Public License, Version 1.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.eclipse.org/org/documents/epl-v10.php |
| * |
| * 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.ide.eclipse.adt.internal.build; |
| |
| import com.android.SdkConstants; |
| import com.android.annotations.NonNull; |
| import com.android.annotations.Nullable; |
| import com.android.ide.eclipse.adt.AdtConstants; |
| import com.android.ide.eclipse.adt.AdtPlugin; |
| import com.android.ide.eclipse.adt.AndroidPrintStream; |
| import com.android.ide.eclipse.adt.internal.preferences.AdtPrefs; |
| import com.android.ide.eclipse.adt.internal.preferences.AdtPrefs.BuildVerbosity; |
| import com.android.ide.eclipse.adt.internal.project.BaseProjectHelper; |
| import com.android.ide.eclipse.adt.internal.sdk.ProjectState; |
| import com.android.ide.eclipse.adt.internal.sdk.Sdk; |
| import com.android.prefs.AndroidLocation.AndroidLocationException; |
| import com.android.sdklib.BuildToolInfo; |
| import com.android.sdklib.IAndroidTarget; |
| import com.android.sdklib.IAndroidTarget.IOptionalLibrary; |
| import com.android.sdklib.build.ApkBuilder; |
| import com.android.sdklib.build.ApkBuilder.JarStatus; |
| import com.android.sdklib.build.ApkBuilder.SigningInfo; |
| import com.android.sdklib.build.ApkCreationException; |
| import com.android.sdklib.build.DuplicateFileException; |
| import com.android.sdklib.build.RenderScriptProcessor; |
| import com.android.sdklib.build.SealedApkException; |
| import com.android.sdklib.internal.build.DebugKeyProvider; |
| import com.android.sdklib.internal.build.DebugKeyProvider.KeytoolException; |
| import com.android.utils.GrabProcessOutput; |
| import com.android.utils.GrabProcessOutput.IProcessOutput; |
| import com.android.utils.GrabProcessOutput.Wait; |
| import com.google.common.base.Charsets; |
| import com.google.common.hash.HashCode; |
| import com.google.common.hash.HashFunction; |
| import com.google.common.hash.Hashing; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IFolder; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.IWorkspaceRoot; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.jdt.core.IClasspathContainer; |
| import org.eclipse.jdt.core.IClasspathEntry; |
| import org.eclipse.jdt.core.IJavaProject; |
| import org.eclipse.jdt.core.JavaCore; |
| import org.eclipse.jdt.core.JavaModelException; |
| import org.eclipse.jface.preference.IPreferenceStore; |
| |
| import java.io.File; |
| import java.io.FileWriter; |
| import java.io.IOException; |
| import java.io.PrintStream; |
| import java.security.PrivateKey; |
| import java.security.cert.X509Certificate; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.TreeMap; |
| |
| /** |
| * Helper with methods for the last 3 steps of the generation of an APK. |
| * |
| * {@link #packageResources(IFile, IProject[], String, int, String, String)} packages the |
| * application resources using aapt into a zip file that is ready to be integrated into the apk. |
| * |
| * {@link #executeDx(IJavaProject, String, String, IJavaProject[])} will convert the Java byte |
| * code into the Dalvik bytecode. |
| * |
| * {@link #finalPackage(String, String, String, boolean, IJavaProject, IProject[], IJavaProject[], String, boolean)} |
| * will make the apk from all the previous components. |
| * |
| * This class only executes the 3 above actions. It does not handle the errors, and simply sends |
| * them back as custom exceptions. |
| * |
| * Warnings are handled by the {@link ResourceMarker} interface. |
| * |
| * Console output (verbose and non verbose) is handled through the {@link AndroidPrintStream} passed |
| * to the constructor. |
| * |
| */ |
| public class BuildHelper { |
| |
| private static final String CONSOLE_PREFIX_DX = "Dx"; //$NON-NLS-1$ |
| private final static String TEMP_PREFIX = "android_"; //$NON-NLS-1$ |
| |
| private static final String COMMAND_CRUNCH = "crunch"; //$NON-NLS-1$ |
| private static final String COMMAND_PACKAGE = "package"; //$NON-NLS-1$ |
| |
| @NonNull |
| private final ProjectState mProjectState; |
| @NonNull |
| private final IProject mProject; |
| @NonNull |
| private final BuildToolInfo mBuildToolInfo; |
| @NonNull |
| private final AndroidPrintStream mOutStream; |
| @NonNull |
| private final AndroidPrintStream mErrStream; |
| private final boolean mForceJumbo; |
| private final boolean mDisableDexMerger; |
| private final boolean mVerbose; |
| private final boolean mDebugMode; |
| |
| private final Set<String> mCompiledCodePaths = new HashSet<String>(); |
| |
| public static final boolean BENCHMARK_FLAG = false; |
| public static long sStartOverallTime = 0; |
| public static long sStartJavaCTime = 0; |
| |
| private final static int MILLION = 1000000; |
| private String mProguardFile; |
| |
| /** |
| * An object able to put a marker on a resource. |
| */ |
| public interface ResourceMarker { |
| void setWarning(IResource resource, String message); |
| } |
| |
| /** |
| * Creates a new post-compiler helper |
| * @param project |
| * @param outStream |
| * @param errStream |
| * @param debugMode whether this is a debug build |
| * @param verbose |
| * @throws CoreException |
| */ |
| public BuildHelper(@NonNull ProjectState projectState, |
| @NonNull BuildToolInfo buildToolInfo, |
| @NonNull AndroidPrintStream outStream, |
| @NonNull AndroidPrintStream errStream, |
| boolean forceJumbo, boolean disableDexMerger, boolean debugMode, |
| boolean verbose, ResourceMarker resMarker) throws CoreException { |
| mProjectState = projectState; |
| mProject = projectState.getProject(); |
| mBuildToolInfo = buildToolInfo; |
| mOutStream = outStream; |
| mErrStream = errStream; |
| mDebugMode = debugMode; |
| mVerbose = verbose; |
| mForceJumbo = forceJumbo; |
| mDisableDexMerger = disableDexMerger; |
| |
| gatherPaths(resMarker); |
| } |
| |
| public void updateCrunchCache() throws AaptExecException, AaptResultException { |
| // Benchmarking start |
| long startCrunchTime = 0; |
| if (BENCHMARK_FLAG) { |
| String msg = "BENCHMARK ADT: Starting Initial Packaging (.ap_)"; //$NON-NLS-1$ |
| AdtPlugin.printBuildToConsole(BuildVerbosity.ALWAYS, mProject, msg); |
| startCrunchTime = System.nanoTime(); |
| } |
| |
| // Get the resources folder to crunch from |
| IFolder resFolder = mProject.getFolder(AdtConstants.WS_RESOURCES); |
| List<String> resPaths = new ArrayList<String>(); |
| resPaths.add(resFolder.getLocation().toOSString()); |
| |
| // Get the output folder where the cache is stored. |
| IFolder binFolder = BaseProjectHelper.getAndroidOutputFolder(mProject); |
| IFolder cacheFolder = binFolder.getFolder(AdtConstants.WS_BIN_RELATIVE_CRUNCHCACHE); |
| String cachePath = cacheFolder.getLocation().toOSString(); |
| |
| /* For crunching, we don't need the osManifestPath, osAssetsPath, or the configFilter |
| * parameters for executeAapt |
| */ |
| executeAapt(COMMAND_CRUNCH, "", resPaths, "", cachePath, "", 0); |
| |
| // Benchmarking end |
| if (BENCHMARK_FLAG) { |
| String msg = "BENCHMARK ADT: Ending Initial Package (.ap_). \nTime Elapsed: " //$NON-NLS-1$ |
| + ((System.nanoTime() - startCrunchTime)/MILLION) + "ms"; //$NON-NLS-1$ |
| AdtPlugin.printBuildToConsole(BuildVerbosity.ALWAYS, mProject, msg); |
| } |
| } |
| |
| /** |
| * Packages the resources of the projet into a .ap_ file. |
| * @param manifestFile the manifest of the project. |
| * @param libProjects the list of library projects that this project depends on. |
| * @param resFilter an optional resource filter to be used with the -c option of aapt. If null |
| * no filters are used. |
| * @param versionCode an optional versionCode to be inserted in the manifest during packaging. |
| * If the value is <=0, no values are inserted. |
| * @param outputFolder where to write the resource ap_ file. |
| * @param outputFilename the name of the resource ap_ file. |
| * @throws AaptExecException |
| * @throws AaptResultException |
| */ |
| public void packageResources(IFile manifestFile, List<IProject> libProjects, String resFilter, |
| int versionCode, String outputFolder, String outputFilename) |
| throws AaptExecException, AaptResultException { |
| |
| // Benchmarking start |
| long startPackageTime = 0; |
| if (BENCHMARK_FLAG) { |
| String msg = "BENCHMARK ADT: Starting Initial Packaging (.ap_)"; //$NON-NLS-1$ |
| AdtPlugin.printBuildToConsole(BuildVerbosity.ALWAYS, mProject, msg); |
| startPackageTime = System.nanoTime(); |
| } |
| |
| // need to figure out some path before we can execute aapt; |
| IFolder binFolder = BaseProjectHelper.getAndroidOutputFolder(mProject); |
| |
| // get the cache folder |
| IFolder cacheFolder = binFolder.getFolder(AdtConstants.WS_BIN_RELATIVE_CRUNCHCACHE); |
| |
| // get the BC folder |
| IFolder bcFolder = binFolder.getFolder(AdtConstants.WS_BIN_RELATIVE_BC); |
| |
| // get the resource folder |
| IFolder resFolder = mProject.getFolder(AdtConstants.WS_RESOURCES); |
| |
| // and the assets folder |
| IFolder assetsFolder = mProject.getFolder(AdtConstants.WS_ASSETS); |
| |
| // we need to make sure this one exists. |
| if (assetsFolder.exists() == false) { |
| assetsFolder = null; |
| } |
| |
| // list of res folder (main project + maybe libraries) |
| ArrayList<String> osResPaths = new ArrayList<String>(); |
| |
| IPath resLocation = resFolder.getLocation(); |
| IPath manifestLocation = manifestFile.getLocation(); |
| |
| if (resLocation != null && manifestLocation != null) { |
| |
| // png cache folder first. |
| addFolderToList(osResPaths, cacheFolder); |
| addFolderToList(osResPaths, bcFolder); |
| |
| // regular res folder next. |
| osResPaths.add(resLocation.toOSString()); |
| |
| // then libraries |
| if (libProjects != null) { |
| for (IProject lib : libProjects) { |
| // png cache folder first |
| IFolder libBinFolder = BaseProjectHelper.getAndroidOutputFolder(lib); |
| |
| IFolder libCacheFolder = libBinFolder.getFolder(AdtConstants.WS_BIN_RELATIVE_CRUNCHCACHE); |
| addFolderToList(osResPaths, libCacheFolder); |
| |
| IFolder libBcFolder = libBinFolder.getFolder(AdtConstants.WS_BIN_RELATIVE_BC); |
| addFolderToList(osResPaths, libBcFolder); |
| |
| // regular res folder next. |
| IFolder libResFolder = lib.getFolder(AdtConstants.WS_RESOURCES); |
| addFolderToList(osResPaths, libResFolder); |
| } |
| } |
| |
| String osManifestPath = manifestLocation.toOSString(); |
| |
| String osAssetsPath = null; |
| if (assetsFolder != null) { |
| osAssetsPath = assetsFolder.getLocation().toOSString(); |
| } |
| |
| // build the default resource package |
| executeAapt(COMMAND_PACKAGE, osManifestPath, osResPaths, osAssetsPath, |
| outputFolder + File.separator + outputFilename, resFilter, |
| versionCode); |
| } |
| |
| // Benchmarking end |
| if (BENCHMARK_FLAG) { |
| String msg = "BENCHMARK ADT: Ending Initial Package (.ap_). \nTime Elapsed: " //$NON-NLS-1$ |
| + ((System.nanoTime() - startPackageTime)/MILLION) + "ms"; //$NON-NLS-1$ |
| AdtPlugin.printBuildToConsole(BuildVerbosity.ALWAYS, mProject, msg); |
| } |
| } |
| |
| /** |
| * Adds os path of a folder to a list only if the folder actually exists. |
| * @param pathList |
| * @param folder |
| */ |
| private void addFolderToList(List<String> pathList, IFolder folder) { |
| // use a File instead of the IFolder API to ignore workspace refresh issue. |
| File testFile = new File(folder.getLocation().toOSString()); |
| if (testFile.isDirectory()) { |
| pathList.add(testFile.getAbsolutePath()); |
| } |
| } |
| |
| /** |
| * Makes a final package signed with the debug key. |
| * |
| * Packages the dex files, the temporary resource file into the final package file. |
| * |
| * Whether the package is a debug package is controlled with the <var>debugMode</var> parameter |
| * in {@link #PostCompilerHelper(IProject, PrintStream, PrintStream, boolean, boolean)} |
| * |
| * @param intermediateApk The path to the temporary resource file. |
| * @param dex The path to the dex file. |
| * @param output The path to the final package file to create. |
| * @param libProjects an optional list of library projects (can be null) |
| * @return true if success, false otherwise. |
| * @throws ApkCreationException |
| * @throws AndroidLocationException |
| * @throws KeytoolException |
| * @throws NativeLibInJarException |
| * @throws CoreException |
| * @throws DuplicateFileException |
| */ |
| public void finalDebugPackage(String intermediateApk, String dex, String output, |
| List<IProject> libProjects, ResourceMarker resMarker) |
| throws ApkCreationException, KeytoolException, AndroidLocationException, |
| NativeLibInJarException, DuplicateFileException, CoreException { |
| |
| AdtPlugin adt = AdtPlugin.getDefault(); |
| if (adt == null) { |
| return; |
| } |
| |
| // get the debug keystore to use. |
| IPreferenceStore store = adt.getPreferenceStore(); |
| String keystoreOsPath = store.getString(AdtPrefs.PREFS_CUSTOM_DEBUG_KEYSTORE); |
| if (keystoreOsPath == null || new File(keystoreOsPath).isFile() == false) { |
| keystoreOsPath = DebugKeyProvider.getDefaultKeyStoreOsPath(); |
| AdtPlugin.printBuildToConsole(BuildVerbosity.VERBOSE, mProject, |
| Messages.ApkBuilder_Using_Default_Key); |
| } else { |
| AdtPlugin.printBuildToConsole(BuildVerbosity.VERBOSE, mProject, |
| String.format(Messages.ApkBuilder_Using_s_To_Sign, keystoreOsPath)); |
| } |
| |
| // from the keystore, get the signing info |
| SigningInfo info = ApkBuilder.getDebugKey(keystoreOsPath, mVerbose ? mOutStream : null); |
| |
| finalPackage(intermediateApk, dex, output, libProjects, |
| info != null ? info.key : null, info != null ? info.certificate : null, resMarker); |
| } |
| |
| /** |
| * Makes the final package. |
| * |
| * Packages the dex files, the temporary resource file into the final package file. |
| * |
| * Whether the package is a debug package is controlled with the <var>debugMode</var> parameter |
| * in {@link #PostCompilerHelper(IProject, PrintStream, PrintStream, boolean, boolean)} |
| * |
| * @param intermediateApk The path to the temporary resource file. |
| * @param dex The path to the dex file. |
| * @param output The path to the final package file to create. |
| * @param debugSign whether the apk must be signed with the debug key. |
| * @param libProjects an optional list of library projects (can be null) |
| * @param abiFilter an optional filter. If not null, then only the matching ABI is included in |
| * the final archive |
| * @return true if success, false otherwise. |
| * @throws NativeLibInJarException |
| * @throws ApkCreationException |
| * @throws CoreException |
| * @throws DuplicateFileException |
| */ |
| public void finalPackage(String intermediateApk, String dex, String output, |
| List<IProject> libProjects, |
| PrivateKey key, X509Certificate certificate, ResourceMarker resMarker) |
| throws NativeLibInJarException, ApkCreationException, DuplicateFileException, |
| CoreException { |
| |
| try { |
| ApkBuilder apkBuilder = new ApkBuilder(output, intermediateApk, dex, |
| key, certificate, |
| mVerbose ? mOutStream: null); |
| apkBuilder.setDebugMode(mDebugMode); |
| |
| // either use the full compiled code paths or just the proguard file |
| // if present |
| Collection<String> pathsCollection = mCompiledCodePaths; |
| if (mProguardFile != null) { |
| pathsCollection = Collections.singletonList(mProguardFile); |
| mProguardFile = null; |
| } |
| |
| // Now we write the standard resources from all the output paths. |
| for (String path : pathsCollection) { |
| File file = new File(path); |
| if (file.isFile()) { |
| JarStatus jarStatus = apkBuilder.addResourcesFromJar(file); |
| |
| // check if we found native libraries in the external library. This |
| // constitutes an error or warning depending on if they are in lib/ |
| if (jarStatus.getNativeLibs().size() > 0) { |
| String libName = file.getName(); |
| |
| String msg = String.format( |
| "Native libraries detected in '%1$s'. See console for more information.", |
| libName); |
| |
| ArrayList<String> consoleMsgs = new ArrayList<String>(); |
| |
| consoleMsgs.add(String.format( |
| "The library '%1$s' contains native libraries that will not run on the device.", |
| libName)); |
| |
| if (jarStatus.hasNativeLibsConflicts()) { |
| consoleMsgs.add("Additionally some of those libraries will interfer with the installation of the application because of their location in lib/"); |
| consoleMsgs.add("lib/ is reserved for NDK libraries."); |
| } |
| |
| consoleMsgs.add("The following libraries were found:"); |
| |
| for (String lib : jarStatus.getNativeLibs()) { |
| consoleMsgs.add(" - " + lib); |
| } |
| |
| String[] consoleStrings = consoleMsgs.toArray(new String[consoleMsgs.size()]); |
| |
| // if there's a conflict or if the prefs force error on any native code in jar |
| // files, throw an exception |
| if (jarStatus.hasNativeLibsConflicts() || |
| AdtPrefs.getPrefs().getBuildForceErrorOnNativeLibInJar()) { |
| throw new NativeLibInJarException(jarStatus, msg, libName, consoleStrings); |
| } else { |
| // otherwise, put a warning, and output to the console also. |
| if (resMarker != null) { |
| resMarker.setWarning(mProject, msg); |
| } |
| |
| for (String string : consoleStrings) { |
| mOutStream.println(string); |
| } |
| } |
| } |
| } else if (file.isDirectory()) { |
| // this is technically not a source folder (class folder instead) but since we |
| // only care about Java resources (ie non class/java files) this will do the |
| // same |
| apkBuilder.addSourceFolder(file); |
| } |
| } |
| |
| // now write the native libraries. |
| // First look if the lib folder is there. |
| IResource libFolder = mProject.findMember(SdkConstants.FD_NATIVE_LIBS); |
| if (libFolder != null && libFolder.exists() && |
| libFolder.getType() == IResource.FOLDER) { |
| // get a File for the folder. |
| apkBuilder.addNativeLibraries(libFolder.getLocation().toFile()); |
| } |
| |
| // next the native libraries for the renderscript support mode. |
| if (mProjectState.getRenderScriptSupportMode()) { |
| IFolder androidOutputFolder = BaseProjectHelper.getAndroidOutputFolder(mProject); |
| IResource rsLibFolder = androidOutputFolder.getFolder( |
| AdtConstants.WS_BIN_RELATIVE_RS_LIBS); |
| File rsLibFolderFile = rsLibFolder.getLocation().toFile(); |
| if (rsLibFolderFile.isDirectory()) { |
| apkBuilder.addNativeLibraries(rsLibFolderFile); |
| } |
| |
| File rsLibs = RenderScriptProcessor.getSupportNativeLibFolder( |
| mBuildToolInfo.getLocation().getAbsolutePath()); |
| if (rsLibs.isDirectory()) { |
| apkBuilder.addNativeLibraries(rsLibs); |
| } |
| } |
| |
| // write the native libraries for the library projects. |
| if (libProjects != null) { |
| for (IProject lib : libProjects) { |
| libFolder = lib.findMember(SdkConstants.FD_NATIVE_LIBS); |
| if (libFolder != null && libFolder.exists() && |
| libFolder.getType() == IResource.FOLDER) { |
| apkBuilder.addNativeLibraries(libFolder.getLocation().toFile()); |
| } |
| } |
| } |
| |
| // seal the APK. |
| apkBuilder.sealApk(); |
| } catch (SealedApkException e) { |
| // this won't happen as we control when the apk is sealed. |
| } |
| } |
| |
| public void setProguardOutput(String proguardFile) { |
| mProguardFile = proguardFile; |
| } |
| |
| public Collection<String> getCompiledCodePaths() { |
| return mCompiledCodePaths; |
| } |
| |
| public void runProguard(List<File> proguardConfigs, File inputJar, Collection<String> jarFiles, |
| File obfuscatedJar, File logOutput) |
| throws ProguardResultException, ProguardExecException, IOException { |
| IAndroidTarget target = Sdk.getCurrent().getTarget(mProject); |
| |
| // prepare the command line for proguard |
| List<String> command = new ArrayList<String>(); |
| command.add(AdtPlugin.getOsAbsoluteProguard()); |
| |
| for (File configFile : proguardConfigs) { |
| command.add("-include"); //$NON-NLS-1$ |
| command.add(quotePath(configFile.getAbsolutePath())); |
| } |
| |
| command.add("-injars"); //$NON-NLS-1$ |
| StringBuilder sb = new StringBuilder(quotePath(inputJar.getAbsolutePath())); |
| for (String jarFile : jarFiles) { |
| sb.append(File.pathSeparatorChar); |
| sb.append(quotePath(jarFile)); |
| } |
| command.add(quoteWinArg(sb.toString())); |
| |
| command.add("-outjars"); //$NON-NLS-1$ |
| command.add(quotePath(obfuscatedJar.getAbsolutePath())); |
| |
| command.add("-libraryjars"); //$NON-NLS-1$ |
| sb = new StringBuilder(quotePath(target.getPath(IAndroidTarget.ANDROID_JAR))); |
| IOptionalLibrary[] libraries = target.getOptionalLibraries(); |
| if (libraries != null) { |
| for (IOptionalLibrary lib : libraries) { |
| sb.append(File.pathSeparatorChar); |
| sb.append(quotePath(lib.getJarPath())); |
| } |
| } |
| command.add(quoteWinArg(sb.toString())); |
| |
| if (logOutput != null) { |
| if (logOutput.isDirectory() == false) { |
| logOutput.mkdirs(); |
| } |
| |
| command.add("-dump"); //$NON-NLS-1$ |
| command.add(new File(logOutput, "dump.txt").getAbsolutePath()); //$NON-NLS-1$ |
| |
| command.add("-printseeds"); //$NON-NLS-1$ |
| command.add(new File(logOutput, "seeds.txt").getAbsolutePath()); //$NON-NLS-1$ |
| |
| command.add("-printusage"); //$NON-NLS-1$ |
| command.add(new File(logOutput, "usage.txt").getAbsolutePath()); //$NON-NLS-1$ |
| |
| command.add("-printmapping"); //$NON-NLS-1$ |
| command.add(new File(logOutput, "mapping.txt").getAbsolutePath()); //$NON-NLS-1$ |
| } |
| |
| String commandArray[] = null; |
| |
| if (SdkConstants.currentPlatform() == SdkConstants.PLATFORM_WINDOWS) { |
| commandArray = createWindowsProguardConfig(command); |
| } |
| |
| if (commandArray == null) { |
| // For Mac & Linux, use a regular command string array. |
| commandArray = command.toArray(new String[command.size()]); |
| } |
| |
| // Define PROGUARD_HOME to point to $SDK/tools/proguard if it's not yet defined. |
| // The Mac/Linux proguard.sh can infer it correctly but not the proguard.bat one. |
| String[] envp = null; |
| Map<String, String> envMap = new TreeMap<String, String>(System.getenv()); |
| if (!envMap.containsKey("PROGUARD_HOME")) { //$NON-NLS-1$ |
| envMap.put("PROGUARD_HOME", Sdk.getCurrent().getSdkOsLocation() + //$NON-NLS-1$ |
| SdkConstants.FD_TOOLS + File.separator + |
| SdkConstants.FD_PROGUARD); |
| envp = new String[envMap.size()]; |
| int i = 0; |
| for (Map.Entry<String, String> entry : envMap.entrySet()) { |
| envp[i++] = String.format("%1$s=%2$s", //$NON-NLS-1$ |
| entry.getKey(), |
| entry.getValue()); |
| } |
| } |
| |
| if (AdtPrefs.getPrefs().getBuildVerbosity() == BuildVerbosity.VERBOSE) { |
| sb = new StringBuilder(); |
| for (String c : commandArray) { |
| sb.append(c).append(' '); |
| } |
| AdtPlugin.printToConsole(mProject, sb.toString()); |
| } |
| |
| // launch |
| int execError = 1; |
| try { |
| // launch the command line process |
| Process process = Runtime.getRuntime().exec(commandArray, envp); |
| |
| // list to store each line of stderr |
| ArrayList<String> results = new ArrayList<String>(); |
| |
| // get the output and return code from the process |
| execError = grabProcessOutput(mProject, process, results); |
| |
| if (mVerbose) { |
| for (String resultString : results) { |
| mOutStream.println(resultString); |
| } |
| } |
| |
| if (execError != 0) { |
| throw new ProguardResultException(execError, |
| results.toArray(new String[results.size()])); |
| } |
| |
| } catch (IOException e) { |
| String msg = String.format(Messages.Proguard_Exec_Error, commandArray[0]); |
| throw new ProguardExecException(msg, e); |
| } catch (InterruptedException e) { |
| String msg = String.format(Messages.Proguard_Exec_Error, commandArray[0]); |
| throw new ProguardExecException(msg, e); |
| } |
| } |
| |
| /** |
| * For tools R8 up to R11, the proguard.bat launcher on Windows only accepts |
| * arguments %1..%9. Since we generally have about 15 arguments, we were working |
| * around this by generating a temporary config file for proguard and then using |
| * that. |
| * Starting with tools R12, the proguard.bat launcher has been fixed to take |
| * all arguments using %* so we no longer need this hack. |
| * |
| * @param command |
| * @return |
| * @throws IOException |
| */ |
| private String[] createWindowsProguardConfig(List<String> command) throws IOException { |
| |
| // Arg 0 is the proguard.bat path and arg 1 is the user config file |
| String launcher = AdtPlugin.readFile(new File(command.get(0))); |
| if (launcher.contains("%*")) { //$NON-NLS-1$ |
| // This is the launcher from Tools R12. Don't work around it. |
| return null; |
| } |
| |
| // On Windows, proguard.bat can only pass %1...%9 to the java -jar proguard.jar |
| // call, but we have at least 15 arguments here so some get dropped silently |
| // and quoting is a big issue. So instead we'll work around that by writing |
| // all the arguments to a temporary config file. |
| |
| String[] commandArray = new String[3]; |
| |
| commandArray[0] = command.get(0); |
| commandArray[1] = command.get(1); |
| |
| // Write all the other arguments to a config file |
| File argsFile = File.createTempFile(TEMP_PREFIX, ".pro"); //$NON-NLS-1$ |
| // TODO FIXME this may leave a lot of temp files around on a long session. |
| // Should have a better way to clean up e.g. before each build. |
| argsFile.deleteOnExit(); |
| |
| FileWriter fw = new FileWriter(argsFile); |
| |
| for (int i = 2; i < command.size(); i++) { |
| String s = command.get(i); |
| fw.write(s); |
| fw.write(s.startsWith("-") ? ' ' : '\n'); //$NON-NLS-1$ |
| } |
| |
| fw.close(); |
| |
| commandArray[2] = "@" + argsFile.getAbsolutePath(); //$NON-NLS-1$ |
| return commandArray; |
| } |
| |
| /** |
| * Quotes a single path for proguard to deal with spaces. |
| * |
| * @param path The path to quote. |
| * @return The original path if it doesn't contain a space. |
| * Or the original path surrounded by single quotes if it contains spaces. |
| */ |
| private String quotePath(String path) { |
| if (path.indexOf(' ') != -1) { |
| path = '\'' + path + '\''; |
| } |
| return path; |
| } |
| |
| /** |
| * Quotes a compound proguard argument to deal with spaces. |
| * <p/> |
| * Proguard takes multi-path arguments such as "path1;path2" for some options. |
| * When the {@link #quotePath} methods adds quotes for such a path if it contains spaces, |
| * the proguard shell wrapper will absorb the quotes, so we need to quote around the |
| * quotes. |
| * |
| * @param path The path to quote. |
| * @return The original path if it doesn't contain a single quote. |
| * Or on Windows the original path surrounded by double quotes if it contains a quote. |
| */ |
| private String quoteWinArg(String path) { |
| if (path.indexOf('\'') != -1 && |
| SdkConstants.currentPlatform() == SdkConstants.PLATFORM_WINDOWS) { |
| path = '"' + path + '"'; |
| } |
| return path; |
| } |
| |
| |
| /** |
| * Execute the Dx tool for dalvik code conversion. |
| * @param javaProject The java project |
| * @param inputPaths the input paths for DX |
| * @param osOutFilePath the path of the dex file to create. |
| * |
| * @throws CoreException |
| * @throws DexException |
| */ |
| public void executeDx(IJavaProject javaProject, Collection<String> inputPaths, |
| String osOutFilePath) |
| throws CoreException, DexException { |
| |
| // get the dex wrapper |
| Sdk sdk = Sdk.getCurrent(); |
| DexWrapper wrapper = sdk.getDexWrapper(mBuildToolInfo); |
| |
| if (wrapper == null) { |
| throw new CoreException(new Status(IStatus.ERROR, AdtPlugin.PLUGIN_ID, |
| Messages.ApkBuilder_UnableBuild_Dex_Not_loaded)); |
| } |
| |
| try { |
| // set a temporary prefix on the print streams. |
| mOutStream.setPrefix(CONSOLE_PREFIX_DX); |
| mErrStream.setPrefix(CONSOLE_PREFIX_DX); |
| |
| IFolder binFolder = BaseProjectHelper.getAndroidOutputFolder(javaProject.getProject()); |
| File binFile = binFolder.getLocation().toFile(); |
| File dexedLibs = new File(binFile, "dexedLibs"); |
| if (dexedLibs.exists() == false) { |
| dexedLibs.mkdir(); |
| } |
| |
| // replace the libs by their dexed versions (dexing them if needed.) |
| List<String> finalInputPaths = new ArrayList<String>(inputPaths.size()); |
| if (mDisableDexMerger || inputPaths.size() == 1) { |
| // only one input, no need to put a pre-dexed version, even if this path is |
| // just a jar file (case for proguard'ed builds) |
| finalInputPaths.addAll(inputPaths); |
| } else { |
| |
| for (String input : inputPaths) { |
| File inputFile = new File(input); |
| if (inputFile.isDirectory()) { |
| finalInputPaths.add(input); |
| } else if (inputFile.isFile()) { |
| String fileName = getDexFileName(inputFile); |
| |
| File dexedLib = new File(dexedLibs, fileName); |
| String dexedLibPath = dexedLib.getAbsolutePath(); |
| |
| if (dexedLib.isFile() == false || |
| dexedLib.lastModified() < inputFile.lastModified()) { |
| |
| if (mVerbose) { |
| mOutStream.println( |
| String.format("Pre-Dexing %1$s -> %2$s", input, fileName)); |
| } |
| |
| if (dexedLib.isFile()) { |
| dexedLib.delete(); |
| } |
| |
| int res = wrapper.run(dexedLibPath, Collections.singleton(input), |
| mForceJumbo, mVerbose, mOutStream, mErrStream); |
| |
| if (res != 0) { |
| // output error message and mark the project. |
| String message = String.format(Messages.Dalvik_Error_d, res); |
| throw new DexException(message); |
| } |
| } else { |
| if (mVerbose) { |
| mOutStream.println( |
| String.format("Using Pre-Dexed %1$s <- %2$s", |
| fileName, input)); |
| } |
| } |
| |
| finalInputPaths.add(dexedLibPath); |
| } |
| } |
| } |
| |
| if (mVerbose) { |
| for (String input : finalInputPaths) { |
| mOutStream.println("Input: " + input); |
| } |
| } |
| |
| int res = wrapper.run(osOutFilePath, |
| finalInputPaths, |
| mForceJumbo, |
| mVerbose, |
| mOutStream, mErrStream); |
| |
| mOutStream.setPrefix(null); |
| mErrStream.setPrefix(null); |
| |
| if (res != 0) { |
| // output error message and marker the project. |
| String message = String.format(Messages.Dalvik_Error_d, res); |
| throw new DexException(message); |
| } |
| } catch (DexException e) { |
| throw e; |
| } catch (Throwable t) { |
| String message = t.getMessage(); |
| if (message == null) { |
| message = t.getClass().getCanonicalName(); |
| } |
| message = String.format(Messages.Dalvik_Error_s, message); |
| |
| throw new DexException(message, t); |
| } |
| } |
| |
| private String getDexFileName(File inputFile) { |
| // get the filename |
| String name = inputFile.getName(); |
| // remove the extension |
| int pos = name.lastIndexOf('.'); |
| if (pos != -1) { |
| name = name.substring(0, pos); |
| } |
| |
| // add a hash of the original file path |
| HashFunction hashFunction = Hashing.md5(); |
| HashCode hashCode = hashFunction.hashString(inputFile.getAbsolutePath(), Charsets.UTF_8); |
| |
| return name + "-" + hashCode.toString() + ".jar"; |
| } |
| |
| /** |
| * Executes aapt. If any error happen, files or the project will be marked. |
| * @param command The command for aapt to execute. Currently supported: package and crunch |
| * @param osManifestPath The path to the manifest file |
| * @param osResPath The path to the res folder |
| * @param osAssetsPath The path to the assets folder. This can be null. |
| * @param osOutFilePath The path to the temporary resource file to create, |
| * or in the case of crunching the path to the cache to create/update. |
| * @param configFilter The configuration filter for the resources to include |
| * (used with -c option, for example "port,en,fr" to include portrait, English and French |
| * resources.) |
| * @param versionCode optional version code to insert in the manifest during packaging. If <=0 |
| * then no value is inserted |
| * @throws AaptExecException |
| * @throws AaptResultException |
| */ |
| private void executeAapt(String aaptCommand, String osManifestPath, |
| List<String> osResPaths, String osAssetsPath, String osOutFilePath, |
| String configFilter, int versionCode) throws AaptExecException, AaptResultException { |
| IAndroidTarget target = Sdk.getCurrent().getTarget(mProject); |
| |
| String aapt = mBuildToolInfo.getPath(BuildToolInfo.PathId.AAPT); |
| |
| // Create the command line. |
| ArrayList<String> commandArray = new ArrayList<String>(); |
| commandArray.add(aapt); |
| commandArray.add(aaptCommand); |
| if (AdtPrefs.getPrefs().getBuildVerbosity() == BuildVerbosity.VERBOSE) { |
| commandArray.add("-v"); //$NON-NLS-1$ |
| } |
| |
| // Common to all commands |
| for (String path : osResPaths) { |
| commandArray.add("-S"); //$NON-NLS-1$ |
| commandArray.add(path); |
| } |
| |
| if (aaptCommand.equals(COMMAND_PACKAGE)) { |
| commandArray.add("-f"); //$NON-NLS-1$ |
| commandArray.add("--no-crunch"); //$NON-NLS-1$ |
| |
| // if more than one res, this means there's a library (or more) and we need |
| // to activate the auto-add-overlay |
| if (osResPaths.size() > 1) { |
| commandArray.add("--auto-add-overlay"); //$NON-NLS-1$ |
| } |
| |
| if (mDebugMode) { |
| commandArray.add("--debug-mode"); //$NON-NLS-1$ |
| } |
| |
| if (versionCode > 0) { |
| commandArray.add("--version-code"); //$NON-NLS-1$ |
| commandArray.add(Integer.toString(versionCode)); |
| } |
| |
| if (configFilter != null) { |
| commandArray.add("-c"); //$NON-NLS-1$ |
| commandArray.add(configFilter); |
| } |
| |
| // never compress apks. |
| commandArray.add("-0"); |
| commandArray.add("apk"); |
| |
| commandArray.add("-M"); //$NON-NLS-1$ |
| commandArray.add(osManifestPath); |
| |
| if (osAssetsPath != null) { |
| commandArray.add("-A"); //$NON-NLS-1$ |
| commandArray.add(osAssetsPath); |
| } |
| |
| commandArray.add("-I"); //$NON-NLS-1$ |
| commandArray.add(target.getPath(IAndroidTarget.ANDROID_JAR)); |
| |
| commandArray.add("-F"); //$NON-NLS-1$ |
| commandArray.add(osOutFilePath); |
| } else if (aaptCommand.equals(COMMAND_CRUNCH)) { |
| commandArray.add("-C"); //$NON-NLS-1$ |
| commandArray.add(osOutFilePath); |
| } |
| |
| String command[] = commandArray.toArray( |
| new String[commandArray.size()]); |
| |
| if (AdtPrefs.getPrefs().getBuildVerbosity() == BuildVerbosity.VERBOSE) { |
| StringBuilder sb = new StringBuilder(); |
| for (String c : command) { |
| sb.append(c); |
| sb.append(' '); |
| } |
| AdtPlugin.printToConsole(mProject, sb.toString()); |
| } |
| |
| // Benchmarking start |
| long startAaptTime = 0; |
| if (BENCHMARK_FLAG) { |
| String msg = "BENCHMARK ADT: Starting " + aaptCommand //$NON-NLS-1$ |
| + " call to Aapt"; //$NON-NLS-1$ |
| AdtPlugin.printBuildToConsole(BuildVerbosity.ALWAYS, mProject, msg); |
| startAaptTime = System.nanoTime(); |
| } |
| |
| // launch |
| try { |
| // launch the command line process |
| Process process = Runtime.getRuntime().exec(command); |
| |
| // list to store each line of stderr |
| ArrayList<String> stdErr = new ArrayList<String>(); |
| |
| // get the output and return code from the process |
| int returnCode = grabProcessOutput(mProject, process, stdErr); |
| |
| if (mVerbose) { |
| for (String stdErrString : stdErr) { |
| mOutStream.println(stdErrString); |
| } |
| } |
| if (returnCode != 0) { |
| throw new AaptResultException(returnCode, |
| stdErr.toArray(new String[stdErr.size()])); |
| } |
| } catch (IOException e) { |
| String msg = String.format(Messages.AAPT_Exec_Error_s, command[0]); |
| throw new AaptExecException(msg, e); |
| } catch (InterruptedException e) { |
| String msg = String.format(Messages.AAPT_Exec_Error_s, command[0]); |
| throw new AaptExecException(msg, e); |
| } |
| |
| // Benchmarking end |
| if (BENCHMARK_FLAG) { |
| String msg = "BENCHMARK ADT: Ending " + aaptCommand //$NON-NLS-1$ |
| + " call to Aapt.\nBENCHMARK ADT: Time Elapsed: " //$NON-NLS-1$ |
| + ((System.nanoTime() - startAaptTime)/MILLION) + "ms"; //$NON-NLS-1$ |
| AdtPlugin.printBuildToConsole(BuildVerbosity.ALWAYS, mProject, msg); |
| } |
| } |
| |
| /** |
| * Computes all the project output and dependencies that must go into building the apk. |
| * |
| * @param resMarker |
| * @throws CoreException |
| */ |
| private void gatherPaths(ResourceMarker resMarker) |
| throws CoreException { |
| IWorkspaceRoot wsRoot = ResourcesPlugin.getWorkspace().getRoot(); |
| |
| // get a java project for the project. |
| IJavaProject javaProject = JavaCore.create(mProject); |
| |
| |
| // get the output of the main project |
| IPath path = javaProject.getOutputLocation(); |
| IResource outputResource = wsRoot.findMember(path); |
| if (outputResource != null && outputResource.getType() == IResource.FOLDER) { |
| mCompiledCodePaths.add(outputResource.getLocation().toOSString()); |
| } |
| |
| // we could use IJavaProject.getResolvedClasspath directly, but we actually |
| // want to see the containers themselves. |
| IClasspathEntry[] classpaths = javaProject.readRawClasspath(); |
| if (classpaths != null) { |
| for (IClasspathEntry e : classpaths) { |
| // ignore non exported entries, unless they're in the DEPEDENCIES container, |
| // in which case we always want it (there may be some older projects that |
| // have it as non exported). |
| if (e.isExported() || |
| (e.getEntryKind() == IClasspathEntry.CPE_CONTAINER && |
| e.getPath().toString().equals(AdtConstants.CONTAINER_DEPENDENCIES))) { |
| handleCPE(e, javaProject, wsRoot, resMarker); |
| } |
| } |
| } |
| } |
| |
| private void handleCPE(IClasspathEntry entry, IJavaProject javaProject, |
| IWorkspaceRoot wsRoot, ResourceMarker resMarker) { |
| |
| // if this is a classpath variable reference, we resolve it. |
| if (entry.getEntryKind() == IClasspathEntry.CPE_VARIABLE) { |
| entry = JavaCore.getResolvedClasspathEntry(entry); |
| } |
| |
| if (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT) { |
| IProject refProject = wsRoot.getProject(entry.getPath().lastSegment()); |
| try { |
| // ignore if it's an Android project, or if it's not a Java Project |
| if (refProject.hasNature(JavaCore.NATURE_ID) && |
| refProject.hasNature(AdtConstants.NATURE_DEFAULT) == false) { |
| IJavaProject refJavaProject = JavaCore.create(refProject); |
| |
| // get the output folder |
| IPath path = refJavaProject.getOutputLocation(); |
| IResource outputResource = wsRoot.findMember(path); |
| if (outputResource != null && outputResource.getType() == IResource.FOLDER) { |
| mCompiledCodePaths.add(outputResource.getLocation().toOSString()); |
| } |
| } |
| } catch (CoreException exception) { |
| // can't query the project nature? ignore |
| } |
| |
| } else if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) { |
| handleClasspathLibrary(entry, wsRoot, resMarker); |
| } else if (entry.getEntryKind() == IClasspathEntry.CPE_CONTAINER) { |
| // get the container |
| try { |
| IClasspathContainer container = JavaCore.getClasspathContainer( |
| entry.getPath(), javaProject); |
| // ignore the system and default_system types as they represent |
| // libraries that are part of the runtime. |
| if (container != null && container.getKind() == IClasspathContainer.K_APPLICATION) { |
| IClasspathEntry[] entries = container.getClasspathEntries(); |
| for (IClasspathEntry cpe : entries) { |
| handleCPE(cpe, javaProject, wsRoot, resMarker); |
| } |
| } |
| } catch (JavaModelException jme) { |
| // can't resolve the container? ignore it. |
| AdtPlugin.log(jme, "Failed to resolve ClasspathContainer: %s", entry.getPath()); |
| } |
| } |
| } |
| |
| private void handleClasspathLibrary(IClasspathEntry e, IWorkspaceRoot wsRoot, |
| ResourceMarker resMarker) { |
| // get the IPath |
| IPath path = e.getPath(); |
| |
| IResource resource = wsRoot.findMember(path); |
| |
| if (resource != null && resource.getType() == IResource.PROJECT) { |
| // if it's a project we should just ignore it because it's going to be added |
| // later when we add all the referenced projects. |
| |
| } else if (SdkConstants.EXT_JAR.equalsIgnoreCase(path.getFileExtension())) { |
| // case of a jar file (which could be relative to the workspace or a full path) |
| if (resource != null && resource.exists() && |
| resource.getType() == IResource.FILE) { |
| mCompiledCodePaths.add(resource.getLocation().toOSString()); |
| } else { |
| // if the jar path doesn't match a workspace resource, |
| // then we get an OSString and check if this links to a valid file. |
| String osFullPath = path.toOSString(); |
| |
| File f = new File(osFullPath); |
| if (f.isFile()) { |
| mCompiledCodePaths.add(osFullPath); |
| } else { |
| String message = String.format( Messages.Couldnt_Locate_s_Error, |
| path); |
| // always output to the console |
| mOutStream.println(message); |
| |
| // put a marker |
| if (resMarker != null) { |
| resMarker.setWarning(mProject, message); |
| } |
| } |
| } |
| } else { |
| // this can be the case for a class folder. |
| if (resource != null && resource.exists() && |
| resource.getType() == IResource.FOLDER) { |
| mCompiledCodePaths.add(resource.getLocation().toOSString()); |
| } else { |
| // if the path doesn't match a workspace resource, |
| // then we get an OSString and check if this links to a valid folder. |
| String osFullPath = path.toOSString(); |
| |
| File f = new File(osFullPath); |
| if (f.isDirectory()) { |
| mCompiledCodePaths.add(osFullPath); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Checks a {@link IFile} to make sure it should be packaged as standard resources. |
| * @param file the IFile representing the file. |
| * @return true if the file should be packaged as standard java resources. |
| */ |
| public static boolean checkFileForPackaging(IFile file) { |
| String name = file.getName(); |
| |
| String ext = file.getFileExtension(); |
| return ApkBuilder.checkFileForPackaging(name, ext); |
| } |
| |
| /** |
| * Checks whether an {@link IFolder} and its content is valid for packaging into the .apk as |
| * standard Java resource. |
| * @param folder the {@link IFolder} to check. |
| */ |
| public static boolean checkFolderForPackaging(IFolder folder) { |
| String name = folder.getName(); |
| return ApkBuilder.checkFolderForPackaging(name); |
| } |
| |
| /** |
| * Returns a list of {@link IJavaProject} matching the provided {@link IProject} objects. |
| * @param projects the IProject objects. |
| * @return a new list object containing the IJavaProject object for the given IProject objects. |
| * @throws CoreException |
| */ |
| public static List<IJavaProject> getJavaProjects(List<IProject> projects) throws CoreException { |
| ArrayList<IJavaProject> list = new ArrayList<IJavaProject>(); |
| |
| for (IProject p : projects) { |
| if (p.isOpen() && p.hasNature(JavaCore.NATURE_ID)) { |
| |
| list.add(JavaCore.create(p)); |
| } |
| } |
| |
| return list; |
| } |
| |
| /** |
| * Get the stderr output of a process and return when the process is done. |
| * @param process The process to get the output from |
| * @param stderr The array to store the stderr output |
| * @return the process return code. |
| * @throws InterruptedException |
| */ |
| public final static int grabProcessOutput( |
| final IProject project, |
| final Process process, |
| final ArrayList<String> stderr) |
| throws InterruptedException { |
| |
| return GrabProcessOutput.grabProcessOutput( |
| process, |
| Wait.WAIT_FOR_READERS, // we really want to make sure we get all the output! |
| new IProcessOutput() { |
| |
| @SuppressWarnings("unused") |
| @Override |
| public void out(@Nullable String line) { |
| if (line != null) { |
| // If benchmarking always print the lines that |
| // correspond to benchmarking info returned by ADT |
| if (BENCHMARK_FLAG && line.startsWith("BENCHMARK:")) { //$NON-NLS-1$ |
| AdtPlugin.printBuildToConsole(BuildVerbosity.ALWAYS, |
| project, line); |
| } else { |
| AdtPlugin.printBuildToConsole(BuildVerbosity.VERBOSE, |
| project, line); |
| } |
| } |
| } |
| |
| @Override |
| public void err(@Nullable String line) { |
| if (line != null) { |
| stderr.add(line); |
| if (BuildVerbosity.VERBOSE == AdtPrefs.getPrefs().getBuildVerbosity()) { |
| AdtPlugin.printErrorToConsole(project, line); |
| } |
| } |
| } |
| }); |
| } |
| } |
