| /* | |
| * Copyright (C) 2015 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 "Resource.h" | |
| #include "ValueVisitor.h" | |
| #include "process/SymbolTable.h" | |
| #include "util/Comparators.h" | |
| #include "util/Util.h" | |
| #include <androidfw/AssetManager.h> | |
| #include <androidfw/ResourceTypes.h> | |
| namespace aapt { | |
| const ISymbolTable::Symbol* SymbolTableWrapper::findByName(const ResourceName& name) { | |
| if (const std::shared_ptr<Symbol>& s = mCache.get(name)) { | |
| return s.get(); | |
| } | |
| Maybe<ResourceTable::SearchResult> result = mTable->findResource(name); | |
| if (!result) { | |
| if (name.type == ResourceType::kAttr) { | |
| // Recurse and try looking up a private attribute. | |
| return findByName(ResourceName(name.package, ResourceType::kAttrPrivate, name.entry)); | |
| } | |
| return {}; | |
| } | |
| ResourceTable::SearchResult sr = result.value(); | |
| // If no ID exists, we treat the symbol as missing. SymbolTables are used to | |
| // find symbols to link. | |
| if (!sr.package->id || !sr.type->id || !sr.entry->id) { | |
| return {}; | |
| } | |
| std::shared_ptr<Symbol> symbol = std::make_shared<Symbol>(); | |
| symbol->id = ResourceId(sr.package->id.value(), sr.type->id.value(), sr.entry->id.value()); | |
| symbol->isPublic = (sr.entry->symbolStatus.state == SymbolState::kPublic); | |
| if (name.type == ResourceType::kAttr || name.type == ResourceType::kAttrPrivate) { | |
| const ConfigDescription kDefaultConfig; | |
| auto iter = std::lower_bound(sr.entry->values.begin(), sr.entry->values.end(), | |
| kDefaultConfig, cmp::lessThanConfig); | |
| if (iter != sr.entry->values.end() && iter->config == kDefaultConfig) { | |
| // This resource has an Attribute. | |
| if (Attribute* attr = valueCast<Attribute>(iter->value.get())) { | |
| symbol->attribute = util::make_unique<Attribute>(*attr); | |
| } else { | |
| return {}; | |
| } | |
| } | |
| } | |
| if (name.type == ResourceType::kAttrPrivate) { | |
| // Masquerade this entry as kAttr. | |
| mCache.put(ResourceName(name.package, ResourceType::kAttr, name.entry), symbol); | |
| } else { | |
| mCache.put(name, symbol); | |
| } | |
| return symbol.get(); | |
| } | |
| static std::shared_ptr<ISymbolTable::Symbol> lookupAttributeInTable(const android::ResTable& table, | |
| ResourceId id) { | |
| // Try as a bag. | |
| const android::ResTable::bag_entry* entry; | |
| ssize_t count = table.lockBag(id.id, &entry); | |
| if (count < 0) { | |
| table.unlockBag(entry); | |
| return nullptr; | |
| } | |
| // We found a resource. | |
| std::shared_ptr<ISymbolTable::Symbol> s = std::make_shared<ISymbolTable::Symbol>(); | |
| s->id = id; | |
| // Check to see if it is an attribute. | |
| for (size_t i = 0; i < (size_t) count; i++) { | |
| if (entry[i].map.name.ident == android::ResTable_map::ATTR_TYPE) { | |
| s->attribute = util::make_unique<Attribute>(false); | |
| s->attribute->typeMask = entry[i].map.value.data; | |
| break; | |
| } | |
| } | |
| if (s->attribute) { | |
| for (size_t i = 0; i < (size_t) count; i++) { | |
| const android::ResTable_map& mapEntry = entry[i].map; | |
| if (Res_INTERNALID(mapEntry.name.ident)) { | |
| switch (mapEntry.name.ident) { | |
| case android::ResTable_map::ATTR_MIN: | |
| s->attribute->minInt = static_cast<int32_t>(mapEntry.value.data); | |
| break; | |
| case android::ResTable_map::ATTR_MAX: | |
| s->attribute->maxInt = static_cast<int32_t>(mapEntry.value.data); | |
| break; | |
| } | |
| continue; | |
| } | |
| android::ResTable::resource_name entryName; | |
| if (!table.getResourceName(mapEntry.name.ident, false, &entryName)) { | |
| table.unlockBag(entry); | |
| return nullptr; | |
| } | |
| const ResourceType* parsedType = parseResourceType( | |
| StringPiece16(entryName.type, entryName.typeLen)); | |
| if (!parsedType) { | |
| table.unlockBag(entry); | |
| return nullptr; | |
| } | |
| Attribute::Symbol symbol; | |
| symbol.symbol.name = ResourceName( | |
| StringPiece16(entryName.package, entryName.packageLen), | |
| *parsedType, | |
| StringPiece16(entryName.name, entryName.nameLen)); | |
| symbol.symbol.id = ResourceId(mapEntry.name.ident); | |
| symbol.value = mapEntry.value.data; | |
| s->attribute->symbols.push_back(std::move(symbol)); | |
| } | |
| } | |
| table.unlockBag(entry); | |
| return s; | |
| } | |
| const ISymbolTable::Symbol* AssetManagerSymbolTableBuilder::AssetManagerSymbolTable::findByName( | |
| const ResourceName& name) { | |
| if (const std::shared_ptr<Symbol>& s = mCache.get(name)) { | |
| return s.get(); | |
| } | |
| for (const auto& asset : mAssets) { | |
| const android::ResTable& table = asset->getResources(false); | |
| StringPiece16 typeStr = toString(name.type); | |
| uint32_t typeSpecFlags = 0; | |
| ResourceId resId = table.identifierForName(name.entry.data(), name.entry.size(), | |
| typeStr.data(), typeStr.size(), | |
| name.package.data(), name.package.size(), | |
| &typeSpecFlags); | |
| if (!resId.isValid()) { | |
| continue; | |
| } | |
| std::shared_ptr<Symbol> s; | |
| if (name.type == ResourceType::kAttr) { | |
| s = lookupAttributeInTable(table, resId); | |
| } else { | |
| s = std::make_shared<Symbol>(); | |
| s->id = resId; | |
| } | |
| if (s) { | |
| s->isPublic = (typeSpecFlags & android::ResTable_typeSpec::SPEC_PUBLIC) != 0; | |
| mCache.put(name, s); | |
| return s.get(); | |
| } | |
| } | |
| return nullptr; | |
| } | |
| static Maybe<ResourceName> getResourceName(const android::ResTable& table, ResourceId id) { | |
| android::ResTable::resource_name resName; | |
| if (!table.getResourceName(id.id, true, &resName)) { | |
| return {}; | |
| } | |
| ResourceName name; | |
| if (resName.package) { | |
| name.package = StringPiece16(resName.package, resName.packageLen).toString(); | |
| } | |
| const ResourceType* type; | |
| if (resName.type) { | |
| type = parseResourceType(StringPiece16(resName.type, resName.typeLen)); | |
| } else if (resName.type8) { | |
| type = parseResourceType(util::utf8ToUtf16(StringPiece(resName.type8, resName.typeLen))); | |
| } else { | |
| return {}; | |
| } | |
| if (!type) { | |
| return {}; | |
| } | |
| name.type = *type; | |
| if (resName.name) { | |
| name.entry = StringPiece16(resName.name, resName.nameLen).toString(); | |
| } else if (resName.name8) { | |
| name.entry = util::utf8ToUtf16(StringPiece(resName.name8, resName.nameLen)); | |
| } else { | |
| return {}; | |
| } | |
| return name; | |
| } | |
| const ISymbolTable::Symbol* AssetManagerSymbolTableBuilder::AssetManagerSymbolTable::findById( | |
| ResourceId id) { | |
| if (const std::shared_ptr<Symbol>& s = mIdCache.get(id)) { | |
| return s.get(); | |
| } | |
| for (const auto& asset : mAssets) { | |
| const android::ResTable& table = asset->getResources(false); | |
| Maybe<ResourceName> maybeName = getResourceName(table, id); | |
| if (!maybeName) { | |
| continue; | |
| } | |
| uint32_t typeSpecFlags = 0; | |
| table.getResourceFlags(id.id, &typeSpecFlags); | |
| std::shared_ptr<Symbol> s; | |
| if (maybeName.value().type == ResourceType::kAttr) { | |
| s = lookupAttributeInTable(table, id); | |
| } else { | |
| s = std::make_shared<Symbol>(); | |
| s->id = id; | |
| } | |
| if (s) { | |
| s->isPublic = (typeSpecFlags & android::ResTable_typeSpec::SPEC_PUBLIC) != 0; | |
| mIdCache.put(id, s); | |
| return s.get(); | |
| } | |
| } | |
| return nullptr; | |
| } | |
| const ISymbolTable::Symbol* JoinedSymbolTableBuilder::JoinedSymbolTable::findByName( | |
| const ResourceName& name) { | |
| for (auto& symbolTable : mSymbolTables) { | |
| if (const Symbol* s = symbolTable->findByName(name)) { | |
| return s; | |
| } | |
| } | |
| return {}; | |
| } | |
| const ISymbolTable::Symbol* JoinedSymbolTableBuilder::JoinedSymbolTable::findById(ResourceId id) { | |
| for (auto& symbolTable : mSymbolTables) { | |
| if (const Symbol* s = symbolTable->findById(id)) { | |
| return s; | |
| } | |
| } | |
| return {}; | |
| } | |
| } // namespace aapt |