AAPT2: Separate out the various steps
An early refactor. Some ideas became clearer as
development continued. Now the various phases are much
clearer and more easily reusable.
Also added a ton of tests!
Change-Id: Ic8f0a70c8222370352e63533b329c40457c0903e
diff --git a/tools/aapt2/process/IResourceTableConsumer.h b/tools/aapt2/process/IResourceTableConsumer.h
new file mode 100644
index 0000000..24ad05d
--- /dev/null
+++ b/tools/aapt2/process/IResourceTableConsumer.h
@@ -0,0 +1,75 @@
+/*
+ * 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.
+ */
+
+#ifndef AAPT_PROCESS_IRESOURCETABLECONSUMER_H
+#define AAPT_PROCESS_IRESOURCETABLECONSUMER_H
+
+#include "Diagnostics.h"
+#include "NameMangler.h"
+#include "Resource.h"
+#include "ResourceValues.h"
+#include "Source.h"
+
+#include <iostream>
+#include <list>
+#include <sstream>
+
+namespace aapt {
+
+class ResourceTable;
+struct ISymbolTable;
+
+struct IAaptContext {
+ virtual ~IAaptContext() = default;
+
+ virtual ISymbolTable* getExternalSymbols() = 0;
+ virtual IDiagnostics* getDiagnostics() = 0;
+ virtual StringPiece16 getCompilationPackage() = 0;
+ virtual uint8_t getPackageId() = 0;
+ virtual NameMangler* getNameMangler() = 0;
+};
+
+struct IResourceTableConsumer {
+ virtual ~IResourceTableConsumer() = default;
+
+ virtual bool consume(IAaptContext* context, ResourceTable* table) = 0;
+};
+
+namespace xml {
+struct Node;
+}
+
+struct XmlResource {
+ ResourceFile file;
+ std::unique_ptr<xml::Node> root;
+};
+
+struct IXmlResourceConsumer {
+ virtual ~IXmlResourceConsumer() = default;
+
+ virtual bool consume(IAaptContext* context, XmlResource* resource) = 0;
+};
+
+struct IPackageDeclStack {
+ virtual ~IPackageDeclStack() = default;
+
+ virtual Maybe<ResourceName> transformPackage(const ResourceName& name,
+ const StringPiece16& localPackage) const = 0;
+};
+
+} // namespace aapt
+
+#endif /* AAPT_PROCESS_IRESOURCETABLECONSUMER_H */
diff --git a/tools/aapt2/process/SymbolTable.cpp b/tools/aapt2/process/SymbolTable.cpp
new file mode 100644
index 0000000..c96b080
--- /dev/null
+++ b/tools/aapt2/process/SymbolTable.cpp
@@ -0,0 +1,204 @@
+/*
+ * 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 "util/Util.h"
+
+#include "process/SymbolTable.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() };
+
+ if (name.type == ResourceType::kAttr || name.type == ResourceType::kAttrPrivate) {
+ auto lt = [](ResourceConfigValue& lhs, const ConfigDescription& rhs) -> bool {
+ return lhs.config < rhs;
+ };
+
+ const ConfigDescription kDefaultConfig;
+ auto iter = std::lower_bound(sr.entry->values.begin(), sr.entry->values.end(),
+ kDefaultConfig, lt);
+
+ if (iter != sr.entry->values.end() && iter->config == kDefaultConfig) {
+ // This resource has an Attribute.
+ symbol->attribute = util::make_unique<Attribute>(
+ *static_cast<Attribute*>(iter->value.get()));
+ }
+ }
+
+ 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> lookupIdInTable(const android::ResTable& table,
+ ResourceId id) {
+ android::Res_value val = {};
+ ssize_t block = table.getResource(id.id, &val, true);
+ if (block >= 0) {
+ std::shared_ptr<ISymbolTable::Symbol> s = std::make_shared<ISymbolTable::Symbol>();
+ s->id = id;
+ return s;
+ }
+
+ // 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++) {
+ if (!Res_INTERNALID(entry[i].map.name.ident)) {
+ android::ResTable::resource_name entryName;
+ if (!table.getResourceName(entry[i].map.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 = ResourceNameRef(
+ StringPiece16(entryName.package, entryName.packageLen),
+ *parsedType,
+ StringPiece16(entryName.name, entryName.nameLen)).toResourceName();
+ symbol.symbol.id = ResourceId(entry[i].map.name.ident);
+ symbol.value = entry[i].map.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);
+ ResourceId resId = table.identifierForName(name.entry.data(), name.entry.size(),
+ typeStr.data(), typeStr.size(),
+ name.package.data(), name.package.size());
+ if (!resId.isValid()) {
+ continue;
+ }
+
+ std::shared_ptr<Symbol> s = lookupIdInTable(table, resId);
+ if (s) {
+ mCache.put(name, s);
+ return s.get();
+ }
+ }
+ return nullptr;
+}
+
+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);
+
+ std::shared_ptr<Symbol> s = lookupIdInTable(table, id);
+ if (s) {
+ 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
diff --git a/tools/aapt2/process/SymbolTable.h b/tools/aapt2/process/SymbolTable.h
new file mode 100644
index 0000000..22096ed
--- /dev/null
+++ b/tools/aapt2/process/SymbolTable.h
@@ -0,0 +1,152 @@
+/*
+ * 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.
+ */
+
+#ifndef AAPT_PROCESS_SYMBOLTABLE_H
+#define AAPT_PROCESS_SYMBOLTABLE_H
+
+#include "Resource.h"
+#include "ResourceTable.h"
+#include "ResourceValues.h"
+#include "util/Util.h"
+
+#include <utils/JenkinsHash.h>
+#include <utils/LruCache.h>
+
+#include <androidfw/AssetManager.h>
+#include <algorithm>
+#include <map>
+#include <memory>
+#include <vector>
+
+namespace aapt {
+
+struct ISymbolTable {
+ virtual ~ISymbolTable() = default;
+
+ struct Symbol {
+ ResourceId id;
+ std::unique_ptr<Attribute> attribute;
+ bool isPublic;
+ };
+
+ /**
+ * Never hold on to the result between calls to findByName or findById. The results
+ * are typically stored in a cache which may evict entries.
+ */
+ virtual const Symbol* findByName(const ResourceName& name) = 0;
+ virtual const Symbol* findById(ResourceId id) = 0;
+};
+
+inline android::hash_t hash_type(const ResourceName& name) {
+ std::hash<std::u16string> strHash;
+ android::hash_t hash = 0;
+ hash = android::JenkinsHashMix(hash, strHash(name.package));
+ hash = android::JenkinsHashMix(hash, (uint32_t) name.type);
+ hash = android::JenkinsHashMix(hash, strHash(name.entry));
+ return hash;
+}
+
+inline android::hash_t hash_type(const ResourceId& id) {
+ return android::hash_type(id.id);
+}
+
+/**
+ * Presents a ResourceTable as an ISymbolTable, caching results.
+ * Instances of this class must outlive the encompassed ResourceTable.
+ * Since symbols are cached, the ResourceTable should not change during the
+ * lifetime of this SymbolTableWrapper.
+ *
+ * If a resource in the ResourceTable does not have a ResourceID assigned to it,
+ * it is ignored.
+ *
+ * Lookups by ID are ignored.
+ */
+class SymbolTableWrapper : public ISymbolTable {
+private:
+ ResourceTable* mTable;
+
+ // We use shared_ptr because unique_ptr is not supported and
+ // we need automatic deletion.
+ android::LruCache<ResourceName, std::shared_ptr<Symbol>> mCache;
+
+public:
+ SymbolTableWrapper(ResourceTable* table) : mTable(table), mCache(200) {
+ }
+
+ const Symbol* findByName(const ResourceName& name) override;
+
+ // Unsupported, all queries to ResourceTable should be done by name.
+ const Symbol* findById(ResourceId id) override {
+ return {};
+ }
+};
+
+class AssetManagerSymbolTableBuilder {
+private:
+ struct AssetManagerSymbolTable : public ISymbolTable {
+ std::vector<std::unique_ptr<android::AssetManager>> mAssets;
+
+ // We use shared_ptr because unique_ptr is not supported and
+ // we need automatic deletion.
+ android::LruCache<ResourceName, std::shared_ptr<Symbol>> mCache;
+ android::LruCache<ResourceId, std::shared_ptr<Symbol>> mIdCache;
+
+ AssetManagerSymbolTable() : mCache(200), mIdCache(200) {
+ }
+
+ const Symbol* findByName(const ResourceName& name) override;
+ const Symbol* findById(ResourceId id) override;
+ };
+
+ std::unique_ptr<AssetManagerSymbolTable> mSymbolTable =
+ util::make_unique<AssetManagerSymbolTable>();
+
+public:
+ AssetManagerSymbolTableBuilder& add(std::unique_ptr<android::AssetManager> assetManager) {
+ mSymbolTable->mAssets.push_back(std::move(assetManager));
+ return *this;
+ }
+
+ std::unique_ptr<ISymbolTable> build() {
+ return std::move(mSymbolTable);
+ }
+};
+
+class JoinedSymbolTableBuilder {
+private:
+ struct JoinedSymbolTable : public ISymbolTable {
+ std::vector<std::unique_ptr<ISymbolTable>> mSymbolTables;
+
+ const Symbol* findByName(const ResourceName& name) override;
+ const Symbol* findById(ResourceId id) override;
+ };
+
+ std::unique_ptr<JoinedSymbolTable> mSymbolTable = util::make_unique<JoinedSymbolTable>();
+
+public:
+ JoinedSymbolTableBuilder& addSymbolTable(std::unique_ptr<ISymbolTable> table) {
+ mSymbolTable->mSymbolTables.push_back(std::move(table));
+ return *this;
+ }
+
+ std::unique_ptr<ISymbolTable> build() {
+ return std::move(mSymbolTable);
+ }
+};
+
+} // namespace aapt
+
+#endif /* AAPT_PROCESS_SYMBOLTABLE_H */
diff --git a/tools/aapt2/process/SymbolTable_test.cpp b/tools/aapt2/process/SymbolTable_test.cpp
new file mode 100644
index 0000000..1dc3b4f
--- /dev/null
+++ b/tools/aapt2/process/SymbolTable_test.cpp
@@ -0,0 +1,56 @@
+/*
+ * 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 "process/SymbolTable.h"
+#include "test/Builders.h"
+#include "test/Context.h"
+
+#include <gtest/gtest.h>
+
+namespace aapt {
+
+TEST(SymbolTableWrapperTest, FindSymbolsWithIds) {
+ std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
+ .addSimple(u"@android:id/foo", ResourceId(0x01020000))
+ .addSimple(u"@android:id/bar")
+ .addValue(u"@android:attr/foo", ResourceId(0x01010000),
+ test::AttributeBuilder().build())
+ .build();
+
+ SymbolTableWrapper symbolTable(table.get());
+ EXPECT_NE(symbolTable.findByName(test::parseNameOrDie(u"@android:id/foo")), nullptr);
+ EXPECT_EQ(symbolTable.findByName(test::parseNameOrDie(u"@android:id/bar")), nullptr);
+
+ const ISymbolTable::Symbol* s = symbolTable.findByName(
+ test::parseNameOrDie(u"@android:attr/foo"));
+ ASSERT_NE(s, nullptr);
+ EXPECT_NE(s->attribute, nullptr);
+}
+
+TEST(SymbolTableWrapperTest, FindPrivateAttrSymbol) {
+ std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
+ .addValue(u"@android:^attr-private/foo", ResourceId(0x01010000),
+ test::AttributeBuilder().build())
+ .build();
+
+ SymbolTableWrapper symbolTable(table.get());
+ const ISymbolTable::Symbol* s = symbolTable.findByName(
+ test::parseNameOrDie(u"@android:attr/foo"));
+ ASSERT_NE(s, nullptr);
+ EXPECT_NE(s->attribute, nullptr);
+}
+
+} // namespace aapt