tools/aapt2/split/TableSplitter.cpp - platform/frameworks/base - Gitiles

 /*
  * 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.
  */

 #include "ConfigDescription.h"
 #include "ResourceTable.h"
 #include "split/TableSplitter.h"

 #include <algorithm>
 #include <map>
 #include <set>
 #include <unordered_map>
 #include <vector>

 namespace aapt {

 using ConfigClaimedMap = std::unordered_map<ResourceConfigValue*, bool>;
 using ConfigDensityGroups = std::map<ConfigDescription, std::vector<ResourceConfigValue*>>;

 static ConfigDescription copyWithoutDensity(const ConfigDescription& config) {
     ConfigDescription withoutDensity = config;
     withoutDensity.density = 0;
     return withoutDensity;
 }

 /**
  * Selects values that match exactly the constraints given.
  */
 class SplitValueSelector {
 public:
     SplitValueSelector(const SplitConstraints& constraints) {
         for (const ConfigDescription& config : constraints.configs) {
             if (config.density == 0) {
                 mDensityIndependentConfigs.insert(config);
             } else {
                 mDensityDependentConfigToDensityMap[copyWithoutDensity(config)] = config.density;
             }
         }
     }

     std::vector<ResourceConfigValue*> selectValues(const ConfigDensityGroups& densityGroups,
                                                    ConfigClaimedMap* claimedValues) {
         std::vector<ResourceConfigValue*> selected;

         // Select the regular values.
         for (auto& entry : *claimedValues) {
             // Check if the entry has a density.
             ResourceConfigValue* configValue = entry.first;
             if (configValue->config.density == 0 && !entry.second) {
                 // This is still available.
                 if (mDensityIndependentConfigs.find(configValue->config) !=
                         mDensityIndependentConfigs.end()) {
                     selected.push_back(configValue);

                     // Mark the entry as taken.
                     entry.second = true;
                 }
             }
         }

         // Now examine the densities
         for (auto& entry : densityGroups) {
             // We do not care if the value is claimed, since density values can be
             // in multiple splits.
             const ConfigDescription& config = entry.first;
             const std::vector<ResourceConfigValue*>& relatedValues = entry.second;

             auto densityValueIter = mDensityDependentConfigToDensityMap.find(config);
             if (densityValueIter != mDensityDependentConfigToDensityMap.end()) {
                 // Select the best one!
                 ConfigDescription targetDensity = config;
                 targetDensity.density = densityValueIter->second;

                 ResourceConfigValue* bestValue = nullptr;
                 for (ResourceConfigValue* thisValue : relatedValues) {
                     if (!bestValue ||
                             thisValue->config.isBetterThan(bestValue->config, &targetDensity)) {
                         bestValue = thisValue;
                     }

                     // When we select one of these, they are all claimed such that the base
                     // doesn't include any anymore.
                     (*claimedValues)[thisValue] = true;
                 }
                 assert(bestValue);
                 selected.push_back(bestValue);
             }
         }
         return selected;
     }

 private:
     std::set<ConfigDescription> mDensityIndependentConfigs;
     std::map<ConfigDescription, uint16_t> mDensityDependentConfigToDensityMap;
 };

 /**
  * Marking non-preferred densities as claimed will make sure the base doesn't include them,
  * leaving only the preferred density behind.
  */
 static void markNonPreferredDensitiesAsClaimed(uint16_t preferredDensity,
                                                const ConfigDensityGroups& densityGroups,
                                                ConfigClaimedMap* configClaimedMap) {
     for (auto& entry : densityGroups) {
         const ConfigDescription& config = entry.first;
         const std::vector<ResourceConfigValue*>& relatedValues = entry.second;

         ConfigDescription targetDensity = config;
         targetDensity.density = preferredDensity;
         ResourceConfigValue* bestValue = nullptr;
         for (ResourceConfigValue* thisValue : relatedValues) {
             if (!bestValue) {
                 bestValue = thisValue;
             } else if (thisValue->config.isBetterThan(bestValue->config, &targetDensity)) {
                 // Claim the previous value so that it is not included in the base.
                 (*configClaimedMap)[bestValue] = true;
                 bestValue = thisValue;
             } else {
                 // Claim this value so that it is not included in the base.
                 (*configClaimedMap)[thisValue] = true;
             }
         }
         assert(bestValue);
     }
 }

 bool TableSplitter::verifySplitConstraints(IAaptContext* context) {
     bool error = false;
     for (size_t i = 0; i < mSplitConstraints.size(); i++) {
         for (size_t j = i + 1; j < mSplitConstraints.size(); j++) {
             for (const ConfigDescription& config : mSplitConstraints[i].configs) {
                 if (mSplitConstraints[j].configs.find(config) !=
                         mSplitConstraints[j].configs.end()) {
                     context->getDiagnostics()->error(DiagMessage() << "config '" << config
                                                      << "' appears in multiple splits, "
                                                      << "target split ambiguous");
                     error = true;
                 }
             }
         }
     }
     return !error;
 }

 void TableSplitter::splitTable(ResourceTable* originalTable) {
     const size_t splitCount = mSplitConstraints.size();
     for (auto& pkg : originalTable->packages) {
         // Initialize all packages for splits.
         for (size_t idx = 0; idx < splitCount; idx++) {
             ResourceTable* splitTable = mSplits[idx].get();
             splitTable->createPackage(pkg->name, pkg->id);
         }

         for (auto& type : pkg->types) {
             if (type->type == ResourceType::kMipmap) {
                 // Always keep mipmaps.
                 continue;
             }

             for (auto& entry : type->entries) {
                 if (mConfigFilter) {
                     // First eliminate any resource that we definitely don't want.
                     for (std::unique_ptr<ResourceConfigValue>& configValue : entry->values) {
                         if (!mConfigFilter->match(configValue->config)) {
                             // null out the entry. We will clean up and remove nulls at the end
                             // for performance reasons.
                             configValue.reset();
                         }
                     }
                 }

                 // Organize the values into two separate buckets. Those that are density-dependent
                 // and those that are density-independent.
                 // One density technically matches all density, it's just that some densities
                 // match better. So we need to be aware of the full set of densities to make this
                 // decision.
                 ConfigDensityGroups densityGroups;
                 ConfigClaimedMap configClaimedMap;
                 for (const std::unique_ptr<ResourceConfigValue>& configValue : entry->values) {
                     if (configValue) {
                         configClaimedMap[configValue.get()] = false;

                         if (configValue->config.density != 0) {
                             // Create a bucket for this density-dependent config.
                             densityGroups[copyWithoutDensity(configValue->config)]
                                           .push_back(configValue.get());
                         }
                     }
                 }

                 // First we check all the splits. If it doesn't match one of the splits, we
                 // leave it in the base.
                 for (size_t idx = 0; idx < splitCount; idx++) {
                     const SplitConstraints& splitConstraint = mSplitConstraints[idx];
                     ResourceTable* splitTable = mSplits[idx].get();

                     // Select the values we want from this entry for this split.
                     SplitValueSelector selector(splitConstraint);
                     std::vector<ResourceConfigValue*> selectedValues =
                             selector.selectValues(densityGroups, &configClaimedMap);

                     // No need to do any work if we selected nothing.
                     if (!selectedValues.empty()) {
                         // Create the same resource structure in the split. We do this lazily
                         // because we might not have actual values for each type/entry.
                         ResourceTablePackage* splitPkg = splitTable->findPackage(pkg->name);
                         ResourceTableType* splitType = splitPkg->findOrCreateType(type->type);
                         if (!splitType->id) {
                             splitType->id = type->id;
                             splitType->symbolStatus = type->symbolStatus;
                         }

                         ResourceEntry* splitEntry = splitType->findOrCreateEntry(entry->name);
                         if (!splitEntry->id) {
                             splitEntry->id = entry->id;
                             splitEntry->symbolStatus = entry->symbolStatus;
                         }

                         // Copy the selected values into the new Split Entry.
                         for (ResourceConfigValue* configValue : selectedValues) {
                             ResourceConfigValue* newConfigValue = splitEntry->findOrCreateValue(
                                     configValue->config, configValue->product);
                             newConfigValue->value = std::unique_ptr<Value>(
                                     configValue->value->clone(&splitTable->stringPool));
                         }
                     }
                 }

                 if (mPreferredDensity) {
                     markNonPreferredDensitiesAsClaimed(mPreferredDensity.value(),
                                                        densityGroups,
                                                        &configClaimedMap);
                 }

                 // All splits are handled, now check to see what wasn't claimed and remove
                 // whatever exists in other splits.
                 for (std::unique_ptr<ResourceConfigValue>& configValue : entry->values) {
                     if (configValue && configClaimedMap[configValue.get()]) {
                         // Claimed, remove from base.
                         configValue.reset();
                     }
                 }

                 // Now erase all nullptrs.
                 entry->values.erase(
                         std::remove(entry->values.begin(), entry->values.end(), nullptr),
                         entry->values.end());
             }
         }
     }
 }

 } // namespace aapt
	/*
	* 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.
	*/

	#include "ConfigDescription.h"
	#include "ResourceTable.h"
	#include "split/TableSplitter.h"

	#include <algorithm>
	#include <map>
	#include <set>
	#include <unordered_map>
	#include <vector>

	namespace aapt {

	using ConfigClaimedMap = std::unordered_map<ResourceConfigValue*, bool>;
	using ConfigDensityGroups = std::map<ConfigDescription, std::vector<ResourceConfigValue*>>;

	static ConfigDescription copyWithoutDensity(const ConfigDescription& config) {
	ConfigDescription withoutDensity = config;
	withoutDensity.density = 0;
	return withoutDensity;
	}

	/**
	* Selects values that match exactly the constraints given.
	*/
	class SplitValueSelector {
	public:
	SplitValueSelector(const SplitConstraints& constraints) {
	for (const ConfigDescription& config : constraints.configs) {
	if (config.density == 0) {
	mDensityIndependentConfigs.insert(config);
	} else {
	mDensityDependentConfigToDensityMap[copyWithoutDensity(config)] = config.density;
	}
	}
	}

	std::vector<ResourceConfigValue*> selectValues(const ConfigDensityGroups& densityGroups,
	ConfigClaimedMap* claimedValues) {
	std::vector<ResourceConfigValue*> selected;

	// Select the regular values.
	for (auto& entry : *claimedValues) {
	// Check if the entry has a density.
	ResourceConfigValue* configValue = entry.first;
	if (configValue->config.density == 0 && !entry.second) {
	// This is still available.
	if (mDensityIndependentConfigs.find(configValue->config) !=
	mDensityIndependentConfigs.end()) {
	selected.push_back(configValue);

	// Mark the entry as taken.
	entry.second = true;
	}
	}
	}

	// Now examine the densities
	for (auto& entry : densityGroups) {
	// We do not care if the value is claimed, since density values can be
	// in multiple splits.
	const ConfigDescription& config = entry.first;
	const std::vector<ResourceConfigValue*>& relatedValues = entry.second;

	auto densityValueIter = mDensityDependentConfigToDensityMap.find(config);
	if (densityValueIter != mDensityDependentConfigToDensityMap.end()) {
	// Select the best one!
	ConfigDescription targetDensity = config;
	targetDensity.density = densityValueIter->second;

	ResourceConfigValue* bestValue = nullptr;
	for (ResourceConfigValue* thisValue : relatedValues) {
	if (!bestValue \|\|
	thisValue->config.isBetterThan(bestValue->config, &targetDensity)) {
	bestValue = thisValue;
	}

	// When we select one of these, they are all claimed such that the base
	// doesn't include any anymore.
	(*claimedValues)[thisValue] = true;
	}
	assert(bestValue);
	selected.push_back(bestValue);
	}
	}
	return selected;
	}

	private:
	std::set<ConfigDescription> mDensityIndependentConfigs;
	std::map<ConfigDescription, uint16_t> mDensityDependentConfigToDensityMap;
	};

	/**
	* Marking non-preferred densities as claimed will make sure the base doesn't include them,
	* leaving only the preferred density behind.
	*/
	static void markNonPreferredDensitiesAsClaimed(uint16_t preferredDensity,
	const ConfigDensityGroups& densityGroups,
	ConfigClaimedMap* configClaimedMap) {
	for (auto& entry : densityGroups) {
	const ConfigDescription& config = entry.first;
	const std::vector<ResourceConfigValue*>& relatedValues = entry.second;

	ConfigDescription targetDensity = config;
	targetDensity.density = preferredDensity;
	ResourceConfigValue* bestValue = nullptr;
	for (ResourceConfigValue* thisValue : relatedValues) {
	if (!bestValue) {
	bestValue = thisValue;
	} else if (thisValue->config.isBetterThan(bestValue->config, &targetDensity)) {
	// Claim the previous value so that it is not included in the base.
	(*configClaimedMap)[bestValue] = true;
	bestValue = thisValue;
	} else {
	// Claim this value so that it is not included in the base.
	(*configClaimedMap)[thisValue] = true;
	}
	}
	assert(bestValue);
	}
	}

	bool TableSplitter::verifySplitConstraints(IAaptContext* context) {
	bool error = false;
	for (size_t i = 0; i < mSplitConstraints.size(); i++) {
	for (size_t j = i + 1; j < mSplitConstraints.size(); j++) {
	for (const ConfigDescription& config : mSplitConstraints[i].configs) {
	if (mSplitConstraints[j].configs.find(config) !=
	mSplitConstraints[j].configs.end()) {
	context->getDiagnostics()->error(DiagMessage() << "config '" << config
	<< "' appears in multiple splits, "
	<< "target split ambiguous");
	error = true;
	}
	}
	}
	}
	return !error;
	}

	void TableSplitter::splitTable(ResourceTable* originalTable) {
	const size_t splitCount = mSplitConstraints.size();
	for (auto& pkg : originalTable->packages) {
	// Initialize all packages for splits.
	for (size_t idx = 0; idx < splitCount; idx++) {
	ResourceTable* splitTable = mSplits[idx].get();
	splitTable->createPackage(pkg->name, pkg->id);
	}

	for (auto& type : pkg->types) {
	if (type->type == ResourceType::kMipmap) {
	// Always keep mipmaps.
	continue;
	}

	for (auto& entry : type->entries) {
	if (mConfigFilter) {
	// First eliminate any resource that we definitely don't want.
	for (std::unique_ptr<ResourceConfigValue>& configValue : entry->values) {
	if (!mConfigFilter->match(configValue->config)) {
	// null out the entry. We will clean up and remove nulls at the end
	// for performance reasons.
	configValue.reset();
	}
	}
	}

	// Organize the values into two separate buckets. Those that are density-dependent
	// and those that are density-independent.
	// One density technically matches all density, it's just that some densities
	// match better. So we need to be aware of the full set of densities to make this
	// decision.
	ConfigDensityGroups densityGroups;
	ConfigClaimedMap configClaimedMap;
	for (const std::unique_ptr<ResourceConfigValue>& configValue : entry->values) {
	if (configValue) {
	configClaimedMap[configValue.get()] = false;

	if (configValue->config.density != 0) {
	// Create a bucket for this density-dependent config.
	densityGroups[copyWithoutDensity(configValue->config)]
	.push_back(configValue.get());
	}
	}
	}

	// First we check all the splits. If it doesn't match one of the splits, we
	// leave it in the base.
	for (size_t idx = 0; idx < splitCount; idx++) {
	const SplitConstraints& splitConstraint = mSplitConstraints[idx];
	ResourceTable* splitTable = mSplits[idx].get();

	// Select the values we want from this entry for this split.
	SplitValueSelector selector(splitConstraint);
	std::vector<ResourceConfigValue*> selectedValues =
	selector.selectValues(densityGroups, &configClaimedMap);

	// No need to do any work if we selected nothing.
	if (!selectedValues.empty()) {
	// Create the same resource structure in the split. We do this lazily
	// because we might not have actual values for each type/entry.
	ResourceTablePackage* splitPkg = splitTable->findPackage(pkg->name);
	ResourceTableType* splitType = splitPkg->findOrCreateType(type->type);
	if (!splitType->id) {
	splitType->id = type->id;
	splitType->symbolStatus = type->symbolStatus;
	}

	ResourceEntry* splitEntry = splitType->findOrCreateEntry(entry->name);
	if (!splitEntry->id) {
	splitEntry->id = entry->id;
	splitEntry->symbolStatus = entry->symbolStatus;
	}

	// Copy the selected values into the new Split Entry.
	for (ResourceConfigValue* configValue : selectedValues) {
	ResourceConfigValue* newConfigValue = splitEntry->findOrCreateValue(
	configValue->config, configValue->product);
	newConfigValue->value = std::unique_ptr<Value>(
	configValue->value->clone(&splitTable->stringPool));
	}
	}
	}

	if (mPreferredDensity) {
	markNonPreferredDensitiesAsClaimed(mPreferredDensity.value(),
	densityGroups,
	&configClaimedMap);
	}

	// All splits are handled, now check to see what wasn't claimed and remove
	// whatever exists in other splits.
	for (std::unique_ptr<ResourceConfigValue>& configValue : entry->values) {
	if (configValue && configClaimedMap[configValue.get()]) {
	// Claimed, remove from base.
	configValue.reset();
	}
	}

	// Now erase all nullptrs.
	entry->values.erase(
	std::remove(entry->values.begin(), entry->values.end(), nullptr),
	entry->values.end());
	}
	}
	}
	}

	} // namespace aapt