Resource.cpp revision 526d73be4a3a2714fa6112769e16fb6cd0194451
1// 2// Copyright 2006 The Android Open Source Project 3// 4// Build resource files from raw assets. 5// 6#include "AaptAssets.h" 7#include "AaptUtil.h" 8#include "AaptXml.h" 9#include "CacheUpdater.h" 10#include "CrunchCache.h" 11#include "FileFinder.h" 12#include "Images.h" 13#include "IndentPrinter.h" 14#include "Main.h" 15#include "ResourceTable.h" 16#include "StringPool.h" 17#include "Symbol.h" 18#include "WorkQueue.h" 19#include "XMLNode.h" 20 21#include <algorithm> 22 23// STATUST: mingw does seem to redefine UNKNOWN_ERROR from our enum value, so a cast is necessary. 24 25#if !defined(_WIN32) 26# define ZD "%zd" 27# define ZD_TYPE ssize_t 28# define STATUST(x) x 29#else 30# define ZD "%ld" 31# define ZD_TYPE long 32# define STATUST(x) (status_t)x 33#endif 34 35// Set to true for noisy debug output. 36static const bool kIsDebug = false; 37 38// Number of threads to use for preprocessing images. 39static const size_t MAX_THREADS = 4; 40 41// ========================================================================== 42// ========================================================================== 43// ========================================================================== 44 45class PackageInfo 46{ 47public: 48 PackageInfo() 49 { 50 } 51 ~PackageInfo() 52 { 53 } 54 55 status_t parsePackage(const sp<AaptGroup>& grp); 56}; 57 58// ========================================================================== 59// ========================================================================== 60// ========================================================================== 61 62String8 parseResourceName(const String8& leaf) 63{ 64 const char* firstDot = strchr(leaf.string(), '.'); 65 const char* str = leaf.string(); 66 67 if (firstDot) { 68 return String8(str, firstDot-str); 69 } else { 70 return String8(str); 71 } 72} 73 74ResourceTypeSet::ResourceTypeSet() 75 :RefBase(), 76 KeyedVector<String8,sp<AaptGroup> >() 77{ 78} 79 80FilePathStore::FilePathStore() 81 :RefBase(), 82 Vector<String8>() 83{ 84} 85 86class ResourceDirIterator 87{ 88public: 89 ResourceDirIterator(const sp<ResourceTypeSet>& set, const String8& resType) 90 : mResType(resType), mSet(set), mSetPos(0), mGroupPos(0) 91 { 92 memset(&mParams, 0, sizeof(ResTable_config)); 93 } 94 95 inline const sp<AaptGroup>& getGroup() const { return mGroup; } 96 inline const sp<AaptFile>& getFile() const { return mFile; } 97 98 inline const String8& getBaseName() const { return mBaseName; } 99 inline const String8& getLeafName() const { return mLeafName; } 100 inline String8 getPath() const { return mPath; } 101 inline const ResTable_config& getParams() const { return mParams; } 102 103 enum { 104 EOD = 1 105 }; 106 107 ssize_t next() 108 { 109 while (true) { 110 sp<AaptGroup> group; 111 sp<AaptFile> file; 112 113 // Try to get next file in this current group. 114 if (mGroup != NULL && mGroupPos < mGroup->getFiles().size()) { 115 group = mGroup; 116 file = group->getFiles().valueAt(mGroupPos++); 117 118 // Try to get the next group/file in this directory 119 } else if (mSetPos < mSet->size()) { 120 mGroup = group = mSet->valueAt(mSetPos++); 121 if (group->getFiles().size() < 1) { 122 continue; 123 } 124 file = group->getFiles().valueAt(0); 125 mGroupPos = 1; 126 127 // All done! 128 } else { 129 return EOD; 130 } 131 132 mFile = file; 133 134 String8 leaf(group->getLeaf()); 135 mLeafName = String8(leaf); 136 mParams = file->getGroupEntry().toParams(); 137 if (kIsDebug) { 138 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", 139 group->getPath().string(), mParams.mcc, mParams.mnc, 140 mParams.language[0] ? mParams.language[0] : '-', 141 mParams.language[1] ? mParams.language[1] : '-', 142 mParams.country[0] ? mParams.country[0] : '-', 143 mParams.country[1] ? mParams.country[1] : '-', 144 mParams.orientation, mParams.uiMode, 145 mParams.density, mParams.touchscreen, mParams.keyboard, 146 mParams.inputFlags, mParams.navigation); 147 } 148 mPath = "res"; 149 mPath.appendPath(file->getGroupEntry().toDirName(mResType)); 150 mPath.appendPath(leaf); 151 mBaseName = parseResourceName(leaf); 152 if (mBaseName == "") { 153 fprintf(stderr, "Error: malformed resource filename %s\n", 154 file->getPrintableSource().string()); 155 return UNKNOWN_ERROR; 156 } 157 158 if (kIsDebug) { 159 printf("file name=%s\n", mBaseName.string()); 160 } 161 162 return NO_ERROR; 163 } 164 } 165 166private: 167 String8 mResType; 168 169 const sp<ResourceTypeSet> mSet; 170 size_t mSetPos; 171 172 sp<AaptGroup> mGroup; 173 size_t mGroupPos; 174 175 sp<AaptFile> mFile; 176 String8 mBaseName; 177 String8 mLeafName; 178 String8 mPath; 179 ResTable_config mParams; 180}; 181 182class AnnotationProcessor { 183public: 184 AnnotationProcessor() : mDeprecated(false), mSystemApi(false) { } 185 186 void preprocessComment(String8& comment) { 187 if (comment.size() > 0) { 188 if (comment.contains("@deprecated")) { 189 mDeprecated = true; 190 } 191 if (comment.removeAll("@SystemApi")) { 192 mSystemApi = true; 193 } 194 } 195 } 196 197 void printAnnotations(FILE* fp, const char* indentStr) { 198 if (mDeprecated) { 199 fprintf(fp, "%s@Deprecated\n", indentStr); 200 } 201 if (mSystemApi) { 202 fprintf(fp, "%s@android.annotation.SystemApi\n", indentStr); 203 } 204 } 205 206private: 207 bool mDeprecated; 208 bool mSystemApi; 209}; 210 211// ========================================================================== 212// ========================================================================== 213// ========================================================================== 214 215bool isValidResourceType(const String8& type) 216{ 217 return type == "anim" || type == "animator" || type == "interpolator" 218 || type == "transition" 219 || type == "drawable" || type == "layout" 220 || type == "values" || type == "xml" || type == "raw" 221 || type == "color" || type == "menu" || type == "mipmap"; 222} 223 224static status_t parsePackage(Bundle* bundle, const sp<AaptAssets>& assets, 225 const sp<AaptGroup>& grp) 226{ 227 if (grp->getFiles().size() != 1) { 228 fprintf(stderr, "warning: Multiple AndroidManifest.xml files found, using %s\n", 229 grp->getFiles().valueAt(0)->getPrintableSource().string()); 230 } 231 232 sp<AaptFile> file = grp->getFiles().valueAt(0); 233 234 ResXMLTree block; 235 status_t err = parseXMLResource(file, &block); 236 if (err != NO_ERROR) { 237 return err; 238 } 239 //printXMLBlock(&block); 240 241 ResXMLTree::event_code_t code; 242 while ((code=block.next()) != ResXMLTree::START_TAG 243 && code != ResXMLTree::END_DOCUMENT 244 && code != ResXMLTree::BAD_DOCUMENT) { 245 } 246 247 size_t len; 248 if (code != ResXMLTree::START_TAG) { 249 fprintf(stderr, "%s:%d: No start tag found\n", 250 file->getPrintableSource().string(), block.getLineNumber()); 251 return UNKNOWN_ERROR; 252 } 253 if (strcmp16(block.getElementName(&len), String16("manifest").string()) != 0) { 254 fprintf(stderr, "%s:%d: Invalid start tag %s, expected <manifest>\n", 255 file->getPrintableSource().string(), block.getLineNumber(), 256 String8(block.getElementName(&len)).string()); 257 return UNKNOWN_ERROR; 258 } 259 260 ssize_t nameIndex = block.indexOfAttribute(NULL, "package"); 261 if (nameIndex < 0) { 262 fprintf(stderr, "%s:%d: <manifest> does not have package attribute.\n", 263 file->getPrintableSource().string(), block.getLineNumber()); 264 return UNKNOWN_ERROR; 265 } 266 267 assets->setPackage(String8(block.getAttributeStringValue(nameIndex, &len))); 268 269 ssize_t revisionCodeIndex = block.indexOfAttribute(RESOURCES_ANDROID_NAMESPACE, "revisionCode"); 270 if (revisionCodeIndex >= 0) { 271 bundle->setRevisionCode(String8(block.getAttributeStringValue(revisionCodeIndex, &len)).string()); 272 } 273 274 String16 uses_sdk16("uses-sdk"); 275 while ((code=block.next()) != ResXMLTree::END_DOCUMENT 276 && code != ResXMLTree::BAD_DOCUMENT) { 277 if (code == ResXMLTree::START_TAG) { 278 if (strcmp16(block.getElementName(&len), uses_sdk16.string()) == 0) { 279 ssize_t minSdkIndex = block.indexOfAttribute(RESOURCES_ANDROID_NAMESPACE, 280 "minSdkVersion"); 281 if (minSdkIndex >= 0) { 282 const char16_t* minSdk16 = block.getAttributeStringValue(minSdkIndex, &len); 283 const char* minSdk8 = strdup(String8(minSdk16).string()); 284 bundle->setManifestMinSdkVersion(minSdk8); 285 } 286 } 287 } 288 } 289 290 return NO_ERROR; 291} 292 293// ========================================================================== 294// ========================================================================== 295// ========================================================================== 296 297static status_t makeFileResources(Bundle* bundle, const sp<AaptAssets>& assets, 298 ResourceTable* table, 299 const sp<ResourceTypeSet>& set, 300 const char* resType) 301{ 302 String8 type8(resType); 303 String16 type16(resType); 304 305 bool hasErrors = false; 306 307 ResourceDirIterator it(set, String8(resType)); 308 ssize_t res; 309 while ((res=it.next()) == NO_ERROR) { 310 if (bundle->getVerbose()) { 311 printf(" (new resource id %s from %s)\n", 312 it.getBaseName().string(), it.getFile()->getPrintableSource().string()); 313 } 314 String16 baseName(it.getBaseName()); 315 const char16_t* str = baseName.string(); 316 const char16_t* const end = str + baseName.size(); 317 while (str < end) { 318 if (!((*str >= 'a' && *str <= 'z') 319 || (*str >= '0' && *str <= '9') 320 || *str == '_' || *str == '.')) { 321 fprintf(stderr, "%s: Invalid file name: must contain only [a-z0-9_.]\n", 322 it.getPath().string()); 323 hasErrors = true; 324 } 325 str++; 326 } 327 String8 resPath = it.getPath(); 328 resPath.convertToResPath(); 329 status_t result = table->addEntry(SourcePos(it.getPath(), 0), 330 String16(assets->getPackage()), 331 type16, 332 baseName, 333 String16(resPath), 334 NULL, 335 &it.getParams()); 336 if (result != NO_ERROR) { 337 hasErrors = true; 338 } else { 339 assets->addResource(it.getLeafName(), resPath, it.getFile(), type8); 340 } 341 } 342 343 return hasErrors ? STATUST(UNKNOWN_ERROR) : NO_ERROR; 344} 345 346class PreProcessImageWorkUnit : public WorkQueue::WorkUnit { 347public: 348 PreProcessImageWorkUnit(const Bundle* bundle, const sp<AaptAssets>& assets, 349 const sp<AaptFile>& file, volatile bool* hasErrors) : 350 mBundle(bundle), mAssets(assets), mFile(file), mHasErrors(hasErrors) { 351 } 352 353 virtual bool run() { 354 status_t status = preProcessImage(mBundle, mAssets, mFile, NULL); 355 if (status) { 356 *mHasErrors = true; 357 } 358 return true; // continue even if there are errors 359 } 360 361private: 362 const Bundle* mBundle; 363 sp<AaptAssets> mAssets; 364 sp<AaptFile> mFile; 365 volatile bool* mHasErrors; 366}; 367 368static status_t preProcessImages(const Bundle* bundle, const sp<AaptAssets>& assets, 369 const sp<ResourceTypeSet>& set, const char* type) 370{ 371 volatile bool hasErrors = false; 372 ssize_t res = NO_ERROR; 373 if (bundle->getUseCrunchCache() == false) { 374 WorkQueue wq(MAX_THREADS, false); 375 ResourceDirIterator it(set, String8(type)); 376 while ((res=it.next()) == NO_ERROR) { 377 PreProcessImageWorkUnit* w = new PreProcessImageWorkUnit( 378 bundle, assets, it.getFile(), &hasErrors); 379 status_t status = wq.schedule(w); 380 if (status) { 381 fprintf(stderr, "preProcessImages failed: schedule() returned %d\n", status); 382 hasErrors = true; 383 delete w; 384 break; 385 } 386 } 387 status_t status = wq.finish(); 388 if (status) { 389 fprintf(stderr, "preProcessImages failed: finish() returned %d\n", status); 390 hasErrors = true; 391 } 392 } 393 return (hasErrors || (res < NO_ERROR)) ? STATUST(UNKNOWN_ERROR) : NO_ERROR; 394} 395 396static void collect_files(const sp<AaptDir>& dir, 397 KeyedVector<String8, sp<ResourceTypeSet> >* resources) 398{ 399 const DefaultKeyedVector<String8, sp<AaptGroup> >& groups = dir->getFiles(); 400 int N = groups.size(); 401 for (int i=0; i<N; i++) { 402 String8 leafName = groups.keyAt(i); 403 const sp<AaptGroup>& group = groups.valueAt(i); 404 405 const DefaultKeyedVector<AaptGroupEntry, sp<AaptFile> >& files 406 = group->getFiles(); 407 408 if (files.size() == 0) { 409 continue; 410 } 411 412 String8 resType = files.valueAt(0)->getResourceType(); 413 414 ssize_t index = resources->indexOfKey(resType); 415 416 if (index < 0) { 417 sp<ResourceTypeSet> set = new ResourceTypeSet(); 418 if (kIsDebug) { 419 printf("Creating new resource type set for leaf %s with group %s (%p)\n", 420 leafName.string(), group->getPath().string(), group.get()); 421 } 422 set->add(leafName, group); 423 resources->add(resType, set); 424 } else { 425 sp<ResourceTypeSet> set = resources->valueAt(index); 426 index = set->indexOfKey(leafName); 427 if (index < 0) { 428 if (kIsDebug) { 429 printf("Adding to resource type set for leaf %s group %s (%p)\n", 430 leafName.string(), group->getPath().string(), group.get()); 431 } 432 set->add(leafName, group); 433 } else { 434 sp<AaptGroup> existingGroup = set->valueAt(index); 435 if (kIsDebug) { 436 printf("Extending to resource type set for leaf %s group %s (%p)\n", 437 leafName.string(), group->getPath().string(), group.get()); 438 } 439 for (size_t j=0; j<files.size(); j++) { 440 if (kIsDebug) { 441 printf("Adding file %s in group %s resType %s\n", 442 files.valueAt(j)->getSourceFile().string(), 443 files.keyAt(j).toDirName(String8()).string(), 444 resType.string()); 445 } 446 existingGroup->addFile(files.valueAt(j)); 447 } 448 } 449 } 450 } 451} 452 453static void collect_files(const sp<AaptAssets>& ass, 454 KeyedVector<String8, sp<ResourceTypeSet> >* resources) 455{ 456 const Vector<sp<AaptDir> >& dirs = ass->resDirs(); 457 int N = dirs.size(); 458 459 for (int i=0; i<N; i++) { 460 sp<AaptDir> d = dirs.itemAt(i); 461 if (kIsDebug) { 462 printf("Collecting dir #%d %p: %s, leaf %s\n", i, d.get(), d->getPath().string(), 463 d->getLeaf().string()); 464 } 465 collect_files(d, resources); 466 467 // don't try to include the res dir 468 if (kIsDebug) { 469 printf("Removing dir leaf %s\n", d->getLeaf().string()); 470 } 471 ass->removeDir(d->getLeaf()); 472 } 473} 474 475enum { 476 ATTR_OKAY = -1, 477 ATTR_NOT_FOUND = -2, 478 ATTR_LEADING_SPACES = -3, 479 ATTR_TRAILING_SPACES = -4 480}; 481static int validateAttr(const String8& path, const ResTable& table, 482 const ResXMLParser& parser, 483 const char* ns, const char* attr, const char* validChars, bool required) 484{ 485 size_t len; 486 487 ssize_t index = parser.indexOfAttribute(ns, attr); 488 const char16_t* str; 489 Res_value value; 490 if (index >= 0 && parser.getAttributeValue(index, &value) >= 0) { 491 const ResStringPool* pool = &parser.getStrings(); 492 if (value.dataType == Res_value::TYPE_REFERENCE) { 493 uint32_t specFlags = 0; 494 int strIdx; 495 if ((strIdx=table.resolveReference(&value, 0x10000000, NULL, &specFlags)) < 0) { 496 fprintf(stderr, "%s:%d: Tag <%s> attribute %s references unknown resid 0x%08x.\n", 497 path.string(), parser.getLineNumber(), 498 String8(parser.getElementName(&len)).string(), attr, 499 value.data); 500 return ATTR_NOT_FOUND; 501 } 502 503 pool = table.getTableStringBlock(strIdx); 504 #if 0 505 if (pool != NULL) { 506 str = pool->stringAt(value.data, &len); 507 } 508 printf("***** RES ATTR: %s specFlags=0x%x strIdx=%d: %s\n", attr, 509 specFlags, strIdx, str != NULL ? String8(str).string() : "???"); 510 #endif 511 if ((specFlags&~ResTable_typeSpec::SPEC_PUBLIC) != 0 && false) { 512 fprintf(stderr, "%s:%d: Tag <%s> attribute %s varies by configurations 0x%x.\n", 513 path.string(), parser.getLineNumber(), 514 String8(parser.getElementName(&len)).string(), attr, 515 specFlags); 516 return ATTR_NOT_FOUND; 517 } 518 } 519 if (value.dataType == Res_value::TYPE_STRING) { 520 if (pool == NULL) { 521 fprintf(stderr, "%s:%d: Tag <%s> attribute %s has no string block.\n", 522 path.string(), parser.getLineNumber(), 523 String8(parser.getElementName(&len)).string(), attr); 524 return ATTR_NOT_FOUND; 525 } 526 if ((str=pool->stringAt(value.data, &len)) == NULL) { 527 fprintf(stderr, "%s:%d: Tag <%s> attribute %s has corrupt string value.\n", 528 path.string(), parser.getLineNumber(), 529 String8(parser.getElementName(&len)).string(), attr); 530 return ATTR_NOT_FOUND; 531 } 532 } else { 533 fprintf(stderr, "%s:%d: Tag <%s> attribute %s has invalid type %d.\n", 534 path.string(), parser.getLineNumber(), 535 String8(parser.getElementName(&len)).string(), attr, 536 value.dataType); 537 return ATTR_NOT_FOUND; 538 } 539 if (validChars) { 540 for (size_t i=0; i<len; i++) { 541 char16_t c = str[i]; 542 const char* p = validChars; 543 bool okay = false; 544 while (*p) { 545 if (c == *p) { 546 okay = true; 547 break; 548 } 549 p++; 550 } 551 if (!okay) { 552 fprintf(stderr, "%s:%d: Tag <%s> attribute %s has invalid character '%c'.\n", 553 path.string(), parser.getLineNumber(), 554 String8(parser.getElementName(&len)).string(), attr, (char)str[i]); 555 return (int)i; 556 } 557 } 558 } 559 if (*str == ' ') { 560 fprintf(stderr, "%s:%d: Tag <%s> attribute %s can not start with a space.\n", 561 path.string(), parser.getLineNumber(), 562 String8(parser.getElementName(&len)).string(), attr); 563 return ATTR_LEADING_SPACES; 564 } 565 if (len != 0 && str[len-1] == ' ') { 566 fprintf(stderr, "%s:%d: Tag <%s> attribute %s can not end with a space.\n", 567 path.string(), parser.getLineNumber(), 568 String8(parser.getElementName(&len)).string(), attr); 569 return ATTR_TRAILING_SPACES; 570 } 571 return ATTR_OKAY; 572 } 573 if (required) { 574 fprintf(stderr, "%s:%d: Tag <%s> missing required attribute %s.\n", 575 path.string(), parser.getLineNumber(), 576 String8(parser.getElementName(&len)).string(), attr); 577 return ATTR_NOT_FOUND; 578 } 579 return ATTR_OKAY; 580} 581 582static void checkForIds(const String8& path, ResXMLParser& parser) 583{ 584 ResXMLTree::event_code_t code; 585 while ((code=parser.next()) != ResXMLTree::END_DOCUMENT 586 && code > ResXMLTree::BAD_DOCUMENT) { 587 if (code == ResXMLTree::START_TAG) { 588 ssize_t index = parser.indexOfAttribute(NULL, "id"); 589 if (index >= 0) { 590 fprintf(stderr, "%s:%d: warning: found plain 'id' attribute; did you mean the new 'android:id' name?\n", 591 path.string(), parser.getLineNumber()); 592 } 593 } 594 } 595} 596 597static bool applyFileOverlay(Bundle *bundle, 598 const sp<AaptAssets>& assets, 599 sp<ResourceTypeSet> *baseSet, 600 const char *resType) 601{ 602 if (bundle->getVerbose()) { 603 printf("applyFileOverlay for %s\n", resType); 604 } 605 606 // Replace any base level files in this category with any found from the overlay 607 // Also add any found only in the overlay. 608 sp<AaptAssets> overlay = assets->getOverlay(); 609 String8 resTypeString(resType); 610 611 // work through the linked list of overlays 612 while (overlay.get()) { 613 KeyedVector<String8, sp<ResourceTypeSet> >* overlayRes = overlay->getResources(); 614 615 // get the overlay resources of the requested type 616 ssize_t index = overlayRes->indexOfKey(resTypeString); 617 if (index >= 0) { 618 sp<ResourceTypeSet> overlaySet = overlayRes->valueAt(index); 619 620 // for each of the resources, check for a match in the previously built 621 // non-overlay "baseset". 622 size_t overlayCount = overlaySet->size(); 623 for (size_t overlayIndex=0; overlayIndex<overlayCount; overlayIndex++) { 624 if (bundle->getVerbose()) { 625 printf("trying overlaySet Key=%s\n",overlaySet->keyAt(overlayIndex).string()); 626 } 627 ssize_t baseIndex = -1; 628 if (baseSet->get() != NULL) { 629 baseIndex = (*baseSet)->indexOfKey(overlaySet->keyAt(overlayIndex)); 630 } 631 if (baseIndex >= 0) { 632 // look for same flavor. For a given file (strings.xml, for example) 633 // there may be a locale specific or other flavors - we want to match 634 // the same flavor. 635 sp<AaptGroup> overlayGroup = overlaySet->valueAt(overlayIndex); 636 sp<AaptGroup> baseGroup = (*baseSet)->valueAt(baseIndex); 637 638 DefaultKeyedVector<AaptGroupEntry, sp<AaptFile> > overlayFiles = 639 overlayGroup->getFiles(); 640 if (bundle->getVerbose()) { 641 DefaultKeyedVector<AaptGroupEntry, sp<AaptFile> > baseFiles = 642 baseGroup->getFiles(); 643 for (size_t i=0; i < baseFiles.size(); i++) { 644 printf("baseFile " ZD " has flavor %s\n", (ZD_TYPE) i, 645 baseFiles.keyAt(i).toString().string()); 646 } 647 for (size_t i=0; i < overlayFiles.size(); i++) { 648 printf("overlayFile " ZD " has flavor %s\n", (ZD_TYPE) i, 649 overlayFiles.keyAt(i).toString().string()); 650 } 651 } 652 653 size_t overlayGroupSize = overlayFiles.size(); 654 for (size_t overlayGroupIndex = 0; 655 overlayGroupIndex<overlayGroupSize; 656 overlayGroupIndex++) { 657 ssize_t baseFileIndex = 658 baseGroup->getFiles().indexOfKey(overlayFiles. 659 keyAt(overlayGroupIndex)); 660 if (baseFileIndex >= 0) { 661 if (bundle->getVerbose()) { 662 printf("found a match (" ZD ") for overlay file %s, for flavor %s\n", 663 (ZD_TYPE) baseFileIndex, 664 overlayGroup->getLeaf().string(), 665 overlayFiles.keyAt(overlayGroupIndex).toString().string()); 666 } 667 baseGroup->removeFile(baseFileIndex); 668 } else { 669 // didn't find a match fall through and add it.. 670 if (true || bundle->getVerbose()) { 671 printf("nothing matches overlay file %s, for flavor %s\n", 672 overlayGroup->getLeaf().string(), 673 overlayFiles.keyAt(overlayGroupIndex).toString().string()); 674 } 675 } 676 baseGroup->addFile(overlayFiles.valueAt(overlayGroupIndex)); 677 assets->addGroupEntry(overlayFiles.keyAt(overlayGroupIndex)); 678 } 679 } else { 680 if (baseSet->get() == NULL) { 681 *baseSet = new ResourceTypeSet(); 682 assets->getResources()->add(String8(resType), *baseSet); 683 } 684 // this group doesn't exist (a file that's only in the overlay) 685 (*baseSet)->add(overlaySet->keyAt(overlayIndex), 686 overlaySet->valueAt(overlayIndex)); 687 // make sure all flavors are defined in the resources. 688 sp<AaptGroup> overlayGroup = overlaySet->valueAt(overlayIndex); 689 DefaultKeyedVector<AaptGroupEntry, sp<AaptFile> > overlayFiles = 690 overlayGroup->getFiles(); 691 size_t overlayGroupSize = overlayFiles.size(); 692 for (size_t overlayGroupIndex = 0; 693 overlayGroupIndex<overlayGroupSize; 694 overlayGroupIndex++) { 695 assets->addGroupEntry(overlayFiles.keyAt(overlayGroupIndex)); 696 } 697 } 698 } 699 // this overlay didn't have resources for this type 700 } 701 // try next overlay 702 overlay = overlay->getOverlay(); 703 } 704 return true; 705} 706 707/* 708 * Inserts an attribute in a given node. 709 * If errorOnFailedInsert is true, and the attribute already exists, returns false. 710 * If replaceExisting is true, the attribute will be updated if it already exists. 711 * Returns true otherwise, even if the attribute already exists, and does not modify 712 * the existing attribute's value. 713 */ 714bool addTagAttribute(const sp<XMLNode>& node, const char* ns8, 715 const char* attr8, const char* value, bool errorOnFailedInsert, 716 bool replaceExisting) 717{ 718 if (value == NULL) { 719 return true; 720 } 721 722 const String16 ns(ns8); 723 const String16 attr(attr8); 724 725 XMLNode::attribute_entry* existingEntry = node->editAttribute(ns, attr); 726 if (existingEntry != NULL) { 727 if (replaceExisting) { 728 if (kIsDebug) { 729 printf("Info: AndroidManifest.xml already defines %s (in %s);" 730 " overwriting existing value from manifest.\n", 731 String8(attr).string(), String8(ns).string()); 732 } 733 existingEntry->string = String16(value); 734 return true; 735 } 736 737 if (errorOnFailedInsert) { 738 fprintf(stderr, "Error: AndroidManifest.xml already defines %s (in %s);" 739 " cannot insert new value %s.\n", 740 String8(attr).string(), String8(ns).string(), value); 741 return false; 742 } 743 744 fprintf(stderr, "Warning: AndroidManifest.xml already defines %s (in %s);" 745 " using existing value in manifest.\n", 746 String8(attr).string(), String8(ns).string()); 747 748 // don't stop the build. 749 return true; 750 } 751 752 node->addAttribute(ns, attr, String16(value)); 753 return true; 754} 755 756/* 757 * Inserts an attribute in a given node, only if the attribute does not 758 * exist. 759 * If errorOnFailedInsert is true, and the attribute already exists, returns false. 760 * Returns true otherwise, even if the attribute already exists. 761 */ 762bool addTagAttribute(const sp<XMLNode>& node, const char* ns8, 763 const char* attr8, const char* value, bool errorOnFailedInsert) 764{ 765 return addTagAttribute(node, ns8, attr8, value, errorOnFailedInsert, false); 766} 767 768static void fullyQualifyClassName(const String8& package, sp<XMLNode> node, 769 const String16& attrName) { 770 XMLNode::attribute_entry* attr = node->editAttribute( 771 String16("http://schemas.android.com/apk/res/android"), attrName); 772 if (attr != NULL) { 773 String8 name(attr->string); 774 775 // asdf --> package.asdf 776 // .asdf .a.b --> package.asdf package.a.b 777 // asdf.adsf --> asdf.asdf 778 String8 className; 779 const char* p = name.string(); 780 const char* q = strchr(p, '.'); 781 if (p == q) { 782 className += package; 783 className += name; 784 } else if (q == NULL) { 785 className += package; 786 className += "."; 787 className += name; 788 } else { 789 className += name; 790 } 791 if (kIsDebug) { 792 printf("Qualifying class '%s' to '%s'", name.string(), className.string()); 793 } 794 attr->string.setTo(String16(className)); 795 } 796} 797 798status_t massageManifest(Bundle* bundle, sp<XMLNode> root) 799{ 800 root = root->searchElement(String16(), String16("manifest")); 801 if (root == NULL) { 802 fprintf(stderr, "No <manifest> tag.\n"); 803 return UNKNOWN_ERROR; 804 } 805 806 bool errorOnFailedInsert = bundle->getErrorOnFailedInsert(); 807 bool replaceVersion = bundle->getReplaceVersion(); 808 809 if (!addTagAttribute(root, RESOURCES_ANDROID_NAMESPACE, "versionCode", 810 bundle->getVersionCode(), errorOnFailedInsert, replaceVersion)) { 811 return UNKNOWN_ERROR; 812 } else { 813 const XMLNode::attribute_entry* attr = root->getAttribute( 814 String16(RESOURCES_ANDROID_NAMESPACE), String16("versionCode")); 815 if (attr != NULL) { 816 bundle->setVersionCode(strdup(String8(attr->string).string())); 817 } 818 } 819 820 if (!addTagAttribute(root, RESOURCES_ANDROID_NAMESPACE, "versionName", 821 bundle->getVersionName(), errorOnFailedInsert, replaceVersion)) { 822 return UNKNOWN_ERROR; 823 } else { 824 const XMLNode::attribute_entry* attr = root->getAttribute( 825 String16(RESOURCES_ANDROID_NAMESPACE), String16("versionName")); 826 if (attr != NULL) { 827 bundle->setVersionName(strdup(String8(attr->string).string())); 828 } 829 } 830 831 sp<XMLNode> vers = root->getChildElement(String16(), String16("uses-sdk")); 832 if (bundle->getMinSdkVersion() != NULL 833 || bundle->getTargetSdkVersion() != NULL 834 || bundle->getMaxSdkVersion() != NULL) { 835 if (vers == NULL) { 836 vers = XMLNode::newElement(root->getFilename(), String16(), String16("uses-sdk")); 837 root->insertChildAt(vers, 0); 838 } 839 840 if (!addTagAttribute(vers, RESOURCES_ANDROID_NAMESPACE, "minSdkVersion", 841 bundle->getMinSdkVersion(), errorOnFailedInsert)) { 842 return UNKNOWN_ERROR; 843 } 844 if (!addTagAttribute(vers, RESOURCES_ANDROID_NAMESPACE, "targetSdkVersion", 845 bundle->getTargetSdkVersion(), errorOnFailedInsert)) { 846 return UNKNOWN_ERROR; 847 } 848 if (!addTagAttribute(vers, RESOURCES_ANDROID_NAMESPACE, "maxSdkVersion", 849 bundle->getMaxSdkVersion(), errorOnFailedInsert)) { 850 return UNKNOWN_ERROR; 851 } 852 } 853 854 if (vers != NULL) { 855 const XMLNode::attribute_entry* attr = vers->getAttribute( 856 String16(RESOURCES_ANDROID_NAMESPACE), String16("minSdkVersion")); 857 if (attr != NULL) { 858 bundle->setMinSdkVersion(strdup(String8(attr->string).string())); 859 } 860 } 861 862 if (bundle->getPlatformBuildVersionCode() != "") { 863 if (!addTagAttribute(root, "", "platformBuildVersionCode", 864 bundle->getPlatformBuildVersionCode(), errorOnFailedInsert, true)) { 865 return UNKNOWN_ERROR; 866 } 867 } 868 869 if (bundle->getPlatformBuildVersionName() != "") { 870 if (!addTagAttribute(root, "", "platformBuildVersionName", 871 bundle->getPlatformBuildVersionName(), errorOnFailedInsert, true)) { 872 return UNKNOWN_ERROR; 873 } 874 } 875 876 if (bundle->getDebugMode()) { 877 sp<XMLNode> application = root->getChildElement(String16(), String16("application")); 878 if (application != NULL) { 879 if (!addTagAttribute(application, RESOURCES_ANDROID_NAMESPACE, "debuggable", "true", 880 errorOnFailedInsert)) { 881 return UNKNOWN_ERROR; 882 } 883 } 884 } 885 886 // Deal with manifest package name overrides 887 const char* manifestPackageNameOverride = bundle->getManifestPackageNameOverride(); 888 if (manifestPackageNameOverride != NULL) { 889 // Update the actual package name 890 XMLNode::attribute_entry* attr = root->editAttribute(String16(), String16("package")); 891 if (attr == NULL) { 892 fprintf(stderr, "package name is required with --rename-manifest-package.\n"); 893 return UNKNOWN_ERROR; 894 } 895 String8 origPackage(attr->string); 896 attr->string.setTo(String16(manifestPackageNameOverride)); 897 if (kIsDebug) { 898 printf("Overriding package '%s' to be '%s'\n", origPackage.string(), 899 manifestPackageNameOverride); 900 } 901 902 // Make class names fully qualified 903 sp<XMLNode> application = root->getChildElement(String16(), String16("application")); 904 if (application != NULL) { 905 fullyQualifyClassName(origPackage, application, String16("name")); 906 fullyQualifyClassName(origPackage, application, String16("backupAgent")); 907 908 Vector<sp<XMLNode> >& children = const_cast<Vector<sp<XMLNode> >&>(application->getChildren()); 909 for (size_t i = 0; i < children.size(); i++) { 910 sp<XMLNode> child = children.editItemAt(i); 911 String8 tag(child->getElementName()); 912 if (tag == "activity" || tag == "service" || tag == "receiver" || tag == "provider") { 913 fullyQualifyClassName(origPackage, child, String16("name")); 914 } else if (tag == "activity-alias") { 915 fullyQualifyClassName(origPackage, child, String16("name")); 916 fullyQualifyClassName(origPackage, child, String16("targetActivity")); 917 } 918 } 919 } 920 } 921 922 // Deal with manifest package name overrides 923 const char* instrumentationPackageNameOverride = bundle->getInstrumentationPackageNameOverride(); 924 if (instrumentationPackageNameOverride != NULL) { 925 // Fix up instrumentation targets. 926 Vector<sp<XMLNode> >& children = const_cast<Vector<sp<XMLNode> >&>(root->getChildren()); 927 for (size_t i = 0; i < children.size(); i++) { 928 sp<XMLNode> child = children.editItemAt(i); 929 String8 tag(child->getElementName()); 930 if (tag == "instrumentation") { 931 XMLNode::attribute_entry* attr = child->editAttribute( 932 String16("http://schemas.android.com/apk/res/android"), String16("targetPackage")); 933 if (attr != NULL) { 934 attr->string.setTo(String16(instrumentationPackageNameOverride)); 935 } 936 } 937 } 938 } 939 940 // Generate split name if feature is present. 941 const XMLNode::attribute_entry* attr = root->getAttribute(String16(), String16("featureName")); 942 if (attr != NULL) { 943 String16 splitName("feature_"); 944 splitName.append(attr->string); 945 status_t err = root->addAttribute(String16(), String16("split"), splitName); 946 if (err != NO_ERROR) { 947 ALOGE("Failed to insert split name into AndroidManifest.xml"); 948 return err; 949 } 950 } 951 952 return NO_ERROR; 953} 954 955static int32_t getPlatformAssetCookie(const AssetManager& assets) { 956 // Find the system package (0x01). AAPT always generates attributes 957 // with the type 0x01, so we're looking for the first attribute 958 // resource in the system package. 959 const ResTable& table = assets.getResources(true); 960 Res_value val; 961 ssize_t idx = table.getResource(0x01010000, &val, true); 962 if (idx != NO_ERROR) { 963 // Try as a bag. 964 const ResTable::bag_entry* entry; 965 ssize_t cnt = table.lockBag(0x01010000, &entry); 966 if (cnt >= 0) { 967 idx = entry->stringBlock; 968 } 969 table.unlockBag(entry); 970 } 971 972 if (idx < 0) { 973 return 0; 974 } 975 return table.getTableCookie(idx); 976} 977 978enum { 979 VERSION_CODE_ATTR = 0x0101021b, 980 VERSION_NAME_ATTR = 0x0101021c, 981}; 982 983static ssize_t extractPlatformBuildVersion(ResXMLTree& tree, Bundle* bundle) { 984 size_t len; 985 ResXMLTree::event_code_t code; 986 while ((code = tree.next()) != ResXMLTree::END_DOCUMENT && code != ResXMLTree::BAD_DOCUMENT) { 987 if (code != ResXMLTree::START_TAG) { 988 continue; 989 } 990 991 const char16_t* ctag16 = tree.getElementName(&len); 992 if (ctag16 == NULL) { 993 fprintf(stderr, "ERROR: failed to get XML element name (bad string pool)\n"); 994 return UNKNOWN_ERROR; 995 } 996 997 String8 tag(ctag16, len); 998 if (tag != "manifest") { 999 continue; 1000 } 1001 1002 String8 error; 1003 int32_t versionCode = AaptXml::getIntegerAttribute(tree, VERSION_CODE_ATTR, &error); 1004 if (error != "") { 1005 fprintf(stderr, "ERROR: failed to get platform version code\n"); 1006 return UNKNOWN_ERROR; 1007 } 1008 1009 if (versionCode >= 0 && bundle->getPlatformBuildVersionCode() == "") { 1010 bundle->setPlatformBuildVersionCode(String8::format("%d", versionCode)); 1011 } 1012 1013 String8 versionName = AaptXml::getAttribute(tree, VERSION_NAME_ATTR, &error); 1014 if (error != "") { 1015 fprintf(stderr, "ERROR: failed to get platform version name\n"); 1016 return UNKNOWN_ERROR; 1017 } 1018 1019 if (versionName != "" && bundle->getPlatformBuildVersionName() == "") { 1020 bundle->setPlatformBuildVersionName(versionName); 1021 } 1022 return NO_ERROR; 1023 } 1024 1025 fprintf(stderr, "ERROR: no <manifest> tag found in platform AndroidManifest.xml\n"); 1026 return UNKNOWN_ERROR; 1027} 1028 1029static ssize_t extractPlatformBuildVersion(AssetManager& assets, Bundle* bundle) { 1030 int32_t cookie = getPlatformAssetCookie(assets); 1031 if (cookie == 0) { 1032 // No platform was loaded. 1033 return NO_ERROR; 1034 } 1035 1036 ResXMLTree tree; 1037 Asset* asset = assets.openNonAsset(cookie, "AndroidManifest.xml", Asset::ACCESS_STREAMING); 1038 if (asset == NULL) { 1039 fprintf(stderr, "ERROR: Platform AndroidManifest.xml not found\n"); 1040 return UNKNOWN_ERROR; 1041 } 1042 1043 ssize_t result = NO_ERROR; 1044 if (tree.setTo(asset->getBuffer(true), asset->getLength()) != NO_ERROR) { 1045 fprintf(stderr, "ERROR: Platform AndroidManifest.xml is corrupt\n"); 1046 result = UNKNOWN_ERROR; 1047 } else { 1048 result = extractPlatformBuildVersion(tree, bundle); 1049 } 1050 1051 delete asset; 1052 return result; 1053} 1054 1055#define ASSIGN_IT(n) \ 1056 do { \ 1057 ssize_t index = resources->indexOfKey(String8(#n)); \ 1058 if (index >= 0) { \ 1059 n ## s = resources->valueAt(index); \ 1060 } \ 1061 } while (0) 1062 1063status_t updatePreProcessedCache(Bundle* bundle) 1064{ 1065 #if BENCHMARK 1066 fprintf(stdout, "BENCHMARK: Starting PNG PreProcessing \n"); 1067 long startPNGTime = clock(); 1068 #endif /* BENCHMARK */ 1069 1070 String8 source(bundle->getResourceSourceDirs()[0]); 1071 String8 dest(bundle->getCrunchedOutputDir()); 1072 1073 FileFinder* ff = new SystemFileFinder(); 1074 CrunchCache cc(source,dest,ff); 1075 1076 CacheUpdater* cu = new SystemCacheUpdater(bundle); 1077 size_t numFiles = cc.crunch(cu); 1078 1079 if (bundle->getVerbose()) 1080 fprintf(stdout, "Crunched %d PNG files to update cache\n", (int)numFiles); 1081 1082 delete ff; 1083 delete cu; 1084 1085 #if BENCHMARK 1086 fprintf(stdout, "BENCHMARK: End PNG PreProcessing. Time Elapsed: %f ms \n" 1087 ,(clock() - startPNGTime)/1000.0); 1088 #endif /* BENCHMARK */ 1089 return 0; 1090} 1091 1092status_t generateAndroidManifestForSplit(Bundle* bundle, const sp<AaptAssets>& assets, 1093 const sp<ApkSplit>& split, sp<AaptFile>& outFile, ResourceTable* table) { 1094 const String8 filename("AndroidManifest.xml"); 1095 const String16 androidPrefix("android"); 1096 const String16 androidNSUri("http://schemas.android.com/apk/res/android"); 1097 sp<XMLNode> root = XMLNode::newNamespace(filename, androidPrefix, androidNSUri); 1098 1099 // Build the <manifest> tag 1100 sp<XMLNode> manifest = XMLNode::newElement(filename, String16(), String16("manifest")); 1101 1102 // Add the 'package' attribute which is set to the package name. 1103 const char* packageName = assets->getPackage(); 1104 const char* manifestPackageNameOverride = bundle->getManifestPackageNameOverride(); 1105 if (manifestPackageNameOverride != NULL) { 1106 packageName = manifestPackageNameOverride; 1107 } 1108 manifest->addAttribute(String16(), String16("package"), String16(packageName)); 1109 1110 // Add the 'versionCode' attribute which is set to the original version code. 1111 if (!addTagAttribute(manifest, RESOURCES_ANDROID_NAMESPACE, "versionCode", 1112 bundle->getVersionCode(), true, true)) { 1113 return UNKNOWN_ERROR; 1114 } 1115 1116 // Add the 'revisionCode' attribute, which is set to the original revisionCode. 1117 if (bundle->getRevisionCode().size() > 0) { 1118 if (!addTagAttribute(manifest, RESOURCES_ANDROID_NAMESPACE, "revisionCode", 1119 bundle->getRevisionCode().string(), true, true)) { 1120 return UNKNOWN_ERROR; 1121 } 1122 } 1123 1124 // Add the 'split' attribute which describes the configurations included. 1125 String8 splitName("config."); 1126 splitName.append(split->getPackageSafeName()); 1127 manifest->addAttribute(String16(), String16("split"), String16(splitName)); 1128 1129 // Build an empty <application> tag (required). 1130 sp<XMLNode> app = XMLNode::newElement(filename, String16(), String16("application")); 1131 1132 // Add the 'hasCode' attribute which is never true for resource splits. 1133 if (!addTagAttribute(app, RESOURCES_ANDROID_NAMESPACE, "hasCode", 1134 "false", true, true)) { 1135 return UNKNOWN_ERROR; 1136 } 1137 1138 manifest->addChild(app); 1139 root->addChild(manifest); 1140 1141 int err = compileXmlFile(bundle, assets, String16(), root, outFile, table); 1142 if (err < NO_ERROR) { 1143 return err; 1144 } 1145 outFile->setCompressionMethod(ZipEntry::kCompressDeflated); 1146 return NO_ERROR; 1147} 1148 1149status_t buildResources(Bundle* bundle, const sp<AaptAssets>& assets, sp<ApkBuilder>& builder) 1150{ 1151 // First, look for a package file to parse. This is required to 1152 // be able to generate the resource information. 1153 sp<AaptGroup> androidManifestFile = 1154 assets->getFiles().valueFor(String8("AndroidManifest.xml")); 1155 if (androidManifestFile == NULL) { 1156 fprintf(stderr, "ERROR: No AndroidManifest.xml file found.\n"); 1157 return UNKNOWN_ERROR; 1158 } 1159 1160 status_t err = parsePackage(bundle, assets, androidManifestFile); 1161 if (err != NO_ERROR) { 1162 return err; 1163 } 1164 1165 if (kIsDebug) { 1166 printf("Creating resources for package %s\n", assets->getPackage().string()); 1167 } 1168 1169 // Set the private symbols package if it was declared. 1170 // This can also be declared in XML as <private-symbols name="package" /> 1171 if (bundle->getPrivateSymbolsPackage().size() != 0) { 1172 assets->setSymbolsPrivatePackage(bundle->getPrivateSymbolsPackage()); 1173 } 1174 1175 ResourceTable::PackageType packageType = ResourceTable::App; 1176 if (bundle->getBuildSharedLibrary()) { 1177 packageType = ResourceTable::SharedLibrary; 1178 } else if (bundle->getExtending()) { 1179 packageType = ResourceTable::System; 1180 } else if (!bundle->getFeatureOfPackage().isEmpty()) { 1181 packageType = ResourceTable::AppFeature; 1182 } 1183 1184 ResourceTable table(bundle, String16(assets->getPackage()), packageType); 1185 err = table.addIncludedResources(bundle, assets); 1186 if (err != NO_ERROR) { 1187 return err; 1188 } 1189 1190 if (kIsDebug) { 1191 printf("Found %d included resource packages\n", (int)table.size()); 1192 } 1193 1194 // Standard flags for compiled XML and optional UTF-8 encoding 1195 int xmlFlags = XML_COMPILE_STANDARD_RESOURCE; 1196 1197 /* Only enable UTF-8 if the caller of aapt didn't specifically 1198 * request UTF-16 encoding and the parameters of this package 1199 * allow UTF-8 to be used. 1200 */ 1201 if (!bundle->getUTF16StringsOption()) { 1202 xmlFlags |= XML_COMPILE_UTF8; 1203 } 1204 1205 // -------------------------------------------------------------- 1206 // First, gather all resource information. 1207 // -------------------------------------------------------------- 1208 1209 // resType -> leafName -> group 1210 KeyedVector<String8, sp<ResourceTypeSet> > *resources = 1211 new KeyedVector<String8, sp<ResourceTypeSet> >; 1212 collect_files(assets, resources); 1213 1214 sp<ResourceTypeSet> drawables; 1215 sp<ResourceTypeSet> layouts; 1216 sp<ResourceTypeSet> anims; 1217 sp<ResourceTypeSet> animators; 1218 sp<ResourceTypeSet> interpolators; 1219 sp<ResourceTypeSet> transitions; 1220 sp<ResourceTypeSet> xmls; 1221 sp<ResourceTypeSet> raws; 1222 sp<ResourceTypeSet> colors; 1223 sp<ResourceTypeSet> menus; 1224 sp<ResourceTypeSet> mipmaps; 1225 1226 ASSIGN_IT(drawable); 1227 ASSIGN_IT(layout); 1228 ASSIGN_IT(anim); 1229 ASSIGN_IT(animator); 1230 ASSIGN_IT(interpolator); 1231 ASSIGN_IT(transition); 1232 ASSIGN_IT(xml); 1233 ASSIGN_IT(raw); 1234 ASSIGN_IT(color); 1235 ASSIGN_IT(menu); 1236 ASSIGN_IT(mipmap); 1237 1238 assets->setResources(resources); 1239 // now go through any resource overlays and collect their files 1240 sp<AaptAssets> current = assets->getOverlay(); 1241 while(current.get()) { 1242 KeyedVector<String8, sp<ResourceTypeSet> > *resources = 1243 new KeyedVector<String8, sp<ResourceTypeSet> >; 1244 current->setResources(resources); 1245 collect_files(current, resources); 1246 current = current->getOverlay(); 1247 } 1248 // apply the overlay files to the base set 1249 if (!applyFileOverlay(bundle, assets, &drawables, "drawable") || 1250 !applyFileOverlay(bundle, assets, &layouts, "layout") || 1251 !applyFileOverlay(bundle, assets, &anims, "anim") || 1252 !applyFileOverlay(bundle, assets, &animators, "animator") || 1253 !applyFileOverlay(bundle, assets, &interpolators, "interpolator") || 1254 !applyFileOverlay(bundle, assets, &transitions, "transition") || 1255 !applyFileOverlay(bundle, assets, &xmls, "xml") || 1256 !applyFileOverlay(bundle, assets, &raws, "raw") || 1257 !applyFileOverlay(bundle, assets, &colors, "color") || 1258 !applyFileOverlay(bundle, assets, &menus, "menu") || 1259 !applyFileOverlay(bundle, assets, &mipmaps, "mipmap")) { 1260 return UNKNOWN_ERROR; 1261 } 1262 1263 bool hasErrors = false; 1264 1265 if (drawables != NULL) { 1266 if (bundle->getOutputAPKFile() != NULL) { 1267 err = preProcessImages(bundle, assets, drawables, "drawable"); 1268 } 1269 if (err == NO_ERROR) { 1270 err = makeFileResources(bundle, assets, &table, drawables, "drawable"); 1271 if (err != NO_ERROR) { 1272 hasErrors = true; 1273 } 1274 } else { 1275 hasErrors = true; 1276 } 1277 } 1278 1279 if (mipmaps != NULL) { 1280 if (bundle->getOutputAPKFile() != NULL) { 1281 err = preProcessImages(bundle, assets, mipmaps, "mipmap"); 1282 } 1283 if (err == NO_ERROR) { 1284 err = makeFileResources(bundle, assets, &table, mipmaps, "mipmap"); 1285 if (err != NO_ERROR) { 1286 hasErrors = true; 1287 } 1288 } else { 1289 hasErrors = true; 1290 } 1291 } 1292 1293 if (layouts != NULL) { 1294 err = makeFileResources(bundle, assets, &table, layouts, "layout"); 1295 if (err != NO_ERROR) { 1296 hasErrors = true; 1297 } 1298 } 1299 1300 if (anims != NULL) { 1301 err = makeFileResources(bundle, assets, &table, anims, "anim"); 1302 if (err != NO_ERROR) { 1303 hasErrors = true; 1304 } 1305 } 1306 1307 if (animators != NULL) { 1308 err = makeFileResources(bundle, assets, &table, animators, "animator"); 1309 if (err != NO_ERROR) { 1310 hasErrors = true; 1311 } 1312 } 1313 1314 if (transitions != NULL) { 1315 err = makeFileResources(bundle, assets, &table, transitions, "transition"); 1316 if (err != NO_ERROR) { 1317 hasErrors = true; 1318 } 1319 } 1320 1321 if (interpolators != NULL) { 1322 err = makeFileResources(bundle, assets, &table, interpolators, "interpolator"); 1323 if (err != NO_ERROR) { 1324 hasErrors = true; 1325 } 1326 } 1327 1328 if (xmls != NULL) { 1329 err = makeFileResources(bundle, assets, &table, xmls, "xml"); 1330 if (err != NO_ERROR) { 1331 hasErrors = true; 1332 } 1333 } 1334 1335 if (raws != NULL) { 1336 err = makeFileResources(bundle, assets, &table, raws, "raw"); 1337 if (err != NO_ERROR) { 1338 hasErrors = true; 1339 } 1340 } 1341 1342 // compile resources 1343 current = assets; 1344 while(current.get()) { 1345 KeyedVector<String8, sp<ResourceTypeSet> > *resources = 1346 current->getResources(); 1347 1348 ssize_t index = resources->indexOfKey(String8("values")); 1349 if (index >= 0) { 1350 ResourceDirIterator it(resources->valueAt(index), String8("values")); 1351 ssize_t res; 1352 while ((res=it.next()) == NO_ERROR) { 1353 sp<AaptFile> file = it.getFile(); 1354 res = compileResourceFile(bundle, assets, file, it.getParams(), 1355 (current!=assets), &table); 1356 if (res != NO_ERROR) { 1357 hasErrors = true; 1358 } 1359 } 1360 } 1361 current = current->getOverlay(); 1362 } 1363 1364 if (colors != NULL) { 1365 err = makeFileResources(bundle, assets, &table, colors, "color"); 1366 if (err != NO_ERROR) { 1367 hasErrors = true; 1368 } 1369 } 1370 1371 if (menus != NULL) { 1372 err = makeFileResources(bundle, assets, &table, menus, "menu"); 1373 if (err != NO_ERROR) { 1374 hasErrors = true; 1375 } 1376 } 1377 1378 if (hasErrors) { 1379 return UNKNOWN_ERROR; 1380 } 1381 1382 // -------------------------------------------------------------------- 1383 // Assignment of resource IDs and initial generation of resource table. 1384 // -------------------------------------------------------------------- 1385 1386 if (table.hasResources()) { 1387 err = table.assignResourceIds(); 1388 if (err < NO_ERROR) { 1389 return err; 1390 } 1391 } 1392 1393 // -------------------------------------------------------------- 1394 // Finally, we can now we can compile XML files, which may reference 1395 // resources. 1396 // -------------------------------------------------------------- 1397 1398 if (layouts != NULL) { 1399 ResourceDirIterator it(layouts, String8("layout")); 1400 while ((err=it.next()) == NO_ERROR) { 1401 String8 src = it.getFile()->getPrintableSource(); 1402 err = compileXmlFile(bundle, assets, String16(it.getBaseName()), 1403 it.getFile(), &table, xmlFlags); 1404 if (err == NO_ERROR) { 1405 ResXMLTree block; 1406 block.setTo(it.getFile()->getData(), it.getFile()->getSize(), true); 1407 checkForIds(src, block); 1408 } else { 1409 hasErrors = true; 1410 } 1411 } 1412 1413 if (err < NO_ERROR) { 1414 hasErrors = true; 1415 } 1416 err = NO_ERROR; 1417 } 1418 1419 if (anims != NULL) { 1420 ResourceDirIterator it(anims, String8("anim")); 1421 while ((err=it.next()) == NO_ERROR) { 1422 err = compileXmlFile(bundle, assets, String16(it.getBaseName()), 1423 it.getFile(), &table, xmlFlags); 1424 if (err != NO_ERROR) { 1425 hasErrors = true; 1426 } 1427 } 1428 1429 if (err < NO_ERROR) { 1430 hasErrors = true; 1431 } 1432 err = NO_ERROR; 1433 } 1434 1435 if (animators != NULL) { 1436 ResourceDirIterator it(animators, String8("animator")); 1437 while ((err=it.next()) == NO_ERROR) { 1438 err = compileXmlFile(bundle, assets, String16(it.getBaseName()), 1439 it.getFile(), &table, xmlFlags); 1440 if (err != NO_ERROR) { 1441 hasErrors = true; 1442 } 1443 } 1444 1445 if (err < NO_ERROR) { 1446 hasErrors = true; 1447 } 1448 err = NO_ERROR; 1449 } 1450 1451 if (interpolators != NULL) { 1452 ResourceDirIterator it(interpolators, String8("interpolator")); 1453 while ((err=it.next()) == NO_ERROR) { 1454 err = compileXmlFile(bundle, assets, String16(it.getBaseName()), 1455 it.getFile(), &table, xmlFlags); 1456 if (err != NO_ERROR) { 1457 hasErrors = true; 1458 } 1459 } 1460 1461 if (err < NO_ERROR) { 1462 hasErrors = true; 1463 } 1464 err = NO_ERROR; 1465 } 1466 1467 if (transitions != NULL) { 1468 ResourceDirIterator it(transitions, String8("transition")); 1469 while ((err=it.next()) == NO_ERROR) { 1470 err = compileXmlFile(bundle, assets, String16(it.getBaseName()), 1471 it.getFile(), &table, xmlFlags); 1472 if (err != NO_ERROR) { 1473 hasErrors = true; 1474 } 1475 } 1476 1477 if (err < NO_ERROR) { 1478 hasErrors = true; 1479 } 1480 err = NO_ERROR; 1481 } 1482 1483 if (xmls != NULL) { 1484 ResourceDirIterator it(xmls, String8("xml")); 1485 while ((err=it.next()) == NO_ERROR) { 1486 err = compileXmlFile(bundle, assets, String16(it.getBaseName()), 1487 it.getFile(), &table, xmlFlags); 1488 if (err != NO_ERROR) { 1489 hasErrors = true; 1490 } 1491 } 1492 1493 if (err < NO_ERROR) { 1494 hasErrors = true; 1495 } 1496 err = NO_ERROR; 1497 } 1498 1499 if (drawables != NULL) { 1500 ResourceDirIterator it(drawables, String8("drawable")); 1501 while ((err=it.next()) == NO_ERROR) { 1502 err = postProcessImage(bundle, assets, &table, it.getFile()); 1503 if (err != NO_ERROR) { 1504 hasErrors = true; 1505 } 1506 } 1507 1508 if (err < NO_ERROR) { 1509 hasErrors = true; 1510 } 1511 err = NO_ERROR; 1512 } 1513 1514 if (colors != NULL) { 1515 ResourceDirIterator it(colors, String8("color")); 1516 while ((err=it.next()) == NO_ERROR) { 1517 err = compileXmlFile(bundle, assets, String16(it.getBaseName()), 1518 it.getFile(), &table, xmlFlags); 1519 if (err != NO_ERROR) { 1520 hasErrors = true; 1521 } 1522 } 1523 1524 if (err < NO_ERROR) { 1525 hasErrors = true; 1526 } 1527 err = NO_ERROR; 1528 } 1529 1530 if (menus != NULL) { 1531 ResourceDirIterator it(menus, String8("menu")); 1532 while ((err=it.next()) == NO_ERROR) { 1533 String8 src = it.getFile()->getPrintableSource(); 1534 err = compileXmlFile(bundle, assets, String16(it.getBaseName()), 1535 it.getFile(), &table, xmlFlags); 1536 if (err == NO_ERROR) { 1537 ResXMLTree block; 1538 block.setTo(it.getFile()->getData(), it.getFile()->getSize(), true); 1539 checkForIds(src, block); 1540 } else { 1541 hasErrors = true; 1542 } 1543 } 1544 1545 if (err < NO_ERROR) { 1546 hasErrors = true; 1547 } 1548 err = NO_ERROR; 1549 } 1550 1551 // Now compile any generated resources. 1552 std::queue<CompileResourceWorkItem>& workQueue = table.getWorkQueue(); 1553 while (!workQueue.empty()) { 1554 CompileResourceWorkItem& workItem = workQueue.front(); 1555 int xmlCompilationFlags = xmlFlags | XML_COMPILE_PARSE_VALUES 1556 | XML_COMPILE_ASSIGN_ATTRIBUTE_IDS; 1557 if (!workItem.needsCompiling) { 1558 xmlCompilationFlags &= ~XML_COMPILE_ASSIGN_ATTRIBUTE_IDS; 1559 xmlCompilationFlags &= ~XML_COMPILE_PARSE_VALUES; 1560 } 1561 err = compileXmlFile(bundle, assets, workItem.resourceName, workItem.xmlRoot, 1562 workItem.file, &table, xmlCompilationFlags); 1563 1564 if (err == NO_ERROR) { 1565 assets->addResource(workItem.resPath.getPathLeaf(), 1566 workItem.resPath, 1567 workItem.file, 1568 workItem.file->getResourceType()); 1569 } else { 1570 hasErrors = true; 1571 } 1572 workQueue.pop(); 1573 } 1574 1575 if (table.validateLocalizations()) { 1576 hasErrors = true; 1577 } 1578 1579 if (hasErrors) { 1580 return UNKNOWN_ERROR; 1581 } 1582 1583 // If we're not overriding the platform build versions, 1584 // extract them from the platform APK. 1585 if (packageType != ResourceTable::System && 1586 (bundle->getPlatformBuildVersionCode() == "" || 1587 bundle->getPlatformBuildVersionName() == "")) { 1588 err = extractPlatformBuildVersion(assets->getAssetManager(), bundle); 1589 if (err != NO_ERROR) { 1590 return UNKNOWN_ERROR; 1591 } 1592 } 1593 1594 const sp<AaptFile> manifestFile(androidManifestFile->getFiles().valueAt(0)); 1595 String8 manifestPath(manifestFile->getPrintableSource()); 1596 1597 // Generate final compiled manifest file. 1598 manifestFile->clearData(); 1599 sp<XMLNode> manifestTree = XMLNode::parse(manifestFile); 1600 if (manifestTree == NULL) { 1601 return UNKNOWN_ERROR; 1602 } 1603 err = massageManifest(bundle, manifestTree); 1604 if (err < NO_ERROR) { 1605 return err; 1606 } 1607 err = compileXmlFile(bundle, assets, String16(), manifestTree, manifestFile, &table); 1608 if (err < NO_ERROR) { 1609 return err; 1610 } 1611 1612 if (table.modifyForCompat(bundle) != NO_ERROR) { 1613 return UNKNOWN_ERROR; 1614 } 1615 1616 //block.restart(); 1617 //printXMLBlock(&block); 1618 1619 // -------------------------------------------------------------- 1620 // Generate the final resource table. 1621 // Re-flatten because we may have added new resource IDs 1622 // -------------------------------------------------------------- 1623 1624 1625 ResTable finalResTable; 1626 sp<AaptFile> resFile; 1627 1628 if (table.hasResources()) { 1629 sp<AaptSymbols> symbols = assets->getSymbolsFor(String8("R")); 1630 err = table.addSymbols(symbols, bundle->getSkipSymbolsWithoutDefaultLocalization()); 1631 if (err < NO_ERROR) { 1632 return err; 1633 } 1634 1635 KeyedVector<Symbol, Vector<SymbolDefinition> > densityVaryingResources; 1636 if (builder->getSplits().size() > 1) { 1637 // Only look for density varying resources if we're generating 1638 // splits. 1639 table.getDensityVaryingResources(densityVaryingResources); 1640 } 1641 1642 Vector<sp<ApkSplit> >& splits = builder->getSplits(); 1643 const size_t numSplits = splits.size(); 1644 for (size_t i = 0; i < numSplits; i++) { 1645 sp<ApkSplit>& split = splits.editItemAt(i); 1646 sp<AaptFile> flattenedTable = new AaptFile(String8("resources.arsc"), 1647 AaptGroupEntry(), String8()); 1648 err = table.flatten(bundle, split->getResourceFilter(), 1649 flattenedTable, split->isBase()); 1650 if (err != NO_ERROR) { 1651 fprintf(stderr, "Failed to generate resource table for split '%s'\n", 1652 split->getPrintableName().string()); 1653 return err; 1654 } 1655 split->addEntry(String8("resources.arsc"), flattenedTable); 1656 1657 if (split->isBase()) { 1658 resFile = flattenedTable; 1659 err = finalResTable.add(flattenedTable->getData(), flattenedTable->getSize()); 1660 if (err != NO_ERROR) { 1661 fprintf(stderr, "Generated resource table is corrupt.\n"); 1662 return err; 1663 } 1664 } else { 1665 ResTable resTable; 1666 err = resTable.add(flattenedTable->getData(), flattenedTable->getSize()); 1667 if (err != NO_ERROR) { 1668 fprintf(stderr, "Generated resource table for split '%s' is corrupt.\n", 1669 split->getPrintableName().string()); 1670 return err; 1671 } 1672 1673 bool hasError = false; 1674 const std::set<ConfigDescription>& splitConfigs = split->getConfigs(); 1675 for (std::set<ConfigDescription>::const_iterator iter = splitConfigs.begin(); 1676 iter != splitConfigs.end(); 1677 ++iter) { 1678 const ConfigDescription& config = *iter; 1679 if (AaptConfig::isDensityOnly(config)) { 1680 // Each density only split must contain all 1681 // density only resources. 1682 Res_value val; 1683 resTable.setParameters(&config); 1684 const size_t densityVaryingResourceCount = densityVaryingResources.size(); 1685 for (size_t k = 0; k < densityVaryingResourceCount; k++) { 1686 const Symbol& symbol = densityVaryingResources.keyAt(k); 1687 ssize_t block = resTable.getResource(symbol.id, &val, true); 1688 if (block < 0) { 1689 // Maybe it's in the base? 1690 finalResTable.setParameters(&config); 1691 block = finalResTable.getResource(symbol.id, &val, true); 1692 } 1693 1694 if (block < 0) { 1695 hasError = true; 1696 SourcePos().error("%s has no definition for density split '%s'", 1697 symbol.toString().string(), config.toString().string()); 1698 1699 if (bundle->getVerbose()) { 1700 const Vector<SymbolDefinition>& defs = densityVaryingResources[k]; 1701 const size_t defCount = std::min(size_t(5), defs.size()); 1702 for (size_t d = 0; d < defCount; d++) { 1703 const SymbolDefinition& def = defs[d]; 1704 def.source.error("%s has definition for %s", 1705 symbol.toString().string(), def.config.toString().string()); 1706 } 1707 1708 if (defCount < defs.size()) { 1709 SourcePos().error("and %d more ...", (int) (defs.size() - defCount)); 1710 } 1711 } 1712 } 1713 } 1714 } 1715 } 1716 1717 if (hasError) { 1718 return UNKNOWN_ERROR; 1719 } 1720 1721 // Generate the AndroidManifest for this split. 1722 sp<AaptFile> generatedManifest = new AaptFile(String8("AndroidManifest.xml"), 1723 AaptGroupEntry(), String8()); 1724 err = generateAndroidManifestForSplit(bundle, assets, split, 1725 generatedManifest, &table); 1726 if (err != NO_ERROR) { 1727 fprintf(stderr, "Failed to generate AndroidManifest.xml for split '%s'\n", 1728 split->getPrintableName().string()); 1729 return err; 1730 } 1731 split->addEntry(String8("AndroidManifest.xml"), generatedManifest); 1732 } 1733 } 1734 1735 if (bundle->getPublicOutputFile()) { 1736 FILE* fp = fopen(bundle->getPublicOutputFile(), "w+"); 1737 if (fp == NULL) { 1738 fprintf(stderr, "ERROR: Unable to open public definitions output file %s: %s\n", 1739 (const char*)bundle->getPublicOutputFile(), strerror(errno)); 1740 return UNKNOWN_ERROR; 1741 } 1742 if (bundle->getVerbose()) { 1743 printf(" Writing public definitions to %s.\n", bundle->getPublicOutputFile()); 1744 } 1745 table.writePublicDefinitions(String16(assets->getPackage()), fp); 1746 fclose(fp); 1747 } 1748 1749 if (finalResTable.getTableCount() == 0 || resFile == NULL) { 1750 fprintf(stderr, "No resource table was generated.\n"); 1751 return UNKNOWN_ERROR; 1752 } 1753 } 1754 1755 // Perform a basic validation of the manifest file. This time we 1756 // parse it with the comments intact, so that we can use them to 1757 // generate java docs... so we are not going to write this one 1758 // back out to the final manifest data. 1759 sp<AaptFile> outManifestFile = new AaptFile(manifestFile->getSourceFile(), 1760 manifestFile->getGroupEntry(), 1761 manifestFile->getResourceType()); 1762 err = compileXmlFile(bundle, assets, String16(), manifestFile, 1763 outManifestFile, &table, XML_COMPILE_STANDARD_RESOURCE & ~XML_COMPILE_STRIP_COMMENTS); 1764 if (err < NO_ERROR) { 1765 return err; 1766 } 1767 ResXMLTree block; 1768 block.setTo(outManifestFile->getData(), outManifestFile->getSize(), true); 1769 String16 manifest16("manifest"); 1770 String16 permission16("permission"); 1771 String16 permission_group16("permission-group"); 1772 String16 uses_permission16("uses-permission"); 1773 String16 instrumentation16("instrumentation"); 1774 String16 application16("application"); 1775 String16 provider16("provider"); 1776 String16 service16("service"); 1777 String16 receiver16("receiver"); 1778 String16 activity16("activity"); 1779 String16 action16("action"); 1780 String16 category16("category"); 1781 String16 data16("scheme"); 1782 String16 feature_group16("feature-group"); 1783 String16 uses_feature16("uses-feature"); 1784 const char* packageIdentChars = "abcdefghijklmnopqrstuvwxyz" 1785 "ABCDEFGHIJKLMNOPQRSTUVWXYZ._0123456789"; 1786 const char* packageIdentCharsWithTheStupid = "abcdefghijklmnopqrstuvwxyz" 1787 "ABCDEFGHIJKLMNOPQRSTUVWXYZ._0123456789-"; 1788 const char* classIdentChars = "abcdefghijklmnopqrstuvwxyz" 1789 "ABCDEFGHIJKLMNOPQRSTUVWXYZ._0123456789$"; 1790 const char* processIdentChars = "abcdefghijklmnopqrstuvwxyz" 1791 "ABCDEFGHIJKLMNOPQRSTUVWXYZ._0123456789:"; 1792 const char* authoritiesIdentChars = "abcdefghijklmnopqrstuvwxyz" 1793 "ABCDEFGHIJKLMNOPQRSTUVWXYZ._0123456789-:;"; 1794 const char* typeIdentChars = "abcdefghijklmnopqrstuvwxyz" 1795 "ABCDEFGHIJKLMNOPQRSTUVWXYZ._0123456789:-/*+"; 1796 const char* schemeIdentChars = "abcdefghijklmnopqrstuvwxyz" 1797 "ABCDEFGHIJKLMNOPQRSTUVWXYZ._0123456789-"; 1798 ResXMLTree::event_code_t code; 1799 sp<AaptSymbols> permissionSymbols; 1800 sp<AaptSymbols> permissionGroupSymbols; 1801 while ((code=block.next()) != ResXMLTree::END_DOCUMENT 1802 && code > ResXMLTree::BAD_DOCUMENT) { 1803 if (code == ResXMLTree::START_TAG) { 1804 size_t len; 1805 if (block.getElementNamespace(&len) != NULL) { 1806 continue; 1807 } 1808 if (strcmp16(block.getElementName(&len), manifest16.string()) == 0) { 1809 if (validateAttr(manifestPath, finalResTable, block, NULL, "package", 1810 packageIdentChars, true) != ATTR_OKAY) { 1811 hasErrors = true; 1812 } 1813 if (validateAttr(manifestPath, finalResTable, block, RESOURCES_ANDROID_NAMESPACE, 1814 "sharedUserId", packageIdentChars, false) != ATTR_OKAY) { 1815 hasErrors = true; 1816 } 1817 } else if (strcmp16(block.getElementName(&len), permission16.string()) == 0 1818 || strcmp16(block.getElementName(&len), permission_group16.string()) == 0) { 1819 const bool isGroup = strcmp16(block.getElementName(&len), 1820 permission_group16.string()) == 0; 1821 if (validateAttr(manifestPath, finalResTable, block, RESOURCES_ANDROID_NAMESPACE, 1822 "name", isGroup ? packageIdentCharsWithTheStupid 1823 : packageIdentChars, true) != ATTR_OKAY) { 1824 hasErrors = true; 1825 } 1826 SourcePos srcPos(manifestPath, block.getLineNumber()); 1827 sp<AaptSymbols> syms; 1828 if (!isGroup) { 1829 syms = permissionSymbols; 1830 if (syms == NULL) { 1831 sp<AaptSymbols> symbols = 1832 assets->getSymbolsFor(String8("Manifest")); 1833 syms = permissionSymbols = symbols->addNestedSymbol( 1834 String8("permission"), srcPos); 1835 } 1836 } else { 1837 syms = permissionGroupSymbols; 1838 if (syms == NULL) { 1839 sp<AaptSymbols> symbols = 1840 assets->getSymbolsFor(String8("Manifest")); 1841 syms = permissionGroupSymbols = symbols->addNestedSymbol( 1842 String8("permission_group"), srcPos); 1843 } 1844 } 1845 size_t len; 1846 ssize_t index = block.indexOfAttribute(RESOURCES_ANDROID_NAMESPACE, "name"); 1847 const char16_t* id = block.getAttributeStringValue(index, &len); 1848 if (id == NULL) { 1849 fprintf(stderr, "%s:%d: missing name attribute in element <%s>.\n", 1850 manifestPath.string(), block.getLineNumber(), 1851 String8(block.getElementName(&len)).string()); 1852 hasErrors = true; 1853 break; 1854 } 1855 String8 idStr(id); 1856 char* p = idStr.lockBuffer(idStr.size()); 1857 char* e = p + idStr.size(); 1858 bool begins_with_digit = true; // init to true so an empty string fails 1859 while (e > p) { 1860 e--; 1861 if (*e >= '0' && *e <= '9') { 1862 begins_with_digit = true; 1863 continue; 1864 } 1865 if ((*e >= 'a' && *e <= 'z') || 1866 (*e >= 'A' && *e <= 'Z') || 1867 (*e == '_')) { 1868 begins_with_digit = false; 1869 continue; 1870 } 1871 if (isGroup && (*e == '-')) { 1872 *e = '_'; 1873 begins_with_digit = false; 1874 continue; 1875 } 1876 e++; 1877 break; 1878 } 1879 idStr.unlockBuffer(); 1880 // verify that we stopped because we hit a period or 1881 // the beginning of the string, and that the 1882 // identifier didn't begin with a digit. 1883 if (begins_with_digit || (e != p && *(e-1) != '.')) { 1884 fprintf(stderr, 1885 "%s:%d: Permission name <%s> is not a valid Java symbol\n", 1886 manifestPath.string(), block.getLineNumber(), idStr.string()); 1887 hasErrors = true; 1888 } 1889 syms->addStringSymbol(String8(e), idStr, srcPos); 1890 const char16_t* cmt = block.getComment(&len); 1891 if (cmt != NULL && *cmt != 0) { 1892 //printf("Comment of %s: %s\n", String8(e).string(), 1893 // String8(cmt).string()); 1894 syms->appendComment(String8(e), String16(cmt), srcPos); 1895 } 1896 syms->makeSymbolPublic(String8(e), srcPos); 1897 } else if (strcmp16(block.getElementName(&len), uses_permission16.string()) == 0) { 1898 if (validateAttr(manifestPath, finalResTable, block, RESOURCES_ANDROID_NAMESPACE, 1899 "name", packageIdentChars, true) != ATTR_OKAY) { 1900 hasErrors = true; 1901 } 1902 } else if (strcmp16(block.getElementName(&len), instrumentation16.string()) == 0) { 1903 if (validateAttr(manifestPath, finalResTable, block, RESOURCES_ANDROID_NAMESPACE, 1904 "name", classIdentChars, true) != ATTR_OKAY) { 1905 hasErrors = true; 1906 } 1907 if (validateAttr(manifestPath, finalResTable, block, 1908 RESOURCES_ANDROID_NAMESPACE, "targetPackage", 1909 packageIdentChars, true) != ATTR_OKAY) { 1910 hasErrors = true; 1911 } 1912 } else if (strcmp16(block.getElementName(&len), application16.string()) == 0) { 1913 if (validateAttr(manifestPath, finalResTable, block, RESOURCES_ANDROID_NAMESPACE, 1914 "name", classIdentChars, false) != ATTR_OKAY) { 1915 hasErrors = true; 1916 } 1917 if (validateAttr(manifestPath, finalResTable, block, 1918 RESOURCES_ANDROID_NAMESPACE, "permission", 1919 packageIdentChars, false) != ATTR_OKAY) { 1920 hasErrors = true; 1921 } 1922 if (validateAttr(manifestPath, finalResTable, block, 1923 RESOURCES_ANDROID_NAMESPACE, "process", 1924 processIdentChars, false) != ATTR_OKAY) { 1925 hasErrors = true; 1926 } 1927 if (validateAttr(manifestPath, finalResTable, block, 1928 RESOURCES_ANDROID_NAMESPACE, "taskAffinity", 1929 processIdentChars, false) != ATTR_OKAY) { 1930 hasErrors = true; 1931 } 1932 } else if (strcmp16(block.getElementName(&len), provider16.string()) == 0) { 1933 if (validateAttr(manifestPath, finalResTable, block, RESOURCES_ANDROID_NAMESPACE, 1934 "name", classIdentChars, true) != ATTR_OKAY) { 1935 hasErrors = true; 1936 } 1937 if (validateAttr(manifestPath, finalResTable, block, 1938 RESOURCES_ANDROID_NAMESPACE, "authorities", 1939 authoritiesIdentChars, true) != ATTR_OKAY) { 1940 hasErrors = true; 1941 } 1942 if (validateAttr(manifestPath, finalResTable, block, 1943 RESOURCES_ANDROID_NAMESPACE, "permission", 1944 packageIdentChars, false) != ATTR_OKAY) { 1945 hasErrors = true; 1946 } 1947 if (validateAttr(manifestPath, finalResTable, block, 1948 RESOURCES_ANDROID_NAMESPACE, "process", 1949 processIdentChars, false) != ATTR_OKAY) { 1950 hasErrors = true; 1951 } 1952 } else if (strcmp16(block.getElementName(&len), service16.string()) == 0 1953 || strcmp16(block.getElementName(&len), receiver16.string()) == 0 1954 || strcmp16(block.getElementName(&len), activity16.string()) == 0) { 1955 if (validateAttr(manifestPath, finalResTable, block, RESOURCES_ANDROID_NAMESPACE, 1956 "name", classIdentChars, true) != ATTR_OKAY) { 1957 hasErrors = true; 1958 } 1959 if (validateAttr(manifestPath, finalResTable, block, 1960 RESOURCES_ANDROID_NAMESPACE, "permission", 1961 packageIdentChars, false) != ATTR_OKAY) { 1962 hasErrors = true; 1963 } 1964 if (validateAttr(manifestPath, finalResTable, block, 1965 RESOURCES_ANDROID_NAMESPACE, "process", 1966 processIdentChars, false) != ATTR_OKAY) { 1967 hasErrors = true; 1968 } 1969 if (validateAttr(manifestPath, finalResTable, block, 1970 RESOURCES_ANDROID_NAMESPACE, "taskAffinity", 1971 processIdentChars, false) != ATTR_OKAY) { 1972 hasErrors = true; 1973 } 1974 } else if (strcmp16(block.getElementName(&len), action16.string()) == 0 1975 || strcmp16(block.getElementName(&len), category16.string()) == 0) { 1976 if (validateAttr(manifestPath, finalResTable, block, 1977 RESOURCES_ANDROID_NAMESPACE, "name", 1978 packageIdentChars, true) != ATTR_OKAY) { 1979 hasErrors = true; 1980 } 1981 } else if (strcmp16(block.getElementName(&len), data16.string()) == 0) { 1982 if (validateAttr(manifestPath, finalResTable, block, 1983 RESOURCES_ANDROID_NAMESPACE, "mimeType", 1984 typeIdentChars, true) != ATTR_OKAY) { 1985 hasErrors = true; 1986 } 1987 if (validateAttr(manifestPath, finalResTable, block, 1988 RESOURCES_ANDROID_NAMESPACE, "scheme", 1989 schemeIdentChars, true) != ATTR_OKAY) { 1990 hasErrors = true; 1991 } 1992 } else if (strcmp16(block.getElementName(&len), feature_group16.string()) == 0) { 1993 int depth = 1; 1994 while ((code=block.next()) != ResXMLTree::END_DOCUMENT 1995 && code > ResXMLTree::BAD_DOCUMENT) { 1996 if (code == ResXMLTree::START_TAG) { 1997 depth++; 1998 if (strcmp16(block.getElementName(&len), uses_feature16.string()) == 0) { 1999 ssize_t idx = block.indexOfAttribute( 2000 RESOURCES_ANDROID_NAMESPACE, "required"); 2001 if (idx < 0) { 2002 continue; 2003 } 2004 2005 int32_t data = block.getAttributeData(idx); 2006 if (data == 0) { 2007 fprintf(stderr, "%s:%d: Tag <uses-feature> can not have " 2008 "android:required=\"false\" when inside a " 2009 "<feature-group> tag.\n", 2010 manifestPath.string(), block.getLineNumber()); 2011 hasErrors = true; 2012 } 2013 } 2014 } else if (code == ResXMLTree::END_TAG) { 2015 depth--; 2016 if (depth == 0) { 2017 break; 2018 } 2019 } 2020 } 2021 } 2022 } 2023 } 2024 2025 if (hasErrors) { 2026 return UNKNOWN_ERROR; 2027 } 2028 2029 if (resFile != NULL) { 2030 // These resources are now considered to be a part of the included 2031 // resources, for others to reference. 2032 err = assets->addIncludedResources(resFile); 2033 if (err < NO_ERROR) { 2034 fprintf(stderr, "ERROR: Unable to parse generated resources, aborting.\n"); 2035 return err; 2036 } 2037 } 2038 2039 return err; 2040} 2041 2042static const char* getIndentSpace(int indent) 2043{ 2044static const char whitespace[] = 2045" "; 2046 2047 return whitespace + sizeof(whitespace) - 1 - indent*4; 2048} 2049 2050static String8 flattenSymbol(const String8& symbol) { 2051 String8 result(symbol); 2052 ssize_t first; 2053 if ((first = symbol.find(":", 0)) >= 0 2054 || (first = symbol.find(".", 0)) >= 0) { 2055 size_t size = symbol.size(); 2056 char* buf = result.lockBuffer(size); 2057 for (size_t i = first; i < size; i++) { 2058 if (buf[i] == ':' || buf[i] == '.') { 2059 buf[i] = '_'; 2060 } 2061 } 2062 result.unlockBuffer(size); 2063 } 2064 return result; 2065} 2066 2067static String8 getSymbolPackage(const String8& symbol, const sp<AaptAssets>& assets, bool pub) { 2068 ssize_t colon = symbol.find(":", 0); 2069 if (colon >= 0) { 2070 return String8(symbol.string(), colon); 2071 } 2072 return pub ? assets->getPackage() : assets->getSymbolsPrivatePackage(); 2073} 2074 2075static String8 getSymbolName(const String8& symbol) { 2076 ssize_t colon = symbol.find(":", 0); 2077 if (colon >= 0) { 2078 return String8(symbol.string() + colon + 1); 2079 } 2080 return symbol; 2081} 2082 2083static String16 getAttributeComment(const sp<AaptAssets>& assets, 2084 const String8& name, 2085 String16* outTypeComment = NULL) 2086{ 2087 sp<AaptSymbols> asym = assets->getSymbolsFor(String8("R")); 2088 if (asym != NULL) { 2089 //printf("Got R symbols!\n"); 2090 asym = asym->getNestedSymbols().valueFor(String8("attr")); 2091 if (asym != NULL) { 2092 //printf("Got attrs symbols! comment %s=%s\n", 2093 // name.string(), String8(asym->getComment(name)).string()); 2094 if (outTypeComment != NULL) { 2095 *outTypeComment = asym->getTypeComment(name); 2096 } 2097 return asym->getComment(name); 2098 } 2099 } 2100 return String16(); 2101} 2102 2103static status_t writeResourceLoadedCallbackForLayoutClasses( 2104 FILE* fp, const sp<AaptAssets>& assets, 2105 const sp<AaptSymbols>& symbols, int indent, bool /* includePrivate */) 2106{ 2107 String16 attr16("attr"); 2108 String16 package16(assets->getPackage()); 2109 2110 const char* indentStr = getIndentSpace(indent); 2111 bool hasErrors = false; 2112 2113 size_t i; 2114 size_t N = symbols->getNestedSymbols().size(); 2115 for (i=0; i<N; i++) { 2116 sp<AaptSymbols> nsymbols = symbols->getNestedSymbols().valueAt(i); 2117 String8 realClassName(symbols->getNestedSymbols().keyAt(i)); 2118 String8 nclassName(flattenSymbol(realClassName)); 2119 2120 fprintf(fp, 2121 "%sfor(int i = 0; i < styleable.%s.length; ++i) {\n" 2122 "%sstyleable.%s[i] = (styleable.%s[i] & 0x00ffffff) | (packageId << 24);\n" 2123 "%s}\n", 2124 indentStr, nclassName.string(), 2125 getIndentSpace(indent+1), nclassName.string(), nclassName.string(), 2126 indentStr); 2127 } 2128 2129 return hasErrors ? STATUST(UNKNOWN_ERROR) : NO_ERROR; 2130} 2131 2132static status_t writeResourceLoadedCallback( 2133 FILE* fp, const sp<AaptAssets>& assets, bool includePrivate, 2134 const sp<AaptSymbols>& symbols, const String8& className, int indent) 2135{ 2136 size_t i; 2137 status_t err = NO_ERROR; 2138 2139 size_t N = symbols->getSymbols().size(); 2140 for (i=0; i<N; i++) { 2141 const AaptSymbolEntry& sym = symbols->getSymbols().valueAt(i); 2142 if (sym.typeCode != AaptSymbolEntry::TYPE_INT32) { 2143 continue; 2144 } 2145 if (!assets->isJavaSymbol(sym, includePrivate)) { 2146 continue; 2147 } 2148 String8 flat_name(flattenSymbol(sym.name)); 2149 fprintf(fp, 2150 "%s%s.%s = (%s.%s & 0x00ffffff) | (packageId << 24);\n", 2151 getIndentSpace(indent), className.string(), flat_name.string(), 2152 className.string(), flat_name.string()); 2153 } 2154 2155 N = symbols->getNestedSymbols().size(); 2156 for (i=0; i<N; i++) { 2157 sp<AaptSymbols> nsymbols = symbols->getNestedSymbols().valueAt(i); 2158 String8 nclassName(symbols->getNestedSymbols().keyAt(i)); 2159 if (nclassName == "styleable") { 2160 err = writeResourceLoadedCallbackForLayoutClasses( 2161 fp, assets, nsymbols, indent, includePrivate); 2162 } else { 2163 err = writeResourceLoadedCallback(fp, assets, includePrivate, nsymbols, 2164 nclassName, indent); 2165 } 2166 if (err != NO_ERROR) { 2167 return err; 2168 } 2169 } 2170 2171 return NO_ERROR; 2172} 2173 2174static status_t writeLayoutClasses( 2175 FILE* fp, const sp<AaptAssets>& assets, 2176 const sp<AaptSymbols>& symbols, int indent, bool includePrivate, bool nonConstantId) 2177{ 2178 const char* indentStr = getIndentSpace(indent); 2179 if (!includePrivate) { 2180 fprintf(fp, "%s/** @doconly */\n", indentStr); 2181 } 2182 fprintf(fp, "%spublic static final class styleable {\n", indentStr); 2183 indent++; 2184 2185 String16 attr16("attr"); 2186 String16 package16(assets->getPackage()); 2187 2188 indentStr = getIndentSpace(indent); 2189 bool hasErrors = false; 2190 2191 size_t i; 2192 size_t N = symbols->getNestedSymbols().size(); 2193 for (i=0; i<N; i++) { 2194 sp<AaptSymbols> nsymbols = symbols->getNestedSymbols().valueAt(i); 2195 String8 realClassName(symbols->getNestedSymbols().keyAt(i)); 2196 String8 nclassName(flattenSymbol(realClassName)); 2197 2198 SortedVector<uint32_t> idents; 2199 Vector<uint32_t> origOrder; 2200 Vector<bool> publicFlags; 2201 2202 size_t a; 2203 size_t NA = nsymbols->getSymbols().size(); 2204 for (a=0; a<NA; a++) { 2205 const AaptSymbolEntry& sym(nsymbols->getSymbols().valueAt(a)); 2206 int32_t code = sym.typeCode == AaptSymbolEntry::TYPE_INT32 2207 ? sym.int32Val : 0; 2208 bool isPublic = true; 2209 if (code == 0) { 2210 String16 name16(sym.name); 2211 uint32_t typeSpecFlags; 2212 code = assets->getIncludedResources().identifierForName( 2213 name16.string(), name16.size(), 2214 attr16.string(), attr16.size(), 2215 package16.string(), package16.size(), &typeSpecFlags); 2216 if (code == 0) { 2217 fprintf(stderr, "ERROR: In <declare-styleable> %s, unable to find attribute %s\n", 2218 nclassName.string(), sym.name.string()); 2219 hasErrors = true; 2220 } 2221 isPublic = (typeSpecFlags&ResTable_typeSpec::SPEC_PUBLIC) != 0; 2222 } 2223 idents.add(code); 2224 origOrder.add(code); 2225 publicFlags.add(isPublic); 2226 } 2227 2228 NA = idents.size(); 2229 2230 String16 comment = symbols->getComment(realClassName); 2231 AnnotationProcessor ann; 2232 fprintf(fp, "%s/** ", indentStr); 2233 if (comment.size() > 0) { 2234 String8 cmt(comment); 2235 ann.preprocessComment(cmt); 2236 fprintf(fp, "%s\n", cmt.string()); 2237 } else { 2238 fprintf(fp, "Attributes that can be used with a %s.\n", nclassName.string()); 2239 } 2240 bool hasTable = false; 2241 for (a=0; a<NA; a++) { 2242 ssize_t pos = idents.indexOf(origOrder.itemAt(a)); 2243 if (pos >= 0) { 2244 if (!hasTable) { 2245 hasTable = true; 2246 fprintf(fp, 2247 "%s <p>Includes the following attributes:</p>\n" 2248 "%s <table>\n" 2249 "%s <colgroup align=\"left\" />\n" 2250 "%s <colgroup align=\"left\" />\n" 2251 "%s <tr><th>Attribute</th><th>Description</th></tr>\n", 2252 indentStr, 2253 indentStr, 2254 indentStr, 2255 indentStr, 2256 indentStr); 2257 } 2258 const AaptSymbolEntry& sym = nsymbols->getSymbols().valueAt(a); 2259 if (!publicFlags.itemAt(a) && !includePrivate) { 2260 continue; 2261 } 2262 String8 name8(sym.name); 2263 String16 comment(sym.comment); 2264 if (comment.size() <= 0) { 2265 comment = getAttributeComment(assets, name8); 2266 } 2267 if (comment.contains(u"@removed")) { 2268 continue; 2269 } 2270 if (comment.size() > 0) { 2271 const char16_t* p = comment.string(); 2272 while (*p != 0 && *p != '.') { 2273 if (*p == '{') { 2274 while (*p != 0 && *p != '}') { 2275 p++; 2276 } 2277 } else { 2278 p++; 2279 } 2280 } 2281 if (*p == '.') { 2282 p++; 2283 } 2284 comment = String16(comment.string(), p-comment.string()); 2285 } 2286 fprintf(fp, "%s <tr><td><code>{@link #%s_%s %s:%s}</code></td><td>%s</td></tr>\n", 2287 indentStr, nclassName.string(), 2288 flattenSymbol(name8).string(), 2289 getSymbolPackage(name8, assets, true).string(), 2290 getSymbolName(name8).string(), 2291 String8(comment).string()); 2292 } 2293 } 2294 if (hasTable) { 2295 fprintf(fp, "%s </table>\n", indentStr); 2296 } 2297 for (a=0; a<NA; a++) { 2298 ssize_t pos = idents.indexOf(origOrder.itemAt(a)); 2299 if (pos >= 0) { 2300 const AaptSymbolEntry& sym = nsymbols->getSymbols().valueAt(a); 2301 if (!publicFlags.itemAt(a) && !includePrivate) { 2302 continue; 2303 } 2304 fprintf(fp, "%s @see #%s_%s\n", 2305 indentStr, nclassName.string(), 2306 flattenSymbol(sym.name).string()); 2307 } 2308 } 2309 fprintf(fp, "%s */\n", getIndentSpace(indent)); 2310 2311 ann.printAnnotations(fp, indentStr); 2312 2313 fprintf(fp, 2314 "%spublic static final int[] %s = {\n" 2315 "%s", 2316 indentStr, nclassName.string(), 2317 getIndentSpace(indent+1)); 2318 2319 for (a=0; a<NA; a++) { 2320 if (a != 0) { 2321 if ((a&3) == 0) { 2322 fprintf(fp, ",\n%s", getIndentSpace(indent+1)); 2323 } else { 2324 fprintf(fp, ", "); 2325 } 2326 } 2327 fprintf(fp, "0x%08x", idents[a]); 2328 } 2329 2330 fprintf(fp, "\n%s};\n", indentStr); 2331 2332 for (a=0; a<NA; a++) { 2333 ssize_t pos = idents.indexOf(origOrder.itemAt(a)); 2334 if (pos >= 0) { 2335 const AaptSymbolEntry& sym = nsymbols->getSymbols().valueAt(a); 2336 if (!publicFlags.itemAt(a) && !includePrivate) { 2337 continue; 2338 } 2339 String8 name8(sym.name); 2340 String16 comment(sym.comment); 2341 String16 typeComment; 2342 if (comment.size() <= 0) { 2343 comment = getAttributeComment(assets, name8, &typeComment); 2344 } else { 2345 getAttributeComment(assets, name8, &typeComment); 2346 } 2347 2348 uint32_t typeSpecFlags = 0; 2349 String16 name16(sym.name); 2350 assets->getIncludedResources().identifierForName( 2351 name16.string(), name16.size(), 2352 attr16.string(), attr16.size(), 2353 package16.string(), package16.size(), &typeSpecFlags); 2354 //printf("%s:%s/%s: 0x%08x\n", String8(package16).string(), 2355 // String8(attr16).string(), String8(name16).string(), typeSpecFlags); 2356 const bool pub = (typeSpecFlags&ResTable_typeSpec::SPEC_PUBLIC) != 0; 2357 2358 AnnotationProcessor ann; 2359 fprintf(fp, "%s/**\n", indentStr); 2360 if (comment.size() > 0) { 2361 String8 cmt(comment); 2362 ann.preprocessComment(cmt); 2363 fprintf(fp, "%s <p>\n%s @attr description\n", indentStr, indentStr); 2364 fprintf(fp, "%s %s\n", indentStr, cmt.string()); 2365 } else { 2366 fprintf(fp, 2367 "%s <p>This symbol is the offset where the {@link %s.R.attr#%s}\n" 2368 "%s attribute's value can be found in the {@link #%s} array.\n", 2369 indentStr, 2370 getSymbolPackage(name8, assets, pub).string(), 2371 getSymbolName(name8).string(), 2372 indentStr, nclassName.string()); 2373 } 2374 if (typeComment.size() > 0) { 2375 String8 cmt(typeComment); 2376 ann.preprocessComment(cmt); 2377 fprintf(fp, "\n\n%s %s\n", indentStr, cmt.string()); 2378 } 2379 if (comment.size() > 0) { 2380 if (pub) { 2381 fprintf(fp, 2382 "%s <p>This corresponds to the global attribute\n" 2383 "%s resource symbol {@link %s.R.attr#%s}.\n", 2384 indentStr, indentStr, 2385 getSymbolPackage(name8, assets, true).string(), 2386 getSymbolName(name8).string()); 2387 } else { 2388 fprintf(fp, 2389 "%s <p>This is a private symbol.\n", indentStr); 2390 } 2391 } 2392 fprintf(fp, "%s @attr name %s:%s\n", indentStr, 2393 getSymbolPackage(name8, assets, pub).string(), 2394 getSymbolName(name8).string()); 2395 fprintf(fp, "%s*/\n", indentStr); 2396 ann.printAnnotations(fp, indentStr); 2397 2398 const char * id_format = nonConstantId ? 2399 "%spublic static int %s_%s = %d;\n" : 2400 "%spublic static final int %s_%s = %d;\n"; 2401 2402 fprintf(fp, 2403 id_format, 2404 indentStr, nclassName.string(), 2405 flattenSymbol(name8).string(), (int)pos); 2406 } 2407 } 2408 } 2409 2410 indent--; 2411 fprintf(fp, "%s};\n", getIndentSpace(indent)); 2412 return hasErrors ? STATUST(UNKNOWN_ERROR) : NO_ERROR; 2413} 2414 2415static status_t writeTextLayoutClasses( 2416 FILE* fp, const sp<AaptAssets>& assets, 2417 const sp<AaptSymbols>& symbols, bool includePrivate) 2418{ 2419 String16 attr16("attr"); 2420 String16 package16(assets->getPackage()); 2421 2422 bool hasErrors = false; 2423 2424 size_t i; 2425 size_t N = symbols->getNestedSymbols().size(); 2426 for (i=0; i<N; i++) { 2427 sp<AaptSymbols> nsymbols = symbols->getNestedSymbols().valueAt(i); 2428 String8 realClassName(symbols->getNestedSymbols().keyAt(i)); 2429 String8 nclassName(flattenSymbol(realClassName)); 2430 2431 SortedVector<uint32_t> idents; 2432 Vector<uint32_t> origOrder; 2433 Vector<bool> publicFlags; 2434 2435 size_t a; 2436 size_t NA = nsymbols->getSymbols().size(); 2437 for (a=0; a<NA; a++) { 2438 const AaptSymbolEntry& sym(nsymbols->getSymbols().valueAt(a)); 2439 int32_t code = sym.typeCode == AaptSymbolEntry::TYPE_INT32 2440 ? sym.int32Val : 0; 2441 bool isPublic = true; 2442 if (code == 0) { 2443 String16 name16(sym.name); 2444 uint32_t typeSpecFlags; 2445 code = assets->getIncludedResources().identifierForName( 2446 name16.string(), name16.size(), 2447 attr16.string(), attr16.size(), 2448 package16.string(), package16.size(), &typeSpecFlags); 2449 if (code == 0) { 2450 fprintf(stderr, "ERROR: In <declare-styleable> %s, unable to find attribute %s\n", 2451 nclassName.string(), sym.name.string()); 2452 hasErrors = true; 2453 } 2454 isPublic = (typeSpecFlags&ResTable_typeSpec::SPEC_PUBLIC) != 0; 2455 } 2456 idents.add(code); 2457 origOrder.add(code); 2458 publicFlags.add(isPublic); 2459 } 2460 2461 NA = idents.size(); 2462 2463 fprintf(fp, "int[] styleable %s {", nclassName.string()); 2464 2465 for (a=0; a<NA; a++) { 2466 if (a != 0) { 2467 fprintf(fp, ","); 2468 } 2469 fprintf(fp, " 0x%08x", idents[a]); 2470 } 2471 2472 fprintf(fp, " }\n"); 2473 2474 for (a=0; a<NA; a++) { 2475 ssize_t pos = idents.indexOf(origOrder.itemAt(a)); 2476 if (pos >= 0) { 2477 const AaptSymbolEntry& sym = nsymbols->getSymbols().valueAt(a); 2478 if (!publicFlags.itemAt(a) && !includePrivate) { 2479 continue; 2480 } 2481 String8 name8(sym.name); 2482 String16 comment(sym.comment); 2483 String16 typeComment; 2484 if (comment.size() <= 0) { 2485 comment = getAttributeComment(assets, name8, &typeComment); 2486 } else { 2487 getAttributeComment(assets, name8, &typeComment); 2488 } 2489 2490 uint32_t typeSpecFlags = 0; 2491 String16 name16(sym.name); 2492 assets->getIncludedResources().identifierForName( 2493 name16.string(), name16.size(), 2494 attr16.string(), attr16.size(), 2495 package16.string(), package16.size(), &typeSpecFlags); 2496 //printf("%s:%s/%s: 0x%08x\n", String8(package16).string(), 2497 // String8(attr16).string(), String8(name16).string(), typeSpecFlags); 2498 //const bool pub = (typeSpecFlags&ResTable_typeSpec::SPEC_PUBLIC) != 0; 2499 2500 fprintf(fp, 2501 "int styleable %s_%s %d\n", 2502 nclassName.string(), 2503 flattenSymbol(name8).string(), (int)pos); 2504 } 2505 } 2506 } 2507 2508 return hasErrors ? STATUST(UNKNOWN_ERROR) : NO_ERROR; 2509} 2510 2511static status_t writeSymbolClass( 2512 FILE* fp, const sp<AaptAssets>& assets, bool includePrivate, 2513 const sp<AaptSymbols>& symbols, const String8& className, int indent, 2514 bool nonConstantId, bool emitCallback) 2515{ 2516 fprintf(fp, "%spublic %sfinal class %s {\n", 2517 getIndentSpace(indent), 2518 indent != 0 ? "static " : "", className.string()); 2519 indent++; 2520 2521 size_t i; 2522 status_t err = NO_ERROR; 2523 2524 const char * id_format = nonConstantId ? 2525 "%spublic static int %s=0x%08x;\n" : 2526 "%spublic static final int %s=0x%08x;\n"; 2527 2528 size_t N = symbols->getSymbols().size(); 2529 for (i=0; i<N; i++) { 2530 const AaptSymbolEntry& sym = symbols->getSymbols().valueAt(i); 2531 if (sym.typeCode != AaptSymbolEntry::TYPE_INT32) { 2532 continue; 2533 } 2534 if (!assets->isJavaSymbol(sym, includePrivate)) { 2535 continue; 2536 } 2537 String8 name8(sym.name); 2538 String16 comment(sym.comment); 2539 bool haveComment = false; 2540 AnnotationProcessor ann; 2541 if (comment.size() > 0) { 2542 haveComment = true; 2543 String8 cmt(comment); 2544 ann.preprocessComment(cmt); 2545 fprintf(fp, 2546 "%s/** %s\n", 2547 getIndentSpace(indent), cmt.string()); 2548 } 2549 String16 typeComment(sym.typeComment); 2550 if (typeComment.size() > 0) { 2551 String8 cmt(typeComment); 2552 ann.preprocessComment(cmt); 2553 if (!haveComment) { 2554 haveComment = true; 2555 fprintf(fp, 2556 "%s/** %s\n", getIndentSpace(indent), cmt.string()); 2557 } else { 2558 fprintf(fp, 2559 "%s %s\n", getIndentSpace(indent), cmt.string()); 2560 } 2561 } 2562 if (haveComment) { 2563 fprintf(fp,"%s */\n", getIndentSpace(indent)); 2564 } 2565 ann.printAnnotations(fp, getIndentSpace(indent)); 2566 fprintf(fp, id_format, 2567 getIndentSpace(indent), 2568 flattenSymbol(name8).string(), (int)sym.int32Val); 2569 } 2570 2571 for (i=0; i<N; i++) { 2572 const AaptSymbolEntry& sym = symbols->getSymbols().valueAt(i); 2573 if (sym.typeCode != AaptSymbolEntry::TYPE_STRING) { 2574 continue; 2575 } 2576 if (!assets->isJavaSymbol(sym, includePrivate)) { 2577 continue; 2578 } 2579 String8 name8(sym.name); 2580 String16 comment(sym.comment); 2581 AnnotationProcessor ann; 2582 if (comment.size() > 0) { 2583 String8 cmt(comment); 2584 ann.preprocessComment(cmt); 2585 fprintf(fp, 2586 "%s/** %s\n" 2587 "%s */\n", 2588 getIndentSpace(indent), cmt.string(), 2589 getIndentSpace(indent)); 2590 } 2591 ann.printAnnotations(fp, getIndentSpace(indent)); 2592 fprintf(fp, "%spublic static final String %s=\"%s\";\n", 2593 getIndentSpace(indent), 2594 flattenSymbol(name8).string(), sym.stringVal.string()); 2595 } 2596 2597 sp<AaptSymbols> styleableSymbols; 2598 2599 N = symbols->getNestedSymbols().size(); 2600 for (i=0; i<N; i++) { 2601 sp<AaptSymbols> nsymbols = symbols->getNestedSymbols().valueAt(i); 2602 String8 nclassName(symbols->getNestedSymbols().keyAt(i)); 2603 if (nclassName == "styleable") { 2604 styleableSymbols = nsymbols; 2605 } else { 2606 err = writeSymbolClass(fp, assets, includePrivate, nsymbols, nclassName, 2607 indent, nonConstantId, false); 2608 } 2609 if (err != NO_ERROR) { 2610 return err; 2611 } 2612 } 2613 2614 if (styleableSymbols != NULL) { 2615 err = writeLayoutClasses(fp, assets, styleableSymbols, indent, includePrivate, nonConstantId); 2616 if (err != NO_ERROR) { 2617 return err; 2618 } 2619 } 2620 2621 if (emitCallback) { 2622 fprintf(fp, "%spublic static void onResourcesLoaded(int packageId) {\n", 2623 getIndentSpace(indent)); 2624 writeResourceLoadedCallback(fp, assets, includePrivate, symbols, className, indent + 1); 2625 fprintf(fp, "%s}\n", getIndentSpace(indent)); 2626 } 2627 2628 indent--; 2629 fprintf(fp, "%s}\n", getIndentSpace(indent)); 2630 return NO_ERROR; 2631} 2632 2633static status_t writeTextSymbolClass( 2634 FILE* fp, const sp<AaptAssets>& assets, bool includePrivate, 2635 const sp<AaptSymbols>& symbols, const String8& className) 2636{ 2637 size_t i; 2638 status_t err = NO_ERROR; 2639 2640 size_t N = symbols->getSymbols().size(); 2641 for (i=0; i<N; i++) { 2642 const AaptSymbolEntry& sym = symbols->getSymbols().valueAt(i); 2643 if (sym.typeCode != AaptSymbolEntry::TYPE_INT32) { 2644 continue; 2645 } 2646 2647 if (!assets->isJavaSymbol(sym, includePrivate)) { 2648 continue; 2649 } 2650 2651 String8 name8(sym.name); 2652 fprintf(fp, "int %s %s 0x%08x\n", 2653 className.string(), 2654 flattenSymbol(name8).string(), (int)sym.int32Val); 2655 } 2656 2657 N = symbols->getNestedSymbols().size(); 2658 for (i=0; i<N; i++) { 2659 sp<AaptSymbols> nsymbols = symbols->getNestedSymbols().valueAt(i); 2660 String8 nclassName(symbols->getNestedSymbols().keyAt(i)); 2661 if (nclassName == "styleable") { 2662 err = writeTextLayoutClasses(fp, assets, nsymbols, includePrivate); 2663 } else { 2664 err = writeTextSymbolClass(fp, assets, includePrivate, nsymbols, nclassName); 2665 } 2666 if (err != NO_ERROR) { 2667 return err; 2668 } 2669 } 2670 2671 return NO_ERROR; 2672} 2673 2674status_t writeResourceSymbols(Bundle* bundle, const sp<AaptAssets>& assets, 2675 const String8& package, bool includePrivate, bool emitCallback) 2676{ 2677 if (!bundle->getRClassDir()) { 2678 return NO_ERROR; 2679 } 2680 2681 const char* textSymbolsDest = bundle->getOutputTextSymbols(); 2682 2683 String8 R("R"); 2684 const size_t N = assets->getSymbols().size(); 2685 for (size_t i=0; i<N; i++) { 2686 sp<AaptSymbols> symbols = assets->getSymbols().valueAt(i); 2687 String8 className(assets->getSymbols().keyAt(i)); 2688 String8 dest(bundle->getRClassDir()); 2689 2690 if (bundle->getMakePackageDirs()) { 2691 String8 pkg(package); 2692 const char* last = pkg.string(); 2693 const char* s = last-1; 2694 do { 2695 s++; 2696 if (s > last && (*s == '.' || *s == 0)) { 2697 String8 part(last, s-last); 2698 dest.appendPath(part); 2699#ifdef _WIN32 2700 _mkdir(dest.string()); 2701#else 2702 mkdir(dest.string(), S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IXGRP); 2703#endif 2704 last = s+1; 2705 } 2706 } while (*s); 2707 } 2708 dest.appendPath(className); 2709 dest.append(".java"); 2710 FILE* fp = fopen(dest.string(), "w+"); 2711 if (fp == NULL) { 2712 fprintf(stderr, "ERROR: Unable to open class file %s: %s\n", 2713 dest.string(), strerror(errno)); 2714 return UNKNOWN_ERROR; 2715 } 2716 if (bundle->getVerbose()) { 2717 printf(" Writing symbols for class %s.\n", className.string()); 2718 } 2719 2720 fprintf(fp, 2721 "/* AUTO-GENERATED FILE. DO NOT MODIFY.\n" 2722 " *\n" 2723 " * This class was automatically generated by the\n" 2724 " * aapt tool from the resource data it found. It\n" 2725 " * should not be modified by hand.\n" 2726 " */\n" 2727 "\n" 2728 "package %s;\n\n", package.string()); 2729 2730 status_t err = writeSymbolClass(fp, assets, includePrivate, symbols, 2731 className, 0, bundle->getNonConstantId(), emitCallback); 2732 fclose(fp); 2733 if (err != NO_ERROR) { 2734 return err; 2735 } 2736 2737 if (textSymbolsDest != NULL && R == className) { 2738 String8 textDest(textSymbolsDest); 2739 textDest.appendPath(className); 2740 textDest.append(".txt"); 2741 2742 FILE* fp = fopen(textDest.string(), "w+"); 2743 if (fp == NULL) { 2744 fprintf(stderr, "ERROR: Unable to open text symbol file %s: %s\n", 2745 textDest.string(), strerror(errno)); 2746 return UNKNOWN_ERROR; 2747 } 2748 if (bundle->getVerbose()) { 2749 printf(" Writing text symbols for class %s.\n", className.string()); 2750 } 2751 2752 status_t err = writeTextSymbolClass(fp, assets, includePrivate, symbols, 2753 className); 2754 fclose(fp); 2755 if (err != NO_ERROR) { 2756 return err; 2757 } 2758 } 2759 2760 // If we were asked to generate a dependency file, we'll go ahead and add this R.java 2761 // as a target in the dependency file right next to it. 2762 if (bundle->getGenDependencies() && R == className) { 2763 // Add this R.java to the dependency file 2764 String8 dependencyFile(bundle->getRClassDir()); 2765 dependencyFile.appendPath("R.java.d"); 2766 2767 FILE *fp = fopen(dependencyFile.string(), "a"); 2768 fprintf(fp,"%s \\\n", dest.string()); 2769 fclose(fp); 2770 } 2771 } 2772 2773 return NO_ERROR; 2774} 2775 2776 2777class ProguardKeepSet 2778{ 2779public: 2780 // { rule --> { file locations } } 2781 KeyedVector<String8, SortedVector<String8> > rules; 2782 2783 void add(const String8& rule, const String8& where); 2784}; 2785 2786void ProguardKeepSet::add(const String8& rule, const String8& where) 2787{ 2788 ssize_t index = rules.indexOfKey(rule); 2789 if (index < 0) { 2790 index = rules.add(rule, SortedVector<String8>()); 2791 } 2792 rules.editValueAt(index).add(where); 2793} 2794 2795void 2796addProguardKeepRule(ProguardKeepSet* keep, const String8& inClassName, 2797 const char* pkg, const String8& srcName, int line) 2798{ 2799 String8 className(inClassName); 2800 if (pkg != NULL) { 2801 // asdf --> package.asdf 2802 // .asdf .a.b --> package.asdf package.a.b 2803 // asdf.adsf --> asdf.asdf 2804 const char* p = className.string(); 2805 const char* q = strchr(p, '.'); 2806 if (p == q) { 2807 className = pkg; 2808 className.append(inClassName); 2809 } else if (q == NULL) { 2810 className = pkg; 2811 className.append("."); 2812 className.append(inClassName); 2813 } 2814 } 2815 2816 String8 rule("-keep class "); 2817 rule += className; 2818 rule += " { <init>(...); }"; 2819 2820 String8 location("view "); 2821 location += srcName; 2822 char lineno[20]; 2823 sprintf(lineno, ":%d", line); 2824 location += lineno; 2825 2826 keep->add(rule, location); 2827} 2828 2829void 2830addProguardKeepMethodRule(ProguardKeepSet* keep, const String8& memberName, 2831 const char* /* pkg */, const String8& srcName, int line) 2832{ 2833 String8 rule("-keepclassmembers class * { *** "); 2834 rule += memberName; 2835 rule += "(...); }"; 2836 2837 String8 location("onClick "); 2838 location += srcName; 2839 char lineno[20]; 2840 sprintf(lineno, ":%d", line); 2841 location += lineno; 2842 2843 keep->add(rule, location); 2844} 2845 2846status_t 2847writeProguardForAndroidManifest(ProguardKeepSet* keep, const sp<AaptAssets>& assets, bool mainDex) 2848{ 2849 status_t err; 2850 ResXMLTree tree; 2851 size_t len; 2852 ResXMLTree::event_code_t code; 2853 int depth = 0; 2854 bool inApplication = false; 2855 String8 error; 2856 sp<AaptGroup> assGroup; 2857 sp<AaptFile> assFile; 2858 String8 pkg; 2859 String8 defaultProcess; 2860 2861 // First, look for a package file to parse. This is required to 2862 // be able to generate the resource information. 2863 assGroup = assets->getFiles().valueFor(String8("AndroidManifest.xml")); 2864 if (assGroup == NULL) { 2865 fprintf(stderr, "ERROR: No AndroidManifest.xml file found.\n"); 2866 return -1; 2867 } 2868 2869 if (assGroup->getFiles().size() != 1) { 2870 fprintf(stderr, "warning: Multiple AndroidManifest.xml files found, using %s\n", 2871 assGroup->getFiles().valueAt(0)->getPrintableSource().string()); 2872 } 2873 2874 assFile = assGroup->getFiles().valueAt(0); 2875 2876 err = parseXMLResource(assFile, &tree); 2877 if (err != NO_ERROR) { 2878 return err; 2879 } 2880 2881 tree.restart(); 2882 2883 while ((code=tree.next()) != ResXMLTree::END_DOCUMENT && code != ResXMLTree::BAD_DOCUMENT) { 2884 if (code == ResXMLTree::END_TAG) { 2885 if (/* name == "Application" && */ depth == 2) { 2886 inApplication = false; 2887 } 2888 depth--; 2889 continue; 2890 } 2891 if (code != ResXMLTree::START_TAG) { 2892 continue; 2893 } 2894 depth++; 2895 String8 tag(tree.getElementName(&len)); 2896 // printf("Depth %d tag %s\n", depth, tag.string()); 2897 bool keepTag = false; 2898 if (depth == 1) { 2899 if (tag != "manifest") { 2900 fprintf(stderr, "ERROR: manifest does not start with <manifest> tag\n"); 2901 return -1; 2902 } 2903 pkg = AaptXml::getAttribute(tree, NULL, "package"); 2904 } else if (depth == 2) { 2905 if (tag == "application") { 2906 inApplication = true; 2907 keepTag = true; 2908 2909 String8 agent = AaptXml::getAttribute(tree, 2910 "http://schemas.android.com/apk/res/android", 2911 "backupAgent", &error); 2912 if (agent.length() > 0) { 2913 addProguardKeepRule(keep, agent, pkg.string(), 2914 assFile->getPrintableSource(), tree.getLineNumber()); 2915 } 2916 2917 if (mainDex) { 2918 defaultProcess = AaptXml::getAttribute(tree, 2919 "http://schemas.android.com/apk/res/android", "process", &error); 2920 if (error != "") { 2921 fprintf(stderr, "ERROR: %s\n", error.string()); 2922 return -1; 2923 } 2924 } 2925 } else if (tag == "instrumentation") { 2926 keepTag = true; 2927 } 2928 } 2929 if (!keepTag && inApplication && depth == 3) { 2930 if (tag == "activity" || tag == "service" || tag == "receiver" || tag == "provider") { 2931 keepTag = true; 2932 } 2933 } 2934 if (keepTag) { 2935 String8 name = AaptXml::getAttribute(tree, 2936 "http://schemas.android.com/apk/res/android", "name", &error); 2937 if (error != "") { 2938 fprintf(stderr, "ERROR: %s\n", error.string()); 2939 return -1; 2940 } 2941 2942 keepTag = name.length() > 0; 2943 2944 if (keepTag && mainDex) { 2945 String8 componentProcess = AaptXml::getAttribute(tree, 2946 "http://schemas.android.com/apk/res/android", "process", &error); 2947 if (error != "") { 2948 fprintf(stderr, "ERROR: %s\n", error.string()); 2949 return -1; 2950 } 2951 2952 const String8& process = 2953 componentProcess.length() > 0 ? componentProcess : defaultProcess; 2954 keepTag = process.length() > 0 && process.find(":") != 0; 2955 } 2956 2957 if (keepTag) { 2958 addProguardKeepRule(keep, name, pkg.string(), 2959 assFile->getPrintableSource(), tree.getLineNumber()); 2960 } 2961 } 2962 } 2963 2964 return NO_ERROR; 2965} 2966 2967struct NamespaceAttributePair { 2968 const char* ns; 2969 const char* attr; 2970 2971 NamespaceAttributePair(const char* n, const char* a) : ns(n), attr(a) {} 2972 NamespaceAttributePair() : ns(NULL), attr(NULL) {} 2973}; 2974 2975status_t 2976writeProguardForXml(ProguardKeepSet* keep, const sp<AaptFile>& layoutFile, 2977 const Vector<String8>& startTags, const KeyedVector<String8, Vector<NamespaceAttributePair> >* tagAttrPairs) 2978{ 2979 status_t err; 2980 ResXMLTree tree; 2981 size_t len; 2982 ResXMLTree::event_code_t code; 2983 2984 err = parseXMLResource(layoutFile, &tree); 2985 if (err != NO_ERROR) { 2986 return err; 2987 } 2988 2989 tree.restart(); 2990 2991 if (!startTags.isEmpty()) { 2992 bool haveStart = false; 2993 while ((code=tree.next()) != ResXMLTree::END_DOCUMENT && code != ResXMLTree::BAD_DOCUMENT) { 2994 if (code != ResXMLTree::START_TAG) { 2995 continue; 2996 } 2997 String8 tag(tree.getElementName(&len)); 2998 const size_t numStartTags = startTags.size(); 2999 for (size_t i = 0; i < numStartTags; i++) { 3000 if (tag == startTags[i]) { 3001 haveStart = true; 3002 } 3003 } 3004 break; 3005 } 3006 if (!haveStart) { 3007 return NO_ERROR; 3008 } 3009 } 3010 3011 while ((code=tree.next()) != ResXMLTree::END_DOCUMENT && code != ResXMLTree::BAD_DOCUMENT) { 3012 if (code != ResXMLTree::START_TAG) { 3013 continue; 3014 } 3015 String8 tag(tree.getElementName(&len)); 3016 3017 // If there is no '.', we'll assume that it's one of the built in names. 3018 if (strchr(tag.string(), '.')) { 3019 addProguardKeepRule(keep, tag, NULL, 3020 layoutFile->getPrintableSource(), tree.getLineNumber()); 3021 } else if (tagAttrPairs != NULL) { 3022 ssize_t tagIndex = tagAttrPairs->indexOfKey(tag); 3023 if (tagIndex >= 0) { 3024 const Vector<NamespaceAttributePair>& nsAttrVector = tagAttrPairs->valueAt(tagIndex); 3025 for (size_t i = 0; i < nsAttrVector.size(); i++) { 3026 const NamespaceAttributePair& nsAttr = nsAttrVector[i]; 3027 3028 ssize_t attrIndex = tree.indexOfAttribute(nsAttr.ns, nsAttr.attr); 3029 if (attrIndex < 0) { 3030 // fprintf(stderr, "%s:%d: <%s> does not have attribute %s:%s.\n", 3031 // layoutFile->getPrintableSource().string(), tree.getLineNumber(), 3032 // tag.string(), nsAttr.ns, nsAttr.attr); 3033 } else { 3034 size_t len; 3035 addProguardKeepRule(keep, 3036 String8(tree.getAttributeStringValue(attrIndex, &len)), NULL, 3037 layoutFile->getPrintableSource(), tree.getLineNumber()); 3038 } 3039 } 3040 } 3041 } 3042 ssize_t attrIndex = tree.indexOfAttribute(RESOURCES_ANDROID_NAMESPACE, "onClick"); 3043 if (attrIndex >= 0) { 3044 size_t len; 3045 addProguardKeepMethodRule(keep, 3046 String8(tree.getAttributeStringValue(attrIndex, &len)), NULL, 3047 layoutFile->getPrintableSource(), tree.getLineNumber()); 3048 } 3049 } 3050 3051 return NO_ERROR; 3052} 3053 3054static void addTagAttrPair(KeyedVector<String8, Vector<NamespaceAttributePair> >* dest, 3055 const char* tag, const char* ns, const char* attr) { 3056 String8 tagStr(tag); 3057 ssize_t index = dest->indexOfKey(tagStr); 3058 3059 if (index < 0) { 3060 Vector<NamespaceAttributePair> vector; 3061 vector.add(NamespaceAttributePair(ns, attr)); 3062 dest->add(tagStr, vector); 3063 } else { 3064 dest->editValueAt(index).add(NamespaceAttributePair(ns, attr)); 3065 } 3066} 3067 3068status_t 3069writeProguardForLayouts(ProguardKeepSet* keep, const sp<AaptAssets>& assets) 3070{ 3071 status_t err; 3072 const char* kClass = "class"; 3073 const char* kFragment = "fragment"; 3074 const String8 kTransition("transition"); 3075 const String8 kTransitionPrefix("transition-"); 3076 3077 // tag:attribute pairs that should be checked in layout files. 3078 KeyedVector<String8, Vector<NamespaceAttributePair> > kLayoutTagAttrPairs; 3079 addTagAttrPair(&kLayoutTagAttrPairs, "view", NULL, kClass); 3080 addTagAttrPair(&kLayoutTagAttrPairs, kFragment, NULL, kClass); 3081 addTagAttrPair(&kLayoutTagAttrPairs, kFragment, RESOURCES_ANDROID_NAMESPACE, "name"); 3082 3083 // tag:attribute pairs that should be checked in xml files. 3084 KeyedVector<String8, Vector<NamespaceAttributePair> > kXmlTagAttrPairs; 3085 addTagAttrPair(&kXmlTagAttrPairs, "PreferenceScreen", RESOURCES_ANDROID_NAMESPACE, kFragment); 3086 addTagAttrPair(&kXmlTagAttrPairs, "header", RESOURCES_ANDROID_NAMESPACE, kFragment); 3087 3088 // tag:attribute pairs that should be checked in transition files. 3089 KeyedVector<String8, Vector<NamespaceAttributePair> > kTransitionTagAttrPairs; 3090 addTagAttrPair(&kTransitionTagAttrPairs, kTransition.string(), NULL, kClass); 3091 addTagAttrPair(&kTransitionTagAttrPairs, "pathMotion", NULL, kClass); 3092 3093 const Vector<sp<AaptDir> >& dirs = assets->resDirs(); 3094 const size_t K = dirs.size(); 3095 for (size_t k=0; k<K; k++) { 3096 const sp<AaptDir>& d = dirs.itemAt(k); 3097 const String8& dirName = d->getLeaf(); 3098 Vector<String8> startTags; 3099 const KeyedVector<String8, Vector<NamespaceAttributePair> >* tagAttrPairs = NULL; 3100 if ((dirName == String8("layout")) || (strncmp(dirName.string(), "layout-", 7) == 0)) { 3101 tagAttrPairs = &kLayoutTagAttrPairs; 3102 } else if ((dirName == String8("xml")) || (strncmp(dirName.string(), "xml-", 4) == 0)) { 3103 startTags.add(String8("PreferenceScreen")); 3104 startTags.add(String8("preference-headers")); 3105 tagAttrPairs = &kXmlTagAttrPairs; 3106 } else if ((dirName == String8("menu")) || (strncmp(dirName.string(), "menu-", 5) == 0)) { 3107 startTags.add(String8("menu")); 3108 tagAttrPairs = NULL; 3109 } else if (dirName == kTransition || (strncmp(dirName.string(), kTransitionPrefix.string(), 3110 kTransitionPrefix.size()) == 0)) { 3111 tagAttrPairs = &kTransitionTagAttrPairs; 3112 } else { 3113 continue; 3114 } 3115 3116 const KeyedVector<String8,sp<AaptGroup> > groups = d->getFiles(); 3117 const size_t N = groups.size(); 3118 for (size_t i=0; i<N; i++) { 3119 const sp<AaptGroup>& group = groups.valueAt(i); 3120 const DefaultKeyedVector<AaptGroupEntry, sp<AaptFile> >& files = group->getFiles(); 3121 const size_t M = files.size(); 3122 for (size_t j=0; j<M; j++) { 3123 err = writeProguardForXml(keep, files.valueAt(j), startTags, tagAttrPairs); 3124 if (err < 0) { 3125 return err; 3126 } 3127 } 3128 } 3129 } 3130 // Handle the overlays 3131 sp<AaptAssets> overlay = assets->getOverlay(); 3132 if (overlay.get()) { 3133 return writeProguardForLayouts(keep, overlay); 3134 } 3135 3136 return NO_ERROR; 3137} 3138 3139status_t 3140writeProguardSpec(const char* filename, const ProguardKeepSet& keep, status_t err) 3141{ 3142 FILE* fp = fopen(filename, "w+"); 3143 if (fp == NULL) { 3144 fprintf(stderr, "ERROR: Unable to open class file %s: %s\n", 3145 filename, strerror(errno)); 3146 return UNKNOWN_ERROR; 3147 } 3148 3149 const KeyedVector<String8, SortedVector<String8> >& rules = keep.rules; 3150 const size_t N = rules.size(); 3151 for (size_t i=0; i<N; i++) { 3152 const SortedVector<String8>& locations = rules.valueAt(i); 3153 const size_t M = locations.size(); 3154 for (size_t j=0; j<M; j++) { 3155 fprintf(fp, "# %s\n", locations.itemAt(j).string()); 3156 } 3157 fprintf(fp, "%s\n\n", rules.keyAt(i).string()); 3158 } 3159 fclose(fp); 3160 3161 return err; 3162} 3163 3164status_t 3165writeProguardFile(Bundle* bundle, const sp<AaptAssets>& assets) 3166{ 3167 status_t err = -1; 3168 3169 if (!bundle->getProguardFile()) { 3170 return NO_ERROR; 3171 } 3172 3173 ProguardKeepSet keep; 3174 3175 err = writeProguardForAndroidManifest(&keep, assets, false); 3176 if (err < 0) { 3177 return err; 3178 } 3179 3180 err = writeProguardForLayouts(&keep, assets); 3181 if (err < 0) { 3182 return err; 3183 } 3184 3185 return writeProguardSpec(bundle->getProguardFile(), keep, err); 3186} 3187 3188status_t 3189writeMainDexProguardFile(Bundle* bundle, const sp<AaptAssets>& assets) 3190{ 3191 status_t err = -1; 3192 3193 if (!bundle->getMainDexProguardFile()) { 3194 return NO_ERROR; 3195 } 3196 3197 ProguardKeepSet keep; 3198 3199 err = writeProguardForAndroidManifest(&keep, assets, true); 3200 if (err < 0) { 3201 return err; 3202 } 3203 3204 return writeProguardSpec(bundle->getMainDexProguardFile(), keep, err); 3205} 3206 3207// Loops through the string paths and writes them to the file pointer 3208// Each file path is written on its own line with a terminating backslash. 3209status_t writePathsToFile(const sp<FilePathStore>& files, FILE* fp) 3210{ 3211 status_t deps = -1; 3212 for (size_t file_i = 0; file_i < files->size(); ++file_i) { 3213 // Add the full file path to the dependency file 3214 fprintf(fp, "%s \\\n", files->itemAt(file_i).string()); 3215 deps++; 3216 } 3217 return deps; 3218} 3219 3220status_t 3221writeDependencyPreReqs(Bundle* /* bundle */, const sp<AaptAssets>& assets, FILE* fp, bool includeRaw) 3222{ 3223 status_t deps = -1; 3224 deps += writePathsToFile(assets->getFullResPaths(), fp); 3225 if (includeRaw) { 3226 deps += writePathsToFile(assets->getFullAssetPaths(), fp); 3227 } 3228 return deps; 3229} 3230