[android/aapt.git] / Package.cpp

//
// Copyright 2006 The Android Open Source Project
//
// Package assets into Zip files.
//
#include "Main.h"
#include "AaptAssets.h"
#include "ResourceTable.h"

#include <utils/Log.h>
#include <utils/threads.h>
#include <utils/List.h>
#include <utils/Errors.h>

#include <sys/types.h>
#include <dirent.h>
#include <ctype.h>
#include <errno.h>

using namespace android;

static const char* kExcludeExtension = ".EXCLUDE";

/* these formats are already compressed, or don't compress well */
static const char* kNoCompressExt[] = {
    ".jpg", ".jpeg", ".png", ".gif",
    ".wav", ".mp2", ".mp3", ".ogg", ".aac",
    ".mpg", ".mpeg", ".mid", ".midi", ".smf", ".jet",
    ".rtttl", ".imy", ".xmf", ".mp4", ".m4a",
    ".m4v", ".3gp", ".3gpp", ".3g2", ".3gpp2",
    ".amr", ".awb", ".wma", ".wmv"
};

/* fwd decls, so I can write this downward */
ssize_t processAssets(Bundle* bundle, ZipFile* zip, const sp<AaptAssets>& assets);
ssize_t processAssets(Bundle* bundle, ZipFile* zip, const sp<AaptDir>& dir,
                        const AaptGroupEntry& ge, const ResourceFilter* filter);
bool processFile(Bundle* bundle, ZipFile* zip,
                        const sp<AaptGroup>& group, const sp<AaptFile>& file);
bool okayToCompress(Bundle* bundle, const String8& pathName);
ssize_t processJarFiles(Bundle* bundle, ZipFile* zip);

/*
 * The directory hierarchy looks like this:
 * "outputDir" and "assetRoot" are existing directories.
 *
 * On success, "bundle->numPackages" will be the number of Zip packages
 * we created.
 */
status_t writeAPK(Bundle* bundle, const sp<AaptAssets>& assets,
                       const String8& outputFile)
{
    status_t result = NO_ERROR;
    ZipFile* zip = NULL;
    int count;

    //bundle->setPackageCount(0);

    /*
     * Prep the Zip archive.
     *
     * If the file already exists, fail unless "update" or "force" is set.
     * If "update" is set, update the contents of the existing archive.
     * Else, if "force" is set, remove the existing archive.
     */
    FileType fileType = getFileType(outputFile.string());
    if (fileType == kFileTypeNonexistent) {
        // okay, create it below
    } else if (fileType == kFileTypeRegular) {
        if (bundle->getUpdate()) {
            // okay, open it below
        } else if (bundle->getForce()) {
            if (unlink(outputFile.string()) != 0) {
                fprintf(stderr, "ERROR: unable to remove '%s': %s\n", outputFile.string(),
                        strerror(errno));
                goto bail;
            }
        } else {
            fprintf(stderr, "ERROR: '%s' exists (use '-f' to force overwrite)\n",
                    outputFile.string());
            goto bail;
        }
    } else {
        fprintf(stderr, "ERROR: '%s' exists and is not a regular file\n", outputFile.string());
        goto bail;
    }

    if (bundle->getVerbose()) {
        printf("%s '%s'\n", (fileType == kFileTypeNonexistent) ? "Creating" : "Opening",
                outputFile.string());
    }

    status_t status;
    zip = new ZipFile;
    status = zip->open(outputFile.string(), ZipFile::kOpenReadWrite | ZipFile::kOpenCreate);
    if (status != NO_ERROR) {
        fprintf(stderr, "ERROR: unable to open '%s' as Zip file for writing\n",
                outputFile.string());
        goto bail;
    }

    if (bundle->getVerbose()) {
        printf("Writing all files...\n");
    }

    count = processAssets(bundle, zip, assets);
    if (count < 0) {
        fprintf(stderr, "ERROR: unable to process assets while packaging '%s'\n",
                outputFile.string());
        result = count;
        goto bail;
    }

    if (bundle->getVerbose()) {
        printf("Generated %d file%s\n", count, (count==1) ? "" : "s");
    }
    
    count = processJarFiles(bundle, zip);
    if (count < 0) {
        fprintf(stderr, "ERROR: unable to process jar files while packaging '%s'\n",
                outputFile.string());
        result = count;
        goto bail;
    }
    
    if (bundle->getVerbose())
        printf("Included %d file%s from jar/zip files.\n", count, (count==1) ? "" : "s");
    
    result = NO_ERROR;

    /*
     * Check for cruft.  We set the "marked" flag on all entries we created
     * or decided not to update.  If the entry isn't already slated for
     * deletion, remove it now.
     */
    {
        if (bundle->getVerbose())
            printf("Checking for deleted files\n");
        int i, removed = 0;
        for (i = 0; i < zip->getNumEntries(); i++) {
            ZipEntry* entry = zip->getEntryByIndex(i);

            if (!entry->getMarked() && entry->getDeleted()) {
                if (bundle->getVerbose()) {
                    printf("      (removing crufty '%s')\n",
                        entry->getFileName());
                }
                zip->remove(entry);
                removed++;
            }
        }
        if (bundle->getVerbose() && removed > 0)
            printf("Removed %d file%s\n", removed, (removed==1) ? "" : "s");
    }

    /* tell Zip lib to process deletions and other pending changes */
    result = zip->flush();
    if (result != NO_ERROR) {
        fprintf(stderr, "ERROR: Zip flush failed, archive may be hosed\n");
        goto bail;
    }

    /* anything here? */
    if (zip->getNumEntries() == 0) {
        if (bundle->getVerbose()) {
            printf("Archive is empty -- removing %s\n", outputFile.getPathLeaf().string());
        }
        delete zip;        // close the file so we can remove it in Win32
        zip = NULL;
        if (unlink(outputFile.string()) != 0) {
            fprintf(stderr, "warning: could not unlink '%s'\n", outputFile.string());
        }
    }

    assert(result == NO_ERROR);

bail:
    delete zip;        // must close before remove in Win32
    if (result != NO_ERROR) {
        if (bundle->getVerbose()) {
            printf("Removing %s due to earlier failures\n", outputFile.string());
        }
        if (unlink(outputFile.string()) != 0) {
            fprintf(stderr, "warning: could not unlink '%s'\n", outputFile.string());
        }
    }

    if (result == NO_ERROR && bundle->getVerbose())
        printf("Done!\n");
    return result;
}

ssize_t processAssets(Bundle* bundle, ZipFile* zip,
                      const sp<AaptAssets>& assets)
{
    ResourceFilter filter;
    status_t status = filter.parse(bundle->getConfigurations());
    if (status != NO_ERROR) {
        return -1;
    }

    ssize_t count = 0;

    const size_t N = assets->getGroupEntries().size();
    for (size_t i=0; i<N; i++) {
        const AaptGroupEntry& ge = assets->getGroupEntries()[i];

        ssize_t res = processAssets(bundle, zip, assets, ge, &filter);
        if (res < 0) {
            return res;
        }

        count += res;
    }

    return count;
}

ssize_t processAssets(Bundle* bundle, ZipFile* zip, const sp<AaptDir>& dir,
        const AaptGroupEntry& ge, const ResourceFilter* filter)
{
    ssize_t count = 0;

    const size_t ND = dir->getDirs().size();
    size_t i;
    for (i=0; i<ND; i++) {
        const sp<AaptDir>& subDir = dir->getDirs().valueAt(i);

        const bool filterable = filter != NULL && subDir->getLeaf().find("mipmap-") != 0;

        if (filterable && subDir->getLeaf() != subDir->getPath() && !filter->match(ge.toParams())) {
            continue;
        }

        ssize_t res = processAssets(bundle, zip, subDir, ge, filterable ? filter : NULL);
        if (res < 0) {
            return res;
        }
        count += res;
    }

    if (filter != NULL && !filter->match(ge.toParams())) {
        return count;
    }

    const size_t NF = dir->getFiles().size();
    for (i=0; i<NF; i++) {
        sp<AaptGroup> gp = dir->getFiles().valueAt(i);
        ssize_t fi = gp->getFiles().indexOfKey(ge);
        if (fi >= 0) {
            sp<AaptFile> fl = gp->getFiles().valueAt(fi);
            if (!processFile(bundle, zip, gp, fl)) {
                return UNKNOWN_ERROR;
            }
            count++;
        }
    }

    return count;
}

/*
 * Process a regular file, adding it to the archive if appropriate.
 *
 * If we're in "update" mode, and the file already exists in the archive,
 * delete the existing entry before adding the new one.
 */
bool processFile(Bundle* bundle, ZipFile* zip,
                 const sp<AaptGroup>& group, const sp<AaptFile>& file)
{
    const bool hasData = file->hasData();

    String8 storageName(group->getPath());
    storageName.convertToResPath();
    ZipEntry* entry;
    bool fromGzip = false;
    status_t result;

    /*
     * See if the filename ends in ".EXCLUDE".  We can't use
     * String8::getPathExtension() because the length of what it considers
     * to be an extension is capped.
     *
     * The Asset Manager doesn't check for ".EXCLUDE" in Zip archives,
     * so there's no value in adding them (and it makes life easier on
     * the AssetManager lib if we don't).
     *
     * NOTE: this restriction has been removed.  If you're in this code, you
     * should clean this up, but I'm in here getting rid of Path Name, and I
     * don't want to make other potentially breaking changes --joeo
     */
    int fileNameLen = storageName.length();
    int excludeExtensionLen = strlen(kExcludeExtension);
    if (fileNameLen > excludeExtensionLen
            && (0 == strcmp(storageName.string() + (fileNameLen - excludeExtensionLen),
                            kExcludeExtension))) {
        fprintf(stderr, "warning: '%s' not added to Zip\n", storageName.string());
        return true;
    }

    if (strcasecmp(storageName.getPathExtension().string(), ".gz") == 0) {
        fromGzip = true;
        storageName = storageName.getBasePath();
    }

    if (bundle->getUpdate()) {
        entry = zip->getEntryByName(storageName.string());
        if (entry != NULL) {
            /* file already exists in archive; there can be only one */
            if (entry->getMarked()) {
                fprintf(stderr,
                        "ERROR: '%s' exists twice (check for with & w/o '.gz'?)\n",
                        file->getPrintableSource().string());
                return false;
            }
            if (!hasData) {
                const String8& srcName = file->getSourceFile();
                time_t fileModWhen;
                fileModWhen = getFileModDate(srcName.string());
                if (fileModWhen == (time_t) -1) { // file existence tested earlier,
                    return false;                 //  not expecting an error here
                }
    
                if (fileModWhen > entry->getModWhen()) {
                    // mark as deleted so add() will succeed
                    if (bundle->getVerbose()) {
                        printf("      (removing old '%s')\n", storageName.string());
                    }
    
                    zip->remove(entry);
                } else {
                    // version in archive is newer
                    if (bundle->getVerbose()) {
                        printf("      (not updating '%s')\n", storageName.string());
                    }
                    entry->setMarked(true);
                    return true;
                }
            } else {
                // Generated files are always replaced.
                zip->remove(entry);
            }
        }
    }

    //android_setMinPriority(NULL, ANDROID_LOG_VERBOSE);

    if (fromGzip) {
        result = zip->addGzip(file->getSourceFile().string(), storageName.string(), &entry);
    } else if (!hasData) {
        /* don't compress certain files, e.g. PNGs */
        int compressionMethod = bundle->getCompressionMethod();
        if (!okayToCompress(bundle, storageName)) {
            compressionMethod = ZipEntry::kCompressStored;
        }
        result = zip->add(file->getSourceFile().string(), storageName.string(), compressionMethod,
                            &entry);
    } else {
        result = zip->add(file->getData(), file->getSize(), storageName.string(),
                           file->getCompressionMethod(), &entry);
    }
    if (result == NO_ERROR) {
        if (bundle->getVerbose()) {
            printf("      '%s'%s", storageName.string(), fromGzip ? " (from .gz)" : "");
            if (entry->getCompressionMethod() == ZipEntry::kCompressStored) {
                printf(" (not compressed)\n");
            } else {
                printf(" (compressed %d%%)\n", calcPercent(entry->getUncompressedLen(),
                            entry->getCompressedLen()));
            }
        }
        entry->setMarked(true);
    } else {
        if (result == ALREADY_EXISTS) {
            fprintf(stderr, "      Unable to add '%s': file already in archive (try '-u'?)\n",
                    file->getPrintableSource().string());
        } else {
            fprintf(stderr, "      Unable to add '%s': Zip add failed\n", 
                    file->getPrintableSource().string());
        }
        return false;
    }

    return true;
}

/*
 * Determine whether or not we want to try to compress this file based
 * on the file extension.
 */
bool okayToCompress(Bundle* bundle, const String8& pathName)
{
    String8 ext = pathName.getPathExtension();
    int i;

    if (ext.length() == 0)
        return true;

    for (i = 0; i < NELEM(kNoCompressExt); i++) {
        if (strcasecmp(ext.string(), kNoCompressExt[i]) == 0)
            return false;
    }

    const android::Vector<const char*>& others(bundle->getNoCompressExtensions());
    for (i = 0; i < (int)others.size(); i++) {
        const char* str = others[i];
        int pos = pathName.length() - strlen(str);
        if (pos < 0) {
            continue;
        }
        const char* path = pathName.string();
        if (strcasecmp(path + pos, str) == 0) {
            return false;
        }
    }

    return true;
}

bool endsWith(const char* haystack, const char* needle)
{
    size_t a = strlen(haystack);
    size_t b = strlen(needle);
    if (a < b) return false;
    return strcasecmp(haystack+(a-b), needle) == 0;
}

ssize_t processJarFile(ZipFile* jar, ZipFile* out)
{
    status_t err;
    size_t N = jar->getNumEntries();
    size_t count = 0;
    for (size_t i=0; i<N; i++) {
        ZipEntry* entry = jar->getEntryByIndex(i);
        const char* storageName = entry->getFileName();
        if (endsWith(storageName, ".class")) {
            int compressionMethod = entry->getCompressionMethod();
            size_t size = entry->getUncompressedLen();
            const void* data = jar->uncompress(entry);
            if (data == NULL) {
                fprintf(stderr, "ERROR: unable to uncompress entry '%s'\n",
                    storageName);
                return -1;
            }
            out->add(data, size, storageName, compressionMethod, NULL);
            free((void*)data);
        }
        count++;
    }
    return count;
}

ssize_t processJarFiles(Bundle* bundle, ZipFile* zip)
{
    status_t err;
    ssize_t count = 0;
    const android::Vector<const char*>& jars = bundle->getJarFiles();

    size_t N = jars.size();
    for (size_t i=0; i<N; i++) {
        ZipFile jar;
        err = jar.open(jars[i], ZipFile::kOpenReadOnly);
        if (err != 0) {
            fprintf(stderr, "ERROR: unable to open '%s' as a zip file: %d\n",
                jars[i], err);
            return err;
        }
        err += processJarFile(&jar, zip);
        if (err < 0) {
            fprintf(stderr, "ERROR: unable to process '%s'\n", jars[i]);
            return err;
        }
        count += err;
    }

    return count;
}
Commit	Line	Data
a534180c TAOSP	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
79e5d372 MA	10	#include <utils/Log.h>
	11	#include <utils/threads.h>
	12	#include <utils/List.h>
	13	#include <utils/Errors.h>
a534180c TAOSP	14
	15	#include <sys/types.h>
	16	#include <dirent.h>
	17	#include <ctype.h>
	18	#include <errno.h>
	19
	20	using namespace android;
	21
	22	static const char* kExcludeExtension = ".EXCLUDE";
	23
	24	/* these formats are already compressed, or don't compress well */
	25	static 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 */
	35	ssize_t processAssets(Bundle* bundle, ZipFile* zip, const sp<AaptAssets>& assets);
460ed1b2 KR	36	ssize_t processAssets(Bundle* bundle, ZipFile* zip, const sp<AaptDir>& dir,
460ed1b2 KR	37	const AaptGroupEntry& ge, const ResourceFilter* filter);
a534180c TAOSP	38	bool processFile(Bundle* bundle, ZipFile* zip,
	39	const sp<AaptGroup>& group, const sp<AaptFile>& file);
	40	bool okayToCompress(Bundle* bundle, const String8& pathName);
	41	ssize_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	*/
	50	status_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) {
406a85e3	171	fprintf(stderr, "warning: could not unlink '%s'\n", outputFile.string());
a534180c TAOSP	172	}
	173	}
	174
	175	assert(result == NO_ERROR);
	176
	177	bail:
	178	delete zip; // must close before remove in Win32
	179	if (result != NO_ERROR) {
	180	if (bundle->getVerbose()) {
	181	printf("Removing %s due to earlier failures\n", outputFile.string());
	182	}
	183	if (unlink(outputFile.string()) != 0) {
406a85e3	184	fprintf(stderr, "warning: could not unlink '%s'\n", outputFile.string());
a534180c TAOSP	185	}
	186	}
	187
	188	if (result == NO_ERROR && bundle->getVerbose())
	189	printf("Done!\n");
	190	return result;
	191	}
	192
	193	ssize_t processAssets(Bundle* bundle, ZipFile* zip,
	194	const sp<AaptAssets>& assets)
	195	{
	196	ResourceFilter filter;
	197	status_t status = filter.parse(bundle->getConfigurations());
	198	if (status != NO_ERROR) {
	199	return -1;
	200	}
	201
	202	ssize_t count = 0;
	203
	204	const size_t N = assets->getGroupEntries().size();
	205	for (size_t i=0; i<N; i++) {
	206	const AaptGroupEntry& ge = assets->getGroupEntries()[i];
460ed1b2 KR	207
460ed1b2 KR	208	ssize_t res = processAssets(bundle, zip, assets, ge, &filter);
a534180c TAOSP	209	if (res < 0) {
	210	return res;
	211	}
460ed1b2	212
a534180c TAOSP	213	count += res;
	214	}
	215
	216	return count;
	217	}
	218
460ed1b2 KR	219	ssize_t processAssets(Bundle* bundle, ZipFile* zip, const sp<AaptDir>& dir,
460ed1b2 KR	220	const AaptGroupEntry& ge, const ResourceFilter* filter)
a534180c TAOSP	221	{
	222	ssize_t count = 0;
	223
	224	const size_t ND = dir->getDirs().size();
	225	size_t i;
	226	for (i=0; i<ND; i++) {
460ed1b2 KR	227	const sp<AaptDir>& subDir = dir->getDirs().valueAt(i);
	228
	229	const bool filterable = filter != NULL && subDir->getLeaf().find("mipmap-") != 0;
	230
	231	if (filterable && subDir->getLeaf() != subDir->getPath() && !filter->match(ge.toParams())) {
	232	continue;
	233	}
	234
	235	ssize_t res = processAssets(bundle, zip, subDir, ge, filterable ? filter : NULL);
a534180c TAOSP	236	if (res < 0) {
	237	return res;
	238	}
	239	count += res;
	240	}
	241
460ed1b2 KR	242	if (filter != NULL && !filter->match(ge.toParams())) {
	243	return count;
	244	}
	245
a534180c TAOSP	246	const size_t NF = dir->getFiles().size();
	247	for (i=0; i<NF; i++) {
	248	sp<AaptGroup> gp = dir->getFiles().valueAt(i);
	249	ssize_t fi = gp->getFiles().indexOfKey(ge);
	250	if (fi >= 0) {
	251	sp<AaptFile> fl = gp->getFiles().valueAt(fi);
	252	if (!processFile(bundle, zip, gp, fl)) {
	253	return UNKNOWN_ERROR;
	254	}
	255	count++;
	256	}
	257	}
	258
	259	return count;
	260	}
	261
	262	/*
	263	* Process a regular file, adding it to the archive if appropriate.
	264	*
	265	* If we're in "update" mode, and the file already exists in the archive,
	266	* delete the existing entry before adding the new one.
	267	*/
	268	bool processFile(Bundle* bundle, ZipFile* zip,
	269	const sp<AaptGroup>& group, const sp<AaptFile>& file)
	270	{
	271	const bool hasData = file->hasData();
	272
	273	String8 storageName(group->getPath());
	274	storageName.convertToResPath();
	275	ZipEntry* entry;
	276	bool fromGzip = false;
	277	status_t result;
	278
	279	/*
	280	* See if the filename ends in ".EXCLUDE". We can't use
	281	* String8::getPathExtension() because the length of what it considers
	282	* to be an extension is capped.
	283	*
	284	* The Asset Manager doesn't check for ".EXCLUDE" in Zip archives,
	285	* so there's no value in adding them (and it makes life easier on
	286	* the AssetManager lib if we don't).
	287	*
	288	* NOTE: this restriction has been removed. If you're in this code, you
	289	* should clean this up, but I'm in here getting rid of Path Name, and I
	290	* don't want to make other potentially breaking changes --joeo
	291	*/
	292	int fileNameLen = storageName.length();
	293	int excludeExtensionLen = strlen(kExcludeExtension);
	294	if (fileNameLen > excludeExtensionLen
	295	&& (0 == strcmp(storageName.string() + (fileNameLen - excludeExtensionLen),
	296	kExcludeExtension))) {
406a85e3	297	fprintf(stderr, "warning: '%s' not added to Zip\n", storageName.string());
a534180c TAOSP	298	return true;
	299	}
	300
	301	if (strcasecmp(storageName.getPathExtension().string(), ".gz") == 0) {
	302	fromGzip = true;
	303	storageName = storageName.getBasePath();
	304	}
	305
	306	if (bundle->getUpdate()) {
	307	entry = zip->getEntryByName(storageName.string());
	308	if (entry != NULL) {
	309	/* file already exists in archive; there can be only one */
	310	if (entry->getMarked()) {
	311	fprintf(stderr,
	312	"ERROR: '%s' exists twice (check for with & w/o '.gz'?)\n",
	313	file->getPrintableSource().string());
	314	return false;
	315	}
	316	if (!hasData) {
	317	const String8& srcName = file->getSourceFile();
	318	time_t fileModWhen;
	319	fileModWhen = getFileModDate(srcName.string());
	320	if (fileModWhen == (time_t) -1) { // file existence tested earlier,
	321	return false; // not expecting an error here
	322	}
	323
	324	if (fileModWhen > entry->getModWhen()) {
	325	// mark as deleted so add() will succeed
	326	if (bundle->getVerbose()) {
	327	printf(" (removing old '%s')\n", storageName.string());
	328	}
	329
	330	zip->remove(entry);
	331	} else {
	332	// version in archive is newer
	333	if (bundle->getVerbose()) {
	334	printf(" (not updating '%s')\n", storageName.string());
	335	}
	336	entry->setMarked(true);
	337	return true;
	338	}
	339	} else {
	340	// Generated files are always replaced.
	341	zip->remove(entry);
	342	}
	343	}
	344	}
	345
	346	//android_setMinPriority(NULL, ANDROID_LOG_VERBOSE);
	347
	348	if (fromGzip) {
	349	result = zip->addGzip(file->getSourceFile().string(), storageName.string(), &entry);
	350	} else if (!hasData) {
	351	/* don't compress certain files, e.g. PNGs */
	352	int compressionMethod = bundle->getCompressionMethod();
	353	if (!okayToCompress(bundle, storageName)) {
	354	compressionMethod = ZipEntry::kCompressStored;
	355	}
	356	result = zip->add(file->getSourceFile().string(), storageName.string(), compressionMethod,
	357	&entry);
	358	} else {
	359	result = zip->add(file->getData(), file->getSize(), storageName.string(),
	360	file->getCompressionMethod(), &entry);
	361	}
362	if (result == NO_ERROR) {
363	if (bundle->getVerbose()) {
364	printf(" '%s'%s", storageName.string(), fromGzip ? " (from .gz)" : "");
365	if (entry->getCompressionMethod() == ZipEntry::kCompressStored) {
366	printf(" (not compressed)\n");
367	} else {
368	printf(" (compressed %d%%)\n", calcPercent(entry->getUncompressedLen(),
369	entry->getCompressedLen()));
370	}
371	}
372	entry->setMarked(true);
373	} else {
374	if (result == ALREADY_EXISTS) {
375	fprintf(stderr, " Unable to add '%s': file already in archive (try '-u'?)\n",
376	file->getPrintableSource().string());
377	} else {
378	fprintf(stderr, " Unable to add '%s': Zip add failed\n",
379	file->getPrintableSource().string());
380	}
381	return false;
382	}
383
384	return true;
385	}
386
387	/*
388	* Determine whether or not we want to try to compress this file based
389	* on the file extension.
390	*/
391	bool okayToCompress(Bundle* bundle, const String8& pathName)
392	{
393	String8 ext = pathName.getPathExtension();
394	int i;
395
396	if (ext.length() == 0)
397	return true;
398
399	for (i = 0; i < NELEM(kNoCompressExt); i++) {
400	if (strcasecmp(ext.string(), kNoCompressExt[i]) == 0)
401	return false;
402	}
403
404	const android::Vector<const char*>& others(bundle->getNoCompressExtensions());
405	for (i = 0; i < (int)others.size(); i++) {
406	const char* str = others[i];
407	int pos = pathName.length() - strlen(str);
408	if (pos < 0) {
409	continue;
410	}
411	const char* path = pathName.string();
412	if (strcasecmp(path + pos, str) == 0) {
413	return false;
414	}
415	}
416
417	return true;
418	}
419
420	bool endsWith(const char* haystack, const char* needle)
421	{
422	size_t a = strlen(haystack);
423	size_t b = strlen(needle);
424	if (a < b) return false;
425	return strcasecmp(haystack+(a-b), needle) == 0;
426	}
427
428	ssize_t processJarFile(ZipFile* jar, ZipFile* out)
429	{
430	status_t err;
431	size_t N = jar->getNumEntries();
432	size_t count = 0;
433	for (size_t i=0; i<N; i++) {
434	ZipEntry* entry = jar->getEntryByIndex(i);
435	const char* storageName = entry->getFileName();
436	if (endsWith(storageName, ".class")) {
437	int compressionMethod = entry->getCompressionMethod();
438	size_t size = entry->getUncompressedLen();
439	const void* data = jar->uncompress(entry);
440	if (data == NULL) {
441	fprintf(stderr, "ERROR: unable to uncompress entry '%s'\n",
442	storageName);
443	return -1;
444	}
445	out->add(data, size, storageName, compressionMethod, NULL);
446	free((void*)data);
447	}
448	count++;
449	}
450	return count;
451	}
452
453	ssize_t processJarFiles(Bundle* bundle, ZipFile* zip)
454	{
c70f9935	455	status_t err;
a534180c TAOSP	456	ssize_t count = 0;
	457	const android::Vector<const char*>& jars = bundle->getJarFiles();
	458
	459	size_t N = jars.size();
	460	for (size_t i=0; i<N; i++) {
	461	ZipFile jar;
	462	err = jar.open(jars[i], ZipFile::kOpenReadOnly);
	463	if (err != 0) {
58f944ba	464	fprintf(stderr, "ERROR: unable to open '%s' as a zip file: %d\n",
a534180c TAOSP	465	jars[i], err);
	466	return err;
	467	}
	468	err += processJarFile(&jar, zip);
	469	if (err < 0) {
	470	fprintf(stderr, "ERROR: unable to process '%s'\n", jars[i]);
	471	return err;
	472	}
	473	count += err;
	474	}
	475
	476	return count;
	477	}