Merge "New implementation of AssetManager/ResTable" (fdaa9c58) · Commits · e / os / android_frameworks_base

libs/androidfw/Android.bp

+14 −1

Original line number	Diff line number	Diff line
		@@ -24,10 +24,14 @@ cc_library {
		"-Wunreachable-code",
		],
		srcs: [
		"ApkAssets.cpp",
		"Asset.cpp",
		"AssetDir.cpp",
		"AssetManager.cpp",
		"AssetManager2.cpp",
		"AttributeResolution.cpp",
		"ChunkIterator.cpp",
		"LoadedArsc.cpp",
		"LocaleData.cpp",
		"misc.cpp",
		"ObbFile.cpp",
		@@ -65,7 +69,16 @@ cc_library {
		shared: {
		enabled: false,
		},
		shared_libs: ["libz-host"],
		static_libs: [
		"libziparchive",
		"libbase",
		"liblog",
		"libcutils",
		"libutils",
		],
		shared_libs: [
		"libz-host",
		],
		},
		windows: {
		enabled: true,

libs/androidfw/ApkAssets.cpp

0 → 100644

+104 −0

Original line number	Diff line number	Diff line
		/*
		* 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/ApkAssets.h"

		#include "android-base/logging.h"
		#include "utils/Trace.h"
		#include "ziparchive/zip_archive.h"

		#include "androidfw/Asset.h"
		#include "androidfw/Util.h"

		namespace android {

		std::unique_ptr<ApkAssets> ApkAssets::Load(const std::string& path) {
		ATRACE_NAME("ApkAssets::Load");
		::ZipArchiveHandle unmanaged_handle;
		int32_t result = ::OpenArchive(path.c_str(), &unmanaged_handle);
		if (result != 0) {
		LOG(ERROR) << ::ErrorCodeString(result);
		return {};
		}

		// Wrap the handle in a unique_ptr so it gets automatically closed.
		std::unique_ptr<ApkAssets> loaded_apk(new ApkAssets());
		loaded_apk->zip_handle_.reset(unmanaged_handle);

		::ZipString entry_name("resources.arsc");
		::ZipEntry entry;
		result = ::FindEntry(loaded_apk->zip_handle_.get(), entry_name, &entry);
		if (result != 0) {
		LOG(ERROR) << ::ErrorCodeString(result);
		return {};
		}

		if (entry.method == kCompressDeflated) {
		LOG(WARNING) << "resources.arsc is compressed.";
		}

		loaded_apk->resources_asset_ =
		loaded_apk->Open("resources.arsc", Asset::AccessMode::ACCESS_BUFFER);
		if (loaded_apk->resources_asset_ == nullptr) {
		return {};
		}

		loaded_apk->path_ = path;
		loaded_apk->loaded_arsc_ =
		LoadedArsc::Load(loaded_apk->resources_asset_->getBuffer(true /wordAligned/),
		loaded_apk->resources_asset_->getLength());
		if (loaded_apk->loaded_arsc_ == nullptr) {
		return {};
		}
		return loaded_apk;
		}

		std::unique_ptr<Asset> ApkAssets::Open(const std::string& path, Asset::AccessMode /mode/) const {
		ATRACE_NAME("ApkAssets::Open");
		CHECK(zip_handle_ != nullptr);

		::ZipString name(path.c_str());
		::ZipEntry entry;
		int32_t result = ::FindEntry(zip_handle_.get(), name, &entry);
		if (result != 0) {
		LOG(ERROR) << "No entry '" << path << "' found in APK.";
		return {};
		}

		if (entry.method == kCompressDeflated) {
		auto compressed_asset = util::make_unique<_CompressedAsset>();
		if (compressed_asset->openChunk(::GetFileDescriptor(zip_handle_.get()), entry.offset,
		entry.method, entry.uncompressed_length,
		entry.compressed_length) != NO_ERROR) {
		LOG(ERROR) << "Failed to decompress '" << path << "'.";
		return {};
		}
		return std::move(compressed_asset);
		} else {
		auto uncompressed_asset = util::make_unique<_FileAsset>();
		if (uncompressed_asset->openChunk(path.c_str(), ::GetFileDescriptor(zip_handle_.get()),
		entry.offset, entry.uncompressed_length) != NO_ERROR) {
		LOG(ERROR) << "Failed to mmap '" << path << "'.";
		return {};
		}
		return std::move(uncompressed_asset);
		}
		return {};
		}

		} // namespace android

libs/androidfw/AssetManager2.cpp

0 → 100644

+576 −0

Original line number	Diff line number	Diff line
		/*
		* 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 "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

		namespace android {

		AssetManager2::AssetManager2() { memset(&configuration_, 0, sizeof(configuration_)); }

		bool AssetManager2::SetApkAssets(const std::vector<const ApkAssets*>& apk_assets,
		bool invalidate_caches) {
		apk_assets_ = apk_assets;
		if (invalidate_caches) {
		InvalidateCaches(static_cast<uint32_t>(-1));
		}
		return true;
		}

		const std::vector<const ApkAssets*> AssetManager2::GetApkAssets() const { return apk_assets_; }

		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();
		}

		void AssetManager2::SetConfiguration(const ResTable_config& configuration) {
		const int diff = configuration_.diff(configuration);
		configuration_ = configuration;

		if (diff) {
		InvalidateCaches(static_cast<uint32_t>(diff));
		}
		}

		const ResTable_config& AssetManager2::GetConfiguration() const { return configuration_; }

		std::unique_ptr<Asset> AssetManager2::Open(const std::string& filename, Asset::AccessMode mode) {
		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 std::string new_path = "assets/" + filename;
		return OpenNonAsset(new_path, cookie, mode);
		}

		// 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) {
		ATRACE_CALL();
		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) {
		ATRACE_CALL();
		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, LoadedArsc::Entry* out_entry,
		ResTable_config* out_selected_config,
		uint32_t* out_flags) {
		ATRACE_CALL();

		// Might use this if density_override != 0.
		ResTable_config density_override_config;

		// Select our configuration or generate a density override configuration.
		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;
		}

		LoadedArsc::Entry best_entry;
		ResTable_config best_config;
		int32_t best_index = -1;
		uint32_t cumulated_flags = 0;

		const size_t apk_asset_count = apk_assets_.size();
		for (size_t i = 0; i < apk_asset_count; i++) {
		const LoadedArsc* loaded_arsc = apk_assets_[i]->GetLoadedArsc();

		LoadedArsc::Entry current_entry;
		ResTable_config current_config;
		uint32_t flags = 0;
		if (!loaded_arsc->FindEntry(resid, *desired_config, &current_entry, &current_config, &flags)) {
		continue;
		}

		cumulated_flags \|= flags;

		if (best_index == -1 \|\| current_config.isBetterThan(best_config, desired_config)) {
		best_entry = current_entry;
		best_config = current_config;
		best_index = static_cast<int32_t>(i);
		if (stop_at_first_match) {
		break;
		}
		}
		}

		if (best_index == -1) {
		return kInvalidCookie;
		}

		*out_entry = best_entry;
		*out_selected_config = best_config;
		*out_flags = cumulated_flags;
		return best_index;
		}

		bool AssetManager2::GetResourceName(uint32_t resid, ResourceName* out_name) {
		ATRACE_CALL();

		LoadedArsc::Entry entry;
		ResTable_config config;
		uint32_t flags = 0u;
		ApkAssetsCookie cookie = FindEntry(resid, 0u /* density_override */,
		true /* stop_at_first_match */, &entry, &config, &flags);
		if (cookie == kInvalidCookie) {
		return false;
		}

		const std::string* package_name =
		apk_assets_[cookie]->GetLoadedArsc()->GetPackageNameForId(resid);
		if (package_name == nullptr) {
		return false;
		}

		out_name->package = package_name->data();
		out_name->package_len = package_name->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) {
		LoadedArsc::Entry entry;
		ResTable_config config;
		ApkAssetsCookie cookie = FindEntry(resid, 0u /* density_override */,
		false /* stop_at_first_match */, &entry, &config, out_flags);
		return cookie != 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) {
		ATRACE_CALL();

		LoadedArsc::Entry entry;
		ResTable_config config;
		uint32_t flags = 0u;
		ApkAssetsCookie cookie =
		FindEntry(resid, density_override, false /* stop_at_first_match */, &entry, &config, &flags);
		if (cookie == kInvalidCookie) {
		return kInvalidCookie;
		}

		if (dtohl(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;
		}

		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);
		*out_selected_config = config;
		*out_flags = flags;
		return cookie;
		}

		const ResolvedBag* AssetManager2::GetBag(uint32_t resid) {
		ATRACE_CALL();

		auto cached_iter = cached_bags_.find(resid);
		if (cached_iter != cached_bags_.end()) {
		return cached_iter->second.get();
		}

		LoadedArsc::Entry entry;
		ResTable_config config;
		uint32_t flags = 0u;
		ApkAssetsCookie cookie = FindEntry(resid, 0u /* density_override */,
		false /* stop_at_first_match */, &entry, &config, &flags);
		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);

		const uint32_t parent = dtohl(map->parent.ident);
		if (parent == 0) {
		// There is no parent, 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) {
		new_entry->cookie = cookie;
		new_entry->value.copyFrom_dtoh(map_entry->value);
		new_entry->key = dtohl(map_entry->name.ident);
		new_entry->key_pool = nullptr;
		new_entry->type_pool = nullptr;
		++new_entry;
		}
		new_bag->type_spec_flags = 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;
		}

		// Get the parent and do a merge of the keys.
		const ResolvedBag* parent_bag = GetBag(parent);
		if (parent_bag == nullptr) {
		// Failed to get the parent that should exist.
		return nullptr;
		}

		// Combine flags from the parent and our own bag.
		flags \|= parent_bag->type_spec_flags;

		// 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);
		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) {
		const uint32_t child_key = dtohl(map_entry->name.ident);
		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->value.copyFrom_dtoh(map_entry->value);
		new_entry->key = child_key;
		new_entry->key_pool = nullptr;
		new_entry->type_pool = 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) {
		new_entry->cookie = cookie;
		new_entry->value.copyFrom_dtoh(map_entry->value);
		new_entry->key = dtohl(map_entry->name.ident);
		new_entry->key_pool = nullptr;
		new_entry->type_pool = 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 = reinterpret_cast<ResolvedBag*>(
		realloc(new_bag, sizeof(ResolvedBag) + (actual_count * sizeof(ResolvedBag::Entry))));
		}

		util::unique_cptr<ResolvedBag> final_bag{new_bag};
		final_bag->type_spec_flags = flags;
		final_bag->entry_count = static_cast<uint32_t>(actual_count);
		ResolvedBag* result = final_bag.get();
		cached_bags_[resid] = std::move(final_bag);
		return result;
		}

		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)); }

		bool Theme::ApplyStyle(uint32_t resid, bool force) {
		ATRACE_CALL();

		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;

		// On the first iteration, verify the attribute IDs and
		// update the entry count in each type.
		const auto bag_iter_end = end(bag);
		for (auto bag_iter = begin(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.
		if (!util::is_valid_resid(attr_resid)) {
		return false;
		}

		const uint32_t package_idx = util::get_package_id(attr_resid);

		// The type ID is 1-based, so subtract 1 to get an index.
		const uint32_t type_idx = util::get_type_id(attr_resid) - 1;
		const uint32_t entry_idx = util::get_entry_id(attr_resid);

		std::unique_ptr<Package>& package = packages_[package_idx];
		if (package == nullptr) {
		package.reset(new Package());
		}

		util::unique_cptr<Type>& type = package->types[type_idx];
		if (type == nullptr) {
		// Set the initial capacity to take up a total amount of 1024 bytes.
		constexpr uint32_t kInitialCapacity = (1024u - sizeof(Type)) / sizeof(Entry);
		const uint32_t initial_capacity = std::max(entry_idx, kInitialCapacity);
		type.reset(
		reinterpret_cast<Type>(calloc(sizeof(Type) + (initial_capacity sizeof(Entry)), 1)));
		type->entry_capacity = initial_capacity;
		}

		// Set the entry_count to include this entry. We will populate
		// and resize the array as necessary in the next pass.
		if (entry_idx + 1 > type->entry_count) {
		// Increase the entry count to include this.
		type->entry_count = entry_idx + 1;
		}
		}

		// On the second pass, we will realloc to fit the entry counts
		// and populate the structures.
		for (auto bag_iter = begin(bag); bag_iter != bag_iter_end; ++bag_iter) {
		const uint32_t attr_resid = bag_iter->key;
		const uint32_t package_idx = util::get_package_id(attr_resid);
		const uint32_t type_idx = util::get_type_id(attr_resid) - 1;
		const uint32_t entry_idx = util::get_entry_id(attr_resid);
		Package* package = packages_[package_idx].get();
		util::unique_cptr<Type>& type = package->types[type_idx];
		if (type->entry_count != type->entry_capacity) {
		// Resize to fit the actual entries that will be included.
		Type* type_ptr = type.release();
		type.reset(reinterpret_cast<Type*>(
		realloc(type_ptr, sizeof(Type) + (type_ptr->entry_count * sizeof(Entry)))));
		if (type->entry_capacity < type->entry_count) {
		// Clear the newly allocated memory (which does not get zero initialized).
		// We need to do this because we \|= type_spec_flags.
		memset(type->entries + type->entry_capacity, 0,
		sizeof(Entry) * (type->entry_count - type->entry_capacity));
		}
		type->entry_capacity = type->entry_count;
		}
		Entry& entry = type->entries[entry_idx];
		if (force \|\| entry.value.dataType == Res_value::TYPE_NULL) {
		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 {
		constexpr const int kMaxIterations = 20;

		uint32_t type_spec_flags = 0u;

		for (int iterations_left = kMaxIterations; iterations_left > 0; iterations_left--) {
		if (!util::is_valid_resid(resid)) {
		return kInvalidCookie;
		}

		const uint32_t package_idx = util::get_package_id(resid);

		// Type ID is 1-based, subtract 1 to get the index.
		const uint32_t type_idx = util::get_type_id(resid) - 1;
		const uint32_t entry_idx = util::get_entry_id(resid);

		const Package* package = packages_[package_idx].get();
		if (package == nullptr) {
		return kInvalidCookie;
		}

		const Type* type = package->types[type_idx].get();
		if (type == nullptr) {
		return kInvalidCookie;
		}

		if (entry_idx >= type->entry_count) {
		return kInvalidCookie;
		}

		const Entry& entry = type->entries[entry_idx];
		type_spec_flags \|= entry.type_spec_flags;

		switch (entry.value.dataType) {
		case Res_value::TYPE_ATTRIBUTE:
		resid = entry.value.data;
		break;

		case Res_value::TYPE_NULL:
		return kInvalidCookie;

		default:
		*out_value = entry.value;
		if (out_flags != nullptr) {
		*out_flags = type_spec_flags;
		}
		return entry.cookie;
		}
		}

		LOG(WARNING) << base::StringPrintf("Too many (%d) attribute references, stopped at: 0x%08x",
		kMaxIterations, resid);
		return kInvalidCookie;
		}

		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;
		}

		if (asset_manager_ != o.asset_manager_) {
		return false;
		}

		type_spec_flags_ = o.type_spec_flags_;

		for (size_t p = 0; p < arraysize(packages_); p++) {
		const Package* package = o.packages_[p].get();
		if (package == nullptr) {
		packages_[p].reset();
		continue;
		}

		for (size_t t = 0; t < arraysize(package->types); t++) {
		const Type* type = package->types[t].get();
		if (type == nullptr) {
		packages_[p]->types[t].reset();
		continue;
		}

		const size_t type_alloc_size = sizeof(Type) + (type->entry_capacity * sizeof(Entry));
		void* copied_data = malloc(type_alloc_size);
		memcpy(copied_data, type, type_alloc_size);
		packages_[p]->types[t].reset(reinterpret_cast<Type*>(copied_data));
		}
		}
		return true;
		}

		} // namespace android

libs/androidfw/Chunk.h

0 → 100644

+113 −0

File added.

Preview size limit exceeded, changes collapsed.

libs/androidfw/ChunkIterator.cpp

0 → 100644

+81 −0

File added.

Preview size limit exceeded, changes collapsed.