--- /dev/null
+/*
+ * Copyright (C) 2011 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.ide.eclipse.adt.internal.build.builders.BaseBuilder;
+import com.android.ide.eclipse.adt.internal.project.BaseProjectHelper;
+import com.android.ide.eclipse.adt.internal.project.ProjectHelper;
+import com.android.sdklib.IAndroidTarget;
+import com.android.sdklib.SdkConstants;
+
+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.IProgressMonitor;
+import org.eclipse.jdt.core.IJavaProject;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Base class to handle generated java code.
+ *
+ * It provides management for modified source file list, deleted source file list, reconciliation
+ * of previous lists, storing the current state of the build.
+ *
+ */
+public abstract class SourceProcessor {
+
+ public final static int COMPILE_STATUS_NONE = 0;
+ public final static int COMPILE_STATUS_CODE = 0x1;
+ public final static int COMPILE_STATUS_RES = 0x2;
+
+ /** List of all source files, their dependencies, and their output. */
+ private final Map<IFile, SourceFileData> mFiles = new HashMap<IFile, SourceFileData>();
+
+ private final IJavaProject mJavaProject;
+ private final IFolder mGenFolder;
+ private final SourceChangeHandler mDeltaVisitor;
+
+ /** List of source files pending compilation at the next build */
+ private final List<IFile> mToCompile = new ArrayList<IFile>();
+
+ /** List of removed source files pending cleaning at the next build. */
+ private final List<IFile> mRemoved = new ArrayList<IFile>();
+
+ private int mLastCompilationStatus = COMPILE_STATUS_NONE;
+
+ /**
+ * Quotes a path inside "". If the platform is not windows, the path is returned as is.
+ * @param path the path to quote
+ * @return the quoted path.
+ */
+ public static String quote(String path) {
+ if (SdkConstants.CURRENT_PLATFORM == SdkConstants.PLATFORM_WINDOWS) {
+ return "\"" + path + "\"";
+ }
+
+ return path;
+ }
+
+ protected SourceProcessor(IJavaProject javaProject, IFolder genFolder,
+ SourceChangeHandler deltaVisitor) {
+ mJavaProject = javaProject;
+ mGenFolder = genFolder;
+ mDeltaVisitor = deltaVisitor;
+
+ mDeltaVisitor.init(this);
+
+ IProject project = javaProject.getProject();
+
+ // get all the source files
+ buildSourceFileList();
+
+ // load the known dependencies
+ loadOutputAndDependencies();
+
+ boolean mustCompile = loadState(project);
+
+ // if we stored that we have to compile some files, we build the list that will compile them
+ // all. For now we have to reuse the full list since we don't know which files needed
+ // compilation.
+ if (mustCompile) {
+ mToCompile.addAll(mFiles.keySet());
+ }
+ }
+
+ protected SourceProcessor(IJavaProject javaProject, IFolder genFolder) {
+ this(javaProject, genFolder, new SourceChangeHandler());
+ }
+
+
+ /**
+ * Returns whether the given file is an output of this processor by return the source
+ * file that generated it.
+ * @param file the file to test.
+ * @return the source file that generated the given file or null.
+ */
+ IFile isOutput(IFile file) {
+ for (SourceFileData data : mFiles.values()) {
+ if (data.generated(file)) {
+ return data.getSourceFile();
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * Returns whether the given file is a dependency for other files by returning a list
+ * of file depending on the given file.
+ * @param file the file to test.
+ * @return a list of files that depend on the given file or an empty list if there
+ * are no matches.
+ */
+ List<IFile> isDependency(IFile file) {
+ ArrayList<IFile> files = new ArrayList<IFile>();
+ for (SourceFileData data : mFiles.values()) {
+ if (data.dependsOn(file)) {
+ files.add(data.getSourceFile());
+ }
+ }
+
+ return files;
+ }
+
+ void addData(SourceFileData data) {
+ mFiles.put(data.getSourceFile(), data);
+ }
+
+ SourceFileData getFileData(IFile file) {
+ return mFiles.get(file);
+ }
+
+ Collection<SourceFileData> getAllFileData() {
+ return mFiles.values();
+ }
+
+ public final SourceChangeHandler getChangeHandler() {
+ return mDeltaVisitor;
+ }
+
+ final IJavaProject getJavaProject() {
+ return mJavaProject;
+ }
+
+ final IFolder getGenFolder() {
+ return mGenFolder;
+ }
+
+ final List<IFile> getToCompile() {
+ return mToCompile;
+ }
+
+ final List<IFile> getRemovedFile() {
+ return mRemoved;
+ }
+
+ final void addFileToCompile(IFile file) {
+ mToCompile.add(file);
+ }
+
+ public final void prepareFullBuild(IProject project) {
+ mDeltaVisitor.reset();
+
+ mToCompile.clear();
+ mRemoved.clear();
+
+ // get all the source files
+ buildSourceFileList();
+
+ mToCompile.addAll(mFiles.keySet());
+
+ saveState(project);
+ }
+
+ public final void doneVisiting(IProject project) {
+ // merge the previous file modification lists and the new one.
+ mergeFileModifications(mDeltaVisitor);
+
+ mDeltaVisitor.reset();
+
+ saveState(project);
+ }
+
+ /**
+ * Returns the extension of the source files handled by this processor.
+ * @return
+ */
+ protected abstract String getExtension();
+
+ protected abstract String getSavePropertyName();
+
+ /**
+ * Compiles the source files and return a status bitmask of the type of file that was generated.
+ *
+ */
+ public final int compileFiles(BaseBuilder builder,
+ IProject project, IAndroidTarget projectTarget,
+ List<IPath> sourceFolders, IProgressMonitor monitor) throws CoreException {
+
+ mLastCompilationStatus = COMPILE_STATUS_NONE;
+
+ if (mToCompile.size() == 0 && mRemoved.size() == 0) {
+ return mLastCompilationStatus;
+ }
+
+ // if a source file is being removed before we managed to compile it, it'll be in
+ // both list. We *need* to remove it from the compile list or it'll never go away.
+ for (IFile sourceFile : mRemoved) {
+ int pos = mToCompile.indexOf(sourceFile);
+ if (pos != -1) {
+ mToCompile.remove(pos);
+ }
+ }
+
+ // list of files that have failed compilation.
+ List<IFile> stillNeedCompilation = new ArrayList<IFile>();
+
+ doCompileFiles(mToCompile, builder, project, projectTarget, sourceFolders,
+ stillNeedCompilation, monitor);
+
+ mToCompile.clear();
+ mToCompile.addAll(stillNeedCompilation);
+
+ // Remove the files created from source files that have been removed.
+ for (IFile sourceFile : mRemoved) {
+ // look if we already know the output
+ SourceFileData data = getFileData(sourceFile);
+ if (data != null) {
+ doRemoveFiles(data);
+ }
+ }
+
+ // remove the associated file data.
+ for (IFile removedFile : mRemoved) {
+ mFiles.remove(removedFile);
+ }
+
+ mRemoved.clear();
+
+ // store the build state. If there are any files that failed to compile, we will
+ // force a full aidl compile on the next project open. (unless a full compilation succeed
+ // before the project is closed/re-opened.)
+ saveState(project);
+
+ return mLastCompilationStatus;
+ }
+
+ protected abstract void doCompileFiles(
+ List<IFile> filesToCompile, BaseBuilder builder,
+ IProject project, IAndroidTarget projectTarget,
+ List<IPath> sourceFolders, List<IFile> notCompiledOut, IProgressMonitor monitor)
+ throws CoreException;
+
+ /**
+ * Adds a compilation status. It can be any of (in combination too):
+ * <p/>
+ * {@link #COMPILE_STATUS_CODE} means this processor created source code files.
+ * {@link #COMPILE_STATUS_RES} means this process created resources.
+ */
+ protected void setCompilationStatus(int status) {
+ mLastCompilationStatus |= status;
+ }
+
+ protected void doRemoveFiles(SourceFileData data) throws CoreException {
+ List<IFile> outputFiles = data.getOutputFiles();
+ for (IFile outputFile : outputFiles) {
+ if (outputFile.exists()) {
+ outputFile.getLocation().toFile().delete();
+ }
+ }
+ }
+
+ public final boolean loadState(IProject project) {
+ return ProjectHelper.loadBooleanProperty(project, getSavePropertyName(),
+ true /*defaultValue*/);
+ }
+
+ public final void saveState(IProject project) {
+ // TODO: Optimize by saving only the files that need compilation
+ ProjectHelper.saveStringProperty(project, getSavePropertyName(),
+ Boolean.toString(mToCompile.size() > 0));
+ }
+
+ protected abstract void loadOutputAndDependencies();
+
+
+ protected IPath getSourceFolderFor(IFile file) {
+ // find the source folder for the class so that we can infer the package from the
+ // difference between the file and its source folder.
+ List<IPath> sourceFolders = BaseProjectHelper.getSourceClasspaths(getJavaProject());
+ IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
+
+ for (IPath sourceFolderPath : sourceFolders) {
+ IFolder sourceFolder = root.getFolder(sourceFolderPath);
+ // we don't look in the 'gen' source folder as there will be no source in there.
+ if (sourceFolder.exists() && sourceFolder.equals(getGenFolder()) == false) {
+ // look for the source file parent, until we find this source folder.
+ IResource parent = file;
+ while ((parent = parent.getParent()) != null) {
+ if (parent.equals(sourceFolder)) {
+ return sourceFolderPath;
+ }
+ }
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * Goes through the build paths and fills the list of files to compile.
+ *
+ * @param project The project.
+ * @param sourceFolderPathList The list of source folder paths.
+ */
+ private final void buildSourceFileList() {
+ mFiles.clear();
+
+ IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
+ List<IPath> sourceFolderPathList = BaseProjectHelper.getSourceClasspaths(mJavaProject);
+
+ for (IPath sourceFolderPath : sourceFolderPathList) {
+ IFolder sourceFolder = root.getFolder(sourceFolderPath);
+ // we don't look in the 'gen' source folder as there will be no source in there.
+ if (sourceFolder.exists() && sourceFolder.equals(getGenFolder()) == false) {
+ scanFolderForSourceFiles(sourceFolder, sourceFolder);
+ }
+ }
+ }
+
+ /**
+ * Scans a folder and fills the list of files to compile.
+ * @param sourceFolder the root source folder.
+ * @param folder The folder to scan.
+ */
+ private void scanFolderForSourceFiles(IFolder sourceFolder, IFolder folder) {
+ try {
+ IResource[] members = folder.members();
+ for (IResource r : members) {
+ // get the type of the resource
+ switch (r.getType()) {
+ case IResource.FILE:
+ // if this a file, check that the file actually exist
+ // and that it's the type of of file that's used in this processor
+ if (r.exists() &&
+ getExtension().equalsIgnoreCase(r.getFileExtension())) {
+ mFiles.put((IFile) r, new SourceFileData((IFile) r));
+ }
+ break;
+ case IResource.FOLDER:
+ // recursively go through children
+ scanFolderForSourceFiles(sourceFolder, (IFolder)r);
+ break;
+ default:
+ // this would mean it's a project or the workspace root
+ // which is unlikely to happen. we do nothing
+ break;
+ }
+ }
+ } catch (CoreException e) {
+ // Couldn't get the members list for some reason. Just return.
+ }
+ }
+
+
+ /**
+ * Merge the current list of source file to compile/remove with the one coming from the
+ * delta visitor
+ * @param visitor the delta visitor.
+ */
+ private void mergeFileModifications(SourceChangeHandler visitor) {
+ Set<IFile> toRemove = visitor.getRemovedFiles();
+ Set<IFile> toCompile = visitor.getFilesToCompile();
+
+ // loop through the new toRemove list, and add it to the old one,
+ // plus remove any file that was still to compile and that are now
+ // removed
+ for (IFile r : toRemove) {
+ if (mRemoved.indexOf(r) == -1) {
+ mRemoved.add(r);
+ }
+
+ int index = mToCompile.indexOf(r);
+ if (index != -1) {
+ mToCompile.remove(index);
+ }
+ }
+
+ // now loop through the new files to compile and add it to the list.
+ // Also look for them in the remove list, this would mean that they
+ // were removed, then added back, and we shouldn't remove them, just
+ // recompile them.
+ for (IFile r : toCompile) {
+ if (mToCompile.indexOf(r) == -1) {
+ mToCompile.add(r);
+ }
+
+ int index = mRemoved.indexOf(r);
+ if (index != -1) {
+ mRemoved.remove(index);
+ }
+ }
+ }
+}
OSDN Git Service
