Merge "Add proper dependency support in the dex step of the Ant-based build."

1 files changed, 188 insertions, 89 deletions

diff --git a/anttasks/src/com/android/ant/DependencyGraph.java b/anttasks/src/com/android/ant/DependencyGraph.java
index 11c09e4..7f9c65a 100644
--- a/anttasks/src/com/android/ant/DependencyGraph.java
+++ b/anttasks/src/com/android/ant/DependencyGraph.java
@@ -16,13 +16,15 @@
 
 package com.android.ant;
 
+import org.apache.tools.ant.BuildException;
+
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStreamReader;
-import java.util.ArrayList;
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
@@ -33,15 +35,20 @@ import java.util.Set;
  */
 public class DependencyGraph {
 
+    private static enum DependencyStatus {
+        NONE, NEW_FILE, UPDATED_FILE, MISSING_FILE, ERROR;
+    }
+
     // Files that we know about from the dependency file
-    private List<File> mTargets = Collections.emptyList();
-    private List<File> mPrereqs = mTargets;
+    private Set<File> mTargets = Collections.emptySet();
+    private Set<File> mPrereqs = mTargets;
+    private File mFirstPrereq = null;
     private boolean mMissingDepFile = false;
     private long mDepFileLastModified;
-    private final ArrayList<File> mWatchPaths;
+    private final List<File> mNewInputs;
 
-    public DependencyGraph(String dependencyFilePath, ArrayList<File> watchPaths) {
-        mWatchPaths = watchPaths;
+    public DependencyGraph(String dependencyFilePath, List<File> newInputPaths) {
+        mNewInputs = newInputPaths;
         parseDependencyFile(dependencyFilePath);
     }
 
@@ -55,40 +62,70 @@ public class DependencyGraph {
      *         prerequisite files have been modified since the last target generation.
      */
     public boolean dependenciesHaveChanged(Set<String> extensionsToCheck, boolean printStatus) {
-        boolean missingPrereq = missingPrereqFile();
-        boolean newPrereq = newPrereqFile();
-        boolean missingTarget = missingTargetFile();
-        boolean modPrereq = modifiedPrereq(extensionsToCheck);
-
-        if (printStatus) {
-            if (mMissingDepFile) {
-                System.out.println("No Dependency File Found");
-            }
-            if (missingPrereq) {
-                System.out.println("Found Deleted Prereq File");
-            }
-            if (newPrereq) {
-                System.out.println("Found New Prereq File");
-            }
-            if (missingTarget) {
+        // If no dependency file has been set up, then we'll just return true
+        // if we have a dependency file, we'll check to see what's been changed
+        if (mMissingDepFile) {
+            System.out.println("No Dependency File Found");
+            return true;
+        }
+
+        // check for missing output first
+        if (missingTargetFile()) {
+            if (printStatus) {
                 System.out.println("Found Deleted Target File");
             }
-            if (modPrereq) {
-                System.out.println("Found Modified Prereq File");
-            }
+            return true;
         }
 
-        // If no dependency file has been set up, then we'll just return true
-        // if we have a dependency file, we'll check to see what's been changed
-        return mMissingDepFile || missingPrereq || newPrereq || missingTarget || modPrereq;
+        // get the timestamp of the oldest target.
+        long oldestTarget = getOutputLastModified();
+
+        // first look through the input folders and look for new files or modified files.
+        DependencyStatus status = checkInputs(extensionsToCheck, oldestTarget);
+
+        // this can't find missing files. This is done later.
+        switch (status) {
+            case ERROR:
+                throw new BuildException();
+            case NEW_FILE:
+                if (printStatus) {
+                    System.out.println("Found new input file");
+                }
+                return true;
+            case UPDATED_FILE:
+                if (printStatus) {
+                    System.out.println("Found modified input file");
+                }
+                return true;
+        }
+
+        // now do a full check on the remaining files.
+        status = checkPrereqFiles(extensionsToCheck, oldestTarget);
+        // this can't find new input files. This is done above.
+        switch (status) {
+            case ERROR:
+                throw new BuildException();
+            case MISSING_FILE:
+                if (printStatus) {
+                    System.out.println("Found deleted input file");
+                }
+                return true;
+            case UPDATED_FILE:
+                if (printStatus) {
+                    System.out.println("Found modified input file");
+                }
+                return true;
+        }
+
+        return false;
     }
 
-    public List<File> getTargets() {
-        return mTargets;
+    public Set<File> getTargets() {
+        return Collections.unmodifiableSet(mTargets);
     }
 
-    public List<File> getPrereqs() {
-        return mPrereqs;
+    public File getFirstPrereq() {
+        return mFirstPrereq;
     }
 
     /**
@@ -144,79 +181,157 @@ public class DependencyGraph {
             prereqs = files[1].trim().split(" ");
         }
 
-        mTargets = new ArrayList<File>(targets.length);
+        mTargets = new HashSet<File>(targets.length);
         for (String path : targets) {
             if (path.length() > 0) {
                 mTargets.add(new File(path));
             }
         }
-        mTargets = Collections.unmodifiableList(mTargets);
-        mPrereqs = new ArrayList<File>(prereqs.length);
+
+        mPrereqs = new HashSet<File>(prereqs.length);
         for (String path : prereqs) {
             if (path.length() > 0) {
-                mPrereqs.add(new File(path));
+                File f = new File(path);
+                if (mFirstPrereq == null) {
+                    mFirstPrereq = f;
+                }
+                mPrereqs.add(f);
             }
         }
-        mPrereqs = Collections.unmodifiableList(mPrereqs);
     }
 
     /**
-     * Check all the folders we know about to see if there have been new
-     * files added to them.
-     * @return true if a new file is encountered in the dependency folders
+     * Check all the input files and folders to see if there have been new
+     * files added to them or if any of the existing files have been modified.
+     *
+     * This looks at the input paths, not at the list of known prereq. Therefore this
+     * will not find missing files. It will however remove processed files from the
+     * prereq file list so that we can process those in a 2nd step.
+     *
+     * This should be followed by a call to {@link #checkPrereqFiles(long)} which
+     * will process the remaining files in the prereq list.
+     *
+     * If a change is found, this will return immediatly with either
+     * {@link DependencyStatus#NEW_FILE} or {@link DependencyStatus#UPDATED_FILE}.
+     *
+     * @param extensionsToCheck a set of extensions. Only files with an extension in this set will
+     *        be considered for a modification check. All deleted/created files will still be
+     *        checked. If this is null, all files will be checked for modification date
+     * @param oldestTarget the timestamp of the oldest output file to compare against.
+     *
+     * @return the status of the file in the watched folders.
+     *
      */
-    private boolean newPrereqFile() {
-        if (mWatchPaths != null) {
-            for (File dir : mWatchPaths) {
-                if (newFileInTree(dir)) {
-                    return true;
+    private DependencyStatus checkInputs(Set<String> extensionsToCheck, long oldestTarget) {
+        if (mNewInputs != null) {
+            for (File input : mNewInputs) {
+                if (input.isDirectory()) {
+                    DependencyStatus status = checkInputFolder(input, extensionsToCheck,
+                            oldestTarget);
+                    if (status != DependencyStatus.NONE) {
+                        return status;
+                    }
+                } else if (input.isFile()) {
+                    DependencyStatus status = checkInputFile(input, extensionsToCheck,
+                            oldestTarget);
+                    if (status != DependencyStatus.NONE) {
+                        return status;
+                    }
                 }
             }
         }
+
         // If we make it all the way through our directories we're good.
-        return false;
+        return DependencyStatus.NONE;
     }
 
     /**
      * Check all the files in the tree under root and check to see if the files are
-     * listed under the dependencies. Recurses into subdirs.
-     * @param root the root of the file tree to search through
-     * @return true if a file is encountered in the tree that is not in our list of prereqs
+     * listed under the dependencies, or if they have been modified. Recurses into subdirs.
+     *
+     * @param rootFolder the folder to search through.
+     * @param extensionsToCheck a set of extensions. Only files with an extension in this set will
+     *        be considered for a modification check. All deleted/created files will still be
+     *        checked. If this is null, all files will be checked for modification date
+     * @param oldestTarget the timestamp of the oldest output file to compare against.
+     *
+     * @return the status of the file in the folder.
      */
-    private boolean newFileInTree(File root) {
-        File[] files = root.listFiles();
+    private DependencyStatus checkInputFolder(File rootFolder, Set<String> extensionsToCheck,
+            long oldestTarget) {
+        File[] files = rootFolder.listFiles();
         if (files == null) {
-            System.err.println("ERROR " + root.toString() + " is not a dir or can't be read");
-            return false;
+            System.err.println("ERROR " + rootFolder.toString() + " is not a dir or can't be read");
+            return DependencyStatus.ERROR;
         }
         // Loop through files in this folder
         for (File file : files) {
             // If this is a directory, recurse into it
             if (file.isDirectory()) {
-                if (newFileInTree(file)) {
-                    return true;
+                DependencyStatus status = checkInputFolder(file, extensionsToCheck, oldestTarget);
+                if (status != DependencyStatus.NONE) {
+                    return status;
+                }
+            } else if (file.isFile()) {
+                DependencyStatus status = checkInputFile(file, extensionsToCheck, oldestTarget);
+                if (status != DependencyStatus.NONE) {
+                    return status;
                 }
-            } else if (file.isFile() && mPrereqs.contains(file) == false) {
-                return true;
             }
         }
         // If we got to here then we didn't find anything interesting
-        return false;
+        return DependencyStatus.NONE;
+    }
+
+    private DependencyStatus checkInputFile(File file, Set<String> extensionsToCheck,
+            long oldestTarget) {
+        // if it's a file, remove it from the list of prereqs.
+        // This way if files in this folder don't trigger a build we'll have less
+        // files to go through manually
+        if (mPrereqs.remove(file) == false) {
+            // turns out this is a new file!
+            return DependencyStatus.NEW_FILE;
+        } else {
+            // check the time stamp on this file if it's a file we care about based on the
+            // list of extensions to check.
+            if (extensionsToCheck == null || extensionsToCheck.contains(getExtension(file))) {
+                if (file.lastModified() > oldestTarget) {
+                    return DependencyStatus.UPDATED_FILE;
+                }
+            }
+        }
+
+        return DependencyStatus.NONE;
     }
 
     /**
-     * Check all the prereq files we know about to make sure they're still there
-     * @return true if any of the prereq files are missing.
+     * Check all the prereq files we know about to make sure they're still there, or that they
+     * haven't been modified since the last build.
+     *
+     * @param extensionsToCheck a set of extensions. Only files with an extension in this set will
+     *        be considered for a modification check. All deleted/created files will still be
+     *        checked. If this is null, all files will be checked for modification date
+     *
+     * @return the status of the files
      */
-    private boolean missingPrereqFile() {
+    private DependencyStatus checkPrereqFiles(Set<String> extensionsToCheck, long oldestTarget) {
         // Loop through our prereq files and make sure they still exist
         for (File prereq : mPrereqs) {
             if (prereq.exists() == false) {
-                return true;
+                return DependencyStatus.MISSING_FILE;
+            }
+
+            // check the time stamp on this file if it's a file we care about based on the
+            // list of extensions to check.
+            if (extensionsToCheck == null || extensionsToCheck.contains(getExtension(prereq))) {
+                if (prereq.lastModified() > oldestTarget) {
+                    return DependencyStatus.UPDATED_FILE;
+                }
             }
         }
-        // If we get this far, then all our targets are okay
-        return false;
+
+        // If we get this far, then all our prereq are okay
+        return DependencyStatus.NONE;
     }
 
     /**
@@ -235,12 +350,10 @@ public class DependencyGraph {
     }
 
     /**
-     * Check to see if any of the prerequisite files have been modified since
-     * the targets were last updated.
-     * @return true if the latest prerequisite modification is after the oldest
-     *         target modification.
+     * Returns the earliest modification time stamp from all the output targets. If there
+     * are no known target, the dependency file time stamp is returned.
      */
-    private boolean modifiedPrereq(Set<String> extensionsToCheck) {
+    private long getOutputLastModified() {
         // Find the oldest target
         long oldestTarget = Long.MAX_VALUE;
         // if there's no output, then compare to the time of the dependency file.
@@ -254,20 +367,7 @@ public class DependencyGraph {
             }
         }
 
-        // Find the newest prerequisite
-        long newestPrereq = 0;
-        for (File prereq : mPrereqs) {
-            // If we have a list of extensions that we need to restrict ourselves to, only
-            // consider this file if it has that extension.
-            if (extensionsToCheck == null || extensionsToCheck.contains(getExtension(prereq))) {
-                if (prereq.lastModified() > newestPrereq) {
-                    newestPrereq = prereq.lastModified();
-                }
-            }
-        }
-
-        // And return the comparison
-        return newestPrereq > oldestTarget;
+        return oldestTarget;
     }
 
     /**
@@ -296,11 +396,11 @@ public class DependencyGraph {
     }
 
     /**
-     *  Gets the extension (if present) on a file by looking at the filename
-     *  @param file the file to get the extension of
-     *  @return the extension if present, or the empty string if the filename doesn't have
-     *          and extension.
-     */
+      *  Gets the extension (if present) on a file by looking at the filename
+      *  @param file the file to get the extension of
+      *  @return the extension if present, or the empty string if the filename doesn't have
+      *          and extension.
+      */
     private static String getExtension(File file) {
         String filename = file.getName();
         if (filename.lastIndexOf('.') == -1) {
@@ -309,5 +409,4 @@ public class DependencyGraph {
         // Don't include the leading '.' in the extension
         return filename.substring(filename.lastIndexOf('.') + 1);
     }
-
 }