AssetManager.cpp revision 49921f2c05cff6d4526b5b30f7b8e2d8bbabc069
1/*
2 * Copyright (C) 2006 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17//
18// Provide access to read-only assets.
19//
20
21#define LOG_TAG "asset"
22#define ATRACE_TAG ATRACE_TAG_RESOURCES
23//#define LOG_NDEBUG 0
24
25#include <androidfw/Asset.h>
26#include <androidfw/AssetDir.h>
27#include <androidfw/AssetManager.h>
28#include <androidfw/misc.h>
29#include <androidfw/ResourceTypes.h>
30#include <androidfw/ZipFileRO.h>
31#include <utils/Atomic.h>
32#include <utils/Log.h>
33#include <utils/String8.h>
34#include <utils/String8.h>
35#include <utils/threads.h>
36#include <utils/Timers.h>
37#include <utils/Trace.h>
38
39#include <assert.h>
40#include <dirent.h>
41#include <errno.h>
42#include <string.h> // strerror
43#include <strings.h>
44
45#ifndef TEMP_FAILURE_RETRY
46/* Used to retry syscalls that can return EINTR. */
47#define TEMP_FAILURE_RETRY(exp) ({         \
48    typeof (exp) _rc;                      \
49    do {                                   \
50        _rc = (exp);                       \
51    } while (_rc == -1 && errno == EINTR); \
52    _rc; })
53#endif
54
55using namespace android;
56
57static const bool kIsDebug = false;
58
59/*
60 * Names for default app, locale, and vendor.  We might want to change
61 * these to be an actual locale, e.g. always use en-US as the default.
62 */
63static const char* kDefaultLocale = "default";
64static const char* kDefaultVendor = "default";
65static const char* kAssetsRoot = "assets";
66static const char* kAppZipName = NULL; //"classes.jar";
67static const char* kSystemAssets = "framework/framework-res.apk";
68static const char* kResourceCache = "resource-cache";
69
70static const char* kExcludeExtension = ".EXCLUDE";
71
72static Asset* const kExcludedAsset = (Asset*) 0xd000000d;
73
74static volatile int32_t gCount = 0;
75
76const char* AssetManager::RESOURCES_FILENAME = "resources.arsc";
77const char* AssetManager::IDMAP_BIN = "/system/bin/idmap";
78const char* AssetManager::OVERLAY_DIR = "/vendor/overlay";
79const char* AssetManager::TARGET_PACKAGE_NAME = "android";
80const char* AssetManager::TARGET_APK_PATH = "/system/framework/framework-res.apk";
81const char* AssetManager::IDMAP_DIR = "/data/resource-cache";
82
83namespace {
84    String8 idmapPathForPackagePath(const String8& pkgPath)
85    {
86        const char* root = getenv("ANDROID_DATA");
87        LOG_ALWAYS_FATAL_IF(root == NULL, "ANDROID_DATA not set");
88        String8 path(root);
89        path.appendPath(kResourceCache);
90
91        char buf[256]; // 256 chars should be enough for anyone...
92        strncpy(buf, pkgPath.string(), 255);
93        buf[255] = '\0';
94        char* filename = buf;
95        while (*filename && *filename == '/') {
96            ++filename;
97        }
98        char* p = filename;
99        while (*p) {
100            if (*p == '/') {
101                *p = '@';
102            }
103            ++p;
104        }
105        path.appendPath(filename);
106        path.append("@idmap");
107
108        return path;
109    }
110
111    /*
112     * Like strdup(), but uses C++ "new" operator instead of malloc.
113     */
114    static char* strdupNew(const char* str)
115    {
116        char* newStr;
117        int len;
118
119        if (str == NULL)
120            return NULL;
121
122        len = strlen(str);
123        newStr = new char[len+1];
124        memcpy(newStr, str, len+1);
125
126        return newStr;
127    }
128}
129
130/*
131 * ===========================================================================
132 *      AssetManager
133 * ===========================================================================
134 */
135
136int32_t AssetManager::getGlobalCount()
137{
138    return gCount;
139}
140
141AssetManager::AssetManager(CacheMode cacheMode)
142    : mLocale(NULL), mVendor(NULL),
143      mResources(NULL), mConfig(new ResTable_config),
144      mCacheMode(cacheMode), mCacheValid(false)
145{
146    int count = android_atomic_inc(&gCount) + 1;
147    if (kIsDebug) {
148        ALOGI("Creating AssetManager %p #%d\n", this, count);
149    }
150    memset(mConfig, 0, sizeof(ResTable_config));
151}
152
153AssetManager::~AssetManager(void)
154{
155    int count = android_atomic_dec(&gCount);
156    if (kIsDebug) {
157        ALOGI("Destroying AssetManager in %p #%d\n", this, count);
158    }
159
160    delete mConfig;
161    delete mResources;
162
163    // don't have a String class yet, so make sure we clean up
164    delete[] mLocale;
165    delete[] mVendor;
166}
167
168bool AssetManager::addAssetPath(
169        const String8& path, int32_t* cookie, bool appAsLib, bool isSystemAsset)
170{
171    AutoMutex _l(mLock);
172
173    asset_path ap;
174
175    String8 realPath(path);
176    if (kAppZipName) {
177        realPath.appendPath(kAppZipName);
178    }
179    ap.type = ::getFileType(realPath.string());
180    if (ap.type == kFileTypeRegular) {
181        ap.path = realPath;
182    } else {
183        ap.path = path;
184        ap.type = ::getFileType(path.string());
185        if (ap.type != kFileTypeDirectory && ap.type != kFileTypeRegular) {
186            ALOGW("Asset path %s is neither a directory nor file (type=%d).",
187                 path.string(), (int)ap.type);
188            return false;
189        }
190    }
191
192    // Skip if we have it already.
193    for (size_t i=0; i<mAssetPaths.size(); i++) {
194        if (mAssetPaths[i].path == ap.path) {
195            if (cookie) {
196                *cookie = static_cast<int32_t>(i+1);
197            }
198            return true;
199        }
200    }
201
202    ALOGV("In %p Asset %s path: %s", this,
203         ap.type == kFileTypeDirectory ? "dir" : "zip", ap.path.string());
204
205    ap.isSystemAsset = isSystemAsset;
206    mAssetPaths.add(ap);
207
208    // new paths are always added at the end
209    if (cookie) {
210        *cookie = static_cast<int32_t>(mAssetPaths.size());
211    }
212
213#ifdef __ANDROID__
214    // Load overlays, if any
215    asset_path oap;
216    for (size_t idx = 0; mZipSet.getOverlay(ap.path, idx, &oap); idx++) {
217        oap.isSystemAsset = isSystemAsset;
218        mAssetPaths.add(oap);
219    }
220#endif
221
222    if (mResources != NULL) {
223        appendPathToResTable(ap, appAsLib);
224    }
225
226    return true;
227}
228
229bool AssetManager::addOverlayPath(const String8& packagePath, int32_t* cookie)
230{
231    const String8 idmapPath = idmapPathForPackagePath(packagePath);
232
233    AutoMutex _l(mLock);
234
235    for (size_t i = 0; i < mAssetPaths.size(); ++i) {
236        if (mAssetPaths[i].idmap == idmapPath) {
237           *cookie = static_cast<int32_t>(i + 1);
238            return true;
239         }
240     }
241
242    Asset* idmap = NULL;
243    if ((idmap = openAssetFromFileLocked(idmapPath, Asset::ACCESS_BUFFER)) == NULL) {
244        ALOGW("failed to open idmap file %s\n", idmapPath.string());
245        return false;
246    }
247
248    String8 targetPath;
249    String8 overlayPath;
250    if (!ResTable::getIdmapInfo(idmap->getBuffer(false), idmap->getLength(),
251                NULL, NULL, NULL, &targetPath, &overlayPath)) {
252        ALOGW("failed to read idmap file %s\n", idmapPath.string());
253        delete idmap;
254        return false;
255    }
256    delete idmap;
257
258    if (overlayPath != packagePath) {
259        ALOGW("idmap file %s inconcistent: expected path %s does not match actual path %s\n",
260                idmapPath.string(), packagePath.string(), overlayPath.string());
261        return false;
262    }
263    if (access(targetPath.string(), R_OK) != 0) {
264        ALOGW("failed to access file %s: %s\n", targetPath.string(), strerror(errno));
265        return false;
266    }
267    if (access(idmapPath.string(), R_OK) != 0) {
268        ALOGW("failed to access file %s: %s\n", idmapPath.string(), strerror(errno));
269        return false;
270    }
271    if (access(overlayPath.string(), R_OK) != 0) {
272        ALOGW("failed to access file %s: %s\n", overlayPath.string(), strerror(errno));
273        return false;
274    }
275
276    asset_path oap;
277    oap.path = overlayPath;
278    oap.type = ::getFileType(overlayPath.string());
279    oap.idmap = idmapPath;
280#if 0
281    ALOGD("Overlay added: targetPath=%s overlayPath=%s idmapPath=%s\n",
282            targetPath.string(), overlayPath.string(), idmapPath.string());
283#endif
284    mAssetPaths.add(oap);
285    *cookie = static_cast<int32_t>(mAssetPaths.size());
286
287    if (mResources != NULL) {
288        appendPathToResTable(oap);
289    }
290
291    return true;
292 }
293
294bool AssetManager::createIdmap(const char* targetApkPath, const char* overlayApkPath,
295        uint32_t targetCrc, uint32_t overlayCrc, uint32_t** outData, size_t* outSize)
296{
297    AutoMutex _l(mLock);
298    const String8 paths[2] = { String8(targetApkPath), String8(overlayApkPath) };
299    ResTable tables[2];
300
301    for (int i = 0; i < 2; ++i) {
302        asset_path ap;
303        ap.type = kFileTypeRegular;
304        ap.path = paths[i];
305        Asset* ass = openNonAssetInPathLocked("resources.arsc", Asset::ACCESS_BUFFER, ap);
306        if (ass == NULL) {
307            ALOGW("failed to find resources.arsc in %s\n", ap.path.string());
308            return false;
309        }
310        tables[i].add(ass);
311    }
312
313    return tables[0].createIdmap(tables[1], targetCrc, overlayCrc,
314            targetApkPath, overlayApkPath, (void**)outData, outSize) == NO_ERROR;
315}
316
317bool AssetManager::addDefaultAssets()
318{
319    const char* root = getenv("ANDROID_ROOT");
320    LOG_ALWAYS_FATAL_IF(root == NULL, "ANDROID_ROOT not set");
321
322    String8 path(root);
323    path.appendPath(kSystemAssets);
324
325    return addAssetPath(path, NULL, false /* appAsLib */, true /* isSystemAsset */);
326}
327
328int32_t AssetManager::nextAssetPath(const int32_t cookie) const
329{
330    AutoMutex _l(mLock);
331    const size_t next = static_cast<size_t>(cookie) + 1;
332    return next > mAssetPaths.size() ? -1 : next;
333}
334
335String8 AssetManager::getAssetPath(const int32_t cookie) const
336{
337    AutoMutex _l(mLock);
338    const size_t which = static_cast<size_t>(cookie) - 1;
339    if (which < mAssetPaths.size()) {
340        return mAssetPaths[which].path;
341    }
342    return String8();
343}
344
345/*
346 * Set the current locale.  Use NULL to indicate no locale.
347 *
348 * Close and reopen Zip archives as appropriate, and reset cached
349 * information in the locale-specific sections of the tree.
350 */
351void AssetManager::setLocale(const char* locale)
352{
353    AutoMutex _l(mLock);
354    setLocaleLocked(locale);
355}
356
357
358static const char kFilPrefix[] = "fil";
359static const char kTlPrefix[] = "tl";
360
361// The sizes of the prefixes, excluding the 0 suffix.
362// char.
363static const int kFilPrefixLen = sizeof(kFilPrefix) - 1;
364static const int kTlPrefixLen = sizeof(kTlPrefix) - 1;
365
366void AssetManager::setLocaleLocked(const char* locale)
367{
368    if (mLocale != NULL) {
369        /* previously set, purge cached data */
370        purgeFileNameCacheLocked();
371        //mZipSet.purgeLocale();
372        delete[] mLocale;
373    }
374
375    // If we're attempting to set a locale that starts with "fil",
376    // we should convert it to "tl" for backwards compatibility since
377    // we've been using "tl" instead of "fil" prior to L.
378    //
379    // If the resource table already has entries for "fil", we use that
380    // instead of attempting a fallback.
381    if (strncmp(locale, kFilPrefix, kFilPrefixLen) == 0) {
382        Vector<String8> locales;
383        ResTable* res = mResources;
384        if (res != NULL) {
385            res->getLocales(&locales);
386        }
387        const size_t localesSize = locales.size();
388        bool hasFil = false;
389        for (size_t i = 0; i < localesSize; ++i) {
390            if (locales[i].find(kFilPrefix) == 0) {
391                hasFil = true;
392                break;
393            }
394        }
395
396
397        if (!hasFil) {
398            const size_t newLocaleLen = strlen(locale);
399            // This isn't a bug. We really do want mLocale to be 1 byte
400            // shorter than locale, because we're replacing "fil-" with
401            // "tl-".
402            mLocale = new char[newLocaleLen];
403            // Copy over "tl".
404            memcpy(mLocale, kTlPrefix, kTlPrefixLen);
405            // Copy the rest of |locale|, including the terminating '\0'.
406            memcpy(mLocale + kTlPrefixLen, locale + kFilPrefixLen,
407                   newLocaleLen - kFilPrefixLen + 1);
408            updateResourceParamsLocked();
409            return;
410        }
411    }
412
413    mLocale = strdupNew(locale);
414    updateResourceParamsLocked();
415}
416
417/*
418 * Set the current vendor.  Use NULL to indicate no vendor.
419 *
420 * Close and reopen Zip archives as appropriate, and reset cached
421 * information in the vendor-specific sections of the tree.
422 */
423void AssetManager::setVendor(const char* vendor)
424{
425    AutoMutex _l(mLock);
426
427    if (mVendor != NULL) {
428        /* previously set, purge cached data */
429        purgeFileNameCacheLocked();
430        //mZipSet.purgeVendor();
431        delete[] mVendor;
432    }
433    mVendor = strdupNew(vendor);
434}
435
436void AssetManager::setConfiguration(const ResTable_config& config, const char* locale)
437{
438    AutoMutex _l(mLock);
439    *mConfig = config;
440    if (locale) {
441        setLocaleLocked(locale);
442    } else if (config.language[0] != 0) {
443        char spec[RESTABLE_MAX_LOCALE_LEN];
444        config.getBcp47Locale(spec);
445        setLocaleLocked(spec);
446    } else {
447        updateResourceParamsLocked();
448    }
449}
450
451void AssetManager::getConfiguration(ResTable_config* outConfig) const
452{
453    AutoMutex _l(mLock);
454    *outConfig = *mConfig;
455}
456
457/*
458 * Open an asset.
459 *
460 * The data could be;
461 *  - In a file on disk (assetBase + fileName).
462 *  - In a compressed file on disk (assetBase + fileName.gz).
463 *  - In a Zip archive, uncompressed or compressed.
464 *
465 * It can be in a number of different directories and Zip archives.
466 * The search order is:
467 *  - [appname]
468 *    - locale + vendor
469 *    - "default" + vendor
470 *    - locale + "default"
471 *    - "default + "default"
472 *  - "common"
473 *    - (same as above)
474 *
475 * To find a particular file, we have to try up to eight paths with
476 * all three forms of data.
477 *
478 * We should probably reject requests for "illegal" filenames, e.g. those
479 * with illegal characters or "../" backward relative paths.
480 */
481Asset* AssetManager::open(const char* fileName, AccessMode mode)
482{
483    AutoMutex _l(mLock);
484
485    LOG_FATAL_IF(mAssetPaths.size() == 0, "No assets added to AssetManager");
486
487
488    if (mCacheMode != CACHE_OFF && !mCacheValid)
489        loadFileNameCacheLocked();
490
491    String8 assetName(kAssetsRoot);
492    assetName.appendPath(fileName);
493
494    /*
495     * For each top-level asset path, search for the asset.
496     */
497
498    size_t i = mAssetPaths.size();
499    while (i > 0) {
500        i--;
501        ALOGV("Looking for asset '%s' in '%s'\n",
502                assetName.string(), mAssetPaths.itemAt(i).path.string());
503        Asset* pAsset = openNonAssetInPathLocked(assetName.string(), mode, mAssetPaths.itemAt(i));
504        if (pAsset != NULL) {
505            return pAsset != kExcludedAsset ? pAsset : NULL;
506        }
507    }
508
509    return NULL;
510}
511
512/*
513 * Open a non-asset file as if it were an asset.
514 *
515 * The "fileName" is the partial path starting from the application
516 * name.
517 */
518Asset* AssetManager::openNonAsset(const char* fileName, AccessMode mode, int32_t* outCookie)
519{
520    AutoMutex _l(mLock);
521
522    LOG_FATAL_IF(mAssetPaths.size() == 0, "No assets added to AssetManager");
523
524
525    if (mCacheMode != CACHE_OFF && !mCacheValid)
526        loadFileNameCacheLocked();
527
528    /*
529     * For each top-level asset path, search for the asset.
530     */
531
532    size_t i = mAssetPaths.size();
533    while (i > 0) {
534        i--;
535        ALOGV("Looking for non-asset '%s' in '%s'\n", fileName, mAssetPaths.itemAt(i).path.string());
536        Asset* pAsset = openNonAssetInPathLocked(
537            fileName, mode, mAssetPaths.itemAt(i));
538        if (pAsset != NULL) {
539            if (outCookie != NULL) *outCookie = static_cast<int32_t>(i + 1);
540            return pAsset != kExcludedAsset ? pAsset : NULL;
541        }
542    }
543
544    return NULL;
545}
546
547Asset* AssetManager::openNonAsset(const int32_t cookie, const char* fileName, AccessMode mode)
548{
549    const size_t which = static_cast<size_t>(cookie) - 1;
550
551    AutoMutex _l(mLock);
552
553    LOG_FATAL_IF(mAssetPaths.size() == 0, "No assets added to AssetManager");
554
555    if (mCacheMode != CACHE_OFF && !mCacheValid)
556        loadFileNameCacheLocked();
557
558    if (which < mAssetPaths.size()) {
559        ALOGV("Looking for non-asset '%s' in '%s'\n", fileName,
560                mAssetPaths.itemAt(which).path.string());
561        Asset* pAsset = openNonAssetInPathLocked(
562            fileName, mode, mAssetPaths.itemAt(which));
563        if (pAsset != NULL) {
564            return pAsset != kExcludedAsset ? pAsset : NULL;
565        }
566    }
567
568    return NULL;
569}
570
571/*
572 * Get the type of a file in the asset namespace.
573 *
574 * This currently only works for regular files.  All others (including
575 * directories) will return kFileTypeNonexistent.
576 */
577FileType AssetManager::getFileType(const char* fileName)
578{
579    Asset* pAsset = NULL;
580
581    /*
582     * Open the asset.  This is less efficient than simply finding the
583     * file, but it's not too bad (we don't uncompress or mmap data until
584     * the first read() call).
585     */
586    pAsset = open(fileName, Asset::ACCESS_STREAMING);
587    delete pAsset;
588
589    if (pAsset == NULL)
590        return kFileTypeNonexistent;
591    else
592        return kFileTypeRegular;
593}
594
595bool AssetManager::appendPathToResTable(const asset_path& ap, bool appAsLib) const {
596    // skip those ap's that correspond to system overlays
597    if (ap.isSystemOverlay) {
598        return true;
599    }
600
601    Asset* ass = NULL;
602    ResTable* sharedRes = NULL;
603    bool shared = true;
604    bool onlyEmptyResources = true;
605    ATRACE_NAME(ap.path.string());
606    Asset* idmap = openIdmapLocked(ap);
607    size_t nextEntryIdx = mResources->getTableCount();
608    ALOGV("Looking for resource asset in '%s'\n", ap.path.string());
609    if (ap.type != kFileTypeDirectory) {
610        if (nextEntryIdx == 0) {
611            // The first item is typically the framework resources,
612            // which we want to avoid parsing every time.
613            sharedRes = const_cast<AssetManager*>(this)->
614                mZipSet.getZipResourceTable(ap.path);
615            if (sharedRes != NULL) {
616                // skip ahead the number of system overlay packages preloaded
617                nextEntryIdx = sharedRes->getTableCount();
618            }
619        }
620        if (sharedRes == NULL) {
621            ass = const_cast<AssetManager*>(this)->
622                mZipSet.getZipResourceTableAsset(ap.path);
623            if (ass == NULL) {
624                ALOGV("loading resource table %s\n", ap.path.string());
625                ass = const_cast<AssetManager*>(this)->
626                    openNonAssetInPathLocked("resources.arsc",
627                                             Asset::ACCESS_BUFFER,
628                                             ap);
629                if (ass != NULL && ass != kExcludedAsset) {
630                    ass = const_cast<AssetManager*>(this)->
631                        mZipSet.setZipResourceTableAsset(ap.path, ass);
632                }
633            }
634
635            if (nextEntryIdx == 0 && ass != NULL) {
636                // If this is the first resource table in the asset
637                // manager, then we are going to cache it so that we
638                // can quickly copy it out for others.
639                ALOGV("Creating shared resources for %s", ap.path.string());
640                sharedRes = new ResTable();
641                sharedRes->add(ass, idmap, nextEntryIdx + 1, false);
642#ifdef __ANDROID__
643                const char* data = getenv("ANDROID_DATA");
644                LOG_ALWAYS_FATAL_IF(data == NULL, "ANDROID_DATA not set");
645                String8 overlaysListPath(data);
646                overlaysListPath.appendPath(kResourceCache);
647                overlaysListPath.appendPath("overlays.list");
648                addSystemOverlays(overlaysListPath.string(), ap.path, sharedRes, nextEntryIdx);
649#endif
650                sharedRes = const_cast<AssetManager*>(this)->
651                    mZipSet.setZipResourceTable(ap.path, sharedRes);
652            }
653        }
654    } else {
655        ALOGV("loading resource table %s\n", ap.path.string());
656        ass = const_cast<AssetManager*>(this)->
657            openNonAssetInPathLocked("resources.arsc",
658                                     Asset::ACCESS_BUFFER,
659                                     ap);
660        shared = false;
661    }
662
663    if ((ass != NULL || sharedRes != NULL) && ass != kExcludedAsset) {
664        ALOGV("Installing resource asset %p in to table %p\n", ass, mResources);
665        if (sharedRes != NULL) {
666            ALOGV("Copying existing resources for %s", ap.path.string());
667            mResources->add(sharedRes, ap.isSystemAsset);
668        } else {
669            ALOGV("Parsing resources for %s", ap.path.string());
670            mResources->add(ass, idmap, nextEntryIdx + 1, !shared, appAsLib, ap.isSystemAsset);
671        }
672        onlyEmptyResources = false;
673
674        if (!shared) {
675            delete ass;
676        }
677    } else {
678        ALOGV("Installing empty resources in to table %p\n", mResources);
679        mResources->addEmpty(nextEntryIdx + 1);
680    }
681
682    if (idmap != NULL) {
683        delete idmap;
684    }
685    return onlyEmptyResources;
686}
687
688const ResTable* AssetManager::getResTable(bool required) const
689{
690    ResTable* rt = mResources;
691    if (rt) {
692        return rt;
693    }
694
695    // Iterate through all asset packages, collecting resources from each.
696
697    AutoMutex _l(mLock);
698
699    if (mResources != NULL) {
700        return mResources;
701    }
702
703    if (required) {
704        LOG_FATAL_IF(mAssetPaths.size() == 0, "No assets added to AssetManager");
705    }
706
707    if (mCacheMode != CACHE_OFF && !mCacheValid) {
708        const_cast<AssetManager*>(this)->loadFileNameCacheLocked();
709    }
710
711    mResources = new ResTable();
712    updateResourceParamsLocked();
713
714    bool onlyEmptyResources = true;
715    const size_t N = mAssetPaths.size();
716    for (size_t i=0; i<N; i++) {
717        bool empty = appendPathToResTable(mAssetPaths.itemAt(i));
718        onlyEmptyResources = onlyEmptyResources && empty;
719    }
720
721    if (required && onlyEmptyResources) {
722        ALOGW("Unable to find resources file resources.arsc");
723        delete mResources;
724        mResources = NULL;
725    }
726
727    return mResources;
728}
729
730void AssetManager::updateResourceParamsLocked() const
731{
732    ATRACE_CALL();
733    ResTable* res = mResources;
734    if (!res) {
735        return;
736    }
737
738    if (mLocale) {
739        mConfig->setBcp47Locale(mLocale);
740    } else {
741        mConfig->clearLocale();
742    }
743
744    res->setParameters(mConfig);
745}
746
747Asset* AssetManager::openIdmapLocked(const struct asset_path& ap) const
748{
749    Asset* ass = NULL;
750    if (ap.idmap.size() != 0) {
751        ass = const_cast<AssetManager*>(this)->
752            openAssetFromFileLocked(ap.idmap, Asset::ACCESS_BUFFER);
753        if (ass) {
754            ALOGV("loading idmap %s\n", ap.idmap.string());
755        } else {
756            ALOGW("failed to load idmap %s\n", ap.idmap.string());
757        }
758    }
759    return ass;
760}
761
762void AssetManager::addSystemOverlays(const char* pathOverlaysList,
763        const String8& targetPackagePath, ResTable* sharedRes, size_t offset) const
764{
765    FILE* fin = fopen(pathOverlaysList, "r");
766    if (fin == NULL) {
767        return;
768    }
769
770    char buf[1024];
771    while (fgets(buf, sizeof(buf), fin)) {
772        // format of each line:
773        //   <path to apk><space><path to idmap><newline>
774        char* space = strchr(buf, ' ');
775        char* newline = strchr(buf, '\n');
776        asset_path oap;
777
778        if (space == NULL || newline == NULL || newline < space) {
779            continue;
780        }
781
782        oap.path = String8(buf, space - buf);
783        oap.type = kFileTypeRegular;
784        oap.idmap = String8(space + 1, newline - space - 1);
785        oap.isSystemOverlay = true;
786
787        Asset* oass = const_cast<AssetManager*>(this)->
788            openNonAssetInPathLocked("resources.arsc",
789                    Asset::ACCESS_BUFFER,
790                    oap);
791
792        if (oass != NULL) {
793            Asset* oidmap = openIdmapLocked(oap);
794            offset++;
795            sharedRes->add(oass, oidmap, offset + 1, false);
796            const_cast<AssetManager*>(this)->mAssetPaths.add(oap);
797            const_cast<AssetManager*>(this)->mZipSet.addOverlay(targetPackagePath, oap);
798        }
799    }
800    fclose(fin);
801}
802
803const ResTable& AssetManager::getResources(bool required) const
804{
805    const ResTable* rt = getResTable(required);
806    return *rt;
807}
808
809bool AssetManager::isUpToDate()
810{
811    AutoMutex _l(mLock);
812    return mZipSet.isUpToDate();
813}
814
815void AssetManager::getLocales(Vector<String8>* locales, bool includeSystemLocales) const
816{
817    ResTable* res = mResources;
818    if (res != NULL) {
819        res->getLocales(locales, includeSystemLocales);
820    }
821
822    const size_t numLocales = locales->size();
823    for (size_t i = 0; i < numLocales; ++i) {
824        const String8& localeStr = locales->itemAt(i);
825        if (localeStr.find(kTlPrefix) == 0) {
826            String8 replaced("fil");
827            replaced += (localeStr.string() + kTlPrefixLen);
828            locales->editItemAt(i) = replaced;
829        }
830    }
831}
832
833/*
834 * Open a non-asset file as if it were an asset, searching for it in the
835 * specified app.
836 *
837 * Pass in a NULL values for "appName" if the common app directory should
838 * be used.
839 */
840Asset* AssetManager::openNonAssetInPathLocked(const char* fileName, AccessMode mode,
841    const asset_path& ap)
842{
843    Asset* pAsset = NULL;
844
845    /* look at the filesystem on disk */
846    if (ap.type == kFileTypeDirectory) {
847        String8 path(ap.path);
848        path.appendPath(fileName);
849
850        pAsset = openAssetFromFileLocked(path, mode);
851
852        if (pAsset == NULL) {
853            /* try again, this time with ".gz" */
854            path.append(".gz");
855            pAsset = openAssetFromFileLocked(path, mode);
856        }
857
858        if (pAsset != NULL) {
859            //printf("FOUND NA '%s' on disk\n", fileName);
860            pAsset->setAssetSource(path);
861        }
862
863    /* look inside the zip file */
864    } else {
865        String8 path(fileName);
866
867        /* check the appropriate Zip file */
868        ZipFileRO* pZip = getZipFileLocked(ap);
869        if (pZip != NULL) {
870            //printf("GOT zip, checking NA '%s'\n", (const char*) path);
871            ZipEntryRO entry = pZip->findEntryByName(path.string());
872            if (entry != NULL) {
873                //printf("FOUND NA in Zip file for %s\n", appName ? appName : kAppCommon);
874                pAsset = openAssetFromZipLocked(pZip, entry, mode, path);
875                pZip->releaseEntry(entry);
876            }
877        }
878
879        if (pAsset != NULL) {
880            /* create a "source" name, for debug/display */
881            pAsset->setAssetSource(
882                    createZipSourceNameLocked(ZipSet::getPathName(ap.path.string()), String8(""),
883                                                String8(fileName)));
884        }
885    }
886
887    return pAsset;
888}
889
890/*
891 * Open an asset, searching for it in the directory hierarchy for the
892 * specified app.
893 *
894 * Pass in a NULL values for "appName" if the common app directory should
895 * be used.
896 */
897Asset* AssetManager::openInPathLocked(const char* fileName, AccessMode mode,
898    const asset_path& ap)
899{
900    Asset* pAsset = NULL;
901
902    /*
903     * Try various combinations of locale and vendor.
904     */
905    if (mLocale != NULL && mVendor != NULL)
906        pAsset = openInLocaleVendorLocked(fileName, mode, ap, mLocale, mVendor);
907    if (pAsset == NULL && mVendor != NULL)
908        pAsset = openInLocaleVendorLocked(fileName, mode, ap, NULL, mVendor);
909    if (pAsset == NULL && mLocale != NULL)
910        pAsset = openInLocaleVendorLocked(fileName, mode, ap, mLocale, NULL);
911    if (pAsset == NULL)
912        pAsset = openInLocaleVendorLocked(fileName, mode, ap, NULL, NULL);
913
914    return pAsset;
915}
916
917/*
918 * Open an asset, searching for it in the directory hierarchy for the
919 * specified locale and vendor.
920 *
921 * We also search in "app.jar".
922 *
923 * Pass in NULL values for "appName", "locale", and "vendor" if the
924 * defaults should be used.
925 */
926Asset* AssetManager::openInLocaleVendorLocked(const char* fileName, AccessMode mode,
927    const asset_path& ap, const char* locale, const char* vendor)
928{
929    Asset* pAsset = NULL;
930
931    if (ap.type == kFileTypeDirectory) {
932        if (mCacheMode == CACHE_OFF) {
933            /* look at the filesystem on disk */
934            String8 path(createPathNameLocked(ap, locale, vendor));
935            path.appendPath(fileName);
936
937            String8 excludeName(path);
938            excludeName.append(kExcludeExtension);
939            if (::getFileType(excludeName.string()) != kFileTypeNonexistent) {
940                /* say no more */
941                //printf("+++ excluding '%s'\n", (const char*) excludeName);
942                return kExcludedAsset;
943            }
944
945            pAsset = openAssetFromFileLocked(path, mode);
946
947            if (pAsset == NULL) {
948                /* try again, this time with ".gz" */
949                path.append(".gz");
950                pAsset = openAssetFromFileLocked(path, mode);
951            }
952
953            if (pAsset != NULL)
954                pAsset->setAssetSource(path);
955        } else {
956            /* find in cache */
957            String8 path(createPathNameLocked(ap, locale, vendor));
958            path.appendPath(fileName);
959
960            AssetDir::FileInfo tmpInfo;
961            bool found = false;
962
963            String8 excludeName(path);
964            excludeName.append(kExcludeExtension);
965
966            if (mCache.indexOf(excludeName) != NAME_NOT_FOUND) {
967                /* go no farther */
968                //printf("+++ Excluding '%s'\n", (const char*) excludeName);
969                return kExcludedAsset;
970            }
971
972            /*
973             * File compression extensions (".gz") don't get stored in the
974             * name cache, so we have to try both here.
975             */
976            if (mCache.indexOf(path) != NAME_NOT_FOUND) {
977                found = true;
978                pAsset = openAssetFromFileLocked(path, mode);
979                if (pAsset == NULL) {
980                    /* try again, this time with ".gz" */
981                    path.append(".gz");
982                    pAsset = openAssetFromFileLocked(path, mode);
983                }
984            }
985
986            if (pAsset != NULL)
987                pAsset->setAssetSource(path);
988
989            /*
990             * Don't continue the search into the Zip files.  Our cached info
991             * said it was a file on disk; to be consistent with openDir()
992             * we want to return the loose asset.  If the cached file gets
993             * removed, we fail.
994             *
995             * The alternative is to update our cache when files get deleted,
996             * or make some sort of "best effort" promise, but for now I'm
997             * taking the hard line.
998             */
999            if (found) {
1000                if (pAsset == NULL)
1001                    ALOGD("Expected file not found: '%s'\n", path.string());
1002                return pAsset;
1003            }
1004        }
1005    }
1006
1007    /*
1008     * Either it wasn't found on disk or on the cached view of the disk.
1009     * Dig through the currently-opened set of Zip files.  If caching
1010     * is disabled, the Zip file may get reopened.
1011     */
1012    if (pAsset == NULL && ap.type == kFileTypeRegular) {
1013        String8 path;
1014
1015        path.appendPath((locale != NULL) ? locale : kDefaultLocale);
1016        path.appendPath((vendor != NULL) ? vendor : kDefaultVendor);
1017        path.appendPath(fileName);
1018
1019        /* check the appropriate Zip file */
1020        ZipFileRO* pZip = getZipFileLocked(ap);
1021        if (pZip != NULL) {
1022            //printf("GOT zip, checking '%s'\n", (const char*) path);
1023            ZipEntryRO entry = pZip->findEntryByName(path.string());
1024            if (entry != NULL) {
1025                //printf("FOUND in Zip file for %s/%s-%s\n",
1026                //    appName, locale, vendor);
1027                pAsset = openAssetFromZipLocked(pZip, entry, mode, path);
1028                pZip->releaseEntry(entry);
1029            }
1030        }
1031
1032        if (pAsset != NULL) {
1033            /* create a "source" name, for debug/display */
1034            pAsset->setAssetSource(createZipSourceNameLocked(ZipSet::getPathName(ap.path.string()),
1035                                                             String8(""), String8(fileName)));
1036        }
1037    }
1038
1039    return pAsset;
1040}
1041
1042/*
1043 * Create a "source name" for a file from a Zip archive.
1044 */
1045String8 AssetManager::createZipSourceNameLocked(const String8& zipFileName,
1046    const String8& dirName, const String8& fileName)
1047{
1048    String8 sourceName("zip:");
1049    sourceName.append(zipFileName);
1050    sourceName.append(":");
1051    if (dirName.length() > 0) {
1052        sourceName.appendPath(dirName);
1053    }
1054    sourceName.appendPath(fileName);
1055    return sourceName;
1056}
1057
1058/*
1059 * Create a path to a loose asset (asset-base/app/locale/vendor).
1060 */
1061String8 AssetManager::createPathNameLocked(const asset_path& ap, const char* locale,
1062    const char* vendor)
1063{
1064    String8 path(ap.path);
1065    path.appendPath((locale != NULL) ? locale : kDefaultLocale);
1066    path.appendPath((vendor != NULL) ? vendor : kDefaultVendor);
1067    return path;
1068}
1069
1070/*
1071 * Create a path to a loose asset (asset-base/app/rootDir).
1072 */
1073String8 AssetManager::createPathNameLocked(const asset_path& ap, const char* rootDir)
1074{
1075    String8 path(ap.path);
1076    if (rootDir != NULL) path.appendPath(rootDir);
1077    return path;
1078}
1079
1080/*
1081 * Return a pointer to one of our open Zip archives.  Returns NULL if no
1082 * matching Zip file exists.
1083 *
1084 * Right now we have 2 possible Zip files (1 each in app/"common").
1085 *
1086 * If caching is set to CACHE_OFF, to get the expected behavior we
1087 * need to reopen the Zip file on every request.  That would be silly
1088 * and expensive, so instead we just check the file modification date.
1089 *
1090 * Pass in NULL values for "appName", "locale", and "vendor" if the
1091 * generics should be used.
1092 */
1093ZipFileRO* AssetManager::getZipFileLocked(const asset_path& ap)
1094{
1095    ALOGV("getZipFileLocked() in %p\n", this);
1096
1097    return mZipSet.getZip(ap.path);
1098}
1099
1100/*
1101 * Try to open an asset from a file on disk.
1102 *
1103 * If the file is compressed with gzip, we seek to the start of the
1104 * deflated data and pass that in (just like we would for a Zip archive).
1105 *
1106 * For uncompressed data, we may already have an mmap()ed version sitting
1107 * around.  If so, we want to hand that to the Asset instead.
1108 *
1109 * This returns NULL if the file doesn't exist, couldn't be opened, or
1110 * claims to be a ".gz" but isn't.
1111 */
1112Asset* AssetManager::openAssetFromFileLocked(const String8& pathName,
1113    AccessMode mode)
1114{
1115    Asset* pAsset = NULL;
1116
1117    if (strcasecmp(pathName.getPathExtension().string(), ".gz") == 0) {
1118        //printf("TRYING '%s'\n", (const char*) pathName);
1119        pAsset = Asset::createFromCompressedFile(pathName.string(), mode);
1120    } else {
1121        //printf("TRYING '%s'\n", (const char*) pathName);
1122        pAsset = Asset::createFromFile(pathName.string(), mode);
1123    }
1124
1125    return pAsset;
1126}
1127
1128/*
1129 * Given an entry in a Zip archive, create a new Asset object.
1130 *
1131 * If the entry is uncompressed, we may want to create or share a
1132 * slice of shared memory.
1133 */
1134Asset* AssetManager::openAssetFromZipLocked(const ZipFileRO* pZipFile,
1135    const ZipEntryRO entry, AccessMode mode, const String8& entryName)
1136{
1137    Asset* pAsset = NULL;
1138
1139    // TODO: look for previously-created shared memory slice?
1140    uint16_t method;
1141    uint32_t uncompressedLen;
1142
1143    //printf("USING Zip '%s'\n", pEntry->getFileName());
1144
1145    if (!pZipFile->getEntryInfo(entry, &method, &uncompressedLen, NULL, NULL,
1146            NULL, NULL))
1147    {
1148        ALOGW("getEntryInfo failed\n");
1149        return NULL;
1150    }
1151
1152    FileMap* dataMap = pZipFile->createEntryFileMap(entry);
1153    if (dataMap == NULL) {
1154        ALOGW("create map from entry failed\n");
1155        return NULL;
1156    }
1157
1158    if (method == ZipFileRO::kCompressStored) {
1159        pAsset = Asset::createFromUncompressedMap(dataMap, mode);
1160        ALOGV("Opened uncompressed entry %s in zip %s mode %d: %p", entryName.string(),
1161                dataMap->getFileName(), mode, pAsset);
1162    } else {
1163        pAsset = Asset::createFromCompressedMap(dataMap,
1164            static_cast<size_t>(uncompressedLen), mode);
1165        ALOGV("Opened compressed entry %s in zip %s mode %d: %p", entryName.string(),
1166                dataMap->getFileName(), mode, pAsset);
1167    }
1168    if (pAsset == NULL) {
1169        /* unexpected */
1170        ALOGW("create from segment failed\n");
1171    }
1172
1173    return pAsset;
1174}
1175
1176
1177
1178/*
1179 * Open a directory in the asset namespace.
1180 *
1181 * An "asset directory" is simply the combination of all files in all
1182 * locations, with ".gz" stripped for loose files.  With app, locale, and
1183 * vendor defined, we have 8 directories and 2 Zip archives to scan.
1184 *
1185 * Pass in "" for the root dir.
1186 */
1187AssetDir* AssetManager::openDir(const char* dirName)
1188{
1189    AutoMutex _l(mLock);
1190
1191    AssetDir* pDir = NULL;
1192    SortedVector<AssetDir::FileInfo>* pMergedInfo = NULL;
1193
1194    LOG_FATAL_IF(mAssetPaths.size() == 0, "No assets added to AssetManager");
1195    assert(dirName != NULL);
1196
1197    //printf("+++ openDir(%s) in '%s'\n", dirName, (const char*) mAssetBase);
1198
1199    if (mCacheMode != CACHE_OFF && !mCacheValid)
1200        loadFileNameCacheLocked();
1201
1202    pDir = new AssetDir;
1203
1204    /*
1205     * Scan the various directories, merging what we find into a single
1206     * vector.  We want to scan them in reverse priority order so that
1207     * the ".EXCLUDE" processing works correctly.  Also, if we decide we
1208     * want to remember where the file is coming from, we'll get the right
1209     * version.
1210     *
1211     * We start with Zip archives, then do loose files.
1212     */
1213    pMergedInfo = new SortedVector<AssetDir::FileInfo>;
1214
1215    size_t i = mAssetPaths.size();
1216    while (i > 0) {
1217        i--;
1218        const asset_path& ap = mAssetPaths.itemAt(i);
1219        if (ap.type == kFileTypeRegular) {
1220            ALOGV("Adding directory %s from zip %s", dirName, ap.path.string());
1221            scanAndMergeZipLocked(pMergedInfo, ap, kAssetsRoot, dirName);
1222        } else {
1223            ALOGV("Adding directory %s from dir %s", dirName, ap.path.string());
1224            scanAndMergeDirLocked(pMergedInfo, ap, kAssetsRoot, dirName);
1225        }
1226    }
1227
1228#if 0
1229    printf("FILE LIST:\n");
1230    for (i = 0; i < (size_t) pMergedInfo->size(); i++) {
1231        printf(" %d: (%d) '%s'\n", i,
1232            pMergedInfo->itemAt(i).getFileType(),
1233            (const char*) pMergedInfo->itemAt(i).getFileName());
1234    }
1235#endif
1236
1237    pDir->setFileList(pMergedInfo);
1238    return pDir;
1239}
1240
1241/*
1242 * Open a directory in the non-asset namespace.
1243 *
1244 * An "asset directory" is simply the combination of all files in all
1245 * locations, with ".gz" stripped for loose files.  With app, locale, and
1246 * vendor defined, we have 8 directories and 2 Zip archives to scan.
1247 *
1248 * Pass in "" for the root dir.
1249 */
1250AssetDir* AssetManager::openNonAssetDir(const int32_t cookie, const char* dirName)
1251{
1252    AutoMutex _l(mLock);
1253
1254    AssetDir* pDir = NULL;
1255    SortedVector<AssetDir::FileInfo>* pMergedInfo = NULL;
1256
1257    LOG_FATAL_IF(mAssetPaths.size() == 0, "No assets added to AssetManager");
1258    assert(dirName != NULL);
1259
1260    //printf("+++ openDir(%s) in '%s'\n", dirName, (const char*) mAssetBase);
1261
1262    if (mCacheMode != CACHE_OFF && !mCacheValid)
1263        loadFileNameCacheLocked();
1264
1265    pDir = new AssetDir;
1266
1267    pMergedInfo = new SortedVector<AssetDir::FileInfo>;
1268
1269    const size_t which = static_cast<size_t>(cookie) - 1;
1270
1271    if (which < mAssetPaths.size()) {
1272        const asset_path& ap = mAssetPaths.itemAt(which);
1273        if (ap.type == kFileTypeRegular) {
1274            ALOGV("Adding directory %s from zip %s", dirName, ap.path.string());
1275            scanAndMergeZipLocked(pMergedInfo, ap, NULL, dirName);
1276        } else {
1277            ALOGV("Adding directory %s from dir %s", dirName, ap.path.string());
1278            scanAndMergeDirLocked(pMergedInfo, ap, NULL, dirName);
1279        }
1280    }
1281
1282#if 0
1283    printf("FILE LIST:\n");
1284    for (i = 0; i < (size_t) pMergedInfo->size(); i++) {
1285        printf(" %d: (%d) '%s'\n", i,
1286            pMergedInfo->itemAt(i).getFileType(),
1287            (const char*) pMergedInfo->itemAt(i).getFileName());
1288    }
1289#endif
1290
1291    pDir->setFileList(pMergedInfo);
1292    return pDir;
1293}
1294
1295/*
1296 * Scan the contents of the specified directory and merge them into the
1297 * "pMergedInfo" vector, removing previous entries if we find "exclude"
1298 * directives.
1299 *
1300 * Returns "false" if we found nothing to contribute.
1301 */
1302bool AssetManager::scanAndMergeDirLocked(SortedVector<AssetDir::FileInfo>* pMergedInfo,
1303    const asset_path& ap, const char* rootDir, const char* dirName)
1304{
1305    SortedVector<AssetDir::FileInfo>* pContents;
1306    String8 path;
1307
1308    assert(pMergedInfo != NULL);
1309
1310    //printf("scanAndMergeDir: %s %s %s %s\n", appName, locale, vendor,dirName);
1311
1312    if (mCacheValid) {
1313        int i, start, count;
1314
1315        pContents = new SortedVector<AssetDir::FileInfo>;
1316
1317        /*
1318         * Get the basic partial path and find it in the cache.  That's
1319         * the start point for the search.
1320         */
1321        path = createPathNameLocked(ap, rootDir);
1322        if (dirName[0] != '\0')
1323            path.appendPath(dirName);
1324
1325        start = mCache.indexOf(path);
1326        if (start == NAME_NOT_FOUND) {
1327            //printf("+++ not found in cache: dir '%s'\n", (const char*) path);
1328            delete pContents;
1329            return false;
1330        }
1331
1332        /*
1333         * The match string looks like "common/default/default/foo/bar/".
1334         * The '/' on the end ensures that we don't match on the directory
1335         * itself or on ".../foo/barfy/".
1336         */
1337        path.append("/");
1338
1339        count = mCache.size();
1340
1341        /*
1342         * Pick out the stuff in the current dir by examining the pathname.
1343         * It needs to match the partial pathname prefix, and not have a '/'
1344         * (fssep) anywhere after the prefix.
1345         */
1346        for (i = start+1; i < count; i++) {
1347            if (mCache[i].getFileName().length() > path.length() &&
1348                strncmp(mCache[i].getFileName().string(), path.string(), path.length()) == 0)
1349            {
1350                const char* name = mCache[i].getFileName().string();
1351                // XXX THIS IS BROKEN!  Looks like we need to store the full
1352                // path prefix separately from the file path.
1353                if (strchr(name + path.length(), '/') == NULL) {
1354                    /* grab it, reducing path to just the filename component */
1355                    AssetDir::FileInfo tmp = mCache[i];
1356                    tmp.setFileName(tmp.getFileName().getPathLeaf());
1357                    pContents->add(tmp);
1358                }
1359            } else {
1360                /* no longer in the dir or its subdirs */
1361                break;
1362            }
1363
1364        }
1365    } else {
1366        path = createPathNameLocked(ap, rootDir);
1367        if (dirName[0] != '\0')
1368            path.appendPath(dirName);
1369        pContents = scanDirLocked(path);
1370        if (pContents == NULL)
1371            return false;
1372    }
1373
1374    // if we wanted to do an incremental cache fill, we would do it here
1375
1376    /*
1377     * Process "exclude" directives.  If we find a filename that ends with
1378     * ".EXCLUDE", we look for a matching entry in the "merged" set, and
1379     * remove it if we find it.  We also delete the "exclude" entry.
1380     */
1381    int i, count, exclExtLen;
1382
1383    count = pContents->size();
1384    exclExtLen = strlen(kExcludeExtension);
1385    for (i = 0; i < count; i++) {
1386        const char* name;
1387        int nameLen;
1388
1389        name = pContents->itemAt(i).getFileName().string();
1390        nameLen = strlen(name);
1391        if (nameLen > exclExtLen &&
1392            strcmp(name + (nameLen - exclExtLen), kExcludeExtension) == 0)
1393        {
1394            String8 match(name, nameLen - exclExtLen);
1395            int matchIdx;
1396
1397            matchIdx = AssetDir::FileInfo::findEntry(pMergedInfo, match);
1398            if (matchIdx > 0) {
1399                ALOGV("Excluding '%s' [%s]\n",
1400                    pMergedInfo->itemAt(matchIdx).getFileName().string(),
1401                    pMergedInfo->itemAt(matchIdx).getSourceName().string());
1402                pMergedInfo->removeAt(matchIdx);
1403            } else {
1404                //printf("+++ no match on '%s'\n", (const char*) match);
1405            }
1406
1407            ALOGD("HEY: size=%d removing %d\n", (int)pContents->size(), i);
1408            pContents->removeAt(i);
1409            i--;        // adjust "for" loop
1410            count--;    //  and loop limit
1411        }
1412    }
1413
1414    mergeInfoLocked(pMergedInfo, pContents);
1415
1416    delete pContents;
1417
1418    return true;
1419}
1420
1421/*
1422 * Scan the contents of the specified directory, and stuff what we find
1423 * into a newly-allocated vector.
1424 *
1425 * Files ending in ".gz" will have their extensions removed.
1426 *
1427 * We should probably think about skipping files with "illegal" names,
1428 * e.g. illegal characters (/\:) or excessive length.
1429 *
1430 * Returns NULL if the specified directory doesn't exist.
1431 */
1432SortedVector<AssetDir::FileInfo>* AssetManager::scanDirLocked(const String8& path)
1433{
1434    SortedVector<AssetDir::FileInfo>* pContents = NULL;
1435    DIR* dir;
1436    struct dirent* entry;
1437    FileType fileType;
1438
1439    ALOGV("Scanning dir '%s'\n", path.string());
1440
1441    dir = opendir(path.string());
1442    if (dir == NULL)
1443        return NULL;
1444
1445    pContents = new SortedVector<AssetDir::FileInfo>;
1446
1447    while (1) {
1448        entry = readdir(dir);
1449        if (entry == NULL)
1450            break;
1451
1452        if (strcmp(entry->d_name, ".") == 0 ||
1453            strcmp(entry->d_name, "..") == 0)
1454            continue;
1455
1456#ifdef _DIRENT_HAVE_D_TYPE
1457        if (entry->d_type == DT_REG)
1458            fileType = kFileTypeRegular;
1459        else if (entry->d_type == DT_DIR)
1460            fileType = kFileTypeDirectory;
1461        else
1462            fileType = kFileTypeUnknown;
1463#else
1464        // stat the file
1465        fileType = ::getFileType(path.appendPathCopy(entry->d_name).string());
1466#endif
1467
1468        if (fileType != kFileTypeRegular && fileType != kFileTypeDirectory)
1469            continue;
1470
1471        AssetDir::FileInfo info;
1472        info.set(String8(entry->d_name), fileType);
1473        if (strcasecmp(info.getFileName().getPathExtension().string(), ".gz") == 0)
1474            info.setFileName(info.getFileName().getBasePath());
1475        info.setSourceName(path.appendPathCopy(info.getFileName()));
1476        pContents->add(info);
1477    }
1478
1479    closedir(dir);
1480    return pContents;
1481}
1482
1483/*
1484 * Scan the contents out of the specified Zip archive, and merge what we
1485 * find into "pMergedInfo".  If the Zip archive in question doesn't exist,
1486 * we return immediately.
1487 *
1488 * Returns "false" if we found nothing to contribute.
1489 */
1490bool AssetManager::scanAndMergeZipLocked(SortedVector<AssetDir::FileInfo>* pMergedInfo,
1491    const asset_path& ap, const char* rootDir, const char* baseDirName)
1492{
1493    ZipFileRO* pZip;
1494    Vector<String8> dirs;
1495    AssetDir::FileInfo info;
1496    SortedVector<AssetDir::FileInfo> contents;
1497    String8 sourceName, zipName, dirName;
1498
1499    pZip = mZipSet.getZip(ap.path);
1500    if (pZip == NULL) {
1501        ALOGW("Failure opening zip %s\n", ap.path.string());
1502        return false;
1503    }
1504
1505    zipName = ZipSet::getPathName(ap.path.string());
1506
1507    /* convert "sounds" to "rootDir/sounds" */
1508    if (rootDir != NULL) dirName = rootDir;
1509    dirName.appendPath(baseDirName);
1510
1511    /*
1512     * Scan through the list of files, looking for a match.  The files in
1513     * the Zip table of contents are not in sorted order, so we have to
1514     * process the entire list.  We're looking for a string that begins
1515     * with the characters in "dirName", is followed by a '/', and has no
1516     * subsequent '/' in the stuff that follows.
1517     *
1518     * What makes this especially fun is that directories are not stored
1519     * explicitly in Zip archives, so we have to infer them from context.
1520     * When we see "sounds/foo.wav" we have to leave a note to ourselves
1521     * to insert a directory called "sounds" into the list.  We store
1522     * these in temporary vector so that we only return each one once.
1523     *
1524     * Name comparisons are case-sensitive to match UNIX filesystem
1525     * semantics.
1526     */
1527    int dirNameLen = dirName.length();
1528    void *iterationCookie;
1529    if (!pZip->startIteration(&iterationCookie, dirName.string(), NULL)) {
1530        ALOGW("ZipFileRO::startIteration returned false");
1531        return false;
1532    }
1533
1534    ZipEntryRO entry;
1535    while ((entry = pZip->nextEntry(iterationCookie)) != NULL) {
1536        char nameBuf[256];
1537
1538        if (pZip->getEntryFileName(entry, nameBuf, sizeof(nameBuf)) != 0) {
1539            // TODO: fix this if we expect to have long names
1540            ALOGE("ARGH: name too long?\n");
1541            continue;
1542        }
1543        //printf("Comparing %s in %s?\n", nameBuf, dirName.string());
1544        if (dirNameLen == 0 || nameBuf[dirNameLen] == '/')
1545        {
1546            const char* cp;
1547            const char* nextSlash;
1548
1549            cp = nameBuf + dirNameLen;
1550            if (dirNameLen != 0)
1551                cp++;       // advance past the '/'
1552
1553            nextSlash = strchr(cp, '/');
1554//xxx this may break if there are bare directory entries
1555            if (nextSlash == NULL) {
1556                /* this is a file in the requested directory */
1557
1558                info.set(String8(nameBuf).getPathLeaf(), kFileTypeRegular);
1559
1560                info.setSourceName(
1561                    createZipSourceNameLocked(zipName, dirName, info.getFileName()));
1562
1563                contents.add(info);
1564                //printf("FOUND: file '%s'\n", info.getFileName().string());
1565            } else {
1566                /* this is a subdir; add it if we don't already have it*/
1567                String8 subdirName(cp, nextSlash - cp);
1568                size_t j;
1569                size_t N = dirs.size();
1570
1571                for (j = 0; j < N; j++) {
1572                    if (subdirName == dirs[j]) {
1573                        break;
1574                    }
1575                }
1576                if (j == N) {
1577                    dirs.add(subdirName);
1578                }
1579
1580                //printf("FOUND: dir '%s'\n", subdirName.string());
1581            }
1582        }
1583    }
1584
1585    pZip->endIteration(iterationCookie);
1586
1587    /*
1588     * Add the set of unique directories.
1589     */
1590    for (int i = 0; i < (int) dirs.size(); i++) {
1591        info.set(dirs[i], kFileTypeDirectory);
1592        info.setSourceName(
1593            createZipSourceNameLocked(zipName, dirName, info.getFileName()));
1594        contents.add(info);
1595    }
1596
1597    mergeInfoLocked(pMergedInfo, &contents);
1598
1599    return true;
1600}
1601
1602
1603/*
1604 * Merge two vectors of FileInfo.
1605 *
1606 * The merged contents will be stuffed into *pMergedInfo.
1607 *
1608 * If an entry for a file exists in both "pMergedInfo" and "pContents",
1609 * we use the newer "pContents" entry.
1610 */
1611void AssetManager::mergeInfoLocked(SortedVector<AssetDir::FileInfo>* pMergedInfo,
1612    const SortedVector<AssetDir::FileInfo>* pContents)
1613{
1614    /*
1615     * Merge what we found in this directory with what we found in
1616     * other places.
1617     *
1618     * Two basic approaches:
1619     * (1) Create a new array that holds the unique values of the two
1620     *     arrays.
1621     * (2) Take the elements from pContents and shove them into pMergedInfo.
1622     *
1623     * Because these are vectors of complex objects, moving elements around
1624     * inside the vector requires constructing new objects and allocating
1625     * storage for members.  With approach #1, we're always adding to the
1626     * end, whereas with #2 we could be inserting multiple elements at the
1627     * front of the vector.  Approach #1 requires a full copy of the
1628     * contents of pMergedInfo, but approach #2 requires the same copy for
1629     * every insertion at the front of pMergedInfo.
1630     *
1631     * (We should probably use a SortedVector interface that allows us to
1632     * just stuff items in, trusting us to maintain the sort order.)
1633     */
1634    SortedVector<AssetDir::FileInfo>* pNewSorted;
1635    int mergeMax, contMax;
1636    int mergeIdx, contIdx;
1637
1638    pNewSorted = new SortedVector<AssetDir::FileInfo>;
1639    mergeMax = pMergedInfo->size();
1640    contMax = pContents->size();
1641    mergeIdx = contIdx = 0;
1642
1643    while (mergeIdx < mergeMax || contIdx < contMax) {
1644        if (mergeIdx == mergeMax) {
1645            /* hit end of "merge" list, copy rest of "contents" */
1646            pNewSorted->add(pContents->itemAt(contIdx));
1647            contIdx++;
1648        } else if (contIdx == contMax) {
1649            /* hit end of "cont" list, copy rest of "merge" */
1650            pNewSorted->add(pMergedInfo->itemAt(mergeIdx));
1651            mergeIdx++;
1652        } else if (pMergedInfo->itemAt(mergeIdx) == pContents->itemAt(contIdx))
1653        {
1654            /* items are identical, add newer and advance both indices */
1655            pNewSorted->add(pContents->itemAt(contIdx));
1656            mergeIdx++;
1657            contIdx++;
1658        } else if (pMergedInfo->itemAt(mergeIdx) < pContents->itemAt(contIdx))
1659        {
1660            /* "merge" is lower, add that one */
1661            pNewSorted->add(pMergedInfo->itemAt(mergeIdx));
1662            mergeIdx++;
1663        } else {
1664            /* "cont" is lower, add that one */
1665            assert(pContents->itemAt(contIdx) < pMergedInfo->itemAt(mergeIdx));
1666            pNewSorted->add(pContents->itemAt(contIdx));
1667            contIdx++;
1668        }
1669    }
1670
1671    /*
1672     * Overwrite the "merged" list with the new stuff.
1673     */
1674    *pMergedInfo = *pNewSorted;
1675    delete pNewSorted;
1676
1677#if 0       // for Vector, rather than SortedVector
1678    int i, j;
1679    for (i = pContents->size() -1; i >= 0; i--) {
1680        bool add = true;
1681
1682        for (j = pMergedInfo->size() -1; j >= 0; j--) {
1683            /* case-sensitive comparisons, to behave like UNIX fs */
1684            if (strcmp(pContents->itemAt(i).mFileName,
1685                       pMergedInfo->itemAt(j).mFileName) == 0)
1686            {
1687                /* match, don't add this entry */
1688                add = false;
1689                break;
1690            }
1691        }
1692
1693        if (add)
1694            pMergedInfo->add(pContents->itemAt(i));
1695    }
1696#endif
1697}
1698
1699
1700/*
1701 * Load all files into the file name cache.  We want to do this across
1702 * all combinations of { appname, locale, vendor }, performing a recursive
1703 * directory traversal.
1704 *
1705 * This is not the most efficient data structure.  Also, gathering the
1706 * information as we needed it (file-by-file or directory-by-directory)
1707 * would be faster.  However, on the actual device, 99% of the files will
1708 * live in Zip archives, so this list will be very small.  The trouble
1709 * is that we have to check the "loose" files first, so it's important
1710 * that we don't beat the filesystem silly looking for files that aren't
1711 * there.
1712 *
1713 * Note on thread safety: this is the only function that causes updates
1714 * to mCache, and anybody who tries to use it will call here if !mCacheValid,
1715 * so we need to employ a mutex here.
1716 */
1717void AssetManager::loadFileNameCacheLocked(void)
1718{
1719    assert(!mCacheValid);
1720    assert(mCache.size() == 0);
1721
1722#ifdef DO_TIMINGS   // need to link against -lrt for this now
1723    DurationTimer timer;
1724    timer.start();
1725#endif
1726
1727    fncScanLocked(&mCache, "");
1728
1729#ifdef DO_TIMINGS
1730    timer.stop();
1731    ALOGD("Cache scan took %.3fms\n",
1732        timer.durationUsecs() / 1000.0);
1733#endif
1734
1735#if 0
1736    int i;
1737    printf("CACHED FILE LIST (%d entries):\n", mCache.size());
1738    for (i = 0; i < (int) mCache.size(); i++) {
1739        printf(" %d: (%d) '%s'\n", i,
1740            mCache.itemAt(i).getFileType(),
1741            (const char*) mCache.itemAt(i).getFileName());
1742    }
1743#endif
1744
1745    mCacheValid = true;
1746}
1747
1748/*
1749 * Scan up to 8 versions of the specified directory.
1750 */
1751void AssetManager::fncScanLocked(SortedVector<AssetDir::FileInfo>* pMergedInfo,
1752    const char* dirName)
1753{
1754    size_t i = mAssetPaths.size();
1755    while (i > 0) {
1756        i--;
1757        const asset_path& ap = mAssetPaths.itemAt(i);
1758        fncScanAndMergeDirLocked(pMergedInfo, ap, NULL, NULL, dirName);
1759        if (mLocale != NULL)
1760            fncScanAndMergeDirLocked(pMergedInfo, ap, mLocale, NULL, dirName);
1761        if (mVendor != NULL)
1762            fncScanAndMergeDirLocked(pMergedInfo, ap, NULL, mVendor, dirName);
1763        if (mLocale != NULL && mVendor != NULL)
1764            fncScanAndMergeDirLocked(pMergedInfo, ap, mLocale, mVendor, dirName);
1765    }
1766}
1767
1768/*
1769 * Recursively scan this directory and all subdirs.
1770 *
1771 * This is similar to scanAndMergeDir, but we don't remove the .EXCLUDE
1772 * files, and we prepend the extended partial path to the filenames.
1773 */
1774bool AssetManager::fncScanAndMergeDirLocked(
1775    SortedVector<AssetDir::FileInfo>* pMergedInfo,
1776    const asset_path& ap, const char* locale, const char* vendor,
1777    const char* dirName)
1778{
1779    SortedVector<AssetDir::FileInfo>* pContents;
1780    String8 partialPath;
1781    String8 fullPath;
1782
1783    // XXX This is broken -- the filename cache needs to hold the base
1784    // asset path separately from its filename.
1785
1786    partialPath = createPathNameLocked(ap, locale, vendor);
1787    if (dirName[0] != '\0') {
1788        partialPath.appendPath(dirName);
1789    }
1790
1791    fullPath = partialPath;
1792    pContents = scanDirLocked(fullPath);
1793    if (pContents == NULL) {
1794        return false;       // directory did not exist
1795    }
1796
1797    /*
1798     * Scan all subdirectories of the current dir, merging what we find
1799     * into "pMergedInfo".
1800     */
1801    for (int i = 0; i < (int) pContents->size(); i++) {
1802        if (pContents->itemAt(i).getFileType() == kFileTypeDirectory) {
1803            String8 subdir(dirName);
1804            subdir.appendPath(pContents->itemAt(i).getFileName());
1805
1806            fncScanAndMergeDirLocked(pMergedInfo, ap, locale, vendor, subdir.string());
1807        }
1808    }
1809
1810    /*
1811     * To be consistent, we want entries for the root directory.  If
1812     * we're the root, add one now.
1813     */
1814    if (dirName[0] == '\0') {
1815        AssetDir::FileInfo tmpInfo;
1816
1817        tmpInfo.set(String8(""), kFileTypeDirectory);
1818        tmpInfo.setSourceName(createPathNameLocked(ap, locale, vendor));
1819        pContents->add(tmpInfo);
1820    }
1821
1822    /*
1823     * We want to prepend the extended partial path to every entry in
1824     * "pContents".  It's the same value for each entry, so this will
1825     * not change the sorting order of the vector contents.
1826     */
1827    for (int i = 0; i < (int) pContents->size(); i++) {
1828        const AssetDir::FileInfo& info = pContents->itemAt(i);
1829        pContents->editItemAt(i).setFileName(partialPath.appendPathCopy(info.getFileName()));
1830    }
1831
1832    mergeInfoLocked(pMergedInfo, pContents);
1833    delete pContents;
1834    return true;
1835}
1836
1837/*
1838 * Trash the cache.
1839 */
1840void AssetManager::purgeFileNameCacheLocked(void)
1841{
1842    mCacheValid = false;
1843    mCache.clear();
1844}
1845
1846/*
1847 * ===========================================================================
1848 *      AssetManager::SharedZip
1849 * ===========================================================================
1850 */
1851
1852
1853Mutex AssetManager::SharedZip::gLock;
1854DefaultKeyedVector<String8, wp<AssetManager::SharedZip> > AssetManager::SharedZip::gOpen;
1855
1856AssetManager::SharedZip::SharedZip(const String8& path, time_t modWhen)
1857    : mPath(path), mZipFile(NULL), mModWhen(modWhen),
1858      mResourceTableAsset(NULL), mResourceTable(NULL)
1859{
1860    if (kIsDebug) {
1861        ALOGI("Creating SharedZip %p %s\n", this, (const char*)mPath);
1862    }
1863    ALOGV("+++ opening zip '%s'\n", mPath.string());
1864    mZipFile = ZipFileRO::open(mPath.string());
1865    if (mZipFile == NULL) {
1866        ALOGD("failed to open Zip archive '%s'\n", mPath.string());
1867    }
1868}
1869
1870sp<AssetManager::SharedZip> AssetManager::SharedZip::get(const String8& path,
1871        bool createIfNotPresent)
1872{
1873    AutoMutex _l(gLock);
1874    time_t modWhen = getFileModDate(path);
1875    sp<SharedZip> zip = gOpen.valueFor(path).promote();
1876    if (zip != NULL && zip->mModWhen == modWhen) {
1877        return zip;
1878    }
1879    if (zip == NULL && !createIfNotPresent) {
1880        return NULL;
1881    }
1882    zip = new SharedZip(path, modWhen);
1883    gOpen.add(path, zip);
1884    return zip;
1885
1886}
1887
1888ZipFileRO* AssetManager::SharedZip::getZip()
1889{
1890    return mZipFile;
1891}
1892
1893Asset* AssetManager::SharedZip::getResourceTableAsset()
1894{
1895    AutoMutex _l(gLock);
1896    ALOGV("Getting from SharedZip %p resource asset %p\n", this, mResourceTableAsset);
1897    return mResourceTableAsset;
1898}
1899
1900Asset* AssetManager::SharedZip::setResourceTableAsset(Asset* asset)
1901{
1902    {
1903        AutoMutex _l(gLock);
1904        if (mResourceTableAsset == NULL) {
1905            // This is not thread safe the first time it is called, so
1906            // do it here with the global lock held.
1907            asset->getBuffer(true);
1908            mResourceTableAsset = asset;
1909            return asset;
1910        }
1911    }
1912    delete asset;
1913    return mResourceTableAsset;
1914}
1915
1916ResTable* AssetManager::SharedZip::getResourceTable()
1917{
1918    ALOGV("Getting from SharedZip %p resource table %p\n", this, mResourceTable);
1919    return mResourceTable;
1920}
1921
1922ResTable* AssetManager::SharedZip::setResourceTable(ResTable* res)
1923{
1924    {
1925        AutoMutex _l(gLock);
1926        if (mResourceTable == NULL) {
1927            mResourceTable = res;
1928            return res;
1929        }
1930    }
1931    delete res;
1932    return mResourceTable;
1933}
1934
1935bool AssetManager::SharedZip::isUpToDate()
1936{
1937    time_t modWhen = getFileModDate(mPath.string());
1938    return mModWhen == modWhen;
1939}
1940
1941void AssetManager::SharedZip::addOverlay(const asset_path& ap)
1942{
1943    mOverlays.add(ap);
1944}
1945
1946bool AssetManager::SharedZip::getOverlay(size_t idx, asset_path* out) const
1947{
1948    if (idx >= mOverlays.size()) {
1949        return false;
1950    }
1951    *out = mOverlays[idx];
1952    return true;
1953}
1954
1955AssetManager::SharedZip::~SharedZip()
1956{
1957    if (kIsDebug) {
1958        ALOGI("Destroying SharedZip %p %s\n", this, (const char*)mPath);
1959    }
1960    if (mResourceTable != NULL) {
1961        delete mResourceTable;
1962    }
1963    if (mResourceTableAsset != NULL) {
1964        delete mResourceTableAsset;
1965    }
1966    if (mZipFile != NULL) {
1967        delete mZipFile;
1968        ALOGV("Closed '%s'\n", mPath.string());
1969    }
1970}
1971
1972/*
1973 * ===========================================================================
1974 *      AssetManager::ZipSet
1975 * ===========================================================================
1976 */
1977
1978/*
1979 * Constructor.
1980 */
1981AssetManager::ZipSet::ZipSet(void)
1982{
1983}
1984
1985/*
1986 * Destructor.  Close any open archives.
1987 */
1988AssetManager::ZipSet::~ZipSet(void)
1989{
1990    size_t N = mZipFile.size();
1991    for (size_t i = 0; i < N; i++)
1992        closeZip(i);
1993}
1994
1995/*
1996 * Close a Zip file and reset the entry.
1997 */
1998void AssetManager::ZipSet::closeZip(int idx)
1999{
2000    mZipFile.editItemAt(idx) = NULL;
2001}
2002
2003
2004/*
2005 * Retrieve the appropriate Zip file from the set.
2006 */
2007ZipFileRO* AssetManager::ZipSet::getZip(const String8& path)
2008{
2009    int idx = getIndex(path);
2010    sp<SharedZip> zip = mZipFile[idx];
2011    if (zip == NULL) {
2012        zip = SharedZip::get(path);
2013        mZipFile.editItemAt(idx) = zip;
2014    }
2015    return zip->getZip();
2016}
2017
2018Asset* AssetManager::ZipSet::getZipResourceTableAsset(const String8& path)
2019{
2020    int idx = getIndex(path);
2021    sp<SharedZip> zip = mZipFile[idx];
2022    if (zip == NULL) {
2023        zip = SharedZip::get(path);
2024        mZipFile.editItemAt(idx) = zip;
2025    }
2026    return zip->getResourceTableAsset();
2027}
2028
2029Asset* AssetManager::ZipSet::setZipResourceTableAsset(const String8& path,
2030                                                 Asset* asset)
2031{
2032    int idx = getIndex(path);
2033    sp<SharedZip> zip = mZipFile[idx];
2034    // doesn't make sense to call before previously accessing.
2035    return zip->setResourceTableAsset(asset);
2036}
2037
2038ResTable* AssetManager::ZipSet::getZipResourceTable(const String8& path)
2039{
2040    int idx = getIndex(path);
2041    sp<SharedZip> zip = mZipFile[idx];
2042    if (zip == NULL) {
2043        zip = SharedZip::get(path);
2044        mZipFile.editItemAt(idx) = zip;
2045    }
2046    return zip->getResourceTable();
2047}
2048
2049ResTable* AssetManager::ZipSet::setZipResourceTable(const String8& path,
2050                                                    ResTable* res)
2051{
2052    int idx = getIndex(path);
2053    sp<SharedZip> zip = mZipFile[idx];
2054    // doesn't make sense to call before previously accessing.
2055    return zip->setResourceTable(res);
2056}
2057
2058/*
2059 * Generate the partial pathname for the specified archive.  The caller
2060 * gets to prepend the asset root directory.
2061 *
2062 * Returns something like "common/en-US-noogle.jar".
2063 */
2064/*static*/ String8 AssetManager::ZipSet::getPathName(const char* zipPath)
2065{
2066    return String8(zipPath);
2067}
2068
2069bool AssetManager::ZipSet::isUpToDate()
2070{
2071    const size_t N = mZipFile.size();
2072    for (size_t i=0; i<N; i++) {
2073        if (mZipFile[i] != NULL && !mZipFile[i]->isUpToDate()) {
2074            return false;
2075        }
2076    }
2077    return true;
2078}
2079
2080void AssetManager::ZipSet::addOverlay(const String8& path, const asset_path& overlay)
2081{
2082    int idx = getIndex(path);
2083    sp<SharedZip> zip = mZipFile[idx];
2084    zip->addOverlay(overlay);
2085}
2086
2087bool AssetManager::ZipSet::getOverlay(const String8& path, size_t idx, asset_path* out) const
2088{
2089    sp<SharedZip> zip = SharedZip::get(path, false);
2090    if (zip == NULL) {
2091        return false;
2092    }
2093    return zip->getOverlay(idx, out);
2094}
2095
2096/*
2097 * Compute the zip file's index.
2098 *
2099 * "appName", "locale", and "vendor" should be set to NULL to indicate the
2100 * default directory.
2101 */
2102int AssetManager::ZipSet::getIndex(const String8& zip) const
2103{
2104    const size_t N = mZipPath.size();
2105    for (size_t i=0; i<N; i++) {
2106        if (mZipPath[i] == zip) {
2107            return i;
2108        }
2109    }
2110
2111    mZipPath.add(zip);
2112    mZipFile.add(NULL);
2113
2114    return mZipPath.size()-1;
2115}
2116