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