drgreen/android_frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
android_frameworks_base/tools/aapt/AaptAssets.h
Adam Lesinski de898ff429 Shared library resource support 
Shared libraries can now export resources for applications
to use.

Exporting resources works the same way the framework exports
resources, by defining the public symbols in res/values/public.xml.

Building a shared library requires aapt to be invoked with the
--shared-lib option. Shared libraries will be assigned a package
ID of 0x00 at build-time. At runtime, all loaded shared libraries
will be assigned a new package ID.

Currently, shared libraries should not import other shared libraries,
as those dependencies will not be loaded at runtime.

At runtime, reflection is used to update the package ID of resource
symbols in the shared library's R class file. The package name of
the R class file is assumed to be the same as the shared library's
package name declared in its manifest. This will be customizable in
a future commit.

See /tests/SharedLibrary/ for examples of a shared library and its
client.

Bug:12724178
Change-Id: I60c0cb8ab87849f8f8a1a13431562fe8603020a7
2014-03-25 12:09:56 -07:00

701 lines
22 KiB
C++
Raw Blame History

//
// 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/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_LOCALE,
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,
};
struct AaptLocaleValue {
char language[4];
char region[4];
char script[4];
char variant[8];
AaptLocaleValue() {
memset(this, 0, sizeof(AaptLocaleValue));
}
// Initialize this AaptLocaleValue from a config string.
bool initFromFilterString(const String8& config);
int initFromDirName(const Vector<String8>& parts, const int startIndex);
// Initialize this AaptLocaleValue from a ResTable_config.
void initFromResTable(const ResTable_config& config);
void writeTo(ResTable_config* out) const;
String8 toDirName() const;
int compare(const AaptLocaleValue& other) const {
return memcmp(this, &other, sizeof(AaptLocaleValue));
}
static void splitAndLowerCase(const char* const chars, Vector<String8>* parts,
const char separator);
inline bool operator<(const AaptLocaleValue& o) const { return compare(o) < 0; }
inline bool operator<=(const AaptLocaleValue& o) const { return compare(o) <= 0; }
inline bool operator==(const AaptLocaleValue& o) const { return compare(o) == 0; }
inline bool operator!=(const AaptLocaleValue& o) const { return compare(o) != 0; }
inline bool operator>=(const AaptLocaleValue& o) const { return compare(o) >= 0; }
inline bool operator>(const AaptLocaleValue& o) const { return compare(o) > 0; }
private:
void setLanguage(const char* language);
void setRegion(const char* language);
void setScript(const char* script);
void setVariant(const char* variant);
};
struct AxisValue {
// Used for all axes except AXIS_LOCALE, which is represented
// as a AaptLocaleValue value.
int intValue;
AaptLocaleValue localeValue;
AxisValue() : intValue(0) {
}
inline int compare(const AxisValue &other) const {
if (intValue != other.intValue) {
return intValue - other.intValue;
}
return localeValue.compare(other.localeValue);
}
inline bool operator<(const AxisValue& o) const { return compare(o) < 0; }
inline bool operator<=(const AxisValue& o) const { return compare(o) <= 0; }
inline bool operator==(const AxisValue& o) const { return compare(o) == 0; }
inline bool operator!=(const AxisValue& o) const { return compare(o) != 0; }
inline bool operator>=(const AxisValue& o) const { return compare(o) >= 0; }
inline bool operator>(const AxisValue& o) const { return compare(o) > 0; }
};
/**
* 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) {
memset(&mParams, 0, sizeof(ResTable_config));
}
bool initFromDirName(const char* dir, String8* resType);
static bool parseFilterNamePart(const String8& part, int* axis, AxisValue* value);
static AxisValue getConfigValueForAxis(const ResTable_config& config, int axis);
static bool configSameExcept(const ResTable_config& config,
const ResTable_config& otherConfig, int axis);
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:
static bool getMccName(const char* name, ResTable_config* out = NULL);
static bool getMncName(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);
String8 mcc;
String8 mnc;
AaptLocaleValue 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* editDataInRange(size_t offset, size_t size);
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, const bool overwriteDuplicate=false);
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,
const bool overwrite=false);
virtual ssize_t slurpFullTree(Bundle* bundle,
const String8& srcDir,
const AaptGroupEntry& kind,
const String8& resType,
sp<FilePathStore>& fullResPaths,
const bool overwrite=false);
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
Reference in New Issue View Git Blame Copy Permalink