AaptAssets.h revision 91447d88f2bdf9c2bf8d1a53570efef6172fba74 
1//
2// Copyright 2006 The Android Open Source Project
3//
4// Information about assets being operated on.
5//
6#ifndef __AAPT_ASSETS_H
7#define __AAPT_ASSETS_H
8
9#include <stdlib.h>
10#include <androidfw/AssetManager.h>
11#include <androidfw/ResourceTypes.h>
12#include <utils/KeyedVector.h>
13#include <utils/RefBase.h>
14#include <utils/SortedVector.h>
15#include <utils/String8.h>
16#include <utils/Vector.h>
17#include "ZipFile.h"
18
19#include "Bundle.h"
20#include "SourcePos.h"
21
22using namespace android;
23
24
25extern const char * const gDefaultIgnoreAssets;
26extern const char * gUserIgnoreAssets;
27
28bool valid_symbol_name(const String8& str);
29
30class AaptAssets;
31
32enum {
33    AXIS_NONE = 0,
34    AXIS_MCC = 1,
35    AXIS_MNC,
36    AXIS_LOCALE,
37    AXIS_SCREENLAYOUTSIZE,
38    AXIS_SCREENLAYOUTLONG,
39    AXIS_ORIENTATION,
40    AXIS_UIMODETYPE,
41    AXIS_UIMODENIGHT,
42    AXIS_DENSITY,
43    AXIS_TOUCHSCREEN,
44    AXIS_KEYSHIDDEN,
45    AXIS_KEYBOARD,
46    AXIS_NAVHIDDEN,
47    AXIS_NAVIGATION,
48    AXIS_SCREENSIZE,
49    AXIS_SMALLESTSCREENWIDTHDP,
50    AXIS_SCREENWIDTHDP,
51    AXIS_SCREENHEIGHTDP,
52    AXIS_LAYOUTDIR,
53    AXIS_VERSION,
54
55    AXIS_START = AXIS_MCC,
56    AXIS_END = AXIS_VERSION,
57};
58
59struct AaptLocaleValue {
60     char language[4];
61     char region[4];
62     char script[4];
63     char variant[8];
64
65     AaptLocaleValue() {
66         memset(this, 0, sizeof(AaptLocaleValue));
67     }
68
69     // Initialize this AaptLocaleValue from a config string.
70     bool initFromFilterString(const String8& config);
71
72     int initFromDirName(const Vector<String8>& parts, const int startIndex);
73
74     // Initialize this AaptLocaleValue from a ResTable_config.
75     void initFromResTable(const ResTable_config& config);
76
77     void writeTo(ResTable_config* out) const;
78
79     String8 toDirName() const;
80
81     int compare(const AaptLocaleValue& other) const {
82         return memcmp(this, &other, sizeof(AaptLocaleValue));
83     }
84
85     static void splitAndLowerCase(const char* const chars, Vector<String8>* parts,
86             const char separator);
87
88     inline bool operator<(const AaptLocaleValue& o) const { return compare(o) < 0; }
89     inline bool operator<=(const AaptLocaleValue& o) const { return compare(o) <= 0; }
90     inline bool operator==(const AaptLocaleValue& o) const { return compare(o) == 0; }
91     inline bool operator!=(const AaptLocaleValue& o) const { return compare(o) != 0; }
92     inline bool operator>=(const AaptLocaleValue& o) const { return compare(o) >= 0; }
93     inline bool operator>(const AaptLocaleValue& o) const { return compare(o) > 0; }
94private:
95     void setLanguage(const char* language);
96     void setRegion(const char* language);
97     void setScript(const char* script);
98     void setVariant(const char* variant);
99};
100
101struct AxisValue {
102    // Used for all axes except AXIS_LOCALE, which is represented
103    // as a AaptLocaleValue value.
104    int intValue;
105    AaptLocaleValue localeValue;
106
107    AxisValue() : intValue(0) {
108    }
109
110    inline int compare(const AxisValue &other) const  {
111        if (intValue != other.intValue) {
112            return intValue - other.intValue;
113        }
114
115        return localeValue.compare(other.localeValue);
116    }
117
118    inline bool operator<(const AxisValue& o) const { return compare(o) < 0; }
119    inline bool operator<=(const AxisValue& o) const { return compare(o) <= 0; }
120    inline bool operator==(const AxisValue& o) const { return compare(o) == 0; }
121    inline bool operator!=(const AxisValue& o) const { return compare(o) != 0; }
122    inline bool operator>=(const AxisValue& o) const { return compare(o) >= 0; }
123    inline bool operator>(const AxisValue& o) const { return compare(o) > 0; }
124};
125
126/**
127 * This structure contains a specific variation of a single file out
128 * of all the variations it can have that we can have.
129 */
130struct AaptGroupEntry
131{
132public:
133    AaptGroupEntry() : mParamsChanged(true) {
134        memset(&mParams, 0, sizeof(ResTable_config));
135    }
136
137    bool initFromDirName(const char* dir, String8* resType);
138
139    static bool parseFilterNamePart(const String8& part, int* axis, AxisValue* value);
140
141    static AxisValue getConfigValueForAxis(const ResTable_config& config, int axis);
142
143    static bool configSameExcept(const ResTable_config& config,
144            const ResTable_config& otherConfig, int axis);
145
146    int compare(const AaptGroupEntry& o) const;
147
148    const ResTable_config toParams() const;
149
150    inline bool operator<(const AaptGroupEntry& o) const { return compare(o) < 0; }
151    inline bool operator<=(const AaptGroupEntry& o) const { return compare(o) <= 0; }
152    inline bool operator==(const AaptGroupEntry& o) const { return compare(o) == 0; }
153    inline bool operator!=(const AaptGroupEntry& o) const { return compare(o) != 0; }
154    inline bool operator>=(const AaptGroupEntry& o) const { return compare(o) >= 0; }
155    inline bool operator>(const AaptGroupEntry& o) const { return compare(o) > 0; }
156
157    String8 toString() const;
158    String8 toDirName(const String8& resType) const;
159
160    const String8& getVersionString() const { return version; }
161
162private:
163    static bool getMccName(const char* name, ResTable_config* out = NULL);
164    static bool getMncName(const char* name, ResTable_config* out = NULL);
165    static bool getScreenLayoutSizeName(const char* name, ResTable_config* out = NULL);
166    static bool getScreenLayoutLongName(const char* name, ResTable_config* out = NULL);
167    static bool getOrientationName(const char* name, ResTable_config* out = NULL);
168    static bool getUiModeTypeName(const char* name, ResTable_config* out = NULL);
169    static bool getUiModeNightName(const char* name, ResTable_config* out = NULL);
170    static bool getDensityName(const char* name, ResTable_config* out = NULL);
171    static bool getTouchscreenName(const char* name, ResTable_config* out = NULL);
172    static bool getKeysHiddenName(const char* name, ResTable_config* out = NULL);
173    static bool getKeyboardName(const char* name, ResTable_config* out = NULL);
174    static bool getNavigationName(const char* name, ResTable_config* out = NULL);
175    static bool getNavHiddenName(const char* name, ResTable_config* out = NULL);
176    static bool getScreenSizeName(const char* name, ResTable_config* out = NULL);
177    static bool getSmallestScreenWidthDpName(const char* name, ResTable_config* out = NULL);
178    static bool getScreenWidthDpName(const char* name, ResTable_config* out = NULL);
179    static bool getScreenHeightDpName(const char* name, ResTable_config* out = NULL);
180    static bool getLayoutDirectionName(const char* name, ResTable_config* out = NULL);
181    static bool getVersionName(const char* name, ResTable_config* out = NULL);
182
183    String8 mcc;
184    String8 mnc;
185    AaptLocaleValue locale;
186    String8 vendor;
187    String8 smallestScreenWidthDp;
188    String8 screenWidthDp;
189    String8 screenHeightDp;
190    String8 screenLayoutSize;
191    String8 screenLayoutLong;
192    String8 orientation;
193    String8 uiModeType;
194    String8 uiModeNight;
195    String8 density;
196    String8 touchscreen;
197    String8 keysHidden;
198    String8 keyboard;
199    String8 navHidden;
200    String8 navigation;
201    String8 screenSize;
202    String8 layoutDirection;
203    String8 version;
204
205    mutable bool mParamsChanged;
206    mutable ResTable_config mParams;
207};
208
209inline int compare_type(const AaptGroupEntry& lhs, const AaptGroupEntry& rhs)
210{
211    return lhs.compare(rhs);
212}
213
214inline int strictly_order_type(const AaptGroupEntry& lhs, const AaptGroupEntry& rhs)
215{
216    return compare_type(lhs, rhs) < 0;
217}
218
219class AaptGroup;
220class FilePathStore;
221
222/**
223 * A single asset file we know about.
224 */
225class AaptFile : public RefBase
226{
227public:
228    AaptFile(const String8& sourceFile, const AaptGroupEntry& groupEntry,
229             const String8& resType)
230        : mGroupEntry(groupEntry)
231        , mResourceType(resType)
232        , mSourceFile(sourceFile)
233        , mData(NULL)
234        , mDataSize(0)
235        , mBufferSize(0)
236        , mCompression(ZipEntry::kCompressStored)
237        {
238            //printf("new AaptFile created %s\n", (const char*)sourceFile);
239        }
240    virtual ~AaptFile() {
241        free(mData);
242    }
243
244    const String8& getPath() const { return mPath; }
245    const AaptGroupEntry& getGroupEntry() const { return mGroupEntry; }
246
247    // Data API.  If there is data attached to the file,
248    // getSourceFile() is not used.
249    bool hasData() const { return mData != NULL; }
250    const void* getData() const { return mData; }
251    size_t getSize() const { return mDataSize; }
252    void* editData(size_t size);
253    void* editData(size_t* outSize = NULL);
254    void* padData(size_t wordSize);
255    status_t writeData(const void* data, size_t size);
256    void clearData();
257
258    const String8& getResourceType() const { return mResourceType; }
259
260    // File API.  If the file does not hold raw data, this is
261    // a full path to a file on the filesystem that holds its data.
262    const String8& getSourceFile() const { return mSourceFile; }
263
264    String8 getPrintableSource() const;
265
266    // Desired compression method, as per utils/ZipEntry.h.  For example,
267    // no compression is ZipEntry::kCompressStored.
268    int getCompressionMethod() const { return mCompression; }
269    void setCompressionMethod(int c) { mCompression = c; }
270private:
271    friend class AaptGroup;
272
273    String8 mPath;
274    AaptGroupEntry mGroupEntry;
275    String8 mResourceType;
276    String8 mSourceFile;
277    void* mData;
278    size_t mDataSize;
279    size_t mBufferSize;
280    int mCompression;
281};
282
283/**
284 * A group of related files (the same file, with different
285 * vendor/locale variations).
286 */
287class AaptGroup : public RefBase
288{
289public:
290    AaptGroup(const String8& leaf, const String8& path)
291        : mLeaf(leaf), mPath(path) { }
292    virtual ~AaptGroup() { }
293
294    const String8& getLeaf() const { return mLeaf; }
295
296    // Returns the relative path after the AaptGroupEntry dirs.
297    const String8& getPath() const { return mPath; }
298
299    const DefaultKeyedVector<AaptGroupEntry, sp<AaptFile> >& getFiles() const
300        { return mFiles; }
301
302    status_t addFile(const sp<AaptFile>& file, const bool overwriteDuplicate=false);
303    void removeFile(size_t index);
304
305    void print(const String8& prefix) const;
306
307    String8 getPrintableSource() const;
308
309private:
310    String8 mLeaf;
311    String8 mPath;
312
313    DefaultKeyedVector<AaptGroupEntry, sp<AaptFile> > mFiles;
314};
315
316/**
317 * A single directory of assets, which can contain files and other
318 * sub-directories.
319 */
320class AaptDir : public RefBase
321{
322public:
323    AaptDir(const String8& leaf, const String8& path)
324        : mLeaf(leaf), mPath(path) { }
325    virtual ~AaptDir() { }
326
327    const String8& getLeaf() const { return mLeaf; }
328
329    const String8& getPath() const { return mPath; }
330
331    const DefaultKeyedVector<String8, sp<AaptGroup> >& getFiles() const { return mFiles; }
332    const DefaultKeyedVector<String8, sp<AaptDir> >& getDirs() const { return mDirs; }
333
334    virtual status_t addFile(const String8& name, const sp<AaptGroup>& file);
335
336    void removeFile(const String8& name);
337    void removeDir(const String8& name);
338
339    /*
340     * Perform some sanity checks on the names of files and directories here.
341     * In particular:
342     *  - Check for illegal chars in filenames.
343     *  - Check filename length.
344     *  - Check for presence of ".gz" and non-".gz" copies of same file.
345     *  - Check for multiple files whose names match in a case-insensitive
346     *    fashion (problematic for some systems).
347     *
348     * Comparing names against all other names is O(n^2).  We could speed
349     * it up some by sorting the entries and being smarter about what we
350     * compare against, but I'm not expecting to have enough files in a
351     * single directory to make a noticeable difference in speed.
352     *
353     * Note that sorting here is not enough to guarantee that the package
354     * contents are sorted -- subsequent updates can rearrange things.
355     */
356    status_t validate() const;
357
358    void print(const String8& prefix) const;
359
360    String8 getPrintableSource() const;
361
362private:
363    friend class AaptAssets;
364
365    status_t addDir(const String8& name, const sp<AaptDir>& dir);
366    sp<AaptDir> makeDir(const String8& name);
367    status_t addLeafFile(const String8& leafName,
368                         const sp<AaptFile>& file,
369                         const bool overwrite=false);
370    virtual ssize_t slurpFullTree(Bundle* bundle,
371                                  const String8& srcDir,
372                                  const AaptGroupEntry& kind,
373                                  const String8& resType,
374                                  sp<FilePathStore>& fullResPaths,
375                                  const bool overwrite=false);
376
377    String8 mLeaf;
378    String8 mPath;
379
380    DefaultKeyedVector<String8, sp<AaptGroup> > mFiles;
381    DefaultKeyedVector<String8, sp<AaptDir> > mDirs;
382};
383
384/**
385 * All information we know about a particular symbol.
386 */
387class AaptSymbolEntry
388{
389public:
390    AaptSymbolEntry()
391        : isPublic(false), isJavaSymbol(false), typeCode(TYPE_UNKNOWN)
392    {
393    }
394    AaptSymbolEntry(const String8& _name)
395        : name(_name), isPublic(false), isJavaSymbol(false), typeCode(TYPE_UNKNOWN)
396    {
397    }
398    AaptSymbolEntry(const AaptSymbolEntry& o)
399        : name(o.name), sourcePos(o.sourcePos), isPublic(o.isPublic)
400        , isJavaSymbol(o.isJavaSymbol), comment(o.comment), typeComment(o.typeComment)
401        , typeCode(o.typeCode), int32Val(o.int32Val), stringVal(o.stringVal)
402    {
403    }
404    AaptSymbolEntry operator=(const AaptSymbolEntry& o)
405    {
406        sourcePos = o.sourcePos;
407        isPublic = o.isPublic;
408        isJavaSymbol = o.isJavaSymbol;
409        comment = o.comment;
410        typeComment = o.typeComment;
411        typeCode = o.typeCode;
412        int32Val = o.int32Val;
413        stringVal = o.stringVal;
414        return *this;
415    }
416
417    const String8 name;
418
419    SourcePos sourcePos;
420    bool isPublic;
421    bool isJavaSymbol;
422
423    String16 comment;
424    String16 typeComment;
425
426    enum {
427        TYPE_UNKNOWN = 0,
428        TYPE_INT32,
429        TYPE_STRING
430    };
431
432    int typeCode;
433
434    // Value.  May be one of these.
435    int32_t int32Val;
436    String8 stringVal;
437};
438
439/**
440 * A group of related symbols (such as indices into a string block)
441 * that have been generated from the assets.
442 */
443class AaptSymbols : public RefBase
444{
445public:
446    AaptSymbols() { }
447    virtual ~AaptSymbols() { }
448
449    status_t addSymbol(const String8& name, int32_t value, const SourcePos& pos) {
450        if (!check_valid_symbol_name(name, pos, "symbol")) {
451            return BAD_VALUE;
452        }
453        AaptSymbolEntry& sym = edit_symbol(name, &pos);
454        sym.typeCode = AaptSymbolEntry::TYPE_INT32;
455        sym.int32Val = value;
456        return NO_ERROR;
457    }
458
459    status_t addStringSymbol(const String8& name, const String8& value,
460            const SourcePos& pos) {
461        if (!check_valid_symbol_name(name, pos, "symbol")) {
462            return BAD_VALUE;
463        }
464        AaptSymbolEntry& sym = edit_symbol(name, &pos);
465        sym.typeCode = AaptSymbolEntry::TYPE_STRING;
466        sym.stringVal = value;
467        return NO_ERROR;
468    }
469
470    status_t makeSymbolPublic(const String8& name, const SourcePos& pos) {
471        if (!check_valid_symbol_name(name, pos, "symbol")) {
472            return BAD_VALUE;
473        }
474        AaptSymbolEntry& sym = edit_symbol(name, &pos);
475        sym.isPublic = true;
476        return NO_ERROR;
477    }
478
479    status_t makeSymbolJavaSymbol(const String8& name, const SourcePos& pos) {
480        if (!check_valid_symbol_name(name, pos, "symbol")) {
481            return BAD_VALUE;
482        }
483        AaptSymbolEntry& sym = edit_symbol(name, &pos);
484        sym.isJavaSymbol = true;
485        return NO_ERROR;
486    }
487
488    void appendComment(const String8& name, const String16& comment, const SourcePos& pos) {
489        if (comment.size() <= 0) {
490            return;
491        }
492        AaptSymbolEntry& sym = edit_symbol(name, &pos);
493        if (sym.comment.size() == 0) {
494            sym.comment = comment;
495        } else {
496            sym.comment.append(String16("\n"));
497            sym.comment.append(comment);
498        }
499    }
500
501    void appendTypeComment(const String8& name, const String16& comment) {
502        if (comment.size() <= 0) {
503            return;
504        }
505        AaptSymbolEntry& sym = edit_symbol(name, NULL);
506        if (sym.typeComment.size() == 0) {
507            sym.typeComment = comment;
508        } else {
509            sym.typeComment.append(String16("\n"));
510            sym.typeComment.append(comment);
511        }
512    }
513
514    sp<AaptSymbols> addNestedSymbol(const String8& name, const SourcePos& pos) {
515        if (!check_valid_symbol_name(name, pos, "nested symbol")) {
516            return NULL;
517        }
518
519        sp<AaptSymbols> sym = mNestedSymbols.valueFor(name);
520        if (sym == NULL) {
521            sym = new AaptSymbols();
522            mNestedSymbols.add(name, sym);
523        }
524
525        return sym;
526    }
527
528    status_t applyJavaSymbols(const sp<AaptSymbols>& javaSymbols);
529
530    const KeyedVector<String8, AaptSymbolEntry>& getSymbols() const
531        { return mSymbols; }
532    const DefaultKeyedVector<String8, sp<AaptSymbols> >& getNestedSymbols() const
533        { return mNestedSymbols; }
534
535    const String16& getComment(const String8& name) const
536        { return get_symbol(name).comment; }
537    const String16& getTypeComment(const String8& name) const
538        { return get_symbol(name).typeComment; }
539
540private:
541    bool check_valid_symbol_name(const String8& symbol, const SourcePos& pos, const char* label) {
542        if (valid_symbol_name(symbol)) {
543            return true;
544        }
545        pos.error("invalid %s: '%s'\n", label, symbol.string());
546        return false;
547    }
548    AaptSymbolEntry& edit_symbol(const String8& symbol, const SourcePos* pos) {
549        ssize_t i = mSymbols.indexOfKey(symbol);
550        if (i < 0) {
551            i = mSymbols.add(symbol, AaptSymbolEntry(symbol));
552        }
553        AaptSymbolEntry& sym = mSymbols.editValueAt(i);
554        if (pos != NULL && sym.sourcePos.line < 0) {
555            sym.sourcePos = *pos;
556        }
557        return sym;
558    }
559    const AaptSymbolEntry& get_symbol(const String8& symbol) const {
560        ssize_t i = mSymbols.indexOfKey(symbol);
561        if (i >= 0) {
562            return mSymbols.valueAt(i);
563        }
564        return mDefSymbol;
565    }
566
567    KeyedVector<String8, AaptSymbolEntry>           mSymbols;
568    DefaultKeyedVector<String8, sp<AaptSymbols> >   mNestedSymbols;
569    AaptSymbolEntry                                 mDefSymbol;
570};
571
572class ResourceTypeSet : public RefBase,
573                        public KeyedVector<String8,sp<AaptGroup> >
574{
575public:
576    ResourceTypeSet();
577};
578
579// Storage for lists of fully qualified paths for
580// resources encountered during slurping.
581class FilePathStore : public RefBase,
582                      public Vector<String8>
583{
584public:
585    FilePathStore();
586};
587
588/**
589 * Asset hierarchy being operated on.
590 */
591class AaptAssets : public AaptDir
592{
593public:
594    AaptAssets();
595    virtual ~AaptAssets() { delete mRes; }
596
597    const String8& getPackage() const { return mPackage; }
598    void setPackage(const String8& package) {
599        mPackage = package;
600        mSymbolsPrivatePackage = package;
601        mHavePrivateSymbols = false;
602    }
603
604    const SortedVector<AaptGroupEntry>& getGroupEntries() const;
605
606    virtual status_t addFile(const String8& name, const sp<AaptGroup>& file);
607
608    sp<AaptFile> addFile(const String8& filePath,
609                         const AaptGroupEntry& entry,
610                         const String8& srcDir,
611                         sp<AaptGroup>* outGroup,
612                         const String8& resType);
613
614    void addResource(const String8& leafName,
615                     const String8& path,
616                     const sp<AaptFile>& file,
617                     const String8& resType);
618
619    void addGroupEntry(const AaptGroupEntry& entry) { mGroupEntries.add(entry); }
620
621    ssize_t slurpFromArgs(Bundle* bundle);
622
623    sp<AaptSymbols> getSymbolsFor(const String8& name);
624
625    sp<AaptSymbols> getJavaSymbolsFor(const String8& name);
626
627    status_t applyJavaSymbols();
628
629    const DefaultKeyedVector<String8, sp<AaptSymbols> >& getSymbols() const { return mSymbols; }
630
631    String8 getSymbolsPrivatePackage() const { return mSymbolsPrivatePackage; }
632    void setSymbolsPrivatePackage(const String8& pkg) {
633        mSymbolsPrivatePackage = pkg;
634        mHavePrivateSymbols = mSymbolsPrivatePackage != mPackage;
635    }
636
637    bool havePrivateSymbols() const { return mHavePrivateSymbols; }
638
639    bool isJavaSymbol(const AaptSymbolEntry& sym, bool includePrivate) const;
640
641    status_t buildIncludedResources(Bundle* bundle);
642    status_t addIncludedResources(const sp<AaptFile>& file);
643    const ResTable& getIncludedResources() const;
644
645    void print(const String8& prefix) const;
646
647    inline const Vector<sp<AaptDir> >& resDirs() const { return mResDirs; }
648    sp<AaptDir> resDir(const String8& name) const;
649
650    inline sp<AaptAssets> getOverlay() { return mOverlay; }
651    inline void setOverlay(sp<AaptAssets>& overlay) { mOverlay = overlay; }
652
653    inline KeyedVector<String8, sp<ResourceTypeSet> >* getResources() { return mRes; }
654    inline void
655        setResources(KeyedVector<String8, sp<ResourceTypeSet> >* res) { delete mRes; mRes = res; }
656
657    inline sp<FilePathStore>& getFullResPaths() { return mFullResPaths; }
658    inline void
659        setFullResPaths(sp<FilePathStore>& res) { mFullResPaths = res; }
660
661    inline sp<FilePathStore>& getFullAssetPaths() { return mFullAssetPaths; }
662    inline void
663        setFullAssetPaths(sp<FilePathStore>& res) { mFullAssetPaths = res; }
664
665private:
666    virtual ssize_t slurpFullTree(Bundle* bundle,
667                                  const String8& srcDir,
668                                  const AaptGroupEntry& kind,
669                                  const String8& resType,
670                                  sp<FilePathStore>& fullResPaths);
671
672    ssize_t slurpResourceTree(Bundle* bundle, const String8& srcDir);
673    ssize_t slurpResourceZip(Bundle* bundle, const char* filename);
674
675    status_t filter(Bundle* bundle);
676
677    String8 mPackage;
678    SortedVector<AaptGroupEntry> mGroupEntries;
679    DefaultKeyedVector<String8, sp<AaptSymbols> > mSymbols;
680    DefaultKeyedVector<String8, sp<AaptSymbols> > mJavaSymbols;
681    String8 mSymbolsPrivatePackage;
682    bool mHavePrivateSymbols;
683
684    Vector<sp<AaptDir> > mResDirs;
685
686    bool mChanged;
687
688    bool mHaveIncludedAssets;
689    AssetManager mIncludedAssets;
690
691    sp<AaptAssets> mOverlay;
692    KeyedVector<String8, sp<ResourceTypeSet> >* mRes;
693
694    sp<FilePathStore> mFullResPaths;
695    sp<FilePathStore> mFullAssetPaths;
696};
697
698#endif // __AAPT_ASSETS_H
699
700