Package.cpp

   1 //
   2 // Copyright 2006 The Android Open Source Project
   3 //
   4 // Package assets into Zip files.
   5 //
   6 #include "Main.h"
   7 #include "AaptAssets.h"
   8 #include "ResourceTable.h"
   9 #include "ResourceFilter.h"
  10
  11 #include <utils/Log.h>
  12 #include <utils/threads.h>
  13 #include <utils/List.h>
  14 #include <utils/Errors.h>
  15
  16 #include <sys/types.h>
  17 #include <dirent.h>
  18 #include <ctype.h>
  19 #include <errno.h>
  20
  21 using namespace android;
  22
  23 static const char* kExcludeExtension = ".EXCLUDE";
  24
  25 /* these formats are already compressed, or don't compress well */
  26 static const char* kNoCompressExt[] = {
  27     ".jpg", ".jpeg", ".png", ".gif",
  28     ".wav", ".mp2", ".mp3", ".ogg", ".aac",
  29     ".mpg", ".mpeg", ".mid", ".midi", ".smf", ".jet",
  30     ".rtttl", ".imy", ".xmf", ".mp4", ".m4a",
  31     ".m4v", ".3gp", ".3gpp", ".3g2", ".3gpp2",
  32     ".amr", ".awb", ".wma", ".wmv"
  33 };
  34
  35 /* fwd decls, so I can write this downward */
  36 ssize_t processAssets(Bundle* bundle, ZipFile* zip, const sp<AaptAssets>& assets);
  37 ssize_t processAssets(Bundle* bundle, ZipFile* zip, const sp<AaptDir>& dir,
  38                         const AaptGroupEntry& ge, const ResourceFilter* filter);
  39 bool processFile(Bundle* bundle, ZipFile* zip,
  40                         const sp<AaptGroup>& group, const sp<AaptFile>& file);
  41 bool okayToCompress(Bundle* bundle, const String8& pathName);
  42 ssize_t processJarFiles(Bundle* bundle, ZipFile* zip);
  43
  44 /*
  45  * The directory hierarchy looks like this:
  46  * "outputDir" and "assetRoot" are existing directories.
  47  *
  48  * On success, "bundle->numPackages" will be the number of Zip packages
  49  * we created.
  50  */
  51 status_t writeAPK(Bundle* bundle, const sp<AaptAssets>& assets,
  52                        const String8& outputFile)
  53 {
  54     #if BENCHMARK
  55     fprintf(stdout, "BENCHMARK: Starting APK Bundling \n");
  56     long startAPKTime = clock();
  57     #endif /* BENCHMARK */
  58
  59     status_t result = NO_ERROR;
  60     ZipFile* zip = NULL;
  61     int count;
  62
  63     //bundle->setPackageCount(0);
  64
  65     /*
  66      * Prep the Zip archive.
  67      *
  68      * If the file already exists, fail unless "update" or "force" is set.
  69      * If "update" is set, update the contents of the existing archive.
  70      * Else, if "force" is set, remove the existing archive.
  71      */
  72     FileType fileType = getFileType(outputFile.string());
  73     if (fileType == kFileTypeNonexistent) {
  74         // okay, create it below
  75     } else if (fileType == kFileTypeRegular) {
  76         if (bundle->getUpdate()) {
  77             // okay, open it below
  78         } else if (bundle->getForce()) {
  79             if (unlink(outputFile.string()) != 0) {
  80                 fprintf(stderr, "ERROR: unable to remove '%s': %s\n", outputFile.string(),
  81                         strerror(errno));
  82                 goto bail;
  83             }
  84         } else {
  85             fprintf(stderr, "ERROR: '%s' exists (use '-f' to force overwrite)\n",
  86                     outputFile.string());
  87             goto bail;
  88         }
  89     } else {
  90         fprintf(stderr, "ERROR: '%s' exists and is not a regular file\n", outputFile.string());
  91         goto bail;
  92     }
  93
  94     if (bundle->getVerbose()) {
  95         printf("%s '%s'\n", (fileType == kFileTypeNonexistent) ? "Creating" : "Opening",
  96                 outputFile.string());
  97     }
  98
  99     status_t status;
 100     zip = new ZipFile;
 101     status = zip->open(outputFile.string(), ZipFile::kOpenReadWrite | ZipFile::kOpenCreate);
 102     if (status != NO_ERROR) {
 103         fprintf(stderr, "ERROR: unable to open '%s' as Zip file for writing\n",
 104                 outputFile.string());
 105         goto bail;
 106     }
 107
 108     if (bundle->getVerbose()) {
 109         printf("Writing all files...\n");
 110     }
 111
 112     count = processAssets(bundle, zip, assets);
 113     if (count < 0) {
 114         fprintf(stderr, "ERROR: unable to process assets while packaging '%s'\n",
 115                 outputFile.string());
 116         result = count;
 117         goto bail;
 118     }
 119
 120     if (bundle->getVerbose()) {
 121         printf("Generated %d file%s\n", count, (count==1) ? "" : "s");
 122     }
 123
 124     count = processJarFiles(bundle, zip);
 125     if (count < 0) {
 126         fprintf(stderr, "ERROR: unable to process jar files while packaging '%s'\n",
 127                 outputFile.string());
 128         result = count;
 129         goto bail;
 130     }
 131
 132     if (bundle->getVerbose())
 133         printf("Included %d file%s from jar/zip files.\n", count, (count==1) ? "" : "s");
 134
 135     result = NO_ERROR;
 136
 137     /*
 138      * Check for cruft.  We set the "marked" flag on all entries we created
 139      * or decided not to update.  If the entry isn't already slated for
 140      * deletion, remove it now.
 141      */
 142     {
 143         if (bundle->getVerbose())
 144             printf("Checking for deleted files\n");
 145         int i, removed = 0;
 146         for (i = 0; i < zip->getNumEntries(); i++) {
 147             ZipEntry* entry = zip->getEntryByIndex(i);
 148
 149             if (!entry->getMarked() && entry->getDeleted()) {
 150                 if (bundle->getVerbose()) {
 151                     printf("      (removing crufty '%s')\n",
 152                         entry->getFileName());
 153                 }
 154                 zip->remove(entry);
 155                 removed++;
 156             }
 157         }
 158         if (bundle->getVerbose() && removed > 0)
 159             printf("Removed %d file%s\n", removed, (removed==1) ? "" : "s");
 160     }
 161
 162     /* tell Zip lib to process deletions and other pending changes */
 163     result = zip->flush();
 164     if (result != NO_ERROR) {
 165         fprintf(stderr, "ERROR: Zip flush failed, archive may be hosed\n");
 166         goto bail;
 167     }
 168
 169     /* anything here? */
 170     if (zip->getNumEntries() == 0) {
 171         if (bundle->getVerbose()) {
 172             printf("Archive is empty -- removing %s\n", outputFile.getPathLeaf().string());
 173         }
 174         delete zip;        // close the file so we can remove it in Win32
 175         zip = NULL;
 176         if (unlink(outputFile.string()) != 0) {
 177             fprintf(stderr, "warning: could not unlink '%s'\n", outputFile.string());
 178         }
 179     }
 180
 181     // If we've been asked to generate a dependency file for the .ap_ package,
 182     // do so here
 183     if (bundle->getGenDependencies()) {
 184         // The dependency file gets output to the same directory
 185         // as the specified output file with an additional .d extension.
 186         // e.g. bin/resources.ap_.d
 187         String8 dependencyFile = outputFile;
 188         dependencyFile.append(".d");
 189
 190         FILE* fp = fopen(dependencyFile.string(), "a");
 191         // Add this file to the dependency file
 192         fprintf(fp, "%s \\\n", outputFile.string());
 193         fclose(fp);
 194     }
 195
 196     assert(result == NO_ERROR);
 197
 198 bail:
 199     delete zip;        // must close before remove in Win32
 200     if (result != NO_ERROR) {
 201         if (bundle->getVerbose()) {
 202             printf("Removing %s due to earlier failures\n", outputFile.string());
 203         }
 204         if (unlink(outputFile.string()) != 0) {
 205             fprintf(stderr, "warning: could not unlink '%s'\n", outputFile.string());
 206         }
 207     }
 208
 209     if (result == NO_ERROR && bundle->getVerbose())
 210         printf("Done!\n");
 211
 212     #if BENCHMARK
 213     fprintf(stdout, "BENCHMARK: End APK Bundling. Time Elapsed: %f ms \n",(clock() - startAPKTime)/1000.0);
 214     #endif /* BENCHMARK */
 215     return result;
 216 }
 217
 218 ssize_t processAssets(Bundle* bundle, ZipFile* zip,
 219                       const sp<AaptAssets>& assets)
 220 {
 221     ResourceFilter filter;
 222     status_t status = filter.parse(bundle->getConfigurations());
 223     if (status != NO_ERROR) {
 224         return -1;
 225     }
 226
 227     ssize_t count = 0;
 228
 229     const size_t N = assets->getGroupEntries().size();
 230     for (size_t i=0; i<N; i++) {
 231         const AaptGroupEntry& ge = assets->getGroupEntries()[i];
 232
 233         ssize_t res = processAssets(bundle, zip, assets, ge, &filter);
 234         if (res < 0) {
 235             return res;
 236         }
 237
 238         count += res;
 239     }
 240
 241     return count;
 242 }
 243
 244 ssize_t processAssets(Bundle* bundle, ZipFile* zip, const sp<AaptDir>& dir,
 245         const AaptGroupEntry& ge, const ResourceFilter* filter)
 246 {
 247     ssize_t count = 0;
 248
 249     const size_t ND = dir->getDirs().size();
 250     size_t i;
 251     for (i=0; i<ND; i++) {
 252         const sp<AaptDir>& subDir = dir->getDirs().valueAt(i);
 253
 254         const bool filterable = filter != NULL && subDir->getLeaf().find("mipmap-") != 0;
 255
 256         if (filterable && subDir->getLeaf() != subDir->getPath() && !filter->match(ge.toParams())) {
 257             continue;
 258         }
 259
 260         ssize_t res = processAssets(bundle, zip, subDir, ge, filterable ? filter : NULL);
 261         if (res < 0) {
 262             return res;
 263         }
 264         count += res;
 265     }
 266
 267     if (filter != NULL && !filter->match(ge.toParams())) {
 268         return count;
 269     }
 270
 271     const size_t NF = dir->getFiles().size();
 272     for (i=0; i<NF; i++) {
 273         sp<AaptGroup> gp = dir->getFiles().valueAt(i);
 274         ssize_t fi = gp->getFiles().indexOfKey(ge);
 275         if (fi >= 0) {
 276             sp<AaptFile> fl = gp->getFiles().valueAt(fi);
 277             if (!processFile(bundle, zip, gp, fl)) {
 278                 return UNKNOWN_ERROR;
 279             }
 280             count++;
 281         }
 282     }
 283
 284     return count;
 285 }
 286
 287 /*
 288  * Process a regular file, adding it to the archive if appropriate.
 289  *
 290  * If we're in "update" mode, and the file already exists in the archive,
 291  * delete the existing entry before adding the new one.
 292  */
 293 bool processFile(Bundle* bundle, ZipFile* zip,
 294                  const sp<AaptGroup>& group, const sp<AaptFile>& file)
 295 {
 296     const bool hasData = file->hasData();
 297
 298     String8 storageName(group->getPath());
 299     storageName.convertToResPath();
 300     ZipEntry* entry;
 301     bool fromGzip = false;
 302     status_t result;
 303
 304     /*
 305      * See if the filename ends in ".EXCLUDE".  We can't use
 306      * String8::getPathExtension() because the length of what it considers
 307      * to be an extension is capped.
 308      *
 309      * The Asset Manager doesn't check for ".EXCLUDE" in Zip archives,
 310      * so there's no value in adding them (and it makes life easier on
 311      * the AssetManager lib if we don't).
 312      *
 313      * NOTE: this restriction has been removed.  If you're in this code, you
 314      * should clean this up, but I'm in here getting rid of Path Name, and I
 315      * don't want to make other potentially breaking changes --joeo
 316      */
 317     int fileNameLen = storageName.length();
 318     int excludeExtensionLen = strlen(kExcludeExtension);
 319     if (fileNameLen > excludeExtensionLen
 320             && (0 == strcmp(storageName.string() + (fileNameLen - excludeExtensionLen),
 321                             kExcludeExtension))) {
 322         fprintf(stderr, "warning: '%s' not added to Zip\n", storageName.string());
 323         return true;
 324     }
 325
 326     if (strcasecmp(storageName.getPathExtension().string(), ".gz") == 0) {
 327         fromGzip = true;
 328         storageName = storageName.getBasePath();
 329     }
 330
 331     if (bundle->getUpdate()) {
 332         entry = zip->getEntryByName(storageName.string());
 333         if (entry != NULL) {
 334             /* file already exists in archive; there can be only one */
 335             if (entry->getMarked()) {
 336                 fprintf(stderr,
 337                         "ERROR: '%s' exists twice (check for with & w/o '.gz'?)\n",
 338                         file->getPrintableSource().string());
 339                 return false;
 340             }
 341             if (!hasData) {
 342                 const String8& srcName = file->getSourceFile();
 343                 time_t fileModWhen;
 344                 fileModWhen = getFileModDate(srcName.string());
 345                 if (fileModWhen == (time_t) -1) { // file existence tested earlier,
 346                     return false;                 //  not expecting an error here
 347                 }
 348
 349                 if (fileModWhen > entry->getModWhen()) {
 350                     // mark as deleted so add() will succeed
 351                     if (bundle->getVerbose()) {
 352                         printf("      (removing old '%s')\n", storageName.string());
 353                     }
 354
 355                     zip->remove(entry);
 356                 } else {
 357                     // version in archive is newer
 358                     if (bundle->getVerbose()) {
 359                         printf("      (not updating '%s')\n", storageName.string());
 360                     }
 361                     entry->setMarked(true);
 362                     return true;
 363                 }
 364             } else {
 365                 // Generated files are always replaced.
 366                 zip->remove(entry);
 367             }
 368         }
 369     }
 370
 371     //android_setMinPriority(NULL, ANDROID_LOG_VERBOSE);
 372
 373     if (fromGzip) {
 374         result = zip->addGzip(file->getSourceFile().string(), storageName.string(), &entry);
 375     } else if (!hasData) {
 376         /* don't compress certain files, e.g. PNGs */
 377         int compressionMethod = bundle->getCompressionMethod();
 378         if (!okayToCompress(bundle, storageName)) {
 379             compressionMethod = ZipEntry::kCompressStored;
 380         }
 381         result = zip->add(file->getSourceFile().string(), storageName.string(), compressionMethod,
 382                             &entry);
 383     } else {
 384         result = zip->add(file->getData(), file->getSize(), storageName.string(),
 385                            file->getCompressionMethod(), &entry);
 386     }
 387     if (result == NO_ERROR) {
 388         if (bundle->getVerbose()) {
 389             printf("      '%s'%s", storageName.string(), fromGzip ? " (from .gz)" : "");
 390             if (entry->getCompressionMethod() == ZipEntry::kCompressStored) {
 391                 printf(" (not compressed)\n");
 392             } else {
 393                 printf(" (compressed %d%%)\n", calcPercent(entry->getUncompressedLen(),
 394                             entry->getCompressedLen()));
 395             }
 396         }
 397         entry->setMarked(true);
 398     } else {
 399         if (result == ALREADY_EXISTS) {
 400             fprintf(stderr, "      Unable to add '%s': file already in archive (try '-u'?)\n",
 401                     file->getPrintableSource().string());
 402         } else {
 403             fprintf(stderr, "      Unable to add '%s': Zip add failed\n",
 404                     file->getPrintableSource().string());
 405         }
 406         return false;
 407     }
 408
 409     return true;
 410 }
 411
 412 /*
 413  * Determine whether or not we want to try to compress this file based
 414  * on the file extension.
 415  */
 416 bool okayToCompress(Bundle* bundle, const String8& pathName)
 417 {
 418     String8 ext = pathName.getPathExtension();
 419     int i;
 420
 421     if (ext.length() == 0)
 422         return true;
 423
 424     for (i = 0; i < NELEM(kNoCompressExt); i++) {
 425         if (strcasecmp(ext.string(), kNoCompressExt[i]) == 0)
 426             return false;
 427     }
 428
 429     const android::Vector<const char*>& others(bundle->getNoCompressExtensions());
 430     for (i = 0; i < (int)others.size(); i++) {
 431         const char* str = others[i];
 432         int pos = pathName.length() - strlen(str);
 433         if (pos < 0) {
 434             continue;
 435         }
 436         const char* path = pathName.string();
 437         if (strcasecmp(path + pos, str) == 0) {
 438             return false;
 439         }
 440     }
 441
 442     return true;
 443 }
 444
 445 bool endsWith(const char* haystack, const char* needle)
 446 {
 447     size_t a = strlen(haystack);
 448     size_t b = strlen(needle);
 449     if (a < b) return false;
 450     return strcasecmp(haystack+(a-b), needle) == 0;
 451 }
 452
 453 ssize_t processJarFile(ZipFile* jar, ZipFile* out)
 454 {
 455     status_t err;
 456     size_t N = jar->getNumEntries();
 457     size_t count = 0;
 458     for (size_t i=0; i<N; i++) {
 459         ZipEntry* entry = jar->getEntryByIndex(i);
 460         const char* storageName = entry->getFileName();
 461         if (endsWith(storageName, ".class")) {
 462             int compressionMethod = entry->getCompressionMethod();
 463             size_t size = entry->getUncompressedLen();
 464             const void* data = jar->uncompress(entry);
 465             if (data == NULL) {
 466                 fprintf(stderr, "ERROR: unable to uncompress entry '%s'\n",
 467                     storageName);
 468                 return -1;
 469             }
 470             out->add(data, size, storageName, compressionMethod, NULL);
 471             free((void*)data);
 472         }
 473         count++;
 474     }
 475     return count;
 476 }
 477
 478 ssize_t processJarFiles(Bundle* bundle, ZipFile* zip)
 479 {
 480     status_t err;
 481     ssize_t count = 0;
 482     const android::Vector<const char*>& jars = bundle->getJarFiles();
 483
 484     size_t N = jars.size();
 485     for (size_t i=0; i<N; i++) {
 486         ZipFile jar;
 487         err = jar.open(jars[i], ZipFile::kOpenReadOnly);
 488         if (err != 0) {
 489             fprintf(stderr, "ERROR: unable to open '%s' as a zip file: %d\n",
 490                 jars[i], err);
 491             return err;
 492         }
 493         err += processJarFile(&jar, zip);
 494         if (err < 0) {
 495             fprintf(stderr, "ERROR: unable to process '%s'\n", jars[i]);
 496             return err;
 497         }
 498         count += err;
 499     }
 500
 501     return count;
 502 }