| /* |
| * 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.common.xml.ManifestData; |
| import com.android.ide.eclipse.adt.AdtConstants; |
| import com.android.ide.eclipse.adt.AdtPlugin; |
| import com.android.ide.eclipse.adt.internal.build.AaptParser; |
| import com.android.ide.eclipse.adt.internal.build.AidlProcessor; |
| import com.android.ide.eclipse.adt.internal.build.Messages; |
| import com.android.ide.eclipse.adt.internal.build.RenderScriptLauncher; |
| import com.android.ide.eclipse.adt.internal.build.RsSourceChangeHandler; |
| import com.android.ide.eclipse.adt.internal.build.SourceProcessor; |
| import com.android.ide.eclipse.adt.internal.build.builders.BaseBuilder.AbortBuildException; |
| import com.android.ide.eclipse.adt.internal.lint.EclipseLintClient; |
| 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.AndroidManifestHelper; |
| import com.android.ide.eclipse.adt.internal.project.BaseProjectHelper; |
| import com.android.ide.eclipse.adt.internal.project.FixLaunchConfig; |
| import com.android.ide.eclipse.adt.internal.project.ProjectHelper; |
| import com.android.ide.eclipse.adt.internal.project.XmlErrorHandler.BasicXmlErrorListener; |
| import com.android.ide.eclipse.adt.internal.resources.manager.IdeScanningContext; |
| import com.android.ide.eclipse.adt.internal.resources.manager.ProjectResources; |
| import com.android.ide.eclipse.adt.internal.resources.manager.ResourceManager; |
| import com.android.ide.eclipse.adt.internal.sdk.AdtManifestMergeCallback; |
| 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.ide.eclipse.adt.io.IFolderWrapper; |
| import com.android.io.StreamException; |
| import com.android.manifmerger.ManifestMerger; |
| import com.android.manifmerger.MergerLog; |
| import com.android.sdklib.AndroidVersion; |
| import com.android.sdklib.BuildToolInfo; |
| import com.android.sdklib.IAndroidTarget; |
| import com.android.sdklib.build.RenderScriptChecker; |
| import com.android.sdklib.build.RenderScriptProcessor; |
| import com.android.sdklib.internal.build.BuildConfigGenerator; |
| import com.android.sdklib.internal.build.SymbolLoader; |
| import com.android.sdklib.internal.build.SymbolWriter; |
| import com.android.sdklib.internal.project.ProjectProperties; |
| import com.android.sdklib.io.FileOp; |
| import com.android.sdklib.repository.FullRevision; |
| import com.android.utils.ILogger; |
| import com.android.utils.Pair; |
| import com.android.xml.AndroidManifest; |
| import com.google.common.collect.ArrayListMultimap; |
| import com.google.common.collect.Lists; |
| import com.google.common.collect.Multimap; |
| |
| 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.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.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.jdt.core.IJavaProject; |
| import org.eclipse.jdt.core.JavaCore; |
| import org.xml.sax.SAXException; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.List; |
| import java.util.Map; |
| |
| import javax.xml.parsers.ParserConfigurationException; |
| |
| /** |
| * Pre Java Compiler. |
| * This incremental builder performs 2 tasks: |
| * <ul> |
| * <li>compiles the resources located in the res/ folder, along with the |
| * AndroidManifest.xml file into the R.java class.</li> |
| * <li>compiles any .aidl files into a corresponding java file.</li> |
| * </ul> |
| * |
| */ |
| public class PreCompilerBuilder 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.PreCompilerBuilder"; //$NON-NLS-1$ |
| |
| /** Flag to pass to PreCompiler builder that the build is a release build. |
| */ |
| public final static String RELEASE_REQUESTED = "android.releaseBuild"; //$NON-NLS-1$ |
| |
| private static final String PROPERTY_PACKAGE = "manifestPackage"; //$NON-NLS-1$ |
| private static final String PROPERTY_MERGE_MANIFEST = "mergeManifest"; //$NON-NLS-1$ |
| private static final String PROPERTY_COMPILE_RESOURCES = "compileResources"; //$NON-NLS-1$ |
| private static final String PROPERTY_COMPILE_BUILDCONFIG = "createBuildConfig"; //$NON-NLS-1$ |
| private static final String PROPERTY_BUILDCONFIG_MODE = "buildConfigMode"; //$NON-NLS-1$ |
| |
| private static final boolean MANIFEST_MERGER_ENABLED_DEFAULT = false; |
| private static final String MANIFEST_MERGER_PROPERTY = "manifestmerger.enabled"; //$NON-NLS-1$ |
| |
| /** Merge Manifest Flag. Computed from resource delta, reset after action is taken. |
| * Stored persistently in the project. */ |
| private boolean mMustMergeManifest = false; |
| /** Resource compilation Flag. Computed from resource delta, reset after action is taken. |
| * Stored persistently in the project. */ |
| private boolean mMustCompileResources = false; |
| /** BuildConfig Flag. Computed from resource delta, reset after action is taken. |
| * Stored persistently in the project. */ |
| private boolean mMustCreateBuildConfig = false; |
| /** BuildConfig last more Flag. Computed from resource delta, reset after action is taken. |
| * Stored persistently in the project. */ |
| private boolean mLastBuildConfigMode; |
| |
| /** cache of the java package defined in the manifest */ |
| private String mManifestPackage; |
| |
| /** Output folder for generated Java File. Created on the Builder init |
| * @see #startupOnInitialize() |
| */ |
| private IFolder mGenFolder; |
| |
| /** |
| * Progress monitor used at the end of every build to refresh the content of the 'gen' folder |
| * and set the generated files as derived. |
| */ |
| private DerivedProgressMonitor mDerivedProgressMonitor; |
| |
| private AidlProcessor mAidlProcessor; |
| private RsSourceChangeHandler mRenderScriptSourceChangeHandler; |
| |
| /** |
| * Progress monitor waiting the end of the process to set a persistent value |
| * in a file. This is typically used in conjunction with <code>IResource.refresh()</code>, |
| * since this call is asynchronous, and we need to wait for it to finish for the file |
| * to be known by eclipse, before we can call <code>resource.setPersistentProperty</code> on |
| * a new file. |
| */ |
| private static class DerivedProgressMonitor implements IProgressMonitor { |
| private boolean mCancelled = false; |
| private boolean mDone = false; |
| private final IFolder mGenFolder; |
| |
| public DerivedProgressMonitor(IFolder genFolder) { |
| mGenFolder = genFolder; |
| } |
| |
| void reset() { |
| mDone = false; |
| } |
| |
| @Override |
| public void beginTask(String name, int totalWork) { |
| } |
| |
| @Override |
| public void done() { |
| if (mDone == false) { |
| mDone = true; |
| processChildrenOf(mGenFolder); |
| } |
| } |
| |
| private void processChildrenOf(IFolder folder) { |
| IResource[] list; |
| try { |
| list = folder.members(); |
| } catch (CoreException e) { |
| return; |
| } |
| |
| for (IResource member : list) { |
| if (member.exists()) { |
| if (member.getType() == IResource.FOLDER) { |
| processChildrenOf((IFolder) member); |
| } |
| |
| try { |
| member.setDerived(true, new NullProgressMonitor()); |
| } catch (CoreException e) { |
| // This really shouldn't happen since we check that the resource |
| // exist. |
| // Worst case scenario, the resource isn't marked as derived. |
| } |
| } |
| } |
| } |
| |
| @Override |
| public void internalWorked(double work) { |
| } |
| |
| @Override |
| public boolean isCanceled() { |
| return mCancelled; |
| } |
| |
| @Override |
| public void setCanceled(boolean value) { |
| mCancelled = value; |
| } |
| |
| @Override |
| public void setTaskName(String name) { |
| } |
| |
| @Override |
| public void subTask(String name) { |
| } |
| |
| @Override |
| public void worked(int work) { |
| } |
| } |
| |
| public PreCompilerBuilder() { |
| super(); |
| } |
| |
| // 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(PRE)", project.getName()); |
| } |
| |
| // For the PreCompiler, only the library projects are considered Referenced projects, |
| // as only those projects have an impact on what is generated by this builder. |
| IProject[] result = null; |
| |
| IFolder resOutFolder = null; |
| |
| try { |
| assert mDerivedProgressMonitor != null; |
| |
| mDerivedProgressMonitor.reset(); |
| |
| // 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(); |
| |
| IAndroidTarget projectTarget = projectState.getTarget(); |
| |
| // get the libraries |
| List<IProject> libProjects = projectState.getFullLibraryProjects(); |
| result = libProjects.toArray(new IProject[libProjects.size()]); |
| |
| IJavaProject javaProject = JavaCore.create(project); |
| |
| // Top level check to make sure the build can move forward. |
| abortOnBadSetup(javaProject, projectState); |
| |
| // now we need to get the classpath list |
| List<IPath> sourceFolderPathList = BaseProjectHelper.getSourceClasspaths(javaProject); |
| |
| IFolder androidOutputFolder = BaseProjectHelper.getAndroidOutputFolder(project); |
| |
| resOutFolder = getResOutFolder(androidOutputFolder); |
| |
| setupSourceProcessors(javaProject, projectState, sourceFolderPathList, |
| androidOutputFolder); |
| |
| PreCompilerDeltaVisitor dv = null; |
| String javaPackage = null; |
| String minSdkVersion = null; |
| |
| if (kind == FULL_BUILD) { |
| AdtPlugin.printBuildToConsole(BuildVerbosity.VERBOSE, project, |
| Messages.Start_Full_Pre_Compiler); |
| |
| if (DEBUG_LOG) { |
| AdtPlugin.log(IStatus.INFO, "%s full build!", project.getName()); |
| } |
| |
| // do some clean up. |
| doClean(project, monitor); |
| |
| mMustMergeManifest = true; |
| mMustCompileResources = true; |
| mMustCreateBuildConfig = true; |
| |
| mAidlProcessor.prepareFullBuild(project); |
| mRenderScriptSourceChangeHandler.prepareFullBuild(); |
| } else { |
| AdtPlugin.printBuildToConsole(BuildVerbosity.VERBOSE, project, |
| Messages.Start_Inc_Pre_Compiler); |
| |
| // Go through the resources and see if something changed. |
| // Even if the mCompileResources flag is true from a previously aborted |
| // build, we need to go through the Resource delta to get a possible |
| // list of aidl files to compile/remove. |
| IResourceDelta delta = getDelta(project); |
| if (delta == null) { |
| mMustCompileResources = true; |
| |
| mAidlProcessor.prepareFullBuild(project); |
| mRenderScriptSourceChangeHandler.prepareFullBuild(); |
| } else { |
| dv = new PreCompilerDeltaVisitor(this, sourceFolderPathList, |
| mAidlProcessor.getChangeHandler(), |
| mRenderScriptSourceChangeHandler); |
| delta.accept(dv); |
| |
| // Check to see if Manifest.xml, Manifest.java, or R.java have changed: |
| mMustCompileResources |= dv.getCompileResources(); |
| mMustMergeManifest |= dv.hasManifestChanged(); |
| |
| // Notify the ResourceManager: |
| ResourceManager resManager = ResourceManager.getInstance(); |
| |
| if (ResourceManager.isAutoBuilding()) { |
| ProjectResources projectResources = resManager.getProjectResources(project); |
| |
| IdeScanningContext context = new IdeScanningContext(projectResources, |
| project, true); |
| |
| boolean wasCleared = projectResources.ensureInitialized(); |
| |
| if (!wasCleared) { |
| resManager.processDelta(delta, context); |
| } |
| |
| // Check whether this project or its dependencies (libraries) have |
| // resources that need compilation |
| if (wasCleared || context.needsFullAapt()) { |
| mMustCompileResources = true; |
| |
| // Must also call markAaptRequested on the project to not just |
| // store "aapt required" on this project, but also on any projects |
| // depending on this project if it's a library project |
| ResourceManager.markAaptRequested(project); |
| } |
| |
| // Update error markers in the source editor |
| if (!mMustCompileResources) { |
| context.updateMarkers(false /* async */); |
| } |
| } // else: already processed the deltas in ResourceManager's IRawDeltaListener |
| |
| mAidlProcessor.doneVisiting(project); |
| |
| // get the java package from the visitor |
| javaPackage = dv.getManifestPackage(); |
| minSdkVersion = dv.getMinSdkVersion(); |
| } |
| } |
| |
| // Has anyone marked this project as needing aapt? Typically done when |
| // one of the library projects this project depends on has changed |
| mMustCompileResources |= ResourceManager.isAaptRequested(project); |
| |
| // if the main manifest didn't change, then we check for the library |
| // ones (will trigger manifest merging too) |
| if (libProjects.size() > 0) { |
| for (IProject libProject : libProjects) { |
| IResourceDelta delta = getDelta(libProject); |
| if (delta != null) { |
| PatternBasedDeltaVisitor visitor = new PatternBasedDeltaVisitor( |
| project, libProject, |
| "PRE:LibManifest"); //$NON-NLS-1$ |
| visitor.addSet(ChangedFileSetHelper.MANIFEST); |
| |
| ChangedFileSet textSymbolCFS = null; |
| if (isLibrary == false) { |
| textSymbolCFS = ChangedFileSetHelper.getTextSymbols( |
| libProject); |
| visitor.addSet(textSymbolCFS); |
| } |
| |
| delta.accept(visitor); |
| |
| mMustMergeManifest |= visitor.checkSet(ChangedFileSetHelper.MANIFEST); |
| |
| if (textSymbolCFS != null) { |
| mMustCompileResources |= visitor.checkSet(textSymbolCFS); |
| } |
| |
| // no need to test others if we have all flags at true. |
| if (mMustMergeManifest && |
| (mMustCompileResources || textSymbolCFS == null)) { |
| break; |
| } |
| } |
| } |
| } |
| |
| // store the build status in the persistent storage |
| saveProjectBooleanProperty(PROPERTY_MERGE_MANIFEST, mMustMergeManifest); |
| saveProjectBooleanProperty(PROPERTY_COMPILE_RESOURCES, mMustCompileResources); |
| saveProjectBooleanProperty(PROPERTY_COMPILE_BUILDCONFIG, mMustCreateBuildConfig); |
| |
| // if there was some XML errors, we just return w/o doing |
| // anything since we've put some markers in the files anyway. |
| if (dv != null && dv.mXmlError) { |
| AdtPlugin.printErrorToConsole(project, Messages.Xml_Error); |
| |
| return result; |
| } |
| |
| if (projectState.getRenderScriptSupportMode()) { |
| FullRevision minBuildToolsRev = new FullRevision(19,0,3); |
| if (mBuildToolInfo.getRevision().compareTo(minBuildToolsRev) == -1) { |
| String msg = "RenderScript support mode requires Build-Tools 19.0.3 or later."; |
| AdtPlugin.printErrorToConsole(project, msg); |
| markProject(AdtConstants.MARKER_ADT, msg, IMarker.SEVERITY_ERROR); |
| |
| return result; |
| } |
| } |
| |
| // get the manifest file |
| IFile manifestFile = ProjectHelper.getManifest(project); |
| |
| if (manifestFile == null) { |
| String msg = String.format(Messages.s_File_Missing, |
| SdkConstants.FN_ANDROID_MANIFEST_XML); |
| AdtPlugin.printErrorToConsole(project, msg); |
| markProject(AdtConstants.MARKER_ADT, msg, IMarker.SEVERITY_ERROR); |
| |
| return result; |
| |
| // TODO: document whether code below that uses manifest (which is now guaranteed |
| // to be null) will actually be executed or not. |
| } |
| |
| // lets check the XML of the manifest first, if that hasn't been done by the |
| // resource delta visitor yet. |
| if (dv == null || dv.getCheckedManifestXml() == false) { |
| BasicXmlErrorListener errorListener = new BasicXmlErrorListener(); |
| try { |
| ManifestData parser = AndroidManifestHelper.parseUnchecked( |
| new IFileWrapper(manifestFile), |
| true /*gather data*/, |
| errorListener); |
| |
| if (errorListener.mHasXmlError == true) { |
| // There was an error in the manifest, its file has been marked |
| // by the XmlErrorHandler. The stopBuild() call below will abort |
| // this with an exception. |
| String msg = String.format(Messages.s_Contains_Xml_Error, |
| SdkConstants.FN_ANDROID_MANIFEST_XML); |
| AdtPlugin.printBuildToConsole(BuildVerbosity.VERBOSE, project, msg); |
| markProject(AdtConstants.MARKER_ADT, msg, IMarker.SEVERITY_ERROR); |
| |
| return result; |
| } |
| |
| // Get the java package from the parser. |
| // This can be null if the parsing failed because the resource is out of sync, |
| // in which case the error will already have been logged anyway. |
| if (parser != null) { |
| javaPackage = parser.getPackage(); |
| minSdkVersion = parser.getMinSdkVersionString(); |
| } |
| } catch (StreamException e) { |
| handleStreamException(e); |
| |
| return result; |
| } catch (ParserConfigurationException e) { |
| String msg = String.format( |
| "Bad parser configuration for %s: %s", |
| manifestFile.getFullPath(), |
| e.getMessage()); |
| |
| handleException(e, msg); |
| return result; |
| |
| } catch (SAXException e) { |
| String msg = String.format( |
| "Parser exception for %s: %s", |
| manifestFile.getFullPath(), |
| e.getMessage()); |
| |
| handleException(e, msg); |
| return result; |
| } catch (IOException e) { |
| String msg = String.format( |
| "I/O error for %s: %s", |
| manifestFile.getFullPath(), |
| e.getMessage()); |
| |
| handleException(e, msg); |
| return result; |
| } |
| } |
| |
| int minSdkValue = -1; |
| |
| if (minSdkVersion != null) { |
| try { |
| minSdkValue = Integer.parseInt(minSdkVersion); |
| } catch (NumberFormatException e) { |
| // it's ok, it means minSdkVersion contains a (hopefully) valid codename. |
| } |
| |
| AndroidVersion targetVersion = projectTarget.getVersion(); |
| |
| // remove earlier marker from the manifest |
| removeMarkersFromResource(manifestFile, AdtConstants.MARKER_ADT); |
| |
| if (minSdkValue != -1) { |
| String codename = targetVersion.getCodename(); |
| if (codename != null) { |
| // integer minSdk when the target is a preview => fatal error |
| String msg = String.format( |
| "Platform %1$s is a preview and requires application manifest to set %2$s to '%1$s'", |
| codename, AndroidManifest.ATTRIBUTE_MIN_SDK_VERSION); |
| AdtPlugin.printErrorToConsole(project, msg); |
| BaseProjectHelper.markResource(manifestFile, AdtConstants.MARKER_ADT, |
| msg, IMarker.SEVERITY_ERROR); |
| return result; |
| } else if (minSdkValue > targetVersion.getApiLevel()) { |
| // integer minSdk is too high for the target => warning |
| String msg = String.format( |
| "Attribute %1$s (%2$d) is higher than the project target API level (%3$d)", |
| AndroidManifest.ATTRIBUTE_MIN_SDK_VERSION, |
| minSdkValue, targetVersion.getApiLevel()); |
| AdtPlugin.printBuildToConsole(BuildVerbosity.VERBOSE, project, msg); |
| BaseProjectHelper.markResource(manifestFile, AdtConstants.MARKER_ADT, |
| msg, IMarker.SEVERITY_WARNING); |
| } |
| } else { |
| // looks like the min sdk is a codename, check it matches the codename |
| // of the platform |
| String codename = targetVersion.getCodename(); |
| if (codename == null) { |
| // platform is not a preview => fatal error |
| String msg = String.format( |
| "Manifest attribute '%1$s' is set to '%2$s'. Integer is expected.", |
| AndroidManifest.ATTRIBUTE_MIN_SDK_VERSION, minSdkVersion); |
| AdtPlugin.printErrorToConsole(project, msg); |
| BaseProjectHelper.markResource(manifestFile, AdtConstants.MARKER_ADT, |
| msg, IMarker.SEVERITY_ERROR); |
| return result; |
| } else if (codename.equals(minSdkVersion) == false) { |
| // platform and manifest codenames don't match => fatal error. |
| String msg = String.format( |
| "Value of manifest attribute '%1$s' does not match platform codename '%2$s'", |
| AndroidManifest.ATTRIBUTE_MIN_SDK_VERSION, codename); |
| AdtPlugin.printErrorToConsole(project, msg); |
| BaseProjectHelper.markResource(manifestFile, AdtConstants.MARKER_ADT, |
| msg, IMarker.SEVERITY_ERROR); |
| return result; |
| } |
| |
| // if we get there, the minSdkVersion is a codename matching the target |
| // platform codename. In this case we set minSdkValue to the previous API |
| // level, as it's used by source processors. |
| minSdkValue = targetVersion.getApiLevel(); |
| } |
| } else if (projectTarget.getVersion().isPreview()) { |
| // else the minSdkVersion is not set but we are using a preview target. |
| // Display an error |
| String codename = projectTarget.getVersion().getCodename(); |
| String msg = String.format( |
| "Platform %1$s is a preview and requires application manifests to set %2$s to '%1$s'", |
| codename, AndroidManifest.ATTRIBUTE_MIN_SDK_VERSION); |
| AdtPlugin.printErrorToConsole(project, msg); |
| BaseProjectHelper.markResource(manifestFile, AdtConstants.MARKER_ADT, msg, |
| IMarker.SEVERITY_ERROR); |
| return result; |
| } |
| |
| if (javaPackage == null || javaPackage.length() == 0) { |
| // looks like the AndroidManifest file isn't valid. |
| String msg = String.format(Messages.s_Doesnt_Declare_Package_Error, |
| SdkConstants.FN_ANDROID_MANIFEST_XML); |
| AdtPlugin.printErrorToConsole(project, msg); |
| BaseProjectHelper.markResource(manifestFile, AdtConstants.MARKER_ADT, |
| msg, IMarker.SEVERITY_ERROR); |
| |
| return result; |
| } else if (javaPackage.indexOf('.') == -1) { |
| // The application package name does not contain 2+ segments! |
| String msg = String.format( |
| "Application package '%1$s' must have a minimum of 2 segments.", |
| SdkConstants.FN_ANDROID_MANIFEST_XML); |
| AdtPlugin.printErrorToConsole(project, msg); |
| BaseProjectHelper.markResource(manifestFile, AdtConstants.MARKER_ADT, |
| msg, IMarker.SEVERITY_ERROR); |
| |
| return result; |
| } |
| |
| // at this point we have the java package. We need to make sure it's not a different |
| // package than the previous one that were built. |
| if (javaPackage.equals(mManifestPackage) == false) { |
| // The manifest package has changed, the user may want to update |
| // the launch configuration |
| if (mManifestPackage != null) { |
| AdtPlugin.printBuildToConsole(BuildVerbosity.VERBOSE, project, |
| Messages.Checking_Package_Change); |
| |
| FixLaunchConfig flc = new FixLaunchConfig(project, mManifestPackage, |
| javaPackage); |
| flc.start(); |
| } |
| |
| // record the new manifest package, and save it. |
| mManifestPackage = javaPackage; |
| saveProjectStringProperty(PROPERTY_PACKAGE, mManifestPackage); |
| |
| // force a clean |
| doClean(project, monitor); |
| mMustMergeManifest = true; |
| mMustCompileResources = true; |
| mMustCreateBuildConfig = true; |
| mAidlProcessor.prepareFullBuild(project); |
| mRenderScriptSourceChangeHandler.prepareFullBuild(); |
| |
| saveProjectBooleanProperty(PROPERTY_MERGE_MANIFEST, mMustMergeManifest); |
| saveProjectBooleanProperty(PROPERTY_COMPILE_RESOURCES, mMustCompileResources); |
| saveProjectBooleanProperty(PROPERTY_COMPILE_BUILDCONFIG, mMustCreateBuildConfig); |
| } |
| |
| try { |
| handleBuildConfig(args); |
| } catch (IOException e) { |
| handleException(e, "Failed to create BuildConfig class"); |
| return result; |
| } |
| |
| // merge the manifest |
| if (mMustMergeManifest) { |
| boolean enabled = MANIFEST_MERGER_ENABLED_DEFAULT; |
| String propValue = projectState.getProperty(MANIFEST_MERGER_PROPERTY); |
| if (propValue != null) { |
| enabled = Boolean.valueOf(propValue); |
| } |
| |
| if (mergeManifest(androidOutputFolder, libProjects, enabled) == false) { |
| return result; |
| } |
| } |
| |
| List<File> libProjectsOut = new ArrayList<File>(libProjects.size()); |
| for (IProject libProject : libProjects) { |
| libProjectsOut.add( |
| BaseProjectHelper.getAndroidOutputFolder(libProject) |
| .getLocation().toFile()); |
| } |
| |
| // run the source processors |
| int processorStatus = SourceProcessor.COMPILE_STATUS_NONE; |
| |
| |
| try { |
| processorStatus |= mAidlProcessor.compileFiles(this, |
| project, projectTarget, sourceFolderPathList, |
| libProjectsOut, monitor); |
| } catch (Throwable t) { |
| handleException(t, "Failed to run aidl. Check workspace log for detail."); |
| return result; |
| } |
| |
| try { |
| processorStatus |= compileRs(minSdkValue, projectState, androidOutputFolder, |
| resOutFolder, monitor); |
| } catch (Throwable t) { |
| handleException(t, "Failed to run renderscript. Check workspace log for detail."); |
| return result; |
| } |
| |
| // if a processor created some resources file, force recompilation of the resources. |
| if ((processorStatus & SourceProcessor.COMPILE_STATUS_RES) != 0) { |
| mMustCompileResources = true; |
| // save the current state before attempting the compilation |
| saveProjectBooleanProperty(PROPERTY_COMPILE_RESOURCES, mMustCompileResources); |
| } |
| |
| // handle the resources, after the processors are run since some (renderscript) |
| // generate resources. |
| boolean compiledTheResources = mMustCompileResources; |
| if (mMustCompileResources) { |
| if (DEBUG_LOG) { |
| AdtPlugin.log(IStatus.INFO, "%s compiling resources!", project.getName()); |
| } |
| |
| IFile proguardFile = null; |
| if (projectState.getProperty(ProjectProperties.PROPERTY_PROGUARD_CONFIG) != null) { |
| proguardFile = androidOutputFolder.getFile(AdtConstants.FN_AAPT_PROGUARD); |
| } |
| |
| handleResources(project, javaPackage, projectTarget, manifestFile, resOutFolder, |
| libProjects, isLibrary, proguardFile); |
| } |
| |
| if (processorStatus == SourceProcessor.COMPILE_STATUS_NONE && |
| compiledTheResources == false) { |
| AdtPlugin.printBuildToConsole(BuildVerbosity.VERBOSE, project, |
| Messages.Nothing_To_Compile); |
| } |
| } catch (AbortBuildException e) { |
| return result; |
| } finally { |
| // refresh the 'gen' source folder. Once this is done with the custom progress |
| // monitor to mark all new files as derived |
| mGenFolder.refreshLocal(IResource.DEPTH_INFINITE, mDerivedProgressMonitor); |
| if (resOutFolder != null) { |
| resOutFolder.refreshLocal(IResource.DEPTH_INFINITE, mDerivedProgressMonitor); |
| } |
| } |
| |
| return result; |
| } |
| |
| private IFolder getResOutFolder(IFolder androidOutputFolder) { |
| return androidOutputFolder.getFolder(AdtConstants.WS_BIN_RELATIVE_BC); |
| } |
| |
| @Override |
| protected void clean(IProgressMonitor monitor) throws CoreException { |
| super.clean(monitor); |
| |
| if (DEBUG_LOG) { |
| AdtPlugin.log(IStatus.INFO, "%s CLEAN(PRE)", getProject().getName()); |
| } |
| |
| doClean(getProject(), monitor); |
| if (mGenFolder != null) { |
| mGenFolder.refreshLocal(IResource.DEPTH_INFINITE, monitor); |
| } |
| } |
| |
| private void doClean(IProject project, IProgressMonitor monitor) throws CoreException { |
| AdtPlugin.printBuildToConsole(BuildVerbosity.VERBOSE, project, |
| Messages.Removing_Generated_Classes); |
| |
| // remove all the derived resources from the 'gen' source folder. |
| if (mGenFolder != null && mGenFolder.exists()) { |
| // gen folder should not be derived, but previous version could set it to derived |
| // so we make sure this isn't the case (or it'll get deleted by the clean) |
| mGenFolder.setDerived(false, monitor); |
| |
| removeDerivedResources(mGenFolder, monitor); |
| } |
| |
| // Clear the project of the generic markers |
| removeMarkersFromContainer(project, AdtConstants.MARKER_AAPT_COMPILE); |
| removeMarkersFromContainer(project, AdtConstants.MARKER_XML); |
| removeMarkersFromContainer(project, AdtConstants.MARKER_AIDL); |
| removeMarkersFromContainer(project, AdtConstants.MARKER_RENDERSCRIPT); |
| removeMarkersFromContainer(project, AdtConstants.MARKER_MANIFMERGER); |
| removeMarkersFromContainer(project, AdtConstants.MARKER_ANDROID); |
| |
| // Also clean up lint |
| EclipseLintClient.clearMarkers(project); |
| |
| // clean the project repo |
| ProjectResources res = ResourceManager.getInstance().getProjectResources(project); |
| res.clear(); |
| } |
| |
| @Override |
| protected void startupOnInitialize() { |
| try { |
| super.startupOnInitialize(); |
| |
| IProject project = getProject(); |
| |
| // load the previous IFolder and java package. |
| mManifestPackage = loadProjectStringProperty(PROPERTY_PACKAGE); |
| |
| // get the source folder in which all the Java files are created |
| mGenFolder = project.getFolder(SdkConstants.FD_GEN_SOURCES); |
| mDerivedProgressMonitor = new DerivedProgressMonitor(mGenFolder); |
| |
| // Load the current compile flags. We ask for true if not found to force a recompile. |
| mMustMergeManifest = loadProjectBooleanProperty(PROPERTY_MERGE_MANIFEST, true); |
| mMustCompileResources = loadProjectBooleanProperty(PROPERTY_COMPILE_RESOURCES, true); |
| mMustCreateBuildConfig = loadProjectBooleanProperty(PROPERTY_COMPILE_BUILDCONFIG, true); |
| Boolean v = ProjectHelper.loadBooleanProperty(project, PROPERTY_BUILDCONFIG_MODE); |
| if (v == null) { |
| // no previous build config mode? force regenerate |
| mMustCreateBuildConfig = true; |
| } else { |
| mLastBuildConfigMode = v; |
| } |
| |
| } catch (Throwable throwable) { |
| AdtPlugin.log(throwable, "Failed to finish PrecompilerBuilder#startupOnInitialize()"); |
| } |
| } |
| |
| private void setupSourceProcessors(@NonNull IJavaProject javaProject, |
| @NonNull ProjectState projectState, |
| @NonNull List<IPath> sourceFolderPathList, |
| @NonNull IFolder androidOutputFolder) { |
| if (mAidlProcessor == null) { |
| mAidlProcessor = new AidlProcessor(javaProject, mBuildToolInfo, mGenFolder); |
| } else { |
| mAidlProcessor.setBuildToolInfo(mBuildToolInfo); |
| } |
| |
| List<File> sourceFolders = Lists.newArrayListWithCapacity(sourceFolderPathList.size()); |
| IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot(); |
| |
| for (IPath path : sourceFolderPathList) { |
| IResource resource = root.findMember(path); |
| if (resource != null && resource.exists() && resource.getType() == IResource.FOLDER) { |
| IPath fullPath = resource.getLocation(); |
| if (fullPath != null) { |
| sourceFolders.add(fullPath.toFile()); |
| } |
| } |
| } |
| |
| RenderScriptChecker checker = new RenderScriptChecker(sourceFolders, |
| androidOutputFolder.getLocation().toFile()); |
| mRenderScriptSourceChangeHandler = new RsSourceChangeHandler(checker); |
| } |
| |
| private int compileRs(int minSdkValue, |
| @NonNull ProjectState projectState, |
| @NonNull IFolder androidOutputFolder, |
| @NonNull IFolder resOutFolder, |
| @NonNull IProgressMonitor monitor) |
| throws IOException, InterruptedException { |
| if (!mRenderScriptSourceChangeHandler.mustCompile()) { |
| return SourceProcessor.COMPILE_STATUS_NONE; |
| } |
| |
| RenderScriptChecker checker = mRenderScriptSourceChangeHandler.getChecker(); |
| |
| List<File> inputs = checker.findInputFiles(); |
| List<File> importFolders = checker.getSourceFolders(); |
| File buildFolder = androidOutputFolder.getLocation().toFile(); |
| |
| |
| // get the renderscript target |
| int rsTarget = minSdkValue == -1 ? 11 : minSdkValue; |
| String rsTargetStr = projectState.getProperty(ProjectProperties.PROPERTY_RS_TARGET); |
| if (rsTargetStr != null) { |
| try { |
| rsTarget = Integer.parseInt(rsTargetStr); |
| } catch (NumberFormatException e) { |
| handleException(e, String.format( |
| "Property %s is not an integer.", |
| ProjectProperties.PROPERTY_RS_TARGET)); |
| return SourceProcessor.COMPILE_STATUS_NONE; |
| } |
| } |
| |
| RenderScriptProcessor processor = new RenderScriptProcessor( |
| inputs, |
| importFolders, |
| buildFolder, |
| mGenFolder.getLocation().toFile(), |
| resOutFolder.getLocation().toFile(), |
| new File(buildFolder, SdkConstants.FD_RS_OBJ), |
| new File(buildFolder, SdkConstants.FD_RS_LIBS), |
| mBuildToolInfo, |
| rsTarget, |
| false /*debugBuild, always false for now*/, |
| 3, |
| projectState.getRenderScriptSupportMode()); |
| |
| // clean old dependency files fiest |
| checker.cleanDependencies(); |
| |
| // then clean old output files |
| processor.cleanOldOutput(checker.getOldOutputs()); |
| |
| RenderScriptLauncher launcher = new RenderScriptLauncher( |
| getProject(), |
| mGenFolder, |
| resOutFolder, |
| monitor, |
| AdtPrefs.getPrefs().getBuildVerbosity() == BuildVerbosity.VERBOSE /*verbose*/); |
| |
| // and run the build |
| processor.build(launcher); |
| |
| return SourceProcessor.COMPILE_STATUS_CODE | SourceProcessor.COMPILE_STATUS_RES; |
| } |
| |
| @SuppressWarnings("deprecation") |
| private void handleBuildConfig(@SuppressWarnings("rawtypes") Map args) |
| throws IOException, CoreException { |
| boolean debugMode = !args.containsKey(RELEASE_REQUESTED); |
| |
| BuildConfigGenerator generator = new BuildConfigGenerator( |
| mGenFolder.getLocation().toOSString(), mManifestPackage, debugMode); |
| |
| if (mMustCreateBuildConfig == false) { |
| // check the file is present. |
| IFolder folder = getGenManifestPackageFolder(); |
| if (folder.exists(new Path(BuildConfigGenerator.BUILD_CONFIG_NAME)) == false) { |
| mMustCreateBuildConfig = true; |
| AdtPlugin.printBuildToConsole(BuildVerbosity.VERBOSE, getProject(), |
| String.format("Class %1$s is missing!", |
| BuildConfigGenerator.BUILD_CONFIG_NAME)); |
| } else if (debugMode != mLastBuildConfigMode) { |
| // else if the build mode changed, force creation |
| mMustCreateBuildConfig = true; |
| AdtPlugin.printBuildToConsole(BuildVerbosity.VERBOSE, getProject(), |
| String.format("Different build mode, must update %1$s!", |
| BuildConfigGenerator.BUILD_CONFIG_NAME)); |
| } |
| } |
| |
| if (mMustCreateBuildConfig) { |
| if (DEBUG_LOG) { |
| AdtPlugin.log(IStatus.INFO, "%s generating BuilderConfig!", getProject().getName()); |
| } |
| |
| AdtPlugin.printBuildToConsole(BuildVerbosity.VERBOSE, getProject(), |
| String.format("Generating %1$s...", BuildConfigGenerator.BUILD_CONFIG_NAME)); |
| generator.generate(); |
| |
| mMustCreateBuildConfig = false; |
| saveProjectBooleanProperty(PROPERTY_COMPILE_BUILDCONFIG, mMustCreateBuildConfig); |
| saveProjectBooleanProperty(PROPERTY_BUILDCONFIG_MODE, mLastBuildConfigMode = debugMode); |
| } |
| } |
| |
| private boolean mergeManifest(IFolder androidOutFolder, List<IProject> libProjects, |
| boolean enabled) throws CoreException { |
| if (DEBUG_LOG) { |
| AdtPlugin.log(IStatus.INFO, "%s merging manifests!", getProject().getName()); |
| } |
| |
| IFile outFile = androidOutFolder.getFile(SdkConstants.FN_ANDROID_MANIFEST_XML); |
| IFile manifest = getProject().getFile(SdkConstants.FN_ANDROID_MANIFEST_XML); |
| |
| // remove existing markers from the manifest. |
| // FIXME: only remove from manifest once the markers are put there. |
| removeMarkersFromResource(getProject(), AdtConstants.MARKER_MANIFMERGER); |
| |
| // If the merging is not enabled or if there's no library then we simply copy the |
| // manifest over. |
| if (enabled == false || libProjects.size() == 0) { |
| try { |
| new FileOp().copyFile(manifest.getLocation().toFile(), |
| outFile.getLocation().toFile()); |
| |
| outFile.refreshLocal(IResource.DEPTH_INFINITE, mDerivedProgressMonitor); |
| |
| saveProjectBooleanProperty(PROPERTY_MERGE_MANIFEST, mMustMergeManifest = false); |
| } catch (IOException e) { |
| handleException(e, "Failed to copy Manifest"); |
| return false; |
| } |
| } else { |
| final ArrayList<String> errors = new ArrayList<String>(); |
| |
| // TODO change MergerLog.wrapSdkLog by a custom IMergerLog that will create |
| // and maintain error markers. |
| ManifestMerger merger = new ManifestMerger( |
| MergerLog.wrapSdkLog(new ILogger() { |
| @Override |
| public void warning(@NonNull String warningFormat, Object... args) { |
| AdtPlugin.printToConsole(getProject(), String.format(warningFormat, args)); |
| } |
| |
| @Override |
| public void info(@NonNull String msgFormat, Object... args) { |
| AdtPlugin.printToConsole(getProject(), String.format(msgFormat, args)); |
| } |
| |
| @Override |
| public void verbose(@NonNull String msgFormat, Object... args) { |
| info(msgFormat, args); |
| } |
| |
| @Override |
| public void error(@Nullable Throwable t, @Nullable String errorFormat, |
| Object... args) { |
| errors.add(String.format(errorFormat, args)); |
| } |
| }), |
| new AdtManifestMergeCallback()); |
| |
| File[] libManifests = new File[libProjects.size()]; |
| int libIndex = 0; |
| for (IProject lib : libProjects) { |
| libManifests[libIndex++] = lib.getFile(SdkConstants.FN_ANDROID_MANIFEST_XML) |
| .getLocation().toFile(); |
| } |
| |
| if (merger.process( |
| outFile.getLocation().toFile(), |
| manifest.getLocation().toFile(), |
| libManifests, |
| null /*injectAttributes*/, null /*packageOverride*/) == false) { |
| if (errors.size() > 1) { |
| StringBuilder sb = new StringBuilder(); |
| for (String s : errors) { |
| sb.append(s).append('\n'); |
| } |
| |
| markProject(AdtConstants.MARKER_MANIFMERGER, sb.toString(), |
| IMarker.SEVERITY_ERROR); |
| |
| } else if (errors.size() == 1) { |
| markProject(AdtConstants.MARKER_MANIFMERGER, errors.get(0), |
| IMarker.SEVERITY_ERROR); |
| } else { |
| markProject(AdtConstants.MARKER_MANIFMERGER, "Unknown error merging manifest", |
| IMarker.SEVERITY_ERROR); |
| } |
| return false; |
| } |
| |
| outFile.refreshLocal(IResource.DEPTH_INFINITE, mDerivedProgressMonitor); |
| saveProjectBooleanProperty(PROPERTY_MERGE_MANIFEST, mMustMergeManifest = false); |
| } |
| |
| return true; |
| } |
| |
| /** |
| * Handles resource changes and regenerate whatever files need regenerating. |
| * @param project the main project |
| * @param javaPackage the app package for the main project |
| * @param projectTarget the target of the main project |
| * @param manifest the {@link IFile} representing the project manifest |
| * @param libProjects the library dependencies |
| * @param isLibrary if the project is a library project |
| * @throws CoreException |
| * @throws AbortBuildException |
| */ |
| private void handleResources(IProject project, String javaPackage, IAndroidTarget projectTarget, |
| IFile manifest, IFolder resOutFolder, List<IProject> libProjects, boolean isLibrary, |
| IFile proguardFile) throws CoreException, AbortBuildException { |
| // get the resource folder |
| IFolder resFolder = project.getFolder(AdtConstants.WS_RESOURCES); |
| |
| // get the file system path |
| IPath outputLocation = mGenFolder.getLocation(); |
| IPath resLocation = resFolder.getLocation(); |
| IPath manifestLocation = manifest == null ? null : manifest.getLocation(); |
| |
| // those locations have to exist for us to do something! |
| if (outputLocation != null && resLocation != null |
| && manifestLocation != null) { |
| String osOutputPath = outputLocation.toOSString(); |
| String osResPath = resLocation.toOSString(); |
| String osManifestPath = manifestLocation.toOSString(); |
| |
| // remove the aapt markers |
| removeMarkersFromResource(manifest, AdtConstants.MARKER_AAPT_COMPILE); |
| removeMarkersFromContainer(resFolder, AdtConstants.MARKER_AAPT_COMPILE); |
| |
| AdtPlugin.printBuildToConsole(BuildVerbosity.VERBOSE, project, |
| Messages.Preparing_Generated_Files); |
| |
| // we need to figure out where to store the R class. |
| // get the parent folder for R.java and update mManifestPackageSourceFolder |
| IFolder mainPackageFolder = getGenManifestPackageFolder(); |
| |
| // handle libraries |
| ArrayList<IFolder> libResFolders = Lists.newArrayList(); |
| ArrayList<Pair<File, String>> libRFiles = Lists.newArrayList(); |
| if (libProjects != null) { |
| for (IProject lib : libProjects) { |
| IFolder libResFolder = lib.getFolder(SdkConstants.FD_RES); |
| if (libResFolder.exists()) { |
| libResFolders.add(libResFolder); |
| } |
| |
| try { |
| // get the package of the library, and if it's different form the |
| // main project, generate the R class for it too. |
| String libJavaPackage = AndroidManifest.getPackage(new IFolderWrapper(lib)); |
| if (libJavaPackage.equals(javaPackage) == false) { |
| |
| IFolder libOutput = BaseProjectHelper.getAndroidOutputFolder(lib); |
| File libOutputFolder = libOutput.getLocation().toFile(); |
| |
| libRFiles.add(Pair.of( |
| new File(libOutputFolder, "R.txt"), |
| libJavaPackage)); |
| |
| } |
| } catch (Exception e) { |
| } |
| } |
| } |
| |
| String proguardFilePath = proguardFile != null ? |
| proguardFile.getLocation().toOSString(): null; |
| |
| File resOutFile = resOutFolder.getLocation().toFile(); |
| String resOutPath = resOutFile.isDirectory() ? resOutFile.getAbsolutePath() : null; |
| |
| execAapt(project, projectTarget, osOutputPath, resOutPath, osResPath, osManifestPath, |
| mainPackageFolder, libResFolders, libRFiles, isLibrary, proguardFilePath); |
| } |
| } |
| |
| /** |
| * Executes AAPT to generate R.java/Manifest.java |
| * @param project the main project |
| * @param projectTarget the main project target |
| * @param osOutputPath the OS output path for the generated file. This is the source folder, not |
| * the package folder. |
| * @param osResPath the OS path to the res folder for the main project |
| * @param osManifestPath the OS path to the manifest of the main project |
| * @param packageFolder the IFolder that will contain the generated file. Unlike |
| * <var>osOutputPath</var> this is the direct parent of the generated files. |
| * If <var>customJavaPackage</var> is not null, this must match the new destination triggered |
| * by its value. |
| * @param libResFolders the list of res folders for the library. |
| * @param libRFiles a list of R files for the libraries. |
| * @param isLibrary if the project is a library project |
| * @param proguardFile an optional path to store proguard information |
| * @throws AbortBuildException |
| */ |
| @SuppressWarnings("deprecation") |
| private void execAapt(IProject project, IAndroidTarget projectTarget, String osOutputPath, |
| String osBcOutPath, String osResPath, String osManifestPath, IFolder packageFolder, |
| ArrayList<IFolder> libResFolders, List<Pair<File, String>> libRFiles, |
| boolean isLibrary, String proguardFile) |
| throws AbortBuildException { |
| |
| // We actually need to delete the manifest.java as it may become empty and |
| // in this case aapt doesn't generate an empty one, but instead doesn't |
| // touch it. |
| IFile manifestJavaFile = packageFolder.getFile(SdkConstants.FN_MANIFEST_CLASS); |
| manifestJavaFile.getLocation().toFile().delete(); |
| |
| // launch aapt: create the command line |
| ArrayList<String> array = new ArrayList<String>(); |
| |
| String aaptPath = mBuildToolInfo.getPath(BuildToolInfo.PathId.AAPT); |
| |
| array.add(aaptPath); |
| array.add("package"); //$NON-NLS-1$ |
| array.add("-m"); //$NON-NLS-1$ |
| if (AdtPrefs.getPrefs().getBuildVerbosity() == BuildVerbosity.VERBOSE) { |
| array.add("-v"); //$NON-NLS-1$ |
| } |
| |
| if (isLibrary) { |
| array.add("--non-constant-id"); //$NON-NLS-1$ |
| } |
| |
| if (libResFolders.size() > 0) { |
| array.add("--auto-add-overlay"); //$NON-NLS-1$ |
| } |
| |
| // If a library or has libraries, generate a text version of the R symbols. |
| File outputFolder = BaseProjectHelper.getAndroidOutputFolder(project).getLocation() |
| .toFile(); |
| |
| if (isLibrary || !libRFiles.isEmpty()) { |
| array.add("--output-text-symbols"); //$NON-NLS-1$ |
| array.add(outputFolder.getAbsolutePath()); |
| } |
| |
| array.add("-J"); //$NON-NLS-1$ |
| array.add(osOutputPath); |
| array.add("-M"); //$NON-NLS-1$ |
| array.add(osManifestPath); |
| if (osBcOutPath != null) { |
| array.add("-S"); //$NON-NLS-1$ |
| array.add(osBcOutPath); |
| } |
| array.add("-S"); //$NON-NLS-1$ |
| array.add(osResPath); |
| for (IFolder libResFolder : libResFolders) { |
| array.add("-S"); //$NON-NLS-1$ |
| array.add(libResFolder.getLocation().toOSString()); |
| } |
| |
| array.add("-I"); //$NON-NLS-1$ |
| array.add(projectTarget.getPath(IAndroidTarget.ANDROID_JAR)); |
| |
| // use the proguard file |
| if (proguardFile != null && proguardFile.length() > 0) { |
| array.add("-G"); |
| array.add(proguardFile); |
| } |
| |
| if (AdtPrefs.getPrefs().getBuildVerbosity() == BuildVerbosity.VERBOSE) { |
| StringBuilder sb = new StringBuilder(); |
| for (String c : array) { |
| sb.append(c); |
| sb.append(' '); |
| } |
| String cmd_line = sb.toString(); |
| AdtPlugin.printToConsole(project, cmd_line); |
| } |
| |
| // launch |
| try { |
| // launch the command line process |
| Process process = Runtime.getRuntime().exec( |
| array.toArray(new String[array.size()])); |
| |
| // 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(process, stdErr); |
| |
| // attempt to parse the error output |
| boolean parsingError = AaptParser.parseOutput(stdErr, project); |
| |
| // if we couldn't parse the output we display it in the console. |
| if (parsingError) { |
| if (returnCode != 0) { |
| AdtPlugin.printErrorToConsole(project, stdErr.toArray()); |
| } else { |
| AdtPlugin.printBuildToConsole(BuildVerbosity.NORMAL, |
| project, stdErr.toArray()); |
| } |
| } |
| |
| if (returnCode != 0) { |
| // 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. |
| if (parsingError) { |
| markProject(AdtConstants.MARKER_ADT, |
| Messages.Unparsed_AAPT_Errors, IMarker.SEVERITY_ERROR); |
| } else if (stdErr.size() == 0) { |
| // no parsing error because sdterr was empty. We still need to put |
| // a marker otherwise there's no user visible feedback. |
| markProject(AdtConstants.MARKER_ADT, |
| String.format(Messages.AAPT_Exec_Error_d, returnCode), |
| IMarker.SEVERITY_ERROR); |
| } |
| |
| AdtPlugin.printBuildToConsole(BuildVerbosity.VERBOSE, project, |
| Messages.AAPT_Error); |
| |
| // abort if exec failed. |
| throw new AbortBuildException(); |
| } |
| |
| // now if the project has libraries, R needs to be created for each libraries |
| // unless this is a library. |
| if (isLibrary == false && !libRFiles.isEmpty()) { |
| File rFile = new File(outputFolder, SdkConstants.FN_RESOURCE_TEXT); |
| // if the project has no resources, the file could not exist. |
| if (rFile.isFile()) { |
| // Load the full symbols from the full R.txt file. |
| SymbolLoader fullSymbolValues = new SymbolLoader(rFile); |
| fullSymbolValues.load(); |
| |
| Multimap<String, SymbolLoader> libMap = ArrayListMultimap.create(); |
| |
| // 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). |
| |
| for (Pair<File, String> lib : libRFiles) { |
| String libPackage = lib.getSecond(); |
| File rText = lib.getFirst(); |
| |
| if (rText.isFile()) { |
| // load the lib symbols |
| SymbolLoader libSymbols = new SymbolLoader(rText); |
| libSymbols.load(); |
| |
| // store these symbols by associating them with the package name. |
| libMap.put(libPackage, libSymbols); |
| } |
| } |
| |
| // now loop on all the package names, merge all the symbols to write, |
| // and write them |
| for (String packageName : libMap.keySet()) { |
| Collection<SymbolLoader> symbols = libMap.get(packageName); |
| |
| SymbolWriter writer = new SymbolWriter(osOutputPath, packageName, |
| fullSymbolValues); |
| for (SymbolLoader symbolLoader : symbols) { |
| writer.addSymbolsToWrite(symbolLoader); |
| } |
| writer.write(); |
| } |
| } |
| } |
| |
| } catch (IOException e1) { |
| // something happen while executing the process, |
| // mark the project and exit |
| String msg; |
| String path = array.get(0); |
| if (!new File(path).exists()) { |
| msg = String.format(Messages.AAPT_Exec_Error_s, path); |
| } else { |
| String description = e1.getLocalizedMessage(); |
| if (e1.getCause() != null && e1.getCause() != e1) { |
| description = description + ": " + e1.getCause().getLocalizedMessage(); |
| } |
| msg = String.format(Messages.AAPT_Exec_Error_Other_s, description); |
| } |
| |
| markProject(AdtConstants.MARKER_ADT, msg, IMarker.SEVERITY_ERROR); |
| |
| // Add workaround for the Linux problem described here: |
| // http://developer.android.com/sdk/installing.html#troubleshooting |
| // There are various posts on StackOverflow elsewhere where people are asking |
| // about aapt failing to run, so even though this is documented in the |
| // Troubleshooting section add an error message to help with this |
| // scenario. |
| if (SdkConstants.CURRENT_PLATFORM == SdkConstants.PLATFORM_LINUX |
| && System.getProperty("os.arch").endsWith("64") //$NON-NLS-1$ //$NON-NLS-2$ |
| && new File(aaptPath).exists() |
| && new File("/usr/bin/apt-get").exists()) { //$NON-NLS-1$ |
| markProject(AdtConstants.MARKER_ADT, |
| "Hint: On 64-bit systems, make sure the 32-bit libraries are installed: \"sudo apt-get install ia32-libs\" or on some systems, \"sudo apt-get install lib32z1\"", |
| IMarker.SEVERITY_ERROR); |
| // Note - this uses SEVERITY_ERROR even though it's really SEVERITY_INFO because |
| // we want this error message to show up adjacent to the aapt error message |
| // (and Eclipse sorts by priority) |
| } |
| |
| // This interrupts the build. |
| throw new AbortBuildException(); |
| } catch (InterruptedException e) { |
| // we got interrupted waiting for the process to end... |
| // mark the project and exit |
| String msg = String.format(Messages.AAPT_Exec_Error_s, array.get(0)); |
| markProject(AdtConstants.MARKER_ADT, msg, IMarker.SEVERITY_ERROR); |
| |
| // This interrupts the build. |
| throw new AbortBuildException(); |
| } finally { |
| // we've at least attempted to run aapt, save the fact that we don't have to |
| // run it again, unless there's a new resource change. |
| saveProjectBooleanProperty(PROPERTY_COMPILE_RESOURCES, |
| mMustCompileResources = false); |
| ResourceManager.clearAaptRequest(project); |
| } |
| } |
| |
| /** |
| * Creates a relative {@link IPath} from a java package. |
| * @param javaPackageName the java package. |
| */ |
| private IPath getJavaPackagePath(String javaPackageName) { |
| // convert the java package into path |
| String[] segments = javaPackageName.split(AdtConstants.RE_DOT); |
| |
| StringBuilder path = new StringBuilder(); |
| for (String s : segments) { |
| path.append(AdtConstants.WS_SEP_CHAR); |
| path.append(s); |
| } |
| |
| return new Path(path.toString()); |
| } |
| |
| /** |
| * Returns an {@link IFolder} (located inside the 'gen' source folder), that matches the |
| * package defined in the manifest. This {@link IFolder} may not actually exist |
| * (aapt will create it anyway). |
| * @return the {@link IFolder} that will contain the R class or null if |
| * the folder was not found. |
| * @throws CoreException |
| */ |
| private IFolder getGenManifestPackageFolder() throws CoreException { |
| // get the path for the package |
| IPath packagePath = getJavaPackagePath(mManifestPackage); |
| |
| // get a folder for this path under the 'gen' source folder, and return it. |
| // This IFolder may not reference an actual existing folder. |
| return mGenFolder.getFolder(packagePath); |
| } |
| } |
