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/io/File.h b/tools/aapt2/io/File.h
index 9fca398..b4d4971 100644
--- a/tools/aapt2/io/File.h
+++ b/tools/aapt2/io/File.h
@@ -52,6 +52,14 @@
virtual const Source& getSource() const = 0;
};
+class IFileCollectionIterator {
+public:
+ virtual ~IFileCollectionIterator() = default;
+
+ virtual bool hasNext() = 0;
+ virtual IFile* next() = 0;
+};
+
/**
* Interface for a collection of files, all of which share a common source. That source may
* simply be the filesystem, or a ZIP archive.
@@ -60,10 +68,8 @@
public:
virtual ~IFileCollection() = default;
- using const_iterator = std::vector<std::unique_ptr<IFile>>::const_iterator;
-
- virtual const_iterator begin() const = 0;
- virtual const_iterator end() const = 0;
+ virtual IFile* findFile(const StringPiece& path) = 0;
+ virtual std::unique_ptr<IFileCollectionIterator> iterator() = 0;
};
} // namespace io
diff --git a/tools/aapt2/io/FileSystem.cpp b/tools/aapt2/io/FileSystem.cpp
new file mode 100644
index 0000000..76f87ae
--- /dev/null
+++ b/tools/aapt2/io/FileSystem.cpp
@@ -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.
+ */
+
+#include "Source.h"
+#include "io/FileSystem.h"
+#include "util/Files.h"
+#include "util/Maybe.h"
+#include "util/StringPiece.h"
+#include "util/Util.h"
+
+#include <utils/FileMap.h>
+
+namespace aapt {
+namespace io {
+
+RegularFile::RegularFile(const Source& source) : mSource(source) {
+}
+
+std::unique_ptr<IData> RegularFile::openAsData() {
+ android::FileMap map;
+ if (Maybe<android::FileMap> map = file::mmapPath(mSource.path, nullptr)) {
+ return util::make_unique<MmappedData>(std::move(map.value()));
+ }
+ return {};
+}
+
+const Source& RegularFile::getSource() const {
+ return mSource;
+}
+
+FileCollectionIterator::FileCollectionIterator(FileCollection* collection) :
+ mCurrent(collection->mFiles.begin()), mEnd(collection->mFiles.end()) {
+}
+
+bool FileCollectionIterator::hasNext() {
+ return mCurrent != mEnd;
+}
+
+IFile* FileCollectionIterator::next() {
+ IFile* result = mCurrent->second.get();
+ ++mCurrent;
+ return result;
+}
+
+IFile* FileCollection::insertFile(const StringPiece& path) {
+ return (mFiles[path.toString()] = util::make_unique<RegularFile>(Source(path))).get();
+}
+
+IFile* FileCollection::findFile(const StringPiece& path) {
+ auto iter = mFiles.find(path.toString());
+ if (iter != mFiles.end()) {
+ return iter->second.get();
+ }
+ return nullptr;
+}
+
+std::unique_ptr<IFileCollectionIterator> FileCollection::iterator() {
+ return util::make_unique<FileCollectionIterator>(this);
+}
+
+} // namespace io
+} // namespace aapt
diff --git a/tools/aapt2/io/FileSystem.h b/tools/aapt2/io/FileSystem.h
index 5dbefcc..f0559c0 100644
--- a/tools/aapt2/io/FileSystem.h
+++ b/tools/aapt2/io/FileSystem.h
@@ -18,7 +18,8 @@
#define AAPT_IO_FILESYSTEM_H
#include "io/File.h"
-#include "util/Files.h"
+
+#include <map>
namespace aapt {
namespace io {
@@ -28,25 +29,28 @@
*/
class RegularFile : public IFile {
public:
- RegularFile(const Source& source) : mSource(source) {
- }
+ RegularFile(const Source& source);
- std::unique_ptr<IData> openAsData() override {
- android::FileMap map;
- if (Maybe<android::FileMap> map = file::mmapPath(mSource.path, nullptr)) {
- return util::make_unique<MmappedData>(std::move(map.value()));
- }
- return {};
- }
-
- const Source& getSource() const override {
- return mSource;
- }
+ std::unique_ptr<IData> openAsData() override;
+ const Source& getSource() const override;
private:
Source mSource;
};
+class FileCollection;
+
+class FileCollectionIterator : public IFileCollectionIterator {
+public:
+ FileCollectionIterator(FileCollection* collection);
+
+ bool hasNext() override;
+ io::IFile* next() override;
+
+private:
+ std::map<std::string, std::unique_ptr<IFile>>::const_iterator mCurrent, mEnd;
+};
+
/**
* An IFileCollection representing the file system.
*/
@@ -55,21 +59,13 @@
/**
* Adds a file located at path. Returns the IFile representation of that file.
*/
- IFile* insertFile(const StringPiece& path) {
- mFiles.push_back(util::make_unique<RegularFile>(Source(path)));
- return mFiles.back().get();
- }
-
- const_iterator begin() const override {
- return mFiles.begin();
- }
-
- const_iterator end() const override {
- return mFiles.end();
- }
+ IFile* insertFile(const StringPiece& path);
+ IFile* findFile(const StringPiece& path) override;
+ std::unique_ptr<IFileCollectionIterator> iterator() override;
private:
- std::vector<std::unique_ptr<IFile>> mFiles;
+ friend class FileCollectionIterator;
+ std::map<std::string, std::unique_ptr<IFile>> mFiles;
};
} // namespace io
diff --git a/tools/aapt2/io/ZipArchive.cpp b/tools/aapt2/io/ZipArchive.cpp
new file mode 100644
index 0000000..bf0f4aa
--- /dev/null
+++ b/tools/aapt2/io/ZipArchive.cpp
@@ -0,0 +1,135 @@
+/*
+ * 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 "Source.h"
+#include "io/ZipArchive.h"
+#include "util/Util.h"
+
+#include <utils/FileMap.h>
+#include <ziparchive/zip_archive.h>
+
+namespace aapt {
+namespace io {
+
+ZipFile::ZipFile(ZipArchiveHandle handle, const ZipEntry& entry, const Source& source) :
+ mZipHandle(handle), mZipEntry(entry), mSource(source) {
+}
+
+std::unique_ptr<IData> ZipFile::openAsData() {
+ if (mZipEntry.method == kCompressStored) {
+ int fd = GetFileDescriptor(mZipHandle);
+
+ android::FileMap fileMap;
+ bool result = fileMap.create(nullptr, fd, mZipEntry.offset,
+ mZipEntry.uncompressed_length, true);
+ if (!result) {
+ return {};
+ }
+ return util::make_unique<MmappedData>(std::move(fileMap));
+
+ } else {
+ std::unique_ptr<uint8_t[]> data = std::unique_ptr<uint8_t[]>(
+ new uint8_t[mZipEntry.uncompressed_length]);
+ int32_t result = ExtractToMemory(mZipHandle, &mZipEntry, data.get(),
+ static_cast<uint32_t>(mZipEntry.uncompressed_length));
+ if (result != 0) {
+ return {};
+ }
+ return util::make_unique<MallocData>(std::move(data), mZipEntry.uncompressed_length);
+ }
+}
+
+const Source& ZipFile::getSource() const {
+ return mSource;
+}
+
+ZipFileCollectionIterator::ZipFileCollectionIterator(ZipFileCollection* collection) :
+ mCurrent(collection->mFiles.begin()), mEnd(collection->mFiles.end()) {
+}
+
+bool ZipFileCollectionIterator::hasNext() {
+ return mCurrent != mEnd;
+}
+
+IFile* ZipFileCollectionIterator::next() {
+ IFile* result = mCurrent->second.get();
+ ++mCurrent;
+ return result;
+}
+
+ZipFileCollection::ZipFileCollection() : mHandle(nullptr) {
+}
+
+std::unique_ptr<ZipFileCollection> ZipFileCollection::create(const StringPiece& path,
+ std::string* outError) {
+ std::unique_ptr<ZipFileCollection> collection = std::unique_ptr<ZipFileCollection>(
+ new ZipFileCollection());
+
+ int32_t result = OpenArchive(path.data(), &collection->mHandle);
+ if (result != 0) {
+ if (outError) *outError = ErrorCodeString(result);
+ return {};
+ }
+
+ ZipString suffix(".flat");
+ void* cookie = nullptr;
+ result = StartIteration(collection->mHandle, &cookie, nullptr, &suffix);
+ if (result != 0) {
+ if (outError) *outError = ErrorCodeString(result);
+ return {};
+ }
+
+ using IterationEnder = std::unique_ptr<void, decltype(EndIteration)*>;
+ IterationEnder iterationEnder(cookie, EndIteration);
+
+ ZipString zipEntryName;
+ ZipEntry zipData;
+ while ((result = Next(cookie, &zipData, &zipEntryName)) == 0) {
+ std::string zipEntryPath = std::string(reinterpret_cast<const char*>(zipEntryName.name),
+ zipEntryName.name_length);
+ std::string nestedPath = path.toString() + "@" + zipEntryPath;
+ collection->mFiles[zipEntryPath] = util::make_unique<ZipFile>(collection->mHandle,
+ zipData,
+ Source(nestedPath));
+ }
+
+ if (result != -1) {
+ if (outError) *outError = ErrorCodeString(result);
+ return {};
+ }
+ return collection;
+}
+
+IFile* ZipFileCollection::findFile(const StringPiece& path) {
+ auto iter = mFiles.find(path.toString());
+ if (iter != mFiles.end()) {
+ return iter->second.get();
+ }
+ return nullptr;
+}
+
+std::unique_ptr<IFileCollectionIterator> ZipFileCollection::iterator() {
+ return util::make_unique<ZipFileCollectionIterator>(this);
+}
+
+ZipFileCollection::~ZipFileCollection() {
+ if (mHandle) {
+ CloseArchive(mHandle);
+ }
+}
+
+} // namespace io
+} // namespace aapt
diff --git a/tools/aapt2/io/ZipArchive.h b/tools/aapt2/io/ZipArchive.h
index 98afc49..5ad119d 100644
--- a/tools/aapt2/io/ZipArchive.h
+++ b/tools/aapt2/io/ZipArchive.h
@@ -20,7 +20,7 @@
#include "io/File.h"
#include "util/StringPiece.h"
-#include <utils/FileMap.h>
+#include <map>
#include <ziparchive/zip_archive.h>
namespace aapt {
@@ -32,37 +32,10 @@
*/
class ZipFile : public IFile {
public:
- ZipFile(ZipArchiveHandle handle, const ZipEntry& entry, const Source& source) :
- mZipHandle(handle), mZipEntry(entry), mSource(source) {
- }
+ ZipFile(ZipArchiveHandle handle, const ZipEntry& entry, const Source& source);
- std::unique_ptr<IData> openAsData() override {
- if (mZipEntry.method == kCompressStored) {
- int fd = GetFileDescriptor(mZipHandle);
-
- android::FileMap fileMap;
- bool result = fileMap.create(nullptr, fd, mZipEntry.offset,
- mZipEntry.uncompressed_length, true);
- if (!result) {
- return {};
- }
- return util::make_unique<MmappedData>(std::move(fileMap));
-
- } else {
- std::unique_ptr<uint8_t[]> data = std::unique_ptr<uint8_t[]>(
- new uint8_t[mZipEntry.uncompressed_length]);
- int32_t result = ExtractToMemory(mZipHandle, &mZipEntry, data.get(),
- static_cast<uint32_t>(mZipEntry.uncompressed_length));
- if (result != 0) {
- return {};
- }
- return util::make_unique<MallocData>(std::move(data), mZipEntry.uncompressed_length);
- }
- }
-
- const Source& getSource() const override {
- return mSource;
- }
+ std::unique_ptr<IData> openAsData() override;
+ const Source& getSource() const override;
private:
ZipArchiveHandle mZipHandle;
@@ -70,71 +43,38 @@
Source mSource;
};
+class ZipFileCollection;
+
+class ZipFileCollectionIterator : public IFileCollectionIterator {
+public:
+ ZipFileCollectionIterator(ZipFileCollection* collection);
+
+ bool hasNext() override;
+ io::IFile* next() override;
+
+private:
+ std::map<std::string, std::unique_ptr<IFile>>::const_iterator mCurrent, mEnd;
+};
+
/**
* An IFileCollection that represents a ZIP archive and the entries within it.
*/
class ZipFileCollection : public IFileCollection {
public:
static std::unique_ptr<ZipFileCollection> create(const StringPiece& path,
- std::string* outError) {
- std::unique_ptr<ZipFileCollection> collection = std::unique_ptr<ZipFileCollection>(
- new ZipFileCollection());
+ std::string* outError);
- int32_t result = OpenArchive(path.data(), &collection->mHandle);
- if (result != 0) {
- if (outError) *outError = ErrorCodeString(result);
- return {};
- }
+ io::IFile* findFile(const StringPiece& path) override;
+ std::unique_ptr<IFileCollectionIterator> iterator() override;
- ZipString suffix(".flat");
- void* cookie = nullptr;
- result = StartIteration(collection->mHandle, &cookie, nullptr, &suffix);
- if (result != 0) {
- if (outError) *outError = ErrorCodeString(result);
- return {};
- }
-
- using IterationEnder = std::unique_ptr<void, decltype(EndIteration)*>;
- IterationEnder iterationEnder(cookie, EndIteration);
-
- ZipString zipEntryName;
- ZipEntry zipData;
- while ((result = Next(cookie, &zipData, &zipEntryName)) == 0) {
- std::string nestedPath = path.toString();
- nestedPath += "@" + std::string(reinterpret_cast<const char*>(zipEntryName.name),
- zipEntryName.name_length);
- collection->mFiles.push_back(util::make_unique<ZipFile>(collection->mHandle,
- zipData,
- Source(nestedPath)));
- }
-
- if (result != -1) {
- if (outError) *outError = ErrorCodeString(result);
- return {};
- }
- return collection;
- }
-
- const_iterator begin() const override {
- return mFiles.begin();
- }
-
- const_iterator end() const override {
- return mFiles.end();
- }
-
- ~ZipFileCollection() override {
- if (mHandle) {
- CloseArchive(mHandle);
- }
- }
+ ~ZipFileCollection() override;
private:
- ZipFileCollection() : mHandle(nullptr) {
- }
+ friend class ZipFileCollectionIterator;
+ ZipFileCollection();
ZipArchiveHandle mHandle;
- std::vector<std::unique_ptr<IFile>> mFiles;
+ std::map<std::string, std::unique_ptr<IFile>> mFiles;
};
} // namespace io