{

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)

{

memset(&mParams, 0, sizeof(ResTable_config));

}

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();

if (kIsDebug) {

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;

}

if (kIsDebug) {

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;

AnnotationProcessor() : mDeprecated(false), mSystemApi(false) { }

void preprocessComment(String8& comment) {

if (comment.size() > 0) {

if (comment.contains("@deprecated")) {

mDeprecated = true;

}

if (comment.removeAll("@SystemApi")) {

mSystemApi = true;

}

}

}

void printAnnotations(FILE* fp, const char* indentStr) {

if (mDeprecated) {

fprintf(fp, "%s@Deprecated\n", indentStr);

}

if (mSystemApi) {

fprintf(fp, "%s@android.annotation.SystemApi\n", indentStr);

}

}

bool mDeprecated;

bool mSystemApi;

{

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

|| type == "transition" || type == "font"

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

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

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

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)));

ssize_t revisionCodeIndex = block.indexOfAttribute(RESOURCES_ANDROID_NAMESPACE, "revisionCode");

if (revisionCodeIndex >= 0) {

bundle->setRevisionCode(String8(block.getAttributeStringValue(revisionCodeIndex, &len)).string());

}

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 char16_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();

status_t result = table->addEntry(SourcePos(it.getPath(), 0),

String16(assets->getPackage()),

type16,

baseName,

String16(resPath),

NULL,

&it.getParams());

if (result != NO_ERROR) {

hasErrors = true;

} else {

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

}

}

return hasErrors ? STATUST(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)) ? STATUST(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++) {

const 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();

if (kIsDebug) {

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 {

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

index = set->indexOfKey(leafName);

if (index < 0) {

if (kIsDebug) {

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);

if (kIsDebug) {

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++) {

if (kIsDebug) {

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

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

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

resType.string());

}

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++) {

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

if (kIsDebug) {

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

if (kIsDebug) {

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 char16_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++) {

char16_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 (len != 0 && 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) {

const 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());

}

ssize_t baseIndex = -1;

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

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

}

if (baseIndex >= 0) {

// 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++) {

ssize_t baseFileIndex =

baseGroup->getFiles().indexOfKey(overlayFiles.

keyAt(overlayGroupIndex));

if (baseFileIndex >= 0) {

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,

bool replaceExisting)

{

if (value == NULL) {

return true;

}

const String16 ns(ns8);

const String16 attr(attr8);

XMLNode::attribute_entry* existingEntry = node->editAttribute(ns, attr);

if (existingEntry != NULL) {

if (replaceExisting) {

existingEntry->string = String16(value);

return true;

}

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;

}

// don't stop the build.

return true;

}

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

return true;

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

{

return addTagAttribute(node, ns8, attr8, value, errorOnFailedInsert, false);

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;

}

if (kIsDebug) {

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

}

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

}

const String16& nameStr, ResourceTable* table) {

sp<ResourceTable::Package> pkg = table->getPackage(packageStr);

if (pkg != NULL) {

sp<ResourceTable::Type> type = pkg->getTypes().valueFor(typeStr);

if (type != NULL) {

return type->getConfigs().valueFor(nameStr);

}

}

return NULL;

const DefaultKeyedVector<ConfigDescription, sp<ResourceTable::Entry>>& entries =

configList->getEntries();

uint16_t maxSdkVersion = 0u;

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

maxSdkVersion = std::max(maxSdkVersion, entries.keyAt(i).sdkVersion);

}

return maxSdkVersion;

ResourceTable* table) {

bool publicOnly = false;

const char* err;

String16 iconPackage, iconType, iconName;

if (!ResTable::expandResourceRef(iconRef.string(), iconRef.size(), &iconPackage, &iconType,

&iconName, NULL, &table->getAssetsPackage(), &err,

&publicOnly)) {

// Errors will be raised in later XML compilation.

return;

}

sp<ResourceTable::ConfigList> iconEntry = findEntry(iconPackage, iconType, iconName, table);

if (iconEntry == NULL || getMaxSdkVersion(iconEntry) < SDK_O) {

// The icon is not adaptive, so nothing to massage.

return;

}

String16 roundIconPackage, roundIconType, roundIconName;

if (!ResTable::expandResourceRef(roundIconRef.string(), roundIconRef.size(), &roundIconPackage,

&roundIconType, &roundIconName, NULL, &table->getAssetsPackage(),

&err, &publicOnly)) {

// Errors will be raised in later XML compilation.

return;

}

sp<ResourceTable::ConfigList> roundIconEntry = findEntry(roundIconPackage, roundIconType,

roundIconName, table);

if (roundIconEntry == NULL || getMaxSdkVersion(roundIconEntry) >= SDK_O) {

// The developer explicitly used a v26 compatible drawable as the roundIcon, meaning we should

// not generate an alias to the icon drawable.

return;

}

String16 aliasValue = String16(String8::format("@%s:%s/%s", String8(iconPackage).string(),

String8(iconType).string(),

String8(iconName).string()));

// Add an equivalent v26 entry to the roundIcon for each v26 variant of the regular icon.

const DefaultKeyedVector<ConfigDescription, sp<ResourceTable::Entry>>& configList =

iconEntry->getEntries();

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

if (configList.keyAt(i).sdkVersion >= SDK_O) {

table->addEntry(SourcePos(), roundIconPackage, roundIconType, roundIconName, aliasValue,

NULL, &configList.keyAt(i));

}

}

{

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

if (root == NULL) {

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

return UNKNOWN_ERROR;

}

bool errorOnFailedInsert = bundle->getErrorOnFailedInsert();

bool replaceVersion = bundle->getReplaceVersion();

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

bundle->getVersionCode(), errorOnFailedInsert, replaceVersion)) {

return UNKNOWN_ERROR;

} else {

const XMLNode::attribute_entry* attr = root->getAttribute(

String16(RESOURCES_ANDROID_NAMESPACE), String16("versionCode"));

if (attr != NULL) {

bundle->setVersionCode(strdup(String8(attr->string).string()));

}

}

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

bundle->getVersionName(), errorOnFailedInsert, replaceVersion)) {

return UNKNOWN_ERROR;

} else {

const XMLNode::attribute_entry* attr = root->getAttribute(

String16(RESOURCES_ANDROID_NAMESPACE), String16("versionName"));

if (attr != NULL) {

bundle->setVersionName(strdup(String8(attr->string).string()));

}

}

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

if (bundle->getMinSdkVersion() != NULL

|| bundle->getTargetSdkVersion() != NULL

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

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 (vers != NULL) {

const XMLNode::attribute_entry* attr = vers->getAttribute(

String16(RESOURCES_ANDROID_NAMESPACE), String16("minSdkVersion"));

if (attr != NULL) {

bundle->setMinSdkVersion(strdup(String8(attr->string).string()));

}

}

if (bundle->getCompileSdkVersion() != 0) {

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

String8::format("%d", bundle->getCompileSdkVersion()),

errorOnFailedInsert, true)) {

return UNKNOWN_ERROR;

}

}

if (bundle->getCompileSdkVersionCodename() != "") {

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

bundle->getCompileSdkVersionCodename(), errorOnFailedInsert, true)) {

return UNKNOWN_ERROR;

}

}

if (bundle->getPlatformBuildVersionCode() != "") {

if (!addTagAttribute(root, "", "platformBuildVersionCode",

bundle->getPlatformBuildVersionCode(), errorOnFailedInsert, true)) {

return UNKNOWN_ERROR;

}

}

if (bundle->getPlatformBuildVersionName() != "") {

if (!addTagAttribute(root, "", "platformBuildVersionName",

bundle->getPlatformBuildVersionName(), errorOnFailedInsert, true)) {

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));

if (kIsDebug) {

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.