am 9139868b: am ba6c98db: am 82943ecf: am d40c93f6: Merge "Add dependency generation...

* commit '9139868b6c5cb29b3665984225dceb0193fec31d':
  Add dependency generation to Aapt for R.java

diff --git a/AaptAssets.cpp b/AaptAssets.cpp
index 29d2b872eadd61f55a903d8fb830a56907bd95bc..b35878a7b313fde3f0575c0f4abee28e014077d2 100644 (file)
--- a/AaptAssets.cpp
+++ b/AaptAssets.cpp
@@ -1560,10 +1560,10 @@ status_t AaptDir::addLeafFile(const String8& leafName, const sp<AaptFile>& file)
 }
 
 ssize_t AaptDir::slurpFullTree(Bundle* bundle, const String8& srcDir,
-                            const AaptGroupEntry& kind, const String8& resType)
+                            const AaptGroupEntry& kind, const String8& resType,
+                            sp<FilePathStore>& fullResPaths)
 {
     Vector<String8> fileNames;
-
     {
         DIR* dir = NULL;
 
@@ -1586,9 +1586,14 @@ ssize_t AaptDir::slurpFullTree(Bundle* bundle, const String8& srcDir,
             if (isHidden(srcDir.string(), entry->d_name))
                 continue;
 
-            fileNames.add(String8(entry->d_name));
+            String8 name(entry->d_name);
+            fileNames.add(name);
+            // Add fully qualified path for dependency purposes
+            // if we're collecting them
+            if (fullResPaths != NULL) {
+                fullResPaths->add(srcDir.appendPathCopy(name));
+            }
         }
-
         closedir(dir);
     }
 
@@ -1615,7 +1620,7 @@ ssize_t AaptDir::slurpFullTree(Bundle* bundle, const String8& srcDir,
                 notAdded = true;
             }
             ssize_t res = subdir->slurpFullTree(bundle, pathName, kind,
-                                                resType);
+                                                resType, fullResPaths);
             if (res < NO_ERROR) {
                 return res;
             }
@@ -1847,7 +1852,7 @@ ssize_t AaptAssets::slurpFromArgs(Bundle* bundle)
         sp<AaptDir> assetAaptDir = makeDir(String8(kAssetDir));
         AaptGroupEntry group;
         count = assetAaptDir->slurpFullTree(bundle, assetRoot, group,
-                                            String8());
+                                            String8(), mFullResPaths);
         if (count < 0) {
             totalCount = count;
             goto bail;
@@ -1878,6 +1883,7 @@ ssize_t AaptAssets::slurpFromArgs(Bundle* bundle)
                     sp<AaptAssets> nextOverlay = new AaptAssets();
                     current->setOverlay(nextOverlay);
                     current = nextOverlay;
+                    current->setFullResPaths(mFullResPaths);
                 }
                 count = current->slurpResourceTree(bundle, String8(res));
 
@@ -1920,7 +1926,7 @@ ssize_t AaptAssets::slurpFromArgs(Bundle* bundle)
          * guarantees about ordering, so we're okay with an inorder search
          * using whatever order the OS happens to hand back to us.
          */
-        count = slurpFullTree(bundle, assetRoot, AaptGroupEntry(), String8());
+        count = slurpFullTree(bundle, assetRoot, AaptGroupEntry(), String8(), mFullResPaths);
         if (count < 0) {
             /* failure; report error and remove archive */
             totalCount = count;
@@ -1946,9 +1952,10 @@ bail:
 
 ssize_t AaptAssets::slurpFullTree(Bundle* bundle, const String8& srcDir,
                                     const AaptGroupEntry& kind,
-                                    const String8& resType)
+                                    const String8& resType,
+                                    sp<FilePathStore>& fullResPaths)
 {
-    ssize_t res = AaptDir::slurpFullTree(bundle, srcDir, kind, resType);
+    ssize_t res = AaptDir::slurpFullTree(bundle, srcDir, kind, resType, fullResPaths);
     if (res > 0) {
         mGroupEntries.add(kind);
     }
@@ -2010,7 +2017,7 @@ ssize_t AaptAssets::slurpResourceTree(Bundle* bundle, const String8& srcDir)
         if (type == kFileTypeDirectory) {
             sp<AaptDir> dir = makeDir(String8(entry->d_name));
             ssize_t res = dir->slurpFullTree(bundle, subdirName, group,
-                                                resType);
+                                                resType, mFullResPaths);
             if (res < 0) {
                 count = res;
                 goto bail;

diff --git a/AaptAssets.h b/AaptAssets.h
index 65743d80f35b33732d433034b947718808eafe68..a1c7c40818ddc2ec9d99ced133b45da50fc8be87 100644 (file)
--- a/AaptAssets.h
+++ b/AaptAssets.h
@@ -140,6 +140,7 @@ inline int strictly_order_type(const AaptGroupEntry& lhs, const AaptGroupEntry&
 }
 
 class AaptGroup;
+class FilePathStore;
 
 /**
  * A single asset file we know about.
@@ -269,7 +270,8 @@ public:
     virtual ssize_t slurpFullTree(Bundle* bundle,
                                   const String8& srcDir,
                                   const AaptGroupEntry& kind,
-                                  const String8& resType);
+                                  const String8& resType,
+                                  sp<FilePathStore>& fullResPaths);
 
     /*
      * Perform some sanity checks on the names of files and directories here.
@@ -484,6 +486,14 @@ public:
     ResourceTypeSet();
 };
 
+// Storage for lists of fully qualified paths for
+// resources encountered during slurping.
+class FilePathStore : public RefBase,
+                      public Vector<String8>
+{
+public:
+    FilePathStore();
+};
 
 /**
  * Asset hierarchy being operated on.
@@ -517,7 +527,8 @@ public:
     virtual ssize_t slurpFullTree(Bundle* bundle,
                                   const String8& srcDir,
                                   const AaptGroupEntry& kind,
-                                  const String8& resType);
+                                  const String8& resType,
+                                  sp<FilePathStore>& fullResPaths);
 
     ssize_t slurpResourceTree(Bundle* bundle, const String8& srcDir);
     ssize_t slurpResourceZip(Bundle* bundle, const char* filename);
@@ -545,6 +556,10 @@ public:
     inline void 
         setResources(KeyedVector<String8, sp<ResourceTypeSet> >* res) { delete mRes; mRes = res; }
 
+    inline sp<FilePathStore>& getFullResPaths() { return mFullResPaths; }
+    inline void
+        setFullResPaths(sp<FilePathStore>& res) { mFullResPaths = res; }
+
 private:
     String8 mPackage;
     SortedVector<AaptGroupEntry> mGroupEntries;
@@ -558,6 +573,8 @@ private:
 
     sp<AaptAssets> mOverlay;
     KeyedVector<String8, sp<ResourceTypeSet> >* mRes;
+
+    sp<FilePathStore> mFullResPaths;
 };
 
 #endif // __AAPT_ASSETS_H

diff --git a/Bundle.h b/Bundle.h
index a32aa7f5c97ec8f6cd464a48ba38458d907d8bd4..56fe5249f0184531bf1d987e3b5bff1581883bee 100644 (file)
--- a/Bundle.h
+++ b/Bundle.h
@@ -41,7 +41,8 @@ public:
           mCompressionMethod(0), mOutputAPKFile(NULL),
           mManifestPackageNameOverride(NULL), mInstrumentationPackageNameOverride(NULL),
           mIsOverlayPackage(false),
-          mAutoAddOverlay(false), mAssetSourceDir(NULL), mProguardFile(NULL),
+          mAutoAddOverlay(false), mGenDependencies(false),
+          mAssetSourceDir(NULL), mProguardFile(NULL),
           mAndroidManifestFile(NULL), mPublicOutputFile(NULL),
           mRClassDir(NULL), mResourceIntermediatesDir(NULL), mManifestMinSdkVersion(NULL),
           mMinSdkVersion(NULL), mTargetSdkVersion(NULL), mMaxSdkVersion(NULL),
@@ -97,6 +98,8 @@ public:
     void setIsOverlayPackage(bool val) { mIsOverlayPackage = val; }
     bool getAutoAddOverlay() { return mAutoAddOverlay; }
     void setAutoAddOverlay(bool val) { mAutoAddOverlay = val; }
+    bool getGenDependencies() { return mGenDependencies; }
+    void setGenDependencies(bool val) { mGenDependencies = val; }
 
     /*
      * Input options.
@@ -226,6 +229,7 @@ private:
     const char* mInstrumentationPackageNameOverride;
     bool        mIsOverlayPackage;
     bool        mAutoAddOverlay;
+    bool        mGenDependencies;
     const char* mAssetSourceDir;
     const char* mProguardFile;
     const char* mAndroidManifestFile;

diff --git a/Command.cpp b/Command.cpp
index a369e8042c2cd4903637c6b8359f0373bbe83e2f..903c62cef1fe69d3102286d2886530a36f400968 100644 (file)
--- a/Command.cpp
+++ b/Command.cpp
@@ -1508,6 +1508,8 @@ int doPackage(Bundle* bundle)
     status_t err;
     sp<AaptAssets> assets;
     int N;
+    FILE* fp;
+    String8 dependencyFile;
 
     // -c zz_ZZ means do pseudolocalization
     ResourceFilter filter;
@@ -1542,6 +1544,13 @@ int doPackage(Bundle* bundle)
 
     // Load the assets.
     assets = new AaptAssets();
+
+    // Set up the resource gathering in assets if we're trying to make R.java
+    if (bundle->getGenDependencies()) {
+        sp<FilePathStore> pathStore = new FilePathStore;
+        assets->setFullResPaths(pathStore);
+    }
+
     err = assets->slurpFromArgs(bundle);
     if (err < 0) {
         goto bail;
@@ -1551,7 +1560,7 @@ int doPackage(Bundle* bundle)
         assets->print();
     }
 
-    // If they asked for any files that need to be compiled, do so.
+    // If they asked for any fileAs that need to be compiled, do so.
     if (bundle->getResourceSourceDirs().size() || bundle->getAndroidManifestFile()) {
         err = buildResources(bundle, assets);
         if (err != 0) {
@@ -1565,18 +1574,26 @@ int doPackage(Bundle* bundle)
         goto bail;
     }
 
+    if (bundle->getGenDependencies()) {
+        dependencyFile = String8(bundle->getRClassDir());
+        // Make sure we have a clean dependency file to start with
+        dependencyFile.appendPath("R.d");
+        fp = fopen(dependencyFile, "w");
+        fclose(fp);
+    }
+
     // Write out R.java constants
     if (assets->getPackage() == assets->getSymbolsPrivatePackage()) {
         if (bundle->getCustomPackage() == NULL) {
             err = writeResourceSymbols(bundle, assets, assets->getPackage(), true);
             // Copy R.java for libraries
             if (bundle->getExtraPackages() != NULL) {
-                // Split on semicolon
+                // Split on colon
                 String8 libs(bundle->getExtraPackages());
-                char* packageString = strtok(libs.lockBuffer(libs.length()), ";");
+                char* packageString = strtok(libs.lockBuffer(libs.length()), ":");
                 while (packageString != NULL) {
                     err = writeResourceSymbols(bundle, assets, String8(packageString), true);
-                    packageString = strtok(NULL, ";");
+                    packageString = strtok(NULL, ":");
                 }
                 libs.unlockBuffer();
             }
@@ -1598,6 +1615,19 @@ int doPackage(Bundle* bundle)
         }
     }
 
+    if (bundle->getGenDependencies()) {
+        // Now that writeResourceSymbols has taken care of writing the
+        // dependency targets to the dependencyFile, we'll write the
+        // pre-requisites.
+        fp = fopen(dependencyFile, "a+");
+        fprintf(fp, " : ");
+        err = writeDependencyPreReqs(bundle, assets, fp);
+
+        // Also manually add the AndroidManifeset since it's a non-asset
+        fprintf(fp, "%s \\\n", bundle->getAndroidManifestFile());
+        fclose(fp);
+    }
+
     // Write out the ProGuard file
     err = writeProguardFile(bundle, assets);
     if (err < 0) {

diff --git a/Main.cpp b/Main.cpp
index 732541d7f4b0ac52ce54f5d8019d8911f350c722..8edb5b53b194c96cddad9efcbbf4fad44add09af 100644 (file)
--- a/Main.cpp
+++ b/Main.cpp
@@ -146,7 +146,9 @@ void usage(void)
         "   --custom-package\n"
         "       generates R.java into a different package.\n"
         "   --extra-packages\n"
-        "       generate R.java for libraries. Separate libraries with ';'.\n"
+        "       generate R.java for libraries. Separate libraries with ':'.\n"
+        "   --generate-dependencies\n"
+        "       generate a dependency file for R.java.\n"
         "   --auto-add-overlay\n"
         "       Automatically add resources that are only in overlays.\n"
         "   --rename-manifest-package\n"
@@ -486,6 +488,8 @@ int main(int argc, char* const argv[])
                         goto bail;
                     }
                     bundle.setExtraPackages(argv[0]);
+                } else if (strcmp(cp, "-generate-dependencies") == 0) {
+                    bundle.setGenDependencies(true);
                 } else if (strcmp(cp, "-utf16") == 0) {
                     bundle.setWantUTF16(true);
                 } else if (strcmp(cp, "-rename-manifest-package") == 0) {

diff --git a/Main.h b/Main.h
index 3ba4f39062f81aeb71a23d494ce65ad7432baa43..1df114430fd3869ff8b1f1d3f20bf01825786860 100644 (file)
--- a/Main.h
+++ b/Main.h
@@ -46,4 +46,5 @@ int dumpResources(Bundle* bundle);
 String8 getAttribute(const ResXMLTree& tree, const char* ns,
                             const char* attr, String8* outError);
 
+status_t writeDependencyPreReqs(Bundle* bundle, const sp<AaptAssets>& assets, FILE* fp);
 #endif // __MAIN_H

diff --git a/Resource.cpp b/Resource.cpp
index b4ac92987d6ead86ae44028d16a1519c68d9ad75..99e781dc5a52feba2d9a9833a3c7fd0cfb3cb52a 100644 (file)
--- a/Resource.cpp
+++ b/Resource.cpp
@@ -51,6 +51,12 @@ ResourceTypeSet::ResourceTypeSet()
 {
 }
 
+FilePathStore::FilePathStore()
+    :RefBase(),
+     Vector<String8>()
+{
+}
+
 class ResourceDirIterator
 {
 public:
@@ -1917,6 +1923,16 @@ status_t writeResourceSymbols(Bundle* bundle, const sp<AaptAssets>& assets,
             return err;
         }
         fclose(fp);
+
+        if (bundle->getGenDependencies()) {
+            // Add this R.java to the dependency file
+            String8 dependencyFile(bundle->getRClassDir());
+            dependencyFile.appendPath("R.d");
+
+            fp = fopen(dependencyFile.string(), "a");
+            fprintf(fp,"%s \\\n", dest.string());
+            fclose(fp);
+        }
     }
 
     return NO_ERROR;
@@ -2244,3 +2260,16 @@ writeProguardFile(Bundle* bundle, const sp<AaptAssets>& assets)
 
     return err;
 }
+
+status_t
+writeDependencyPreReqs(Bundle* bundle, const sp<AaptAssets>& assets, FILE* fp)
+{
+    status_t deps = -1;
+    sp<FilePathStore> files = assets->getFullResPaths();
+    for (size_t file_i = 0; file_i < files->size(); ++file_i) {
+        // Add the full file path to the dependency file
+        fprintf(fp, "%s \\\n", files->itemAt(file_i).string());
+        deps++;
+    }
+    return deps;
+}