Android apk讀取資源文件過程詳解
上一篇咱們着重分析了資源是如何編譯和打包到apk裏的，重點在於resources.arsc和R.java兩個文件，還不瞭解的朋友能夠先看上一篇的內容：Android資源編譯和打包過程分析。熟悉了apk裏資源是如何分佈的以後，咱們就能夠來分析apk讀取的時候是如何獲取到最適合這個設備的資源的過程了。java
注意：這裏源碼都是看的Android 8.0的源碼，其餘系統版本原理基本相似。android
首先咱們來提出問題： Question1：好比一個圖片資源被放在drawable-xhdpi和drawable-xxhdpi兩個文件夾裏，apk讀取的時候是如何經過設備信息來獲取到最合適的那個圖片資源的？c++
通常狀況下，咱們在java代碼裏獲取圖片，獲取string字符串，都是用到以下代碼：數組
//設置背景drawable
tvAdvancedTask.setBackground(getResources().getDrawable(R.drawable.learning_task_unselected));
//設置字體顏色
tvAdvancedTask.setTextColor(getResources().getColor(R.color.color_9B6D00));
複製代碼
咱們就從這個入口開始一部一部進行剖析。這裏咱們主要剖析剛纔問題中的圖片資源，string，layout等讀取過程在底層基本相同，只是在上層解析獲取的時候稍微有些不一樣而已，都是小問題，首先來看下我理的整個流程圖，接下來咱們會按照流程圖來一步一步剖析。 緩存
咱們先來看getResource()方法：bash
@Override
public Resources getResources() {
if (mResources == null && VectorEnabledTintResources.shouldBeUsed()) {
mResources = new VectorEnabledTintResources(this, super.getResources());
}
return mResources == null ? super.getResources() : mResources;
}
複製代碼
mResources若是爲空的話則調用父類的getResources()來建立，跟進去到父類ContextTheme.java：微信
@Override
public Resources getResources() {
return getResourcesInternal();
}
private Resources getResourcesInternal() {
if (mResources == null) {
if (mOverrideConfiguration == null) {
mResources = super.getResources();
} else {
final Context resContext = createConfigurationContext(mOverrideConfiguration);
mResources = resContext.getResources();
}
}
return mResources;
}
複製代碼
mOverrideConfiguration是Configuration類的對象，主要負責描述可能影響應用程序檢索的資源的全部設備配置信息，包括屏幕大小，屏幕方向等。若是這個對象爲空的話，則經過ContextTheme的父類也就是ContextWrapper的getResources()方法獲取，否則則建立一個Context對象直接獲取。接下來咱們進ContextWrapper的getResources()方法：cookie
@Override
public Resources getResources() {
return mBase.getResources();
}
複製代碼
這裏其實也就是調用了Context對象的getResources()方法，接着進Context類：app
public abstract Resources getResources();
複製代碼
getResources()方法在Context類中是一個抽象函數，那咱們就進他的實現類ContextImpl.java中去看：less
@Override
public Resources getResources() {
return mResources;
}
複製代碼
這裏咱們就獲取到了已經init好了的Resources實例，其實熟悉Activity建立過程的朋友應該清楚，ActivityThread類的成員函數performLaunchActivity在應用程序進程中會建立一個Activity實例，建立實例的同時會爲它設置運行上下文也就是Context實例，而Activity的父類ContextThemeWrapper的父類ContextWrapper類裏有一個ContextImpl對象mBase，二者就關聯起來了。Activity經過這個mBase對象裝飾上了不少ContextImpl類的操做，好比上面一直在講的getResources()方法，還有getAssets()，startService()等操做，這是個很典型的裝飾者模式。
public class ContextWrapper extends Context {
Context mBase;
public ContextWrapper(Context base) {
mBase = base;
}
/**
* Set the base context for this ContextWrapper. All calls will then be
* delegated to the base context. Throws
* IllegalStateException if a base context has already been set.
*
* @param base The new base context for this wrapper.
*/
protected void attachBaseContext(Context base) {
if (mBase != null) {
throw new IllegalStateException("Base context already set");
}
mBase = base;
}
//...............................
}
複製代碼
這裏咱們就獲取到了Resources類的實例，獲取到實例之後咱們就能夠來分析getDrawable方法了：
@Deprecated
public Drawable getDrawable(@DrawableRes int id) throws NotFoundException {
final Drawable d = getDrawable(id, null);
if (d != null && d.canApplyTheme()) {
Log.w(TAG, "Drawable " + getResourceName(id) + " has unresolved theme "
+ "attributes! Consider using Resources.getDrawable(int, Theme) or "
+ "Context.getDrawable(int).", new RuntimeException());
}
return d;
}
複製代碼
這裏傳進來的id其實就是該資源對應的那個id，也就是上文中Android資源編譯和打包過程分析中第8步給資源生成資源id中的那個id。接着跟下去：
public Drawable getDrawable(@DrawableRes int id, @Nullable Theme theme)
throws NotFoundException {
return getDrawableForDensity(id, 0, theme);
}
複製代碼
以後進入getDrawableForDensity(@DrawableRes int id, int density, @Nullable Theme theme)方法：
public Drawable getDrawableForDensity(@DrawableRes int id, int density, @Nullable Theme theme) {
final TypedValue value = obtainTempTypedValue();
try {
final ResourcesImpl impl = mResourcesImpl;
impl.getValueForDensity(id, density, value, true);
return impl.loadDrawable(this, value, id, density, theme);
} finally {
releaseTempTypedValue(value);
}
}
複製代碼
這裏咱們看到新建了一個ResourcesImpl對象，而後調用了該對象的getValueForDensity方法，而後return該對象的loadDrawable方法取加載獲取到的Drawable對象。loadDrawable咱們稍後再講，這已是整個過程的最後收尾了，接下來咱們進ResourcesImpl.java的getValueForDensity方法，根據字面意思這個方法就是根據設備取獲取資源。
void getValueForDensity(@AnyRes int id, int density, TypedValue outValue,
boolean resolveRefs) throws NotFoundException {
boolean found = mAssets.getResourceValue(id, density, outValue, resolveRefs);
if (found) {
return;
}
throw new NotFoundException("Resource ID #0x" + Integer.toHexString(id));
}
複製代碼
這個方法調用了AssetManager的getResourceValue方法去判斷是否能根據id能夠讀取到，若是讀取不到，則拋出異常。AssetManager這個類也就是Android應用程序資源管理器，也就是咱們這篇文章真正的主角，主要負責讀取資源文件。在剛纔分析Resources對象建立過程當中講到ContextImpl類裏有一個getResources()方法，這裏的AssetManager對象也是同樣，經過ContextImpl裏的getAssets()方法獲取實例。 接下來來看AssetManager.java的getResourceValue方法
final boolean getResourceValue(@AnyRes int resId, int densityDpi, @NonNull TypedValue outValue,
boolean resolveRefs) {
synchronized (this) {
final int block = loadResourceValue(resId, (short) densityDpi, outValue, resolveRefs);
if (block < 0) {
return false;
}
// Convert the changing configurations flags populated by native code.
outValue.changingConfigurations = ActivityInfo.activityInfoConfigNativeToJava(
outValue.changingConfigurations);
if (outValue.type == TypedValue.TYPE_STRING) {
outValue.string = mStringBlocks[block].get(outValue.data);
}
return true;
}
}
複製代碼
.這裏能夠看到AssetManager經過調用loadResourceValue方法去加載相對應資源id的資源，而且獲取到一個int整型的block值。若是這個block大於等於0的話，就表示加載成功，而且會把結果保存在參數outValue所描述的一個TypedValue對象中。 接着咱們再進loadResourceValue方法：
private native final int loadResourceValue(int ident, short density, TypedValue outValue,
boolean resolve);
複製代碼
咱們發現這是一個jni方法，因此咱們就須要去看對應的c++方法了，源碼地址在 android_util_AssetManager.cpp：
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 (kThrowOnBadId) {
if (block == BAD_INDEX) {
jniThrowException(env, "java/lang/IllegalStateException", "Bad resource!");
return 0;
}
}
uint32_t ref = ident;
if (resolve) {
block = res.resolveReference(&value, block, &ref, &typeSpecFlags, &config);
if (kThrowOnBadId) {
if (block == BAD_INDEX) {
jniThrowException(env, "java/lang/IllegalStateException", "Bad resource!");
return 0;
}
}
}
if (block >= 0) {
return copyValue(env, outValue, &res, value, ref, block, typeSpecFlags, &config);
}
return static_cast<jint>(block);
}
複製代碼
根據jni的拋出異常咱們能夠看出這個方法裏的邏輯就是整個的核心邏輯過程，這裏咱們一步一步慢慢來分析整個過程，上面的代碼大體能夠分爲如下幾步： 一、首先調用assetManagerForJavaObject方法把java層AssetManager對象轉換爲C++層的AssetManager對象。 二、而後調用他的getResources方法獲取到一個ResourceTable對象res，ResourceTable對象其實就是上篇資源打包文章中提到的資源表，它包括了全部的資源信息。 三、建立Res_value對象value，ResTable_config對象config，uint32_t類型typeSpecFlags，調用res的getResource方法獲取相對應id的資源選項值以及它的配置信息，並保存下來 四、若是resolve是true的話，調用res的resolveReference方法來解析第3部中獲取到的資源選項值和配置信息，若是獲取到的block標記項爲BAD_INDEX的話則拋出異常。 五、若是block大於等於0的話，則調用copyValue方法返回最終的資源內容。
這基本上就是C++層資源文件讀取的核心邏輯過程，第1步建立過程就不詳述了，主要來看2-5步，接下來讓咱們深刻2-5的代碼方法裏來看apk是如何找到最適合當前本身的想要的資源選項的。 先來看第2步getResource方法：
const ResTable& AssetManager::getResources(bool required) const
{
const ResTable* rt = getResTable(required);
return *rt;
}
複製代碼
這裏咱們看到調用了getResTable方法來獲取ResTable對象的，咱們再進getResTable方法：
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");
}
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));
onlyEmptyResources = onlyEmptyResources && empty;
}
if (required && onlyEmptyResources) {
ALOGW("Unable to find resources file resources.arsc");
delete mResources;
mResources = NULL;
}
return mResources;
}
複製代碼
這裏咱們看到首先建立了一個ResTable對象rt，指向了mResources，若是不爲空則直接返回，這就說明該資源包裏面的資源索引表resources.arsc已經被解析過了，若是爲空，那麼就會去建立一個自動的互斥鎖，在Android的native源代碼裏你會常常看到AutoMutex _l(mLock);，這是什麼意思呢？AutoMutex其實就是Thread的一種自動的互斥鎖，在函數代碼中使用 AutoMutex 就能夠鎖定對象，而代碼執行完AutoMutex所在的代碼域以後，就自動釋放鎖。這裏用互斥鎖鎖上的目的是爲了防止其餘線程也去解析當前資源包裏的resources.arsc資源索引表，因此接下來會再次進行判斷，是否爲空的狀況。 若是仍是爲空的話，那麼接下來就會去解析該資源包裏的resources.arsc了。 在上一篇將資源文件打包到apk的文章中，咱們已經知道一個apk不只要去訪問本身的資源文件，還要去訪問系統的資源文件，因此一個應用程序要使用的資源包通常是2個，一個是系統資源包，一個是本身的apk文件，固然這裏也有特殊狀況，阿里sophix在資源替換上的方案是建立了一個新的資源包，後面咱們會分析到，這裏先不提。而這些資源包的路徑都會保存在AssetManager的成員變量mAssetPaths裏。 這裏對mAssetPaths裏的每一個資源包循環調用appendPathToResTable方法獲取一個布爾型的empty值，接下來咱們就進appendPathToResTable方法看一下：
bool AssetManager::appendPathToResTable(const asset_path& ap, bool appAsLib) const {
// skip those ap's that correspond to system overlays if (ap.isSystemOverlay) { return true; } Asset* ass = NULL; ResTable* sharedRes = NULL; bool shared = true; bool onlyEmptyResources = true; ATRACE_NAME(ap.path.string()); Asset* idmap = openIdmapLocked(ap); size_t nextEntryIdx = mResources->getTableCount(); ALOGV("Looking for resource asset in '%s'\n", ap.path.string()); if (ap.type != kFileTypeDirectory) { if (nextEntryIdx == 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 nextEntryIdx = sharedRes->getTableCount(); } } 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 (nextEntryIdx == 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, nextEntryIdx + 1, false); #ifdef __ANDROID__ 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, nextEntryIdx); #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, ap.isSystemAsset); } else { ALOGV("Parsing resources for %s", ap.path.string()); mResources->add(ass, idmap, nextEntryIdx + 1, !shared, appAsLib, ap.isSystemAsset); } onlyEmptyResources = false; if (!shared) { delete ass; } } else { ALOGV("Installing empty resources in to table %p\n", mResources); mResources->addEmpty(nextEntryIdx + 1); } if (idmap != NULL) { delete idmap; } return onlyEmptyResources; } 複製代碼
這個方法比較長，讓咱們一點點來分析，前面都是一些初始化的操做，先判斷是不是系統資源包，若是是系統資源包，則直接調用AssetManager對象的成員變量mZipSet的方法getZipResourceTable方法直接獲取對應的ResTable對象，爲了不重複加載解析系統資源包的狀況。 若是不是系統資源包的話，則會先去調用AssetManager對象的成員變量mZipSet的方法getZipResourceTableAsset先獲取到一個Asset對象，固然這是針對已經資源包下的resources.arsc已經提取出來的狀況，若是沒有提取過的話那麼ass就爲空，就會去加載該資源包路徑下的resources.arsc，經過AssetManager對象的openNonAssetInPathLocked方法讀取到rsources.arsc保存到Asset對象ass中。 以後的if判斷又回到系統資源包，若是是系統資源包的話，也就是nextEntryIndx等於0的狀況下，則會進行一系列的緩存操做，以便可以快速地將其複製出來供其餘地方使用。這裏須要注意系統資源包有一個overlay機制，也就是資源覆蓋機制，手機廠商能夠利用這個機制來自定義的系統資源以覆蓋系統默認的系統資源，達到個性化系統界面的目的。這裏會經過addSystemOverlays方法來更新系統資源包，這裏就不詳述了。 這以後就是把asset對象加載到ResTable對象mResources，這裏若是sharedRes不等於null的話，也就是這是一個系統資源包，會經過複製的方式調用add方法把asset對象加載到ResTable的mResources對象中，若是不是的話則會經過解析的方式add進去。接下來咱們跟下面的add方法進去看一看，代碼在ResourceTypes.cpp裏：
status_t ResTable::add(
Asset* asset, Asset* idmapAsset, const int32_t cookie, bool copyData,
bool appAsLib, bool isSystemAsset) {
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, appAsLib, cookie, copyData, isSystemAsset);
}
複製代碼
status_t ResTable::addInternal(const void* data, size_t dataSize, const void* idmapData, size_t idmapDataSize,
bool appAsLib, const int32_t cookie, bool copyData, bool isSystemAsset)
{
if (!data) {
return NO_ERROR;
}
if (dataSize < sizeof(ResTable_header)) {
ALOGE("Invalid data. Size(%d) is smaller than a ResTable_header(%d).",
(int) dataSize, (int) sizeof(ResTable_header));
return UNKNOWN_ERROR;
}
Header* header = new Header(this);
header->index = mHeaders.size();
header->cookie = cookie;
if (idmapData != NULL) {
header->resourceIDMap = (uint32_t*) malloc(idmapDataSize);
if (header->resourceIDMap == NULL) {
delete header;
return (mError = NO_MEMORY);
}
memcpy(header->resourceIDMap, idmapData, idmapDataSize);
header->resourceIDMapSize = idmapDataSize;
}
mHeaders.add(header);
const bool notDeviceEndian = htods(0xf0) != 0xf0;
if (kDebugLoadTableNoisy) {
ALOGV("Adding resources to ResTable: data=%p, size=%zu, cookie=%d, copy=%d "
"idmap=%p\n", data, dataSize, cookie, copyData, idmapData);
}
if (copyData || notDeviceEndian) {
header->ownedData = malloc(dataSize);
if (header->ownedData == NULL) {
return (mError=NO_MEMORY);
}
memcpy(header->ownedData, data, dataSize);
data = header->ownedData;
}
header->header = (const ResTable_header*)data;
header->size = dtohl(header->header->header.size);
if (kDebugLoadTableSuperNoisy) {
ALOGI("Got size %zu, again size 0x%x, raw size 0x%x\n", header->size,
dtohl(header->header->header.size), header->header->header.size);
}
if (kDebugLoadTableNoisy) {
ALOGV("Loading ResTable @%p:\n", header->header);
}
if (dtohs(header->header->header.headerSize) > header->size
|| header->size > dataSize) {
ALOGW("Bad resource table: header size 0x%x or total size 0x%x is larger than data size 0x%x\n",
(int)dtohs(header->header->header.headerSize),
(int)header->size, (int)dataSize);
return (mError=BAD_TYPE);
}
if (((dtohs(header->header->header.headerSize)|header->size)&0x3) != 0) {
ALOGW("Bad resource table: header size 0x%x or total size 0x%x is not on an integer boundary\n",
(int)dtohs(header->header->header.headerSize),
(int)header->size);
return (mError=BAD_TYPE);
}
header->dataEnd = ((const uint8_t*)header->header) + header->size;
// Iterate through all chunks.
size_t curPackage = 0;
const ResChunk_header* chunk =
(const ResChunk_header*)(((const uint8_t*)header->header)
+ dtohs(header->header->header.headerSize));
while (((const uint8_t*)chunk) <= (header->dataEnd-sizeof(ResChunk_header)) &&
((const uint8_t*)chunk) <= (header->dataEnd-dtohl(chunk->size))) {
status_t err = validate_chunk(chunk, sizeof(ResChunk_header), header->dataEnd, "ResTable");
if (err != NO_ERROR) {
return (mError=err);
}
if (kDebugTableNoisy) {
ALOGV("Chunk: type=0x%x, headerSize=0x%x, size=0x%x, pos=%p\n",
dtohs(chunk->type), dtohs(chunk->headerSize), dtohl(chunk->size),
(void*)(((const uint8_t*)chunk) - ((const uint8_t*)header->header)));
}
const size_t csize = dtohl(chunk->size);
const uint16_t ctype = dtohs(chunk->type);
if (ctype == RES_STRING_POOL_TYPE) {
if (header->values.getError() != NO_ERROR) {
// Only use the first string chunk; ignore any others that
// may appear.
status_t err = header->values.setTo(chunk, csize);
if (err != NO_ERROR) {
return (mError=err);
}
} else {
ALOGW("Multiple string chunks found in resource table.");
}
} else if (ctype == RES_TABLE_PACKAGE_TYPE) {
if (curPackage >= dtohl(header->header->packageCount)) {
ALOGW("More package chunks were found than the %d declared in the header.",
dtohl(header->header->packageCount));
return (mError=BAD_TYPE);
}
if (parsePackage(
(ResTable_package*)chunk, header, appAsLib, isSystemAsset) != NO_ERROR) {
return mError;
}
curPackage++;
} else {
ALOGW("Unknown chunk type 0x%x in table at %p.\n",
ctype,
(void*)(((const uint8_t*)chunk) - ((const uint8_t*)header->header)));
}
chunk = (const ResChunk_header*)
(((const uint8_t*)chunk) + csize);
}
if (curPackage < dtohl(header->header->packageCount)) {
ALOGW("Fewer package chunks (%d) were found than the %d declared in the header.",
(int)curPackage, dtohl(header->header->packageCount));
return (mError=BAD_TYPE);
}
mError = header->values.getError();
if (mError != NO_ERROR) {
ALOGW("No string values found in resource table!");
}
if (kDebugTableNoisy) {
ALOGV("Returning from add with mError=%d\n", mError);
}
return mError;
}
複製代碼
這裏咱們能夠看到add方法進去之後職責基本上就是Asset對象所描述的resources.arsc文件的內容進行解析，解析最後會獲得一個系列的Package信息。每個Package又包含了一個資源類型字符串資源池和一個資源項名稱字符串資源池，以及一系列的資源類型規範數據塊和一系列的資源項數據塊。解析過程這裏就不詳述了，整個resources.arsc的解析過程在上一篇Android資源編譯和打包過程分析已經有詳述了，不清楚的朋友能夠先去看看上一篇。 ok這裏咱們就已經把上面的AssetManager的getResource方法弄通了，獲得了一個資源表ResTable對象。咱們回上去，回到android_content_AssetManager_loadResourceValue方法，咱們看到這一步以後建立了Res_value對象value，ResTable_config對象config，uint32_t類型typeSpecFlags，調用剛獲取到的RestTable的對象res的getResource方法獲取相對應id的資源選項值以及它的配置信息，並保存下來。 咱們進res的getResource方法繼續探究：
ssize_t ResTable::getResource(uint32_t resID, Res_value* outValue, bool mayBeBag, uint16_t density,
uint32_t* outSpecFlags, ResTable_config* outConfig) const
{
if (mError != NO_ERROR) {
return mError;
}
const ssize_t p = getResourcePackageIndex(resID);
const int t = Res_GETTYPE(resID);
const int e = Res_GETENTRY(resID);
if (p < 0) {
if (Res_GETPACKAGE(resID)+1 == 0) {
ALOGW("No package identifier when getting value for resource number 0x%08x", resID);
} else {
ALOGW("No known package when getting value for resource number 0x%08x", resID);
}
return BAD_INDEX;
}
if (t < 0) {
ALOGW("No type identifier when getting value for resource number 0x%08x", resID);
return BAD_INDEX;
}
const PackageGroup* const grp = mPackageGroups[p];
if (grp == NULL) {
ALOGW("Bad identifier when getting value for resource number 0x%08x", resID);
return BAD_INDEX;
}
// Allow overriding density
ResTable_config desiredConfig = mParams;
if (density > 0) {
desiredConfig.density = density;
}
Entry entry;
status_t err = getEntry(grp, t, e, &desiredConfig, &entry);
if (err != NO_ERROR) {
// Only log the failure when we're not running on the host as // part of a tool. The caller will do its own logging. #ifndef STATIC_ANDROIDFW_FOR_TOOLS ALOGW("Failure getting entry for 0x%08x (t=%d e=%d) (error %d)\n", resID, t, e, err); #endif return err; } if ((dtohs(entry.entry->flags) & ResTable_entry::FLAG_COMPLEX) != 0) { if (!mayBeBag) { ALOGW("Requesting resource 0x%08x failed because it is complex\n", resID); } return BAD_VALUE; } const Res_value* value = reinterpret_cast<const Res_value*>( reinterpret_cast<const uint8_t*>(entry.entry) + entry.entry->size); outValue->size = dtohs(value->size); outValue->res0 = value->res0; outValue->dataType = value->dataType; outValue->data = dtohl(value->data); // The reference may be pointing to a resource in a shared library. These // references have build-time generated package IDs. These ids may not match // the actual package IDs of the corresponding packages in this ResTable. // We need to fix the package ID based on a mapping. if (grp->dynamicRefTable.lookupResourceValue(outValue) != NO_ERROR) { ALOGW("Failed to resolve referenced package: 0x%08x", outValue->data); return BAD_VALUE; } if (kDebugTableNoisy) { size_t len; printf("Found value: pkg=%zu, type=%d, str=%s, int=%d\n", entry.package->header->index, outValue->dataType, outValue->dataType == Res_value::TYPE_STRING ? String8(entry.package->header->values.stringAt(outValue->data, &len)).string() : "", outValue->data); } if (outSpecFlags != NULL) { *outSpecFlags = entry.specFlags; } if (outConfig != NULL) { *outConfig = entry.config; } return entry.package->header->index; } 複製代碼
先來看傳進來的參數，resId是要去尋找資源的資源id，uint32_t* outSpecFlags, ResTable_config* outConfig都是以前新建的兩個對象，density往上看過去應該是getDrawableForDensity方法裏傳進來的0。 首先分別調用getResourcePackageIndex方法，Res_GETTYPE方法，Res_GETENTRY方法獲取到該資源id的packageId，typeId和entryId。而後根據這個packageid獲取到了一個packageGroup，而後拿這些數據去調用getEntry方法，接下來咱們來深究下getEntry方法：
status_t ResTable::getEntry(
const PackageGroup* packageGroup, int typeIndex, int entryIndex,
const ResTable_config* config,
Entry* outEntry) 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));
// 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;
bool currentTypeIsOverlay = false;
// Runtime overlay packages provide a mapping of app resource
// ID to package resource ID.
if (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;
}
// Check that the entry idx is within range of the declared entry count (ResTable_typeSpec).
// Particular types (ResTable_type) may be encoded with sparse entries, and so their
// entryCount do not need to match.
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 Vector<const ResTable_type*>* candidateConfigs = &typeSpec->configs;
std::shared_ptr<Vector<const ResTable_type*>> filteredConfigs;
if (config && memcmp(&mParams, config, sizeof(mParams)) == 0) {
// Grab the lock first so we can safely get the current filtered list.
AutoMutex _lock(mFilteredConfigLock);
// This configuration is equal to the one we have previously cached for,
// so use the filtered configs.
const TypeCacheEntry& cacheEntry = packageGroup->typeCacheEntries[typeIndex];
if (i < cacheEntry.filteredConfigs.size()) {
if (cacheEntry.filteredConfigs[i]) {
// Grab a reference to the shared_ptr so it doesn't get destroyed while // going through this list. filteredConfigs = cacheEntry.filteredConfigs[i]; // Use this filtered list. candidateConfigs = filteredConfigs.get(); } } } const size_t numConfigs = candidateConfigs->size(); for (size_t c = 0; c < numConfigs; c++) { const ResTable_type* const thisType = candidateConfigs->itemAt(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; } const uint32_t* const eindex = reinterpret_cast<const uint32_t*>( reinterpret_cast<const uint8_t*>(thisType) + dtohs(thisType->header.headerSize)); uint32_t thisOffset; // Check if there is the desired entry in this type. if (thisType->flags & ResTable_type::FLAG_SPARSE) { // This is encoded as a sparse map, so perform a binary search. const ResTable_sparseTypeEntry* sparseIndices = reinterpret_cast<const ResTable_sparseTypeEntry*>(eindex); const ResTable_sparseTypeEntry* result = std::lower_bound( sparseIndices, sparseIndices + dtohl(thisType->entryCount), realEntryIndex, keyCompare); if (result == sparseIndices + dtohl(thisType->entryCount) || dtohs(result->idx) != realEntryIndex) { // No entry found. continue; } // Extract the offset from the entry. Each offset must be a multiple of 4 // so we store it as the real offset divided by 4. thisOffset = dtohs(result->offset) * 4u; } else { if (static_cast<uint32_t>(realEntryIndex) >= dtohl(thisType->entryCount)) { // Entry does not exist. continue; } 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 (!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)); } return NO_ERROR; } 複製代碼
getEntry方法很長，簡而言之就是爲了從一個packageGroup裏找到一個指定typeId，entryId和最符合當前配置信息的資源項。 首先從packageGroup中獲取到對應的typeList，由於上面獲取到的packgroup可能含有多個package，因此這裏有一個for循環在每個package中查找最合適的資源選項。 接着來看這個for循環的內容。for循環獲取到每一個package的type，由於在一個packageGroup中，第一個永遠都是一開始的基package，後面的都是overlay package，若是這個資源類型規範type指向的是idmapEntries的話，就會把realEntryntryIndex，realTypeIndex指向overlay package下提供的index，在運行的時候overlay package是提供應用程序資源ID到包資源ID的映射的。 在上一篇中咱們知道ResTable_type結構體中會有一個類型爲unit32_t的偏移數組。而這個偏移數組的第entryIndex個元素的值就表示Entry ID等於entryIndex的資源項的具體內容相對於ResTable_type結構體的偏移值。因此這裏咱們根據realEntryIndex就能夠得到這個資源項的具體內容相對於ResTable_type結構體的偏移值。 以後就會去比較ResTable_type裏的配置信息和config參數裏配置的信息哪一個更匹配一點，以此去拿到那個最合適的資源，而後保存在bestType，bestOffset，bsetConfig，bestPackage字段中，並返回給上一層。這樣就經過getEntry方法獲取到了最匹配現有配置信息的資源了。 這以後，咱們再回上去，回到android_content_AssetManager_loadResourceValue方法，這以後就是調用resolveReference方法來解析上面獲取到的資源選項值和配置信息了，那讓咱們來看resolveReference方法：
ssize_t ResTable::resolveReference(Res_value* value, ssize_t blockIndex,
uint32_t* outLastRef, uint32_t* inoutTypeSpecFlags,
ResTable_config* outConfig) const
{
int count=0;
while (blockIndex >= 0 && value->dataType == Res_value::TYPE_REFERENCE
&& value->data != 0 && count < 20) {
if (outLastRef) *outLastRef = value->data;
uint32_t newFlags = 0;
const ssize_t newIndex = getResource(value->data, value, true, 0, &newFlags,
outConfig);
if (newIndex == BAD_INDEX) {
return BAD_INDEX;
}
if (kDebugTableTheme) {
ALOGI("Resolving reference 0x%x: newIndex=%d, type=0x%x, data=0x%x\n",
value->data, (int)newIndex, (int)value->dataType, value->data);
}
//printf("Getting reference 0x%08x: newIndex=%d\n", value->data, newIndex);
if (inoutTypeSpecFlags != NULL) *inoutTypeSpecFlags |= newFlags;
if (newIndex < 0) {
// This can fail if the resource being referenced is a style...
// in this case, just return the reference, and expect the
// caller to deal with.
return blockIndex;
}
blockIndex = newIndex;
count++;
}
return blockIndex;
}
複製代碼
這裏咱們看到咱們把獲取到的Res_value對象不斷的循環嗲用ResTable的getResource方法來進行解析，getResource方法幹嗎的上面咱們已經講過了。不斷循環的條件是若是這個value的dataType值等於TYPE_REFERENCE的話，這個意思就是這個value它只是一個引用。咱們也看到了這裏限制了循環20次，防止無限循環。
經過resolveReference方法獲取到了blockIndex值後，會進行斷定，若是blockIndex 大於等於0的話，則會調用copyValue方法返回最終的資源內容：
jint copyValue(JNIEnv* env, jobject outValue, const ResTable* table,
const Res_value& value, uint32_t ref, ssize_t block,
uint32_t typeSpecFlags, ResTable_config* config)
{
env->SetIntField(outValue, gTypedValueOffsets.mType, value.dataType);
env->SetIntField(outValue, gTypedValueOffsets.mAssetCookie,
static_cast<jint>(table->getTableCookie(block)));
env->SetIntField(outValue, gTypedValueOffsets.mData, value.data);
env->SetObjectField(outValue, gTypedValueOffsets.mString, NULL);
env->SetIntField(outValue, gTypedValueOffsets.mResourceId, ref);
env->SetIntField(outValue, gTypedValueOffsets.mChangingConfigurations,
typeSpecFlags);
if (config != NULL) {
env->SetIntField(outValue, gTypedValueOffsets.mDensity, config->density);
}
return block;
}
複製代碼
接下來咱們能夠回到getDrawableForDensity方法了，在分析完ResourcesImpl的getValueForDensity方法的整個流程之後，return調用的是ResourcesImpl對象的loadDrawable方法去得到Drawable對象，根據咱們獲取到的資源內容，去根據他的type去獲取對應的drawable。
ok，到這裏咱們總算把這個過程所有理完了，上面的問題咱們也基本理通了。。。。 在理清了資源文件打包的時候是如何打包到apk裏和apk運行的時候是如何讀取資源文件的過程之後，咱們就能夠作以後的探索了，根據咱們理的整個過程，咱們怎麼樣操做下才能夠實現資源線上熱修復的功能。。。
本系列目錄： Android熱修復原理簡要介紹和學習計劃
我的微信公共帳號已上線，歡迎關注：
- 1. 經過tomcat讀取文件資源
- 2. android apk反編譯(獲取源碼，資源文件等)
- 3. 讀取資源文件
- 4. framework資源文件讀取
- 5. 資源文件讀取
- 6. 資源文件的讀取
- 7. maven工程讀取resource資源文件
- 8. Android —— 讀寫資源文件
- 9. 讀取 其餘Apk 中的資源文件
- 10. ubuntu下反編譯android apk 獲取xml文件資源文件和java文件
- 更多相關文章...
- • *.hbm.xml映射文件詳解 - Hibernate教程
- • MyBatis配置文件詳解 - MyBatis教程
- • IDEA下SpringBoot工程配置文件沒有提示
- • JDK13 GA發佈：5大特性解讀
-
每一个你不满意的现在，都有一个你没有努力的曾经。