Java tutorial
/* * Copyright (C) 2007 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.builders; 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.build.AaptExecException; import com.android.ide.eclipse.adt.internal.build.AaptParser; import com.android.ide.eclipse.adt.internal.build.AaptResultException; import com.android.ide.eclipse.adt.internal.build.BuildHelper; import com.android.ide.eclipse.adt.internal.build.BuildHelper.ResourceMarker; import com.android.ide.eclipse.adt.internal.build.DexException; import com.android.ide.eclipse.adt.internal.build.Messages; import com.android.ide.eclipse.adt.internal.build.NativeLibInJarException; import com.android.ide.eclipse.adt.internal.lint.LintDeltaProcessor; 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.ApkInstallManager; import com.android.ide.eclipse.adt.internal.project.BaseProjectHelper; import com.android.ide.eclipse.adt.internal.project.LibraryClasspathContainerInitializer; import com.android.ide.eclipse.adt.internal.project.ProjectHelper; import com.android.ide.eclipse.adt.internal.resources.manager.ResourceManager; import com.android.ide.eclipse.adt.internal.sdk.ProjectState; import com.android.ide.eclipse.adt.internal.sdk.Sdk; import com.android.ide.eclipse.adt.io.IFileWrapper; import com.android.prefs.AndroidLocation.AndroidLocationException; import com.android.sdklib.build.ApkBuilder; import com.android.sdklib.build.ApkCreationException; import com.android.sdklib.build.DuplicateFileException; import com.android.sdklib.build.IArchiveBuilder; import com.android.sdklib.build.SealedApkException; import com.android.sdklib.internal.build.DebugKeyProvider.KeytoolException; import com.android.xml.AndroidManifest; import org.eclipse.core.resources.IContainer; import org.eclipse.core.resources.IFile; import org.eclipse.core.resources.IFolder; import org.eclipse.core.resources.IMarker; import org.eclipse.core.resources.IProject; import org.eclipse.core.resources.IResource; import org.eclipse.core.resources.IResourceDelta; import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.IPath; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.core.runtime.IStatus; import org.eclipse.jdt.core.IJavaModelMarker; import org.eclipse.jdt.core.IJavaProject; import org.eclipse.jdt.core.JavaCore; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.util.ArrayList; import java.util.Collection; import java.util.List; import java.util.Map; import java.util.jar.Attributes; import java.util.jar.JarEntry; import java.util.jar.JarOutputStream; import java.util.jar.Manifest; import java.util.regex.Pattern; public class PostCompilerBuilder extends BaseBuilder { /** This ID is used in plugin.xml and in each project's .project file. * It cannot be changed even if the class is renamed/moved */ public static final String ID = "com.android.ide.eclipse.adt.ApkBuilder"; //$NON-NLS-1$ private static final String PROPERTY_CONVERT_TO_DEX = "convertToDex"; //$NON-NLS-1$ private static final String PROPERTY_PACKAGE_RESOURCES = "packageResources"; //$NON-NLS-1$ private static final String PROPERTY_BUILD_APK = "buildApk"; //$NON-NLS-1$ /** Flag to pass to PostCompiler builder that sets if it runs or not. * Set this flag whenever calling build if PostCompiler is to run */ public final static String POST_C_REQUESTED = "RunPostCompiler"; //$NON-NLS-1$ /** * Dex conversion flag. This is set to true if one of the changed/added/removed * file is a .class file. Upon visiting all the delta resource, if this * flag is true, then we know we'll have to make the "classes.dex" file. */ private boolean mConvertToDex = false; /** * Package resources flag. This is set to true if one of the changed/added/removed * file is a resource file. Upon visiting all the delta resource, if * this flag is true, then we know we'll have to repackage the resources. */ private boolean mPackageResources = false; /** * Final package build flag. */ private boolean mBuildFinalPackage = false; private AndroidPrintStream mOutStream = null; private AndroidPrintStream mErrStream = null; private ResourceMarker mResourceMarker = new ResourceMarker() { @Override public void setWarning(IResource resource, String message) { BaseProjectHelper.markResource(resource, AdtConstants.MARKER_PACKAGING, message, IMarker.SEVERITY_WARNING); } }; public PostCompilerBuilder() { super(); } @Override protected void clean(IProgressMonitor monitor) throws CoreException { super.clean(monitor); // Get the project. IProject project = getProject(); if (DEBUG_LOG) { AdtPlugin.log(IStatus.INFO, "%s CLEAN(POST)", project.getName()); } // Clear the project of the generic markers removeMarkersFromContainer(project, AdtConstants.MARKER_AAPT_PACKAGE); removeMarkersFromContainer(project, AdtConstants.MARKER_PACKAGING); // also remove the files in the output folder (but not the Eclipse output folder). IFolder javaOutput = BaseProjectHelper.getJavaOutputFolder(project); IFolder androidOutput = BaseProjectHelper.getAndroidOutputFolder(project); if (javaOutput.equals(androidOutput) == false) { // get the content IResource[] members = androidOutput.members(); for (IResource member : members) { if (member.equals(javaOutput) == false) { member.delete(true /*force*/, monitor); } } } } // build() returns a list of project from which this project depends for future compilation. @Override protected IProject[] build(int kind, @SuppressWarnings("rawtypes") Map args, IProgressMonitor monitor) throws CoreException { // get a project object IProject project = getProject(); if (DEBUG_LOG) { AdtPlugin.log(IStatus.INFO, "%s BUILD(POST)", project.getName()); } // Benchmarking start long startBuildTime = 0; if (BuildHelper.BENCHMARK_FLAG) { // End JavaC Timer String msg = "BENCHMARK ADT: Ending Compilation \n BENCHMARK ADT: Time Elapsed: " + //$NON-NLS-1$ (System.nanoTime() - BuildHelper.sStartJavaCTime) / Math.pow(10, 6) + "ms"; //$NON-NLS-1$ AdtPlugin.printBuildToConsole(BuildVerbosity.ALWAYS, project, msg); msg = "BENCHMARK ADT: Starting PostCompilation"; //$NON-NLS-1$ AdtPlugin.printBuildToConsole(BuildVerbosity.ALWAYS, project, msg); startBuildTime = System.nanoTime(); } // list of referenced projects. This is a mix of java projects and library projects // and is computed below. IProject[] allRefProjects = null; try { // get the project info ProjectState projectState = Sdk.getProjectState(project); // this can happen if the project has no project.properties. if (projectState == null) { return null; } boolean isLibrary = projectState.isLibrary(); // get the libraries List<IProject> libProjects = projectState.getFullLibraryProjects(); IJavaProject javaProject = JavaCore.create(project); // get the list of referenced projects. List<IProject> javaProjects = ProjectHelper.getReferencedProjects(project); List<IJavaProject> referencedJavaProjects = BuildHelper.getJavaProjects(javaProjects); // mix the java project and the library projects final int size = libProjects.size() + javaProjects.size(); ArrayList<IProject> refList = new ArrayList<IProject>(size); refList.addAll(libProjects); refList.addAll(javaProjects); allRefProjects = refList.toArray(new IProject[size]); // get the android output folder IFolder androidOutputFolder = BaseProjectHelper.getAndroidOutputFolder(project); IFolder resOutputFolder = androidOutputFolder.getFolder(SdkConstants.FD_RES); // First thing we do is go through the resource delta to not // lose it if we have to abort the build for any reason. if (args.containsKey(POST_C_REQUESTED) && AdtPrefs.getPrefs().getBuildSkipPostCompileOnFileSave()) { // Skip over flag setting } else if (kind == FULL_BUILD) { AdtPlugin.printBuildToConsole(BuildVerbosity.VERBOSE, project, Messages.Start_Full_Apk_Build); if (DEBUG_LOG) { AdtPlugin.log(IStatus.INFO, "%s full build!", project.getName()); } // Full build: we do all the steps. mPackageResources = true; mConvertToDex = true; mBuildFinalPackage = true; } else { AdtPlugin.printBuildToConsole(BuildVerbosity.VERBOSE, project, Messages.Start_Inc_Apk_Build); // go through the resources and see if something changed. IResourceDelta delta = getDelta(project); if (delta == null) { // no delta? Same as full build: we do all the steps. mPackageResources = true; mConvertToDex = true; mBuildFinalPackage = true; } else { if (ResourceManager.isAutoBuilding() && AdtPrefs.getPrefs().isLintOnSave()) { // Check for errors on save/build, if enabled LintDeltaProcessor.create().process(delta); } PatternBasedDeltaVisitor dv = new PatternBasedDeltaVisitor(project, project, "POST:Main"); ChangedFileSet manifestCfs = ChangedFileSetHelper.getMergedManifestCfs(project); dv.addSet(manifestCfs); ChangedFileSet resCfs = ChangedFileSetHelper.getResCfs(project); dv.addSet(resCfs); ChangedFileSet androidCodeCfs = ChangedFileSetHelper.getCodeCfs(project); dv.addSet(androidCodeCfs); ChangedFileSet javaResCfs = ChangedFileSetHelper.getJavaResCfs(project); dv.addSet(javaResCfs); dv.addSet(ChangedFileSetHelper.NATIVE_LIBS); delta.accept(dv); // save the state mPackageResources |= dv.checkSet(manifestCfs) || dv.checkSet(resCfs); mConvertToDex |= dv.checkSet(androidCodeCfs); mBuildFinalPackage |= dv.checkSet(javaResCfs) || dv.checkSet(ChangedFileSetHelper.NATIVE_LIBS); } // check the libraries if (libProjects.size() > 0) { for (IProject libProject : libProjects) { delta = getDelta(libProject); if (delta != null) { PatternBasedDeltaVisitor visitor = new PatternBasedDeltaVisitor(project, libProject, "POST:Lib"); ChangedFileSet libResCfs = ChangedFileSetHelper.getFullResCfs(libProject); visitor.addSet(libResCfs); visitor.addSet(ChangedFileSetHelper.NATIVE_LIBS); // FIXME: add check on the library.jar? delta.accept(visitor); mPackageResources |= visitor.checkSet(libResCfs); mBuildFinalPackage |= visitor.checkSet(ChangedFileSetHelper.NATIVE_LIBS); } } } // also go through the delta for all the referenced projects final int referencedCount = referencedJavaProjects.size(); for (int i = 0; i < referencedCount; i++) { IJavaProject referencedJavaProject = referencedJavaProjects.get(i); delta = getDelta(referencedJavaProject.getProject()); if (delta != null) { IProject referencedProject = referencedJavaProject.getProject(); PatternBasedDeltaVisitor visitor = new PatternBasedDeltaVisitor(project, referencedProject, "POST:RefedProject"); ChangedFileSet javaResCfs = ChangedFileSetHelper.getJavaResCfs(referencedProject); visitor.addSet(javaResCfs); ChangedFileSet bytecodeCfs = ChangedFileSetHelper.getByteCodeCfs(referencedProject); visitor.addSet(bytecodeCfs); delta.accept(visitor); // save the state mConvertToDex |= visitor.checkSet(bytecodeCfs); mBuildFinalPackage |= visitor.checkSet(javaResCfs); } } } // store the build status in the persistent storage saveProjectBooleanProperty(PROPERTY_CONVERT_TO_DEX, mConvertToDex); saveProjectBooleanProperty(PROPERTY_PACKAGE_RESOURCES, mPackageResources); saveProjectBooleanProperty(PROPERTY_BUILD_APK, mBuildFinalPackage); // Top level check to make sure the build can move forward. Only do this after recording // delta changes. abortOnBadSetup(javaProject, projectState); // Get the output stream. Since the builder is created for the life of the // project, they can be kept around. if (mOutStream == null) { mOutStream = new AndroidPrintStream(project, null /*prefix*/, AdtPlugin.getOutStream()); mErrStream = new AndroidPrintStream(project, null /*prefix*/, AdtPlugin.getOutStream()); } // remove older packaging markers. removeMarkersFromContainer(javaProject.getProject(), AdtConstants.MARKER_PACKAGING); // finished with the common init and tests. Special case of the library. if (isLibrary) { // check the jar output file is present, if not create it. IFile jarIFile = androidOutputFolder .getFile(project.getName().toLowerCase() + SdkConstants.DOT_JAR); if (mConvertToDex == false && jarIFile.exists() == false) { mConvertToDex = true; } // also update the crunch cache always since aapt does it smartly only // on the files that need it. if (DEBUG_LOG) { AdtPlugin.log(IStatus.INFO, "%s running crunch!", project.getName()); } BuildHelper helper = new BuildHelper(projectState, mBuildToolInfo, mOutStream, mErrStream, false /*jumbo mode doesn't matter here*/, false /*dex merger doesn't matter here*/, true /*debugMode*/, AdtPrefs.getPrefs().getBuildVerbosity() == BuildVerbosity.VERBOSE, mResourceMarker); updateCrunchCache(project, helper); // refresh recursively bin/res folder resOutputFolder.refreshLocal(IResource.DEPTH_INFINITE, monitor); if (mConvertToDex) { // in this case this means some class files changed and // we need to update the jar file. if (DEBUG_LOG) { AdtPlugin.log(IStatus.INFO, "%s updating jar!", project.getName()); } // resource to the AndroidManifest.xml file IFile manifestFile = project.getFile(SdkConstants.FN_ANDROID_MANIFEST_XML); String appPackage = AndroidManifest.getPackage(new IFileWrapper(manifestFile)); IFolder javaOutputFolder = BaseProjectHelper.getJavaOutputFolder(project); writeLibraryPackage(jarIFile, project, appPackage, javaOutputFolder); saveProjectBooleanProperty(PROPERTY_CONVERT_TO_DEX, mConvertToDex = false); // refresh the bin folder content with no recursion to update the library // jar file. androidOutputFolder.refreshLocal(IResource.DEPTH_ONE, monitor); // Also update the projects. The only way to force recompile them is to // reset the library container. List<ProjectState> parentProjects = projectState.getParentProjects(); LibraryClasspathContainerInitializer.updateProject(parentProjects); } return allRefProjects; } // Check to see if we're going to launch or export. If not, we can skip // the packaging and dexing process. if (!args.containsKey(POST_C_REQUESTED) && AdtPrefs.getPrefs().getBuildSkipPostCompileOnFileSave()) { AdtPlugin.printBuildToConsole(BuildVerbosity.VERBOSE, project, Messages.Skip_Post_Compiler); return allRefProjects; } else { AdtPlugin.printBuildToConsole(BuildVerbosity.VERBOSE, project, Messages.Start_Full_Post_Compiler); } // first thing we do is check that the SDK directory has been setup. String osSdkFolder = AdtPlugin.getOsSdkFolder(); if (osSdkFolder.length() == 0) { // this has already been checked in the precompiler. Therefore, // while we do have to cancel the build, we don't have to return // any error or throw anything. return allRefProjects; } // do some extra check, in case the output files are not present. This // will force to recreate them. IResource tmp = null; if (mPackageResources == false) { // check the full resource package tmp = androidOutputFolder.findMember(AdtConstants.FN_RESOURCES_AP_); if (tmp == null || tmp.exists() == false) { mPackageResources = true; } } // check classes.dex is present. If not we force to recreate it. if (mConvertToDex == false) { tmp = androidOutputFolder.findMember(SdkConstants.FN_APK_CLASSES_DEX); if (tmp == null || tmp.exists() == false) { mConvertToDex = true; } } // also check the final file(s)! String finalPackageName = ProjectHelper.getApkFilename(project, null /*config*/); if (mBuildFinalPackage == false) { tmp = androidOutputFolder.findMember(finalPackageName); if (tmp == null || (tmp instanceof IFile && tmp.exists() == false)) { String msg = String.format(Messages.s_Missing_Repackaging, finalPackageName); AdtPlugin.printBuildToConsole(BuildVerbosity.VERBOSE, project, msg); mBuildFinalPackage = true; } } // at this point we know if we need to recreate the temporary apk // or the dex file, but we don't know if we simply need to recreate them // because they are missing // refresh the output directory first IContainer ic = androidOutputFolder.getParent(); if (ic != null) { ic.refreshLocal(IResource.DEPTH_ONE, monitor); } // we need to test all three, as we may need to make the final package // but not the intermediary ones. if (mPackageResources || mConvertToDex || mBuildFinalPackage) { String forceJumboStr = projectState.getProperty(AdtConstants.DEX_OPTIONS_FORCEJUMBO); Boolean jumbo = Boolean.valueOf(forceJumboStr); String dexMergerStr = projectState.getProperty(AdtConstants.DEX_OPTIONS_DISABLE_MERGER); Boolean dexMerger = Boolean.valueOf(dexMergerStr); BuildHelper helper = new BuildHelper(projectState, mBuildToolInfo, mOutStream, mErrStream, jumbo.booleanValue(), dexMerger.booleanValue(), true /*debugMode*/, AdtPrefs.getPrefs().getBuildVerbosity() == BuildVerbosity.VERBOSE, mResourceMarker); IPath androidBinLocation = androidOutputFolder.getLocation(); if (androidBinLocation == null) { markProject(AdtConstants.MARKER_PACKAGING, Messages.Output_Missing, IMarker.SEVERITY_ERROR); return allRefProjects; } String osAndroidBinPath = androidBinLocation.toOSString(); // resource to the AndroidManifest.xml file IFile manifestFile = androidOutputFolder.getFile(SdkConstants.FN_ANDROID_MANIFEST_XML); if (manifestFile == null || manifestFile.exists() == false) { // mark project and exit String msg = String.format(Messages.s_File_Missing, SdkConstants.FN_ANDROID_MANIFEST_XML); markProject(AdtConstants.MARKER_PACKAGING, msg, IMarker.SEVERITY_ERROR); return allRefProjects; } // Remove the old .apk. // This make sure that if the apk is corrupted, then dx (which would attempt // to open it), will not fail. String osFinalPackagePath = osAndroidBinPath + File.separator + finalPackageName; File finalPackage = new File(osFinalPackagePath); // if delete failed, this is not really a problem, as the final package generation // handle already present .apk, and if that one failed as well, the user will be // notified. finalPackage.delete(); // Check if we need to package the resources. if (mPackageResources) { // also update the crunch cache always since aapt does it smartly only // on the files that need it. if (DEBUG_LOG) { AdtPlugin.log(IStatus.INFO, "%s running crunch!", project.getName()); } if (updateCrunchCache(project, helper) == false) { return allRefProjects; } // refresh recursively bin/res folder resOutputFolder.refreshLocal(IResource.DEPTH_INFINITE, monitor); if (DEBUG_LOG) { AdtPlugin.log(IStatus.INFO, "%s packaging resources!", project.getName()); } // remove some aapt_package only markers. removeMarkersFromContainer(project, AdtConstants.MARKER_AAPT_PACKAGE); try { helper.packageResources(manifestFile, libProjects, null /*resfilter*/, 0 /*versionCode */, osAndroidBinPath, AdtConstants.FN_RESOURCES_AP_); } catch (AaptExecException e) { BaseProjectHelper.markResource(project, AdtConstants.MARKER_PACKAGING, e.getMessage(), IMarker.SEVERITY_ERROR); return allRefProjects; } catch (AaptResultException e) { // attempt to parse the error output String[] aaptOutput = e.getOutput(); boolean parsingError = AaptParser.parseOutput(aaptOutput, project); // if we couldn't parse the output we display it in the console. if (parsingError) { AdtPlugin.printErrorToConsole(project, (Object[]) aaptOutput); // if the exec failed, and we couldn't parse the error output (and // therefore not all files that should have been marked, were marked), // we put a generic marker on the project and abort. BaseProjectHelper.markResource(project, AdtConstants.MARKER_PACKAGING, Messages.Unparsed_AAPT_Errors, IMarker.SEVERITY_ERROR); } } // build has been done. reset the state of the builder mPackageResources = false; // and store it saveProjectBooleanProperty(PROPERTY_PACKAGE_RESOURCES, mPackageResources); } String classesDexPath = osAndroidBinPath + File.separator + SdkConstants.FN_APK_CLASSES_DEX; // then we check if we need to package the .class into classes.dex if (mConvertToDex) { if (DEBUG_LOG) { AdtPlugin.log(IStatus.INFO, "%s running dex!", project.getName()); } try { Collection<String> dxInputPaths = helper.getCompiledCodePaths(); helper.executeDx(javaProject, dxInputPaths, classesDexPath); } catch (DexException e) { String message = e.getMessage(); AdtPlugin.printErrorToConsole(project, message); BaseProjectHelper.markResource(project, AdtConstants.MARKER_PACKAGING, message, IMarker.SEVERITY_ERROR); Throwable cause = e.getCause(); if (cause instanceof NoClassDefFoundError || cause instanceof NoSuchMethodError) { AdtPlugin.printErrorToConsole(project, Messages.Incompatible_VM_Warning, Messages.Requires_1_5_Error); } // dx failed, we return return allRefProjects; } // build has been done. reset the state of the builder mConvertToDex = false; // and store it saveProjectBooleanProperty(PROPERTY_CONVERT_TO_DEX, mConvertToDex); } // now we need to make the final package from the intermediary apk // and classes.dex. // This is the default package with all the resources. try { if (DEBUG_LOG) { AdtPlugin.log(IStatus.INFO, "%s making final package!", project.getName()); } helper.finalDebugPackage(osAndroidBinPath + File.separator + AdtConstants.FN_RESOURCES_AP_, classesDexPath, osFinalPackagePath, libProjects, mResourceMarker); } catch (KeytoolException e) { String eMessage = e.getMessage(); // mark the project with the standard message String msg = String.format(Messages.Final_Archive_Error_s, eMessage); BaseProjectHelper.markResource(project, AdtConstants.MARKER_PACKAGING, msg, IMarker.SEVERITY_ERROR); // output more info in the console AdtPlugin.printErrorToConsole(project, msg, String.format(Messages.ApkBuilder_JAVA_HOME_is_s, e.getJavaHome()), Messages.ApkBuilder_Update_or_Execute_manually_s, e.getCommandLine()); AdtPlugin.log(e, msg); return allRefProjects; } catch (ApkCreationException e) { String eMessage = e.getMessage(); // mark the project with the standard message String msg = String.format(Messages.Final_Archive_Error_s, eMessage); BaseProjectHelper.markResource(project, AdtConstants.MARKER_PACKAGING, msg, IMarker.SEVERITY_ERROR); AdtPlugin.log(e, msg); } catch (AndroidLocationException e) { String eMessage = e.getMessage(); // mark the project with the standard message String msg = String.format(Messages.Final_Archive_Error_s, eMessage); BaseProjectHelper.markResource(project, AdtConstants.MARKER_PACKAGING, msg, IMarker.SEVERITY_ERROR); AdtPlugin.log(e, msg); } catch (NativeLibInJarException e) { String msg = e.getMessage(); BaseProjectHelper.markResource(project, AdtConstants.MARKER_PACKAGING, msg, IMarker.SEVERITY_ERROR); AdtPlugin.printErrorToConsole(project, (Object[]) e.getAdditionalInfo()); } catch (CoreException e) { // mark project and return String msg = String.format(Messages.Final_Archive_Error_s, e.getMessage()); AdtPlugin.printErrorToConsole(project, msg); BaseProjectHelper.markResource(project, AdtConstants.MARKER_PACKAGING, msg, IMarker.SEVERITY_ERROR); AdtPlugin.log(e, msg); } catch (DuplicateFileException e) { String msg1 = String.format( "Found duplicate file for APK: %1$s\nOrigin 1: %2$s\nOrigin 2: %3$s", e.getArchivePath(), e.getFile1(), e.getFile2()); String msg2 = String.format(Messages.Final_Archive_Error_s, msg1); AdtPlugin.printErrorToConsole(project, msg2); BaseProjectHelper.markResource(project, AdtConstants.MARKER_PACKAGING, msg2, IMarker.SEVERITY_ERROR); } // we are done. // refresh the bin folder content with no recursion. androidOutputFolder.refreshLocal(IResource.DEPTH_ONE, monitor); // build has been done. reset the state of the builder mBuildFinalPackage = false; // and store it saveProjectBooleanProperty(PROPERTY_BUILD_APK, mBuildFinalPackage); // reset the installation manager to force new installs of this project ApkInstallManager.getInstance().resetInstallationFor(project); AdtPlugin.printBuildToConsole(BuildVerbosity.VERBOSE, getProject(), "Build Success!"); } } catch (AbortBuildException e) { return allRefProjects; } catch (Exception exception) { // try to catch other exception to actually display an error. This will be useful // if we get an NPE or something so that we can at least notify the user that something // went wrong. // first check if this is a CoreException we threw to cancel the build. if (exception instanceof CoreException) { if (((CoreException) exception).getStatus().getSeverity() == IStatus.CANCEL) { // Project is already marked with an error. Nothing to do return allRefProjects; } } String msg = exception.getMessage(); if (msg == null) { msg = exception.getClass().getCanonicalName(); } msg = String.format("Unknown error: %1$s", msg); AdtPlugin.logAndPrintError(exception, project.getName(), msg); markProject(AdtConstants.MARKER_PACKAGING, msg, IMarker.SEVERITY_ERROR); } // Benchmarking end if (BuildHelper.BENCHMARK_FLAG) { String msg = "BENCHMARK ADT: Ending PostCompilation. \n BENCHMARK ADT: Time Elapsed: " + //$NON-NLS-1$ ((System.nanoTime() - startBuildTime) / Math.pow(10, 6)) + "ms"; //$NON-NLS-1$ AdtPlugin.printBuildToConsole(BuildVerbosity.ALWAYS, project, msg); // End Overall Timer msg = "BENCHMARK ADT: Done with everything! \n BENCHMARK ADT: Time Elapsed: " + //$NON-NLS-1$ (System.nanoTime() - BuildHelper.sStartOverallTime) / Math.pow(10, 6) + "ms"; //$NON-NLS-1$ AdtPlugin.printBuildToConsole(BuildVerbosity.ALWAYS, project, msg); } return allRefProjects; } private static class JarBuilder implements IArchiveBuilder { private static Pattern R_PATTERN = Pattern.compile("R(\\$.*)?\\.class"); //$NON-NLS-1$ private static String BUILD_CONFIG_CLASS = "BuildConfig.class"; //$NON-NLS-1$ private final byte[] buffer = new byte[1024]; private final JarOutputStream mOutputStream; private final String mAppPackage; JarBuilder(JarOutputStream outputStream, String appPackage) { mOutputStream = outputStream; mAppPackage = appPackage.replace('.', '/'); } public void addFile(IFile file, IFolder rootFolder) throws ApkCreationException { // we only package class file from the output folder if (SdkConstants.EXT_CLASS.equals(file.getFileExtension()) == false) { return; } IPath packageApp = file.getParent().getFullPath().makeRelativeTo(rootFolder.getFullPath()); String name = file.getName(); // Ignore the library's R/Manifest/BuildConfig classes. if (mAppPackage.equals(packageApp.toString()) && (BUILD_CONFIG_CLASS.equals(name) || R_PATTERN.matcher(name).matches())) { return; } IPath path = file.getFullPath().makeRelativeTo(rootFolder.getFullPath()); try { addFile(file.getContents(), file.getLocalTimeStamp(), path.toString()); } catch (ApkCreationException e) { throw e; } catch (Exception e) { throw new ApkCreationException(e, "Failed to add %s", file); } } @Override public void addFile(File file, String archivePath) throws ApkCreationException, SealedApkException, DuplicateFileException { try { FileInputStream inputStream = new FileInputStream(file); long lastModified = file.lastModified(); addFile(inputStream, lastModified, archivePath); } catch (ApkCreationException e) { throw e; } catch (Exception e) { throw new ApkCreationException(e, "Failed to add %s", file); } } private void addFile(InputStream content, long lastModified, String archivePath) throws IOException, ApkCreationException { // create the jar entry JarEntry entry = new JarEntry(archivePath); entry.setTime(lastModified); try { // add the entry to the jar archive mOutputStream.putNextEntry(entry); // read the content of the entry from the input stream, and write // it into the archive. int count; while ((count = content.read(buffer)) != -1) { mOutputStream.write(buffer, 0, count); } } finally { try { if (content != null) { content.close(); } } catch (Exception e) { throw new ApkCreationException(e, "Failed to close stream"); } } } } /** * Updates the crunch cache if needed and return true if the build must continue. */ private boolean updateCrunchCache(IProject project, BuildHelper helper) { try { helper.updateCrunchCache(); } catch (AaptExecException e) { BaseProjectHelper.markResource(project, AdtConstants.MARKER_PACKAGING, e.getMessage(), IMarker.SEVERITY_ERROR); return false; } catch (AaptResultException e) { // attempt to parse the error output String[] aaptOutput = e.getOutput(); boolean parsingError = AaptParser.parseOutput(aaptOutput, project); // if we couldn't parse the output we display it in the console. if (parsingError) { AdtPlugin.printErrorToConsole(project, (Object[]) aaptOutput); } } return true; } /** * Writes the library jar file. * @param jarIFile the destination file * @param project the library project * @param appPackage the library android package * @param javaOutputFolder the JDT output folder. */ private void writeLibraryPackage(IFile jarIFile, IProject project, String appPackage, IFolder javaOutputFolder) { JarOutputStream jos = null; try { Manifest manifest = new Manifest(); Attributes mainAttributes = manifest.getMainAttributes(); mainAttributes.put(Attributes.Name.CLASS_PATH, "Android ADT"); //$NON-NLS-1$ mainAttributes.putValue("Created-By", "1.0 (Android)"); //$NON-NLS-1$ //$NON-NLS-2$ jos = new JarOutputStream(new FileOutputStream(jarIFile.getLocation().toFile()), manifest); JarBuilder jarBuilder = new JarBuilder(jos, appPackage); // write the class files writeClassFilesIntoJar(jarBuilder, javaOutputFolder, javaOutputFolder); // now write the standard Java resources from the output folder ApkBuilder.addSourceFolder(jarBuilder, javaOutputFolder.getLocation().toFile()); saveProjectBooleanProperty(PROPERTY_CONVERT_TO_DEX, mConvertToDex); } catch (Exception e) { AdtPlugin.log(e, "Failed to write jar file %s", jarIFile.getLocation().toOSString()); } finally { if (jos != null) { try { jos.close(); } catch (IOException e) { // pass } } } } private void writeClassFilesIntoJar(JarBuilder builder, IFolder folder, IFolder rootFolder) throws CoreException, IOException, ApkCreationException { IResource[] members = folder.members(); for (IResource member : members) { if (member.getType() == IResource.FOLDER) { writeClassFilesIntoJar(builder, (IFolder) member, rootFolder); } else if (member.getType() == IResource.FILE) { IFile file = (IFile) member; builder.addFile(file, rootFolder); } } } @Override protected void startupOnInitialize() { super.startupOnInitialize(); // load the build status. We pass true as the default value to // force a recompile in case the property was not found mConvertToDex = loadProjectBooleanProperty(PROPERTY_CONVERT_TO_DEX, true); mPackageResources = loadProjectBooleanProperty(PROPERTY_PACKAGE_RESOURCES, true); mBuildFinalPackage = loadProjectBooleanProperty(PROPERTY_BUILD_APK, true); } @Override protected void abortOnBadSetup(@NonNull IJavaProject javaProject, @Nullable ProjectState projectState) throws AbortBuildException, CoreException { super.abortOnBadSetup(javaProject, projectState); IProject iProject = getProject(); // do a (hopefully quick) search for Precompiler type markers. Those are always only // errors. stopOnMarker(iProject, AdtConstants.MARKER_AAPT_COMPILE, IResource.DEPTH_INFINITE, false /*checkSeverity*/); stopOnMarker(iProject, AdtConstants.MARKER_AIDL, IResource.DEPTH_INFINITE, false /*checkSeverity*/); stopOnMarker(iProject, AdtConstants.MARKER_RENDERSCRIPT, IResource.DEPTH_INFINITE, false /*checkSeverity*/); stopOnMarker(iProject, AdtConstants.MARKER_ANDROID, IResource.DEPTH_ZERO, false /*checkSeverity*/); // do a search for JDT markers. Those can be errors or warnings stopOnMarker(iProject, IJavaModelMarker.JAVA_MODEL_PROBLEM_MARKER, IResource.DEPTH_INFINITE, true /*checkSeverity*/); stopOnMarker(iProject, IJavaModelMarker.BUILDPATH_PROBLEM_MARKER, IResource.DEPTH_INFINITE, true /*checkSeverity*/); } }