AAPT2: Fix overlay support
Supports the <add-resource> tag and mimics old AAPT behavior of
not allowing new resources defined unless <add-resource> was used
or --auto-add-overlay was specified.
Change-Id: I9b461137357617ade37fd7045b418b8e6450b9c4
diff --git a/tools/aapt2/link/Link.cpp b/tools/aapt2/link/Link.cpp
index 33d9272..652e52f 100644
--- a/tools/aapt2/link/Link.cpp
+++ b/tools/aapt2/link/Link.cpp
@@ -57,6 +57,7 @@
bool staticLib = false;
bool verbose = false;
bool outputToDirectory = false;
+ bool autoAddOverlay = false;
Maybe<std::u16string> privateSymbols;
Maybe<std::u16string> minSdkVersionDefault;
Maybe<std::u16string> targetSdkVersionDefault;
@@ -104,23 +105,6 @@
mCollections.push_back(std::move(fileCollection));
}
- std::string buildResourceFileName(const ResourceFile& resFile) {
- std::stringstream out;
- out << "res/" << resFile.name.type;
- if (resFile.config != ConfigDescription{}) {
- out << "-" << resFile.config;
- }
- out << "/";
-
- if (mContext.getNameMangler()->shouldMangle(resFile.name.package)) {
- out << NameMangler::mangleEntry(resFile.name.package, resFile.name.entry);
- } else {
- out << resFile.name.entry;
- }
- out << file::getExtension(resFile.source.path);
- return out.str();
- }
-
/**
* Creates a SymbolTable that loads symbols from the various APKs and caches the
* results for faster lookup.
@@ -425,45 +409,28 @@
return false;
}
- if (!mTableMerger->merge(file->getSource(), table.get(), override)) {
- return false;
+ bool result = false;
+ if (override) {
+ result = mTableMerger->mergeOverlay(file->getSource(), table.get());
+ } else {
+ result = mTableMerger->merge(file->getSource(), table.get());
}
- return true;
+ return result;
}
- bool mergeCompiledFile(io::IFile* file, std::unique_ptr<ResourceFile> fileDesc, bool override) {
- // Apply the package name used for this compilation phase if none was specified.
- if (fileDesc->name.package.empty()) {
- fileDesc->name.package = mContext.getCompilationPackage().toString();
+ bool mergeCompiledFile(io::IFile* file, std::unique_ptr<ResourceFile> fileDesc, bool overlay) {
+ if (mOptions.verbose) {
+ mContext.getDiagnostics()->note(DiagMessage() << "adding " << file->getSource());
}
- // Mangle the name if necessary.
- ResourceNameRef resName = fileDesc->name;
- Maybe<ResourceName> mangledName = mContext.getNameMangler()->mangleName(fileDesc->name);
- if (mangledName) {
- resName = mangledName.value();
- }
-
- // If we are overriding resources, we supply a custom resolver function.
- std::function<int(Value*,Value*)> resolver;
- if (override) {
- resolver = [](Value* a, Value* b) -> int {
- int result = ResourceTable::resolveValueCollision(a, b);
- if (result == 0) {
- // Always accept the new value if it would normally conflict (override).
- result = 1;
- }
- return result;
- };
+ bool result = false;
+ if (overlay) {
+ result = mTableMerger->mergeFileOverlay(*fileDesc, file);
} else {
- // Otherwise use the default resolution.
- resolver = ResourceTable::resolveValueCollision;
+ result = mTableMerger->mergeFile(*fileDesc, file);
}
- // Add this file to the table.
- if (!mFinalTable.addFileReference(resName, fileDesc->config, fileDesc->source,
- util::utf8ToUtf16(buildResourceFileName(*fileDesc)),
- resolver, mContext.getDiagnostics())) {
+ if (!result) {
return false;
}
@@ -489,10 +456,6 @@
return false;
}
}
-
- // Now add this file for later processing. Once the table is assigned IDs, we can compile
- // this file.
- mFilesToProcess.insert(FileToProcess{ std::move(fileDesc), file });
return true;
}
@@ -509,8 +472,8 @@
}
bool error = false;
- for (const std::unique_ptr<io::IFile>& file : *collection) {
- if (!processFile(file.get(), override)) {
+ for (auto iter = collection->iterator(); iter->hasNext(); ) {
+ if (!processFile(iter->next(), override)) {
error = true;
}
}
@@ -588,7 +551,9 @@
return 1;
}
- mTableMerger = util::make_unique<TableMerger>(&mContext, &mFinalTable);
+ TableMergerOptions tableMergerOptions;
+ tableMergerOptions.autoAddOverlay = mOptions.autoAddOverlay;
+ mTableMerger = util::make_unique<TableMerger>(&mContext, &mFinalTable, tableMergerOptions);
if (mOptions.verbose) {
mContext.getDiagnostics()->note(
@@ -698,31 +663,47 @@
return 1;
}
- for (const FileToProcess& file : mFilesToProcess) {
- const StringPiece path = file.file->getSource().path;
+ for (auto& mergeEntry : mTableMerger->getFilesToMerge()) {
+ const ResourceKeyRef& key = mergeEntry.first;
+ const FileToMerge& fileToMerge = mergeEntry.second;
- if (file.fileExport->name.type != ResourceType::kRaw &&
- util::stringEndsWith<char>(path, ".xml.flat")) {
+ const StringPiece path = fileToMerge.file->getSource().path;
+
+ if (key.name.type != ResourceType::kRaw &&
+ (util::stringEndsWith<char>(path, ".xml.flat") ||
+ util::stringEndsWith<char>(path, ".xml"))) {
if (mOptions.verbose) {
mContext.getDiagnostics()->note(DiagMessage() << "linking " << path);
}
- std::unique_ptr<io::IData> data = file.file->openAsData();
+ io::IFile* file = fileToMerge.file;
+ std::unique_ptr<io::IData> data = file->openAsData();
if (!data) {
- mContext.getDiagnostics()->error(DiagMessage(file.file->getSource())
+ mContext.getDiagnostics()->error(DiagMessage(file->getSource())
<< "failed to open file");
return 1;
}
- std::unique_ptr<xml::XmlResource> xmlRes = loadBinaryXmlSkipFileExport(
- file.file->getSource(), data->data(), data->size(),
- mContext.getDiagnostics());
+ std::unique_ptr<xml::XmlResource> xmlRes;
+ if (util::stringEndsWith<char>(path, ".flat")) {
+ xmlRes = loadBinaryXmlSkipFileExport(file->getSource(),
+ data->data(), data->size(),
+ mContext.getDiagnostics());
+ } else {
+ xmlRes = xml::inflate(data->data(), data->size(), mContext.getDiagnostics(),
+ file->getSource());
+ }
+
if (!xmlRes) {
return 1;
}
- // Move the file description over.
- xmlRes->file = std::move(*file.fileExport);
+ // Create the file description header.
+ xmlRes->file = ResourceFile{
+ key.name.toResourceName(),
+ key.config,
+ fileToMerge.originalSource,
+ };
XmlReferenceLinker xmlLinker;
if (xmlLinker.consume(&mContext, xmlRes.get())) {
@@ -736,7 +717,7 @@
maxSdkLevel = std::max<size_t>(xmlRes->file.config.sdkVersion, 1u);
}
- if (!flattenXml(xmlRes.get(), buildResourceFileName(xmlRes->file), maxSdkLevel,
+ if (!flattenXml(xmlRes.get(), fileToMerge.dstPath, maxSdkLevel,
archiveWriter.get())) {
error = true;
}
@@ -750,19 +731,23 @@
xmlRes->file.config,
sdkLevel)) {
xmlRes->file.config.sdkVersion = sdkLevel;
+
+ std::string genResourcePath = ResourceUtils::buildResourceFileName(
+ xmlRes->file, mContext.getNameMangler());
+
bool added = mFinalTable.addFileReference(
xmlRes->file.name,
xmlRes->file.config,
xmlRes->file.source,
- util::utf8ToUtf16(buildResourceFileName(xmlRes->file)),
+ util::utf8ToUtf16(genResourcePath),
mContext.getDiagnostics());
if (!added) {
error = true;
continue;
}
- if (!flattenXml(xmlRes.get(), buildResourceFileName(xmlRes->file),
- sdkLevel, archiveWriter.get())) {
+ if (!flattenXml(xmlRes.get(), genResourcePath, sdkLevel,
+ archiveWriter.get())) {
error = true;
}
}
@@ -777,7 +762,7 @@
mContext.getDiagnostics()->note(DiagMessage() << "copying " << path);
}
- if (!copyFileToArchive(file.file, buildResourceFileName(*file.fileExport), 0,
+ if (!copyFileToArchive(fileToMerge.file, fileToMerge.dstPath, 0,
archiveWriter.get())) {
error = true;
}
@@ -845,15 +830,7 @@
if (mOptions.verbose) {
Debug::printTable(&mFinalTable);
- for (; !mTableMerger->getFileMergeQueue()->empty();
- mTableMerger->getFileMergeQueue()->pop()) {
- const FileToMerge& f = mTableMerger->getFileMergeQueue()->front();
- mContext.getDiagnostics()->note(
- DiagMessage() << f.srcPath << " -> " << f.dstPath << " from (0x"
- << std::hex << (uintptr_t) f.srcTable << std::dec);
- }
}
-
return 0;
}
@@ -861,24 +838,15 @@
LinkOptions mOptions;
LinkContext mContext;
ResourceTable mFinalTable;
+
+ ResourceTable mLocalFileTable;
std::unique_ptr<TableMerger> mTableMerger;
+ // A pointer to the FileCollection representing the filesystem (not archives).
io::FileCollection* mFileCollection;
+
+ // A vector of IFileCollections. This is mainly here to keep ownership of the collections.
std::vector<std::unique_ptr<io::IFileCollection>> mCollections;
-
- struct FileToProcess {
- std::unique_ptr<ResourceFile> fileExport;
- io::IFile* file;
- };
-
- struct FileToProcessComparator {
- bool operator()(const FileToProcess& a, const FileToProcess& b) {
- return std::tie(a.fileExport->name, a.fileExport->config) <
- std::tie(b.fileExport->name, b.fileExport->config);
- }
- };
-
- std::set<FileToProcess, FileToProcessComparator> mFilesToProcess;
};
int link(const std::vector<StringPiece>& args) {
@@ -915,6 +883,8 @@
"package name", &privateSymbolsPackage)
.optionalFlagList("--extra-packages", "Generate the same R.java but with different "
"package names", &extraJavaPackages)
+ .optionalSwitch("--auto-add-overlay", "Allows the addition of new resources in "
+ "overlays without <add-resource> tags", &options.autoAddOverlay)
.optionalSwitch("-v", "Enables verbose logging", &options.verbose);
if (!flags.parse("aapt2 link", args, &std::cerr)) {
diff --git a/tools/aapt2/link/TableMerger.cpp b/tools/aapt2/link/TableMerger.cpp
index a06a1bf..27a23bd 100644
--- a/tools/aapt2/link/TableMerger.cpp
+++ b/tools/aapt2/link/TableMerger.cpp
@@ -15,6 +15,7 @@
*/
#include "ResourceTable.h"
+#include "ResourceUtils.h"
#include "ResourceValues.h"
#include "ValueVisitor.h"
@@ -26,8 +27,9 @@
namespace aapt {
-TableMerger::TableMerger(IAaptContext* context, ResourceTable* outTable) :
- mContext(context), mMasterTable(outTable) {
+TableMerger::TableMerger(IAaptContext* context, ResourceTable* outTable,
+ const TableMergerOptions& options) :
+ mContext(context), mMasterTable(outTable), mOptions(options) {
// Create the desired package that all tables will be merged into.
mMasterPackage = mMasterTable->createPackage(
mContext->getCompilationPackage(), mContext->getPackageId());
@@ -37,7 +39,8 @@
/**
* This will merge packages with the same package name (or no package name).
*/
-bool TableMerger::merge(const Source& src, ResourceTable* table, bool overrideExisting) {
+bool TableMerger::mergeImpl(const Source& src, ResourceTable* table,
+ bool overlay, bool allowNew) {
const uint8_t desiredPackageId = mContext->getPackageId();
bool error = false;
@@ -55,19 +58,26 @@
// mangled, then looked up at resolution time.
// Also, when linking, we convert references with no package name to use
// the compilation package name.
- if (!doMerge(src, table, package.get(), false, overrideExisting)) {
- error = true;
- }
+ error |= !doMerge(src, table, package.get(),
+ false /* mangle */, overlay, allowNew, {});
}
}
return !error;
}
+bool TableMerger::merge(const Source& src, ResourceTable* table) {
+ return mergeImpl(src, table, false /* overlay */, true /* allow new */);
+}
+
+bool TableMerger::mergeOverlay(const Source& src, ResourceTable* table) {
+ return mergeImpl(src, table, true /* overlay */, mOptions.autoAddOverlay);
+}
+
/**
* This will merge and mangle resources from a static library.
*/
bool TableMerger::mergeAndMangle(const Source& src, const StringPiece16& packageName,
- ResourceTable* table) {
+ ResourceTable* table, io::IFileCollection* collection) {
bool error = false;
for (auto& package : table->packages) {
// Warn of packages with an unrelated ID.
@@ -79,16 +89,35 @@
bool mangle = packageName != mContext->getCompilationPackage();
mMergedPackages.insert(package->name);
- if (!doMerge(src, table, package.get(), mangle, false)) {
- error = true;
- }
+
+ auto callback = [&](const ResourceNameRef& name, const ConfigDescription& config,
+ FileReference* newFile, FileReference* oldFile) -> bool {
+ // The old file's path points inside the APK, so we can use it as is.
+ io::IFile* f = collection->findFile(util::utf16ToUtf8(*oldFile->path));
+ if (!f) {
+ mContext->getDiagnostics()->error(DiagMessage(src) << "file '" << *oldFile->path
+ << "' not found");
+ return false;
+ }
+
+ mFilesToMerge[ResourceKeyRef{ name, config }] = FileToMerge{
+ f, oldFile->getSource(), util::utf16ToUtf8(*newFile->path) };
+ return true;
+ };
+
+ error |= !doMerge(src, table, package.get(),
+ mangle, false /* overlay */, true /* allow new */, callback);
}
return !error;
}
-bool TableMerger::doMerge(const Source& src, ResourceTable* srcTable,
- ResourceTablePackage* srcPackage, const bool manglePackage,
- const bool overrideExisting) {
+bool TableMerger::doMerge(const Source& src,
+ ResourceTable* srcTable,
+ ResourceTablePackage* srcPackage,
+ const bool manglePackage,
+ const bool overlay,
+ const bool allowNewResources,
+ FileMergeCallback callback) {
bool error = false;
for (auto& srcType : srcPackage->types) {
@@ -112,10 +141,33 @@
for (auto& srcEntry : srcType->entries) {
ResourceEntry* dstEntry;
if (manglePackage) {
- dstEntry = dstType->findOrCreateEntry(NameMangler::mangleEntry(
- srcPackage->name, srcEntry->name));
+ std::u16string mangledName = NameMangler::mangleEntry(srcPackage->name,
+ srcEntry->name);
+ if (allowNewResources) {
+ dstEntry = dstType->findOrCreateEntry(mangledName);
+ } else {
+ dstEntry = dstType->findEntry(mangledName);
+ }
} else {
- dstEntry = dstType->findOrCreateEntry(srcEntry->name);
+ if (allowNewResources) {
+ dstEntry = dstType->findOrCreateEntry(srcEntry->name);
+ } else {
+ dstEntry = dstType->findEntry(srcEntry->name);
+ }
+ }
+
+ if (!dstEntry) {
+ mContext->getDiagnostics()->error(DiagMessage(src)
+ << "resource "
+ << ResourceNameRef(srcPackage->name,
+ srcType->type,
+ srcEntry->name)
+ << " does not override an existing resource");
+ mContext->getDiagnostics()->note(DiagMessage(src)
+ << "define an <add-resource> tag or use "
+ "--auto-add-overlay");
+ error = true;
+ continue;
}
if (srcEntry->symbolStatus.state != SymbolState::kUndefined) {
@@ -143,6 +195,8 @@
}
}
+ ResourceNameRef resName(mMasterPackage->name, dstType->type, dstEntry->name);
+
for (ResourceConfigValue& srcValue : srcEntry->values) {
auto iter = std::lower_bound(dstEntry->values.begin(), dstEntry->values.end(),
srcValue.config, cmp::lessThanConfig);
@@ -150,7 +204,7 @@
if (iter != dstEntry->values.end() && iter->config == srcValue.config) {
const int collisionResult = ResourceTable::resolveValueCollision(
iter->value.get(), srcValue.value.get());
- if (collisionResult == 0 && !overrideExisting) {
+ if (collisionResult == 0 && !overlay) {
// Error!
ResourceNameRef resourceName(srcPackage->name,
srcType->type,
@@ -175,10 +229,26 @@
iter = dstEntry->values.insert(iter, ResourceConfigValue{ srcValue.config });
}
- if (manglePackage) {
- iter->value = cloneAndMangle(srcTable, srcPackage->name, srcValue.value.get());
+ if (FileReference* f = valueCast<FileReference>(srcValue.value.get())) {
+ std::unique_ptr<FileReference> newFileRef;
+ if (manglePackage) {
+ newFileRef = cloneAndMangleFile(srcPackage->name, *f);
+ } else {
+ newFileRef = std::unique_ptr<FileReference>(f->clone(
+ &mMasterTable->stringPool));
+ }
+
+ if (callback) {
+ if (!callback(resName, iter->config, newFileRef.get(), f)) {
+ error = true;
+ continue;
+ }
+ }
+ iter->value = std::move(newFileRef);
+
} else {
- iter->value = clone(srcValue.value.get());
+ iter->value = std::unique_ptr<Value>(srcValue.value->clone(
+ &mMasterTable->stringPool));
}
}
}
@@ -186,28 +256,52 @@
return !error;
}
-std::unique_ptr<Value> TableMerger::cloneAndMangle(ResourceTable* table,
- const std::u16string& package,
- Value* value) {
- if (FileReference* f = valueCast<FileReference>(value)) {
- // Mangle the path.
- StringPiece16 prefix, entry, suffix;
- if (util::extractResFilePathParts(*f->path, &prefix, &entry, &suffix)) {
- std::u16string mangledEntry = NameMangler::mangleEntry(package, entry.toString());
- std::u16string newPath = prefix.toString() + mangledEntry + suffix.toString();
- mFilesToMerge.push(FileToMerge{ table, *f->path, newPath });
- std::unique_ptr<FileReference> fileRef = util::make_unique<FileReference>(
- mMasterTable->stringPool.makeRef(newPath));
- fileRef->setComment(f->getComment());
- fileRef->setSource(f->getSource());
- return std::move(fileRef);
- }
+std::unique_ptr<FileReference> TableMerger::cloneAndMangleFile(const std::u16string& package,
+ const FileReference& fileRef) {
+
+ StringPiece16 prefix, entry, suffix;
+ if (util::extractResFilePathParts(*fileRef.path, &prefix, &entry, &suffix)) {
+ std::u16string mangledEntry = NameMangler::mangleEntry(package, entry.toString());
+ std::u16string newPath = prefix.toString() + mangledEntry + suffix.toString();
+ std::unique_ptr<FileReference> newFileRef = util::make_unique<FileReference>(
+ mMasterTable->stringPool.makeRef(newPath));
+ newFileRef->setComment(fileRef.getComment());
+ newFileRef->setSource(fileRef.getSource());
+ return newFileRef;
}
- return clone(value);
+ return std::unique_ptr<FileReference>(fileRef.clone(&mMasterTable->stringPool));
}
-std::unique_ptr<Value> TableMerger::clone(Value* value) {
- return std::unique_ptr<Value>(value->clone(&mMasterTable->stringPool));
+bool TableMerger::mergeFileImpl(const ResourceFile& fileDesc, io::IFile* file, bool overlay) {
+ ResourceTable table;
+ std::u16string path = util::utf8ToUtf16(ResourceUtils::buildResourceFileName(fileDesc,
+ nullptr));
+ std::unique_ptr<FileReference> fileRef = util::make_unique<FileReference>(
+ table.stringPool.makeRef(path));
+ fileRef->setSource(fileDesc.source);
+
+ ResourceTablePackage* pkg = table.createPackage(fileDesc.name.package, 0x0);
+ pkg->findOrCreateType(fileDesc.name.type)
+ ->findOrCreateEntry(fileDesc.name.entry)
+ ->values.push_back(ResourceConfigValue{ fileDesc.config, std::move(fileRef) });
+
+ auto callback = [&](const ResourceNameRef& name, const ConfigDescription& config,
+ FileReference* newFile, FileReference* oldFile) -> bool {
+ mFilesToMerge[ResourceKeyRef{ name, config }] = FileToMerge{
+ file, oldFile->getSource(), util::utf16ToUtf8(*newFile->path) };
+ return true;
+ };
+
+ return doMerge(file->getSource(), &table, pkg,
+ false /* mangle */, overlay /* overlay */, true /* allow new */, callback);
+}
+
+bool TableMerger::mergeFile(const ResourceFile& fileDesc, io::IFile* file) {
+ return mergeFileImpl(fileDesc, file, false /* overlay */);
+}
+
+bool TableMerger::mergeFileOverlay(const ResourceFile& fileDesc, io::IFile* file) {
+ return mergeFileImpl(fileDesc, file, true /* overlay */);
}
} // namespace aapt
diff --git a/tools/aapt2/link/TableMerger.h b/tools/aapt2/link/TableMerger.h
index a2c9dbf..e1be5d5 100644
--- a/tools/aapt2/link/TableMerger.h
+++ b/tools/aapt2/link/TableMerger.h
@@ -17,21 +17,40 @@
#ifndef AAPT_TABLEMERGER_H
#define AAPT_TABLEMERGER_H
+#include "Resource.h"
#include "ResourceTable.h"
#include "ResourceValues.h"
+#include "io/File.h"
+#include "process/IResourceTableConsumer.h"
#include "util/Util.h"
-#include "process/IResourceTableConsumer.h"
-
-#include <queue>
-#include <set>
+#include <functional>
+#include <map>
namespace aapt {
struct FileToMerge {
- ResourceTable* srcTable;
- std::u16string srcPath;
- std::u16string dstPath;
+ /**
+ * The compiled file from which to read the data.
+ */
+ io::IFile* file;
+
+ /**
+ * Where the original, uncompiled file came from.
+ */
+ Source originalSource;
+
+ /**
+ * The destination path within the APK/archive.
+ */
+ std::string dstPath;
+};
+
+struct TableMergerOptions {
+ /**
+ * If true, resources in overlays can be added without previously having existed.
+ */
+ bool autoAddOverlay = false;
};
/**
@@ -50,40 +69,74 @@
*/
class TableMerger {
public:
- TableMerger(IAaptContext* context, ResourceTable* outTable);
+ /**
+ * Note: The outTable ResourceTable must live longer than this TableMerger. References
+ * are made to this ResourceTable for efficiency reasons.
+ */
+ TableMerger(IAaptContext* context, ResourceTable* outTable, const TableMergerOptions& options);
- inline std::queue<FileToMerge>* getFileMergeQueue() {
- return &mFilesToMerge;
+ const std::map<ResourceKeyRef, FileToMerge>& getFilesToMerge() {
+ return mFilesToMerge;
}
- inline const std::set<std::u16string>& getMergedPackages() const {
+ const std::set<std::u16string>& getMergedPackages() const {
return mMergedPackages;
}
/**
* Merges resources from the same or empty package. This is for local sources.
*/
- bool merge(const Source& src, ResourceTable* table, bool overrideExisting);
+ bool merge(const Source& src, ResourceTable* table);
+
+ /**
+ * Merges resources from an overlay ResourceTable.
+ */
+ bool mergeOverlay(const Source& src, ResourceTable* table);
/**
* Merges resources from the given package, mangling the name. This is for static libraries.
+ * An io::IFileCollection is needed in order to find the referenced Files and process them.
*/
- bool mergeAndMangle(const Source& src, const StringPiece16& package, ResourceTable* table);
+ bool mergeAndMangle(const Source& src, const StringPiece16& package, ResourceTable* table,
+ io::IFileCollection* collection);
+
+ /**
+ * Merges a compiled file that belongs to this same or empty package. This is for local sources.
+ */
+ bool mergeFile(const ResourceFile& fileDesc, io::IFile* file);
+
+ /**
+ * Merges a compiled file from an overlay, overriding an existing definition.
+ */
+ bool mergeFileOverlay(const ResourceFile& fileDesc, io::IFile* file);
private:
+ using FileMergeCallback = std::function<bool(const ResourceNameRef&,
+ const ConfigDescription& config,
+ FileReference*,
+ FileReference*)>;
+
IAaptContext* mContext;
ResourceTable* mMasterTable;
+ TableMergerOptions mOptions;
ResourceTablePackage* mMasterPackage;
std::set<std::u16string> mMergedPackages;
- std::queue<FileToMerge> mFilesToMerge;
+ std::map<ResourceKeyRef, FileToMerge> mFilesToMerge;
+
+ bool mergeFileImpl(const ResourceFile& fileDesc, io::IFile* file, bool overlay);
+
+ bool mergeImpl(const Source& src, ResourceTable* srcTable,
+ bool overlay, bool allowNew);
bool doMerge(const Source& src, ResourceTable* srcTable, ResourceTablePackage* srcPackage,
- const bool manglePackage, const bool overrideExisting);
+ const bool manglePackage,
+ const bool overlay,
+ const bool allowNewResources,
+ FileMergeCallback callback);
- std::unique_ptr<Value> cloneAndMangle(ResourceTable* table, const std::u16string& package,
- Value* value);
- std::unique_ptr<Value> clone(Value* value);
+ std::unique_ptr<FileReference> cloneAndMangleFile(const std::u16string& package,
+ const FileReference& value);
};
} // namespace aapt
diff --git a/tools/aapt2/link/TableMerger_test.cpp b/tools/aapt2/link/TableMerger_test.cpp
index b7ffba7..fa4afd3 100644
--- a/tools/aapt2/link/TableMerger_test.cpp
+++ b/tools/aapt2/link/TableMerger_test.cpp
@@ -14,8 +14,8 @@
* limitations under the License.
*/
+#include "io/FileSystem.h"
#include "link/TableMerger.h"
-
#include "test/Builders.h"
#include "test/Context.h"
@@ -57,10 +57,11 @@
.build();
ResourceTable finalTable;
- TableMerger merger(mContext.get(), &finalTable);
+ TableMerger merger(mContext.get(), &finalTable, TableMergerOptions{});
+ io::FileCollection collection;
- ASSERT_TRUE(merger.merge({}, tableA.get(), false));
- ASSERT_TRUE(merger.mergeAndMangle({}, u"com.app.b", tableB.get()));
+ ASSERT_TRUE(merger.merge({}, tableA.get()));
+ ASSERT_TRUE(merger.mergeAndMangle({}, u"com.app.b", tableB.get(), &collection));
EXPECT_TRUE(merger.getMergedPackages().count(u"com.app.b") != 0);
@@ -76,6 +77,60 @@
AAPT_EXPECT_TRUE(finalTable.findResource(test::parseNameOrDie(u"@com.app.a:id/com.app.b$foo")));
}
+TEST_F(TableMergerTest, MergeFile) {
+ ResourceTable finalTable;
+ TableMergerOptions options;
+ options.autoAddOverlay = false;
+ TableMerger merger(mContext.get(), &finalTable, options);
+
+ ResourceFile fileDesc;
+ fileDesc.config = test::parseConfigOrDie("hdpi-v4");
+ fileDesc.name = test::parseNameOrDie(u"@layout/main");
+ fileDesc.source = Source("res/layout-hdpi/main.xml");
+ test::TestFile testFile("path/to/res/layout-hdpi/main.xml.flat");
+
+ ASSERT_TRUE(merger.mergeFile(fileDesc, &testFile));
+
+ FileReference* file = test::getValueForConfig<FileReference>(&finalTable,
+ u"@com.app.a:layout/main",
+ test::parseConfigOrDie("hdpi-v4"));
+ ASSERT_NE(nullptr, file);
+ EXPECT_EQ(std::u16string(u"res/layout-hdpi-v4/main.xml"), *file->path);
+
+ ResourceName name = test::parseNameOrDie(u"@com.app.a:layout/main");
+ ResourceKeyRef key = { name, test::parseConfigOrDie("hdpi-v4") };
+
+ auto iter = merger.getFilesToMerge().find(key);
+ ASSERT_NE(merger.getFilesToMerge().end(), iter);
+
+ const FileToMerge& actualFileToMerge = iter->second;
+ EXPECT_EQ(&testFile, actualFileToMerge.file);
+ EXPECT_EQ(std::string("res/layout-hdpi-v4/main.xml"), actualFileToMerge.dstPath);
+}
+
+TEST_F(TableMergerTest, MergeFileOverlay) {
+ ResourceTable finalTable;
+ TableMergerOptions tableMergerOptions;
+ tableMergerOptions.autoAddOverlay = false;
+ TableMerger merger(mContext.get(), &finalTable, tableMergerOptions);
+
+ ResourceFile fileDesc;
+ fileDesc.name = test::parseNameOrDie(u"@xml/foo");
+ test::TestFile fileA("path/to/fileA.xml.flat");
+ test::TestFile fileB("path/to/fileB.xml.flat");
+
+ ASSERT_TRUE(merger.mergeFile(fileDesc, &fileA));
+ ASSERT_TRUE(merger.mergeFileOverlay(fileDesc, &fileB));
+
+ ResourceName name = test::parseNameOrDie(u"@com.app.a:xml/foo");
+ ResourceKeyRef key = { name, ConfigDescription{} };
+ auto iter = merger.getFilesToMerge().find(key);
+ ASSERT_NE(merger.getFilesToMerge().end(), iter);
+
+ const FileToMerge& actualFileToMerge = iter->second;
+ EXPECT_EQ(&fileB, actualFileToMerge.file);
+}
+
TEST_F(TableMergerTest, MergeFileReferences) {
std::unique_ptr<ResourceTable> tableA = test::ResourceTableBuilder()
.setPackageId(u"com.app.a", 0x7f)
@@ -87,10 +142,12 @@
.build();
ResourceTable finalTable;
- TableMerger merger(mContext.get(), &finalTable);
+ TableMerger merger(mContext.get(), &finalTable, TableMergerOptions{});
+ io::FileCollection collection;
+ collection.insertFile("res/xml/file.xml");
- ASSERT_TRUE(merger.merge({}, tableA.get(), false));
- ASSERT_TRUE(merger.mergeAndMangle({}, u"com.app.b", tableB.get()));
+ ASSERT_TRUE(merger.merge({}, tableA.get()));
+ ASSERT_TRUE(merger.mergeAndMangle({}, u"com.app.b", tableB.get(), &collection));
FileReference* f = test::getValue<FileReference>(&finalTable, u"@com.app.a:xml/file");
ASSERT_NE(f, nullptr);
@@ -100,13 +157,90 @@
ASSERT_NE(f, nullptr);
EXPECT_EQ(std::u16string(u"res/xml/com.app.b$file.xml"), *f->path);
- std::queue<FileToMerge>* filesToMerge = merger.getFileMergeQueue();
- ASSERT_FALSE(filesToMerge->empty());
+ ResourceName name = test::parseNameOrDie(u"@com.app.a:xml/com.app.b$file");
+ ResourceKeyRef key = { name, ConfigDescription{} };
+ auto iter = merger.getFilesToMerge().find(key);
+ ASSERT_NE(merger.getFilesToMerge().end(), iter);
- FileToMerge& fileToMerge = filesToMerge->front();
- EXPECT_EQ(fileToMerge.srcTable, tableB.get());
- EXPECT_EQ(fileToMerge.srcPath, u"res/xml/file.xml");
- EXPECT_EQ(fileToMerge.dstPath, u"res/xml/com.app.b$file.xml");
+ const FileToMerge& actualFileToMerge = iter->second;
+ EXPECT_EQ(Source("res/xml/file.xml"), actualFileToMerge.file->getSource());
+ EXPECT_EQ(std::string("res/xml/com.app.b$file.xml"), actualFileToMerge.dstPath);
+}
+
+TEST_F(TableMergerTest, OverrideResourceWithOverlay) {
+ std::unique_ptr<ResourceTable> base = test::ResourceTableBuilder()
+ .setPackageId(u"", 0x00)
+ .addValue(u"@bool/foo", ResourceUtils::tryParseBool(u"true"))
+ .build();
+ std::unique_ptr<ResourceTable> overlay = test::ResourceTableBuilder()
+ .setPackageId(u"", 0x00)
+ .addValue(u"@bool/foo", ResourceUtils::tryParseBool(u"false"))
+ .build();
+
+ ResourceTable finalTable;
+ TableMergerOptions tableMergerOptions;
+ tableMergerOptions.autoAddOverlay = false;
+ TableMerger merger(mContext.get(), &finalTable, tableMergerOptions);
+
+ ASSERT_TRUE(merger.merge({}, base.get()));
+ ASSERT_TRUE(merger.mergeOverlay({}, overlay.get()));
+
+ BinaryPrimitive* foo = test::getValue<BinaryPrimitive>(&finalTable, u"@com.app.a:bool/foo");
+ ASSERT_NE(nullptr, foo);
+ EXPECT_EQ(0x0u, foo->value.data);
+}
+
+TEST_F(TableMergerTest, MergeAddResourceFromOverlay) {
+ std::unique_ptr<ResourceTable> tableA = test::ResourceTableBuilder()
+ .setPackageId(u"", 0x7f)
+ .setSymbolState(u"@bool/foo", {}, SymbolState::kUndefined)
+ .build();
+ std::unique_ptr<ResourceTable> tableB = test::ResourceTableBuilder()
+ .setPackageId(u"", 0x7f)
+ .addValue(u"@bool/foo", ResourceUtils::tryParseBool(u"true"))
+ .build();
+
+ ResourceTable finalTable;
+ TableMerger merger(mContext.get(), &finalTable, TableMergerOptions{});
+
+ ASSERT_TRUE(merger.merge({}, tableA.get()));
+ ASSERT_TRUE(merger.mergeOverlay({}, tableB.get()));
+}
+
+TEST_F(TableMergerTest, MergeAddResourceFromOverlayWithAutoAddOverlay) {
+ std::unique_ptr<ResourceTable> tableA = test::ResourceTableBuilder()
+ .setPackageId(u"", 0x7f)
+ .build();
+ std::unique_ptr<ResourceTable> tableB = test::ResourceTableBuilder()
+ .setPackageId(u"", 0x7f)
+ .addValue(u"@bool/foo", ResourceUtils::tryParseBool(u"true"))
+ .build();
+
+ ResourceTable finalTable;
+ TableMergerOptions options;
+ options.autoAddOverlay = true;
+ TableMerger merger(mContext.get(), &finalTable, options);
+
+ ASSERT_TRUE(merger.merge({}, tableA.get()));
+ ASSERT_TRUE(merger.mergeOverlay({}, tableB.get()));
+}
+
+TEST_F(TableMergerTest, FailToMergeNewResourceWithoutAutoAddOverlay) {
+ std::unique_ptr<ResourceTable> tableA = test::ResourceTableBuilder()
+ .setPackageId(u"", 0x7f)
+ .build();
+ std::unique_ptr<ResourceTable> tableB = test::ResourceTableBuilder()
+ .setPackageId(u"", 0x7f)
+ .addValue(u"@bool/foo", ResourceUtils::tryParseBool(u"true"))
+ .build();
+
+ ResourceTable finalTable;
+ TableMergerOptions options;
+ options.autoAddOverlay = false;
+ TableMerger merger(mContext.get(), &finalTable, options);
+
+ ASSERT_TRUE(merger.merge({}, tableA.get()));
+ ASSERT_FALSE(merger.mergeOverlay({}, tableB.get()));
}
} // namespace aapt