Android 系统架构 —— 资源的查找与打开

// frameworks/base/core/jni/android_util_AssetManager.cpp
static jint NativeGetResourceValue(JNIEnv* env, jclass /*clazz*/, jlong ptr, jint resid,
                                   jshort density, jobject typed_value,
                                   jboolean resolve_references) {
  // 获取 Native 实现对象 AssetManager2
  ScopedLock<AssetManager2> assetmanager(AssetManagerFromLong(ptr));
  Res_value value;
  ResTable_config selected_config;
  uint32_t flags;
  // 1. 调用 AssetManager2.GetResource, 获取这个 resid 对应的资源数据
  ApkAssetsCookie cookie =
      assetmanager->GetResource(static_cast<uint32_t>(resid), false /*may_be_bag*/,
                                static_cast<uint16_t>(density), &value, &selected_config, &flags);
  ......
  uint32_t ref = static_cast<uint32_t>(resid);
  // 2. 解析资源引用, 由之前的传参可知, 这里为 true
  if (resolve_references) {
    cookie = assetmanager->ResolveReference(cookie, &value, &selected_config, &flags, &ref);
    ......
  }
  // 3. 将解析到的资源数据注入到 typed_value 中
  return CopyValue(env, cookie, value, ref, flags, &selected_config, typed_value);
}

// frameworks/base/libs/androidfw/AssetManager2.cpp
ApkAssetsCookie AssetManager2::GetResource(uint32_t resid, bool may_be_bag,
                                           uint16_t density_override, Res_value* out_value,
                                           ResTable_config* out_selected_config,
                                           uint32_t* out_flags) const {
  FindEntryResult entry;
  
  // 1. 调用 FindEntry 函数, 找寻 resid 的资源, 保存在 FindEntryResult 中
  ApkAssetsCookie cookie =
      FindEntry(resid, density_override, false /* stop_at_first_match */, &entry);
  
  ......
  // 2. 若为复杂的资源, 则保存资源的引用
  if (dtohs(entry.entry->flags) & ResTable_entry::FLAG_COMPLEX) {
    ......
    // Create a reference since we can't represent this complex type as a Res_value.
    out_value->dataType = Res_value::TYPE_REFERENCE;
    out_value->data = resid;
    // 保存资源记录的条目
    *out_selected_config = entry.config;
    *out_flags = entry.type_flags;
    return cookie;
  }
  
  // 3. 若为 values 类型的资源, 则将数据直接注入到 out_value 中
  const Res_value* device_value = reinterpret_cast<const Res_value*>(
      reinterpret_cast<const uint8_t*>(entry.entry) + dtohs(entry.entry->size));
  out_value->copyFrom_dtoh(*device_value);
  
  ......
  
  return cookie;
}

// frameworks/base/libs/androidfw/AssetManager2.cpp
ApkAssetsCookie AssetManager2::FindEntry(uint32_t resid, uint16_t density_override,
                                         bool /*stop_at_first_match*/,
                                         FindEntryResult* out_entry) const {
  
  // Might use this if density_override != 0.
  ResTable_config density_override_config;

  // Select our configuration or generate a density override configuration.
  const ResTable_config* desired_config = &configuration_;
  if (density_override != 0 && density_override != configuration_.density) {
    density_override_config = configuration_;
    density_override_config.density = density_override;
    desired_config = &density_override_config;
  }
  ......
  const uint32_t package_id = get_package_id(resid); // 获取运行时 packageId
  const uint8_t type_idx = get_type_id(resid) - 1;   // 获取资源的类型 ID
  const uint16_t entry_idx = get_entry_id(resid);    // 获取资源的数据项 ID
  
  // 1. 根据运行时 package_id 找到它在 package_groups_ 中的索引位置 package_idx
  const uint8_t package_idx = package_ids_[package_id];
  ......
  // 2. 获取运行时 ID 对应的 PackageGroup
  const PackageGroup& package_group = package_groups_[package_idx];
  
  const size_t package_count = package_group.packages_.size();

  ApkAssetsCookie best_cookie = kInvalidCookie;
  const LoadedPackage* best_package = nullptr;
  const ResTable_type* best_type = nullptr;
  const ResTable_config* best_config = nullptr;
  ResTable_config best_config_copy;
  uint32_t best_offset = 0u;
  uint32_t type_flags = 0u;
  
  ......

  // 从 PacakgeGroup 中的资源包 LoadedPackage 中获取数据
  for (size_t pi = 0; pi < package_count; pi++) {
    const ConfiguredPackage& loaded_package_impl = package_group.packages_[pi];
    
    // 3. 获取 LoadedPackage 对象
    const LoadedPackage* loaded_package = loaded_package_impl.loaded_package_;
    
    ApkAssetsCookie cookie = package_group.cookies_[pi];

    // 4. 从 LoadedPackage 中通过 type_idx 获取资源类型对象 TypeSpec
    const TypeSpec* type_spec = loaded_package->GetTypeSpecByTypeIndex(type_idx);
    ......

    uint16_t local_entry_idx = entry_idx;
    
    ......
    
    // 5. 查找资源
    // 5.1 从 FilteredConfigGroup 缓存查找资源
    if (use_fast_path) {
    
      ...... // 暂不关心
      
    } 
    // 5.2 从 type_spec 中查找资源
    else {
      const auto iter_end = type_spec->types + type_spec->type_count;
      // 5.2.1 遍历 TypeSpec 中的资源项 ResTable_type
      for (auto iter = type_spec->types; iter != iter_end; ++iter) {
        // 5.2.2 获取资源项配置信息
        ResTable_config this_config;
        
        // 5.2.3 验证是否与期望配置项匹配
        this_config.copyFromDtoH((*iter)->config);
        if (this_config.match(*desired_config)) {
        
          if ((best_config == nullptr || this_config.isBetterThan(*best_config, desired_config)) ||
              (package_is_overlay && this_config.compare(*best_config) == 0)) {
              
            // 5.2.4 根据 local_entry_idx 找到资源值的偏移量
            const uint32_t offset = LoadedPackage::GetEntryOffset(*iter, local_entry_idx);
            
            if (offset == ResTable_type::NO_ENTRY) {
              continue;
            }
            
            // 记录资源值相关信息
            best_cookie = cookie;
            // 记录资源包
            best_package = loaded_package;
            // 记录资源项对象
            best_type = *iter;
            // 记录配置信息
            best_config_copy = this_config;
            best_config = &best_config_copy;
            // 记录偏移量
            best_offset = offset;
          }
          
        }
      }
    }
  }
   
  ......
  
  // 6. 根据 资源项 和 资源值偏移量 找到资源值
  const ResTable_entry* best_entry = LoadedPackage::GetEntryFromOffset(best_type, best_offset);
  
  ......
  
  // 7. 保存到 out_entry 中
  out_entry->entry = best_entry;
  out_entry->config = *best_config;
  out_entry->type_flags = type_flags;
  // 注入资源类型的字符串引用
  out_entry->type_string_ref = StringPoolRef(best_package->GetTypeStringPool(), best_type->id - 1);
  // 注入资源项值的字符串引用
  out_entry->entry_string_ref =
      StringPoolRef(best_package->GetKeyStringPool(), best_entry->key.index);
  out_entry->dynamic_ref_table = &package_group.dynamic_ref_table;
  return best_cookie;
}

// frameworks/base/libs/androidfw/AssetManager2.cpp
ApkAssetsCookie AssetManager2::ResolveReference(ApkAssetsCookie cookie, Res_value* in_out_value,
                                                ResTable_config* in_out_selected_config,
                                                uint32_t* in_out_flags,
                                                uint32_t* out_last_reference) const {
  // 最大查找次数为 20 层
  constexpr const int kMaxIterations = 20;
  // 判断当前解析到的资源 in_out_value 的类型是否为 TYPE_REFERENCE
  for (size_t iteration = 0u; in_out_value->dataType == Res_value::TYPE_REFERENCE&&
                              in_out_value->data != 0u && iteration < kMaxIterations;
       iteration++) {
    // 获取引用
    *out_last_reference = in_out_value->data;
    uint32_t new_flags = 0u;
    // 再次调用 GetResource 解析资源的引用
    cookie = GetResource(in_out_value->data, true /*may_be_bag*/, 0u /*density_override*/,
                         in_out_value, in_out_selected_config, &new_flags);
    if (cookie == kInvalidCookie) {
      return kInvalidCookie;
    }
    if (in_out_flags != nullptr) {
      *in_out_flags |= new_flags;
    }
    if (*out_last_reference == in_out_value->data) {
      // This reference can't be resolved, so exit now and let the caller deal with it.
      return cookie;
    }
  }
  return cookie;
}

// frameworks/base/core/jni/android_util_AssetManager.cpp
static jint CopyValue(JNIEnv* env, ApkAssetsCookie cookie, const Res_value& value, uint32_t ref,
                      uint32_t type_spec_flags, ResTable_config* config, jobject out_typed_value) {
  // 拷贝数据类型
  env->SetIntField(out_typed_value, gTypedValueOffsets.mType, value.dataType);
  // 拷贝 cookie, 即 packageId 的索引
  env->SetIntField(out_typed_value, gTypedValueOffsets.mAssetCookie,
                   ApkAssetsCookieToJavaCookie(cookie));
  // 给 mData 属性赋值
  env->SetIntField(out_typed_value, gTypedValueOffsets.mData, value.data);
  // 给 mString 赋值, 始终为 null
  env->SetObjectField(out_typed_value, gTypedValueOffsets.mString, nullptr);
  // 给 mResourceId 赋值
  env->SetIntField(out_typed_value, gTypedValueOffsets.mResourceId, ref);
  // 给 mChangingConfigurations 赋值
  env->SetIntField(out_typed_value, gTypedValueOffsets.mChangingConfigurations, type_spec_flags);
  if (config != nullptr) {
    // 给 mDensity 赋值
    env->SetIntField(out_typed_value, gTypedValueOffsets.mDensity, config->density);
  }
  return static_cast<jint>(ApkAssetsCookieToJavaCookie(cookie));
}

public final class ApkAssets {
    
    @GuardedBy("this") private StringBlock mStringBlock;

    CharSequence getStringFromPool(int idx) {
        synchronized (this) {
            return mStringBlock.get(idx);
        }
    }
    
}

final class StringBlock {
    
    private final long mNative;
    private CharSequence[] mStrings;
    private SparseArray<CharSequence> mSparseStrings;
    
    public CharSequence get(int idx) {
        synchronized (this) {
            // 1. 从缓存获取
            if (mStrings != null) {
                // 直接从 mStirngs 中根据 id index 获取
                CharSequence res = mStrings[idx];
                if (res != null) {
                    return res;
                }
            } else if (mSparseStrings != null) {
                // 通过 mSparseStrings 获取
                CharSequence res = mSparseStrings.get(idx);
                if (res != null) {
                    return res;
                }
            } 
            // 1.1 若缓存不存在, 则构建缓存
            else {
                // 获取 Native 层字符串池的大小
                final int num = nativeGetSize(mNative);
                if (mUseSparse && num > 250) {
                    // 超过 250 使用 SparseArray 存储
                    mSparseStrings = new SparseArray<CharSequence>();
                } else {
                    // 低于 250 使用 String 暂存
                    mStrings = new CharSequence[num];
                }
            }
            
            // 2. 从 native 层根据 idx 查找字符串
            String str = nativeGetString(mNative, idx);
            CharSequence res = str;
            
            
            .......// 对 style 进行特殊处理
            
            // 3. 缓存数据
            // 缓存到 mStrings 中
            if (mStrings != null) {
                mStrings[idx] = res;
            }
            // 缓存到 mSparseStrings 中
            else {
                mSparseStrings.put(idx, res);
            }
            return res;
        }
    }
}

public class ResourcesImpl {

    XmlResourceParser loadXmlResourceParser(@NonNull String file, @AnyRes int id, int assetCookie,
            @NonNull String type)
            throws NotFoundException {
        if (id != 0) {
            try {
                synchronized (mCachedXmlBlocks) {
                    // 1. 从缓存中查找
                    final int[] cachedXmlBlockCookies = mCachedXmlBlockCookies;
                    final String[] cachedXmlBlockFiles = mCachedXmlBlockFiles;
                    final XmlBlock[] cachedXmlBlocks = mCachedXmlBlocks;
                    // First see if this block is in our cache.
                    final int num = cachedXmlBlockFiles.length;
                    for (int i = 0; i < num; i++) {
                        if (cachedXmlBlockCookies[i] == assetCookie && cachedXmlBlockFiles[i] != null
                                && cachedXmlBlockFiles[i].equals(file)) {
                            return cachedXmlBlocks[i].newParser();
                        }
                    }

                    // 2. 使用 AssetsManager 来打开 Xml 文件
                    final XmlBlock block = mAssets.openXmlBlockAsset(assetCookie, file);
                    if (block != null) {
                        // 2.1 添加到缓存
                        final int pos = (mLastCachedXmlBlockIndex + 1) % num;
                        mLastCachedXmlBlockIndex = pos;
                        final XmlBlock oldBlock = cachedXmlBlocks[pos];
                        if (oldBlock != null) {
                            oldBlock.close();
                        }
                        cachedXmlBlockCookies[pos] = assetCookie;
                        cachedXmlBlockFiles[pos] = file;
                        cachedXmlBlocks[pos] = block;
                        // 3. 创建一个 XmlResourceParser 对象
                        return block.newParser();
                    }
                }
            } catch (Exception e) {
                ......
                throw rnf;
            }
        }
        ......
    }

}

final class XmlBlock implements AutoCloseable {

    private final long mNative;

    
    public XmlResourceParser newParser() {
        synchronized (this) {
            if (mNative != 0) {
                return new Parser(nativeCreateParseState(mNative), this);
            }
            return null;
        }
    }
    
    final class Parser implements XmlResourceParser {
    
        Parser(long parseState, XmlBlock block) {
            mParseState = parseState;
            mBlock = block;
            block.mOpenCount++;
        }
        
    }
    
}

public final class AssetManager implements AutoCloseable {

    @NonNull XmlBlock openXmlBlockAsset(int cookie, @NonNull String fileName) throws IOException {
        ......
        synchronized (this) {
            ......
            // 1. 调用 nativeOpenXmlAsset 在 native 层执行打开操作
            final long xmlBlock = nativeOpenXmlAsset(mObject, cookie, fileName);
            if (xmlBlock == 0) {
                throw new FileNotFoundException("Asset XML file: " + fileName);
            }
            // 2. 创建 Java 层的 XmlBlock
            final XmlBlock block = new XmlBlock(this, xmlBlock);
            ......
            return block;
        }
    }
}

// frameworks/base/core/jni/android_util_AssetManager.cpp
static jlong NativeOpenXmlAsset(JNIEnv* env, jobject /*clazz*/, jlong ptr, jint jcookie,
                                jstring asset_path) {
  ApkAssetsCookie cookie = JavaCookieToApkAssetsCookie(jcookie);
  ......
  ScopedLock<AssetManager2> assetmanager(AssetManagerFromLong(ptr));
  std::unique_ptr<Asset> asset;
  if (cookie != kInvalidCookie) {
    // 1. AssetManager2.OpenNonAsset 打开 XML 资源文件 
    asset = assetmanager->OpenNonAsset(asset_path_utf8.c_str(), cookie, Asset::ACCESS_RANDOM);
  } else {
    ......
  }
  ......
  // 获取 cookie 对应 PacakgeGroup 的动态引用表
  const DynamicRefTable* dynamic_ref_table = assetmanager->GetDynamicRefTableForCookie(cookie);
  // 创建 ResXMLTree 对象
  std::unique_ptr<ResXMLTree> xml_tree = util::make_unique<ResXMLTree>(dynamic_ref_table);
  // 2. 将打开的 Asset 中的 XML 资源数据注入到 ResXMLTree 中
  status_t err = xml_tree->setTo(asset->getBuffer(true), asset->getLength(), true);
  ......
  // 5. 返回到 Java 层
  return reinterpret_cast<jlong>(xml_tree.release());
}

// frameworks/base/libs/androidfw/include/androidfw/AssetManager2.h
std::unique_ptr<Asset> AssetManager2::OpenNonAsset(const std::string& filename,
                                                   ApkAssetsCookie cookie,
                                                   Asset::AccessMode mode) const {
  if (cookie < 0 || static_cast<size_t>(cookie) >= apk_assets_.size()) {
    return {};
  }
  // 根据 cookie 找到对应的 ApkAssets, 调用 ApkAssets 的 Open 打开 XML 文件
  return apk_assets_[cookie]->Open(filename, mode);
}

// frameworks/base/libs/androidfw/ApkAssets.cpp
std::unique_ptr<Asset> ApkAssets::Open(const std::string& path, Asset::AccessMode mode) const {
  CHECK(zip_handle_ != nullptr);
  ::ZipString name(path.c_str());
  ::ZipEntry entry;
  // 1. 从 .apk 压缩包中查找 path 对应的文件
  int32_t result = ::FindEntry(zip_handle_.get(), name, &entry);
  if (result != 0) {
    // 不存在则返回空对象
    return {};
  }
  // 2. 从 .apk 文件中, 将我们要找寻的文件提取出来
  // 2.1 提取压缩的问题
  if (entry.method == kCompressDeflated) {
    // 通过 FileMap, 将我们的文件提取到内存
    std::unique_ptr<FileMap> map = util::make_unique<FileMap>();
    if (!map->create(path_.c_str(), ::GetFileDescriptor(zip_handle_.get()), entry.offset,
                     entry.compressed_length, true /*readOnly*/)) {
      ......
    }
    // 通过 Asset::createFromCompressedMap 创建 Asset 对象
    std::unique_ptr<Asset> asset =
        Asset::createFromCompressedMap(std::move(map), entry.uncompressed_length, mode);
    ......
    return asset;
  } 
  // 2.2 打开未压缩的文件
  else {
    // 通过 FileMap 将文件 mmap 到内存
    std::unique_ptr<FileMap> map = util::make_unique<FileMap>();
    if (!map->create(path_.c_str(), ::GetFileDescriptor(zip_handle_.get()), entry.offset,
                     entry.uncompressed_length, true /*readOnly*/)) {
      ......
      return {};
    }
    // 创建 Asset 对象
    std::unique_ptr<Asset> asset = Asset::createFromUncompressedMap(std::move(map), mode);
    if (asset == nullptr) {
      ......
      return {};
    }
    return asset;
  }
}

/ frameworks/base/libs/androidfw/ResourceTypes.cpp
status_t ResXMLTree::setTo(const void* data, size_t size, bool copyData)
{
    uninit();
    mEventCode = START_DOCUMENT;

    if (!data || !size) {
        return (mError=BAD_TYPE);
    }

    if (copyData) {
        // 开辟一块内存
        mOwnedData = malloc(size);
        if (mOwnedData == NULL) {
            return (mError=NO_MEMORY);
        }
        // 将 data 拷贝到 mOwnedData
        memcpy(mOwnedData, data, size);
        data = mOwnedData;
    }

    mHeader = (const ResXMLTree_header*)data;
    mSize = dtohl(mHeader->header.size);
    if (dtohs(mHeader->header.headerSize) > mSize || mSize > size) {
        ......
        mError = BAD_TYPE;
        restart();
        return mError;
    }
    mDataEnd = ((const uint8_t*)mHeader) + mSize;

    mStrings.uninit();
    mRootNode = NULL;
    mResIds = NULL;
    mNumResIds = 0;

    // First look for a couple interesting chunks: the string block
    // and first XML node.
    const ResChunk_header* chunk =
        (const ResChunk_header*)(((const uint8_t*)mHeader) + dtohs(mHeader->header.headerSize));
        
    const ResChunk_header* lastChunk = chunk;
    while (((const uint8_t*)chunk) < (mDataEnd-sizeof(ResChunk_header)) &&
           ((const uint8_t*)chunk) < (mDataEnd-dtohl(chunk->size))) {
        status_t err = validate_chunk(chunk, sizeof(ResChunk_header), mDataEnd, "XML");
        if (err != NO_ERROR) {
            mError = err;
            goto done;
        }
        const uint16_t type = dtohs(chunk->type);
        const size_t size = dtohl(chunk->size);
        ......
        if (type == RES_STRING_POOL_TYPE) {
            // 解析 XML 中的 String 池
            mStrings.setTo(chunk, size);
        } else if (type == RES_XML_RESOURCE_MAP_TYPE) {
            // 解析 XML 中的 ID 池
            mResIds = (const uint32_t*)
                (((const uint8_t*)chunk)+dtohs(chunk->headerSize));
            mNumResIds = (dtohl(chunk->size)-dtohs(chunk->headerSize))/sizeof(uint32_t);
        } else if (type >= RES_XML_FIRST_CHUNK_TYPE
                   && type <= RES_XML_LAST_CHUNK_TYPE) {
            if (validateNode((const ResXMLTree_node*)chunk) != NO_ERROR) {
                mError = BAD_TYPE;
                goto done;
            }
            mCurNode = (const ResXMLTree_node*)lastChunk;
            if (nextNode() == BAD_DOCUMENT) {
                mError = BAD_TYPE;
                goto done;
            }
            mRootNode = mCurNode;
            mRootExt = mCurExt;
            mRootCode = mEventCode;
            break;
        } else {
           ......
        }
        lastChunk = chunk;
        chunk = (const ResChunk_header*)
            (((const uint8_t*)chunk) + size);
    }

    if (mRootNode == NULL) {
        ......
        mError = BAD_TYPE;
        goto done;
    }

    mError = mStrings.getError();

done:
    restart();
    return mError;
}