CyanogenMode主题模块解析(中)

class ContextImpl extends Context {
...
static ContextImpl createAppContext(ActivityThread mainThread, LoadedApk packageInfo) {
if (packageInfo == null) throw new IllegalArgumentException("packageInfo");
return new ContextImpl(null, mainThread,
packageInfo, null, null, false, null, null, null);
}
...
}

class ContextImpl extends Context{
...
private ContextImpl(ContextImpl container, ActivityThread mainThread,
LoadedApk packageInfo, IBinder activityToken, UserHandle user, boolean restricted,
Display display, Configuration overrideConfiguration, String themePackageName) {
mOuterContext = this;

...

Resources resources = packageInfo.getResources(mainThread);

...
mResources = resources;
...
}

...
}

public final class LoadedApk {

...
public Resources getResources(ActivityThread mainThread) {
if (mResources == null) {
mResources = mainThread.getTopLevelResources(mResDir, mSplitResDirs, mOverlayDirs,
mApplicationInfo.sharedLibraryFiles, Display.DEFAULT_DISPLAY, null, this,
mainThread.getSystemContext(), mPackageName);
}
return mResources;
}
...

}

public final class ActivityThread {
...
Resources getTopLevelResources(String resDir, String[] splitResDirs, String[] overlayDirs,
String[] libDirs, int displayId, Configuration overrideConfiguration,
LoadedApk pkgInfo, Context context, String pkgName) {
return mResourcesManager.getTopLevelResources(resDir, splitResDirs, overlayDirs, libDirs,
displayId, pkgName, overrideConfiguration, pkgInfo.getCompatibilityInfo(), null,
context, pkgInfo.getApplicationInfo().isThemeable);
}
...
}

public class ResourcesManager {
...
public Resources getTopLevelResources(String resDir, String[] splitResDirs,
String[] overlayDirs, String[] libDirs, int displayId, String packageName,
Configuration overrideConfiguration, CompatibilityInfo compatInfo, IBinder token,
Context context, boolean isThemeable) {
final float scale = compatInfo.applicationScale;
ThemeConfig themeConfig = getThemeConfig();
ResourcesKey key = new ResourcesKey(resDir, displayId, overrideConfiguration, scale,
isThemeable, themeConfig, token);
Resources r;
synchronized (this) {
// Resources is app scale dependent.
if (false) {
Slog.w(TAG, "getTopLevelResources: " + resDir + " / " + scale);
}
WeakReference<Resources> wr = mActiveResources.get(key);
r = wr != null ? wr.get() : null;
//if (r != null) Slog.i(TAG, "isUpToDate " + resDir + ": " + r.getAssets().isUpToDate());
if (r != null && r.getAssets().isUpToDate()) {
if (false) {
Slog.w(TAG, "Returning cached resources " + r + " " + resDir
+ ": appScale=" + r.getCompatibilityInfo().applicationScale);
}
return r;
}
}

//if (r != null) {
//    Slog.w(TAG, "Throwing away out-of-date resources!!!! "
//            + r + " " + resDir);
//}

AssetManager assets = new AssetManager();
assets.setAppName(packageName);
assets.setThemeSupport(isThemeable);
// resDir can be null if the 'android' package is creating a new Resources object.
// This is fine, since each AssetManager automatically loads the 'android' package
// already.
if (resDir != null) {
if (assets.addAssetPath(resDir) == 0) {
return null;
}
}

if (splitResDirs != null) {
for (String splitResDir : splitResDirs) {
if (assets.addAssetPath(splitResDir) == 0) {
return null;
}
}
}

if (overlayDirs != null) {
for (String idmapPath : overlayDirs) {
assets.addOverlayPath(idmapPath, null, null, null, null);
}
}

if (libDirs != null) {
for (String libDir : l
13f37
ibDirs) {
if (assets.addAssetPath(libDir) == 0) {
Slog.w(TAG, "Asset path '" + libDir +
"' does not exist or contains no resources.");
}
}
}

//Slog.i(TAG, "Resource: key=" + key + ", display metrics=" + metrics);
DisplayMetrics dm = getDisplayMetricsLocked(displayId);
Configuration config;
boolean isDefaultDisplay = (displayId == Display.DEFAULT_DISPLAY);
final boolean hasOverrideConfig = key.hasOverrideConfiguration();
if (!isDefaultDisplay || hasOverrideConfig) {
config = new Configuration(getConfiguration());
if (!isDefaultDisplay) {
applyNonDefaultDisplayMetricsToConfigurationLocked(dm, config);
}
if (hasOverrideConfig) {
config.updateFrom(key.mOverrideConfiguration);
}
} else {
config = getConfiguration();
}

boolean iconsAttached = false;
/* Attach theme information to the resulting AssetManager when appropriate. */
if (config != null && !context.getPackageManager().isSafeMode()) {
if (themeConfig == null) {
try {
themeConfig = ThemeConfig.getBootTheme(context.getContentResolver());
} catch (Exception e) {
Slog.d(TAG, "ThemeConfig.getBootTheme failed, falling back to system theme", e);
themeConfig = ThemeConfig.getSystemTheme();
}
}

if (isThemeable) {
if (themeConfig != null) {
attachThemeAssets(assets, themeConfig);
attachCommonAssets(assets, themeConfig);
iconsAttached = attachIconAssets(assets, themeConfig);
}
} else if (themeConfig != null &&
!ThemeConfig.SYSTEM_DEFAULT.equals(themeConfig.getFontPkgName())) {
// use system fonts if not themeable and a theme font is currently in use
Typeface.recreateDefaults(true);
}
}

r = new Resources(assets, dm, config, compatInfo, token);
if (iconsAttached) setActivityIcons(r);

if (false) {
Slog.i(TAG, "Created app resources " + resDir + " " + r + ": "
+ r.getConfiguration() + " appScale="
+ r.getCompatibilityInfo().applicationScale);
}

synchronized (this) {
WeakReference<Resources> wr = mActiveResources.get(key);
Resources existing = wr != null ? wr.get() : null;
if (existing != null && existing.getAssets().isUpToDate()) {
// Someone else already created the resources while we were
// unlocked; go ahead and use theirs.
r.getAssets().close();
return existing;
}

// XXX need to remove entries when weak references go away
mActiveResources.put(key, new WeakReference<Resources>(r));
return r;
}
}
...
}

private ThemeConfig getThemeConfig() {
final Configuration config = getConfiguration();
return config != null ? config.themeConfig : null;
}

public Configuration getConfiguration() {
return mResConfiguration;
}

public static ThemeConfig getBootTheme(ContentResolver resolver) {
return getBootThemeForUser(resolver, UserHandle.getCallingUserId());
}

public static ThemeConfig getBootThemeForUser(ContentResolver resolver, int userHandle) {
ThemeConfig bootTheme = mSystemConfig;
try {
String json = Settings.Secure.getStringForUser(resolver,
Configuration.THEME_PKG_CONFIGURATION_PERSISTENCE_PROPERTY, userHandle);
bootTheme = ThemeConfig.fromJson(json);

// Handle upgrade Case: Previously the theme configuration was in separate fields
if (bootTheme == null) {
String overlayPkgName =  Settings.Secure.getStringForUser(resolver,
Configuration.THEME_PACKAGE_NAME_PERSISTENCE_PROPERTY, userHandle);
String iconPackPkgName = Settings.Secure.getStringForUser(resolver,
Configuration.THEME_ICONPACK_PACKAGE_NAME_PERSISTENCE_PROPERTY, userHandle);
String fontPkgName = Settings.Secure.getStringForUser(resolver,
Configuration.THEME_FONT_PACKAGE_NAME_PERSISTENCE_PROPERTY, userHandle);

Builder builder = new Builder();
builder.defaultOverlay(overlayPkgName);
builder.defaultIcon(iconPackPkgName);
builder.defaultFont(fontPkgName);
bootTheme = builder.build();
}
} catch (SecurityException e) {
Log.w(TAG, "Could not get boot theme", e);
}
return bootTheme;
}

private boolean attachThemeAssets(AssetManager assets, ThemeConfig theme) {
PackageInfo piTheme = null;
PackageInfo piTarget = null;
PackageInfo piAndroid = null;

// Some apps run in process of another app (eg keyguard/systemUI) so we must get the
// package name from the res tables. The 0th base package name will be the android group.
// The 1st base package name will be the app group if one is attached. Check if it is there
// first or else the system will crash!
String basePackageName = null;
String resourcePackageName = null;
int count = assets.getBasePackageCount();
if (count > NUM_DEFAULT_ASSETS) {
basePackageName  = assets.getBasePackageName(NUM_DEFAULT_ASSETS);
resourcePackageName = assets.getBaseResourcePackageName(NUM_DEFAULT_ASSETS);
} else if (count == NUM_DEFAULT_ASSETS) {
basePackageName  = assets.getBasePackageName(0);
} else {
return false;
}

try {
piTheme = getPackageManager().getPackageInfo(
theme.getOverlayPkgNameForApp(basePackageName), 0,
UserHandle.getCallingUserId());
piTarget = getPackageManager().getPackageInfo(
basePackageName, 0, UserHandle.getCallingUserId());

// Handle special case where a system app (ex trebuchet) may have had its pkg name
// renamed during an upgrade. basePackageName would be the manifest value which will
// fail on getPackageInfo(). resource pkg is assumed to have the original name
if (piTarget == null && resourcePackageName != null) {
piTarget = getPackageManager().getPackageInfo(resourcePackageName,
0, UserHandle.getCallingUserId());
}
piAndroid = getPackageManager().getPackageInfo("android", 0,
UserHandle.getCallingUserId());
} catch (RemoteException e) {
}

if (piTheme == null || piTheme.applicationInfo == null ||
piTarget == null || piTarget.applicationInfo == null ||
piAndroid == null || piAndroid.applicationInfo == null ||
piTheme.mOverlayTargets == null) {
return false;
}

String themePackageName = piTheme.packageName;
String themePath = piTheme.applicationInfo.publicSourceDir;
if (!piTarget.isThemeApk && piTheme.mOverlayTargets.contains(basePackageName)) {
String targetPackagePath = piTarget.applicationInfo.sourceDir;
String prefixPath = ThemeUtils.getOverlayPathToTarget(basePackageName);

String resCachePath = ThemeUtils.getTargetCacheDir(piTarget.packageName, piTheme);
String resApkPath = resCachePath + "/resources.apk";
String idmapPath = ThemeUtils.getIdmapPath(piTarget.packageName, piTheme.packageName);
int cookie = assets.addOverlayPath(idmapPath, themePath, resApkPath,
targetPackagePath, prefixPath);

if (cookie != 0) {
assets.setThemePackageName(themePackageName);
assets.addThemeCookie(cookie);
}
}

if (!piTarget.isThemeApk && !"android".equals(basePackageName) &&
piTheme.mOverlayTargets.contains("android")) {
String resCachePath= ThemeUtils.getTargetCacheDir(piAndroid.packageName, piTheme);
String prefixPath = ThemeUtils.getOverlayPathToTarget(piAndroid.packageName);
String targetPackagePath = piAndroid.applicationInfo.publicSourceDir;
String resApkPath = resCachePath + "/resources.apk";
String idmapPath = ThemeUtils.getIdmapPath("android", piTheme.packageName);
int cookie = assets.addOverlayPath(idmapPath, themePath,
resApkPath, targetPackagePath, prefixPath);
if (cookie != 0) {
assets.setThemePackageName(themePackageName);
assets.addThemeCookie(cookie);
}
}

return true;
}

public final class AssetManager implements AutoCloseable {

...
public final int addOverlayPath(String idmapPath, String themeApkPath,
String resApkPath, String targetPkgPath, String prefixPath) {
synchronized (this) {
return addOverlayPathNative(idmapPath, themeApkPath, resApkPath, targetPkgPath,
prefixPath);
}
}
...
}

static jint android_content_AssetManager_addOverlayPath(JNIEnv* env, jobject clazz,
jstring idmapPath,
jstring packagePath,
jstring resApkPath, jstring targetPkgPath,
jstring prefixPath)
{
...

AssetManager* am = assetManagerForJavaObject(env, clazz);
if (am == NULL) {
return 0;
}

int32_t cookie;
bool res = am->addOverlayPath(
String8(idmapPath8.c_str()),
String8(packagePath8.c_str()),
&cookie,
String8(resApkPath8.c_str()),
String8(targetPkgPath8.c_str()),
String8(prefixPath8.c_str()));

return (res) ? (jint)cookie : 0;
}

bool AssetManager::addOverlayPath(const String8& idmapPath, const String8& overlayPackagePath,
int32_t* cookie, const String8& resApkPath, const String8& targetPkgPath,
const String8& prefixPath)
{
AutoMutex _l(mLock);

ALOGV("overlayApkPath: %s, idmap Path: %s, resApkPath %s, targetPkgPath: %s",
overlayPackagePath.string(), idmapPath.string(),
resApkPath.string(),
targetPkgPath.string());

for (size_t i = 0; i < mAssetPaths.size(); ++i) {
if (mAssetPaths[i].idmap == idmapPath) {
*cookie = static_cast<int32_t>(i + 1);
return true;
}
}

Asset* idmap = NULL;
if ((idmap = openAssetFromFileLocked(idmapPath, Asset::ACCESS_BUFFER)) == NULL) {
ALOGW("failed to open idmap file %s\n", idmapPath.string());
return false;
}

String8 targetPath;
String8 overlayPath;
if (!ResTable::getIdmapInfo(idmap->getBuffer(false), idmap->getLength(),
NULL, NULL, NULL, &targetPath, &overlayPath)) {
ALOGW("failed to read idmap file %s\n", idmapPath.string());
delete idmap;
return false;
}
delete idmap;

if (overlayPath != overlayPackagePath) {
ALOGW("idmap file %s inconcistent: expected path %s does not match actual path %s\n",
idmapPath.string(), overlayPackagePath.string(), overlayPath.string());
return false;
}
if (access(targetPath.string(), R_OK) != 0) {
ALOGW("failed to access file %s: %s\n", targetPath.string(), strerror(errno));
return false;
}
if (access(idmapPath.string(), R_OK) != 0) {
ALOGW("failed to access file %s: %s\n", idmapPath.string(), strerror(errno));
return false;
}
if (access(overlayPath.string(), R_OK) != 0) {
ALOGW("failed to access file %s: %s\n", overlayPath.string(), strerror(errno));
return false;
}

asset_path oap;
oap.path = overlayPath;
oap.type = ::getFileType(overlayPath.string());
oap.idmap = idmapPath;
oap.resApkPath = resApkPath;
#if 0
ALOGD("Overlay added: targetPath=%s overlayPath=%s idmapPath=%s\n",
targetPath.string(), overlayPath.string(), idmapPath.string());
#endif
oap.prefixPath = prefixPath; //ex: assets/com.foo.bar
mAssetPaths.add(oap);
*cookie = static_cast<int32_t>(mAssetPaths.size());

if (mResources != NULL) {
size_t index = mAssetPaths.size() - 1;
appendPathToResTable(oap, &index);
}

return true;
}

public Drawable getDrawable(int id, @Nullable Theme theme) throws NotFoundException {
return getDrawable(id, theme, true);
}

public Drawable getDrawable(int id, @Nullable Theme theme, boolean supportComposedIcons)
throws NotFoundException {
//Check if an icon is themed
PackageItemInfo info = mIcons != null ? mIcons.get(id) : null;
if (info != null && info.themedIcon != 0) {
id = info.themedIcon;
}

TypedValue value;
synchronized (mAccessLock) {
value = mTmpValue;
if (value == null) {
value = new TypedValue();
} else {
mTmpValue = null;
}
getValue(id, value, true, supportComposedIcons);
}
Drawable res = null;
try {
res = loadDrawable(value, id, theme);
} catch (NotFoundException e) {
// The below statement will be true if we were trying to load a composed icon.
// Since we received a NotFoundException, try to load the original if this
// condition is true, otherwise throw the original exception.
if (supportComposedIcons && mComposedIconInfo != null && info != null &&
info.themedIcon == 0) {
Log.e(TAG, "Failed to retrieve composed icon.", e);
getValue(id, value, true, false);
res = loadDrawable(value, id, theme);
} else {
throw e;
}
}
synchronized (mAccessLock) {
if (mTmpValue == null) {
mTmpValue = value;
}
}
return res;
}

public void getValue(int id, TypedValue outValue, boolean resolveRefs,
boolean supportComposedIcons) throws NotFoundException {
//Check if an icon was themed
PackageItemInfo info = mIcons != null ? mIcons.get(id) : null;
if (info != null && info.themedIcon != 0) {
id = info.themedIcon;
}
boolean found = mAssets.getResourceValue(id, 0, outValue, resolveRefs);
if (found) {
if (supportComposedIcons && IconPackHelper.shouldComposeIcon(mComposedIconInfo)
&& info != null && info.themedIcon == 0) {
Drawable dr = loadDrawable(outValue, id, null);
IconCustomizer.getValue(this, id, outValue, dr);
}
return;
}
throw new NotFoundException("Resource ID #0x"
+ Integer.toHexString(id));
}

final boolean getResourceValue(int ident,
int density,
TypedValue outValue,
boolean resolveRefs)
{
int block = loadResourceValue(ident, (short) density, outValue, resolveRefs);
if (block >= 0) {
if (outValue.type != TypedValue.TYPE_STRING) {
return true;
}
outValue.string = mStringBlocks[block].get(outValue.data);
return true;
}
return false;
}

static jint android_content_AssetManager_loadResourceValue(JNIEnv* env, jobject clazz,
jint ident,
jshort density,
jobject outValue,
jboolean resolve)
{
if (outValue == NULL) {
jniThrowNullPointerException(env, "outValue");
return 0;
}
AssetManager* am = assetManagerForJavaObject(env, clazz);
if (am == NULL) {
return 0;
}
const ResTable& res(am->getResources());

Res_value value;
ResTable_config config;
uint32_t typeSpecFlags;
ssize_t block = res.getResource(ident, &value, false, density, &typeSpecFlags, &config);
#if THROW_ON_BAD_ID
if (block == BAD_INDEX) {
jniThrowException(env, "java/lang/IllegalStateException", "Bad resource!");
return 0;
}
#endif
uint32_t ref = ident;
if (resolve) {
block = res.resolveReference(&value, block, &ref, &typeSpecFlags, &config);
#if THROW_ON_BAD_ID
if (block == BAD_INDEX) {
jniThrowException(env, "java/lang/IllegalStateException", "Bad resource!");
return 0;
}
#endif
}
if (block >= 0) {
return copyValue(env, outValue, &res, value, ref, block, typeSpecFlags, &config);
}

return static_cast<jint>(block);
}

const ResTable& AssetManager::getResources(bool required) const
{
const ResTable* rt = getResTable(required);
return *rt;
}

const ResTable* AssetManager::getResTable(bool required) const
{
ResTable* rt = mResources;
if (rt) {
return rt;
}

// Iterate through all asset packages, collecting resources from each.

AutoMutex _l(mLock);

if (mResources != NULL) {
return mResources;
}

if (required) {
LOG_FATAL_IF(mAssetPaths.size() == 0, "No assets added to AssetManager");
}

if (mCacheMode != CACHE_OFF && !mCacheValid) {
const_cast<AssetManager*>(this)->loadFileNameCacheLocked();
}

mResources = new ResTable();
updateResourceParamsLocked();

bool onlyEmptyResources = true;
const size_t N = mAssetPaths.size();
for (size_t i=0; i<N; i++) {
bool empty = appendPathToResTable(mAssetPaths.itemAt(i), &i);
onlyEmptyResources = onlyEmptyResources && empty;
}

if (required && onlyEmptyResources) {
ALOGW("Unable to find resources file resources.arsc");
delete mResources;
mResources = NULL;
}

return mResources;
}

bool AssetManager::appendPathToResTable(const asset_path& ap, size_t* entryIdx) const {
Asset* ass = NULL;
ResTable* sharedRes = NULL;
bool shared = true;
bool onlyEmptyResources = true;
MY_TRACE_BEGIN(ap.path.string());
Asset* idmap = openIdmapLocked(ap);
ALOGV("Looking for resource asset in '%s'\n", ap.path.string());
if (!ap.resApkPath.isEmpty()) {
// Avoid using prefix path in this case since the compiled resApk will simply have resources.arsc in it
ass = const_cast<AssetManager*>(this)->openNonAssetInPathLocked("resources.arsc", Asset::ACCESS_BUFFER, ap, false);
shared = false;
} else if (ap.type != kFileTypeDirectory) {
if (*entryIdx == 0) {
// The first item is typically the framework resources,
// which we want to avoid parsing every time.
sharedRes = const_cast<AssetManager*>(this)->
mZipSet.getZipResourceTable(ap.path);
if (sharedRes != NULL) {
// skip ahead the number of system overlay packages preloaded
*entryIdx += sharedRes->getTableCount() - 1;
}
}
if (sharedRes == NULL) {
ass = const_cast<AssetManager*>(this)->
mZipSet.getZipResourceTableAsset(ap.path);
if (ass == NULL) {
ALOGV("loading resource table %s\n", ap.path.string());
ass = const_cast<AssetManager*>(this)->
openNonAssetInPathLocked("resources.arsc",
Asset::ACCESS_BUFFER,
ap);
if (ass != NULL && ass != kExcludedAsset) {
ass = const_cast<AssetManager*>(this)->
mZipSet.setZipResourceTableAsset(ap.path, ass);
}
}

if (*entryIdx == 0 && ass != NULL) {
// If this is the first resource table in the asset
// manager, then we are going to cache it so that we
// can quickly copy it out for others.
ALOGV("Creating shared resources for %s", ap.path.string());
sharedRes = new ResTable();
sharedRes->add(ass, idmap, *entryIdx + 1, false, ap.pkgIdOverride);
#ifdef HAVE_ANDROID_OS
const char* data = getenv("ANDROID_DATA");
LOG_ALWAYS_FATAL_IF(data == NULL, "ANDROID_DATA not set");
String8 overlaysListPath(data);
overlaysListPath.appendPath(kResourceCache);
overlaysListPath.appendPath("overlays.list");
addSystemOverlays(overlaysListPath.string(), ap.path, sharedRes, *entryIdx);
#endif
sharedRes = const_cast<AssetManager*>(this)->
mZipSet.setZipResourceTable(ap.path, sharedRes);
}
}
} else {
ALOGV("loading resource table %s\n", ap.path.string());
ass = const_cast<AssetManager*>(this)->
openNonAssetInPathLocked("resources.arsc",
Asset::ACCESS_BUFFER,
ap);
shared = false;
}

if ((ass != NULL || sharedRes != NULL) && ass != kExcludedAsset) {
ALOGV("Installing resource asset %p in to table %p\n", ass, mResources);
if (sharedRes != NULL) {
ALOGV("Copying existing resources for %s", ap.path.string());
mResources->add(sharedRes);
} else {
ALOGV("Parsing resources for %s", ap.path.string());
mResources->add(ass, idmap, *entryIdx + 1, !shared, ap.pkgIdOverride);
}
onlyEmptyResources = false;

if (!shared) {
delete ass;
}
} else {
ALOGV("Installing empty resources in to table %p\n", mResources);
mResources->addEmpty(*entryIdx + 1);
}

if (idmap != NULL) {
delete idmap;
}
MY_TRACE_END();

return onlyEmptyResources;
}

status_t ResTable::add(Asset* asset, Asset* idmapAsset, const int32_t cookie, bool copyData,
const uint32_t pkgIdOverride) {
const void* data = asset->getBuffer(true);
if (data == NULL) {
ALOGW("Unable to get buffer of resource asset file");
return UNKNOWN_ERROR;
}

size_t idmapSize = 0;
const void* idmapData = NULL;
if (idmapAsset != NULL) {
idmapData = idmapAsset->getBuffer(true);
if (idmapData == NULL) {
ALOGW("Unable to get buffer of idmap asset file");
return UNKNOWN_ERROR;
}
idmapSize = static_cast<size_t>(idmapAsset->getLength());
}

return addInternal(data, static_cast<size_t>(asset->getLength()),
idmapData, idmapSize, cookie, copyData, pkgIdOverride);
}
status_t ResTable::addInternal(const void* data, size_t dataSize, const void* idmapData, size_t idmapDataSize,
const int32_t cookie, bool copyData, const uint32_t pkgIdOverride)
{
…
if (parsePackage((ResTable_package*)chunk, header, idOverride) != NO_ERROR) {
return mError;
}
…
}

status_t ResTable::parsePackage(const ResTable_package* const pkg,
const Header* const header, const uint32_t pkgIdOverride)
{
…
if (header->resourceIDMap != NULL) {
status_t err = parseIdmap(header->resourceIDMap, header->resourceIDMapSize, &targetPackageId, &idmapEntries);
if (err != NO_ERROR) {
ALOGW("Overlay is broken");
return (mError=err);
}
}
if (targetGroup != NULL) {
ssize_t idmapIndex = idmapEntries.indexOfKey(typeSpec->id);
if (idmapIndex >= 0) {
typeIndex = idmapEntries[idmapIndex].targetTypeId() - 1;
TypeList& typeList = targetGroup->types.editItemAt(typeIndex);
Type* t = new Type(header, package, newEntryCount);
t->idmapEntries = idmapEntries[idmapIndex];
t->typeSpec = typeSpec;
t->typeSpecFlags = (const uint32_t*)(
((const uint8_t*)typeSpec) + dtohs(typeSpec->header.headerSize));
typeList.add(t);
}
}
…
}

status_t ResTable::getEntry(
const PackageGroup* packageGroup, int typeIndex, int entryIndex,
const ResTable_config* config,
Entry* outEntry,
const bool performMapping) const
{
const TypeList& typeList = packageGroup->types[typeIndex];
if (typeList.isEmpty()) {
ALOGV("Skipping entry type index 0x%02x because type is NULL!\n", typeIndex);
return BAD_TYPE;
}

const ResTable_type* bestType = NULL;
uint32_t bestOffset = ResTable_type::NO_ENTRY;
const Package* bestPackage = NULL;
uint32_t specFlags = 0;
uint8_t actualTypeIndex = typeIndex;
ResTable_config bestConfig;
memset(&bestConfig, 0, sizeof(bestConfig));

bool currentTypeIsOverlay = false;

// Iterate over the Types of each package.
const size_t typeCount = typeList.size();
for (size_t i = 0; i < typeCount; i++) {
const Type* const typeSpec = typeList[i];

int realEntryIndex = entryIndex;
int realTypeIndex = typeIndex;
currentTypeIsOverlay = false;

// Runtime overlay packages provide a mapping of app resource
// ID to package resource ID.
if (performMapping && typeSpec->idmapEntries.hasEntries()) {
uint16_t overlayEntryIndex;
if (typeSpec->idmapEntries.lookup(entryIndex, &overlayEntryIndex) != NO_ERROR) {
// No such mapping exists
continue;
}
realEntryIndex = overlayEntryIndex;
realTypeIndex = typeSpec->idmapEntries.overlayTypeId() - 1;
currentTypeIsOverlay = true;
}

if (static_cast<size_t>(realEntryIndex) >= typeSpec->entryCount) {
ALOGW("For resource 0x%08x, entry index(%d) is beyond type entryCount(%d)",
Res_MAKEID(packageGroup->id - 1, typeIndex, entryIndex),
entryIndex, static_cast<int>(typeSpec->entryCount));
// We should normally abort here, but some legacy apps declare
// resources in the 'android' package (old bug in AAPT).
continue;
}

// Aggregate all the flags for each package that defines this entry.
if (typeSpec->typeSpecFlags != NULL) {
specFlags |= dtohl(typeSpec->typeSpecFlags[realEntryIndex]);
} else {
specFlags = -1;
}

const size_t numConfigs = typeSpec->configs.size();
for (size_t c = 0; c < numConfigs; c++) {
const ResTable_type* const thisType = typeSpec->configs[c];
if (thisType == NULL) {
continue;
}

ResTable_config thisConfig;
thisConfig.copyFromDtoH(thisType->config);

// Check to make sure this one is valid for the current parameters.
if (config != NULL && !thisConfig.match(*config)) {
continue;
}

// Check if there is the desired entry in this type.
const uint8_t* const end = reinterpret_cast<const uint8_t*>(thisType)
+ dtohl(thisType->header.size);
const uint32_t* const eindex = reinterpret_cast<const uint32_t*>(
reinterpret_cast<const uint8_t*>(thisType) + dtohs(thisType->header.headerSize));

uint32_t thisOffset = dtohl(eindex[realEntryIndex]);
if (thisOffset == ResTable_type::NO_ENTRY) {
// There is no entry for this index and configuration.
continue;
}

if (bestType != NULL) {
// Check if this one is less specific than the last found.  If so,
// we will skip it.  We check starting with things we most care
// about to those we least care about.
if (!currentTypeIsOverlay && !thisConfig.isBetterThan(bestConfig, config)) {
if (!currentTypeIsOverlay || thisConfig.compare(bestConfig) != 0) {
continue;
}
}
}

bestType = thisType;
bestOffset = thisOffset;
bestConfig = thisConfig;
bestPackage = typeSpec->package;
actualTypeIndex = realTypeIndex;

// If no config was specified, any type will do, so skip
if (config == NULL) {
break;
}
}
}

if (bestType == NULL) {
return BAD_INDEX;
}

bestOffset += dtohl(bestType->entriesStart);

if (bestOffset > (dtohl(bestType->header.size)-sizeof(ResTable_entry))) {
ALOGW("ResTable_entry at 0x%x is beyond type chunk data 0x%x",
bestOffset, dtohl(bestType->header.size));
return BAD_TYPE;
}
if ((bestOffset & 0x3) != 0) {
ALOGW("ResTable_entry at 0x%x is not on an integer boundary", bestOffset);
return BAD_TYPE;
}

const ResTable_entry* const entry = reinterpret_cast<const ResTable_entry*>(
reinterpret_cast<const uint8_t*>(bestType) + bestOffset);
if (dtohs(entry->size) < sizeof(*entry)) {
ALOGW("ResTable_entry size 0x%x is too small", dtohs(entry->size));
return BAD_TYPE;
}

if (outEntry != NULL) {
outEntry->entry = entry;
outEntry->config = bestConfig;
outEntry->type = bestType;
outEntry->specFlags = specFlags;
outEntry->package = bestPackage;
outEntry->typeStr = StringPoolRef(&bestPackage->typeStrings, actualTypeIndex - bestPackage->typeIdOffset);
outEntry->keyStr = StringPoolRef(&bestPackage->keyStrings, dtohl(entry->key.index));
outEntry->isFromOverlay = currentTypeIsOverlay;
}
return NO_ERROR;
}