diff options
Diffstat (limited to 'tools/aapt/AaptAssets.h')
| -rw-r--r-- | tools/aapt/AaptAssets.h | 633 |
1 files changed, 633 insertions, 0 deletions
diff --git a/tools/aapt/AaptAssets.h b/tools/aapt/AaptAssets.h new file mode 100644 index 0000000..5cfa913 --- /dev/null +++ b/tools/aapt/AaptAssets.h @@ -0,0 +1,633 @@ +// +// Copyright 2006 The Android Open Source Project +// +// Information about assets being operated on. +// +#ifndef __AAPT_ASSETS_H +#define __AAPT_ASSETS_H + +#include <stdlib.h> +#include <androidfw/AssetManager.h> +#include <androidfw/ResourceTypes.h> +#include <utils/KeyedVector.h> +#include <utils/RefBase.h> +#include <utils/SortedVector.h> +#include <utils/String8.h> +#include <utils/String8.h> +#include <utils/Vector.h> +#include "ZipFile.h" + +#include "Bundle.h" +#include "SourcePos.h" + +using namespace android; + + +extern const char * const gDefaultIgnoreAssets; +extern const char * gUserIgnoreAssets; + +bool valid_symbol_name(const String8& str); + +class AaptAssets; + +enum { + AXIS_NONE = 0, + AXIS_MCC = 1, + AXIS_MNC, + AXIS_LANGUAGE, + AXIS_REGION, + AXIS_SCREENLAYOUTSIZE, + AXIS_SCREENLAYOUTLONG, + AXIS_ORIENTATION, + AXIS_UIMODETYPE, + AXIS_UIMODENIGHT, + AXIS_DENSITY, + AXIS_TOUCHSCREEN, + AXIS_KEYSHIDDEN, + AXIS_KEYBOARD, + AXIS_NAVHIDDEN, + AXIS_NAVIGATION, + AXIS_SCREENSIZE, + AXIS_SMALLESTSCREENWIDTHDP, + AXIS_SCREENWIDTHDP, + AXIS_SCREENHEIGHTDP, + AXIS_LAYOUTDIR, + AXIS_VERSION, + + AXIS_START = AXIS_MCC, + AXIS_END = AXIS_VERSION, +}; + +/** + * This structure contains a specific variation of a single file out + * of all the variations it can have that we can have. + */ +struct AaptGroupEntry +{ +public: + AaptGroupEntry() : mParamsChanged(true) { } + AaptGroupEntry(const String8& _locale, const String8& _vendor) + : locale(_locale), vendor(_vendor), mParamsChanged(true) { } + + bool initFromDirName(const char* dir, String8* resType); + + static status_t parseNamePart(const String8& part, int* axis, uint32_t* value); + + static uint32_t getConfigValueForAxis(const ResTable_config& config, int axis); + + static bool configSameExcept(const ResTable_config& config, + const ResTable_config& otherConfig, int axis); + + static bool getMccName(const char* name, ResTable_config* out = NULL); + static bool getMncName(const char* name, ResTable_config* out = NULL); + static bool getLocaleName(const char* name, ResTable_config* out = NULL); + static bool getScreenLayoutSizeName(const char* name, ResTable_config* out = NULL); + static bool getScreenLayoutLongName(const char* name, ResTable_config* out = NULL); + static bool getOrientationName(const char* name, ResTable_config* out = NULL); + static bool getUiModeTypeName(const char* name, ResTable_config* out = NULL); + static bool getUiModeNightName(const char* name, ResTable_config* out = NULL); + static bool getDensityName(const char* name, ResTable_config* out = NULL); + static bool getTouchscreenName(const char* name, ResTable_config* out = NULL); + static bool getKeysHiddenName(const char* name, ResTable_config* out = NULL); + static bool getKeyboardName(const char* name, ResTable_config* out = NULL); + static bool getNavigationName(const char* name, ResTable_config* out = NULL); + static bool getNavHiddenName(const char* name, ResTable_config* out = NULL); + static bool getScreenSizeName(const char* name, ResTable_config* out = NULL); + static bool getSmallestScreenWidthDpName(const char* name, ResTable_config* out = NULL); + static bool getScreenWidthDpName(const char* name, ResTable_config* out = NULL); + static bool getScreenHeightDpName(const char* name, ResTable_config* out = NULL); + static bool getLayoutDirectionName(const char* name, ResTable_config* out = NULL); + static bool getVersionName(const char* name, ResTable_config* out = NULL); + + int compare(const AaptGroupEntry& o) const; + + const ResTable_config& toParams() const; + + inline bool operator<(const AaptGroupEntry& o) const { return compare(o) < 0; } + inline bool operator<=(const AaptGroupEntry& o) const { return compare(o) <= 0; } + inline bool operator==(const AaptGroupEntry& o) const { return compare(o) == 0; } + inline bool operator!=(const AaptGroupEntry& o) const { return compare(o) != 0; } + inline bool operator>=(const AaptGroupEntry& o) const { return compare(o) >= 0; } + inline bool operator>(const AaptGroupEntry& o) const { return compare(o) > 0; } + + String8 toString() const; + String8 toDirName(const String8& resType) const; + + const String8& getVersionString() const { return version; } + +private: + String8 mcc; + String8 mnc; + String8 locale; + String8 vendor; + String8 smallestScreenWidthDp; + String8 screenWidthDp; + String8 screenHeightDp; + String8 screenLayoutSize; + String8 screenLayoutLong; + String8 orientation; + String8 uiModeType; + String8 uiModeNight; + String8 density; + String8 touchscreen; + String8 keysHidden; + String8 keyboard; + String8 navHidden; + String8 navigation; + String8 screenSize; + String8 layoutDirection; + String8 version; + + mutable bool mParamsChanged; + mutable ResTable_config mParams; +}; + +inline int compare_type(const AaptGroupEntry& lhs, const AaptGroupEntry& rhs) +{ + return lhs.compare(rhs); +} + +inline int strictly_order_type(const AaptGroupEntry& lhs, const AaptGroupEntry& rhs) +{ + return compare_type(lhs, rhs) < 0; +} + +class AaptGroup; +class FilePathStore; + +/** + * A single asset file we know about. + */ +class AaptFile : public RefBase +{ +public: + AaptFile(const String8& sourceFile, const AaptGroupEntry& groupEntry, + const String8& resType) + : mGroupEntry(groupEntry) + , mResourceType(resType) + , mSourceFile(sourceFile) + , mData(NULL) + , mDataSize(0) + , mBufferSize(0) + , mCompression(ZipEntry::kCompressStored) + { + //printf("new AaptFile created %s\n", (const char*)sourceFile); + } + virtual ~AaptFile() { + free(mData); + } + + const String8& getPath() const { return mPath; } + const AaptGroupEntry& getGroupEntry() const { return mGroupEntry; } + + // Data API. If there is data attached to the file, + // getSourceFile() is not used. + bool hasData() const { return mData != NULL; } + const void* getData() const { return mData; } + size_t getSize() const { return mDataSize; } + void* editData(size_t size); + void* editData(size_t* outSize = NULL); + void* padData(size_t wordSize); + status_t writeData(const void* data, size_t size); + void clearData(); + + const String8& getResourceType() const { return mResourceType; } + + // File API. If the file does not hold raw data, this is + // a full path to a file on the filesystem that holds its data. + const String8& getSourceFile() const { return mSourceFile; } + + String8 getPrintableSource() const; + + // Desired compression method, as per utils/ZipEntry.h. For example, + // no compression is ZipEntry::kCompressStored. + int getCompressionMethod() const { return mCompression; } + void setCompressionMethod(int c) { mCompression = c; } +private: + friend class AaptGroup; + + String8 mPath; + AaptGroupEntry mGroupEntry; + String8 mResourceType; + String8 mSourceFile; + void* mData; + size_t mDataSize; + size_t mBufferSize; + int mCompression; +}; + +/** + * A group of related files (the same file, with different + * vendor/locale variations). + */ +class AaptGroup : public RefBase +{ +public: + AaptGroup(const String8& leaf, const String8& path) + : mLeaf(leaf), mPath(path) { } + virtual ~AaptGroup() { } + + const String8& getLeaf() const { return mLeaf; } + + // Returns the relative path after the AaptGroupEntry dirs. + const String8& getPath() const { return mPath; } + + const DefaultKeyedVector<AaptGroupEntry, sp<AaptFile> >& getFiles() const + { return mFiles; } + + status_t addFile(const sp<AaptFile>& file); + void removeFile(size_t index); + + void print(const String8& prefix) const; + + String8 getPrintableSource() const; + +private: + String8 mLeaf; + String8 mPath; + + DefaultKeyedVector<AaptGroupEntry, sp<AaptFile> > mFiles; +}; + +/** + * A single directory of assets, which can contain files and other + * sub-directories. + */ +class AaptDir : public RefBase +{ +public: + AaptDir(const String8& leaf, const String8& path) + : mLeaf(leaf), mPath(path) { } + virtual ~AaptDir() { } + + const String8& getLeaf() const { return mLeaf; } + + const String8& getPath() const { return mPath; } + + const DefaultKeyedVector<String8, sp<AaptGroup> >& getFiles() const { return mFiles; } + const DefaultKeyedVector<String8, sp<AaptDir> >& getDirs() const { return mDirs; } + + virtual status_t addFile(const String8& name, const sp<AaptGroup>& file); + + void removeFile(const String8& name); + void removeDir(const String8& name); + + /* + * Perform some sanity checks on the names of files and directories here. + * In particular: + * - Check for illegal chars in filenames. + * - Check filename length. + * - Check for presence of ".gz" and non-".gz" copies of same file. + * - Check for multiple files whose names match in a case-insensitive + * fashion (problematic for some systems). + * + * Comparing names against all other names is O(n^2). We could speed + * it up some by sorting the entries and being smarter about what we + * compare against, but I'm not expecting to have enough files in a + * single directory to make a noticeable difference in speed. + * + * Note that sorting here is not enough to guarantee that the package + * contents are sorted -- subsequent updates can rearrange things. + */ + status_t validate() const; + + void print(const String8& prefix) const; + + String8 getPrintableSource() const; + +private: + friend class AaptAssets; + + status_t addDir(const String8& name, const sp<AaptDir>& dir); + sp<AaptDir> makeDir(const String8& name); + status_t addLeafFile(const String8& leafName, + const sp<AaptFile>& file); + virtual ssize_t slurpFullTree(Bundle* bundle, + const String8& srcDir, + const AaptGroupEntry& kind, + const String8& resType, + sp<FilePathStore>& fullResPaths); + + String8 mLeaf; + String8 mPath; + + DefaultKeyedVector<String8, sp<AaptGroup> > mFiles; + DefaultKeyedVector<String8, sp<AaptDir> > mDirs; +}; + +/** + * All information we know about a particular symbol. + */ +class AaptSymbolEntry +{ +public: + AaptSymbolEntry() + : isPublic(false), isJavaSymbol(false), typeCode(TYPE_UNKNOWN) + { + } + AaptSymbolEntry(const String8& _name) + : name(_name), isPublic(false), isJavaSymbol(false), typeCode(TYPE_UNKNOWN) + { + } + AaptSymbolEntry(const AaptSymbolEntry& o) + : name(o.name), sourcePos(o.sourcePos), isPublic(o.isPublic) + , isJavaSymbol(o.isJavaSymbol), comment(o.comment), typeComment(o.typeComment) + , typeCode(o.typeCode), int32Val(o.int32Val), stringVal(o.stringVal) + { + } + AaptSymbolEntry operator=(const AaptSymbolEntry& o) + { + sourcePos = o.sourcePos; + isPublic = o.isPublic; + isJavaSymbol = o.isJavaSymbol; + comment = o.comment; + typeComment = o.typeComment; + typeCode = o.typeCode; + int32Val = o.int32Val; + stringVal = o.stringVal; + return *this; + } + + const String8 name; + + SourcePos sourcePos; + bool isPublic; + bool isJavaSymbol; + + String16 comment; + String16 typeComment; + + enum { + TYPE_UNKNOWN = 0, + TYPE_INT32, + TYPE_STRING + }; + + int typeCode; + + // Value. May be one of these. + int32_t int32Val; + String8 stringVal; +}; + +/** + * A group of related symbols (such as indices into a string block) + * that have been generated from the assets. + */ +class AaptSymbols : public RefBase +{ +public: + AaptSymbols() { } + virtual ~AaptSymbols() { } + + status_t addSymbol(const String8& name, int32_t value, const SourcePos& pos) { + if (!check_valid_symbol_name(name, pos, "symbol")) { + return BAD_VALUE; + } + AaptSymbolEntry& sym = edit_symbol(name, &pos); + sym.typeCode = AaptSymbolEntry::TYPE_INT32; + sym.int32Val = value; + return NO_ERROR; + } + + status_t addStringSymbol(const String8& name, const String8& value, + const SourcePos& pos) { + if (!check_valid_symbol_name(name, pos, "symbol")) { + return BAD_VALUE; + } + AaptSymbolEntry& sym = edit_symbol(name, &pos); + sym.typeCode = AaptSymbolEntry::TYPE_STRING; + sym.stringVal = value; + return NO_ERROR; + } + + status_t makeSymbolPublic(const String8& name, const SourcePos& pos) { + if (!check_valid_symbol_name(name, pos, "symbol")) { + return BAD_VALUE; + } + AaptSymbolEntry& sym = edit_symbol(name, &pos); + sym.isPublic = true; + return NO_ERROR; + } + + status_t makeSymbolJavaSymbol(const String8& name, const SourcePos& pos) { + if (!check_valid_symbol_name(name, pos, "symbol")) { + return BAD_VALUE; + } + AaptSymbolEntry& sym = edit_symbol(name, &pos); + sym.isJavaSymbol = true; + return NO_ERROR; + } + + void appendComment(const String8& name, const String16& comment, const SourcePos& pos) { + if (comment.size() <= 0) { + return; + } + AaptSymbolEntry& sym = edit_symbol(name, &pos); + if (sym.comment.size() == 0) { + sym.comment = comment; + } else { + sym.comment.append(String16("\n")); + sym.comment.append(comment); + } + } + + void appendTypeComment(const String8& name, const String16& comment) { + if (comment.size() <= 0) { + return; + } + AaptSymbolEntry& sym = edit_symbol(name, NULL); + if (sym.typeComment.size() == 0) { + sym.typeComment = comment; + } else { + sym.typeComment.append(String16("\n")); + sym.typeComment.append(comment); + } + } + + sp<AaptSymbols> addNestedSymbol(const String8& name, const SourcePos& pos) { + if (!check_valid_symbol_name(name, pos, "nested symbol")) { + return NULL; + } + + sp<AaptSymbols> sym = mNestedSymbols.valueFor(name); + if (sym == NULL) { + sym = new AaptSymbols(); + mNestedSymbols.add(name, sym); + } + + return sym; + } + + status_t applyJavaSymbols(const sp<AaptSymbols>& javaSymbols); + + const KeyedVector<String8, AaptSymbolEntry>& getSymbols() const + { return mSymbols; } + const DefaultKeyedVector<String8, sp<AaptSymbols> >& getNestedSymbols() const + { return mNestedSymbols; } + + const String16& getComment(const String8& name) const + { return get_symbol(name).comment; } + const String16& getTypeComment(const String8& name) const + { return get_symbol(name).typeComment; } + +private: + bool check_valid_symbol_name(const String8& symbol, const SourcePos& pos, const char* label) { + if (valid_symbol_name(symbol)) { + return true; + } + pos.error("invalid %s: '%s'\n", label, symbol.string()); + return false; + } + AaptSymbolEntry& edit_symbol(const String8& symbol, const SourcePos* pos) { + ssize_t i = mSymbols.indexOfKey(symbol); + if (i < 0) { + i = mSymbols.add(symbol, AaptSymbolEntry(symbol)); + } + AaptSymbolEntry& sym = mSymbols.editValueAt(i); + if (pos != NULL && sym.sourcePos.line < 0) { + sym.sourcePos = *pos; + } + return sym; + } + const AaptSymbolEntry& get_symbol(const String8& symbol) const { + ssize_t i = mSymbols.indexOfKey(symbol); + if (i >= 0) { + return mSymbols.valueAt(i); + } + return mDefSymbol; + } + + KeyedVector<String8, AaptSymbolEntry> mSymbols; + DefaultKeyedVector<String8, sp<AaptSymbols> > mNestedSymbols; + AaptSymbolEntry mDefSymbol; +}; + +class ResourceTypeSet : public RefBase, + public KeyedVector<String8,sp<AaptGroup> > +{ +public: + ResourceTypeSet(); +}; + +// Storage for lists of fully qualified paths for +// resources encountered during slurping. +class FilePathStore : public RefBase, + public Vector<String8> +{ +public: + FilePathStore(); +}; + +/** + * Asset hierarchy being operated on. + */ +class AaptAssets : public AaptDir +{ +public: + AaptAssets(); + virtual ~AaptAssets() { delete mRes; } + + const String8& getPackage() const { return mPackage; } + void setPackage(const String8& package) { + mPackage = package; + mSymbolsPrivatePackage = package; + mHavePrivateSymbols = false; + } + + const SortedVector<AaptGroupEntry>& getGroupEntries() const; + + virtual status_t addFile(const String8& name, const sp<AaptGroup>& file); + + sp<AaptFile> addFile(const String8& filePath, + const AaptGroupEntry& entry, + const String8& srcDir, + sp<AaptGroup>* outGroup, + const String8& resType); + + void addResource(const String8& leafName, + const String8& path, + const sp<AaptFile>& file, + const String8& resType); + + void addGroupEntry(const AaptGroupEntry& entry) { mGroupEntries.add(entry); } + + ssize_t slurpFromArgs(Bundle* bundle); + + sp<AaptSymbols> getSymbolsFor(const String8& name); + + sp<AaptSymbols> getJavaSymbolsFor(const String8& name); + + status_t applyJavaSymbols(); + + const DefaultKeyedVector<String8, sp<AaptSymbols> >& getSymbols() const { return mSymbols; } + + String8 getSymbolsPrivatePackage() const { return mSymbolsPrivatePackage; } + void setSymbolsPrivatePackage(const String8& pkg) { + mSymbolsPrivatePackage = pkg; + mHavePrivateSymbols = mSymbolsPrivatePackage != mPackage; + } + + bool havePrivateSymbols() const { return mHavePrivateSymbols; } + + bool isJavaSymbol(const AaptSymbolEntry& sym, bool includePrivate) const; + + status_t buildIncludedResources(Bundle* bundle); + status_t addIncludedResources(const sp<AaptFile>& file); + const ResTable& getIncludedResources() const; + + void print(const String8& prefix) const; + + inline const Vector<sp<AaptDir> >& resDirs() const { return mResDirs; } + sp<AaptDir> resDir(const String8& name) const; + + inline sp<AaptAssets> getOverlay() { return mOverlay; } + inline void setOverlay(sp<AaptAssets>& overlay) { mOverlay = overlay; } + + inline KeyedVector<String8, sp<ResourceTypeSet> >* getResources() { return mRes; } + inline void + setResources(KeyedVector<String8, sp<ResourceTypeSet> >* res) { delete mRes; mRes = res; } + + inline sp<FilePathStore>& getFullResPaths() { return mFullResPaths; } + inline void + setFullResPaths(sp<FilePathStore>& res) { mFullResPaths = res; } + + inline sp<FilePathStore>& getFullAssetPaths() { return mFullAssetPaths; } + inline void + setFullAssetPaths(sp<FilePathStore>& res) { mFullAssetPaths = res; } + +private: + virtual ssize_t slurpFullTree(Bundle* bundle, + const String8& srcDir, + const AaptGroupEntry& kind, + const String8& resType, + sp<FilePathStore>& fullResPaths); + + ssize_t slurpResourceTree(Bundle* bundle, const String8& srcDir); + ssize_t slurpResourceZip(Bundle* bundle, const char* filename); + + status_t filter(Bundle* bundle); + + String8 mPackage; + SortedVector<AaptGroupEntry> mGroupEntries; + DefaultKeyedVector<String8, sp<AaptSymbols> > mSymbols; + DefaultKeyedVector<String8, sp<AaptSymbols> > mJavaSymbols; + String8 mSymbolsPrivatePackage; + bool mHavePrivateSymbols; + + Vector<sp<AaptDir> > mResDirs; + + bool mChanged; + + bool mHaveIncludedAssets; + AssetManager mIncludedAssets; + + sp<AaptAssets> mOverlay; + KeyedVector<String8, sp<ResourceTypeSet> >* mRes; + + sp<FilePathStore> mFullResPaths; + sp<FilePathStore> mFullAssetPaths; +}; + +#endif // __AAPT_ASSETS_H + |