blob: 9c1629bc36f58761b3d999b184abd976ea639ae8 [file] [log] [blame]
Adam Lesinski7ad11102016-10-28 16:39:15 -07001/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define ATRACE_TAG ATRACE_TAG_RESOURCES
18
19#include "androidfw/AssetManager2.h"
20
y57cd1952018-04-12 14:26:23 -070021#include <algorithm>
Adam Lesinski30080e22017-10-16 16:18:09 -070022#include <iterator>
Adam Lesinski0c405242017-01-13 20:47:26 -080023#include <set>
24
Adam Lesinski7ad11102016-10-28 16:39:15 -070025#include "android-base/logging.h"
26#include "android-base/stringprintf.h"
27#include "utils/ByteOrder.h"
28#include "utils/Trace.h"
29
30#ifdef _WIN32
31#ifdef ERROR
32#undef ERROR
33#endif
34#endif
35
Adam Lesinski929d6512017-01-16 19:11:19 -080036#include "androidfw/ResourceUtils.h"
37
Adam Lesinski7ad11102016-10-28 16:39:15 -070038namespace android {
39
Adam Lesinskibebfcc42018-02-12 14:27:46 -080040struct FindEntryResult {
41 // A pointer to the resource table entry for this resource.
42 // If the size of the entry is > sizeof(ResTable_entry), it can be cast to
43 // a ResTable_map_entry and processed as a bag/map.
44 const ResTable_entry* entry;
45
46 // The configuration for which the resulting entry was defined. This is already swapped to host
47 // endianness.
48 ResTable_config config;
49
50 // The bitmask of configuration axis with which the resource value varies.
51 uint32_t type_flags;
52
53 // The dynamic package ID map for the package from which this resource came from.
54 const DynamicRefTable* dynamic_ref_table;
55
56 // The string pool reference to the type's name. This uses a different string pool than
57 // the global string pool, but this is hidden from the caller.
58 StringPoolRef type_string_ref;
59
60 // The string pool reference to the entry's name. This uses a different string pool than
61 // the global string pool, but this is hidden from the caller.
62 StringPoolRef entry_string_ref;
63};
64
Adam Lesinski970bd8d2017-09-25 13:21:55 -070065AssetManager2::AssetManager2() {
66 memset(&configuration_, 0, sizeof(configuration_));
67}
Adam Lesinski7ad11102016-10-28 16:39:15 -070068
69bool AssetManager2::SetApkAssets(const std::vector<const ApkAssets*>& apk_assets,
70 bool invalidate_caches) {
71 apk_assets_ = apk_assets;
Adam Lesinskida431a22016-12-29 16:08:16 -050072 BuildDynamicRefTable();
Adam Lesinskibebfcc42018-02-12 14:27:46 -080073 RebuildFilterList();
Adam Lesinski7ad11102016-10-28 16:39:15 -070074 if (invalidate_caches) {
75 InvalidateCaches(static_cast<uint32_t>(-1));
76 }
77 return true;
78}
79
Adam Lesinskida431a22016-12-29 16:08:16 -050080void AssetManager2::BuildDynamicRefTable() {
81 package_groups_.clear();
82 package_ids_.fill(0xff);
83
84 // 0x01 is reserved for the android package.
85 int next_package_id = 0x02;
86 const size_t apk_assets_count = apk_assets_.size();
87 for (size_t i = 0; i < apk_assets_count; i++) {
Adam Lesinski970bd8d2017-09-25 13:21:55 -070088 const LoadedArsc* loaded_arsc = apk_assets_[i]->GetLoadedArsc();
89
90 for (const std::unique_ptr<const LoadedPackage>& package : loaded_arsc->GetPackages()) {
Adam Lesinskida431a22016-12-29 16:08:16 -050091 // Get the package ID or assign one if a shared library.
92 int package_id;
93 if (package->IsDynamic()) {
94 package_id = next_package_id++;
95 } else {
96 package_id = package->GetPackageId();
97 }
98
99 // Add the mapping for package ID to index if not present.
100 uint8_t idx = package_ids_[package_id];
101 if (idx == 0xff) {
102 package_ids_[package_id] = idx = static_cast<uint8_t>(package_groups_.size());
103 package_groups_.push_back({});
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800104 DynamicRefTable& ref_table = package_groups_.back().dynamic_ref_table;
105 ref_table.mAssignedPackageId = package_id;
106 ref_table.mAppAsLib = package->IsDynamic() && package->GetPackageId() == 0x7f;
Adam Lesinskida431a22016-12-29 16:08:16 -0500107 }
108 PackageGroup* package_group = &package_groups_[idx];
109
110 // Add the package and to the set of packages with the same ID.
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800111 package_group->packages_.push_back(ConfiguredPackage{package.get(), {}});
Adam Lesinskida431a22016-12-29 16:08:16 -0500112 package_group->cookies_.push_back(static_cast<ApkAssetsCookie>(i));
113
114 // Add the package name -> build time ID mappings.
115 for (const DynamicPackageEntry& entry : package->GetDynamicPackageMap()) {
116 String16 package_name(entry.package_name.c_str(), entry.package_name.size());
117 package_group->dynamic_ref_table.mEntries.replaceValueFor(
118 package_name, static_cast<uint8_t>(entry.package_id));
119 }
120 }
121 }
122
123 // Now assign the runtime IDs so that we have a build-time to runtime ID map.
124 const auto package_groups_end = package_groups_.end();
125 for (auto iter = package_groups_.begin(); iter != package_groups_end; ++iter) {
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800126 const std::string& package_name = iter->packages_[0].loaded_package_->GetPackageName();
Adam Lesinskida431a22016-12-29 16:08:16 -0500127 for (auto iter2 = package_groups_.begin(); iter2 != package_groups_end; ++iter2) {
128 iter2->dynamic_ref_table.addMapping(String16(package_name.c_str(), package_name.size()),
129 iter->dynamic_ref_table.mAssignedPackageId);
130 }
131 }
132}
133
134void AssetManager2::DumpToLog() const {
135 base::ScopedLogSeverity _log(base::INFO);
136
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800137 LOG(INFO) << base::StringPrintf("AssetManager2(this=%p)", this);
138
Adam Lesinskida431a22016-12-29 16:08:16 -0500139 std::string list;
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800140 for (const auto& apk_assets : apk_assets_) {
141 base::StringAppendF(&list, "%s,", apk_assets->GetPath().c_str());
142 }
143 LOG(INFO) << "ApkAssets: " << list;
144
145 list = "";
Adam Lesinskida431a22016-12-29 16:08:16 -0500146 for (size_t i = 0; i < package_ids_.size(); i++) {
147 if (package_ids_[i] != 0xff) {
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800148 base::StringAppendF(&list, "%02x -> %d, ", (int)i, package_ids_[i]);
Adam Lesinskida431a22016-12-29 16:08:16 -0500149 }
150 }
151 LOG(INFO) << "Package ID map: " << list;
152
Adam Lesinski0dd36992018-01-25 15:38:38 -0800153 for (const auto& package_group: package_groups_) {
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800154 list = "";
155 for (const auto& package : package_group.packages_) {
156 const LoadedPackage* loaded_package = package.loaded_package_;
157 base::StringAppendF(&list, "%s(%02x%s), ", loaded_package->GetPackageName().c_str(),
158 loaded_package->GetPackageId(),
159 (loaded_package->IsDynamic() ? " dynamic" : ""));
160 }
161 LOG(INFO) << base::StringPrintf("PG (%02x): ",
162 package_group.dynamic_ref_table.mAssignedPackageId)
163 << list;
Adam Lesinskida431a22016-12-29 16:08:16 -0500164 }
165}
Adam Lesinski7ad11102016-10-28 16:39:15 -0700166
167const ResStringPool* AssetManager2::GetStringPoolForCookie(ApkAssetsCookie cookie) const {
168 if (cookie < 0 || static_cast<size_t>(cookie) >= apk_assets_.size()) {
169 return nullptr;
170 }
171 return apk_assets_[cookie]->GetLoadedArsc()->GetStringPool();
172}
173
Adam Lesinskida431a22016-12-29 16:08:16 -0500174const DynamicRefTable* AssetManager2::GetDynamicRefTableForPackage(uint32_t package_id) const {
175 if (package_id >= package_ids_.size()) {
176 return nullptr;
177 }
178
179 const size_t idx = package_ids_[package_id];
180 if (idx == 0xff) {
181 return nullptr;
182 }
183 return &package_groups_[idx].dynamic_ref_table;
184}
185
Adam Lesinskid1ecd7a2017-01-23 12:58:11 -0800186const DynamicRefTable* AssetManager2::GetDynamicRefTableForCookie(ApkAssetsCookie cookie) const {
187 for (const PackageGroup& package_group : package_groups_) {
188 for (const ApkAssetsCookie& package_cookie : package_group.cookies_) {
189 if (package_cookie == cookie) {
190 return &package_group.dynamic_ref_table;
191 }
192 }
193 }
194 return nullptr;
195}
196
Adam Lesinski7ad11102016-10-28 16:39:15 -0700197void AssetManager2::SetConfiguration(const ResTable_config& configuration) {
198 const int diff = configuration_.diff(configuration);
199 configuration_ = configuration;
200
201 if (diff) {
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800202 RebuildFilterList();
Adam Lesinski7ad11102016-10-28 16:39:15 -0700203 InvalidateCaches(static_cast<uint32_t>(diff));
204 }
205}
206
Adam Lesinski0c405242017-01-13 20:47:26 -0800207std::set<ResTable_config> AssetManager2::GetResourceConfigurations(bool exclude_system,
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800208 bool exclude_mipmap) const {
209 ATRACE_NAME("AssetManager::GetResourceConfigurations");
Adam Lesinski0c405242017-01-13 20:47:26 -0800210 std::set<ResTable_config> configurations;
211 for (const PackageGroup& package_group : package_groups_) {
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800212 for (const ConfiguredPackage& package : package_group.packages_) {
213 if (exclude_system && package.loaded_package_->IsSystem()) {
Adam Lesinski0c405242017-01-13 20:47:26 -0800214 continue;
215 }
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800216 package.loaded_package_->CollectConfigurations(exclude_mipmap, &configurations);
Adam Lesinski0c405242017-01-13 20:47:26 -0800217 }
218 }
219 return configurations;
220}
221
222std::set<std::string> AssetManager2::GetResourceLocales(bool exclude_system,
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800223 bool merge_equivalent_languages) const {
224 ATRACE_NAME("AssetManager::GetResourceLocales");
Adam Lesinski0c405242017-01-13 20:47:26 -0800225 std::set<std::string> locales;
226 for (const PackageGroup& package_group : package_groups_) {
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800227 for (const ConfiguredPackage& package : package_group.packages_) {
228 if (exclude_system && package.loaded_package_->IsSystem()) {
Adam Lesinski0c405242017-01-13 20:47:26 -0800229 continue;
230 }
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800231 package.loaded_package_->CollectLocales(merge_equivalent_languages, &locales);
Adam Lesinski0c405242017-01-13 20:47:26 -0800232 }
233 }
234 return locales;
235}
236
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800237std::unique_ptr<Asset> AssetManager2::Open(const std::string& filename,
238 Asset::AccessMode mode) const {
Adam Lesinski7ad11102016-10-28 16:39:15 -0700239 const std::string new_path = "assets/" + filename;
240 return OpenNonAsset(new_path, mode);
241}
242
243std::unique_ptr<Asset> AssetManager2::Open(const std::string& filename, ApkAssetsCookie cookie,
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800244 Asset::AccessMode mode) const {
Adam Lesinski7ad11102016-10-28 16:39:15 -0700245 const std::string new_path = "assets/" + filename;
246 return OpenNonAsset(new_path, cookie, mode);
247}
248
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800249std::unique_ptr<AssetDir> AssetManager2::OpenDir(const std::string& dirname) const {
250 ATRACE_NAME("AssetManager::OpenDir");
Adam Lesinskid1ecd7a2017-01-23 12:58:11 -0800251
252 std::string full_path = "assets/" + dirname;
253 std::unique_ptr<SortedVector<AssetDir::FileInfo>> files =
254 util::make_unique<SortedVector<AssetDir::FileInfo>>();
255
256 // Start from the back.
257 for (auto iter = apk_assets_.rbegin(); iter != apk_assets_.rend(); ++iter) {
258 const ApkAssets* apk_assets = *iter;
259
260 auto func = [&](const StringPiece& name, FileType type) {
261 AssetDir::FileInfo info;
262 info.setFileName(String8(name.data(), name.size()));
263 info.setFileType(type);
264 info.setSourceName(String8(apk_assets->GetPath().c_str()));
265 files->add(info);
266 };
267
268 if (!apk_assets->ForEachFile(full_path, func)) {
269 return {};
270 }
271 }
272
273 std::unique_ptr<AssetDir> asset_dir = util::make_unique<AssetDir>();
274 asset_dir->setFileList(files.release());
275 return asset_dir;
276}
277
Adam Lesinski7ad11102016-10-28 16:39:15 -0700278// Search in reverse because that's how we used to do it and we need to preserve behaviour.
279// This is unfortunate, because ClassLoaders delegate to the parent first, so the order
280// is inconsistent for split APKs.
281std::unique_ptr<Asset> AssetManager2::OpenNonAsset(const std::string& filename,
282 Asset::AccessMode mode,
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800283 ApkAssetsCookie* out_cookie) const {
Adam Lesinski7ad11102016-10-28 16:39:15 -0700284 for (int32_t i = apk_assets_.size() - 1; i >= 0; i--) {
285 std::unique_ptr<Asset> asset = apk_assets_[i]->Open(filename, mode);
286 if (asset) {
287 if (out_cookie != nullptr) {
288 *out_cookie = i;
289 }
290 return asset;
291 }
292 }
293
294 if (out_cookie != nullptr) {
295 *out_cookie = kInvalidCookie;
296 }
297 return {};
298}
299
300std::unique_ptr<Asset> AssetManager2::OpenNonAsset(const std::string& filename,
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800301 ApkAssetsCookie cookie,
302 Asset::AccessMode mode) const {
Adam Lesinski7ad11102016-10-28 16:39:15 -0700303 if (cookie < 0 || static_cast<size_t>(cookie) >= apk_assets_.size()) {
304 return {};
305 }
306 return apk_assets_[cookie]->Open(filename, mode);
307}
308
309ApkAssetsCookie AssetManager2::FindEntry(uint32_t resid, uint16_t density_override,
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800310 bool /*stop_at_first_match*/,
311 FindEntryResult* out_entry) const {
Adam Lesinski7ad11102016-10-28 16:39:15 -0700312 // Might use this if density_override != 0.
313 ResTable_config density_override_config;
314
315 // Select our configuration or generate a density override configuration.
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800316 const ResTable_config* desired_config = &configuration_;
Adam Lesinski7ad11102016-10-28 16:39:15 -0700317 if (density_override != 0 && density_override != configuration_.density) {
318 density_override_config = configuration_;
319 density_override_config.density = density_override;
320 desired_config = &density_override_config;
321 }
322
Adam Lesinskid1ecd7a2017-01-23 12:58:11 -0800323 if (!is_valid_resid(resid)) {
Adam Lesinskida431a22016-12-29 16:08:16 -0500324 LOG(ERROR) << base::StringPrintf("Invalid ID 0x%08x.", resid);
325 return kInvalidCookie;
326 }
327
Adam Lesinskid1ecd7a2017-01-23 12:58:11 -0800328 const uint32_t package_id = get_package_id(resid);
329 const uint8_t type_idx = get_type_id(resid) - 1;
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800330 const uint16_t entry_idx = get_entry_id(resid);
Adam Lesinskid1ecd7a2017-01-23 12:58:11 -0800331
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800332 const uint8_t package_idx = package_ids_[package_id];
333 if (package_idx == 0xff) {
Adam Lesinskida431a22016-12-29 16:08:16 -0500334 LOG(ERROR) << base::StringPrintf("No package ID %02x found for ID 0x%08x.", package_id, resid);
335 return kInvalidCookie;
336 }
337
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800338 const PackageGroup& package_group = package_groups_[package_idx];
Adam Lesinskib8b3a262018-02-09 11:01:45 -0800339 const size_t package_count = package_group.packages_.size();
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800340
341 ApkAssetsCookie best_cookie = kInvalidCookie;
342 const LoadedPackage* best_package = nullptr;
343 const ResTable_type* best_type = nullptr;
344 const ResTable_config* best_config = nullptr;
345 ResTable_config best_config_copy;
346 uint32_t best_offset = 0u;
347 uint32_t type_flags = 0u;
348
349 // If desired_config is the same as the set configuration, then we can use our filtered list
350 // and we don't need to match the configurations, since they already matched.
351 const bool use_fast_path = desired_config == &configuration_;
352
353 for (size_t pi = 0; pi < package_count; pi++) {
354 const ConfiguredPackage& loaded_package_impl = package_group.packages_[pi];
355 const LoadedPackage* loaded_package = loaded_package_impl.loaded_package_;
356 ApkAssetsCookie cookie = package_group.cookies_[pi];
357
358 // If the type IDs are offset in this package, we need to take that into account when searching
359 // for a type.
360 const TypeSpec* type_spec = loaded_package->GetTypeSpecByTypeIndex(type_idx);
361 if (UNLIKELY(type_spec == nullptr)) {
Adam Lesinski7ad11102016-10-28 16:39:15 -0700362 continue;
363 }
364
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800365 uint16_t local_entry_idx = entry_idx;
Adam Lesinski7ad11102016-10-28 16:39:15 -0700366
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800367 // If there is an IDMAP supplied with this package, translate the entry ID.
368 if (type_spec->idmap_entries != nullptr) {
369 if (!LoadedIdmap::Lookup(type_spec->idmap_entries, local_entry_idx, &local_entry_idx)) {
370 // There is no mapping, so the resource is not meant to be in this overlay package.
371 continue;
372 }
373 }
374
375 type_flags |= type_spec->GetFlagsForEntryIndex(local_entry_idx);
376
377 // If the package is an overlay, then even configurations that are the same MUST be chosen.
378 const bool package_is_overlay = loaded_package->IsOverlay();
379
380 const FilteredConfigGroup& filtered_group = loaded_package_impl.filtered_configs_[type_idx];
381 if (use_fast_path) {
382 const std::vector<ResTable_config>& candidate_configs = filtered_group.configurations;
383 const size_t type_count = candidate_configs.size();
384 for (uint32_t i = 0; i < type_count; i++) {
385 const ResTable_config& this_config = candidate_configs[i];
386
387 // We can skip calling ResTable_config::match() because we know that all candidate
388 // configurations that do NOT match have been filtered-out.
389 if ((best_config == nullptr || this_config.isBetterThan(*best_config, desired_config)) ||
390 (package_is_overlay && this_config.compare(*best_config) == 0)) {
391 // The configuration matches and is better than the previous selection.
392 // Find the entry value if it exists for this configuration.
393 const ResTable_type* type_chunk = filtered_group.types[i];
394 const uint32_t offset = LoadedPackage::GetEntryOffset(type_chunk, local_entry_idx);
395 if (offset == ResTable_type::NO_ENTRY) {
396 continue;
397 }
398
399 best_cookie = cookie;
400 best_package = loaded_package;
401 best_type = type_chunk;
402 best_config = &this_config;
403 best_offset = offset;
404 }
405 }
406 } else {
407 // This is the slower path, which doesn't use the filtered list of configurations.
408 // Here we must read the ResTable_config from the mmapped APK, convert it to host endianness
409 // and fill in any new fields that did not exist when the APK was compiled.
410 // Furthermore when selecting configurations we can't just record the pointer to the
411 // ResTable_config, we must copy it.
412 const auto iter_end = type_spec->types + type_spec->type_count;
413 for (auto iter = type_spec->types; iter != iter_end; ++iter) {
414 ResTable_config this_config;
415 this_config.copyFromDtoH((*iter)->config);
416
417 if (this_config.match(*desired_config)) {
418 if ((best_config == nullptr || this_config.isBetterThan(*best_config, desired_config)) ||
419 (package_is_overlay && this_config.compare(*best_config) == 0)) {
420 // The configuration matches and is better than the previous selection.
421 // Find the entry value if it exists for this configuration.
422 const uint32_t offset = LoadedPackage::GetEntryOffset(*iter, local_entry_idx);
423 if (offset == ResTable_type::NO_ENTRY) {
424 continue;
425 }
426
427 best_cookie = cookie;
428 best_package = loaded_package;
429 best_type = *iter;
430 best_config_copy = this_config;
431 best_config = &best_config_copy;
432 best_offset = offset;
433 }
434 }
Adam Lesinski7ad11102016-10-28 16:39:15 -0700435 }
436 }
437 }
438
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800439 if (UNLIKELY(best_cookie == kInvalidCookie)) {
Adam Lesinski7ad11102016-10-28 16:39:15 -0700440 return kInvalidCookie;
441 }
442
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800443 const ResTable_entry* best_entry = LoadedPackage::GetEntryFromOffset(best_type, best_offset);
444 if (UNLIKELY(best_entry == nullptr)) {
445 return kInvalidCookie;
446 }
447
448 out_entry->entry = best_entry;
449 out_entry->config = *best_config;
450 out_entry->type_flags = type_flags;
451 out_entry->type_string_ref = StringPoolRef(best_package->GetTypeStringPool(), best_type->id - 1);
452 out_entry->entry_string_ref =
453 StringPoolRef(best_package->GetKeyStringPool(), best_entry->key.index);
Adam Lesinskida431a22016-12-29 16:08:16 -0500454 out_entry->dynamic_ref_table = &package_group.dynamic_ref_table;
Adam Lesinskida431a22016-12-29 16:08:16 -0500455 return best_cookie;
Adam Lesinski7ad11102016-10-28 16:39:15 -0700456}
457
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800458bool AssetManager2::GetResourceName(uint32_t resid, ResourceName* out_name) const {
Adam Lesinski1a1e9c22017-10-13 15:45:34 -0700459 FindEntryResult entry;
460 ApkAssetsCookie cookie =
461 FindEntry(resid, 0u /* density_override */, true /* stop_at_first_match */, &entry);
Adam Lesinski7ad11102016-10-28 16:39:15 -0700462 if (cookie == kInvalidCookie) {
463 return false;
464 }
465
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800466 const LoadedPackage* package =
467 apk_assets_[cookie]->GetLoadedArsc()->GetPackageById(get_package_id(resid));
Adam Lesinskida431a22016-12-29 16:08:16 -0500468 if (package == nullptr) {
Adam Lesinski7ad11102016-10-28 16:39:15 -0700469 return false;
470 }
471
Adam Lesinskida431a22016-12-29 16:08:16 -0500472 out_name->package = package->GetPackageName().data();
473 out_name->package_len = package->GetPackageName().size();
Adam Lesinski7ad11102016-10-28 16:39:15 -0700474
475 out_name->type = entry.type_string_ref.string8(&out_name->type_len);
476 out_name->type16 = nullptr;
477 if (out_name->type == nullptr) {
478 out_name->type16 = entry.type_string_ref.string16(&out_name->type_len);
479 if (out_name->type16 == nullptr) {
480 return false;
481 }
482 }
483
484 out_name->entry = entry.entry_string_ref.string8(&out_name->entry_len);
485 out_name->entry16 = nullptr;
486 if (out_name->entry == nullptr) {
487 out_name->entry16 = entry.entry_string_ref.string16(&out_name->entry_len);
488 if (out_name->entry16 == nullptr) {
489 return false;
490 }
491 }
492 return true;
493}
494
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800495bool AssetManager2::GetResourceFlags(uint32_t resid, uint32_t* out_flags) const {
Adam Lesinski1a1e9c22017-10-13 15:45:34 -0700496 FindEntryResult entry;
497 ApkAssetsCookie cookie =
498 FindEntry(resid, 0u /* density_override */, false /* stop_at_first_match */, &entry);
499 if (cookie != kInvalidCookie) {
500 *out_flags = entry.type_flags;
501 return cookie;
502 }
503 return kInvalidCookie;
Adam Lesinski7ad11102016-10-28 16:39:15 -0700504}
505
506ApkAssetsCookie AssetManager2::GetResource(uint32_t resid, bool may_be_bag,
507 uint16_t density_override, Res_value* out_value,
508 ResTable_config* out_selected_config,
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800509 uint32_t* out_flags) const {
Adam Lesinski1a1e9c22017-10-13 15:45:34 -0700510 FindEntryResult entry;
Adam Lesinski7ad11102016-10-28 16:39:15 -0700511 ApkAssetsCookie cookie =
Adam Lesinski1a1e9c22017-10-13 15:45:34 -0700512 FindEntry(resid, density_override, false /* stop_at_first_match */, &entry);
Adam Lesinski7ad11102016-10-28 16:39:15 -0700513 if (cookie == kInvalidCookie) {
514 return kInvalidCookie;
515 }
516
Adam Lesinski498f6052017-11-29 13:24:29 -0800517 if (dtohs(entry.entry->flags) & ResTable_entry::FLAG_COMPLEX) {
Adam Lesinski7ad11102016-10-28 16:39:15 -0700518 if (!may_be_bag) {
519 LOG(ERROR) << base::StringPrintf("Resource %08x is a complex map type.", resid);
Adam Lesinski0c405242017-01-13 20:47:26 -0800520 return kInvalidCookie;
Adam Lesinski7ad11102016-10-28 16:39:15 -0700521 }
Adam Lesinski0c405242017-01-13 20:47:26 -0800522
523 // Create a reference since we can't represent this complex type as a Res_value.
524 out_value->dataType = Res_value::TYPE_REFERENCE;
525 out_value->data = resid;
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800526 *out_selected_config = entry.config;
Adam Lesinski1a1e9c22017-10-13 15:45:34 -0700527 *out_flags = entry.type_flags;
Adam Lesinski0c405242017-01-13 20:47:26 -0800528 return cookie;
Adam Lesinski7ad11102016-10-28 16:39:15 -0700529 }
530
531 const Res_value* device_value = reinterpret_cast<const Res_value*>(
532 reinterpret_cast<const uint8_t*>(entry.entry) + dtohs(entry.entry->size));
533 out_value->copyFrom_dtoh(*device_value);
Adam Lesinskida431a22016-12-29 16:08:16 -0500534
535 // Convert the package ID to the runtime assigned package ID.
536 entry.dynamic_ref_table->lookupResourceValue(out_value);
537
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800538 *out_selected_config = entry.config;
Adam Lesinski1a1e9c22017-10-13 15:45:34 -0700539 *out_flags = entry.type_flags;
Adam Lesinski7ad11102016-10-28 16:39:15 -0700540 return cookie;
541}
542
Adam Lesinski0c405242017-01-13 20:47:26 -0800543ApkAssetsCookie AssetManager2::ResolveReference(ApkAssetsCookie cookie, Res_value* in_out_value,
544 ResTable_config* in_out_selected_config,
545 uint32_t* in_out_flags,
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800546 uint32_t* out_last_reference) const {
Adam Lesinski0c405242017-01-13 20:47:26 -0800547 constexpr const int kMaxIterations = 20;
548
Adam Lesinski0c405242017-01-13 20:47:26 -0800549 for (size_t iteration = 0u; in_out_value->dataType == Res_value::TYPE_REFERENCE &&
550 in_out_value->data != 0u && iteration < kMaxIterations;
551 iteration++) {
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800552 *out_last_reference = in_out_value->data;
Adam Lesinski0c405242017-01-13 20:47:26 -0800553 uint32_t new_flags = 0u;
554 cookie = GetResource(in_out_value->data, true /*may_be_bag*/, 0u /*density_override*/,
555 in_out_value, in_out_selected_config, &new_flags);
556 if (cookie == kInvalidCookie) {
557 return kInvalidCookie;
558 }
559 if (in_out_flags != nullptr) {
560 *in_out_flags |= new_flags;
561 }
Adam Lesinskid1ecd7a2017-01-23 12:58:11 -0800562 if (*out_last_reference == in_out_value->data) {
Adam Lesinski0c405242017-01-13 20:47:26 -0800563 // This reference can't be resolved, so exit now and let the caller deal with it.
564 return cookie;
565 }
566 }
567 return cookie;
568}
569
Adam Lesinski7ad11102016-10-28 16:39:15 -0700570const ResolvedBag* AssetManager2::GetBag(uint32_t resid) {
y57cd1952018-04-12 14:26:23 -0700571 auto found_resids = std::vector<uint32_t>();
572 return GetBag(resid, found_resids);
573}
574
575const ResolvedBag* AssetManager2::GetBag(uint32_t resid, std::vector<uint32_t>& child_resids) {
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800576 ATRACE_NAME("AssetManager::GetBag");
Adam Lesinski7ad11102016-10-28 16:39:15 -0700577
578 auto cached_iter = cached_bags_.find(resid);
579 if (cached_iter != cached_bags_.end()) {
580 return cached_iter->second.get();
581 }
582
Adam Lesinski1a1e9c22017-10-13 15:45:34 -0700583 FindEntryResult entry;
584 ApkAssetsCookie cookie =
585 FindEntry(resid, 0u /* density_override */, false /* stop_at_first_match */, &entry);
Adam Lesinski7ad11102016-10-28 16:39:15 -0700586 if (cookie == kInvalidCookie) {
587 return nullptr;
588 }
589
590 // Check that the size of the entry header is at least as big as
591 // the desired ResTable_map_entry. Also verify that the entry
592 // was intended to be a map.
593 if (dtohs(entry.entry->size) < sizeof(ResTable_map_entry) ||
594 (dtohs(entry.entry->flags) & ResTable_entry::FLAG_COMPLEX) == 0) {
595 // Not a bag, nothing to do.
596 return nullptr;
597 }
598
599 const ResTable_map_entry* map = reinterpret_cast<const ResTable_map_entry*>(entry.entry);
600 const ResTable_map* map_entry =
601 reinterpret_cast<const ResTable_map*>(reinterpret_cast<const uint8_t*>(map) + map->size);
602 const ResTable_map* const map_entry_end = map_entry + dtohl(map->count);
603
y57cd1952018-04-12 14:26:23 -0700604 // Keep track of ids that have already been seen to prevent infinite loops caused by circular
605 // dependencies between bags
606 child_resids.push_back(resid);
607
Adam Lesinskida431a22016-12-29 16:08:16 -0500608 uint32_t parent_resid = dtohl(map->parent.ident);
y57cd1952018-04-12 14:26:23 -0700609 if (parent_resid == 0 || std::find(child_resids.begin(), child_resids.end(), parent_resid)
610 != child_resids.end()) {
611 // There is no parent or that a circular dependency exist, meaning there is nothing to
612 // inherit and we can do a simple copy of the entries in the map.
Adam Lesinski7ad11102016-10-28 16:39:15 -0700613 const size_t entry_count = map_entry_end - map_entry;
614 util::unique_cptr<ResolvedBag> new_bag{reinterpret_cast<ResolvedBag*>(
615 malloc(sizeof(ResolvedBag) + (entry_count * sizeof(ResolvedBag::Entry))))};
616 ResolvedBag::Entry* new_entry = new_bag->entries;
617 for (; map_entry != map_entry_end; ++map_entry) {
Adam Lesinskida431a22016-12-29 16:08:16 -0500618 uint32_t new_key = dtohl(map_entry->name.ident);
Adam Lesinski929d6512017-01-16 19:11:19 -0800619 if (!is_internal_resid(new_key)) {
Adam Lesinskida431a22016-12-29 16:08:16 -0500620 // Attributes, arrays, etc don't have a resource id as the name. They specify
621 // other data, which would be wrong to change via a lookup.
622 if (entry.dynamic_ref_table->lookupResourceId(&new_key) != NO_ERROR) {
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800623 LOG(ERROR) << base::StringPrintf("Failed to resolve key 0x%08x in bag 0x%08x.", new_key,
624 resid);
Adam Lesinskida431a22016-12-29 16:08:16 -0500625 return nullptr;
626 }
627 }
Adam Lesinski7ad11102016-10-28 16:39:15 -0700628 new_entry->cookie = cookie;
Adam Lesinskida431a22016-12-29 16:08:16 -0500629 new_entry->key = new_key;
Adam Lesinski7ad11102016-10-28 16:39:15 -0700630 new_entry->key_pool = nullptr;
631 new_entry->type_pool = nullptr;
Adam Lesinski30080e22017-10-16 16:18:09 -0700632 new_entry->value.copyFrom_dtoh(map_entry->value);
633 status_t err = entry.dynamic_ref_table->lookupResourceValue(&new_entry->value);
634 if (err != NO_ERROR) {
635 LOG(ERROR) << base::StringPrintf(
636 "Failed to resolve value t=0x%02x d=0x%08x for key 0x%08x.", new_entry->value.dataType,
637 new_entry->value.data, new_key);
638 return nullptr;
639 }
Adam Lesinski7ad11102016-10-28 16:39:15 -0700640 ++new_entry;
641 }
Adam Lesinski1a1e9c22017-10-13 15:45:34 -0700642 new_bag->type_spec_flags = entry.type_flags;
Adam Lesinski7ad11102016-10-28 16:39:15 -0700643 new_bag->entry_count = static_cast<uint32_t>(entry_count);
644 ResolvedBag* result = new_bag.get();
645 cached_bags_[resid] = std::move(new_bag);
646 return result;
647 }
648
Adam Lesinskida431a22016-12-29 16:08:16 -0500649 // In case the parent is a dynamic reference, resolve it.
650 entry.dynamic_ref_table->lookupResourceId(&parent_resid);
651
Adam Lesinski7ad11102016-10-28 16:39:15 -0700652 // Get the parent and do a merge of the keys.
y57cd1952018-04-12 14:26:23 -0700653 const ResolvedBag* parent_bag = GetBag(parent_resid, child_resids);
Adam Lesinski7ad11102016-10-28 16:39:15 -0700654 if (parent_bag == nullptr) {
655 // Failed to get the parent that should exist.
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800656 LOG(ERROR) << base::StringPrintf("Failed to find parent 0x%08x of bag 0x%08x.", parent_resid,
657 resid);
Adam Lesinski7ad11102016-10-28 16:39:15 -0700658 return nullptr;
659 }
660
Adam Lesinski7ad11102016-10-28 16:39:15 -0700661 // Create the max possible entries we can make. Once we construct the bag,
662 // we will realloc to fit to size.
663 const size_t max_count = parent_bag->entry_count + dtohl(map->count);
George Burgess IV09b119f2017-07-25 15:00:04 -0700664 util::unique_cptr<ResolvedBag> new_bag{reinterpret_cast<ResolvedBag*>(
665 malloc(sizeof(ResolvedBag) + (max_count * sizeof(ResolvedBag::Entry))))};
Adam Lesinski7ad11102016-10-28 16:39:15 -0700666 ResolvedBag::Entry* new_entry = new_bag->entries;
667
668 const ResolvedBag::Entry* parent_entry = parent_bag->entries;
669 const ResolvedBag::Entry* const parent_entry_end = parent_entry + parent_bag->entry_count;
670
671 // The keys are expected to be in sorted order. Merge the two bags.
672 while (map_entry != map_entry_end && parent_entry != parent_entry_end) {
Adam Lesinskida431a22016-12-29 16:08:16 -0500673 uint32_t child_key = dtohl(map_entry->name.ident);
Adam Lesinski929d6512017-01-16 19:11:19 -0800674 if (!is_internal_resid(child_key)) {
Adam Lesinskida431a22016-12-29 16:08:16 -0500675 if (entry.dynamic_ref_table->lookupResourceId(&child_key) != NO_ERROR) {
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800676 LOG(ERROR) << base::StringPrintf("Failed to resolve key 0x%08x in bag 0x%08x.", child_key,
677 resid);
Adam Lesinskida431a22016-12-29 16:08:16 -0500678 return nullptr;
679 }
680 }
681
Adam Lesinski7ad11102016-10-28 16:39:15 -0700682 if (child_key <= parent_entry->key) {
683 // Use the child key if it comes before the parent
684 // or is equal to the parent (overrides).
685 new_entry->cookie = cookie;
Adam Lesinski7ad11102016-10-28 16:39:15 -0700686 new_entry->key = child_key;
687 new_entry->key_pool = nullptr;
688 new_entry->type_pool = nullptr;
Adam Lesinski30080e22017-10-16 16:18:09 -0700689 new_entry->value.copyFrom_dtoh(map_entry->value);
690 status_t err = entry.dynamic_ref_table->lookupResourceValue(&new_entry->value);
691 if (err != NO_ERROR) {
692 LOG(ERROR) << base::StringPrintf(
693 "Failed to resolve value t=0x%02x d=0x%08x for key 0x%08x.", new_entry->value.dataType,
694 new_entry->value.data, child_key);
695 return nullptr;
696 }
Adam Lesinski7ad11102016-10-28 16:39:15 -0700697 ++map_entry;
698 } else {
699 // Take the parent entry as-is.
700 memcpy(new_entry, parent_entry, sizeof(*new_entry));
701 }
702
703 if (child_key >= parent_entry->key) {
704 // Move to the next parent entry if we used it or it was overridden.
705 ++parent_entry;
706 }
707 // Increment to the next entry to fill.
708 ++new_entry;
709 }
710
711 // Finish the child entries if they exist.
712 while (map_entry != map_entry_end) {
Adam Lesinskida431a22016-12-29 16:08:16 -0500713 uint32_t new_key = dtohl(map_entry->name.ident);
Adam Lesinski929d6512017-01-16 19:11:19 -0800714 if (!is_internal_resid(new_key)) {
Adam Lesinskida431a22016-12-29 16:08:16 -0500715 if (entry.dynamic_ref_table->lookupResourceId(&new_key) != NO_ERROR) {
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800716 LOG(ERROR) << base::StringPrintf("Failed to resolve key 0x%08x in bag 0x%08x.", new_key,
717 resid);
Adam Lesinskida431a22016-12-29 16:08:16 -0500718 return nullptr;
719 }
720 }
Adam Lesinski7ad11102016-10-28 16:39:15 -0700721 new_entry->cookie = cookie;
Adam Lesinskida431a22016-12-29 16:08:16 -0500722 new_entry->key = new_key;
Adam Lesinski7ad11102016-10-28 16:39:15 -0700723 new_entry->key_pool = nullptr;
724 new_entry->type_pool = nullptr;
Adam Lesinski30080e22017-10-16 16:18:09 -0700725 new_entry->value.copyFrom_dtoh(map_entry->value);
726 status_t err = entry.dynamic_ref_table->lookupResourceValue(&new_entry->value);
727 if (err != NO_ERROR) {
728 LOG(ERROR) << base::StringPrintf("Failed to resolve value t=0x%02x d=0x%08x for key 0x%08x.",
729 new_entry->value.dataType, new_entry->value.data, new_key);
730 return nullptr;
731 }
Adam Lesinski7ad11102016-10-28 16:39:15 -0700732 ++map_entry;
733 ++new_entry;
734 }
735
736 // Finish the parent entries if they exist.
737 if (parent_entry != parent_entry_end) {
738 // Take the rest of the parent entries as-is.
739 const size_t num_entries_to_copy = parent_entry_end - parent_entry;
740 memcpy(new_entry, parent_entry, num_entries_to_copy * sizeof(*new_entry));
741 new_entry += num_entries_to_copy;
742 }
743
744 // Resize the resulting array to fit.
745 const size_t actual_count = new_entry - new_bag->entries;
746 if (actual_count != max_count) {
George Burgess IV09b119f2017-07-25 15:00:04 -0700747 new_bag.reset(reinterpret_cast<ResolvedBag*>(realloc(
748 new_bag.release(), sizeof(ResolvedBag) + (actual_count * sizeof(ResolvedBag::Entry)))));
Adam Lesinski7ad11102016-10-28 16:39:15 -0700749 }
750
Adam Lesinski1a1e9c22017-10-13 15:45:34 -0700751 // Combine flags from the parent and our own bag.
752 new_bag->type_spec_flags = entry.type_flags | parent_bag->type_spec_flags;
George Burgess IV09b119f2017-07-25 15:00:04 -0700753 new_bag->entry_count = static_cast<uint32_t>(actual_count);
754 ResolvedBag* result = new_bag.get();
755 cached_bags_[resid] = std::move(new_bag);
Adam Lesinski7ad11102016-10-28 16:39:15 -0700756 return result;
757}
758
Adam Lesinski929d6512017-01-16 19:11:19 -0800759static bool Utf8ToUtf16(const StringPiece& str, std::u16string* out) {
760 ssize_t len =
761 utf8_to_utf16_length(reinterpret_cast<const uint8_t*>(str.data()), str.size(), false);
762 if (len < 0) {
763 return false;
764 }
765 out->resize(static_cast<size_t>(len));
766 utf8_to_utf16(reinterpret_cast<const uint8_t*>(str.data()), str.size(), &*out->begin(),
767 static_cast<size_t>(len + 1));
768 return true;
769}
770
Adam Lesinski0c405242017-01-13 20:47:26 -0800771uint32_t AssetManager2::GetResourceId(const std::string& resource_name,
772 const std::string& fallback_type,
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800773 const std::string& fallback_package) const {
Adam Lesinski929d6512017-01-16 19:11:19 -0800774 StringPiece package_name, type, entry;
775 if (!ExtractResourceName(resource_name, &package_name, &type, &entry)) {
776 return 0u;
777 }
778
779 if (entry.empty()) {
780 return 0u;
781 }
782
783 if (package_name.empty()) {
784 package_name = fallback_package;
785 }
786
787 if (type.empty()) {
788 type = fallback_type;
789 }
790
791 std::u16string type16;
792 if (!Utf8ToUtf16(type, &type16)) {
793 return 0u;
794 }
795
796 std::u16string entry16;
797 if (!Utf8ToUtf16(entry, &entry16)) {
798 return 0u;
799 }
800
801 const StringPiece16 kAttr16 = u"attr";
802 const static std::u16string kAttrPrivate16 = u"^attr-private";
803
804 for (const PackageGroup& package_group : package_groups_) {
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800805 for (const ConfiguredPackage& package_impl : package_group.packages_) {
806 const LoadedPackage* package = package_impl.loaded_package_;
Adam Lesinski929d6512017-01-16 19:11:19 -0800807 if (package_name != package->GetPackageName()) {
808 // All packages in the same group are expected to have the same package name.
809 break;
810 }
811
812 uint32_t resid = package->FindEntryByName(type16, entry16);
813 if (resid == 0u && kAttr16 == type16) {
814 // Private attributes in libraries (such as the framework) are sometimes encoded
815 // under the type '^attr-private' in order to leave the ID space of public 'attr'
816 // free for future additions. Check '^attr-private' for the same name.
817 resid = package->FindEntryByName(kAttrPrivate16, entry16);
818 }
819
820 if (resid != 0u) {
821 return fix_package_id(resid, package_group.dynamic_ref_table.mAssignedPackageId);
822 }
823 }
824 }
Adam Lesinski0c405242017-01-13 20:47:26 -0800825 return 0u;
826}
827
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800828void AssetManager2::RebuildFilterList() {
829 for (PackageGroup& group : package_groups_) {
830 for (ConfiguredPackage& impl : group.packages_) {
831 // Destroy it.
832 impl.filtered_configs_.~ByteBucketArray();
833
834 // Re-create it.
835 new (&impl.filtered_configs_) ByteBucketArray<FilteredConfigGroup>();
836
837 // Create the filters here.
838 impl.loaded_package_->ForEachTypeSpec([&](const TypeSpec* spec, uint8_t type_index) {
839 FilteredConfigGroup& group = impl.filtered_configs_.editItemAt(type_index);
840 const auto iter_end = spec->types + spec->type_count;
841 for (auto iter = spec->types; iter != iter_end; ++iter) {
842 ResTable_config this_config;
843 this_config.copyFromDtoH((*iter)->config);
844 if (this_config.match(configuration_)) {
845 group.configurations.push_back(this_config);
846 group.types.push_back(*iter);
847 }
848 }
849 });
850 }
851 }
852}
853
Adam Lesinski7ad11102016-10-28 16:39:15 -0700854void AssetManager2::InvalidateCaches(uint32_t diff) {
855 if (diff == 0xffffffffu) {
856 // Everything must go.
857 cached_bags_.clear();
858 return;
859 }
860
861 // Be more conservative with what gets purged. Only if the bag has other possible
862 // variations with respect to what changed (diff) should we remove it.
863 for (auto iter = cached_bags_.cbegin(); iter != cached_bags_.cend();) {
864 if (diff & iter->second->type_spec_flags) {
865 iter = cached_bags_.erase(iter);
866 } else {
867 ++iter;
868 }
869 }
870}
871
Adam Lesinski30080e22017-10-16 16:18:09 -0700872std::unique_ptr<Theme> AssetManager2::NewTheme() {
873 return std::unique_ptr<Theme>(new Theme(this));
874}
875
876Theme::Theme(AssetManager2* asset_manager) : asset_manager_(asset_manager) {
877}
878
879Theme::~Theme() = default;
880
881namespace {
882
883struct ThemeEntry {
884 ApkAssetsCookie cookie;
885 uint32_t type_spec_flags;
886 Res_value value;
887};
888
889struct ThemeType {
890 int entry_count;
891 ThemeEntry entries[0];
892};
893
894constexpr size_t kTypeCount = std::numeric_limits<uint8_t>::max() + 1;
895
896} // namespace
897
898struct Theme::Package {
899 // Each element of Type will be a dynamically sized object
900 // allocated to have the entries stored contiguously with the Type.
901 std::array<util::unique_cptr<ThemeType>, kTypeCount> types;
902};
Adam Lesinski7ad11102016-10-28 16:39:15 -0700903
904bool Theme::ApplyStyle(uint32_t resid, bool force) {
Adam Lesinskibebfcc42018-02-12 14:27:46 -0800905 ATRACE_NAME("Theme::ApplyStyle");
Adam Lesinski7ad11102016-10-28 16:39:15 -0700906
907 const ResolvedBag* bag = asset_manager_->GetBag(resid);
908 if (bag == nullptr) {
909 return false;
910 }
911
912 // Merge the flags from this style.
913 type_spec_flags_ |= bag->type_spec_flags;
914
Adam Lesinski30080e22017-10-16 16:18:09 -0700915 int last_type_idx = -1;
916 int last_package_idx = -1;
917 Package* last_package = nullptr;
918 ThemeType* last_type = nullptr;
919
920 // Iterate backwards, because each bag is sorted in ascending key ID order, meaning we will only
921 // need to perform one resize per type.
922 using reverse_bag_iterator = std::reverse_iterator<const ResolvedBag::Entry*>;
923 const auto bag_iter_end = reverse_bag_iterator(begin(bag));
924 for (auto bag_iter = reverse_bag_iterator(end(bag)); bag_iter != bag_iter_end; ++bag_iter) {
Adam Lesinski7ad11102016-10-28 16:39:15 -0700925 const uint32_t attr_resid = bag_iter->key;
926
Adam Lesinski30080e22017-10-16 16:18:09 -0700927 // If the resource ID passed in is not a style, the key can be some other identifier that is not
928 // a resource ID. We should fail fast instead of operating with strange resource IDs.
Adam Lesinski929d6512017-01-16 19:11:19 -0800929 if (!is_valid_resid(attr_resid)) {
Adam Lesinski7ad11102016-10-28 16:39:15 -0700930 return false;
931 }
932
Adam Lesinski30080e22017-10-16 16:18:09 -0700933 // We don't use the 0-based index for the type so that we can avoid doing ID validation
934 // upon lookup. Instead, we keep space for the type ID 0 in our data structures. Since
935 // the construction of this type is guarded with a resource ID check, it will never be
936 // populated, and querying type ID 0 will always fail.
937 const int package_idx = get_package_id(attr_resid);
938 const int type_idx = get_type_id(attr_resid);
939 const int entry_idx = get_entry_id(attr_resid);
Adam Lesinski7ad11102016-10-28 16:39:15 -0700940
Adam Lesinski30080e22017-10-16 16:18:09 -0700941 if (last_package_idx != package_idx) {
942 std::unique_ptr<Package>& package = packages_[package_idx];
943 if (package == nullptr) {
944 package.reset(new Package());
Adam Lesinski7ad11102016-10-28 16:39:15 -0700945 }
Adam Lesinski30080e22017-10-16 16:18:09 -0700946 last_package_idx = package_idx;
947 last_package = package.get();
948 last_type_idx = -1;
Adam Lesinski7ad11102016-10-28 16:39:15 -0700949 }
Adam Lesinski30080e22017-10-16 16:18:09 -0700950
951 if (last_type_idx != type_idx) {
952 util::unique_cptr<ThemeType>& type = last_package->types[type_idx];
953 if (type == nullptr) {
954 // Allocate enough memory to contain this entry_idx. Since we're iterating in reverse over
955 // a sorted list of attributes, this shouldn't be resized again during this method call.
956 type.reset(reinterpret_cast<ThemeType*>(
957 calloc(sizeof(ThemeType) + (entry_idx + 1) * sizeof(ThemeEntry), 1)));
958 type->entry_count = entry_idx + 1;
959 } else if (entry_idx >= type->entry_count) {
960 // Reallocate the memory to contain this entry_idx. Since we're iterating in reverse over
961 // a sorted list of attributes, this shouldn't be resized again during this method call.
962 const int new_count = entry_idx + 1;
963 type.reset(reinterpret_cast<ThemeType*>(
964 realloc(type.release(), sizeof(ThemeType) + (new_count * sizeof(ThemeEntry)))));
965
966 // Clear out the newly allocated space (which isn't zeroed).
967 memset(type->entries + type->entry_count, 0,
968 (new_count - type->entry_count) * sizeof(ThemeEntry));
969 type->entry_count = new_count;
970 }
971 last_type_idx = type_idx;
972 last_type = type.get();
973 }
974
975 ThemeEntry& entry = last_type->entries[entry_idx];
976 if (force || (entry.value.dataType == Res_value::TYPE_NULL &&
977 entry.value.data != Res_value::DATA_NULL_EMPTY)) {
Adam Lesinski7ad11102016-10-28 16:39:15 -0700978 entry.cookie = bag_iter->cookie;
979 entry.type_spec_flags |= bag->type_spec_flags;
980 entry.value = bag_iter->value;
981 }
982 }
983 return true;
984}
985
986ApkAssetsCookie Theme::GetAttribute(uint32_t resid, Res_value* out_value,
987 uint32_t* out_flags) const {
Adam Lesinski30080e22017-10-16 16:18:09 -0700988 int cnt = 20;
Adam Lesinski7ad11102016-10-28 16:39:15 -0700989
990 uint32_t type_spec_flags = 0u;
991
Adam Lesinski30080e22017-10-16 16:18:09 -0700992 do {
993 const int package_idx = get_package_id(resid);
Adam Lesinski7ad11102016-10-28 16:39:15 -0700994 const Package* package = packages_[package_idx].get();
Adam Lesinski30080e22017-10-16 16:18:09 -0700995 if (package != nullptr) {
996 // The themes are constructed with a 1-based type ID, so no need to decrement here.
997 const int type_idx = get_type_id(resid);
998 const ThemeType* type = package->types[type_idx].get();
999 if (type != nullptr) {
1000 const int entry_idx = get_entry_id(resid);
1001 if (entry_idx < type->entry_count) {
1002 const ThemeEntry& entry = type->entries[entry_idx];
1003 type_spec_flags |= entry.type_spec_flags;
Adam Lesinski7ad11102016-10-28 16:39:15 -07001004
Adam Lesinski30080e22017-10-16 16:18:09 -07001005 if (entry.value.dataType == Res_value::TYPE_ATTRIBUTE) {
1006 if (cnt > 0) {
1007 cnt--;
1008 resid = entry.value.data;
1009 continue;
1010 }
1011 return kInvalidCookie;
1012 }
Adam Lesinski7ad11102016-10-28 16:39:15 -07001013
Adam Lesinski30080e22017-10-16 16:18:09 -07001014 // @null is different than @empty.
1015 if (entry.value.dataType == Res_value::TYPE_NULL &&
1016 entry.value.data != Res_value::DATA_NULL_EMPTY) {
1017 return kInvalidCookie;
1018 }
Adam Lesinski7ad11102016-10-28 16:39:15 -07001019
Adam Lesinski30080e22017-10-16 16:18:09 -07001020 *out_value = entry.value;
Adam Lesinskida431a22016-12-29 16:08:16 -05001021 *out_flags = type_spec_flags;
Adam Lesinski30080e22017-10-16 16:18:09 -07001022 return entry.cookie;
Adam Lesinskida431a22016-12-29 16:08:16 -05001023 }
Adam Lesinskida431a22016-12-29 16:08:16 -05001024 }
Adam Lesinski7ad11102016-10-28 16:39:15 -07001025 }
Adam Lesinski30080e22017-10-16 16:18:09 -07001026 break;
1027 } while (true);
Adam Lesinski7ad11102016-10-28 16:39:15 -07001028 return kInvalidCookie;
1029}
1030
Adam Lesinskid1ecd7a2017-01-23 12:58:11 -08001031ApkAssetsCookie Theme::ResolveAttributeReference(ApkAssetsCookie cookie, Res_value* in_out_value,
1032 ResTable_config* in_out_selected_config,
1033 uint32_t* in_out_type_spec_flags,
Adam Lesinskibebfcc42018-02-12 14:27:46 -08001034 uint32_t* out_last_ref) const {
Adam Lesinskid1ecd7a2017-01-23 12:58:11 -08001035 if (in_out_value->dataType == Res_value::TYPE_ATTRIBUTE) {
1036 uint32_t new_flags;
1037 cookie = GetAttribute(in_out_value->data, in_out_value, &new_flags);
1038 if (cookie == kInvalidCookie) {
1039 return kInvalidCookie;
1040 }
1041
1042 if (in_out_type_spec_flags != nullptr) {
1043 *in_out_type_spec_flags |= new_flags;
1044 }
1045 }
1046 return asset_manager_->ResolveReference(cookie, in_out_value, in_out_selected_config,
1047 in_out_type_spec_flags, out_last_ref);
1048}
1049
Adam Lesinski7ad11102016-10-28 16:39:15 -07001050void Theme::Clear() {
1051 type_spec_flags_ = 0u;
1052 for (std::unique_ptr<Package>& package : packages_) {
1053 package.reset();
1054 }
1055}
1056
1057bool Theme::SetTo(const Theme& o) {
1058 if (this == &o) {
1059 return true;
1060 }
1061
Adam Lesinski7ad11102016-10-28 16:39:15 -07001062 type_spec_flags_ = o.type_spec_flags_;
1063
Adam Lesinski03ebac82017-09-25 13:10:14 -07001064 const bool copy_only_system = asset_manager_ != o.asset_manager_;
1065
Adam Lesinskida431a22016-12-29 16:08:16 -05001066 for (size_t p = 0; p < packages_.size(); p++) {
Adam Lesinski7ad11102016-10-28 16:39:15 -07001067 const Package* package = o.packages_[p].get();
Adam Lesinski03ebac82017-09-25 13:10:14 -07001068 if (package == nullptr || (copy_only_system && p != 0x01)) {
1069 // The other theme doesn't have this package, clear ours.
Adam Lesinski7ad11102016-10-28 16:39:15 -07001070 packages_[p].reset();
1071 continue;
1072 }
1073
Adam Lesinski03ebac82017-09-25 13:10:14 -07001074 if (packages_[p] == nullptr) {
1075 // The other theme has this package, but we don't. Make one.
1076 packages_[p].reset(new Package());
1077 }
1078
Adam Lesinskida431a22016-12-29 16:08:16 -05001079 for (size_t t = 0; t < package->types.size(); t++) {
Adam Lesinski30080e22017-10-16 16:18:09 -07001080 const ThemeType* type = package->types[t].get();
Adam Lesinski7ad11102016-10-28 16:39:15 -07001081 if (type == nullptr) {
Adam Lesinski03ebac82017-09-25 13:10:14 -07001082 // The other theme doesn't have this type, clear ours.
Adam Lesinski7ad11102016-10-28 16:39:15 -07001083 packages_[p]->types[t].reset();
1084 continue;
1085 }
1086
Adam Lesinski03ebac82017-09-25 13:10:14 -07001087 // Create a new type and update it to theirs.
Adam Lesinski30080e22017-10-16 16:18:09 -07001088 const size_t type_alloc_size = sizeof(ThemeType) + (type->entry_count * sizeof(ThemeEntry));
Adam Lesinski7ad11102016-10-28 16:39:15 -07001089 void* copied_data = malloc(type_alloc_size);
1090 memcpy(copied_data, type, type_alloc_size);
Adam Lesinski30080e22017-10-16 16:18:09 -07001091 packages_[p]->types[t].reset(reinterpret_cast<ThemeType*>(copied_data));
Adam Lesinski7ad11102016-10-28 16:39:15 -07001092 }
1093 }
1094 return true;
1095}
1096
1097} // namespace android