| /* |
| * Copyright (C) 2016 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #define ATRACE_TAG ATRACE_TAG_RESOURCES |
| |
| #include "androidfw/AssetManager2.h" |
| |
| #include <algorithm> |
| #include <iterator> |
| #include <set> |
| |
| #include "android-base/logging.h" |
| #include "android-base/stringprintf.h" |
| #include "utils/ByteOrder.h" |
| #include "utils/Trace.h" |
| |
| #ifdef _WIN32 |
| #ifdef ERROR |
| #undef ERROR |
| #endif |
| #endif |
| |
| #include "androidfw/ResourceUtils.h" |
| |
| namespace android { |
| |
| struct FindEntryResult { |
| // A pointer to the resource table entry for this resource. |
| // If the size of the entry is > sizeof(ResTable_entry), it can be cast to |
| // a ResTable_map_entry and processed as a bag/map. |
| const ResTable_entry* entry; |
| |
| // The configuration for which the resulting entry was defined. This is already swapped to host |
| // endianness. |
| ResTable_config config; |
| |
| // The bitmask of configuration axis with which the resource value varies. |
| uint32_t type_flags; |
| |
| // The dynamic package ID map for the package from which this resource came from. |
| const DynamicRefTable* dynamic_ref_table; |
| |
| // The string pool reference to the type's name. This uses a different string pool than |
| // the global string pool, but this is hidden from the caller. |
| StringPoolRef type_string_ref; |
| |
| // The string pool reference to the entry's name. This uses a different string pool than |
| // the global string pool, but this is hidden from the caller. |
| StringPoolRef entry_string_ref; |
| }; |
| |
| AssetManager2::AssetManager2() { |
| memset(&configuration_, 0, sizeof(configuration_)); |
| } |
| |
| bool AssetManager2::SetApkAssets(const std::vector<const ApkAssets*>& apk_assets, |
| bool invalidate_caches) { |
| apk_assets_ = apk_assets; |
| BuildDynamicRefTable(); |
| RebuildFilterList(); |
| if (invalidate_caches) { |
| InvalidateCaches(static_cast<uint32_t>(-1)); |
| } |
| return true; |
| } |
| |
| void AssetManager2::BuildDynamicRefTable() { |
| package_groups_.clear(); |
| package_ids_.fill(0xff); |
| |
| // 0x01 is reserved for the android package. |
| int next_package_id = 0x02; |
| const size_t apk_assets_count = apk_assets_.size(); |
| for (size_t i = 0; i < apk_assets_count; i++) { |
| const LoadedArsc* loaded_arsc = apk_assets_[i]->GetLoadedArsc(); |
| |
| for (const std::unique_ptr<const LoadedPackage>& package : loaded_arsc->GetPackages()) { |
| // Get the package ID or assign one if a shared library. |
| int package_id; |
| if (package->IsDynamic()) { |
| package_id = next_package_id++; |
| } else { |
| package_id = package->GetPackageId(); |
| } |
| |
| // Add the mapping for package ID to index if not present. |
| uint8_t idx = package_ids_[package_id]; |
| if (idx == 0xff) { |
| package_ids_[package_id] = idx = static_cast<uint8_t>(package_groups_.size()); |
| package_groups_.push_back({}); |
| DynamicRefTable& ref_table = package_groups_.back().dynamic_ref_table; |
| ref_table.mAssignedPackageId = package_id; |
| ref_table.mAppAsLib = package->IsDynamic() && package->GetPackageId() == 0x7f; |
| } |
| PackageGroup* package_group = &package_groups_[idx]; |
| |
| // Add the package and to the set of packages with the same ID. |
| package_group->packages_.push_back(ConfiguredPackage{package.get(), {}}); |
| package_group->cookies_.push_back(static_cast<ApkAssetsCookie>(i)); |
| |
| // Add the package name -> build time ID mappings. |
| for (const DynamicPackageEntry& entry : package->GetDynamicPackageMap()) { |
| String16 package_name(entry.package_name.c_str(), entry.package_name.size()); |
| package_group->dynamic_ref_table.mEntries.replaceValueFor( |
| package_name, static_cast<uint8_t>(entry.package_id)); |
| } |
| } |
| } |
| |
| // Now assign the runtime IDs so that we have a build-time to runtime ID map. |
| const auto package_groups_end = package_groups_.end(); |
| for (auto iter = package_groups_.begin(); iter != package_groups_end; ++iter) { |
| const std::string& package_name = iter->packages_[0].loaded_package_->GetPackageName(); |
| for (auto iter2 = package_groups_.begin(); iter2 != package_groups_end; ++iter2) { |
| iter2->dynamic_ref_table.addMapping(String16(package_name.c_str(), package_name.size()), |
| iter->dynamic_ref_table.mAssignedPackageId); |
| } |
| } |
| } |
| |
| void AssetManager2::DumpToLog() const { |
| base::ScopedLogSeverity _log(base::INFO); |
| |
| LOG(INFO) << base::StringPrintf("AssetManager2(this=%p)", this); |
| |
| std::string list; |
| for (const auto& apk_assets : apk_assets_) { |
| base::StringAppendF(&list, "%s,", apk_assets->GetPath().c_str()); |
| } |
| LOG(INFO) << "ApkAssets: " << list; |
| |
| list = ""; |
| for (size_t i = 0; i < package_ids_.size(); i++) { |
| if (package_ids_[i] != 0xff) { |
| base::StringAppendF(&list, "%02x -> %d, ", (int)i, package_ids_[i]); |
| } |
| } |
| LOG(INFO) << "Package ID map: " << list; |
| |
| for (const auto& package_group: package_groups_) { |
| list = ""; |
| for (const auto& package : package_group.packages_) { |
| const LoadedPackage* loaded_package = package.loaded_package_; |
| base::StringAppendF(&list, "%s(%02x%s), ", loaded_package->GetPackageName().c_str(), |
| loaded_package->GetPackageId(), |
| (loaded_package->IsDynamic() ? " dynamic" : "")); |
| } |
| LOG(INFO) << base::StringPrintf("PG (%02x): ", |
| package_group.dynamic_ref_table.mAssignedPackageId) |
| << list; |
| } |
| } |
| |
| const ResStringPool* AssetManager2::GetStringPoolForCookie(ApkAssetsCookie cookie) const { |
| if (cookie < 0 || static_cast<size_t>(cookie) >= apk_assets_.size()) { |
| return nullptr; |
| } |
| return apk_assets_[cookie]->GetLoadedArsc()->GetStringPool(); |
| } |
| |
| const DynamicRefTable* AssetManager2::GetDynamicRefTableForPackage(uint32_t package_id) const { |
| if (package_id >= package_ids_.size()) { |
| return nullptr; |
| } |
| |
| const size_t idx = package_ids_[package_id]; |
| if (idx == 0xff) { |
| return nullptr; |
| } |
| return &package_groups_[idx].dynamic_ref_table; |
| } |
| |
| const DynamicRefTable* AssetManager2::GetDynamicRefTableForCookie(ApkAssetsCookie cookie) const { |
| for (const PackageGroup& package_group : package_groups_) { |
| for (const ApkAssetsCookie& package_cookie : package_group.cookies_) { |
| if (package_cookie == cookie) { |
| return &package_group.dynamic_ref_table; |
| } |
| } |
| } |
| return nullptr; |
| } |
| |
| void AssetManager2::SetConfiguration(const ResTable_config& configuration) { |
| const int diff = configuration_.diff(configuration); |
| configuration_ = configuration; |
| |
| if (diff) { |
| RebuildFilterList(); |
| InvalidateCaches(static_cast<uint32_t>(diff)); |
| } |
| } |
| |
| std::set<ResTable_config> AssetManager2::GetResourceConfigurations(bool exclude_system, |
| bool exclude_mipmap) const { |
| ATRACE_NAME("AssetManager::GetResourceConfigurations"); |
| std::set<ResTable_config> configurations; |
| for (const PackageGroup& package_group : package_groups_) { |
| for (const ConfiguredPackage& package : package_group.packages_) { |
| if (exclude_system && package.loaded_package_->IsSystem()) { |
| continue; |
| } |
| package.loaded_package_->CollectConfigurations(exclude_mipmap, &configurations); |
| } |
| } |
| return configurations; |
| } |
| |
| std::set<std::string> AssetManager2::GetResourceLocales(bool exclude_system, |
| bool merge_equivalent_languages) const { |
| ATRACE_NAME("AssetManager::GetResourceLocales"); |
| std::set<std::string> locales; |
| for (const PackageGroup& package_group : package_groups_) { |
| for (const ConfiguredPackage& package : package_group.packages_) { |
| if (exclude_system && package.loaded_package_->IsSystem()) { |
| continue; |
| } |
| package.loaded_package_->CollectLocales(merge_equivalent_languages, &locales); |
| } |
| } |
| return locales; |
| } |
| |
| std::unique_ptr<Asset> AssetManager2::Open(const std::string& filename, |
| Asset::AccessMode mode) const { |
| const std::string new_path = "assets/" + filename; |
| return OpenNonAsset(new_path, mode); |
| } |
| |
| std::unique_ptr<Asset> AssetManager2::Open(const std::string& filename, ApkAssetsCookie cookie, |
| Asset::AccessMode mode) const { |
| const std::string new_path = "assets/" + filename; |
| return OpenNonAsset(new_path, cookie, mode); |
| } |
| |
| std::unique_ptr<AssetDir> AssetManager2::OpenDir(const std::string& dirname) const { |
| ATRACE_NAME("AssetManager::OpenDir"); |
| |
| std::string full_path = "assets/" + dirname; |
| std::unique_ptr<SortedVector<AssetDir::FileInfo>> files = |
| util::make_unique<SortedVector<AssetDir::FileInfo>>(); |
| |
| // Start from the back. |
| for (auto iter = apk_assets_.rbegin(); iter != apk_assets_.rend(); ++iter) { |
| const ApkAssets* apk_assets = *iter; |
| |
| auto func = [&](const StringPiece& name, FileType type) { |
| AssetDir::FileInfo info; |
| info.setFileName(String8(name.data(), name.size())); |
| info.setFileType(type); |
| info.setSourceName(String8(apk_assets->GetPath().c_str())); |
| files->add(info); |
| }; |
| |
| if (!apk_assets->ForEachFile(full_path, func)) { |
| return {}; |
| } |
| } |
| |
| std::unique_ptr<AssetDir> asset_dir = util::make_unique<AssetDir>(); |
| asset_dir->setFileList(files.release()); |
| return asset_dir; |
| } |
| |
| // Search in reverse because that's how we used to do it and we need to preserve behaviour. |
| // This is unfortunate, because ClassLoaders delegate to the parent first, so the order |
| // is inconsistent for split APKs. |
| std::unique_ptr<Asset> AssetManager2::OpenNonAsset(const std::string& filename, |
| Asset::AccessMode mode, |
| ApkAssetsCookie* out_cookie) const { |
| for (int32_t i = apk_assets_.size() - 1; i >= 0; i--) { |
| std::unique_ptr<Asset> asset = apk_assets_[i]->Open(filename, mode); |
| if (asset) { |
| if (out_cookie != nullptr) { |
| *out_cookie = i; |
| } |
| return asset; |
| } |
| } |
| |
| if (out_cookie != nullptr) { |
| *out_cookie = kInvalidCookie; |
| } |
| return {}; |
| } |
| |
| 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 {}; |
| } |
| return apk_assets_[cookie]->Open(filename, mode); |
| } |
| |
| 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; |
| } |
| |
| if (!is_valid_resid(resid)) { |
| LOG(ERROR) << base::StringPrintf("Invalid ID 0x%08x.", resid); |
| return kInvalidCookie; |
| } |
| |
| const uint32_t package_id = get_package_id(resid); |
| const uint8_t type_idx = get_type_id(resid) - 1; |
| const uint16_t entry_idx = get_entry_id(resid); |
| |
| const uint8_t package_idx = package_ids_[package_id]; |
| if (package_idx == 0xff) { |
| LOG(ERROR) << base::StringPrintf("No package ID %02x found for ID 0x%08x.", package_id, resid); |
| return kInvalidCookie; |
| } |
| |
| 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; |
| |
| // If desired_config is the same as the set configuration, then we can use our filtered list |
| // and we don't need to match the configurations, since they already matched. |
| const bool use_fast_path = desired_config == &configuration_; |
| |
| for (size_t pi = 0; pi < package_count; pi++) { |
| const ConfiguredPackage& loaded_package_impl = package_group.packages_[pi]; |
| const LoadedPackage* loaded_package = loaded_package_impl.loaded_package_; |
| ApkAssetsCookie cookie = package_group.cookies_[pi]; |
| |
| // If the type IDs are offset in this package, we need to take that into account when searching |
| // for a type. |
| const TypeSpec* type_spec = loaded_package->GetTypeSpecByTypeIndex(type_idx); |
| if (UNLIKELY(type_spec == nullptr)) { |
| continue; |
| } |
| |
| uint16_t local_entry_idx = entry_idx; |
| |
| // If there is an IDMAP supplied with this package, translate the entry ID. |
| if (type_spec->idmap_entries != nullptr) { |
| if (!LoadedIdmap::Lookup(type_spec->idmap_entries, local_entry_idx, &local_entry_idx)) { |
| // There is no mapping, so the resource is not meant to be in this overlay package. |
| continue; |
| } |
| } |
| |
| type_flags |= type_spec->GetFlagsForEntryIndex(local_entry_idx); |
| |
| // If the package is an overlay, then even configurations that are the same MUST be chosen. |
| const bool package_is_overlay = loaded_package->IsOverlay(); |
| |
| const FilteredConfigGroup& filtered_group = loaded_package_impl.filtered_configs_[type_idx]; |
| if (use_fast_path) { |
| const std::vector<ResTable_config>& candidate_configs = filtered_group.configurations; |
| const size_t type_count = candidate_configs.size(); |
| for (uint32_t i = 0; i < type_count; i++) { |
| const ResTable_config& this_config = candidate_configs[i]; |
| |
| // We can skip calling ResTable_config::match() because we know that all candidate |
| // configurations that do NOT match have been filtered-out. |
| if ((best_config == nullptr || this_config.isBetterThan(*best_config, desired_config)) || |
| (package_is_overlay && this_config.compare(*best_config) == 0)) { |
| // The configuration matches and is better than the previous selection. |
| // Find the entry value if it exists for this configuration. |
| const ResTable_type* type_chunk = filtered_group.types[i]; |
| const uint32_t offset = LoadedPackage::GetEntryOffset(type_chunk, local_entry_idx); |
| if (offset == ResTable_type::NO_ENTRY) { |
| continue; |
| } |
| |
| best_cookie = cookie; |
| best_package = loaded_package; |
| best_type = type_chunk; |
| best_config = &this_config; |
| best_offset = offset; |
| } |
| } |
| } else { |
| // This is the slower path, which doesn't use the filtered list of configurations. |
| // Here we must read the ResTable_config from the mmapped APK, convert it to host endianness |
| // and fill in any new fields that did not exist when the APK was compiled. |
| // Furthermore when selecting configurations we can't just record the pointer to the |
| // ResTable_config, we must copy it. |
| const auto iter_end = type_spec->types + type_spec->type_count; |
| for (auto iter = type_spec->types; iter != iter_end; ++iter) { |
| ResTable_config this_config; |
| 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)) { |
| // The configuration matches and is better than the previous selection. |
| // Find the entry value if it exists for this configuration. |
| 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; |
| } |
| } |
| } |
| } |
| } |
| |
| if (UNLIKELY(best_cookie == kInvalidCookie)) { |
| return kInvalidCookie; |
| } |
| |
| const ResTable_entry* best_entry = LoadedPackage::GetEntryFromOffset(best_type, best_offset); |
| if (UNLIKELY(best_entry == nullptr)) { |
| return kInvalidCookie; |
| } |
| |
| 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; |
| } |
| |
| bool AssetManager2::GetResourceName(uint32_t resid, ResourceName* out_name) const { |
| FindEntryResult entry; |
| ApkAssetsCookie cookie = |
| FindEntry(resid, 0u /* density_override */, true /* stop_at_first_match */, &entry); |
| if (cookie == kInvalidCookie) { |
| return false; |
| } |
| |
| const LoadedPackage* package = |
| apk_assets_[cookie]->GetLoadedArsc()->GetPackageById(get_package_id(resid)); |
| if (package == nullptr) { |
| return false; |
| } |
| |
| out_name->package = package->GetPackageName().data(); |
| out_name->package_len = package->GetPackageName().size(); |
| |
| out_name->type = entry.type_string_ref.string8(&out_name->type_len); |
| out_name->type16 = nullptr; |
| if (out_name->type == nullptr) { |
| out_name->type16 = entry.type_string_ref.string16(&out_name->type_len); |
| if (out_name->type16 == nullptr) { |
| return false; |
| } |
| } |
| |
| out_name->entry = entry.entry_string_ref.string8(&out_name->entry_len); |
| out_name->entry16 = nullptr; |
| if (out_name->entry == nullptr) { |
| out_name->entry16 = entry.entry_string_ref.string16(&out_name->entry_len); |
| if (out_name->entry16 == nullptr) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| bool AssetManager2::GetResourceFlags(uint32_t resid, uint32_t* out_flags) const { |
| FindEntryResult entry; |
| ApkAssetsCookie cookie = |
| FindEntry(resid, 0u /* density_override */, false /* stop_at_first_match */, &entry); |
| if (cookie != kInvalidCookie) { |
| *out_flags = entry.type_flags; |
| return cookie; |
| } |
| return kInvalidCookie; |
| } |
| |
| 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; |
| ApkAssetsCookie cookie = |
| FindEntry(resid, density_override, false /* stop_at_first_match */, &entry); |
| if (cookie == kInvalidCookie) { |
| return kInvalidCookie; |
| } |
| |
| if (dtohs(entry.entry->flags) & ResTable_entry::FLAG_COMPLEX) { |
| if (!may_be_bag) { |
| LOG(ERROR) << base::StringPrintf("Resource %08x is a complex map type.", resid); |
| return kInvalidCookie; |
| } |
| |
| // 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; |
| } |
| |
| 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); |
| |
| // Convert the package ID to the runtime assigned package ID. |
| entry.dynamic_ref_table->lookupResourceValue(out_value); |
| |
| *out_selected_config = entry.config; |
| *out_flags = entry.type_flags; |
| return cookie; |
| } |
| |
| 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 { |
| constexpr const int kMaxIterations = 20; |
| |
| 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; |
| 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; |
| } |
| |
| const ResolvedBag* AssetManager2::GetBag(uint32_t resid) { |
| auto found_resids = std::vector<uint32_t>(); |
| return GetBag(resid, found_resids); |
| } |
| |
| const ResolvedBag* AssetManager2::GetBag(uint32_t resid, std::vector<uint32_t>& child_resids) { |
| ATRACE_NAME("AssetManager::GetBag"); |
| |
| auto cached_iter = cached_bags_.find(resid); |
| if (cached_iter != cached_bags_.end()) { |
| return cached_iter->second.get(); |
| } |
| |
| FindEntryResult entry; |
| ApkAssetsCookie cookie = |
| FindEntry(resid, 0u /* density_override */, false /* stop_at_first_match */, &entry); |
| if (cookie == kInvalidCookie) { |
| return nullptr; |
| } |
| |
| // Check that the size of the entry header is at least as big as |
| // the desired ResTable_map_entry. Also verify that the entry |
| // was intended to be a map. |
| if (dtohs(entry.entry->size) < sizeof(ResTable_map_entry) || |
| (dtohs(entry.entry->flags) & ResTable_entry::FLAG_COMPLEX) == 0) { |
| // Not a bag, nothing to do. |
| return nullptr; |
| } |
| |
| const ResTable_map_entry* map = reinterpret_cast<const ResTable_map_entry*>(entry.entry); |
| const ResTable_map* map_entry = |
| reinterpret_cast<const ResTable_map*>(reinterpret_cast<const uint8_t*>(map) + map->size); |
| const ResTable_map* const map_entry_end = map_entry + dtohl(map->count); |
| |
| // Keep track of ids that have already been seen to prevent infinite loops caused by circular |
| // dependencies between bags |
| child_resids.push_back(resid); |
| |
| uint32_t parent_resid = dtohl(map->parent.ident); |
| if (parent_resid == 0 || std::find(child_resids.begin(), child_resids.end(), parent_resid) |
| != child_resids.end()) { |
| // There is no parent or that a circular dependency exist, meaning there is nothing to |
| // inherit and we can do a simple copy of the entries in the map. |
| const size_t entry_count = map_entry_end - map_entry; |
| util::unique_cptr<ResolvedBag> new_bag{reinterpret_cast<ResolvedBag*>( |
| malloc(sizeof(ResolvedBag) + (entry_count * sizeof(ResolvedBag::Entry))))}; |
| ResolvedBag::Entry* new_entry = new_bag->entries; |
| for (; map_entry != map_entry_end; ++map_entry) { |
| uint32_t new_key = dtohl(map_entry->name.ident); |
| if (!is_internal_resid(new_key)) { |
| // Attributes, arrays, etc don't have a resource id as the name. They specify |
| // other data, which would be wrong to change via a lookup. |
| if (entry.dynamic_ref_table->lookupResourceId(&new_key) != NO_ERROR) { |
| LOG(ERROR) << base::StringPrintf("Failed to resolve key 0x%08x in bag 0x%08x.", new_key, |
| resid); |
| return nullptr; |
| } |
| } |
| new_entry->cookie = cookie; |
| new_entry->key = new_key; |
| new_entry->key_pool = nullptr; |
| new_entry->type_pool = nullptr; |
| new_entry->value.copyFrom_dtoh(map_entry->value); |
| status_t err = entry.dynamic_ref_table->lookupResourceValue(&new_entry->value); |
| if (err != NO_ERROR) { |
| LOG(ERROR) << base::StringPrintf( |
| "Failed to resolve value t=0x%02x d=0x%08x for key 0x%08x.", new_entry->value.dataType, |
| new_entry->value.data, new_key); |
| return nullptr; |
| } |
| ++new_entry; |
| } |
| new_bag->type_spec_flags = entry.type_flags; |
| new_bag->entry_count = static_cast<uint32_t>(entry_count); |
| ResolvedBag* result = new_bag.get(); |
| cached_bags_[resid] = std::move(new_bag); |
| return result; |
| } |
| |
| // In case the parent is a dynamic reference, resolve it. |
| entry.dynamic_ref_table->lookupResourceId(&parent_resid); |
| |
| // Get the parent and do a merge of the keys. |
| const ResolvedBag* parent_bag = GetBag(parent_resid, child_resids); |
| if (parent_bag == nullptr) { |
| // Failed to get the parent that should exist. |
| LOG(ERROR) << base::StringPrintf("Failed to find parent 0x%08x of bag 0x%08x.", parent_resid, |
| resid); |
| return nullptr; |
| } |
| |
| // Create the max possible entries we can make. Once we construct the bag, |
| // we will realloc to fit to size. |
| const size_t max_count = parent_bag->entry_count + dtohl(map->count); |
| util::unique_cptr<ResolvedBag> new_bag{reinterpret_cast<ResolvedBag*>( |
| malloc(sizeof(ResolvedBag) + (max_count * sizeof(ResolvedBag::Entry))))}; |
| ResolvedBag::Entry* new_entry = new_bag->entries; |
| |
| const ResolvedBag::Entry* parent_entry = parent_bag->entries; |
| const ResolvedBag::Entry* const parent_entry_end = parent_entry + parent_bag->entry_count; |
| |
| // The keys are expected to be in sorted order. Merge the two bags. |
| while (map_entry != map_entry_end && parent_entry != parent_entry_end) { |
| uint32_t child_key = dtohl(map_entry->name.ident); |
| if (!is_internal_resid(child_key)) { |
| if (entry.dynamic_ref_table->lookupResourceId(&child_key) != NO_ERROR) { |
| LOG(ERROR) << base::StringPrintf("Failed to resolve key 0x%08x in bag 0x%08x.", child_key, |
| resid); |
| return nullptr; |
| } |
| } |
| |
| if (child_key <= parent_entry->key) { |
| // Use the child key if it comes before the parent |
| // or is equal to the parent (overrides). |
| new_entry->cookie = cookie; |
| new_entry->key = child_key; |
| new_entry->key_pool = nullptr; |
| new_entry->type_pool = nullptr; |
| new_entry->value.copyFrom_dtoh(map_entry->value); |
| status_t err = entry.dynamic_ref_table->lookupResourceValue(&new_entry->value); |
| if (err != NO_ERROR) { |
| LOG(ERROR) << base::StringPrintf( |
| "Failed to resolve value t=0x%02x d=0x%08x for key 0x%08x.", new_entry->value.dataType, |
| new_entry->value.data, child_key); |
| return nullptr; |
| } |
| ++map_entry; |
| } else { |
| // Take the parent entry as-is. |
| memcpy(new_entry, parent_entry, sizeof(*new_entry)); |
| } |
| |
| if (child_key >= parent_entry->key) { |
| // Move to the next parent entry if we used it or it was overridden. |
| ++parent_entry; |
| } |
| // Increment to the next entry to fill. |
| ++new_entry; |
| } |
| |
| // Finish the child entries if they exist. |
| while (map_entry != map_entry_end) { |
| uint32_t new_key = dtohl(map_entry->name.ident); |
| if (!is_internal_resid(new_key)) { |
| if (entry.dynamic_ref_table->lookupResourceId(&new_key) != NO_ERROR) { |
| LOG(ERROR) << base::StringPrintf("Failed to resolve key 0x%08x in bag 0x%08x.", new_key, |
| resid); |
| return nullptr; |
| } |
| } |
| new_entry->cookie = cookie; |
| new_entry->key = new_key; |
| new_entry->key_pool = nullptr; |
| new_entry->type_pool = nullptr; |
| new_entry->value.copyFrom_dtoh(map_entry->value); |
| status_t err = entry.dynamic_ref_table->lookupResourceValue(&new_entry->value); |
| if (err != NO_ERROR) { |
| LOG(ERROR) << base::StringPrintf("Failed to resolve value t=0x%02x d=0x%08x for key 0x%08x.", |
| new_entry->value.dataType, new_entry->value.data, new_key); |
| return nullptr; |
| } |
| ++map_entry; |
| ++new_entry; |
| } |
| |
| // Finish the parent entries if they exist. |
| if (parent_entry != parent_entry_end) { |
| // Take the rest of the parent entries as-is. |
| const size_t num_entries_to_copy = parent_entry_end - parent_entry; |
| memcpy(new_entry, parent_entry, num_entries_to_copy * sizeof(*new_entry)); |
| new_entry += num_entries_to_copy; |
| } |
| |
| // Resize the resulting array to fit. |
| const size_t actual_count = new_entry - new_bag->entries; |
| if (actual_count != max_count) { |
| new_bag.reset(reinterpret_cast<ResolvedBag*>(realloc( |
| new_bag.release(), sizeof(ResolvedBag) + (actual_count * sizeof(ResolvedBag::Entry))))); |
| } |
| |
| // Combine flags from the parent and our own bag. |
| new_bag->type_spec_flags = entry.type_flags | parent_bag->type_spec_flags; |
| new_bag->entry_count = static_cast<uint32_t>(actual_count); |
| ResolvedBag* result = new_bag.get(); |
| cached_bags_[resid] = std::move(new_bag); |
| return result; |
| } |
| |
| static bool Utf8ToUtf16(const StringPiece& str, std::u16string* out) { |
| ssize_t len = |
| utf8_to_utf16_length(reinterpret_cast<const uint8_t*>(str.data()), str.size(), false); |
| if (len < 0) { |
| return false; |
| } |
| out->resize(static_cast<size_t>(len)); |
| utf8_to_utf16(reinterpret_cast<const uint8_t*>(str.data()), str.size(), &*out->begin(), |
| static_cast<size_t>(len + 1)); |
| return true; |
| } |
| |
| uint32_t AssetManager2::GetResourceId(const std::string& resource_name, |
| const std::string& fallback_type, |
| const std::string& fallback_package) const { |
| StringPiece package_name, type, entry; |
| if (!ExtractResourceName(resource_name, &package_name, &type, &entry)) { |
| return 0u; |
| } |
| |
| if (entry.empty()) { |
| return 0u; |
| } |
| |
| if (package_name.empty()) { |
| package_name = fallback_package; |
| } |
| |
| if (type.empty()) { |
| type = fallback_type; |
| } |
| |
| std::u16string type16; |
| if (!Utf8ToUtf16(type, &type16)) { |
| return 0u; |
| } |
| |
| std::u16string entry16; |
| if (!Utf8ToUtf16(entry, &entry16)) { |
| return 0u; |
| } |
| |
| const StringPiece16 kAttr16 = u"attr"; |
| const static std::u16string kAttrPrivate16 = u"^attr-private"; |
| |
| for (const PackageGroup& package_group : package_groups_) { |
| for (const ConfiguredPackage& package_impl : package_group.packages_) { |
| const LoadedPackage* package = package_impl.loaded_package_; |
| if (package_name != package->GetPackageName()) { |
| // All packages in the same group are expected to have the same package name. |
| break; |
| } |
| |
| uint32_t resid = package->FindEntryByName(type16, entry16); |
| if (resid == 0u && kAttr16 == type16) { |
| // Private attributes in libraries (such as the framework) are sometimes encoded |
| // under the type '^attr-private' in order to leave the ID space of public 'attr' |
| // free for future additions. Check '^attr-private' for the same name. |
| resid = package->FindEntryByName(kAttrPrivate16, entry16); |
| } |
| |
| if (resid != 0u) { |
| return fix_package_id(resid, package_group.dynamic_ref_table.mAssignedPackageId); |
| } |
| } |
| } |
| return 0u; |
| } |
| |
| void AssetManager2::RebuildFilterList() { |
| for (PackageGroup& group : package_groups_) { |
| for (ConfiguredPackage& impl : group.packages_) { |
| // Destroy it. |
| impl.filtered_configs_.~ByteBucketArray(); |
| |
| // Re-create it. |
| new (&impl.filtered_configs_) ByteBucketArray<FilteredConfigGroup>(); |
| |
| // Create the filters here. |
| impl.loaded_package_->ForEachTypeSpec([&](const TypeSpec* spec, uint8_t type_index) { |
| FilteredConfigGroup& group = impl.filtered_configs_.editItemAt(type_index); |
| const auto iter_end = spec->types + spec->type_count; |
| for (auto iter = spec->types; iter != iter_end; ++iter) { |
| ResTable_config this_config; |
| this_config.copyFromDtoH((*iter)->config); |
| if (this_config.match(configuration_)) { |
| group.configurations.push_back(this_config); |
| group.types.push_back(*iter); |
| } |
| } |
| }); |
| } |
| } |
| } |
| |
| void AssetManager2::InvalidateCaches(uint32_t diff) { |
| if (diff == 0xffffffffu) { |
| // Everything must go. |
| cached_bags_.clear(); |
| return; |
| } |
| |
| // Be more conservative with what gets purged. Only if the bag has other possible |
| // variations with respect to what changed (diff) should we remove it. |
| for (auto iter = cached_bags_.cbegin(); iter != cached_bags_.cend();) { |
| if (diff & iter->second->type_spec_flags) { |
| iter = cached_bags_.erase(iter); |
| } else { |
| ++iter; |
| } |
| } |
| } |
| |
| std::unique_ptr<Theme> AssetManager2::NewTheme() { |
| return std::unique_ptr<Theme>(new Theme(this)); |
| } |
| |
| Theme::Theme(AssetManager2* asset_manager) : asset_manager_(asset_manager) { |
| } |
| |
| Theme::~Theme() = default; |
| |
| namespace { |
| |
| struct ThemeEntry { |
| ApkAssetsCookie cookie; |
| uint32_t type_spec_flags; |
| Res_value value; |
| }; |
| |
| struct ThemeType { |
| int entry_count; |
| ThemeEntry entries[0]; |
| }; |
| |
| constexpr size_t kTypeCount = std::numeric_limits<uint8_t>::max() + 1; |
| |
| } // namespace |
| |
| struct Theme::Package { |
| // Each element of Type will be a dynamically sized object |
| // allocated to have the entries stored contiguously with the Type. |
| std::array<util::unique_cptr<ThemeType>, kTypeCount> types; |
| }; |
| |
| bool Theme::ApplyStyle(uint32_t resid, bool force) { |
| ATRACE_NAME("Theme::ApplyStyle"); |
| |
| const ResolvedBag* bag = asset_manager_->GetBag(resid); |
| if (bag == nullptr) { |
| return false; |
| } |
| |
| // Merge the flags from this style. |
| type_spec_flags_ |= bag->type_spec_flags; |
| |
| int last_type_idx = -1; |
| int last_package_idx = -1; |
| Package* last_package = nullptr; |
| ThemeType* last_type = nullptr; |
| |
| // Iterate backwards, because each bag is sorted in ascending key ID order, meaning we will only |
| // need to perform one resize per type. |
| using reverse_bag_iterator = std::reverse_iterator<const ResolvedBag::Entry*>; |
| const auto bag_iter_end = reverse_bag_iterator(begin(bag)); |
| for (auto bag_iter = reverse_bag_iterator(end(bag)); bag_iter != bag_iter_end; ++bag_iter) { |
| const uint32_t attr_resid = bag_iter->key; |
| |
| // If the resource ID passed in is not a style, the key can be some other identifier that is not |
| // a resource ID. We should fail fast instead of operating with strange resource IDs. |
| if (!is_valid_resid(attr_resid)) { |
| return false; |
| } |
| |
| // We don't use the 0-based index for the type so that we can avoid doing ID validation |
| // upon lookup. Instead, we keep space for the type ID 0 in our data structures. Since |
| // the construction of this type is guarded with a resource ID check, it will never be |
| // populated, and querying type ID 0 will always fail. |
| const int package_idx = get_package_id(attr_resid); |
| const int type_idx = get_type_id(attr_resid); |
| const int entry_idx = get_entry_id(attr_resid); |
| |
| if (last_package_idx != package_idx) { |
| std::unique_ptr<Package>& package = packages_[package_idx]; |
| if (package == nullptr) { |
| package.reset(new Package()); |
| } |
| last_package_idx = package_idx; |
| last_package = package.get(); |
| last_type_idx = -1; |
| } |
| |
| if (last_type_idx != type_idx) { |
| util::unique_cptr<ThemeType>& type = last_package->types[type_idx]; |
| if (type == nullptr) { |
| // Allocate enough memory to contain this entry_idx. Since we're iterating in reverse over |
| // a sorted list of attributes, this shouldn't be resized again during this method call. |
| type.reset(reinterpret_cast<ThemeType*>( |
| calloc(sizeof(ThemeType) + (entry_idx + 1) * sizeof(ThemeEntry), 1))); |
| type->entry_count = entry_idx + 1; |
| } else if (entry_idx >= type->entry_count) { |
| // Reallocate the memory to contain this entry_idx. Since we're iterating in reverse over |
| // a sorted list of attributes, this shouldn't be resized again during this method call. |
| const int new_count = entry_idx + 1; |
| type.reset(reinterpret_cast<ThemeType*>( |
| realloc(type.release(), sizeof(ThemeType) + (new_count * sizeof(ThemeEntry))))); |
| |
| // Clear out the newly allocated space (which isn't zeroed). |
| memset(type->entries + type->entry_count, 0, |
| (new_count - type->entry_count) * sizeof(ThemeEntry)); |
| type->entry_count = new_count; |
| } |
| last_type_idx = type_idx; |
| last_type = type.get(); |
| } |
| |
| ThemeEntry& entry = last_type->entries[entry_idx]; |
| if (force || (entry.value.dataType == Res_value::TYPE_NULL && |
| entry.value.data != Res_value::DATA_NULL_EMPTY)) { |
| entry.cookie = bag_iter->cookie; |
| entry.type_spec_flags |= bag->type_spec_flags; |
| entry.value = bag_iter->value; |
| } |
| } |
| return true; |
| } |
| |
| ApkAssetsCookie Theme::GetAttribute(uint32_t resid, Res_value* out_value, |
| uint32_t* out_flags) const { |
| int cnt = 20; |
| |
| uint32_t type_spec_flags = 0u; |
| |
| do { |
| const int package_idx = get_package_id(resid); |
| const Package* package = packages_[package_idx].get(); |
| if (package != nullptr) { |
| // The themes are constructed with a 1-based type ID, so no need to decrement here. |
| const int type_idx = get_type_id(resid); |
| const ThemeType* type = package->types[type_idx].get(); |
| if (type != nullptr) { |
| const int entry_idx = get_entry_id(resid); |
| if (entry_idx < type->entry_count) { |
| const ThemeEntry& entry = type->entries[entry_idx]; |
| type_spec_flags |= entry.type_spec_flags; |
| |
| if (entry.value.dataType == Res_value::TYPE_ATTRIBUTE) { |
| if (cnt > 0) { |
| cnt--; |
| resid = entry.value.data; |
| continue; |
| } |
| return kInvalidCookie; |
| } |
| |
| // @null is different than @empty. |
| if (entry.value.dataType == Res_value::TYPE_NULL && |
| entry.value.data != Res_value::DATA_NULL_EMPTY) { |
| return kInvalidCookie; |
| } |
| |
| *out_value = entry.value; |
| *out_flags = type_spec_flags; |
| return entry.cookie; |
| } |
| } |
| } |
| break; |
| } while (true); |
| return kInvalidCookie; |
| } |
| |
| ApkAssetsCookie Theme::ResolveAttributeReference(ApkAssetsCookie cookie, Res_value* in_out_value, |
| ResTable_config* in_out_selected_config, |
| uint32_t* in_out_type_spec_flags, |
| uint32_t* out_last_ref) const { |
| if (in_out_value->dataType == Res_value::TYPE_ATTRIBUTE) { |
| uint32_t new_flags; |
| cookie = GetAttribute(in_out_value->data, in_out_value, &new_flags); |
| if (cookie == kInvalidCookie) { |
| return kInvalidCookie; |
| } |
| |
| if (in_out_type_spec_flags != nullptr) { |
| *in_out_type_spec_flags |= new_flags; |
| } |
| } |
| return asset_manager_->ResolveReference(cookie, in_out_value, in_out_selected_config, |
| in_out_type_spec_flags, out_last_ref); |
| } |
| |
| void Theme::Clear() { |
| type_spec_flags_ = 0u; |
| for (std::unique_ptr<Package>& package : packages_) { |
| package.reset(); |
| } |
| } |
| |
| bool Theme::SetTo(const Theme& o) { |
| if (this == &o) { |
| return true; |
| } |
| |
| type_spec_flags_ = o.type_spec_flags_; |
| |
| const bool copy_only_system = asset_manager_ != o.asset_manager_; |
| |
| for (size_t p = 0; p < packages_.size(); p++) { |
| const Package* package = o.packages_[p].get(); |
| if (package == nullptr || (copy_only_system && p != 0x01)) { |
| // The other theme doesn't have this package, clear ours. |
| packages_[p].reset(); |
| continue; |
| } |
| |
| if (packages_[p] == nullptr) { |
| // The other theme has this package, but we don't. Make one. |
| packages_[p].reset(new Package()); |
| } |
| |
| for (size_t t = 0; t < package->types.size(); t++) { |
| const ThemeType* type = package->types[t].get(); |
| if (type == nullptr) { |
| // The other theme doesn't have this type, clear ours. |
| packages_[p]->types[t].reset(); |
| continue; |
| } |
| |
| // Create a new type and update it to theirs. |
| const size_t type_alloc_size = sizeof(ThemeType) + (type->entry_count * sizeof(ThemeEntry)); |
| void* copied_data = malloc(type_alloc_size); |
| memcpy(copied_data, type, type_alloc_size); |
| packages_[p]->types[t].reset(reinterpret_cast<ThemeType*>(copied_data)); |
| } |
| } |
| return true; |
| } |
| |
| } // namespace android |
