AaptAssets.cpp

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