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