From: Xavier Ducrohet Date: Tue, 11 Sep 2012 21:45:22 +0000 (-0700) Subject: Add --output-text-symbols option to aapt. do not merge. X-Git-Url: https://git.saurik.com/android/aapt.git/commitdiff_plain/d4ee3b303621db0c85465c6bee031fe11be66313 Add --output-text-symbols option to aapt. do not merge. Library projects in the SDK are built using --non-constant-id to generate a temporary R.java class. When the library is packaged with the application to generate an apk, the R class is recreated with the proper IDs due to all the resources coming from the app and all the libraries. However for large apps with many libraries (each with their own R class in their package), this means a lot of unnecessary IDs: all R classes contains all the IDs including for resources from by projects they don't have access through the dependency graph. For really large apps (X,000 resources), with lots of libraries (10+), this can generate tens of thousands of resources, which can trigger dalvik's limit of 65K fields and methods per dex files. This changes lets aapt generate not only the R class but a simple text file containing the list of all those IDs so that it is easier to parse back. The SDK build system will not ask aapt to generate the R class of the libraries (through the --extra-packages option), instead it will then read this file to know what IDs are needed for each library and generate a much smaller R class for each library (using the same text file output from compiling all the resources to get the final integer value). Chery-picked from f5de650ff1e161ea135c828e43515895343d2c0f Change-Id: I0e08ceb6e4ceb3feb169ce17df21dd35a2505e7f --- diff --git a/Bundle.h b/Bundle.h index daeadc0..4f93294 100644 --- a/Bundle.h +++ b/Bundle.h @@ -62,7 +62,8 @@ public: mMinSdkVersion(NULL), mTargetSdkVersion(NULL), mMaxSdkVersion(NULL), mVersionCode(NULL), mVersionName(NULL), mCustomPackage(NULL), mExtraPackages(NULL), mMaxResVersion(NULL), mDebugMode(false), mNonConstantId(false), mProduct(NULL), - mUseCrunchCache(false), mArgc(0), mArgv(NULL) + mUseCrunchCache(false), mOutputTextSymbols(NULL), + mArgc(0), mArgv(NULL) {} ~Bundle(void) {} @@ -174,6 +175,8 @@ public: void setProduct(const char * val) { mProduct = val; } void setUseCrunchCache(bool val) { mUseCrunchCache = val; } bool getUseCrunchCache() const { return mUseCrunchCache; } + const char* getOutputTextSymbols() const { return mOutputTextSymbols; } + void setOutputTextSymbols(const char* val) { mOutputTextSymbols = val; } /* * Set and get the file specification. @@ -280,6 +283,7 @@ private: bool mNonConstantId; const char* mProduct; bool mUseCrunchCache; + const char* mOutputTextSymbols; /* file specification */ int mArgc; diff --git a/Main.cpp b/Main.cpp index 9f05c6a..98c65d2 100644 --- a/Main.cpp +++ b/Main.cpp @@ -70,7 +70,8 @@ void usage(void) " [--product product1,product2,...] \\\n" " [-c CONFIGS] [--preferred-configurations CONFIGS] \\\n" " [-o] \\\n" - " [raw-files-dir [raw-files-dir] ...]\n" + " [raw-files-dir [raw-files-dir] ...] \\\n" + " [--output-text-symbols DIR]\n" "\n" " Package the android resources. It will read assets and resources that are\n" " supplied with the -M -A -S or raw-files-dir arguments. The -J -P -F and -R\n" @@ -179,6 +180,9 @@ void usage(void) " Make the resources ID non constant. This is required to make an R java class\n" " that does not contain the final value but is used to make reusable compiled\n" " libraries that need to access resources.\n" + " --output-text-symbols\n" + " Generates a text file containing the resource symbols of the R class in the\n" + " specified folder.\n" " --ignore-assets\n" " Assets to be ignored. Default pattern is:\n" " %s\n", @@ -547,6 +551,15 @@ int main(int argc, char* const argv[]) bundle.setInstrumentationPackageNameOverride(argv[0]); } else if (strcmp(cp, "-auto-add-overlay") == 0) { bundle.setAutoAddOverlay(true); + } else if (strcmp(cp, "-output-text-symbols") == 0) { + argc--; + argv++; + if (!argc) { + fprintf(stderr, "ERROR: No argument supplied for '-output-text-symbols' option\n"); + wantUsage = true; + goto bail; + } + bundle.setOutputTextSymbols(argv[0]); } else if (strcmp(cp, "-product") == 0) { argc--; argv++; diff --git a/Resource.cpp b/Resource.cpp index ee076e6..e4f8d81 100644 --- a/Resource.cpp +++ b/Resource.cpp @@ -1821,6 +1821,110 @@ static status_t writeLayoutClasses( return hasErrors ? UNKNOWN_ERROR : NO_ERROR; } +static status_t writeTextLayoutClasses( + FILE* fp, const sp& assets, + const sp& symbols, bool includePrivate) +{ + String16 attr16("attr"); + String16 package16(assets->getPackage()); + + bool hasErrors = false; + + size_t i; + size_t N = symbols->getNestedSymbols().size(); + for (i=0; i nsymbols = symbols->getNestedSymbols().valueAt(i); + String16 nclassName16(symbols->getNestedSymbols().keyAt(i)); + String8 realClassName(nclassName16); + if (fixupSymbol(&nclassName16) != NO_ERROR) { + hasErrors = true; + } + String8 nclassName(nclassName16); + + SortedVector idents; + Vector origOrder; + Vector publicFlags; + + size_t a; + size_t NA = nsymbols->getSymbols().size(); + for (a=0; agetSymbols().valueAt(a)); + int32_t code = sym.typeCode == AaptSymbolEntry::TYPE_INT32 + ? sym.int32Val : 0; + bool isPublic = true; + if (code == 0) { + String16 name16(sym.name); + uint32_t typeSpecFlags; + code = assets->getIncludedResources().identifierForName( + name16.string(), name16.size(), + attr16.string(), attr16.size(), + package16.string(), package16.size(), &typeSpecFlags); + if (code == 0) { + fprintf(stderr, "ERROR: In %s, unable to find attribute %s\n", + nclassName.string(), sym.name.string()); + hasErrors = true; + } + isPublic = (typeSpecFlags&ResTable_typeSpec::SPEC_PUBLIC) != 0; + } + idents.add(code); + origOrder.add(code); + publicFlags.add(isPublic); + } + + NA = idents.size(); + + fprintf(fp, "int[] styleable %s {", nclassName.string()); + + for (a=0; a= 0) { + const AaptSymbolEntry& sym = nsymbols->getSymbols().valueAt(a); + if (!publicFlags.itemAt(a) && !includePrivate) { + continue; + } + String8 name8(sym.name); + String16 comment(sym.comment); + String16 typeComment; + if (comment.size() <= 0) { + comment = getAttributeComment(assets, name8, &typeComment); + } else { + getAttributeComment(assets, name8, &typeComment); + } + String16 name(name8); + if (fixupSymbol(&name) != NO_ERROR) { + hasErrors = true; + } + + uint32_t typeSpecFlags = 0; + String16 name16(sym.name); + assets->getIncludedResources().identifierForName( + name16.string(), name16.size(), + attr16.string(), attr16.size(), + package16.string(), package16.size(), &typeSpecFlags); + //printf("%s:%s/%s: 0x%08x\n", String8(package16).string(), + // String8(attr16).string(), String8(name16).string(), typeSpecFlags); + const bool pub = (typeSpecFlags&ResTable_typeSpec::SPEC_PUBLIC) != 0; + + fprintf(fp, + "int styleable.%s_%s %d\n", + nclassName.string(), + String8(name).string(), (int)pos); + } + } + } + + return hasErrors ? UNKNOWN_ERROR : NO_ERROR; +} + static status_t writeSymbolClass( FILE* fp, const sp& assets, bool includePrivate, const sp& symbols, const String8& className, int indent, @@ -1848,7 +1952,6 @@ static status_t writeSymbolClass( continue; } String16 name(sym.name); - String8 realName(name); if (fixupSymbol(&name) != NO_ERROR) { return UNKNOWN_ERROR; } @@ -1960,6 +2063,51 @@ static status_t writeSymbolClass( return NO_ERROR; } +static status_t writeTextSymbolClass( + FILE* fp, const sp& assets, bool includePrivate, + const sp& symbols, const String8& className) +{ + size_t i; + status_t err = NO_ERROR; + + size_t N = symbols->getSymbols().size(); + for (i=0; igetSymbols().valueAt(i); + if (sym.typeCode != AaptSymbolEntry::TYPE_INT32) { + continue; + } + + if (!assets->isJavaSymbol(sym, includePrivate)) { + continue; + } + + String16 name(sym.name); + if (fixupSymbol(&name) != NO_ERROR) { + return UNKNOWN_ERROR; + } + + fprintf(fp, "int %s %s 0x%08x\n", + className.string(), + String8(name).string(), (int)sym.int32Val); + } + + N = symbols->getNestedSymbols().size(); + for (i=0; i nsymbols = symbols->getNestedSymbols().valueAt(i); + String8 nclassName(symbols->getNestedSymbols().keyAt(i)); + if (nclassName == "styleable") { + err = writeTextLayoutClasses(fp, assets, nsymbols, includePrivate); + } else { + err = writeTextSymbolClass(fp, assets, includePrivate, nsymbols, nclassName); + } + if (err != NO_ERROR) { + return err; + } + } + + return NO_ERROR; +} + status_t writeResourceSymbols(Bundle* bundle, const sp& assets, const String8& package, bool includePrivate) { @@ -1967,11 +2115,15 @@ status_t writeResourceSymbols(Bundle* bundle, const sp& assets, return NO_ERROR; } + const char* textSymbolsDest = bundle->getOutputTextSymbols(); + + String8 R("R"); const size_t N = assets->getSymbols().size(); for (size_t i=0; i symbols = assets->getSymbols().valueAt(i); String8 className(assets->getSymbols().keyAt(i)); String8 dest(bundle->getRClassDir()); + if (bundle->getMakePackageDirs()) { String8 pkg(package); const char* last = pkg.string(); @@ -2003,14 +2155,14 @@ status_t writeResourceSymbols(Bundle* bundle, const sp& assets, } fprintf(fp, - "/* AUTO-GENERATED FILE. DO NOT MODIFY.\n" - " *\n" - " * This class was automatically generated by the\n" - " * aapt tool from the resource data it found. It\n" - " * should not be modified by hand.\n" - " */\n" - "\n" - "package %s;\n\n", package.string()); + "/* AUTO-GENERATED FILE. DO NOT MODIFY.\n" + " *\n" + " * This class was automatically generated by the\n" + " * aapt tool from the resource data it found. It\n" + " * should not be modified by hand.\n" + " */\n" + "\n" + "package %s;\n\n", package.string()); status_t err = writeSymbolClass(fp, assets, includePrivate, symbols, className, 0, bundle->getNonConstantId()); @@ -2019,14 +2171,37 @@ status_t writeResourceSymbols(Bundle* bundle, const sp& assets, } fclose(fp); + if (textSymbolsDest != NULL && R == className) { + String8 textDest(textSymbolsDest); + textDest.appendPath(className); + textDest.append(".txt"); + + FILE* fp = fopen(textDest.string(), "w+"); + if (fp == NULL) { + fprintf(stderr, "ERROR: Unable to open text symbol file %s: %s\n", + textDest.string(), strerror(errno)); + return UNKNOWN_ERROR; + } + if (bundle->getVerbose()) { + printf(" Writing text symbols for class %s.\n", className.string()); + } + + status_t err = writeTextSymbolClass(fp, assets, includePrivate, symbols, + className); + if (err != NO_ERROR) { + return err; + } + fclose(fp); + } + // If we were asked to generate a dependency file, we'll go ahead and add this R.java // as a target in the dependency file right next to it. - if (bundle->getGenDependencies()) { + if (bundle->getGenDependencies() && R == className) { // Add this R.java to the dependency file String8 dependencyFile(bundle->getRClassDir()); dependencyFile.appendPath("R.java.d"); - fp = fopen(dependencyFile.string(), "a"); + FILE *fp = fopen(dependencyFile.string(), "a"); fprintf(fp,"%s \\\n", dest.string()); fclose(fp); } @@ -2036,7 +2211,6 @@ status_t writeResourceSymbols(Bundle* bundle, const sp& assets, } - class ProguardKeepSet { public: