blob: 59249529fbbab19d2d54b566c09dcd3b7a1643da [file] [log] [blame]
//
// 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;
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_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 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 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