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