1 // 2 // Copyright 2006 The Android Open Source Project 3 // 4 5 #include "AaptAssets.h" 6 #include "AaptConfig.h" 7 #include "AaptUtil.h" 8 #include "Main.h" 9 #include "ResourceFilter.h" 10 11 #include <utils/misc.h> 12 #include <utils/SortedVector.h> 13 14 #include <ctype.h> 15 #include <dirent.h> 16 #include <errno.h> 17 18 static const char* kAssetDir = "assets"; 19 static const char* kResourceDir = "res"; 20 static const char* kValuesDir = "values"; 21 static const char* kMipmapDir = "mipmap"; 22 static const char* kInvalidChars = "/\\:"; 23 static const size_t kMaxAssetFileName = 100; 24 25 static const String8 kResString(kResourceDir); 26 27 /* 28 * Names of asset files must meet the following criteria: 29 * 30 * - the filename length must be less than kMaxAssetFileName bytes long 31 * (and can't be empty) 32 * - all characters must be 7-bit printable ASCII 33 * - none of { '/' '\\' ':' } 34 * 35 * Pass in just the filename, not the full path. 36 */ 37 static bool validateFileName(const char* fileName) 38 { 39 const char* cp = fileName; 40 size_t len = 0; 41 42 while (*cp != '\0') { 43 if ((*cp & 0x80) != 0) 44 return false; // reject high ASCII 45 if (*cp < 0x20 || *cp >= 0x7f) 46 return false; // reject control chars and 0x7f 47 if (strchr(kInvalidChars, *cp) != NULL) 48 return false; // reject path sep chars 49 cp++; 50 len++; 51 } 52 53 if (len < 1 || len > kMaxAssetFileName) 54 return false; // reject empty or too long 55 56 return true; 57 } 58 59 // The default to use if no other ignore pattern is defined. 60 const char * const gDefaultIgnoreAssets = 61 "!.svn:!.git:!.ds_store:!*.scc:.*:<dir>_*:!CVS:!thumbs.db:!picasa.ini:!*~"; 62 // The ignore pattern that can be passed via --ignore-assets in Main.cpp 63 const char * gUserIgnoreAssets = NULL; 64 65 static bool isHidden(const char *root, const char *path) 66 { 67 // Patterns syntax: 68 // - Delimiter is : 69 // - Entry can start with the flag ! to avoid printing a warning 70 // about the file being ignored. 71 // - Entry can have the flag "<dir>" to match only directories 72 // or <file> to match only files. Default is to match both. 73 // - Entry can be a simplified glob "<prefix>*" or "*<suffix>" 74 // where prefix/suffix must have at least 1 character (so that 75 // we don't match a '*' catch-all pattern.) 76 // - The special filenames "." and ".." are always ignored. 77 // - Otherwise the full string is matched. 78 // - match is not case-sensitive. 79 80 if (strcmp(path, ".") == 0 || strcmp(path, "..") == 0) { 81 return true; 82 } 83 84 const char *delim = ":"; 85 const char *p = gUserIgnoreAssets; 86 if (!p || !p[0]) { 87 p = getenv("ANDROID_AAPT_IGNORE"); 88 } 89 if (!p || !p[0]) { 90 p = gDefaultIgnoreAssets; 91 } 92 char *patterns = strdup(p); 93 94 bool ignore = false; 95 bool chatty = true; 96 char *matchedPattern = NULL; 97 98 String8 fullPath(root); 99 fullPath.appendPath(path); 100 FileType type = getFileType(fullPath); 101 102 int plen = strlen(path); 103 104 // Note: we don't have strtok_r under mingw. 105 for(char *token = strtok(patterns, delim); 106 !ignore && token != NULL; 107 token = strtok(NULL, delim)) { 108 chatty = token[0] != '!'; 109 if (!chatty) token++; // skip ! 110 if (strncasecmp(token, "<dir>" , 5) == 0) { 111 if (type != kFileTypeDirectory) continue; 112 token += 5; 113 } 114 if (strncasecmp(token, "<file>", 6) == 0) { 115 if (type != kFileTypeRegular) continue; 116 token += 6; 117 } 118 119 matchedPattern = token; 120 int n = strlen(token); 121 122 if (token[0] == '*') { 123 // Match *suffix 124 token++; 125 n--; 126 if (n <= plen) { 127 ignore = strncasecmp(token, path + plen - n, n) == 0; 128 } 129 } else if (n > 1 && token[n - 1] == '*') { 130 // Match prefix* 131 ignore = strncasecmp(token, path, n - 1) == 0; 132 } else { 133 ignore = strcasecmp(token, path) == 0; 134 } 135 } 136 137 if (ignore && chatty) { 138 fprintf(stderr, " (skipping %s '%s' due to ANDROID_AAPT_IGNORE pattern '%s')\n", 139 type == kFileTypeDirectory ? "dir" : "file", 140 path, 141 matchedPattern ? matchedPattern : ""); 142 } 143 144 free(patterns); 145 return ignore; 146 } 147 148 // ========================================================================= 149 // ========================================================================= 150 // ========================================================================= 151 152 /* static */ 153 inline bool isAlpha(const String8& string) { 154 const size_t length = string.length(); 155 for (size_t i = 0; i < length; ++i) { 156 if (!isalpha(string[i])) { 157 return false; 158 } 159 } 160 161 return true; 162 } 163 164 /* static */ 165 inline bool isNumber(const String8& string) { 166 const size_t length = string.length(); 167 for (size_t i = 0; i < length; ++i) { 168 if (!isdigit(string[i])) { 169 return false; 170 } 171 } 172 173 return true; 174 } 175 176 void AaptLocaleValue::setLanguage(const char* languageChars) { 177 size_t i = 0; 178 while ((*languageChars) != '\0' && i < sizeof(language)/sizeof(language[0])) { 179 language[i++] = tolower(*languageChars); 180 languageChars++; 181 } 182 } 183 184 void AaptLocaleValue::setRegion(const char* regionChars) { 185 size_t i = 0; 186 while ((*regionChars) != '\0' && i < sizeof(region)/sizeof(region[0])) { 187 region[i++] = toupper(*regionChars); 188 regionChars++; 189 } 190 } 191 192 void AaptLocaleValue::setScript(const char* scriptChars) { 193 size_t i = 0; 194 while ((*scriptChars) != '\0' && i < sizeof(script)/sizeof(script[0])) { 195 if (i == 0) { 196 script[i++] = toupper(*scriptChars); 197 } else { 198 script[i++] = tolower(*scriptChars); 199 } 200 scriptChars++; 201 } 202 } 203 204 void AaptLocaleValue::setVariant(const char* variantChars) { 205 size_t i = 0; 206 while ((*variantChars) != '\0' && i < sizeof(variant)/sizeof(variant[0])) { 207 variant[i++] = *variantChars; 208 variantChars++; 209 } 210 } 211 212 bool AaptLocaleValue::initFromFilterString(const String8& str) { 213 // A locale (as specified in the filter) is an underscore separated name such 214 // as "en_US", "en_Latn_US", or "en_US_POSIX". 215 Vector<String8> parts = AaptUtil::splitAndLowerCase(str, '_'); 216 217 const int numTags = parts.size(); 218 bool valid = false; 219 if (numTags >= 1) { 220 const String8& lang = parts[0]; 221 if (isAlpha(lang) && (lang.length() == 2 || lang.length() == 3)) { 222 setLanguage(lang.string()); 223 valid = true; 224 } 225 } 226 227 if (!valid || numTags == 1) { 228 return valid; 229 } 230 231 // At this point, valid == true && numTags > 1. 232 const String8& part2 = parts[1]; 233 if ((part2.length() == 2 && isAlpha(part2)) || 234 (part2.length() == 3 && isNumber(part2))) { 235 setRegion(part2.string()); 236 } else if (part2.length() == 4 && isAlpha(part2)) { 237 setScript(part2.string()); 238 } else if (part2.length() >= 4 && part2.length() <= 8) { 239 setVariant(part2.string()); 240 } else { 241 valid = false; 242 } 243 244 if (!valid || numTags == 2) { 245 return valid; 246 } 247 248 // At this point, valid == true && numTags > 1. 249 const String8& part3 = parts[2]; 250 if (((part3.length() == 2 && isAlpha(part3)) || 251 (part3.length() == 3 && isNumber(part3))) && script[0]) { 252 setRegion(part3.string()); 253 } else if (part3.length() >= 4 && part3.length() <= 8) { 254 setVariant(part3.string()); 255 } else { 256 valid = false; 257 } 258 259 if (!valid || numTags == 3) { 260 return valid; 261 } 262 263 const String8& part4 = parts[3]; 264 if (part4.length() >= 4 && part4.length() <= 8) { 265 setVariant(part4.string()); 266 } else { 267 valid = false; 268 } 269 270 if (!valid || numTags > 4) { 271 return false; 272 } 273 274 return true; 275 } 276 277 int AaptLocaleValue::initFromDirName(const Vector<String8>& parts, const int startIndex) { 278 const int size = parts.size(); 279 int currentIndex = startIndex; 280 281 String8 part = parts[currentIndex]; 282 if (part[0] == 'b' && part[1] == '+') { 283 // This is a "modified" BCP 47 language tag. Same semantics as BCP 47 tags, 284 // except that the separator is "+" and not "-". 285 Vector<String8> subtags = AaptUtil::splitAndLowerCase(part, '+'); 286 subtags.removeItemsAt(0); 287 if (subtags.size() == 1) { 288 setLanguage(subtags[0]); 289 } else if (subtags.size() == 2) { 290 setLanguage(subtags[0]); 291 292 // The second tag can either be a region, a variant or a script. 293 switch (subtags[1].size()) { 294 case 2: 295 case 3: 296 setRegion(subtags[1]); 297 break; 298 case 4: 299 if (isAlpha(subtags[1])) { 300 setScript(subtags[1]); 301 break; 302 } 303 // This is not alphabetical, so we fall through to variant 304 case 5: 305 case 6: 306 case 7: 307 case 8: 308 setVariant(subtags[1]); 309 break; 310 default: 311 fprintf(stderr, "ERROR: Invalid BCP 47 tag in directory name %s\n", 312 part.string()); 313 return -1; 314 } 315 } else if (subtags.size() == 3) { 316 // The language is always the first subtag. 317 setLanguage(subtags[0]); 318 319 // The second subtag can either be a script or a region code. 320 // If its size is 4, it's a script code, else it's a region code. 321 bool hasRegion = false; 322 if (subtags[1].size() == 4) { 323 setScript(subtags[1]); 324 } else if (subtags[1].size() == 2 || subtags[1].size() == 3) { 325 setRegion(subtags[1]); 326 hasRegion = true; 327 } else { 328 fprintf(stderr, "ERROR: Invalid BCP 47 tag in directory name %s\n", part.string()); 329 return -1; 330 } 331 332 // The third tag can either be a region code (if the second tag was 333 // a script), else a variant code. 334 if (subtags[2].size() >= 4) { 335 setVariant(subtags[2]); 336 } else { 337 setRegion(subtags[2]); 338 } 339 } else if (subtags.size() == 4) { 340 setLanguage(subtags[0]); 341 setScript(subtags[1]); 342 setRegion(subtags[2]); 343 setVariant(subtags[3]); 344 } else { 345 fprintf(stderr, "ERROR: Invalid BCP 47 tag in directory name: %s\n", part.string()); 346 return -1; 347 } 348 349 return ++currentIndex; 350 } else { 351 if ((part.length() == 2 || part.length() == 3) 352 && isAlpha(part) && strcmp("car", part.string())) { 353 setLanguage(part); 354 if (++currentIndex == size) { 355 return size; 356 } 357 } else { 358 return currentIndex; 359 } 360 361 part = parts[currentIndex]; 362 if (part.string()[0] == 'r' && part.length() == 3) { 363 setRegion(part.string() + 1); 364 if (++currentIndex == size) { 365 return size; 366 } 367 } 368 } 369 370 return currentIndex; 371 } 372 373 void AaptLocaleValue::initFromResTable(const ResTable_config& config) { 374 config.unpackLanguage(language); 375 config.unpackRegion(region); 376 if (config.localeScript[0] && !config.localeScriptWasComputed) { 377 memcpy(script, config.localeScript, sizeof(config.localeScript)); 378 } 379 380 if (config.localeVariant[0]) { 381 memcpy(variant, config.localeVariant, sizeof(config.localeVariant)); 382 } 383 } 384 385 void AaptLocaleValue::writeTo(ResTable_config* out) const { 386 out->packLanguage(language); 387 out->packRegion(region); 388 389 if (script[0]) { 390 memcpy(out->localeScript, script, sizeof(out->localeScript)); 391 } 392 393 if (variant[0]) { 394 memcpy(out->localeVariant, variant, sizeof(out->localeVariant)); 395 } 396 } 397 398 bool 399 AaptGroupEntry::initFromDirName(const char* dir, String8* resType) 400 { 401 const char* q = strchr(dir, '-'); 402 size_t typeLen; 403 if (q != NULL) { 404 typeLen = q - dir; 405 } else { 406 typeLen = strlen(dir); 407 } 408 409 String8 type(dir, typeLen); 410 if (!isValidResourceType(type)) { 411 return false; 412 } 413 414 if (q != NULL) { 415 if (!AaptConfig::parse(String8(q + 1), &mParams)) { 416 return false; 417 } 418 } 419 420 *resType = type; 421 return true; 422 } 423 424 String8 425 AaptGroupEntry::toDirName(const String8& resType) const 426 { 427 String8 s = resType; 428 String8 params = mParams.toString(); 429 if (params.length() > 0) { 430 if (s.length() > 0) { 431 s += "-"; 432 } 433 s += params; 434 } 435 return s; 436 } 437 438 439 // ========================================================================= 440 // ========================================================================= 441 // ========================================================================= 442 443 void* AaptFile::editData(size_t size) 444 { 445 if (size <= mBufferSize) { 446 mDataSize = size; 447 return mData; 448 } 449 size_t allocSize = (size*3)/2; 450 void* buf = realloc(mData, allocSize); 451 if (buf == NULL) { 452 return NULL; 453 } 454 mData = buf; 455 mDataSize = size; 456 mBufferSize = allocSize; 457 return buf; 458 } 459 460 void* AaptFile::editDataInRange(size_t offset, size_t size) 461 { 462 return (void*)(((uint8_t*) editData(offset + size)) + offset); 463 } 464 465 void* AaptFile::editData(size_t* outSize) 466 { 467 if (outSize) { 468 *outSize = mDataSize; 469 } 470 return mData; 471 } 472 473 void* AaptFile::padData(size_t wordSize) 474 { 475 const size_t extra = mDataSize%wordSize; 476 if (extra == 0) { 477 return mData; 478 } 479 480 size_t initial = mDataSize; 481 void* data = editData(initial+(wordSize-extra)); 482 if (data != NULL) { 483 memset(((uint8_t*)data) + initial, 0, wordSize-extra); 484 } 485 return data; 486 } 487 488 status_t AaptFile::writeData(const void* data, size_t size) 489 { 490 size_t end = mDataSize; 491 size_t total = size + end; 492 void* buf = editData(total); 493 if (buf == NULL) { 494 return UNKNOWN_ERROR; 495 } 496 memcpy(((char*)buf)+end, data, size); 497 return NO_ERROR; 498 } 499 500 void AaptFile::clearData() 501 { 502 if (mData != NULL) free(mData); 503 mData = NULL; 504 mDataSize = 0; 505 mBufferSize = 0; 506 } 507 508 String8 AaptFile::getPrintableSource() const 509 { 510 if (hasData()) { 511 String8 name(mGroupEntry.toDirName(String8())); 512 name.appendPath(mPath); 513 name.append(" #generated"); 514 return name; 515 } 516 return mSourceFile; 517 } 518 519 // ========================================================================= 520 // ========================================================================= 521 // ========================================================================= 522 523 status_t AaptGroup::addFile(const sp<AaptFile>& file, const bool overwriteDuplicate) 524 { 525 ssize_t index = mFiles.indexOfKey(file->getGroupEntry()); 526 if (index >= 0 && overwriteDuplicate) { 527 fprintf(stderr, "warning: overwriting '%s' with '%s'\n", 528 mFiles[index]->getSourceFile().string(), 529 file->getSourceFile().string()); 530 removeFile(index); 531 index = -1; 532 } 533 534 if (index < 0) { 535 file->mPath = mPath; 536 mFiles.add(file->getGroupEntry(), file); 537 return NO_ERROR; 538 } 539 540 // Check if the version is automatically applied. This is a common source of 541 // error. 542 ConfigDescription withoutVersion = file->getGroupEntry().toParams(); 543 withoutVersion.version = 0; 544 AaptConfig::applyVersionForCompatibility(&withoutVersion); 545 546 const sp<AaptFile>& originalFile = mFiles.valueAt(index); 547 SourcePos(file->getSourceFile(), -1) 548 .error("Duplicate file.\n%s: Original is here. %s", 549 originalFile->getPrintableSource().string(), 550 (withoutVersion.version != 0) ? "The version qualifier may be implied." : ""); 551 return UNKNOWN_ERROR; 552 } 553 554 void AaptGroup::removeFile(size_t index) 555 { 556 mFiles.removeItemsAt(index); 557 } 558 559 void AaptGroup::print(const String8& prefix) const 560 { 561 printf("%s%s\n", prefix.string(), getPath().string()); 562 const size_t N=mFiles.size(); 563 size_t i; 564 for (i=0; i<N; i++) { 565 sp<AaptFile> file = mFiles.valueAt(i); 566 const AaptGroupEntry& e = file->getGroupEntry(); 567 if (file->hasData()) { 568 printf("%s Gen: (%s) %d bytes\n", prefix.string(), e.toDirName(String8()).string(), 569 (int)file->getSize()); 570 } else { 571 printf("%s Src: (%s) %s\n", prefix.string(), e.toDirName(String8()).string(), 572 file->getPrintableSource().string()); 573 } 574 //printf("%s File Group Entry: %s\n", prefix.string(), 575 // file->getGroupEntry().toDirName(String8()).string()); 576 } 577 } 578 579 String8 AaptGroup::getPrintableSource() const 580 { 581 if (mFiles.size() > 0) { 582 // Arbitrarily pull the first source file out of the list. 583 return mFiles.valueAt(0)->getPrintableSource(); 584 } 585 586 // Should never hit this case, but to be safe... 587 return getPath(); 588 589 } 590 591 // ========================================================================= 592 // ========================================================================= 593 // ========================================================================= 594 595 status_t AaptDir::addFile(const String8& name, const sp<AaptGroup>& file) 596 { 597 if (mFiles.indexOfKey(name) >= 0) { 598 return ALREADY_EXISTS; 599 } 600 mFiles.add(name, file); 601 return NO_ERROR; 602 } 603 604 status_t AaptDir::addDir(const String8& name, const sp<AaptDir>& dir) 605 { 606 if (mDirs.indexOfKey(name) >= 0) { 607 return ALREADY_EXISTS; 608 } 609 mDirs.add(name, dir); 610 return NO_ERROR; 611 } 612 613 sp<AaptDir> AaptDir::makeDir(const String8& path) 614 { 615 String8 name; 616 String8 remain = path; 617 618 sp<AaptDir> subdir = this; 619 while (name = remain.walkPath(&remain), remain != "") { 620 subdir = subdir->makeDir(name); 621 } 622 623 ssize_t i = subdir->mDirs.indexOfKey(name); 624 if (i >= 0) { 625 return subdir->mDirs.valueAt(i); 626 } 627 sp<AaptDir> dir = new AaptDir(name, subdir->mPath.appendPathCopy(name)); 628 subdir->mDirs.add(name, dir); 629 return dir; 630 } 631 632 void AaptDir::removeFile(const String8& name) 633 { 634 mFiles.removeItem(name); 635 } 636 637 void AaptDir::removeDir(const String8& name) 638 { 639 mDirs.removeItem(name); 640 } 641 642 status_t AaptDir::addLeafFile(const String8& leafName, const sp<AaptFile>& file, 643 const bool overwrite) 644 { 645 sp<AaptGroup> group; 646 if (mFiles.indexOfKey(leafName) >= 0) { 647 group = mFiles.valueFor(leafName); 648 } else { 649 group = new AaptGroup(leafName, mPath.appendPathCopy(leafName)); 650 mFiles.add(leafName, group); 651 } 652 653 return group->addFile(file, overwrite); 654 } 655 656 ssize_t AaptDir::slurpFullTree(Bundle* bundle, const String8& srcDir, 657 const AaptGroupEntry& kind, const String8& resType, 658 sp<FilePathStore>& fullResPaths, const bool overwrite) 659 { 660 Vector<String8> fileNames; 661 { 662 DIR* dir = NULL; 663 664 dir = opendir(srcDir.string()); 665 if (dir == NULL) { 666 fprintf(stderr, "ERROR: opendir(%s): %s\n", srcDir.string(), strerror(errno)); 667 return UNKNOWN_ERROR; 668 } 669 670 /* 671 * Slurp the filenames out of the directory. 672 */ 673 while (1) { 674 struct dirent* entry; 675 676 entry = readdir(dir); 677 if (entry == NULL) 678 break; 679 680 if (isHidden(srcDir.string(), entry->d_name)) 681 continue; 682 683 String8 name(entry->d_name); 684 fileNames.add(name); 685 // Add fully qualified path for dependency purposes 686 // if we're collecting them 687 if (fullResPaths != NULL) { 688 fullResPaths->add(srcDir.appendPathCopy(name)); 689 } 690 } 691 closedir(dir); 692 } 693 694 ssize_t count = 0; 695 696 /* 697 * Stash away the files and recursively descend into subdirectories. 698 */ 699 const size_t N = fileNames.size(); 700 size_t i; 701 for (i = 0; i < N; i++) { 702 String8 pathName(srcDir); 703 FileType type; 704 705 pathName.appendPath(fileNames[i].string()); 706 type = getFileType(pathName.string()); 707 if (type == kFileTypeDirectory) { 708 sp<AaptDir> subdir; 709 bool notAdded = false; 710 if (mDirs.indexOfKey(fileNames[i]) >= 0) { 711 subdir = mDirs.valueFor(fileNames[i]); 712 } else { 713 subdir = new AaptDir(fileNames[i], mPath.appendPathCopy(fileNames[i])); 714 notAdded = true; 715 } 716 ssize_t res = subdir->slurpFullTree(bundle, pathName, kind, 717 resType, fullResPaths, overwrite); 718 if (res < NO_ERROR) { 719 return res; 720 } 721 if (res > 0 && notAdded) { 722 mDirs.add(fileNames[i], subdir); 723 } 724 count += res; 725 } else if (type == kFileTypeRegular) { 726 sp<AaptFile> file = new AaptFile(pathName, kind, resType); 727 status_t err = addLeafFile(fileNames[i], file, overwrite); 728 if (err != NO_ERROR) { 729 return err; 730 } 731 732 count++; 733 734 } else { 735 if (bundle->getVerbose()) 736 printf(" (ignoring non-file/dir '%s')\n", pathName.string()); 737 } 738 } 739 740 return count; 741 } 742 743 status_t AaptDir::validate() const 744 { 745 const size_t NF = mFiles.size(); 746 const size_t ND = mDirs.size(); 747 size_t i; 748 for (i = 0; i < NF; i++) { 749 if (!validateFileName(mFiles.valueAt(i)->getLeaf().string())) { 750 SourcePos(mFiles.valueAt(i)->getPrintableSource(), -1).error( 751 "Invalid filename. Unable to add."); 752 return UNKNOWN_ERROR; 753 } 754 755 size_t j; 756 for (j = i+1; j < NF; j++) { 757 if (strcasecmp(mFiles.valueAt(i)->getLeaf().string(), 758 mFiles.valueAt(j)->getLeaf().string()) == 0) { 759 SourcePos(mFiles.valueAt(i)->getPrintableSource(), -1).error( 760 "File is case-insensitive equivalent to: %s", 761 mFiles.valueAt(j)->getPrintableSource().string()); 762 return UNKNOWN_ERROR; 763 } 764 765 // TODO: if ".gz", check for non-.gz; if non-, check for ".gz" 766 // (this is mostly caught by the "marked" stuff, below) 767 } 768 769 for (j = 0; j < ND; j++) { 770 if (strcasecmp(mFiles.valueAt(i)->getLeaf().string(), 771 mDirs.valueAt(j)->getLeaf().string()) == 0) { 772 SourcePos(mFiles.valueAt(i)->getPrintableSource(), -1).error( 773 "File conflicts with dir from: %s", 774 mDirs.valueAt(j)->getPrintableSource().string()); 775 return UNKNOWN_ERROR; 776 } 777 } 778 } 779 780 for (i = 0; i < ND; i++) { 781 if (!validateFileName(mDirs.valueAt(i)->getLeaf().string())) { 782 SourcePos(mDirs.valueAt(i)->getPrintableSource(), -1).error( 783 "Invalid directory name, unable to add."); 784 return UNKNOWN_ERROR; 785 } 786 787 size_t j; 788 for (j = i+1; j < ND; j++) { 789 if (strcasecmp(mDirs.valueAt(i)->getLeaf().string(), 790 mDirs.valueAt(j)->getLeaf().string()) == 0) { 791 SourcePos(mDirs.valueAt(i)->getPrintableSource(), -1).error( 792 "Directory is case-insensitive equivalent to: %s", 793 mDirs.valueAt(j)->getPrintableSource().string()); 794 return UNKNOWN_ERROR; 795 } 796 } 797 798 status_t err = mDirs.valueAt(i)->validate(); 799 if (err != NO_ERROR) { 800 return err; 801 } 802 } 803 804 return NO_ERROR; 805 } 806 807 void AaptDir::print(const String8& prefix) const 808 { 809 const size_t ND=getDirs().size(); 810 size_t i; 811 for (i=0; i<ND; i++) { 812 getDirs().valueAt(i)->print(prefix); 813 } 814 815 const size_t NF=getFiles().size(); 816 for (i=0; i<NF; i++) { 817 getFiles().valueAt(i)->print(prefix); 818 } 819 } 820 821 String8 AaptDir::getPrintableSource() const 822 { 823 if (mFiles.size() > 0) { 824 // Arbitrarily pull the first file out of the list as the source dir. 825 return mFiles.valueAt(0)->getPrintableSource().getPathDir(); 826 } 827 if (mDirs.size() > 0) { 828 // Or arbitrarily pull the first dir out of the list as the source dir. 829 return mDirs.valueAt(0)->getPrintableSource().getPathDir(); 830 } 831 832 // Should never hit this case, but to be safe... 833 return mPath; 834 835 } 836 837 // ========================================================================= 838 // ========================================================================= 839 // ========================================================================= 840 841 status_t AaptSymbols::applyJavaSymbols(const sp<AaptSymbols>& javaSymbols) 842 { 843 status_t err = NO_ERROR; 844 size_t N = javaSymbols->mSymbols.size(); 845 for (size_t i=0; i<N; i++) { 846 const String8& name = javaSymbols->mSymbols.keyAt(i); 847 const AaptSymbolEntry& entry = javaSymbols->mSymbols.valueAt(i); 848 ssize_t pos = mSymbols.indexOfKey(name); 849 if (pos < 0) { 850 entry.sourcePos.error("Symbol '%s' declared with <java-symbol> not defined\n", name.string()); 851 err = UNKNOWN_ERROR; 852 continue; 853 } 854 //printf("**** setting symbol #%d/%d %s to isJavaSymbol=%d\n", 855 // i, N, name.string(), entry.isJavaSymbol ? 1 : 0); 856 mSymbols.editValueAt(pos).isJavaSymbol = entry.isJavaSymbol; 857 } 858 859 N = javaSymbols->mNestedSymbols.size(); 860 for (size_t i=0; i<N; i++) { 861 const String8& name = javaSymbols->mNestedSymbols.keyAt(i); 862 const sp<AaptSymbols>& symbols = javaSymbols->mNestedSymbols.valueAt(i); 863 ssize_t pos = mNestedSymbols.indexOfKey(name); 864 if (pos < 0) { 865 SourcePos pos; 866 pos.error("Java symbol dir %s not defined\n", name.string()); 867 err = UNKNOWN_ERROR; 868 continue; 869 } 870 //printf("**** applying java symbols in dir %s\n", name.string()); 871 status_t myerr = mNestedSymbols.valueAt(pos)->applyJavaSymbols(symbols); 872 if (myerr != NO_ERROR) { 873 err = myerr; 874 } 875 } 876 877 return err; 878 } 879 880 // ========================================================================= 881 // ========================================================================= 882 // ========================================================================= 883 884 AaptAssets::AaptAssets() 885 : AaptDir(String8(), String8()), 886 mHavePrivateSymbols(false), 887 mChanged(false), mHaveIncludedAssets(false), 888 mRes(NULL) {} 889 890 const SortedVector<AaptGroupEntry>& AaptAssets::getGroupEntries() const { 891 if (mChanged) { 892 } 893 return mGroupEntries; 894 } 895 896 status_t AaptAssets::addFile(const String8& name, const sp<AaptGroup>& file) 897 { 898 mChanged = true; 899 return AaptDir::addFile(name, file); 900 } 901 902 sp<AaptFile> AaptAssets::addFile( 903 const String8& filePath, const AaptGroupEntry& entry, 904 const String8& srcDir, sp<AaptGroup>* outGroup, 905 const String8& resType) 906 { 907 sp<AaptDir> dir = this; 908 sp<AaptGroup> group; 909 sp<AaptFile> file; 910 String8 root, remain(filePath), partialPath; 911 while (remain.length() > 0) { 912 root = remain.walkPath(&remain); 913 partialPath.appendPath(root); 914 915 const String8 rootStr(root); 916 917 if (remain.length() == 0) { 918 ssize_t i = dir->getFiles().indexOfKey(rootStr); 919 if (i >= 0) { 920 group = dir->getFiles().valueAt(i); 921 } else { 922 group = new AaptGroup(rootStr, filePath); 923 status_t res = dir->addFile(rootStr, group); 924 if (res != NO_ERROR) { 925 return NULL; 926 } 927 } 928 file = new AaptFile(srcDir.appendPathCopy(filePath), entry, resType); 929 status_t res = group->addFile(file); 930 if (res != NO_ERROR) { 931 return NULL; 932 } 933 break; 934 935 } else { 936 ssize_t i = dir->getDirs().indexOfKey(rootStr); 937 if (i >= 0) { 938 dir = dir->getDirs().valueAt(i); 939 } else { 940 sp<AaptDir> subdir = new AaptDir(rootStr, partialPath); 941 status_t res = dir->addDir(rootStr, subdir); 942 if (res != NO_ERROR) { 943 return NULL; 944 } 945 dir = subdir; 946 } 947 } 948 } 949 950 mGroupEntries.add(entry); 951 if (outGroup) *outGroup = group; 952 return file; 953 } 954 955 void AaptAssets::addResource(const String8& leafName, const String8& path, 956 const sp<AaptFile>& file, const String8& resType) 957 { 958 sp<AaptDir> res = AaptDir::makeDir(kResString); 959 String8 dirname = file->getGroupEntry().toDirName(resType); 960 sp<AaptDir> subdir = res->makeDir(dirname); 961 sp<AaptGroup> grr = new AaptGroup(leafName, path); 962 grr->addFile(file); 963 964 subdir->addFile(leafName, grr); 965 } 966 967 968 ssize_t AaptAssets::slurpFromArgs(Bundle* bundle) 969 { 970 int count; 971 int totalCount = 0; 972 FileType type; 973 const Vector<const char *>& resDirs = bundle->getResourceSourceDirs(); 974 const size_t dirCount =resDirs.size(); 975 sp<AaptAssets> current = this; 976 977 const int N = bundle->getFileSpecCount(); 978 979 /* 980 * If a package manifest was specified, include that first. 981 */ 982 if (bundle->getAndroidManifestFile() != NULL) { 983 // place at root of zip. 984 String8 srcFile(bundle->getAndroidManifestFile()); 985 addFile(srcFile.getPathLeaf(), AaptGroupEntry(), srcFile.getPathDir(), 986 NULL, String8()); 987 totalCount++; 988 } 989 990 /* 991 * If a directory of custom assets was supplied, slurp 'em up. 992 */ 993 const Vector<const char*>& assetDirs = bundle->getAssetSourceDirs(); 994 const int AN = assetDirs.size(); 995 for (int i = 0; i < AN; i++) { 996 FileType type = getFileType(assetDirs[i]); 997 if (type == kFileTypeNonexistent) { 998 fprintf(stderr, "ERROR: asset directory '%s' does not exist\n", assetDirs[i]); 999 return UNKNOWN_ERROR; 1000 } 1001 if (type != kFileTypeDirectory) { 1002 fprintf(stderr, "ERROR: '%s' is not a directory\n", assetDirs[i]); 1003 return UNKNOWN_ERROR; 1004 } 1005 1006 String8 assetRoot(assetDirs[i]); 1007 sp<AaptDir> assetAaptDir = makeDir(String8(kAssetDir)); 1008 AaptGroupEntry group; 1009 count = assetAaptDir->slurpFullTree(bundle, assetRoot, group, 1010 String8(), mFullAssetPaths, true); 1011 if (count < 0) { 1012 totalCount = count; 1013 goto bail; 1014 } 1015 if (count > 0) { 1016 mGroupEntries.add(group); 1017 } 1018 totalCount += count; 1019 1020 if (bundle->getVerbose()) { 1021 printf("Found %d custom asset file%s in %s\n", 1022 count, (count==1) ? "" : "s", assetDirs[i]); 1023 } 1024 } 1025 1026 /* 1027 * If a directory of resource-specific assets was supplied, slurp 'em up. 1028 */ 1029 for (size_t i=0; i<dirCount; i++) { 1030 const char *res = resDirs[i]; 1031 if (res) { 1032 type = getFileType(res); 1033 if (type == kFileTypeNonexistent) { 1034 fprintf(stderr, "ERROR: resource directory '%s' does not exist\n", res); 1035 return UNKNOWN_ERROR; 1036 } 1037 if (type == kFileTypeDirectory) { 1038 if (i>0) { 1039 sp<AaptAssets> nextOverlay = new AaptAssets(); 1040 current->setOverlay(nextOverlay); 1041 current = nextOverlay; 1042 current->setFullResPaths(mFullResPaths); 1043 } 1044 count = current->slurpResourceTree(bundle, String8(res)); 1045 if (i > 0 && count > 0) { 1046 count = current->filter(bundle); 1047 } 1048 1049 if (count < 0) { 1050 totalCount = count; 1051 goto bail; 1052 } 1053 totalCount += count; 1054 } 1055 else { 1056 fprintf(stderr, "ERROR: '%s' is not a directory\n", res); 1057 return UNKNOWN_ERROR; 1058 } 1059 } 1060 1061 } 1062 /* 1063 * Now do any additional raw files. 1064 */ 1065 for (int arg=0; arg<N; arg++) { 1066 const char* assetDir = bundle->getFileSpecEntry(arg); 1067 1068 FileType type = getFileType(assetDir); 1069 if (type == kFileTypeNonexistent) { 1070 fprintf(stderr, "ERROR: input directory '%s' does not exist\n", assetDir); 1071 return UNKNOWN_ERROR; 1072 } 1073 if (type != kFileTypeDirectory) { 1074 fprintf(stderr, "ERROR: '%s' is not a directory\n", assetDir); 1075 return UNKNOWN_ERROR; 1076 } 1077 1078 String8 assetRoot(assetDir); 1079 1080 if (bundle->getVerbose()) 1081 printf("Processing raw dir '%s'\n", (const char*) assetDir); 1082 1083 /* 1084 * Do a recursive traversal of subdir tree. We don't make any 1085 * guarantees about ordering, so we're okay with an inorder search 1086 * using whatever order the OS happens to hand back to us. 1087 */ 1088 count = slurpFullTree(bundle, assetRoot, AaptGroupEntry(), String8(), mFullAssetPaths); 1089 if (count < 0) { 1090 /* failure; report error and remove archive */ 1091 totalCount = count; 1092 goto bail; 1093 } 1094 totalCount += count; 1095 1096 if (bundle->getVerbose()) 1097 printf("Found %d asset file%s in %s\n", 1098 count, (count==1) ? "" : "s", assetDir); 1099 } 1100 1101 count = validate(); 1102 if (count != NO_ERROR) { 1103 totalCount = count; 1104 goto bail; 1105 } 1106 1107 count = filter(bundle); 1108 if (count != NO_ERROR) { 1109 totalCount = count; 1110 goto bail; 1111 } 1112 1113 bail: 1114 return totalCount; 1115 } 1116 1117 ssize_t AaptAssets::slurpFullTree(Bundle* bundle, const String8& srcDir, 1118 const AaptGroupEntry& kind, 1119 const String8& resType, 1120 sp<FilePathStore>& fullResPaths, 1121 const bool overwrite) 1122 { 1123 ssize_t res = AaptDir::slurpFullTree(bundle, srcDir, kind, resType, fullResPaths, overwrite); 1124 if (res > 0) { 1125 mGroupEntries.add(kind); 1126 } 1127 1128 return res; 1129 } 1130 1131 ssize_t AaptAssets::slurpResourceTree(Bundle* bundle, const String8& srcDir) 1132 { 1133 ssize_t err = 0; 1134 1135 DIR* dir = opendir(srcDir.string()); 1136 if (dir == NULL) { 1137 fprintf(stderr, "ERROR: opendir(%s): %s\n", srcDir.string(), strerror(errno)); 1138 return UNKNOWN_ERROR; 1139 } 1140 1141 status_t count = 0; 1142 1143 /* 1144 * Run through the directory, looking for dirs that match the 1145 * expected pattern. 1146 */ 1147 while (1) { 1148 struct dirent* entry = readdir(dir); 1149 if (entry == NULL) { 1150 break; 1151 } 1152 1153 if (isHidden(srcDir.string(), entry->d_name)) { 1154 continue; 1155 } 1156 1157 String8 subdirName(srcDir); 1158 subdirName.appendPath(entry->d_name); 1159 1160 AaptGroupEntry group; 1161 String8 resType; 1162 bool b = group.initFromDirName(entry->d_name, &resType); 1163 if (!b) { 1164 fprintf(stderr, "invalid resource directory name: %s %s\n", srcDir.string(), 1165 entry->d_name); 1166 err = -1; 1167 continue; 1168 } 1169 1170 if (bundle->getMaxResVersion() != NULL && group.getVersionString().length() != 0) { 1171 int maxResInt = atoi(bundle->getMaxResVersion()); 1172 const char *verString = group.getVersionString().string(); 1173 int dirVersionInt = atoi(verString + 1); // skip 'v' in version name 1174 if (dirVersionInt > maxResInt) { 1175 fprintf(stderr, "max res %d, skipping %s\n", maxResInt, entry->d_name); 1176 continue; 1177 } 1178 } 1179 1180 FileType type = getFileType(subdirName.string()); 1181 1182 if (type == kFileTypeDirectory) { 1183 sp<AaptDir> dir = makeDir(resType); 1184 ssize_t res = dir->slurpFullTree(bundle, subdirName, group, 1185 resType, mFullResPaths); 1186 if (res < 0) { 1187 count = res; 1188 goto bail; 1189 } 1190 if (res > 0) { 1191 mGroupEntries.add(group); 1192 count += res; 1193 } 1194 1195 // Only add this directory if we don't already have a resource dir 1196 // for the current type. This ensures that we only add the dir once 1197 // for all configs. 1198 sp<AaptDir> rdir = resDir(resType); 1199 if (rdir == NULL) { 1200 mResDirs.add(dir); 1201 } 1202 } else { 1203 if (bundle->getVerbose()) { 1204 fprintf(stderr, " (ignoring file '%s')\n", subdirName.string()); 1205 } 1206 } 1207 } 1208 1209 bail: 1210 closedir(dir); 1211 dir = NULL; 1212 1213 if (err != 0) { 1214 return err; 1215 } 1216 return count; 1217 } 1218 1219 ssize_t 1220 AaptAssets::slurpResourceZip(Bundle* /* bundle */, const char* filename) 1221 { 1222 int count = 0; 1223 SortedVector<AaptGroupEntry> entries; 1224 1225 ZipFile* zip = new ZipFile; 1226 status_t err = zip->open(filename, ZipFile::kOpenReadOnly); 1227 if (err != NO_ERROR) { 1228 fprintf(stderr, "error opening zip file %s\n", filename); 1229 count = err; 1230 delete zip; 1231 return -1; 1232 } 1233 1234 const int N = zip->getNumEntries(); 1235 for (int i=0; i<N; i++) { 1236 ZipEntry* entry = zip->getEntryByIndex(i); 1237 if (entry->getDeleted()) { 1238 continue; 1239 } 1240 1241 String8 entryName(entry->getFileName()); 1242 1243 String8 dirName = entryName.getPathDir(); 1244 sp<AaptDir> dir = dirName == "" ? this : makeDir(dirName); 1245 1246 String8 resType; 1247 AaptGroupEntry kind; 1248 1249 String8 remain; 1250 if (entryName.walkPath(&remain) == kResourceDir) { 1251 // these are the resources, pull their type out of the directory name 1252 kind.initFromDirName(remain.walkPath().string(), &resType); 1253 } else { 1254 // these are untyped and don't have an AaptGroupEntry 1255 } 1256 if (entries.indexOf(kind) < 0) { 1257 entries.add(kind); 1258 mGroupEntries.add(kind); 1259 } 1260 1261 // use the one from the zip file if they both exist. 1262 dir->removeFile(entryName.getPathLeaf()); 1263 1264 sp<AaptFile> file = new AaptFile(entryName, kind, resType); 1265 status_t err = dir->addLeafFile(entryName.getPathLeaf(), file); 1266 if (err != NO_ERROR) { 1267 fprintf(stderr, "err=%s entryName=%s\n", strerror(err), entryName.string()); 1268 count = err; 1269 goto bail; 1270 } 1271 file->setCompressionMethod(entry->getCompressionMethod()); 1272 1273 #if 0 1274 if (entryName == "AndroidManifest.xml") { 1275 printf("AndroidManifest.xml\n"); 1276 } 1277 printf("\n\nfile: %s\n", entryName.string()); 1278 #endif 1279 1280 size_t len = entry->getUncompressedLen(); 1281 void* data = zip->uncompress(entry); 1282 void* buf = file->editData(len); 1283 memcpy(buf, data, len); 1284 1285 #if 0 1286 const int OFF = 0; 1287 const unsigned char* p = (unsigned char*)data; 1288 const unsigned char* end = p+len; 1289 p += OFF; 1290 for (int i=0; i<32 && p < end; i++) { 1291 printf("0x%03x ", i*0x10 + OFF); 1292 for (int j=0; j<0x10 && p < end; j++) { 1293 printf(" %02x", *p); 1294 p++; 1295 } 1296 printf("\n"); 1297 } 1298 #endif 1299 1300 free(data); 1301 1302 count++; 1303 } 1304 1305 bail: 1306 delete zip; 1307 return count; 1308 } 1309 1310 status_t AaptAssets::filter(Bundle* bundle) 1311 { 1312 WeakResourceFilter reqFilter; 1313 status_t err = reqFilter.parse(bundle->getConfigurations()); 1314 if (err != NO_ERROR) { 1315 return err; 1316 } 1317 1318 uint32_t preferredDensity = 0; 1319 if (bundle->getPreferredDensity().size() > 0) { 1320 ResTable_config preferredConfig; 1321 if (!AaptConfig::parseDensity(bundle->getPreferredDensity().string(), &preferredConfig)) { 1322 fprintf(stderr, "Error parsing preferred density: %s\n", 1323 bundle->getPreferredDensity().string()); 1324 return UNKNOWN_ERROR; 1325 } 1326 preferredDensity = preferredConfig.density; 1327 } 1328 1329 if (reqFilter.isEmpty() && preferredDensity == 0) { 1330 return NO_ERROR; 1331 } 1332 1333 if (bundle->getVerbose()) { 1334 if (!reqFilter.isEmpty()) { 1335 printf("Applying required filter: %s\n", 1336 bundle->getConfigurations().string()); 1337 } 1338 if (preferredDensity > 0) { 1339 printf("Applying preferred density filter: %s\n", 1340 bundle->getPreferredDensity().string()); 1341 } 1342 } 1343 1344 const Vector<sp<AaptDir> >& resdirs = mResDirs; 1345 const size_t ND = resdirs.size(); 1346 for (size_t i=0; i<ND; i++) { 1347 const sp<AaptDir>& dir = resdirs.itemAt(i); 1348 if (dir->getLeaf() == kValuesDir) { 1349 // The "value" dir is special since a single file defines 1350 // multiple resources, so we can not do filtering on the 1351 // files themselves. 1352 continue; 1353 } 1354 if (dir->getLeaf() == kMipmapDir) { 1355 // We also skip the "mipmap" directory, since the point of this 1356 // is to include all densities without stripping. If you put 1357 // other configurations in here as well they won't be stripped 1358 // either... So don't do that. Seriously. What is wrong with you? 1359 continue; 1360 } 1361 1362 const size_t NG = dir->getFiles().size(); 1363 for (size_t j=0; j<NG; j++) { 1364 sp<AaptGroup> grp = dir->getFiles().valueAt(j); 1365 1366 // First remove any configurations we know we don't need. 1367 for (size_t k=0; k<grp->getFiles().size(); k++) { 1368 sp<AaptFile> file = grp->getFiles().valueAt(k); 1369 if (k == 0 && grp->getFiles().size() == 1) { 1370 // If this is the only file left, we need to keep it. 1371 // Otherwise the resource IDs we are using will be inconsistent 1372 // with what we get when not stripping. Sucky, but at least 1373 // for now we can rely on the back-end doing another filtering 1374 // pass to take this out and leave us with this resource name 1375 // containing no entries. 1376 continue; 1377 } 1378 if (file->getPath().getPathExtension() == ".xml") { 1379 // We can't remove .xml files at this point, because when 1380 // we parse them they may add identifier resources, so 1381 // removing them can cause our resource identifiers to 1382 // become inconsistent. 1383 continue; 1384 } 1385 const ResTable_config& config(file->getGroupEntry().toParams()); 1386 if (!reqFilter.match(config)) { 1387 if (bundle->getVerbose()) { 1388 printf("Pruning unneeded resource: %s\n", 1389 file->getPrintableSource().string()); 1390 } 1391 grp->removeFile(k); 1392 k--; 1393 } 1394 } 1395 1396 // Quick check: no preferred filters, nothing more to do. 1397 if (preferredDensity == 0) { 1398 continue; 1399 } 1400 1401 // Get the preferred density if there is one. We do not match exactly for density. 1402 // If our preferred density is hdpi but we only have mdpi and xhdpi resources, we 1403 // pick xhdpi. 1404 for (size_t k=0; k<grp->getFiles().size(); k++) { 1405 sp<AaptFile> file = grp->getFiles().valueAt(k); 1406 if (k == 0 && grp->getFiles().size() == 1) { 1407 // If this is the only file left, we need to keep it. 1408 // Otherwise the resource IDs we are using will be inconsistent 1409 // with what we get when not stripping. Sucky, but at least 1410 // for now we can rely on the back-end doing another filtering 1411 // pass to take this out and leave us with this resource name 1412 // containing no entries. 1413 continue; 1414 } 1415 if (file->getPath().getPathExtension() == ".xml") { 1416 // We can't remove .xml files at this point, because when 1417 // we parse them they may add identifier resources, so 1418 // removing them can cause our resource identifiers to 1419 // become inconsistent. 1420 continue; 1421 } 1422 const ResTable_config& config(file->getGroupEntry().toParams()); 1423 if (config.density != 0 && config.density != preferredDensity) { 1424 // This is a resource we would prefer not to have. Check 1425 // to see if have a similar variation that we would like 1426 // to have and, if so, we can drop it. 1427 uint32_t bestDensity = config.density; 1428 1429 for (size_t m=0; m<grp->getFiles().size(); m++) { 1430 if (m == k) { 1431 continue; 1432 } 1433 1434 sp<AaptFile> mfile = grp->getFiles().valueAt(m); 1435 const ResTable_config& mconfig(mfile->getGroupEntry().toParams()); 1436 if (AaptConfig::isSameExcept(config, mconfig, ResTable_config::CONFIG_DENSITY)) { 1437 // See if there is a better density resource 1438 if (mconfig.density < bestDensity && 1439 mconfig.density >= preferredDensity && 1440 bestDensity > preferredDensity) { 1441 // This density is our preferred density, or between our best density and 1442 // the preferred density, therefore it is better. 1443 bestDensity = mconfig.density; 1444 } else if (mconfig.density > bestDensity && 1445 bestDensity < preferredDensity) { 1446 // This density is better than our best density and 1447 // our best density was smaller than our preferred 1448 // density, so it is better. 1449 bestDensity = mconfig.density; 1450 } 1451 } 1452 } 1453 1454 if (bestDensity != config.density) { 1455 if (bundle->getVerbose()) { 1456 printf("Pruning unneeded resource: %s\n", 1457 file->getPrintableSource().string()); 1458 } 1459 grp->removeFile(k); 1460 k--; 1461 } 1462 } 1463 } 1464 } 1465 } 1466 1467 return NO_ERROR; 1468 } 1469 1470 sp<AaptSymbols> AaptAssets::getSymbolsFor(const String8& name) 1471 { 1472 sp<AaptSymbols> sym = mSymbols.valueFor(name); 1473 if (sym == NULL) { 1474 sym = new AaptSymbols(); 1475 mSymbols.add(name, sym); 1476 } 1477 return sym; 1478 } 1479 1480 sp<AaptSymbols> AaptAssets::getJavaSymbolsFor(const String8& name) 1481 { 1482 sp<AaptSymbols> sym = mJavaSymbols.valueFor(name); 1483 if (sym == NULL) { 1484 sym = new AaptSymbols(); 1485 mJavaSymbols.add(name, sym); 1486 } 1487 return sym; 1488 } 1489 1490 status_t AaptAssets::applyJavaSymbols() 1491 { 1492 size_t N = mJavaSymbols.size(); 1493 for (size_t i=0; i<N; i++) { 1494 const String8& name = mJavaSymbols.keyAt(i); 1495 const sp<AaptSymbols>& symbols = mJavaSymbols.valueAt(i); 1496 ssize_t pos = mSymbols.indexOfKey(name); 1497 if (pos < 0) { 1498 SourcePos pos; 1499 pos.error("Java symbol dir %s not defined\n", name.string()); 1500 return UNKNOWN_ERROR; 1501 } 1502 //printf("**** applying java symbols in dir %s\n", name.string()); 1503 status_t err = mSymbols.valueAt(pos)->applyJavaSymbols(symbols); 1504 if (err != NO_ERROR) { 1505 return err; 1506 } 1507 } 1508 1509 return NO_ERROR; 1510 } 1511 1512 bool AaptAssets::isJavaSymbol(const AaptSymbolEntry& sym, bool includePrivate) const { 1513 //printf("isJavaSymbol %s: public=%d, includePrivate=%d, isJavaSymbol=%d\n", 1514 // sym.name.string(), sym.isPublic ? 1 : 0, includePrivate ? 1 : 0, 1515 // sym.isJavaSymbol ? 1 : 0); 1516 if (!mHavePrivateSymbols) return true; 1517 if (sym.isPublic) return true; 1518 if (includePrivate && sym.isJavaSymbol) return true; 1519 return false; 1520 } 1521 1522 status_t AaptAssets::buildIncludedResources(Bundle* bundle) 1523 { 1524 if (mHaveIncludedAssets) { 1525 return NO_ERROR; 1526 } 1527 1528 // Add in all includes. 1529 const Vector<String8>& includes = bundle->getPackageIncludes(); 1530 const size_t packageIncludeCount = includes.size(); 1531 for (size_t i = 0; i < packageIncludeCount; i++) { 1532 if (bundle->getVerbose()) { 1533 printf("Including resources from package: %s\n", includes[i].string()); 1534 } 1535 1536 if (!mIncludedAssets.addAssetPath(includes[i], NULL)) { 1537 fprintf(stderr, "ERROR: Asset package include '%s' not found.\n", 1538 includes[i].string()); 1539 return UNKNOWN_ERROR; 1540 } 1541 } 1542 1543 const String8& featureOfBase = bundle->getFeatureOfPackage(); 1544 if (!featureOfBase.isEmpty()) { 1545 if (bundle->getVerbose()) { 1546 printf("Including base feature resources from package: %s\n", 1547 featureOfBase.string()); 1548 } 1549 1550 if (!mIncludedAssets.addAssetPath(featureOfBase, NULL)) { 1551 fprintf(stderr, "ERROR: base feature package '%s' not found.\n", 1552 featureOfBase.string()); 1553 return UNKNOWN_ERROR; 1554 } 1555 } 1556 1557 mHaveIncludedAssets = true; 1558 1559 return NO_ERROR; 1560 } 1561 1562 status_t AaptAssets::addIncludedResources(const sp<AaptFile>& file) 1563 { 1564 const ResTable& res = getIncludedResources(); 1565 // XXX dirty! 1566 return const_cast<ResTable&>(res).add(file->getData(), file->getSize()); 1567 } 1568 1569 const ResTable& AaptAssets::getIncludedResources() const 1570 { 1571 return mIncludedAssets.getResources(false); 1572 } 1573 1574 AssetManager& AaptAssets::getAssetManager() 1575 { 1576 return mIncludedAssets; 1577 } 1578 1579 void AaptAssets::print(const String8& prefix) const 1580 { 1581 String8 innerPrefix(prefix); 1582 innerPrefix.append(" "); 1583 String8 innerInnerPrefix(innerPrefix); 1584 innerInnerPrefix.append(" "); 1585 printf("%sConfigurations:\n", prefix.string()); 1586 const size_t N=mGroupEntries.size(); 1587 for (size_t i=0; i<N; i++) { 1588 String8 cname = mGroupEntries.itemAt(i).toDirName(String8()); 1589 printf("%s %s\n", prefix.string(), 1590 cname != "" ? cname.string() : "(default)"); 1591 } 1592 1593 printf("\n%sFiles:\n", prefix.string()); 1594 AaptDir::print(innerPrefix); 1595 1596 printf("\n%sResource Dirs:\n", prefix.string()); 1597 const Vector<sp<AaptDir> >& resdirs = mResDirs; 1598 const size_t NR = resdirs.size(); 1599 for (size_t i=0; i<NR; i++) { 1600 const sp<AaptDir>& d = resdirs.itemAt(i); 1601 printf("%s Type %s\n", prefix.string(), d->getLeaf().string()); 1602 d->print(innerInnerPrefix); 1603 } 1604 } 1605 1606 sp<AaptDir> AaptAssets::resDir(const String8& name) const 1607 { 1608 const Vector<sp<AaptDir> >& resdirs = mResDirs; 1609 const size_t N = resdirs.size(); 1610 for (size_t i=0; i<N; i++) { 1611 const sp<AaptDir>& d = resdirs.itemAt(i); 1612 if (d->getLeaf() == name) { 1613 return d; 1614 } 1615 } 1616 return NULL; 1617 } 1618 1619 bool 1620 valid_symbol_name(const String8& symbol) 1621 { 1622 static char const * const KEYWORDS[] = { 1623 "abstract", "assert", "boolean", "break", 1624 "byte", "case", "catch", "char", "class", "const", "continue", 1625 "default", "do", "double", "else", "enum", "extends", "final", 1626 "finally", "float", "for", "goto", "if", "implements", "import", 1627 "instanceof", "int", "interface", "long", "native", "new", "package", 1628 "private", "protected", "public", "return", "short", "static", 1629 "strictfp", "super", "switch", "synchronized", "this", "throw", 1630 "throws", "transient", "try", "void", "volatile", "while", 1631 "true", "false", "null", 1632 NULL 1633 }; 1634 const char*const* k = KEYWORDS; 1635 const char*const s = symbol.string(); 1636 while (*k) { 1637 if (0 == strcmp(s, *k)) { 1638 return false; 1639 } 1640 k++; 1641 } 1642 return true; 1643 } 1644
