AaptAssets.cpp

   1 //
   2 // Copyright 2006 The Android Open Source Project
   3 //
   4
   5 #include "AaptAssets.h"
   6 #include "Main.h"
   7
   8 #include <utils/misc.h>
   9 #include <utils/SortedVector.h>
  10
  11 #include <ctype.h>
  12 #include <dirent.h>
  13 #include <errno.h>
  14
  15 static const char* kDefaultLocale = "default";
  16 static const char* kWildcardName = "any";
  17 static const char* kAssetDir = "assets";
  18 static const char* kResourceDir = "res";
  19 static const char* kInvalidChars = "/\\:";
  20 static const size_t kMaxAssetFileName = 100;
  21
  22 static const String8 kResString(kResourceDir);
  23
  24 /*
  25  * Names of asset files must meet the following criteria:
  26  *
  27  *  - the filename length must be less than kMaxAssetFileName bytes long
  28  *    (and can't be empty)
  29  *  - all characters must be 7-bit printable ASCII
  30  *  - none of { '/' '\\' ':' }
  31  *
  32  * Pass in just the filename, not the full path.
  33  */
  34 static bool validateFileName(const char* fileName)
  35 {
  36     const char* cp = fileName;
  37     size_t len = 0;
  38
  39     while (*cp != '\0') {
  40         if ((*cp & 0x80) != 0)
  41             return false;           // reject high ASCII
  42         if (*cp < 0x20 || *cp >= 0x7f)
  43             return false;           // reject control chars and 0x7f
  44         if (strchr(kInvalidChars, *cp) != NULL)
  45             return false;           // reject path sep chars
  46         cp++;
  47         len++;
  48     }
  49
  50     if (len < 1 || len > kMaxAssetFileName)
  51         return false;               // reject empty or too long
  52
  53     return true;
  54 }
  55
  56 static bool isHidden(const char *root, const char *path)
  57 {
  58     const char *ext  = NULL;
  59     const char *type = NULL;
  60
  61     // Skip all hidden files.
  62     if (path[0] == '.') {
  63         // Skip ., .. and  .svn but don't chatter about it.
  64         if (strcmp(path, ".") == 0
  65             || strcmp(path, "..") == 0
  66             || strcmp(path, ".svn") == 0) {
  67             return true;
  68         }
  69         type = "hidden";
  70     } else if (path[0] == '_') {
  71         // skip directories starting with _ (don't chatter about it)
  72         String8 subdirName(root);
  73         subdirName.appendPath(path);
  74         if (getFileType(subdirName.string()) == kFileTypeDirectory) {
  75             return true;
  76         }
  77     } else if (strcmp(path, "CVS") == 0) {
  78         // Skip CVS but don't chatter about it.
  79         return true;
  80     } else if (strcasecmp(path, "thumbs.db") == 0
  81                || strcasecmp(path, "picasa.ini") == 0) {
  82         // Skip suspected image indexes files.
  83         type = "index";
  84     } else if (path[strlen(path)-1] == '~') {
  85         // Skip suspected emacs backup files.
  86         type = "backup";
  87     } else if ((ext = strrchr(path, '.')) != NULL && strcmp(ext, ".scc") == 0) {
  88         // Skip VisualSourceSafe files and don't chatter about it
  89         return true;
  90     } else {
  91         // Let everything else through.
  92         return false;
  93     }
  94
  95     /* If we get this far, "type" should be set and the file
  96      * should be skipped.
  97      */
  98     String8 subdirName(root);
  99     subdirName.appendPath(path);
 100     fprintf(stderr, "    (skipping %s %s '%s')\n", type,
 101             getFileType(subdirName.string())==kFileTypeDirectory ? "dir":"file",
 102             subdirName.string());
 103
 104     return true;
 105 }
 106
 107 // =========================================================================
 108 // =========================================================================
 109 // =========================================================================
 110
 111 status_t
 112 AaptGroupEntry::parseNamePart(const String8& part, int* axis, uint32_t* value)
 113 {
 114     ResTable_config config;
 115
 116     // IMSI - MCC
 117     if (getMccName(part.string(), &config)) {
 118         *axis = AXIS_MCC;
 119         *value = config.mcc;
 120         return 0;
 121     }
 122
 123     // IMSI - MNC
 124     if (getMncName(part.string(), &config)) {
 125         *axis = AXIS_MNC;
 126         *value = config.mnc;
 127         return 0;
 128     }
 129
 130     // locale - language
 131     if (part.length() == 2 && isalpha(part[0]) && isalpha(part[1])) {
 132         *axis = AXIS_LANGUAGE;
 133         *value = part[1] << 8 | part[0];
 134         return 0;
 135     }
 136
 137     // locale - language_REGION
 138     if (part.length() == 5 && isalpha(part[0]) && isalpha(part[1])
 139             && part[2] == '_' && isalpha(part[3]) && isalpha(part[4])) {
 140         *axis = AXIS_LANGUAGE;
 141         *value = (part[4] << 24) | (part[3] << 16) | (part[1] << 8) | (part[0]);
 142         return 0;
 143     }
 144
 145     // smallest screen dp width
 146     if (getSmallestScreenWidthDpName(part.string(), &config)) {
 147         *axis = AXIS_SMALLESTSCREENWIDTHDP;
 148         *value = config.smallestScreenWidthDp;
 149         return 0;
 150     }
 151
 152     // screen dp width
 153     if (getScreenWidthDpName(part.string(), &config)) {
 154         *axis = AXIS_SCREENWIDTHDP;
 155         *value = config.screenWidthDp;
 156         return 0;
 157     }
 158
 159     // screen dp height
 160     if (getScreenHeightDpName(part.string(), &config)) {
 161         *axis = AXIS_SCREENHEIGHTDP;
 162         *value = config.screenHeightDp;
 163         return 0;
 164     }
 165
 166     // screen layout size
 167     if (getScreenLayoutSizeName(part.string(), &config)) {
 168         *axis = AXIS_SCREENLAYOUTSIZE;
 169         *value = (config.screenLayout&ResTable_config::MASK_SCREENSIZE);
 170         return 0;
 171     }
 172
 173     // screen layout long
 174     if (getScreenLayoutLongName(part.string(), &config)) {
 175         *axis = AXIS_SCREENLAYOUTLONG;
 176         *value = (config.screenLayout&ResTable_config::MASK_SCREENLONG);
 177         return 0;
 178     }
 179
 180     // orientation
 181     if (getOrientationName(part.string(), &config)) {
 182         *axis = AXIS_ORIENTATION;
 183         *value = config.orientation;
 184         return 0;
 185     }
 186
 187     // ui mode type
 188     if (getUiModeTypeName(part.string(), &config)) {
 189         *axis = AXIS_UIMODETYPE;
 190         *value = (config.uiMode&ResTable_config::MASK_UI_MODE_TYPE);
 191         return 0;
 192     }
 193
 194     // ui mode night
 195     if (getUiModeNightName(part.string(), &config)) {
 196         *axis = AXIS_UIMODENIGHT;
 197         *value = (config.uiMode&ResTable_config::MASK_UI_MODE_NIGHT);
 198         return 0;
 199     }
 200
 201     // density
 202     if (getDensityName(part.string(), &config)) {
 203         *axis = AXIS_DENSITY;
 204         *value = config.density;
 205         return 0;
 206     }
 207
 208     // touchscreen
 209     if (getTouchscreenName(part.string(), &config)) {
 210         *axis = AXIS_TOUCHSCREEN;
 211         *value = config.touchscreen;
 212         return 0;
 213     }
 214
 215     // keyboard hidden
 216     if (getKeysHiddenName(part.string(), &config)) {
 217         *axis = AXIS_KEYSHIDDEN;
 218         *value = config.inputFlags;
 219         return 0;
 220     }
 221
 222     // keyboard
 223     if (getKeyboardName(part.string(), &config)) {
 224         *axis = AXIS_KEYBOARD;
 225         *value = config.keyboard;
 226         return 0;
 227     }
 228
 229     // navigation hidden
 230     if (getNavHiddenName(part.string(), &config)) {
 231         *axis = AXIS_NAVHIDDEN;
 232         *value = config.inputFlags;
 233         return 0;
 234     }
 235
 236     // navigation
 237     if (getNavigationName(part.string(), &config)) {
 238         *axis = AXIS_NAVIGATION;
 239         *value = config.navigation;
 240         return 0;
 241     }
 242
 243     // screen size
 244     if (getScreenSizeName(part.string(), &config)) {
 245         *axis = AXIS_SCREENSIZE;
 246         *value = config.screenSize;
 247         return 0;
 248     }
 249
 250     // version
 251     if (getVersionName(part.string(), &config)) {
 252         *axis = AXIS_VERSION;
 253         *value = config.version;
 254         return 0;
 255     }
 256
 257     return 1;
 258 }
 259
 260 bool
 261 AaptGroupEntry::initFromDirName(const char* dir, String8* resType)
 262 {
 263     Vector<String8> parts;
 264
 265     String8 mcc, mnc, loc, layoutsize, layoutlong, orient, den;
 266     String8 touch, key, keysHidden, nav, navHidden, size, vers;
 267     String8 uiModeType, uiModeNight, smallestwidthdp, widthdp, heightdp;
 268
 269     const char *p = dir;
 270     const char *q;
 271     while (NULL != (q = strchr(p, '-'))) {
 272         String8 val(p, q-p);
 273         val.toLower();
 274         parts.add(val);
 275         //printf("part: %s\n", parts[parts.size()-1].string());
 276         p = q+1;
 277     }
 278     String8 val(p);
 279     val.toLower();
 280     parts.add(val);
 281     //printf("part: %s\n", parts[parts.size()-1].string());
 282
 283     const int N = parts.size();
 284     int index = 0;
 285     String8 part = parts[index];
 286
 287     // resource type
 288     if (!isValidResourceType(part)) {
 289         return false;
 290     }
 291     *resType = part;
 292
 293     index++;
 294     if (index == N) {
 295         goto success;
 296     }
 297     part = parts[index];
 298
 299     // imsi - mcc
 300     if (getMccName(part.string())) {
 301         mcc = part;
 302
 303         index++;
 304         if (index == N) {
 305             goto success;
 306         }
 307         part = parts[index];
 308     } else {
 309         //printf("not mcc: %s\n", part.string());
 310     }
 311
 312     // imsi - mnc
 313     if (getMncName(part.string())) {
 314         mnc = part;
 315
 316         index++;
 317         if (index == N) {
 318             goto success;
 319         }
 320         part = parts[index];
 321     } else {
 322         //printf("not mcc: %s\n", part.string());
 323     }
 324
 325     // locale - language
 326     if (part.length() == 2 && isalpha(part[0]) && isalpha(part[1])) {
 327         loc = part;
 328
 329         index++;
 330         if (index == N) {
 331             goto success;
 332         }
 333         part = parts[index];
 334     } else {
 335         //printf("not language: %s\n", part.string());
 336     }
 337
 338     // locale - region
 339     if (loc.length() > 0
 340             && part.length() == 3 && part[0] == 'r' && part[0] && part[1]) {
 341         loc += "-";
 342         part.toUpper();
 343         loc += part.string() + 1;
 344
 345         index++;
 346         if (index == N) {
 347             goto success;
 348         }
 349         part = parts[index];
 350     } else {
 351         //printf("not region: %s\n", part.string());
 352     }
 353
 354     if (getSmallestScreenWidthDpName(part.string())) {
 355         smallestwidthdp = part;
 356
 357         index++;
 358         if (index == N) {
 359             goto success;
 360         }
 361         part = parts[index];
 362     } else {
 363         //printf("not smallest screen width dp: %s\n", part.string());
 364     }
 365
 366     if (getScreenWidthDpName(part.string())) {
 367         widthdp = part;
 368
 369         index++;
 370         if (index == N) {
 371             goto success;
 372         }
 373         part = parts[index];
 374     } else {
 375         //printf("not screen width dp: %s\n", part.string());
 376     }
 377
 378     if (getScreenHeightDpName(part.string())) {
 379         heightdp = part;
 380
 381         index++;
 382         if (index == N) {
 383             goto success;
 384         }
 385         part = parts[index];
 386     } else {
 387         //printf("not screen height dp: %s\n", part.string());
 388     }
 389
 390     if (getScreenLayoutSizeName(part.string())) {
 391         layoutsize = part;
 392
 393         index++;
 394         if (index == N) {
 395             goto success;
 396         }
 397         part = parts[index];
 398     } else {
 399         //printf("not screen layout size: %s\n", part.string());
 400     }
 401
 402     if (getScreenLayoutLongName(part.string())) {
 403         layoutlong = part;
 404
 405         index++;
 406         if (index == N) {
 407             goto success;
 408         }
 409         part = parts[index];
 410     } else {
 411         //printf("not screen layout long: %s\n", part.string());
 412     }
 413
 414     // orientation
 415     if (getOrientationName(part.string())) {
 416         orient = part;
 417
 418         index++;
 419         if (index == N) {
 420             goto success;
 421         }
 422         part = parts[index];
 423     } else {
 424         //printf("not orientation: %s\n", part.string());
 425     }
 426
 427     // ui mode type
 428     if (getUiModeTypeName(part.string())) {
 429         uiModeType = part;
 430
 431         index++;
 432         if (index == N) {
 433             goto success;
 434         }
 435         part = parts[index];
 436     } else {
 437         //printf("not ui mode type: %s\n", part.string());
 438     }
 439
 440     // ui mode night
 441     if (getUiModeNightName(part.string())) {
 442         uiModeNight = part;
 443
 444         index++;
 445         if (index == N) {
 446             goto success;
 447         }
 448         part = parts[index];
 449     } else {
 450         //printf("not ui mode night: %s\n", part.string());
 451     }
 452
 453     // density
 454     if (getDensityName(part.string())) {
 455         den = part;
 456
 457         index++;
 458         if (index == N) {
 459             goto success;
 460         }
 461         part = parts[index];
 462     } else {
 463         //printf("not density: %s\n", part.string());
 464     }
 465
 466     // touchscreen
 467     if (getTouchscreenName(part.string())) {
 468         touch = part;
 469
 470         index++;
 471         if (index == N) {
 472             goto success;
 473         }
 474         part = parts[index];
 475     } else {
 476         //printf("not touchscreen: %s\n", part.string());
 477     }
 478
 479     // keyboard hidden
 480     if (getKeysHiddenName(part.string())) {
 481         keysHidden = part;
 482
 483         index++;
 484         if (index == N) {
 485             goto success;
 486         }
 487         part = parts[index];
 488     } else {
 489         //printf("not keysHidden: %s\n", part.string());
 490     }
 491
 492     // keyboard
 493     if (getKeyboardName(part.string())) {
 494         key = part;
 495
 496         index++;
 497         if (index == N) {
 498             goto success;
 499         }
 500         part = parts[index];
 501     } else {
 502         //printf("not keyboard: %s\n", part.string());
 503     }
 504
 505     // navigation hidden
 506     if (getNavHiddenName(part.string())) {
 507         navHidden = part;
 508
 509         index++;
 510         if (index == N) {
 511             goto success;
 512         }
 513         part = parts[index];
 514     } else {
 515         //printf("not navHidden: %s\n", part.string());
 516     }
 517
 518     if (getNavigationName(part.string())) {
 519         nav = part;
 520
 521         index++;
 522         if (index == N) {
 523             goto success;
 524         }
 525         part = parts[index];
 526     } else {
 527         //printf("not navigation: %s\n", part.string());
 528     }
 529
 530     if (getScreenSizeName(part.string())) {
 531         size = part;
 532
 533         index++;
 534         if (index == N) {
 535             goto success;
 536         }
 537         part = parts[index];
 538     } else {
 539         //printf("not screen size: %s\n", part.string());
 540     }
 541
 542     if (getVersionName(part.string())) {
 543         vers = part;
 544
 545         index++;
 546         if (index == N) {
 547             goto success;
 548         }
 549         part = parts[index];
 550     } else {
 551         //printf("not version: %s\n", part.string());
 552     }
 553
 554     // if there are extra parts, it doesn't match
 555     return false;
 556
 557 success:
 558     this->mcc = mcc;
 559     this->mnc = mnc;
 560     this->locale = loc;
 561     this->screenLayoutSize = layoutsize;
 562     this->screenLayoutLong = layoutlong;
 563     this->smallestScreenWidthDp = smallestwidthdp;
 564     this->screenWidthDp = widthdp;
 565     this->screenHeightDp = heightdp;
 566     this->orientation = orient;
 567     this->uiModeType = uiModeType;
 568     this->uiModeNight = uiModeNight;
 569     this->density = den;
 570     this->touchscreen = touch;
 571     this->keysHidden = keysHidden;
 572     this->keyboard = key;
 573     this->navHidden = navHidden;
 574     this->navigation = nav;
 575     this->screenSize = size;
 576     this->version = vers;
 577
 578     // what is this anyway?
 579     this->vendor = "";
 580
 581     return true;
 582 }
 583
 584 String8
 585 AaptGroupEntry::toString() const
 586 {
 587     String8 s = this->mcc;
 588     s += ",";
 589     s += this->mnc;
 590     s += ",";
 591     s += this->locale;
 592     s += ",";
 593     s += smallestScreenWidthDp;
 594     s += ",";
 595     s += screenWidthDp;
 596     s += ",";
 597     s += screenHeightDp;
 598     s += ",";
 599     s += screenLayoutSize;
 600     s += ",";
 601     s += screenLayoutLong;
 602     s += ",";
 603     s += this->orientation;
 604     s += ",";
 605     s += uiModeType;
 606     s += ",";
 607     s += uiModeNight;
 608     s += ",";
 609     s += density;
 610     s += ",";
 611     s += touchscreen;
 612     s += ",";
 613     s += keysHidden;
 614     s += ",";
 615     s += keyboard;
 616     s += ",";
 617     s += navHidden;
 618     s += ",";
 619     s += navigation;
 620     s += ",";
 621     s += screenSize;
 622     s += ",";
 623     s += version;
 624     return s;
 625 }
 626
 627 String8
 628 AaptGroupEntry::toDirName(const String8& resType) const
 629 {
 630     String8 s = resType;
 631     if (this->mcc != "") {
 632         s += "-";
 633         s += mcc;
 634     }
 635     if (this->mnc != "") {
 636         s += "-";
 637         s += mnc;
 638     }
 639     if (this->locale != "") {
 640         s += "-";
 641         s += locale;
 642     }
 643     if (this->smallestScreenWidthDp != "") {
 644         s += "-";
 645         s += smallestScreenWidthDp;
 646     }
 647     if (this->screenWidthDp != "") {
 648         s += "-";
 649         s += screenWidthDp;
 650     }
 651     if (this->screenHeightDp != "") {
 652         s += "-";
 653         s += screenHeightDp;
 654     }
 655     if (this->screenLayoutSize != "") {
 656         s += "-";
 657         s += screenLayoutSize;
 658     }
 659     if (this->screenLayoutLong != "") {
 660         s += "-";
 661         s += screenLayoutLong;
 662     }
 663     if (this->orientation != "") {
 664         s += "-";
 665         s += orientation;
 666     }
 667     if (this->uiModeType != "") {
 668         s += "-";
 669         s += uiModeType;
 670     }
 671     if (this->uiModeNight != "") {
 672         s += "-";
 673         s += uiModeNight;
 674     }
 675     if (this->density != "") {
 676         s += "-";
 677         s += density;
 678     }
 679     if (this->touchscreen != "") {
 680         s += "-";
 681         s += touchscreen;
 682     }
 683     if (this->keysHidden != "") {
 684         s += "-";
 685         s += keysHidden;
 686     }
 687     if (this->keyboard != "") {
 688         s += "-";
 689         s += keyboard;
 690     }
 691     if (this->navHidden != "") {
 692         s += "-";
 693         s += navHidden;
 694     }
 695     if (this->navigation != "") {
 696         s += "-";
 697         s += navigation;
 698     }
 699     if (this->screenSize != "") {
 700         s += "-";
 701         s += screenSize;
 702     }
 703     if (this->version != "") {
 704         s += "-";
 705         s += version;
 706     }
 707
 708     return s;
 709 }
 710
 711 bool AaptGroupEntry::getMccName(const char* name,
 712                                     ResTable_config* out)
 713 {
 714     if (strcmp(name, kWildcardName) == 0) {
 715         if (out) out->mcc = 0;
 716         return true;
 717     }
 718     const char* c = name;
 719     if (tolower(*c) != 'm') return false;
 720     c++;
 721     if (tolower(*c) != 'c') return false;
 722     c++;
 723     if (tolower(*c) != 'c') return false;
 724     c++;
 725
 726     const char* val = c;
 727
 728     while (*c >= '0' && *c <= '9') {
 729         c++;
 730     }
 731     if (*c != 0) return false;
 732     if (c-val != 3) return false;
 733
 734     int d = atoi(val);
 735     if (d != 0) {
 736         if (out) out->mcc = d;
 737         return true;
 738     }
 739
 740     return false;
 741 }
 742
 743 bool AaptGroupEntry::getMncName(const char* name,
 744                                     ResTable_config* out)
 745 {
 746     if (strcmp(name, kWildcardName) == 0) {
 747         if (out) out->mcc = 0;
 748         return true;
 749     }
 750     const char* c = name;
 751     if (tolower(*c) != 'm') return false;
 752     c++;
 753     if (tolower(*c) != 'n') return false;
 754     c++;
 755     if (tolower(*c) != 'c') return false;
 756     c++;
 757
 758     const char* val = c;
 759
 760     while (*c >= '0' && *c <= '9') {
 761         c++;
 762     }
 763     if (*c != 0) return false;
 764     if (c-val == 0 || c-val > 3) return false;
 765
 766     if (out) {
 767         out->mnc = atoi(val);
 768     }
 769
 770     return true;
 771 }
 772
 773 /*
 774  * Does this directory name fit the pattern of a locale dir ("en-rUS" or
 775  * "default")?
 776  *
 777  * TODO: Should insist that the first two letters are lower case, and the
 778  * second two are upper.
 779  */
 780 bool AaptGroupEntry::getLocaleName(const char* fileName,
 781                                    ResTable_config* out)
 782 {
 783     if (strcmp(fileName, kWildcardName) == 0
 784             || strcmp(fileName, kDefaultLocale) == 0) {
 785         if (out) {
 786             out->language[0] = 0;
 787             out->language[1] = 0;
 788             out->country[0] = 0;
 789             out->country[1] = 0;
 790         }
 791         return true;
 792     }
 793
 794     if (strlen(fileName) == 2 && isalpha(fileName[0]) && isalpha(fileName[1])) {
 795         if (out) {
 796             out->language[0] = fileName[0];
 797             out->language[1] = fileName[1];
 798             out->country[0] = 0;
 799             out->country[1] = 0;
 800         }
 801         return true;
 802     }
 803
 804     if (strlen(fileName) == 5 &&
 805         isalpha(fileName[0]) &&
 806         isalpha(fileName[1]) &&
 807         fileName[2] == '-' &&
 808         isalpha(fileName[3]) &&
 809         isalpha(fileName[4])) {
 810         if (out) {
 811             out->language[0] = fileName[0];
 812             out->language[1] = fileName[1];
 813             out->country[0] = fileName[3];
 814             out->country[1] = fileName[4];
 815         }
 816         return true;
 817     }
 818
 819     return false;
 820 }
 821
 822 bool AaptGroupEntry::getScreenLayoutSizeName(const char* name,
 823                                      ResTable_config* out)
 824 {
 825     if (strcmp(name, kWildcardName) == 0) {
 826         if (out) out->screenLayout =
 827                 (out->screenLayout&~ResTable_config::MASK_SCREENSIZE)
 828                 | ResTable_config::SCREENSIZE_ANY;
 829         return true;
 830     } else if (strcmp(name, "small") == 0) {
 831         if (out) out->screenLayout =
 832                 (out->screenLayout&~ResTable_config::MASK_SCREENSIZE)
 833                 | ResTable_config::SCREENSIZE_SMALL;
 834         return true;
 835     } else if (strcmp(name, "normal") == 0) {
 836         if (out) out->screenLayout =
 837                 (out->screenLayout&~ResTable_config::MASK_SCREENSIZE)
 838                 | ResTable_config::SCREENSIZE_NORMAL;
 839         return true;
 840     } else if (strcmp(name, "large") == 0) {
 841         if (out) out->screenLayout =
 842                 (out->screenLayout&~ResTable_config::MASK_SCREENSIZE)
 843                 | ResTable_config::SCREENSIZE_LARGE;
 844         return true;
 845     } else if (strcmp(name, "xlarge") == 0) {
 846         if (out) out->screenLayout =
 847                 (out->screenLayout&~ResTable_config::MASK_SCREENSIZE)
 848                 | ResTable_config::SCREENSIZE_XLARGE;
 849         return true;
 850     }
 851
 852     return false;
 853 }
 854
 855 bool AaptGroupEntry::getScreenLayoutLongName(const char* name,
 856                                      ResTable_config* out)
 857 {
 858     if (strcmp(name, kWildcardName) == 0) {
 859         if (out) out->screenLayout =
 860                 (out->screenLayout&~ResTable_config::MASK_SCREENLONG)
 861                 | ResTable_config::SCREENLONG_ANY;
 862         return true;
 863     } else if (strcmp(name, "long") == 0) {
 864         if (out) out->screenLayout =
 865                 (out->screenLayout&~ResTable_config::MASK_SCREENLONG)
 866                 | ResTable_config::SCREENLONG_YES;
 867         return true;
 868     } else if (strcmp(name, "notlong") == 0) {
 869         if (out) out->screenLayout =
 870                 (out->screenLayout&~ResTable_config::MASK_SCREENLONG)
 871                 | ResTable_config::SCREENLONG_NO;
 872         return true;
 873     }
 874
 875     return false;
 876 }
 877
 878 bool AaptGroupEntry::getOrientationName(const char* name,
 879                                         ResTable_config* out)
 880 {
 881     if (strcmp(name, kWildcardName) == 0) {
 882         if (out) out->orientation = out->ORIENTATION_ANY;
 883         return true;
 884     } else if (strcmp(name, "port") == 0) {
 885         if (out) out->orientation = out->ORIENTATION_PORT;
 886         return true;
 887     } else if (strcmp(name, "land") == 0) {
 888         if (out) out->orientation = out->ORIENTATION_LAND;
 889         return true;
 890     } else if (strcmp(name, "square") == 0) {
 891         if (out) out->orientation = out->ORIENTATION_SQUARE;
 892         return true;
 893     }
 894
 895     return false;
 896 }
 897
 898 bool AaptGroupEntry::getUiModeTypeName(const char* name,
 899                                        ResTable_config* out)
 900 {
 901     if (strcmp(name, kWildcardName) == 0) {
 902         if (out) out->uiMode =
 903                 (out->uiMode&~ResTable_config::MASK_UI_MODE_TYPE)
 904                 | ResTable_config::UI_MODE_TYPE_ANY;
 905         return true;
 906     } else if (strcmp(name, "desk") == 0) {
 907       if (out) out->uiMode =
 908               (out->uiMode&~ResTable_config::MASK_UI_MODE_TYPE)
 909               | ResTable_config::UI_MODE_TYPE_DESK;
 910         return true;
 911     } else if (strcmp(name, "car") == 0) {
 912       if (out) out->uiMode =
 913               (out->uiMode&~ResTable_config::MASK_UI_MODE_TYPE)
 914               | ResTable_config::UI_MODE_TYPE_CAR;
 915         return true;
 916     } else if (strcmp(name, "television") == 0) {
 917       if (out) out->uiMode =
 918               (out->uiMode&~ResTable_config::MASK_UI_MODE_TYPE)
 919               | ResTable_config::UI_MODE_TYPE_TELEVISION;
 920         return true;
 921     }
 922
 923     return false;
 924 }
 925
 926 bool AaptGroupEntry::getUiModeNightName(const char* name,
 927                                           ResTable_config* out)
 928 {
 929     if (strcmp(name, kWildcardName) == 0) {
 930         if (out) out->uiMode =
 931                 (out->uiMode&~ResTable_config::MASK_UI_MODE_NIGHT)
 932                 | ResTable_config::UI_MODE_NIGHT_ANY;
 933         return true;
 934     } else if (strcmp(name, "night") == 0) {
 935         if (out) out->uiMode =
 936                 (out->uiMode&~ResTable_config::MASK_UI_MODE_NIGHT)
 937                 | ResTable_config::UI_MODE_NIGHT_YES;
 938         return true;
 939     } else if (strcmp(name, "notnight") == 0) {
 940       if (out) out->uiMode =
 941               (out->uiMode&~ResTable_config::MASK_UI_MODE_NIGHT)
 942               | ResTable_config::UI_MODE_NIGHT_NO;
 943         return true;
 944     }
 945
 946     return false;
 947 }
 948
 949 bool AaptGroupEntry::getDensityName(const char* name,
 950                                     ResTable_config* out)
 951 {
 952     if (strcmp(name, kWildcardName) == 0) {
 953         if (out) out->density = ResTable_config::DENSITY_DEFAULT;
 954         return true;
 955     }
 956
 957     if (strcmp(name, "nodpi") == 0) {
 958         if (out) out->density = ResTable_config::DENSITY_NONE;
 959         return true;
 960     }
 961
 962     if (strcmp(name, "ldpi") == 0) {
 963         if (out) out->density = ResTable_config::DENSITY_LOW;
 964         return true;
 965     }
 966
 967     if (strcmp(name, "mdpi") == 0) {
 968         if (out) out->density = ResTable_config::DENSITY_MEDIUM;
 969         return true;
 970     }
 971
 972     if (strcmp(name, "tvdpi") == 0) {
 973         if (out) out->density = ResTable_config::DENSITY_TV;
 974         return true;
 975     }
 976
 977     if (strcmp(name, "hdpi") == 0) {
 978         if (out) out->density = ResTable_config::DENSITY_HIGH;
 979         return true;
 980     }
 981
 982     if (strcmp(name, "xhdpi") == 0) {
 983         if (out) out->density = ResTable_config::DENSITY_MEDIUM*2;
 984         return true;
 985     }
 986
 987     char* c = (char*)name;
 988     while (*c >= '0' && *c <= '9') {
 989         c++;
 990     }
 991
 992     // check that we have 'dpi' after the last digit.
 993     if (toupper(c[0]) != 'D' ||
 994             toupper(c[1]) != 'P' ||
 995             toupper(c[2]) != 'I' ||
 996             c[3] != 0) {
 997         return false;
 998     }
 999
1000     // temporarily replace the first letter with \0 to
1001     // use atoi.
1002     char tmp = c[0];
1003     c[0] = '\0';
1004
1005     int d = atoi(name);
1006     c[0] = tmp;
1007
1008     if (d != 0) {
1009         if (out) out->density = d;
1010         return true;
1011     }
1012
1013     return false;
1014 }
1015
1016 bool AaptGroupEntry::getTouchscreenName(const char* name,
1017                                         ResTable_config* out)
1018 {
1019     if (strcmp(name, kWildcardName) == 0) {
1020         if (out) out->touchscreen = out->TOUCHSCREEN_ANY;
1021         return true;
1022     } else if (strcmp(name, "notouch") == 0) {
1023         if (out) out->touchscreen = out->TOUCHSCREEN_NOTOUCH;
1024         return true;
1025     } else if (strcmp(name, "stylus") == 0) {
1026         if (out) out->touchscreen = out->TOUCHSCREEN_STYLUS;
1027         return true;
1028     } else if (strcmp(name, "finger") == 0) {
1029         if (out) out->touchscreen = out->TOUCHSCREEN_FINGER;
1030         return true;
1031     }
1032
1033     return false;
1034 }
1035
1036 bool AaptGroupEntry::getKeysHiddenName(const char* name,
1037                                        ResTable_config* out)
1038 {
1039     uint8_t mask = 0;
1040     uint8_t value = 0;
1041     if (strcmp(name, kWildcardName) == 0) {
1042         mask = ResTable_config::MASK_KEYSHIDDEN;
1043         value = ResTable_config::KEYSHIDDEN_ANY;
1044     } else if (strcmp(name, "keysexposed") == 0) {
1045         mask = ResTable_config::MASK_KEYSHIDDEN;
1046         value = ResTable_config::KEYSHIDDEN_NO;
1047     } else if (strcmp(name, "keyshidden") == 0) {
1048         mask = ResTable_config::MASK_KEYSHIDDEN;
1049         value = ResTable_config::KEYSHIDDEN_YES;
1050     } else if (strcmp(name, "keyssoft") == 0) {
1051         mask = ResTable_config::MASK_KEYSHIDDEN;
1052         value = ResTable_config::KEYSHIDDEN_SOFT;
1053     }
1054
1055     if (mask != 0) {
1056         if (out) out->inputFlags = (out->inputFlags&~mask) | value;
1057         return true;
1058     }
1059
1060     return false;
1061 }
1062
1063 bool AaptGroupEntry::getKeyboardName(const char* name,
1064                                         ResTable_config* out)
1065 {
1066     if (strcmp(name, kWildcardName) == 0) {
1067         if (out) out->keyboard = out->KEYBOARD_ANY;
1068         return true;
1069     } else if (strcmp(name, "nokeys") == 0) {
1070         if (out) out->keyboard = out->KEYBOARD_NOKEYS;
1071         return true;
1072     } else if (strcmp(name, "qwerty") == 0) {
1073         if (out) out->keyboard = out->KEYBOARD_QWERTY;
1074         return true;
1075     } else if (strcmp(name, "12key") == 0) {
1076         if (out) out->keyboard = out->KEYBOARD_12KEY;
1077         return true;
1078     }
1079
1080     return false;
1081 }
1082
1083 bool AaptGroupEntry::getNavHiddenName(const char* name,
1084                                        ResTable_config* out)
1085 {
1086     uint8_t mask = 0;
1087     uint8_t value = 0;
1088     if (strcmp(name, kWildcardName) == 0) {
1089         mask = ResTable_config::MASK_NAVHIDDEN;
1090         value = ResTable_config::NAVHIDDEN_ANY;
1091     } else if (strcmp(name, "navexposed") == 0) {
1092         mask = ResTable_config::MASK_NAVHIDDEN;
1093         value = ResTable_config::NAVHIDDEN_NO;
1094     } else if (strcmp(name, "navhidden") == 0) {
1095         mask = ResTable_config::MASK_NAVHIDDEN;
1096         value = ResTable_config::NAVHIDDEN_YES;
1097     }
1098
1099     if (mask != 0) {
1100         if (out) out->inputFlags = (out->inputFlags&~mask) | value;
1101         return true;
1102     }
1103
1104     return false;
1105 }
1106
1107 bool AaptGroupEntry::getNavigationName(const char* name,
1108                                      ResTable_config* out)
1109 {
1110     if (strcmp(name, kWildcardName) == 0) {
1111         if (out) out->navigation = out->NAVIGATION_ANY;
1112         return true;
1113     } else if (strcmp(name, "nonav") == 0) {
1114         if (out) out->navigation = out->NAVIGATION_NONAV;
1115         return true;
1116     } else if (strcmp(name, "dpad") == 0) {
1117         if (out) out->navigation = out->NAVIGATION_DPAD;
1118         return true;
1119     } else if (strcmp(name, "trackball") == 0) {
1120         if (out) out->navigation = out->NAVIGATION_TRACKBALL;
1121         return true;
1122     } else if (strcmp(name, "wheel") == 0) {
1123         if (out) out->navigation = out->NAVIGATION_WHEEL;
1124         return true;
1125     }
1126
1127     return false;
1128 }
1129
1130 bool AaptGroupEntry::getScreenSizeName(const char* name, ResTable_config* out)
1131 {
1132     if (strcmp(name, kWildcardName) == 0) {
1133         if (out) {
1134             out->screenWidth = out->SCREENWIDTH_ANY;
1135             out->screenHeight = out->SCREENHEIGHT_ANY;
1136         }
1137         return true;
1138     }
1139
1140     const char* x = name;
1141     while (*x >= '0' && *x <= '9') x++;
1142     if (x == name || *x != 'x') return false;
1143     String8 xName(name, x-name);
1144     x++;
1145
1146     const char* y = x;
1147     while (*y >= '0' && *y <= '9') y++;
1148     if (y == name || *y != 0) return false;
1149     String8 yName(x, y-x);
1150
1151     uint16_t w = (uint16_t)atoi(xName.string());
1152     uint16_t h = (uint16_t)atoi(yName.string());
1153     if (w < h) {
1154         return false;
1155     }
1156
1157     if (out) {
1158         out->screenWidth = w;
1159         out->screenHeight = h;
1160     }
1161
1162     return true;
1163 }
1164
1165 bool AaptGroupEntry::getSmallestScreenWidthDpName(const char* name, ResTable_config* out)
1166 {
1167     if (strcmp(name, kWildcardName) == 0) {
1168         if (out) {
1169             out->smallestScreenWidthDp = out->SCREENWIDTH_ANY;
1170         }
1171         return true;
1172     }
1173
1174     if (*name != 's') return false;
1175     name++;
1176     if (*name != 'w') return false;
1177     name++;
1178     const char* x = name;
1179     while (*x >= '0' && *x <= '9') x++;
1180     if (x == name || x[0] != 'd' || x[1] != 'p' || x[2] != 0) return false;
1181     String8 xName(name, x-name);
1182
1183     if (out) {
1184         out->smallestScreenWidthDp = (uint16_t)atoi(xName.string());
1185     }
1186
1187     return true;
1188 }
1189
1190 bool AaptGroupEntry::getScreenWidthDpName(const char* name, ResTable_config* out)
1191 {
1192     if (strcmp(name, kWildcardName) == 0) {
1193         if (out) {
1194             out->screenWidthDp = out->SCREENWIDTH_ANY;
1195         }
1196         return true;
1197     }
1198
1199     if (*name != 'w') return false;
1200     name++;
1201     const char* x = name;
1202     while (*x >= '0' && *x <= '9') x++;
1203     if (x == name || x[0] != 'd' || x[1] != 'p' || x[2] != 0) return false;
1204     String8 xName(name, x-name);
1205
1206     if (out) {
1207         out->screenWidthDp = (uint16_t)atoi(xName.string());
1208     }
1209
1210     return true;
1211 }
1212
1213 bool AaptGroupEntry::getScreenHeightDpName(const char* name, ResTable_config* out)
1214 {
1215     if (strcmp(name, kWildcardName) == 0) {
1216         if (out) {
1217             out->screenHeightDp = out->SCREENWIDTH_ANY;
1218         }
1219         return true;
1220     }
1221
1222     if (*name != 'h') return false;
1223     name++;
1224     const char* x = name;
1225     while (*x >= '0' && *x <= '9') x++;
1226     if (x == name || x[0] != 'd' || x[1] != 'p' || x[2] != 0) return false;
1227     String8 xName(name, x-name);
1228
1229     if (out) {
1230         out->screenHeightDp = (uint16_t)atoi(xName.string());
1231     }
1232
1233     return true;
1234 }
1235
1236 bool AaptGroupEntry::getVersionName(const char* name, ResTable_config* out)
1237 {
1238     if (strcmp(name, kWildcardName) == 0) {
1239         if (out) {
1240             out->sdkVersion = out->SDKVERSION_ANY;
1241             out->minorVersion = out->MINORVERSION_ANY;
1242         }
1243         return true;
1244     }
1245
1246     if (*name != 'v') {
1247         return false;
1248     }
1249
1250     name++;
1251     const char* s = name;
1252     while (*s >= '0' && *s <= '9') s++;
1253     if (s == name || *s != 0) return false;
1254     String8 sdkName(name, s-name);
1255
1256     if (out) {
1257         out->sdkVersion = (uint16_t)atoi(sdkName.string());
1258         out->minorVersion = 0;
1259     }
1260
1261     return true;
1262 }
1263
1264 int AaptGroupEntry::compare(const AaptGroupEntry& o) const
1265 {
1266     int v = mcc.compare(o.mcc);
1267     if (v == 0) v = mnc.compare(o.mnc);
1268     if (v == 0) v = locale.compare(o.locale);
1269     if (v == 0) v = vendor.compare(o.vendor);
1270     if (v == 0) v = smallestScreenWidthDp.compare(o.smallestScreenWidthDp);
1271     if (v == 0) v = screenWidthDp.compare(o.screenWidthDp);
1272     if (v == 0) v = screenHeightDp.compare(o.screenHeightDp);
1273     if (v == 0) v = screenLayoutSize.compare(o.screenLayoutSize);
1274     if (v == 0) v = screenLayoutLong.compare(o.screenLayoutLong);
1275     if (v == 0) v = orientation.compare(o.orientation);
1276     if (v == 0) v = uiModeType.compare(o.uiModeType);
1277     if (v == 0) v = uiModeNight.compare(o.uiModeNight);
1278     if (v == 0) v = density.compare(o.density);
1279     if (v == 0) v = touchscreen.compare(o.touchscreen);
1280     if (v == 0) v = keysHidden.compare(o.keysHidden);
1281     if (v == 0) v = keyboard.compare(o.keyboard);
1282     if (v == 0) v = navHidden.compare(o.navHidden);
1283     if (v == 0) v = navigation.compare(o.navigation);
1284     if (v == 0) v = screenSize.compare(o.screenSize);
1285     if (v == 0) v = version.compare(o.version);
1286     return v;
1287 }
1288
1289 ResTable_config AaptGroupEntry::toParams() const
1290 {
1291     ResTable_config params;
1292     memset(&params, 0, sizeof(params));
1293     getMccName(mcc.string(), &params);
1294     getMncName(mnc.string(), &params);
1295     getLocaleName(locale.string(), &params);
1296     getSmallestScreenWidthDpName(smallestScreenWidthDp.string(), &params);
1297     getScreenWidthDpName(screenWidthDp.string(), &params);
1298     getScreenHeightDpName(screenHeightDp.string(), &params);
1299     getScreenLayoutSizeName(screenLayoutSize.string(), &params);
1300     getScreenLayoutLongName(screenLayoutLong.string(), &params);
1301     getOrientationName(orientation.string(), &params);
1302     getUiModeTypeName(uiModeType.string(), &params);
1303     getUiModeNightName(uiModeNight.string(), &params);
1304     getDensityName(density.string(), &params);
1305     getTouchscreenName(touchscreen.string(), &params);
1306     getKeysHiddenName(keysHidden.string(), &params);
1307     getKeyboardName(keyboard.string(), &params);
1308     getNavHiddenName(navHidden.string(), &params);
1309     getNavigationName(navigation.string(), &params);
1310     getScreenSizeName(screenSize.string(), &params);
1311     getVersionName(version.string(), &params);
1312
1313     // Fix up version number based on specified parameters.
1314     int minSdk = 0;
1315     if (params.smallestScreenWidthDp != ResTable_config::SCREENWIDTH_ANY
1316             || params.screenWidthDp != ResTable_config::SCREENWIDTH_ANY
1317             || params.screenHeightDp != ResTable_config::SCREENHEIGHT_ANY) {
1318         minSdk = SDK_HONEYCOMB_MR2;
1319     } else if ((params.uiMode&ResTable_config::MASK_UI_MODE_TYPE)
1320                 != ResTable_config::UI_MODE_TYPE_ANY
1321             ||  (params.uiMode&ResTable_config::MASK_UI_MODE_NIGHT)
1322                 != ResTable_config::UI_MODE_NIGHT_ANY) {
1323         minSdk = SDK_FROYO;
1324     } else if ((params.screenLayout&ResTable_config::MASK_SCREENSIZE)
1325                 != ResTable_config::SCREENSIZE_ANY
1326             ||  (params.screenLayout&ResTable_config::MASK_SCREENLONG)
1327                 != ResTable_config::SCREENLONG_ANY
1328             || params.density != ResTable_config::DENSITY_DEFAULT) {
1329         minSdk = SDK_DONUT;
1330     }
1331
1332     if (minSdk > params.sdkVersion) {
1333         params.sdkVersion = minSdk;
1334     }
1335
1336     return params;
1337 }
1338
1339 // =========================================================================
1340 // =========================================================================
1341 // =========================================================================
1342
1343 void* AaptFile::editData(size_t size)
1344 {
1345     if (size <= mBufferSize) {
1346         mDataSize = size;
1347         return mData;
1348     }
1349     size_t allocSize = (size*3)/2;
1350     void* buf = realloc(mData, allocSize);
1351     if (buf == NULL) {
1352         return NULL;
1353     }
1354     mData = buf;
1355     mDataSize = size;
1356     mBufferSize = allocSize;
1357     return buf;
1358 }
1359
1360 void* AaptFile::editData(size_t* outSize)
1361 {
1362     if (outSize) {
1363         *outSize = mDataSize;
1364     }
1365     return mData;
1366 }
1367
1368 void* AaptFile::padData(size_t wordSize)
1369 {
1370     const size_t extra = mDataSize%wordSize;
1371     if (extra == 0) {
1372         return mData;
1373     }
1374
1375     size_t initial = mDataSize;
1376     void* data = editData(initial+(wordSize-extra));
1377     if (data != NULL) {
1378         memset(((uint8_t*)data) + initial, 0, wordSize-extra);
1379     }
1380     return data;
1381 }
1382
1383 status_t AaptFile::writeData(const void* data, size_t size)
1384 {
1385     size_t end = mDataSize;
1386     size_t total = size + end;
1387     void* buf = editData(total);
1388     if (buf == NULL) {
1389         return UNKNOWN_ERROR;
1390     }
1391     memcpy(((char*)buf)+end, data, size);
1392     return NO_ERROR;
1393 }
1394
1395 void AaptFile::clearData()
1396 {
1397     if (mData != NULL) free(mData);
1398     mData = NULL;
1399     mDataSize = 0;
1400     mBufferSize = 0;
1401 }
1402
1403 String8 AaptFile::getPrintableSource() const
1404 {
1405     if (hasData()) {
1406         String8 name(mGroupEntry.locale.string());
1407         name.appendPath(mGroupEntry.vendor.string());
1408         name.appendPath(mPath);
1409         name.append(" #generated");
1410         return name;
1411     }
1412     return mSourceFile;
1413 }
1414
1415 // =========================================================================
1416 // =========================================================================
1417 // =========================================================================
1418
1419 status_t AaptGroup::addFile(const sp<AaptFile>& file)
1420 {
1421     if (mFiles.indexOfKey(file->getGroupEntry()) < 0) {
1422         file->mPath = mPath;
1423         mFiles.add(file->getGroupEntry(), file);
1424         return NO_ERROR;
1425     }
1426
1427     SourcePos(file->getSourceFile(), -1).error("Duplicate file.\n%s: Original is here.",
1428                                                getPrintableSource().string());
1429     return UNKNOWN_ERROR;
1430 }
1431
1432 void AaptGroup::removeFile(size_t index)
1433 {
1434         mFiles.removeItemsAt(index);
1435 }
1436
1437 void AaptGroup::print() const
1438 {
1439     printf("  %s\n", getPath().string());
1440     const size_t N=mFiles.size();
1441     size_t i;
1442     for (i=0; i<N; i++) {
1443         sp<AaptFile> file = mFiles.valueAt(i);
1444         const AaptGroupEntry& e = file->getGroupEntry();
1445         if (file->hasData()) {
1446             printf("      Gen: (%s) %d bytes\n", e.toString().string(),
1447                     (int)file->getSize());
1448         } else {
1449             printf("      Src: %s\n", file->getPrintableSource().string());
1450         }
1451     }
1452 }
1453
1454 String8 AaptGroup::getPrintableSource() const
1455 {
1456     if (mFiles.size() > 0) {
1457         // Arbitrarily pull the first source file out of the list.
1458         return mFiles.valueAt(0)->getPrintableSource();
1459     }
1460
1461     // Should never hit this case, but to be safe...
1462     return getPath();
1463
1464 }
1465
1466 // =========================================================================
1467 // =========================================================================
1468 // =========================================================================
1469
1470 status_t AaptDir::addFile(const String8& name, const sp<AaptGroup>& file)
1471 {
1472     if (mFiles.indexOfKey(name) >= 0) {
1473         return ALREADY_EXISTS;
1474     }
1475     mFiles.add(name, file);
1476     return NO_ERROR;
1477 }
1478
1479 status_t AaptDir::addDir(const String8& name, const sp<AaptDir>& dir)
1480 {
1481     if (mDirs.indexOfKey(name) >= 0) {
1482         return ALREADY_EXISTS;
1483     }
1484     mDirs.add(name, dir);
1485     return NO_ERROR;
1486 }
1487
1488 sp<AaptDir> AaptDir::makeDir(const String8& path)
1489 {
1490     String8 name;
1491     String8 remain = path;
1492
1493     sp<AaptDir> subdir = this;
1494     while (name = remain.walkPath(&remain), remain != "") {
1495         subdir = subdir->makeDir(name);
1496     }
1497
1498     ssize_t i = subdir->mDirs.indexOfKey(name);
1499     if (i >= 0) {
1500         return subdir->mDirs.valueAt(i);
1501     }
1502     sp<AaptDir> dir = new AaptDir(name, subdir->mPath.appendPathCopy(name));
1503     subdir->mDirs.add(name, dir);
1504     return dir;
1505 }
1506
1507 void AaptDir::removeFile(const String8& name)
1508 {
1509     mFiles.removeItem(name);
1510 }
1511
1512 void AaptDir::removeDir(const String8& name)
1513 {
1514     mDirs.removeItem(name);
1515 }
1516
1517 status_t AaptDir::renameFile(const sp<AaptFile>& file, const String8& newName)
1518 {
1519         sp<AaptGroup> origGroup;
1520
1521         // Find and remove the given file with shear, brute force!
1522         const size_t NG = mFiles.size();
1523         size_t i;
1524         for (i=0; origGroup == NULL && i<NG; i++) {
1525                 sp<AaptGroup> g = mFiles.valueAt(i);
1526                 const size_t NF = g->getFiles().size();
1527                 for (size_t j=0; j<NF; j++) {
1528                         if (g->getFiles().valueAt(j) == file) {
1529                                 origGroup = g;
1530                                 g->removeFile(j);
1531                                 if (NF == 1) {
1532                                         mFiles.removeItemsAt(i);
1533                                 }
1534                                 break;
1535                         }
1536                 }
1537         }
1538
1539         //printf("Renaming %s to %s\n", file->getPath().getPathName(), newName.string());
1540
1541         // Place the file under its new name.
1542         if (origGroup != NULL) {
1543                 return addLeafFile(newName, file);
1544         }
1545
1546         return NO_ERROR;
1547 }
1548
1549 status_t AaptDir::addLeafFile(const String8& leafName, const sp<AaptFile>& file)
1550 {
1551     sp<AaptGroup> group;
1552     if (mFiles.indexOfKey(leafName) >= 0) {
1553         group = mFiles.valueFor(leafName);
1554     } else {
1555         group = new AaptGroup(leafName, mPath.appendPathCopy(leafName));
1556         mFiles.add(leafName, group);
1557     }
1558
1559     return group->addFile(file);
1560 }
1561
1562 ssize_t AaptDir::slurpFullTree(Bundle* bundle, const String8& srcDir,
1563                             const AaptGroupEntry& kind, const String8& resType)
1564 {
1565     Vector<String8> fileNames;
1566
1567     {
1568         DIR* dir = NULL;
1569
1570         dir = opendir(srcDir.string());
1571         if (dir == NULL) {
1572             fprintf(stderr, "ERROR: opendir(%s): %s\n", srcDir.string(), strerror(errno));
1573             return UNKNOWN_ERROR;
1574         }
1575
1576         /*
1577          * Slurp the filenames out of the directory.
1578          */
1579         while (1) {
1580             struct dirent* entry;
1581
1582             entry = readdir(dir);
1583             if (entry == NULL)
1584                 break;
1585
1586             if (isHidden(srcDir.string(), entry->d_name))
1587                 continue;
1588
1589             fileNames.add(String8(entry->d_name));
1590         }
1591
1592         closedir(dir);
1593     }
1594
1595     ssize_t count = 0;
1596
1597     /*
1598      * Stash away the files and recursively descend into subdirectories.
1599      */
1600     const size_t N = fileNames.size();
1601     size_t i;
1602     for (i = 0; i < N; i++) {
1603         String8 pathName(srcDir);
1604         FileType type;
1605
1606         pathName.appendPath(fileNames[i].string());
1607         type = getFileType(pathName.string());
1608         if (type == kFileTypeDirectory) {
1609             sp<AaptDir> subdir;
1610             bool notAdded = false;
1611             if (mDirs.indexOfKey(fileNames[i]) >= 0) {
1612                 subdir = mDirs.valueFor(fileNames[i]);
1613             } else {
1614                 subdir = new AaptDir(fileNames[i], mPath.appendPathCopy(fileNames[i]));
1615                 notAdded = true;
1616             }
1617             ssize_t res = subdir->slurpFullTree(bundle, pathName, kind,
1618                                                 resType);
1619             if (res < NO_ERROR) {
1620                 return res;
1621             }
1622             if (res > 0 && notAdded) {
1623                 mDirs.add(fileNames[i], subdir);
1624             }
1625             count += res;
1626         } else if (type == kFileTypeRegular) {
1627             sp<AaptFile> file = new AaptFile(pathName, kind, resType);
1628             status_t err = addLeafFile(fileNames[i], file);
1629             if (err != NO_ERROR) {
1630                 return err;
1631             }
1632
1633             count++;
1634
1635         } else {
1636             if (bundle->getVerbose())
1637                 printf("   (ignoring non-file/dir '%s')\n", pathName.string());
1638         }
1639     }
1640
1641     return count;
1642 }
1643
1644 status_t AaptDir::validate() const
1645 {
1646     const size_t NF = mFiles.size();
1647     const size_t ND = mDirs.size();
1648     size_t i;
1649     for (i = 0; i < NF; i++) {
1650         if (!validateFileName(mFiles.valueAt(i)->getLeaf().string())) {
1651             SourcePos(mFiles.valueAt(i)->getPrintableSource(), -1).error(
1652                     "Invalid filename.  Unable to add.");
1653             return UNKNOWN_ERROR;
1654         }
1655
1656         size_t j;
1657         for (j = i+1; j < NF; j++) {
1658             if (strcasecmp(mFiles.valueAt(i)->getLeaf().string(),
1659                            mFiles.valueAt(j)->getLeaf().string()) == 0) {
1660                 SourcePos(mFiles.valueAt(i)->getPrintableSource(), -1).error(
1661                         "File is case-insensitive equivalent to: %s",
1662                         mFiles.valueAt(j)->getPrintableSource().string());
1663                 return UNKNOWN_ERROR;
1664             }
1665
1666             // TODO: if ".gz", check for non-.gz; if non-, check for ".gz"
1667             // (this is mostly caught by the "marked" stuff, below)
1668         }
1669
1670         for (j = 0; j < ND; j++) {
1671             if (strcasecmp(mFiles.valueAt(i)->getLeaf().string(),
1672                            mDirs.valueAt(j)->getLeaf().string()) == 0) {
1673                 SourcePos(mFiles.valueAt(i)->getPrintableSource(), -1).error(
1674                         "File conflicts with dir from: %s",
1675                         mDirs.valueAt(j)->getPrintableSource().string());
1676                 return UNKNOWN_ERROR;
1677             }
1678         }
1679     }
1680
1681     for (i = 0; i < ND; i++) {
1682         if (!validateFileName(mDirs.valueAt(i)->getLeaf().string())) {
1683             SourcePos(mDirs.valueAt(i)->getPrintableSource(), -1).error(
1684                     "Invalid directory name, unable to add.");
1685             return UNKNOWN_ERROR;
1686         }
1687
1688         size_t j;
1689         for (j = i+1; j < ND; j++) {
1690             if (strcasecmp(mDirs.valueAt(i)->getLeaf().string(),
1691                            mDirs.valueAt(j)->getLeaf().string()) == 0) {
1692                 SourcePos(mDirs.valueAt(i)->getPrintableSource(), -1).error(
1693                         "Directory is case-insensitive equivalent to: %s",
1694                         mDirs.valueAt(j)->getPrintableSource().string());
1695                 return UNKNOWN_ERROR;
1696             }
1697         }
1698
1699         status_t err = mDirs.valueAt(i)->validate();
1700         if (err != NO_ERROR) {
1701             return err;
1702         }
1703     }
1704
1705     return NO_ERROR;
1706 }
1707
1708 void AaptDir::print() const
1709 {
1710     const size_t ND=getDirs().size();
1711     size_t i;
1712     for (i=0; i<ND; i++) {
1713         getDirs().valueAt(i)->print();
1714     }
1715
1716     const size_t NF=getFiles().size();
1717     for (i=0; i<NF; i++) {
1718         getFiles().valueAt(i)->print();
1719     }
1720 }
1721
1722 String8 AaptDir::getPrintableSource() const
1723 {
1724     if (mFiles.size() > 0) {
1725         // Arbitrarily pull the first file out of the list as the source dir.
1726         return mFiles.valueAt(0)->getPrintableSource().getPathDir();
1727     }
1728     if (mDirs.size() > 0) {
1729         // Or arbitrarily pull the first dir out of the list as the source dir.
1730         return mDirs.valueAt(0)->getPrintableSource().getPathDir();
1731     }
1732
1733     // Should never hit this case, but to be safe...
1734     return mPath;
1735
1736 }
1737
1738 // =========================================================================
1739 // =========================================================================
1740 // =========================================================================
1741
1742 sp<AaptFile> AaptAssets::addFile(
1743         const String8& filePath, const AaptGroupEntry& entry,
1744         const String8& srcDir, sp<AaptGroup>* outGroup,
1745         const String8& resType)
1746 {
1747     sp<AaptDir> dir = this;
1748     sp<AaptGroup> group;
1749     sp<AaptFile> file;
1750     String8 root, remain(filePath), partialPath;
1751     while (remain.length() > 0) {
1752         root = remain.walkPath(&remain);
1753         partialPath.appendPath(root);
1754
1755         const String8 rootStr(root);
1756
1757         if (remain.length() == 0) {
1758             ssize_t i = dir->getFiles().indexOfKey(rootStr);
1759             if (i >= 0) {
1760                 group = dir->getFiles().valueAt(i);
1761             } else {
1762                 group = new AaptGroup(rootStr, filePath);
1763                 status_t res = dir->addFile(rootStr, group);
1764                 if (res != NO_ERROR) {
1765                     return NULL;
1766                 }
1767             }
1768             file = new AaptFile(srcDir.appendPathCopy(filePath), entry, resType);
1769             status_t res = group->addFile(file);
1770             if (res != NO_ERROR) {
1771                 return NULL;
1772             }
1773             break;
1774
1775         } else {
1776             ssize_t i = dir->getDirs().indexOfKey(rootStr);
1777             if (i >= 0) {
1778                 dir = dir->getDirs().valueAt(i);
1779             } else {
1780                 sp<AaptDir> subdir = new AaptDir(rootStr, partialPath);
1781                 status_t res = dir->addDir(rootStr, subdir);
1782                 if (res != NO_ERROR) {
1783                     return NULL;
1784                 }
1785                 dir = subdir;
1786             }
1787         }
1788     }
1789
1790     mGroupEntries.add(entry);
1791     if (outGroup) *outGroup = group;
1792     return file;
1793 }
1794
1795 void AaptAssets::addResource(const String8& leafName, const String8& path,
1796                 const sp<AaptFile>& file, const String8& resType)
1797 {
1798     sp<AaptDir> res = AaptDir::makeDir(kResString);
1799     String8 dirname = file->getGroupEntry().toDirName(resType);
1800     sp<AaptDir> subdir = res->makeDir(dirname);
1801     sp<AaptGroup> grr = new AaptGroup(leafName, path);
1802     grr->addFile(file);
1803
1804     subdir->addFile(leafName, grr);
1805 }
1806
1807
1808 ssize_t AaptAssets::slurpFromArgs(Bundle* bundle)
1809 {
1810     int count;
1811     int totalCount = 0;
1812     FileType type;
1813     const Vector<const char *>& resDirs = bundle->getResourceSourceDirs();
1814     const size_t dirCount =resDirs.size();
1815     sp<AaptAssets> current = this;
1816
1817     const int N = bundle->getFileSpecCount();
1818
1819     /*
1820      * If a package manifest was specified, include that first.
1821      */
1822     if (bundle->getAndroidManifestFile() != NULL) {
1823         // place at root of zip.
1824         String8 srcFile(bundle->getAndroidManifestFile());
1825         addFile(srcFile.getPathLeaf(), AaptGroupEntry(), srcFile.getPathDir(),
1826                 NULL, String8());
1827         totalCount++;
1828     }
1829
1830     /*
1831      * If a directory of custom assets was supplied, slurp 'em up.
1832      */
1833     if (bundle->getAssetSourceDir()) {
1834         const char* assetDir = bundle->getAssetSourceDir();
1835
1836         FileType type = getFileType(assetDir);
1837         if (type == kFileTypeNonexistent) {
1838             fprintf(stderr, "ERROR: asset directory '%s' does not exist\n", assetDir);
1839             return UNKNOWN_ERROR;
1840         }
1841         if (type != kFileTypeDirectory) {
1842             fprintf(stderr, "ERROR: '%s' is not a directory\n", assetDir);
1843             return UNKNOWN_ERROR;
1844         }
1845
1846         String8 assetRoot(assetDir);
1847         sp<AaptDir> assetAaptDir = makeDir(String8(kAssetDir));
1848         AaptGroupEntry group;
1849         count = assetAaptDir->slurpFullTree(bundle, assetRoot, group,
1850                                             String8());
1851         if (count < 0) {
1852             totalCount = count;
1853             goto bail;
1854         }
1855         if (count > 0) {
1856             mGroupEntries.add(group);
1857         }
1858         totalCount += count;
1859
1860         if (bundle->getVerbose())
1861             printf("Found %d custom asset file%s in %s\n",
1862                    count, (count==1) ? "" : "s", assetDir);
1863     }
1864
1865     /*
1866      * If a directory of resource-specific assets was supplied, slurp 'em up.
1867      */
1868     for (size_t i=0; i<dirCount; i++) {
1869         const char *res = resDirs[i];
1870         if (res) {
1871             type = getFileType(res);
1872             if (type == kFileTypeNonexistent) {
1873                 fprintf(stderr, "ERROR: resource directory '%s' does not exist\n", res);
1874                 return UNKNOWN_ERROR;
1875             }
1876             if (type == kFileTypeDirectory) {
1877                 if (i>0) {
1878                     sp<AaptAssets> nextOverlay = new AaptAssets();
1879                     current->setOverlay(nextOverlay);
1880                     current = nextOverlay;
1881                 }
1882                 count = current->slurpResourceTree(bundle, String8(res));
1883
1884                 if (count < 0) {
1885                     totalCount = count;
1886                     goto bail;
1887                 }
1888                 totalCount += count;
1889             }
1890             else {
1891                 fprintf(stderr, "ERROR: '%s' is not a directory\n", res);
1892                 return UNKNOWN_ERROR;
1893             }
1894         }
1895
1896     }
1897     /*
1898      * Now do any additional raw files.
1899      */
1900     for (int arg=0; arg<N; arg++) {
1901         const char* assetDir = bundle->getFileSpecEntry(arg);
1902
1903         FileType type = getFileType(assetDir);
1904         if (type == kFileTypeNonexistent) {
1905             fprintf(stderr, "ERROR: input directory '%s' does not exist\n", assetDir);
1906             return UNKNOWN_ERROR;
1907         }
1908         if (type != kFileTypeDirectory) {
1909             fprintf(stderr, "ERROR: '%s' is not a directory\n", assetDir);
1910             return UNKNOWN_ERROR;
1911         }
1912
1913         String8 assetRoot(assetDir);
1914
1915         if (bundle->getVerbose())
1916             printf("Processing raw dir '%s'\n", (const char*) assetDir);
1917
1918         /*
1919          * Do a recursive traversal of subdir tree.  We don't make any
1920          * guarantees about ordering, so we're okay with an inorder search
1921          * using whatever order the OS happens to hand back to us.
1922          */
1923         count = slurpFullTree(bundle, assetRoot, AaptGroupEntry(), String8());
1924         if (count < 0) {
1925             /* failure; report error and remove archive */
1926             totalCount = count;
1927             goto bail;
1928         }
1929         totalCount += count;
1930
1931         if (bundle->getVerbose())
1932             printf("Found %d asset file%s in %s\n",
1933                    count, (count==1) ? "" : "s", assetDir);
1934     }
1935
1936     count = validate();
1937     if (count != NO_ERROR) {
1938         totalCount = count;
1939         goto bail;
1940     }
1941
1942
1943 bail:
1944     return totalCount;
1945 }
1946
1947 ssize_t AaptAssets::slurpFullTree(Bundle* bundle, const String8& srcDir,
1948                                     const AaptGroupEntry& kind,
1949                                     const String8& resType)
1950 {
1951     ssize_t res = AaptDir::slurpFullTree(bundle, srcDir, kind, resType);
1952     if (res > 0) {
1953         mGroupEntries.add(kind);
1954     }
1955
1956     return res;
1957 }
1958
1959 ssize_t AaptAssets::slurpResourceTree(Bundle* bundle, const String8& srcDir)
1960 {
1961     ssize_t err = 0;
1962
1963     DIR* dir = opendir(srcDir.string());
1964     if (dir == NULL) {
1965         fprintf(stderr, "ERROR: opendir(%s): %s\n", srcDir.string(), strerror(errno));
1966         return UNKNOWN_ERROR;
1967     }
1968
1969     status_t count = 0;
1970
1971     /*
1972      * Run through the directory, looking for dirs that match the
1973      * expected pattern.
1974      */
1975     while (1) {
1976         struct dirent* entry = readdir(dir);
1977         if (entry == NULL) {
1978             break;
1979         }
1980
1981         if (isHidden(srcDir.string(), entry->d_name)) {
1982             continue;
1983         }
1984
1985         String8 subdirName(srcDir);
1986         subdirName.appendPath(entry->d_name);
1987
1988         AaptGroupEntry group;
1989         String8 resType;
1990         bool b = group.initFromDirName(entry->d_name, &resType);
1991         if (!b) {
1992             fprintf(stderr, "invalid resource directory name: %s/%s\n", srcDir.string(),
1993                     entry->d_name);
1994             err = -1;
1995             continue;
1996         }
1997
1998         if (bundle->getMaxResVersion() != NULL && group.version.length() != 0) {
1999             int maxResInt = atoi(bundle->getMaxResVersion());
2000             const char *verString = group.version.string();
2001             int dirVersionInt = atoi(verString + 1); // skip 'v' in version name
2002             if (dirVersionInt > maxResInt) {
2003               fprintf(stderr, "max res %d, skipping %s\n", maxResInt, entry->d_name);
2004               continue;
2005             }
2006         }
2007
2008         FileType type = getFileType(subdirName.string());
2009
2010         if (type == kFileTypeDirectory) {
2011             sp<AaptDir> dir = makeDir(String8(entry->d_name));
2012             ssize_t res = dir->slurpFullTree(bundle, subdirName, group,
2013                                                 resType);
2014             if (res < 0) {
2015                 count = res;
2016                 goto bail;
2017             }
2018             if (res > 0) {
2019                 mGroupEntries.add(group);
2020                 count += res;
2021             }
2022
2023             mDirs.add(dir);
2024         } else {
2025             if (bundle->getVerbose()) {
2026                 fprintf(stderr, "   (ignoring file '%s')\n", subdirName.string());
2027             }
2028         }
2029     }
2030
2031 bail:
2032     closedir(dir);
2033     dir = NULL;
2034
2035     if (err != 0) {
2036         return err;
2037     }
2038     return count;
2039 }
2040
2041 ssize_t
2042 AaptAssets::slurpResourceZip(Bundle* bundle, const char* filename)
2043 {
2044     int count = 0;
2045     SortedVector<AaptGroupEntry> entries;
2046
2047     ZipFile* zip = new ZipFile;
2048     status_t err = zip->open(filename, ZipFile::kOpenReadOnly);
2049     if (err != NO_ERROR) {
2050         fprintf(stderr, "error opening zip file %s\n", filename);
2051         count = err;
2052         delete zip;
2053         return -1;
2054     }
2055
2056     const int N = zip->getNumEntries();
2057     for (int i=0; i<N; i++) {
2058         ZipEntry* entry = zip->getEntryByIndex(i);
2059         if (entry->getDeleted()) {
2060             continue;
2061         }
2062
2063         String8 entryName(entry->getFileName());
2064
2065         String8 dirName = entryName.getPathDir();
2066         sp<AaptDir> dir = dirName == "" ? this : makeDir(dirName);
2067
2068         String8 resType;
2069         AaptGroupEntry kind;
2070
2071         String8 remain;
2072         if (entryName.walkPath(&remain) == kResourceDir) {
2073             // these are the resources, pull their type out of the directory name
2074             kind.initFromDirName(remain.walkPath().string(), &resType);
2075         } else {
2076             // these are untyped and don't have an AaptGroupEntry
2077         }
2078         if (entries.indexOf(kind) < 0) {
2079             entries.add(kind);
2080             mGroupEntries.add(kind);
2081         }
2082
2083         // use the one from the zip file if they both exist.
2084         dir->removeFile(entryName.getPathLeaf());
2085
2086         sp<AaptFile> file = new AaptFile(entryName, kind, resType);
2087         status_t err = dir->addLeafFile(entryName.getPathLeaf(), file);
2088         if (err != NO_ERROR) {
2089             fprintf(stderr, "err=%s entryName=%s\n", strerror(err), entryName.string());
2090             count = err;
2091             goto bail;
2092         }
2093         file->setCompressionMethod(entry->getCompressionMethod());
2094
2095 #if 0
2096         if (entryName == "AndroidManifest.xml") {
2097             printf("AndroidManifest.xml\n");
2098         }
2099         printf("\n\nfile: %s\n", entryName.string());
2100 #endif
2101
2102         size_t len = entry->getUncompressedLen();
2103         void* data = zip->uncompress(entry);
2104         void* buf = file->editData(len);
2105         memcpy(buf, data, len);
2106
2107 #if 0
2108         const int OFF = 0;
2109         const unsigned char* p = (unsigned char*)data;
2110         const unsigned char* end = p+len;
2111         p += OFF;
2112         for (int i=0; i<32 && p < end; i++) {
2113             printf("0x%03x ", i*0x10 + OFF);
2114             for (int j=0; j<0x10 && p < end; j++) {
2115                 printf(" %02x", *p);
2116                 p++;
2117             }
2118             printf("\n");
2119         }
2120 #endif
2121
2122         free(data);
2123
2124         count++;
2125     }
2126
2127 bail:
2128     delete zip;
2129     return count;
2130 }
2131
2132 sp<AaptSymbols> AaptAssets::getSymbolsFor(const String8& name)
2133 {
2134     sp<AaptSymbols> sym = mSymbols.valueFor(name);
2135     if (sym == NULL) {
2136         sym = new AaptSymbols();
2137         mSymbols.add(name, sym);
2138     }
2139     return sym;
2140 }
2141
2142 status_t AaptAssets::buildIncludedResources(Bundle* bundle)
2143 {
2144     if (!mHaveIncludedAssets) {
2145         // Add in all includes.
2146         const Vector<const char*>& incl = bundle->getPackageIncludes();
2147         const size_t N=incl.size();
2148         for (size_t i=0; i<N; i++) {
2149             if (bundle->getVerbose())
2150                 printf("Including resources from package: %s\n", incl[i]);
2151             if (!mIncludedAssets.addAssetPath(String8(incl[i]), NULL)) {
2152                 fprintf(stderr, "ERROR: Asset package include '%s' not found.\n",
2153                         incl[i]);
2154                 return UNKNOWN_ERROR;
2155             }
2156         }
2157         mHaveIncludedAssets = true;
2158     }
2159
2160     return NO_ERROR;
2161 }
2162
2163 status_t AaptAssets::addIncludedResources(const sp<AaptFile>& file)
2164 {
2165     const ResTable& res = getIncludedResources();
2166     // XXX dirty!
2167     return const_cast<ResTable&>(res).add(file->getData(), file->getSize(), NULL);
2168 }
2169
2170 const ResTable& AaptAssets::getIncludedResources() const
2171 {
2172     return mIncludedAssets.getResources(false);
2173 }
2174
2175 void AaptAssets::print() const
2176 {
2177     printf("Locale/Vendor pairs:\n");
2178     const size_t N=mGroupEntries.size();
2179     for (size_t i=0; i<N; i++) {
2180         printf("   %s/%s\n",
2181                mGroupEntries.itemAt(i).locale.string(),
2182                mGroupEntries.itemAt(i).vendor.string());
2183     }
2184
2185     printf("\nFiles:\n");
2186     AaptDir::print();
2187 }
2188
2189 sp<AaptDir> AaptAssets::resDir(const String8& name)
2190 {
2191     const Vector<sp<AaptDir> >& dirs = mDirs;
2192     const size_t N = dirs.size();
2193     for (size_t i=0; i<N; i++) {
2194         const sp<AaptDir>& d = dirs.itemAt(i);
2195         if (d->getLeaf() == name) {
2196             return d;
2197         }
2198     }
2199     return NULL;
2200 }
2201
2202 bool
2203 valid_symbol_name(const String8& symbol)
2204 {
2205     static char const * const KEYWORDS[] = {
2206         "abstract", "assert", "boolean", "break",
2207         "byte", "case", "catch", "char", "class", "const", "continue",
2208         "default", "do", "double", "else", "enum", "extends", "final",
2209         "finally", "float", "for", "goto", "if", "implements", "import",
2210         "instanceof", "int", "interface", "long", "native", "new", "package",
2211         "private", "protected", "public", "return", "short", "static",
2212         "strictfp", "super", "switch", "synchronized", "this", "throw",
2213         "throws", "transient", "try", "void", "volatile", "while",
2214         "true", "false", "null",
2215         NULL
2216     };
2217     const char*const* k = KEYWORDS;
2218     const char*const s = symbol.string();
2219     while (*k) {
2220         if (0 == strcmp(s, *k)) {
2221             return false;
2222         }
2223         k++;
2224     }
2225     return true;
2226 }