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