{

PackageInfo()

{

}

~PackageInfo()

{

}

status_t parsePackage(const sp<AaptGroup>& grp);

{

const char* firstDot = strchr(leaf.string(), '.');

const char* str = leaf.string();

if (firstDot) {

return String8(str, firstDot-str);

} else {

return String8(str);

}

:RefBase(),

KeyedVector<String8,sp<AaptGroup> >()

{

:RefBase(),

Vector<String8>()

{

{

ResourceDirIterator(const sp<ResourceTypeSet>& set, const String8& resType)

: mResType(resType), mSet(set), mSetPos(0), mGroupPos(0)

{

}

inline const sp<AaptGroup>& getGroup() const { return mGroup; }

inline const sp<AaptFile>& getFile() const { return mFile; }

inline const String8& getBaseName() const { return mBaseName; }

inline const String8& getLeafName() const { return mLeafName; }

inline String8 getPath() const { return mPath; }

inline const ResTable_config& getParams() const { return mParams; }

enum {

EOD = 1

};

ssize_t next()

{

while (true) {

sp<AaptGroup> group;

sp<AaptFile> file;

// Try to get next file in this current group.

if (mGroup != NULL && mGroupPos < mGroup->getFiles().size()) {

group = mGroup;

file = group->getFiles().valueAt(mGroupPos++);

// Try to get the next group/file in this directory

} else if (mSetPos < mSet->size()) {

mGroup = group = mSet->valueAt(mSetPos++);

if (group->getFiles().size() < 1) {

continue;

}

file = group->getFiles().valueAt(0);

mGroupPos = 1;

// All done!

} else {

return EOD;

}

mFile = file;

String8 leaf(group->getLeaf());

mLeafName = String8(leaf);

mParams = file->getGroupEntry().toParams();

NOISY(printf("Dir %s: mcc=%d mnc=%d lang=%c%c cnt=%c%c orient=%d ui=%d density=%d touch=%d key=%d inp=%d nav=%d\n",

group->getPath().string(), mParams.mcc, mParams.mnc,

mParams.language[0] ? mParams.language[0] : '-',

mParams.language[1] ? mParams.language[1] : '-',

mParams.country[0] ? mParams.country[0] : '-',

mParams.country[1] ? mParams.country[1] : '-',

mParams.orientation, mParams.uiMode,

mParams.density, mParams.touchscreen, mParams.keyboard,

mParams.inputFlags, mParams.navigation));

mPath = "res";

mPath.appendPath(file->getGroupEntry().toDirName(mResType));

mPath.appendPath(leaf);

mBaseName = parseResourceName(leaf);

if (mBaseName == "") {

fprintf(stderr, "Error: malformed resource filename %s\n",

file->getPrintableSource().string());

return UNKNOWN_ERROR;

}

NOISY(printf("file name=%s\n", mBaseName.string()));

return NO_ERROR;

}

}

String8 mResType;

const sp<ResourceTypeSet> mSet;

size_t mSetPos;

sp<AaptGroup> mGroup;

size_t mGroupPos;

sp<AaptFile> mFile;

String8 mBaseName;

String8 mLeafName;

String8 mPath;

ResTable_config mParams;

{

return type == "anim" || type == "animator" || type == "interpolator"

|| type == "drawable" || type == "layout"

|| type == "values" || type == "xml" || type == "raw"

|| type == "color" || type == "menu" || type == "mipmap";

{

sp<AaptGroup> group = assets->getFiles().valueFor(String8("resources.arsc"));

sp<AaptFile> file;

if (group != NULL) {

file = group->getFiles().valueFor(AaptGroupEntry());

if (file != NULL) {

return file;

}

}

if (!makeIfNecessary) {

return NULL;

}

return assets->addFile(String8("resources.arsc"), AaptGroupEntry(), String8(),

NULL, String8());

const sp<AaptGroup>& grp)

{

if (grp->getFiles().size() != 1) {

fprintf(stderr, "warning: Multiple AndroidManifest.xml files found, using %s\n",

grp->getFiles().valueAt(0)->getPrintableSource().string());

}

sp<AaptFile> file = grp->getFiles().valueAt(0);

ResXMLTree block;

status_t err = parseXMLResource(file, &block);

if (err != NO_ERROR) {

return err;

}

//printXMLBlock(&block);

ResXMLTree::event_code_t code;

while ((code=block.next()) != ResXMLTree::START_TAG

&& code != ResXMLTree::END_DOCUMENT

&& code != ResXMLTree::BAD_DOCUMENT) {

}

size_t len;

if (code != ResXMLTree::START_TAG) {

fprintf(stderr, "%s:%d: No start tag found\n",

file->getPrintableSource().string(), block.getLineNumber());

return UNKNOWN_ERROR;

}

if (strcmp16(block.getElementName(&len), String16("manifest").string()) != 0) {

fprintf(stderr, "%s:%d: Invalid start tag %s, expected <manifest>\n",

file->getPrintableSource().string(), block.getLineNumber(),

String8(block.getElementName(&len)).string());

return UNKNOWN_ERROR;

}

ssize_t nameIndex = block.indexOfAttribute(NULL, "package");

if (nameIndex < 0) {

fprintf(stderr, "%s:%d: <manifest> does not have package attribute.\n",

file->getPrintableSource().string(), block.getLineNumber());

return UNKNOWN_ERROR;

}

assets->setPackage(String8(block.getAttributeStringValue(nameIndex, &len)));

String16 uses_sdk16("uses-sdk");

while ((code=block.next()) != ResXMLTree::END_DOCUMENT

&& code != ResXMLTree::BAD_DOCUMENT) {

if (code == ResXMLTree::START_TAG) {

if (strcmp16(block.getElementName(&len), uses_sdk16.string()) == 0) {

ssize_t minSdkIndex = block.indexOfAttribute(RESOURCES_ANDROID_NAMESPACE,

"minSdkVersion");

if (minSdkIndex >= 0) {

const uint16_t* minSdk16 = block.getAttributeStringValue(minSdkIndex, &len);

const char* minSdk8 = strdup(String8(minSdk16).string());

bundle->setManifestMinSdkVersion(minSdk8);

}

}

}

}

return NO_ERROR;

ResourceTable* table,

const sp<ResourceTypeSet>& set,

const char* resType)

{

String8 type8(resType);

String16 type16(resType);

bool hasErrors = false;

ResourceDirIterator it(set, String8(resType));

ssize_t res;

while ((res=it.next()) == NO_ERROR) {

if (bundle->getVerbose()) {

printf(" (new resource id %s from %s)\n",

it.getBaseName().string(), it.getFile()->getPrintableSource().string());

}

String16 baseName(it.getBaseName());

const char16_t* str = baseName.string();

const char16_t* const end = str + baseName.size();

while (str < end) {

if (!((*str >= 'a' && *str <= 'z')

|| (*str >= '0' && *str <= '9')

|| *str == '_' || *str == '.')) {

fprintf(stderr, "%s: Invalid file name: must contain only [a-z0-9_.]\n",

it.getPath().string());

hasErrors = true;

}

str++;

}

String8 resPath = it.getPath();

resPath.convertToResPath();

table->addEntry(SourcePos(it.getPath(), 0), String16(assets->getPackage()),

type16,

baseName,

String16(resPath),

NULL,

&it.getParams());

assets->addResource(it.getLeafName(), resPath, it.getFile(), type8);

}

return hasErrors ? UNKNOWN_ERROR : NO_ERROR;

PreProcessImageWorkUnit(const Bundle* bundle, const sp<AaptAssets>& assets,

const sp<AaptFile>& file, volatile bool* hasErrors) :

mBundle(bundle), mAssets(assets), mFile(file), mHasErrors(hasErrors) {

}

virtual bool run() {

status_t status = preProcessImage(mBundle, mAssets, mFile, NULL);

if (status) {

*mHasErrors = true;

}

return true; // continue even if there are errors

}

const Bundle* mBundle;

sp<AaptAssets> mAssets;

sp<AaptFile> mFile;

volatile bool* mHasErrors;

const sp<ResourceTypeSet>& set, const char* type)

{

volatile bool hasErrors = false;

ssize_t res = NO_ERROR;

if (bundle->getUseCrunchCache() == false) {

WorkQueue wq(MAX_THREADS, false);

ResourceDirIterator it(set, String8(type));

while ((res=it.next()) == NO_ERROR) {

PreProcessImageWorkUnit* w = new PreProcessImageWorkUnit(

bundle, assets, it.getFile(), &hasErrors);

status_t status = wq.schedule(w);

if (status) {

fprintf(stderr, "preProcessImages failed: schedule() returned %d\n", status);

hasErrors = true;

delete w;

break;

}

}

status_t status = wq.finish();

if (status) {

fprintf(stderr, "preProcessImages failed: finish() returned %d\n", status);

hasErrors = true;

}

}

return (hasErrors || (res < NO_ERROR)) ? UNKNOWN_ERROR : NO_ERROR;

ResourceTable* table,

const sp<ResourceTypeSet>& set)

{

ResourceDirIterator it(set, String8("drawable"));

bool hasErrors = false;

ssize_t res;

while ((res=it.next()) == NO_ERROR) {

res = postProcessImage(assets, table, it.getFile());

if (res < NO_ERROR) {

hasErrors = true;

}

}

return (hasErrors || (res < NO_ERROR)) ? UNKNOWN_ERROR : NO_ERROR;

KeyedVector<String8, sp<ResourceTypeSet> >* resources)

{

const DefaultKeyedVector<String8, sp<AaptGroup> >& groups = dir->getFiles();

int N = groups.size();

for (int i=0; i<N; i++) {

String8 leafName = groups.keyAt(i);

const sp<AaptGroup>& group = groups.valueAt(i);

const DefaultKeyedVector<AaptGroupEntry, sp<AaptFile> >& files

= group->getFiles();

if (files.size() == 0) {

continue;

}

String8 resType = files.valueAt(0)->getResourceType();

ssize_t index = resources->indexOfKey(resType);

if (index < 0) {

sp<ResourceTypeSet> set = new ResourceTypeSet();

NOISY(printf("Creating new resource type set for leaf %s with group %s (%p)\n",

leafName.string(), group->getPath().string(), group.get()));

set->add(leafName, group);

resources->add(resType, set);

} else {

sp<ResourceTypeSet> set = resources->valueAt(index);

index = set->indexOfKey(leafName);

if (index < 0) {

NOISY(printf("Adding to resource type set for leaf %s group %s (%p)\n",

leafName.string(), group->getPath().string(), group.get()));

set->add(leafName, group);

} else {

sp<AaptGroup> existingGroup = set->valueAt(index);

NOISY(printf("Extending to resource type set for leaf %s group %s (%p)\n",

leafName.string(), group->getPath().string(), group.get()));

for (size_t j=0; j<files.size(); j++) {

NOISY(printf("Adding file %s in group %s resType %s\n",

files.valueAt(j)->getSourceFile().string(),

files.keyAt(j).toDirName(String8()).string(),

resType.string()));

status_t err = existingGroup->addFile(files.valueAt(j));

}

}

}

}

KeyedVector<String8, sp<ResourceTypeSet> >* resources)

{

const Vector<sp<AaptDir> >& dirs = ass->resDirs();

int N = dirs.size();

for (int i=0; i<N; i++) {

sp<AaptDir> d = dirs.itemAt(i);

NOISY(printf("Collecting dir #%d %p: %s, leaf %s\n", i, d.get(), d->getPath().string(),

d->getLeaf().string()));

collect_files(d, resources);

// don't try to include the res dir

NOISY(printf("Removing dir leaf %s\n", d->getLeaf().string()));

ass->removeDir(d->getLeaf());

}

const ResXMLParser& parser,

const char* ns, const char* attr, const char* validChars, bool required)

{

size_t len;

ssize_t index = parser.indexOfAttribute(ns, attr);

const uint16_t* str;

Res_value value;

if (index >= 0 && parser.getAttributeValue(index, &value) >= 0) {

const ResStringPool* pool = &parser.getStrings();

if (value.dataType == Res_value::TYPE_REFERENCE) {

uint32_t specFlags = 0;

int strIdx;

if ((strIdx=table.resolveReference(&value, 0x10000000, NULL, &specFlags)) < 0) {

fprintf(stderr, "%s:%d: Tag <%s> attribute %s references unknown resid 0x%08x.\n",

path.string(), parser.getLineNumber(),

String8(parser.getElementName(&len)).string(), attr,

value.data);

return ATTR_NOT_FOUND;

}

pool = table.getTableStringBlock(strIdx);

#if 0

if (pool != NULL) {

str = pool->stringAt(value.data, &len);

}

printf("***** RES ATTR: %s specFlags=0x%x strIdx=%d: %s\n", attr,

specFlags, strIdx, str != NULL ? String8(str).string() : "???");

#endif

if ((specFlags&~ResTable_typeSpec::SPEC_PUBLIC) != 0 && false) {

fprintf(stderr, "%s:%d: Tag <%s> attribute %s varies by configurations 0x%x.\n",

path.string(), parser.getLineNumber(),

String8(parser.getElementName(&len)).string(), attr,

specFlags);

return ATTR_NOT_FOUND;

}

}

if (value.dataType == Res_value::TYPE_STRING) {

if (pool == NULL) {

fprintf(stderr, "%s:%d: Tag <%s> attribute %s has no string block.\n",

path.string(), parser.getLineNumber(),

String8(parser.getElementName(&len)).string(), attr);

return ATTR_NOT_FOUND;

}

if ((str=pool->stringAt(value.data, &len)) == NULL) {

fprintf(stderr, "%s:%d: Tag <%s> attribute %s has corrupt string value.\n",

path.string(), parser.getLineNumber(),

String8(parser.getElementName(&len)).string(), attr);

return ATTR_NOT_FOUND;

}

} else {

fprintf(stderr, "%s:%d: Tag <%s> attribute %s has invalid type %d.\n",

path.string(), parser.getLineNumber(),

String8(parser.getElementName(&len)).string(), attr,

value.dataType);

return ATTR_NOT_FOUND;

}

if (validChars) {

for (size_t i=0; i<len; i++) {

uint16_t c = str[i];

const char* p = validChars;

bool okay = false;

while (*p) {

if (c == *p) {

okay = true;

break;

}

p++;

}

if (!okay) {

fprintf(stderr, "%s:%d: Tag <%s> attribute %s has invalid character '%c'.\n",

path.string(), parser.getLineNumber(),

String8(parser.getElementName(&len)).string(), attr, (char)str[i]);

return (int)i;

}

}

}

if (*str == ' ') {

fprintf(stderr, "%s:%d: Tag <%s> attribute %s can not start with a space.\n",

path.string(), parser.getLineNumber(),

String8(parser.getElementName(&len)).string(), attr);

return ATTR_LEADING_SPACES;

}

if (str[len-1] == ' ') {

fprintf(stderr, "%s:%d: Tag <%s> attribute %s can not end with a space.\n",

path.string(), parser.getLineNumber(),

String8(parser.getElementName(&len)).string(), attr);

return ATTR_TRAILING_SPACES;

}

return ATTR_OKAY;

}

if (required) {

fprintf(stderr, "%s:%d: Tag <%s> missing required attribute %s.\n",

path.string(), parser.getLineNumber(),

String8(parser.getElementName(&len)).string(), attr);

return ATTR_NOT_FOUND;

}

return ATTR_OKAY;

{

ResXMLTree::event_code_t code;

while ((code=parser.next()) != ResXMLTree::END_DOCUMENT

&& code > ResXMLTree::BAD_DOCUMENT) {

if (code == ResXMLTree::START_TAG) {

ssize_t index = parser.indexOfAttribute(NULL, "id");

if (index >= 0) {

fprintf(stderr, "%s:%d: warning: found plain 'id' attribute; did you mean the new 'android:id' name?\n",

path.string(), parser.getLineNumber());

}

}

}

const sp<AaptAssets>& assets,

sp<ResourceTypeSet> *baseSet,

const char *resType)

{

if (bundle->getVerbose()) {

printf("applyFileOverlay for %s\n", resType);

}

// Replace any base level files in this category with any found from the overlay

// Also add any found only in the overlay.

sp<AaptAssets> overlay = assets->getOverlay();

String8 resTypeString(resType);

// work through the linked list of overlays

while (overlay.get()) {

KeyedVector<String8, sp<ResourceTypeSet> >* overlayRes = overlay->getResources();

// get the overlay resources of the requested type

ssize_t index = overlayRes->indexOfKey(resTypeString);

if (index >= 0) {

sp<ResourceTypeSet> overlaySet = overlayRes->valueAt(index);

// for each of the resources, check for a match in the previously built

// non-overlay "baseset".

size_t overlayCount = overlaySet->size();

for (size_t overlayIndex=0; overlayIndex<overlayCount; overlayIndex++) {

if (bundle->getVerbose()) {

printf("trying overlaySet Key=%s\n",overlaySet->keyAt(overlayIndex).string());

}

size_t baseIndex = UNKNOWN_ERROR;

if (baseSet->get() != NULL) {

baseIndex = (*baseSet)->indexOfKey(overlaySet->keyAt(overlayIndex));

}

if (baseIndex < UNKNOWN_ERROR) {

// look for same flavor. For a given file (strings.xml, for example)

// there may be a locale specific or other flavors - we want to match

// the same flavor.

sp<AaptGroup> overlayGroup = overlaySet->valueAt(overlayIndex);

sp<AaptGroup> baseGroup = (*baseSet)->valueAt(baseIndex);

DefaultKeyedVector<AaptGroupEntry, sp<AaptFile> > overlayFiles =

overlayGroup->getFiles();

if (bundle->getVerbose()) {

DefaultKeyedVector<AaptGroupEntry, sp<AaptFile> > baseFiles =

baseGroup->getFiles();

for (size_t i=0; i < baseFiles.size(); i++) {

printf("baseFile " ZD " has flavor %s\n", (ZD_TYPE) i,

baseFiles.keyAt(i).toString().string());

}

for (size_t i=0; i < overlayFiles.size(); i++) {

printf("overlayFile " ZD " has flavor %s\n", (ZD_TYPE) i,

overlayFiles.keyAt(i).toString().string());

}

}

size_t overlayGroupSize = overlayFiles.size();

for (size_t overlayGroupIndex = 0;

overlayGroupIndex<overlayGroupSize;

overlayGroupIndex++) {

size_t baseFileIndex =

baseGroup->getFiles().indexOfKey(overlayFiles.

keyAt(overlayGroupIndex));

if (baseFileIndex < UNKNOWN_ERROR) {

if (bundle->getVerbose()) {

printf("found a match (" ZD ") for overlay file %s, for flavor %s\n",

(ZD_TYPE) baseFileIndex,

overlayGroup->getLeaf().string(),

overlayFiles.keyAt(overlayGroupIndex).toString().string());

}

baseGroup->removeFile(baseFileIndex);

} else {

// didn't find a match fall through and add it..

if (true || bundle->getVerbose()) {

printf("nothing matches overlay file %s, for flavor %s\n",

overlayGroup->getLeaf().string(),

overlayFiles.keyAt(overlayGroupIndex).toString().string());

}

}

baseGroup->addFile(overlayFiles.valueAt(overlayGroupIndex));

assets->addGroupEntry(overlayFiles.keyAt(overlayGroupIndex));

}

} else {

if (baseSet->get() == NULL) {

*baseSet = new ResourceTypeSet();

assets->getResources()->add(String8(resType), *baseSet);

}

// this group doesn't exist (a file that's only in the overlay)

(*baseSet)->add(overlaySet->keyAt(overlayIndex),

overlaySet->valueAt(overlayIndex));

// make sure all flavors are defined in the resources.

sp<AaptGroup> overlayGroup = overlaySet->valueAt(overlayIndex);

DefaultKeyedVector<AaptGroupEntry, sp<AaptFile> > overlayFiles =

overlayGroup->getFiles();

size_t overlayGroupSize = overlayFiles.size();

for (size_t overlayGroupIndex = 0;

overlayGroupIndex<overlayGroupSize;

overlayGroupIndex++) {

assets->addGroupEntry(overlayFiles.keyAt(overlayGroupIndex));

}

}

}

// this overlay didn't have resources for this type

}

// try next overlay

overlay = overlay->getOverlay();

}

return true;

const char* attr8, const char* value, bool errorOnFailedInsert)

{

if (value == NULL) {

return true;

}

const String16 ns(ns8);

const String16 attr(attr8);

if (node->getAttribute(ns, attr) != NULL) {

if (errorOnFailedInsert) {

fprintf(stderr, "Error: AndroidManifest.xml already defines %s (in %s);"

" cannot insert new value %s.\n",

String8(attr).string(), String8(ns).string(), value);

return false;

}

fprintf(stderr, "Warning: AndroidManifest.xml already defines %s (in %s);"

" using existing value in manifest.\n",

String8(attr).string(), String8(ns).string());

// don't stop the build.

return true;

}

node->addAttribute(ns, attr, String16(value));

return true;

const String16& attrName) {

XMLNode::attribute_entry* attr = node->editAttribute(

String16("http://schemas.android.com/apk/res/android"), attrName);

if (attr != NULL) {

String8 name(attr->string);

// asdf --> package.asdf

// .asdf .a.b --> package.asdf package.a.b

// asdf.adsf --> asdf.asdf

String8 className;

const char* p = name.string();

const char* q = strchr(p, '.');

if (p == q) {

className += package;

className += name;

} else if (q == NULL) {

className += package;

className += ".";

className += name;

} else {

className += name;

}

NOISY(printf("Qualifying class '%s' to '%s'", name.string(), className.string()));

attr->string.setTo(String16(className));

}

{

root = root->searchElement(String16(), String16("manifest"));

if (root == NULL) {

fprintf(stderr, "No <manifest> tag.\n");

return UNKNOWN_ERROR;

}

bool errorOnFailedInsert = bundle->getErrorOnFailedInsert();

if (!addTagAttribute(root, RESOURCES_ANDROID_NAMESPACE, "versionCode",

bundle->getVersionCode(), errorOnFailedInsert)) {

return UNKNOWN_ERROR;

}

if (!addTagAttribute(root, RESOURCES_ANDROID_NAMESPACE, "versionName",

bundle->getVersionName(), errorOnFailedInsert)) {

return UNKNOWN_ERROR;

}

if (bundle->getMinSdkVersion() != NULL

|| bundle->getTargetSdkVersion() != NULL

|| bundle->getMaxSdkVersion() != NULL) {

sp<XMLNode> vers = root->getChildElement(String16(), String16("uses-sdk"));

if (vers == NULL) {

vers = XMLNode::newElement(root->getFilename(), String16(), String16("uses-sdk"));

root->insertChildAt(vers, 0);

}

if (!addTagAttribute(vers, RESOURCES_ANDROID_NAMESPACE, "minSdkVersion",

bundle->getMinSdkVersion(), errorOnFailedInsert)) {

return UNKNOWN_ERROR;

}

if (!addTagAttribute(vers, RESOURCES_ANDROID_NAMESPACE, "targetSdkVersion",

bundle->getTargetSdkVersion(), errorOnFailedInsert)) {

return UNKNOWN_ERROR;

}

if (!addTagAttribute(vers, RESOURCES_ANDROID_NAMESPACE, "maxSdkVersion",

bundle->getMaxSdkVersion(), errorOnFailedInsert)) {

return UNKNOWN_ERROR;

}

}

if (bundle->getDebugMode()) {

sp<XMLNode> application = root->getChildElement(String16(), String16("application"));

if (application != NULL) {

if (!addTagAttribute(application, RESOURCES_ANDROID_NAMESPACE, "debuggable", "true",

errorOnFailedInsert)) {

return UNKNOWN_ERROR;

}

}

}

// Deal with manifest package name overrides

const char* manifestPackageNameOverride = bundle->getManifestPackageNameOverride();

if (manifestPackageNameOverride != NULL) {

// Update the actual package name

XMLNode::attribute_entry* attr = root->editAttribute(String16(), String16("package"));

if (attr == NULL) {

fprintf(stderr, "package name is required with --rename-manifest-package.\n");

return UNKNOWN_ERROR;

}

String8 origPackage(attr->string);

attr->string.setTo(String16(manifestPackageNameOverride));

NOISY(printf("Overriding package '%s' to be '%s'\n", origPackage.string(), manifestPackageNameOverride));

// Make class names fully qualified

sp<XMLNode> application = root->getChildElement(String16(), String16("application"));

if (application != NULL) {

fullyQualifyClassName(origPackage, application, String16("name"));

fullyQualifyClassName(origPackage, application, String16("backupAgent"));

Vector<sp<XMLNode> >& children = const_cast<Vector<sp<XMLNode> >&>(application->getChildren());

for (size_t i = 0; i < children.size(); i++) {

sp<XMLNode> child = children.editItemAt(i);

String8 tag(child->getElementName());

if (tag == "activity" || tag == "service" || tag == "receiver" || tag == "provider") {

fullyQualifyClassName(origPackage, child, String16("name"));

} else if (tag == "activity-alias") {

fullyQualifyClassName(origPackage, child, String16("name"));

fullyQualifyClassName(origPackage, child, String16("targetActivity"));

}

}

}

}

// Deal with manifest package name overrides

const char* instrumentationPackageNameOverride = bundle->getInstrumentationPackageNameOverride();

if (instrumentationPackageNameOverride != NULL) {

// Fix up instrumentation targets.

Vector<sp<XMLNode> >& children = const_cast<Vector<sp<XMLNode> >&>(root->getChildren());

for (size_t i = 0; i < children.size(); i++) {

sp<XMLNode> child = children.editItemAt(i);

String8 tag(child->getElementName());

if (tag == "instrumentation") {

XMLNode::attribute_entry* attr = child->editAttribute(

String16("http://schemas.android.com/apk/res/android"), String16("targetPackage"));

if (attr != NULL) {

attr->string.setTo(String16(instrumentationPackageNameOverride));

}

}

}

}

return NO_ERROR;

{

#if BENCHMARK

fprintf(stdout, "BENCHMARK: Starting PNG PreProcessing \n");

long startPNGTime = clock();

#endif /* BENCHMARK */

String8 source(bundle->getResourceSourceDirs()[0]);

String8 dest(bundle->getCrunchedOutputDir());

FileFinder* ff = new SystemFileFinder();

CrunchCache cc(source,dest,ff);

CacheUpdater* cu = new SystemCacheUpdater(bundle);

size_t numFiles = cc.crunch(cu);

if (bundle->getVerbose())

fprintf(stdout, "Crunched %d PNG files to update cache\n", (int)numFiles);

delete ff;

delete cu;

#if BENCHMARK

fprintf(stdout, "BENCHMARK: End PNG PreProcessing. Time Elapsed: %f ms \n"

,(clock() - startPNGTime)/1000.0);

#endif /* BENCHMARK */

return 0;

{

// First, look for a package file to parse. This is required to

// be able to generate the resource information.

sp<AaptGroup> androidManifestFile =

assets->getFiles().valueFor(String8("AndroidManifest.xml"));

if (androidManifestFile == NULL) {

fprintf(stderr, "ERROR: No AndroidManifest.xml file found.\n");

return UNKNOWN_ERROR;

}

status_t err = parsePackage(bundle, assets, androidManifestFile);

if (err != NO_ERROR) {

return err;

}

NOISY(printf("Creating resources for package %s\n",

assets->getPackage().string()));

ResourceTable table(bundle, String16(assets->getPackage()));

err = table.addIncludedResources(bundle, assets);

if (err != NO_ERROR) {

return err;

}

NOISY(printf("Found %d included resource packages\n", (int)table.size()));

// Standard flags for compiled XML and optional UTF-8 encoding

int xmlFlags = XML_COMPILE_STANDARD_RESOURCE;

/* Only enable UTF-8 if the caller of aapt didn't specifically

if (!bundle->getUTF16StringsOption()) {

xmlFlags |= XML_COMPILE_UTF8;

}

// --------------------------------------------------------------

// First, gather all resource information.

// --------------------------------------------------------------

// resType -> leafName -> group

KeyedVector<String8, sp<ResourceTypeSet> > *resources =

new KeyedVector<String8, sp<ResourceTypeSet> >;

collect_files(assets, resources);

sp<ResourceTypeSet> drawables;

sp<ResourceTypeSet> layouts;

sp<ResourceTypeSet> anims;

sp<ResourceTypeSet> animators;

sp<ResourceTypeSet> interpolators;

sp<ResourceTypeSet> xmls;

sp<ResourceTypeSet> raws;

sp<ResourceTypeSet> colors;

sp<ResourceTypeSet> menus;

sp<ResourceTypeSet> mipmaps;

ASSIGN_IT(drawable);

ASSIGN_IT(layout);

ASSIGN_IT(anim);

ASSIGN_IT(animator);

ASSIGN_IT(interpolator);

ASSIGN_IT(xml);

ASSIGN_IT(raw);

ASSIGN_IT(color);

ASSIGN_IT(menu);

ASSIGN_IT(mipmap);

assets->setResources(resources);

// now go through any resource overlays and collect their files

sp<AaptAssets> current = assets->getOverlay();

while(current.get()) {

KeyedVector<String8, sp<ResourceTypeSet> > *resources =

new KeyedVector<String8, sp<ResourceTypeSet> >;

current->setResources(resources);

collect_files(current, resources);

current = current->getOverlay();

}

// apply the overlay files to the base set

if (!applyFileOverlay(bundle, assets, &drawables, "drawable") ||

!applyFileOverlay(bundle, assets, &layouts, "layout") ||

!applyFileOverlay(bundle, assets, &anims, "anim") ||

!applyFileOverlay(bundle, assets, &animators, "animator") ||

!applyFileOverlay(bundle, assets, &interpolators, "interpolator") ||

!applyFileOverlay(bundle, assets, &xmls, "xml") ||

!applyFileOverlay(bundle, assets, &raws, "raw") ||

!applyFileOverlay(bundle, assets, &colors, "color") ||

!applyFileOverlay(bundle, assets, &menus, "menu") ||

!applyFileOverlay(bundle, assets, &mipmaps, "mipmap")) {

return UNKNOWN_ERROR;

}

bool hasErrors = false;

if (drawables != NULL) {

if (bundle->getOutputAPKFile() != NULL) {

err = preProcessImages(bundle, assets, drawables, "drawable");

}

if (err == NO_ERROR) {

err = makeFileResources(bundle, assets, &table, drawables, "drawable");

if (err != NO_ERROR) {

hasErrors = true;

}

} else {

hasErrors = true;

}

}

if (mipmaps != NULL) {

if (bundle->getOutputAPKFile() != NULL) {

err = preProcessImages(bundle, assets, mipmaps, "mipmap");

}

if (err == NO_ERROR) {

err = makeFileResources(bundle, assets, &table, mipmaps, "mipmap");

if (err != NO_ERROR) {

hasErrors = true;

}