Command.cpp

   1 //
   2 // Copyright 2006 The Android Open Source Project
   3 //
   4 // Android Asset Packaging Tool main entry point.
   5 //
   6 #include "Main.h"
   7 #include "Bundle.h"
   8 #include "ResourceTable.h"
   9 #include "XMLNode.h"
  10
  11 #include <utils.h>
  12 #include <utils/ZipFile.h>
  13
  14 #include <fcntl.h>
  15 #include <errno.h>
  16
  17 using namespace android;
  18
  19 /*
  20  * Show version info.  All the cool kids do it.
  21  */
  22 int doVersion(Bundle* bundle)
  23 {
  24     if (bundle->getFileSpecCount() != 0)
  25         printf("(ignoring extra arguments)\n");
  26     printf("Android Asset Packaging Tool, v0.2\n");
  27
  28     return 0;
  29 }
  30
  31
  32 /*
  33  * Open the file read only.  The call fails if the file doesn't exist.
  34  *
  35  * Returns NULL on failure.
  36  */
  37 ZipFile* openReadOnly(const char* fileName)
  38 {
  39     ZipFile* zip;
  40     status_t result;
  41
  42     zip = new ZipFile;
  43     result = zip->open(fileName, ZipFile::kOpenReadOnly);
  44     if (result != NO_ERROR) {
  45         if (result == NAME_NOT_FOUND)
  46             fprintf(stderr, "ERROR: '%s' not found\n", fileName);
  47         else if (result == PERMISSION_DENIED)
  48             fprintf(stderr, "ERROR: '%s' access denied\n", fileName);
  49         else
  50             fprintf(stderr, "ERROR: failed opening '%s' as Zip file\n",
  51                 fileName);
  52         delete zip;
  53         return NULL;
  54     }
  55
  56     return zip;
  57 }
  58
  59 /*
  60  * Open the file read-write.  The file will be created if it doesn't
  61  * already exist and "okayToCreate" is set.
  62  *
  63  * Returns NULL on failure.
  64  */
  65 ZipFile* openReadWrite(const char* fileName, bool okayToCreate)
  66 {
  67     ZipFile* zip = NULL;
  68     status_t result;
  69     int flags;
  70
  71     flags = ZipFile::kOpenReadWrite;
  72     if (okayToCreate)
  73         flags |= ZipFile::kOpenCreate;
  74
  75     zip = new ZipFile;
  76     result = zip->open(fileName, flags);
  77     if (result != NO_ERROR) {
  78         delete zip;
  79         zip = NULL;
  80         goto bail;
  81     }
  82
  83 bail:
  84     return zip;
  85 }
  86
  87
  88 /*
  89  * Return a short string describing the compression method.
  90  */
  91 const char* compressionName(int method)
  92 {
  93     if (method == ZipEntry::kCompressStored)
  94         return "Stored";
  95     else if (method == ZipEntry::kCompressDeflated)
  96         return "Deflated";
  97     else
  98         return "Unknown";
  99 }
 100
 101 /*
 102  * Return the percent reduction in size (0% == no compression).
 103  */
 104 int calcPercent(long uncompressedLen, long compressedLen)
 105 {
 106     if (!uncompressedLen)
 107         return 0;
 108     else
 109         return (int) (100.0 - (compressedLen * 100.0) / uncompressedLen + 0.5);
 110 }
 111
 112 /*
 113  * Handle the "list" command, which can be a simple file dump or
 114  * a verbose listing.
 115  *
 116  * The verbose listing closely matches the output of the Info-ZIP "unzip"
 117  * command.
 118  */
 119 int doList(Bundle* bundle)
 120 {
 121     int result = 1;
 122     ZipFile* zip = NULL;
 123     const ZipEntry* entry;
 124     long totalUncLen, totalCompLen;
 125     const char* zipFileName;
 126
 127     if (bundle->getFileSpecCount() != 1) {
 128         fprintf(stderr, "ERROR: specify zip file name (only)\n");
 129         goto bail;
 130     }
 131     zipFileName = bundle->getFileSpecEntry(0);
 132
 133     zip = openReadOnly(zipFileName);
 134     if (zip == NULL)
 135         goto bail;
 136
 137     int count, i;
 138
 139     if (bundle->getVerbose()) {
 140         printf("Archive:  %s\n", zipFileName);
 141         printf(
 142             " Length   Method    Size  Ratio   Date   Time   CRC-32    Name\n");
 143         printf(
 144             "--------  ------  ------- -----   ----   ----   ------    ----\n");
 145     }
 146
 147     totalUncLen = totalCompLen = 0;
 148
 149     count = zip->getNumEntries();
 150     for (i = 0; i < count; i++) {
 151         entry = zip->getEntryByIndex(i);
 152         if (bundle->getVerbose()) {
 153             char dateBuf[32];
 154             time_t when;
 155
 156             when = entry->getModWhen();
 157             strftime(dateBuf, sizeof(dateBuf), "%m-%d-%y %H:%M",
 158                 localtime(&when));
 159
 160             printf("%8ld  %-7.7s %7ld %3d%%  %s  %08lx  %s\n",
 161                 (long) entry->getUncompressedLen(),
 162                 compressionName(entry->getCompressionMethod()),
 163                 (long) entry->getCompressedLen(),
 164                 calcPercent(entry->getUncompressedLen(),
 165                             entry->getCompressedLen()),
 166                 dateBuf,
 167                 entry->getCRC32(),
 168                 entry->getFileName());
 169         } else {
 170             printf("%s\n", entry->getFileName());
 171         }
 172
 173         totalUncLen += entry->getUncompressedLen();
 174         totalCompLen += entry->getCompressedLen();
 175     }
 176
 177     if (bundle->getVerbose()) {
 178         printf(
 179         "--------          -------  ---                            -------\n");
 180         printf("%8ld          %7ld  %2d%%                            %d files\n",
 181             totalUncLen,
 182             totalCompLen,
 183             calcPercent(totalUncLen, totalCompLen),
 184             zip->getNumEntries());
 185     }
 186
 187     if (bundle->getAndroidList()) {
 188         AssetManager assets;
 189         if (!assets.addAssetPath(String8(zipFileName), NULL)) {
 190             fprintf(stderr, "ERROR: list -a failed because assets could not be loaded\n");
 191             goto bail;
 192         }
 193
 194         const ResTable& res = assets.getResources(false);
 195         if (&res == NULL) {
 196             printf("\nNo resource table found.\n");
 197         } else {
 198             printf("\nResource table:\n");
 199             res.print();
 200         }
 201
 202         Asset* manifestAsset = assets.openNonAsset("AndroidManifest.xml",
 203                                                    Asset::ACCESS_BUFFER);
 204         if (manifestAsset == NULL) {
 205             printf("\nNo AndroidManifest.xml found.\n");
 206         } else {
 207             printf("\nAndroid manifest:\n");
 208             ResXMLTree tree;
 209             tree.setTo(manifestAsset->getBuffer(true),
 210                        manifestAsset->getLength());
 211             printXMLBlock(&tree);
 212         }
 213         delete manifestAsset;
 214     }
 215
 216     result = 0;
 217
 218 bail:
 219     delete zip;
 220     return result;
 221 }
 222
 223 static ssize_t indexOfAttribute(const ResXMLTree& tree, uint32_t attrRes)
 224 {
 225     size_t N = tree.getAttributeCount();
 226     for (size_t i=0; i<N; i++) {
 227         if (tree.getAttributeNameResID(i) == attrRes) {
 228             return (ssize_t)i;
 229         }
 230     }
 231     return -1;
 232 }
 233
 234 static String8 getAttribute(const ResXMLTree& tree, const char* ns,
 235                             const char* attr, String8* outError)
 236 {
 237     ssize_t idx = tree.indexOfAttribute(ns, attr);
 238     if (idx < 0) {
 239         return String8();
 240     }
 241     Res_value value;
 242     if (tree.getAttributeValue(idx, &value) != NO_ERROR) {
 243         if (value.dataType != Res_value::TYPE_STRING) {
 244             if (outError != NULL) *outError = "attribute is not a string value";
 245             return String8();
 246         }
 247     }
 248     size_t len;
 249     const uint16_t* str = tree.getAttributeStringValue(idx, &len);
 250     return str ? String8(str, len) : String8();
 251 }
 252
 253 static String8 getAttribute(const ResXMLTree& tree, uint32_t attrRes, String8* outError)
 254 {
 255     ssize_t idx = indexOfAttribute(tree, attrRes);
 256     if (idx < 0) {
 257         return String8();
 258     }
 259     Res_value value;
 260     if (tree.getAttributeValue(idx, &value) != NO_ERROR) {
 261         if (value.dataType != Res_value::TYPE_STRING) {
 262             if (outError != NULL) *outError = "attribute is not a string value";
 263             return String8();
 264         }
 265     }
 266     size_t len;
 267     const uint16_t* str = tree.getAttributeStringValue(idx, &len);
 268     return str ? String8(str, len) : String8();
 269 }
 270
 271 static int32_t getIntegerAttribute(const ResXMLTree& tree, uint32_t attrRes, String8* outError)
 272 {
 273     ssize_t idx = indexOfAttribute(tree, attrRes);
 274     if (idx < 0) {
 275         return -1;
 276     }
 277     Res_value value;
 278     if (tree.getAttributeValue(idx, &value) != NO_ERROR) {
 279         if (value.dataType != Res_value::TYPE_INT_DEC) {
 280             if (outError != NULL) *outError = "attribute is not an integer value";
 281             return -1;
 282         }
 283     }
 284     return value.data;
 285 }
 286
 287 static String8 getResolvedAttribute(const ResTable* resTable, const ResXMLTree& tree,
 288         uint32_t attrRes, String8* outError)
 289 {
 290     ssize_t idx = indexOfAttribute(tree, attrRes);
 291     if (idx < 0) {
 292         return String8();
 293     }
 294     Res_value value;
 295     if (tree.getAttributeValue(idx, &value) != NO_ERROR) {
 296         if (value.dataType == Res_value::TYPE_STRING) {
 297             size_t len;
 298             const uint16_t* str = tree.getAttributeStringValue(idx, &len);
 299             return str ? String8(str, len) : String8();
 300         }
 301         resTable->resolveReference(&value, 0);
 302         if (value.dataType != Res_value::TYPE_STRING) {
 303             if (outError != NULL) *outError = "attribute is not a string value";
 304             return String8();
 305         }
 306     }
 307     size_t len;
 308     const Res_value* value2 = &value;
 309     const char16_t* str = const_cast<ResTable*>(resTable)->valueToString(value2, 0, NULL, &len);
 310     return str ? String8(str, len) : String8();
 311 }
 312
 313 // These are attribute resource constants for the platform, as found
 314 // in android.R.attr
 315 enum {
 316     NAME_ATTR = 0x01010003,
 317     VERSION_CODE_ATTR = 0x0101021b,
 318     VERSION_NAME_ATTR = 0x0101021c,
 319     LABEL_ATTR = 0x01010001,
 320     ICON_ATTR = 0x01010002,
 321     MIN_SDK_VERSION_ATTR = 0x0101020c
 322 };
 323
 324 const char *getComponentName(String8 &pkgName, String8 &componentName) {
 325     ssize_t idx = componentName.find(".");
 326     String8 retStr(pkgName);
 327     if (idx == 0) {
 328         retStr += componentName;
 329     } else if (idx < 0) {
 330         retStr += ".";
 331         retStr += componentName;
 332     } else {
 333         return componentName.string();
 334     }
 335     return retStr.string();
 336 }
 337
 338 /*
 339  * Handle the "dump" command, to extract select data from an archive.
 340  */
 341 int doDump(Bundle* bundle)
 342 {
 343     status_t result = UNKNOWN_ERROR;
 344     Asset* asset = NULL;
 345
 346     if (bundle->getFileSpecCount() < 1) {
 347         fprintf(stderr, "ERROR: no dump option specified\n");
 348         return 1;
 349     }
 350
 351     if (bundle->getFileSpecCount() < 2) {
 352         fprintf(stderr, "ERROR: no dump file specified\n");
 353         return 1;
 354     }
 355
 356     const char* option = bundle->getFileSpecEntry(0);
 357     const char* filename = bundle->getFileSpecEntry(1);
 358
 359     AssetManager assets;
 360     if (!assets.addAssetPath(String8(filename), NULL)) {
 361         fprintf(stderr, "ERROR: dump failed because assets could not be loaded\n");
 362         return 1;
 363     }
 364
 365     const ResTable& res = assets.getResources(false);
 366     if (&res == NULL) {
 367         fprintf(stderr, "ERROR: dump failed because no resource table was found\n");
 368         goto bail;
 369     }
 370
 371     if (strcmp("resources", option) == 0) {
 372         res.print();
 373
 374     } else if (strcmp("xmltree", option) == 0) {
 375         if (bundle->getFileSpecCount() < 3) {
 376             fprintf(stderr, "ERROR: no dump xmltree resource file specified\n");
 377             goto bail;
 378         }
 379
 380         for (int i=2; i<bundle->getFileSpecCount(); i++) {
 381             const char* resname = bundle->getFileSpecEntry(i);
 382             ResXMLTree tree;
 383             asset = assets.openNonAsset(resname, Asset::ACCESS_BUFFER);
 384             if (asset == NULL) {
 385                 fprintf(stderr, "ERROR: dump failed because resource %p found\n", resname);
 386                 goto bail;
 387             }
 388
 389             if (tree.setTo(asset->getBuffer(true),
 390                            asset->getLength()) != NO_ERROR) {
 391                 fprintf(stderr, "ERROR: Resource %s is corrupt\n", resname);
 392                 goto bail;
 393             }
 394             tree.restart();
 395             printXMLBlock(&tree);
 396             delete asset;
 397             asset = NULL;
 398         }
 399
 400     } else if (strcmp("xmlstrings", option) == 0) {
 401         if (bundle->getFileSpecCount() < 3) {
 402             fprintf(stderr, "ERROR: no dump xmltree resource file specified\n");
 403             goto bail;
 404         }
 405
 406         for (int i=2; i<bundle->getFileSpecCount(); i++) {
 407             const char* resname = bundle->getFileSpecEntry(i);
 408             ResXMLTree tree;
 409             asset = assets.openNonAsset(resname, Asset::ACCESS_BUFFER);
 410             if (asset == NULL) {
 411                 fprintf(stderr, "ERROR: dump failed because resource %p found\n", resname);
 412                 goto bail;
 413             }
 414
 415             if (tree.setTo(asset->getBuffer(true),
 416                            asset->getLength()) != NO_ERROR) {
 417                 fprintf(stderr, "ERROR: Resource %s is corrupt\n", resname);
 418                 goto bail;
 419             }
 420             printStringPool(&tree.getStrings());
 421             delete asset;
 422             asset = NULL;
 423         }
 424
 425     } else {
 426         ResXMLTree tree;
 427         asset = assets.openNonAsset("AndroidManifest.xml",
 428                                             Asset::ACCESS_BUFFER);
 429         if (asset == NULL) {
 430             fprintf(stderr, "ERROR: dump failed because no AndroidManifest.xml found\n");
 431             goto bail;
 432         }
 433
 434         if (tree.setTo(asset->getBuffer(true),
 435                        asset->getLength()) != NO_ERROR) {
 436             fprintf(stderr, "ERROR: AndroidManifest.xml is corrupt\n");
 437             goto bail;
 438         }
 439         tree.restart();
 440
 441         if (strcmp("permissions", option) == 0) {
 442             size_t len;
 443             ResXMLTree::event_code_t code;
 444             int depth = 0;
 445             while ((code=tree.next()) != ResXMLTree::END_DOCUMENT && code != ResXMLTree::BAD_DOCUMENT) {
 446                 if (code == ResXMLTree::END_TAG) {
 447                     depth--;
 448                     continue;
 449                 }
 450                 if (code != ResXMLTree::START_TAG) {
 451                     continue;
 452                 }
 453                 depth++;
 454                 String8 tag(tree.getElementName(&len));
 455                 //printf("Depth %d tag %s\n", depth, tag.string());
 456                 if (depth == 1) {
 457                     if (tag != "manifest") {
 458                         fprintf(stderr, "ERROR: manifest does not start with <manifest> tag\n");
 459                         goto bail;
 460                     }
 461                     String8 pkg = getAttribute(tree, NULL, "package", NULL);
 462                     printf("package: %s\n", pkg.string());
 463                 } else if (depth == 2 && tag == "permission") {
 464                     String8 error;
 465                     String8 name = getAttribute(tree, NAME_ATTR, &error);
 466                     if (error != "") {
 467                         fprintf(stderr, "ERROR: %s\n", error.string());
 468                         goto bail;
 469                     }
 470                     printf("permission: %s\n", name.string());
 471                 } else if (depth == 2 && tag == "uses-permission") {
 472                     String8 error;
 473                     String8 name = getAttribute(tree, NAME_ATTR, &error);
 474                     if (error != "") {
 475                         fprintf(stderr, "ERROR: %s\n", error.string());
 476                         goto bail;
 477                     }
 478                     printf("uses-permission: %s\n", name.string());
 479                 }
 480             }
 481         } else if (strcmp("badging", option) == 0) {
 482             size_t len;
 483             ResXMLTree::event_code_t code;
 484             int depth = 0;
 485             String8 error;
 486             bool withinActivity = false;
 487             bool isMainActivity = false;
 488             bool isLauncherActivity = false;
 489             bool withinApplication = false;
 490             bool withinReceiver = false;
 491             String8 pkg;
 492             String8 activityName;
 493             String8 activityLabel;
 494             String8 activityIcon;
 495             String8 receiverName;
 496             while ((code=tree.next()) != ResXMLTree::END_DOCUMENT && code != ResXMLTree::BAD_DOCUMENT) {
 497                 if (code == ResXMLTree::END_TAG) {
 498                     depth--;
 499                     continue;
 500                 }
 501                 if (code != ResXMLTree::START_TAG) {
 502                     continue;
 503                 }
 504                 depth++;
 505                 String8 tag(tree.getElementName(&len));
 506                 //printf("Depth %d tag %s\n", depth, tag.string());
 507                 if (depth == 1) {
 508                     if (tag != "manifest") {
 509                         fprintf(stderr, "ERROR: manifest does not start with <manifest> tag\n");
 510                         goto bail;
 511                     }
 512                     pkg = getAttribute(tree, NULL, "package", NULL);
 513                     printf("package: name='%s' ", pkg.string());
 514                     int32_t versionCode = getIntegerAttribute(tree, VERSION_CODE_ATTR, &error);
 515                     if (error != "") {
 516                         fprintf(stderr, "ERROR getting 'android:versionCode' attribute: %s\n", error.string());
 517                         goto bail;
 518                     }
 519                     if (versionCode > 0) {
 520                         printf("versionCode='%d' ", versionCode);
 521                     } else {
 522                         printf("versionCode='' ");
 523                     }
 524                     String8 versionName = getAttribute(tree, VERSION_NAME_ATTR, &error);
 525                     if (error != "") {
 526                         fprintf(stderr, "ERROR getting 'android:versionName' attribute: %s\n", error.string());
 527                         goto bail;
 528                     }
 529                     printf("versionName='%s'\n", versionName.string());
 530                 } else if (depth == 2) {
 531                     withinApplication = false;
 532                     if (tag == "application") {
 533                         withinApplication = true;
 534                         String8 label = getResolvedAttribute(&res, tree, LABEL_ATTR, &error);
 535                          if (error != "") {
 536                              fprintf(stderr, "ERROR getting 'android:label' attribute: %s\n", error.string());
 537                              goto bail;
 538                         }
 539                         printf("application: label='%s' ", label.string());
 540                         String8 icon = getResolvedAttribute(&res, tree, ICON_ATTR, &error);
 541                         if (error != "") {
 542                             fprintf(stderr, "ERROR getting 'android:icon' attribute: %s\n", error.string());
 543                             goto bail;
 544                         }
 545                         printf("icon='%s'\n", icon.string());
 546                     } else if (tag == "uses-sdk") {
 547                         int32_t sdkVersion = getIntegerAttribute(tree, MIN_SDK_VERSION_ATTR, &error);
 548                         if (error != "") {
 549                             fprintf(stderr, "ERROR getting 'android:minSdkVersion' attribute: %s\n", error.string());
 550                             goto bail;
 551                         }
 552                         if (sdkVersion != -1) {
 553                             printf("sdkVersion:'%d'\n", sdkVersion);
 554                         }
 555                     }
 556                 } else if (depth == 3 && withinApplication) {
 557                     withinActivity = false;
 558                     withinReceiver = false;
 559                     if(tag == "activity") {
 560                         withinActivity = true;
 561                         activityName = getAttribute(tree, NAME_ATTR, &error);
 562                         if (error != "") {
 563                             fprintf(stderr, "ERROR getting 'android:name' attribute: %s\n", error.string());
 564                             goto bail;
 565                         }
 566
 567                         activityLabel = getResolvedAttribute(&res, tree, LABEL_ATTR, &error);
 568                         if (error != "") {
 569                             fprintf(stderr, "ERROR getting 'android:label' attribute: %s\n", error.string());
 570                             goto bail;
 571                         }
 572
 573                         activityIcon = getResolvedAttribute(&res, tree, ICON_ATTR, &error);
 574                         if (error != "") {
 575                             fprintf(stderr, "ERROR getting 'android:icon' attribute: %s\n", error.string());
 576                             goto bail;
 577                         }
 578                     } else if (tag == "uses-library") {
 579                         String8 libraryName = getAttribute(tree, NAME_ATTR, &error);
 580                         if (error != "") {
 581                             fprintf(stderr, "ERROR getting 'android:name' attribute for uses-library: %s\n", error.string());
 582                             goto bail;
 583                         }
 584                         printf("uses-library:'%s'\n", libraryName.string());
 585                     } else if (tag == "receiver") {
 586                         withinReceiver = true;
 587                         receiverName = getAttribute(tree, NAME_ATTR, &error);
 588
 589                         if (error != "") {
 590                             fprintf(stderr, "ERROR getting 'android:name' attribute for receiver: %s\n", error.string());
 591                             goto bail;
 592                         }
 593                     }
 594                 } else if (depth == 5) {
 595                         if (withinActivity) {
 596                             if (tag == "action") {
 597                                 //printf("LOG: action tag\n");
 598                                 String8 action = getAttribute(tree, NAME_ATTR, &error);
 599                                 if (error != "") {
 600                                     fprintf(stderr, "ERROR getting 'android:name' attribute: %s\n", error.string());
 601                                     goto bail;
 602                                 }
 603                                 if (action == "android.intent.action.MAIN") {
 604                                     isMainActivity = true;
 605                                     //printf("LOG: isMainActivity==true\n");
 606                                 }
 607                         } else if (tag == "category") {
 608                             String8 category = getAttribute(tree, NAME_ATTR, &error);
 609                             if (error != "") {
 610                                 fprintf(stderr, "ERROR getting 'name' attribute: %s\n", error.string());
 611                                 goto bail;
 612                             }
 613                             if (category == "android.intent.category.LAUNCHER") {
 614                                 isLauncherActivity = true;
 615                                 //printf("LOG: isLauncherActivity==true\n");
 616                             }
 617                         }
 618                     } else if (withinReceiver) {
 619                         if (tag == "action") {
 620                             String8 action = getAttribute(tree, NAME_ATTR, &error);
 621                             if (error != "") {
 622                                 fprintf(stderr, "ERROR getting 'android:name' attribute for receiver: %s\n", error.string());
 623                                 goto bail;
 624                             }
 625                             if (action == "android.appwidget.action.APPWIDGET_UPDATE") {
 626                                 const char *rName = getComponentName(pkg, receiverName);
 627                                 if (rName != NULL) {
 628                                     printf("gadget-receiver:'%s/%s'\n", pkg.string(), rName);
 629                                 }
 630                             }
 631                         }
 632                     }
 633                 }
 634
 635                 if (depth < 2) {
 636                     withinApplication = false;
 637                 }
 638                 if (depth < 3) {
 639                     //if (withinActivity) printf("LOG: withinActivity==false\n");
 640                     withinActivity = false;
 641                     withinReceiver = false;
 642                 }
 643
 644                 if (depth < 5) {
 645                     //if (isMainActivity) printf("LOG: isMainActivity==false\n");
 646                     //if (isLauncherActivity) printf("LOG: isLauncherActivity==false\n");
 647                     isMainActivity = false;
 648                     isLauncherActivity = false;
 649                 }
 650
 651                 if (withinActivity && isMainActivity && isLauncherActivity) {
 652                     printf("launchable activity:");
 653                     const char *aName = getComponentName(pkg, activityName);
 654                     if (aName != NULL) {
 655                         printf(" name='%s'", aName);
 656                     }
 657                     printf("label='%s' icon='%s'\n",
 658                            activityLabel.string(),
 659                            activityIcon.string());
 660                 }
 661             }
 662             printf("locales:");
 663             Vector<String8> locales;
 664             res.getLocales(&locales);
 665             const size_t N = locales.size();
 666             for (size_t i=0; i<N; i++) {
 667                 const char* localeStr =  locales[i].string();
 668                 if (localeStr == NULL || strlen(localeStr) == 0) {
 669                     localeStr = "--_--";
 670                 }
 671                 printf(" '%s'", localeStr);
 672             }
 673             printf("\n");
 674         } else if (strcmp("configurations", option) == 0) {
 675             Vector<ResTable_config> configs;
 676             res.getConfigurations(&configs);
 677             const size_t N = configs.size();
 678             for (size_t i=0; i<N; i++) {
 679                 printf("%s\n", configs[i].toString().string());
 680             }
 681         } else {
 682             fprintf(stderr, "ERROR: unknown dump option '%s'\n", option);
 683             goto bail;
 684         }
 685     }
 686
 687     result = NO_ERROR;
 688
 689 bail:
 690     if (asset) {
 691         delete asset;
 692     }
 693     return (result != NO_ERROR);
 694 }
 695
 696
 697 /*
 698  * Handle the "add" command, which wants to add files to a new or
 699  * pre-existing archive.
 700  */
 701 int doAdd(Bundle* bundle)
 702 {
 703     ZipFile* zip = NULL;
 704     status_t result = UNKNOWN_ERROR;
 705     const char* zipFileName;
 706
 707     if (bundle->getUpdate()) {
 708         /* avoid confusion */
 709         fprintf(stderr, "ERROR: can't use '-u' with add\n");
 710         goto bail;
 711     }
 712
 713     if (bundle->getFileSpecCount() < 1) {
 714         fprintf(stderr, "ERROR: must specify zip file name\n");
 715         goto bail;
 716     }
 717     zipFileName = bundle->getFileSpecEntry(0);
 718
 719     if (bundle->getFileSpecCount() < 2) {
 720         fprintf(stderr, "NOTE: nothing to do\n");
 721         goto bail;
 722     }
 723
 724     zip = openReadWrite(zipFileName, true);
 725     if (zip == NULL) {
 726         fprintf(stderr, "ERROR: failed opening/creating '%s' as Zip file\n", zipFileName);
 727         goto bail;
 728     }
 729
 730     for (int i = 1; i < bundle->getFileSpecCount(); i++) {
 731         const char* fileName = bundle->getFileSpecEntry(i);
 732
 733         if (strcasecmp(String8(fileName).getPathExtension().string(), ".gz") == 0) {
 734             printf(" '%s'... (from gzip)\n", fileName);
 735             result = zip->addGzip(fileName, String8(fileName).getBasePath().string(), NULL);
 736         } else {
 737             printf(" '%s'...\n", fileName);
 738             result = zip->add(fileName, bundle->getCompressionMethod(), NULL);
 739         }
 740         if (result != NO_ERROR) {
 741             fprintf(stderr, "Unable to add '%s' to '%s'", bundle->getFileSpecEntry(i), zipFileName);
 742             if (result == NAME_NOT_FOUND)
 743                 fprintf(stderr, ": file not found\n");
 744             else if (result == ALREADY_EXISTS)
 745                 fprintf(stderr, ": already exists in archive\n");
 746             else
 747                 fprintf(stderr, "\n");
 748             goto bail;
 749         }
 750     }
 751
 752     result = NO_ERROR;
 753
 754 bail:
 755     delete zip;
 756     return (result != NO_ERROR);
 757 }
 758
 759
 760 /*
 761  * Delete files from an existing archive.
 762  */
 763 int doRemove(Bundle* bundle)
 764 {
 765     ZipFile* zip = NULL;
 766     status_t result = UNKNOWN_ERROR;
 767     const char* zipFileName;
 768
 769     if (bundle->getFileSpecCount() < 1) {
 770         fprintf(stderr, "ERROR: must specify zip file name\n");
 771         goto bail;
 772     }
 773     zipFileName = bundle->getFileSpecEntry(0);
 774
 775     if (bundle->getFileSpecCount() < 2) {
 776         fprintf(stderr, "NOTE: nothing to do\n");
 777         goto bail;
 778     }
 779
 780     zip = openReadWrite(zipFileName, false);
 781     if (zip == NULL) {
 782         fprintf(stderr, "ERROR: failed opening Zip archive '%s'\n",
 783             zipFileName);
 784         goto bail;
 785     }
 786
 787     for (int i = 1; i < bundle->getFileSpecCount(); i++) {
 788         const char* fileName = bundle->getFileSpecEntry(i);
 789         ZipEntry* entry;
 790
 791         entry = zip->getEntryByName(fileName);
 792         if (entry == NULL) {
 793             printf(" '%s' NOT FOUND\n", fileName);
 794             continue;
 795         }
 796
 797         result = zip->remove(entry);
 798
 799         if (result != NO_ERROR) {
 800             fprintf(stderr, "Unable to delete '%s' from '%s'\n",
 801                 bundle->getFileSpecEntry(i), zipFileName);
 802             goto bail;
 803         }
 804     }
 805
 806     /* update the archive */
 807     zip->flush();
 808
 809 bail:
 810     delete zip;
 811     return (result != NO_ERROR);
 812 }
 813
 814
 815 /*
 816  * Package up an asset directory and associated application files.
 817  */
 818 int doPackage(Bundle* bundle)
 819 {
 820     const char* outputAPKFile;
 821     int retVal = 1;
 822     status_t err;
 823     sp<AaptAssets> assets;
 824     int N;
 825
 826     // -c zz_ZZ means do pseudolocalization
 827     ResourceFilter filter;
 828     err = filter.parse(bundle->getConfigurations());
 829     if (err != NO_ERROR) {
 830         goto bail;
 831     }
 832     if (filter.containsPseudo()) {
 833         bundle->setPseudolocalize(true);
 834     }
 835
 836     N = bundle->getFileSpecCount();
 837     if (N < 1 && bundle->getResourceSourceDirs().size() == 0 && bundle->getJarFiles().size() == 0
 838             && bundle->getAndroidManifestFile() == NULL && bundle->getAssetSourceDir() == NULL) {
 839         fprintf(stderr, "ERROR: no input files\n");
 840         goto bail;
 841     }
 842
 843     outputAPKFile = bundle->getOutputAPKFile();
 844
 845     // Make sure the filenames provided exist and are of the appropriate type.
 846     if (outputAPKFile) {
 847         FileType type;
 848         type = getFileType(outputAPKFile);
 849         if (type != kFileTypeNonexistent && type != kFileTypeRegular) {
 850             fprintf(stderr,
 851                 "ERROR: output file '%s' exists but is not regular file\n",
 852                 outputAPKFile);
 853             goto bail;
 854         }
 855     }
 856
 857     // Load the assets.
 858     assets = new AaptAssets();
 859     err = assets->slurpFromArgs(bundle);
 860     if (err < 0) {
 861         goto bail;
 862     }
 863
 864     if (bundle->getVerbose()) {
 865         assets->print();
 866     }
 867
 868     // If they asked for any files that need to be compiled, do so.
 869     if (bundle->getResourceSourceDirs().size() || bundle->getAndroidManifestFile()) {
 870         err = buildResources(bundle, assets);
 871         if (err != 0) {
 872             goto bail;
 873         }
 874     }
 875
 876     // At this point we've read everything and processed everything.  From here
 877     // on out it's just writing output files.
 878     if (SourcePos::hasErrors()) {
 879         goto bail;
 880     }
 881
 882     // Write out R.java constants
 883     if (assets->getPackage() == assets->getSymbolsPrivatePackage()) {
 884         err = writeResourceSymbols(bundle, assets, assets->getPackage(), true);
 885         if (err < 0) {
 886             goto bail;
 887         }
 888     } else {
 889         err = writeResourceSymbols(bundle, assets, assets->getPackage(), false);
 890         if (err < 0) {
 891             goto bail;
 892         }
 893         err = writeResourceSymbols(bundle, assets, assets->getSymbolsPrivatePackage(), true);
 894         if (err < 0) {
 895             goto bail;
 896         }
 897     }
 898
 899     // Write the apk
 900     if (outputAPKFile) {
 901         err = writeAPK(bundle, assets, String8(outputAPKFile));
 902         if (err != NO_ERROR) {
 903             fprintf(stderr, "ERROR: packaging of '%s' failed\n", outputAPKFile);
 904             goto bail;
 905         }
 906     }
 907
 908     retVal = 0;
 909 bail:
 910     if (SourcePos::hasErrors()) {
 911         SourcePos::printErrors(stderr);
 912     }
 913     return retVal;
 914 }