diff options
Diffstat (limited to 'tools/aapt2')
119 files changed, 24133 insertions, 0 deletions
diff --git a/tools/aapt2/Android.mk b/tools/aapt2/Android.mk new file mode 100644 index 0000000..10f8150 --- /dev/null +++ b/tools/aapt2/Android.mk @@ -0,0 +1,157 @@ +# +# 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. +# + +# This tool is prebuilt if we're doing an app-only build. +ifeq ($(TARGET_BUILD_APPS)$(filter true,$(TARGET_BUILD_PDK)),) + +# ========================================================== +# Setup some common variables for the different build +# targets here. +# ========================================================== +LOCAL_PATH:= $(call my-dir) + +main := Main.cpp +sources := \ + BigBuffer.cpp \ + BinaryResourceParser.cpp \ + BindingXmlPullParser.cpp \ + ConfigDescription.cpp \ + Debug.cpp \ + Files.cpp \ + Flag.cpp \ + JavaClassGenerator.cpp \ + Linker.cpp \ + Locale.cpp \ + Logger.cpp \ + ManifestMerger.cpp \ + ManifestParser.cpp \ + ManifestValidator.cpp \ + Png.cpp \ + ProguardRules.cpp \ + ResChunkPullParser.cpp \ + Resource.cpp \ + ResourceParser.cpp \ + ResourceTable.cpp \ + ResourceTableResolver.cpp \ + ResourceValues.cpp \ + SdkConstants.cpp \ + StringPool.cpp \ + TableFlattener.cpp \ + Util.cpp \ + ScopedXmlPullParser.cpp \ + SourceXmlPullParser.cpp \ + XliffXmlPullParser.cpp \ + XmlDom.cpp \ + XmlFlattener.cpp \ + ZipEntry.cpp \ + ZipFile.cpp + +testSources := \ + BigBuffer_test.cpp \ + BindingXmlPullParser_test.cpp \ + Compat_test.cpp \ + ConfigDescription_test.cpp \ + JavaClassGenerator_test.cpp \ + Linker_test.cpp \ + Locale_test.cpp \ + ManifestMerger_test.cpp \ + ManifestParser_test.cpp \ + Maybe_test.cpp \ + NameMangler_test.cpp \ + ResourceParser_test.cpp \ + Resource_test.cpp \ + ResourceTable_test.cpp \ + ScopedXmlPullParser_test.cpp \ + StringPiece_test.cpp \ + StringPool_test.cpp \ + Util_test.cpp \ + XliffXmlPullParser_test.cpp \ + XmlDom_test.cpp \ + XmlFlattener_test.cpp + +cIncludes := \ + external/libpng \ + external/libz + +hostLdLibs := + +hostStaticLibs := \ + libandroidfw \ + libutils \ + liblog \ + libcutils \ + libexpat \ + libziparchive-host \ + libpng \ + libbase + +ifneq ($(strip $(USE_MINGW)),) + hostStaticLibs += libz +else + hostLdLibs += -lz +endif + +cFlags := -Wall -Werror -Wno-unused-parameter -UNDEBUG +cppFlags := -std=c++11 -Wno-missing-field-initializers -Wno-unused-private-field + +# ========================================================== +# Build the host static library: libaapt2 +# ========================================================== +include $(CLEAR_VARS) +LOCAL_MODULE := libaapt2 + +LOCAL_SRC_FILES := $(sources) +LOCAL_C_INCLUDES += $(cIncludes) +LOCAL_CFLAGS += $(cFlags) +LOCAL_CPPFLAGS += $(cppFlags) + +include $(BUILD_HOST_STATIC_LIBRARY) + + +# ========================================================== +# Build the host tests: libaapt2_tests +# ========================================================== +include $(CLEAR_VARS) +LOCAL_MODULE := libaapt2_tests +LOCAL_MODULE_TAGS := tests + +LOCAL_SRC_FILES := $(testSources) + +LOCAL_C_INCLUDES += $(cIncludes) +LOCAL_STATIC_LIBRARIES += libaapt2 $(hostStaticLibs) +LOCAL_LDLIBS += $(hostLdLibs) +LOCAL_CFLAGS += $(cFlags) +LOCAL_CPPFLAGS += $(cppFlags) + +include $(BUILD_HOST_NATIVE_TEST) + +# ========================================================== +# Build the host executable: aapt2 +# ========================================================== +include $(CLEAR_VARS) +LOCAL_MODULE := aapt2 + +LOCAL_SRC_FILES := $(main) + +LOCAL_C_INCLUDES += $(cIncludes) +LOCAL_STATIC_LIBRARIES += libaapt2 $(hostStaticLibs) +LOCAL_LDLIBS += $(hostLdLibs) +LOCAL_CFLAGS += $(cFlags) +LOCAL_CPPFLAGS += $(cppFlags) + +include $(BUILD_HOST_EXECUTABLE) + +endif # No TARGET_BUILD_APPS or TARGET_BUILD_PDK diff --git a/tools/aapt2/AppInfo.h b/tools/aapt2/AppInfo.h new file mode 100644 index 0000000..30047f7 --- /dev/null +++ b/tools/aapt2/AppInfo.h @@ -0,0 +1,37 @@ +/* + * 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_APP_INFO_H +#define AAPT_APP_INFO_H + +#include <string> + +namespace aapt { + +/** + * Holds basic information about the app being built. Most of this information + * will come from the app's AndroidManifest. + */ +struct AppInfo { + /** + * App's package name. + */ + std::u16string package; +}; + +} // namespace aapt + +#endif // AAPT_APP_INFO_H diff --git a/tools/aapt2/BigBuffer.cpp b/tools/aapt2/BigBuffer.cpp new file mode 100644 index 0000000..8f57172 --- /dev/null +++ b/tools/aapt2/BigBuffer.cpp @@ -0,0 +1,52 @@ +/* + * 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 "BigBuffer.h" + +#include <algorithm> +#include <memory> +#include <vector> + +namespace aapt { + +void* BigBuffer::nextBlockImpl(size_t size) { + if (!mBlocks.empty()) { + Block& block = mBlocks.back(); + if (block.mBlockSize - block.size >= size) { + void* outBuffer = block.buffer.get() + block.size; + block.size += size; + mSize += size; + return outBuffer; + } + } + + const size_t actualSize = std::max(mBlockSize, size); + + Block block = {}; + + // Zero-allocate the block's buffer. + block.buffer = std::unique_ptr<uint8_t[]>(new uint8_t[actualSize]()); + assert(block.buffer); + + block.size = size; + block.mBlockSize = actualSize; + + mBlocks.push_back(std::move(block)); + mSize += size; + return mBlocks.back().buffer.get(); +} + +} // namespace aapt diff --git a/tools/aapt2/BigBuffer.h b/tools/aapt2/BigBuffer.h new file mode 100644 index 0000000..8b6569c --- /dev/null +++ b/tools/aapt2/BigBuffer.h @@ -0,0 +1,159 @@ +/* + * 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_BIG_BUFFER_H +#define AAPT_BIG_BUFFER_H + +#include <cassert> +#include <cstring> +#include <memory> +#include <vector> + +namespace aapt { + +/** + * Inspired by protobuf's ZeroCopyOutputStream, offers blocks of memory + * in which to write without knowing the full size of the entire payload. + * This is essentially a list of memory blocks. As one fills up, another + * block is allocated and appended to the end of the list. + */ +class BigBuffer { +public: + /** + * A contiguous block of allocated memory. + */ + struct Block { + /** + * Pointer to the memory. + */ + std::unique_ptr<uint8_t[]> buffer; + + /** + * Size of memory that is currently occupied. The actual + * allocation may be larger. + */ + size_t size; + + private: + friend class BigBuffer; + + /** + * The size of the memory block allocation. + */ + size_t mBlockSize; + }; + + typedef std::vector<Block>::const_iterator const_iterator; + + /** + * Create a BigBuffer with block allocation sizes + * of blockSize. + */ + BigBuffer(size_t blockSize); + + BigBuffer(const BigBuffer&) = delete; // No copying. + + BigBuffer(BigBuffer&& rhs); + + /** + * Number of occupied bytes in all the allocated blocks. + */ + size_t size() const; + + /** + * Returns a pointer to an array of T, where T is + * a POD type. The elements are zero-initialized. + */ + template <typename T> + T* nextBlock(size_t count = 1); + + /** + * Moves the specified BigBuffer into this one. When this method + * returns, buffer is empty. + */ + void appendBuffer(BigBuffer&& buffer); + + /** + * Pads the block with 'bytes' bytes of zero values. + */ + void pad(size_t bytes); + + /** + * Pads the block so that it aligns on a 4 byte boundary. + */ + void align4(); + + const_iterator begin() const; + const_iterator end() const; + +private: + /** + * Returns a pointer to a buffer of the requested size. + * The buffer is zero-initialized. + */ + void* nextBlockImpl(size_t size); + + size_t mBlockSize; + size_t mSize; + std::vector<Block> mBlocks; +}; + +inline BigBuffer::BigBuffer(size_t blockSize) : mBlockSize(blockSize), mSize(0) { +} + +inline BigBuffer::BigBuffer(BigBuffer&& rhs) : + mBlockSize(rhs.mBlockSize), mSize(rhs.mSize), mBlocks(std::move(rhs.mBlocks)) { +} + +inline size_t BigBuffer::size() const { + return mSize; +} + +template <typename T> +inline T* BigBuffer::nextBlock(size_t count) { + assert(count != 0); + return reinterpret_cast<T*>(nextBlockImpl(sizeof(T) * count)); +} + +inline void BigBuffer::appendBuffer(BigBuffer&& buffer) { + std::move(buffer.mBlocks.begin(), buffer.mBlocks.end(), std::back_inserter(mBlocks)); + mSize += buffer.mSize; + buffer.mBlocks.clear(); + buffer.mSize = 0; +} + +inline void BigBuffer::pad(size_t bytes) { + nextBlock<char>(bytes); +} + +inline void BigBuffer::align4() { + const size_t unaligned = mSize % 4; + if (unaligned != 0) { + pad(4 - unaligned); + } +} + +inline BigBuffer::const_iterator BigBuffer::begin() const { + return mBlocks.begin(); +} + +inline BigBuffer::const_iterator BigBuffer::end() const { + return mBlocks.end(); +} + +} // namespace aapt + +#endif // AAPT_BIG_BUFFER_H diff --git a/tools/aapt2/BigBuffer_test.cpp b/tools/aapt2/BigBuffer_test.cpp new file mode 100644 index 0000000..01ee8d7 --- /dev/null +++ b/tools/aapt2/BigBuffer_test.cpp @@ -0,0 +1,98 @@ +/* + * 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 "BigBuffer.h" + +#include <gtest/gtest.h> + +namespace aapt { + +TEST(BigBufferTest, AllocateSingleBlock) { + BigBuffer buffer(4); + + EXPECT_NE(nullptr, buffer.nextBlock<char>(2)); + EXPECT_EQ(2u, buffer.size()); +} + +TEST(BigBufferTest, ReturnSameBlockIfNextAllocationFits) { + BigBuffer buffer(16); + + char* b1 = buffer.nextBlock<char>(8); + EXPECT_NE(nullptr, b1); + + char* b2 = buffer.nextBlock<char>(4); + EXPECT_NE(nullptr, b2); + + EXPECT_EQ(b1 + 8, b2); +} + +TEST(BigBufferTest, AllocateExactSizeBlockIfLargerThanBlockSize) { + BigBuffer buffer(16); + + EXPECT_NE(nullptr, buffer.nextBlock<char>(32)); + EXPECT_EQ(32u, buffer.size()); +} + +TEST(BigBufferTest, AppendAndMoveBlock) { + BigBuffer buffer(16); + + uint32_t* b1 = buffer.nextBlock<uint32_t>(); + ASSERT_NE(nullptr, b1); + *b1 = 33; + + { + BigBuffer buffer2(16); + b1 = buffer2.nextBlock<uint32_t>(); + ASSERT_NE(nullptr, b1); + *b1 = 44; + + buffer.appendBuffer(std::move(buffer2)); + EXPECT_EQ(0u, buffer2.size()); + EXPECT_EQ(buffer2.begin(), buffer2.end()); + } + + EXPECT_EQ(2 * sizeof(uint32_t), buffer.size()); + + auto b = buffer.begin(); + ASSERT_NE(b, buffer.end()); + ASSERT_EQ(sizeof(uint32_t), b->size); + ASSERT_EQ(33u, *reinterpret_cast<uint32_t*>(b->buffer.get())); + ++b; + + ASSERT_NE(b, buffer.end()); + ASSERT_EQ(sizeof(uint32_t), b->size); + ASSERT_EQ(44u, *reinterpret_cast<uint32_t*>(b->buffer.get())); + ++b; + + ASSERT_EQ(b, buffer.end()); +} + +TEST(BigBufferTest, PadAndAlignProperly) { + BigBuffer buffer(16); + + ASSERT_NE(buffer.nextBlock<char>(2), nullptr); + ASSERT_EQ(2u, buffer.size()); + buffer.pad(2); + ASSERT_EQ(4u, buffer.size()); + buffer.align4(); + ASSERT_EQ(4u, buffer.size()); + buffer.pad(2); + ASSERT_EQ(6u, buffer.size()); + buffer.align4(); + ASSERT_EQ(8u, buffer.size()); +} + +} // namespace aapt diff --git a/tools/aapt2/BinaryResourceParser.cpp b/tools/aapt2/BinaryResourceParser.cpp new file mode 100644 index 0000000..3559f43 --- /dev/null +++ b/tools/aapt2/BinaryResourceParser.cpp @@ -0,0 +1,877 @@ +/* + * 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 "BinaryResourceParser.h" +#include "Logger.h" +#include "ResChunkPullParser.h" +#include "Resolver.h" +#include "ResourceParser.h" +#include "ResourceTable.h" +#include "ResourceTypeExtensions.h" +#include "ResourceValues.h" +#include "Source.h" +#include "Util.h" + +#include <androidfw/ResourceTypes.h> +#include <androidfw/TypeWrappers.h> +#include <map> +#include <string> + +namespace aapt { + +using namespace android; + +/* + * Visitor that converts a reference's resource ID to a resource name, + * given a mapping from resource ID to resource name. + */ +struct ReferenceIdToNameVisitor : ValueVisitor { + ReferenceIdToNameVisitor(const std::shared_ptr<IResolver>& resolver, + std::map<ResourceId, ResourceName>* cache) : + mResolver(resolver), mCache(cache) { + } + + void visit(Reference& reference, ValueVisitorArgs&) override { + idToName(reference); + } + + void visit(Attribute& attr, ValueVisitorArgs&) override { + for (auto& entry : attr.symbols) { + idToName(entry.symbol); + } + } + + void visit(Style& style, ValueVisitorArgs&) override { + if (style.parent.id.isValid()) { + idToName(style.parent); + } + + for (auto& entry : style.entries) { + idToName(entry.key); + entry.value->accept(*this, {}); + } + } + + void visit(Styleable& styleable, ValueVisitorArgs&) override { + for (auto& attr : styleable.entries) { + idToName(attr); + } + } + + void visit(Array& array, ValueVisitorArgs&) override { + for (auto& item : array.items) { + item->accept(*this, {}); + } + } + + void visit(Plural& plural, ValueVisitorArgs&) override { + for (auto& item : plural.values) { + if (item) { + item->accept(*this, {}); + } + } + } + +private: + void idToName(Reference& reference) { + if (!reference.id.isValid()) { + return; + } + + auto cacheIter = mCache->find(reference.id); + if (cacheIter != mCache->end()) { + reference.name = cacheIter->second; + reference.id = 0; + } else { + Maybe<ResourceName> result = mResolver->findName(reference.id); + if (result) { + reference.name = result.value(); + + // Add to cache. + mCache->insert({reference.id, reference.name}); + + reference.id = 0; + } + } + } + + std::shared_ptr<IResolver> mResolver; + std::map<ResourceId, ResourceName>* mCache; +}; + + +BinaryResourceParser::BinaryResourceParser(const std::shared_ptr<ResourceTable>& table, + const std::shared_ptr<IResolver>& resolver, + const Source& source, + const void* data, + size_t len) : + mTable(table), mResolver(resolver), mSource(source), mData(data), mDataLen(len) { +} + +bool BinaryResourceParser::parse() { + ResChunkPullParser parser(mData, mDataLen); + + bool error = false; + while(ResChunkPullParser::isGoodEvent(parser.next())) { + if (parser.getChunk()->type != android::RES_TABLE_TYPE) { + Logger::warn(mSource) + << "unknown chunk of type '" + << parser.getChunk()->type + << "'." + << std::endl; + continue; + } + + error |= !parseTable(parser.getChunk()); + } + + if (parser.getEvent() == ResChunkPullParser::Event::BadDocument) { + Logger::error(mSource) + << "bad document: " + << parser.getLastError() + << "." + << std::endl; + return false; + } + return !error; +} + +bool BinaryResourceParser::getSymbol(const void* data, ResourceNameRef* outSymbol) { + if (!mSymbolEntries || mSymbolEntryCount == 0) { + return false; + } + + if (reinterpret_cast<uintptr_t>(data) < reinterpret_cast<uintptr_t>(mData)) { + return false; + } + + // We only support 32 bit offsets right now. + const uintptr_t offset = reinterpret_cast<uintptr_t>(data) - + reinterpret_cast<uintptr_t>(mData); + if (offset > std::numeric_limits<uint32_t>::max()) { + return false; + } + + for (size_t i = 0; i < mSymbolEntryCount; i++) { + if (mSymbolEntries[i].offset == offset) { + // This offset is a symbol! + const StringPiece16 str = util::getString(mSymbolPool, + mSymbolEntries[i].stringIndex); + StringPiece16 typeStr; + ResourceParser::extractResourceName(str, &outSymbol->package, &typeStr, + &outSymbol->entry); + const ResourceType* type = parseResourceType(typeStr); + if (!type) { + return false; + } + outSymbol->type = *type; + + // Since we scan the symbol table in order, we can start looking for the + // next symbol from this point. + mSymbolEntryCount -= i + 1; + mSymbolEntries += i + 1; + return true; + } + } + return false; +} + +bool BinaryResourceParser::parseSymbolTable(const ResChunk_header* chunk) { + const SymbolTable_header* symbolTableHeader = convertTo<SymbolTable_header>(chunk); + if (!symbolTableHeader) { + Logger::error(mSource) + << "could not parse chunk as SymbolTable_header." + << std::endl; + return false; + } + + const size_t entrySizeBytes = symbolTableHeader->count * sizeof(SymbolTable_entry); + if (entrySizeBytes > getChunkDataLen(symbolTableHeader->header)) { + Logger::error(mSource) + << "entries extend beyond chunk." + << std::endl; + return false; + } + + mSymbolEntries = reinterpret_cast<const SymbolTable_entry*>( + getChunkData(symbolTableHeader->header)); + mSymbolEntryCount = symbolTableHeader->count; + + ResChunkPullParser parser(getChunkData(symbolTableHeader->header) + entrySizeBytes, + getChunkDataLen(symbolTableHeader->header) - entrySizeBytes); + if (!ResChunkPullParser::isGoodEvent(parser.next())) { + Logger::error(mSource) + << "failed to parse chunk: " + << parser.getLastError() + << "." + << std::endl; + return false; + } + + if (parser.getChunk()->type != android::RES_STRING_POOL_TYPE) { + Logger::error(mSource) + << "expected Symbol string pool." + << std::endl; + return false; + } + + if (mSymbolPool.setTo(parser.getChunk(), parser.getChunk()->size) != NO_ERROR) { + Logger::error(mSource) + << "failed to parse symbol string pool with code: " + << mSymbolPool.getError() + << "." + << std::endl; + return false; + } + return true; +} + +bool BinaryResourceParser::parseTable(const ResChunk_header* chunk) { + const ResTable_header* tableHeader = convertTo<ResTable_header>(chunk); + if (!tableHeader) { + Logger::error(mSource) + << "could not parse chunk as ResTable_header." + << std::endl; + return false; + } + + ResChunkPullParser parser(getChunkData(tableHeader->header), + getChunkDataLen(tableHeader->header)); + while (ResChunkPullParser::isGoodEvent(parser.next())) { + switch (parser.getChunk()->type) { + case android::RES_STRING_POOL_TYPE: + if (mValuePool.getError() == NO_INIT) { + if (mValuePool.setTo(parser.getChunk(), parser.getChunk()->size) != + NO_ERROR) { + Logger::error(mSource) + << "failed to parse value string pool with code: " + << mValuePool.getError() + << "." + << std::endl; + return false; + } + + // Reserve some space for the strings we are going to add. + mTable->getValueStringPool().hintWillAdd( + mValuePool.size(), mValuePool.styleCount()); + } else { + Logger::warn(mSource) + << "unexpected string pool." + << std::endl; + } + break; + + case RES_TABLE_SYMBOL_TABLE_TYPE: + if (!parseSymbolTable(parser.getChunk())) { + return false; + } + break; + + case RES_TABLE_SOURCE_POOL_TYPE: { + if (mSourcePool.setTo(getChunkData(*parser.getChunk()), + getChunkDataLen(*parser.getChunk())) != NO_ERROR) { + Logger::error(mSource) + << "failed to parse source pool with code: " + << mSourcePool.getError() + << "." + << std::endl; + return false; + } + break; + } + + case android::RES_TABLE_PACKAGE_TYPE: + if (!parsePackage(parser.getChunk())) { + return false; + } + break; + + default: + Logger::warn(mSource) + << "unexpected chunk of type " + << parser.getChunk()->type + << "." + << std::endl; + break; + } + } + + if (parser.getEvent() == ResChunkPullParser::Event::BadDocument) { + Logger::error(mSource) + << "bad resource table: " << parser.getLastError() + << "." + << std::endl; + return false; + } + return true; +} + +bool BinaryResourceParser::parsePackage(const ResChunk_header* chunk) { + if (mValuePool.getError() != NO_ERROR) { + Logger::error(mSource) + << "no value string pool for ResTable." + << std::endl; + return false; + } + + const ResTable_package* packageHeader = convertTo<ResTable_package>(chunk); + if (!packageHeader) { + Logger::error(mSource) + << "could not parse chunk as ResTable_header." + << std::endl; + return false; + } + + if (mTable->getPackageId() == ResourceTable::kUnsetPackageId) { + // This is the first time the table has it's package ID set. + mTable->setPackageId(packageHeader->id); + } else if (mTable->getPackageId() != packageHeader->id) { + Logger::error(mSource) + << "ResTable_package has package ID " + << std::hex << packageHeader->id << std::dec + << " but ResourceTable has package ID " + << std::hex << mTable->getPackageId() << std::dec + << std::endl; + return false; + } + + size_t len = strnlen16(reinterpret_cast<const char16_t*>(packageHeader->name), + sizeof(packageHeader->name) / sizeof(packageHeader->name[0])); + mTable->setPackage(StringPiece16(reinterpret_cast<const char16_t*>(packageHeader->name), len)); + + ResChunkPullParser parser(getChunkData(packageHeader->header), + getChunkDataLen(packageHeader->header)); + while (ResChunkPullParser::isGoodEvent(parser.next())) { + switch (parser.getChunk()->type) { + case android::RES_STRING_POOL_TYPE: + if (mTypePool.getError() == NO_INIT) { + if (mTypePool.setTo(parser.getChunk(), parser.getChunk()->size) != + NO_ERROR) { + Logger::error(mSource) + << "failed to parse type string pool with code " + << mTypePool.getError() + << "." + << std::endl; + return false; + } + } else if (mKeyPool.getError() == NO_INIT) { + if (mKeyPool.setTo(parser.getChunk(), parser.getChunk()->size) != + NO_ERROR) { + Logger::error(mSource) + << "failed to parse key string pool with code " + << mKeyPool.getError() + << "." + << std::endl; + return false; + } + } else { + Logger::warn(mSource) + << "unexpected string pool." + << std::endl; + } + break; + + case android::RES_TABLE_TYPE_SPEC_TYPE: + if (!parseTypeSpec(parser.getChunk())) { + return false; + } + break; + + case android::RES_TABLE_TYPE_TYPE: + if (!parseType(parser.getChunk())) { + return false; + } + break; + + case RES_TABLE_PUBLIC_TYPE: + if (!parsePublic(parser.getChunk())) { + return false; + } + break; + + default: + Logger::warn(mSource) + << "unexpected chunk of type " + << parser.getChunk()->type + << "." + << std::endl; + break; + } + } + + if (parser.getEvent() == ResChunkPullParser::Event::BadDocument) { + Logger::error(mSource) + << "bad package: " + << parser.getLastError() + << "." + << std::endl; + return false; + } + + // Now go through the table and change resource ID references to + // symbolic references. + + ReferenceIdToNameVisitor visitor(mResolver, &mIdIndex); + for (auto& type : *mTable) { + for (auto& entry : type->entries) { + for (auto& configValue : entry->values) { + configValue.value->accept(visitor, {}); + } + } + } + return true; +} + +bool BinaryResourceParser::parsePublic(const ResChunk_header* chunk) { + const Public_header* header = convertTo<Public_header>(chunk); + + if (header->typeId == 0) { + Logger::error(mSource) + << "invalid type ID " << header->typeId << std::endl; + return false; + } + + const ResourceType* parsedType = parseResourceType(util::getString(mTypePool, + header->typeId - 1)); + if (!parsedType) { + Logger::error(mSource) + << "invalid type " << util::getString(mTypePool, header->typeId - 1) << std::endl; + return false; + } + + const uintptr_t chunkEnd = reinterpret_cast<uintptr_t>(chunk) + chunk->size; + const Public_entry* entry = reinterpret_cast<const Public_entry*>( + getChunkData(header->header)); + for (uint32_t i = 0; i < header->count; i++) { + if (reinterpret_cast<uintptr_t>(entry) + sizeof(*entry) > chunkEnd) { + Logger::error(mSource) + << "Public_entry extends beyond chunk." + << std::endl; + return false; + } + + const ResourceId resId = { mTable->getPackageId(), header->typeId, entry->entryId }; + const ResourceName name = { + mTable->getPackage(), + *parsedType, + util::getString(mKeyPool, entry->key.index).toString() }; + + SourceLine source; + if (mSourcePool.getError() == NO_ERROR) { + source.path = util::utf16ToUtf8(util::getString(mSourcePool, entry->source.index)); + source.line = entry->sourceLine; + } + + if (!mTable->markPublicAllowMangled(name, resId, source)) { + return false; + } + + // Add this resource name->id mapping to the index so + // that we can resolve all ID references to name references. + auto cacheIter = mIdIndex.find(resId); + if (cacheIter == mIdIndex.end()) { + mIdIndex.insert({ resId, name }); + } + + entry++; + } + return true; +} + +bool BinaryResourceParser::parseTypeSpec(const ResChunk_header* chunk) { + if (mTypePool.getError() != NO_ERROR) { + Logger::error(mSource) + << "no type string pool available for ResTable_typeSpec." + << std::endl; + return false; + } + + const ResTable_typeSpec* typeSpec = convertTo<ResTable_typeSpec>(chunk); + if (!typeSpec) { + Logger::error(mSource) + << "could not parse chunk as ResTable_typeSpec." + << std::endl; + return false; + } + + if (typeSpec->id == 0) { + Logger::error(mSource) + << "ResTable_typeSpec has invalid id: " + << typeSpec->id + << "." + << std::endl; + return false; + } + return true; +} + +bool BinaryResourceParser::parseType(const ResChunk_header* chunk) { + if (mTypePool.getError() != NO_ERROR) { + Logger::error(mSource) + << "no type string pool available for ResTable_typeSpec." + << std::endl; + return false; + } + + if (mKeyPool.getError() != NO_ERROR) { + Logger::error(mSource) + << "no key string pool available for ResTable_type." + << std::endl; + return false; + } + + const ResTable_type* type = convertTo<ResTable_type>(chunk); + if (!type) { + Logger::error(mSource) + << "could not parse chunk as ResTable_type." + << std::endl; + return false; + } + + if (type->id == 0) { + Logger::error(mSource) + << "ResTable_type has invalid id: " + << type->id + << "." + << std::endl; + return false; + } + + const ConfigDescription config(type->config); + const StringPiece16 typeName = util::getString(mTypePool, type->id - 1); + + const ResourceType* parsedType = parseResourceType(typeName); + if (!parsedType) { + Logger::error(mSource) + << "invalid type name '" + << typeName + << "' for type with ID " + << uint32_t(type->id) + << "." << std::endl; + return false; + } + + android::TypeVariant tv(type); + for (auto it = tv.beginEntries(); it != tv.endEntries(); ++it) { + if (!*it) { + continue; + } + + const ResTable_entry* entry = *it; + const ResourceName name = { + mTable->getPackage(), + *parsedType, + util::getString(mKeyPool, entry->key.index).toString() + }; + + const ResourceId resId = { mTable->getPackageId(), type->id, it.index() }; + + std::unique_ptr<Value> resourceValue; + const ResTable_entry_source* sourceBlock = nullptr; + if (entry->flags & ResTable_entry::FLAG_COMPLEX) { + const ResTable_map_entry* mapEntry = static_cast<const ResTable_map_entry*>(entry); + if (mapEntry->size - sizeof(*mapEntry) == sizeof(*sourceBlock)) { + const uint8_t* data = reinterpret_cast<const uint8_t*>(mapEntry); + data += mapEntry->size - sizeof(*sourceBlock); + sourceBlock = reinterpret_cast<const ResTable_entry_source*>(data); + } + + // TODO(adamlesinski): Check that the entry count is valid. + resourceValue = parseMapEntry(name, config, mapEntry); + } else { + if (entry->size - sizeof(*entry) == sizeof(*sourceBlock)) { + const uint8_t* data = reinterpret_cast<const uint8_t*>(entry); + data += entry->size - sizeof(*sourceBlock); + sourceBlock = reinterpret_cast<const ResTable_entry_source*>(data); + } + + const Res_value* value = reinterpret_cast<const Res_value*>( + reinterpret_cast<const uint8_t*>(entry) + entry->size); + resourceValue = parseValue(name, config, value, entry->flags); + } + + if (!resourceValue) { + // TODO(adamlesinski): For now this is ok, but it really shouldn't be. + continue; + } + + SourceLine source = mSource.line(0); + if (sourceBlock) { + size_t len; + const char* str = mSourcePool.string8At(sourceBlock->pathIndex, &len); + if (str) { + source.path.assign(str, len); + } + source.line = sourceBlock->line; + } + + if (!mTable->addResourceAllowMangled(name, config, source, std::move(resourceValue))) { + return false; + } + + if ((entry->flags & ResTable_entry::FLAG_PUBLIC) != 0) { + if (!mTable->markPublicAllowMangled(name, resId, mSource.line(0))) { + return false; + } + } + + // Add this resource name->id mapping to the index so + // that we can resolve all ID references to name references. + auto cacheIter = mIdIndex.find(resId); + if (cacheIter == mIdIndex.end()) { + mIdIndex.insert({ resId, name }); + } + } + return true; +} + +std::unique_ptr<Item> BinaryResourceParser::parseValue(const ResourceNameRef& name, + const ConfigDescription& config, + const Res_value* value, + uint16_t flags) { + if (name.type == ResourceType::kId) { + return util::make_unique<Id>(); + } + + if (value->dataType == Res_value::TYPE_STRING) { + StringPiece16 str = util::getString(mValuePool, value->data); + + const ResStringPool_span* spans = mValuePool.styleAt(value->data); + if (spans != nullptr) { + StyleString styleStr = { str.toString() }; + while (spans->name.index != ResStringPool_span::END) { + styleStr.spans.push_back(Span{ + util::getString(mValuePool, spans->name.index).toString(), + spans->firstChar, + spans->lastChar + }); + spans++; + } + return util::make_unique<StyledString>( + mTable->getValueStringPool().makeRef( + styleStr, StringPool::Context{1, config})); + } else { + if (name.type != ResourceType::kString && + util::stringStartsWith<char16_t>(str, u"res/")) { + // This must be a FileReference. + return util::make_unique<FileReference>(mTable->getValueStringPool().makeRef( + str, StringPool::Context{ 0, config })); + } + + // There are no styles associated with this string, so treat it as + // a simple string. + return util::make_unique<String>( + mTable->getValueStringPool().makeRef( + str, StringPool::Context{1, config})); + } + } + + if (value->dataType == Res_value::TYPE_REFERENCE || + value->dataType == Res_value::TYPE_ATTRIBUTE) { + const Reference::Type type = (value->dataType == Res_value::TYPE_REFERENCE) ? + Reference::Type::kResource : Reference::Type::kAttribute; + + if (value->data != 0) { + // This is a normal reference. + return util::make_unique<Reference>(value->data, type); + } + + // This reference has an invalid ID. Check if it is an unresolved symbol. + ResourceNameRef symbol; + if (getSymbol(&value->data, &symbol)) { + return util::make_unique<Reference>(symbol, type); + } + + // This is not an unresolved symbol, so it must be the magic @null reference. + Res_value nullType = {}; + nullType.dataType = Res_value::TYPE_REFERENCE; + return util::make_unique<BinaryPrimitive>(nullType); + } + + if (value->dataType == ExtendedTypes::TYPE_RAW_STRING) { + return util::make_unique<RawString>( + mTable->getValueStringPool().makeRef(util::getString(mValuePool, value->data), + StringPool::Context{ 1, config })); + } + + // Treat this as a raw binary primitive. + return util::make_unique<BinaryPrimitive>(*value); +} + +std::unique_ptr<Value> BinaryResourceParser::parseMapEntry(const ResourceNameRef& name, + const ConfigDescription& config, + const ResTable_map_entry* map) { + switch (name.type) { + case ResourceType::kStyle: + return parseStyle(name, config, map); + case ResourceType::kAttr: + return parseAttr(name, config, map); + case ResourceType::kArray: + return parseArray(name, config, map); + case ResourceType::kStyleable: + return parseStyleable(name, config, map); + case ResourceType::kPlurals: + return parsePlural(name, config, map); + default: + break; + } + return {}; +} + +std::unique_ptr<Style> BinaryResourceParser::parseStyle(const ResourceNameRef& name, + const ConfigDescription& config, + const ResTable_map_entry* map) { + std::unique_ptr<Style> style = util::make_unique<Style>(); + if (map->parent.ident == 0) { + // The parent is either not set or it is an unresolved symbol. + // Check to see if it is a symbol. + ResourceNameRef symbol; + if (getSymbol(&map->parent.ident, &symbol)) { + style->parent.name = symbol.toResourceName(); + } + } else { + // The parent is a regular reference to a resource. + style->parent.id = map->parent.ident; + } + + for (const ResTable_map& mapEntry : map) { + style->entries.emplace_back(); + Style::Entry& styleEntry = style->entries.back(); + + if (mapEntry.name.ident == 0) { + // The map entry's key (attribute) is not set. This must be + // a symbol reference, so resolve it. + ResourceNameRef symbol; + bool result = getSymbol(&mapEntry.name.ident, &symbol); + assert(result); + styleEntry.key.name = symbol.toResourceName(); + } else { + // The map entry's key (attribute) is a regular reference. + styleEntry.key.id = mapEntry.name.ident; + } + + // Parse the attribute's value. + styleEntry.value = parseValue(name, config, &mapEntry.value, 0); + assert(styleEntry.value); + } + return style; +} + +std::unique_ptr<Attribute> BinaryResourceParser::parseAttr(const ResourceNameRef& name, + const ConfigDescription& config, + const ResTable_map_entry* map) { + const bool isWeak = (map->flags & ResTable_entry::FLAG_WEAK) != 0; + std::unique_ptr<Attribute> attr = util::make_unique<Attribute>(isWeak); + + // First we must discover what type of attribute this is. Find the type mask. + auto typeMaskIter = std::find_if(begin(map), end(map), [](const ResTable_map& entry) -> bool { + return entry.name.ident == ResTable_map::ATTR_TYPE; + }); + + if (typeMaskIter != end(map)) { + attr->typeMask = typeMaskIter->value.data; + } + + if (attr->typeMask & (ResTable_map::TYPE_ENUM | ResTable_map::TYPE_FLAGS)) { + for (const ResTable_map& mapEntry : map) { + if (Res_INTERNALID(mapEntry.name.ident)) { + continue; + } + + Attribute::Symbol symbol; + symbol.value = mapEntry.value.data; + if (mapEntry.name.ident == 0) { + // The map entry's key (id) is not set. This must be + // a symbol reference, so resolve it. + ResourceNameRef symbolName; + bool result = getSymbol(&mapEntry.name.ident, &symbolName); + assert(result); + symbol.symbol.name = symbolName.toResourceName(); + } else { + // The map entry's key (id) is a regular reference. + symbol.symbol.id = mapEntry.name.ident; + } + + attr->symbols.push_back(std::move(symbol)); + } + } + + // TODO(adamlesinski): Find min, max, i80n, etc attributes. + return attr; +} + +std::unique_ptr<Array> BinaryResourceParser::parseArray(const ResourceNameRef& name, + const ConfigDescription& config, + const ResTable_map_entry* map) { + std::unique_ptr<Array> array = util::make_unique<Array>(); + for (const ResTable_map& mapEntry : map) { + array->items.push_back(parseValue(name, config, &mapEntry.value, 0)); + } + return array; +} + +std::unique_ptr<Styleable> BinaryResourceParser::parseStyleable(const ResourceNameRef& name, + const ConfigDescription& config, + const ResTable_map_entry* map) { + std::unique_ptr<Styleable> styleable = util::make_unique<Styleable>(); + for (const ResTable_map& mapEntry : map) { + if (mapEntry.name.ident == 0) { + // The map entry's key (attribute) is not set. This must be + // a symbol reference, so resolve it. + ResourceNameRef symbol; + bool result = getSymbol(&mapEntry.name.ident, &symbol); + assert(result); + styleable->entries.emplace_back(symbol); + } else { + // The map entry's key (attribute) is a regular reference. + styleable->entries.emplace_back(mapEntry.name.ident); + } + } + return styleable; +} + +std::unique_ptr<Plural> BinaryResourceParser::parsePlural(const ResourceNameRef& name, + const ConfigDescription& config, + const ResTable_map_entry* map) { + std::unique_ptr<Plural> plural = util::make_unique<Plural>(); + for (const ResTable_map& mapEntry : map) { + std::unique_ptr<Item> item = parseValue(name, config, &mapEntry.value, 0); + + switch (mapEntry.name.ident) { + case android::ResTable_map::ATTR_ZERO: + plural->values[Plural::Zero] = std::move(item); + break; + case android::ResTable_map::ATTR_ONE: + plural->values[Plural::One] = std::move(item); + break; + case android::ResTable_map::ATTR_TWO: + plural->values[Plural::Two] = std::move(item); + break; + case android::ResTable_map::ATTR_FEW: + plural->values[Plural::Few] = std::move(item); + break; + case android::ResTable_map::ATTR_MANY: + plural->values[Plural::Many] = std::move(item); + break; + case android::ResTable_map::ATTR_OTHER: + plural->values[Plural::Other] = std::move(item); + break; + } + } + return plural; +} + +} // namespace aapt diff --git a/tools/aapt2/BinaryResourceParser.h b/tools/aapt2/BinaryResourceParser.h new file mode 100644 index 0000000..32876cd --- /dev/null +++ b/tools/aapt2/BinaryResourceParser.h @@ -0,0 +1,159 @@ +/* + * 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_BINARY_RESOURCE_PARSER_H +#define AAPT_BINARY_RESOURCE_PARSER_H + +#include "Resolver.h" +#include "ResourceTable.h" +#include "ResourceValues.h" +#include "Source.h" + +#include <androidfw/ResourceTypes.h> +#include <string> + +namespace aapt { + +struct SymbolTable_entry; + +/* + * Parses a binary resource table (resources.arsc) and adds the entries + * to a ResourceTable. This is different than the libandroidfw ResTable + * in that it scans the table from top to bottom and doesn't require + * support for random access. It is also able to parse non-runtime + * chunks and types. + */ +class BinaryResourceParser { +public: + /* + * Creates a parser, which will read `len` bytes from `data`, and + * add any resources parsed to `table`. `source` is for logging purposes. + */ + BinaryResourceParser(const std::shared_ptr<ResourceTable>& table, + const std::shared_ptr<IResolver>& resolver, + const Source& source, + const void* data, size_t len); + + BinaryResourceParser(const BinaryResourceParser&) = delete; // No copy. + + /* + * Parses the binary resource table and returns true if successful. + */ + bool parse(); + +private: + // Helper method to retrieve the symbol name for a given table offset specified + // as a pointer. + bool getSymbol(const void* data, ResourceNameRef* outSymbol); + + bool parseTable(const android::ResChunk_header* chunk); + bool parseSymbolTable(const android::ResChunk_header* chunk); + + // Looks up the resource ID in the reference and converts it to a name if available. + bool idToName(Reference* reference); + + bool parsePackage(const android::ResChunk_header* chunk); + bool parsePublic(const android::ResChunk_header* chunk); + bool parseTypeSpec(const android::ResChunk_header* chunk); + bool parseType(const android::ResChunk_header* chunk); + + std::unique_ptr<Item> parseValue(const ResourceNameRef& name, + const ConfigDescription& config, const android::Res_value* value, uint16_t flags); + + std::unique_ptr<Value> parseMapEntry(const ResourceNameRef& name, + const ConfigDescription& config, const android::ResTable_map_entry* map); + + std::unique_ptr<Style> parseStyle(const ResourceNameRef& name, + const ConfigDescription& config, const android::ResTable_map_entry* map); + + std::unique_ptr<Attribute> parseAttr(const ResourceNameRef& name, + const ConfigDescription& config, const android::ResTable_map_entry* map); + + std::unique_ptr<Array> parseArray(const ResourceNameRef& name, + const ConfigDescription& config, const android::ResTable_map_entry* map); + + std::unique_ptr<Plural> parsePlural(const ResourceNameRef& name, + const ConfigDescription& config, const android::ResTable_map_entry* map); + + std::unique_ptr<Styleable> parseStyleable(const ResourceNameRef& name, + const ConfigDescription& config, const android::ResTable_map_entry* map); + + std::shared_ptr<ResourceTable> mTable; + + std::shared_ptr<IResolver> mResolver; + + const Source mSource; + + const void* mData; + const size_t mDataLen; + + // The package name of the resource table. + std::u16string mPackage; + + // The array of symbol entries. Each element points to an offset + // in the table and an index into the symbol table string pool. + const SymbolTable_entry* mSymbolEntries = nullptr; + + // Number of symbol entries. + size_t mSymbolEntryCount = 0; + + // The symbol table string pool. Holds the names of symbols + // referenced in this table but not defined nor resolved to an + // ID. + android::ResStringPool mSymbolPool; + + // The source string pool. Resource entries may have an extra + // field that points into this string pool, which denotes where + // the resource was parsed from originally. + android::ResStringPool mSourcePool; + + // The standard value string pool for resource values. + android::ResStringPool mValuePool; + + // The string pool that holds the names of the types defined + // in this table. + android::ResStringPool mTypePool; + + // The string pool that holds the names of the entries defined + // in this table. + android::ResStringPool mKeyPool; + + // A mapping of resource ID to resource name. When we finish parsing + // we use this to convert all resource IDs to symbolic references. + std::map<ResourceId, ResourceName> mIdIndex; +}; + +} // namespace aapt + +namespace android { + +/** + * Iterator functionality for ResTable_map_entry. + */ + +inline const ResTable_map* begin(const ResTable_map_entry* map) { + return reinterpret_cast<const ResTable_map*>( + reinterpret_cast<const uint8_t*>(map) + map->size); +} + +inline const ResTable_map* end(const ResTable_map_entry* map) { + return reinterpret_cast<const ResTable_map*>( + reinterpret_cast<const uint8_t*>(map) + map->size) + map->count; +} + +} // namespace android + +#endif // AAPT_BINARY_RESOURCE_PARSER_H diff --git a/tools/aapt2/BindingXmlPullParser.cpp b/tools/aapt2/BindingXmlPullParser.cpp new file mode 100644 index 0000000..4b7a656 --- /dev/null +++ b/tools/aapt2/BindingXmlPullParser.cpp @@ -0,0 +1,268 @@ +/* + * 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 "BindingXmlPullParser.h" +#include "Util.h" + +#include <iostream> +#include <sstream> +#include <string> +#include <vector> + +namespace aapt { + +constexpr const char16_t* kBindingNamespaceUri = u"http://schemas.android.com/apk/binding"; +constexpr const char16_t* kAndroidNamespaceUri = u"http://schemas.android.com/apk/res/android"; +constexpr const char16_t* kVariableTagName = u"variable"; +constexpr const char* kBindingTagPrefix = "android:binding_"; + +BindingXmlPullParser::BindingXmlPullParser(const std::shared_ptr<XmlPullParser>& parser) : + mParser(parser), mOverride(false), mNextTagId(0) { +} + +bool BindingXmlPullParser::readVariableDeclaration() { + VarDecl var; + + const auto endAttrIter = mParser->endAttributes(); + for (auto attrIter = mParser->beginAttributes(); attrIter != endAttrIter; ++attrIter) { + if (!attrIter->namespaceUri.empty()) { + continue; + } + + if (attrIter->name == u"name") { + var.name = util::utf16ToUtf8(attrIter->value); + } else if (attrIter->name == u"type") { + var.type = util::utf16ToUtf8(attrIter->value); + } + } + + XmlPullParser::skipCurrentElement(mParser.get()); + + if (var.name.empty()) { + mLastError = "variable declaration missing name"; + return false; + } + + if (var.type.empty()) { + mLastError = "variable declaration missing type"; + return false; + } + + mVarDecls.push_back(std::move(var)); + return true; +} + +bool BindingXmlPullParser::readExpressions() { + mOverride = true; + std::vector<XmlPullParser::Attribute> expressions; + std::string idValue; + + const auto endAttrIter = mParser->endAttributes(); + for (auto attr = mParser->beginAttributes(); attr != endAttrIter; ++attr) { + if (attr->namespaceUri == kAndroidNamespaceUri && attr->name == u"id") { + idValue = util::utf16ToUtf8(attr->value); + } else { + StringPiece16 value = util::trimWhitespace(attr->value); + if (util::stringStartsWith<char16_t>(value, u"@{") && + util::stringEndsWith<char16_t>(value, u"}")) { + // This is attribute's value is an expression of the form + // @{expression}. We need to capture the expression inside. + expressions.push_back(XmlPullParser::Attribute{ + attr->namespaceUri, + attr->name, + value.substr(2, value.size() - 3).toString() + }); + } else { + // This is a normal attribute, use as is. + mAttributes.emplace_back(*attr); + } + } + } + + // Check if we have any expressions. + if (!expressions.empty()) { + // We have expressions, so let's assign the target a tag number + // and add it to our targets list. + int32_t targetId = mNextTagId++; + mTargets.push_back(Target{ + util::utf16ToUtf8(mParser->getElementName()), + idValue, + targetId, + std::move(expressions) + }); + + std::stringstream numGen; + numGen << kBindingTagPrefix << targetId; + mAttributes.push_back(XmlPullParser::Attribute{ + std::u16string(kAndroidNamespaceUri), + std::u16string(u"tag"), + util::utf8ToUtf16(numGen.str()) + }); + } + return true; +} + +XmlPullParser::Event BindingXmlPullParser::next() { + // Clear old state in preparation for the next event. + mOverride = false; + mAttributes.clear(); + + while (true) { + Event event = mParser->next(); + if (event == Event::kStartElement) { + if (mParser->getElementNamespace().empty() && + mParser->getElementName() == kVariableTagName) { + // This is a variable tag. Record data from it, and + // then discard the entire element. + if (!readVariableDeclaration()) { + // mLastError is set, so getEvent will return kBadDocument. + return getEvent(); + } + continue; + } else { + // Check for expressions of the form @{} in attribute text. + const auto endAttrIter = mParser->endAttributes(); + for (auto attr = mParser->beginAttributes(); attr != endAttrIter; ++attr) { + StringPiece16 value = util::trimWhitespace(attr->value); + if (util::stringStartsWith<char16_t>(value, u"@{") && + util::stringEndsWith<char16_t>(value, u"}")) { + if (!readExpressions()) { + return getEvent(); + } + break; + } + } + } + } else if (event == Event::kStartNamespace || event == Event::kEndNamespace) { + if (mParser->getNamespaceUri() == kBindingNamespaceUri) { + // Skip binding namespace tags. + continue; + } + } + return event; + } + return Event::kBadDocument; +} + +bool BindingXmlPullParser::writeToFile(std::ostream& out) const { + out << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"; + out << "<Layout directory=\"\" layout=\"\" layoutId=\"\">\n"; + + // Write the variables. + out << " <Variables>\n"; + for (const VarDecl& v : mVarDecls) { + out << " <entries name=\"" << v.name << "\" type=\"" << v.type << "\"/>\n"; + } + out << " </Variables>\n"; + + // Write the imports. + + std::stringstream tagGen; + + // Write the targets. + out << " <Targets>\n"; + for (const Target& t : mTargets) { + tagGen.str({}); + tagGen << kBindingTagPrefix << t.tagId; + out << " <Target boundClass=\"" << t.className << "\" id=\"" << t.id + << "\" tag=\"" << tagGen.str() << "\">\n"; + out << " <Expressions>\n"; + for (const XmlPullParser::Attribute& a : t.expressions) { + out << " <Expression attribute=\"" << a.namespaceUri << ":" << a.name + << "\" text=\"" << a.value << "\"/>\n"; + } + out << " </Expressions>\n"; + out << " </Target>\n"; + } + out << " </Targets>\n"; + + out << "</Layout>\n"; + return bool(out); +} + +XmlPullParser::const_iterator BindingXmlPullParser::beginAttributes() const { + if (mOverride) { + return mAttributes.begin(); + } + return mParser->beginAttributes(); +} + +XmlPullParser::const_iterator BindingXmlPullParser::endAttributes() const { + if (mOverride) { + return mAttributes.end(); + } + return mParser->endAttributes(); +} + +size_t BindingXmlPullParser::getAttributeCount() const { + if (mOverride) { + return mAttributes.size(); + } + return mParser->getAttributeCount(); +} + +XmlPullParser::Event BindingXmlPullParser::getEvent() const { + if (!mLastError.empty()) { + return Event::kBadDocument; + } + return mParser->getEvent(); +} + +const std::string& BindingXmlPullParser::getLastError() const { + if (!mLastError.empty()) { + return mLastError; + } + return mParser->getLastError(); +} + +const std::u16string& BindingXmlPullParser::getComment() const { + return mParser->getComment(); +} + +size_t BindingXmlPullParser::getLineNumber() const { + return mParser->getLineNumber(); +} + +size_t BindingXmlPullParser::getDepth() const { + return mParser->getDepth(); +} + +const std::u16string& BindingXmlPullParser::getText() const { + return mParser->getText(); +} + +const std::u16string& BindingXmlPullParser::getNamespacePrefix() const { + return mParser->getNamespacePrefix(); +} + +const std::u16string& BindingXmlPullParser::getNamespaceUri() const { + return mParser->getNamespaceUri(); +} + +bool BindingXmlPullParser::applyPackageAlias(std::u16string* package, + const std::u16string& defaultPackage) const { + return mParser->applyPackageAlias(package, defaultPackage); +} + +const std::u16string& BindingXmlPullParser::getElementNamespace() const { + return mParser->getElementNamespace(); +} + +const std::u16string& BindingXmlPullParser::getElementName() const { + return mParser->getElementName(); +} + +} // namespace aapt diff --git a/tools/aapt2/BindingXmlPullParser.h b/tools/aapt2/BindingXmlPullParser.h new file mode 100644 index 0000000..cfb16ef --- /dev/null +++ b/tools/aapt2/BindingXmlPullParser.h @@ -0,0 +1,90 @@ +/* + * 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_BINDING_XML_PULL_PARSER_H +#define AAPT_BINDING_XML_PULL_PARSER_H + +#include "XmlPullParser.h" + +#include <iostream> +#include <memory> +#include <string> + +namespace aapt { + +class BindingXmlPullParser : public XmlPullParser { +public: + BindingXmlPullParser(const std::shared_ptr<XmlPullParser>& parser); + BindingXmlPullParser(const BindingXmlPullParser& rhs) = delete; + + Event getEvent() const override; + const std::string& getLastError() const override; + Event next() override; + + const std::u16string& getComment() const override; + size_t getLineNumber() const override; + size_t getDepth() const override; + + const std::u16string& getText() const override; + + const std::u16string& getNamespacePrefix() const override; + const std::u16string& getNamespaceUri() const override; + bool applyPackageAlias(std::u16string* package, const std::u16string& defaultPackage) + const override; + + const std::u16string& getElementNamespace() const override; + const std::u16string& getElementName() const override; + + const_iterator beginAttributes() const override; + const_iterator endAttributes() const override; + size_t getAttributeCount() const override; + + bool writeToFile(std::ostream& out) const; + +private: + struct VarDecl { + std::string name; + std::string type; + }; + + struct Import { + std::string name; + std::string type; + }; + + struct Target { + std::string className; + std::string id; + int32_t tagId; + + std::vector<XmlPullParser::Attribute> expressions; + }; + + bool readVariableDeclaration(); + bool readExpressions(); + + std::shared_ptr<XmlPullParser> mParser; + std::string mLastError; + bool mOverride; + std::vector<XmlPullParser::Attribute> mAttributes; + std::vector<VarDecl> mVarDecls; + std::vector<Target> mTargets; + int32_t mNextTagId; +}; + +} // namespace aapt + +#endif // AAPT_BINDING_XML_PULL_PARSER_H diff --git a/tools/aapt2/BindingXmlPullParser_test.cpp b/tools/aapt2/BindingXmlPullParser_test.cpp new file mode 100644 index 0000000..28edcb6 --- /dev/null +++ b/tools/aapt2/BindingXmlPullParser_test.cpp @@ -0,0 +1,110 @@ +/* + * 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 "SourceXmlPullParser.h" +#include "BindingXmlPullParser.h" + +#include <gtest/gtest.h> +#include <sstream> +#include <string> + +namespace aapt { + +constexpr const char16_t* kAndroidNamespaceUri = u"http://schemas.android.com/apk/res/android"; + +TEST(BindingXmlPullParserTest, SubstituteBindingExpressionsWithTag) { + std::stringstream input; + input << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" + << "<LinearLayout xmlns:android=\"http://schemas.android.com/apk/res/android\"\n" + << " xmlns:bind=\"http://schemas.android.com/apk/binding\"\n" + << " android:id=\"@+id/content\">\n" + << " <variable name=\"user\" type=\"com.android.test.User\"/>\n" + << " <TextView android:text=\"@{user.name}\" android:layout_width=\"wrap_content\"\n" + << " android:layout_height=\"wrap_content\"/>\n" + << "</LinearLayout>\n"; + std::shared_ptr<XmlPullParser> sourceParser = std::make_shared<SourceXmlPullParser>(input); + BindingXmlPullParser parser(sourceParser); + + ASSERT_EQ(XmlPullParser::Event::kStartNamespace, parser.next()); + EXPECT_EQ(std::u16string(u"http://schemas.android.com/apk/res/android"), + parser.getNamespaceUri()); + + ASSERT_EQ(XmlPullParser::Event::kStartElement, parser.next()); + EXPECT_EQ(std::u16string(u"LinearLayout"), parser.getElementName()); + + while (parser.next() == XmlPullParser::Event::kText) {} + + ASSERT_EQ(XmlPullParser::Event::kStartElement, parser.getEvent()); + EXPECT_EQ(std::u16string(u"TextView"), parser.getElementName()); + + ASSERT_EQ(3u, parser.getAttributeCount()); + const auto endAttr = parser.endAttributes(); + EXPECT_NE(endAttr, parser.findAttribute(kAndroidNamespaceUri, u"layout_width")); + EXPECT_NE(endAttr, parser.findAttribute(kAndroidNamespaceUri, u"layout_height")); + EXPECT_NE(endAttr, parser.findAttribute(kAndroidNamespaceUri, u"tag")); + + while (parser.next() == XmlPullParser::Event::kText) {} + + ASSERT_EQ(XmlPullParser::Event::kEndElement, parser.getEvent()); + + while (parser.next() == XmlPullParser::Event::kText) {} + + ASSERT_EQ(XmlPullParser::Event::kEndElement, parser.getEvent()); + ASSERT_EQ(XmlPullParser::Event::kEndNamespace, parser.next()); +} + +TEST(BindingXmlPullParserTest, GenerateVariableDeclarations) { + std::stringstream input; + input << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" + << "<LinearLayout xmlns:android=\"http://schemas.android.com/apk/res/android\"\n" + << " xmlns:bind=\"http://schemas.android.com/apk/binding\"\n" + << " android:id=\"@+id/content\">\n" + << " <variable name=\"user\" type=\"com.android.test.User\"/>\n" + << "</LinearLayout>\n"; + std::shared_ptr<XmlPullParser> sourceParser = std::make_shared<SourceXmlPullParser>(input); + BindingXmlPullParser parser(sourceParser); + + while (XmlPullParser::isGoodEvent(parser.next())) { + ASSERT_NE(XmlPullParser::Event::kBadDocument, parser.getEvent()); + } + + std::stringstream output; + ASSERT_TRUE(parser.writeToFile(output)); + + std::string result = output.str(); + EXPECT_NE(std::string::npos, + result.find("<entries name=\"user\" type=\"com.android.test.User\"/>")); +} + +TEST(BindingXmlPullParserTest, FailOnMissingNameOrTypeInVariableDeclaration) { + std::stringstream input; + input << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" + << "<LinearLayout xmlns:android=\"http://schemas.android.com/apk/res/android\"\n" + << " xmlns:bind=\"http://schemas.android.com/apk/binding\"\n" + << " android:id=\"@+id/content\">\n" + << " <variable name=\"user\"/>\n" + << "</LinearLayout>\n"; + std::shared_ptr<XmlPullParser> sourceParser = std::make_shared<SourceXmlPullParser>(input); + BindingXmlPullParser parser(sourceParser); + + while (XmlPullParser::isGoodEvent(parser.next())) {} + + EXPECT_EQ(XmlPullParser::Event::kBadDocument, parser.getEvent()); + EXPECT_FALSE(parser.getLastError().empty()); +} + + +} // namespace aapt diff --git a/tools/aapt2/Compat_test.cpp b/tools/aapt2/Compat_test.cpp new file mode 100644 index 0000000..96aee44 --- /dev/null +++ b/tools/aapt2/Compat_test.cpp @@ -0,0 +1,33 @@ +/* + * 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 <gtest/gtest.h> + +namespace aapt { + +TEST(CompatTest, VersionAttributesInStyle) { +} + +TEST(CompatTest, VersionAttributesInXML) { +} + +TEST(CompatTest, DoNotOverrideExistingVersionedFiles) { +} + +TEST(CompatTest, VersionAttributesInStyleWithCorrectPrecedence) { +} + +} // namespace aapt diff --git a/tools/aapt2/ConfigDescription.cpp b/tools/aapt2/ConfigDescription.cpp new file mode 100644 index 0000000..6ddf94a --- /dev/null +++ b/tools/aapt2/ConfigDescription.cpp @@ -0,0 +1,752 @@ +/* + * 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 "Locale.h" +#include "SdkConstants.h" +#include "StringPiece.h" +#include "Util.h" + +#include <androidfw/ResourceTypes.h> +#include <string> +#include <vector> + +namespace aapt { + +using android::ResTable_config; + +static const char* kWildcardName = "any"; + +static bool parseMcc(const char* name, ResTable_config* out) { + if (strcmp(name, kWildcardName) == 0) { + if (out) out->mcc = 0; + return true; + } + const char* c = name; + if (tolower(*c) != 'm') return false; + c++; + if (tolower(*c) != 'c') return false; + c++; + if (tolower(*c) != 'c') return false; + c++; + + const char* val = c; + + while (*c >= '0' && *c <= '9') { + c++; + } + if (*c != 0) return false; + if (c-val != 3) return false; + + int d = atoi(val); + if (d != 0) { + if (out) out->mcc = d; + return true; + } + + return false; +} + +static bool parseMnc(const char* name, ResTable_config* out) { + if (strcmp(name, kWildcardName) == 0) { + if (out) out->mcc = 0; + return true; + } + const char* c = name; + if (tolower(*c) != 'm') return false; + c++; + if (tolower(*c) != 'n') return false; + c++; + if (tolower(*c) != 'c') return false; + c++; + + const char* val = c; + + while (*c >= '0' && *c <= '9') { + c++; + } + if (*c != 0) return false; + if (c-val == 0 || c-val > 3) return false; + + if (out) { + out->mnc = atoi(val); + if (out->mnc == 0) { + out->mnc = ACONFIGURATION_MNC_ZERO; + } + } + + return true; +} + +static bool parseLayoutDirection(const char* name, ResTable_config* out) { + if (strcmp(name, kWildcardName) == 0) { + if (out) out->screenLayout = + (out->screenLayout&~ResTable_config::MASK_LAYOUTDIR) + | ResTable_config::LAYOUTDIR_ANY; + return true; + } else if (strcmp(name, "ldltr") == 0) { + if (out) out->screenLayout = + (out->screenLayout&~ResTable_config::MASK_LAYOUTDIR) + | ResTable_config::LAYOUTDIR_LTR; + return true; + } else if (strcmp(name, "ldrtl") == 0) { + if (out) out->screenLayout = + (out->screenLayout&~ResTable_config::MASK_LAYOUTDIR) + | ResTable_config::LAYOUTDIR_RTL; + return true; + } + + return false; +} + +static bool parseScreenLayoutSize(const char* name, ResTable_config* out) { + if (strcmp(name, kWildcardName) == 0) { + if (out) out->screenLayout = + (out->screenLayout&~ResTable_config::MASK_SCREENSIZE) + | ResTable_config::SCREENSIZE_ANY; + return true; + } else if (strcmp(name, "small") == 0) { + if (out) out->screenLayout = + (out->screenLayout&~ResTable_config::MASK_SCREENSIZE) + | ResTable_config::SCREENSIZE_SMALL; + return true; + } else if (strcmp(name, "normal") == 0) { + if (out) out->screenLayout = + (out->screenLayout&~ResTable_config::MASK_SCREENSIZE) + | ResTable_config::SCREENSIZE_NORMAL; + return true; + } else if (strcmp(name, "large") == 0) { + if (out) out->screenLayout = + (out->screenLayout&~ResTable_config::MASK_SCREENSIZE) + | ResTable_config::SCREENSIZE_LARGE; + return true; + } else if (strcmp(name, "xlarge") == 0) { + if (out) out->screenLayout = + (out->screenLayout&~ResTable_config::MASK_SCREENSIZE) + | ResTable_config::SCREENSIZE_XLARGE; + return true; + } + + return false; +} + +static bool parseScreenLayoutLong(const char* name, ResTable_config* out) { + if (strcmp(name, kWildcardName) == 0) { + if (out) out->screenLayout = + (out->screenLayout&~ResTable_config::MASK_SCREENLONG) + | ResTable_config::SCREENLONG_ANY; + return true; + } else if (strcmp(name, "long") == 0) { + if (out) out->screenLayout = + (out->screenLayout&~ResTable_config::MASK_SCREENLONG) + | ResTable_config::SCREENLONG_YES; + return true; + } else if (strcmp(name, "notlong") == 0) { + if (out) out->screenLayout = + (out->screenLayout&~ResTable_config::MASK_SCREENLONG) + | ResTable_config::SCREENLONG_NO; + return true; + } + + return false; +} + +static bool parseOrientation(const char* name, ResTable_config* out) { + if (strcmp(name, kWildcardName) == 0) { + if (out) out->orientation = out->ORIENTATION_ANY; + return true; + } else if (strcmp(name, "port") == 0) { + if (out) out->orientation = out->ORIENTATION_PORT; + return true; + } else if (strcmp(name, "land") == 0) { + if (out) out->orientation = out->ORIENTATION_LAND; + return true; + } else if (strcmp(name, "square") == 0) { + if (out) out->orientation = out->ORIENTATION_SQUARE; + return true; + } + + return false; +} + +static bool parseUiModeType(const char* name, ResTable_config* out) { + if (strcmp(name, kWildcardName) == 0) { + if (out) out->uiMode = + (out->uiMode&~ResTable_config::MASK_UI_MODE_TYPE) + | ResTable_config::UI_MODE_TYPE_ANY; + return true; + } else if (strcmp(name, "desk") == 0) { + if (out) out->uiMode = + (out->uiMode&~ResTable_config::MASK_UI_MODE_TYPE) + | ResTable_config::UI_MODE_TYPE_DESK; + return true; + } else if (strcmp(name, "car") == 0) { + if (out) out->uiMode = + (out->uiMode&~ResTable_config::MASK_UI_MODE_TYPE) + | ResTable_config::UI_MODE_TYPE_CAR; + return true; + } else if (strcmp(name, "television") == 0) { + if (out) out->uiMode = + (out->uiMode&~ResTable_config::MASK_UI_MODE_TYPE) + | ResTable_config::UI_MODE_TYPE_TELEVISION; + return true; + } else if (strcmp(name, "appliance") == 0) { + if (out) out->uiMode = + (out->uiMode&~ResTable_config::MASK_UI_MODE_TYPE) + | ResTable_config::UI_MODE_TYPE_APPLIANCE; + return true; + } else if (strcmp(name, "watch") == 0) { + if (out) out->uiMode = + (out->uiMode&~ResTable_config::MASK_UI_MODE_TYPE) + | ResTable_config::UI_MODE_TYPE_WATCH; + return true; + } + + return false; +} + +static bool parseUiModeNight(const char* name, ResTable_config* out) { + if (strcmp(name, kWildcardName) == 0) { + if (out) out->uiMode = + (out->uiMode&~ResTable_config::MASK_UI_MODE_NIGHT) + | ResTable_config::UI_MODE_NIGHT_ANY; + return true; + } else if (strcmp(name, "night") == 0) { + if (out) out->uiMode = + (out->uiMode&~ResTable_config::MASK_UI_MODE_NIGHT) + | ResTable_config::UI_MODE_NIGHT_YES; + return true; + } else if (strcmp(name, "notnight") == 0) { + if (out) out->uiMode = + (out->uiMode&~ResTable_config::MASK_UI_MODE_NIGHT) + | ResTable_config::UI_MODE_NIGHT_NO; + return true; + } + + return false; +} + +static bool parseDensity(const char* name, ResTable_config* out) { + if (strcmp(name, kWildcardName) == 0) { + if (out) out->density = ResTable_config::DENSITY_DEFAULT; + return true; + } + + if (strcmp(name, "anydpi") == 0) { + if (out) out->density = ResTable_config::DENSITY_ANY; + return true; + } + + if (strcmp(name, "nodpi") == 0) { + if (out) out->density = ResTable_config::DENSITY_NONE; + return true; + } + + if (strcmp(name, "ldpi") == 0) { + if (out) out->density = ResTable_config::DENSITY_LOW; + return true; + } + + if (strcmp(name, "mdpi") == 0) { + if (out) out->density = ResTable_config::DENSITY_MEDIUM; + return true; + } + + if (strcmp(name, "tvdpi") == 0) { + if (out) out->density = ResTable_config::DENSITY_TV; + return true; + } + + if (strcmp(name, "hdpi") == 0) { + if (out) out->density = ResTable_config::DENSITY_HIGH; + return true; + } + + if (strcmp(name, "xhdpi") == 0) { + if (out) out->density = ResTable_config::DENSITY_XHIGH; + return true; + } + + if (strcmp(name, "xxhdpi") == 0) { + if (out) out->density = ResTable_config::DENSITY_XXHIGH; + return true; + } + + if (strcmp(name, "xxxhdpi") == 0) { + if (out) out->density = ResTable_config::DENSITY_XXXHIGH; + return true; + } + + char* c = (char*)name; + while (*c >= '0' && *c <= '9') { + c++; + } + + // check that we have 'dpi' after the last digit. + if (toupper(c[0]) != 'D' || + toupper(c[1]) != 'P' || + toupper(c[2]) != 'I' || + c[3] != 0) { + return false; + } + + // temporarily replace the first letter with \0 to + // use atoi. + char tmp = c[0]; + c[0] = '\0'; + + int d = atoi(name); + c[0] = tmp; + + if (d != 0) { + if (out) out->density = d; + return true; + } + + return false; +} + +static bool parseTouchscreen(const char* name, ResTable_config* out) { + if (strcmp(name, kWildcardName) == 0) { + if (out) out->touchscreen = out->TOUCHSCREEN_ANY; + return true; + } else if (strcmp(name, "notouch") == 0) { + if (out) out->touchscreen = out->TOUCHSCREEN_NOTOUCH; + return true; + } else if (strcmp(name, "stylus") == 0) { + if (out) out->touchscreen = out->TOUCHSCREEN_STYLUS; + return true; + } else if (strcmp(name, "finger") == 0) { + if (out) out->touchscreen = out->TOUCHSCREEN_FINGER; + return true; + } + + return false; +} + +static bool parseKeysHidden(const char* name, ResTable_config* out) { + uint8_t mask = 0; + uint8_t value = 0; + if (strcmp(name, kWildcardName) == 0) { + mask = ResTable_config::MASK_KEYSHIDDEN; + value = ResTable_config::KEYSHIDDEN_ANY; + } else if (strcmp(name, "keysexposed") == 0) { + mask = ResTable_config::MASK_KEYSHIDDEN; + value = ResTable_config::KEYSHIDDEN_NO; + } else if (strcmp(name, "keyshidden") == 0) { + mask = ResTable_config::MASK_KEYSHIDDEN; + value = ResTable_config::KEYSHIDDEN_YES; + } else if (strcmp(name, "keyssoft") == 0) { + mask = ResTable_config::MASK_KEYSHIDDEN; + value = ResTable_config::KEYSHIDDEN_SOFT; + } + + if (mask != 0) { + if (out) out->inputFlags = (out->inputFlags&~mask) | value; + return true; + } + + return false; +} + +static bool parseKeyboard(const char* name, ResTable_config* out) { + if (strcmp(name, kWildcardName) == 0) { + if (out) out->keyboard = out->KEYBOARD_ANY; + return true; + } else if (strcmp(name, "nokeys") == 0) { + if (out) out->keyboard = out->KEYBOARD_NOKEYS; + return true; + } else if (strcmp(name, "qwerty") == 0) { + if (out) out->keyboard = out->KEYBOARD_QWERTY; + return true; + } else if (strcmp(name, "12key") == 0) { + if (out) out->keyboard = out->KEYBOARD_12KEY; + return true; + } + + return false; +} + +static bool parseNavHidden(const char* name, ResTable_config* out) { + uint8_t mask = 0; + uint8_t value = 0; + if (strcmp(name, kWildcardName) == 0) { + mask = ResTable_config::MASK_NAVHIDDEN; + value = ResTable_config::NAVHIDDEN_ANY; + } else if (strcmp(name, "navexposed") == 0) { + mask = ResTable_config::MASK_NAVHIDDEN; + value = ResTable_config::NAVHIDDEN_NO; + } else if (strcmp(name, "navhidden") == 0) { + mask = ResTable_config::MASK_NAVHIDDEN; + value = ResTable_config::NAVHIDDEN_YES; + } + + if (mask != 0) { + if (out) out->inputFlags = (out->inputFlags&~mask) | value; + return true; + } + + return false; +} + +static bool parseNavigation(const char* name, ResTable_config* out) { + if (strcmp(name, kWildcardName) == 0) { + if (out) out->navigation = out->NAVIGATION_ANY; + return true; + } else if (strcmp(name, "nonav") == 0) { + if (out) out->navigation = out->NAVIGATION_NONAV; + return true; + } else if (strcmp(name, "dpad") == 0) { + if (out) out->navigation = out->NAVIGATION_DPAD; + return true; + } else if (strcmp(name, "trackball") == 0) { + if (out) out->navigation = out->NAVIGATION_TRACKBALL; + return true; + } else if (strcmp(name, "wheel") == 0) { + if (out) out->navigation = out->NAVIGATION_WHEEL; + return true; + } + + return false; +} + +static bool parseScreenSize(const char* name, ResTable_config* out) { + if (strcmp(name, kWildcardName) == 0) { + if (out) { + out->screenWidth = out->SCREENWIDTH_ANY; + out->screenHeight = out->SCREENHEIGHT_ANY; + } + return true; + } + + const char* x = name; + while (*x >= '0' && *x <= '9') x++; + if (x == name || *x != 'x') return false; + std::string xName(name, x-name); + x++; + + const char* y = x; + while (*y >= '0' && *y <= '9') y++; + if (y == name || *y != 0) return false; + std::string yName(x, y-x); + + uint16_t w = (uint16_t)atoi(xName.c_str()); + uint16_t h = (uint16_t)atoi(yName.c_str()); + if (w < h) { + return false; + } + + if (out) { + out->screenWidth = w; + out->screenHeight = h; + } + + return true; +} + +static bool parseSmallestScreenWidthDp(const char* name, ResTable_config* out) { + if (strcmp(name, kWildcardName) == 0) { + if (out) { + out->smallestScreenWidthDp = out->SCREENWIDTH_ANY; + } + return true; + } + + if (*name != 's') return false; + name++; + if (*name != 'w') return false; + name++; + const char* x = name; + while (*x >= '0' && *x <= '9') x++; + if (x == name || x[0] != 'd' || x[1] != 'p' || x[2] != 0) return false; + std::string xName(name, x-name); + + if (out) { + out->smallestScreenWidthDp = (uint16_t)atoi(xName.c_str()); + } + + return true; +} + +static bool parseScreenWidthDp(const char* name, ResTable_config* out) { + if (strcmp(name, kWildcardName) == 0) { + if (out) { + out->screenWidthDp = out->SCREENWIDTH_ANY; + } + return true; + } + + if (*name != 'w') return false; + name++; + const char* x = name; + while (*x >= '0' && *x <= '9') x++; + if (x == name || x[0] != 'd' || x[1] != 'p' || x[2] != 0) return false; + std::string xName(name, x-name); + + if (out) { + out->screenWidthDp = (uint16_t)atoi(xName.c_str()); + } + + return true; +} + +static bool parseScreenHeightDp(const char* name, ResTable_config* out) { + if (strcmp(name, kWildcardName) == 0) { + if (out) { + out->screenHeightDp = out->SCREENWIDTH_ANY; + } + return true; + } + + if (*name != 'h') return false; + name++; + const char* x = name; + while (*x >= '0' && *x <= '9') x++; + if (x == name || x[0] != 'd' || x[1] != 'p' || x[2] != 0) return false; + std::string xName(name, x-name); + + if (out) { + out->screenHeightDp = (uint16_t)atoi(xName.c_str()); + } + + return true; +} + +static bool parseVersion(const char* name, ResTable_config* out) { + if (strcmp(name, kWildcardName) == 0) { + if (out) { + out->sdkVersion = out->SDKVERSION_ANY; + out->minorVersion = out->MINORVERSION_ANY; + } + return true; + } + + if (*name != 'v') { + return false; + } + + name++; + const char* s = name; + while (*s >= '0' && *s <= '9') s++; + if (s == name || *s != 0) return false; + std::string sdkName(name, s-name); + + if (out) { + out->sdkVersion = (uint16_t)atoi(sdkName.c_str()); + out->minorVersion = 0; + } + + return true; +} + +bool ConfigDescription::parse(const StringPiece& str, ConfigDescription* out) { + std::vector<std::string> parts = util::splitAndLowercase(str, '-'); + + ConfigDescription config; + ssize_t partsConsumed = 0; + LocaleValue locale; + + const auto partsEnd = parts.end(); + auto partIter = parts.begin(); + + if (str.size() == 0) { + goto success; + } + + if (parseMcc(partIter->c_str(), &config)) { + ++partIter; + if (partIter == partsEnd) { + goto success; + } + } + + if (parseMnc(partIter->c_str(), &config)) { + ++partIter; + if (partIter == partsEnd) { + goto success; + } + } + + // Locale spans a few '-' separators, so we let it + // control the index. + partsConsumed = locale.initFromParts(partIter, partsEnd); + if (partsConsumed < 0) { + return false; + } else { + locale.writeTo(&config); + partIter += partsConsumed; + if (partIter == partsEnd) { + goto success; + } + } + + if (parseLayoutDirection(partIter->c_str(), &config)) { + ++partIter; + if (partIter == partsEnd) { + goto success; + } + } + + if (parseSmallestScreenWidthDp(partIter->c_str(), &config)) { + ++partIter; + if (partIter == partsEnd) { + goto success; + } + } + + if (parseScreenWidthDp(partIter->c_str(), &config)) { + ++partIter; + if (partIter == partsEnd) { + goto success; + } + } + + if (parseScreenHeightDp(partIter->c_str(), &config)) { + ++partIter; + if (partIter == partsEnd) { + goto success; + } + } + + if (parseScreenLayoutSize(partIter->c_str(), &config)) { + ++partIter; + if (partIter == partsEnd) { + goto success; + } + } + + if (parseScreenLayoutLong(partIter->c_str(), &config)) { + ++partIter; + if (partIter == partsEnd) { + goto success; + } + } + + if (parseOrientation(partIter->c_str(), &config)) { + ++partIter; + if (partIter == partsEnd) { + goto success; + } + } + + if (parseUiModeType(partIter->c_str(), &config)) { + ++partIter; + if (partIter == partsEnd) { + goto success; + } + } + + if (parseUiModeNight(partIter->c_str(), &config)) { + ++partIter; + if (partIter == partsEnd) { + goto success; + } + } + + if (parseDensity(partIter->c_str(), &config)) { + ++partIter; + if (partIter == partsEnd) { + goto success; + } + } + + if (parseTouchscreen(partIter->c_str(), &config)) { + ++partIter; + if (partIter == partsEnd) { + goto success; + } + } + + if (parseKeysHidden(partIter->c_str(), &config)) { + ++partIter; + if (partIter == partsEnd) { + goto success; + } + } + + if (parseKeyboard(partIter->c_str(), &config)) { + ++partIter; + if (partIter == partsEnd) { + goto success; + } + } + + if (parseNavHidden(partIter->c_str(), &config)) { + ++partIter; + if (partIter == partsEnd) { + goto success; + } + } + + if (parseNavigation(partIter->c_str(), &config)) { + ++partIter; + if (partIter == partsEnd) { + goto success; + } + } + + if (parseScreenSize(partIter->c_str(), &config)) { + ++partIter; + if (partIter == partsEnd) { + goto success; + } + } + + if (parseVersion(partIter->c_str(), &config)) { + ++partIter; + if (partIter == partsEnd) { + goto success; + } + } + + // Unrecognized. + return false; + +success: + if (out != NULL) { + applyVersionForCompatibility(&config); + *out = config; + } + return true; +} + +void ConfigDescription::applyVersionForCompatibility(ConfigDescription* config) { + uint16_t minSdk = 0; + if (config->density == ResTable_config::DENSITY_ANY) { + minSdk = SDK_LOLLIPOP; + } else if (config->smallestScreenWidthDp != ResTable_config::SCREENWIDTH_ANY + || config->screenWidthDp != ResTable_config::SCREENWIDTH_ANY + || config->screenHeightDp != ResTable_config::SCREENHEIGHT_ANY) { + minSdk = SDK_HONEYCOMB_MR2; + } else if ((config->uiMode & ResTable_config::MASK_UI_MODE_TYPE) + != ResTable_config::UI_MODE_TYPE_ANY + || (config->uiMode & ResTable_config::MASK_UI_MODE_NIGHT) + != ResTable_config::UI_MODE_NIGHT_ANY) { + minSdk = SDK_FROYO; + } else if ((config->screenLayout & ResTable_config::MASK_SCREENSIZE) + != ResTable_config::SCREENSIZE_ANY + || (config->screenLayout & ResTable_config::MASK_SCREENLONG) + != ResTable_config::SCREENLONG_ANY + || config->density != ResTable_config::DENSITY_DEFAULT) { + minSdk = SDK_DONUT; + } + + if (minSdk > config->sdkVersion) { + config->sdkVersion = minSdk; + } +} + +} // namespace aapt diff --git a/tools/aapt2/ConfigDescription.h b/tools/aapt2/ConfigDescription.h new file mode 100644 index 0000000..67b4b75 --- /dev/null +++ b/tools/aapt2/ConfigDescription.h @@ -0,0 +1,129 @@ +/* + * 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_CONFIG_DESCRIPTION_H +#define AAPT_CONFIG_DESCRIPTION_H + +#include "StringPiece.h" + +#include <androidfw/ResourceTypes.h> +#include <ostream> + +namespace aapt { + +/* + * Subclass of ResTable_config that adds convenient + * initialization and comparison methods. + */ +struct ConfigDescription : public android::ResTable_config { + /* + * Parse a string of the form 'fr-sw600dp-land' and fill in the + * given ResTable_config with resulting configuration parameters. + * + * The resulting configuration has the appropriate sdkVersion defined + * for backwards compatibility. + */ + static bool parse(const StringPiece& str, ConfigDescription* out = nullptr); + + /** + * If the configuration uses an axis that was added after + * the original Android release, make sure the SDK version + * is set accordingly. + */ + static void applyVersionForCompatibility(ConfigDescription* config); + + ConfigDescription(); + ConfigDescription(const android::ResTable_config& o); + ConfigDescription(const ConfigDescription& o); + ConfigDescription(ConfigDescription&& o); + + ConfigDescription& operator=(const android::ResTable_config& o); + ConfigDescription& operator=(const ConfigDescription& o); + ConfigDescription& operator=(ConfigDescription&& o); + + bool operator<(const ConfigDescription& o) const; + bool operator<=(const ConfigDescription& o) const; + bool operator==(const ConfigDescription& o) const; + bool operator!=(const ConfigDescription& o) const; + bool operator>=(const ConfigDescription& o) const; + bool operator>(const ConfigDescription& o) const; +}; + +inline ConfigDescription::ConfigDescription() { + memset(this, 0, sizeof(*this)); + size = sizeof(android::ResTable_config); +} + +inline ConfigDescription::ConfigDescription(const android::ResTable_config& o) { + *static_cast<android::ResTable_config*>(this) = o; + size = sizeof(android::ResTable_config); +} + +inline ConfigDescription::ConfigDescription(const ConfigDescription& o) { + *static_cast<android::ResTable_config*>(this) = o; +} + +inline ConfigDescription::ConfigDescription(ConfigDescription&& o) { + *this = o; +} + +inline ConfigDescription& ConfigDescription::operator=(const android::ResTable_config& o) { + *static_cast<android::ResTable_config*>(this) = o; + size = sizeof(android::ResTable_config); + return *this; +} + +inline ConfigDescription& ConfigDescription::operator=(const ConfigDescription& o) { + *static_cast<android::ResTable_config*>(this) = o; + return *this; +} + +inline ConfigDescription& ConfigDescription::operator=(ConfigDescription&& o) { + *this = o; + return *this; +} + +inline bool ConfigDescription::operator<(const ConfigDescription& o) const { + return compare(o) < 0; +} + +inline bool ConfigDescription::operator<=(const ConfigDescription& o) const { + return compare(o) <= 0; +} + +inline bool ConfigDescription::operator==(const ConfigDescription& o) const { + return compare(o) == 0; +} + +inline bool ConfigDescription::operator!=(const ConfigDescription& o) const { + return compare(o) != 0; +} + +inline bool ConfigDescription::operator>=(const ConfigDescription& o) const { + return compare(o) >= 0; +} + +inline bool ConfigDescription::operator>(const ConfigDescription& o) const { + return compare(o) > 0; +} + +inline ::std::ostream& operator<<(::std::ostream& out, const ConfigDescription& o) { + return out << o.toString().string(); +} + +} // namespace aapt + +#endif // AAPT_CONFIG_DESCRIPTION_H diff --git a/tools/aapt2/ConfigDescription_test.cpp b/tools/aapt2/ConfigDescription_test.cpp new file mode 100644 index 0000000..c57e351 --- /dev/null +++ b/tools/aapt2/ConfigDescription_test.cpp @@ -0,0 +1,82 @@ +/* + * 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 "StringPiece.h" + +#include <gtest/gtest.h> +#include <string> + +namespace aapt { + +static ::testing::AssertionResult TestParse(const StringPiece& input, + ConfigDescription* config = nullptr) { + if (ConfigDescription::parse(input, config)) { + return ::testing::AssertionSuccess() << input << " was successfully parsed"; + } + return ::testing::AssertionFailure() << input << " could not be parsed"; +} + +TEST(ConfigDescriptionTest, ParseFailWhenQualifiersAreOutOfOrder) { + EXPECT_FALSE(TestParse("en-sw600dp-ldrtl")); + EXPECT_FALSE(TestParse("land-en")); + EXPECT_FALSE(TestParse("hdpi-320dpi")); +} + +TEST(ConfigDescriptionTest, ParseFailWhenQualifiersAreNotMatched) { + EXPECT_FALSE(TestParse("en-sw600dp-ILLEGAL")); +} + +TEST(ConfigDescriptionTest, ParseFailWhenQualifiersHaveTrailingDash) { + EXPECT_FALSE(TestParse("en-sw600dp-land-")); +} + +TEST(ConfigDescriptionTest, ParseBasicQualifiers) { + ConfigDescription config; + EXPECT_TRUE(TestParse("", &config)); + EXPECT_EQ(std::string(""), config.toString().string()); + + EXPECT_TRUE(TestParse("fr-land", &config)); + EXPECT_EQ(std::string("fr-land"), config.toString().string()); + + EXPECT_TRUE(TestParse("mcc310-pl-sw720dp-normal-long-port-night-" + "xhdpi-keyssoft-qwerty-navexposed-nonav", &config)); + EXPECT_EQ(std::string("mcc310-pl-sw720dp-normal-long-port-night-" + "xhdpi-keyssoft-qwerty-navexposed-nonav-v13"), config.toString().string()); +} + +TEST(ConfigDescriptionTest, ParseLocales) { + ConfigDescription config; + EXPECT_TRUE(TestParse("en-rUS", &config)); + EXPECT_EQ(std::string("en-rUS"), config.toString().string()); +} + +TEST(ConfigDescriptionTest, ParseQualifierAddedInApi13) { + ConfigDescription config; + EXPECT_TRUE(TestParse("sw600dp", &config)); + EXPECT_EQ(std::string("sw600dp-v13"), config.toString().string()); + + EXPECT_TRUE(TestParse("sw600dp-v8", &config)); + EXPECT_EQ(std::string("sw600dp-v13"), config.toString().string()); +} + +TEST(ConfigDescriptionTest, ParseCarAttribute) { + ConfigDescription config; + EXPECT_TRUE(TestParse("car", &config)); + EXPECT_EQ(android::ResTable_config::UI_MODE_TYPE_CAR, config.uiMode); +} + +} // namespace aapt diff --git a/tools/aapt2/Debug.cpp b/tools/aapt2/Debug.cpp new file mode 100644 index 0000000..cf222c6 --- /dev/null +++ b/tools/aapt2/Debug.cpp @@ -0,0 +1,192 @@ +/* + * 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 "Debug.h" +#include "ResourceTable.h" +#include "ResourceValues.h" +#include "Util.h" + +#include <algorithm> +#include <iostream> +#include <map> +#include <memory> +#include <queue> +#include <set> +#include <vector> + +namespace aapt { + +struct PrintVisitor : ConstValueVisitor { + void visit(const Attribute& attr, ValueVisitorArgs&) override { + std::cout << "(attr) type="; + attr.printMask(std::cout); + static constexpr uint32_t kMask = android::ResTable_map::TYPE_ENUM | + android::ResTable_map::TYPE_FLAGS; + if (attr.typeMask & kMask) { + for (const auto& symbol : attr.symbols) { + std::cout << "\n " + << symbol.symbol.name.entry << " (" << symbol.symbol.id << ") = " + << symbol.value; + } + } + } + + void visit(const Style& style, ValueVisitorArgs&) override { + std::cout << "(style)"; + if (style.parent.name.isValid() || style.parent.id.isValid()) { + std::cout << " parent="; + if (style.parent.name.isValid()) { + std::cout << style.parent.name << " "; + } + + if (style.parent.id.isValid()) { + std::cout << style.parent.id; + } + } + + for (const auto& entry : style.entries) { + std::cout << "\n "; + if (entry.key.name.isValid()) { + std::cout << entry.key.name.package << ":" << entry.key.name.entry; + } + + if (entry.key.id.isValid()) { + std::cout << "(" << entry.key.id << ")"; + } + + std::cout << "=" << *entry.value; + } + } + + void visit(const Array& array, ValueVisitorArgs&) override { + array.print(std::cout); + } + + void visit(const Plural& plural, ValueVisitorArgs&) override { + plural.print(std::cout); + } + + void visit(const Styleable& styleable, ValueVisitorArgs&) override { + styleable.print(std::cout); + } + + void visitItem(const Item& item, ValueVisitorArgs& args) override { + item.print(std::cout); + } +}; + +void Debug::printTable(const std::shared_ptr<ResourceTable>& table) { + std::cout << "Package name=" << table->getPackage(); + if (table->getPackageId() != ResourceTable::kUnsetPackageId) { + std::cout << " id=" << std::hex << table->getPackageId() << std::dec; + } + std::cout << std::endl; + + for (const auto& type : *table) { + std::cout << " type " << type->type; + if (type->typeId != ResourceTableType::kUnsetTypeId) { + std::cout << " id=" << std::hex << type->typeId << std::dec; + } + std::cout << " entryCount=" << type->entries.size() << std::endl; + + std::vector<const ResourceEntry*> sortedEntries; + for (const auto& entry : type->entries) { + auto iter = std::lower_bound(sortedEntries.begin(), sortedEntries.end(), entry.get(), + [](const ResourceEntry* a, const ResourceEntry* b) -> bool { + return a->entryId < b->entryId; + }); + sortedEntries.insert(iter, entry.get()); + } + + for (const ResourceEntry* entry : sortedEntries) { + ResourceId id = { table->getPackageId(), type->typeId, entry->entryId }; + ResourceName name = { table->getPackage(), type->type, entry->name }; + std::cout << " spec resource " << id << " " << name; + if (entry->publicStatus.isPublic) { + std::cout << " PUBLIC"; + } + std::cout << std::endl; + + PrintVisitor visitor; + for (const auto& value : entry->values) { + std::cout << " (" << value.config << ") "; + value.value->accept(visitor, {}); + std::cout << std::endl; + } + } + } +} + +static size_t getNodeIndex(const std::vector<ResourceName>& names, const ResourceName& name) { + auto iter = std::lower_bound(names.begin(), names.end(), name); + assert(iter != names.end() && *iter == name); + return std::distance(names.begin(), iter); +} + +void Debug::printStyleGraph(const std::shared_ptr<ResourceTable>& table, + const ResourceName& targetStyle) { + std::map<ResourceName, std::set<ResourceName>> graph; + + std::queue<ResourceName> stylesToVisit; + stylesToVisit.push(targetStyle); + for (; !stylesToVisit.empty(); stylesToVisit.pop()) { + const ResourceName& styleName = stylesToVisit.front(); + std::set<ResourceName>& parents = graph[styleName]; + if (!parents.empty()) { + // We've already visited this style. + continue; + } + + const ResourceTableType* type; + const ResourceEntry* entry; + std::tie(type, entry) = table->findResource(styleName); + if (entry) { + for (const auto& value : entry->values) { + visitFunc<Style>(*value.value, [&](const Style& style) { + if (style.parent.name.isValid()) { + parents.insert(style.parent.name); + stylesToVisit.push(style.parent.name); + } + }); + } + } + } + + std::vector<ResourceName> names; + for (const auto& entry : graph) { + names.push_back(entry.first); + } + + std::cout << "digraph styles {\n"; + for (const auto& name : names) { + std::cout << " node_" << getNodeIndex(names, name) + << " [label=\"" << name << "\"];\n"; + } + + for (const auto& entry : graph) { + const ResourceName& styleName = entry.first; + size_t styleNodeIndex = getNodeIndex(names, styleName); + + for (const auto& parentName : entry.second) { + std::cout << " node_" << styleNodeIndex << " -> " + << "node_" << getNodeIndex(names, parentName) << ";\n"; + } + } + + std::cout << "}" << std::endl; +} + +} // namespace aapt diff --git a/tools/aapt2/Debug.h b/tools/aapt2/Debug.h new file mode 100644 index 0000000..cdb3dcb --- /dev/null +++ b/tools/aapt2/Debug.h @@ -0,0 +1,35 @@ +/* + * 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_DEBUG_H +#define AAPT_DEBUG_H + +#include "Resource.h" +#include "ResourceTable.h" + +#include <memory> + +namespace aapt { + +struct Debug { + static void printTable(const std::shared_ptr<ResourceTable>& table); + static void printStyleGraph(const std::shared_ptr<ResourceTable>& table, + const ResourceName& targetStyle); +}; + +} // namespace aapt + +#endif // AAPT_DEBUG_H diff --git a/tools/aapt2/Files.cpp b/tools/aapt2/Files.cpp new file mode 100644 index 0000000..8484148 --- /dev/null +++ b/tools/aapt2/Files.cpp @@ -0,0 +1,188 @@ +/* + * 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 "Files.h" +#include "Util.h" + +#include <cerrno> +#include <dirent.h> +#include <string> +#include <sys/stat.h> + +#ifdef HAVE_MS_C_RUNTIME +// Windows includes. +#include <direct.h> +#endif + +namespace aapt { + +FileType getFileType(const StringPiece& path) { + struct stat sb; + if (stat(path.data(), &sb) < 0) { + if (errno == ENOENT || errno == ENOTDIR) { + return FileType::kNonexistant; + } + return FileType::kUnknown; + } + + if (S_ISREG(sb.st_mode)) { + return FileType::kRegular; + } else if (S_ISDIR(sb.st_mode)) { + return FileType::kDirectory; + } else if (S_ISCHR(sb.st_mode)) { + return FileType::kCharDev; + } else if (S_ISBLK(sb.st_mode)) { + return FileType::kBlockDev; + } else if (S_ISFIFO(sb.st_mode)) { + return FileType::kFifo; +#if defined(S_ISLNK) + } else if (S_ISLNK(sb.st_mode)) { + return FileType::kSymlink; +#endif +#if defined(S_ISSOCK) + } else if (S_ISSOCK(sb.st_mode)) { + return FileType::kSocket; +#endif + } else { + return FileType::kUnknown; + } +} + +std::vector<std::string> listFiles(const StringPiece& root) { + DIR* dir = opendir(root.data()); + if (dir == nullptr) { + Logger::error(Source{ root.toString() }) + << "unable to open file: " + << strerror(errno) + << "." + << std::endl; + return {}; + } + + std::vector<std::string> files; + dirent* entry; + while ((entry = readdir(dir))) { + files.emplace_back(entry->d_name); + } + + closedir(dir); + return files; +} + +inline static int mkdirImpl(const StringPiece& path) { +#ifdef HAVE_MS_C_RUNTIME + return _mkdir(path.toString().c_str()); +#else + return mkdir(path.toString().c_str(), S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IXGRP); +#endif +} + +bool mkdirs(const StringPiece& path) { + const char* start = path.begin(); + const char* end = path.end(); + for (const char* current = start; current != end; ++current) { + if (*current == sDirSep) { + StringPiece parentPath(start, current - start); + int result = mkdirImpl(parentPath); + if (result < 0 && errno != EEXIST) { + return false; + } + } + } + return mkdirImpl(path) == 0 || errno == EEXIST; +} + +std::string getStem(const StringPiece& path) { + const char* start = path.begin(); + const char* end = path.end(); + for (const char* current = end - 1; current != start - 1; --current) { + if (*current == sDirSep) { + return std::string(start, current - start); + } + } + return {}; +} + +bool FileFilter::setPattern(const StringPiece& pattern) { + mPatternTokens = util::splitAndLowercase(pattern, ':'); + return true; +} + +bool FileFilter::operator()(const std::string& filename, FileType type) const { + if (filename == "." || filename == "..") { + return false; + } + + const char kDir[] = "dir"; + const char kFile[] = "file"; + const size_t filenameLen = filename.length(); + bool chatty = true; + for (const std::string& token : mPatternTokens) { + const char* tokenStr = token.c_str(); + if (*tokenStr == '!') { + chatty = false; + tokenStr++; + } + + if (strncasecmp(tokenStr, kDir, sizeof(kDir)) == 0) { + if (type != FileType::kDirectory) { + continue; + } + tokenStr += sizeof(kDir); + } + + if (strncasecmp(tokenStr, kFile, sizeof(kFile)) == 0) { + if (type != FileType::kRegular) { + continue; + } + tokenStr += sizeof(kFile); + } + + bool ignore = false; + size_t n = strlen(tokenStr); + if (*tokenStr == '*') { + // Math suffix. + tokenStr++; + n--; + if (n <= filenameLen) { + ignore = strncasecmp(tokenStr, filename.c_str() + filenameLen - n, n) == 0; + } + } else if (n > 1 && tokenStr[n - 1] == '*') { + // Match prefix. + ignore = strncasecmp(tokenStr, filename.c_str(), n - 1) == 0; + } else { + ignore = strcasecmp(tokenStr, filename.c_str()) == 0; + } + + if (ignore) { + if (chatty) { + Logger::warn() + << "skipping " << + (type == FileType::kDirectory ? "dir '" : "file '") + << filename + << "' due to ignore pattern '" + << token + << "'." + << std::endl; + } + return false; + } + } + return true; +} + + +} // namespace aapt diff --git a/tools/aapt2/Files.h b/tools/aapt2/Files.h new file mode 100644 index 0000000..844fd2b --- /dev/null +++ b/tools/aapt2/Files.h @@ -0,0 +1,128 @@ +/* + * 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_FILES_H +#define AAPT_FILES_H + +#include "Logger.h" +#include "Source.h" +#include "StringPiece.h" + +#include <cassert> +#include <string> +#include <vector> + +namespace aapt { + +#ifdef _WIN32 +constexpr const char sDirSep = '\\'; +#else +constexpr const char sDirSep = '/'; +#endif + +enum class FileType { + kUnknown = 0, + kNonexistant, + kRegular, + kDirectory, + kCharDev, + kBlockDev, + kFifo, + kSymlink, + kSocket, +}; + +FileType getFileType(const StringPiece& path); + +/* + * Lists files under the directory `root`. Files are listed + * with just their leaf (filename) names. + */ +std::vector<std::string> listFiles(const StringPiece& root); + +/* + * Appends a path to `base`, separated by the directory separator. + */ +void appendPath(std::string* base, const StringPiece& part); + +/* + * Appends a series of paths to `base`, separated by the + * system directory separator. + */ +template <typename... Ts > +void appendPath(std::string* base, const StringPiece& part, const Ts&... parts); + +/* + * Makes all the directories in `path`. The last element in the path + * is interpreted as a directory. + */ +bool mkdirs(const StringPiece& path); + +/** + * Returns all but the last part of the path. + */ +std::string getStem(const StringPiece& path); + +/* + * Filter that determines which resource files/directories are + * processed by AAPT. Takes a pattern string supplied by the user. + * Pattern format is specified in the + * FileFilter::setPattern(const std::string&) method. + */ +class FileFilter { +public: + /* + * Patterns syntax: + * - Delimiter is : + * - Entry can start with the flag ! to avoid printing a warning + * about the file being ignored. + * - Entry can have the flag "<dir>" to match only directories + * or <file> to match only files. Default is to match both. + * - Entry can be a simplified glob "<prefix>*" or "*<suffix>" + * where prefix/suffix must have at least 1 character (so that + * we don't match a '*' catch-all pattern.) + * - The special filenames "." and ".." are always ignored. + * - Otherwise the full string is matched. + * - match is not case-sensitive. + */ + bool setPattern(const StringPiece& pattern); + + /** + * Applies the filter, returning true for pass, false for fail. + */ + bool operator()(const std::string& filename, FileType type) const; + +private: + std::vector<std::string> mPatternTokens; +}; + +inline void appendPath(std::string* base, const StringPiece& part) { + assert(base); + *base += sDirSep; + base->append(part.data(), part.size()); +} + +template <typename... Ts > +void appendPath(std::string* base, const StringPiece& part, const Ts&... parts) { + assert(base); + *base += sDirSep; + base->append(part.data(), part.size()); + appendPath(base, parts...); +} + +} // namespace aapt + +#endif // AAPT_FILES_H diff --git a/tools/aapt2/Flag.cpp b/tools/aapt2/Flag.cpp new file mode 100644 index 0000000..76985da --- /dev/null +++ b/tools/aapt2/Flag.cpp @@ -0,0 +1,132 @@ +#include "Flag.h" +#include "StringPiece.h" + +#include <functional> +#include <iomanip> +#include <iostream> +#include <string> +#include <vector> + +namespace aapt { +namespace flag { + +struct Flag { + std::string name; + std::string description; + std::function<bool(const StringPiece&, std::string*)> action; + bool required; + bool* flagResult; + bool flagValueWhenSet; + bool parsed; +}; + +static std::vector<Flag> sFlags; +static std::vector<std::string> sArgs; + +static std::function<bool(const StringPiece&, std::string*)> wrap( + const std::function<void(const StringPiece&)>& action) { + return [action](const StringPiece& arg, std::string*) -> bool { + action(arg); + return true; + }; +} + +void optionalFlag(const StringPiece& name, const StringPiece& description, + std::function<void(const StringPiece&)> action) { + sFlags.push_back(Flag{ + name.toString(), description.toString(), wrap(action), + false, nullptr, false, false }); +} + +void requiredFlag(const StringPiece& name, const StringPiece& description, + std::function<void(const StringPiece&)> action) { + sFlags.push_back(Flag{ name.toString(), description.toString(), wrap(action), + true, nullptr, false, false }); +} + +void requiredFlag(const StringPiece& name, const StringPiece& description, + std::function<bool(const StringPiece&, std::string*)> action) { + sFlags.push_back(Flag{ name.toString(), description.toString(), action, + true, nullptr, false, false }); +} + +void optionalSwitch(const StringPiece& name, const StringPiece& description, bool resultWhenSet, + bool* result) { + sFlags.push_back(Flag{ + name.toString(), description.toString(), {}, + false, result, resultWhenSet, false }); +} + +void usageAndDie(const StringPiece& command) { + std::cerr << command << " [options]"; + for (const Flag& flag : sFlags) { + if (flag.required) { + std::cerr << " " << flag.name << " arg"; + } + } + std::cerr << " files..." << std::endl << std::endl << "Options:" << std::endl; + + for (const Flag& flag : sFlags) { + std::string command = flag.name; + if (!flag.flagResult) { + command += " arg "; + } + std::cerr << " " << std::setw(30) << std::left << command + << flag.description << std::endl; + } + exit(1); +} + +void parse(int argc, char** argv, const StringPiece& command) { + std::string errorStr; + for (int i = 0; i < argc; i++) { + const StringPiece arg(argv[i]); + if (*arg.data() != '-') { + sArgs.push_back(arg.toString()); + continue; + } + + bool match = false; + for (Flag& flag : sFlags) { + if (arg == flag.name) { + match = true; + flag.parsed = true; + if (flag.flagResult) { + *flag.flagResult = flag.flagValueWhenSet; + } else { + i++; + if (i >= argc) { + std::cerr << flag.name << " missing argument." << std::endl + << std::endl; + usageAndDie(command); + } + + if (!flag.action(argv[i], &errorStr)) { + std::cerr << errorStr << "." << std::endl << std::endl; + usageAndDie(command); + } + } + break; + } + } + + if (!match) { + std::cerr << "unknown option '" << arg << "'." << std::endl << std::endl; + usageAndDie(command); + } + } + + for (const Flag& flag : sFlags) { + if (flag.required && !flag.parsed) { + std::cerr << "missing required flag " << flag.name << std::endl << std::endl; + usageAndDie(command); + } + } +} + +const std::vector<std::string>& getArgs() { + return sArgs; +} + +} // namespace flag +} // namespace aapt diff --git a/tools/aapt2/Flag.h b/tools/aapt2/Flag.h new file mode 100644 index 0000000..e863742 --- /dev/null +++ b/tools/aapt2/Flag.h @@ -0,0 +1,34 @@ +#ifndef AAPT_FLAG_H +#define AAPT_FLAG_H + +#include "StringPiece.h" + +#include <functional> +#include <string> +#include <vector> + +namespace aapt { +namespace flag { + +void requiredFlag(const StringPiece& name, const StringPiece& description, + std::function<void(const StringPiece&)> action); + +void requiredFlag(const StringPiece& name, const StringPiece& description, + std::function<bool(const StringPiece&, std::string*)> action); + +void optionalFlag(const StringPiece& name, const StringPiece& description, + std::function<void(const StringPiece&)> action); + +void optionalSwitch(const StringPiece& name, const StringPiece& description, bool resultWhenSet, + bool* result); + +void usageAndDie(const StringPiece& command); + +void parse(int argc, char** argv, const StringPiece& command); + +const std::vector<std::string>& getArgs(); + +} // namespace flag +} // namespace aapt + +#endif // AAPT_FLAG_H diff --git a/tools/aapt2/JavaClassGenerator.cpp b/tools/aapt2/JavaClassGenerator.cpp new file mode 100644 index 0000000..e2ffe79 --- /dev/null +++ b/tools/aapt2/JavaClassGenerator.cpp @@ -0,0 +1,208 @@ +/* + * 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 "JavaClassGenerator.h" +#include "NameMangler.h" +#include "Resource.h" +#include "ResourceTable.h" +#include "ResourceValues.h" +#include "StringPiece.h" + +#include <algorithm> +#include <ostream> +#include <set> +#include <sstream> +#include <tuple> + +namespace aapt { + +// The number of attributes to emit per line in a Styleable array. +constexpr size_t kAttribsPerLine = 4; + +JavaClassGenerator::JavaClassGenerator(const std::shared_ptr<const ResourceTable>& table, + Options options) : + mTable(table), mOptions(options) { +} + +static void generateHeader(std::ostream& out, const StringPiece16& package) { + out << "/* AUTO-GENERATED FILE. DO NOT MODIFY.\n" + " *\n" + " * This class was automatically generated by the\n" + " * aapt tool from the resource data it found. It\n" + " * should not be modified by hand.\n" + " */\n\n"; + out << "package " << package << ";" + << std::endl + << std::endl; +} + +static const std::set<StringPiece16> sJavaIdentifiers = { + u"abstract", u"assert", u"boolean", u"break", u"byte", + u"case", u"catch", u"char", u"class", u"const", u"continue", + u"default", u"do", u"double", u"else", u"enum", u"extends", + u"final", u"finally", u"float", u"for", u"goto", u"if", + u"implements", u"import", u"instanceof", u"int", u"interface", + u"long", u"native", u"new", u"package", u"private", u"protected", + u"public", u"return", u"short", u"static", u"strictfp", u"super", + u"switch", u"synchronized", u"this", u"throw", u"throws", + u"transient", u"try", u"void", u"volatile", u"while", u"true", + u"false", u"null" +}; + +static bool isValidSymbol(const StringPiece16& symbol) { + return sJavaIdentifiers.find(symbol) == sJavaIdentifiers.end(); +} + +/* + * Java symbols can not contain . or -, but those are valid in a resource name. + * Replace those with '_'. + */ +static std::u16string transform(const StringPiece16& symbol) { + std::u16string output = symbol.toString(); + for (char16_t& c : output) { + if (c == u'.' || c == u'-') { + c = u'_'; + } + } + return output; +} + +struct GenArgs : ValueVisitorArgs { + GenArgs(std::ostream* o, const std::u16string* p, std::u16string* e) : + out(o), package(p), entryName(e) { + } + + std::ostream* out; + const std::u16string* package; + std::u16string* entryName; +}; + +void JavaClassGenerator::visit(const Styleable& styleable, ValueVisitorArgs& a) { + const StringPiece finalModifier = mOptions.useFinal ? " final" : ""; + std::ostream* out = static_cast<GenArgs&>(a).out; + const std::u16string* package = static_cast<GenArgs&>(a).package; + std::u16string* entryName = static_cast<GenArgs&>(a).entryName; + + // This must be sorted by resource ID. + std::vector<std::pair<ResourceId, ResourceNameRef>> sortedAttributes; + sortedAttributes.reserve(styleable.entries.size()); + for (const auto& attr : styleable.entries) { + // If we are not encoding final attributes, the styleable entry may have no ID + // if we are building a static library. + assert((!mOptions.useFinal || attr.id.isValid()) && "no ID set for Styleable entry"); + assert(attr.name.isValid() && "no name set for Styleable entry"); + sortedAttributes.emplace_back(attr.id, attr.name); + } + std::sort(sortedAttributes.begin(), sortedAttributes.end()); + + // First we emit the array containing the IDs of each attribute. + *out << " " + << "public static final int[] " << transform(*entryName) << " = {"; + + const size_t attrCount = sortedAttributes.size(); + for (size_t i = 0; i < attrCount; i++) { + if (i % kAttribsPerLine == 0) { + *out << std::endl << " "; + } + + *out << sortedAttributes[i].first; + if (i != attrCount - 1) { + *out << ", "; + } + } + *out << std::endl << " };" << std::endl; + + // Now we emit the indices into the array. + for (size_t i = 0; i < attrCount; i++) { + *out << " " + << "public static" << finalModifier + << " int " << transform(*entryName); + + // We may reference IDs from other packages, so prefix the entry name with + // the package. + const ResourceNameRef& itemName = sortedAttributes[i].second; + if (itemName.package != *package) { + *out << "_" << transform(itemName.package); + } + *out << "_" << transform(itemName.entry) << " = " << i << ";" << std::endl; + } +} + +bool JavaClassGenerator::generateType(const std::u16string& package, size_t packageId, + const ResourceTableType& type, std::ostream& out) { + const StringPiece finalModifier = mOptions.useFinal ? " final" : ""; + + std::u16string unmangledPackage; + std::u16string unmangledName; + for (const auto& entry : type.entries) { + ResourceId id = { packageId, type.typeId, entry->entryId }; + assert(id.isValid()); + + unmangledName = entry->name; + if (NameMangler::unmangle(&unmangledName, &unmangledPackage)) { + // The entry name was mangled, and we successfully unmangled it. + // Check that we want to emit this symbol. + if (package != unmangledPackage) { + // Skip the entry if it doesn't belong to the package we're writing. + continue; + } + } else { + if (package != mTable->getPackage()) { + // We are processing a mangled package name, + // but this is a non-mangled resource. + continue; + } + } + + if (!isValidSymbol(unmangledName)) { + ResourceNameRef resourceName = { package, type.type, unmangledName }; + std::stringstream err; + err << "invalid symbol name '" << resourceName << "'"; + mError = err.str(); + return false; + } + + if (type.type == ResourceType::kStyleable) { + assert(!entry->values.empty()); + entry->values.front().value->accept(*this, GenArgs{ &out, &package, &unmangledName }); + } else { + out << " " << "public static" << finalModifier + << " int " << transform(unmangledName) << " = " << id << ";" << std::endl; + } + } + return true; +} + +bool JavaClassGenerator::generate(const std::u16string& package, std::ostream& out) { + const size_t packageId = mTable->getPackageId(); + + generateHeader(out, package); + + out << "public final class R {" << std::endl; + + for (const auto& type : *mTable) { + out << " public static final class " << type->type << " {" << std::endl; + if (!generateType(package, packageId, *type, out)) { + return false; + } + out << " }" << std::endl; + } + + out << "}" << std::endl; + return true; +} + +} // namespace aapt diff --git a/tools/aapt2/JavaClassGenerator.h b/tools/aapt2/JavaClassGenerator.h new file mode 100644 index 0000000..f8b9ee3 --- /dev/null +++ b/tools/aapt2/JavaClassGenerator.h @@ -0,0 +1,77 @@ +/* + * 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_JAVA_CLASS_GENERATOR_H +#define AAPT_JAVA_CLASS_GENERATOR_H + +#include "ResourceTable.h" +#include "ResourceValues.h" + +#include <ostream> +#include <string> + +namespace aapt { + +/* + * Generates the R.java file for a resource table. + */ +class JavaClassGenerator : ConstValueVisitor { +public: + /* + * A set of options for this JavaClassGenerator. + */ + struct Options { + /* + * Specifies whether to use the 'final' modifier + * on resource entries. Default is true. + */ + bool useFinal = true; + }; + + JavaClassGenerator(const std::shared_ptr<const ResourceTable>& table, Options options); + + /* + * Writes the R.java file to `out`. Only symbols belonging to `package` are written. + * All symbols technically belong to a single package, but linked libraries will + * have their names mangled, denoting that they came from a different package. + * We need to generate these symbols in a separate file. + * Returns true on success. + */ + bool generate(const std::u16string& package, std::ostream& out); + + /* + * ConstValueVisitor implementation. + */ + void visit(const Styleable& styleable, ValueVisitorArgs& args); + + const std::string& getError() const; + +private: + bool generateType(const std::u16string& package, size_t packageId, + const ResourceTableType& type, std::ostream& out); + + std::shared_ptr<const ResourceTable> mTable; + Options mOptions; + std::string mError; +}; + +inline const std::string& JavaClassGenerator::getError() const { + return mError; +} + +} // namespace aapt + +#endif // AAPT_JAVA_CLASS_GENERATOR_H diff --git a/tools/aapt2/JavaClassGenerator_test.cpp b/tools/aapt2/JavaClassGenerator_test.cpp new file mode 100644 index 0000000..b385ff4 --- /dev/null +++ b/tools/aapt2/JavaClassGenerator_test.cpp @@ -0,0 +1,146 @@ +/* + * 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 "JavaClassGenerator.h" +#include "Linker.h" +#include "MockResolver.h" +#include "ResourceTable.h" +#include "ResourceTableResolver.h" +#include "ResourceValues.h" +#include "Util.h" + +#include <gtest/gtest.h> +#include <sstream> +#include <string> + +namespace aapt { + +struct JavaClassGeneratorTest : public ::testing::Test { + virtual void SetUp() override { + mTable = std::make_shared<ResourceTable>(); + mTable->setPackage(u"android"); + mTable->setPackageId(0x01); + } + + bool addResource(const ResourceNameRef& name, ResourceId id) { + return mTable->addResource(name, id, {}, SourceLine{ "test.xml", 21 }, + util::make_unique<Id>()); + } + + std::shared_ptr<ResourceTable> mTable; +}; + +TEST_F(JavaClassGeneratorTest, FailWhenEntryIsJavaKeyword) { + ASSERT_TRUE(addResource(ResourceName{ {}, ResourceType::kId, u"class" }, + ResourceId{ 0x01, 0x02, 0x0000 })); + + JavaClassGenerator generator(mTable, {}); + + std::stringstream out; + EXPECT_FALSE(generator.generate(mTable->getPackage(), out)); +} + +TEST_F(JavaClassGeneratorTest, TransformInvalidJavaIdentifierCharacter) { + ASSERT_TRUE(addResource(ResourceName{ {}, ResourceType::kId, u"hey-man" }, + ResourceId{ 0x01, 0x02, 0x0000 })); + + ASSERT_TRUE(addResource(ResourceName{ {}, ResourceType::kAttr, u"cool.attr" }, + ResourceId{ 0x01, 0x01, 0x0000 })); + + std::unique_ptr<Styleable> styleable = util::make_unique<Styleable>(); + Reference ref(ResourceName{ u"android", ResourceType::kAttr, u"cool.attr"}); + ref.id = ResourceId{ 0x01, 0x01, 0x0000 }; + styleable->entries.emplace_back(ref); + + ASSERT_TRUE(mTable->addResource(ResourceName{ {}, ResourceType::kStyleable, u"hey.dude" }, + ResourceId{ 0x01, 0x03, 0x0000 }, {}, + SourceLine{ "test.xml", 21 }, std::move(styleable))); + + JavaClassGenerator generator(mTable, {}); + + std::stringstream out; + EXPECT_TRUE(generator.generate(mTable->getPackage(), out)); + std::string output = out.str(); + + EXPECT_NE(std::string::npos, + output.find("public static final int hey_man = 0x01020000;")); + + EXPECT_NE(std::string::npos, + output.find("public static final int[] hey_dude = {")); + + EXPECT_NE(std::string::npos, + output.find("public static final int hey_dude_cool_attr = 0;")); +} + + +TEST_F(JavaClassGeneratorTest, EmitPackageMangledSymbols) { + ASSERT_TRUE(addResource(ResourceName{ {}, ResourceType::kId, u"foo" }, + ResourceId{ 0x01, 0x02, 0x0000 })); + ResourceTable table; + table.setPackage(u"com.lib"); + ASSERT_TRUE(table.addResource(ResourceName{ {}, ResourceType::kId, u"test" }, {}, + SourceLine{ "lib.xml", 33 }, util::make_unique<Id>())); + ASSERT_TRUE(mTable->merge(std::move(table))); + + Linker linker(mTable, + std::make_shared<MockResolver>(mTable, std::map<ResourceName, ResourceId>()), + {}); + ASSERT_TRUE(linker.linkAndValidate()); + + JavaClassGenerator generator(mTable, {}); + + std::stringstream out; + EXPECT_TRUE(generator.generate(mTable->getPackage(), out)); + std::string output = out.str(); + EXPECT_NE(std::string::npos, output.find("int foo =")); + EXPECT_EQ(std::string::npos, output.find("int test =")); + + out.str(""); + EXPECT_TRUE(generator.generate(u"com.lib", out)); + output = out.str(); + EXPECT_NE(std::string::npos, output.find("int test =")); + EXPECT_EQ(std::string::npos, output.find("int foo =")); +} + +TEST_F(JavaClassGeneratorTest, EmitOtherPackagesAttributesInStyleable) { + std::unique_ptr<Styleable> styleable = util::make_unique<Styleable>(); + styleable->entries.emplace_back(ResourceNameRef{ mTable->getPackage(), + ResourceType::kAttr, + u"bar" }); + styleable->entries.emplace_back(ResourceNameRef{ u"com.lib", ResourceType::kAttr, u"bar" }); + ASSERT_TRUE(mTable->addResource(ResourceName{ {}, ResourceType::kStyleable, u"Foo" }, {}, {}, + std::move(styleable))); + + std::shared_ptr<IResolver> resolver = std::make_shared<MockResolver>(mTable, + std::map<ResourceName, ResourceId>({ + { ResourceName{ u"android", ResourceType::kAttr, u"bar" }, + ResourceId{ 0x01, 0x01, 0x0000 } }, + { ResourceName{ u"com.lib", ResourceType::kAttr, u"bar" }, + ResourceId{ 0x02, 0x01, 0x0000 } }})); + + Linker linker(mTable, resolver, {}); + ASSERT_TRUE(linker.linkAndValidate()); + + JavaClassGenerator generator(mTable, {}); + + std::stringstream out; + EXPECT_TRUE(generator.generate(mTable->getPackage(), out)); + std::string output = out.str(); + EXPECT_NE(std::string::npos, output.find("int Foo_bar =")); + EXPECT_NE(std::string::npos, output.find("int Foo_com_lib_bar =")); +} + +} // namespace aapt diff --git a/tools/aapt2/Linker.cpp b/tools/aapt2/Linker.cpp new file mode 100644 index 0000000..f3f04a5 --- /dev/null +++ b/tools/aapt2/Linker.cpp @@ -0,0 +1,290 @@ +/* + * 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 "Linker.h" +#include "Logger.h" +#include "NameMangler.h" +#include "Resolver.h" +#include "ResourceParser.h" +#include "ResourceTable.h" +#include "ResourceValues.h" +#include "StringPiece.h" +#include "Util.h" + +#include <androidfw/AssetManager.h> +#include <array> +#include <bitset> +#include <iostream> +#include <map> +#include <ostream> +#include <set> +#include <sstream> +#include <tuple> +#include <vector> + +namespace aapt { + +Linker::Args::Args(const ResourceNameRef& r, const SourceLine& s) : referrer(r), source(s) { +} + +Linker::Linker(const std::shared_ptr<ResourceTable>& table, + const std::shared_ptr<IResolver>& resolver, const Options& options) : + mResolver(resolver), mTable(table), mOptions(options), mError(false) { +} + +bool Linker::linkAndValidate() { + std::bitset<256> usedTypeIds; + std::array<std::set<uint16_t>, 256> usedIds; + usedTypeIds.set(0); + + // Collect which resource IDs are already taken. + for (auto& type : *mTable) { + if (type->typeId != ResourceTableType::kUnsetTypeId) { + // The ID for this type has already been set. We + // mark this ID as taken so we don't re-assign it + // later. + usedTypeIds.set(type->typeId); + } + + for (auto& entry : type->entries) { + if (type->typeId != ResourceTableType::kUnsetTypeId && + entry->entryId != ResourceEntry::kUnsetEntryId) { + // The ID for this entry has already been set. We + // mark this ID as taken so we don't re-assign it + // later. + usedIds[type->typeId].insert(entry->entryId); + } + } + } + + // Assign resource IDs that are available. + size_t nextTypeIndex = 0; + for (auto& type : *mTable) { + if (type->typeId == ResourceTableType::kUnsetTypeId) { + while (nextTypeIndex < usedTypeIds.size() && usedTypeIds[nextTypeIndex]) { + nextTypeIndex++; + } + type->typeId = nextTypeIndex++; + } + + const auto endEntryIter = std::end(usedIds[type->typeId]); + auto nextEntryIter = std::begin(usedIds[type->typeId]); + size_t nextIndex = 0; + for (auto& entry : type->entries) { + if (entry->entryId == ResourceTableType::kUnsetTypeId) { + while (nextEntryIter != endEntryIter && + nextIndex == *nextEntryIter) { + nextIndex++; + ++nextEntryIter; + } + entry->entryId = nextIndex++; + } + } + } + + // Now do reference linking. + for (auto& type : *mTable) { + for (auto& entry : type->entries) { + if (entry->publicStatus.isPublic && entry->values.empty()) { + // A public resource has no values. It will not be encoded + // properly without a symbol table. This is a unresolved symbol. + addUnresolvedSymbol(ResourceNameRef{ + mTable->getPackage(), type->type, entry->name }, + entry->publicStatus.source); + continue; + } + + for (auto& valueConfig : entry->values) { + // Dispatch to the right method of this linker + // based on the value's type. + valueConfig.value->accept(*this, Args{ + ResourceNameRef{ mTable->getPackage(), type->type, entry->name }, + valueConfig.source + }); + } + } + } + return !mError; +} + +const Linker::ResourceNameToSourceMap& Linker::getUnresolvedReferences() const { + return mUnresolvedSymbols; +} + +void Linker::doResolveReference(Reference& reference, const SourceLine& source) { + Maybe<ResourceId> result = mResolver->findId(reference.name); + if (!result) { + addUnresolvedSymbol(reference.name, source); + return; + } + assert(result.value().isValid()); + + if (mOptions.linkResourceIds) { + reference.id = result.value(); + } else { + reference.id = 0; + } +} + +const Attribute* Linker::doResolveAttribute(Reference& attribute, const SourceLine& source) { + Maybe<IResolver::Entry> result = mResolver->findAttribute(attribute.name); + if (!result || !result.value().attr) { + addUnresolvedSymbol(attribute.name, source); + return nullptr; + } + + const IResolver::Entry& entry = result.value(); + assert(entry.id.isValid()); + + if (mOptions.linkResourceIds) { + attribute.id = entry.id; + } else { + attribute.id = 0; + } + return entry.attr; +} + +void Linker::visit(Reference& reference, ValueVisitorArgs& a) { + Args& args = static_cast<Args&>(a); + + if (!reference.name.isValid()) { + // We can't have a completely bad reference. + if (!reference.id.isValid()) { + Logger::error() << "srsly? " << args.referrer << std::endl; + assert(reference.id.isValid()); + } + + // This reference has no name but has an ID. + // It is a really bad error to have no name and have the same + // package ID. + assert(reference.id.packageId() != mTable->getPackageId()); + + // The reference goes outside this package, let it stay as a + // resource ID because it will not change. + return; + } + + doResolveReference(reference, args.source); + + // TODO(adamlesinski): Verify the referencedType is another reference + // or a compatible primitive. +} + +void Linker::processAttributeValue(const ResourceNameRef& name, const SourceLine& source, + const Attribute& attr, std::unique_ptr<Item>& value) { + std::unique_ptr<Item> convertedValue; + visitFunc<RawString>(*value, [&](RawString& str) { + // This is a raw string, so check if it can be converted to anything. + // We can NOT swap value with the converted value in here, since + // we called through the original value. + + auto onCreateReference = [&](const ResourceName& name) { + // We should never get here. All references would have been + // parsed in the parser phase. + assert(false); + }; + + convertedValue = ResourceParser::parseItemForAttribute(*str.value, attr, + onCreateReference); + if (!convertedValue && attr.typeMask & android::ResTable_map::TYPE_STRING) { + // Last effort is to parse as a string. + util::StringBuilder builder; + builder.append(*str.value); + if (builder) { + convertedValue = util::make_unique<String>( + mTable->getValueStringPool().makeRef(builder.str())); + } + } + }); + + if (convertedValue) { + value = std::move(convertedValue); + } + + // Process this new or old value (it can be a reference!). + value->accept(*this, Args{ name, source }); + + // Flatten the value to see what resource type it is. + android::Res_value resValue; + value->flatten(resValue); + + // Always allow references. + const uint32_t typeMask = attr.typeMask | android::ResTable_map::TYPE_REFERENCE; + if (!(typeMask & ResourceParser::androidTypeToAttributeTypeMask(resValue.dataType))) { + Logger::error(source) + << *value + << " is not compatible with attribute " + << attr + << "." + << std::endl; + mError = true; + } +} + +void Linker::visit(Style& style, ValueVisitorArgs& a) { + Args& args = static_cast<Args&>(a); + + if (style.parent.name.isValid() || style.parent.id.isValid()) { + visit(style.parent, a); + } + + for (Style::Entry& styleEntry : style.entries) { + const Attribute* attr = doResolveAttribute(styleEntry.key, args.source); + if (attr) { + processAttributeValue(args.referrer, args.source, *attr, styleEntry.value); + } + } +} + +void Linker::visit(Attribute& attr, ValueVisitorArgs& a) { + static constexpr uint32_t kMask = android::ResTable_map::TYPE_ENUM | + android::ResTable_map::TYPE_FLAGS; + if (attr.typeMask & kMask) { + for (auto& symbol : attr.symbols) { + visit(symbol.symbol, a); + } + } +} + +void Linker::visit(Styleable& styleable, ValueVisitorArgs& a) { + for (auto& attrRef : styleable.entries) { + visit(attrRef, a); + } +} + +void Linker::visit(Array& array, ValueVisitorArgs& a) { + Args& args = static_cast<Args&>(a); + + for (auto& item : array.items) { + item->accept(*this, Args{ args.referrer, args.source }); + } +} + +void Linker::visit(Plural& plural, ValueVisitorArgs& a) { + Args& args = static_cast<Args&>(a); + + for (auto& item : plural.values) { + if (item) { + item->accept(*this, Args{ args.referrer, args.source }); + } + } +} + +void Linker::addUnresolvedSymbol(const ResourceNameRef& name, const SourceLine& source) { + mUnresolvedSymbols[name.toResourceName()].push_back(source); +} + +} // namespace aapt diff --git a/tools/aapt2/Linker.h b/tools/aapt2/Linker.h new file mode 100644 index 0000000..6f03515 --- /dev/null +++ b/tools/aapt2/Linker.h @@ -0,0 +1,124 @@ +/* + * 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_LINKER_H +#define AAPT_LINKER_H + +#include "Resolver.h" +#include "ResourceTable.h" +#include "ResourceValues.h" +#include "Source.h" +#include "StringPiece.h" + +#include <androidfw/AssetManager.h> +#include <map> +#include <memory> +#include <ostream> +#include <set> +#include <vector> + +namespace aapt { + +/** + * The Linker has two jobs. It follows resource references + * and verifies that their targert exists and that their + * types are compatible. The Linker will also assign resource + * IDs and fill in all the dependent references with the newly + * assigned resource IDs. + * + * To do this, the Linker builds a graph of references. This + * can be useful to do other analysis, like building a + * dependency graph of source files. The hope is to be able to + * add functionality that operates on the graph without + * overcomplicating the Linker. + * + * TODO(adamlesinski): Build the graph first then run the separate + * steps over the graph. + */ +class Linker : ValueVisitor { +public: + struct Options { + /** + * Assign resource Ids to references when linking. + * When building a static library, set this to false. + */ + bool linkResourceIds = true; + }; + + /** + * Create a Linker for the given resource table with the sources available in + * IResolver. IResolver should contain the ResourceTable as a source too. + */ + Linker(const std::shared_ptr<ResourceTable>& table, + const std::shared_ptr<IResolver>& resolver, const Options& options); + + Linker(const Linker&) = delete; + + virtual ~Linker() = default; + + /** + * Entry point to the linker. Assigns resource IDs, follows references, + * and validates types. Returns true if all references to defined values + * are type-compatible. Missing resource references are recorded but do + * not cause this method to fail. + */ + bool linkAndValidate(); + + /** + * Returns any references to resources that were not defined in any of the + * sources. + */ + using ResourceNameToSourceMap = std::map<ResourceName, std::vector<SourceLine>>; + const ResourceNameToSourceMap& getUnresolvedReferences() const; + +protected: + virtual void doResolveReference(Reference& reference, const SourceLine& source); + virtual const Attribute* doResolveAttribute(Reference& attribute, const SourceLine& source); + + std::shared_ptr<IResolver> mResolver; + +private: + struct Args : public ValueVisitorArgs { + Args(const ResourceNameRef& r, const SourceLine& s); + + const ResourceNameRef& referrer; + const SourceLine& source; + }; + + // + // Overrides of ValueVisitor + // + void visit(Reference& reference, ValueVisitorArgs& args) override; + void visit(Attribute& attribute, ValueVisitorArgs& args) override; + void visit(Styleable& styleable, ValueVisitorArgs& args) override; + void visit(Style& style, ValueVisitorArgs& args) override; + void visit(Array& array, ValueVisitorArgs& args) override; + void visit(Plural& plural, ValueVisitorArgs& args) override; + + void processAttributeValue(const ResourceNameRef& name, const SourceLine& source, + const Attribute& attr, std::unique_ptr<Item>& value); + + void addUnresolvedSymbol(const ResourceNameRef& name, const SourceLine& source); + + std::shared_ptr<ResourceTable> mTable; + std::map<ResourceName, std::vector<SourceLine>> mUnresolvedSymbols; + Options mOptions; + bool mError; +}; + +} // namespace aapt + +#endif // AAPT_LINKER_H diff --git a/tools/aapt2/Linker_test.cpp b/tools/aapt2/Linker_test.cpp new file mode 100644 index 0000000..d897f98 --- /dev/null +++ b/tools/aapt2/Linker_test.cpp @@ -0,0 +1,153 @@ +/* + * 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 "Linker.h" +#include "ResourceTable.h" +#include "ResourceTableResolver.h" +#include "ResourceValues.h" +#include "Util.h" + +#include <androidfw/AssetManager.h> +#include <gtest/gtest.h> +#include <string> + +namespace aapt { + +struct LinkerTest : public ::testing::Test { + virtual void SetUp() override { + mTable = std::make_shared<ResourceTable>(); + mTable->setPackage(u"android"); + mTable->setPackageId(0x01); + mLinker = std::make_shared<Linker>(mTable, std::make_shared<ResourceTableResolver>( + mTable, std::vector<std::shared_ptr<const android::AssetManager>>()), + Linker::Options{}); + + // Create a few attributes for use in the tests. + + addResource(ResourceName{ {}, ResourceType::kAttr, u"integer" }, + util::make_unique<Attribute>(false, android::ResTable_map::TYPE_INTEGER)); + + addResource(ResourceName{ {}, ResourceType::kAttr, u"string" }, + util::make_unique<Attribute>(false, android::ResTable_map::TYPE_STRING)); + + addResource(ResourceName{ {}, ResourceType::kId, u"apple" }, util::make_unique<Id>()); + + addResource(ResourceName{ {}, ResourceType::kId, u"banana" }, util::make_unique<Id>()); + + std::unique_ptr<Attribute> flagAttr = util::make_unique<Attribute>( + false, android::ResTable_map::TYPE_FLAGS); + flagAttr->symbols.push_back(Attribute::Symbol{ + ResourceNameRef{ u"android", ResourceType::kId, u"apple" }, 1 }); + flagAttr->symbols.push_back(Attribute::Symbol{ + ResourceNameRef{ u"android", ResourceType::kId, u"banana" }, 2 }); + addResource(ResourceName{ {}, ResourceType::kAttr, u"flags" }, std::move(flagAttr)); + } + + /* + * Convenience method for adding resources with the default configuration and some + * bogus source line. + */ + bool addResource(const ResourceNameRef& name, std::unique_ptr<Value> value) { + return mTable->addResource(name, {}, SourceLine{ "test.xml", 21 }, std::move(value)); + } + + std::shared_ptr<ResourceTable> mTable; + std::shared_ptr<Linker> mLinker; +}; + +TEST_F(LinkerTest, DoNotInterpretEscapedStringAsReference) { + ASSERT_TRUE(addResource(ResourceName{ u"android", ResourceType::kString, u"foo" }, + util::make_unique<String>(mTable->getValueStringPool().makeRef(u"?123")))); + + ASSERT_TRUE(mLinker->linkAndValidate()); + EXPECT_TRUE(mLinker->getUnresolvedReferences().empty()); +} + +TEST_F(LinkerTest, EscapeAndConvertRawString) { + std::unique_ptr<Style> style = util::make_unique<Style>(); + style->entries.push_back(Style::Entry{ + ResourceNameRef{ u"android", ResourceType::kAttr, u"integer" }, + util::make_unique<RawString>(mTable->getValueStringPool().makeRef(u" 123")) + }); + const Style* result = style.get(); + ASSERT_TRUE(addResource(ResourceName{ u"android", ResourceType::kStyle, u"foo" }, + std::move(style))); + + ASSERT_TRUE(mLinker->linkAndValidate()); + EXPECT_TRUE(mLinker->getUnresolvedReferences().empty()); + + EXPECT_NE(nullptr, dynamic_cast<BinaryPrimitive*>(result->entries.front().value.get())); +} + +TEST_F(LinkerTest, FailToConvertRawString) { + std::unique_ptr<Style> style = util::make_unique<Style>(); + style->entries.push_back(Style::Entry{ + ResourceNameRef{ u"android", ResourceType::kAttr, u"integer" }, + util::make_unique<RawString>(mTable->getValueStringPool().makeRef(u"yo what is up?")) + }); + ASSERT_TRUE(addResource(ResourceName{ u"android", ResourceType::kStyle, u"foo" }, + std::move(style))); + + ASSERT_FALSE(mLinker->linkAndValidate()); +} + +TEST_F(LinkerTest, ConvertRawStringToString) { + std::unique_ptr<Style> style = util::make_unique<Style>(); + style->entries.push_back(Style::Entry{ + ResourceNameRef{ u"android", ResourceType::kAttr, u"string" }, + util::make_unique<RawString>( + mTable->getValueStringPool().makeRef(u" \"this is \\u00fa\".")) + }); + const Style* result = style.get(); + ASSERT_TRUE(addResource(ResourceName{ u"android", ResourceType::kStyle, u"foo" }, + std::move(style))); + + ASSERT_TRUE(mLinker->linkAndValidate()); + EXPECT_TRUE(mLinker->getUnresolvedReferences().empty()); + + const String* str = dynamic_cast<const String*>(result->entries.front().value.get()); + ASSERT_NE(nullptr, str); + EXPECT_EQ(*str->value, u"this is \u00fa."); +} + +TEST_F(LinkerTest, ConvertRawStringToFlags) { + std::unique_ptr<Style> style = util::make_unique<Style>(); + style->entries.push_back(Style::Entry{ + ResourceNameRef{ u"android", ResourceType::kAttr, u"flags" }, + util::make_unique<RawString>(mTable->getValueStringPool().makeRef(u"banana | apple")) + }); + const Style* result = style.get(); + ASSERT_TRUE(addResource(ResourceName{ u"android", ResourceType::kStyle, u"foo" }, + std::move(style))); + + ASSERT_TRUE(mLinker->linkAndValidate()); + EXPECT_TRUE(mLinker->getUnresolvedReferences().empty()); + + const BinaryPrimitive* bin = dynamic_cast<const BinaryPrimitive*>( + result->entries.front().value.get()); + ASSERT_NE(nullptr, bin); + EXPECT_EQ(bin->value.data, 1u | 2u); +} + +TEST_F(LinkerTest, AllowReferenceWithOnlyResourceIdPointingToDifferentPackage) { + ASSERT_TRUE(addResource(ResourceName{ u"android", ResourceType::kInteger, u"foo" }, + util::make_unique<Reference>(ResourceId{ 0x02, 0x01, 0x01 }))); + + ASSERT_TRUE(mLinker->linkAndValidate()); + EXPECT_TRUE(mLinker->getUnresolvedReferences().empty()); +} + +} // namespace aapt diff --git a/tools/aapt2/Locale.cpp b/tools/aapt2/Locale.cpp new file mode 100644 index 0000000..eed0ea7 --- /dev/null +++ b/tools/aapt2/Locale.cpp @@ -0,0 +1,274 @@ +/* + * 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 "Locale.h" +#include "Util.h" + +#include <algorithm> +#include <ctype.h> +#include <string> +#include <vector> + +namespace aapt { + +using android::ResTable_config; + +void LocaleValue::setLanguage(const char* languageChars) { + size_t i = 0; + while ((*languageChars) != '\0') { + language[i++] = ::tolower(*languageChars); + languageChars++; + } +} + +void LocaleValue::setRegion(const char* regionChars) { + size_t i = 0; + while ((*regionChars) != '\0') { + region[i++] = ::toupper(*regionChars); + regionChars++; + } +} + +void LocaleValue::setScript(const char* scriptChars) { + size_t i = 0; + while ((*scriptChars) != '\0') { + if (i == 0) { + script[i++] = ::toupper(*scriptChars); + } else { + script[i++] = ::tolower(*scriptChars); + } + scriptChars++; + } +} + +void LocaleValue::setVariant(const char* variantChars) { + size_t i = 0; + while ((*variantChars) != '\0') { + variant[i++] = *variantChars; + variantChars++; + } +} + +static inline bool isAlpha(const std::string& str) { + return std::all_of(std::begin(str), std::end(str), ::isalpha); +} + +static inline bool isNumber(const std::string& str) { + return std::all_of(std::begin(str), std::end(str), ::isdigit); +} + +bool LocaleValue::initFromFilterString(const std::string& str) { + // A locale (as specified in the filter) is an underscore separated name such + // as "en_US", "en_Latn_US", or "en_US_POSIX". + std::vector<std::string> parts = util::splitAndLowercase(str, '_'); + + const int numTags = parts.size(); + bool valid = false; + if (numTags >= 1) { + const std::string& lang = parts[0]; + if (isAlpha(lang) && (lang.length() == 2 || lang.length() == 3)) { + setLanguage(lang.c_str()); + valid = true; + } + } + + if (!valid || numTags == 1) { + return valid; + } + + // At this point, valid == true && numTags > 1. + const std::string& part2 = parts[1]; + if ((part2.length() == 2 && isAlpha(part2)) || + (part2.length() == 3 && isNumber(part2))) { + setRegion(part2.c_str()); + } else if (part2.length() == 4 && isAlpha(part2)) { + setScript(part2.c_str()); + } else if (part2.length() >= 5 && part2.length() <= 8) { + setVariant(part2.c_str()); + } else { + valid = false; + } + + if (!valid || numTags == 2) { + return valid; + } + + // At this point, valid == true && numTags > 1. + const std::string& part3 = parts[2]; + if (((part3.length() == 2 && isAlpha(part3)) || + (part3.length() == 3 && isNumber(part3))) && script[0]) { + setRegion(part3.c_str()); + } else if (part3.length() >= 5 && part3.length() <= 8) { + setVariant(part3.c_str()); + } else { + valid = false; + } + + if (!valid || numTags == 3) { + return valid; + } + + const std::string& part4 = parts[3]; + if (part4.length() >= 5 && part4.length() <= 8) { + setVariant(part4.c_str()); + } else { + valid = false; + } + + if (!valid || numTags > 4) { + return false; + } + + return true; +} + +ssize_t LocaleValue::initFromParts(std::vector<std::string>::iterator iter, + std::vector<std::string>::iterator end) { + const std::vector<std::string>::iterator startIter = iter; + + std::string& part = *iter; + if (part[0] == 'b' && part[1] == '+') { + // This is a "modified" BCP-47 language tag. Same semantics as BCP-47 tags, + // except that the separator is "+" and not "-". + std::vector<std::string> subtags = util::splitAndLowercase(part, '+'); + subtags.erase(subtags.begin()); + if (subtags.size() == 1) { + setLanguage(subtags[0].c_str()); + } else if (subtags.size() == 2) { + setLanguage(subtags[0].c_str()); + + // The second tag can either be a region, a variant or a script. + switch (subtags[1].size()) { + case 2: + case 3: + setRegion(subtags[1].c_str()); + break; + case 4: + setScript(subtags[1].c_str()); + break; + case 5: + case 6: + case 7: + case 8: + setVariant(subtags[1].c_str()); + break; + default: + return -1; + } + } else if (subtags.size() == 3) { + // The language is always the first subtag. + setLanguage(subtags[0].c_str()); + + // The second subtag can either be a script or a region code. + // If its size is 4, it's a script code, else it's a region code. + if (subtags[1].size() == 4) { + setScript(subtags[1].c_str()); + } else if (subtags[1].size() == 2 || subtags[1].size() == 3) { + setRegion(subtags[1].c_str()); + } else { + return -1; + } + + // The third tag can either be a region code (if the second tag was + // a script), else a variant code. + if (subtags[2].size() > 4) { + setVariant(subtags[2].c_str()); + } else { + setRegion(subtags[2].c_str()); + } + } else if (subtags.size() == 4) { + setLanguage(subtags[0].c_str()); + setScript(subtags[1].c_str()); + setRegion(subtags[2].c_str()); + setVariant(subtags[3].c_str()); + } else { + return -1; + } + + ++iter; + + } else { + if ((part.length() == 2 || part.length() == 3) + && isAlpha(part) && part != "car") { + setLanguage(part.c_str()); + ++iter; + + if (iter != end) { + const std::string& regionPart = *iter; + if (regionPart.c_str()[0] == 'r' && regionPart.length() == 3) { + setRegion(regionPart.c_str() + 1); + ++iter; + } + } + } + } + + return static_cast<ssize_t>(iter - startIter); +} + + +std::string LocaleValue::toDirName() const { + std::string dirName; + if (language[0]) { + dirName += language; + } else { + return dirName; + } + + if (script[0]) { + dirName += "-s"; + dirName += script; + } + + if (region[0]) { + dirName += "-r"; + dirName += region; + } + + if (variant[0]) { + dirName += "-v"; + dirName += variant; + } + + return dirName; +} + +void LocaleValue::initFromResTable(const ResTable_config& config) { + config.unpackLanguage(language); + config.unpackRegion(region); + if (config.localeScript[0]) { + memcpy(script, config.localeScript, sizeof(config.localeScript)); + } + + if (config.localeVariant[0]) { + memcpy(variant, config.localeVariant, sizeof(config.localeVariant)); + } +} + +void LocaleValue::writeTo(ResTable_config* out) const { + out->packLanguage(language); + out->packRegion(region); + + if (script[0]) { + memcpy(out->localeScript, script, sizeof(out->localeScript)); + } + + if (variant[0]) { + memcpy(out->localeVariant, variant, sizeof(out->localeVariant)); + } +} + +} // namespace aapt diff --git a/tools/aapt2/Locale.h b/tools/aapt2/Locale.h new file mode 100644 index 0000000..ceec764 --- /dev/null +++ b/tools/aapt2/Locale.h @@ -0,0 +1,114 @@ +/* + * 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_LOCALE_VALUE_H +#define AAPT_LOCALE_VALUE_H + +#include <androidfw/ResourceTypes.h> +#include <string> +#include <vector> + +namespace aapt { + +/** + * A convenience class to build and parse locales. + */ +struct LocaleValue { + char language[4]; + char region[4]; + char script[4]; + char variant[8]; + + inline LocaleValue(); + + /** + * Initialize this LocaleValue from a config string. + */ + bool initFromFilterString(const std::string& config); + + /** + * Initialize this LocaleValue from parts of a vector. + */ + ssize_t initFromParts(std::vector<std::string>::iterator iter, + std::vector<std::string>::iterator end); + + /** + * Initialize this LocaleValue from a ResTable_config. + */ + void initFromResTable(const android::ResTable_config& config); + + /** + * Set the locale in a ResTable_config from this LocaleValue. + */ + void writeTo(android::ResTable_config* out) const; + + std::string toDirName() const; + + inline int compare(const LocaleValue& other) const; + + inline bool operator<(const LocaleValue& o) const; + inline bool operator<=(const LocaleValue& o) const; + inline bool operator==(const LocaleValue& o) const; + inline bool operator!=(const LocaleValue& o) const; + inline bool operator>=(const LocaleValue& o) const; + inline bool operator>(const LocaleValue& o) const; + +private: + void setLanguage(const char* language); + void setRegion(const char* language); + void setScript(const char* script); + void setVariant(const char* variant); +}; + +// +// Implementation +// + +LocaleValue::LocaleValue() { + memset(this, 0, sizeof(LocaleValue)); +} + +int LocaleValue::compare(const LocaleValue& other) const { + return memcmp(this, &other, sizeof(LocaleValue)); +} + +bool LocaleValue::operator<(const LocaleValue& o) const { + return compare(o) < 0; +} + +bool LocaleValue::operator<=(const LocaleValue& o) const { + return compare(o) <= 0; +} + +bool LocaleValue::operator==(const LocaleValue& o) const { + return compare(o) == 0; +} + +bool LocaleValue::operator!=(const LocaleValue& o) const { + return compare(o) != 0; +} + +bool LocaleValue::operator>=(const LocaleValue& o) const { + return compare(o) >= 0; +} + +bool LocaleValue::operator>(const LocaleValue& o) const { + return compare(o) > 0; +} + +} // namespace aapt + +#endif // AAPT_LOCALE_VALUE_H diff --git a/tools/aapt2/Locale_test.cpp b/tools/aapt2/Locale_test.cpp new file mode 100644 index 0000000..4e154d6 --- /dev/null +++ b/tools/aapt2/Locale_test.cpp @@ -0,0 +1,82 @@ +/* + * 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 "Locale.h" +#include "Util.h" + +#include <gtest/gtest.h> +#include <string> + +namespace aapt { + +static ::testing::AssertionResult TestLanguage(const char* input, const char* lang) { + std::vector<std::string> parts = util::splitAndLowercase(std::string(input), '-'); + LocaleValue lv; + ssize_t count = lv.initFromParts(std::begin(parts), std::end(parts)); + if (count < 0) { + return ::testing::AssertionFailure() << " failed to parse '" << input << "'."; + } + + if (count != 1) { + return ::testing::AssertionFailure() << count + << " parts were consumed parsing '" << input << "' but expected 1."; + } + + if (memcmp(lv.language, lang, std::min(strlen(lang), sizeof(lv.language))) != 0) { + return ::testing::AssertionFailure() << "expected " << lang << " but got " + << std::string(lv.language, sizeof(lv.language)) << "."; + } + + return ::testing::AssertionSuccess(); +} + +static ::testing::AssertionResult TestLanguageRegion(const char* input, const char* lang, + const char* region) { + std::vector<std::string> parts = util::splitAndLowercase(std::string(input), '-'); + LocaleValue lv; + ssize_t count = lv.initFromParts(std::begin(parts), std::end(parts)); + if (count < 0) { + return ::testing::AssertionFailure() << " failed to parse '" << input << "'."; + } + + if (count != 2) { + return ::testing::AssertionFailure() << count + << " parts were consumed parsing '" << input << "' but expected 2."; + } + + if (memcmp(lv.language, lang, std::min(strlen(lang), sizeof(lv.language))) != 0) { + return ::testing::AssertionFailure() << "expected " << input << " but got " + << std::string(lv.language, sizeof(lv.language)) << "."; + } + + if (memcmp(lv.region, region, std::min(strlen(region), sizeof(lv.region))) != 0) { + return ::testing::AssertionFailure() << "expected " << region << " but got " + << std::string(lv.region, sizeof(lv.region)) << "."; + } + + return ::testing::AssertionSuccess(); +} + +TEST(ConfigDescriptionTest, ParseLanguage) { + EXPECT_TRUE(TestLanguage("en", "en")); + EXPECT_TRUE(TestLanguage("fr", "fr")); + EXPECT_FALSE(TestLanguage("land", "")); + EXPECT_TRUE(TestLanguage("fr-land", "fr")); + + EXPECT_TRUE(TestLanguageRegion("fr-rCA", "fr", "CA")); +} + +} // namespace aapt diff --git a/tools/aapt2/Logger.cpp b/tools/aapt2/Logger.cpp new file mode 100644 index 0000000..3847185 --- /dev/null +++ b/tools/aapt2/Logger.cpp @@ -0,0 +1,97 @@ +/* + * 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 "Logger.h" +#include "Source.h" + +#include <memory> +#include <iostream> + +namespace aapt { + +Log::Log(std::ostream& _out, std::ostream& _err) : out(_out), err(_err) { +} + +std::shared_ptr<Log> Logger::sLog(std::make_shared<Log>(std::cerr, std::cerr)); + +void Logger::setLog(const std::shared_ptr<Log>& log) { + sLog = log; +} + +std::ostream& Logger::error() { + return sLog->err << "error: "; +} + +std::ostream& Logger::error(const Source& source) { + return sLog->err << source << ": error: "; +} + +std::ostream& Logger::error(const SourceLine& source) { + return sLog->err << source << ": error: "; +} + +std::ostream& Logger::warn() { + return sLog->err << "warning: "; +} + +std::ostream& Logger::warn(const Source& source) { + return sLog->err << source << ": warning: "; +} + +std::ostream& Logger::warn(const SourceLine& source) { + return sLog->err << source << ": warning: "; +} + +std::ostream& Logger::note() { + return sLog->out << "note: "; +} + +std::ostream& Logger::note(const Source& source) { + return sLog->err << source << ": note: "; +} + +std::ostream& Logger::note(const SourceLine& source) { + return sLog->err << source << ": note: "; +} + +SourceLogger::SourceLogger(const Source& source) +: mSource(source) { +} + +std::ostream& SourceLogger::error() { + return Logger::error(mSource); +} + +std::ostream& SourceLogger::error(size_t line) { + return Logger::error(SourceLine{ mSource.path, line }); +} + +std::ostream& SourceLogger::warn() { + return Logger::warn(mSource); +} + +std::ostream& SourceLogger::warn(size_t line) { + return Logger::warn(SourceLine{ mSource.path, line }); +} + +std::ostream& SourceLogger::note() { + return Logger::note(mSource); +} + +std::ostream& SourceLogger::note(size_t line) { + return Logger::note(SourceLine{ mSource.path, line }); +} + +} // namespace aapt diff --git a/tools/aapt2/Logger.h b/tools/aapt2/Logger.h new file mode 100644 index 0000000..1d437eb --- /dev/null +++ b/tools/aapt2/Logger.h @@ -0,0 +1,81 @@ +/* + * 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_LOGGER_H +#define AAPT_LOGGER_H + +#include "Source.h" + +#include <memory> +#include <ostream> +#include <string> +#include <utils/String8.h> + +namespace aapt { + +struct Log { + Log(std::ostream& out, std::ostream& err); + Log(const Log& rhs) = delete; + + std::ostream& out; + std::ostream& err; +}; + +class Logger { +public: + static void setLog(const std::shared_ptr<Log>& log); + + static std::ostream& error(); + static std::ostream& error(const Source& source); + static std::ostream& error(const SourceLine& sourceLine); + + static std::ostream& warn(); + static std::ostream& warn(const Source& source); + static std::ostream& warn(const SourceLine& sourceLine); + + static std::ostream& note(); + static std::ostream& note(const Source& source); + static std::ostream& note(const SourceLine& sourceLine); + +private: + static std::shared_ptr<Log> sLog; +}; + +class SourceLogger { +public: + SourceLogger(const Source& source); + + std::ostream& error(); + std::ostream& error(size_t line); + + std::ostream& warn(); + std::ostream& warn(size_t line); + + std::ostream& note(); + std::ostream& note(size_t line); + +private: + Source mSource; +}; + +inline ::std::ostream& operator<<(::std::ostream& out, const std::u16string& str) { + android::String8 utf8(str.data(), str.size()); + return out.write(utf8.string(), utf8.size()); +} + +} // namespace aapt + +#endif // AAPT_LOGGER_H diff --git a/tools/aapt2/Main.cpp b/tools/aapt2/Main.cpp new file mode 100644 index 0000000..41c229d --- /dev/null +++ b/tools/aapt2/Main.cpp @@ -0,0 +1,1277 @@ +/* + * 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 "AppInfo.h" +#include "BigBuffer.h" +#include "BinaryResourceParser.h" +#include "BindingXmlPullParser.h" +#include "Debug.h" +#include "Files.h" +#include "Flag.h" +#include "JavaClassGenerator.h" +#include "Linker.h" +#include "ManifestMerger.h" +#include "ManifestParser.h" +#include "ManifestValidator.h" +#include "NameMangler.h" +#include "Png.h" +#include "ProguardRules.h" +#include "ResourceParser.h" +#include "ResourceTable.h" +#include "ResourceTableResolver.h" +#include "ResourceValues.h" +#include "SdkConstants.h" +#include "SourceXmlPullParser.h" +#include "StringPiece.h" +#include "TableFlattener.h" +#include "Util.h" +#include "XmlFlattener.h" +#include "ZipFile.h" + +#include <algorithm> +#include <androidfw/AssetManager.h> +#include <cstdlib> +#include <dirent.h> +#include <errno.h> +#include <fstream> +#include <iostream> +#include <sstream> +#include <sys/stat.h> +#include <unordered_set> +#include <utils/Errors.h> + +constexpr const char* kAaptVersionStr = "2.0-alpha"; + +using namespace aapt; + +/** + * Used with smart pointers to free malloc'ed memory. + */ +struct DeleteMalloc { + void operator()(void* ptr) { + free(ptr); + } +}; + +struct StaticLibraryData { + Source source; + std::unique_ptr<ZipFile> apk; +}; + +/** + * Collect files from 'root', filtering out any files that do not + * match the FileFilter 'filter'. + */ +bool walkTree(const Source& root, const FileFilter& filter, + std::vector<Source>* outEntries) { + bool error = false; + + for (const std::string& dirName : listFiles(root.path)) { + std::string dir = root.path; + appendPath(&dir, dirName); + + FileType ft = getFileType(dir); + if (!filter(dirName, ft)) { + continue; + } + + if (ft != FileType::kDirectory) { + continue; + } + + for (const std::string& fileName : listFiles(dir)) { + std::string file(dir); + appendPath(&file, fileName); + + FileType ft = getFileType(file); + if (!filter(fileName, ft)) { + continue; + } + + if (ft != FileType::kRegular) { + Logger::error(Source{ file }) << "not a regular file." << std::endl; + error = true; + continue; + } + outEntries->push_back(Source{ file }); + } + } + return !error; +} + +void versionStylesForCompat(const std::shared_ptr<ResourceTable>& table) { + for (auto& type : *table) { + if (type->type != ResourceType::kStyle) { + continue; + } + + for (auto& entry : type->entries) { + // Add the versioned styles we want to create + // here. They are added to the table after + // iterating over the original set of styles. + // + // A stack is used since auto-generated styles + // from later versions should override + // auto-generated styles from earlier versions. + // Iterating over the styles is done in order, + // so we will always visit sdkVersions from smallest + // to largest. + std::stack<ResourceConfigValue> addStack; + + for (ResourceConfigValue& configValue : entry->values) { + visitFunc<Style>(*configValue.value, [&](Style& style) { + // Collect which entries we've stripped and the smallest + // SDK level which was stripped. + size_t minSdkStripped = std::numeric_limits<size_t>::max(); + std::vector<Style::Entry> stripped; + + // Iterate over the style's entries and erase/record the + // attributes whose SDK level exceeds the config's sdkVersion. + auto iter = style.entries.begin(); + while (iter != style.entries.end()) { + if (iter->key.name.package == u"android") { + size_t sdkLevel = findAttributeSdkLevel(iter->key.name); + if (sdkLevel > 1 && sdkLevel > configValue.config.sdkVersion) { + // Record that we are about to strip this. + stripped.emplace_back(std::move(*iter)); + minSdkStripped = std::min(minSdkStripped, sdkLevel); + + // Erase this from this style. + iter = style.entries.erase(iter); + continue; + } + } + ++iter; + } + + if (!stripped.empty()) { + // We have stripped attributes, so let's create a new style to hold them. + ConfigDescription versionConfig(configValue.config); + versionConfig.sdkVersion = minSdkStripped; + + ResourceConfigValue value = { + versionConfig, + configValue.source, + {}, + + // Create a copy of the original style. + std::unique_ptr<Value>(configValue.value->clone( + &table->getValueStringPool())) + }; + + Style& newStyle = static_cast<Style&>(*value.value); + + // Move the recorded stripped attributes into this new style. + std::move(stripped.begin(), stripped.end(), + std::back_inserter(newStyle.entries)); + + // We will add this style to the table later. If we do it now, we will + // mess up iteration. + addStack.push(std::move(value)); + } + }); + } + + auto comparator = + [](const ResourceConfigValue& lhs, const ConfigDescription& rhs) -> bool { + return lhs.config < rhs; + }; + + while (!addStack.empty()) { + ResourceConfigValue& value = addStack.top(); + auto iter = std::lower_bound(entry->values.begin(), entry->values.end(), + value.config, comparator); + if (iter == entry->values.end() || iter->config != value.config) { + entry->values.insert(iter, std::move(value)); + } + addStack.pop(); + } + } + } +} + +struct CompileItem { + ResourceName name; + ConfigDescription config; + Source source; + std::string extension; +}; + +struct LinkItem { + ResourceName name; + ConfigDescription config; + Source source; + std::string originalPath; + ZipFile* apk; + std::u16string originalPackage; +}; + +template <typename TChar> +static BasicStringPiece<TChar> getExtension(const BasicStringPiece<TChar>& str) { + auto iter = std::find(str.begin(), str.end(), static_cast<TChar>('.')); + if (iter == str.end()) { + return BasicStringPiece<TChar>(); + } + size_t offset = (iter - str.begin()) + 1; + return str.substr(offset, str.size() - offset); +} + +std::string buildFileReference(const ResourceNameRef& name, const ConfigDescription& config, + const StringPiece& extension) { + std::stringstream path; + path << "res/" << name.type; + if (config != ConfigDescription{}) { + path << "-" << config; + } + path << "/" << util::utf16ToUtf8(name.entry); + if (!extension.empty()) { + path << "." << extension; + } + return path.str(); +} + +std::string buildFileReference(const CompileItem& item) { + return buildFileReference(item.name, item.config, item.extension); +} + +std::string buildFileReference(const LinkItem& item) { + return buildFileReference(item.name, item.config, getExtension<char>(item.originalPath)); +} + +template <typename T> +bool addFileReference(const std::shared_ptr<ResourceTable>& table, const T& item) { + StringPool& pool = table->getValueStringPool(); + StringPool::Ref ref = pool.makeRef(util::utf8ToUtf16(buildFileReference(item)), + StringPool::Context{ 0, item.config }); + return table->addResource(item.name, item.config, item.source.line(0), + util::make_unique<FileReference>(ref)); +} + +struct AaptOptions { + enum class Phase { + Link, + Compile, + Dump, + DumpStyleGraph, + }; + + enum class PackageType { + StandardApp, + StaticLibrary, + }; + + // The phase to process. + Phase phase; + + // The type of package to produce. + PackageType packageType = PackageType::StandardApp; + + // Details about the app. + AppInfo appInfo; + + // The location of the manifest file. + Source manifest; + + // The APK files to link. + std::vector<Source> input; + + // The libraries these files may reference. + std::vector<Source> libraries; + + // Output path. This can be a directory or file + // depending on the phase. + Source output; + + // Directory in which to write binding xml files. + Source bindingOutput; + + // Directory to in which to generate R.java. + Maybe<Source> generateJavaClass; + + // File in which to produce proguard rules. + Maybe<Source> generateProguardRules; + + // Whether to output verbose details about + // compilation. + bool verbose = false; + + // Whether or not to auto-version styles or layouts + // referencing attributes defined in a newer SDK + // level than the style or layout is defined for. + bool versionStylesAndLayouts = true; + + // The target style that will have it's style hierarchy dumped + // when the phase is DumpStyleGraph. + ResourceName dumpStyleTarget; +}; + +struct IdCollector : public xml::Visitor { + IdCollector(const Source& source, const std::shared_ptr<ResourceTable>& table) : + mSource(source), mTable(table) { + } + + virtual void visit(xml::Text* node) override {} + + virtual void visit(xml::Namespace* node) override { + for (const auto& child : node->children) { + child->accept(this); + } + } + + virtual void visit(xml::Element* node) override { + for (const xml::Attribute& attr : node->attributes) { + bool create = false; + bool priv = false; + ResourceNameRef nameRef; + if (ResourceParser::tryParseReference(attr.value, &nameRef, &create, &priv)) { + if (create) { + mTable->addResource(nameRef, {}, mSource.line(node->lineNumber), + util::make_unique<Id>()); + } + } + } + + for (const auto& child : node->children) { + child->accept(this); + } + } + +private: + Source mSource; + std::shared_ptr<ResourceTable> mTable; +}; + +bool compileXml(const AaptOptions& options, const std::shared_ptr<ResourceTable>& table, + const CompileItem& item, ZipFile* outApk) { + std::ifstream in(item.source.path, std::ifstream::binary); + if (!in) { + Logger::error(item.source) << strerror(errno) << std::endl; + return false; + } + + SourceLogger logger(item.source); + std::unique_ptr<xml::Node> root = xml::inflate(&in, &logger); + if (!root) { + return false; + } + + // Collect any resource ID's declared here. + IdCollector idCollector(item.source, table); + root->accept(&idCollector); + + BigBuffer outBuffer(1024); + if (!xml::flatten(root.get(), options.appInfo.package, &outBuffer)) { + logger.error() << "failed to encode XML." << std::endl; + return false; + } + + // Write the resulting compiled XML file to the output APK. + if (outApk->add(outBuffer, buildFileReference(item).data(), ZipEntry::kCompressStored, + nullptr) != android::NO_ERROR) { + Logger::error(options.output) << "failed to write compiled '" << item.source + << "' to apk." << std::endl; + return false; + } + return true; +} + +/** + * Determines if a layout should be auto generated based on SDK level. We do not + * generate a layout if there is already a layout defined whose SDK version is greater than + * the one we want to generate. + */ +bool shouldGenerateVersionedResource(const std::shared_ptr<const ResourceTable>& table, + const ResourceName& name, const ConfigDescription& config, + int sdkVersionToGenerate) { + assert(sdkVersionToGenerate > config.sdkVersion); + const ResourceTableType* type; + const ResourceEntry* entry; + std::tie(type, entry) = table->findResource(name); + assert(type && entry); + + auto iter = std::lower_bound(entry->values.begin(), entry->values.end(), config, + [](const ResourceConfigValue& lhs, const ConfigDescription& config) -> bool { + return lhs.config < config; + }); + + assert(iter != entry->values.end()); + ++iter; + + if (iter == entry->values.end()) { + return true; + } + + ConfigDescription newConfig = config; + newConfig.sdkVersion = sdkVersionToGenerate; + return newConfig < iter->config; +} + +bool linkXml(const AaptOptions& options, const std::shared_ptr<ResourceTable>& table, + const std::shared_ptr<IResolver>& resolver, const LinkItem& item, + const void* data, size_t dataLen, ZipFile* outApk, std::queue<LinkItem>* outQueue, + proguard::KeepSet* keepSet) { + SourceLogger logger(item.source); + std::unique_ptr<xml::Node> root = xml::inflate(data, dataLen, &logger); + if (!root) { + return false; + } + + xml::FlattenOptions xmlOptions; + if (options.packageType == AaptOptions::PackageType::StaticLibrary) { + xmlOptions.keepRawValues = true; + } + + if (options.versionStylesAndLayouts) { + // We strip attributes that do not belong in this version of the resource. + // Non-version qualified resources have an implicit version 1 requirement. + xmlOptions.maxSdkAttribute = item.config.sdkVersion ? item.config.sdkVersion : 1; + } + + if (options.generateProguardRules) { + proguard::collectProguardRules(item.name.type, item.source, root.get(), keepSet); + } + + BigBuffer outBuffer(1024); + Maybe<size_t> minStrippedSdk = xml::flattenAndLink(item.source, root.get(), + item.originalPackage, resolver, + xmlOptions, &outBuffer); + if (!minStrippedSdk) { + logger.error() << "failed to encode XML." << std::endl; + return false; + } + + if (minStrippedSdk.value() > 0) { + // Something was stripped, so let's generate a new file + // with the version of the smallest SDK version stripped. + // We can only generate a versioned layout if there doesn't exist a layout + // with sdk version greater than the current one but less than the one we + // want to generate. + if (shouldGenerateVersionedResource(table, item.name, item.config, + minStrippedSdk.value())) { + LinkItem newWork = item; + newWork.config.sdkVersion = minStrippedSdk.value(); + outQueue->push(newWork); + + if (!addFileReference(table, newWork)) { + Logger::error(options.output) << "failed to add auto-versioned resource '" + << newWork.name << "'." << std::endl; + return false; + } + } + } + + if (outApk->add(outBuffer, buildFileReference(item).data(), ZipEntry::kCompressDeflated, + nullptr) != android::NO_ERROR) { + Logger::error(options.output) << "failed to write linked file '" + << buildFileReference(item) << "' to apk." << std::endl; + return false; + } + return true; +} + +bool compilePng(const AaptOptions& options, const CompileItem& item, ZipFile* outApk) { + std::ifstream in(item.source.path, std::ifstream::binary); + if (!in) { + Logger::error(item.source) << strerror(errno) << std::endl; + return false; + } + + BigBuffer outBuffer(4096); + std::string err; + Png png; + if (!png.process(item.source, in, &outBuffer, {}, &err)) { + Logger::error(item.source) << err << std::endl; + return false; + } + + if (outApk->add(outBuffer, buildFileReference(item).data(), ZipEntry::kCompressStored, + nullptr) != android::NO_ERROR) { + Logger::error(options.output) << "failed to write compiled '" << item.source + << "' to apk." << std::endl; + return false; + } + return true; +} + +bool copyFile(const AaptOptions& options, const CompileItem& item, ZipFile* outApk) { + if (outApk->add(item.source.path.data(), buildFileReference(item).data(), + ZipEntry::kCompressStored, nullptr) != android::NO_ERROR) { + Logger::error(options.output) << "failed to copy file '" << item.source << "' to apk." + << std::endl; + return false; + } + return true; +} + +bool compileManifest(const AaptOptions& options, const std::shared_ptr<IResolver>& resolver, + const std::map<std::shared_ptr<ResourceTable>, StaticLibraryData>& libApks, + const android::ResTable& table, ZipFile* outApk, proguard::KeepSet* keepSet) { + if (options.verbose) { + Logger::note(options.manifest) << "compiling AndroidManifest.xml." << std::endl; + } + + std::ifstream in(options.manifest.path, std::ifstream::binary); + if (!in) { + Logger::error(options.manifest) << strerror(errno) << std::endl; + return false; + } + + SourceLogger logger(options.manifest); + std::unique_ptr<xml::Node> root = xml::inflate(&in, &logger); + if (!root) { + return false; + } + + ManifestMerger merger({}); + if (!merger.setAppManifest(options.manifest, options.appInfo.package, std::move(root))) { + return false; + } + + for (const auto& entry : libApks) { + ZipFile* libApk = entry.second.apk.get(); + const std::u16string& libPackage = entry.first->getPackage(); + const Source& libSource = entry.second.source; + + ZipEntry* zipEntry = libApk->getEntryByName("AndroidManifest.xml"); + if (!zipEntry) { + continue; + } + + std::unique_ptr<void, DeleteMalloc> uncompressedData = std::unique_ptr<void, DeleteMalloc>( + libApk->uncompress(zipEntry)); + assert(uncompressedData); + + SourceLogger logger(libSource); + std::unique_ptr<xml::Node> libRoot = xml::inflate(uncompressedData.get(), + zipEntry->getUncompressedLen(), &logger); + if (!libRoot) { + return false; + } + + if (!merger.mergeLibraryManifest(libSource, libPackage, std::move(libRoot))) { + return false; + } + } + + if (options.generateProguardRules) { + proguard::collectProguardRulesForManifest(options.manifest, merger.getMergedXml(), + keepSet); + } + + BigBuffer outBuffer(1024); + if (!xml::flattenAndLink(options.manifest, merger.getMergedXml(), options.appInfo.package, + resolver, {}, &outBuffer)) { + return false; + } + + std::unique_ptr<uint8_t[]> data = util::copy(outBuffer); + + android::ResXMLTree tree; + if (tree.setTo(data.get(), outBuffer.size(), false) != android::NO_ERROR) { + return false; + } + + ManifestValidator validator(table); + if (!validator.validate(options.manifest, &tree)) { + return false; + } + + if (outApk->add(data.get(), outBuffer.size(), "AndroidManifest.xml", + ZipEntry::kCompressStored, nullptr) != android::NO_ERROR) { + Logger::error(options.output) << "failed to write 'AndroidManifest.xml' to apk." + << std::endl; + return false; + } + return true; +} + +static bool compileValues(const std::shared_ptr<ResourceTable>& table, const Source& source, + const ConfigDescription& config) { + std::ifstream in(source.path, std::ifstream::binary); + if (!in) { + Logger::error(source) << strerror(errno) << std::endl; + return false; + } + + std::shared_ptr<XmlPullParser> xmlParser = std::make_shared<SourceXmlPullParser>(in); + ResourceParser parser(table, source, config, xmlParser); + return parser.parse(); +} + +struct ResourcePathData { + std::u16string resourceDir; + std::u16string name; + std::string extension; + ConfigDescription config; +}; + +/** + * Resource file paths are expected to look like: + * [--/res/]type[-config]/name + */ +static Maybe<ResourcePathData> extractResourcePathData(const Source& source) { + // TODO(adamlesinski): Use Windows path separator on windows. + std::vector<std::string> parts = util::splitAndLowercase(source.path, '/'); + if (parts.size() < 2) { + Logger::error(source) << "bad resource path." << std::endl; + return {}; + } + + std::string& dir = parts[parts.size() - 2]; + StringPiece dirStr = dir; + + ConfigDescription config; + size_t dashPos = dir.find('-'); + if (dashPos != std::string::npos) { + StringPiece configStr = dirStr.substr(dashPos + 1, dir.size() - (dashPos + 1)); + if (!ConfigDescription::parse(configStr, &config)) { + Logger::error(source) + << "invalid configuration '" + << configStr + << "'." + << std::endl; + return {}; + } + dirStr = dirStr.substr(0, dashPos); + } + + std::string& filename = parts[parts.size() - 1]; + StringPiece name = filename; + StringPiece extension; + size_t dotPos = filename.find('.'); + if (dotPos != std::string::npos) { + extension = name.substr(dotPos + 1, filename.size() - (dotPos + 1)); + name = name.substr(0, dotPos); + } + + return ResourcePathData{ + util::utf8ToUtf16(dirStr), + util::utf8ToUtf16(name), + extension.toString(), + config + }; +} + +bool writeResourceTable(const AaptOptions& options, const std::shared_ptr<ResourceTable>& table, + const TableFlattener::Options& flattenerOptions, ZipFile* outApk) { + if (table->begin() != table->end()) { + BigBuffer buffer(1024); + TableFlattener flattener(flattenerOptions); + if (!flattener.flatten(&buffer, *table)) { + Logger::error() << "failed to flatten resource table." << std::endl; + return false; + } + + if (options.verbose) { + Logger::note() << "Final resource table size=" << util::formatSize(buffer.size()) + << std::endl; + } + + if (outApk->add(buffer, "resources.arsc", ZipEntry::kCompressStored, nullptr) != + android::NO_ERROR) { + Logger::note(options.output) << "failed to store resource table." << std::endl; + return false; + } + } + return true; +} + +/** + * For each FileReference in the table, adds a LinkItem to the link queue for processing. + */ +static void addApkFilesToLinkQueue(const std::u16string& package, const Source& source, + const std::shared_ptr<ResourceTable>& table, + const std::unique_ptr<ZipFile>& apk, + std::queue<LinkItem>* outLinkQueue) { + bool mangle = package != table->getPackage(); + for (auto& type : *table) { + for (auto& entry : type->entries) { + ResourceName name = { package, type->type, entry->name }; + if (mangle) { + NameMangler::mangle(table->getPackage(), &name.entry); + } + + for (auto& value : entry->values) { + visitFunc<FileReference>(*value.value, [&](FileReference& ref) { + std::string pathUtf8 = util::utf16ToUtf8(*ref.path); + Source newSource = source; + newSource.path += "/"; + newSource.path += pathUtf8; + outLinkQueue->push(LinkItem{ + name, value.config, newSource, pathUtf8, apk.get(), + table->getPackage() }); + // Now rewrite the file path. + if (mangle) { + ref.path = table->getValueStringPool().makeRef(util::utf8ToUtf16( + buildFileReference(name, value.config, + getExtension<char>(pathUtf8)))); + } + }); + } + } + } +} + +static constexpr int kOpenFlags = ZipFile::kOpenCreate | ZipFile::kOpenTruncate | + ZipFile::kOpenReadWrite; + +bool link(const AaptOptions& options, const std::shared_ptr<ResourceTable>& outTable, + const std::shared_ptr<IResolver>& resolver) { + std::map<std::shared_ptr<ResourceTable>, StaticLibraryData> apkFiles; + std::unordered_set<std::u16string> linkedPackages; + + // Populate the linkedPackages with our own. + linkedPackages.insert(options.appInfo.package); + + // Load all APK files. + for (const Source& source : options.input) { + std::unique_ptr<ZipFile> zipFile = util::make_unique<ZipFile>(); + if (zipFile->open(source.path.data(), ZipFile::kOpenReadOnly) != android::NO_ERROR) { + Logger::error(source) << "failed to open: " << strerror(errno) << std::endl; + return false; + } + + std::shared_ptr<ResourceTable> table = std::make_shared<ResourceTable>(); + + ZipEntry* entry = zipFile->getEntryByName("resources.arsc"); + if (!entry) { + Logger::error(source) << "missing 'resources.arsc'." << std::endl; + return false; + } + + std::unique_ptr<void, DeleteMalloc> uncompressedData = std::unique_ptr<void, DeleteMalloc>( + zipFile->uncompress(entry)); + assert(uncompressedData); + + BinaryResourceParser parser(table, resolver, source, uncompressedData.get(), + entry->getUncompressedLen()); + if (!parser.parse()) { + return false; + } + + // Keep track of where this table came from. + apkFiles[table] = StaticLibraryData{ source, std::move(zipFile) }; + + // Add the package to the set of linked packages. + linkedPackages.insert(table->getPackage()); + } + + std::queue<LinkItem> linkQueue; + for (auto& p : apkFiles) { + const std::shared_ptr<ResourceTable>& inTable = p.first; + + // Collect all FileReferences and add them to the queue for processing. + addApkFilesToLinkQueue(options.appInfo.package, p.second.source, inTable, p.second.apk, + &linkQueue); + + // Merge the tables. + if (!outTable->merge(std::move(*inTable))) { + return false; + } + } + + // Version all styles referencing attributes outside of their specified SDK version. + if (options.versionStylesAndLayouts) { + versionStylesForCompat(outTable); + } + + { + // Now that everything is merged, let's link it. + Linker::Options linkerOptions; + if (options.packageType == AaptOptions::PackageType::StaticLibrary) { + linkerOptions.linkResourceIds = false; + } + Linker linker(outTable, resolver, linkerOptions); + if (!linker.linkAndValidate()) { + return false; + } + + // Verify that all symbols exist. + const auto& unresolvedRefs = linker.getUnresolvedReferences(); + if (!unresolvedRefs.empty()) { + for (const auto& entry : unresolvedRefs) { + for (const auto& source : entry.second) { + Logger::error(source) << "unresolved symbol '" << entry.first << "'." + << std::endl; + } + } + return false; + } + } + + // Open the output APK file for writing. + ZipFile outApk; + if (outApk.open(options.output.path.data(), kOpenFlags) != android::NO_ERROR) { + Logger::error(options.output) << "failed to open: " << strerror(errno) << std::endl; + return false; + } + + proguard::KeepSet keepSet; + + android::ResTable binTable; + if (!compileManifest(options, resolver, apkFiles, binTable, &outApk, &keepSet)) { + return false; + } + + for (; !linkQueue.empty(); linkQueue.pop()) { + const LinkItem& item = linkQueue.front(); + + assert(!item.originalPackage.empty()); + ZipEntry* entry = item.apk->getEntryByName(item.originalPath.data()); + if (!entry) { + Logger::error(item.source) << "failed to find '" << item.originalPath << "'." + << std::endl; + return false; + } + + if (util::stringEndsWith<char>(item.originalPath, ".xml")) { + void* uncompressedData = item.apk->uncompress(entry); + assert(uncompressedData); + + if (!linkXml(options, outTable, resolver, item, uncompressedData, + entry->getUncompressedLen(), &outApk, &linkQueue, &keepSet)) { + Logger::error(options.output) << "failed to link '" << item.originalPath << "'." + << std::endl; + return false; + } + } else { + if (outApk.add(item.apk, entry, buildFileReference(item).data(), 0, nullptr) != + android::NO_ERROR) { + Logger::error(options.output) << "failed to copy '" << item.originalPath << "'." + << std::endl; + return false; + } + } + } + + // Generate the Java class file. + if (options.generateJavaClass) { + JavaClassGenerator::Options javaOptions; + if (options.packageType == AaptOptions::PackageType::StaticLibrary) { + javaOptions.useFinal = false; + } + JavaClassGenerator generator(outTable, javaOptions); + + for (const std::u16string& package : linkedPackages) { + Source outPath = options.generateJavaClass.value(); + + // Build the output directory from the package name. + // Eg. com.android.app -> com/android/app + const std::string packageUtf8 = util::utf16ToUtf8(package); + for (StringPiece part : util::tokenize<char>(packageUtf8, '.')) { + appendPath(&outPath.path, part); + } + + if (!mkdirs(outPath.path)) { + Logger::error(outPath) << strerror(errno) << std::endl; + return false; + } + + appendPath(&outPath.path, "R.java"); + + if (options.verbose) { + Logger::note(outPath) << "writing Java symbols." << std::endl; + } + + std::ofstream fout(outPath.path); + if (!fout) { + Logger::error(outPath) << strerror(errno) << std::endl; + return false; + } + + if (!generator.generate(package, fout)) { + Logger::error(outPath) << generator.getError() << "." << std::endl; + return false; + } + } + } + + // Generate the Proguard rules file. + if (options.generateProguardRules) { + const Source& outPath = options.generateProguardRules.value(); + + if (options.verbose) { + Logger::note(outPath) << "writing proguard rules." << std::endl; + } + + std::ofstream fout(outPath.path); + if (!fout) { + Logger::error(outPath) << strerror(errno) << std::endl; + return false; + } + + if (!proguard::writeKeepSet(&fout, keepSet)) { + Logger::error(outPath) << "failed to write proguard rules." << std::endl; + return false; + } + } + + outTable->getValueStringPool().prune(); + outTable->getValueStringPool().sort( + [](const StringPool::Entry& a, const StringPool::Entry& b) -> bool { + if (a.context.priority < b.context.priority) { + return true; + } + + if (a.context.priority > b.context.priority) { + return false; + } + return a.value < b.value; + }); + + + // Flatten the resource table. + TableFlattener::Options flattenerOptions; + if (options.packageType != AaptOptions::PackageType::StaticLibrary) { + flattenerOptions.useExtendedChunks = false; + } + + if (!writeResourceTable(options, outTable, flattenerOptions, &outApk)) { + return false; + } + + outApk.flush(); + return true; +} + +bool compile(const AaptOptions& options, const std::shared_ptr<ResourceTable>& table, + const std::shared_ptr<IResolver>& resolver) { + std::queue<CompileItem> compileQueue; + bool error = false; + + // Compile all the resource files passed in on the command line. + for (const Source& source : options.input) { + // Need to parse the resource type/config/filename. + Maybe<ResourcePathData> maybePathData = extractResourcePathData(source); + if (!maybePathData) { + return false; + } + + const ResourcePathData& pathData = maybePathData.value(); + if (pathData.resourceDir == u"values") { + // The file is in the values directory, which means its contents will + // go into the resource table. + if (options.verbose) { + Logger::note(source) << "compiling values." << std::endl; + } + + error |= !compileValues(table, source, pathData.config); + } else { + // The file is in a directory like 'layout' or 'drawable'. Find out + // the type. + const ResourceType* type = parseResourceType(pathData.resourceDir); + if (!type) { + Logger::error(source) << "invalid resource type '" << pathData.resourceDir << "'." + << std::endl; + return false; + } + + compileQueue.push(CompileItem{ + ResourceName{ table->getPackage(), *type, pathData.name }, + pathData.config, + source, + pathData.extension + }); + } + } + + if (error) { + return false; + } + // Open the output APK file for writing. + ZipFile outApk; + if (outApk.open(options.output.path.data(), kOpenFlags) != android::NO_ERROR) { + Logger::error(options.output) << "failed to open: " << strerror(errno) << std::endl; + return false; + } + + // Compile each file. + for (; !compileQueue.empty(); compileQueue.pop()) { + const CompileItem& item = compileQueue.front(); + + // Add the file name to the resource table. + error |= !addFileReference(table, item); + + if (item.extension == "xml") { + error |= !compileXml(options, table, item, &outApk); + } else if (item.extension == "png" || item.extension == "9.png") { + error |= !compilePng(options, item, &outApk); + } else { + error |= !copyFile(options, item, &outApk); + } + } + + if (error) { + return false; + } + + // Link and assign resource IDs. + Linker linker(table, resolver, {}); + if (!linker.linkAndValidate()) { + return false; + } + + // Flatten the resource table. + if (!writeResourceTable(options, table, {}, &outApk)) { + return false; + } + + outApk.flush(); + return true; +} + +bool loadAppInfo(const Source& source, AppInfo* outInfo) { + std::ifstream ifs(source.path, std::ifstream::in | std::ifstream::binary); + if (!ifs) { + Logger::error(source) << strerror(errno) << std::endl; + return false; + } + + ManifestParser parser; + std::shared_ptr<XmlPullParser> pullParser = std::make_shared<SourceXmlPullParser>(ifs); + return parser.parse(source, pullParser, outInfo); +} + +static void printCommandsAndDie() { + std::cerr << "The following commands are supported:" << std::endl << std::endl; + std::cerr << "compile compiles a subset of resources" << std::endl; + std::cerr << "link links together compiled resources and libraries" << std::endl; + std::cerr << "dump dumps resource contents to to standard out" << std::endl; + std::cerr << std::endl; + std::cerr << "run aapt2 with one of the commands and the -h flag for extra details." + << std::endl; + exit(1); +} + +static AaptOptions prepareArgs(int argc, char** argv) { + if (argc < 2) { + std::cerr << "no command specified." << std::endl << std::endl; + printCommandsAndDie(); + } + + const StringPiece command(argv[1]); + argc -= 2; + argv += 2; + + AaptOptions options; + + if (command == "--version" || command == "version") { + std::cout << kAaptVersionStr << std::endl; + exit(0); + } else if (command == "link") { + options.phase = AaptOptions::Phase::Link; + } else if (command == "compile") { + options.phase = AaptOptions::Phase::Compile; + } else if (command == "dump") { + options.phase = AaptOptions::Phase::Dump; + } else if (command == "dump-style-graph") { + options.phase = AaptOptions::Phase::DumpStyleGraph; + } else { + std::cerr << "invalid command '" << command << "'." << std::endl << std::endl; + printCommandsAndDie(); + } + + bool isStaticLib = false; + if (options.phase == AaptOptions::Phase::Compile || + options.phase == AaptOptions::Phase::Link) { + if (options.phase == AaptOptions::Phase::Compile) { + flag::requiredFlag("--package", "Android package name", + [&options](const StringPiece& arg) { + options.appInfo.package = util::utf8ToUtf16(arg); + }); + } else if (options.phase == AaptOptions::Phase::Link) { + flag::requiredFlag("--manifest", "AndroidManifest.xml of your app", + [&options](const StringPiece& arg) { + options.manifest = Source{ arg.toString() }; + }); + + flag::optionalFlag("-I", "add an Android APK to link against", + [&options](const StringPiece& arg) { + options.libraries.push_back(Source{ arg.toString() }); + }); + + flag::optionalFlag("--java", "directory in which to generate R.java", + [&options](const StringPiece& arg) { + options.generateJavaClass = Source{ arg.toString() }; + }); + + flag::optionalFlag("--proguard", "file in which to output proguard rules", + [&options](const StringPiece& arg) { + options.generateProguardRules = Source{ arg.toString() }; + }); + + flag::optionalSwitch("--static-lib", "generate a static Android library", true, + &isStaticLib); + + flag::optionalFlag("--binding", "Output directory for binding XML files", + [&options](const StringPiece& arg) { + options.bindingOutput = Source{ arg.toString() }; + }); + flag::optionalSwitch("--no-version", "Disables automatic style and layout versioning", + false, &options.versionStylesAndLayouts); + } + + // Common flags for all steps. + flag::requiredFlag("-o", "Output path", [&options](const StringPiece& arg) { + options.output = Source{ arg.toString() }; + }); + } else if (options.phase == AaptOptions::Phase::DumpStyleGraph) { + flag::requiredFlag("--style", "Name of the style to dump", + [&options](const StringPiece& arg, std::string* outError) -> bool { + Reference styleReference; + if (!ResourceParser::parseStyleParentReference(util::utf8ToUtf16(arg), + &styleReference, outError)) { + return false; + } + options.dumpStyleTarget = styleReference.name; + return true; + }); + } + + bool help = false; + flag::optionalSwitch("-v", "enables verbose logging", true, &options.verbose); + flag::optionalSwitch("-h", "displays this help menu", true, &help); + + // Build the command string for output (eg. "aapt2 compile"). + std::string fullCommand = "aapt2"; + fullCommand += " "; + fullCommand += command.toString(); + + // Actually read the command line flags. + flag::parse(argc, argv, fullCommand); + + if (help) { + flag::usageAndDie(fullCommand); + } + + if (isStaticLib) { + options.packageType = AaptOptions::PackageType::StaticLibrary; + } + + // Copy all the remaining arguments. + for (const std::string& arg : flag::getArgs()) { + options.input.push_back(Source{ arg }); + } + return options; +} + +static bool doDump(const AaptOptions& options) { + for (const Source& source : options.input) { + std::unique_ptr<ZipFile> zipFile = util::make_unique<ZipFile>(); + if (zipFile->open(source.path.data(), ZipFile::kOpenReadOnly) != android::NO_ERROR) { + Logger::error(source) << "failed to open: " << strerror(errno) << std::endl; + return false; + } + + std::shared_ptr<ResourceTable> table = std::make_shared<ResourceTable>(); + std::shared_ptr<ResourceTableResolver> resolver = + std::make_shared<ResourceTableResolver>( + table, std::vector<std::shared_ptr<const android::AssetManager>>()); + + ZipEntry* entry = zipFile->getEntryByName("resources.arsc"); + if (!entry) { + Logger::error(source) << "missing 'resources.arsc'." << std::endl; + return false; + } + + std::unique_ptr<void, DeleteMalloc> uncompressedData = std::unique_ptr<void, DeleteMalloc>( + zipFile->uncompress(entry)); + assert(uncompressedData); + + BinaryResourceParser parser(table, resolver, source, uncompressedData.get(), + entry->getUncompressedLen()); + if (!parser.parse()) { + return false; + } + + if (options.phase == AaptOptions::Phase::Dump) { + Debug::printTable(table); + } else if (options.phase == AaptOptions::Phase::DumpStyleGraph) { + Debug::printStyleGraph(table, options.dumpStyleTarget); + } + } + return true; +} + +int main(int argc, char** argv) { + Logger::setLog(std::make_shared<Log>(std::cerr, std::cerr)); + AaptOptions options = prepareArgs(argc, argv); + + if (options.phase == AaptOptions::Phase::Dump || + options.phase == AaptOptions::Phase::DumpStyleGraph) { + if (!doDump(options)) { + return 1; + } + return 0; + } + + // If we specified a manifest, go ahead and load the package name from the manifest. + if (!options.manifest.path.empty()) { + if (!loadAppInfo(options.manifest, &options.appInfo)) { + return false; + } + } + + // Verify we have some common options set. + if (options.appInfo.package.empty()) { + Logger::error() << "no package name specified." << std::endl; + return false; + } + + // Every phase needs a resource table. + std::shared_ptr<ResourceTable> table = std::make_shared<ResourceTable>(); + table->setPackage(options.appInfo.package); + if (options.appInfo.package == u"android") { + table->setPackageId(0x01); + } else { + table->setPackageId(0x7f); + } + + // Load the included libraries. + std::vector<std::shared_ptr<const android::AssetManager>> sources; + for (const Source& source : options.libraries) { + std::shared_ptr<android::AssetManager> assetManager = + std::make_shared<android::AssetManager>(); + int32_t cookie; + if (!assetManager->addAssetPath(android::String8(source.path.data()), &cookie)) { + Logger::error(source) << "failed to load library." << std::endl; + return false; + } + + if (cookie == 0) { + Logger::error(source) << "failed to load library." << std::endl; + return false; + } + sources.push_back(assetManager); + } + + // Make the resolver that will cache IDs for us. + std::shared_ptr<ResourceTableResolver> resolver = std::make_shared<ResourceTableResolver>( + table, sources); + + if (options.phase == AaptOptions::Phase::Compile) { + if (!compile(options, table, resolver)) { + Logger::error() << "aapt exiting with failures." << std::endl; + return 1; + } + } else if (options.phase == AaptOptions::Phase::Link) { + if (!link(options, table, resolver)) { + Logger::error() << "aapt exiting with failures." << std::endl; + return 1; + } + } + return 0; +} diff --git a/tools/aapt2/ManifestMerger.cpp b/tools/aapt2/ManifestMerger.cpp new file mode 100644 index 0000000..71d3424 --- /dev/null +++ b/tools/aapt2/ManifestMerger.cpp @@ -0,0 +1,376 @@ +#include "ManifestMerger.h" +#include "Maybe.h" +#include "ResourceParser.h" +#include "Source.h" +#include "Util.h" +#include "XmlPullParser.h" + +#include <iostream> +#include <memory> +#include <set> +#include <string> + +namespace aapt { + +constexpr const char16_t* kSchemaAndroid = u"http://schemas.android.com/apk/res/android"; + +static xml::Element* findManifest(xml::Node* root) { + if (!root) { + return nullptr; + } + + while (root->type == xml::NodeType::kNamespace) { + if (root->children.empty()) { + break; + } + root = root->children[0].get(); + } + + if (root && root->type == xml::NodeType::kElement) { + xml::Element* el = static_cast<xml::Element*>(root); + if (el->namespaceUri.empty() && el->name == u"manifest") { + return el; + } + } + return nullptr; +} + +static xml::Element* findChildWithSameName(xml::Element* parent, xml::Element* src) { + xml::Attribute* attrKey = src->findAttribute(kSchemaAndroid, u"name"); + if (!attrKey) { + return nullptr; + } + return parent->findChildWithAttribute(src->namespaceUri, src->name, attrKey); +} + +static bool attrLess(const xml::Attribute& lhs, const xml::Attribute& rhs) { + return std::tie(lhs.namespaceUri, lhs.name, lhs.value) + < std::tie(rhs.namespaceUri, rhs.name, rhs.value); +} + +static int compare(xml::Element* lhs, xml::Element* rhs) { + int diff = lhs->attributes.size() - rhs->attributes.size(); + if (diff != 0) { + return diff; + } + + std::set<xml::Attribute, decltype(&attrLess)> lhsAttrs(&attrLess); + lhsAttrs.insert(lhs->attributes.begin(), lhs->attributes.end()); + for (auto& attr : rhs->attributes) { + if (lhsAttrs.erase(attr) == 0) { + // The rhs attribute is not in the left. + return -1; + } + } + + if (!lhsAttrs.empty()) { + // The lhs has attributes not in the rhs. + return 1; + } + return 0; +} + +ManifestMerger::ManifestMerger(const Options& options) : + mOptions(options), mAppLogger({}), mLogger({}) { +} + +bool ManifestMerger::setAppManifest(const Source& source, const std::u16string& package, + std::unique_ptr<xml::Node> root) { + + mAppLogger = SourceLogger{ source }; + mRoot = std::move(root); + return true; +} + +bool ManifestMerger::checkEqual(xml::Element* elA, xml::Element* elB) { + if (compare(elA, elB) != 0) { + mLogger.error(elB->lineNumber) + << "library tag '" << elB->name << "' conflicts with app tag." + << std::endl; + mAppLogger.note(elA->lineNumber) + << "app tag '" << elA->name << "' defined here." + << std::endl; + return false; + } + + std::vector<xml::Element*> childrenA = elA->getChildElements(); + std::vector<xml::Element*> childrenB = elB->getChildElements(); + + if (childrenA.size() != childrenB.size()) { + mLogger.error(elB->lineNumber) + << "library tag '" << elB->name << "' children conflict with app tag." + << std::endl; + mAppLogger.note(elA->lineNumber) + << "app tag '" << elA->name << "' defined here." + << std::endl; + return false; + } + + auto cmp = [](xml::Element* lhs, xml::Element* rhs) -> bool { + return compare(lhs, rhs) < 0; + }; + + std::sort(childrenA.begin(), childrenA.end(), cmp); + std::sort(childrenB.begin(), childrenB.end(), cmp); + + for (size_t i = 0; i < childrenA.size(); i++) { + if (!checkEqual(childrenA[i], childrenB[i])) { + return false; + } + } + return true; +} + +bool ManifestMerger::mergeNewOrEqual(xml::Element* parentA, xml::Element* elA, xml::Element* elB) { + if (!elA) { + parentA->addChild(elB->clone()); + return true; + } + return checkEqual(elA, elB); +} + +bool ManifestMerger::mergePreferRequired(xml::Element* parentA, xml::Element* elA, + xml::Element* elB) { + if (!elA) { + parentA->addChild(elB->clone()); + return true; + } + + xml::Attribute* reqA = elA->findAttribute(kSchemaAndroid, u"required"); + xml::Attribute* reqB = elB->findAttribute(kSchemaAndroid, u"required"); + bool requiredA = !reqA || (reqA->value != u"false" && reqA->value != u"FALSE"); + bool requiredB = !reqB || (reqB->value != u"false" && reqB->value != u"FALSE"); + if (!requiredA && requiredB) { + if (reqA) { + *reqA = xml::Attribute{ kSchemaAndroid, u"required", u"true" }; + } else { + elA->attributes.push_back(xml::Attribute{ kSchemaAndroid, u"required", u"true" }); + } + } + return true; +} + +static int findIntegerValue(xml::Attribute* attr, int defaultValue) { + if (attr) { + std::unique_ptr<BinaryPrimitive> integer = ResourceParser::tryParseInt(attr->value); + if (integer) { + return integer->value.data; + } + } + return defaultValue; +} + +bool ManifestMerger::mergeUsesSdk(xml::Element* elA, xml::Element* elB) { + bool error = false; + xml::Attribute* minAttrA = nullptr; + xml::Attribute* minAttrB = nullptr; + if (elA) { + minAttrA = elA->findAttribute(kSchemaAndroid, u"minSdkVersion"); + } + + if (elB) { + minAttrB = elB->findAttribute(kSchemaAndroid, u"minSdkVersion"); + } + + int minSdkA = findIntegerValue(minAttrA, 1); + int minSdkB = findIntegerValue(minAttrB, 1); + + if (minSdkA < minSdkB) { + std::ostream* out; + if (minAttrA) { + out = &(mAppLogger.error(elA->lineNumber) << "app declares "); + } else if (elA) { + out = &(mAppLogger.error(elA->lineNumber) << "app has implied "); + } else { + out = &(mAppLogger.error() << "app has implied "); + } + + *out << "minSdkVersion=" << minSdkA << " but library expects a higher SDK version." + << std::endl; + + // elB is valid because minSdkB wouldn't be greater than minSdkA if it wasn't. + mLogger.note(elB->lineNumber) + << "library declares minSdkVersion=" << minSdkB << "." + << std::endl; + error = true; + } + + xml::Attribute* targetAttrA = nullptr; + xml::Attribute* targetAttrB = nullptr; + + if (elA) { + targetAttrA = elA->findAttribute(kSchemaAndroid, u"targetSdkVersion"); + } + + if (elB) { + targetAttrB = elB->findAttribute(kSchemaAndroid, u"targetSdkVersion"); + } + + int targetSdkA = findIntegerValue(targetAttrA, minSdkA); + int targetSdkB = findIntegerValue(targetAttrB, minSdkB); + + if (targetSdkA < targetSdkB) { + std::ostream* out; + if (targetAttrA) { + out = &(mAppLogger.warn(elA->lineNumber) << "app declares "); + } else if (elA) { + out = &(mAppLogger.warn(elA->lineNumber) << "app has implied "); + } else { + out = &(mAppLogger.warn() << "app has implied "); + } + + *out << "targetSdkVerion=" << targetSdkA << " but library expects target SDK " + << targetSdkB << "." << std::endl; + + mLogger.note(elB->lineNumber) + << "library declares targetSdkVersion=" << targetSdkB << "." + << std::endl; + error = true; + } + return !error; +} + +bool ManifestMerger::mergeApplication(xml::Element* applicationA, xml::Element* applicationB) { + if (!applicationA || !applicationB) { + return true; + } + + bool error = false; + + // First make sure that the names are identical. + xml::Attribute* nameA = applicationA->findAttribute(kSchemaAndroid, u"name"); + xml::Attribute* nameB = applicationB->findAttribute(kSchemaAndroid, u"name"); + if (nameB) { + if (!nameA) { + applicationA->attributes.push_back(*nameB); + } else if (nameA->value != nameB->value) { + mLogger.error(applicationB->lineNumber) + << "conflicting application name '" + << nameB->value + << "'." << std::endl; + mAppLogger.note(applicationA->lineNumber) + << "application defines application name '" + << nameA->value + << "'." << std::endl; + error = true; + } + } + + // Now we descend into the activity/receiver/service/provider tags + for (xml::Element* elB : applicationB->getChildElements()) { + if (!elB->namespaceUri.empty()) { + continue; + } + + if (elB->name == u"activity" || elB->name == u"activity-alias" + || elB->name == u"service" || elB->name == u"receiver" + || elB->name == u"provider" || elB->name == u"meta-data") { + xml::Element* elA = findChildWithSameName(applicationA, elB); + error |= !mergeNewOrEqual(applicationA, elA, elB); + } else if (elB->name == u"uses-library") { + xml::Element* elA = findChildWithSameName(applicationA, elB); + error |= !mergePreferRequired(applicationA, elA, elB); + } + } + return !error; +} + +bool ManifestMerger::mergeLibraryManifest(const Source& source, const std::u16string& package, + std::unique_ptr<xml::Node> libRoot) { + mLogger = SourceLogger{ source }; + xml::Element* manifestA = findManifest(mRoot.get()); + xml::Element* manifestB = findManifest(libRoot.get()); + if (!manifestA) { + mAppLogger.error() << "missing manifest tag." << std::endl; + return false; + } + + if (!manifestB) { + mLogger.error() << "library missing manifest tag." << std::endl; + return false; + } + + bool error = false; + + // Do <application> first. + xml::Element* applicationA = manifestA->findChild({}, u"application"); + xml::Element* applicationB = manifestB->findChild({}, u"application"); + error |= !mergeApplication(applicationA, applicationB); + + // Do <uses-sdk> next. + xml::Element* usesSdkA = manifestA->findChild({}, u"uses-sdk"); + xml::Element* usesSdkB = manifestB->findChild({}, u"uses-sdk"); + error |= !mergeUsesSdk(usesSdkA, usesSdkB); + + for (xml::Element* elB : manifestB->getChildElements()) { + if (!elB->namespaceUri.empty()) { + continue; + } + + if (elB->name == u"uses-permission" || elB->name == u"permission" + || elB->name == u"permission-group" || elB->name == u"permission-tree") { + xml::Element* elA = findChildWithSameName(manifestA, elB); + error |= !mergeNewOrEqual(manifestA, elA, elB); + } else if (elB->name == u"uses-feature") { + xml::Element* elA = findChildWithSameName(manifestA, elB); + error |= !mergePreferRequired(manifestA, elA, elB); + } else if (elB->name == u"uses-configuration" || elB->name == u"supports-screen" + || elB->name == u"compatible-screens" || elB->name == u"supports-gl-texture") { + xml::Element* elA = findChildWithSameName(manifestA, elB); + error |= !checkEqual(elA, elB); + } + } + return !error; +} + +static void printMerged(xml::Node* node, int depth) { + std::string indent; + for (int i = 0; i < depth; i++) { + indent += " "; + } + + switch (node->type) { + case xml::NodeType::kNamespace: + std::cerr << indent << "N: " + << "xmlns:" << static_cast<xml::Namespace*>(node)->namespacePrefix + << "=\"" << static_cast<xml::Namespace*>(node)->namespaceUri + << "\"\n"; + break; + + case xml::NodeType::kElement: + std::cerr << indent << "E: " + << static_cast<xml::Element*>(node)->namespaceUri + << ":" << static_cast<xml::Element*>(node)->name + << "\n"; + for (const auto& attr : static_cast<xml::Element*>(node)->attributes) { + std::cerr << indent << " A: " + << attr.namespaceUri + << ":" << attr.name + << "=\"" << attr.value << "\"\n"; + } + break; + + case xml::NodeType::kText: + std::cerr << indent << "T: \"" << static_cast<xml::Text*>(node)->text << "\"\n"; + break; + } + + for (auto& child : node->children) { + printMerged(child.get(), depth + 1); + } +} + +xml::Node* ManifestMerger::getMergedXml() { + return mRoot.get(); +} + +bool ManifestMerger::printMerged() { + if (!mRoot) { + return false; + } + + ::aapt::printMerged(mRoot.get(), 0); + return true; +} + +} // namespace aapt diff --git a/tools/aapt2/ManifestMerger.h b/tools/aapt2/ManifestMerger.h new file mode 100644 index 0000000..c6219db --- /dev/null +++ b/tools/aapt2/ManifestMerger.h @@ -0,0 +1,45 @@ +#ifndef AAPT_MANIFEST_MERGER_H +#define AAPT_MANIFEST_MERGER_H + +#include "Logger.h" +#include "Source.h" +#include "XmlDom.h" + +#include <memory> +#include <string> + +namespace aapt { + +class ManifestMerger { +public: + struct Options { + }; + + ManifestMerger(const Options& options); + + bool setAppManifest(const Source& source, const std::u16string& package, + std::unique_ptr<xml::Node> root); + + bool mergeLibraryManifest(const Source& source, const std::u16string& package, + std::unique_ptr<xml::Node> libRoot); + + xml::Node* getMergedXml(); + + bool printMerged(); + +private: + bool mergeNewOrEqual(xml::Element* parentA, xml::Element* elA, xml::Element* elB); + bool mergePreferRequired(xml::Element* parentA, xml::Element* elA, xml::Element* elB); + bool checkEqual(xml::Element* elA, xml::Element* elB); + bool mergeApplication(xml::Element* applicationA, xml::Element* applicationB); + bool mergeUsesSdk(xml::Element* elA, xml::Element* elB); + + Options mOptions; + std::unique_ptr<xml::Node> mRoot; + SourceLogger mAppLogger; + SourceLogger mLogger; +}; + +} // namespace aapt + +#endif // AAPT_MANIFEST_MERGER_H diff --git a/tools/aapt2/ManifestMerger_test.cpp b/tools/aapt2/ManifestMerger_test.cpp new file mode 100644 index 0000000..6838253 --- /dev/null +++ b/tools/aapt2/ManifestMerger_test.cpp @@ -0,0 +1,121 @@ +/* + * 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 "ManifestMerger.h" +#include "SourceXmlPullParser.h" + +#include <gtest/gtest.h> +#include <sstream> +#include <string> + +namespace aapt { + +constexpr const char* kAppManifest = R"EOF(<?xml version="1.0" encoding="utf-8"?> +<manifest xmlns:android="http://schemas.android.com/apk/res/android"> + <uses-sdk android:minSdkVersion="7" android:targetSdkVersion="21" /> + <uses-permission android:name="android.permission.INTERNET"/> + <uses-feature android:name="android.hardware.GPS" android:required="false" /> + <application android:name="com.android.library.Application"> + <activity android:name="com.android.example.MainActivity"> + <intent-filter> + <action android:name="android.intent.action.MAIN" /> + <category android:name="android.intent.category.DEFAULT" /> + </intent-filter> + </activity> + <service android:name="com.android.library.Service"> + <intent-filter> + <action android:name="com.android.library.intent.action.SYNC" /> + </intent-filter> + </service> + </application> +</manifest> +)EOF"; + +constexpr const char* kLibManifest = R"EOF(<?xml version="1.0" encoding="utf-8"?> +<manifest xmlns:android="http://schemas.android.com/apk/res/android"> + <uses-sdk android:minSdkVersion="4" android:targetSdkVersion="21" /> + <uses-permission android:name="android.permission.INTERNET" /> + <uses-feature android:name="android.hardware.GPS" /> + <uses-permission android:name="android.permission.GPS" /> + <application android:name="com.android.library.Application"> + <service android:name="com.android.library.Service"> + <intent-filter> + <action android:name="com.android.library.intent.action.SYNC" /> + </intent-filter> + </service> + <provider android:name="com.android.library.DocumentProvider" + android:authorities="com.android.library.documents" + android:grantUriPermission="true" + android:exported="true" + android:permission="android.permission.MANAGE_DOCUMENTS" + android:enabled="@bool/atLeastKitKat"> + <intent-filter> + <action android:name="android.content.action.DOCUMENTS_PROVIDER" /> + </intent-filter> + </provider> + </application> +</manifest> +)EOF"; + +constexpr const char* kBadLibManifest = R"EOF(<?xml version="1.0" encoding="utf-8"?> +<manifest xmlns:android="http://schemas.android.com/apk/res/android"> + <uses-sdk android:minSdkVersion="17" android:targetSdkVersion="22" /> + <uses-permission android:name="android.permission.INTERNET" /> + <uses-feature android:name="android.hardware.GPS" /> + <uses-permission android:name="android.permission.GPS" /> + <application android:name="com.android.library.Application2"> + <service android:name="com.android.library.Service"> + <intent-filter> + <action android:name="com.android.library.intent.action.SYNC_ACTION" /> + </intent-filter> + </service> + </application> +</manifest> +)EOF"; + +TEST(ManifestMergerTest, MergeManifestsSuccess) { + std::stringstream inA(kAppManifest); + std::stringstream inB(kLibManifest); + + const Source sourceA = { "AndroidManifest.xml" }; + const Source sourceB = { "lib.apk/AndroidManifest.xml" }; + SourceLogger loggerA(sourceA); + SourceLogger loggerB(sourceB); + + ManifestMerger merger({}); + EXPECT_TRUE(merger.setAppManifest(sourceA, u"com.android.example", + xml::inflate(&inA, &loggerA))); + EXPECT_TRUE(merger.mergeLibraryManifest(sourceB, u"com.android.library", + xml::inflate(&inB, &loggerB))); +} + +TEST(ManifestMergerTest, MergeManifestFail) { + std::stringstream inA(kAppManifest); + std::stringstream inB(kBadLibManifest); + + const Source sourceA = { "AndroidManifest.xml" }; + const Source sourceB = { "lib.apk/AndroidManifest.xml" }; + SourceLogger loggerA(sourceA); + SourceLogger loggerB(sourceB); + + ManifestMerger merger({}); + EXPECT_TRUE(merger.setAppManifest(sourceA, u"com.android.example", + xml::inflate(&inA, &loggerA))); + EXPECT_FALSE(merger.mergeLibraryManifest(sourceB, u"com.android.library", + xml::inflate(&inB, &loggerB))); +} + +} // namespace aapt diff --git a/tools/aapt2/ManifestParser.cpp b/tools/aapt2/ManifestParser.cpp new file mode 100644 index 0000000..b8f0a43 --- /dev/null +++ b/tools/aapt2/ManifestParser.cpp @@ -0,0 +1,84 @@ +/* + * 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 "AppInfo.h" +#include "Logger.h" +#include "ManifestParser.h" +#include "Source.h" +#include "XmlPullParser.h" + +#include <string> + +namespace aapt { + +bool ManifestParser::parse(const Source& source, std::shared_ptr<XmlPullParser> parser, + AppInfo* outInfo) { + SourceLogger logger = { source }; + + int depth = 0; + while (XmlPullParser::isGoodEvent(parser->next())) { + XmlPullParser::Event event = parser->getEvent(); + if (event == XmlPullParser::Event::kEndElement) { + depth--; + continue; + } else if (event != XmlPullParser::Event::kStartElement) { + continue; + } + + depth++; + + const std::u16string& element = parser->getElementName(); + if (depth == 1) { + if (element == u"manifest") { + if (!parseManifest(logger, parser, outInfo)) { + return false; + } + } else { + logger.error() + << "unexpected top-level element '" + << element + << "'." + << std::endl; + return false; + } + } else { + XmlPullParser::skipCurrentElement(parser.get()); + } + } + + if (parser->getEvent() == XmlPullParser::Event::kBadDocument) { + logger.error(parser->getLineNumber()) + << "failed to parse manifest: " + << parser->getLastError() + << "." + << std::endl; + return false; + } + return true; +} + +bool ManifestParser::parseManifest(SourceLogger& logger, std::shared_ptr<XmlPullParser> parser, + AppInfo* outInfo) { + auto attrIter = parser->findAttribute(u"", u"package"); + if (attrIter == parser->endAttributes() || attrIter->value.empty()) { + logger.error() << "no 'package' attribute found for element <manifest>." << std::endl; + return false; + } + outInfo->package = attrIter->value; + return true; +} + +} // namespace aapt diff --git a/tools/aapt2/ManifestParser.h b/tools/aapt2/ManifestParser.h new file mode 100644 index 0000000..f2e43d4 --- /dev/null +++ b/tools/aapt2/ManifestParser.h @@ -0,0 +1,45 @@ +/* + * 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_MANIFEST_PARSER_H +#define AAPT_MANIFEST_PARSER_H + +#include "AppInfo.h" +#include "Logger.h" +#include "Source.h" +#include "XmlPullParser.h" + +namespace aapt { + +/* + * Parses an AndroidManifest.xml file and fills in an AppInfo structure with + * app data. + */ +class ManifestParser { +public: + ManifestParser() = default; + ManifestParser(const ManifestParser&) = delete; + + bool parse(const Source& source, std::shared_ptr<XmlPullParser> parser, AppInfo* outInfo); + +private: + bool parseManifest(SourceLogger& logger, std::shared_ptr<XmlPullParser> parser, + AppInfo* outInfo); +}; + +} // namespace aapt + +#endif // AAPT_MANIFEST_PARSER_H diff --git a/tools/aapt2/ManifestParser_test.cpp b/tools/aapt2/ManifestParser_test.cpp new file mode 100644 index 0000000..be3a6fb --- /dev/null +++ b/tools/aapt2/ManifestParser_test.cpp @@ -0,0 +1,42 @@ +/* + * 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 "AppInfo.h" +#include "ManifestParser.h" +#include "SourceXmlPullParser.h" + +#include <gtest/gtest.h> +#include <sstream> +#include <string> + +namespace aapt { + +TEST(ManifestParserTest, FindPackage) { + std::stringstream input; + input << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" + "<manifest xmlns:android=\"http://schemas.android.com/apk/res/android\"\n" + "package=\"android\">\n" + "</manifest>\n"; + + ManifestParser parser; + AppInfo info; + std::shared_ptr<XmlPullParser> xmlParser = std::make_shared<SourceXmlPullParser>(input); + ASSERT_TRUE(parser.parse(Source{ "AndroidManifest.xml" }, xmlParser, &info)); + + EXPECT_EQ(std::u16string(u"android"), info.package); +} + +} // namespace aapt diff --git a/tools/aapt2/ManifestValidator.cpp b/tools/aapt2/ManifestValidator.cpp new file mode 100644 index 0000000..123b9fa --- /dev/null +++ b/tools/aapt2/ManifestValidator.cpp @@ -0,0 +1,217 @@ +/* + * 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 "Logger.h" +#include "ManifestValidator.h" +#include "Maybe.h" +#include "Source.h" +#include "Util.h" + +#include <androidfw/ResourceTypes.h> + +namespace aapt { + +ManifestValidator::ManifestValidator(const android::ResTable& table) +: mTable(table) { +} + +bool ManifestValidator::validate(const Source& source, android::ResXMLParser* parser) { + SourceLogger logger(source); + + android::ResXMLParser::event_code_t code; + while ((code = parser->next()) != android::ResXMLParser::END_DOCUMENT && + code != android::ResXMLParser::BAD_DOCUMENT) { + if (code != android::ResXMLParser::START_TAG) { + continue; + } + + size_t len = 0; + const StringPiece16 namespaceUri(parser->getElementNamespace(&len), len); + if (!namespaceUri.empty()) { + continue; + } + + const StringPiece16 name(parser->getElementName(&len), len); + if (name.empty()) { + logger.error(parser->getLineNumber()) + << "failed to get the element name." + << std::endl; + return false; + } + + if (name == u"manifest") { + if (!validateManifest(source, parser)) { + return false; + } + } + } + return true; +} + +Maybe<StringPiece16> ManifestValidator::getAttributeValue(android::ResXMLParser* parser, + size_t idx) { + android::Res_value value; + if (parser->getAttributeValue(idx, &value) < 0) { + return StringPiece16(); + } + + const android::ResStringPool* pool = &parser->getStrings(); + if (value.dataType == android::Res_value::TYPE_REFERENCE) { + ssize_t strIdx = mTable.resolveReference(&value, 0x10000000u); + if (strIdx < 0) { + return {}; + } + pool = mTable.getTableStringBlock(strIdx); + } + + if (value.dataType != android::Res_value::TYPE_STRING || !pool) { + return {}; + } + return util::getString(*pool, value.data); +} + +Maybe<StringPiece16> ManifestValidator::getAttributeInlineValue(android::ResXMLParser* parser, + size_t idx) { + android::Res_value value; + if (parser->getAttributeValue(idx, &value) < 0) { + return StringPiece16(); + } + + if (value.dataType != android::Res_value::TYPE_STRING) { + return {}; + } + return util::getString(parser->getStrings(), value.data); +} + +bool ManifestValidator::validateInlineAttribute(android::ResXMLParser* parser, size_t idx, + SourceLogger& logger, + const StringPiece16& charSet) { + size_t len = 0; + StringPiece16 element(parser->getElementName(&len), len); + StringPiece16 attributeName(parser->getAttributeName(idx, &len), len); + Maybe<StringPiece16> result = getAttributeInlineValue(parser, idx); + if (!result) { + logger.error(parser->getLineNumber()) + << "<" + << element + << "> must have a '" + << attributeName + << "' attribute with a string literal value." + << std::endl; + return false; + } + return validateAttributeImpl(element, attributeName, result.value(), charSet, + parser->getLineNumber(), logger); +} + +bool ManifestValidator::validateAttribute(android::ResXMLParser* parser, size_t idx, + SourceLogger& logger, const StringPiece16& charSet) { + size_t len = 0; + StringPiece16 element(parser->getElementName(&len), len); + StringPiece16 attributeName(parser->getAttributeName(idx, &len), len); + Maybe<StringPiece16> result = getAttributeValue(parser, idx); + if (!result) { + logger.error(parser->getLineNumber()) + << "<" + << element + << "> must have a '" + << attributeName + << "' attribute that points to a string." + << std::endl; + return false; + } + return validateAttributeImpl(element, attributeName, result.value(), charSet, + parser->getLineNumber(), logger); +} + +bool ManifestValidator::validateAttributeImpl(const StringPiece16& element, + const StringPiece16& attributeName, + const StringPiece16& attributeValue, + const StringPiece16& charSet, size_t lineNumber, + SourceLogger& logger) { + StringPiece16::const_iterator badIter = + util::findNonAlphaNumericAndNotInSet(attributeValue, charSet); + if (badIter != attributeValue.end()) { + logger.error(lineNumber) + << "tag <" + << element + << "> attribute '" + << attributeName + << "' has invalid character '" + << StringPiece16(badIter, 1) + << "'." + << std::endl; + return false; + } + + if (!attributeValue.empty()) { + StringPiece16 trimmed = util::trimWhitespace(attributeValue); + if (attributeValue.begin() != trimmed.begin()) { + logger.error(lineNumber) + << "tag <" + << element + << "> attribute '" + << attributeName + << "' can not start with whitespace." + << std::endl; + return false; + } + + if (attributeValue.end() != trimmed.end()) { + logger.error(lineNumber) + << "tag <" + << element + << "> attribute '" + << attributeName + << "' can not end with whitespace." + << std::endl; + return false; + } + } + return true; +} + +constexpr const char16_t* kPackageIdentSet = u"._"; + +bool ManifestValidator::validateManifest(const Source& source, android::ResXMLParser* parser) { + bool error = false; + SourceLogger logger(source); + + const StringPiece16 kAndroid = u"android"; + const StringPiece16 kPackage = u"package"; + const StringPiece16 kSharedUserId = u"sharedUserId"; + + ssize_t idx; + + idx = parser->indexOfAttribute(nullptr, 0, kPackage.data(), kPackage.size()); + if (idx < 0) { + logger.error(parser->getLineNumber()) + << "missing package attribute." + << std::endl; + error = true; + } else { + error |= !validateInlineAttribute(parser, idx, logger, kPackageIdentSet); + } + + idx = parser->indexOfAttribute(kAndroid.data(), kAndroid.size(), + kSharedUserId.data(), kSharedUserId.size()); + if (idx >= 0) { + error |= !validateInlineAttribute(parser, idx, logger, kPackageIdentSet); + } + return !error; +} + +} // namespace aapt diff --git a/tools/aapt2/ManifestValidator.h b/tools/aapt2/ManifestValidator.h new file mode 100644 index 0000000..3188784 --- /dev/null +++ b/tools/aapt2/ManifestValidator.h @@ -0,0 +1,55 @@ +/* + * 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_MANIFEST_VALIDATOR_H +#define AAPT_MANIFEST_VALIDATOR_H + +#include "Logger.h" +#include "Maybe.h" +#include "Source.h" +#include "StringPiece.h" + +#include <androidfw/ResourceTypes.h> + +namespace aapt { + +class ManifestValidator { +public: + ManifestValidator(const android::ResTable& table); + ManifestValidator(const ManifestValidator&) = delete; + + bool validate(const Source& source, android::ResXMLParser* parser); + +private: + bool validateManifest(const Source& source, android::ResXMLParser* parser); + + Maybe<StringPiece16> getAttributeInlineValue(android::ResXMLParser* parser, size_t idx); + Maybe<StringPiece16> getAttributeValue(android::ResXMLParser* parser, size_t idx); + + bool validateInlineAttribute(android::ResXMLParser* parser, size_t idx, + SourceLogger& logger, const StringPiece16& charSet); + bool validateAttribute(android::ResXMLParser* parser, size_t idx, SourceLogger& logger, + const StringPiece16& charSet); + bool validateAttributeImpl(const StringPiece16& element, const StringPiece16& attributeName, + const StringPiece16& attributeValue, const StringPiece16& charSet, + size_t lineNumber, SourceLogger& logger); + + const android::ResTable& mTable; +}; + +} // namespace aapt + +#endif // AAPT_MANIFEST_VALIDATOR_H diff --git a/tools/aapt2/Maybe.h b/tools/aapt2/Maybe.h new file mode 100644 index 0000000..ff6625f --- /dev/null +++ b/tools/aapt2/Maybe.h @@ -0,0 +1,280 @@ +/* + * 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_MAYBE_H +#define AAPT_MAYBE_H + +#include <cassert> +#include <type_traits> +#include <utility> + +namespace aapt { + +/** + * Either holds a valid value of type T, or holds Nothing. + * The value is stored inline in this structure, so no + * heap memory is used when creating a Maybe<T> object. + */ +template <typename T> +class Maybe { +public: + /** + * Construct Nothing. + */ + Maybe(); + + ~Maybe(); + + Maybe(const Maybe& rhs); + + template <typename U> + Maybe(const Maybe<U>& rhs); + + Maybe(Maybe&& rhs); + + template <typename U> + Maybe(Maybe<U>&& rhs); + + Maybe& operator=(const Maybe& rhs); + + template <typename U> + Maybe& operator=(const Maybe<U>& rhs); + + Maybe& operator=(Maybe&& rhs); + + template <typename U> + Maybe& operator=(Maybe<U>&& rhs); + + /** + * Construct a Maybe holding a value. + */ + Maybe(const T& value); + + /** + * Construct a Maybe holding a value. + */ + Maybe(T&& value); + + /** + * True if this holds a value, false if + * it holds Nothing. + */ + operator bool() const; + + /** + * Gets the value if one exists, or else + * panics. + */ + T& value(); + + /** + * Gets the value if one exists, or else + * panics. + */ + const T& value() const; + +private: + template <typename U> + friend class Maybe; + + template <typename U> + Maybe& copy(const Maybe<U>& rhs); + + template <typename U> + Maybe& move(Maybe<U>&& rhs); + + void destroy(); + + bool mNothing; + + typename std::aligned_storage<sizeof(T), alignof(T)>::type mStorage; +}; + +template <typename T> +Maybe<T>::Maybe() +: mNothing(true) { +} + +template <typename T> +Maybe<T>::~Maybe() { + if (!mNothing) { + destroy(); + } +} + +template <typename T> +Maybe<T>::Maybe(const Maybe& rhs) +: mNothing(rhs.mNothing) { + if (!rhs.mNothing) { + new (&mStorage) T(reinterpret_cast<const T&>(rhs.mStorage)); + } +} + +template <typename T> +template <typename U> +Maybe<T>::Maybe(const Maybe<U>& rhs) +: mNothing(rhs.mNothing) { + if (!rhs.mNothing) { + new (&mStorage) T(reinterpret_cast<const U&>(rhs.mStorage)); + } +} + +template <typename T> +Maybe<T>::Maybe(Maybe&& rhs) +: mNothing(rhs.mNothing) { + if (!rhs.mNothing) { + rhs.mNothing = true; + + // Move the value from rhs. + new (&mStorage) T(std::move(reinterpret_cast<T&>(rhs.mStorage))); + rhs.destroy(); + } +} + +template <typename T> +template <typename U> +Maybe<T>::Maybe(Maybe<U>&& rhs) +: mNothing(rhs.mNothing) { + if (!rhs.mNothing) { + rhs.mNothing = true; + + // Move the value from rhs. + new (&mStorage) T(std::move(reinterpret_cast<U&>(rhs.mStorage))); + rhs.destroy(); + } +} + +template <typename T> +inline Maybe<T>& Maybe<T>::operator=(const Maybe& rhs) { + // Delegate to the actual assignment. + return copy(rhs); +} + +template <typename T> +template <typename U> +inline Maybe<T>& Maybe<T>::operator=(const Maybe<U>& rhs) { + return copy(rhs); +} + +template <typename T> +template <typename U> +Maybe<T>& Maybe<T>::copy(const Maybe<U>& rhs) { + if (mNothing && rhs.mNothing) { + // Both are nothing, nothing to do. + return *this; + } else if (!mNothing && !rhs.mNothing) { + // We both are something, so assign rhs to us. + reinterpret_cast<T&>(mStorage) = reinterpret_cast<const U&>(rhs.mStorage); + } else if (mNothing) { + // We are nothing but rhs is something. + mNothing = rhs.mNothing; + + // Copy the value from rhs. + new (&mStorage) T(reinterpret_cast<const U&>(rhs.mStorage)); + } else { + // We are something but rhs is nothing, so destroy our value. + mNothing = rhs.mNothing; + destroy(); + } + return *this; +} + +template <typename T> +inline Maybe<T>& Maybe<T>::operator=(Maybe&& rhs) { + // Delegate to the actual assignment. + return move(std::forward<Maybe<T>>(rhs)); +} + +template <typename T> +template <typename U> +inline Maybe<T>& Maybe<T>::operator=(Maybe<U>&& rhs) { + return move(std::forward<Maybe<U>>(rhs)); +} + +template <typename T> +template <typename U> +Maybe<T>& Maybe<T>::move(Maybe<U>&& rhs) { + if (mNothing && rhs.mNothing) { + // Both are nothing, nothing to do. + return *this; + } else if (!mNothing && !rhs.mNothing) { + // We both are something, so move assign rhs to us. + rhs.mNothing = true; + reinterpret_cast<T&>(mStorage) = std::move(reinterpret_cast<U&>(rhs.mStorage)); + rhs.destroy(); + } else if (mNothing) { + // We are nothing but rhs is something. + mNothing = false; + rhs.mNothing = true; + + // Move the value from rhs. + new (&mStorage) T(std::move(reinterpret_cast<U&>(rhs.mStorage))); + rhs.destroy(); + } else { + // We are something but rhs is nothing, so destroy our value. + mNothing = true; + destroy(); + } + return *this; +} + +template <typename T> +Maybe<T>::Maybe(const T& value) +: mNothing(false) { + new (&mStorage) T(value); +} + +template <typename T> +Maybe<T>::Maybe(T&& value) +: mNothing(false) { + new (&mStorage) T(std::forward<T>(value)); +} + +template <typename T> +Maybe<T>::operator bool() const { + return !mNothing; +} + +template <typename T> +T& Maybe<T>::value() { + assert(!mNothing && "Maybe<T>::value() called on Nothing"); + return reinterpret_cast<T&>(mStorage); +} + +template <typename T> +const T& Maybe<T>::value() const { + assert(!mNothing && "Maybe<T>::value() called on Nothing"); + return reinterpret_cast<const T&>(mStorage); +} + +template <typename T> +void Maybe<T>::destroy() { + reinterpret_cast<T&>(mStorage).~T(); +} + +template <typename T> +inline Maybe<typename std::remove_reference<T>::type> make_value(T&& value) { + return Maybe<typename std::remove_reference<T>::type>(std::forward<T>(value)); +} + +template <typename T> +inline Maybe<T> make_nothing() { + return Maybe<T>(); +} + +} // namespace aapt + +#endif // AAPT_MAYBE_H diff --git a/tools/aapt2/Maybe_test.cpp b/tools/aapt2/Maybe_test.cpp new file mode 100644 index 0000000..71bbb94 --- /dev/null +++ b/tools/aapt2/Maybe_test.cpp @@ -0,0 +1,121 @@ +/* + * 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 <gtest/gtest.h> +#include <string> + +#include "Maybe.h" + +namespace aapt { + +struct Dummy { + Dummy() { + data = new int; + *data = 1; + std::cerr << "Construct Dummy{0x" << (void *) this + << "} with data=0x" << (void*) data + << std::endl; + } + + Dummy(const Dummy& rhs) { + data = nullptr; + if (rhs.data) { + data = new int; + *data = *rhs.data; + } + std::cerr << "CopyConstruct Dummy{0x" << (void *) this + << "} from Dummy{0x" << (const void*) &rhs + << "}" << std::endl; + } + + Dummy(Dummy&& rhs) { + data = rhs.data; + rhs.data = nullptr; + std::cerr << "MoveConstruct Dummy{0x" << (void *) this + << "} from Dummy{0x" << (const void*) &rhs + << "}" << std::endl; + } + + Dummy& operator=(const Dummy& rhs) { + delete data; + data = nullptr; + + if (rhs.data) { + data = new int; + *data = *rhs.data; + } + std::cerr << "CopyAssign Dummy{0x" << (void *) this + << "} from Dummy{0x" << (const void*) &rhs + << "}" << std::endl; + return *this; + } + + Dummy& operator=(Dummy&& rhs) { + delete data; + data = rhs.data; + rhs.data = nullptr; + std::cerr << "MoveAssign Dummy{0x" << (void *) this + << "} from Dummy{0x" << (const void*) &rhs + << "}" << std::endl; + return *this; + } + + ~Dummy() { + std::cerr << "Destruct Dummy{0x" << (void *) this + << "} with data=0x" << (void*) data + << std::endl; + delete data; + } + + int* data; +}; + +TEST(MaybeTest, MakeNothing) { + Maybe<int> val = make_nothing<int>(); + EXPECT_FALSE(val); + + Maybe<std::string> val2 = make_nothing<std::string>(); + EXPECT_FALSE(val2); + + val2 = make_nothing<std::string>(); + EXPECT_FALSE(val2); +} + +TEST(MaybeTest, MakeSomething) { + Maybe<int> val = make_value(23); + ASSERT_TRUE(val); + EXPECT_EQ(23, val.value()); + + Maybe<std::string> val2 = make_value(std::string("hey")); + ASSERT_TRUE(val2); + EXPECT_EQ(std::string("hey"), val2.value()); +} + +TEST(MaybeTest, Lifecycle) { + Maybe<Dummy> val = make_nothing<Dummy>(); + + Maybe<Dummy> val2 = make_value(Dummy()); +} + +TEST(MaybeTest, MoveAssign) { + Maybe<Dummy> val; + { + Maybe<Dummy> val2 = Dummy(); + val = std::move(val2); + } +} + +} // namespace aapt diff --git a/tools/aapt2/MockResolver.h b/tools/aapt2/MockResolver.h new file mode 100644 index 0000000..0c9b954 --- /dev/null +++ b/tools/aapt2/MockResolver.h @@ -0,0 +1,93 @@ +/* + * 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_MOCK_RESOLVER_H +#define AAPT_MOCK_RESOLVER_H + +#include "Maybe.h" +#include "Resolver.h" +#include "Resource.h" +#include "ResourceTable.h" +#include "ResourceTableResolver.h" +#include "ResourceValues.h" +#include "StringPiece.h" + +#include <map> +#include <string> + +namespace aapt { + +struct MockResolver : public IResolver { + MockResolver(const std::shared_ptr<ResourceTable>& table, + const std::map<ResourceName, ResourceId>& items) : + mResolver(std::make_shared<ResourceTableResolver>( + table, std::vector<std::shared_ptr<const android::AssetManager>>())), + mAttr(false, android::ResTable_map::TYPE_ANY), mItems(items) { + } + + virtual Maybe<ResourceId> findId(const ResourceName& name) override { + Maybe<ResourceId> result = mResolver->findId(name); + if (result) { + return result; + } + + const auto iter = mItems.find(name); + if (iter != mItems.end()) { + return iter->second; + } + return {}; + } + + virtual Maybe<Entry> findAttribute(const ResourceName& name) override { + Maybe<Entry> tableResult = mResolver->findAttribute(name); + if (tableResult) { + return tableResult; + } + + Maybe<ResourceId> result = findId(name); + if (result) { + if (name.type == ResourceType::kAttr) { + return Entry{ result.value(), &mAttr }; + } else { + return Entry{ result.value() }; + } + } + return {}; + } + + virtual Maybe<ResourceName> findName(ResourceId resId) override { + Maybe<ResourceName> result = mResolver->findName(resId); + if (result) { + return result; + } + + for (auto& p : mItems) { + if (p.second == resId) { + return p.first; + } + } + return {}; + } + +private: + std::shared_ptr<ResourceTableResolver> mResolver; + Attribute mAttr; + std::map<ResourceName, ResourceId> mItems; +}; + +} // namespace aapt + +#endif // AAPT_MOCK_RESOLVER_H diff --git a/tools/aapt2/NameMangler.h b/tools/aapt2/NameMangler.h new file mode 100644 index 0000000..1e15e20 --- /dev/null +++ b/tools/aapt2/NameMangler.h @@ -0,0 +1,54 @@ +/* + * 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_NAME_MANGLER_H +#define AAPT_NAME_MANGLER_H + +#include <string> + +namespace aapt { + +struct NameMangler { + /** + * Mangles the name in `outName` with the `package` and stores the mangled + * result in `outName`. The mangled name should contain symbols that are + * illegal to define in XML, so that there will never be name mangling + * collisions. + */ + static void mangle(const std::u16string& package, std::u16string* outName) { + *outName = package + u"$" + *outName; + } + + /** + * Unmangles the name in `outName`, storing the correct name back in `outName` + * and the package in `outPackage`. Returns true if the name was unmangled or + * false if the name was never mangled to begin with. + */ + static bool unmangle(std::u16string* outName, std::u16string* outPackage) { + size_t pivot = outName->find(u'$'); + if (pivot == std::string::npos) { + return false; + } + + outPackage->assign(outName->data(), pivot); + outName->assign(outName->data() + pivot + 1, outName->size() - (pivot + 1)); + return true; + } +}; + +} // namespace aapt + +#endif // AAPT_NAME_MANGLER_H diff --git a/tools/aapt2/NameMangler_test.cpp b/tools/aapt2/NameMangler_test.cpp new file mode 100644 index 0000000..6103655 --- /dev/null +++ b/tools/aapt2/NameMangler_test.cpp @@ -0,0 +1,45 @@ +/* + * 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 "NameMangler.h" + +#include <gtest/gtest.h> +#include <string> + +namespace aapt { + +TEST(NameManglerTest, MangleName) { + std::u16string package = u"android.appcompat"; + std::u16string name = u"Platform.AppCompat"; + + NameMangler::mangle(package, &name); + EXPECT_EQ(name, u"android.appcompat$Platform.AppCompat"); + + std::u16string newPackage; + ASSERT_TRUE(NameMangler::unmangle(&name, &newPackage)); + EXPECT_EQ(name, u"Platform.AppCompat"); + EXPECT_EQ(newPackage, u"android.appcompat"); +} + +TEST(NameManglerTest, IgnoreUnmangledName) { + std::u16string package; + std::u16string name = u"foo_bar"; + + EXPECT_FALSE(NameMangler::unmangle(&name, &package)); + EXPECT_EQ(name, u"foo_bar"); +} + +} // namespace aapt diff --git a/tools/aapt2/Png.cpp b/tools/aapt2/Png.cpp new file mode 100644 index 0000000..4e9b68e --- /dev/null +++ b/tools/aapt2/Png.cpp @@ -0,0 +1,1280 @@ +/* + * 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 "BigBuffer.h" +#include "Logger.h" +#include "Png.h" +#include "Source.h" +#include "Util.h" + +#include <androidfw/ResourceTypes.h> +#include <iostream> +#include <png.h> +#include <sstream> +#include <string> +#include <vector> +#include <zlib.h> + +namespace aapt { + +constexpr bool kDebug = false; +constexpr size_t kPngSignatureSize = 8u; + +struct PngInfo { + ~PngInfo() { + for (png_bytep row : rows) { + if (row != nullptr) { + delete[] row; + } + } + + delete[] xDivs; + delete[] yDivs; + } + + void* serialize9Patch() { + void* serialized = android::Res_png_9patch::serialize(info9Patch, xDivs, yDivs, + colors.data()); + reinterpret_cast<android::Res_png_9patch*>(serialized)->deviceToFile(); + return serialized; + } + + uint32_t width = 0; + uint32_t height = 0; + std::vector<png_bytep> rows; + + bool is9Patch = false; + android::Res_png_9patch info9Patch; + int32_t* xDivs = nullptr; + int32_t* yDivs = nullptr; + std::vector<uint32_t> colors; + + // Layout padding. + bool haveLayoutBounds = false; + int32_t layoutBoundsLeft; + int32_t layoutBoundsTop; + int32_t layoutBoundsRight; + int32_t layoutBoundsBottom; + + // Round rect outline description. + int32_t outlineInsetsLeft; + int32_t outlineInsetsTop; + int32_t outlineInsetsRight; + int32_t outlineInsetsBottom; + float outlineRadius; + uint8_t outlineAlpha; +}; + +static void readDataFromStream(png_structp readPtr, png_bytep data, png_size_t length) { + std::istream* input = reinterpret_cast<std::istream*>(png_get_io_ptr(readPtr)); + if (!input->read(reinterpret_cast<char*>(data), length)) { + png_error(readPtr, strerror(errno)); + } +} + +static void writeDataToStream(png_structp writePtr, png_bytep data, png_size_t length) { + BigBuffer* outBuffer = reinterpret_cast<BigBuffer*>(png_get_io_ptr(writePtr)); + png_bytep buf = outBuffer->nextBlock<png_byte>(length); + memcpy(buf, data, length); +} + +static void flushDataToStream(png_structp /*writePtr*/) { +} + +static void logWarning(png_structp readPtr, png_const_charp warningMessage) { + SourceLogger* logger = reinterpret_cast<SourceLogger*>(png_get_error_ptr(readPtr)); + logger->warn() << warningMessage << "." << std::endl; +} + + +static bool readPng(png_structp readPtr, png_infop infoPtr, PngInfo* outInfo, + std::string* outError) { + if (setjmp(png_jmpbuf(readPtr))) { + *outError = "failed reading png"; + return false; + } + + png_set_sig_bytes(readPtr, kPngSignatureSize); + png_read_info(readPtr, infoPtr); + + int colorType, bitDepth, interlaceType, compressionType; + png_get_IHDR(readPtr, infoPtr, &outInfo->width, &outInfo->height, &bitDepth, &colorType, + &interlaceType, &compressionType, nullptr); + + if (colorType == PNG_COLOR_TYPE_PALETTE) { + png_set_palette_to_rgb(readPtr); + } + + if (colorType == PNG_COLOR_TYPE_GRAY && bitDepth < 8) { + png_set_expand_gray_1_2_4_to_8(readPtr); + } + + if (png_get_valid(readPtr, infoPtr, PNG_INFO_tRNS)) { + png_set_tRNS_to_alpha(readPtr); + } + + if (bitDepth == 16) { + png_set_strip_16(readPtr); + } + + if (!(colorType & PNG_COLOR_MASK_ALPHA)) { + png_set_add_alpha(readPtr, 0xFF, PNG_FILLER_AFTER); + } + + if (colorType == PNG_COLOR_TYPE_GRAY || colorType == PNG_COLOR_TYPE_GRAY_ALPHA) { + png_set_gray_to_rgb(readPtr); + } + + png_set_interlace_handling(readPtr); + png_read_update_info(readPtr, infoPtr); + + const uint32_t rowBytes = png_get_rowbytes(readPtr, infoPtr); + outInfo->rows.resize(outInfo->height); + for (size_t i = 0; i < outInfo->height; i++) { + outInfo->rows[i] = new png_byte[rowBytes]; + } + + png_read_image(readPtr, outInfo->rows.data()); + png_read_end(readPtr, infoPtr); + return true; +} + +static void checkNinePatchSerialization(android::Res_png_9patch* inPatch, void* data) { + size_t patchSize = inPatch->serializedSize(); + void* newData = malloc(patchSize); + memcpy(newData, data, patchSize); + android::Res_png_9patch* outPatch = inPatch->deserialize(newData); + outPatch->fileToDevice(); + // deserialization is done in place, so outPatch == newData + assert(outPatch == newData); + assert(outPatch->numXDivs == inPatch->numXDivs); + assert(outPatch->numYDivs == inPatch->numYDivs); + assert(outPatch->paddingLeft == inPatch->paddingLeft); + assert(outPatch->paddingRight == inPatch->paddingRight); + assert(outPatch->paddingTop == inPatch->paddingTop); + assert(outPatch->paddingBottom == inPatch->paddingBottom); +/* for (int i = 0; i < outPatch->numXDivs; i++) { + assert(outPatch->getXDivs()[i] == inPatch->getXDivs()[i]); + } + for (int i = 0; i < outPatch->numYDivs; i++) { + assert(outPatch->getYDivs()[i] == inPatch->getYDivs()[i]); + } + for (int i = 0; i < outPatch->numColors; i++) { + assert(outPatch->getColors()[i] == inPatch->getColors()[i]); + }*/ + free(newData); +} + +/*static void dump_image(int w, int h, const png_byte* const* rows, int color_type) { + int i, j, rr, gg, bb, aa; + + int bpp; + if (color_type == PNG_COLOR_TYPE_PALETTE || color_type == PNG_COLOR_TYPE_GRAY) { + bpp = 1; + } else if (color_type == PNG_COLOR_TYPE_GRAY_ALPHA) { + bpp = 2; + } else if (color_type == PNG_COLOR_TYPE_RGB || color_type == PNG_COLOR_TYPE_RGB_ALPHA) { + // We use a padding byte even when there is no alpha + bpp = 4; + } else { + printf("Unknown color type %d.\n", color_type); + } + + for (j = 0; j < h; j++) { + const png_byte* row = rows[j]; + for (i = 0; i < w; i++) { + rr = row[0]; + gg = row[1]; + bb = row[2]; + aa = row[3]; + row += bpp; + + if (i == 0) { + printf("Row %d:", j); + } + switch (bpp) { + case 1: + printf(" (%d)", rr); + break; + case 2: + printf(" (%d %d", rr, gg); + break; + case 3: + printf(" (%d %d %d)", rr, gg, bb); + break; + case 4: + printf(" (%d %d %d %d)", rr, gg, bb, aa); + break; + } + if (i == (w - 1)) { + printf("\n"); + } + } + } +}*/ + +#define MAX(a,b) ((a)>(b)?(a):(b)) +#define ABS(a) ((a)<0?-(a):(a)) + +static void analyze_image(SourceLogger* logger, const PngInfo& imageInfo, int grayscaleTolerance, + png_colorp rgbPalette, png_bytep alphaPalette, + int *paletteEntries, bool *hasTransparency, int *colorType, + png_bytepp outRows) { + int w = imageInfo.width; + int h = imageInfo.height; + int i, j, rr, gg, bb, aa, idx; + uint32_t colors[256], col; + int num_colors = 0; + int maxGrayDeviation = 0; + + bool isOpaque = true; + bool isPalette = true; + bool isGrayscale = true; + + // Scan the entire image and determine if: + // 1. Every pixel has R == G == B (grayscale) + // 2. Every pixel has A == 255 (opaque) + // 3. There are no more than 256 distinct RGBA colors + + if (kDebug) { + printf("Initial image data:\n"); + //dump_image(w, h, imageInfo.rows.data(), PNG_COLOR_TYPE_RGB_ALPHA); + } + + for (j = 0; j < h; j++) { + const png_byte* row = imageInfo.rows[j]; + png_bytep out = outRows[j]; + for (i = 0; i < w; i++) { + rr = *row++; + gg = *row++; + bb = *row++; + aa = *row++; + + int odev = maxGrayDeviation; + maxGrayDeviation = MAX(ABS(rr - gg), maxGrayDeviation); + maxGrayDeviation = MAX(ABS(gg - bb), maxGrayDeviation); + maxGrayDeviation = MAX(ABS(bb - rr), maxGrayDeviation); + if (maxGrayDeviation > odev) { + if (kDebug) { + printf("New max dev. = %d at pixel (%d, %d) = (%d %d %d %d)\n", + maxGrayDeviation, i, j, rr, gg, bb, aa); + } + } + + // Check if image is really grayscale + if (isGrayscale) { + if (rr != gg || rr != bb) { + if (kDebug) { + printf("Found a non-gray pixel at %d, %d = (%d %d %d %d)\n", + i, j, rr, gg, bb, aa); + } + isGrayscale = false; + } + } + + // Check if image is really opaque + if (isOpaque) { + if (aa != 0xff) { + if (kDebug) { + printf("Found a non-opaque pixel at %d, %d = (%d %d %d %d)\n", + i, j, rr, gg, bb, aa); + } + isOpaque = false; + } + } + + // Check if image is really <= 256 colors + if (isPalette) { + col = (uint32_t) ((rr << 24) | (gg << 16) | (bb << 8) | aa); + bool match = false; + for (idx = 0; idx < num_colors; idx++) { + if (colors[idx] == col) { + match = true; + break; + } + } + + // Write the palette index for the pixel to outRows optimistically + // We might overwrite it later if we decide to encode as gray or + // gray + alpha + *out++ = idx; + if (!match) { + if (num_colors == 256) { + if (kDebug) { + printf("Found 257th color at %d, %d\n", i, j); + } + isPalette = false; + } else { + colors[num_colors++] = col; + } + } + } + } + } + + *paletteEntries = 0; + *hasTransparency = !isOpaque; + int bpp = isOpaque ? 3 : 4; + int paletteSize = w * h + bpp * num_colors; + + if (kDebug) { + printf("isGrayscale = %s\n", isGrayscale ? "true" : "false"); + printf("isOpaque = %s\n", isOpaque ? "true" : "false"); + printf("isPalette = %s\n", isPalette ? "true" : "false"); + printf("Size w/ palette = %d, gray+alpha = %d, rgb(a) = %d\n", + paletteSize, 2 * w * h, bpp * w * h); + printf("Max gray deviation = %d, tolerance = %d\n", maxGrayDeviation, grayscaleTolerance); + } + + // Choose the best color type for the image. + // 1. Opaque gray - use COLOR_TYPE_GRAY at 1 byte/pixel + // 2. Gray + alpha - use COLOR_TYPE_PALETTE if the number of distinct combinations + // is sufficiently small, otherwise use COLOR_TYPE_GRAY_ALPHA + // 3. RGB(A) - use COLOR_TYPE_PALETTE if the number of distinct colors is sufficiently + // small, otherwise use COLOR_TYPE_RGB{_ALPHA} + if (isGrayscale) { + if (isOpaque) { + *colorType = PNG_COLOR_TYPE_GRAY; // 1 byte/pixel + } else { + // Use a simple heuristic to determine whether using a palette will + // save space versus using gray + alpha for each pixel. + // This doesn't take into account chunk overhead, filtering, LZ + // compression, etc. + if (isPalette && (paletteSize < 2 * w * h)) { + *colorType = PNG_COLOR_TYPE_PALETTE; // 1 byte/pixel + 4 bytes/color + } else { + *colorType = PNG_COLOR_TYPE_GRAY_ALPHA; // 2 bytes per pixel + } + } + } else if (isPalette && (paletteSize < bpp * w * h)) { + *colorType = PNG_COLOR_TYPE_PALETTE; + } else { + if (maxGrayDeviation <= grayscaleTolerance) { + logger->note() << "forcing image to gray (max deviation = " << maxGrayDeviation + << ")." + << std::endl; + *colorType = isOpaque ? PNG_COLOR_TYPE_GRAY : PNG_COLOR_TYPE_GRAY_ALPHA; + } else { + *colorType = isOpaque ? PNG_COLOR_TYPE_RGB : PNG_COLOR_TYPE_RGB_ALPHA; + } + } + + // Perform postprocessing of the image or palette data based on the final + // color type chosen + + if (*colorType == PNG_COLOR_TYPE_PALETTE) { + // Create separate RGB and Alpha palettes and set the number of colors + *paletteEntries = num_colors; + + // Create the RGB and alpha palettes + for (int idx = 0; idx < num_colors; idx++) { + col = colors[idx]; + rgbPalette[idx].red = (png_byte) ((col >> 24) & 0xff); + rgbPalette[idx].green = (png_byte) ((col >> 16) & 0xff); + rgbPalette[idx].blue = (png_byte) ((col >> 8) & 0xff); + alphaPalette[idx] = (png_byte) (col & 0xff); + } + } else if (*colorType == PNG_COLOR_TYPE_GRAY || *colorType == PNG_COLOR_TYPE_GRAY_ALPHA) { + // If the image is gray or gray + alpha, compact the pixels into outRows + for (j = 0; j < h; j++) { + const png_byte* row = imageInfo.rows[j]; + png_bytep out = outRows[j]; + for (i = 0; i < w; i++) { + rr = *row++; + gg = *row++; + bb = *row++; + aa = *row++; + + if (isGrayscale) { + *out++ = rr; + } else { + *out++ = (png_byte) (rr * 0.2126f + gg * 0.7152f + bb * 0.0722f); + } + if (!isOpaque) { + *out++ = aa; + } + } + } + } +} + +static bool writePng(png_structp writePtr, png_infop infoPtr, PngInfo* info, + int grayScaleTolerance, SourceLogger* logger, std::string* outError) { + if (setjmp(png_jmpbuf(writePtr))) { + *outError = "failed to write png"; + return false; + } + + uint32_t width, height; + int colorType, bitDepth, interlaceType, compressionType; + + png_unknown_chunk unknowns[3]; + unknowns[0].data = nullptr; + unknowns[1].data = nullptr; + unknowns[2].data = nullptr; + + png_bytepp outRows = (png_bytepp) malloc((int) info->height * sizeof(png_bytep)); + if (outRows == (png_bytepp) 0) { + printf("Can't allocate output buffer!\n"); + exit(1); + } + for (uint32_t i = 0; i < info->height; i++) { + outRows[i] = (png_bytep) malloc(2 * (int) info->width); + if (outRows[i] == (png_bytep) 0) { + printf("Can't allocate output buffer!\n"); + exit(1); + } + } + + png_set_compression_level(writePtr, Z_BEST_COMPRESSION); + + if (kDebug) { + logger->note() << "writing image: w = " << info->width + << ", h = " << info->height + << std::endl; + } + + png_color rgbPalette[256]; + png_byte alphaPalette[256]; + bool hasTransparency; + int paletteEntries; + + analyze_image(logger, *info, grayScaleTolerance, rgbPalette, alphaPalette, + &paletteEntries, &hasTransparency, &colorType, outRows); + + // If the image is a 9-patch, we need to preserve it as a ARGB file to make + // sure the pixels will not be pre-dithered/clamped until we decide they are + if (info->is9Patch && (colorType == PNG_COLOR_TYPE_RGB || + colorType == PNG_COLOR_TYPE_GRAY || colorType == PNG_COLOR_TYPE_PALETTE)) { + colorType = PNG_COLOR_TYPE_RGB_ALPHA; + } + + if (kDebug) { + switch (colorType) { + case PNG_COLOR_TYPE_PALETTE: + logger->note() << "has " << paletteEntries + << " colors" << (hasTransparency ? " (with alpha)" : "") + << ", using PNG_COLOR_TYPE_PALLETTE." + << std::endl; + break; + case PNG_COLOR_TYPE_GRAY: + logger->note() << "is opaque gray, using PNG_COLOR_TYPE_GRAY." << std::endl; + break; + case PNG_COLOR_TYPE_GRAY_ALPHA: + logger->note() << "is gray + alpha, using PNG_COLOR_TYPE_GRAY_ALPHA." << std::endl; + break; + case PNG_COLOR_TYPE_RGB: + logger->note() << "is opaque RGB, using PNG_COLOR_TYPE_RGB." << std::endl; + break; + case PNG_COLOR_TYPE_RGB_ALPHA: + logger->note() << "is RGB + alpha, using PNG_COLOR_TYPE_RGB_ALPHA." << std::endl; + break; + } + } + + png_set_IHDR(writePtr, infoPtr, info->width, info->height, 8, colorType, + PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); + + if (colorType == PNG_COLOR_TYPE_PALETTE) { + png_set_PLTE(writePtr, infoPtr, rgbPalette, paletteEntries); + if (hasTransparency) { + png_set_tRNS(writePtr, infoPtr, alphaPalette, paletteEntries, (png_color_16p) 0); + } + png_set_filter(writePtr, 0, PNG_NO_FILTERS); + } else { + png_set_filter(writePtr, 0, PNG_ALL_FILTERS); + } + + if (info->is9Patch) { + int chunkCount = 2 + (info->haveLayoutBounds ? 1 : 0); + int pIndex = info->haveLayoutBounds ? 2 : 1; + int bIndex = 1; + int oIndex = 0; + + // Chunks ordered thusly because older platforms depend on the base 9 patch data being last + png_bytep chunkNames = info->haveLayoutBounds + ? (png_bytep)"npOl\0npLb\0npTc\0" + : (png_bytep)"npOl\0npTc"; + + // base 9 patch data + if (kDebug) { + logger->note() << "adding 9-patch info..." << std::endl; + } + strcpy((char*)unknowns[pIndex].name, "npTc"); + unknowns[pIndex].data = (png_byte*) info->serialize9Patch(); + unknowns[pIndex].size = info->info9Patch.serializedSize(); + // TODO: remove the check below when everything works + checkNinePatchSerialization(&info->info9Patch, unknowns[pIndex].data); + + // automatically generated 9 patch outline data + int chunkSize = sizeof(png_uint_32) * 6; + strcpy((char*)unknowns[oIndex].name, "npOl"); + unknowns[oIndex].data = (png_byte*) calloc(chunkSize, 1); + png_byte outputData[chunkSize]; + memcpy(&outputData, &info->outlineInsetsLeft, 4 * sizeof(png_uint_32)); + ((float*) outputData)[4] = info->outlineRadius; + ((png_uint_32*) outputData)[5] = info->outlineAlpha; + memcpy(unknowns[oIndex].data, &outputData, chunkSize); + unknowns[oIndex].size = chunkSize; + + // optional optical inset / layout bounds data + if (info->haveLayoutBounds) { + int chunkSize = sizeof(png_uint_32) * 4; + strcpy((char*)unknowns[bIndex].name, "npLb"); + unknowns[bIndex].data = (png_byte*) calloc(chunkSize, 1); + memcpy(unknowns[bIndex].data, &info->layoutBoundsLeft, chunkSize); + unknowns[bIndex].size = chunkSize; + } + + for (int i = 0; i < chunkCount; i++) { + unknowns[i].location = PNG_HAVE_PLTE; + } + png_set_keep_unknown_chunks(writePtr, PNG_HANDLE_CHUNK_ALWAYS, + chunkNames, chunkCount); + png_set_unknown_chunks(writePtr, infoPtr, unknowns, chunkCount); + +#if PNG_LIBPNG_VER < 10600 + // Deal with unknown chunk location bug in 1.5.x and earlier. + png_set_unknown_chunk_location(writePtr, infoPtr, 0, PNG_HAVE_PLTE); + if (info->haveLayoutBounds) { + png_set_unknown_chunk_location(writePtr, infoPtr, 1, PNG_HAVE_PLTE); + } +#endif + } + + png_write_info(writePtr, infoPtr); + + png_bytepp rows; + if (colorType == PNG_COLOR_TYPE_RGB || colorType == PNG_COLOR_TYPE_RGB_ALPHA) { + if (colorType == PNG_COLOR_TYPE_RGB) { + png_set_filler(writePtr, 0, PNG_FILLER_AFTER); + } + rows = info->rows.data(); + } else { + rows = outRows; + } + png_write_image(writePtr, rows); + + if (kDebug) { + printf("Final image data:\n"); + //dump_image(info->width, info->height, rows, colorType); + } + + png_write_end(writePtr, infoPtr); + + for (uint32_t i = 0; i < info->height; i++) { + free(outRows[i]); + } + free(outRows); + free(unknowns[0].data); + free(unknowns[1].data); + free(unknowns[2].data); + + png_get_IHDR(writePtr, infoPtr, &width, &height, &bitDepth, &colorType, &interlaceType, + &compressionType, nullptr); + + if (kDebug) { + logger->note() << "image written: w = " << width << ", h = " << height + << ", d = " << bitDepth << ", colors = " << colorType + << ", inter = " << interlaceType << ", comp = " << compressionType + << std::endl; + } + return true; +} + +constexpr uint32_t kColorWhite = 0xffffffffu; +constexpr uint32_t kColorTick = 0xff000000u; +constexpr uint32_t kColorLayoutBoundsTick = 0xff0000ffu; + +enum class TickType { + kNone, + kTick, + kLayoutBounds, + kBoth +}; + +static TickType tickType(png_bytep p, bool transparent, const char** outError) { + png_uint_32 color = p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24); + + if (transparent) { + if (p[3] == 0) { + return TickType::kNone; + } + if (color == kColorLayoutBoundsTick) { + return TickType::kLayoutBounds; + } + if (color == kColorTick) { + return TickType::kTick; + } + + // Error cases + if (p[3] != 0xff) { + *outError = "Frame pixels must be either solid or transparent " + "(not intermediate alphas)"; + return TickType::kNone; + } + + if (p[0] != 0 || p[1] != 0 || p[2] != 0) { + *outError = "Ticks in transparent frame must be black or red"; + } + return TickType::kTick; + } + + if (p[3] != 0xFF) { + *outError = "White frame must be a solid color (no alpha)"; + } + if (color == kColorWhite) { + return TickType::kNone; + } + if (color == kColorTick) { + return TickType::kTick; + } + if (color == kColorLayoutBoundsTick) { + return TickType::kLayoutBounds; + } + + if (p[0] != 0 || p[1] != 0 || p[2] != 0) { + *outError = "Ticks in white frame must be black or red"; + return TickType::kNone; + } + return TickType::kTick; +} + +enum class TickState { + kStart, + kInside1, + kOutside1 +}; + +static bool getHorizontalTicks(png_bytep row, int width, bool transparent, bool required, + int32_t* outLeft, int32_t* outRight, const char** outError, + uint8_t* outDivs, bool multipleAllowed) { + *outLeft = *outRight = -1; + TickState state = TickState::kStart; + bool found = false; + + for (int i = 1; i < width - 1; i++) { + if (tickType(row+i*4, transparent, outError) == TickType::kTick) { + if (state == TickState::kStart || + (state == TickState::kOutside1 && multipleAllowed)) { + *outLeft = i-1; + *outRight = width-2; + found = true; + if (outDivs != NULL) { + *outDivs += 2; + } + state = TickState::kInside1; + } else if (state == TickState::kOutside1) { + *outError = "Can't have more than one marked region along edge"; + *outLeft = i; + return false; + } + } else if (!*outError) { + if (state == TickState::kInside1) { + // We're done with this div. Move on to the next. + *outRight = i-1; + outRight += 2; + outLeft += 2; + state = TickState::kOutside1; + } + } else { + *outLeft = i; + return false; + } + } + + if (required && !found) { + *outError = "No marked region found along edge"; + *outLeft = -1; + return false; + } + return true; +} + +static bool getVerticalTicks(png_bytepp rows, int offset, int height, bool transparent, + bool required, int32_t* outTop, int32_t* outBottom, + const char** outError, uint8_t* outDivs, bool multipleAllowed) { + *outTop = *outBottom = -1; + TickState state = TickState::kStart; + bool found = false; + + for (int i = 1; i < height - 1; i++) { + if (tickType(rows[i]+offset, transparent, outError) == TickType::kTick) { + if (state == TickState::kStart || + (state == TickState::kOutside1 && multipleAllowed)) { + *outTop = i-1; + *outBottom = height-2; + found = true; + if (outDivs != NULL) { + *outDivs += 2; + } + state = TickState::kInside1; + } else if (state == TickState::kOutside1) { + *outError = "Can't have more than one marked region along edge"; + *outTop = i; + return false; + } + } else if (!*outError) { + if (state == TickState::kInside1) { + // We're done with this div. Move on to the next. + *outBottom = i-1; + outTop += 2; + outBottom += 2; + state = TickState::kOutside1; + } + } else { + *outTop = i; + return false; + } + } + + if (required && !found) { + *outError = "No marked region found along edge"; + *outTop = -1; + return false; + } + return true; +} + +static bool getHorizontalLayoutBoundsTicks(png_bytep row, int width, bool transparent, + bool /* required */, int32_t* outLeft, + int32_t* outRight, const char** outError) { + *outLeft = *outRight = 0; + + // Look for left tick + if (tickType(row + 4, transparent, outError) == TickType::kLayoutBounds) { + // Starting with a layout padding tick + int i = 1; + while (i < width - 1) { + (*outLeft)++; + i++; + if (tickType(row + i * 4, transparent, outError) != TickType::kLayoutBounds) { + break; + } + } + } + + // Look for right tick + if (tickType(row + (width - 2) * 4, transparent, outError) == TickType::kLayoutBounds) { + // Ending with a layout padding tick + int i = width - 2; + while (i > 1) { + (*outRight)++; + i--; + if (tickType(row+i*4, transparent, outError) != TickType::kLayoutBounds) { + break; + } + } + } + return true; +} + +static bool getVerticalLayoutBoundsTicks(png_bytepp rows, int offset, int height, bool transparent, + bool /* required */, int32_t* outTop, int32_t* outBottom, + const char** outError) { + *outTop = *outBottom = 0; + + // Look for top tick + if (tickType(rows[1] + offset, transparent, outError) == TickType::kLayoutBounds) { + // Starting with a layout padding tick + int i = 1; + while (i < height - 1) { + (*outTop)++; + i++; + if (tickType(rows[i] + offset, transparent, outError) != TickType::kLayoutBounds) { + break; + } + } + } + + // Look for bottom tick + if (tickType(rows[height - 2] + offset, transparent, outError) == TickType::kLayoutBounds) { + // Ending with a layout padding tick + int i = height - 2; + while (i > 1) { + (*outBottom)++; + i--; + if (tickType(rows[i] + offset, transparent, outError) != TickType::kLayoutBounds) { + break; + } + } + } + return true; +} + +static void findMaxOpacity(png_bytepp rows, int startX, int startY, int endX, int endY, + int dX, int dY, int* outInset) { + uint8_t maxOpacity = 0; + int inset = 0; + *outInset = 0; + for (int x = startX, y = startY; x != endX && y != endY; x += dX, y += dY, inset++) { + png_byte* color = rows[y] + x * 4; + uint8_t opacity = color[3]; + if (opacity > maxOpacity) { + maxOpacity = opacity; + *outInset = inset; + } + if (opacity == 0xff) return; + } +} + +static uint8_t maxAlphaOverRow(png_bytep row, int startX, int endX) { + uint8_t maxAlpha = 0; + for (int x = startX; x < endX; x++) { + uint8_t alpha = (row + x * 4)[3]; + if (alpha > maxAlpha) maxAlpha = alpha; + } + return maxAlpha; +} + +static uint8_t maxAlphaOverCol(png_bytepp rows, int offsetX, int startY, int endY) { + uint8_t maxAlpha = 0; + for (int y = startY; y < endY; y++) { + uint8_t alpha = (rows[y] + offsetX * 4)[3]; + if (alpha > maxAlpha) maxAlpha = alpha; + } + return maxAlpha; +} + +static void getOutline(PngInfo* image) { + int midX = image->width / 2; + int midY = image->height / 2; + int endX = image->width - 2; + int endY = image->height - 2; + + // find left and right extent of nine patch content on center row + if (image->width > 4) { + findMaxOpacity(image->rows.data(), 1, midY, midX, -1, 1, 0, &image->outlineInsetsLeft); + findMaxOpacity(image->rows.data(), endX, midY, midX, -1, -1, 0, + &image->outlineInsetsRight); + } else { + image->outlineInsetsLeft = 0; + image->outlineInsetsRight = 0; + } + + // find top and bottom extent of nine patch content on center column + if (image->height > 4) { + findMaxOpacity(image->rows.data(), midX, 1, -1, midY, 0, 1, &image->outlineInsetsTop); + findMaxOpacity(image->rows.data(), midX, endY, -1, midY, 0, -1, + &image->outlineInsetsBottom); + } else { + image->outlineInsetsTop = 0; + image->outlineInsetsBottom = 0; + } + + int innerStartX = 1 + image->outlineInsetsLeft; + int innerStartY = 1 + image->outlineInsetsTop; + int innerEndX = endX - image->outlineInsetsRight; + int innerEndY = endY - image->outlineInsetsBottom; + int innerMidX = (innerEndX + innerStartX) / 2; + int innerMidY = (innerEndY + innerStartY) / 2; + + // assuming the image is a round rect, compute the radius by marching + // diagonally from the top left corner towards the center + image->outlineAlpha = std::max( + maxAlphaOverRow(image->rows[innerMidY], innerStartX, innerEndX), + maxAlphaOverCol(image->rows.data(), innerMidX, innerStartY, innerStartY)); + + int diagonalInset = 0; + findMaxOpacity(image->rows.data(), innerStartX, innerStartY, innerMidX, innerMidY, 1, 1, + &diagonalInset); + + /* Determine source radius based upon inset: + * sqrt(r^2 + r^2) = sqrt(i^2 + i^2) + r + * sqrt(2) * r = sqrt(2) * i + r + * (sqrt(2) - 1) * r = sqrt(2) * i + * r = sqrt(2) / (sqrt(2) - 1) * i + */ + image->outlineRadius = 3.4142f * diagonalInset; + + if (kDebug) { + printf("outline insets %d %d %d %d, rad %f, alpha %x\n", + image->outlineInsetsLeft, + image->outlineInsetsTop, + image->outlineInsetsRight, + image->outlineInsetsBottom, + image->outlineRadius, + image->outlineAlpha); + } +} + +static uint32_t getColor(png_bytepp rows, int left, int top, int right, int bottom) { + png_bytep color = rows[top] + left*4; + + if (left > right || top > bottom) { + return android::Res_png_9patch::TRANSPARENT_COLOR; + } + + while (top <= bottom) { + for (int i = left; i <= right; i++) { + png_bytep p = rows[top]+i*4; + if (color[3] == 0) { + if (p[3] != 0) { + return android::Res_png_9patch::NO_COLOR; + } + } else if (p[0] != color[0] || p[1] != color[1] || + p[2] != color[2] || p[3] != color[3]) { + return android::Res_png_9patch::NO_COLOR; + } + } + top++; + } + + if (color[3] == 0) { + return android::Res_png_9patch::TRANSPARENT_COLOR; + } + return (color[3]<<24) | (color[0]<<16) | (color[1]<<8) | color[2]; +} + +static bool do9Patch(PngInfo* image, std::string* outError) { + image->is9Patch = true; + + int W = image->width; + int H = image->height; + int i, j; + + const int maxSizeXDivs = W * sizeof(int32_t); + const int maxSizeYDivs = H * sizeof(int32_t); + int32_t* xDivs = image->xDivs = new int32_t[W]; + int32_t* yDivs = image->yDivs = new int32_t[H]; + uint8_t numXDivs = 0; + uint8_t numYDivs = 0; + + int8_t numColors; + int numRows; + int numCols; + int top; + int left; + int right; + int bottom; + memset(xDivs, -1, maxSizeXDivs); + memset(yDivs, -1, maxSizeYDivs); + image->info9Patch.paddingLeft = image->info9Patch.paddingRight = -1; + image->info9Patch.paddingTop = image->info9Patch.paddingBottom = -1; + image->layoutBoundsLeft = image->layoutBoundsRight = 0; + image->layoutBoundsTop = image->layoutBoundsBottom = 0; + + png_bytep p = image->rows[0]; + bool transparent = p[3] == 0; + bool hasColor = false; + + const char* errorMsg = nullptr; + int errorPixel = -1; + const char* errorEdge = nullptr; + + int colorIndex = 0; + std::vector<png_bytep> newRows; + + // Validate size... + if (W < 3 || H < 3) { + errorMsg = "Image must be at least 3x3 (1x1 without frame) pixels"; + goto getout; + } + + // Validate frame... + if (!transparent && + (p[0] != 0xFF || p[1] != 0xFF || p[2] != 0xFF || p[3] != 0xFF)) { + errorMsg = "Must have one-pixel frame that is either transparent or white"; + goto getout; + } + + // Find left and right of sizing areas... + if (!getHorizontalTicks(p, W, transparent, true, &xDivs[0], &xDivs[1], &errorMsg, &numXDivs, + true)) { + errorPixel = xDivs[0]; + errorEdge = "top"; + goto getout; + } + + // Find top and bottom of sizing areas... + if (!getVerticalTicks(image->rows.data(), 0, H, transparent, true, &yDivs[0], &yDivs[1], + &errorMsg, &numYDivs, true)) { + errorPixel = yDivs[0]; + errorEdge = "left"; + goto getout; + } + + // Copy patch size data into image... + image->info9Patch.numXDivs = numXDivs; + image->info9Patch.numYDivs = numYDivs; + + // Find left and right of padding area... + if (!getHorizontalTicks(image->rows[H-1], W, transparent, false, + &image->info9Patch.paddingLeft, &image->info9Patch.paddingRight, + &errorMsg, nullptr, false)) { + errorPixel = image->info9Patch.paddingLeft; + errorEdge = "bottom"; + goto getout; + } + + // Find top and bottom of padding area... + if (!getVerticalTicks(image->rows.data(), (W-1)*4, H, transparent, false, + &image->info9Patch.paddingTop, &image->info9Patch.paddingBottom, + &errorMsg, nullptr, false)) { + errorPixel = image->info9Patch.paddingTop; + errorEdge = "right"; + goto getout; + } + + // Find left and right of layout padding... + getHorizontalLayoutBoundsTicks(image->rows[H-1], W, transparent, false, + &image->layoutBoundsLeft, &image->layoutBoundsRight, &errorMsg); + + getVerticalLayoutBoundsTicks(image->rows.data(), (W-1)*4, H, transparent, false, + &image->layoutBoundsTop, &image->layoutBoundsBottom, &errorMsg); + + image->haveLayoutBounds = image->layoutBoundsLeft != 0 + || image->layoutBoundsRight != 0 + || image->layoutBoundsTop != 0 + || image->layoutBoundsBottom != 0; + + if (image->haveLayoutBounds) { + if (kDebug) { + printf("layoutBounds=%d %d %d %d\n", image->layoutBoundsLeft, image->layoutBoundsTop, + image->layoutBoundsRight, image->layoutBoundsBottom); + } + } + + // use opacity of pixels to estimate the round rect outline + getOutline(image); + + // If padding is not yet specified, take values from size. + if (image->info9Patch.paddingLeft < 0) { + image->info9Patch.paddingLeft = xDivs[0]; + image->info9Patch.paddingRight = W - 2 - xDivs[1]; + } else { + // Adjust value to be correct! + image->info9Patch.paddingRight = W - 2 - image->info9Patch.paddingRight; + } + if (image->info9Patch.paddingTop < 0) { + image->info9Patch.paddingTop = yDivs[0]; + image->info9Patch.paddingBottom = H - 2 - yDivs[1]; + } else { + // Adjust value to be correct! + image->info9Patch.paddingBottom = H - 2 - image->info9Patch.paddingBottom; + } + +/* if (kDebug) { + printf("Size ticks for %s: x0=%d, x1=%d, y0=%d, y1=%d\n", imageName, + xDivs[0], xDivs[1], + yDivs[0], yDivs[1]); + printf("padding ticks for %s: l=%d, r=%d, t=%d, b=%d\n", imageName, + image->info9Patch.paddingLeft, image->info9Patch.paddingRight, + image->info9Patch.paddingTop, image->info9Patch.paddingBottom); + }*/ + + // Remove frame from image. + newRows.resize(H - 2); + for (i = 0; i < H - 2; i++) { + newRows[i] = image->rows[i + 1]; + memmove(newRows[i], newRows[i] + 4, (W - 2) * 4); + } + image->rows.swap(newRows); + + image->width -= 2; + W = image->width; + image->height -= 2; + H = image->height; + + // Figure out the number of rows and columns in the N-patch + numCols = numXDivs + 1; + if (xDivs[0] == 0) { // Column 1 is strechable + numCols--; + } + if (xDivs[numXDivs - 1] == W) { + numCols--; + } + numRows = numYDivs + 1; + if (yDivs[0] == 0) { // Row 1 is strechable + numRows--; + } + if (yDivs[numYDivs - 1] == H) { + numRows--; + } + + // Make sure the amount of rows and columns will fit in the number of + // colors we can use in the 9-patch format. + if (numRows * numCols > 0x7F) { + errorMsg = "Too many rows and columns in 9-patch perimeter"; + goto getout; + } + + numColors = numRows * numCols; + image->info9Patch.numColors = numColors; + image->colors.resize(numColors); + + // Fill in color information for each patch. + + uint32_t c; + top = 0; + + // The first row always starts with the top being at y=0 and the bottom + // being either yDivs[1] (if yDivs[0]=0) of yDivs[0]. In the former case + // the first row is stretchable along the Y axis, otherwise it is fixed. + // The last row always ends with the bottom being bitmap.height and the top + // being either yDivs[numYDivs-2] (if yDivs[numYDivs-1]=bitmap.height) or + // yDivs[numYDivs-1]. In the former case the last row is stretchable along + // the Y axis, otherwise it is fixed. + // + // The first and last columns are similarly treated with respect to the X + // axis. + // + // The above is to help explain some of the special casing that goes on the + // code below. + + // The initial yDiv and whether the first row is considered stretchable or + // not depends on whether yDiv[0] was zero or not. + for (j = (yDivs[0] == 0 ? 1 : 0); j <= numYDivs && top < H; j++) { + if (j == numYDivs) { + bottom = H; + } else { + bottom = yDivs[j]; + } + left = 0; + // The initial xDiv and whether the first column is considered + // stretchable or not depends on whether xDiv[0] was zero or not. + for (i = xDivs[0] == 0 ? 1 : 0; i <= numXDivs && left < W; i++) { + if (i == numXDivs) { + right = W; + } else { + right = xDivs[i]; + } + c = getColor(image->rows.data(), left, top, right - 1, bottom - 1); + image->colors[colorIndex++] = c; + if (kDebug) { + if (c != android::Res_png_9patch::NO_COLOR) { + hasColor = true; + } + } + left = right; + } + top = bottom; + } + + assert(colorIndex == numColors); + + if (kDebug && hasColor) { + for (i = 0; i < numColors; i++) { + if (i == 0) printf("Colors:\n"); + printf(" #%08x", image->colors[i]); + if (i == numColors - 1) printf("\n"); + } + } +getout: + if (errorMsg) { + std::stringstream err; + err << "9-patch malformed: " << errorMsg; + if (!errorEdge) { + err << "." << std::endl; + if (errorPixel >= 0) { + err << "Found at pixel #" << errorPixel << " along " << errorEdge << " edge"; + } else { + err << "Found along " << errorEdge << " edge"; + } + } + *outError = err.str(); + return false; + } + return true; +} + + +bool Png::process(const Source& source, std::istream& input, BigBuffer* outBuffer, + const Options& options, std::string* outError) { + png_byte signature[kPngSignatureSize]; + + // Read the PNG signature first. + if (!input.read(reinterpret_cast<char*>(signature), kPngSignatureSize)) { + *outError = strerror(errno); + return false; + } + + // If the PNG signature doesn't match, bail early. + if (png_sig_cmp(signature, 0, kPngSignatureSize) != 0) { + *outError = "not a valid png file"; + return false; + } + + SourceLogger logger(source); + bool result = false; + png_structp readPtr = nullptr; + png_infop infoPtr = nullptr; + png_structp writePtr = nullptr; + png_infop writeInfoPtr = nullptr; + PngInfo pngInfo = {}; + + readPtr = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, nullptr, nullptr); + if (!readPtr) { + *outError = "failed to allocate read ptr"; + goto bail; + } + + infoPtr = png_create_info_struct(readPtr); + if (!infoPtr) { + *outError = "failed to allocate info ptr"; + goto bail; + } + + png_set_error_fn(readPtr, reinterpret_cast<png_voidp>(&logger), nullptr, logWarning); + + // Set the read function to read from std::istream. + png_set_read_fn(readPtr, (png_voidp)&input, readDataFromStream); + + if (!readPng(readPtr, infoPtr, &pngInfo, outError)) { + goto bail; + } + + if (util::stringEndsWith<char>(source.path, ".9.png")) { + if (!do9Patch(&pngInfo, outError)) { + goto bail; + } + } + + writePtr = png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, nullptr, nullptr); + if (!writePtr) { + *outError = "failed to allocate write ptr"; + goto bail; + } + + writeInfoPtr = png_create_info_struct(writePtr); + if (!writeInfoPtr) { + *outError = "failed to allocate write info ptr"; + goto bail; + } + + png_set_error_fn(writePtr, nullptr, nullptr, logWarning); + + // Set the write function to write to std::ostream. + png_set_write_fn(writePtr, (png_voidp)outBuffer, writeDataToStream, flushDataToStream); + + if (!writePng(writePtr, writeInfoPtr, &pngInfo, options.grayScaleTolerance, &logger, + outError)) { + goto bail; + } + + result = true; +bail: + if (readPtr) { + png_destroy_read_struct(&readPtr, &infoPtr, nullptr); + } + + if (writePtr) { + png_destroy_write_struct(&writePtr, &writeInfoPtr); + } + return result; +} + +} // namespace aapt diff --git a/tools/aapt2/Png.h b/tools/aapt2/Png.h new file mode 100644 index 0000000..4577ab8 --- /dev/null +++ b/tools/aapt2/Png.h @@ -0,0 +1,39 @@ +/* + * 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_PNG_H +#define AAPT_PNG_H + +#include "BigBuffer.h" +#include "Source.h" + +#include <iostream> +#include <string> + +namespace aapt { + +struct Png { + struct Options { + int grayScaleTolerance = 0; + }; + + bool process(const Source& source, std::istream& input, BigBuffer* outBuffer, + const Options& options, std::string* outError); +}; + +} // namespace aapt + +#endif // AAPT_PNG_H diff --git a/tools/aapt2/ProguardRules.cpp b/tools/aapt2/ProguardRules.cpp new file mode 100644 index 0000000..e89fb7c --- /dev/null +++ b/tools/aapt2/ProguardRules.cpp @@ -0,0 +1,240 @@ +/* + * 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 "ProguardRules.h" +#include "Util.h" +#include "XmlDom.h" + +#include <memory> +#include <string> + +namespace aapt { +namespace proguard { + +constexpr const char16_t* kSchemaAndroid = u"http://schemas.android.com/apk/res/android"; + +class BaseVisitor : public xml::Visitor { +public: + BaseVisitor(const Source& source, KeepSet* keepSet) : mSource(source), mKeepSet(keepSet) { + } + + virtual void visit(xml::Text*) override {}; + + virtual void visit(xml::Namespace* node) override { + for (const auto& child : node->children) { + child->accept(this); + } + } + + virtual void visit(xml::Element* node) override { + if (!node->namespaceUri.empty()) { + Maybe<std::u16string> maybePackage = util::extractPackageFromNamespace( + node->namespaceUri); + if (maybePackage) { + // This is a custom view, let's figure out the class name from this. + std::u16string package = maybePackage.value() + u"." + node->name; + if (util::isJavaClassName(package)) { + addClass(node->lineNumber, package); + } + } + } else if (util::isJavaClassName(node->name)) { + addClass(node->lineNumber, node->name); + } + + for (const auto& child: node->children) { + child->accept(this); + } + } + +protected: + void addClass(size_t lineNumber, const std::u16string& className) { + mKeepSet->addClass(mSource.line(lineNumber), className); + } + + void addMethod(size_t lineNumber, const std::u16string& methodName) { + mKeepSet->addMethod(mSource.line(lineNumber), methodName); + } + +private: + Source mSource; + KeepSet* mKeepSet; +}; + +struct LayoutVisitor : public BaseVisitor { + LayoutVisitor(const Source& source, KeepSet* keepSet) : BaseVisitor(source, keepSet) { + } + + virtual void visit(xml::Element* node) override { + bool checkClass = false; + bool checkName = false; + if (node->namespaceUri.empty()) { + checkClass = node->name == u"view" || node->name == u"fragment"; + } else if (node->namespaceUri == kSchemaAndroid) { + checkName = node->name == u"fragment"; + } + + for (const auto& attr : node->attributes) { + if (checkClass && attr.namespaceUri.empty() && attr.name == u"class" && + util::isJavaClassName(attr.value)) { + addClass(node->lineNumber, attr.value); + } else if (checkName && attr.namespaceUri == kSchemaAndroid && attr.name == u"name" && + util::isJavaClassName(attr.value)) { + addClass(node->lineNumber, attr.value); + } else if (attr.namespaceUri == kSchemaAndroid && attr.name == u"onClick") { + addMethod(node->lineNumber, attr.value); + } + } + + BaseVisitor::visit(node); + } +}; + +struct XmlResourceVisitor : public BaseVisitor { + XmlResourceVisitor(const Source& source, KeepSet* keepSet) : BaseVisitor(source, keepSet) { + } + + virtual void visit(xml::Element* node) override { + bool checkFragment = false; + if (node->namespaceUri.empty()) { + checkFragment = node->name == u"PreferenceScreen" || node->name == u"header"; + } + + if (checkFragment) { + xml::Attribute* attr = node->findAttribute(kSchemaAndroid, u"fragment"); + if (attr && util::isJavaClassName(attr->value)) { + addClass(node->lineNumber, attr->value); + } + } + + BaseVisitor::visit(node); + } +}; + +struct TransitionVisitor : public BaseVisitor { + TransitionVisitor(const Source& source, KeepSet* keepSet) : BaseVisitor(source, keepSet) { + } + + virtual void visit(xml::Element* node) override { + bool checkClass = node->namespaceUri.empty() && + (node->name == u"transition" || node->name == u"pathMotion"); + if (checkClass) { + xml::Attribute* attr = node->findAttribute({}, u"class"); + if (attr && util::isJavaClassName(attr->value)) { + addClass(node->lineNumber, attr->value); + } + } + + BaseVisitor::visit(node); + } +}; + +struct ManifestVisitor : public BaseVisitor { + ManifestVisitor(const Source& source, KeepSet* keepSet) : BaseVisitor(source, keepSet) { + } + + virtual void visit(xml::Element* node) override { + if (node->namespaceUri.empty()) { + bool getName = false; + if (node->name == u"manifest") { + xml::Attribute* attr = node->findAttribute({}, u"package"); + if (attr) { + mPackage = attr->value; + } + } else if (node->name == u"application") { + getName = true; + xml::Attribute* attr = node->findAttribute(kSchemaAndroid, u"backupAgent"); + if (attr) { + Maybe<std::u16string> result = util::getFullyQualifiedClassName(mPackage, + attr->value); + if (result) { + addClass(node->lineNumber, result.value()); + } + } + } else if (node->name == u"activity" || node->name == u"service" || + node->name == u"receiver" || node->name == u"provider" || + node->name == u"instrumentation") { + getName = true; + } + + if (getName) { + xml::Attribute* attr = node->findAttribute(kSchemaAndroid, u"name"); + if (attr) { + Maybe<std::u16string> result = util::getFullyQualifiedClassName(mPackage, + attr->value); + if (result) { + addClass(node->lineNumber, result.value()); + } + } + } + } + BaseVisitor::visit(node); + } + + std::u16string mPackage; +}; + +bool collectProguardRulesForManifest(const Source& source, xml::Node* node, KeepSet* keepSet) { + ManifestVisitor visitor(source, keepSet); + node->accept(&visitor); + return true; +} + +bool collectProguardRules(ResourceType type, const Source& source, xml::Node* node, + KeepSet* keepSet) { + switch (type) { + case ResourceType::kLayout: { + LayoutVisitor visitor(source, keepSet); + node->accept(&visitor); + break; + } + + case ResourceType::kXml: { + XmlResourceVisitor visitor(source, keepSet); + node->accept(&visitor); + break; + } + + case ResourceType::kTransition: { + TransitionVisitor visitor(source, keepSet); + node->accept(&visitor); + break; + } + + default: + break; + } + return true; +} + +bool writeKeepSet(std::ostream* out, const KeepSet& keepSet) { + for (const auto& entry : keepSet.mKeepSet) { + for (const SourceLine& source : entry.second) { + *out << "// Referenced at " << source << "\n"; + } + *out << "-keep class " << entry.first << " { <init>(...); }\n" << std::endl; + } + + for (const auto& entry : keepSet.mKeepMethodSet) { + for (const SourceLine& source : entry.second) { + *out << "// Referenced at " << source << "\n"; + } + *out << "-keepclassmembers class * { *** " << entry.first << "(...); }\n" << std::endl; + } + return true; +} + +} // namespace proguard +} // namespace aapt diff --git a/tools/aapt2/ProguardRules.h b/tools/aapt2/ProguardRules.h new file mode 100644 index 0000000..bbb3e64 --- /dev/null +++ b/tools/aapt2/ProguardRules.h @@ -0,0 +1,58 @@ +/* + * 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_PROGUARD_RULES_H +#define AAPT_PROGUARD_RULES_H + +#include "Resource.h" +#include "Source.h" +#include "XmlDom.h" + +#include <map> +#include <ostream> +#include <set> +#include <string> + +namespace aapt { +namespace proguard { + +class KeepSet { +public: + inline void addClass(const SourceLine& source, const std::u16string& className) { + mKeepSet[className].insert(source); + } + + inline void addMethod(const SourceLine& source, const std::u16string& methodName) { + mKeepMethodSet[methodName].insert(source); + } + +private: + friend bool writeKeepSet(std::ostream* out, const KeepSet& keepSet); + + std::map<std::u16string, std::set<SourceLine>> mKeepSet; + std::map<std::u16string, std::set<SourceLine>> mKeepMethodSet; +}; + +bool collectProguardRulesForManifest(const Source& source, xml::Node* node, KeepSet* keepSet); +bool collectProguardRules(ResourceType type, const Source& source, xml::Node* node, + KeepSet* keepSet); + +bool writeKeepSet(std::ostream* out, const KeepSet& keepSet); + +} // namespace proguard +} // namespace aapt + +#endif // AAPT_PROGUARD_RULES_H diff --git a/tools/aapt2/ResChunkPullParser.cpp b/tools/aapt2/ResChunkPullParser.cpp new file mode 100644 index 0000000..78ea60e --- /dev/null +++ b/tools/aapt2/ResChunkPullParser.cpp @@ -0,0 +1,68 @@ +/* + * 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 "ResChunkPullParser.h" + +#include <androidfw/ResourceTypes.h> +#include <cstddef> + +namespace aapt { + +using android::ResChunk_header; + +ResChunkPullParser::Event ResChunkPullParser::next() { + if (!isGoodEvent(mEvent)) { + return mEvent; + } + + if (mEvent == Event::StartDocument) { + mCurrentChunk = mData; + } else { + mCurrentChunk = reinterpret_cast<const ResChunk_header*>( + reinterpret_cast<const char*>(mCurrentChunk) + mCurrentChunk->size); + } + + const std::ptrdiff_t diff = reinterpret_cast<const char*>(mCurrentChunk) + - reinterpret_cast<const char*>(mData); + assert(diff >= 0 && "diff is negative"); + const size_t offset = static_cast<const size_t>(diff); + + if (offset == mLen) { + mCurrentChunk = nullptr; + return (mEvent = Event::EndDocument); + } else if (offset + sizeof(ResChunk_header) > mLen) { + mLastError = "chunk is past the end of the document"; + mCurrentChunk = nullptr; + return (mEvent = Event::BadDocument); + } + + if (mCurrentChunk->headerSize < sizeof(ResChunk_header)) { + mLastError = "chunk has too small header"; + mCurrentChunk = nullptr; + return (mEvent = Event::BadDocument); + } else if (mCurrentChunk->size < mCurrentChunk->headerSize) { + mLastError = "chunk's total size is smaller than header"; + mCurrentChunk = nullptr; + return (mEvent = Event::BadDocument); + } else if (offset + mCurrentChunk->size > mLen) { + mLastError = "chunk's data extends past the end of the document"; + mCurrentChunk = nullptr; + return (mEvent = Event::BadDocument); + } + return (mEvent = Event::Chunk); +} + +} // namespace aapt diff --git a/tools/aapt2/ResChunkPullParser.h b/tools/aapt2/ResChunkPullParser.h new file mode 100644 index 0000000..1426ed2 --- /dev/null +++ b/tools/aapt2/ResChunkPullParser.h @@ -0,0 +1,122 @@ +/* + * 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_RES_CHUNK_PULL_PARSER_H +#define AAPT_RES_CHUNK_PULL_PARSER_H + +#include <androidfw/ResourceTypes.h> +#include <string> + +namespace aapt { + +/** + * A pull parser, modeled after XmlPullParser, that reads + * android::ResChunk_header structs from a block of data. + * + * An android::ResChunk_header specifies a type, headerSize, + * and size. The pull parser will verify that the chunk's size + * doesn't extend beyond the available data, and will iterate + * over each chunk in the given block of data. + * + * Processing nested chunks is done by creating a new ResChunkPullParser + * pointing to the data portion of a chunk. + */ +class ResChunkPullParser { +public: + enum class Event { + StartDocument, + EndDocument, + BadDocument, + + Chunk, + }; + + /** + * Returns false if the event is EndDocument or BadDocument. + */ + static bool isGoodEvent(Event event); + + /** + * Create a ResChunkPullParser to read android::ResChunk_headers + * from the memory pointed to by data, of len bytes. + */ + ResChunkPullParser(const void* data, size_t len); + + ResChunkPullParser(const ResChunkPullParser&) = delete; + + Event getEvent() const; + const std::string& getLastError() const; + const android::ResChunk_header* getChunk() const; + + /** + * Move to the next android::ResChunk_header. + */ + Event next(); + +private: + Event mEvent; + const android::ResChunk_header* mData; + size_t mLen; + const android::ResChunk_header* mCurrentChunk; + std::string mLastError; +}; + +template <typename T> +inline static const T* convertTo(const android::ResChunk_header* chunk) { + if (chunk->headerSize < sizeof(T)) { + return nullptr; + } + return reinterpret_cast<const T*>(chunk); +} + +inline static const uint8_t* getChunkData(const android::ResChunk_header& chunk) { + return reinterpret_cast<const uint8_t*>(&chunk) + chunk.headerSize; +} + +inline static size_t getChunkDataLen(const android::ResChunk_header& chunk) { + return chunk.size - chunk.headerSize; +} + +// +// Implementation +// + +inline bool ResChunkPullParser::isGoodEvent(ResChunkPullParser::Event event) { + return event != Event::EndDocument && event != Event::BadDocument; +} + +inline ResChunkPullParser::ResChunkPullParser(const void* data, size_t len) : + mEvent(Event::StartDocument), + mData(reinterpret_cast<const android::ResChunk_header*>(data)), + mLen(len), + mCurrentChunk(nullptr) { +} + +inline ResChunkPullParser::Event ResChunkPullParser::getEvent() const { + return mEvent; +} + +inline const std::string& ResChunkPullParser::getLastError() const { + return mLastError; +} + +inline const android::ResChunk_header* ResChunkPullParser::getChunk() const { + return mCurrentChunk; +} + +} // namespace aapt + +#endif // AAPT_RES_CHUNK_PULL_PARSER_H diff --git a/tools/aapt2/Resolver.h b/tools/aapt2/Resolver.h new file mode 100644 index 0000000..cb9318e --- /dev/null +++ b/tools/aapt2/Resolver.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_RESOLVER_H +#define AAPT_RESOLVER_H + +#include "Maybe.h" +#include "Resource.h" +#include "ResourceValues.h" + +#include <androidfw/ResourceTypes.h> + +namespace aapt { + +/** + * Resolves symbolic references (package:type/entry) into resource IDs/objects. + */ +class IResolver { +public: + virtual ~IResolver() {}; + + /** + * Holds the result of a resource name lookup. + */ + struct Entry { + /** + * The ID of the resource. ResourceId::isValid() may + * return false if the resource has not been assigned + * an ID. + */ + ResourceId id; + + /** + * If the resource is an attribute, this will point + * to a valid Attribute object, or else it will be + * nullptr. + */ + const Attribute* attr; + }; + + /** + * Returns a ResourceID if the name is found. The ResourceID + * may not be valid if the resource was not assigned an ID. + */ + virtual Maybe<ResourceId> findId(const ResourceName& name) = 0; + + /** + * Returns an Entry if the name is found. Entry::attr + * may be nullptr if the resource is not an attribute. + */ + virtual Maybe<Entry> findAttribute(const ResourceName& name) = 0; + + /** + * Find a resource by ID. Resolvers may contain resources without + * resource IDs assigned to them. + */ + virtual Maybe<ResourceName> findName(ResourceId resId) = 0; +}; + +} // namespace aapt + +#endif // AAPT_RESOLVER_H diff --git a/tools/aapt2/Resource.cpp b/tools/aapt2/Resource.cpp new file mode 100644 index 0000000..287d8de --- /dev/null +++ b/tools/aapt2/Resource.cpp @@ -0,0 +1,90 @@ +/* + * 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 "Resource.h" +#include "StringPiece.h" + +#include <map> +#include <string> + +namespace aapt { + +StringPiece16 toString(ResourceType type) { + switch (type) { + case ResourceType::kAnim: return u"anim"; + case ResourceType::kAnimator: return u"animator"; + case ResourceType::kArray: return u"array"; + case ResourceType::kAttr: return u"attr"; + case ResourceType::kAttrPrivate: return u"attr"; + case ResourceType::kBool: return u"bool"; + case ResourceType::kColor: return u"color"; + case ResourceType::kDimen: return u"dimen"; + case ResourceType::kDrawable: return u"drawable"; + case ResourceType::kFraction: return u"fraction"; + case ResourceType::kId: return u"id"; + case ResourceType::kInteger: return u"integer"; + case ResourceType::kIntegerArray: return u"integer-array"; + case ResourceType::kInterpolator: return u"interpolator"; + case ResourceType::kLayout: return u"layout"; + case ResourceType::kMenu: return u"menu"; + case ResourceType::kMipmap: return u"mipmap"; + case ResourceType::kPlurals: return u"plurals"; + case ResourceType::kRaw: return u"raw"; + case ResourceType::kString: return u"string"; + case ResourceType::kStyle: return u"style"; + case ResourceType::kStyleable: return u"styleable"; + case ResourceType::kTransition: return u"transition"; + case ResourceType::kXml: return u"xml"; + } + return {}; +} + +static const std::map<StringPiece16, ResourceType> sResourceTypeMap { + { u"anim", ResourceType::kAnim }, + { u"animator", ResourceType::kAnimator }, + { u"array", ResourceType::kArray }, + { u"attr", ResourceType::kAttr }, + { u"^attr-private", ResourceType::kAttrPrivate }, + { u"bool", ResourceType::kBool }, + { u"color", ResourceType::kColor }, + { u"dimen", ResourceType::kDimen }, + { u"drawable", ResourceType::kDrawable }, + { u"fraction", ResourceType::kFraction }, + { u"id", ResourceType::kId }, + { u"integer", ResourceType::kInteger }, + { u"integer-array", ResourceType::kIntegerArray }, + { u"interpolator", ResourceType::kInterpolator }, + { u"layout", ResourceType::kLayout }, + { u"menu", ResourceType::kMenu }, + { u"mipmap", ResourceType::kMipmap }, + { u"plurals", ResourceType::kPlurals }, + { u"raw", ResourceType::kRaw }, + { u"string", ResourceType::kString }, + { u"style", ResourceType::kStyle }, + { u"styleable", ResourceType::kStyleable }, + { u"transition", ResourceType::kTransition }, + { u"xml", ResourceType::kXml }, +}; + +const ResourceType* parseResourceType(const StringPiece16& str) { + auto iter = sResourceTypeMap.find(str); + if (iter == std::end(sResourceTypeMap)) { + return nullptr; + } + return &iter->second; +} + +} // namespace aapt diff --git a/tools/aapt2/Resource.h b/tools/aapt2/Resource.h new file mode 100644 index 0000000..fa9ac07 --- /dev/null +++ b/tools/aapt2/Resource.h @@ -0,0 +1,290 @@ +/* + * 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_RESOURCE_H +#define AAPT_RESOURCE_H + +#include "StringPiece.h" + +#include <iomanip> +#include <limits> +#include <string> +#include <tuple> + +namespace aapt { + +/** + * The various types of resource types available. Corresponds + * to the 'type' in package:type/entry. + */ +enum class ResourceType { + kAnim, + kAnimator, + kArray, + kAttr, + kAttrPrivate, + kBool, + kColor, + kDimen, + kDrawable, + kFraction, + kId, + kInteger, + kIntegerArray, + kInterpolator, + kLayout, + kMenu, + kMipmap, + kPlurals, + kRaw, + kString, + kStyle, + kStyleable, + kTransition, + kXml, +}; + +StringPiece16 toString(ResourceType type); + +/** + * Returns a pointer to a valid ResourceType, or nullptr if + * the string was invalid. + */ +const ResourceType* parseResourceType(const StringPiece16& str); + +/** + * A resource's name. This can uniquely identify + * a resource in the ResourceTable. + */ +struct ResourceName { + std::u16string package; + ResourceType type; + std::u16string entry; + + bool isValid() const; + bool operator<(const ResourceName& rhs) const; + bool operator==(const ResourceName& rhs) const; + bool operator!=(const ResourceName& rhs) const; +}; + +/** + * Same as ResourceName, but uses StringPieces instead. + * Use this if you need to avoid copying and know that + * the lifetime of this object is shorter than that + * of the original string. + */ +struct ResourceNameRef { + StringPiece16 package; + ResourceType type; + StringPiece16 entry; + + ResourceNameRef() = default; + ResourceNameRef(const ResourceNameRef&) = default; + ResourceNameRef(ResourceNameRef&&) = default; + ResourceNameRef(const ResourceName& rhs); + ResourceNameRef(const StringPiece16& p, ResourceType t, const StringPiece16& e); + ResourceNameRef& operator=(const ResourceNameRef& rhs) = default; + ResourceNameRef& operator=(ResourceNameRef&& rhs) = default; + ResourceNameRef& operator=(const ResourceName& rhs); + + ResourceName toResourceName() const; + bool isValid() const; + + bool operator<(const ResourceNameRef& rhs) const; + bool operator==(const ResourceNameRef& rhs) const; + bool operator!=(const ResourceNameRef& rhs) const; +}; + +/** + * A binary identifier representing a resource. Internally it + * is a 32bit integer split as follows: + * + * 0xPPTTEEEE + * + * PP: 8 bit package identifier. 0x01 is reserved for system + * and 0x7f is reserved for the running app. + * TT: 8 bit type identifier. 0x00 is invalid. + * EEEE: 16 bit entry identifier. + */ +struct ResourceId { + uint32_t id; + + ResourceId(); + ResourceId(const ResourceId& rhs); + ResourceId(uint32_t resId); + ResourceId(size_t p, size_t t, size_t e); + + bool isValid() const; + uint8_t packageId() const; + uint8_t typeId() const; + uint16_t entryId() const; + bool operator<(const ResourceId& rhs) const; + bool operator==(const ResourceId& rhs) const; +}; + +// +// ResourceId implementation. +// + +inline ResourceId::ResourceId() : id(0) { +} + +inline ResourceId::ResourceId(const ResourceId& rhs) : id(rhs.id) { +} + +inline ResourceId::ResourceId(uint32_t resId) : id(resId) { +} + +inline ResourceId::ResourceId(size_t p, size_t t, size_t e) : id(0) { + if (p > std::numeric_limits<uint8_t>::max() || + t > std::numeric_limits<uint8_t>::max() || + e > std::numeric_limits<uint16_t>::max()) { + // This will leave the ResourceId in an invalid state. + return; + } + + id = (static_cast<uint8_t>(p) << 24) | + (static_cast<uint8_t>(t) << 16) | + static_cast<uint16_t>(e); +} + +inline bool ResourceId::isValid() const { + return (id & 0xff000000u) != 0 && (id & 0x00ff0000u) != 0; +} + +inline uint8_t ResourceId::packageId() const { + return static_cast<uint8_t>(id >> 24); +} + +inline uint8_t ResourceId::typeId() const { + return static_cast<uint8_t>(id >> 16); +} + +inline uint16_t ResourceId::entryId() const { + return static_cast<uint16_t>(id); +} + +inline bool ResourceId::operator<(const ResourceId& rhs) const { + return id < rhs.id; +} + +inline bool ResourceId::operator==(const ResourceId& rhs) const { + return id == rhs.id; +} + +inline ::std::ostream& operator<<(::std::ostream& out, + const ResourceId& resId) { + std::ios_base::fmtflags oldFlags = out.flags(); + char oldFill = out.fill(); + out << "0x" << std::internal << std::setfill('0') << std::setw(8) + << std::hex << resId.id; + out.flags(oldFlags); + out.fill(oldFill); + return out; +} + +// +// ResourceType implementation. +// + +inline ::std::ostream& operator<<(::std::ostream& out, const ResourceType& val) { + return out << toString(val); +} + +// +// ResourceName implementation. +// + +inline bool ResourceName::isValid() const { + return !package.empty() && !entry.empty(); +} + +inline bool ResourceName::operator<(const ResourceName& rhs) const { + return std::tie(package, type, entry) + < std::tie(rhs.package, rhs.type, rhs.entry); +} + +inline bool ResourceName::operator==(const ResourceName& rhs) const { + return std::tie(package, type, entry) + == std::tie(rhs.package, rhs.type, rhs.entry); +} + +inline bool ResourceName::operator!=(const ResourceName& rhs) const { + return std::tie(package, type, entry) + != std::tie(rhs.package, rhs.type, rhs.entry); +} + +inline ::std::ostream& operator<<(::std::ostream& out, const ResourceName& name) { + if (!name.package.empty()) { + out << name.package << ":"; + } + return out << name.type << "/" << name.entry; +} + + +// +// ResourceNameRef implementation. +// + +inline ResourceNameRef::ResourceNameRef(const ResourceName& rhs) : + package(rhs.package), type(rhs.type), entry(rhs.entry) { +} + +inline ResourceNameRef::ResourceNameRef(const StringPiece16& p, ResourceType t, + const StringPiece16& e) : + package(p), type(t), entry(e) { +} + +inline ResourceNameRef& ResourceNameRef::operator=(const ResourceName& rhs) { + package = rhs.package; + type = rhs.type; + entry = rhs.entry; + return *this; +} + +inline ResourceName ResourceNameRef::toResourceName() const { + return { package.toString(), type, entry.toString() }; +} + +inline bool ResourceNameRef::isValid() const { + return !package.empty() && !entry.empty(); +} + +inline bool ResourceNameRef::operator<(const ResourceNameRef& rhs) const { + return std::tie(package, type, entry) + < std::tie(rhs.package, rhs.type, rhs.entry); +} + +inline bool ResourceNameRef::operator==(const ResourceNameRef& rhs) const { + return std::tie(package, type, entry) + == std::tie(rhs.package, rhs.type, rhs.entry); +} + +inline bool ResourceNameRef::operator!=(const ResourceNameRef& rhs) const { + return std::tie(package, type, entry) + != std::tie(rhs.package, rhs.type, rhs.entry); +} + +inline ::std::ostream& operator<<(::std::ostream& out, const ResourceNameRef& name) { + if (!name.package.empty()) { + out << name.package << ":"; + } + return out << name.type << "/" << name.entry; +} + +} // namespace aapt + +#endif // AAPT_RESOURCE_H diff --git a/tools/aapt2/ResourceParser.cpp b/tools/aapt2/ResourceParser.cpp new file mode 100644 index 0000000..13f916b --- /dev/null +++ b/tools/aapt2/ResourceParser.cpp @@ -0,0 +1,1401 @@ +/* + * 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 "Logger.h" +#include "ResourceParser.h" +#include "ResourceValues.h" +#include "ScopedXmlPullParser.h" +#include "SourceXmlPullParser.h" +#include "Util.h" +#include "XliffXmlPullParser.h" + +#include <sstream> + +namespace aapt { + +void ResourceParser::extractResourceName(const StringPiece16& str, StringPiece16* outPackage, + StringPiece16* outType, StringPiece16* outEntry) { + const char16_t* start = str.data(); + const char16_t* end = start + str.size(); + const char16_t* current = start; + while (current != end) { + if (outType->size() == 0 && *current == u'/') { + outType->assign(start, current - start); + start = current + 1; + } else if (outPackage->size() == 0 && *current == u':') { + outPackage->assign(start, current - start); + start = current + 1; + } + current++; + } + outEntry->assign(start, end - start); +} + +bool ResourceParser::tryParseReference(const StringPiece16& str, ResourceNameRef* outRef, + bool* outCreate, bool* outPrivate) { + StringPiece16 trimmedStr(util::trimWhitespace(str)); + if (trimmedStr.empty()) { + return false; + } + + if (trimmedStr.data()[0] == u'@') { + size_t offset = 1; + *outCreate = false; + if (trimmedStr.data()[1] == u'+') { + *outCreate = true; + offset += 1; + } else if (trimmedStr.data()[1] == u'*') { + *outPrivate = true; + offset += 1; + } + StringPiece16 package; + StringPiece16 type; + StringPiece16 entry; + extractResourceName(trimmedStr.substr(offset, trimmedStr.size() - offset), + &package, &type, &entry); + + const ResourceType* parsedType = parseResourceType(type); + if (!parsedType) { + return false; + } + + if (*outCreate && *parsedType != ResourceType::kId) { + return false; + } + + outRef->package = package; + outRef->type = *parsedType; + outRef->entry = entry; + return true; + } + return false; +} + +bool ResourceParser::tryParseAttributeReference(const StringPiece16& str, + ResourceNameRef* outRef) { + StringPiece16 trimmedStr(util::trimWhitespace(str)); + if (trimmedStr.empty()) { + return false; + } + + if (*trimmedStr.data() == u'?') { + StringPiece16 package; + StringPiece16 type; + StringPiece16 entry; + extractResourceName(trimmedStr.substr(1, trimmedStr.size() - 1), &package, &type, &entry); + + if (!type.empty() && type != u"attr") { + return false; + } + + outRef->package = package; + outRef->type = ResourceType::kAttr; + outRef->entry = entry; + return true; + } + return false; +} + +/* + * Style parent's are a bit different. We accept the following formats: + * + * @[package:]style/<entry> + * ?[package:]style/<entry> + * <package>:[style/]<entry> + * [package:style/]<entry> + */ +bool ResourceParser::parseStyleParentReference(const StringPiece16& str, Reference* outReference, + std::string* outError) { + if (str.empty()) { + return true; + } + + StringPiece16 name = str; + + bool hasLeadingIdentifiers = false; + bool privateRef = false; + + // Skip over these identifiers. A style's parent is a normal reference. + if (name.data()[0] == u'@' || name.data()[0] == u'?') { + hasLeadingIdentifiers = true; + name = name.substr(1, name.size() - 1); + if (name.data()[0] == u'*') { + privateRef = true; + name = name.substr(1, name.size() - 1); + } + } + + ResourceNameRef ref; + ref.type = ResourceType::kStyle; + + StringPiece16 typeStr; + extractResourceName(name, &ref.package, &typeStr, &ref.entry); + if (!typeStr.empty()) { + // If we have a type, make sure it is a Style. + const ResourceType* parsedType = parseResourceType(typeStr); + if (!parsedType || *parsedType != ResourceType::kStyle) { + std::stringstream err; + err << "invalid resource type '" << typeStr << "' for parent of style"; + *outError = err.str(); + return false; + } + } else { + // No type was defined, this should not have a leading identifier. + if (hasLeadingIdentifiers) { + std::stringstream err; + err << "invalid parent reference '" << str << "'"; + *outError = err.str(); + return false; + } + } + + if (!hasLeadingIdentifiers && ref.package.empty() && !typeStr.empty()) { + std::stringstream err; + err << "invalid parent reference '" << str << "'"; + *outError = err.str(); + return false; + } + + outReference->name = ref.toResourceName(); + outReference->privateReference = privateRef; + return true; +} + +std::unique_ptr<Reference> ResourceParser::tryParseReference(const StringPiece16& str, + bool* outCreate) { + ResourceNameRef ref; + bool privateRef = false; + if (tryParseReference(str, &ref, outCreate, &privateRef)) { + std::unique_ptr<Reference> value = util::make_unique<Reference>(ref); + value->privateReference = privateRef; + return value; + } + + if (tryParseAttributeReference(str, &ref)) { + *outCreate = false; + return util::make_unique<Reference>(ref, Reference::Type::kAttribute); + } + return {}; +} + +std::unique_ptr<BinaryPrimitive> ResourceParser::tryParseNullOrEmpty(const StringPiece16& str) { + StringPiece16 trimmedStr(util::trimWhitespace(str)); + android::Res_value value = {}; + if (trimmedStr == u"@null") { + // TYPE_NULL with data set to 0 is interpreted by the runtime as an error. + // Instead we set the data type to TYPE_REFERENCE with a value of 0. + value.dataType = android::Res_value::TYPE_REFERENCE; + } else if (trimmedStr == u"@empty") { + // TYPE_NULL with value of DATA_NULL_EMPTY is handled fine by the runtime. + value.dataType = android::Res_value::TYPE_NULL; + value.data = android::Res_value::DATA_NULL_EMPTY; + } else { + return {}; + } + return util::make_unique<BinaryPrimitive>(value); +} + +std::unique_ptr<BinaryPrimitive> ResourceParser::tryParseEnumSymbol(const Attribute& enumAttr, + const StringPiece16& str) { + StringPiece16 trimmedStr(util::trimWhitespace(str)); + for (const auto& entry : enumAttr.symbols) { + // Enum symbols are stored as @package:id/symbol resources, + // so we need to match against the 'entry' part of the identifier. + const ResourceName& enumSymbolResourceName = entry.symbol.name; + if (trimmedStr == enumSymbolResourceName.entry) { + android::Res_value value = {}; + value.dataType = android::Res_value::TYPE_INT_DEC; + value.data = entry.value; + return util::make_unique<BinaryPrimitive>(value); + } + } + return {}; +} + +std::unique_ptr<BinaryPrimitive> ResourceParser::tryParseFlagSymbol(const Attribute& flagAttr, + const StringPiece16& str) { + android::Res_value flags = {}; + flags.dataType = android::Res_value::TYPE_INT_DEC; + + for (StringPiece16 part : util::tokenize(str, u'|')) { + StringPiece16 trimmedPart = util::trimWhitespace(part); + + bool flagSet = false; + for (const auto& entry : flagAttr.symbols) { + // Flag symbols are stored as @package:id/symbol resources, + // so we need to match against the 'entry' part of the identifier. + const ResourceName& flagSymbolResourceName = entry.symbol.name; + if (trimmedPart == flagSymbolResourceName.entry) { + flags.data |= entry.value; + flagSet = true; + break; + } + } + + if (!flagSet) { + return {}; + } + } + return util::make_unique<BinaryPrimitive>(flags); +} + +static uint32_t parseHex(char16_t c, bool* outError) { + if (c >= u'0' && c <= u'9') { + return c - u'0'; + } else if (c >= u'a' && c <= u'f') { + return c - u'a' + 0xa; + } else if (c >= u'A' && c <= u'F') { + return c - u'A' + 0xa; + } else { + *outError = true; + return 0xffffffffu; + } +} + +std::unique_ptr<BinaryPrimitive> ResourceParser::tryParseColor(const StringPiece16& str) { + StringPiece16 colorStr(util::trimWhitespace(str)); + const char16_t* start = colorStr.data(); + const size_t len = colorStr.size(); + if (len == 0 || start[0] != u'#') { + return {}; + } + + android::Res_value value = {}; + bool error = false; + if (len == 4) { + value.dataType = android::Res_value::TYPE_INT_COLOR_RGB4; + value.data = 0xff000000u; + value.data |= parseHex(start[1], &error) << 20; + value.data |= parseHex(start[1], &error) << 16; + value.data |= parseHex(start[2], &error) << 12; + value.data |= parseHex(start[2], &error) << 8; + value.data |= parseHex(start[3], &error) << 4; + value.data |= parseHex(start[3], &error); + } else if (len == 5) { + value.dataType = android::Res_value::TYPE_INT_COLOR_ARGB4; + value.data |= parseHex(start[1], &error) << 28; + value.data |= parseHex(start[1], &error) << 24; + value.data |= parseHex(start[2], &error) << 20; + value.data |= parseHex(start[2], &error) << 16; + value.data |= parseHex(start[3], &error) << 12; + value.data |= parseHex(start[3], &error) << 8; + value.data |= parseHex(start[4], &error) << 4; + value.data |= parseHex(start[4], &error); + } else if (len == 7) { + value.dataType = android::Res_value::TYPE_INT_COLOR_RGB8; + value.data = 0xff000000u; + value.data |= parseHex(start[1], &error) << 20; + value.data |= parseHex(start[2], &error) << 16; + value.data |= parseHex(start[3], &error) << 12; + value.data |= parseHex(start[4], &error) << 8; + value.data |= parseHex(start[5], &error) << 4; + value.data |= parseHex(start[6], &error); + } else if (len == 9) { + value.dataType = android::Res_value::TYPE_INT_COLOR_ARGB8; + value.data |= parseHex(start[1], &error) << 28; + value.data |= parseHex(start[2], &error) << 24; + value.data |= parseHex(start[3], &error) << 20; + value.data |= parseHex(start[4], &error) << 16; + value.data |= parseHex(start[5], &error) << 12; + value.data |= parseHex(start[6], &error) << 8; + value.data |= parseHex(start[7], &error) << 4; + value.data |= parseHex(start[8], &error); + } else { + return {}; + } + return error ? std::unique_ptr<BinaryPrimitive>() : util::make_unique<BinaryPrimitive>(value); +} + +std::unique_ptr<BinaryPrimitive> ResourceParser::tryParseBool(const StringPiece16& str) { + StringPiece16 trimmedStr(util::trimWhitespace(str)); + uint32_t data = 0; + if (trimmedStr == u"true" || trimmedStr == u"TRUE") { + data = 0xffffffffu; + } else if (trimmedStr != u"false" && trimmedStr != u"FALSE") { + return {}; + } + android::Res_value value = {}; + value.dataType = android::Res_value::TYPE_INT_BOOLEAN; + value.data = data; + return util::make_unique<BinaryPrimitive>(value); +} + +std::unique_ptr<BinaryPrimitive> ResourceParser::tryParseInt(const StringPiece16& str) { + android::Res_value value; + if (!android::ResTable::stringToInt(str.data(), str.size(), &value)) { + return {}; + } + return util::make_unique<BinaryPrimitive>(value); +} + +std::unique_ptr<BinaryPrimitive> ResourceParser::tryParseFloat(const StringPiece16& str) { + android::Res_value value; + if (!android::ResTable::stringToFloat(str.data(), str.size(), &value)) { + return {}; + } + return util::make_unique<BinaryPrimitive>(value); +} + +uint32_t ResourceParser::androidTypeToAttributeTypeMask(uint16_t type) { + switch (type) { + case android::Res_value::TYPE_NULL: + case android::Res_value::TYPE_REFERENCE: + case android::Res_value::TYPE_ATTRIBUTE: + case android::Res_value::TYPE_DYNAMIC_REFERENCE: + return android::ResTable_map::TYPE_REFERENCE; + + case android::Res_value::TYPE_STRING: + return android::ResTable_map::TYPE_STRING; + + case android::Res_value::TYPE_FLOAT: + return android::ResTable_map::TYPE_FLOAT; + + case android::Res_value::TYPE_DIMENSION: + return android::ResTable_map::TYPE_DIMENSION; + + case android::Res_value::TYPE_FRACTION: + return android::ResTable_map::TYPE_FRACTION; + + case android::Res_value::TYPE_INT_DEC: + case android::Res_value::TYPE_INT_HEX: + return android::ResTable_map::TYPE_INTEGER | + android::ResTable_map::TYPE_ENUM | + android::ResTable_map::TYPE_FLAGS; + + case android::Res_value::TYPE_INT_BOOLEAN: + return android::ResTable_map::TYPE_BOOLEAN; + + case android::Res_value::TYPE_INT_COLOR_ARGB8: + case android::Res_value::TYPE_INT_COLOR_RGB8: + case android::Res_value::TYPE_INT_COLOR_ARGB4: + case android::Res_value::TYPE_INT_COLOR_RGB4: + return android::ResTable_map::TYPE_COLOR; + + default: + return 0; + }; +} + +std::unique_ptr<Item> ResourceParser::parseItemForAttribute( + const StringPiece16& value, uint32_t typeMask, + std::function<void(const ResourceName&)> onCreateReference) { + std::unique_ptr<BinaryPrimitive> nullOrEmpty = tryParseNullOrEmpty(value); + if (nullOrEmpty) { + return std::move(nullOrEmpty); + } + + bool create = false; + std::unique_ptr<Reference> reference = tryParseReference(value, &create); + if (reference) { + if (create && onCreateReference) { + onCreateReference(reference->name); + } + return std::move(reference); + } + + if (typeMask & android::ResTable_map::TYPE_COLOR) { + // Try parsing this as a color. + std::unique_ptr<BinaryPrimitive> color = tryParseColor(value); + if (color) { + return std::move(color); + } + } + + if (typeMask & android::ResTable_map::TYPE_BOOLEAN) { + // Try parsing this as a boolean. + std::unique_ptr<BinaryPrimitive> boolean = tryParseBool(value); + if (boolean) { + return std::move(boolean); + } + } + + if (typeMask & android::ResTable_map::TYPE_INTEGER) { + // Try parsing this as an integer. + std::unique_ptr<BinaryPrimitive> integer = tryParseInt(value); + if (integer) { + return std::move(integer); + } + } + + const uint32_t floatMask = android::ResTable_map::TYPE_FLOAT | + android::ResTable_map::TYPE_DIMENSION | + android::ResTable_map::TYPE_FRACTION; + if (typeMask & floatMask) { + // Try parsing this as a float. + std::unique_ptr<BinaryPrimitive> floatingPoint = tryParseFloat(value); + if (floatingPoint) { + if (typeMask & androidTypeToAttributeTypeMask(floatingPoint->value.dataType)) { + return std::move(floatingPoint); + } + } + } + return {}; +} + +/** + * We successively try to parse the string as a resource type that the Attribute + * allows. + */ +std::unique_ptr<Item> ResourceParser::parseItemForAttribute( + const StringPiece16& str, const Attribute& attr, + std::function<void(const ResourceName&)> onCreateReference) { + const uint32_t typeMask = attr.typeMask; + std::unique_ptr<Item> value = parseItemForAttribute(str, typeMask, onCreateReference); + if (value) { + return value; + } + + if (typeMask & android::ResTable_map::TYPE_ENUM) { + // Try parsing this as an enum. + std::unique_ptr<BinaryPrimitive> enumValue = tryParseEnumSymbol(attr, str); + if (enumValue) { + return std::move(enumValue); + } + } + + if (typeMask & android::ResTable_map::TYPE_FLAGS) { + // Try parsing this as a flag. + std::unique_ptr<BinaryPrimitive> flagValue = tryParseFlagSymbol(attr, str); + if (flagValue) { + return std::move(flagValue); + } + } + return {}; +} + +ResourceParser::ResourceParser(const std::shared_ptr<ResourceTable>& table, const Source& source, + const ConfigDescription& config, + const std::shared_ptr<XmlPullParser>& parser) : + mTable(table), mSource(source), mConfig(config), mLogger(source), + mParser(std::make_shared<XliffXmlPullParser>(parser)) { +} + +/** + * Build a string from XML that converts nested elements into Span objects. + */ +bool ResourceParser::flattenXmlSubtree(XmlPullParser* parser, std::u16string* outRawString, + StyleString* outStyleString) { + std::vector<Span> spanStack; + + outRawString->clear(); + outStyleString->spans.clear(); + util::StringBuilder builder; + size_t depth = 1; + while (XmlPullParser::isGoodEvent(parser->next())) { + const XmlPullParser::Event event = parser->getEvent(); + if (event == XmlPullParser::Event::kEndElement) { + depth--; + if (depth == 0) { + break; + } + + spanStack.back().lastChar = builder.str().size(); + outStyleString->spans.push_back(spanStack.back()); + spanStack.pop_back(); + + } else if (event == XmlPullParser::Event::kText) { + // TODO(adamlesinski): Verify format strings. + outRawString->append(parser->getText()); + builder.append(parser->getText()); + + } else if (event == XmlPullParser::Event::kStartElement) { + if (parser->getElementNamespace().size() > 0) { + mLogger.warn(parser->getLineNumber()) + << "skipping element '" + << parser->getElementName() + << "' with unknown namespace '" + << parser->getElementNamespace() + << "'." + << std::endl; + XmlPullParser::skipCurrentElement(parser); + continue; + } + depth++; + + // Build a span object out of the nested element. + std::u16string spanName = parser->getElementName(); + const auto endAttrIter = parser->endAttributes(); + for (auto attrIter = parser->beginAttributes(); attrIter != endAttrIter; ++attrIter) { + spanName += u";"; + spanName += attrIter->name; + spanName += u"="; + spanName += attrIter->value; + } + + if (builder.str().size() > std::numeric_limits<uint32_t>::max()) { + mLogger.error(parser->getLineNumber()) + << "style string '" + << builder.str() + << "' is too long." + << std::endl; + return false; + } + spanStack.push_back(Span{ spanName, static_cast<uint32_t>(builder.str().size()) }); + + } else if (event == XmlPullParser::Event::kComment) { + // Skip + } else { + mLogger.warn(parser->getLineNumber()) + << "unknown event " + << event + << "." + << std::endl; + } + } + assert(spanStack.empty() && "spans haven't been fully processed"); + + outStyleString->str = builder.str(); + return true; +} + +bool ResourceParser::parse() { + while (XmlPullParser::isGoodEvent(mParser->next())) { + if (mParser->getEvent() != XmlPullParser::Event::kStartElement) { + continue; + } + + ScopedXmlPullParser parser(mParser.get()); + if (!parser.getElementNamespace().empty() || + parser.getElementName() != u"resources") { + mLogger.error(parser.getLineNumber()) + << "root element must be <resources> in the global namespace." + << std::endl; + return false; + } + + if (!parseResources(&parser)) { + return false; + } + } + + if (mParser->getEvent() == XmlPullParser::Event::kBadDocument) { + mLogger.error(mParser->getLineNumber()) + << mParser->getLastError() + << std::endl; + return false; + } + return true; +} + +bool ResourceParser::parseResources(XmlPullParser* parser) { + bool success = true; + + std::u16string comment; + while (XmlPullParser::isGoodEvent(parser->next())) { + const XmlPullParser::Event event = parser->getEvent(); + if (event == XmlPullParser::Event::kComment) { + comment = parser->getComment(); + continue; + } + + if (event == XmlPullParser::Event::kText) { + if (!util::trimWhitespace(parser->getText()).empty()) { + comment = u""; + } + continue; + } + + if (event != XmlPullParser::Event::kStartElement) { + continue; + } + + ScopedXmlPullParser childParser(parser); + + if (!childParser.getElementNamespace().empty()) { + // Skip unknown namespace. + continue; + } + + StringPiece16 name = childParser.getElementName(); + if (name == u"skip" || name == u"eat-comment") { + continue; + } + + if (name == u"private-symbols") { + // Handle differently. + mLogger.note(childParser.getLineNumber()) + << "got a <private-symbols> tag." + << std::endl; + continue; + } + + const auto endAttrIter = childParser.endAttributes(); + auto attrIter = childParser.findAttribute(u"", u"name"); + if (attrIter == endAttrIter || attrIter->value.empty()) { + mLogger.error(childParser.getLineNumber()) + << "<" << name << "> tag must have a 'name' attribute." + << std::endl; + success = false; + continue; + } + + // Copy because our iterator will go out of scope when + // we parse more XML. + std::u16string attributeName = attrIter->value; + + if (name == u"item") { + // Items simply have their type encoded in the type attribute. + auto typeIter = childParser.findAttribute(u"", u"type"); + if (typeIter == endAttrIter || typeIter->value.empty()) { + mLogger.error(childParser.getLineNumber()) + << "<item> must have a 'type' attribute." + << std::endl; + success = false; + continue; + } + name = typeIter->value; + } + + if (name == u"id") { + success &= mTable->addResource(ResourceNameRef{ {}, ResourceType::kId, attributeName }, + {}, mSource.line(childParser.getLineNumber()), + util::make_unique<Id>()); + } else if (name == u"string") { + success &= parseString(&childParser, + ResourceNameRef{ {}, ResourceType::kString, attributeName }); + } else if (name == u"color") { + success &= parseColor(&childParser, + ResourceNameRef{ {}, ResourceType::kColor, attributeName }); + } else if (name == u"drawable") { + success &= parseColor(&childParser, + ResourceNameRef{ {}, ResourceType::kDrawable, attributeName }); + } else if (name == u"bool") { + success &= parsePrimitive(&childParser, + ResourceNameRef{ {}, ResourceType::kBool, attributeName }); + } else if (name == u"integer") { + success &= parsePrimitive( + &childParser, + ResourceNameRef{ {}, ResourceType::kInteger, attributeName }); + } else if (name == u"dimen") { + success &= parsePrimitive(&childParser, + ResourceNameRef{ {}, ResourceType::kDimen, attributeName }); + } else if (name == u"fraction") { +// success &= parsePrimitive( +// &childParser, +// ResourceNameRef{ {}, ResourceType::kFraction, attributeName }); + } else if (name == u"style") { + success &= parseStyle(&childParser, + ResourceNameRef{ {}, ResourceType::kStyle, attributeName }); + } else if (name == u"plurals") { + success &= parsePlural(&childParser, + ResourceNameRef{ {}, ResourceType::kPlurals, attributeName }); + } else if (name == u"array") { + success &= parseArray(&childParser, + ResourceNameRef{ {}, ResourceType::kArray, attributeName }, + android::ResTable_map::TYPE_ANY); + } else if (name == u"string-array") { + success &= parseArray(&childParser, + ResourceNameRef{ {}, ResourceType::kArray, attributeName }, + android::ResTable_map::TYPE_STRING); + } else if (name == u"integer-array") { + success &= parseArray(&childParser, + ResourceNameRef{ {}, ResourceType::kArray, attributeName }, + android::ResTable_map::TYPE_INTEGER); + } else if (name == u"public") { + success &= parsePublic(&childParser, attributeName); + } else if (name == u"declare-styleable") { + success &= parseDeclareStyleable( + &childParser, + ResourceNameRef{ {}, ResourceType::kStyleable, attributeName }); + } else if (name == u"attr") { + success &= parseAttr(&childParser, + ResourceNameRef{ {}, ResourceType::kAttr, attributeName }); + } else if (name == u"bag") { + } else if (name == u"public-padding") { + } else if (name == u"java-symbol") { + } else if (name == u"add-resource") { + } + } + + if (parser->getEvent() == XmlPullParser::Event::kBadDocument) { + mLogger.error(parser->getLineNumber()) + << parser->getLastError() + << std::endl; + return false; + } + return success; +} + + + +enum { + kAllowRawString = true, + kNoRawString = false +}; + +/** + * Reads the entire XML subtree and attempts to parse it as some Item, + * with typeMask denoting which items it can be. If allowRawValue is + * true, a RawString is returned if the XML couldn't be parsed as + * an Item. If allowRawValue is false, nullptr is returned in this + * case. + */ +std::unique_ptr<Item> ResourceParser::parseXml(XmlPullParser* parser, uint32_t typeMask, + bool allowRawValue) { + const size_t beginXmlLine = parser->getLineNumber(); + + std::u16string rawValue; + StyleString styleString; + if (!flattenXmlSubtree(parser, &rawValue, &styleString)) { + return {}; + } + + StringPool& pool = mTable->getValueStringPool(); + + if (!styleString.spans.empty()) { + // This can only be a StyledString. + return util::make_unique<StyledString>( + pool.makeRef(styleString, StringPool::Context{ 1, mConfig })); + } + + auto onCreateReference = [&](const ResourceName& name) { + // name.package can be empty here, as it will assume the package name of the table. + mTable->addResource(name, {}, mSource.line(beginXmlLine), util::make_unique<Id>()); + }; + + // Process the raw value. + std::unique_ptr<Item> processedItem = parseItemForAttribute(rawValue, typeMask, + onCreateReference); + if (processedItem) { + // Fix up the reference. + visitFunc<Reference>(*processedItem, [&](Reference& ref) { + if (!ref.name.package.empty()) { + // The package name was set, so lookup its alias. + parser->applyPackageAlias(&ref.name.package, mTable->getPackage()); + } else { + // The package name was left empty, so it assumes the default package + // without alias lookup. + ref.name.package = mTable->getPackage(); + } + }); + return processedItem; + } + + // Try making a regular string. + if (typeMask & android::ResTable_map::TYPE_STRING) { + // Use the trimmed, escaped string. + return util::make_unique<String>( + pool.makeRef(styleString.str, StringPool::Context{ 1, mConfig })); + } + + // We can't parse this so return a RawString if we are allowed. + if (allowRawValue) { + return util::make_unique<RawString>( + pool.makeRef(rawValue, StringPool::Context{ 1, mConfig })); + } + return {}; +} + +bool ResourceParser::parseString(XmlPullParser* parser, const ResourceNameRef& resourceName) { + const SourceLine source = mSource.line(parser->getLineNumber()); + + // Mark the string as untranslateable if needed. + const auto endAttrIter = parser->endAttributes(); + auto attrIter = parser->findAttribute(u"", u"untranslateable"); + // bool untranslateable = attrIter != endAttrIter; + // TODO(adamlesinski): Do something with this (mark the string). + + // Deal with the product. + attrIter = parser->findAttribute(u"", u"product"); + if (attrIter != endAttrIter) { + if (attrIter->value != u"default" && attrIter->value != u"phone") { + // TODO(adamlesinski): Match products. + return true; + } + } + + std::unique_ptr<Item> processedItem = parseXml(parser, android::ResTable_map::TYPE_STRING, + kNoRawString); + if (!processedItem) { + mLogger.error(source.line) + << "not a valid string." + << std::endl; + return false; + } + + return mTable->addResource(resourceName, mConfig, source, std::move(processedItem)); +} + +bool ResourceParser::parseColor(XmlPullParser* parser, const ResourceNameRef& resourceName) { + const SourceLine source = mSource.line(parser->getLineNumber()); + + std::unique_ptr<Item> item = parseXml(parser, android::ResTable_map::TYPE_COLOR, kNoRawString); + if (!item) { + mLogger.error(source.line) << "invalid color." << std::endl; + return false; + } + return mTable->addResource(resourceName, mConfig, source, std::move(item)); +} + +bool ResourceParser::parsePrimitive(XmlPullParser* parser, const ResourceNameRef& resourceName) { + const SourceLine source = mSource.line(parser->getLineNumber()); + + uint32_t typeMask = 0; + switch (resourceName.type) { + case ResourceType::kInteger: + typeMask |= android::ResTable_map::TYPE_INTEGER; + break; + + case ResourceType::kDimen: + typeMask |= android::ResTable_map::TYPE_DIMENSION + | android::ResTable_map::TYPE_FLOAT + | android::ResTable_map::TYPE_FRACTION; + break; + + case ResourceType::kBool: + typeMask |= android::ResTable_map::TYPE_BOOLEAN; + break; + + default: + assert(false); + break; + } + + std::unique_ptr<Item> item = parseXml(parser, typeMask, kNoRawString); + if (!item) { + mLogger.error(source.line) + << "invalid " + << resourceName.type + << "." + << std::endl; + return false; + } + + return mTable->addResource(resourceName, mConfig, source, std::move(item)); +} + +bool ResourceParser::parsePublic(XmlPullParser* parser, const StringPiece16& name) { + const SourceLine source = mSource.line(parser->getLineNumber()); + + const auto endAttrIter = parser->endAttributes(); + const auto typeAttrIter = parser->findAttribute(u"", u"type"); + if (typeAttrIter == endAttrIter || typeAttrIter->value.empty()) { + mLogger.error(source.line) + << "<public> must have a 'type' attribute." + << std::endl; + return false; + } + + const ResourceType* parsedType = parseResourceType(typeAttrIter->value); + if (!parsedType) { + mLogger.error(source.line) + << "invalid resource type '" + << typeAttrIter->value + << "' in <public>." + << std::endl; + return false; + } + + ResourceNameRef resourceName { {}, *parsedType, name }; + ResourceId resourceId; + + const auto idAttrIter = parser->findAttribute(u"", u"id"); + if (idAttrIter != endAttrIter && !idAttrIter->value.empty()) { + android::Res_value val; + bool result = android::ResTable::stringToInt(idAttrIter->value.data(), + idAttrIter->value.size(), &val); + resourceId.id = val.data; + if (!result || !resourceId.isValid()) { + mLogger.error(source.line) + << "invalid resource ID '" + << idAttrIter->value + << "' in <public>." + << std::endl; + return false; + } + } + + if (*parsedType == ResourceType::kId) { + // An ID marked as public is also the definition of an ID. + mTable->addResource(resourceName, {}, source, util::make_unique<Id>()); + } + + return mTable->markPublic(resourceName, resourceId, source); +} + +static uint32_t parseFormatType(const StringPiece16& piece) { + if (piece == u"reference") return android::ResTable_map::TYPE_REFERENCE; + else if (piece == u"string") return android::ResTable_map::TYPE_STRING; + else if (piece == u"integer") return android::ResTable_map::TYPE_INTEGER; + else if (piece == u"boolean") return android::ResTable_map::TYPE_BOOLEAN; + else if (piece == u"color") return android::ResTable_map::TYPE_COLOR; + else if (piece == u"float") return android::ResTable_map::TYPE_FLOAT; + else if (piece == u"dimension") return android::ResTable_map::TYPE_DIMENSION; + else if (piece == u"fraction") return android::ResTable_map::TYPE_FRACTION; + else if (piece == u"enum") return android::ResTable_map::TYPE_ENUM; + else if (piece == u"flags") return android::ResTable_map::TYPE_FLAGS; + return 0; +} + +static uint32_t parseFormatAttribute(const StringPiece16& str) { + uint32_t mask = 0; + for (StringPiece16 part : util::tokenize(str, u'|')) { + StringPiece16 trimmedPart = util::trimWhitespace(part); + uint32_t type = parseFormatType(trimmedPart); + if (type == 0) { + return 0; + } + mask |= type; + } + return mask; +} + +bool ResourceParser::parseAttr(XmlPullParser* parser, const ResourceNameRef& resourceName) { + const SourceLine source = mSource.line(parser->getLineNumber()); + ResourceName actualName = resourceName.toResourceName(); + std::unique_ptr<Attribute> attr = parseAttrImpl(parser, &actualName, false); + if (!attr) { + return false; + } + return mTable->addResource(actualName, mConfig, source, std::move(attr)); +} + +std::unique_ptr<Attribute> ResourceParser::parseAttrImpl(XmlPullParser* parser, + ResourceName* resourceName, + bool weak) { + uint32_t typeMask = 0; + + const auto endAttrIter = parser->endAttributes(); + const auto formatAttrIter = parser->findAttribute(u"", u"format"); + if (formatAttrIter != endAttrIter) { + typeMask = parseFormatAttribute(formatAttrIter->value); + if (typeMask == 0) { + mLogger.error(parser->getLineNumber()) + << "invalid attribute format '" + << formatAttrIter->value + << "'." + << std::endl; + return {}; + } + } + + // If this is a declaration, the package name may be in the name. Separate these out. + // Eg. <attr name="android:text" /> + // No format attribute is allowed. + if (weak && formatAttrIter == endAttrIter) { + StringPiece16 package, type, name; + extractResourceName(resourceName->entry, &package, &type, &name); + if (type.empty() && !package.empty()) { + resourceName->package = package.toString(); + resourceName->entry = name.toString(); + } + } + + std::vector<Attribute::Symbol> items; + + bool error = false; + while (XmlPullParser::isGoodEvent(parser->next())) { + if (parser->getEvent() != XmlPullParser::Event::kStartElement) { + continue; + } + + ScopedXmlPullParser childParser(parser); + + const std::u16string& name = childParser.getElementName(); + if (!childParser.getElementNamespace().empty() + || (name != u"flag" && name != u"enum")) { + mLogger.error(childParser.getLineNumber()) + << "unexpected tag <" + << name + << "> in <attr>." + << std::endl; + error = true; + continue; + } + + if (name == u"enum") { + if (typeMask & android::ResTable_map::TYPE_FLAGS) { + mLogger.error(childParser.getLineNumber()) + << "can not define an <enum>; already defined a <flag>." + << std::endl; + error = true; + continue; + } + typeMask |= android::ResTable_map::TYPE_ENUM; + } else if (name == u"flag") { + if (typeMask & android::ResTable_map::TYPE_ENUM) { + mLogger.error(childParser.getLineNumber()) + << "can not define a <flag>; already defined an <enum>." + << std::endl; + error = true; + continue; + } + typeMask |= android::ResTable_map::TYPE_FLAGS; + } + + Attribute::Symbol item; + if (parseEnumOrFlagItem(&childParser, name, &item)) { + if (!mTable->addResource(item.symbol.name, mConfig, + mSource.line(childParser.getLineNumber()), + util::make_unique<Id>())) { + error = true; + } else { + items.push_back(std::move(item)); + } + } else { + error = true; + } + } + + if (error) { + return {}; + } + + std::unique_ptr<Attribute> attr = util::make_unique<Attribute>(weak); + attr->symbols.swap(items); + attr->typeMask = typeMask ? typeMask : uint32_t(android::ResTable_map::TYPE_ANY); + return attr; +} + +bool ResourceParser::parseEnumOrFlagItem(XmlPullParser* parser, const StringPiece16& tag, + Attribute::Symbol* outSymbol) { + const auto attrIterEnd = parser->endAttributes(); + const auto nameAttrIter = parser->findAttribute(u"", u"name"); + if (nameAttrIter == attrIterEnd || nameAttrIter->value.empty()) { + mLogger.error(parser->getLineNumber()) + << "no attribute 'name' found for tag <" << tag << ">." + << std::endl; + return false; + } + + const auto valueAttrIter = parser->findAttribute(u"", u"value"); + if (valueAttrIter == attrIterEnd || valueAttrIter->value.empty()) { + mLogger.error(parser->getLineNumber()) + << "no attribute 'value' found for tag <" << tag << ">." + << std::endl; + return false; + } + + android::Res_value val; + if (!android::ResTable::stringToInt(valueAttrIter->value.data(), + valueAttrIter->value.size(), &val)) { + mLogger.error(parser->getLineNumber()) + << "invalid value '" + << valueAttrIter->value + << "' for <" << tag << ">; must be an integer." + << std::endl; + return false; + } + + outSymbol->symbol.name = ResourceName { + mTable->getPackage(), ResourceType::kId, nameAttrIter->value }; + outSymbol->value = val.data; + return true; +} + +static bool parseXmlAttributeName(StringPiece16 str, ResourceName* outName) { + str = util::trimWhitespace(str); + const char16_t* const start = str.data(); + const char16_t* const end = start + str.size(); + const char16_t* p = start; + + StringPiece16 package; + StringPiece16 name; + while (p != end) { + if (*p == u':') { + package = StringPiece16(start, p - start); + name = StringPiece16(p + 1, end - (p + 1)); + break; + } + p++; + } + + outName->package = package.toString(); + outName->type = ResourceType::kAttr; + if (name.size() == 0) { + outName->entry = str.toString(); + } else { + outName->entry = name.toString(); + } + return true; +} + +bool ResourceParser::parseUntypedItem(XmlPullParser* parser, Style& style) { + const auto endAttrIter = parser->endAttributes(); + const auto nameAttrIter = parser->findAttribute(u"", u"name"); + if (nameAttrIter == endAttrIter || nameAttrIter->value.empty()) { + mLogger.error(parser->getLineNumber()) + << "<item> must have a 'name' attribute." + << std::endl; + return false; + } + + ResourceName key; + if (!parseXmlAttributeName(nameAttrIter->value, &key)) { + mLogger.error(parser->getLineNumber()) + << "invalid attribute name '" + << nameAttrIter->value + << "'." + << std::endl; + return false; + } + + if (!key.package.empty()) { + // We have a package name set, so lookup its alias. + parser->applyPackageAlias(&key.package, mTable->getPackage()); + } else { + // The package name was omitted, so use the default package name with + // no alias lookup. + key.package = mTable->getPackage(); + } + + std::unique_ptr<Item> value = parseXml(parser, 0, kAllowRawString); + if (!value) { + return false; + } + + style.entries.push_back(Style::Entry{ Reference(key), std::move(value) }); + return true; +} + +bool ResourceParser::parseStyle(XmlPullParser* parser, const ResourceNameRef& resourceName) { + const SourceLine source = mSource.line(parser->getLineNumber()); + std::unique_ptr<Style> style = util::make_unique<Style>(); + + const auto endAttrIter = parser->endAttributes(); + const auto parentAttrIter = parser->findAttribute(u"", u"parent"); + if (parentAttrIter != endAttrIter) { + std::string errStr; + if (!parseStyleParentReference(parentAttrIter->value, &style->parent, &errStr)) { + mLogger.error(source.line) << errStr << "." << std::endl; + return false; + } + + if (!style->parent.name.package.empty()) { + // Try to interpret the package name as an alias. These take precedence. + parser->applyPackageAlias(&style->parent.name.package, mTable->getPackage()); + } else { + // If no package is specified, this can not be an alias and is the local package. + style->parent.name.package = mTable->getPackage(); + } + } else { + // No parent was specified, so try inferring it from the style name. + std::u16string styleName = resourceName.entry.toString(); + size_t pos = styleName.find_last_of(u'.'); + if (pos != std::string::npos) { + style->parentInferred = true; + style->parent.name.package = mTable->getPackage(); + style->parent.name.type = ResourceType::kStyle; + style->parent.name.entry = styleName.substr(0, pos); + } + } + + bool success = true; + while (XmlPullParser::isGoodEvent(parser->next())) { + if (parser->getEvent() != XmlPullParser::Event::kStartElement) { + continue; + } + + ScopedXmlPullParser childParser(parser); + const std::u16string& name = childParser.getElementName(); + if (name == u"item") { + success &= parseUntypedItem(&childParser, *style); + } else { + mLogger.error(childParser.getLineNumber()) + << "unexpected tag <" + << name + << "> in <style> resource." + << std::endl; + success = false; + } + } + + if (!success) { + return false; + } + + return mTable->addResource(resourceName, mConfig, source, std::move(style)); +} + +bool ResourceParser::parseArray(XmlPullParser* parser, const ResourceNameRef& resourceName, + uint32_t typeMask) { + const SourceLine source = mSource.line(parser->getLineNumber()); + std::unique_ptr<Array> array = util::make_unique<Array>(); + + bool error = false; + while (XmlPullParser::isGoodEvent(parser->next())) { + if (parser->getEvent() != XmlPullParser::Event::kStartElement) { + continue; + } + + ScopedXmlPullParser childParser(parser); + + if (childParser.getElementName() != u"item") { + mLogger.error(childParser.getLineNumber()) + << "unexpected tag <" + << childParser.getElementName() + << "> in <array> resource." + << std::endl; + error = true; + continue; + } + + std::unique_ptr<Item> item = parseXml(&childParser, typeMask, kNoRawString); + if (!item) { + error = true; + continue; + } + array->items.emplace_back(std::move(item)); + } + + if (error) { + return false; + } + + return mTable->addResource(resourceName, mConfig, source, std::move(array)); +} + +bool ResourceParser::parsePlural(XmlPullParser* parser, const ResourceNameRef& resourceName) { + const SourceLine source = mSource.line(parser->getLineNumber()); + std::unique_ptr<Plural> plural = util::make_unique<Plural>(); + + bool success = true; + while (XmlPullParser::isGoodEvent(parser->next())) { + if (parser->getEvent() != XmlPullParser::Event::kStartElement) { + continue; + } + + ScopedXmlPullParser childParser(parser); + + if (!childParser.getElementNamespace().empty() || + childParser.getElementName() != u"item") { + success = false; + continue; + } + + const auto endAttrIter = childParser.endAttributes(); + auto attrIter = childParser.findAttribute(u"", u"quantity"); + if (attrIter == endAttrIter || attrIter->value.empty()) { + mLogger.error(childParser.getLineNumber()) + << "<item> in <plurals> requires attribute 'quantity'." + << std::endl; + success = false; + continue; + } + + StringPiece16 trimmedQuantity = util::trimWhitespace(attrIter->value); + size_t index = 0; + if (trimmedQuantity == u"zero") { + index = Plural::Zero; + } else if (trimmedQuantity == u"one") { + index = Plural::One; + } else if (trimmedQuantity == u"two") { + index = Plural::Two; + } else if (trimmedQuantity == u"few") { + index = Plural::Few; + } else if (trimmedQuantity == u"many") { + index = Plural::Many; + } else if (trimmedQuantity == u"other") { + index = Plural::Other; + } else { + mLogger.error(childParser.getLineNumber()) + << "<item> in <plural> has invalid value '" + << trimmedQuantity + << "' for attribute 'quantity'." + << std::endl; + success = false; + continue; + } + + if (plural->values[index]) { + mLogger.error(childParser.getLineNumber()) + << "duplicate quantity '" + << trimmedQuantity + << "'." + << std::endl; + success = false; + continue; + } + + if (!(plural->values[index] = parseXml(&childParser, android::ResTable_map::TYPE_STRING, + kNoRawString))) { + success = false; + } + } + + if (!success) { + return false; + } + + return mTable->addResource(resourceName, mConfig, source, std::move(plural)); +} + +bool ResourceParser::parseDeclareStyleable(XmlPullParser* parser, + const ResourceNameRef& resourceName) { + const SourceLine source = mSource.line(parser->getLineNumber()); + std::unique_ptr<Styleable> styleable = util::make_unique<Styleable>(); + + bool success = true; + while (XmlPullParser::isGoodEvent(parser->next())) { + if (parser->getEvent() != XmlPullParser::Event::kStartElement) { + continue; + } + + ScopedXmlPullParser childParser(parser); + + const std::u16string& elementName = childParser.getElementName(); + if (elementName == u"attr") { + const auto endAttrIter = childParser.endAttributes(); + auto attrIter = childParser.findAttribute(u"", u"name"); + if (attrIter == endAttrIter || attrIter->value.empty()) { + mLogger.error(childParser.getLineNumber()) + << "<attr> tag must have a 'name' attribute." + << std::endl; + success = false; + continue; + } + + // Copy because our iterator will be invalidated. + ResourceName attrResourceName = { + mTable->getPackage(), + ResourceType::kAttr, + attrIter->value + }; + + std::unique_ptr<Attribute> attr = parseAttrImpl(&childParser, &attrResourceName, true); + if (!attr) { + success = false; + continue; + } + + styleable->entries.emplace_back(attrResourceName); + + // The package may have been corrected to another package. If that is so, + // we don't add the declaration. + if (attrResourceName.package == mTable->getPackage()) { + success &= mTable->addResource(attrResourceName, mConfig, + mSource.line(childParser.getLineNumber()), + std::move(attr)); + } + + } else if (elementName != u"eat-comment" && elementName != u"skip") { + mLogger.error(childParser.getLineNumber()) + << "<" + << elementName + << "> is not allowed inside <declare-styleable>." + << std::endl; + success = false; + } + } + + if (!success) { + return false; + } + + return mTable->addResource(resourceName, mConfig, source, std::move(styleable)); +} + +} // namespace aapt diff --git a/tools/aapt2/ResourceParser.h b/tools/aapt2/ResourceParser.h new file mode 100644 index 0000000..7618999 --- /dev/null +++ b/tools/aapt2/ResourceParser.h @@ -0,0 +1,195 @@ +/* + * 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_RESOURCE_PARSER_H +#define AAPT_RESOURCE_PARSER_H + +#include "ConfigDescription.h" +#include "Logger.h" +#include "ResourceTable.h" +#include "ResourceValues.h" +#include "StringPiece.h" +#include "StringPool.h" +#include "XmlPullParser.h" + +#include <istream> +#include <memory> + +namespace aapt { + +/* + * Parses an XML file for resources and adds them to a ResourceTable. + */ +class ResourceParser { +public: + /* + * Extracts the package, type, and name from a string of the format: + * + * [package:]type/name + * + * where the package can be empty. Validation must be performed on each + * individual extracted piece to verify that the pieces are valid. + */ + static void extractResourceName(const StringPiece16& str, StringPiece16* outPackage, + StringPiece16* outType, StringPiece16* outEntry); + + /* + * Returns true if the string was parsed as a reference (@[+][package:]type/name), with + * `outReference` set to the parsed reference. + * + * If '+' was present in the reference, `outCreate` is set to true. + * If '*' was present in the reference, `outPrivate` is set to true. + */ + static bool tryParseReference(const StringPiece16& str, ResourceNameRef* outReference, + bool* outCreate, bool* outPrivate); + + /* + * Returns true if the string was parsed as an attribute reference (?[package:]type/name), + * with `outReference` set to the parsed reference. + */ + static bool tryParseAttributeReference(const StringPiece16& str, + ResourceNameRef* outReference); + + /* + * Returns true if the string `str` was parsed as a valid reference to a style. + * The format for a style parent is slightly more flexible than a normal reference: + * + * @[package:]style/<entry> or + * ?[package:]style/<entry> or + * <package>:[style/]<entry> + */ + static bool parseStyleParentReference(const StringPiece16& str, Reference* outReference, + std::string* outError); + + /* + * Returns a Reference object if the string was parsed as a resource or attribute reference, + * ( @[+][package:]type/name | ?[package:]type/name ) setting outCreate to true if + * the '+' was present in the string. + */ + static std::unique_ptr<Reference> tryParseReference(const StringPiece16& str, + bool* outCreate); + + /* + * Returns a BinaryPrimitve object representing @null or @empty if the string was parsed + * as one. + */ + static std::unique_ptr<BinaryPrimitive> tryParseNullOrEmpty(const StringPiece16& str); + + /* + * Returns a BinaryPrimitve object representing a color if the string was parsed + * as one. + */ + static std::unique_ptr<BinaryPrimitive> tryParseColor(const StringPiece16& str); + + /* + * Returns a BinaryPrimitve object representing a boolean if the string was parsed + * as one. + */ + static std::unique_ptr<BinaryPrimitive> tryParseBool(const StringPiece16& str); + + /* + * Returns a BinaryPrimitve object representing an integer if the string was parsed + * as one. + */ + static std::unique_ptr<BinaryPrimitive> tryParseInt(const StringPiece16& str); + + /* + * Returns a BinaryPrimitve object representing a floating point number + * (float, dimension, etc) if the string was parsed as one. + */ + static std::unique_ptr<BinaryPrimitive> tryParseFloat(const StringPiece16& str); + + /* + * Returns a BinaryPrimitve object representing an enum symbol if the string was parsed + * as one. + */ + static std::unique_ptr<BinaryPrimitive> tryParseEnumSymbol(const Attribute& enumAttr, + const StringPiece16& str); + + /* + * Returns a BinaryPrimitve object representing a flag symbol if the string was parsed + * as one. + */ + static std::unique_ptr<BinaryPrimitive> tryParseFlagSymbol(const Attribute& enumAttr, + const StringPiece16& str); + /* + * Try to convert a string to an Item for the given attribute. The attribute will + * restrict what values the string can be converted to. + * The callback function onCreateReference is called when the parsed item is a + * reference to an ID that must be created (@+id/foo). + */ + static std::unique_ptr<Item> parseItemForAttribute( + const StringPiece16& value, const Attribute& attr, + std::function<void(const ResourceName&)> onCreateReference = {}); + + static std::unique_ptr<Item> parseItemForAttribute( + const StringPiece16& value, uint32_t typeMask, + std::function<void(const ResourceName&)> onCreateReference = {}); + + static uint32_t androidTypeToAttributeTypeMask(uint16_t type); + + ResourceParser(const std::shared_ptr<ResourceTable>& table, const Source& source, + const ConfigDescription& config, const std::shared_ptr<XmlPullParser>& parser); + + ResourceParser(const ResourceParser&) = delete; // No copy. + + bool parse(); + +private: + /* + * Parses the XML subtree as a StyleString (flattened XML representation for strings + * with formatting). If successful, `outStyleString` + * contains the escaped and whitespace trimmed text, while `outRawString` + * contains the unescaped text. Returns true on success. + */ + bool flattenXmlSubtree(XmlPullParser* parser, std::u16string* outRawString,\ + StyleString* outStyleString); + + /* + * Parses the XML subtree and converts it to an Item. The type of Item that can be + * parsed is denoted by the `typeMask`. If `allowRawValue` is true and the subtree + * can not be parsed as a regular Item, then a RawString is returned. Otherwise + * this returns nullptr. + */ + std::unique_ptr<Item> parseXml(XmlPullParser* parser, uint32_t typeMask, bool allowRawValue); + + bool parseResources(XmlPullParser* parser); + bool parseString(XmlPullParser* parser, const ResourceNameRef& resourceName); + bool parseColor(XmlPullParser* parser, const ResourceNameRef& resourceName); + bool parsePrimitive(XmlPullParser* parser, const ResourceNameRef& resourceName); + bool parsePublic(XmlPullParser* parser, const StringPiece16& name); + bool parseAttr(XmlPullParser* parser, const ResourceNameRef& resourceName); + std::unique_ptr<Attribute> parseAttrImpl(XmlPullParser* parser, + ResourceName* resourceName, + bool weak); + bool parseEnumOrFlagItem(XmlPullParser* parser, const StringPiece16& tag, + Attribute::Symbol* outSymbol); + bool parseStyle(XmlPullParser* parser, const ResourceNameRef& resourceName); + bool parseUntypedItem(XmlPullParser* parser, Style& style); + bool parseDeclareStyleable(XmlPullParser* parser, const ResourceNameRef& resourceName); + bool parseArray(XmlPullParser* parser, const ResourceNameRef& resourceName, uint32_t typeMask); + bool parsePlural(XmlPullParser* parser, const ResourceNameRef& resourceName); + + std::shared_ptr<ResourceTable> mTable; + Source mSource; + ConfigDescription mConfig; + SourceLogger mLogger; + std::shared_ptr<XmlPullParser> mParser; +}; + +} // namespace aapt + +#endif // AAPT_RESOURCE_PARSER_H diff --git a/tools/aapt2/ResourceParser_test.cpp b/tools/aapt2/ResourceParser_test.cpp new file mode 100644 index 0000000..a93d0ff --- /dev/null +++ b/tools/aapt2/ResourceParser_test.cpp @@ -0,0 +1,492 @@ +/* + * 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 "ResourceParser.h" +#include "ResourceTable.h" +#include "ResourceValues.h" +#include "SourceXmlPullParser.h" + +#include <gtest/gtest.h> +#include <sstream> +#include <string> + +namespace aapt { + +constexpr const char* kXmlPreamble = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"; + +TEST(ResourceParserReferenceTest, ParseReferenceWithNoPackage) { + ResourceNameRef expected = { {}, ResourceType::kColor, u"foo" }; + ResourceNameRef actual; + bool create = false; + bool privateRef = false; + EXPECT_TRUE(ResourceParser::tryParseReference(u"@color/foo", &actual, &create, &privateRef)); + EXPECT_EQ(expected, actual); + EXPECT_FALSE(create); + EXPECT_FALSE(privateRef); +} + +TEST(ResourceParserReferenceTest, ParseReferenceWithPackage) { + ResourceNameRef expected = { u"android", ResourceType::kColor, u"foo" }; + ResourceNameRef actual; + bool create = false; + bool privateRef = false; + EXPECT_TRUE(ResourceParser::tryParseReference(u"@android:color/foo", &actual, &create, + &privateRef)); + EXPECT_EQ(expected, actual); + EXPECT_FALSE(create); + EXPECT_FALSE(privateRef); +} + +TEST(ResourceParserReferenceTest, ParseReferenceWithSurroundingWhitespace) { + ResourceNameRef expected = { u"android", ResourceType::kColor, u"foo" }; + ResourceNameRef actual; + bool create = false; + bool privateRef = false; + EXPECT_TRUE(ResourceParser::tryParseReference(u"\t @android:color/foo\n \n\t", &actual, + &create, &privateRef)); + EXPECT_EQ(expected, actual); + EXPECT_FALSE(create); + EXPECT_FALSE(privateRef); +} + +TEST(ResourceParserReferenceTest, ParseAutoCreateIdReference) { + ResourceNameRef expected = { u"android", ResourceType::kId, u"foo" }; + ResourceNameRef actual; + bool create = false; + bool privateRef = false; + EXPECT_TRUE(ResourceParser::tryParseReference(u"@+android:id/foo", &actual, &create, + &privateRef)); + EXPECT_EQ(expected, actual); + EXPECT_TRUE(create); + EXPECT_FALSE(privateRef); +} + +TEST(ResourceParserReferenceTest, ParsePrivateReference) { + ResourceNameRef expected = { u"android", ResourceType::kId, u"foo" }; + ResourceNameRef actual; + bool create = false; + bool privateRef = false; + EXPECT_TRUE(ResourceParser::tryParseReference(u"@*android:id/foo", &actual, &create, + &privateRef)); + EXPECT_EQ(expected, actual); + EXPECT_FALSE(create); + EXPECT_TRUE(privateRef); +} + +TEST(ResourceParserReferenceTest, FailToParseAutoCreateNonIdReference) { + bool create = false; + bool privateRef = false; + ResourceNameRef actual; + EXPECT_FALSE(ResourceParser::tryParseReference(u"@+android:color/foo", &actual, &create, + &privateRef)); +} + +TEST(ResourceParserReferenceTest, ParseStyleParentReference) { + Reference ref; + std::string errStr; + EXPECT_TRUE(ResourceParser::parseStyleParentReference(u"@android:style/foo", &ref, &errStr)); + EXPECT_EQ(ref.name, (ResourceName{ u"android", ResourceType::kStyle, u"foo" })); + + EXPECT_TRUE(ResourceParser::parseStyleParentReference(u"@style/foo", &ref, &errStr)); + EXPECT_EQ(ref.name, (ResourceName{ {}, ResourceType::kStyle, u"foo" })); + + EXPECT_TRUE(ResourceParser::parseStyleParentReference(u"?android:style/foo", &ref, &errStr)); + EXPECT_EQ(ref.name, (ResourceName{ u"android", ResourceType::kStyle, u"foo" })); + + EXPECT_TRUE(ResourceParser::parseStyleParentReference(u"?style/foo", &ref, &errStr)); + EXPECT_EQ(ref.name, (ResourceName{ {}, ResourceType::kStyle, u"foo" })); + + EXPECT_TRUE(ResourceParser::parseStyleParentReference(u"android:style/foo", &ref, &errStr)); + EXPECT_EQ(ref.name, (ResourceName{ u"android", ResourceType::kStyle, u"foo" })); + + EXPECT_TRUE(ResourceParser::parseStyleParentReference(u"android:foo", &ref, &errStr)); + EXPECT_EQ(ref.name, (ResourceName{ u"android", ResourceType::kStyle, u"foo" })); + + EXPECT_TRUE(ResourceParser::parseStyleParentReference(u"foo", &ref, &errStr)); + EXPECT_EQ(ref.name, (ResourceName{ {}, ResourceType::kStyle, u"foo" })); +} + +struct ResourceParserTest : public ::testing::Test { + virtual void SetUp() override { + mTable = std::make_shared<ResourceTable>(); + mTable->setPackage(u"android"); + } + + ::testing::AssertionResult testParse(const StringPiece& str) { + std::stringstream input(kXmlPreamble); + input << "<resources>\n" << str << "\n</resources>" << std::endl; + ResourceParser parser(mTable, Source{ "test" }, {}, + std::make_shared<SourceXmlPullParser>(input)); + if (parser.parse()) { + return ::testing::AssertionSuccess(); + } + return ::testing::AssertionFailure(); + } + + template <typename T> + const T* findResource(const ResourceNameRef& name, const ConfigDescription& config) { + using std::begin; + using std::end; + + const ResourceTableType* type; + const ResourceEntry* entry; + std::tie(type, entry) = mTable->findResource(name); + if (!type || !entry) { + return nullptr; + } + + for (const auto& configValue : entry->values) { + if (configValue.config == config) { + return dynamic_cast<const T*>(configValue.value.get()); + } + } + return nullptr; + } + + template <typename T> + const T* findResource(const ResourceNameRef& name) { + return findResource<T>(name, {}); + } + + std::shared_ptr<ResourceTable> mTable; +}; + +TEST_F(ResourceParserTest, FailToParseWithNoRootResourcesElement) { + std::stringstream input(kXmlPreamble); + input << "<attr name=\"foo\"/>" << std::endl; + ResourceParser parser(mTable, {}, {}, std::make_shared<SourceXmlPullParser>(input)); + ASSERT_FALSE(parser.parse()); +} + +TEST_F(ResourceParserTest, ParseQuotedString) { + std::string input = "<string name=\"foo\"> \" hey there \" </string>"; + ASSERT_TRUE(testParse(input)); + + const String* str = findResource<String>(ResourceName{ + u"android", ResourceType::kString, u"foo"}); + ASSERT_NE(nullptr, str); + EXPECT_EQ(std::u16string(u" hey there "), *str->value); +} + +TEST_F(ResourceParserTest, ParseEscapedString) { + std::string input = "<string name=\"foo\">\\?123</string>"; + ASSERT_TRUE(testParse(input)); + + const String* str = findResource<String>(ResourceName{ + u"android", ResourceType::kString, u"foo" }); + ASSERT_NE(nullptr, str); + EXPECT_EQ(std::u16string(u"?123"), *str->value); +} + +TEST_F(ResourceParserTest, ParseNull) { + std::string input = "<integer name=\"foo\">@null</integer>"; + ASSERT_TRUE(testParse(input)); + + // The Android runtime treats a value of android::Res_value::TYPE_NULL as + // a non-existing value, and this causes problems in styles when trying to resolve + // an attribute. Null values must be encoded as android::Res_value::TYPE_REFERENCE + // with a data value of 0. + const BinaryPrimitive* integer = findResource<BinaryPrimitive>(ResourceName{ + u"android", ResourceType::kInteger, u"foo" }); + ASSERT_NE(nullptr, integer); + EXPECT_EQ(uint16_t(android::Res_value::TYPE_REFERENCE), integer->value.dataType); + EXPECT_EQ(0u, integer->value.data); +} + +TEST_F(ResourceParserTest, ParseEmpty) { + std::string input = "<integer name=\"foo\">@empty</integer>"; + ASSERT_TRUE(testParse(input)); + + const BinaryPrimitive* integer = findResource<BinaryPrimitive>(ResourceName{ + u"android", ResourceType::kInteger, u"foo" }); + ASSERT_NE(nullptr, integer); + EXPECT_EQ(uint16_t(android::Res_value::TYPE_NULL), integer->value.dataType); + EXPECT_EQ(uint32_t(android::Res_value::DATA_NULL_EMPTY), integer->value.data); +} + +TEST_F(ResourceParserTest, ParseAttr) { + std::string input = "<attr name=\"foo\" format=\"string\"/>\n" + "<attr name=\"bar\"/>"; + ASSERT_TRUE(testParse(input)); + + const Attribute* attr = findResource<Attribute>(ResourceName{ + u"android", ResourceType::kAttr, u"foo"}); + EXPECT_NE(nullptr, attr); + EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_STRING), attr->typeMask); + + attr = findResource<Attribute>(ResourceName{ + u"android", ResourceType::kAttr, u"bar"}); + EXPECT_NE(nullptr, attr); + EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_ANY), attr->typeMask); +} + +TEST_F(ResourceParserTest, ParseUseAndDeclOfAttr) { + std::string input = "<declare-styleable name=\"Styleable\">\n" + " <attr name=\"foo\" />\n" + "</declare-styleable>\n" + "<attr name=\"foo\" format=\"string\"/>"; + ASSERT_TRUE(testParse(input)); + + const Attribute* attr = findResource<Attribute>(ResourceName{ + u"android", ResourceType::kAttr, u"foo"}); + ASSERT_NE(nullptr, attr); + EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_STRING), attr->typeMask); +} + +TEST_F(ResourceParserTest, ParseDoubleUseOfAttr) { + std::string input = "<declare-styleable name=\"Theme\">" + " <attr name=\"foo\" />\n" + "</declare-styleable>\n" + "<declare-styleable name=\"Window\">\n" + " <attr name=\"foo\" format=\"boolean\"/>\n" + "</declare-styleable>"; + ASSERT_TRUE(testParse(input)); + + const Attribute* attr = findResource<Attribute>(ResourceName{ + u"android", ResourceType::kAttr, u"foo"}); + ASSERT_NE(nullptr, attr); + EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_BOOLEAN), attr->typeMask); +} + +TEST_F(ResourceParserTest, ParseEnumAttr) { + std::string input = "<attr name=\"foo\">\n" + " <enum name=\"bar\" value=\"0\"/>\n" + " <enum name=\"bat\" value=\"1\"/>\n" + " <enum name=\"baz\" value=\"2\"/>\n" + "</attr>"; + ASSERT_TRUE(testParse(input)); + + const Attribute* enumAttr = findResource<Attribute>(ResourceName{ + u"android", ResourceType::kAttr, u"foo"}); + ASSERT_NE(enumAttr, nullptr); + EXPECT_EQ(enumAttr->typeMask, android::ResTable_map::TYPE_ENUM); + ASSERT_EQ(enumAttr->symbols.size(), 3u); + + EXPECT_EQ(enumAttr->symbols[0].symbol.name.entry, u"bar"); + EXPECT_EQ(enumAttr->symbols[0].value, 0u); + + EXPECT_EQ(enumAttr->symbols[1].symbol.name.entry, u"bat"); + EXPECT_EQ(enumAttr->symbols[1].value, 1u); + + EXPECT_EQ(enumAttr->symbols[2].symbol.name.entry, u"baz"); + EXPECT_EQ(enumAttr->symbols[2].value, 2u); +} + +TEST_F(ResourceParserTest, ParseFlagAttr) { + std::string input = "<attr name=\"foo\">\n" + " <flag name=\"bar\" value=\"0\"/>\n" + " <flag name=\"bat\" value=\"1\"/>\n" + " <flag name=\"baz\" value=\"2\"/>\n" + "</attr>"; + ASSERT_TRUE(testParse(input)); + + const Attribute* flagAttr = findResource<Attribute>(ResourceName{ + u"android", ResourceType::kAttr, u"foo"}); + ASSERT_NE(flagAttr, nullptr); + EXPECT_EQ(flagAttr->typeMask, android::ResTable_map::TYPE_FLAGS); + ASSERT_EQ(flagAttr->symbols.size(), 3u); + + EXPECT_EQ(flagAttr->symbols[0].symbol.name.entry, u"bar"); + EXPECT_EQ(flagAttr->symbols[0].value, 0u); + + EXPECT_EQ(flagAttr->symbols[1].symbol.name.entry, u"bat"); + EXPECT_EQ(flagAttr->symbols[1].value, 1u); + + EXPECT_EQ(flagAttr->symbols[2].symbol.name.entry, u"baz"); + EXPECT_EQ(flagAttr->symbols[2].value, 2u); + + std::unique_ptr<BinaryPrimitive> flagValue = + ResourceParser::tryParseFlagSymbol(*flagAttr, u"baz|bat"); + ASSERT_NE(flagValue, nullptr); + EXPECT_EQ(flagValue->value.data, 1u | 2u); +} + +TEST_F(ResourceParserTest, FailToParseEnumAttrWithNonUniqueKeys) { + std::string input = "<attr name=\"foo\">\n" + " <enum name=\"bar\" value=\"0\"/>\n" + " <enum name=\"bat\" value=\"1\"/>\n" + " <enum name=\"bat\" value=\"2\"/>\n" + "</attr>"; + ASSERT_FALSE(testParse(input)); +} + +TEST_F(ResourceParserTest, ParseStyle) { + std::string input = "<style name=\"foo\" parent=\"@style/fu\">\n" + " <item name=\"bar\">#ffffffff</item>\n" + " <item name=\"bat\">@string/hey</item>\n" + " <item name=\"baz\"><b>hey</b></item>\n" + "</style>"; + ASSERT_TRUE(testParse(input)); + + const Style* style = findResource<Style>(ResourceName{ + u"android", ResourceType::kStyle, u"foo"}); + ASSERT_NE(style, nullptr); + EXPECT_EQ(ResourceNameRef(u"android", ResourceType::kStyle, u"fu"), style->parent.name); + ASSERT_EQ(style->entries.size(), 3u); + + EXPECT_EQ(style->entries[0].key.name, + (ResourceName{ u"android", ResourceType::kAttr, u"bar" })); + EXPECT_EQ(style->entries[1].key.name, + (ResourceName{ u"android", ResourceType::kAttr, u"bat" })); + EXPECT_EQ(style->entries[2].key.name, + (ResourceName{ u"android", ResourceType::kAttr, u"baz" })); +} + +TEST_F(ResourceParserTest, ParseStyleWithShorthandParent) { + std::string input = "<style name=\"foo\" parent=\"com.app:Theme\"/>"; + ASSERT_TRUE(testParse(input)); + + const Style* style = findResource<Style>( + ResourceName{ u"android", ResourceType::kStyle, u"foo" }); + ASSERT_NE(style, nullptr); + EXPECT_EQ(ResourceNameRef(u"com.app", ResourceType::kStyle, u"Theme"), style->parent.name); +} + +TEST_F(ResourceParserTest, ParseStyleWithPackageAliasedParent) { + std::string input = "<style xmlns:app=\"http://schemas.android.com/apk/res/android\"\n" + " name=\"foo\" parent=\"app:Theme\"/>"; + ASSERT_TRUE(testParse(input)); + + const Style* style = findResource<Style>(ResourceName{ + u"android", ResourceType::kStyle, u"foo" }); + ASSERT_NE(style, nullptr); + EXPECT_EQ(ResourceNameRef(u"android", ResourceType::kStyle, u"Theme"), style->parent.name); +} + +TEST_F(ResourceParserTest, ParseStyleWithPackageAliasedItems) { + std::string input = + "<style xmlns:app=\"http://schemas.android.com/apk/res/android\" name=\"foo\">\n" + " <item name=\"app:bar\">0</item>\n" + "</style>"; + ASSERT_TRUE(testParse(input)); + + const Style* style = findResource<Style>(ResourceName{ + u"android", ResourceType::kStyle, u"foo" }); + ASSERT_NE(style, nullptr); + ASSERT_EQ(1u, style->entries.size()); + EXPECT_EQ(ResourceNameRef(u"android", ResourceType::kAttr, u"bar"), + style->entries[0].key.name); +} + +TEST_F(ResourceParserTest, ParseStyleWithInferredParent) { + std::string input = "<style name=\"foo.bar\"/>"; + ASSERT_TRUE(testParse(input)); + + const Style* style = findResource<Style>(ResourceName{ + u"android", ResourceType::kStyle, u"foo.bar" }); + ASSERT_NE(style, nullptr); + EXPECT_EQ(style->parent.name, (ResourceName{ u"android", ResourceType::kStyle, u"foo" })); + EXPECT_TRUE(style->parentInferred); +} + +TEST_F(ResourceParserTest, ParseStyleWithInferredParentOverridenByEmptyParentAttribute) { + std::string input = "<style name=\"foo.bar\" parent=\"\"/>"; + ASSERT_TRUE(testParse(input)); + + const Style* style = findResource<Style>(ResourceName{ + u"android", ResourceType::kStyle, u"foo.bar" }); + ASSERT_NE(style, nullptr); + EXPECT_FALSE(style->parent.name.isValid()); + EXPECT_FALSE(style->parentInferred); +} + +TEST_F(ResourceParserTest, ParseAutoGeneratedIdReference) { + std::string input = "<string name=\"foo\">@+id/bar</string>"; + ASSERT_TRUE(testParse(input)); + + const Id* id = findResource<Id>(ResourceName{ u"android", ResourceType::kId, u"bar"}); + ASSERT_NE(id, nullptr); +} + +TEST_F(ResourceParserTest, ParseAttributesDeclareStyleable) { + std::string input = "<declare-styleable name=\"foo\">\n" + " <attr name=\"bar\" />\n" + " <attr name=\"bat\" format=\"string|reference\"/>\n" + "</declare-styleable>"; + ASSERT_TRUE(testParse(input)); + + const Attribute* attr = findResource<Attribute>(ResourceName{ + u"android", ResourceType::kAttr, u"bar"}); + ASSERT_NE(attr, nullptr); + EXPECT_TRUE(attr->isWeak()); + + attr = findResource<Attribute>(ResourceName{ u"android", ResourceType::kAttr, u"bat"}); + ASSERT_NE(attr, nullptr); + EXPECT_TRUE(attr->isWeak()); + + const Styleable* styleable = findResource<Styleable>(ResourceName{ + u"android", ResourceType::kStyleable, u"foo" }); + ASSERT_NE(styleable, nullptr); + ASSERT_EQ(2u, styleable->entries.size()); + + EXPECT_EQ((ResourceName{u"android", ResourceType::kAttr, u"bar"}), styleable->entries[0].name); + EXPECT_EQ((ResourceName{u"android", ResourceType::kAttr, u"bat"}), styleable->entries[1].name); +} + +TEST_F(ResourceParserTest, ParseArray) { + std::string input = "<array name=\"foo\">\n" + " <item>@string/ref</item>\n" + " <item>hey</item>\n" + " <item>23</item>\n" + "</array>"; + ASSERT_TRUE(testParse(input)); + + const Array* array = findResource<Array>(ResourceName{ + u"android", ResourceType::kArray, u"foo" }); + ASSERT_NE(array, nullptr); + ASSERT_EQ(3u, array->items.size()); + + EXPECT_NE(nullptr, dynamic_cast<const Reference*>(array->items[0].get())); + EXPECT_NE(nullptr, dynamic_cast<const String*>(array->items[1].get())); + EXPECT_NE(nullptr, dynamic_cast<const BinaryPrimitive*>(array->items[2].get())); +} + +TEST_F(ResourceParserTest, ParsePlural) { + std::string input = "<plurals name=\"foo\">\n" + " <item quantity=\"other\">apples</item>\n" + " <item quantity=\"one\">apple</item>\n" + "</plurals>"; + ASSERT_TRUE(testParse(input)); +} + +TEST_F(ResourceParserTest, ParseCommentsWithResource) { + std::string input = "<!-- This is a comment -->\n" + "<string name=\"foo\">Hi</string>"; + ASSERT_TRUE(testParse(input)); + + const ResourceTableType* type; + const ResourceEntry* entry; + std::tie(type, entry) = mTable->findResource(ResourceName{ + u"android", ResourceType::kString, u"foo"}); + ASSERT_NE(type, nullptr); + ASSERT_NE(entry, nullptr); + ASSERT_FALSE(entry->values.empty()); + EXPECT_EQ(entry->values.front().comment, u"This is a comment"); +} + +/* + * Declaring an ID as public should not require a separate definition + * (as an ID has no value). + */ +TEST_F(ResourceParserTest, ParsePublicIdAsDefinition) { + std::string input = "<public type=\"id\" name=\"foo\"/>"; + ASSERT_TRUE(testParse(input)); + + const Id* id = findResource<Id>(ResourceName{ u"android", ResourceType::kId, u"foo" }); + ASSERT_NE(nullptr, id); +} + +} // namespace aapt diff --git a/tools/aapt2/ResourceTable.cpp b/tools/aapt2/ResourceTable.cpp new file mode 100644 index 0000000..c93ecc7 --- /dev/null +++ b/tools/aapt2/ResourceTable.cpp @@ -0,0 +1,430 @@ +/* + * 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 "Logger.h" +#include "NameMangler.h" +#include "ResourceTable.h" +#include "ResourceValues.h" +#include "Util.h" + +#include <algorithm> +#include <androidfw/ResourceTypes.h> +#include <memory> +#include <string> +#include <tuple> + +namespace aapt { + +static bool compareConfigs(const ResourceConfigValue& lhs, const ConfigDescription& rhs) { + return lhs.config < rhs; +} + +static bool lessThanType(const std::unique_ptr<ResourceTableType>& lhs, ResourceType rhs) { + return lhs->type < rhs; +} + +static bool lessThanEntry(const std::unique_ptr<ResourceEntry>& lhs, const StringPiece16& rhs) { + return lhs->name.compare(0, lhs->name.size(), rhs.data(), rhs.size()) < 0; +} + +ResourceTable::ResourceTable() : mPackageId(kUnsetPackageId) { + // Make sure attrs always have type ID 1. + findOrCreateType(ResourceType::kAttr)->typeId = 1; +} + +std::unique_ptr<ResourceTableType>& ResourceTable::findOrCreateType(ResourceType type) { + auto last = mTypes.end(); + auto iter = std::lower_bound(mTypes.begin(), last, type, lessThanType); + if (iter != last) { + if ((*iter)->type == type) { + return *iter; + } + } + return *mTypes.emplace(iter, new ResourceTableType{ type }); +} + +std::unique_ptr<ResourceEntry>& ResourceTable::findOrCreateEntry( + std::unique_ptr<ResourceTableType>& type, const StringPiece16& name) { + auto last = type->entries.end(); + auto iter = std::lower_bound(type->entries.begin(), last, name, lessThanEntry); + if (iter != last) { + if (name == (*iter)->name) { + return *iter; + } + } + return *type->entries.emplace(iter, new ResourceEntry{ name }); +} + +struct IsAttributeVisitor : ConstValueVisitor { + bool isAttribute = false; + + void visit(const Attribute&, ValueVisitorArgs&) override { + isAttribute = true; + } + + operator bool() { + return isAttribute; + } +}; + +/** + * The default handler for collisions. A return value of -1 means keep the + * existing value, 0 means fail, and +1 means take the incoming value. + */ +static int defaultCollisionHandler(const Value& existing, const Value& incoming) { + IsAttributeVisitor existingIsAttr, incomingIsAttr; + existing.accept(existingIsAttr, {}); + incoming.accept(incomingIsAttr, {}); + + if (!incomingIsAttr) { + if (incoming.isWeak()) { + // We're trying to add a weak resource but a resource + // already exists. Keep the existing. + return -1; + } else if (existing.isWeak()) { + // Override the weak resource with the new strong resource. + return 1; + } + // The existing and incoming values are strong, this is an error + // if the values are not both attributes. + return 0; + } + + if (!existingIsAttr) { + if (existing.isWeak()) { + // The existing value is not an attribute and it is weak, + // so take the incoming attribute value. + return 1; + } + // The existing value is not an attribute and it is strong, + // so the incoming attribute value is an error. + return 0; + } + + // + // Attribute specific handling. At this point we know both + // values are attributes. Since we can declare and define + // attributes all-over, we do special handling to see + // which definition sticks. + // + const Attribute& existingAttr = static_cast<const Attribute&>(existing); + const Attribute& incomingAttr = static_cast<const Attribute&>(incoming); + if (existingAttr.typeMask == incomingAttr.typeMask) { + // The two attributes are both DECLs, but they are plain attributes + // with the same formats. + // Keep the strongest one. + return existingAttr.isWeak() ? 1 : -1; + } + + if (existingAttr.isWeak() && existingAttr.typeMask == android::ResTable_map::TYPE_ANY) { + // Any incoming attribute is better than this. + return 1; + } + + if (incomingAttr.isWeak() && incomingAttr.typeMask == android::ResTable_map::TYPE_ANY) { + // The incoming attribute may be a USE instead of a DECL. + // Keep the existing attribute. + return -1; + } + return 0; +} + +static constexpr const char16_t* kValidNameChars = u"._-"; +static constexpr const char16_t* kValidNameMangledChars = u"._-$"; + +bool ResourceTable::addResource(const ResourceNameRef& name, const ConfigDescription& config, + const SourceLine& source, std::unique_ptr<Value> value) { + return addResourceImpl(name, ResourceId{}, config, source, std::move(value), kValidNameChars); +} + +bool ResourceTable::addResource(const ResourceNameRef& name, const ResourceId resId, + const ConfigDescription& config, const SourceLine& source, + std::unique_ptr<Value> value) { + return addResourceImpl(name, resId, config, source, std::move(value), kValidNameChars); +} + +bool ResourceTable::addResourceAllowMangled(const ResourceNameRef& name, + const ConfigDescription& config, + const SourceLine& source, + std::unique_ptr<Value> value) { + return addResourceImpl(name, ResourceId{}, config, source, std::move(value), + kValidNameMangledChars); +} + +bool ResourceTable::addResourceImpl(const ResourceNameRef& name, const ResourceId resId, + const ConfigDescription& config, const SourceLine& source, + std::unique_ptr<Value> value, const char16_t* validChars) { + if (!name.package.empty() && name.package != mPackage) { + Logger::error(source) + << "resource '" + << name + << "' has incompatible package. Must be '" + << mPackage + << "'." + << std::endl; + return false; + } + + auto badCharIter = util::findNonAlphaNumericAndNotInSet(name.entry, validChars); + if (badCharIter != name.entry.end()) { + Logger::error(source) + << "resource '" + << name + << "' has invalid entry name '" + << name.entry + << "'. Invalid character '" + << StringPiece16(badCharIter, 1) + << "'." + << std::endl; + return false; + } + + std::unique_ptr<ResourceTableType>& type = findOrCreateType(name.type); + if (resId.isValid() && type->typeId != ResourceTableType::kUnsetTypeId && + type->typeId != resId.typeId()) { + Logger::error(source) + << "trying to add resource '" + << name + << "' with ID " + << resId + << " but type '" + << type->type + << "' already has ID " + << std::hex << type->typeId << std::dec + << "." + << std::endl; + return false; + } + + std::unique_ptr<ResourceEntry>& entry = findOrCreateEntry(type, name.entry); + if (resId.isValid() && entry->entryId != ResourceEntry::kUnsetEntryId && + entry->entryId != resId.entryId()) { + Logger::error(source) + << "trying to add resource '" + << name + << "' with ID " + << resId + << " but resource already has ID " + << ResourceId(mPackageId, type->typeId, entry->entryId) + << "." + << std::endl; + return false; + } + + const auto endIter = std::end(entry->values); + auto iter = std::lower_bound(std::begin(entry->values), endIter, config, compareConfigs); + if (iter == endIter || iter->config != config) { + // This resource did not exist before, add it. + entry->values.insert(iter, ResourceConfigValue{ config, source, {}, std::move(value) }); + } else { + int collisionResult = defaultCollisionHandler(*iter->value, *value); + if (collisionResult > 0) { + // Take the incoming value. + *iter = ResourceConfigValue{ config, source, {}, std::move(value) }; + } else if (collisionResult == 0) { + Logger::error(source) + << "duplicate value for resource '" << name << "' " + << "with config '" << iter->config << "'." + << std::endl; + + Logger::error(iter->source) + << "resource previously defined here." + << std::endl; + return false; + } + } + + if (resId.isValid()) { + type->typeId = resId.typeId(); + entry->entryId = resId.entryId(); + } + return true; +} + +bool ResourceTable::markPublic(const ResourceNameRef& name, const ResourceId resId, + const SourceLine& source) { + return markPublicImpl(name, resId, source, kValidNameChars); +} + +bool ResourceTable::markPublicAllowMangled(const ResourceNameRef& name, const ResourceId resId, + const SourceLine& source) { + return markPublicImpl(name, resId, source, kValidNameMangledChars); +} + +bool ResourceTable::markPublicImpl(const ResourceNameRef& name, const ResourceId resId, + const SourceLine& source, const char16_t* validChars) { + if (!name.package.empty() && name.package != mPackage) { + Logger::error(source) + << "resource '" + << name + << "' has incompatible package. Must be '" + << mPackage + << "'." + << std::endl; + return false; + } + + auto badCharIter = util::findNonAlphaNumericAndNotInSet(name.entry, validChars); + if (badCharIter != name.entry.end()) { + Logger::error(source) + << "resource '" + << name + << "' has invalid entry name '" + << name.entry + << "'. Invalid character '" + << StringPiece16(badCharIter, 1) + << "'." + << std::endl; + return false; + } + + std::unique_ptr<ResourceTableType>& type = findOrCreateType(name.type); + if (resId.isValid() && type->typeId != ResourceTableType::kUnsetTypeId && + type->typeId != resId.typeId()) { + Logger::error(source) + << "trying to make resource '" + << name + << "' public with ID " + << resId + << " but type '" + << type->type + << "' already has ID " + << std::hex << type->typeId << std::dec + << "." + << std::endl; + return false; + } + + std::unique_ptr<ResourceEntry>& entry = findOrCreateEntry(type, name.entry); + if (resId.isValid() && entry->entryId != ResourceEntry::kUnsetEntryId && + entry->entryId != resId.entryId()) { + Logger::error(source) + << "trying to make resource '" + << name + << "' public with ID " + << resId + << " but resource already has ID " + << ResourceId(mPackageId, type->typeId, entry->entryId) + << "." + << std::endl; + return false; + } + + type->publicStatus.isPublic = true; + entry->publicStatus.isPublic = true; + entry->publicStatus.source = source; + + if (resId.isValid()) { + type->typeId = resId.typeId(); + entry->entryId = resId.entryId(); + } + return true; +} + +bool ResourceTable::merge(ResourceTable&& other) { + const bool mangleNames = mPackage != other.getPackage(); + std::u16string mangledName; + + for (auto& otherType : other) { + std::unique_ptr<ResourceTableType>& type = findOrCreateType(otherType->type); + if (otherType->publicStatus.isPublic) { + if (type->publicStatus.isPublic && type->typeId != otherType->typeId) { + Logger::error() << "can not merge type '" << type->type + << "': conflicting public IDs " + << "(" << type->typeId << " vs " << otherType->typeId << ")." + << std::endl; + return false; + } + type->publicStatus = std::move(otherType->publicStatus); + type->typeId = otherType->typeId; + } + + for (auto& otherEntry : otherType->entries) { + const std::u16string* nameToAdd = &otherEntry->name; + if (mangleNames) { + mangledName = otherEntry->name; + NameMangler::mangle(other.getPackage(), &mangledName); + nameToAdd = &mangledName; + } + + std::unique_ptr<ResourceEntry>& entry = findOrCreateEntry(type, *nameToAdd); + if (otherEntry->publicStatus.isPublic) { + if (entry->publicStatus.isPublic && entry->entryId != otherEntry->entryId) { + Logger::error() << "can not merge entry '" << type->type << "/" << entry->name + << "': conflicting public IDs " + << "(" << entry->entryId << " vs " << entry->entryId << ")." + << std::endl; + return false; + } + entry->publicStatus = std::move(otherEntry->publicStatus); + entry->entryId = otherEntry->entryId; + } + + for (ResourceConfigValue& otherValue : otherEntry->values) { + auto iter = std::lower_bound(entry->values.begin(), entry->values.end(), + otherValue.config, compareConfigs); + if (iter != entry->values.end() && iter->config == otherValue.config) { + int collisionResult = defaultCollisionHandler(*iter->value, *otherValue.value); + if (collisionResult > 0) { + // Take the incoming value. + iter->source = std::move(otherValue.source); + iter->comment = std::move(otherValue.comment); + iter->value = std::unique_ptr<Value>(otherValue.value->clone(&mValuePool)); + } else if (collisionResult == 0) { + ResourceNameRef resourceName = { mPackage, type->type, entry->name }; + Logger::error(otherValue.source) + << "resource '" << resourceName << "' has a conflicting value for " + << "configuration (" << otherValue.config << ")." + << std::endl; + Logger::note(iter->source) << "originally defined here." << std::endl; + return false; + } + } else { + entry->values.insert(iter, ResourceConfigValue{ + otherValue.config, + std::move(otherValue.source), + std::move(otherValue.comment), + std::unique_ptr<Value>(otherValue.value->clone(&mValuePool)), + }); + } + } + } + } + return true; +} + +std::tuple<const ResourceTableType*, const ResourceEntry*> +ResourceTable::findResource(const ResourceNameRef& name) const { + if (name.package != mPackage) { + return {}; + } + + auto iter = std::lower_bound(mTypes.begin(), mTypes.end(), name.type, lessThanType); + if (iter == mTypes.end() || (*iter)->type != name.type) { + return {}; + } + + const std::unique_ptr<ResourceTableType>& type = *iter; + auto iter2 = std::lower_bound(type->entries.begin(), type->entries.end(), name.entry, + lessThanEntry); + if (iter2 == type->entries.end() || name.entry != (*iter2)->name) { + return {}; + } + return std::make_tuple(iter->get(), iter2->get()); +} + +} // namespace aapt diff --git a/tools/aapt2/ResourceTable.h b/tools/aapt2/ResourceTable.h new file mode 100644 index 0000000..706f56a --- /dev/null +++ b/tools/aapt2/ResourceTable.h @@ -0,0 +1,277 @@ +/* + * 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_RESOURCE_TABLE_H +#define AAPT_RESOURCE_TABLE_H + +#include "ConfigDescription.h" +#include "Resource.h" +#include "ResourceValues.h" +#include "Source.h" +#include "StringPool.h" + +#include <memory> +#include <string> +#include <tuple> +#include <vector> + +namespace aapt { + +/** + * The Public status of a resource. + */ +struct Public { + bool isPublic = false; + SourceLine source; + std::u16string comment; +}; + +/** + * The resource value for a specific configuration. + */ +struct ResourceConfigValue { + ConfigDescription config; + SourceLine source; + std::u16string comment; + std::unique_ptr<Value> value; +}; + +/** + * Represents a resource entry, which may have + * varying values for each defined configuration. + */ +struct ResourceEntry { + enum { + kUnsetEntryId = 0xffffffffu + }; + + /** + * The name of the resource. Immutable, as + * this determines the order of this resource + * when doing lookups. + */ + const std::u16string name; + + /** + * The entry ID for this resource. + */ + size_t entryId; + + /** + * Whether this resource is public (and must maintain the same + * entry ID across builds). + */ + Public publicStatus; + + /** + * The resource's values for each configuration. + */ + std::vector<ResourceConfigValue> values; + + inline ResourceEntry(const StringPiece16& _name); + inline ResourceEntry(const ResourceEntry* rhs); +}; + +/** + * Represents a resource type, which holds entries defined + * for this type. + */ +struct ResourceTableType { + enum { + kUnsetTypeId = 0xffffffffu + }; + + /** + * The logical type of resource (string, drawable, layout, etc.). + */ + const ResourceType type; + + /** + * The type ID for this resource. + */ + size_t typeId; + + /** + * Whether this type is public (and must maintain the same + * type ID across builds). + */ + Public publicStatus; + + /** + * List of resources for this type. + */ + std::vector<std::unique_ptr<ResourceEntry>> entries; + + ResourceTableType(const ResourceType _type); + ResourceTableType(const ResourceTableType* rhs); +}; + +/** + * The container and index for all resources defined for an app. This gets + * flattened into a binary resource table (resources.arsc). + */ +class ResourceTable { +public: + using iterator = std::vector<std::unique_ptr<ResourceTableType>>::iterator; + using const_iterator = std::vector<std::unique_ptr<ResourceTableType>>::const_iterator; + + enum { + kUnsetPackageId = 0xffffffff + }; + + ResourceTable(); + + size_t getPackageId() const; + void setPackageId(size_t packageId); + + const std::u16string& getPackage() const; + void setPackage(const StringPiece16& package); + + bool addResource(const ResourceNameRef& name, const ConfigDescription& config, + const SourceLine& source, std::unique_ptr<Value> value); + + /** + * Same as addResource, but doesn't verify the validity of the name. This is used + * when loading resources from an existing binary resource table that may have mangled + * names. + */ + bool addResourceAllowMangled(const ResourceNameRef& name, const ConfigDescription& config, + const SourceLine& source, std::unique_ptr<Value> value); + + bool addResource(const ResourceNameRef& name, const ResourceId resId, + const ConfigDescription& config, const SourceLine& source, + std::unique_ptr<Value> value); + + bool markPublic(const ResourceNameRef& name, const ResourceId resId, const SourceLine& source); + bool markPublicAllowMangled(const ResourceNameRef& name, const ResourceId resId, + const SourceLine& source); + + /* + * Merges the resources from `other` into this table, mangling the names of the resources + * if `other` has a different package name. + */ + bool merge(ResourceTable&& other); + + /** + * Returns the string pool used by this ResourceTable. + * Values that reference strings should use this pool to create + * their strings. + */ + StringPool& getValueStringPool(); + const StringPool& getValueStringPool() const; + + std::tuple<const ResourceTableType*, const ResourceEntry*> + findResource(const ResourceNameRef& name) const; + + iterator begin(); + iterator end(); + const_iterator begin() const; + const_iterator end() const; + +private: + std::unique_ptr<ResourceTableType>& findOrCreateType(ResourceType type); + std::unique_ptr<ResourceEntry>& findOrCreateEntry(std::unique_ptr<ResourceTableType>& type, + const StringPiece16& name); + + bool addResourceImpl(const ResourceNameRef& name, const ResourceId resId, + const ConfigDescription& config, const SourceLine& source, + std::unique_ptr<Value> value, const char16_t* validChars); + bool markPublicImpl(const ResourceNameRef& name, const ResourceId resId, + const SourceLine& source, const char16_t* validChars); + + std::u16string mPackage; + size_t mPackageId; + + // StringPool must come before mTypes so that it is destroyed after. + // When StringPool references are destroyed (as they will be when mTypes + // is destroyed), they decrement a refCount, which would cause invalid + // memory access if the pool was already destroyed. + StringPool mValuePool; + + std::vector<std::unique_ptr<ResourceTableType>> mTypes; +}; + +// +// ResourceEntry implementation. +// + +inline ResourceEntry::ResourceEntry(const StringPiece16& _name) : + name(_name.toString()), entryId(kUnsetEntryId) { +} + +inline ResourceEntry::ResourceEntry(const ResourceEntry* rhs) : + name(rhs->name), entryId(rhs->entryId), publicStatus(rhs->publicStatus) { +} + +// +// ResourceTableType implementation. +// + +inline ResourceTableType::ResourceTableType(const ResourceType _type) : + type(_type), typeId(kUnsetTypeId) { +} + +inline ResourceTableType::ResourceTableType(const ResourceTableType* rhs) : + type(rhs->type), typeId(rhs->typeId), publicStatus(rhs->publicStatus) { +} + +// +// ResourceTable implementation. +// + +inline StringPool& ResourceTable::getValueStringPool() { + return mValuePool; +} + +inline const StringPool& ResourceTable::getValueStringPool() const { + return mValuePool; +} + +inline ResourceTable::iterator ResourceTable::begin() { + return mTypes.begin(); +} + +inline ResourceTable::iterator ResourceTable::end() { + return mTypes.end(); +} + +inline ResourceTable::const_iterator ResourceTable::begin() const { + return mTypes.begin(); +} + +inline ResourceTable::const_iterator ResourceTable::end() const { + return mTypes.end(); +} + +inline const std::u16string& ResourceTable::getPackage() const { + return mPackage; +} + +inline size_t ResourceTable::getPackageId() const { + return mPackageId; +} + +inline void ResourceTable::setPackage(const StringPiece16& package) { + mPackage = package.toString(); +} + +inline void ResourceTable::setPackageId(size_t packageId) { + mPackageId = packageId; +} + +} // namespace aapt + +#endif // AAPT_RESOURCE_TABLE_H diff --git a/tools/aapt2/ResourceTableResolver.cpp b/tools/aapt2/ResourceTableResolver.cpp new file mode 100644 index 0000000..910c2c0 --- /dev/null +++ b/tools/aapt2/ResourceTableResolver.cpp @@ -0,0 +1,202 @@ +/* + * 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 "Maybe.h" +#include "NameMangler.h" +#include "Resource.h" +#include "ResourceTable.h" +#include "ResourceTableResolver.h" +#include "ResourceValues.h" +#include "Util.h" + +#include <androidfw/AssetManager.h> +#include <androidfw/ResourceTypes.h> +#include <memory> +#include <vector> + +namespace aapt { + +ResourceTableResolver::ResourceTableResolver( + std::shared_ptr<const ResourceTable> table, + const std::vector<std::shared_ptr<const android::AssetManager>>& sources) : + mTable(table), mSources(sources) { + for (const auto& assetManager : mSources) { + const android::ResTable& resTable = assetManager->getResources(false); + const size_t packageCount = resTable.getBasePackageCount(); + for (size_t i = 0; i < packageCount; i++) { + std::u16string packageName = resTable.getBasePackageName(i).string(); + mIncludedPackages.insert(std::move(packageName)); + } + } +} + +Maybe<ResourceId> ResourceTableResolver::findId(const ResourceName& name) { + Maybe<Entry> result = findAttribute(name); + if (result) { + return result.value().id; + } + return {}; +} + +Maybe<IResolver::Entry> ResourceTableResolver::findAttribute(const ResourceName& name) { + auto cacheIter = mCache.find(name); + if (cacheIter != std::end(mCache)) { + return Entry{ cacheIter->second.id, cacheIter->second.attr.get() }; + } + + ResourceName mangledName; + const ResourceName* nameToSearch = &name; + if (name.package != mTable->getPackage()) { + // This may be a reference to an included resource or + // to a mangled resource. + if (mIncludedPackages.find(name.package) == mIncludedPackages.end()) { + // This is not in our included set, so mangle the name and + // check for that. + mangledName.entry = name.entry; + NameMangler::mangle(name.package, &mangledName.entry); + mangledName.package = mTable->getPackage(); + mangledName.type = name.type; + nameToSearch = &mangledName; + } else { + const CacheEntry* cacheEntry = buildCacheEntry(name); + if (cacheEntry) { + return Entry{ cacheEntry->id, cacheEntry->attr.get() }; + } + return {}; + } + } + + const ResourceTableType* type; + const ResourceEntry* entry; + std::tie(type, entry) = mTable->findResource(*nameToSearch); + if (type && entry) { + Entry result = {}; + if (mTable->getPackageId() != ResourceTable::kUnsetPackageId && + type->typeId != ResourceTableType::kUnsetTypeId && + entry->entryId != ResourceEntry::kUnsetEntryId) { + result.id = ResourceId(mTable->getPackageId(), type->typeId, entry->entryId); + } + + if (!entry->values.empty()) { + visitFunc<Attribute>(*entry->values.front().value, [&result](Attribute& attr) { + result.attr = &attr; + }); + } + return result; + } + return {}; +} + +Maybe<ResourceName> ResourceTableResolver::findName(ResourceId resId) { + for (const auto& assetManager : mSources) { + const android::ResTable& table = assetManager->getResources(false); + + android::ResTable::resource_name resourceName; + if (!table.getResourceName(resId.id, false, &resourceName)) { + continue; + } + + const ResourceType* type = parseResourceType(StringPiece16(resourceName.type, + resourceName.typeLen)); + assert(type); + return ResourceName{ + { resourceName.package, resourceName.packageLen }, + *type, + { resourceName.name, resourceName.nameLen } }; + } + return {}; +} + +/** + * This is called when we need to lookup a resource name in the AssetManager. + * Since the values in the AssetManager are not parsed like in a ResourceTable, + * we must create Attribute objects here if we find them. + */ +const ResourceTableResolver::CacheEntry* ResourceTableResolver::buildCacheEntry( + const ResourceName& name) { + for (const auto& assetManager : mSources) { + const android::ResTable& table = assetManager->getResources(false); + + const StringPiece16 type16 = toString(name.type); + ResourceId resId { + table.identifierForName( + name.entry.data(), name.entry.size(), + type16.data(), type16.size(), + name.package.data(), name.package.size()) + }; + + if (!resId.isValid()) { + continue; + } + + CacheEntry& entry = mCache[name]; + entry.id = resId; + + // + // Now check to see if this resource is an Attribute. + // + + const android::ResTable::bag_entry* bagBegin; + ssize_t bags = table.lockBag(resId.id, &bagBegin); + if (bags < 1) { + table.unlockBag(bagBegin); + return &entry; + } + + // Look for the ATTR_TYPE key in the bag and check the types it supports. + uint32_t attrTypeMask = 0; + for (ssize_t i = 0; i < bags; i++) { + if (bagBegin[i].map.name.ident == android::ResTable_map::ATTR_TYPE) { + attrTypeMask = bagBegin[i].map.value.data; + } + } + + entry.attr = util::make_unique<Attribute>(false); + + if (attrTypeMask & android::ResTable_map::TYPE_ENUM || + attrTypeMask & android::ResTable_map::TYPE_FLAGS) { + for (ssize_t i = 0; i < bags; i++) { + if (Res_INTERNALID(bagBegin[i].map.name.ident)) { + // Internal IDs are special keys, which are not enum/flag symbols, so skip. + continue; + } + + android::ResTable::resource_name symbolName; + bool result = table.getResourceName(bagBegin[i].map.name.ident, false, + &symbolName); + assert(result); + const ResourceType* type = parseResourceType( + StringPiece16(symbolName.type, symbolName.typeLen)); + assert(type); + + entry.attr->symbols.push_back(Attribute::Symbol{ + Reference(ResourceNameRef( + StringPiece16(symbolName.package, symbolName.packageLen), + *type, + StringPiece16(symbolName.name, symbolName.nameLen))), + bagBegin[i].map.value.data + }); + } + } + + entry.attr->typeMask |= attrTypeMask; + table.unlockBag(bagBegin); + return &entry; + } + return nullptr; +} + +} // namespace aapt diff --git a/tools/aapt2/ResourceTableResolver.h b/tools/aapt2/ResourceTableResolver.h new file mode 100644 index 0000000..8f6b0b5 --- /dev/null +++ b/tools/aapt2/ResourceTableResolver.h @@ -0,0 +1,70 @@ +/* + * 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_RESOURCE_TABLE_RESOLVER_H +#define AAPT_RESOURCE_TABLE_RESOLVER_H + +#include "Maybe.h" +#include "Resolver.h" +#include "Resource.h" +#include "ResourceTable.h" +#include "ResourceValues.h" + +#include <androidfw/AssetManager.h> +#include <memory> +#include <vector> +#include <unordered_set> + +namespace aapt { + +/** + * Encapsulates the search of library sources as well as the local ResourceTable. + */ +class ResourceTableResolver : public IResolver { +public: + /** + * Creates a resolver with a local ResourceTable and an AssetManager + * loaded with library packages. + */ + ResourceTableResolver( + std::shared_ptr<const ResourceTable> table, + const std::vector<std::shared_ptr<const android::AssetManager>>& sources); + + ResourceTableResolver(const ResourceTableResolver&) = delete; // Not copyable. + + virtual Maybe<ResourceId> findId(const ResourceName& name) override; + + virtual Maybe<Entry> findAttribute(const ResourceName& name) override; + + virtual Maybe<ResourceName> findName(ResourceId resId) override; + +private: + struct CacheEntry { + ResourceId id; + std::unique_ptr<Attribute> attr; + }; + + const CacheEntry* buildCacheEntry(const ResourceName& name); + + std::shared_ptr<const ResourceTable> mTable; + std::vector<std::shared_ptr<const android::AssetManager>> mSources; + std::map<ResourceName, CacheEntry> mCache; + std::unordered_set<std::u16string> mIncludedPackages; +}; + +} // namespace aapt + +#endif // AAPT_RESOURCE_TABLE_RESOLVER_H diff --git a/tools/aapt2/ResourceTable_test.cpp b/tools/aapt2/ResourceTable_test.cpp new file mode 100644 index 0000000..06d8699 --- /dev/null +++ b/tools/aapt2/ResourceTable_test.cpp @@ -0,0 +1,228 @@ +/* + * 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 "ResourceTable.h" +#include "ResourceValues.h" +#include "Util.h" + +#include <algorithm> +#include <gtest/gtest.h> +#include <ostream> +#include <string> + +namespace aapt { + +struct TestValue : public Value { + std::u16string value; + + TestValue(StringPiece16 str) : value(str.toString()) { + } + + TestValue* clone(StringPool* /*newPool*/) const override { + return new TestValue(value); + } + + void print(std::ostream& out) const override { + out << "(test) " << value; + } + + virtual void accept(ValueVisitor&, ValueVisitorArgs&&) override {} + virtual void accept(ConstValueVisitor&, ValueVisitorArgs&&) const override {} +}; + +struct TestWeakValue : public Value { + bool isWeak() const override { + return true; + } + + TestWeakValue* clone(StringPool* /*newPool*/) const override { + return new TestWeakValue(); + } + + void print(std::ostream& out) const override { + out << "(test) [weak]"; + } + + virtual void accept(ValueVisitor&, ValueVisitorArgs&&) override {} + virtual void accept(ConstValueVisitor&, ValueVisitorArgs&&) const override {} +}; + +TEST(ResourceTableTest, FailToAddResourceWithBadName) { + ResourceTable table; + table.setPackage(u"android"); + + EXPECT_FALSE(table.addResource( + ResourceNameRef{ u"android", ResourceType::kId, u"hey,there" }, + {}, SourceLine{ "test.xml", 21 }, + util::make_unique<TestValue>(u"rawValue"))); + + EXPECT_FALSE(table.addResource( + ResourceNameRef{ u"android", ResourceType::kId, u"hey:there" }, + {}, SourceLine{ "test.xml", 21 }, + util::make_unique<TestValue>(u"rawValue"))); +} + +TEST(ResourceTableTest, AddOneResource) { + const std::u16string kAndroidPackage = u"android"; + + ResourceTable table; + table.setPackage(kAndroidPackage); + + const ResourceName name = { kAndroidPackage, ResourceType::kAttr, u"id" }; + + EXPECT_TRUE(table.addResource(name, {}, SourceLine{ "test/path/file.xml", 23 }, + util::make_unique<TestValue>(u"rawValue"))); + + const ResourceTableType* type; + const ResourceEntry* entry; + std::tie(type, entry) = table.findResource(name); + ASSERT_NE(nullptr, type); + ASSERT_NE(nullptr, entry); + EXPECT_EQ(name.entry, entry->name); + + ASSERT_NE(std::end(entry->values), + std::find_if(std::begin(entry->values), std::end(entry->values), + [](const ResourceConfigValue& val) -> bool { + return val.config == ConfigDescription{}; + })); +} + +TEST(ResourceTableTest, AddMultipleResources) { + const std::u16string kAndroidPackage = u"android"; + ResourceTable table; + table.setPackage(kAndroidPackage); + + ConfigDescription config; + ConfigDescription languageConfig; + memcpy(languageConfig.language, "pl", sizeof(languageConfig.language)); + + EXPECT_TRUE(table.addResource( + ResourceName{ kAndroidPackage, ResourceType::kAttr, u"layout_width" }, + config, SourceLine{ "test/path/file.xml", 10 }, + util::make_unique<TestValue>(u"rawValue"))); + + EXPECT_TRUE(table.addResource( + ResourceName{ kAndroidPackage, ResourceType::kAttr, u"id" }, + config, SourceLine{ "test/path/file.xml", 12 }, + util::make_unique<TestValue>(u"rawValue"))); + + EXPECT_TRUE(table.addResource( + ResourceName{ kAndroidPackage, ResourceType::kString, u"ok" }, + config, SourceLine{ "test/path/file.xml", 14 }, + util::make_unique<TestValue>(u"Ok"))); + + EXPECT_TRUE(table.addResource( + ResourceName{ kAndroidPackage, ResourceType::kString, u"ok" }, + languageConfig, SourceLine{ "test/path/file.xml", 20 }, + util::make_unique<TestValue>(u"Tak"))); + + const auto endTypeIter = std::end(table); + auto typeIter = std::begin(table); + + ASSERT_NE(endTypeIter, typeIter); + EXPECT_EQ(ResourceType::kAttr, (*typeIter)->type); + + { + const std::unique_ptr<ResourceTableType>& type = *typeIter; + const auto endEntryIter = std::end(type->entries); + auto entryIter = std::begin(type->entries); + ASSERT_NE(endEntryIter, entryIter); + EXPECT_EQ(std::u16string(u"id"), (*entryIter)->name); + + ++entryIter; + ASSERT_NE(endEntryIter, entryIter); + EXPECT_EQ(std::u16string(u"layout_width"), (*entryIter)->name); + + ++entryIter; + ASSERT_EQ(endEntryIter, entryIter); + } + + ++typeIter; + ASSERT_NE(endTypeIter, typeIter); + EXPECT_EQ(ResourceType::kString, (*typeIter)->type); + + { + const std::unique_ptr<ResourceTableType>& type = *typeIter; + const auto endEntryIter = std::end(type->entries); + auto entryIter = std::begin(type->entries); + ASSERT_NE(endEntryIter, entryIter); + EXPECT_EQ(std::u16string(u"ok"), (*entryIter)->name); + + { + const std::unique_ptr<ResourceEntry>& entry = *entryIter; + const auto endConfigIter = std::end(entry->values); + auto configIter = std::begin(entry->values); + + ASSERT_NE(endConfigIter, configIter); + EXPECT_EQ(config, configIter->config); + const TestValue* value = + dynamic_cast<const TestValue*>(configIter->value.get()); + ASSERT_NE(nullptr, value); + EXPECT_EQ(std::u16string(u"Ok"), value->value); + + ++configIter; + ASSERT_NE(endConfigIter, configIter); + EXPECT_EQ(languageConfig, configIter->config); + EXPECT_NE(nullptr, configIter->value); + + value = dynamic_cast<const TestValue*>(configIter->value.get()); + ASSERT_NE(nullptr, value); + EXPECT_EQ(std::u16string(u"Tak"), value->value); + + ++configIter; + EXPECT_EQ(endConfigIter, configIter); + } + + ++entryIter; + ASSERT_EQ(endEntryIter, entryIter); + } + + ++typeIter; + EXPECT_EQ(endTypeIter, typeIter); +} + +TEST(ResourceTableTest, OverrideWeakResourceValue) { + const std::u16string kAndroid = u"android"; + + ResourceTable table; + table.setPackage(kAndroid); + table.setPackageId(0x01); + + ASSERT_TRUE(table.addResource( + ResourceName{ kAndroid, ResourceType::kAttr, u"foo" }, + {}, {}, util::make_unique<TestWeakValue>())); + + const ResourceTableType* type; + const ResourceEntry* entry; + std::tie(type, entry) = table.findResource( + ResourceNameRef{ kAndroid, ResourceType::kAttr, u"foo" }); + ASSERT_NE(nullptr, type); + ASSERT_NE(nullptr, entry); + ASSERT_EQ(entry->values.size(), 1u); + EXPECT_TRUE(entry->values.front().value->isWeak()); + + ASSERT_TRUE(table.addResource(ResourceName{ kAndroid, ResourceType::kAttr, u"foo" }, {}, {}, + util::make_unique<TestValue>(u"bar"))); + + std::tie(type, entry) = table.findResource( + ResourceNameRef{ kAndroid, ResourceType::kAttr, u"foo" }); + ASSERT_NE(nullptr, type); + ASSERT_NE(nullptr, entry); + ASSERT_EQ(entry->values.size(), 1u); + EXPECT_FALSE(entry->values.front().value->isWeak()); +} + +} // namespace aapt diff --git a/tools/aapt2/ResourceTypeExtensions.h b/tools/aapt2/ResourceTypeExtensions.h new file mode 100644 index 0000000..dcbe923 --- /dev/null +++ b/tools/aapt2/ResourceTypeExtensions.h @@ -0,0 +1,147 @@ +/* + * 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_RESOURCE_TYPE_EXTENSIONS_H +#define AAPT_RESOURCE_TYPE_EXTENSIONS_H + +#include <androidfw/ResourceTypes.h> + +namespace aapt { + +/** + * New android::ResChunk_header types defined + * for AAPT to use. + * + * TODO(adamlesinski): Consider reserving these + * enums in androidfw/ResourceTypes.h to avoid + * future collisions. + */ +enum { + RES_TABLE_PUBLIC_TYPE = 0x000d, + + /** + * A chunk that holds the string pool + * for source entries (path/to/source:line). + */ + RES_TABLE_SOURCE_POOL_TYPE = 0x000e, + + /** + * A chunk holding names of externally + * defined symbols and offsets to where + * they are referenced in the table. + */ + RES_TABLE_SYMBOL_TABLE_TYPE = 0x000f, +}; + +/** + * New resource types that are meant to only be used + * by AAPT and will not end up on the device. + */ +struct ExtendedTypes { + enum { + /** + * A raw string value that hasn't had its escape sequences + * processed nor whitespace removed. + */ + TYPE_RAW_STRING = 0xfe + }; +}; + +struct Public_header { + android::ResChunk_header header; + + /** + * The ID of the type this structure refers to. + */ + uint8_t typeId; + + /** + * Reserved. Must be 0. + */ + uint8_t res0; + + /** + * Reserved. Must be 0. + */ + uint16_t res1; + + /** + * Number of public entries. + */ + uint32_t count; +}; + +struct Public_entry { + uint16_t entryId; + uint16_t res0; + android::ResStringPool_ref key; + android::ResStringPool_ref source; + uint32_t sourceLine; +}; + +/** + * A chunk with type RES_TABLE_SYMBOL_TABLE_TYPE. + * Following the header are count number of SymbolTable_entry + * structures, followed by an android::ResStringPool_header. + */ +struct SymbolTable_header { + android::ResChunk_header header; + + /** + * Number of SymbolTable_entry structures following + * this header. + */ + uint32_t count; +}; + +struct SymbolTable_entry { + /** + * Offset from the beginning of the resource table + * where the symbol entry is referenced. + */ + uint32_t offset; + + /** + * The index into the string pool where the name of this + * symbol exists. + */ + uint32_t stringIndex; +}; + +/** + * A structure representing the source of a resourc entry. + * Appears after an android::ResTable_entry or android::ResTable_map_entry. + * + * TODO(adamlesinski): This causes some issues when runtime code checks + * the size of an android::ResTable_entry. It assumes it is an + * android::ResTable_map_entry if the size is bigger than an android::ResTable_entry + * which may not be true if this structure is present. + */ +struct ResTable_entry_source { + /** + * Index into the source string pool. + */ + uint32_t pathIndex; + + /** + * Line number this resource was defined on. + */ + uint32_t line; +}; + +} // namespace aapt + +#endif // AAPT_RESOURCE_TYPE_EXTENSIONS_H diff --git a/tools/aapt2/ResourceValues.cpp b/tools/aapt2/ResourceValues.cpp new file mode 100644 index 0000000..aabb375 --- /dev/null +++ b/tools/aapt2/ResourceValues.cpp @@ -0,0 +1,419 @@ +/* + * 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 "Resource.h" +#include "ResourceTypeExtensions.h" +#include "ResourceValues.h" +#include "Util.h" + +#include <androidfw/ResourceTypes.h> +#include <limits> + +namespace aapt { + +bool Value::isItem() const { + return false; +} + +bool Value::isWeak() const { + return false; +} + +bool Item::isItem() const { + return true; +} + +RawString::RawString(const StringPool::Ref& ref) : value(ref) { +} + +RawString* RawString::clone(StringPool* newPool) const { + return new RawString(newPool->makeRef(*value)); +} + +bool RawString::flatten(android::Res_value& outValue) const { + outValue.dataType = ExtendedTypes::TYPE_RAW_STRING; + outValue.data = static_cast<uint32_t>(value.getIndex()); + return true; +} + +void RawString::print(std::ostream& out) const { + out << "(raw string) " << *value; +} + +Reference::Reference() : referenceType(Reference::Type::kResource) { +} + +Reference::Reference(const ResourceNameRef& n, Type t) : + name(n.toResourceName()), referenceType(t) { +} + +Reference::Reference(const ResourceId& i, Type type) : id(i), referenceType(type) { +} + +bool Reference::flatten(android::Res_value& outValue) const { + outValue.dataType = (referenceType == Reference::Type::kResource) + ? android::Res_value::TYPE_REFERENCE + : android::Res_value::TYPE_ATTRIBUTE; + outValue.data = id.id; + return true; +} + +Reference* Reference::clone(StringPool* /*newPool*/) const { + Reference* ref = new Reference(); + ref->referenceType = referenceType; + ref->name = name; + ref->id = id; + return ref; +} + +void Reference::print(std::ostream& out) const { + out << "(reference) "; + if (referenceType == Reference::Type::kResource) { + out << "@"; + } else { + out << "?"; + } + + if (name.isValid()) { + out << name; + } + + if (id.isValid() || Res_INTERNALID(id.id)) { + out << " " << id; + } +} + +bool Id::isWeak() const { + return true; +} + +bool Id::flatten(android::Res_value& out) const { + out.dataType = android::Res_value::TYPE_INT_BOOLEAN; + out.data = 0; + return true; +} + +Id* Id::clone(StringPool* /*newPool*/) const { + return new Id(); +} + +void Id::print(std::ostream& out) const { + out << "(id)"; +} + +String::String(const StringPool::Ref& ref) : value(ref) { +} + +bool String::flatten(android::Res_value& outValue) const { + // Verify that our StringPool index is within encodeable limits. + if (value.getIndex() > std::numeric_limits<uint32_t>::max()) { + return false; + } + + outValue.dataType = android::Res_value::TYPE_STRING; + outValue.data = static_cast<uint32_t>(value.getIndex()); + return true; +} + +String* String::clone(StringPool* newPool) const { + return new String(newPool->makeRef(*value)); +} + +void String::print(std::ostream& out) const { + out << "(string) \"" << *value << "\""; +} + +StyledString::StyledString(const StringPool::StyleRef& ref) : value(ref) { +} + +bool StyledString::flatten(android::Res_value& outValue) const { + if (value.getIndex() > std::numeric_limits<uint32_t>::max()) { + return false; + } + + outValue.dataType = android::Res_value::TYPE_STRING; + outValue.data = static_cast<uint32_t>(value.getIndex()); + return true; +} + +StyledString* StyledString::clone(StringPool* newPool) const { + return new StyledString(newPool->makeRef(value)); +} + +void StyledString::print(std::ostream& out) const { + out << "(styled string) \"" << *value->str << "\""; +} + +FileReference::FileReference(const StringPool::Ref& _path) : path(_path) { +} + +bool FileReference::flatten(android::Res_value& outValue) const { + if (path.getIndex() > std::numeric_limits<uint32_t>::max()) { + return false; + } + + outValue.dataType = android::Res_value::TYPE_STRING; + outValue.data = static_cast<uint32_t>(path.getIndex()); + return true; +} + +FileReference* FileReference::clone(StringPool* newPool) const { + return new FileReference(newPool->makeRef(*path)); +} + +void FileReference::print(std::ostream& out) const { + out << "(file) " << *path; +} + +BinaryPrimitive::BinaryPrimitive(const android::Res_value& val) : value(val) { +} + +bool BinaryPrimitive::flatten(android::Res_value& outValue) const { + outValue = value; + return true; +} + +BinaryPrimitive* BinaryPrimitive::clone(StringPool* /*newPool*/) const { + return new BinaryPrimitive(value); +} + +void BinaryPrimitive::print(std::ostream& out) const { + switch (value.dataType) { + case android::Res_value::TYPE_NULL: + out << "(null)"; + break; + case android::Res_value::TYPE_INT_DEC: + out << "(integer) " << value.data; + break; + case android::Res_value::TYPE_INT_HEX: + out << "(integer) " << std::hex << value.data << std::dec; + break; + case android::Res_value::TYPE_INT_BOOLEAN: + out << "(boolean) " << (value.data != 0 ? "true" : "false"); + break; + case android::Res_value::TYPE_INT_COLOR_ARGB8: + case android::Res_value::TYPE_INT_COLOR_RGB8: + case android::Res_value::TYPE_INT_COLOR_ARGB4: + case android::Res_value::TYPE_INT_COLOR_RGB4: + out << "(color) #" << std::hex << value.data << std::dec; + break; + default: + out << "(unknown 0x" << std::hex << (int) value.dataType << ") 0x" + << std::hex << value.data << std::dec; + break; + } +} + +Attribute::Attribute(bool w, uint32_t t) : weak(w), typeMask(t) { +} + +bool Attribute::isWeak() const { + return weak; +} + +Attribute* Attribute::clone(StringPool* /*newPool*/) const { + Attribute* attr = new Attribute(weak); + attr->typeMask = typeMask; + std::copy(symbols.begin(), symbols.end(), std::back_inserter(attr->symbols)); + return attr; +} + +void Attribute::printMask(std::ostream& out) const { + if (typeMask == android::ResTable_map::TYPE_ANY) { + out << "any"; + return; + } + + bool set = false; + if ((typeMask & android::ResTable_map::TYPE_REFERENCE) != 0) { + if (!set) { + set = true; + } else { + out << "|"; + } + out << "reference"; + } + + if ((typeMask & android::ResTable_map::TYPE_STRING) != 0) { + if (!set) { + set = true; + } else { + out << "|"; + } + out << "string"; + } + + if ((typeMask & android::ResTable_map::TYPE_INTEGER) != 0) { + if (!set) { + set = true; + } else { + out << "|"; + } + out << "integer"; + } + + if ((typeMask & android::ResTable_map::TYPE_BOOLEAN) != 0) { + if (!set) { + set = true; + } else { + out << "|"; + } + out << "boolean"; + } + + if ((typeMask & android::ResTable_map::TYPE_COLOR) != 0) { + if (!set) { + set = true; + } else { + out << "|"; + } + out << "color"; + } + + if ((typeMask & android::ResTable_map::TYPE_FLOAT) != 0) { + if (!set) { + set = true; + } else { + out << "|"; + } + out << "float"; + } + + if ((typeMask & android::ResTable_map::TYPE_DIMENSION) != 0) { + if (!set) { + set = true; + } else { + out << "|"; + } + out << "dimension"; + } + + if ((typeMask & android::ResTable_map::TYPE_FRACTION) != 0) { + if (!set) { + set = true; + } else { + out << "|"; + } + out << "fraction"; + } + + if ((typeMask & android::ResTable_map::TYPE_ENUM) != 0) { + if (!set) { + set = true; + } else { + out << "|"; + } + out << "enum"; + } + + if ((typeMask & android::ResTable_map::TYPE_FLAGS) != 0) { + if (!set) { + set = true; + } else { + out << "|"; + } + out << "flags"; + } +} + +void Attribute::print(std::ostream& out) const { + out << "(attr) "; + printMask(out); + + out << " [" + << util::joiner(symbols.begin(), symbols.end(), ", ") + << "]"; + + if (weak) { + out << " [weak]"; + } +} + +Style* Style::clone(StringPool* newPool) const { + Style* style = new Style(); + style->parent = parent; + style->parentInferred = parentInferred; + for (auto& entry : entries) { + style->entries.push_back(Entry{ + entry.key, + std::unique_ptr<Item>(entry.value->clone(newPool)) + }); + } + return style; +} + +void Style::print(std::ostream& out) const { + out << "(style) "; + if (!parent.name.entry.empty()) { + out << parent.name; + } + out << " [" + << util::joiner(entries.begin(), entries.end(), ", ") + << "]"; +} + +static ::std::ostream& operator<<(::std::ostream& out, const Style::Entry& value) { + out << value.key.name << " = "; + value.value->print(out); + return out; +} + +Array* Array::clone(StringPool* newPool) const { + Array* array = new Array(); + for (auto& item : items) { + array->items.emplace_back(std::unique_ptr<Item>(item->clone(newPool))); + } + return array; +} + +void Array::print(std::ostream& out) const { + out << "(array) [" + << util::joiner(items.begin(), items.end(), ", ") + << "]"; +} + +Plural* Plural::clone(StringPool* newPool) const { + Plural* p = new Plural(); + const size_t count = values.size(); + for (size_t i = 0; i < count; i++) { + if (values[i]) { + p->values[i] = std::unique_ptr<Item>(values[i]->clone(newPool)); + } + } + return p; +} + +void Plural::print(std::ostream& out) const { + out << "(plural)"; +} + +static ::std::ostream& operator<<(::std::ostream& out, const std::unique_ptr<Item>& item) { + return out << *item; +} + +Styleable* Styleable::clone(StringPool* /*newPool*/) const { + Styleable* styleable = new Styleable(); + std::copy(entries.begin(), entries.end(), std::back_inserter(styleable->entries)); + return styleable; +} + +void Styleable::print(std::ostream& out) const { + out << "(styleable) " << " [" + << util::joiner(entries.begin(), entries.end(), ", ") + << "]"; +} + +} // namespace aapt diff --git a/tools/aapt2/ResourceValues.h b/tools/aapt2/ResourceValues.h new file mode 100644 index 0000000..ef6594e --- /dev/null +++ b/tools/aapt2/ResourceValues.h @@ -0,0 +1,448 @@ +/* + * 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_RESOURCE_VALUES_H +#define AAPT_RESOURCE_VALUES_H + +#include "Resource.h" +#include "StringPool.h" + +#include <array> +#include <androidfw/ResourceTypes.h> +#include <ostream> +#include <vector> + +namespace aapt { + +struct ValueVisitor; +struct ConstValueVisitor; +struct ValueVisitorArgs; + +/** + * A resource value. This is an all-encompassing representation + * of Item and Map and their subclasses. The way to do + * type specific operations is to check the Value's type() and + * cast it to the appropriate subclass. This isn't super clean, + * but it is the simplest strategy. + */ +struct Value { + /** + * Whether or not this is an Item. + */ + virtual bool isItem() const; + + /** + * Whether this value is weak and can be overriden without + * warning or error. Default for base class is false. + */ + virtual bool isWeak() const; + + /** + * Calls the appropriate overload of ValueVisitor. + */ + virtual void accept(ValueVisitor& visitor, ValueVisitorArgs&& args) = 0; + + /** + * Const version of accept(). + */ + virtual void accept(ConstValueVisitor& visitor, ValueVisitorArgs&& args) const = 0; + + /** + * Clone the value. + */ + virtual Value* clone(StringPool* newPool) const = 0; + + /** + * Human readable printout of this value. + */ + virtual void print(std::ostream& out) const = 0; +}; + +/** + * Inherit from this to get visitor accepting implementations for free. + */ +template <typename Derived> +struct BaseValue : public Value { + virtual void accept(ValueVisitor& visitor, ValueVisitorArgs&& args) override; + virtual void accept(ConstValueVisitor& visitor, ValueVisitorArgs&& args) const override; +}; + +/** + * A resource item with a single value. This maps to android::ResTable_entry. + */ +struct Item : public Value { + /** + * An Item is, of course, an Item. + */ + virtual bool isItem() const override; + + /** + * Clone the Item. + */ + virtual Item* clone(StringPool* newPool) const override = 0; + + /** + * Fills in an android::Res_value structure with this Item's binary representation. + * Returns false if an error ocurred. + */ + virtual bool flatten(android::Res_value& outValue) const = 0; +}; + +/** + * Inherit from this to get visitor accepting implementations for free. + */ +template <typename Derived> +struct BaseItem : public Item { + virtual void accept(ValueVisitor& visitor, ValueVisitorArgs&& args) override; + virtual void accept(ConstValueVisitor& visitor, ValueVisitorArgs&& args) const override; +}; + +/** + * A reference to another resource. This maps to android::Res_value::TYPE_REFERENCE. + * + * A reference can be symbolic (with the name set to a valid resource name) or be + * numeric (the id is set to a valid resource ID). + */ +struct Reference : public BaseItem<Reference> { + enum class Type { + kResource, + kAttribute, + }; + + ResourceName name; + ResourceId id; + Reference::Type referenceType; + bool privateReference = false; + + Reference(); + Reference(const ResourceNameRef& n, Type type = Type::kResource); + Reference(const ResourceId& i, Type type = Type::kResource); + + bool flatten(android::Res_value& outValue) const override; + Reference* clone(StringPool* newPool) const override; + void print(std::ostream& out) const override; +}; + +/** + * An ID resource. Has no real value, just a place holder. + */ +struct Id : public BaseItem<Id> { + bool isWeak() const override; + bool flatten(android::Res_value& out) const override; + Id* clone(StringPool* newPool) const override; + void print(std::ostream& out) const override; +}; + +/** + * A raw, unprocessed string. This may contain quotations, + * escape sequences, and whitespace. This shall *NOT* + * end up in the final resource table. + */ +struct RawString : public BaseItem<RawString> { + StringPool::Ref value; + + RawString(const StringPool::Ref& ref); + + bool flatten(android::Res_value& outValue) const override; + RawString* clone(StringPool* newPool) const override; + void print(std::ostream& out) const override; +}; + +struct String : public BaseItem<String> { + StringPool::Ref value; + + String(const StringPool::Ref& ref); + + bool flatten(android::Res_value& outValue) const override; + String* clone(StringPool* newPool) const override; + void print(std::ostream& out) const override; +}; + +struct StyledString : public BaseItem<StyledString> { + StringPool::StyleRef value; + + StyledString(const StringPool::StyleRef& ref); + + bool flatten(android::Res_value& outValue) const override; + StyledString* clone(StringPool* newPool) const override; + void print(std::ostream& out) const override; +}; + +struct FileReference : public BaseItem<FileReference> { + StringPool::Ref path; + + FileReference() = default; + FileReference(const StringPool::Ref& path); + + bool flatten(android::Res_value& outValue) const override; + FileReference* clone(StringPool* newPool) const override; + void print(std::ostream& out) const override; +}; + +/** + * Represents any other android::Res_value. + */ +struct BinaryPrimitive : public BaseItem<BinaryPrimitive> { + android::Res_value value; + + BinaryPrimitive() = default; + BinaryPrimitive(const android::Res_value& val); + + bool flatten(android::Res_value& outValue) const override; + BinaryPrimitive* clone(StringPool* newPool) const override; + void print(std::ostream& out) const override; +}; + +struct Attribute : public BaseValue<Attribute> { + struct Symbol { + Reference symbol; + uint32_t value; + }; + + bool weak; + uint32_t typeMask; + uint32_t minInt; + uint32_t maxInt; + std::vector<Symbol> symbols; + + Attribute(bool w, uint32_t t = 0u); + + bool isWeak() const override; + virtual Attribute* clone(StringPool* newPool) const override; + void printMask(std::ostream& out) const; + virtual void print(std::ostream& out) const override; +}; + +struct Style : public BaseValue<Style> { + struct Entry { + Reference key; + std::unique_ptr<Item> value; + }; + + Reference parent; + + /** + * If set to true, the parent was auto inferred from the + * style's name. + */ + bool parentInferred = false; + + std::vector<Entry> entries; + + Style* clone(StringPool* newPool) const override; + void print(std::ostream& out) const override; +}; + +struct Array : public BaseValue<Array> { + std::vector<std::unique_ptr<Item>> items; + + Array* clone(StringPool* newPool) const override; + void print(std::ostream& out) const override; +}; + +struct Plural : public BaseValue<Plural> { + enum { + Zero = 0, + One, + Two, + Few, + Many, + Other, + Count + }; + + std::array<std::unique_ptr<Item>, Count> values; + + Plural* clone(StringPool* newPool) const override; + void print(std::ostream& out) const override; +}; + +struct Styleable : public BaseValue<Styleable> { + std::vector<Reference> entries; + + Styleable* clone(StringPool* newPool) const override; + void print(std::ostream& out) const override; +}; + +/** + * Stream operator for printing Value objects. + */ +inline ::std::ostream& operator<<(::std::ostream& out, const Value& value) { + value.print(out); + return out; +} + +inline ::std::ostream& operator<<(::std::ostream& out, const Attribute::Symbol& s) { + return out << s.symbol.name.entry << "=" << s.value; +} + +/** + * The argument object that gets passed through the value + * back to the ValueVisitor. Subclasses of ValueVisitor should + * subclass ValueVisitorArgs to contain the data they need + * to operate. + */ +struct ValueVisitorArgs {}; + +/** + * Visits a value and runs the appropriate method based on its type. + */ +struct ValueVisitor { + virtual void visit(Reference& reference, ValueVisitorArgs& args) { + visitItem(reference, args); + } + + virtual void visit(RawString& string, ValueVisitorArgs& args) { + visitItem(string, args); + } + + virtual void visit(String& string, ValueVisitorArgs& args) { + visitItem(string, args); + } + + virtual void visit(StyledString& string, ValueVisitorArgs& args) { + visitItem(string, args); + } + + virtual void visit(FileReference& file, ValueVisitorArgs& args) { + visitItem(file, args); + } + + virtual void visit(Id& id, ValueVisitorArgs& args) { + visitItem(id, args); + } + + virtual void visit(BinaryPrimitive& primitive, ValueVisitorArgs& args) { + visitItem(primitive, args); + } + + virtual void visit(Attribute& attr, ValueVisitorArgs& args) {} + virtual void visit(Style& style, ValueVisitorArgs& args) {} + virtual void visit(Array& array, ValueVisitorArgs& args) {} + virtual void visit(Plural& array, ValueVisitorArgs& args) {} + virtual void visit(Styleable& styleable, ValueVisitorArgs& args) {} + + virtual void visitItem(Item& item, ValueVisitorArgs& args) {} +}; + +/** + * Const version of ValueVisitor. + */ +struct ConstValueVisitor { + virtual void visit(const Reference& reference, ValueVisitorArgs& args) { + visitItem(reference, args); + } + + virtual void visit(const RawString& string, ValueVisitorArgs& args) { + visitItem(string, args); + } + + virtual void visit(const String& string, ValueVisitorArgs& args) { + visitItem(string, args); + } + + virtual void visit(const StyledString& string, ValueVisitorArgs& args) { + visitItem(string, args); + } + + virtual void visit(const FileReference& file, ValueVisitorArgs& args) { + visitItem(file, args); + } + + virtual void visit(const Id& id, ValueVisitorArgs& args) { + visitItem(id, args); + } + + virtual void visit(const BinaryPrimitive& primitive, ValueVisitorArgs& args) { + visitItem(primitive, args); + } + + virtual void visit(const Attribute& attr, ValueVisitorArgs& args) {} + virtual void visit(const Style& style, ValueVisitorArgs& args) {} + virtual void visit(const Array& array, ValueVisitorArgs& args) {} + virtual void visit(const Plural& array, ValueVisitorArgs& args) {} + virtual void visit(const Styleable& styleable, ValueVisitorArgs& args) {} + + virtual void visitItem(const Item& item, ValueVisitorArgs& args) {} +}; + +/** + * Convenience Visitor that forwards a specific type to a function. + * Args are not used as the function can bind variables. Do not use + * directly, use the wrapper visitFunc() method. + */ +template <typename T, typename TFunc> +struct ValueVisitorFunc : ValueVisitor { + TFunc func; + + ValueVisitorFunc(TFunc f) : func(f) { + } + + void visit(T& value, ValueVisitorArgs&) override { + func(value); + } +}; + +/** + * Const version of ValueVisitorFunc. + */ +template <typename T, typename TFunc> +struct ConstValueVisitorFunc : ConstValueVisitor { + TFunc func; + + ConstValueVisitorFunc(TFunc f) : func(f) { + } + + void visit(const T& value, ValueVisitorArgs&) override { + func(value); + } +}; + +template <typename T, typename TFunc> +void visitFunc(Value& value, TFunc f) { + ValueVisitorFunc<T, TFunc> visitor(f); + value.accept(visitor, ValueVisitorArgs{}); +} + +template <typename T, typename TFunc> +void visitFunc(const Value& value, TFunc f) { + ConstValueVisitorFunc<T, TFunc> visitor(f); + value.accept(visitor, ValueVisitorArgs{}); +} + +template <typename Derived> +void BaseValue<Derived>::accept(ValueVisitor& visitor, ValueVisitorArgs&& args) { + visitor.visit(static_cast<Derived&>(*this), args); +} + +template <typename Derived> +void BaseValue<Derived>::accept(ConstValueVisitor& visitor, ValueVisitorArgs&& args) const { + visitor.visit(static_cast<const Derived&>(*this), args); +} + +template <typename Derived> +void BaseItem<Derived>::accept(ValueVisitor& visitor, ValueVisitorArgs&& args) { + visitor.visit(static_cast<Derived&>(*this), args); +} + +template <typename Derived> +void BaseItem<Derived>::accept(ConstValueVisitor& visitor, ValueVisitorArgs&& args) const { + visitor.visit(static_cast<const Derived&>(*this), args); +} + +} // namespace aapt + +#endif // AAPT_RESOURCE_VALUES_H diff --git a/tools/aapt2/Resource_test.cpp b/tools/aapt2/Resource_test.cpp new file mode 100644 index 0000000..d957999 --- /dev/null +++ b/tools/aapt2/Resource_test.cpp @@ -0,0 +1,120 @@ +/* + * 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 <gtest/gtest.h> + +#include "Resource.h" + +namespace aapt { + +TEST(ResourceTypeTest, ParseResourceTypes) { + const ResourceType* type = parseResourceType(u"anim"); + ASSERT_NE(type, nullptr); + EXPECT_EQ(*type, ResourceType::kAnim); + + type = parseResourceType(u"animator"); + ASSERT_NE(type, nullptr); + EXPECT_EQ(*type, ResourceType::kAnimator); + + type = parseResourceType(u"array"); + ASSERT_NE(type, nullptr); + EXPECT_EQ(*type, ResourceType::kArray); + + type = parseResourceType(u"attr"); + ASSERT_NE(type, nullptr); + EXPECT_EQ(*type, ResourceType::kAttr); + + type = parseResourceType(u"^attr-private"); + ASSERT_NE(type, nullptr); + EXPECT_EQ(*type, ResourceType::kAttrPrivate); + + type = parseResourceType(u"bool"); + ASSERT_NE(type, nullptr); + EXPECT_EQ(*type, ResourceType::kBool); + + type = parseResourceType(u"color"); + ASSERT_NE(type, nullptr); + EXPECT_EQ(*type, ResourceType::kColor); + + type = parseResourceType(u"dimen"); + ASSERT_NE(type, nullptr); + EXPECT_EQ(*type, ResourceType::kDimen); + + type = parseResourceType(u"drawable"); + ASSERT_NE(type, nullptr); + EXPECT_EQ(*type, ResourceType::kDrawable); + + type = parseResourceType(u"fraction"); + ASSERT_NE(type, nullptr); + EXPECT_EQ(*type, ResourceType::kFraction); + + type = parseResourceType(u"id"); + ASSERT_NE(type, nullptr); + EXPECT_EQ(*type, ResourceType::kId); + + type = parseResourceType(u"integer"); + ASSERT_NE(type, nullptr); + EXPECT_EQ(*type, ResourceType::kInteger); + + type = parseResourceType(u"integer-array"); + ASSERT_NE(type, nullptr); + EXPECT_EQ(*type, ResourceType::kIntegerArray); + + type = parseResourceType(u"interpolator"); + ASSERT_NE(type, nullptr); + EXPECT_EQ(*type, ResourceType::kInterpolator); + + type = parseResourceType(u"layout"); + ASSERT_NE(type, nullptr); + EXPECT_EQ(*type, ResourceType::kLayout); + + type = parseResourceType(u"menu"); + ASSERT_NE(type, nullptr); + EXPECT_EQ(*type, ResourceType::kMenu); + + type = parseResourceType(u"mipmap"); + ASSERT_NE(type, nullptr); + EXPECT_EQ(*type, ResourceType::kMipmap); + + type = parseResourceType(u"plurals"); + ASSERT_NE(type, nullptr); + EXPECT_EQ(*type, ResourceType::kPlurals); + + type = parseResourceType(u"raw"); + ASSERT_NE(type, nullptr); + EXPECT_EQ(*type, ResourceType::kRaw); + + type = parseResourceType(u"string"); + ASSERT_NE(type, nullptr); + EXPECT_EQ(*type, ResourceType::kString); + + type = parseResourceType(u"style"); + ASSERT_NE(type, nullptr); + EXPECT_EQ(*type, ResourceType::kStyle); + + type = parseResourceType(u"transition"); + ASSERT_NE(type, nullptr); + EXPECT_EQ(*type, ResourceType::kTransition); + + type = parseResourceType(u"xml"); + ASSERT_NE(type, nullptr); + EXPECT_EQ(*type, ResourceType::kXml); + + type = parseResourceType(u"blahaha"); + EXPECT_EQ(type, nullptr); +} + +} // namespace aapt diff --git a/tools/aapt2/ScopedXmlPullParser.cpp b/tools/aapt2/ScopedXmlPullParser.cpp new file mode 100644 index 0000000..48da93e --- /dev/null +++ b/tools/aapt2/ScopedXmlPullParser.cpp @@ -0,0 +1,104 @@ +/* + * 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 "ScopedXmlPullParser.h" + +#include <string> + +namespace aapt { + +ScopedXmlPullParser::ScopedXmlPullParser(XmlPullParser* parser) : + mParser(parser), mDepth(parser->getDepth()), mDone(false) { +} + +ScopedXmlPullParser::~ScopedXmlPullParser() { + while (isGoodEvent(next())); +} + +XmlPullParser::Event ScopedXmlPullParser::next() { + if (mDone) { + return Event::kEndDocument; + } + + const Event event = mParser->next(); + if (mParser->getDepth() <= mDepth) { + mDone = true; + } + return event; +} + +XmlPullParser::Event ScopedXmlPullParser::getEvent() const { + return mParser->getEvent(); +} + +const std::string& ScopedXmlPullParser::getLastError() const { + return mParser->getLastError(); +} + +const std::u16string& ScopedXmlPullParser::getComment() const { + return mParser->getComment(); +} + +size_t ScopedXmlPullParser::getLineNumber() const { + return mParser->getLineNumber(); +} + +size_t ScopedXmlPullParser::getDepth() const { + const size_t depth = mParser->getDepth(); + if (depth < mDepth) { + return 0; + } + return depth - mDepth; +} + +const std::u16string& ScopedXmlPullParser::getText() const { + return mParser->getText(); +} + +const std::u16string& ScopedXmlPullParser::getNamespacePrefix() const { + return mParser->getNamespacePrefix(); +} + +const std::u16string& ScopedXmlPullParser::getNamespaceUri() const { + return mParser->getNamespaceUri(); +} + +bool ScopedXmlPullParser::applyPackageAlias(std::u16string* package, + const std::u16string& defaultPackage) const { + return mParser->applyPackageAlias(package, defaultPackage); +} + +const std::u16string& ScopedXmlPullParser::getElementNamespace() const { + return mParser->getElementNamespace(); +} + +const std::u16string& ScopedXmlPullParser::getElementName() const { + return mParser->getElementName(); +} + +size_t ScopedXmlPullParser::getAttributeCount() const { + return mParser->getAttributeCount(); +} + +XmlPullParser::const_iterator ScopedXmlPullParser::beginAttributes() const { + return mParser->beginAttributes(); +} + +XmlPullParser::const_iterator ScopedXmlPullParser::endAttributes() const { + return mParser->endAttributes(); +} + +} // namespace aapt diff --git a/tools/aapt2/ScopedXmlPullParser.h b/tools/aapt2/ScopedXmlPullParser.h new file mode 100644 index 0000000..a040f60 --- /dev/null +++ b/tools/aapt2/ScopedXmlPullParser.h @@ -0,0 +1,85 @@ +/* + * 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_SCOPED_XML_PULL_PARSER_H +#define AAPT_SCOPED_XML_PULL_PARSER_H + +#include "XmlPullParser.h" + +#include <string> + +namespace aapt { + +/** + * An XmlPullParser that will not read past the depth + * of the underlying parser. When this parser is destroyed, + * it moves the underlying parser to the same depth it + * started with. + * + * You can write code like this: + * + * while (XmlPullParser::isGoodEvent(parser.next())) { + * if (parser.getEvent() != XmlPullParser::Event::StartElement) { + * continue; + * } + * + * ScopedXmlPullParser scoped(parser); + * if (parser.getElementName() == u"id") { + * // do work. + * } else { + * // do nothing, as all the sub elements will be skipped + * // when scoped goes out of scope. + * } + * } + */ +class ScopedXmlPullParser : public XmlPullParser { +public: + ScopedXmlPullParser(XmlPullParser* parser); + ScopedXmlPullParser(const ScopedXmlPullParser&) = delete; + ScopedXmlPullParser& operator=(const ScopedXmlPullParser&) = delete; + ~ScopedXmlPullParser(); + + Event getEvent() const override; + const std::string& getLastError() const override; + Event next() override; + + const std::u16string& getComment() const override; + size_t getLineNumber() const override; + size_t getDepth() const override; + + const std::u16string& getText() const override; + + const std::u16string& getNamespacePrefix() const override; + const std::u16string& getNamespaceUri() const override; + bool applyPackageAlias(std::u16string* package, const std::u16string& defaultPackage) + const override; + + const std::u16string& getElementNamespace() const override; + const std::u16string& getElementName() const override; + + const_iterator beginAttributes() const override; + const_iterator endAttributes() const override; + size_t getAttributeCount() const override; + +private: + XmlPullParser* mParser; + size_t mDepth; + bool mDone; +}; + +} // namespace aapt + +#endif // AAPT_SCOPED_XML_PULL_PARSER_H diff --git a/tools/aapt2/ScopedXmlPullParser_test.cpp b/tools/aapt2/ScopedXmlPullParser_test.cpp new file mode 100644 index 0000000..342f305 --- /dev/null +++ b/tools/aapt2/ScopedXmlPullParser_test.cpp @@ -0,0 +1,106 @@ +/* + * 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 "ScopedXmlPullParser.h" +#include "SourceXmlPullParser.h" + +#include <gtest/gtest.h> +#include <sstream> +#include <string> + +namespace aapt { + +TEST(ScopedXmlPullParserTest, StopIteratingAtNoNZeroDepth) { + std::stringstream input; + input << "<?xml version=\"1.0\" encoding=\"utf-8\"?>" << std::endl + << "<resources><string></string></resources>" << std::endl; + + SourceXmlPullParser sourceParser(input); + EXPECT_EQ(XmlPullParser::Event::kStartElement, sourceParser.next()); + EXPECT_EQ(std::u16string(u"resources"), sourceParser.getElementName()); + + EXPECT_EQ(XmlPullParser::Event::kStartElement, sourceParser.next()); + EXPECT_EQ(std::u16string(u"string"), sourceParser.getElementName()); + + { + ScopedXmlPullParser scopedParser(&sourceParser); + EXPECT_EQ(XmlPullParser::Event::kEndElement, scopedParser.next()); + EXPECT_EQ(std::u16string(u"string"), sourceParser.getElementName()); + + EXPECT_EQ(XmlPullParser::Event::kEndDocument, scopedParser.next()); + } + + EXPECT_EQ(XmlPullParser::Event::kEndElement, sourceParser.next()); + EXPECT_EQ(std::u16string(u"resources"), sourceParser.getElementName()); + + EXPECT_EQ(XmlPullParser::Event::kEndDocument, sourceParser.next()); +} + +TEST(ScopedXmlPullParserTest, FinishCurrentElementOnDestruction) { + std::stringstream input; + input << "<?xml version=\"1.0\" encoding=\"utf-8\"?>" << std::endl + << "<resources><string></string></resources>" << std::endl; + + SourceXmlPullParser sourceParser(input); + EXPECT_EQ(XmlPullParser::Event::kStartElement, sourceParser.next()); + EXPECT_EQ(std::u16string(u"resources"), sourceParser.getElementName()); + + EXPECT_EQ(XmlPullParser::Event::kStartElement, sourceParser.next()); + EXPECT_EQ(std::u16string(u"string"), sourceParser.getElementName()); + + { + ScopedXmlPullParser scopedParser(&sourceParser); + EXPECT_EQ(std::u16string(u"string"), sourceParser.getElementName()); + } + + EXPECT_EQ(XmlPullParser::Event::kEndElement, sourceParser.next()); + EXPECT_EQ(std::u16string(u"resources"), sourceParser.getElementName()); + + EXPECT_EQ(XmlPullParser::Event::kEndDocument, sourceParser.next()); +} + +TEST(ScopedXmlPullParserTest, NestedParsersOperateCorrectly) { + std::stringstream input; + input << "<?xml version=\"1.0\" encoding=\"utf-8\"?>" << std::endl + << "<resources><string><foo></foo></string></resources>" << std::endl; + + SourceXmlPullParser sourceParser(input); + EXPECT_EQ(XmlPullParser::Event::kStartElement, sourceParser.next()); + EXPECT_EQ(std::u16string(u"resources"), sourceParser.getElementName()); + + EXPECT_EQ(XmlPullParser::Event::kStartElement, sourceParser.next()); + EXPECT_EQ(std::u16string(u"string"), sourceParser.getElementName()); + + { + ScopedXmlPullParser scopedParser(&sourceParser); + EXPECT_EQ(std::u16string(u"string"), scopedParser.getElementName()); + while (XmlPullParser::isGoodEvent(scopedParser.next())) { + if (scopedParser.getEvent() != XmlPullParser::Event::kStartElement) { + continue; + } + + ScopedXmlPullParser subScopedParser(&scopedParser); + EXPECT_EQ(std::u16string(u"foo"), subScopedParser.getElementName()); + } + } + + EXPECT_EQ(XmlPullParser::Event::kEndElement, sourceParser.next()); + EXPECT_EQ(std::u16string(u"resources"), sourceParser.getElementName()); + + EXPECT_EQ(XmlPullParser::Event::kEndDocument, sourceParser.next()); +} + +} // namespace aapt diff --git a/tools/aapt2/SdkConstants.cpp b/tools/aapt2/SdkConstants.cpp new file mode 100644 index 0000000..9bdae49 --- /dev/null +++ b/tools/aapt2/SdkConstants.cpp @@ -0,0 +1,737 @@ +/* + * 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 "SdkConstants.h" + +#include <algorithm> +#include <string> +#include <unordered_map> +#include <vector> + +namespace aapt { + +static const std::vector<std::pair<uint16_t, size_t>> sAttrIdMap = { + { 0x021c, 1 }, + { 0x021d, 2 }, + { 0x0269, SDK_CUPCAKE }, + { 0x028d, SDK_DONUT }, + { 0x02ad, SDK_ECLAIR }, + { 0x02b3, SDK_ECLAIR_0_1 }, + { 0x02b5, SDK_ECLAIR_MR1 }, + { 0x02bd, SDK_FROYO }, + { 0x02cb, SDK_GINGERBREAD }, + { 0x0361, SDK_HONEYCOMB }, + { 0x0366, SDK_HONEYCOMB_MR1 }, + { 0x03a6, SDK_HONEYCOMB_MR2 }, + { 0x03ae, SDK_JELLY_BEAN }, + { 0x03cc, SDK_JELLY_BEAN_MR1 }, + { 0x03da, SDK_JELLY_BEAN_MR2 }, + { 0x03f1, SDK_KITKAT }, + { 0x03f6, SDK_KITKAT_WATCH }, + { 0x04ce, SDK_LOLLIPOP }, +}; + +static bool lessEntryId(const std::pair<uint16_t, size_t>& p, uint16_t entryId) { + return p.first < entryId; +} + +size_t findAttributeSdkLevel(ResourceId id) { + if (id.packageId() != 0x01 && id.typeId() != 0x01) { + return 0; + } + auto iter = std::lower_bound(sAttrIdMap.begin(), sAttrIdMap.end(), id.entryId(), lessEntryId); + if (iter == sAttrIdMap.end()) { + return SDK_LOLLIPOP_MR1; + } + return iter->second; +} + +static const std::unordered_map<std::u16string, size_t> sAttrMap = { + { u"marqueeRepeatLimit", 2 }, + { u"windowNoDisplay", 3 }, + { u"backgroundDimEnabled", 3 }, + { u"inputType", 3 }, + { u"isDefault", 3 }, + { u"windowDisablePreview", 3 }, + { u"privateImeOptions", 3 }, + { u"editorExtras", 3 }, + { u"settingsActivity", 3 }, + { u"fastScrollEnabled", 3 }, + { u"reqTouchScreen", 3 }, + { u"reqKeyboardType", 3 }, + { u"reqHardKeyboard", 3 }, + { u"reqNavigation", 3 }, + { u"windowSoftInputMode", 3 }, + { u"imeFullscreenBackground", 3 }, + { u"noHistory", 3 }, + { u"headerDividersEnabled", 3 }, + { u"footerDividersEnabled", 3 }, + { u"candidatesTextStyleSpans", 3 }, + { u"smoothScrollbar", 3 }, + { u"reqFiveWayNav", 3 }, + { u"keyBackground", 3 }, + { u"keyTextSize", 3 }, + { u"labelTextSize", 3 }, + { u"keyTextColor", 3 }, + { u"keyPreviewLayout", 3 }, + { u"keyPreviewOffset", 3 }, + { u"keyPreviewHeight", 3 }, + { u"verticalCorrection", 3 }, + { u"popupLayout", 3 }, + { u"state_long_pressable", 3 }, + { u"keyWidth", 3 }, + { u"keyHeight", 3 }, + { u"horizontalGap", 3 }, + { u"verticalGap", 3 }, + { u"rowEdgeFlags", 3 }, + { u"codes", 3 }, + { u"popupKeyboard", 3 }, + { u"popupCharacters", 3 }, + { u"keyEdgeFlags", 3 }, + { u"isModifier", 3 }, + { u"isSticky", 3 }, + { u"isRepeatable", 3 }, + { u"iconPreview", 3 }, + { u"keyOutputText", 3 }, + { u"keyLabel", 3 }, + { u"keyIcon", 3 }, + { u"keyboardMode", 3 }, + { u"isScrollContainer", 3 }, + { u"fillEnabled", 3 }, + { u"updatePeriodMillis", 3 }, + { u"initialLayout", 3 }, + { u"voiceSearchMode", 3 }, + { u"voiceLanguageModel", 3 }, + { u"voicePromptText", 3 }, + { u"voiceLanguage", 3 }, + { u"voiceMaxResults", 3 }, + { u"bottomOffset", 3 }, + { u"topOffset", 3 }, + { u"allowSingleTap", 3 }, + { u"handle", 3 }, + { u"content", 3 }, + { u"animateOnClick", 3 }, + { u"configure", 3 }, + { u"hapticFeedbackEnabled", 3 }, + { u"innerRadius", 3 }, + { u"thickness", 3 }, + { u"sharedUserLabel", 3 }, + { u"dropDownWidth", 3 }, + { u"dropDownAnchor", 3 }, + { u"imeOptions", 3 }, + { u"imeActionLabel", 3 }, + { u"imeActionId", 3 }, + { u"imeExtractEnterAnimation", 3 }, + { u"imeExtractExitAnimation", 3 }, + { u"tension", 4 }, + { u"extraTension", 4 }, + { u"anyDensity", 4 }, + { u"searchSuggestThreshold", 4 }, + { u"includeInGlobalSearch", 4 }, + { u"onClick", 4 }, + { u"targetSdkVersion", 4 }, + { u"maxSdkVersion", 4 }, + { u"testOnly", 4 }, + { u"contentDescription", 4 }, + { u"gestureStrokeWidth", 4 }, + { u"gestureColor", 4 }, + { u"uncertainGestureColor", 4 }, + { u"fadeOffset", 4 }, + { u"fadeDuration", 4 }, + { u"gestureStrokeType", 4 }, + { u"gestureStrokeLengthThreshold", 4 }, + { u"gestureStrokeSquarenessThreshold", 4 }, + { u"gestureStrokeAngleThreshold", 4 }, + { u"eventsInterceptionEnabled", 4 }, + { u"fadeEnabled", 4 }, + { u"backupAgent", 4 }, + { u"allowBackup", 4 }, + { u"glEsVersion", 4 }, + { u"queryAfterZeroResults", 4 }, + { u"dropDownHeight", 4 }, + { u"smallScreens", 4 }, + { u"normalScreens", 4 }, + { u"largeScreens", 4 }, + { u"progressBarStyleInverse", 4 }, + { u"progressBarStyleSmallInverse", 4 }, + { u"progressBarStyleLargeInverse", 4 }, + { u"searchSettingsDescription", 4 }, + { u"textColorPrimaryInverseDisableOnly", 4 }, + { u"autoUrlDetect", 4 }, + { u"resizeable", 4 }, + { u"required", 5 }, + { u"accountType", 5 }, + { u"contentAuthority", 5 }, + { u"userVisible", 5 }, + { u"windowShowWallpaper", 5 }, + { u"wallpaperOpenEnterAnimation", 5 }, + { u"wallpaperOpenExitAnimation", 5 }, + { u"wallpaperCloseEnterAnimation", 5 }, + { u"wallpaperCloseExitAnimation", 5 }, + { u"wallpaperIntraOpenEnterAnimation", 5 }, + { u"wallpaperIntraOpenExitAnimation", 5 }, + { u"wallpaperIntraCloseEnterAnimation", 5 }, + { u"wallpaperIntraCloseExitAnimation", 5 }, + { u"supportsUploading", 5 }, + { u"killAfterRestore", 5 }, + { u"restoreNeedsApplication", 5 }, + { u"smallIcon", 5 }, + { u"accountPreferences", 5 }, + { u"textAppearanceSearchResultSubtitle", 5 }, + { u"textAppearanceSearchResultTitle", 5 }, + { u"summaryColumn", 5 }, + { u"detailColumn", 5 }, + { u"detailSocialSummary", 5 }, + { u"thumbnail", 5 }, + { u"detachWallpaper", 5 }, + { u"finishOnCloseSystemDialogs", 5 }, + { u"scrollbarFadeDuration", 5 }, + { u"scrollbarDefaultDelayBeforeFade", 5 }, + { u"fadeScrollbars", 5 }, + { u"colorBackgroundCacheHint", 5 }, + { u"dropDownHorizontalOffset", 5 }, + { u"dropDownVerticalOffset", 5 }, + { u"quickContactBadgeStyleWindowSmall", 6 }, + { u"quickContactBadgeStyleWindowMedium", 6 }, + { u"quickContactBadgeStyleWindowLarge", 6 }, + { u"quickContactBadgeStyleSmallWindowSmall", 6 }, + { u"quickContactBadgeStyleSmallWindowMedium", 6 }, + { u"quickContactBadgeStyleSmallWindowLarge", 6 }, + { u"author", 7 }, + { u"autoStart", 7 }, + { u"expandableListViewWhiteStyle", 8 }, + { u"installLocation", 8 }, + { u"vmSafeMode", 8 }, + { u"webTextViewStyle", 8 }, + { u"restoreAnyVersion", 8 }, + { u"tabStripLeft", 8 }, + { u"tabStripRight", 8 }, + { u"tabStripEnabled", 8 }, + { u"logo", 9 }, + { u"xlargeScreens", 9 }, + { u"immersive", 9 }, + { u"overScrollMode", 9 }, + { u"overScrollHeader", 9 }, + { u"overScrollFooter", 9 }, + { u"filterTouchesWhenObscured", 9 }, + { u"textSelectHandleLeft", 9 }, + { u"textSelectHandleRight", 9 }, + { u"textSelectHandle", 9 }, + { u"textSelectHandleWindowStyle", 9 }, + { u"popupAnimationStyle", 9 }, + { u"screenSize", 9 }, + { u"screenDensity", 9 }, + { u"allContactsName", 11 }, + { u"windowActionBar", 11 }, + { u"actionBarStyle", 11 }, + { u"navigationMode", 11 }, + { u"displayOptions", 11 }, + { u"subtitle", 11 }, + { u"customNavigationLayout", 11 }, + { u"hardwareAccelerated", 11 }, + { u"measureWithLargestChild", 11 }, + { u"animateFirstView", 11 }, + { u"dropDownSpinnerStyle", 11 }, + { u"actionDropDownStyle", 11 }, + { u"actionButtonStyle", 11 }, + { u"showAsAction", 11 }, + { u"previewImage", 11 }, + { u"actionModeBackground", 11 }, + { u"actionModeCloseDrawable", 11 }, + { u"windowActionModeOverlay", 11 }, + { u"valueFrom", 11 }, + { u"valueTo", 11 }, + { u"valueType", 11 }, + { u"propertyName", 11 }, + { u"ordering", 11 }, + { u"fragment", 11 }, + { u"windowActionBarOverlay", 11 }, + { u"fragmentOpenEnterAnimation", 11 }, + { u"fragmentOpenExitAnimation", 11 }, + { u"fragmentCloseEnterAnimation", 11 }, + { u"fragmentCloseExitAnimation", 11 }, + { u"fragmentFadeEnterAnimation", 11 }, + { u"fragmentFadeExitAnimation", 11 }, + { u"actionBarSize", 11 }, + { u"imeSubtypeLocale", 11 }, + { u"imeSubtypeMode", 11 }, + { u"imeSubtypeExtraValue", 11 }, + { u"splitMotionEvents", 11 }, + { u"listChoiceBackgroundIndicator", 11 }, + { u"spinnerMode", 11 }, + { u"animateLayoutChanges", 11 }, + { u"actionBarTabStyle", 11 }, + { u"actionBarTabBarStyle", 11 }, + { u"actionBarTabTextStyle", 11 }, + { u"actionOverflowButtonStyle", 11 }, + { u"actionModeCloseButtonStyle", 11 }, + { u"titleTextStyle", 11 }, + { u"subtitleTextStyle", 11 }, + { u"iconifiedByDefault", 11 }, + { u"actionLayout", 11 }, + { u"actionViewClass", 11 }, + { u"activatedBackgroundIndicator", 11 }, + { u"state_activated", 11 }, + { u"listPopupWindowStyle", 11 }, + { u"popupMenuStyle", 11 }, + { u"textAppearanceLargePopupMenu", 11 }, + { u"textAppearanceSmallPopupMenu", 11 }, + { u"breadCrumbTitle", 11 }, + { u"breadCrumbShortTitle", 11 }, + { u"listDividerAlertDialog", 11 }, + { u"textColorAlertDialogListItem", 11 }, + { u"loopViews", 11 }, + { u"dialogTheme", 11 }, + { u"alertDialogTheme", 11 }, + { u"dividerVertical", 11 }, + { u"homeAsUpIndicator", 11 }, + { u"enterFadeDuration", 11 }, + { u"exitFadeDuration", 11 }, + { u"selectableItemBackground", 11 }, + { u"autoAdvanceViewId", 11 }, + { u"useIntrinsicSizeAsMinimum", 11 }, + { u"actionModeCutDrawable", 11 }, + { u"actionModeCopyDrawable", 11 }, + { u"actionModePasteDrawable", 11 }, + { u"textEditPasteWindowLayout", 11 }, + { u"textEditNoPasteWindowLayout", 11 }, + { u"textIsSelectable", 11 }, + { u"windowEnableSplitTouch", 11 }, + { u"indeterminateProgressStyle", 11 }, + { u"progressBarPadding", 11 }, + { u"animationResolution", 11 }, + { u"state_accelerated", 11 }, + { u"baseline", 11 }, + { u"homeLayout", 11 }, + { u"opacity", 11 }, + { u"alpha", 11 }, + { u"transformPivotX", 11 }, + { u"transformPivotY", 11 }, + { u"translationX", 11 }, + { u"translationY", 11 }, + { u"scaleX", 11 }, + { u"scaleY", 11 }, + { u"rotation", 11 }, + { u"rotationX", 11 }, + { u"rotationY", 11 }, + { u"showDividers", 11 }, + { u"dividerPadding", 11 }, + { u"borderlessButtonStyle", 11 }, + { u"dividerHorizontal", 11 }, + { u"itemPadding", 11 }, + { u"buttonBarStyle", 11 }, + { u"buttonBarButtonStyle", 11 }, + { u"segmentedButtonStyle", 11 }, + { u"staticWallpaperPreview", 11 }, + { u"allowParallelSyncs", 11 }, + { u"isAlwaysSyncable", 11 }, + { u"verticalScrollbarPosition", 11 }, + { u"fastScrollAlwaysVisible", 11 }, + { u"fastScrollThumbDrawable", 11 }, + { u"fastScrollPreviewBackgroundLeft", 11 }, + { u"fastScrollPreviewBackgroundRight", 11 }, + { u"fastScrollTrackDrawable", 11 }, + { u"fastScrollOverlayPosition", 11 }, + { u"customTokens", 11 }, + { u"nextFocusForward", 11 }, + { u"firstDayOfWeek", 11 }, + { u"showWeekNumber", 11 }, + { u"minDate", 11 }, + { u"maxDate", 11 }, + { u"shownWeekCount", 11 }, + { u"selectedWeekBackgroundColor", 11 }, + { u"focusedMonthDateColor", 11 }, + { u"unfocusedMonthDateColor", 11 }, + { u"weekNumberColor", 11 }, + { u"weekSeparatorLineColor", 11 }, + { u"selectedDateVerticalBar", 11 }, + { u"weekDayTextAppearance", 11 }, + { u"dateTextAppearance", 11 }, + { u"solidColor", 11 }, + { u"spinnersShown", 11 }, + { u"calendarViewShown", 11 }, + { u"state_multiline", 11 }, + { u"detailsElementBackground", 11 }, + { u"textColorHighlightInverse", 11 }, + { u"textColorLinkInverse", 11 }, + { u"editTextColor", 11 }, + { u"editTextBackground", 11 }, + { u"horizontalScrollViewStyle", 11 }, + { u"layerType", 11 }, + { u"alertDialogIcon", 11 }, + { u"windowMinWidthMajor", 11 }, + { u"windowMinWidthMinor", 11 }, + { u"queryHint", 11 }, + { u"fastScrollTextColor", 11 }, + { u"largeHeap", 11 }, + { u"windowCloseOnTouchOutside", 11 }, + { u"datePickerStyle", 11 }, + { u"calendarViewStyle", 11 }, + { u"textEditSidePasteWindowLayout", 11 }, + { u"textEditSideNoPasteWindowLayout", 11 }, + { u"actionMenuTextAppearance", 11 }, + { u"actionMenuTextColor", 11 }, + { u"textCursorDrawable", 12 }, + { u"resizeMode", 12 }, + { u"requiresSmallestWidthDp", 12 }, + { u"compatibleWidthLimitDp", 12 }, + { u"largestWidthLimitDp", 12 }, + { u"state_hovered", 13 }, + { u"state_drag_can_accept", 13 }, + { u"state_drag_hovered", 13 }, + { u"stopWithTask", 13 }, + { u"switchTextOn", 13 }, + { u"switchTextOff", 13 }, + { u"switchPreferenceStyle", 13 }, + { u"switchTextAppearance", 13 }, + { u"track", 13 }, + { u"switchMinWidth", 13 }, + { u"switchPadding", 13 }, + { u"thumbTextPadding", 13 }, + { u"textSuggestionsWindowStyle", 13 }, + { u"textEditSuggestionItemLayout", 13 }, + { u"rowCount", 13 }, + { u"rowOrderPreserved", 13 }, + { u"columnCount", 13 }, + { u"columnOrderPreserved", 13 }, + { u"useDefaultMargins", 13 }, + { u"alignmentMode", 13 }, + { u"layout_row", 13 }, + { u"layout_rowSpan", 13 }, + { u"layout_columnSpan", 13 }, + { u"actionModeSelectAllDrawable", 13 }, + { u"isAuxiliary", 13 }, + { u"accessibilityEventTypes", 13 }, + { u"packageNames", 13 }, + { u"accessibilityFeedbackType", 13 }, + { u"notificationTimeout", 13 }, + { u"accessibilityFlags", 13 }, + { u"canRetrieveWindowContent", 13 }, + { u"listPreferredItemHeightLarge", 13 }, + { u"listPreferredItemHeightSmall", 13 }, + { u"actionBarSplitStyle", 13 }, + { u"actionProviderClass", 13 }, + { u"backgroundStacked", 13 }, + { u"backgroundSplit", 13 }, + { u"textAllCaps", 13 }, + { u"colorPressedHighlight", 13 }, + { u"colorLongPressedHighlight", 13 }, + { u"colorFocusedHighlight", 13 }, + { u"colorActivatedHighlight", 13 }, + { u"colorMultiSelectHighlight", 13 }, + { u"drawableStart", 13 }, + { u"drawableEnd", 13 }, + { u"actionModeStyle", 13 }, + { u"minResizeWidth", 13 }, + { u"minResizeHeight", 13 }, + { u"actionBarWidgetTheme", 13 }, + { u"uiOptions", 13 }, + { u"subtypeLocale", 13 }, + { u"subtypeExtraValue", 13 }, + { u"actionBarDivider", 13 }, + { u"actionBarItemBackground", 13 }, + { u"actionModeSplitBackground", 13 }, + { u"textAppearanceListItem", 13 }, + { u"textAppearanceListItemSmall", 13 }, + { u"targetDescriptions", 13 }, + { u"directionDescriptions", 13 }, + { u"overridesImplicitlyEnabledSubtype", 13 }, + { u"listPreferredItemPaddingLeft", 13 }, + { u"listPreferredItemPaddingRight", 13 }, + { u"requiresFadingEdge", 13 }, + { u"publicKey", 13 }, + { u"parentActivityName", 16 }, + { u"isolatedProcess", 16 }, + { u"importantForAccessibility", 16 }, + { u"keyboardLayout", 16 }, + { u"fontFamily", 16 }, + { u"mediaRouteButtonStyle", 16 }, + { u"mediaRouteTypes", 16 }, + { u"supportsRtl", 17 }, + { u"textDirection", 17 }, + { u"textAlignment", 17 }, + { u"layoutDirection", 17 }, + { u"paddingStart", 17 }, + { u"paddingEnd", 17 }, + { u"layout_marginStart", 17 }, + { u"layout_marginEnd", 17 }, + { u"layout_toStartOf", 17 }, + { u"layout_toEndOf", 17 }, + { u"layout_alignStart", 17 }, + { u"layout_alignEnd", 17 }, + { u"layout_alignParentStart", 17 }, + { u"layout_alignParentEnd", 17 }, + { u"listPreferredItemPaddingStart", 17 }, + { u"listPreferredItemPaddingEnd", 17 }, + { u"singleUser", 17 }, + { u"presentationTheme", 17 }, + { u"subtypeId", 17 }, + { u"initialKeyguardLayout", 17 }, + { u"widgetCategory", 17 }, + { u"permissionGroupFlags", 17 }, + { u"labelFor", 17 }, + { u"permissionFlags", 17 }, + { u"checkedTextViewStyle", 17 }, + { u"showOnLockScreen", 17 }, + { u"format12Hour", 17 }, + { u"format24Hour", 17 }, + { u"timeZone", 17 }, + { u"mipMap", 18 }, + { u"mirrorForRtl", 18 }, + { u"windowOverscan", 18 }, + { u"requiredForAllUsers", 18 }, + { u"indicatorStart", 18 }, + { u"indicatorEnd", 18 }, + { u"childIndicatorStart", 18 }, + { u"childIndicatorEnd", 18 }, + { u"restrictedAccountType", 18 }, + { u"requiredAccountType", 18 }, + { u"canRequestTouchExplorationMode", 18 }, + { u"canRequestEnhancedWebAccessibility", 18 }, + { u"canRequestFilterKeyEvents", 18 }, + { u"layoutMode", 18 }, + { u"keySet", 19 }, + { u"targetId", 19 }, + { u"fromScene", 19 }, + { u"toScene", 19 }, + { u"transition", 19 }, + { u"transitionOrdering", 19 }, + { u"fadingMode", 19 }, + { u"startDelay", 19 }, + { u"ssp", 19 }, + { u"sspPrefix", 19 }, + { u"sspPattern", 19 }, + { u"addPrintersActivity", 19 }, + { u"vendor", 19 }, + { u"category", 19 }, + { u"isAsciiCapable", 19 }, + { u"autoMirrored", 19 }, + { u"supportsSwitchingToNextInputMethod", 19 }, + { u"requireDeviceUnlock", 19 }, + { u"apduServiceBanner", 19 }, + { u"accessibilityLiveRegion", 19 }, + { u"windowTranslucentStatus", 19 }, + { u"windowTranslucentNavigation", 19 }, + { u"advancedPrintOptionsActivity", 19 }, + { u"banner", 20 }, + { u"windowSwipeToDismiss", 20 }, + { u"isGame", 20 }, + { u"allowEmbedded", 20 }, + { u"setupActivity", 20 }, + { u"fastScrollStyle", 21 }, + { u"windowContentTransitions", 21 }, + { u"windowContentTransitionManager", 21 }, + { u"translationZ", 21 }, + { u"tintMode", 21 }, + { u"controlX1", 21 }, + { u"controlY1", 21 }, + { u"controlX2", 21 }, + { u"controlY2", 21 }, + { u"transitionName", 21 }, + { u"transitionGroup", 21 }, + { u"viewportWidth", 21 }, + { u"viewportHeight", 21 }, + { u"fillColor", 21 }, + { u"pathData", 21 }, + { u"strokeColor", 21 }, + { u"strokeWidth", 21 }, + { u"trimPathStart", 21 }, + { u"trimPathEnd", 21 }, + { u"trimPathOffset", 21 }, + { u"strokeLineCap", 21 }, + { u"strokeLineJoin", 21 }, + { u"strokeMiterLimit", 21 }, + { u"colorControlNormal", 21 }, + { u"colorControlActivated", 21 }, + { u"colorButtonNormal", 21 }, + { u"colorControlHighlight", 21 }, + { u"persistableMode", 21 }, + { u"titleTextAppearance", 21 }, + { u"subtitleTextAppearance", 21 }, + { u"slideEdge", 21 }, + { u"actionBarTheme", 21 }, + { u"textAppearanceListItemSecondary", 21 }, + { u"colorPrimary", 21 }, + { u"colorPrimaryDark", 21 }, + { u"colorAccent", 21 }, + { u"nestedScrollingEnabled", 21 }, + { u"windowEnterTransition", 21 }, + { u"windowExitTransition", 21 }, + { u"windowSharedElementEnterTransition", 21 }, + { u"windowSharedElementExitTransition", 21 }, + { u"windowAllowReturnTransitionOverlap", 21 }, + { u"windowAllowEnterTransitionOverlap", 21 }, + { u"sessionService", 21 }, + { u"stackViewStyle", 21 }, + { u"switchStyle", 21 }, + { u"elevation", 21 }, + { u"excludeId", 21 }, + { u"excludeClass", 21 }, + { u"hideOnContentScroll", 21 }, + { u"actionOverflowMenuStyle", 21 }, + { u"documentLaunchMode", 21 }, + { u"maxRecents", 21 }, + { u"autoRemoveFromRecents", 21 }, + { u"stateListAnimator", 21 }, + { u"toId", 21 }, + { u"fromId", 21 }, + { u"reversible", 21 }, + { u"splitTrack", 21 }, + { u"targetName", 21 }, + { u"excludeName", 21 }, + { u"matchOrder", 21 }, + { u"windowDrawsSystemBarBackgrounds", 21 }, + { u"statusBarColor", 21 }, + { u"navigationBarColor", 21 }, + { u"contentInsetStart", 21 }, + { u"contentInsetEnd", 21 }, + { u"contentInsetLeft", 21 }, + { u"contentInsetRight", 21 }, + { u"paddingMode", 21 }, + { u"layout_rowWeight", 21 }, + { u"layout_columnWeight", 21 }, + { u"translateX", 21 }, + { u"translateY", 21 }, + { u"selectableItemBackgroundBorderless", 21 }, + { u"elegantTextHeight", 21 }, + { u"searchKeyphraseId", 21 }, + { u"searchKeyphrase", 21 }, + { u"searchKeyphraseSupportedLocales", 21 }, + { u"windowTransitionBackgroundFadeDuration", 21 }, + { u"overlapAnchor", 21 }, + { u"progressTint", 21 }, + { u"progressTintMode", 21 }, + { u"progressBackgroundTint", 21 }, + { u"progressBackgroundTintMode", 21 }, + { u"secondaryProgressTint", 21 }, + { u"secondaryProgressTintMode", 21 }, + { u"indeterminateTint", 21 }, + { u"indeterminateTintMode", 21 }, + { u"backgroundTint", 21 }, + { u"backgroundTintMode", 21 }, + { u"foregroundTint", 21 }, + { u"foregroundTintMode", 21 }, + { u"buttonTint", 21 }, + { u"buttonTintMode", 21 }, + { u"thumbTint", 21 }, + { u"thumbTintMode", 21 }, + { u"fullBackupOnly", 21 }, + { u"propertyXName", 21 }, + { u"propertyYName", 21 }, + { u"relinquishTaskIdentity", 21 }, + { u"tileModeX", 21 }, + { u"tileModeY", 21 }, + { u"actionModeShareDrawable", 21 }, + { u"actionModeFindDrawable", 21 }, + { u"actionModeWebSearchDrawable", 21 }, + { u"transitionVisibilityMode", 21 }, + { u"minimumHorizontalAngle", 21 }, + { u"minimumVerticalAngle", 21 }, + { u"maximumAngle", 21 }, + { u"searchViewStyle", 21 }, + { u"closeIcon", 21 }, + { u"goIcon", 21 }, + { u"searchIcon", 21 }, + { u"voiceIcon", 21 }, + { u"commitIcon", 21 }, + { u"suggestionRowLayout", 21 }, + { u"queryBackground", 21 }, + { u"submitBackground", 21 }, + { u"buttonBarPositiveButtonStyle", 21 }, + { u"buttonBarNeutralButtonStyle", 21 }, + { u"buttonBarNegativeButtonStyle", 21 }, + { u"popupElevation", 21 }, + { u"actionBarPopupTheme", 21 }, + { u"multiArch", 21 }, + { u"touchscreenBlocksFocus", 21 }, + { u"windowElevation", 21 }, + { u"launchTaskBehindTargetAnimation", 21 }, + { u"launchTaskBehindSourceAnimation", 21 }, + { u"restrictionType", 21 }, + { u"dayOfWeekBackground", 21 }, + { u"dayOfWeekTextAppearance", 21 }, + { u"headerMonthTextAppearance", 21 }, + { u"headerDayOfMonthTextAppearance", 21 }, + { u"headerYearTextAppearance", 21 }, + { u"yearListItemTextAppearance", 21 }, + { u"yearListSelectorColor", 21 }, + { u"calendarTextColor", 21 }, + { u"recognitionService", 21 }, + { u"timePickerStyle", 21 }, + { u"timePickerDialogTheme", 21 }, + { u"headerTimeTextAppearance", 21 }, + { u"headerAmPmTextAppearance", 21 }, + { u"numbersTextColor", 21 }, + { u"numbersBackgroundColor", 21 }, + { u"numbersSelectorColor", 21 }, + { u"amPmTextColor", 21 }, + { u"amPmBackgroundColor", 21 }, + { u"searchKeyphraseRecognitionFlags", 21 }, + { u"checkMarkTint", 21 }, + { u"checkMarkTintMode", 21 }, + { u"popupTheme", 21 }, + { u"toolbarStyle", 21 }, + { u"windowClipToOutline", 21 }, + { u"datePickerDialogTheme", 21 }, + { u"showText", 21 }, + { u"windowReturnTransition", 21 }, + { u"windowReenterTransition", 21 }, + { u"windowSharedElementReturnTransition", 21 }, + { u"windowSharedElementReenterTransition", 21 }, + { u"resumeWhilePausing", 21 }, + { u"datePickerMode", 21 }, + { u"timePickerMode", 21 }, + { u"inset", 21 }, + { u"letterSpacing", 21 }, + { u"fontFeatureSettings", 21 }, + { u"outlineProvider", 21 }, + { u"contentAgeHint", 21 }, + { u"country", 21 }, + { u"windowSharedElementsUseOverlay", 21 }, + { u"reparent", 21 }, + { u"reparentWithOverlay", 21 }, + { u"ambientShadowAlpha", 21 }, + { u"spotShadowAlpha", 21 }, + { u"navigationIcon", 21 }, + { u"navigationContentDescription", 21 }, + { u"fragmentExitTransition", 21 }, + { u"fragmentEnterTransition", 21 }, + { u"fragmentSharedElementEnterTransition", 21 }, + { u"fragmentReturnTransition", 21 }, + { u"fragmentSharedElementReturnTransition", 21 }, + { u"fragmentReenterTransition", 21 }, + { u"fragmentAllowEnterTransitionOverlap", 21 }, + { u"fragmentAllowReturnTransitionOverlap", 21 }, + { u"patternPathData", 21 }, + { u"strokeAlpha", 21 }, + { u"fillAlpha", 21 }, + { u"windowActivityTransitions", 21 }, + { u"colorEdgeEffect", 21 } +}; + +size_t findAttributeSdkLevel(const ResourceName& name) { + if (name.package != u"android" && name.type != ResourceType::kAttr) { + return 0; + } + + auto iter = sAttrMap.find(name.entry); + if (iter != sAttrMap.end()) { + return iter->second; + } + return SDK_LOLLIPOP_MR1; +} + +} // namespace aapt diff --git a/tools/aapt2/SdkConstants.h b/tools/aapt2/SdkConstants.h new file mode 100644 index 0000000..803da03 --- /dev/null +++ b/tools/aapt2/SdkConstants.h @@ -0,0 +1,52 @@ +/* + * 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_SDK_CONSTANTS_H +#define AAPT_SDK_CONSTANTS_H + +#include "Resource.h" + +namespace aapt { + +enum { + SDK_CUPCAKE = 3, + SDK_DONUT = 4, + SDK_ECLAIR = 5, + SDK_ECLAIR_0_1 = 6, + SDK_ECLAIR_MR1 = 7, + SDK_FROYO = 8, + SDK_GINGERBREAD = 9, + SDK_GINGERBREAD_MR1 = 10, + SDK_HONEYCOMB = 11, + SDK_HONEYCOMB_MR1 = 12, + SDK_HONEYCOMB_MR2 = 13, + SDK_ICE_CREAM_SANDWICH = 14, + SDK_ICE_CREAM_SANDWICH_MR1 = 15, + SDK_JELLY_BEAN = 16, + SDK_JELLY_BEAN_MR1 = 17, + SDK_JELLY_BEAN_MR2 = 18, + SDK_KITKAT = 19, + SDK_KITKAT_WATCH = 20, + SDK_LOLLIPOP = 21, + SDK_LOLLIPOP_MR1 = 22, +}; + +size_t findAttributeSdkLevel(ResourceId id); +size_t findAttributeSdkLevel(const ResourceName& name); + +} // namespace aapt + +#endif // AAPT_SDK_CONSTANTS_H diff --git a/tools/aapt2/Source.h b/tools/aapt2/Source.h new file mode 100644 index 0000000..3606488 --- /dev/null +++ b/tools/aapt2/Source.h @@ -0,0 +1,90 @@ +/* + * 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_SOURCE_H +#define AAPT_SOURCE_H + +#include <ostream> +#include <string> +#include <tuple> + +namespace aapt { + +struct SourceLineColumn; +struct SourceLine; + +/** + * Represents a file on disk. Used for logging and + * showing errors. + */ +struct Source { + std::string path; + + inline SourceLine line(size_t line) const; +}; + +/** + * Represents a file on disk and a line number in that file. + * Used for logging and showing errors. + */ +struct SourceLine { + std::string path; + size_t line; + + inline SourceLineColumn column(size_t column) const; +}; + +/** + * Represents a file on disk and a line:column number in that file. + * Used for logging and showing errors. + */ +struct SourceLineColumn { + std::string path; + size_t line; + size_t column; +}; + +// +// Implementations +// + +SourceLine Source::line(size_t line) const { + return SourceLine{ path, line }; +} + +SourceLineColumn SourceLine::column(size_t column) const { + return SourceLineColumn{ path, line, column }; +} + +inline ::std::ostream& operator<<(::std::ostream& out, const Source& source) { + return out << source.path; +} + +inline ::std::ostream& operator<<(::std::ostream& out, const SourceLine& source) { + return out << source.path << ":" << source.line; +} + +inline ::std::ostream& operator<<(::std::ostream& out, const SourceLineColumn& source) { + return out << source.path << ":" << source.line << ":" << source.column; +} + +inline bool operator<(const SourceLine& lhs, const SourceLine& rhs) { + return std::tie(lhs.path, lhs.line) < std::tie(rhs.path, rhs.line); +} + +} // namespace aapt + +#endif // AAPT_SOURCE_H diff --git a/tools/aapt2/SourceXmlPullParser.cpp b/tools/aapt2/SourceXmlPullParser.cpp new file mode 100644 index 0000000..8099044 --- /dev/null +++ b/tools/aapt2/SourceXmlPullParser.cpp @@ -0,0 +1,283 @@ +/* + * 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 <iostream> +#include <string> + +#include "Maybe.h" +#include "SourceXmlPullParser.h" +#include "Util.h" + +namespace aapt { + +constexpr char kXmlNamespaceSep = 1; + +SourceXmlPullParser::SourceXmlPullParser(std::istream& in) : mIn(in), mEmpty(), mDepth(0) { + mParser = XML_ParserCreateNS(nullptr, kXmlNamespaceSep); + XML_SetUserData(mParser, this); + XML_SetElementHandler(mParser, startElementHandler, endElementHandler); + XML_SetNamespaceDeclHandler(mParser, startNamespaceHandler, endNamespaceHandler); + XML_SetCharacterDataHandler(mParser, characterDataHandler); + XML_SetCommentHandler(mParser, commentDataHandler); + mEventQueue.push(EventData{ Event::kStartDocument, 0, mDepth++ }); +} + +SourceXmlPullParser::~SourceXmlPullParser() { + XML_ParserFree(mParser); +} + +SourceXmlPullParser::Event SourceXmlPullParser::next() { + const Event currentEvent = getEvent(); + if (currentEvent == Event::kBadDocument || currentEvent == Event::kEndDocument) { + return currentEvent; + } + + mEventQueue.pop(); + while (mEventQueue.empty()) { + mIn.read(mBuffer, sizeof(mBuffer) / sizeof(*mBuffer)); + + const bool done = mIn.eof(); + if (mIn.bad() && !done) { + mLastError = strerror(errno); + mEventQueue.push(EventData{ Event::kBadDocument }); + continue; + } + + if (XML_Parse(mParser, mBuffer, mIn.gcount(), done) == XML_STATUS_ERROR) { + mLastError = XML_ErrorString(XML_GetErrorCode(mParser)); + mEventQueue.push(EventData{ Event::kBadDocument }); + continue; + } + + if (done) { + mEventQueue.push(EventData{ Event::kEndDocument, 0, 0 }); + } + } + + Event event = getEvent(); + + // Record namespace prefixes and package names so that we can do our own + // handling of references that use namespace aliases. + if (event == Event::kStartNamespace || event == Event::kEndNamespace) { + Maybe<std::u16string> result = util::extractPackageFromNamespace(getNamespaceUri()); + if (event == Event::kStartNamespace) { + if (result) { + mPackageAliases.emplace_back(getNamespacePrefix(), result.value()); + } + } else { + if (result) { + assert(mPackageAliases.back().second == result.value()); + mPackageAliases.pop_back(); + } + } + } + + return event; +} + +SourceXmlPullParser::Event SourceXmlPullParser::getEvent() const { + return mEventQueue.front().event; +} + +const std::string& SourceXmlPullParser::getLastError() const { + return mLastError; +} + +const std::u16string& SourceXmlPullParser::getComment() const { + return mEventQueue.front().comment; +} + +size_t SourceXmlPullParser::getLineNumber() const { + return mEventQueue.front().lineNumber; +} + +size_t SourceXmlPullParser::getDepth() const { + return mEventQueue.front().depth; +} + +const std::u16string& SourceXmlPullParser::getText() const { + if (getEvent() != Event::kText) { + return mEmpty; + } + return mEventQueue.front().data1; +} + +const std::u16string& SourceXmlPullParser::getNamespacePrefix() const { + const Event currentEvent = getEvent(); + if (currentEvent != Event::kStartNamespace && currentEvent != Event::kEndNamespace) { + return mEmpty; + } + return mEventQueue.front().data1; +} + +const std::u16string& SourceXmlPullParser::getNamespaceUri() const { + const Event currentEvent = getEvent(); + if (currentEvent != Event::kStartNamespace && currentEvent != Event::kEndNamespace) { + return mEmpty; + } + return mEventQueue.front().data2; +} + +bool SourceXmlPullParser::applyPackageAlias(std::u16string* package, + const std::u16string& defaultPackage) const { + const auto endIter = mPackageAliases.rend(); + for (auto iter = mPackageAliases.rbegin(); iter != endIter; ++iter) { + if (iter->first == *package) { + if (iter->second.empty()) { + *package = defaultPackage; + } else { + *package = iter->second; + } + return true; + } + } + return false; +} + +const std::u16string& SourceXmlPullParser::getElementNamespace() const { + const Event currentEvent = getEvent(); + if (currentEvent != Event::kStartElement && currentEvent != Event::kEndElement) { + return mEmpty; + } + return mEventQueue.front().data1; +} + +const std::u16string& SourceXmlPullParser::getElementName() const { + const Event currentEvent = getEvent(); + if (currentEvent != Event::kStartElement && currentEvent != Event::kEndElement) { + return mEmpty; + } + return mEventQueue.front().data2; +} + +XmlPullParser::const_iterator SourceXmlPullParser::beginAttributes() const { + return mEventQueue.front().attributes.begin(); +} + +XmlPullParser::const_iterator SourceXmlPullParser::endAttributes() const { + return mEventQueue.front().attributes.end(); +} + +size_t SourceXmlPullParser::getAttributeCount() const { + if (getEvent() != Event::kStartElement) { + return 0; + } + return mEventQueue.front().attributes.size(); +} + +/** + * Extracts the namespace and name of an expanded element or attribute name. + */ +static void splitName(const char* name, std::u16string& outNs, std::u16string& outName) { + const char* p = name; + while (*p != 0 && *p != kXmlNamespaceSep) { + p++; + } + + if (*p == 0) { + outNs = std::u16string(); + outName = util::utf8ToUtf16(name); + } else { + outNs = util::utf8ToUtf16(StringPiece(name, (p - name))); + outName = util::utf8ToUtf16(p + 1); + } +} + +void XMLCALL SourceXmlPullParser::startNamespaceHandler(void* userData, const char* prefix, + const char* uri) { + SourceXmlPullParser* parser = reinterpret_cast<SourceXmlPullParser*>(userData); + std::u16string namespaceUri = uri != nullptr ? util::utf8ToUtf16(uri) : std::u16string(); + parser->mNamespaceUris.push(namespaceUri); + parser->mEventQueue.push(EventData{ + Event::kStartNamespace, + XML_GetCurrentLineNumber(parser->mParser), + parser->mDepth++, + prefix != nullptr ? util::utf8ToUtf16(prefix) : std::u16string(), + namespaceUri + }); +} + +void XMLCALL SourceXmlPullParser::startElementHandler(void* userData, const char* name, + const char** attrs) { + SourceXmlPullParser* parser = reinterpret_cast<SourceXmlPullParser*>(userData); + + EventData data = { + Event::kStartElement, XML_GetCurrentLineNumber(parser->mParser), parser->mDepth++ + }; + splitName(name, data.data1, data.data2); + + while (*attrs) { + Attribute attribute; + splitName(*attrs++, attribute.namespaceUri, attribute.name); + attribute.value = util::utf8ToUtf16(*attrs++); + + // Insert in sorted order. + auto iter = std::lower_bound(data.attributes.begin(), data.attributes.end(), attribute); + data.attributes.insert(iter, std::move(attribute)); + } + + // Move the structure into the queue (no copy). + parser->mEventQueue.push(std::move(data)); +} + +void XMLCALL SourceXmlPullParser::characterDataHandler(void* userData, const char* s, int len) { + SourceXmlPullParser* parser = reinterpret_cast<SourceXmlPullParser*>(userData); + + parser->mEventQueue.push(EventData{ + Event::kText, + XML_GetCurrentLineNumber(parser->mParser), + parser->mDepth, + util::utf8ToUtf16(StringPiece(s, len)) + }); +} + +void XMLCALL SourceXmlPullParser::endElementHandler(void* userData, const char* name) { + SourceXmlPullParser* parser = reinterpret_cast<SourceXmlPullParser*>(userData); + + EventData data = { + Event::kEndElement, XML_GetCurrentLineNumber(parser->mParser), --(parser->mDepth) + }; + splitName(name, data.data1, data.data2); + + // Move the data into the queue (no copy). + parser->mEventQueue.push(std::move(data)); +} + +void XMLCALL SourceXmlPullParser::endNamespaceHandler(void* userData, const char* prefix) { + SourceXmlPullParser* parser = reinterpret_cast<SourceXmlPullParser*>(userData); + + parser->mEventQueue.push(EventData{ + Event::kEndNamespace, + XML_GetCurrentLineNumber(parser->mParser), + --(parser->mDepth), + prefix != nullptr ? util::utf8ToUtf16(prefix) : std::u16string(), + parser->mNamespaceUris.top() + }); + parser->mNamespaceUris.pop(); +} + +void XMLCALL SourceXmlPullParser::commentDataHandler(void* userData, const char* comment) { + SourceXmlPullParser* parser = reinterpret_cast<SourceXmlPullParser*>(userData); + + parser->mEventQueue.push(EventData{ + Event::kComment, + XML_GetCurrentLineNumber(parser->mParser), + parser->mDepth, + util::utf8ToUtf16(comment) + }); +} + +} // namespace aapt diff --git a/tools/aapt2/SourceXmlPullParser.h b/tools/aapt2/SourceXmlPullParser.h new file mode 100644 index 0000000..15936d6 --- /dev/null +++ b/tools/aapt2/SourceXmlPullParser.h @@ -0,0 +1,91 @@ +/* + * 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_SOURCE_XML_PULL_PARSER_H +#define AAPT_SOURCE_XML_PULL_PARSER_H + +#include "XmlPullParser.h" + +#include <istream> +#include <libexpat/expat.h> +#include <queue> +#include <stack> +#include <string> +#include <vector> + +namespace aapt { + +class SourceXmlPullParser : public XmlPullParser { +public: + SourceXmlPullParser(std::istream& in); + SourceXmlPullParser(const SourceXmlPullParser& rhs) = delete; + ~SourceXmlPullParser(); + + Event getEvent() const override; + const std::string& getLastError() const override ; + Event next() override ; + + const std::u16string& getComment() const override; + size_t getLineNumber() const override; + size_t getDepth() const override; + + const std::u16string& getText() const override; + + const std::u16string& getNamespacePrefix() const override; + const std::u16string& getNamespaceUri() const override; + bool applyPackageAlias(std::u16string* package, + const std::u16string& defaultPackage) const override; + + + const std::u16string& getElementNamespace() const override; + const std::u16string& getElementName() const override; + + const_iterator beginAttributes() const override; + const_iterator endAttributes() const override; + size_t getAttributeCount() const override; + +private: + static void XMLCALL startNamespaceHandler(void* userData, const char* prefix, const char* uri); + static void XMLCALL startElementHandler(void* userData, const char* name, const char** attrs); + static void XMLCALL characterDataHandler(void* userData, const char* s, int len); + static void XMLCALL endElementHandler(void* userData, const char* name); + static void XMLCALL endNamespaceHandler(void* userData, const char* prefix); + static void XMLCALL commentDataHandler(void* userData, const char* comment); + + struct EventData { + Event event; + size_t lineNumber; + size_t depth; + std::u16string data1; + std::u16string data2; + std::u16string comment; + std::vector<Attribute> attributes; + }; + + std::istream& mIn; + XML_Parser mParser; + char mBuffer[16384]; + std::queue<EventData> mEventQueue; + std::string mLastError; + const std::u16string mEmpty; + size_t mDepth; + std::stack<std::u16string> mNamespaceUris; + std::vector<std::pair<std::u16string, std::u16string>> mPackageAliases; +}; + +} // namespace aapt + +#endif // AAPT_SOURCE_XML_PULL_PARSER_H diff --git a/tools/aapt2/StringPiece.h b/tools/aapt2/StringPiece.h new file mode 100644 index 0000000..e2a1597 --- /dev/null +++ b/tools/aapt2/StringPiece.h @@ -0,0 +1,232 @@ +/* + * 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_STRING_PIECE_H +#define AAPT_STRING_PIECE_H + +#include <ostream> +#include <string> +#include <utils/String8.h> +#include <utils/Unicode.h> + +namespace aapt { + +/** + * Read only wrapper around basic C strings. + * Prevents excessive copying. + * + * WARNING: When creating from std::basic_string<>, moving the original + * std::basic_string<> will invalidate the data held in a BasicStringPiece<>. + * BasicStringPiece<> should only be used transitively. + */ +template <typename TChar> +class BasicStringPiece { +public: + using const_iterator = const TChar*; + + BasicStringPiece(); + BasicStringPiece(const BasicStringPiece<TChar>& str); + BasicStringPiece(const std::basic_string<TChar>& str); + BasicStringPiece(const TChar* str); + BasicStringPiece(const TChar* str, size_t len); + + BasicStringPiece<TChar>& operator=(const BasicStringPiece<TChar>& rhs); + BasicStringPiece<TChar>& assign(const TChar* str, size_t len); + + BasicStringPiece<TChar> substr(size_t start, size_t len) const; + BasicStringPiece<TChar> substr(BasicStringPiece<TChar>::const_iterator begin, + BasicStringPiece<TChar>::const_iterator end) const; + + const TChar* data() const; + size_t length() const; + size_t size() const; + bool empty() const; + std::basic_string<TChar> toString() const; + + int compare(const BasicStringPiece<TChar>& rhs) const; + bool operator<(const BasicStringPiece<TChar>& rhs) const; + bool operator>(const BasicStringPiece<TChar>& rhs) const; + bool operator==(const BasicStringPiece<TChar>& rhs) const; + bool operator!=(const BasicStringPiece<TChar>& rhs) const; + + const_iterator begin() const; + const_iterator end() const; + +private: + const TChar* mData; + size_t mLength; +}; + +using StringPiece = BasicStringPiece<char>; +using StringPiece16 = BasicStringPiece<char16_t>; + +// +// BasicStringPiece implementation. +// + +template <typename TChar> +inline BasicStringPiece<TChar>::BasicStringPiece() : mData(nullptr) , mLength(0) { +} + +template <typename TChar> +inline BasicStringPiece<TChar>::BasicStringPiece(const BasicStringPiece<TChar>& str) : + mData(str.mData), mLength(str.mLength) { +} + +template <typename TChar> +inline BasicStringPiece<TChar>::BasicStringPiece(const std::basic_string<TChar>& str) : + mData(str.data()), mLength(str.length()) { +} + +template <> +inline BasicStringPiece<char>::BasicStringPiece(const char* str) : + mData(str), mLength(str != nullptr ? strlen(str) : 0) { +} + +template <> +inline BasicStringPiece<char16_t>::BasicStringPiece(const char16_t* str) : + mData(str), mLength(str != nullptr ? strlen16(str) : 0) { +} + +template <typename TChar> +inline BasicStringPiece<TChar>::BasicStringPiece(const TChar* str, size_t len) : + mData(str), mLength(len) { +} + +template <typename TChar> +inline BasicStringPiece<TChar>& BasicStringPiece<TChar>::operator=( + const BasicStringPiece<TChar>& rhs) { + mData = rhs.mData; + mLength = rhs.mLength; + return *this; +} + +template <typename TChar> +inline BasicStringPiece<TChar>& BasicStringPiece<TChar>::assign(const TChar* str, size_t len) { + mData = str; + mLength = len; + return *this; +} + + +template <typename TChar> +inline BasicStringPiece<TChar> BasicStringPiece<TChar>::substr(size_t start, size_t len) const { + if (start + len > mLength) { + return BasicStringPiece<TChar>(); + } + return BasicStringPiece<TChar>(mData + start, len); +} + +template <typename TChar> +inline BasicStringPiece<TChar> BasicStringPiece<TChar>::substr( + BasicStringPiece<TChar>::const_iterator begin, + BasicStringPiece<TChar>::const_iterator end) const { + return BasicStringPiece<TChar>(begin, end - begin); +} + +template <typename TChar> +inline const TChar* BasicStringPiece<TChar>::data() const { + return mData; +} + +template <typename TChar> +inline size_t BasicStringPiece<TChar>::length() const { + return mLength; +} + +template <typename TChar> +inline size_t BasicStringPiece<TChar>::size() const { + return mLength; +} + +template <typename TChar> +inline bool BasicStringPiece<TChar>::empty() const { + return mLength == 0; +} + +template <typename TChar> +inline std::basic_string<TChar> BasicStringPiece<TChar>::toString() const { + return std::basic_string<TChar>(mData, mLength); +} + +template <> +inline int BasicStringPiece<char>::compare(const BasicStringPiece<char>& rhs) const { + const char nullStr = '\0'; + const char* b1 = mData != nullptr ? mData : &nullStr; + const char* e1 = b1 + mLength; + const char* b2 = rhs.mData != nullptr ? rhs.mData : &nullStr; + const char* e2 = b2 + rhs.mLength; + + while (b1 < e1 && b2 < e2) { + const int d = static_cast<int>(*b1++) - static_cast<int>(*b2++); + if (d) { + return d; + } + } + return static_cast<int>(mLength - rhs.mLength); +} + +inline ::std::ostream& operator<<(::std::ostream& out, const BasicStringPiece<char16_t>& str) { + android::String8 utf8(str.data(), str.size()); + return out.write(utf8.string(), utf8.size()); +} + + +template <> +inline int BasicStringPiece<char16_t>::compare(const BasicStringPiece<char16_t>& rhs) const { + const char16_t nullStr = u'\0'; + const char16_t* b1 = mData != nullptr ? mData : &nullStr; + const char16_t* b2 = rhs.mData != nullptr ? rhs.mData : &nullStr; + return strzcmp16(b1, mLength, b2, rhs.mLength); +} + +template <typename TChar> +inline bool BasicStringPiece<TChar>::operator<(const BasicStringPiece<TChar>& rhs) const { + return compare(rhs) < 0; +} + +template <typename TChar> +inline bool BasicStringPiece<TChar>::operator>(const BasicStringPiece<TChar>& rhs) const { + return compare(rhs) > 0; +} + +template <typename TChar> +inline bool BasicStringPiece<TChar>::operator==(const BasicStringPiece<TChar>& rhs) const { + return compare(rhs) == 0; +} + +template <typename TChar> +inline bool BasicStringPiece<TChar>::operator!=(const BasicStringPiece<TChar>& rhs) const { + return compare(rhs) != 0; +} + +template <typename TChar> +inline typename BasicStringPiece<TChar>::const_iterator BasicStringPiece<TChar>::begin() const { + return mData; +} + +template <typename TChar> +inline typename BasicStringPiece<TChar>::const_iterator BasicStringPiece<TChar>::end() const { + return mData + mLength; +} + +inline ::std::ostream& operator<<(::std::ostream& out, const BasicStringPiece<char>& str) { + return out.write(str.data(), str.size()); +} + +} // namespace aapt + +#endif // AAPT_STRING_PIECE_H diff --git a/tools/aapt2/StringPiece_test.cpp b/tools/aapt2/StringPiece_test.cpp new file mode 100644 index 0000000..43f7a37 --- /dev/null +++ b/tools/aapt2/StringPiece_test.cpp @@ -0,0 +1,62 @@ +/* + * 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 <algorithm> +#include <gtest/gtest.h> +#include <string> +#include <vector> + +#include "StringPiece.h" + +namespace aapt { + +TEST(StringPieceTest, CompareNonNullTerminatedPiece) { + StringPiece a("hello world", 5); + StringPiece b("hello moon", 5); + EXPECT_EQ(a, b); + + StringPiece16 a16(u"hello world", 5); + StringPiece16 b16(u"hello moon", 5); + EXPECT_EQ(a16, b16); +} + +TEST(StringPieceTest, PiecesHaveCorrectSortOrder) { + std::u16string testing(u"testing"); + std::u16string banana(u"banana"); + std::u16string car(u"car"); + + EXPECT_TRUE(StringPiece16(testing) > banana); + EXPECT_TRUE(StringPiece16(testing) > car); + EXPECT_TRUE(StringPiece16(banana) < testing); + EXPECT_TRUE(StringPiece16(banana) < car); + EXPECT_TRUE(StringPiece16(car) < testing); + EXPECT_TRUE(StringPiece16(car) > banana); +} + +TEST(StringPieceTest, PiecesHaveCorrectSortOrderUtf8) { + std::string testing("testing"); + std::string banana("banana"); + std::string car("car"); + + EXPECT_TRUE(StringPiece(testing) > banana); + EXPECT_TRUE(StringPiece(testing) > car); + EXPECT_TRUE(StringPiece(banana) < testing); + EXPECT_TRUE(StringPiece(banana) < car); + EXPECT_TRUE(StringPiece(car) < testing); + EXPECT_TRUE(StringPiece(car) > banana); +} + +} // namespace aapt diff --git a/tools/aapt2/StringPool.cpp b/tools/aapt2/StringPool.cpp new file mode 100644 index 0000000..c19aa98 --- /dev/null +++ b/tools/aapt2/StringPool.cpp @@ -0,0 +1,394 @@ +/* + * 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 "BigBuffer.h" +#include "StringPiece.h" +#include "StringPool.h" +#include "Util.h" + +#include <algorithm> +#include <androidfw/ResourceTypes.h> +#include <memory> +#include <string> + +namespace aapt { + +StringPool::Ref::Ref() : mEntry(nullptr) { +} + +StringPool::Ref::Ref(const StringPool::Ref& rhs) : mEntry(rhs.mEntry) { + if (mEntry != nullptr) { + mEntry->ref++; + } +} + +StringPool::Ref::Ref(StringPool::Entry* entry) : mEntry(entry) { + if (mEntry != nullptr) { + mEntry->ref++; + } +} + +StringPool::Ref::~Ref() { + if (mEntry != nullptr) { + mEntry->ref--; + } +} + +StringPool::Ref& StringPool::Ref::operator=(const StringPool::Ref& rhs) { + if (rhs.mEntry != nullptr) { + rhs.mEntry->ref++; + } + + if (mEntry != nullptr) { + mEntry->ref--; + } + mEntry = rhs.mEntry; + return *this; +} + +const std::u16string* StringPool::Ref::operator->() const { + return &mEntry->value; +} + +const std::u16string& StringPool::Ref::operator*() const { + return mEntry->value; +} + +size_t StringPool::Ref::getIndex() const { + return mEntry->index; +} + +const StringPool::Context& StringPool::Ref::getContext() const { + return mEntry->context; +} + +StringPool::StyleRef::StyleRef() : mEntry(nullptr) { +} + +StringPool::StyleRef::StyleRef(const StringPool::StyleRef& rhs) : mEntry(rhs.mEntry) { + if (mEntry != nullptr) { + mEntry->ref++; + } +} + +StringPool::StyleRef::StyleRef(StringPool::StyleEntry* entry) : mEntry(entry) { + if (mEntry != nullptr) { + mEntry->ref++; + } +} + +StringPool::StyleRef::~StyleRef() { + if (mEntry != nullptr) { + mEntry->ref--; + } +} + +StringPool::StyleRef& StringPool::StyleRef::operator=(const StringPool::StyleRef& rhs) { + if (rhs.mEntry != nullptr) { + rhs.mEntry->ref++; + } + + if (mEntry != nullptr) { + mEntry->ref--; + } + mEntry = rhs.mEntry; + return *this; +} + +const StringPool::StyleEntry* StringPool::StyleRef::operator->() const { + return mEntry; +} + +const StringPool::StyleEntry& StringPool::StyleRef::operator*() const { + return *mEntry; +} + +size_t StringPool::StyleRef::getIndex() const { + return mEntry->str.getIndex(); +} + +const StringPool::Context& StringPool::StyleRef::getContext() const { + return mEntry->str.getContext(); +} + +StringPool::Ref StringPool::makeRef(const StringPiece16& str) { + return makeRefImpl(str, Context{}, true); +} + +StringPool::Ref StringPool::makeRef(const StringPiece16& str, const Context& context) { + return makeRefImpl(str, context, true); +} + +StringPool::Ref StringPool::makeRefImpl(const StringPiece16& str, const Context& context, + bool unique) { + if (unique) { + auto iter = mIndexedStrings.find(str); + if (iter != std::end(mIndexedStrings)) { + return Ref(iter->second); + } + } + + Entry* entry = new Entry(); + entry->value = str.toString(); + entry->context = context; + entry->index = mStrings.size(); + entry->ref = 0; + mStrings.emplace_back(entry); + mIndexedStrings.insert(std::make_pair(StringPiece16(entry->value), entry)); + return Ref(entry); +} + +StringPool::StyleRef StringPool::makeRef(const StyleString& str) { + return makeRef(str, Context{}); +} + +StringPool::StyleRef StringPool::makeRef(const StyleString& str, const Context& context) { + Entry* entry = new Entry(); + entry->value = str.str; + entry->context = context; + entry->index = mStrings.size(); + entry->ref = 0; + mStrings.emplace_back(entry); + mIndexedStrings.insert(std::make_pair(StringPiece16(entry->value), entry)); + + StyleEntry* styleEntry = new StyleEntry(); + styleEntry->str = Ref(entry); + for (const aapt::Span& span : str.spans) { + styleEntry->spans.emplace_back(Span{makeRef(span.name), + span.firstChar, span.lastChar}); + } + styleEntry->ref = 0; + mStyles.emplace_back(styleEntry); + return StyleRef(styleEntry); +} + +StringPool::StyleRef StringPool::makeRef(const StyleRef& ref) { + Entry* entry = new Entry(); + entry->value = *ref.mEntry->str; + entry->context = ref.mEntry->str.mEntry->context; + entry->index = mStrings.size(); + entry->ref = 0; + mStrings.emplace_back(entry); + mIndexedStrings.insert(std::make_pair(StringPiece16(entry->value), entry)); + + StyleEntry* styleEntry = new StyleEntry(); + styleEntry->str = Ref(entry); + for (const Span& span : ref.mEntry->spans) { + styleEntry->spans.emplace_back(Span{ makeRef(*span.name), span.firstChar, span.lastChar }); + } + styleEntry->ref = 0; + mStyles.emplace_back(styleEntry); + return StyleRef(styleEntry); +} + +void StringPool::merge(StringPool&& pool) { + mIndexedStrings.insert(pool.mIndexedStrings.begin(), pool.mIndexedStrings.end()); + pool.mIndexedStrings.clear(); + std::move(pool.mStrings.begin(), pool.mStrings.end(), std::back_inserter(mStrings)); + pool.mStrings.clear(); + std::move(pool.mStyles.begin(), pool.mStyles.end(), std::back_inserter(mStyles)); + pool.mStyles.clear(); + + // Assign the indices. + const size_t len = mStrings.size(); + for (size_t index = 0; index < len; index++) { + mStrings[index]->index = index; + } +} + +void StringPool::hintWillAdd(size_t stringCount, size_t styleCount) { + mStrings.reserve(mStrings.size() + stringCount); + mStyles.reserve(mStyles.size() + styleCount); +} + +void StringPool::prune() { + const auto iterEnd = std::end(mIndexedStrings); + auto indexIter = std::begin(mIndexedStrings); + while (indexIter != iterEnd) { + if (indexIter->second->ref <= 0) { + mIndexedStrings.erase(indexIter++); + } else { + ++indexIter; + } + } + + auto endIter2 = std::remove_if(std::begin(mStrings), std::end(mStrings), + [](const std::unique_ptr<Entry>& entry) -> bool { + return entry->ref <= 0; + } + ); + + auto endIter3 = std::remove_if(std::begin(mStyles), std::end(mStyles), + [](const std::unique_ptr<StyleEntry>& entry) -> bool { + return entry->ref <= 0; + } + ); + + // Remove the entries at the end or else we'll be accessing + // a deleted string from the StyleEntry. + mStrings.erase(endIter2, std::end(mStrings)); + mStyles.erase(endIter3, std::end(mStyles)); +} + +void StringPool::sort(const std::function<bool(const Entry&, const Entry&)>& cmp) { + std::sort(std::begin(mStrings), std::end(mStrings), + [&cmp](const std::unique_ptr<Entry>& a, const std::unique_ptr<Entry>& b) -> bool { + return cmp(*a, *b); + } + ); + + // Assign the indices. + const size_t len = mStrings.size(); + for (size_t index = 0; index < len; index++) { + mStrings[index]->index = index; + } + + // Reorder the styles. + std::sort(std::begin(mStyles), std::end(mStyles), + [](const std::unique_ptr<StyleEntry>& lhs, + const std::unique_ptr<StyleEntry>& rhs) -> bool { + return lhs->str.getIndex() < rhs->str.getIndex(); + } + ); +} + +template <typename T> +static T* encodeLength(T* data, size_t length) { + static_assert(std::is_integral<T>::value, "wat."); + + constexpr size_t kMask = 1 << ((sizeof(T) * 8) - 1); + constexpr size_t kMaxSize = kMask - 1; + if (length > kMaxSize) { + *data++ = kMask | (kMaxSize & (length >> (sizeof(T) * 8))); + } + *data++ = length; + return data; +} + +template <typename T> +static size_t encodedLengthUnits(size_t length) { + static_assert(std::is_integral<T>::value, "wat."); + + constexpr size_t kMask = 1 << ((sizeof(T) * 8) - 1); + constexpr size_t kMaxSize = kMask - 1; + return length > kMaxSize ? 2 : 1; +} + + +bool StringPool::flatten(BigBuffer* out, const StringPool& pool, bool utf8) { + const size_t startIndex = out->size(); + android::ResStringPool_header* header = out->nextBlock<android::ResStringPool_header>(); + header->header.type = android::RES_STRING_POOL_TYPE; + header->header.headerSize = sizeof(*header); + header->stringCount = pool.size(); + if (utf8) { + header->flags |= android::ResStringPool_header::UTF8_FLAG; + } + + uint32_t* indices = pool.size() != 0 ? out->nextBlock<uint32_t>(pool.size()) : nullptr; + + uint32_t* styleIndices = nullptr; + if (!pool.mStyles.empty()) { + header->styleCount = pool.mStyles.back()->str.getIndex() + 1; + styleIndices = out->nextBlock<uint32_t>(header->styleCount); + } + + const size_t beforeStringsIndex = out->size(); + header->stringsStart = beforeStringsIndex - startIndex; + + for (const auto& entry : pool) { + *indices = out->size() - beforeStringsIndex; + indices++; + + if (utf8) { + std::string encoded = util::utf16ToUtf8(entry->value); + + const size_t totalSize = encodedLengthUnits<char>(entry->value.size()) + + encodedLengthUnits<char>(encoded.length()) + + encoded.size() + 1; + + char* data = out->nextBlock<char>(totalSize); + + // First encode the actual UTF16 string length. + data = encodeLength(data, entry->value.size()); + + // Now encode the size of the converted UTF8 string. + data = encodeLength(data, encoded.length()); + strncpy(data, encoded.data(), encoded.size()); + } else { + const size_t totalSize = encodedLengthUnits<char16_t>(entry->value.size()) + + entry->value.size() + 1; + + char16_t* data = out->nextBlock<char16_t>(totalSize); + + // Encode the actual UTF16 string length. + data = encodeLength(data, entry->value.size()); + strncpy16(data, entry->value.data(), entry->value.size()); + } + } + + out->align4(); + + if (!pool.mStyles.empty()) { + const size_t beforeStylesIndex = out->size(); + header->stylesStart = beforeStylesIndex - startIndex; + + size_t currentIndex = 0; + for (const auto& entry : pool.mStyles) { + while (entry->str.getIndex() > currentIndex) { + styleIndices[currentIndex++] = out->size() - beforeStylesIndex; + + uint32_t* spanOffset = out->nextBlock<uint32_t>(); + *spanOffset = android::ResStringPool_span::END; + } + styleIndices[currentIndex++] = out->size() - beforeStylesIndex; + + android::ResStringPool_span* span = + out->nextBlock<android::ResStringPool_span>(entry->spans.size()); + for (const auto& s : entry->spans) { + span->name.index = s.name.getIndex(); + span->firstChar = s.firstChar; + span->lastChar = s.lastChar; + span++; + } + + uint32_t* spanEnd = out->nextBlock<uint32_t>(); + *spanEnd = android::ResStringPool_span::END; + } + + // The error checking code in the platform looks for an entire + // ResStringPool_span structure worth of 0xFFFFFFFF at the end + // of the style block, so fill in the remaining 2 32bit words + // with 0xFFFFFFFF. + const size_t paddingLength = sizeof(android::ResStringPool_span) + - sizeof(android::ResStringPool_span::name); + uint8_t* padding = out->nextBlock<uint8_t>(paddingLength); + memset(padding, 0xff, paddingLength); + out->align4(); + } + header->header.size = out->size() - startIndex; + return true; +} + +bool StringPool::flattenUtf8(BigBuffer* out, const StringPool& pool) { + return flatten(out, pool, true); +} + +bool StringPool::flattenUtf16(BigBuffer* out, const StringPool& pool) { + return flatten(out, pool, false); +} + +} // namespace aapt diff --git a/tools/aapt2/StringPool.h b/tools/aapt2/StringPool.h new file mode 100644 index 0000000..14304a6 --- /dev/null +++ b/tools/aapt2/StringPool.h @@ -0,0 +1,223 @@ +/* + * 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_STRING_POOL_H +#define AAPT_STRING_POOL_H + +#include "BigBuffer.h" +#include "ConfigDescription.h" +#include "StringPiece.h" + +#include <functional> +#include <map> +#include <memory> +#include <string> +#include <vector> + +namespace aapt { + +struct Span { + std::u16string name; + uint32_t firstChar; + uint32_t lastChar; +}; + +struct StyleString { + std::u16string str; + std::vector<Span> spans; +}; + +class StringPool { +public: + struct Context { + uint32_t priority; + ConfigDescription config; + }; + + class Entry; + + class Ref { + public: + Ref(); + Ref(const Ref&); + ~Ref(); + + Ref& operator=(const Ref& rhs); + const std::u16string* operator->() const; + const std::u16string& operator*() const; + + size_t getIndex() const; + const Context& getContext() const; + + private: + friend class StringPool; + + Ref(Entry* entry); + + Entry* mEntry; + }; + + class StyleEntry; + + class StyleRef { + public: + StyleRef(); + StyleRef(const StyleRef&); + ~StyleRef(); + + StyleRef& operator=(const StyleRef& rhs); + const StyleEntry* operator->() const; + const StyleEntry& operator*() const; + + size_t getIndex() const; + const Context& getContext() const; + + private: + friend class StringPool; + + StyleRef(StyleEntry* entry); + + StyleEntry* mEntry; + }; + + class Entry { + public: + std::u16string value; + Context context; + size_t index; + + private: + friend class StringPool; + friend class Ref; + + int ref; + }; + + struct Span { + Ref name; + uint32_t firstChar; + uint32_t lastChar; + }; + + class StyleEntry { + public: + Ref str; + std::vector<Span> spans; + + private: + friend class StringPool; + friend class StyleRef; + + int ref; + }; + + using const_iterator = std::vector<std::unique_ptr<Entry>>::const_iterator; + + static bool flattenUtf8(BigBuffer* out, const StringPool& pool); + static bool flattenUtf16(BigBuffer* out, const StringPool& pool); + + StringPool() = default; + StringPool(const StringPool&) = delete; + + /** + * Adds a string to the pool, unless it already exists. Returns + * a reference to the string in the pool. + */ + Ref makeRef(const StringPiece16& str); + + /** + * Adds a string to the pool, unless it already exists, with a context + * object that can be used when sorting the string pool. Returns + * a reference to the string in the pool. + */ + Ref makeRef(const StringPiece16& str, const Context& context); + + /** + * Adds a style to the string pool and returns a reference to it. + */ + StyleRef makeRef(const StyleString& str); + + /** + * Adds a style to the string pool with a context object that + * can be used when sorting the string pool. Returns a reference + * to the style in the string pool. + */ + StyleRef makeRef(const StyleString& str, const Context& context); + + /** + * Adds a style from another string pool. Returns a reference to the + * style in the string pool. + */ + StyleRef makeRef(const StyleRef& ref); + + /** + * Moves pool into this one without coalescing strings. When this + * function returns, pool will be empty. + */ + void merge(StringPool&& pool); + + /** + * Retuns the number of strings in the table. + */ + inline size_t size() const; + + /** + * Reserves space for strings and styles as an optimization. + */ + void hintWillAdd(size_t stringCount, size_t styleCount); + + /** + * Sorts the strings according to some comparison function. + */ + void sort(const std::function<bool(const Entry&, const Entry&)>& cmp); + + /** + * Removes any strings that have no references. + */ + void prune(); + +private: + friend const_iterator begin(const StringPool& pool); + friend const_iterator end(const StringPool& pool); + + static bool flatten(BigBuffer* out, const StringPool& pool, bool utf8); + + Ref makeRefImpl(const StringPiece16& str, const Context& context, bool unique); + + std::vector<std::unique_ptr<Entry>> mStrings; + std::vector<std::unique_ptr<StyleEntry>> mStyles; + std::multimap<StringPiece16, Entry*> mIndexedStrings; +}; + +// +// Inline implementation +// + +inline size_t StringPool::size() const { + return mStrings.size(); +} + +inline StringPool::const_iterator begin(const StringPool& pool) { + return pool.mStrings.begin(); +} + +inline StringPool::const_iterator end(const StringPool& pool) { + return pool.mStrings.end(); +} + +} // namespace aapt + +#endif // AAPT_STRING_POOL_H diff --git a/tools/aapt2/StringPool_test.cpp b/tools/aapt2/StringPool_test.cpp new file mode 100644 index 0000000..9552937 --- /dev/null +++ b/tools/aapt2/StringPool_test.cpp @@ -0,0 +1,223 @@ +/* + * 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 "StringPool.h" +#include "Util.h" + +#include <gtest/gtest.h> +#include <string> + +using namespace android; + +namespace aapt { + +TEST(StringPoolTest, InsertOneString) { + StringPool pool; + + StringPool::Ref ref = pool.makeRef(u"wut"); + EXPECT_EQ(*ref, u"wut"); +} + +TEST(StringPoolTest, InsertTwoUniqueStrings) { + StringPool pool; + + StringPool::Ref ref = pool.makeRef(u"wut"); + StringPool::Ref ref2 = pool.makeRef(u"hey"); + + EXPECT_EQ(*ref, u"wut"); + EXPECT_EQ(*ref2, u"hey"); +} + +TEST(StringPoolTest, DoNotInsertNewDuplicateString) { + StringPool pool; + + StringPool::Ref ref = pool.makeRef(u"wut"); + StringPool::Ref ref2 = pool.makeRef(u"wut"); + + EXPECT_EQ(*ref, u"wut"); + EXPECT_EQ(*ref2, u"wut"); + EXPECT_EQ(1u, pool.size()); +} + +TEST(StringPoolTest, MaintainInsertionOrderIndex) { + StringPool pool; + + StringPool::Ref ref = pool.makeRef(u"z"); + StringPool::Ref ref2 = pool.makeRef(u"a"); + StringPool::Ref ref3 = pool.makeRef(u"m"); + + EXPECT_EQ(0u, ref.getIndex()); + EXPECT_EQ(1u, ref2.getIndex()); + EXPECT_EQ(2u, ref3.getIndex()); +} + +TEST(StringPoolTest, PruneStringsWithNoReferences) { + StringPool pool; + + { + StringPool::Ref ref = pool.makeRef(u"wut"); + EXPECT_EQ(*ref, u"wut"); + EXPECT_EQ(1u, pool.size()); + } + + EXPECT_EQ(1u, pool.size()); + pool.prune(); + EXPECT_EQ(0u, pool.size()); +} + +TEST(StringPoolTest, SortAndMaintainIndexesInReferences) { + StringPool pool; + + StringPool::Ref ref = pool.makeRef(u"z"); + StringPool::StyleRef ref2 = pool.makeRef(StyleString{ {u"a"} }); + StringPool::Ref ref3 = pool.makeRef(u"m"); + + EXPECT_EQ(*ref, u"z"); + EXPECT_EQ(0u, ref.getIndex()); + + EXPECT_EQ(*(ref2->str), u"a"); + EXPECT_EQ(1u, ref2.getIndex()); + + EXPECT_EQ(*ref3, u"m"); + EXPECT_EQ(2u, ref3.getIndex()); + + pool.sort([](const StringPool::Entry& a, const StringPool::Entry& b) -> bool { + return a.value < b.value; + }); + + + EXPECT_EQ(*ref, u"z"); + EXPECT_EQ(2u, ref.getIndex()); + + EXPECT_EQ(*(ref2->str), u"a"); + EXPECT_EQ(0u, ref2.getIndex()); + + EXPECT_EQ(*ref3, u"m"); + EXPECT_EQ(1u, ref3.getIndex()); +} + +TEST(StringPoolTest, SortAndStillDedupe) { + StringPool pool; + + StringPool::Ref ref = pool.makeRef(u"z"); + StringPool::Ref ref2 = pool.makeRef(u"a"); + StringPool::Ref ref3 = pool.makeRef(u"m"); + + pool.sort([](const StringPool::Entry& a, const StringPool::Entry& b) -> bool { + return a.value < b.value; + }); + + StringPool::Ref ref4 = pool.makeRef(u"z"); + StringPool::Ref ref5 = pool.makeRef(u"a"); + StringPool::Ref ref6 = pool.makeRef(u"m"); + + EXPECT_EQ(ref4.getIndex(), ref.getIndex()); + EXPECT_EQ(ref5.getIndex(), ref2.getIndex()); + EXPECT_EQ(ref6.getIndex(), ref3.getIndex()); +} + +TEST(StringPoolTest, AddStyles) { + StringPool pool; + + StyleString str { + { u"android" }, + { + Span{ { u"b" }, 2, 6 } + } + }; + + StringPool::StyleRef ref = pool.makeRef(str); + + EXPECT_EQ(0u, ref.getIndex()); + EXPECT_EQ(std::u16string(u"android"), *(ref->str)); + ASSERT_EQ(1u, ref->spans.size()); + + const StringPool::Span& span = ref->spans.front(); + EXPECT_EQ(*(span.name), u"b"); + EXPECT_EQ(2u, span.firstChar); + EXPECT_EQ(6u, span.lastChar); +} + +TEST(StringPoolTest, DoNotDedupeStyleWithSameStringAsNonStyle) { + StringPool pool; + + StringPool::Ref ref = pool.makeRef(u"android"); + + StyleString str { { u"android" } }; + StringPool::StyleRef styleRef = pool.makeRef(str); + + EXPECT_NE(ref.getIndex(), styleRef.getIndex()); +} + +TEST(StringPoolTest, FlattenEmptyStringPoolUtf8) { + StringPool pool; + BigBuffer buffer(1024); + StringPool::flattenUtf8(&buffer, pool); + + std::unique_ptr<uint8_t[]> data = util::copy(buffer); + android::ResStringPool test; + ASSERT_EQ(test.setTo(data.get(), buffer.size()), android::NO_ERROR); +} + +constexpr const char16_t* sLongString = u"バッテリーを長持ちさせるため、バッテリーセーバーは端末のパフォーマンスを抑え、バイブレーション、位置情報サービス、大半のバックグラウンドデータを制限します。メール、SMSや、同期を使 用するその他のアプリは、起動しても更新されないことがあります。バッテリーセーバーは端末の充電中は自動的にOFFになります。"; + +TEST(StringPoolTest, FlattenUtf8) { + StringPool pool; + + StringPool::Ref ref1 = pool.makeRef(u"hello"); + StringPool::Ref ref2 = pool.makeRef(u"goodbye"); + StringPool::Ref ref3 = pool.makeRef(sLongString); + StringPool::StyleRef ref4 = pool.makeRef(StyleString{ + { u"style" }, + { Span{ { u"b" }, 0, 1 }, Span{ { u"i" }, 2, 3 } } + }); + + EXPECT_EQ(0u, ref1.getIndex()); + EXPECT_EQ(1u, ref2.getIndex()); + EXPECT_EQ(2u, ref3.getIndex()); + EXPECT_EQ(3u, ref4.getIndex()); + + BigBuffer buffer(1024); + StringPool::flattenUtf8(&buffer, pool); + + std::unique_ptr<uint8_t[]> data = util::copy(buffer); + { + android::ResStringPool test; + ASSERT_EQ(test.setTo(data.get(), buffer.size()), android::NO_ERROR); + + EXPECT_EQ(util::getString(test, 0), u"hello"); + EXPECT_EQ(util::getString(test, 1), u"goodbye"); + EXPECT_EQ(util::getString(test, 2), sLongString); + EXPECT_EQ(util::getString(test, 3), u"style"); + + const ResStringPool_span* span = test.styleAt(3); + ASSERT_NE(nullptr, span); + EXPECT_EQ(util::getString(test, span->name.index), u"b"); + EXPECT_EQ(0u, span->firstChar); + EXPECT_EQ(1u, span->lastChar); + span++; + + ASSERT_NE(ResStringPool_span::END, span->name.index); + EXPECT_EQ(util::getString(test, span->name.index), u"i"); + EXPECT_EQ(2u, span->firstChar); + EXPECT_EQ(3u, span->lastChar); + span++; + + EXPECT_EQ(ResStringPool_span::END, span->name.index); + } +} + +} // namespace aapt diff --git a/tools/aapt2/TableFlattener.cpp b/tools/aapt2/TableFlattener.cpp new file mode 100644 index 0000000..539c48f --- /dev/null +++ b/tools/aapt2/TableFlattener.cpp @@ -0,0 +1,577 @@ +/* + * 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 "BigBuffer.h" +#include "ConfigDescription.h" +#include "Logger.h" +#include "ResourceTable.h" +#include "ResourceTypeExtensions.h" +#include "ResourceValues.h" +#include "StringPool.h" +#include "TableFlattener.h" +#include "Util.h" + +#include <algorithm> +#include <androidfw/ResourceTypes.h> +#include <sstream> + +namespace aapt { + +struct FlatEntry { + const ResourceEntry* entry; + const Value* value; + uint32_t entryKey; + uint32_t sourcePathKey; + uint32_t sourceLine; +}; + +/** + * Visitor that knows how to encode Map values. + */ +class MapFlattener : public ConstValueVisitor { +public: + MapFlattener(BigBuffer* out, const FlatEntry& flatEntry, SymbolEntryVector* symbols) : + mOut(out), mSymbols(symbols) { + mMap = mOut->nextBlock<android::ResTable_map_entry>(); + mMap->key.index = flatEntry.entryKey; + mMap->flags = android::ResTable_entry::FLAG_COMPLEX; + if (flatEntry.entry->publicStatus.isPublic) { + mMap->flags |= android::ResTable_entry::FLAG_PUBLIC; + } + if (flatEntry.value->isWeak()) { + mMap->flags |= android::ResTable_entry::FLAG_WEAK; + } + + ResTable_entry_source* sourceBlock = mOut->nextBlock<ResTable_entry_source>(); + sourceBlock->pathIndex = flatEntry.sourcePathKey; + sourceBlock->line = flatEntry.sourceLine; + + mMap->size = sizeof(*mMap) + sizeof(*sourceBlock); + } + + void flattenParent(const Reference& ref) { + if (!ref.id.isValid()) { + mSymbols->push_back({ + ResourceNameRef(ref.name), + (mOut->size() - mMap->size) + sizeof(*mMap) - sizeof(android::ResTable_entry) + }); + } + mMap->parent.ident = ref.id.id; + } + + void flattenEntry(const Reference& key, const Item& value) { + mMap->count++; + + android::ResTable_map* outMapEntry = mOut->nextBlock<android::ResTable_map>(); + + // Write the key. + if (!Res_INTERNALID(key.id.id) && !key.id.isValid()) { + assert(key.name.isValid()); + mSymbols->push_back(std::make_pair(ResourceNameRef(key.name), + mOut->size() - sizeof(*outMapEntry))); + } + outMapEntry->name.ident = key.id.id; + + // Write the value. + value.flatten(outMapEntry->value); + + if (outMapEntry->value.data == 0x0) { + visitFunc<Reference>(value, [&](const Reference& reference) { + mSymbols->push_back(std::make_pair(ResourceNameRef(reference.name), + mOut->size() - sizeof(outMapEntry->value.data))); + }); + } + outMapEntry->value.size = sizeof(outMapEntry->value); + } + + void flattenValueOnly(const Item& value) { + mMap->count++; + + android::ResTable_map* outMapEntry = mOut->nextBlock<android::ResTable_map>(); + + // Write the value. + value.flatten(outMapEntry->value); + + if (outMapEntry->value.data == 0x0) { + visitFunc<Reference>(value, [&](const Reference& reference) { + mSymbols->push_back(std::make_pair(ResourceNameRef(reference.name), + mOut->size() - sizeof(outMapEntry->value.data))); + }); + } + outMapEntry->value.size = sizeof(outMapEntry->value); + } + + static bool compareStyleEntries(const Style::Entry* lhs, const Style::Entry* rhs) { + return lhs->key.id < rhs->key.id; + } + + void visit(const Style& style, ValueVisitorArgs&) override { + if (style.parent.name.isValid()) { + flattenParent(style.parent); + } + + // First sort the entries by ID. + std::vector<const Style::Entry*> sortedEntries; + for (const auto& styleEntry : style.entries) { + auto iter = std::lower_bound(sortedEntries.begin(), sortedEntries.end(), + &styleEntry, compareStyleEntries); + sortedEntries.insert(iter, &styleEntry); + } + + for (const Style::Entry* styleEntry : sortedEntries) { + flattenEntry(styleEntry->key, *styleEntry->value); + } + } + + void visit(const Attribute& attr, ValueVisitorArgs&) override { + android::Res_value tempVal; + tempVal.dataType = android::Res_value::TYPE_INT_DEC; + tempVal.data = attr.typeMask; + flattenEntry(Reference(ResourceId{android::ResTable_map::ATTR_TYPE}), + BinaryPrimitive(tempVal)); + + for (const auto& symbol : attr.symbols) { + tempVal.data = symbol.value; + flattenEntry(symbol.symbol, BinaryPrimitive(tempVal)); + } + } + + void visit(const Styleable& styleable, ValueVisitorArgs&) override { + for (const auto& attr : styleable.entries) { + flattenEntry(attr, BinaryPrimitive(android::Res_value{})); + } + } + + void visit(const Array& array, ValueVisitorArgs&) override { + for (const auto& item : array.items) { + flattenValueOnly(*item); + } + } + + void visit(const Plural& plural, ValueVisitorArgs&) override { + const size_t count = plural.values.size(); + for (size_t i = 0; i < count; i++) { + if (!plural.values[i]) { + continue; + } + + ResourceId q; + switch (i) { + case Plural::Zero: + q.id = android::ResTable_map::ATTR_ZERO; + break; + + case Plural::One: + q.id = android::ResTable_map::ATTR_ONE; + break; + + case Plural::Two: + q.id = android::ResTable_map::ATTR_TWO; + break; + + case Plural::Few: + q.id = android::ResTable_map::ATTR_FEW; + break; + + case Plural::Many: + q.id = android::ResTable_map::ATTR_MANY; + break; + + case Plural::Other: + q.id = android::ResTable_map::ATTR_OTHER; + break; + + default: + assert(false); + break; + } + + flattenEntry(Reference(q), *plural.values[i]); + } + } + +private: + BigBuffer* mOut; + SymbolEntryVector* mSymbols; + android::ResTable_map_entry* mMap; +}; + +/** + * Flattens a value, with special handling for References. + */ +struct ValueFlattener : ConstValueVisitor { + ValueFlattener(BigBuffer* out, SymbolEntryVector* symbols) : + result(false), mOut(out), mOutValue(nullptr), mSymbols(symbols) { + mOutValue = mOut->nextBlock<android::Res_value>(); + } + + virtual void visit(const Reference& ref, ValueVisitorArgs& a) override { + visitItem(ref, a); + if (mOutValue->data == 0x0) { + mSymbols->push_back({ + ResourceNameRef(ref.name), + mOut->size() - sizeof(mOutValue->data)}); + } + } + + virtual void visitItem(const Item& item, ValueVisitorArgs&) override { + result = item.flatten(*mOutValue); + mOutValue->res0 = 0; + mOutValue->size = sizeof(*mOutValue); + } + + bool result; + +private: + BigBuffer* mOut; + android::Res_value* mOutValue; + SymbolEntryVector* mSymbols; +}; + +TableFlattener::TableFlattener(Options options) +: mOptions(options) { +} + +bool TableFlattener::flattenValue(BigBuffer* out, const FlatEntry& flatEntry, + SymbolEntryVector* symbols) { + if (flatEntry.value->isItem()) { + android::ResTable_entry* entry = out->nextBlock<android::ResTable_entry>(); + + if (flatEntry.entry->publicStatus.isPublic) { + entry->flags |= android::ResTable_entry::FLAG_PUBLIC; + } + + if (flatEntry.value->isWeak()) { + entry->flags |= android::ResTable_entry::FLAG_WEAK; + } + + entry->key.index = flatEntry.entryKey; + entry->size = sizeof(*entry); + + if (mOptions.useExtendedChunks) { + // Write the extra source block. This will be ignored by + // the Android runtime. + ResTable_entry_source* sourceBlock = out->nextBlock<ResTable_entry_source>(); + sourceBlock->pathIndex = flatEntry.sourcePathKey; + sourceBlock->line = flatEntry.sourceLine; + entry->size += sizeof(*sourceBlock); + } + + const Item* item = static_cast<const Item*>(flatEntry.value); + ValueFlattener flattener(out, symbols); + item->accept(flattener, {}); + return flattener.result; + } + + MapFlattener flattener(out, flatEntry, symbols); + flatEntry.value->accept(flattener, {}); + return true; +} + +bool TableFlattener::flatten(BigBuffer* out, const ResourceTable& table) { + const size_t beginning = out->size(); + + if (table.getPackage().size() == 0) { + Logger::error() + << "ResourceTable has no package name." + << std::endl; + return false; + } + + if (table.getPackageId() == ResourceTable::kUnsetPackageId) { + Logger::error() + << "ResourceTable has no package ID set." + << std::endl; + return false; + } + + SymbolEntryVector symbolEntries; + + StringPool typePool; + StringPool keyPool; + StringPool sourcePool; + + // Sort the types by their IDs. They will be inserted into the StringPool + // in this order. + std::vector<ResourceTableType*> sortedTypes; + for (const auto& type : table) { + if (type->type == ResourceType::kStyleable && !mOptions.useExtendedChunks) { + continue; + } + + auto iter = std::lower_bound(std::begin(sortedTypes), std::end(sortedTypes), type.get(), + [](const ResourceTableType* lhs, const ResourceTableType* rhs) -> bool { + return lhs->typeId < rhs->typeId; + }); + sortedTypes.insert(iter, type.get()); + } + + BigBuffer typeBlock(1024); + size_t expectedTypeId = 1; + for (const ResourceTableType* type : sortedTypes) { + if (type->typeId == ResourceTableType::kUnsetTypeId + || type->typeId == 0) { + Logger::error() + << "resource type '" + << type->type + << "' from package '" + << table.getPackage() + << "' has no ID." + << std::endl; + return false; + } + + // If there is a gap in the type IDs, fill in the StringPool + // with empty values until we reach the ID we expect. + while (type->typeId > expectedTypeId) { + std::u16string typeName(u"?"); + typeName += expectedTypeId; + typePool.makeRef(typeName); + expectedTypeId++; + } + expectedTypeId++; + typePool.makeRef(toString(type->type)); + + android::ResTable_typeSpec* spec = typeBlock.nextBlock<android::ResTable_typeSpec>(); + spec->header.type = android::RES_TABLE_TYPE_SPEC_TYPE; + spec->header.headerSize = sizeof(*spec); + spec->header.size = spec->header.headerSize + (type->entries.size() * sizeof(uint32_t)); + spec->id = type->typeId; + spec->entryCount = type->entries.size(); + + if (type->entries.empty()) { + continue; + } + + // Reserve space for the masks of each resource in this type. These + // show for which configuration axis the resource changes. + uint32_t* configMasks = typeBlock.nextBlock<uint32_t>(type->entries.size()); + + // Sort the entries by entry ID and write their configuration masks. + std::vector<ResourceEntry*> entries; + const size_t entryCount = type->entries.size(); + for (size_t entryIndex = 0; entryIndex < entryCount; entryIndex++) { + const auto& entry = type->entries[entryIndex]; + + if (entry->entryId == ResourceEntry::kUnsetEntryId) { + Logger::error() + << "resource '" + << ResourceName{ table.getPackage(), type->type, entry->name } + << "' has no ID." + << std::endl; + return false; + } + + auto iter = std::lower_bound(std::begin(entries), std::end(entries), entry.get(), + [](const ResourceEntry* lhs, const ResourceEntry* rhs) -> bool { + return lhs->entryId < rhs->entryId; + }); + entries.insert(iter, entry.get()); + + // Populate the config masks for this entry. + if (entry->publicStatus.isPublic) { + configMasks[entry->entryId] |= android::ResTable_typeSpec::SPEC_PUBLIC; + } + + const size_t configCount = entry->values.size(); + for (size_t i = 0; i < configCount; i++) { + const ConfigDescription& config = entry->values[i].config; + for (size_t j = i + 1; j < configCount; j++) { + configMasks[entry->entryId] |= config.diff(entry->values[j].config); + } + } + } + + const size_t beforePublicHeader = typeBlock.size(); + Public_header* publicHeader = nullptr; + if (mOptions.useExtendedChunks) { + publicHeader = typeBlock.nextBlock<Public_header>(); + publicHeader->header.type = RES_TABLE_PUBLIC_TYPE; + publicHeader->header.headerSize = sizeof(*publicHeader); + publicHeader->typeId = type->typeId; + } + + // The binary resource table lists resource entries for each configuration. + // We store them inverted, where a resource entry lists the values for each + // configuration available. Here we reverse this to match the binary table. + std::map<ConfigDescription, std::vector<FlatEntry>> data; + for (const ResourceEntry* entry : entries) { + size_t keyIndex = keyPool.makeRef(entry->name).getIndex(); + + if (keyIndex > std::numeric_limits<uint32_t>::max()) { + Logger::error() + << "resource key string pool exceeded max size." + << std::endl; + return false; + } + + if (publicHeader && entry->publicStatus.isPublic) { + // Write the public status of this entry. + Public_entry* publicEntry = typeBlock.nextBlock<Public_entry>(); + publicEntry->entryId = static_cast<uint32_t>(entry->entryId); + publicEntry->key.index = static_cast<uint32_t>(keyIndex); + publicEntry->source.index = static_cast<uint32_t>(sourcePool.makeRef( + util::utf8ToUtf16(entry->publicStatus.source.path)).getIndex()); + publicEntry->sourceLine = static_cast<uint32_t>(entry->publicStatus.source.line); + publicHeader->count += 1; + } + + for (const auto& configValue : entry->values) { + data[configValue.config].push_back(FlatEntry{ + entry, + configValue.value.get(), + static_cast<uint32_t>(keyIndex), + static_cast<uint32_t>(sourcePool.makeRef(util::utf8ToUtf16( + configValue.source.path)).getIndex()), + static_cast<uint32_t>(configValue.source.line) + }); + } + } + + if (publicHeader) { + typeBlock.align4(); + publicHeader->header.size = + static_cast<uint32_t>(typeBlock.size() - beforePublicHeader); + } + + // Begin flattening a configuration for the current type. + for (const auto& entry : data) { + const size_t typeHeaderStart = typeBlock.size(); + android::ResTable_type* typeHeader = typeBlock.nextBlock<android::ResTable_type>(); + typeHeader->header.type = android::RES_TABLE_TYPE_TYPE; + typeHeader->header.headerSize = sizeof(*typeHeader); + typeHeader->id = type->typeId; + typeHeader->entryCount = type->entries.size(); + typeHeader->entriesStart = typeHeader->header.headerSize + + (sizeof(uint32_t) * type->entries.size()); + typeHeader->config = entry.first; + + uint32_t* indices = typeBlock.nextBlock<uint32_t>(type->entries.size()); + memset(indices, 0xff, type->entries.size() * sizeof(uint32_t)); + + const size_t entryStart = typeBlock.size(); + for (const FlatEntry& flatEntry : entry.second) { + assert(flatEntry.entry->entryId < type->entries.size()); + indices[flatEntry.entry->entryId] = typeBlock.size() - entryStart; + if (!flattenValue(&typeBlock, flatEntry, &symbolEntries)) { + Logger::error() + << "failed to flatten resource '" + << ResourceNameRef { + table.getPackage(), type->type, flatEntry.entry->name } + << "' for configuration '" + << entry.first + << "'." + << std::endl; + return false; + } + } + + typeBlock.align4(); + typeHeader->header.size = typeBlock.size() - typeHeaderStart; + } + } + + const size_t beforeTable = out->size(); + android::ResTable_header* header = out->nextBlock<android::ResTable_header>(); + header->header.type = android::RES_TABLE_TYPE; + header->header.headerSize = sizeof(*header); + header->packageCount = 1; + + SymbolTable_entry* symbolEntryData = nullptr; + if (!symbolEntries.empty() && mOptions.useExtendedChunks) { + const size_t beforeSymbolTable = out->size(); + StringPool symbolPool; + SymbolTable_header* symbolHeader = out->nextBlock<SymbolTable_header>(); + symbolHeader->header.type = RES_TABLE_SYMBOL_TABLE_TYPE; + symbolHeader->header.headerSize = sizeof(*symbolHeader); + symbolHeader->count = symbolEntries.size(); + + symbolEntryData = out->nextBlock<SymbolTable_entry>(symbolHeader->count); + + size_t i = 0; + for (const auto& entry : symbolEntries) { + symbolEntryData[i].offset = entry.second; + StringPool::Ref ref = symbolPool.makeRef( + entry.first.package.toString() + u":" + + toString(entry.first.type).toString() + u"/" + + entry.first.entry.toString()); + symbolEntryData[i].stringIndex = ref.getIndex(); + i++; + } + + StringPool::flattenUtf8(out, symbolPool); + out->align4(); + symbolHeader->header.size = out->size() - beforeSymbolTable; + } + + if (sourcePool.size() > 0 && mOptions.useExtendedChunks) { + const size_t beforeSourcePool = out->size(); + android::ResChunk_header* sourceHeader = out->nextBlock<android::ResChunk_header>(); + sourceHeader->type = RES_TABLE_SOURCE_POOL_TYPE; + sourceHeader->headerSize = sizeof(*sourceHeader); + StringPool::flattenUtf8(out, sourcePool); + out->align4(); + sourceHeader->size = out->size() - beforeSourcePool; + } + + StringPool::flattenUtf8(out, table.getValueStringPool()); + + const size_t beforePackageIndex = out->size(); + android::ResTable_package* package = out->nextBlock<android::ResTable_package>(); + package->header.type = android::RES_TABLE_PACKAGE_TYPE; + package->header.headerSize = sizeof(*package); + + if (table.getPackageId() > std::numeric_limits<uint8_t>::max()) { + Logger::error() + << "package ID 0x'" + << std::hex << table.getPackageId() << std::dec + << "' is invalid." + << std::endl; + return false; + } + package->id = table.getPackageId(); + + if (table.getPackage().size() >= sizeof(package->name) / sizeof(package->name[0])) { + Logger::error() + << "package name '" + << table.getPackage() + << "' is too long." + << std::endl; + return false; + } + memcpy(package->name, reinterpret_cast<const uint16_t*>(table.getPackage().data()), + table.getPackage().length() * sizeof(char16_t)); + package->name[table.getPackage().length()] = 0; + + package->typeStrings = package->header.headerSize; + StringPool::flattenUtf16(out, typePool); + package->keyStrings = out->size() - beforePackageIndex; + StringPool::flattenUtf16(out, keyPool); + + if (symbolEntryData != nullptr) { + for (size_t i = 0; i < symbolEntries.size(); i++) { + symbolEntryData[i].offset += out->size() - beginning; + } + } + + out->appendBuffer(std::move(typeBlock)); + + package->header.size = out->size() - beforePackageIndex; + header->header.size = out->size() - beforeTable; + return true; +} + +} // namespace aapt diff --git a/tools/aapt2/TableFlattener.h b/tools/aapt2/TableFlattener.h new file mode 100644 index 0000000..ccbb737 --- /dev/null +++ b/tools/aapt2/TableFlattener.h @@ -0,0 +1,61 @@ +/* + * 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_TABLE_FLATTENER_H +#define AAPT_TABLE_FLATTENER_H + +#include "BigBuffer.h" +#include "ResourceTable.h" + +namespace aapt { + +using SymbolEntryVector = std::vector<std::pair<ResourceNameRef, uint32_t>>; + +struct FlatEntry; + +/** + * Flattens a ResourceTable into a binary format suitable + * for loading into a ResTable on the host or device. + */ +struct TableFlattener { + /** + * A set of options for this TableFlattener. + */ + struct Options { + /** + * Specifies whether to output extended chunks, like + * source information and mising symbol entries. Default + * is true. + * + * Set this to false when emitting the final table to be used + * on device. + */ + bool useExtendedChunks = true; + }; + + TableFlattener(Options options); + + bool flatten(BigBuffer* out, const ResourceTable& table); + +private: + bool flattenValue(BigBuffer* out, const FlatEntry& flatEntry, SymbolEntryVector* symbols); + + Options mOptions; +}; + +} // namespace aapt + +#endif // AAPT_TABLE_FLATTENER_H diff --git a/tools/aapt2/Util.cpp b/tools/aapt2/Util.cpp new file mode 100644 index 0000000..03ecd1a --- /dev/null +++ b/tools/aapt2/Util.cpp @@ -0,0 +1,343 @@ +/* + * 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 "BigBuffer.h" +#include "Maybe.h" +#include "StringPiece.h" +#include "Util.h" + +#include <algorithm> +#include <ostream> +#include <string> +#include <utils/Unicode.h> +#include <vector> + +namespace aapt { +namespace util { + +constexpr const char16_t* kSchemaAuto = u"http://schemas.android.com/apk/res-auto"; +constexpr const char16_t* kSchemaPrefix = u"http://schemas.android.com/apk/res/"; + +static std::vector<std::string> splitAndTransform(const StringPiece& str, char sep, + const std::function<char(char)>& f) { + std::vector<std::string> parts; + const StringPiece::const_iterator end = std::end(str); + StringPiece::const_iterator start = std::begin(str); + StringPiece::const_iterator current; + do { + current = std::find(start, end, sep); + parts.emplace_back(str.substr(start, current).toString()); + if (f) { + std::string& part = parts.back(); + std::transform(part.begin(), part.end(), part.begin(), f); + } + start = current + 1; + } while (current != end); + return parts; +} + +std::vector<std::string> split(const StringPiece& str, char sep) { + return splitAndTransform(str, sep, nullptr); +} + +std::vector<std::string> splitAndLowercase(const StringPiece& str, char sep) { + return splitAndTransform(str, sep, ::tolower); +} + +StringPiece16 trimWhitespace(const StringPiece16& str) { + if (str.size() == 0 || str.data() == nullptr) { + return str; + } + + const char16_t* start = str.data(); + const char16_t* end = str.data() + str.length(); + + while (start != end && util::isspace16(*start)) { + start++; + } + + while (end != start && util::isspace16(*(end - 1))) { + end--; + } + + return StringPiece16(start, end - start); +} + +StringPiece16::const_iterator findNonAlphaNumericAndNotInSet(const StringPiece16& str, + const StringPiece16& allowedChars) { + const auto endIter = str.end(); + for (auto iter = str.begin(); iter != endIter; ++iter) { + char16_t c = *iter; + if ((c >= u'a' && c <= u'z') || + (c >= u'A' && c <= u'Z') || + (c >= u'0' && c <= u'9')) { + continue; + } + + bool match = false; + for (char16_t i : allowedChars) { + if (c == i) { + match = true; + break; + } + } + + if (!match) { + return iter; + } + } + return endIter; +} + +bool isJavaClassName(const StringPiece16& str) { + size_t pieces = 0; + for (const StringPiece16& piece : tokenize(str, u'.')) { + pieces++; + if (piece.empty()) { + return false; + } + + // Can't have starting or trailing $ character. + if (piece.data()[0] == u'$' || piece.data()[piece.size() - 1] == u'$') { + return false; + } + + if (findNonAlphaNumericAndNotInSet(piece, u"$_") != piece.end()) { + return false; + } + } + return pieces >= 2; +} + +Maybe<std::u16string> getFullyQualifiedClassName(const StringPiece16& package, + const StringPiece16& className) { + if (className.empty()) { + return {}; + } + + if (util::isJavaClassName(className)) { + return className.toString(); + } + + if (package.empty()) { + return {}; + } + + std::u16string result(package.data(), package.size()); + if (className.data()[0] != u'.') { + result += u'.'; + } + result.append(className.data(), className.size()); + if (!isJavaClassName(result)) { + return {}; + } + return result; +} + +static Maybe<char16_t> parseUnicodeCodepoint(const char16_t** start, const char16_t* end) { + char16_t code = 0; + for (size_t i = 0; i < 4 && *start != end; i++, (*start)++) { + char16_t c = **start; + int a; + if (c >= '0' && c <= '9') { + a = c - '0'; + } else if (c >= 'a' && c <= 'f') { + a = c - 'a' + 10; + } else if (c >= 'A' && c <= 'F') { + a = c - 'A' + 10; + } else { + return make_nothing<char16_t>(); + } + code = (code << 4) | a; + } + return make_value(code); +} + +StringBuilder& StringBuilder::append(const StringPiece16& str) { + if (!mError.empty()) { + return *this; + } + + const char16_t* const end = str.end(); + const char16_t* start = str.begin(); + const char16_t* current = start; + while (current != end) { + if (*current == u'"') { + if (!mQuote && mTrailingSpace) { + // We found an opening quote, and we have + // trailing space, so we should append that + // space now. + if (mTrailingSpace) { + // We had trailing whitespace, so + // replace with a single space. + if (!mStr.empty()) { + mStr += u' '; + } + mTrailingSpace = false; + } + } + mQuote = !mQuote; + mStr.append(start, current - start); + start = current + 1; + } else if (*current == u'\'' && !mQuote) { + // This should be escaped. + mError = "unescaped apostrophe"; + return *this; + } else if (*current == u'\\') { + // This is an escape sequence, convert to the real value. + if (!mQuote && mTrailingSpace) { + // We had trailing whitespace, so + // replace with a single space. + if (!mStr.empty()) { + mStr += u' '; + } + mTrailingSpace = false; + } + mStr.append(start, current - start); + start = current + 1; + + current++; + if (current != end) { + switch (*current) { + case u't': + mStr += u'\t'; + break; + case u'n': + mStr += u'\n'; + break; + case u'#': + mStr += u'#'; + break; + case u'@': + mStr += u'@'; + break; + case u'?': + mStr += u'?'; + break; + case u'"': + mStr += u'"'; + break; + case u'\'': + mStr += u'\''; + break; + case u'\\': + mStr += u'\\'; + break; + case u'u': { + current++; + Maybe<char16_t> c = parseUnicodeCodepoint(¤t, end); + if (!c) { + mError = "invalid unicode escape sequence"; + return *this; + } + mStr += c.value(); + current -= 1; + break; + } + + default: + // Ignore. + break; + } + start = current + 1; + } + } else if (!mQuote) { + // This is not quoted text, so look for whitespace. + if (isspace16(*current)) { + // We found whitespace, see if we have seen some + // before. + if (!mTrailingSpace) { + // We didn't see a previous adjacent space, + // so mark that we did. + mTrailingSpace = true; + mStr.append(start, current - start); + } + + // Keep skipping whitespace. + start = current + 1; + } else if (mTrailingSpace) { + // We saw trailing space before, so replace all + // that trailing space with one space. + if (!mStr.empty()) { + mStr += u' '; + } + mTrailingSpace = false; + } + } + current++; + } + mStr.append(start, end - start); + return *this; +} + +std::u16string utf8ToUtf16(const StringPiece& utf8) { + ssize_t utf16Length = utf8_to_utf16_length(reinterpret_cast<const uint8_t*>(utf8.data()), + utf8.length()); + if (utf16Length <= 0) { + return {}; + } + + std::u16string utf16; + utf16.resize(utf16Length); + utf8_to_utf16(reinterpret_cast<const uint8_t*>(utf8.data()), utf8.length(), &*utf16.begin()); + return utf16; +} + +std::string utf16ToUtf8(const StringPiece16& utf16) { + ssize_t utf8Length = utf16_to_utf8_length(utf16.data(), utf16.length()); + if (utf8Length <= 0) { + return {}; + } + + std::string utf8; + utf8.resize(utf8Length); + utf16_to_utf8(utf16.data(), utf16.length(), &*utf8.begin()); + return utf8; +} + +bool writeAll(std::ostream& out, const BigBuffer& buffer) { + for (const auto& b : buffer) { + if (!out.write(reinterpret_cast<const char*>(b.buffer.get()), b.size)) { + return false; + } + } + return true; +} + +std::unique_ptr<uint8_t[]> copy(const BigBuffer& buffer) { + std::unique_ptr<uint8_t[]> data = std::unique_ptr<uint8_t[]>(new uint8_t[buffer.size()]); + uint8_t* p = data.get(); + for (const auto& block : buffer) { + memcpy(p, block.buffer.get(), block.size); + p += block.size; + } + return data; +} + +Maybe<std::u16string> extractPackageFromNamespace(const std::u16string& namespaceUri) { + if (stringStartsWith<char16_t>(namespaceUri, kSchemaPrefix)) { + StringPiece16 schemaPrefix = kSchemaPrefix; + StringPiece16 package = namespaceUri; + return package.substr(schemaPrefix.size(), package.size() - schemaPrefix.size()) + .toString(); + } else if (namespaceUri == kSchemaAuto) { + return std::u16string(); + } + return {}; +} + +} // namespace util +} // namespace aapt diff --git a/tools/aapt2/Util.h b/tools/aapt2/Util.h new file mode 100644 index 0000000..9cdb152 --- /dev/null +++ b/tools/aapt2/Util.h @@ -0,0 +1,320 @@ +/* + * 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_UTIL_H +#define AAPT_UTIL_H + +#include "BigBuffer.h" +#include "Maybe.h" +#include "StringPiece.h" + +#include <androidfw/ResourceTypes.h> +#include <functional> +#include <memory> +#include <ostream> +#include <string> +#include <vector> + +namespace aapt { +namespace util { + +std::vector<std::string> split(const StringPiece& str, char sep); +std::vector<std::string> splitAndLowercase(const StringPiece& str, char sep); + +/** + * Returns true if the string starts with prefix. + */ +template <typename T> +bool stringStartsWith(const BasicStringPiece<T>& str, const BasicStringPiece<T>& prefix) { + if (str.size() < prefix.size()) { + return false; + } + return str.substr(0, prefix.size()) == prefix; +} + +/** + * Returns true if the string ends with suffix. + */ +template <typename T> +bool stringEndsWith(const BasicStringPiece<T>& str, const BasicStringPiece<T>& suffix) { + if (str.size() < suffix.size()) { + return false; + } + return str.substr(str.size() - suffix.size(), suffix.size()) == suffix; +} + +/** + * Creates a new StringPiece16 that points to a substring + * of the original string without leading or trailing whitespace. + */ +StringPiece16 trimWhitespace(const StringPiece16& str); + +/** + * UTF-16 isspace(). It basically checks for lower range characters that are + * whitespace. + */ +inline bool isspace16(char16_t c) { + return c < 0x0080 && isspace(c); +} + +/** + * Returns an iterator to the first character that is not alpha-numeric and that + * is not in the allowedChars set. + */ +StringPiece16::const_iterator findNonAlphaNumericAndNotInSet(const StringPiece16& str, + const StringPiece16& allowedChars); + +/** + * Tests that the string is a valid Java class name. + */ +bool isJavaClassName(const StringPiece16& str); + +/** + * Converts the class name to a fully qualified class name from the given `package`. Ex: + * + * asdf --> package.asdf + * .asdf --> package.asdf + * .a.b --> package.a.b + * asdf.adsf --> asdf.adsf + */ +Maybe<std::u16string> getFullyQualifiedClassName(const StringPiece16& package, + const StringPiece16& className); + + +/** + * Makes a std::unique_ptr<> with the template parameter inferred by the compiler. + * This will be present in C++14 and can be removed then. + */ +template <typename T, class... Args> +std::unique_ptr<T> make_unique(Args&&... args) { + return std::unique_ptr<T>(new T{std::forward<Args>(args)...}); +} + +/** + * Writes a set of items to the std::ostream, joining the times with the provided + * separator. + */ +template <typename Iterator> +::std::function<::std::ostream&(::std::ostream&)> joiner(Iterator begin, Iterator end, + const char* sep) { + return [begin, end, sep](::std::ostream& out) -> ::std::ostream& { + for (auto iter = begin; iter != end; ++iter) { + if (iter != begin) { + out << sep; + } + out << *iter; + } + return out; + }; +} + +inline ::std::function<::std::ostream&(::std::ostream&)> formatSize(size_t size) { + return [size](::std::ostream& out) -> ::std::ostream& { + constexpr size_t K = 1024u; + constexpr size_t M = K * K; + constexpr size_t G = M * K; + if (size < K) { + out << size << "B"; + } else if (size < M) { + out << (double(size) / K) << " KiB"; + } else if (size < G) { + out << (double(size) / M) << " MiB"; + } else { + out << (double(size) / G) << " GiB"; + } + return out; + }; +} + +/** + * Helper method to extract a string from a StringPool. + */ +inline StringPiece16 getString(const android::ResStringPool& pool, size_t idx) { + size_t len; + const char16_t* str = pool.stringAt(idx, &len); + if (str != nullptr) { + return StringPiece16(str, len); + } + return StringPiece16(); +} + +class StringBuilder { +public: + StringBuilder& append(const StringPiece16& str); + const std::u16string& str() const; + const std::string& error() const; + operator bool() const; + +private: + std::u16string mStr; + bool mQuote = false; + bool mTrailingSpace = false; + std::string mError; +}; + +inline const std::u16string& StringBuilder::str() const { + return mStr; +} + +inline const std::string& StringBuilder::error() const { + return mError; +} + +inline StringBuilder::operator bool() const { + return mError.empty(); +} + +/** + * Converts a UTF8 string to a UTF16 string. + */ +std::u16string utf8ToUtf16(const StringPiece& utf8); +std::string utf16ToUtf8(const StringPiece16& utf8); + +/** + * Writes the entire BigBuffer to the output stream. + */ +bool writeAll(std::ostream& out, const BigBuffer& buffer); + +/* + * Copies the entire BigBuffer into a single buffer. + */ +std::unique_ptr<uint8_t[]> copy(const BigBuffer& buffer); + +/** + * A Tokenizer implemented as an iterable collection. It does not allocate + * any memory on the heap nor use standard containers. + */ +template <typename Char> +class Tokenizer { +public: + class iterator { + public: + iterator(const iterator&) = default; + iterator& operator=(const iterator&) = default; + + iterator& operator++(); + BasicStringPiece<Char> operator*(); + bool operator==(const iterator& rhs) const; + bool operator!=(const iterator& rhs) const; + + private: + friend class Tokenizer<Char>; + + iterator(BasicStringPiece<Char> s, Char sep, BasicStringPiece<Char> tok); + + BasicStringPiece<Char> str; + Char separator; + BasicStringPiece<Char> token; + }; + + Tokenizer(BasicStringPiece<Char> str, Char sep); + iterator begin(); + iterator end(); + +private: + const iterator mBegin; + const iterator mEnd; +}; + +template <typename Char> +inline Tokenizer<Char> tokenize(BasicStringPiece<Char> str, Char sep) { + return Tokenizer<Char>(str, sep); +} + +template <typename Char> +typename Tokenizer<Char>::iterator& Tokenizer<Char>::iterator::operator++() { + const Char* start = token.end(); + const Char* end = str.end(); + if (start == end) { + token.assign(token.end(), 0); + return *this; + } + + start += 1; + const Char* current = start; + while (current != end) { + if (*current == separator) { + token.assign(start, current - start); + return *this; + } + ++current; + } + token.assign(start, end - start); + return *this; +} + +template <typename Char> +inline BasicStringPiece<Char> Tokenizer<Char>::iterator::operator*() { + return token; +} + +template <typename Char> +inline bool Tokenizer<Char>::iterator::operator==(const iterator& rhs) const { + // We check equality here a bit differently. + // We need to know that the addresses are the same. + return token.begin() == rhs.token.begin() && token.end() == rhs.token.end(); +} + +template <typename Char> +inline bool Tokenizer<Char>::iterator::operator!=(const iterator& rhs) const { + return !(*this == rhs); +} + +template <typename Char> +inline Tokenizer<Char>::iterator::iterator(BasicStringPiece<Char> s, Char sep, + BasicStringPiece<Char> tok) : + str(s), separator(sep), token(tok) { +} + +template <typename Char> +inline typename Tokenizer<Char>::iterator Tokenizer<Char>::begin() { + return mBegin; +} + +template <typename Char> +inline typename Tokenizer<Char>::iterator Tokenizer<Char>::end() { + return mEnd; +} + +template <typename Char> +inline Tokenizer<Char>::Tokenizer(BasicStringPiece<Char> str, Char sep) : + mBegin(++iterator(str, sep, BasicStringPiece<Char>(str.begin() - 1, 0))), + mEnd(str, sep, BasicStringPiece<Char>(str.end(), 0)) { +} + +/** + * Returns a package name if the namespace URI is of the form: + * http://schemas.android.com/apk/res/<package> + * + * Special case: if namespaceUri is http://schemas.android.com/apk/res-auto, + * returns an empty package name. + */ +Maybe<std::u16string> extractPackageFromNamespace(const std::u16string& namespaceUri); + +} // namespace util + +/** + * Stream operator for functions. Calls the function with the stream as an argument. + * In the aapt namespace for lookup. + */ +inline ::std::ostream& operator<<(::std::ostream& out, + ::std::function<::std::ostream&(::std::ostream&)> f) { + return f(out); +} + +} // namespace aapt + +#endif // AAPT_UTIL_H diff --git a/tools/aapt2/Util_test.cpp b/tools/aapt2/Util_test.cpp new file mode 100644 index 0000000..0b08d24 --- /dev/null +++ b/tools/aapt2/Util_test.cpp @@ -0,0 +1,136 @@ +/* + * 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 <gtest/gtest.h> +#include <string> + +#include "StringPiece.h" +#include "Util.h" + +namespace aapt { + +TEST(UtilTest, TrimOnlyWhitespace) { + const std::u16string full = u"\n "; + + StringPiece16 trimmed = util::trimWhitespace(full); + EXPECT_TRUE(trimmed.empty()); + EXPECT_EQ(0u, trimmed.size()); +} + +TEST(UtilTest, StringEndsWith) { + EXPECT_TRUE(util::stringEndsWith<char>("hello.xml", ".xml")); +} + +TEST(UtilTest, StringStartsWith) { + EXPECT_TRUE(util::stringStartsWith<char>("hello.xml", "he")); +} + +TEST(UtilTest, StringBuilderWhitespaceRemoval) { + EXPECT_EQ(StringPiece16(u"hey guys this is so cool"), + util::StringBuilder().append(u" hey guys ") + .append(u" this is so cool ") + .str()); + + EXPECT_EQ(StringPiece16(u" wow, so many \t spaces. what?"), + util::StringBuilder().append(u" \" wow, so many \t ") + .append(u"spaces. \"what? ") + .str()); + + EXPECT_EQ(StringPiece16(u"where is the pie?"), + util::StringBuilder().append(u" where \t ") + .append(u" \nis the "" pie?") + .str()); +} + +TEST(UtilTest, StringBuilderEscaping) { + EXPECT_EQ(StringPiece16(u"hey guys\n this \t is so\\ cool"), + util::StringBuilder().append(u" hey guys\\n ") + .append(u" this \\t is so\\\\ cool ") + .str()); + + EXPECT_EQ(StringPiece16(u"@?#\\\'"), + util::StringBuilder().append(u"\\@\\?\\#\\\\\\'") + .str()); +} + +TEST(UtilTest, StringBuilderMisplacedQuote) { + util::StringBuilder builder{}; + EXPECT_FALSE(builder.append(u"they're coming!")); +} + +TEST(UtilTest, StringBuilderUnicodeCodes) { + EXPECT_EQ(StringPiece16(u"\u00AF\u0AF0 woah"), + util::StringBuilder().append(u"\\u00AF\\u0AF0 woah") + .str()); + + EXPECT_FALSE(util::StringBuilder().append(u"\\u00 yo")); +} + +TEST(UtilTest, TokenizeInput) { + auto tokenizer = util::tokenize(StringPiece16(u"this| is|the|end"), u'|'); + auto iter = tokenizer.begin(); + ASSERT_EQ(*iter, StringPiece16(u"this")); + ++iter; + ASSERT_EQ(*iter, StringPiece16(u" is")); + ++iter; + ASSERT_EQ(*iter, StringPiece16(u"the")); + ++iter; + ASSERT_EQ(*iter, StringPiece16(u"end")); + ++iter; + ASSERT_EQ(tokenizer.end(), iter); +} + +TEST(UtilTest, IsJavaClassName) { + EXPECT_TRUE(util::isJavaClassName(u"android.test.Class")); + EXPECT_TRUE(util::isJavaClassName(u"android.test.Class$Inner")); + EXPECT_TRUE(util::isJavaClassName(u"android_test.test.Class")); + EXPECT_TRUE(util::isJavaClassName(u"_android_.test._Class_")); + EXPECT_FALSE(util::isJavaClassName(u"android.test.$Inner")); + EXPECT_FALSE(util::isJavaClassName(u"android.test.Inner$")); + EXPECT_FALSE(util::isJavaClassName(u".test.Class")); + EXPECT_FALSE(util::isJavaClassName(u"android")); +} + +TEST(UtilTest, FullyQualifiedClassName) { + Maybe<std::u16string> res = util::getFullyQualifiedClassName(u"android", u"asdf"); + ASSERT_TRUE(res); + EXPECT_EQ(res.value(), u"android.asdf"); + + res = util::getFullyQualifiedClassName(u"android", u".asdf"); + ASSERT_TRUE(res); + EXPECT_EQ(res.value(), u"android.asdf"); + + res = util::getFullyQualifiedClassName(u"android", u".a.b"); + ASSERT_TRUE(res); + EXPECT_EQ(res.value(), u"android.a.b"); + + res = util::getFullyQualifiedClassName(u"android", u"a.b"); + ASSERT_TRUE(res); + EXPECT_EQ(res.value(), u"a.b"); + + res = util::getFullyQualifiedClassName(u"", u"a.b"); + ASSERT_TRUE(res); + EXPECT_EQ(res.value(), u"a.b"); + + res = util::getFullyQualifiedClassName(u"", u""); + ASSERT_FALSE(res); + + res = util::getFullyQualifiedClassName(u"android", u"./Apple"); + ASSERT_FALSE(res); +} + + +} // namespace aapt diff --git a/tools/aapt2/XliffXmlPullParser.cpp b/tools/aapt2/XliffXmlPullParser.cpp new file mode 100644 index 0000000..31115f2 --- /dev/null +++ b/tools/aapt2/XliffXmlPullParser.cpp @@ -0,0 +1,113 @@ +/* + * 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 "XliffXmlPullParser.h" + +#include <string> + +namespace aapt { + +XliffXmlPullParser::XliffXmlPullParser(const std::shared_ptr<XmlPullParser>& parser) : + mParser(parser) { +} + +XmlPullParser::Event XliffXmlPullParser::next() { + while (XmlPullParser::isGoodEvent(mParser->next())) { + Event event = mParser->getEvent(); + if (event != Event::kStartElement && event != Event::kEndElement) { + break; + } + + if (mParser->getElementNamespace() != + u"urn:oasis:names:tc:xliff:document:1.2") { + break; + } + + const std::u16string& name = mParser->getElementName(); + if (name != u"bpt" + && name != u"ept" + && name != u"it" + && name != u"ph" + && name != u"g" + && name != u"bx" + && name != u"ex" + && name != u"x") { + break; + } + + // We hit a tag that was ignored, so get the next event. + } + return mParser->getEvent(); +} + +XmlPullParser::Event XliffXmlPullParser::getEvent() const { + return mParser->getEvent(); +} + +const std::string& XliffXmlPullParser::getLastError() const { + return mParser->getLastError(); +} + +const std::u16string& XliffXmlPullParser::getComment() const { + return mParser->getComment(); +} + +size_t XliffXmlPullParser::getLineNumber() const { + return mParser->getLineNumber(); +} + +size_t XliffXmlPullParser::getDepth() const { + return mParser->getDepth(); +} + +const std::u16string& XliffXmlPullParser::getText() const { + return mParser->getText(); +} + +const std::u16string& XliffXmlPullParser::getNamespacePrefix() const { + return mParser->getNamespacePrefix(); +} + +const std::u16string& XliffXmlPullParser::getNamespaceUri() const { + return mParser->getNamespaceUri(); +} + +bool XliffXmlPullParser::applyPackageAlias(std::u16string* package, + const std::u16string& defaultPackage) const { + return mParser->applyPackageAlias(package, defaultPackage); +} + +const std::u16string& XliffXmlPullParser::getElementNamespace() const { + return mParser->getElementNamespace(); +} + +const std::u16string& XliffXmlPullParser::getElementName() const { + return mParser->getElementName(); +} + +size_t XliffXmlPullParser::getAttributeCount() const { + return mParser->getAttributeCount(); +} + +XmlPullParser::const_iterator XliffXmlPullParser::beginAttributes() const { + return mParser->beginAttributes(); +} + +XmlPullParser::const_iterator XliffXmlPullParser::endAttributes() const { + return mParser->endAttributes(); +} + +} // namespace aapt diff --git a/tools/aapt2/XliffXmlPullParser.h b/tools/aapt2/XliffXmlPullParser.h new file mode 100644 index 0000000..7791227 --- /dev/null +++ b/tools/aapt2/XliffXmlPullParser.h @@ -0,0 +1,64 @@ +/* + * 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_XLIFF_XML_PULL_PARSER_H +#define AAPT_XLIFF_XML_PULL_PARSER_H + +#include "XmlPullParser.h" + +#include <memory> +#include <string> + +namespace aapt { + +/** + * Strips xliff elements and provides the caller with a view of the + * underlying XML without xliff. + */ +class XliffXmlPullParser : public XmlPullParser { +public: + XliffXmlPullParser(const std::shared_ptr<XmlPullParser>& parser); + XliffXmlPullParser(const XliffXmlPullParser& rhs) = delete; + + Event getEvent() const override; + const std::string& getLastError() const override; + Event next() override; + + const std::u16string& getComment() const override; + size_t getLineNumber() const override; + size_t getDepth() const override; + + const std::u16string& getText() const override; + + const std::u16string& getNamespacePrefix() const override; + const std::u16string& getNamespaceUri() const override; + bool applyPackageAlias(std::u16string* package, const std::u16string& defaultPackage) + const override; + + const std::u16string& getElementNamespace() const override; + const std::u16string& getElementName() const override; + + const_iterator beginAttributes() const override; + const_iterator endAttributes() const override; + size_t getAttributeCount() const override; + +private: + std::shared_ptr<XmlPullParser> mParser; +}; + +} // namespace aapt + +#endif // AAPT_XLIFF_XML_PULL_PARSER_H diff --git a/tools/aapt2/XliffXmlPullParser_test.cpp b/tools/aapt2/XliffXmlPullParser_test.cpp new file mode 100644 index 0000000..f903072 --- /dev/null +++ b/tools/aapt2/XliffXmlPullParser_test.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 "SourceXmlPullParser.h" +#include "XliffXmlPullParser.h" + +#include <gtest/gtest.h> +#include <sstream> +#include <string> + +namespace aapt { + +TEST(XliffXmlPullParserTest, IgnoreXliffTags) { + std::stringstream input; + input << "<?xml version=\"1.0\" encoding=\"utf-8\"?>" << std::endl + << "<resources xmlns:xliff=\"urn:oasis:names:tc:xliff:document:1.2\">" << std::endl + << "<string name=\"foo\">" + << "Hey <xliff:g><xliff:it>there</xliff:it></xliff:g> world</string>" << std::endl + << "</resources>" << std::endl; + std::shared_ptr<XmlPullParser> sourceParser = std::make_shared<SourceXmlPullParser>(input); + XliffXmlPullParser parser(sourceParser); + EXPECT_EQ(XmlPullParser::Event::kStartDocument, parser.getEvent()); + + EXPECT_EQ(XmlPullParser::Event::kStartNamespace, parser.next()); + EXPECT_EQ(parser.getNamespaceUri(), u"urn:oasis:names:tc:xliff:document:1.2"); + EXPECT_EQ(parser.getNamespacePrefix(), u"xliff"); + + EXPECT_EQ(XmlPullParser::Event::kStartElement, parser.next()); + EXPECT_EQ(parser.getElementNamespace(), u""); + EXPECT_EQ(parser.getElementName(), u"resources"); + EXPECT_EQ(XmlPullParser::Event::kText, parser.next()); // Account for newline/whitespace. + + EXPECT_EQ(XmlPullParser::Event::kStartElement, parser.next()); + EXPECT_EQ(parser.getElementNamespace(), u""); + EXPECT_EQ(parser.getElementName(), u"string"); + + EXPECT_EQ(XmlPullParser::Event::kText, parser.next()); + EXPECT_EQ(parser.getText(), u"Hey "); + + EXPECT_EQ(XmlPullParser::Event::kText, parser.next()); + EXPECT_EQ(parser.getText(), u"there"); + + EXPECT_EQ(XmlPullParser::Event::kText, parser.next()); + EXPECT_EQ(parser.getText(), u" world"); + + EXPECT_EQ(XmlPullParser::Event::kEndElement, parser.next()); + EXPECT_EQ(parser.getElementNamespace(), u""); + EXPECT_EQ(parser.getElementName(), u"string"); + EXPECT_EQ(XmlPullParser::Event::kText, parser.next()); // Account for newline/whitespace. + + EXPECT_EQ(XmlPullParser::Event::kEndElement, parser.next()); + EXPECT_EQ(parser.getElementNamespace(), u""); + EXPECT_EQ(parser.getElementName(), u"resources"); + + EXPECT_EQ(XmlPullParser::Event::kEndNamespace, parser.next()); + EXPECT_EQ(parser.getNamespacePrefix(), u"xliff"); + EXPECT_EQ(parser.getNamespaceUri(), u"urn:oasis:names:tc:xliff:document:1.2"); + + EXPECT_EQ(XmlPullParser::Event::kEndDocument, parser.next()); +} + +} // namespace aapt diff --git a/tools/aapt2/XmlDom.cpp b/tools/aapt2/XmlDom.cpp new file mode 100644 index 0000000..763029f --- /dev/null +++ b/tools/aapt2/XmlDom.cpp @@ -0,0 +1,431 @@ +/* + * 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 "Logger.h" +#include "Util.h" +#include "XmlDom.h" +#include "XmlPullParser.h" + +#include <cassert> +#include <memory> +#include <stack> +#include <string> +#include <tuple> + +namespace aapt { +namespace xml { + +constexpr char kXmlNamespaceSep = 1; + +struct Stack { + std::unique_ptr<xml::Node> root; + std::stack<xml::Node*> nodeStack; + std::u16string pendingComment; +}; + +/** + * Extracts the namespace and name of an expanded element or attribute name. + */ +static void splitName(const char* name, std::u16string* outNs, std::u16string* outName) { + const char* p = name; + while (*p != 0 && *p != kXmlNamespaceSep) { + p++; + } + + if (*p == 0) { + outNs->clear(); + *outName = util::utf8ToUtf16(name); + } else { + *outNs = util::utf8ToUtf16(StringPiece(name, (p - name))); + *outName = util::utf8ToUtf16(p + 1); + } +} + +static void addToStack(Stack* stack, XML_Parser parser, std::unique_ptr<Node> node) { + node->lineNumber = XML_GetCurrentLineNumber(parser); + node->columnNumber = XML_GetCurrentColumnNumber(parser); + + Node* thisNode = node.get(); + if (!stack->nodeStack.empty()) { + stack->nodeStack.top()->addChild(std::move(node)); + } else { + stack->root = std::move(node); + } + + if (thisNode->type != NodeType::kText) { + stack->nodeStack.push(thisNode); + } +} + +static void XMLCALL startNamespaceHandler(void* userData, const char* prefix, const char* uri) { + XML_Parser parser = reinterpret_cast<XML_Parser>(userData); + Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser)); + + std::unique_ptr<Namespace> ns = util::make_unique<Namespace>(); + if (prefix) { + ns->namespacePrefix = util::utf8ToUtf16(prefix); + } + + if (uri) { + ns->namespaceUri = util::utf8ToUtf16(uri); + } + + addToStack(stack, parser, std::move(ns)); +} + +static void XMLCALL endNamespaceHandler(void* userData, const char* prefix) { + XML_Parser parser = reinterpret_cast<XML_Parser>(userData); + Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser)); + + assert(!stack->nodeStack.empty()); + stack->nodeStack.pop(); +} + +static bool lessAttribute(const Attribute& lhs, const Attribute& rhs) { + return std::tie(lhs.namespaceUri, lhs.name, lhs.value) < + std::tie(rhs.namespaceUri, rhs.name, rhs.value); +} + +static void XMLCALL startElementHandler(void* userData, const char* name, const char** attrs) { + XML_Parser parser = reinterpret_cast<XML_Parser>(userData); + Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser)); + + std::unique_ptr<Element> el = util::make_unique<Element>(); + splitName(name, &el->namespaceUri, &el->name); + + while (*attrs) { + Attribute attribute; + splitName(*attrs++, &attribute.namespaceUri, &attribute.name); + attribute.value = util::utf8ToUtf16(*attrs++); + + // Insert in sorted order. + auto iter = std::lower_bound(el->attributes.begin(), el->attributes.end(), attribute, + lessAttribute); + el->attributes.insert(iter, std::move(attribute)); + } + + el->comment = std::move(stack->pendingComment); + addToStack(stack, parser, std::move(el)); +} + +static void XMLCALL endElementHandler(void* userData, const char* name) { + XML_Parser parser = reinterpret_cast<XML_Parser>(userData); + Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser)); + + assert(!stack->nodeStack.empty()); + stack->nodeStack.top()->comment = std::move(stack->pendingComment); + stack->nodeStack.pop(); +} + +static void XMLCALL characterDataHandler(void* userData, const char* s, int len) { + XML_Parser parser = reinterpret_cast<XML_Parser>(userData); + Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser)); + + if (!s || len <= 0) { + return; + } + + // See if we can just append the text to a previous text node. + if (!stack->nodeStack.empty()) { + Node* currentParent = stack->nodeStack.top(); + if (!currentParent->children.empty()) { + Node* lastChild = currentParent->children.back().get(); + if (lastChild->type == NodeType::kText) { + Text* text = static_cast<Text*>(lastChild); + text->text += util::utf8ToUtf16(StringPiece(s, len)); + return; + } + } + } + + std::unique_ptr<Text> text = util::make_unique<Text>(); + text->text = util::utf8ToUtf16(StringPiece(s, len)); + addToStack(stack, parser, std::move(text)); +} + +static void XMLCALL commentDataHandler(void* userData, const char* comment) { + XML_Parser parser = reinterpret_cast<XML_Parser>(userData); + Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser)); + + if (!stack->pendingComment.empty()) { + stack->pendingComment += '\n'; + } + stack->pendingComment += util::utf8ToUtf16(comment); +} + +std::unique_ptr<Node> inflate(std::istream* in, SourceLogger* logger) { + Stack stack; + + XML_Parser parser = XML_ParserCreateNS(nullptr, kXmlNamespaceSep); + XML_SetUserData(parser, &stack); + XML_UseParserAsHandlerArg(parser); + XML_SetElementHandler(parser, startElementHandler, endElementHandler); + XML_SetNamespaceDeclHandler(parser, startNamespaceHandler, endNamespaceHandler); + XML_SetCharacterDataHandler(parser, characterDataHandler); + XML_SetCommentHandler(parser, commentDataHandler); + + char buffer[1024]; + while (!in->eof()) { + in->read(buffer, sizeof(buffer) / sizeof(buffer[0])); + if (in->bad() && !in->eof()) { + stack.root = {}; + logger->error() << strerror(errno) << std::endl; + break; + } + + if (XML_Parse(parser, buffer, in->gcount(), in->eof()) == XML_STATUS_ERROR) { + stack.root = {}; + logger->error(XML_GetCurrentLineNumber(parser)) + << XML_ErrorString(XML_GetErrorCode(parser)) << std::endl; + break; + } + } + + XML_ParserFree(parser); + return std::move(stack.root); +} + +static void copyAttributes(Element* el, android::ResXMLParser* parser) { + const size_t attrCount = parser->getAttributeCount(); + if (attrCount > 0) { + el->attributes.reserve(attrCount); + for (size_t i = 0; i < attrCount; i++) { + Attribute attr; + size_t len; + const char16_t* str16 = parser->getAttributeNamespace(i, &len); + if (str16) { + attr.namespaceUri.assign(str16, len); + } + + str16 = parser->getAttributeName(i, &len); + if (str16) { + attr.name.assign(str16, len); + } + + str16 = parser->getAttributeStringValue(i, &len); + if (str16) { + attr.value.assign(str16, len); + } + el->attributes.push_back(std::move(attr)); + } + } +} + +std::unique_ptr<Node> inflate(const void* data, size_t dataLen, SourceLogger* logger) { + std::unique_ptr<Node> root; + std::stack<Node*> nodeStack; + + android::ResXMLTree tree; + if (tree.setTo(data, dataLen) != android::NO_ERROR) { + return {}; + } + + android::ResXMLParser::event_code_t code; + while ((code = tree.next()) != android::ResXMLParser::BAD_DOCUMENT && + code != android::ResXMLParser::END_DOCUMENT) { + std::unique_ptr<Node> newNode; + switch (code) { + case android::ResXMLParser::START_NAMESPACE: { + std::unique_ptr<Namespace> node = util::make_unique<Namespace>(); + size_t len; + const char16_t* str16 = tree.getNamespacePrefix(&len); + if (str16) { + node->namespacePrefix.assign(str16, len); + } + + str16 = tree.getNamespaceUri(&len); + if (str16) { + node->namespaceUri.assign(str16, len); + } + newNode = std::move(node); + break; + } + + case android::ResXMLParser::START_TAG: { + std::unique_ptr<Element> node = util::make_unique<Element>(); + size_t len; + const char16_t* str16 = tree.getElementNamespace(&len); + if (str16) { + node->namespaceUri.assign(str16, len); + } + + str16 = tree.getElementName(&len); + if (str16) { + node->name.assign(str16, len); + } + + copyAttributes(node.get(), &tree); + + newNode = std::move(node); + break; + } + + case android::ResXMLParser::TEXT: { + std::unique_ptr<Text> node = util::make_unique<Text>(); + size_t len; + const char16_t* str16 = tree.getText(&len); + if (str16) { + node->text.assign(str16, len); + } + newNode = std::move(node); + break; + } + + case android::ResXMLParser::END_NAMESPACE: + case android::ResXMLParser::END_TAG: + assert(!nodeStack.empty()); + nodeStack.pop(); + break; + + default: + assert(false); + break; + } + + if (newNode) { + newNode->lineNumber = tree.getLineNumber(); + + Node* thisNode = newNode.get(); + if (!root) { + assert(nodeStack.empty()); + root = std::move(newNode); + } else { + assert(!nodeStack.empty()); + nodeStack.top()->addChild(std::move(newNode)); + } + + if (thisNode->type != NodeType::kText) { + nodeStack.push(thisNode); + } + } + } + return std::move(root); +} + +Node::Node(NodeType type) : type(type), parent(nullptr), lineNumber(0), columnNumber(0) { +} + +void Node::addChild(std::unique_ptr<Node> child) { + child->parent = this; + children.push_back(std::move(child)); +} + +Namespace::Namespace() : BaseNode(NodeType::kNamespace) { +} + +std::unique_ptr<Node> Namespace::clone() const { + Namespace* ns = new Namespace(); + ns->lineNumber = lineNumber; + ns->columnNumber = columnNumber; + ns->comment = comment; + ns->namespacePrefix = namespacePrefix; + ns->namespaceUri = namespaceUri; + for (auto& child : children) { + ns->addChild(child->clone()); + } + return std::unique_ptr<Node>(ns); +} + +Element::Element() : BaseNode(NodeType::kElement) { +} + +std::unique_ptr<Node> Element::clone() const { + Element* el = new Element(); + el->lineNumber = lineNumber; + el->columnNumber = columnNumber; + el->comment = comment; + el->namespaceUri = namespaceUri; + el->name = name; + el->attributes = attributes; + for (auto& child : children) { + el->addChild(child->clone()); + } + return std::unique_ptr<Node>(el); +} + +Attribute* Element::findAttribute(const StringPiece16& ns, const StringPiece16& name) { + for (auto& attr : attributes) { + if (ns == attr.namespaceUri && name == attr.name) { + return &attr; + } + } + return nullptr; +} + +Element* Element::findChild(const StringPiece16& ns, const StringPiece16& name) { + return findChildWithAttribute(ns, name, nullptr); +} + +Element* Element::findChildWithAttribute(const StringPiece16& ns, const StringPiece16& name, + const Attribute* reqAttr) { + for (auto& childNode : children) { + Node* child = childNode.get(); + while (child->type == NodeType::kNamespace) { + if (child->children.empty()) { + break; + } + child = child->children[0].get(); + } + + if (child->type == NodeType::kElement) { + Element* el = static_cast<Element*>(child); + if (ns == el->namespaceUri && name == el->name) { + if (!reqAttr) { + return el; + } + + Attribute* attrName = el->findAttribute(reqAttr->namespaceUri, reqAttr->name); + if (attrName && attrName->value == reqAttr->value) { + return el; + } + } + } + } + return nullptr; +} + +std::vector<Element*> Element::getChildElements() { + std::vector<Element*> elements; + for (auto& childNode : children) { + Node* child = childNode.get(); + while (child->type == NodeType::kNamespace) { + if (child->children.empty()) { + break; + } + child = child->children[0].get(); + } + + if (child->type == NodeType::kElement) { + elements.push_back(static_cast<Element*>(child)); + } + } + return elements; +} + +Text::Text() : BaseNode(NodeType::kText) { +} + +std::unique_ptr<Node> Text::clone() const { + Text* el = new Text(); + el->lineNumber = lineNumber; + el->columnNumber = columnNumber; + el->comment = comment; + el->text = text; + return std::unique_ptr<Node>(el); +} + +} // namespace xml +} // namespace aapt diff --git a/tools/aapt2/XmlDom.h b/tools/aapt2/XmlDom.h new file mode 100644 index 0000000..6931884 --- /dev/null +++ b/tools/aapt2/XmlDom.h @@ -0,0 +1,154 @@ +/* + * 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_XML_DOM_H +#define AAPT_XML_DOM_H + +#include "Logger.h" +#include "StringPiece.h" + +#include <istream> +#include <libexpat/expat.h> +#include <memory> +#include <string> +#include <vector> + +namespace aapt { +namespace xml { + +struct Visitor; + +/** + * The type of node. Can be used to downcast to the concrete XML node + * class. + */ +enum class NodeType { + kNamespace, + kElement, + kText, +}; + +/** + * Base class for all XML nodes. + */ +struct Node { + NodeType type; + Node* parent; + size_t lineNumber; + size_t columnNumber; + std::u16string comment; + std::vector<std::unique_ptr<Node>> children; + + Node(NodeType type); + void addChild(std::unique_ptr<Node> child); + virtual std::unique_ptr<Node> clone() const = 0; + virtual void accept(Visitor* visitor) = 0; + virtual ~Node() {} +}; + +/** + * Base class that implements the visitor methods for a + * subclass of Node. + */ +template <typename Derived> +struct BaseNode : public Node { + BaseNode(NodeType t); + virtual void accept(Visitor* visitor) override; +}; + +/** + * A Namespace XML node. Can only have one child. + */ +struct Namespace : public BaseNode<Namespace> { + std::u16string namespacePrefix; + std::u16string namespaceUri; + + Namespace(); + virtual std::unique_ptr<Node> clone() const override; +}; + +/** + * An XML attribute. + */ +struct Attribute { + std::u16string namespaceUri; + std::u16string name; + std::u16string value; +}; + +/** + * An Element XML node. + */ +struct Element : public BaseNode<Element> { + std::u16string namespaceUri; + std::u16string name; + std::vector<Attribute> attributes; + + Element(); + virtual std::unique_ptr<Node> clone() const override; + Attribute* findAttribute(const StringPiece16& ns, const StringPiece16& name); + xml::Element* findChild(const StringPiece16& ns, const StringPiece16& name); + xml::Element* findChildWithAttribute(const StringPiece16& ns, const StringPiece16& name, + const xml::Attribute* reqAttr); + std::vector<xml::Element*> getChildElements(); +}; + +/** + * A Text (CDATA) XML node. Can not have any children. + */ +struct Text : public BaseNode<Text> { + std::u16string text; + + Text(); + virtual std::unique_ptr<Node> clone() const override; +}; + +/** + * Inflates an XML DOM from a text stream, logging errors to the logger. + * Returns the root node on success, or nullptr on failure. + */ +std::unique_ptr<Node> inflate(std::istream* in, SourceLogger* logger); + +/** + * Inflates an XML DOM from a binary ResXMLTree, logging errors to the logger. + * Returns the root node on success, or nullptr on failure. + */ +std::unique_ptr<Node> inflate(const void* data, size_t dataLen, SourceLogger* logger); + +/** + * A visitor interface for the different XML Node subtypes. + */ +struct Visitor { + virtual void visit(Namespace* node) = 0; + virtual void visit(Element* node) = 0; + virtual void visit(Text* text) = 0; +}; + +// Implementations + +template <typename Derived> +BaseNode<Derived>::BaseNode(NodeType type) : Node(type) { +} + +template <typename Derived> +void BaseNode<Derived>::accept(Visitor* visitor) { + visitor->visit(static_cast<Derived*>(this)); +} + +} // namespace xml +} // namespace aapt + +#endif // AAPT_XML_DOM_H diff --git a/tools/aapt2/XmlDom_test.cpp b/tools/aapt2/XmlDom_test.cpp new file mode 100644 index 0000000..0217144 --- /dev/null +++ b/tools/aapt2/XmlDom_test.cpp @@ -0,0 +1,49 @@ +/* + * 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 "XmlDom.h" + +#include <gtest/gtest.h> +#include <sstream> +#include <string> + +namespace aapt { + +constexpr const char* kXmlPreamble = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"; + +TEST(XmlDomTest, Inflate) { + std::stringstream in(kXmlPreamble); + in << R"EOF( + <Layout xmlns:android="http://schemas.android.com/apk/res/android" + android:layout_width="match_parent" + android:layout_height="wrap_content"> + <TextView android:id="@+id/id" + android:layout_width="wrap_content" + android:layout_height="wrap_content" /> + </Layout> + )EOF"; + + SourceLogger logger(Source{ "/test/path" }); + std::unique_ptr<xml::Node> root = xml::inflate(&in, &logger); + ASSERT_NE(root, nullptr); + + EXPECT_EQ(root->type, xml::NodeType::kNamespace); + xml::Namespace* ns = static_cast<xml::Namespace*>(root.get()); + EXPECT_EQ(ns->namespaceUri, u"http://schemas.android.com/apk/res/android"); + EXPECT_EQ(ns->namespacePrefix, u"android"); +} + +} // namespace aapt diff --git a/tools/aapt2/XmlFlattener.cpp b/tools/aapt2/XmlFlattener.cpp new file mode 100644 index 0000000..56b5613 --- /dev/null +++ b/tools/aapt2/XmlFlattener.cpp @@ -0,0 +1,574 @@ +/* + * 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 "BigBuffer.h" +#include "Logger.h" +#include "Maybe.h" +#include "Resolver.h" +#include "Resource.h" +#include "ResourceParser.h" +#include "ResourceValues.h" +#include "SdkConstants.h" +#include "Source.h" +#include "StringPool.h" +#include "Util.h" +#include "XmlFlattener.h" + +#include <androidfw/ResourceTypes.h> +#include <limits> +#include <map> +#include <string> +#include <vector> + +namespace aapt { +namespace xml { + +constexpr uint32_t kLowPriority = 0xffffffffu; + +// A vector that maps String refs to their final destination in the out buffer. +using FlatStringRefList = std::vector<std::pair<StringPool::Ref, android::ResStringPool_ref*>>; + +struct XmlFlattener : public Visitor { + XmlFlattener(BigBuffer* outBuffer, StringPool* pool, FlatStringRefList* stringRefs, + const std::u16string& defaultPackage) : + mOut(outBuffer), mPool(pool), mStringRefs(stringRefs), + mDefaultPackage(defaultPackage) { + } + + // No copying. + XmlFlattener(const XmlFlattener&) = delete; + XmlFlattener& operator=(const XmlFlattener&) = delete; + + void writeNamespace(Namespace* node, uint16_t type) { + const size_t startIndex = mOut->size(); + android::ResXMLTree_node* flatNode = mOut->nextBlock<android::ResXMLTree_node>(); + android::ResXMLTree_namespaceExt* flatNs = + mOut->nextBlock<android::ResXMLTree_namespaceExt>(); + mOut->align4(); + + flatNode->header = { type, sizeof(*flatNode), (uint32_t)(mOut->size() - startIndex) }; + flatNode->lineNumber = node->lineNumber; + flatNode->comment.index = -1; + addString(node->namespacePrefix, kLowPriority, &flatNs->prefix); + addString(node->namespaceUri, kLowPriority, &flatNs->uri); + } + + virtual void visit(Namespace* node) override { + // Extract the package/prefix from this namespace node. + Maybe<std::u16string> package = util::extractPackageFromNamespace(node->namespaceUri); + if (package) { + mPackageAliases.emplace_back( + node->namespacePrefix, + package.value().empty() ? mDefaultPackage : package.value()); + } + + writeNamespace(node, android::RES_XML_START_NAMESPACE_TYPE); + for (const auto& child : node->children) { + child->accept(this); + } + writeNamespace(node, android::RES_XML_END_NAMESPACE_TYPE); + + if (package) { + mPackageAliases.pop_back(); + } + } + + virtual void visit(Text* node) override { + if (util::trimWhitespace(node->text).empty()) { + return; + } + + const size_t startIndex = mOut->size(); + android::ResXMLTree_node* flatNode = mOut->nextBlock<android::ResXMLTree_node>(); + android::ResXMLTree_cdataExt* flatText = mOut->nextBlock<android::ResXMLTree_cdataExt>(); + mOut->align4(); + + const uint16_t type = android::RES_XML_CDATA_TYPE; + flatNode->header = { type, sizeof(*flatNode), (uint32_t)(mOut->size() - startIndex) }; + flatNode->lineNumber = node->lineNumber; + flatNode->comment.index = -1; + addString(node->text, kLowPriority, &flatText->data); + } + + virtual void visit(Element* node) override { + const size_t startIndex = mOut->size(); + android::ResXMLTree_node* flatNode = mOut->nextBlock<android::ResXMLTree_node>(); + android::ResXMLTree_attrExt* flatElem = mOut->nextBlock<android::ResXMLTree_attrExt>(); + + const uint16_t type = android::RES_XML_START_ELEMENT_TYPE; + flatNode->header = { type, sizeof(*flatNode), 0 }; + flatNode->lineNumber = node->lineNumber; + flatNode->comment.index = -1; + + addString(node->namespaceUri, kLowPriority, &flatElem->ns); + addString(node->name, kLowPriority, &flatElem->name); + flatElem->attributeStart = sizeof(*flatElem); + flatElem->attributeSize = sizeof(android::ResXMLTree_attribute); + flatElem->attributeCount = node->attributes.size(); + + if (!writeAttributes(mOut, node, flatElem)) { + mError = true; + } + + mOut->align4(); + flatNode->header.size = (uint32_t)(mOut->size() - startIndex); + + for (const auto& child : node->children) { + child->accept(this); + } + + const size_t startEndIndex = mOut->size(); + android::ResXMLTree_node* flatEndNode = mOut->nextBlock<android::ResXMLTree_node>(); + android::ResXMLTree_endElementExt* flatEndElem = + mOut->nextBlock<android::ResXMLTree_endElementExt>(); + mOut->align4(); + + const uint16_t endType = android::RES_XML_END_ELEMENT_TYPE; + flatEndNode->header = { endType, sizeof(*flatEndNode), + (uint32_t)(mOut->size() - startEndIndex) }; + flatEndNode->lineNumber = node->lineNumber; + flatEndNode->comment.index = -1; + + addString(node->namespaceUri, kLowPriority, &flatEndElem->ns); + addString(node->name, kLowPriority, &flatEndElem->name); + } + + bool success() const { + return !mError; + } + +protected: + void addString(const StringPiece16& str, uint32_t priority, android::ResStringPool_ref* dest) { + if (!str.empty()) { + mStringRefs->emplace_back(mPool->makeRef(str, StringPool::Context{ priority }), dest); + } else { + // The device doesn't think a string of size 0 is the same as null. + dest->index = -1; + } + } + + void addString(const StringPool::Ref& ref, android::ResStringPool_ref* dest) { + mStringRefs->emplace_back(ref, dest); + } + + Maybe<std::u16string> getPackageAlias(const std::u16string& prefix) { + const auto endIter = mPackageAliases.rend(); + for (auto iter = mPackageAliases.rbegin(); iter != endIter; ++iter) { + if (iter->first == prefix) { + return iter->second; + } + } + return {}; + } + + const std::u16string& getDefaultPackage() const { + return mDefaultPackage; + } + + /** + * Subclasses override this to deal with attributes. Attributes can be flattened as + * raw values or as resources. + */ + virtual bool writeAttributes(BigBuffer* out, Element* node, + android::ResXMLTree_attrExt* flatElem) = 0; + +private: + BigBuffer* mOut; + StringPool* mPool; + FlatStringRefList* mStringRefs; + std::u16string mDefaultPackage; + bool mError = false; + std::vector<std::pair<std::u16string, std::u16string>> mPackageAliases; +}; + +/** + * Flattens XML, encoding the attributes as raw strings. This is used in the compile phase. + */ +struct CompileXmlFlattener : public XmlFlattener { + CompileXmlFlattener(BigBuffer* outBuffer, StringPool* pool, FlatStringRefList* stringRefs, + const std::u16string& defaultPackage) : + XmlFlattener(outBuffer, pool, stringRefs, defaultPackage) { + } + + virtual bool writeAttributes(BigBuffer* out, Element* node, + android::ResXMLTree_attrExt* flatElem) override { + flatElem->attributeCount = node->attributes.size(); + if (node->attributes.empty()) { + return true; + } + + android::ResXMLTree_attribute* flatAttrs = out->nextBlock<android::ResXMLTree_attribute>( + node->attributes.size()); + for (const Attribute& attr : node->attributes) { + addString(attr.namespaceUri, kLowPriority, &flatAttrs->ns); + addString(attr.name, kLowPriority, &flatAttrs->name); + addString(attr.value, kLowPriority, &flatAttrs->rawValue); + flatAttrs++; + } + return true; + } +}; + +struct AttributeToFlatten { + uint32_t resourceId = 0; + const Attribute* xmlAttr = nullptr; + const ::aapt::Attribute* resourceAttr = nullptr; +}; + +static bool lessAttributeId(const AttributeToFlatten& a, uint32_t id) { + return a.resourceId < id; +} + +/** + * Flattens XML, encoding the attributes as resources. + */ +struct LinkedXmlFlattener : public XmlFlattener { + LinkedXmlFlattener(BigBuffer* outBuffer, StringPool* pool, + std::map<std::u16string, StringPool>* packagePools, + FlatStringRefList* stringRefs, + const std::u16string& defaultPackage, + const std::shared_ptr<IResolver>& resolver, + SourceLogger* logger, + const FlattenOptions& options) : + XmlFlattener(outBuffer, pool, stringRefs, defaultPackage), mResolver(resolver), + mLogger(logger), mPackagePools(packagePools), mOptions(options) { + } + + virtual bool writeAttributes(BigBuffer* out, Element* node, + android::ResXMLTree_attrExt* flatElem) override { + bool error = false; + std::vector<AttributeToFlatten> sortedAttributes; + uint32_t nextAttributeId = 0x80000000u; + + // Sort and filter attributes by their resource ID. + for (const Attribute& attr : node->attributes) { + AttributeToFlatten attrToFlatten; + attrToFlatten.xmlAttr = &attr; + + Maybe<std::u16string> package = util::extractPackageFromNamespace(attr.namespaceUri); + if (package) { + // Find the Attribute object via our Resolver. + ResourceName attrName = { package.value(), ResourceType::kAttr, attr.name }; + if (attrName.package.empty()) { + attrName.package = getDefaultPackage(); + } + + Maybe<IResolver::Entry> result = mResolver->findAttribute(attrName); + if (!result || !result.value().id.isValid() || !result.value().attr) { + error = true; + mLogger->error(node->lineNumber) + << "unresolved attribute '" << attrName << "'." + << std::endl; + } else { + attrToFlatten.resourceId = result.value().id.id; + attrToFlatten.resourceAttr = result.value().attr; + + size_t sdk = findAttributeSdkLevel(attrToFlatten.resourceId); + if (mOptions.maxSdkAttribute && sdk > mOptions.maxSdkAttribute.value()) { + // We need to filter this attribute out. + mSmallestFilteredSdk = std::min(mSmallestFilteredSdk, sdk); + continue; + } + } + } + + if (attrToFlatten.resourceId == 0) { + // Attributes that have no resource ID (because they don't belong to a + // package) should appear after those that do have resource IDs. Assign + // them some integer value that will appear after. + attrToFlatten.resourceId = nextAttributeId++; + } + + // Insert the attribute into the sorted vector. + auto iter = std::lower_bound(sortedAttributes.begin(), sortedAttributes.end(), + attrToFlatten.resourceId, lessAttributeId); + sortedAttributes.insert(iter, std::move(attrToFlatten)); + } + + flatElem->attributeCount = sortedAttributes.size(); + if (sortedAttributes.empty()) { + return true; + } + + android::ResXMLTree_attribute* flatAttr = out->nextBlock<android::ResXMLTree_attribute>( + sortedAttributes.size()); + + // Now that we have sorted the attributes into their final encoded order, it's time + // to actually write them out. + uint16_t attributeIndex = 1; + for (const AttributeToFlatten& attrToFlatten : sortedAttributes) { + Maybe<std::u16string> package = util::extractPackageFromNamespace( + attrToFlatten.xmlAttr->namespaceUri); + + // Assign the indices for specific attributes. + if (package && package.value() == u"android" && attrToFlatten.xmlAttr->name == u"id") { + flatElem->idIndex = attributeIndex; + } else if (attrToFlatten.xmlAttr->namespaceUri.empty()) { + if (attrToFlatten.xmlAttr->name == u"class") { + flatElem->classIndex = attributeIndex; + } else if (attrToFlatten.xmlAttr->name == u"style") { + flatElem->styleIndex = attributeIndex; + } + } + attributeIndex++; + + // Add the namespaceUri and name to the list of StringRefs to encode. + addString(attrToFlatten.xmlAttr->namespaceUri, kLowPriority, &flatAttr->ns); + flatAttr->rawValue.index = -1; + + if (!attrToFlatten.resourceAttr) { + addString(attrToFlatten.xmlAttr->name, kLowPriority, &flatAttr->name); + } else { + // We've already extracted the package successfully before. + assert(package); + + // Attribute names are stored without packages, but we use + // their StringPool index to lookup their resource IDs. + // This will cause collisions, so we can't dedupe + // attribute names from different packages. We use separate + // pools that we later combine. + // + // Lookup the StringPool for this package and make the reference there. + StringPool::Ref nameRef = (*mPackagePools)[package.value()].makeRef( + attrToFlatten.xmlAttr->name, + StringPool::Context{ attrToFlatten.resourceId }); + + // Add it to the list of strings to flatten. + addString(nameRef, &flatAttr->name); + + if (mOptions.keepRawValues) { + // Keep raw values (this is for static libraries). + // TODO(with a smarter inflater for binary XML, we can do without this). + addString(attrToFlatten.xmlAttr->value, kLowPriority, &flatAttr->rawValue); + } + } + + error |= !flattenItem(node, attrToFlatten.xmlAttr->value, attrToFlatten.resourceAttr, + flatAttr); + flatAttr->typedValue.size = sizeof(flatAttr->typedValue); + flatAttr++; + } + return !error; + } + + Maybe<size_t> getSmallestFilteredSdk() const { + if (mSmallestFilteredSdk == std::numeric_limits<size_t>::max()) { + return {}; + } + return mSmallestFilteredSdk; + } + +private: + bool flattenItem(const Node* el, const std::u16string& value, const ::aapt::Attribute* attr, + android::ResXMLTree_attribute* flatAttr) { + std::unique_ptr<Item> item; + if (!attr) { + bool create = false; + item = ResourceParser::tryParseReference(value, &create); + if (!item) { + flatAttr->typedValue.dataType = android::Res_value::TYPE_STRING; + addString(value, kLowPriority, &flatAttr->rawValue); + addString(value, kLowPriority, reinterpret_cast<android::ResStringPool_ref*>( + &flatAttr->typedValue.data)); + return true; + } + } else { + item = ResourceParser::parseItemForAttribute(value, *attr); + if (!item) { + if (!(attr->typeMask & android::ResTable_map::TYPE_STRING)) { + mLogger->error(el->lineNumber) + << "'" + << value + << "' is not compatible with attribute '" + << *attr + << "'." + << std::endl; + return false; + } + + flatAttr->typedValue.dataType = android::Res_value::TYPE_STRING; + addString(value, kLowPriority, &flatAttr->rawValue); + addString(value, kLowPriority, reinterpret_cast<android::ResStringPool_ref*>( + &flatAttr->typedValue.data)); + return true; + } + } + + assert(item); + + bool error = false; + + // If this is a reference, resolve the name into an ID. + visitFunc<Reference>(*item, [&](Reference& reference) { + // First see if we can convert the package name from a prefix to a real + // package name. + ResourceName realName = reference.name; + if (!realName.package.empty()) { + Maybe<std::u16string> package = getPackageAlias(realName.package); + if (package) { + realName.package = package.value(); + } + } else { + realName.package = getDefaultPackage(); + } + + Maybe<ResourceId> result = mResolver->findId(realName); + if (!result || !result.value().isValid()) { + std::ostream& out = mLogger->error(el->lineNumber) + << "unresolved reference '" + << reference.name + << "'"; + if (realName != reference.name) { + out << " (aka '" << realName << "')"; + } + out << "'." << std::endl; + error = true; + } else { + reference.id = result.value(); + } + }); + + if (error) { + return false; + } + + item->flatten(flatAttr->typedValue); + return true; + } + + std::shared_ptr<IResolver> mResolver; + SourceLogger* mLogger; + std::map<std::u16string, StringPool>* mPackagePools; + FlattenOptions mOptions; + size_t mSmallestFilteredSdk = std::numeric_limits<size_t>::max(); +}; + +/** + * The binary XML file expects the StringPool to appear first, but we haven't collected the + * strings yet. We write to a temporary BigBuffer while parsing the input, adding strings + * we encounter to the StringPool. At the end, we write the StringPool to the given BigBuffer and + * then move the data from the temporary BigBuffer into the given one. This incurs no + * copies as the given BigBuffer simply takes ownership of the data. + */ +static void flattenXml(StringPool* pool, FlatStringRefList* stringRefs, BigBuffer* outBuffer, + BigBuffer&& xmlTreeBuffer) { + // Sort the string pool so that attribute resource IDs show up first. + pool->sort([](const StringPool::Entry& a, const StringPool::Entry& b) -> bool { + return a.context.priority < b.context.priority; + }); + + // Now we flatten the string pool references into the correct places. + for (const auto& refEntry : *stringRefs) { + refEntry.second->index = refEntry.first.getIndex(); + } + + // Write the XML header. + const size_t beforeXmlTreeIndex = outBuffer->size(); + android::ResXMLTree_header* header = outBuffer->nextBlock<android::ResXMLTree_header>(); + header->header.type = android::RES_XML_TYPE; + header->header.headerSize = sizeof(*header); + + // Flatten the StringPool. + StringPool::flattenUtf16(outBuffer, *pool); + + // Write the array of resource IDs, indexed by StringPool order. + const size_t beforeResIdMapIndex = outBuffer->size(); + android::ResChunk_header* resIdMapChunk = outBuffer->nextBlock<android::ResChunk_header>(); + resIdMapChunk->type = android::RES_XML_RESOURCE_MAP_TYPE; + resIdMapChunk->headerSize = sizeof(*resIdMapChunk); + for (const auto& str : *pool) { + ResourceId id { str->context.priority }; + if (id.id == kLowPriority || !id.isValid()) { + // When we see the first non-resource ID, + // we're done. + break; + } + + *outBuffer->nextBlock<uint32_t>() = id.id; + } + resIdMapChunk->size = outBuffer->size() - beforeResIdMapIndex; + + // Move the temporary BigBuffer into outBuffer. + outBuffer->appendBuffer(std::move(xmlTreeBuffer)); + header->header.size = outBuffer->size() - beforeXmlTreeIndex; +} + +bool flatten(Node* root, const std::u16string& defaultPackage, BigBuffer* outBuffer) { + StringPool pool; + + // This will hold the StringRefs and the location in which to write the index. + // Once we sort the StringPool, we can assign the updated indices + // to the correct data locations. + FlatStringRefList stringRefs; + + // Since we don't know the size of the final StringPool, we write to this + // temporary BigBuffer, which we will append to outBuffer later. + BigBuffer out(1024); + + CompileXmlFlattener flattener(&out, &pool, &stringRefs, defaultPackage); + root->accept(&flattener); + + if (!flattener.success()) { + return false; + } + + flattenXml(&pool, &stringRefs, outBuffer, std::move(out)); + return true; +}; + +Maybe<size_t> flattenAndLink(const Source& source, Node* root, + const std::u16string& defaultPackage, + const std::shared_ptr<IResolver>& resolver, + const FlattenOptions& options, BigBuffer* outBuffer) { + SourceLogger logger(source); + StringPool pool; + + // Attribute names are stored without packages, but we use + // their StringPool index to lookup their resource IDs. + // This will cause collisions, so we can't dedupe + // attribute names from different packages. We use separate + // pools that we later combine. + std::map<std::u16string, StringPool> packagePools; + + FlatStringRefList stringRefs; + + // Since we don't know the size of the final StringPool, we write to this + // temporary BigBuffer, which we will append to outBuffer later. + BigBuffer out(1024); + + LinkedXmlFlattener flattener(&out, &pool, &packagePools, &stringRefs, defaultPackage, resolver, + &logger, options); + root->accept(&flattener); + + if (!flattener.success()) { + return {}; + } + + // Merge the package pools into the main pool. + for (auto& packagePoolEntry : packagePools) { + pool.merge(std::move(packagePoolEntry.second)); + } + + flattenXml(&pool, &stringRefs, outBuffer, std::move(out)); + + if (flattener.getSmallestFilteredSdk()) { + return flattener.getSmallestFilteredSdk(); + } + return 0; +} + +} // namespace xml +} // namespace aapt diff --git a/tools/aapt2/XmlFlattener.h b/tools/aapt2/XmlFlattener.h new file mode 100644 index 0000000..4ece0a3 --- /dev/null +++ b/tools/aapt2/XmlFlattener.h @@ -0,0 +1,69 @@ +/* + * 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_XML_FLATTENER_H +#define AAPT_XML_FLATTENER_H + +#include "BigBuffer.h" +#include "Maybe.h" +#include "Resolver.h" +#include "Source.h" +#include "XmlDom.h" + +#include <string> + +namespace aapt { +namespace xml { + +/** + * Flattens an XML file into a binary representation parseable by + * the Android resource system. + */ +bool flatten(Node* root, const std::u16string& defaultPackage, BigBuffer* outBuffer); + +/** + * Options for flattenAndLink. + */ +struct FlattenOptions { + /** + * Keep attribute raw string values along with typed values. + */ + bool keepRawValues = false; + + /** + * If set, any attribute introduced in a later SDK will not be encoded. + */ + Maybe<size_t> maxSdkAttribute; +}; + +/** + * Like flatten(Node*,BigBuffer*), but references to resources are checked + * and string values are transformed to typed data where possible. + * + * `defaultPackage` is used when a reference has no package or the namespace URI + * "http://schemas.android.com/apk/res-auto" is used. + * + * `resolver` is used to resolve references to resources. + */ +Maybe<size_t> flattenAndLink(const Source& source, Node* root, + const std::u16string& defaultPackage, + const std::shared_ptr<IResolver>& resolver, + const FlattenOptions& options, BigBuffer* outBuffer); + +} // namespace xml +} // namespace aapt + +#endif // AAPT_XML_FLATTENER_H diff --git a/tools/aapt2/XmlFlattener_test.cpp b/tools/aapt2/XmlFlattener_test.cpp new file mode 100644 index 0000000..8915d24 --- /dev/null +++ b/tools/aapt2/XmlFlattener_test.cpp @@ -0,0 +1,232 @@ +/* + * 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 "MockResolver.h" +#include "ResourceTable.h" +#include "ResourceValues.h" +#include "Util.h" +#include "XmlFlattener.h" + +#include <androidfw/AssetManager.h> +#include <androidfw/ResourceTypes.h> +#include <gtest/gtest.h> +#include <sstream> +#include <string> + +using namespace android; + +namespace aapt { +namespace xml { + +constexpr const char* kXmlPreamble = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"; + +class XmlFlattenerTest : public ::testing::Test { +public: + virtual void SetUp() override { + mResolver = std::make_shared<MockResolver>( + std::make_shared<ResourceTable>(), + std::map<ResourceName, ResourceId>({ + { ResourceName{ u"android", ResourceType::kAttr, u"attr" }, + ResourceId{ 0x01010000u } }, + { ResourceName{ u"android", ResourceType::kId, u"id" }, + ResourceId{ 0x01020000u } }, + { ResourceName{ u"com.lib", ResourceType::kAttr, u"attr" }, + ResourceId{ 0x01010001u } }, + { ResourceName{ u"com.lib", ResourceType::kId, u"id" }, + ResourceId{ 0x01020001u } }})); + } + + ::testing::AssertionResult testFlatten(const std::string& in, ResXMLTree* outTree) { + std::stringstream input(kXmlPreamble); + input << in << std::endl; + + SourceLogger logger(Source{ "test.xml" }); + std::unique_ptr<Node> root = inflate(&input, &logger); + if (!root) { + return ::testing::AssertionFailure(); + } + + BigBuffer outBuffer(1024); + if (!flattenAndLink(Source{ "test.xml" }, root.get(), std::u16string(u"android"), + mResolver, {}, &outBuffer)) { + return ::testing::AssertionFailure(); + } + + std::unique_ptr<uint8_t[]> data = util::copy(outBuffer); + if (outTree->setTo(data.get(), outBuffer.size(), true) != NO_ERROR) { + return ::testing::AssertionFailure(); + } + return ::testing::AssertionSuccess(); + } + + std::shared_ptr<IResolver> mResolver; +}; + +TEST_F(XmlFlattenerTest, ParseSimpleView) { + std::string input = R"EOF( + <View xmlns:android="http://schemas.android.com/apk/res/android" + android:attr="@id/id" + class="str" + style="@id/id"> + </View> + )EOF"; + ResXMLTree tree; + ASSERT_TRUE(testFlatten(input, &tree)); + + while (tree.next() != ResXMLTree::START_TAG) { + ASSERT_NE(tree.getEventType(), ResXMLTree::END_DOCUMENT); + ASSERT_NE(tree.getEventType(), ResXMLTree::BAD_DOCUMENT); + } + + const StringPiece16 androidNs = u"http://schemas.android.com/apk/res/android"; + const StringPiece16 attrName = u"attr"; + ssize_t idx = tree.indexOfAttribute(androidNs.data(), androidNs.size(), attrName.data(), + attrName.size()); + ASSERT_GE(idx, 0); + EXPECT_EQ(tree.getAttributeNameResID(idx), 0x01010000u); + EXPECT_EQ(tree.getAttributeDataType(idx), android::Res_value::TYPE_REFERENCE); + + const StringPiece16 class16 = u"class"; + idx = tree.indexOfAttribute(nullptr, 0, class16.data(), class16.size()); + ASSERT_GE(idx, 0); + EXPECT_EQ(tree.getAttributeNameResID(idx), 0u); + EXPECT_EQ(tree.getAttributeDataType(idx), android::Res_value::TYPE_STRING); + EXPECT_EQ(tree.getAttributeData(idx), tree.getAttributeValueStringID(idx)); + + const StringPiece16 style16 = u"style"; + idx = tree.indexOfAttribute(nullptr, 0, style16.data(), style16.size()); + ASSERT_GE(idx, 0); + EXPECT_EQ(tree.getAttributeNameResID(idx), 0u); + EXPECT_EQ(tree.getAttributeDataType(idx), android::Res_value::TYPE_REFERENCE); + EXPECT_EQ((uint32_t) tree.getAttributeData(idx), 0x01020000u); + EXPECT_EQ(tree.getAttributeValueStringID(idx), -1); + + while (tree.next() != ResXMLTree::END_DOCUMENT) { + ASSERT_NE(tree.getEventType(), ResXMLTree::BAD_DOCUMENT); + } +} + +TEST_F(XmlFlattenerTest, ParseViewWithPackageAlias) { + std::string input = "<View xmlns:ns1=\"http://schemas.android.com/apk/res/android\"\n" + " xmlns:ns2=\"http://schemas.android.com/apk/res/android\"\n" + " ns1:attr=\"@ns2:id/id\">\n" + "</View>"; + ResXMLTree tree; + ASSERT_TRUE(testFlatten(input, &tree)); + + while (tree.next() != ResXMLTree::END_DOCUMENT) { + ASSERT_NE(tree.getEventType(), ResXMLTree::BAD_DOCUMENT); + } +} + +::testing::AssertionResult attributeNameAndValueEquals(ResXMLTree* tree, size_t index, + ResourceId nameId, ResourceId valueId) { + if (index >= tree->getAttributeCount()) { + return ::testing::AssertionFailure() << "index " << index << " is out of bounds (" + << tree->getAttributeCount() << ")"; + } + + if (tree->getAttributeNameResID(index) != nameId.id) { + return ::testing::AssertionFailure() + << "attribute at index " << index << " has ID " + << ResourceId{ (uint32_t) tree->getAttributeNameResID(index) } + << ". Expected ID " << nameId; + } + + if (tree->getAttributeDataType(index) != Res_value::TYPE_REFERENCE) { + return ::testing::AssertionFailure() << "attribute at index " << index << " has value of " + << "type " << std::hex + << tree->getAttributeDataType(index) << std::dec + << ". Expected reference (" << std::hex + << Res_value::TYPE_REFERENCE << std::dec << ")"; + } + + if ((uint32_t) tree->getAttributeData(index) != valueId.id) { + return ::testing::AssertionFailure() + << "attribute at index " << index << " has value " << "with ID " + << ResourceId{ (uint32_t) tree->getAttributeData(index) } + << ". Expected ID " << valueId; + } + return ::testing::AssertionSuccess(); +} + +TEST_F(XmlFlattenerTest, ParseViewWithShadowedPackageAlias) { + std::string input = "<View xmlns:app=\"http://schemas.android.com/apk/res/android\"\n" + " app:attr=\"@app:id/id\">\n" + " <View xmlns:app=\"http://schemas.android.com/apk/res/com.lib\"\n" + " app:attr=\"@app:id/id\"/>\n" + "</View>"; + ResXMLTree tree; + ASSERT_TRUE(testFlatten(input, &tree)); + + while (tree.next() != ResXMLTree::START_TAG) { + ASSERT_NE(tree.getEventType(), ResXMLTree::BAD_DOCUMENT); + ASSERT_NE(tree.getEventType(), ResXMLTree::END_DOCUMENT); + } + + ASSERT_TRUE(attributeNameAndValueEquals(&tree, 0u, ResourceId{ 0x01010000u }, + ResourceId{ 0x01020000u })); + + while (tree.next() != ResXMLTree::START_TAG) { + ASSERT_NE(tree.getEventType(), ResXMLTree::BAD_DOCUMENT); + ASSERT_NE(tree.getEventType(), ResXMLTree::END_DOCUMENT); + } + + ASSERT_TRUE(attributeNameAndValueEquals(&tree, 0u, ResourceId{ 0x01010001u }, + ResourceId{ 0x01020001u })); +} + +TEST_F(XmlFlattenerTest, ParseViewWithLocalPackageAndAliasOfTheSameName) { + std::string input = "<View xmlns:android=\"http://schemas.android.com/apk/res/com.lib\"\n" + " android:attr=\"@id/id\"/>"; + ResXMLTree tree; + ASSERT_TRUE(testFlatten(input, &tree)); + + while (tree.next() != ResXMLTree::START_TAG) { + ASSERT_NE(tree.getEventType(), ResXMLTree::BAD_DOCUMENT); + ASSERT_NE(tree.getEventType(), ResXMLTree::END_DOCUMENT); + } + + // We expect the 'android:attr' to be converted to 'com.lib:attr' due to the namespace + // assignment. + // However, we didn't give '@id/id' a package, so it should use the default package + // 'android', and not be converted from 'android' to 'com.lib'. + ASSERT_TRUE(attributeNameAndValueEquals(&tree, 0u, ResourceId{ 0x01010001u }, + ResourceId{ 0x01020000u })); +} + +/* + * The device ResXMLParser in libandroidfw differentiates between empty namespace and null + * namespace. + */ +TEST_F(XmlFlattenerTest, NoNamespaceIsNotTheSameAsEmptyNamespace) { + std::string input = "<View xmlns:android=\"http://schemas.android.com/apk/res/android\"\n" + " package=\"android\"/>"; + + ResXMLTree tree; + ASSERT_TRUE(testFlatten(input, &tree)); + + while (tree.next() != ResXMLTree::START_TAG) { + ASSERT_NE(tree.getEventType(), ResXMLTree::BAD_DOCUMENT); + ASSERT_NE(tree.getEventType(), ResXMLTree::END_DOCUMENT); + } + + const StringPiece16 kPackage = u"package"; + EXPECT_GE(tree.indexOfAttribute(nullptr, 0, kPackage.data(), kPackage.size()), 0); +} + +} // namespace xml +} // namespace aapt diff --git a/tools/aapt2/XmlPullParser.h b/tools/aapt2/XmlPullParser.h new file mode 100644 index 0000000..accfd30 --- /dev/null +++ b/tools/aapt2/XmlPullParser.h @@ -0,0 +1,214 @@ +/* + * 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_XML_PULL_PARSER_H +#define AAPT_XML_PULL_PARSER_H + +#include <algorithm> +#include <ostream> +#include <string> +#include <vector> + +#include "StringPiece.h" + +namespace aapt { + +class XmlPullParser { +public: + enum class Event { + kBadDocument, + kStartDocument, + kEndDocument, + + kStartNamespace, + kEndNamespace, + kStartElement, + kEndElement, + kText, + kComment, + }; + + static void skipCurrentElement(XmlPullParser* parser); + static bool isGoodEvent(Event event); + + virtual ~XmlPullParser() {} + + /** + * Returns the current event that is being processed. + */ + virtual Event getEvent() const = 0; + + virtual const std::string& getLastError() const = 0; + + /** + * Note, unlike XmlPullParser, the first call to next() will return + * StartElement of the first element. + */ + virtual Event next() = 0; + + // + // These are available for all nodes. + // + + virtual const std::u16string& getComment() const = 0; + virtual size_t getLineNumber() const = 0; + virtual size_t getDepth() const = 0; + + /** + * Returns the character data for a Text event. + */ + virtual const std::u16string& getText() const = 0; + + // + // Namespace prefix and URI are available for StartNamespace and EndNamespace. + // + + virtual const std::u16string& getNamespacePrefix() const = 0; + virtual const std::u16string& getNamespaceUri() const = 0; + + /* + * Uses the current stack of namespaces to resolve the package. Eg: + * xmlns:app = "http://schemas.android.com/apk/res/com.android.app" + * ... + * android:text="@app:string/message" + * + * In this case, 'app' will be converted to 'com.android.app'. + * + * If xmlns:app="http://schemas.android.com/apk/res-auto", then + * 'package' will be set to 'defaultPackage'. + */ + virtual bool applyPackageAlias(std::u16string* package, + const std::u16string& defaultPackage) const = 0; + + // + // These are available for StartElement and EndElement. + // + + virtual const std::u16string& getElementNamespace() const = 0; + virtual const std::u16string& getElementName() const = 0; + + // + // Remaining methods are for retrieving information about attributes + // associated with a StartElement. + // + // Attributes must be in sorted order (according to the less than operator + // of struct Attribute). + // + + struct Attribute { + std::u16string namespaceUri; + std::u16string name; + std::u16string value; + + int compare(const Attribute& rhs) const; + bool operator<(const Attribute& rhs) const; + bool operator==(const Attribute& rhs) const; + bool operator!=(const Attribute& rhs) const; + }; + + using const_iterator = std::vector<Attribute>::const_iterator; + + virtual const_iterator beginAttributes() const = 0; + virtual const_iterator endAttributes() const = 0; + virtual size_t getAttributeCount() const = 0; + const_iterator findAttribute(StringPiece16 namespaceUri, StringPiece16 name) const; +}; + +// +// Implementation +// + +inline ::std::ostream& operator<<(::std::ostream& out, XmlPullParser::Event event) { + switch (event) { + case XmlPullParser::Event::kBadDocument: return out << "BadDocument"; + case XmlPullParser::Event::kStartDocument: return out << "StartDocument"; + case XmlPullParser::Event::kEndDocument: return out << "EndDocument"; + case XmlPullParser::Event::kStartNamespace: return out << "StartNamespace"; + case XmlPullParser::Event::kEndNamespace: return out << "EndNamespace"; + case XmlPullParser::Event::kStartElement: return out << "StartElement"; + case XmlPullParser::Event::kEndElement: return out << "EndElement"; + case XmlPullParser::Event::kText: return out << "Text"; + case XmlPullParser::Event::kComment: return out << "Comment"; + } + return out; +} + +inline void XmlPullParser::skipCurrentElement(XmlPullParser* parser) { + int depth = 1; + while (depth > 0) { + switch (parser->next()) { + case Event::kEndDocument: + case Event::kBadDocument: + return; + case Event::kStartElement: + depth++; + break; + case Event::kEndElement: + depth--; + break; + default: + break; + } + } +} + +inline bool XmlPullParser::isGoodEvent(XmlPullParser::Event event) { + return event != Event::kBadDocument && event != Event::kEndDocument; +} + +inline int XmlPullParser::Attribute::compare(const Attribute& rhs) const { + int cmp = namespaceUri.compare(rhs.namespaceUri); + if (cmp != 0) return cmp; + return name.compare(rhs.name); +} + +inline bool XmlPullParser::Attribute::operator<(const Attribute& rhs) const { + return compare(rhs) < 0; +} + +inline bool XmlPullParser::Attribute::operator==(const Attribute& rhs) const { + return compare(rhs) == 0; +} + +inline bool XmlPullParser::Attribute::operator!=(const Attribute& rhs) const { + return compare(rhs) != 0; +} + +inline XmlPullParser::const_iterator XmlPullParser::findAttribute(StringPiece16 namespaceUri, + StringPiece16 name) const { + const auto endIter = endAttributes(); + const auto iter = std::lower_bound(beginAttributes(), endIter, + std::pair<StringPiece16, StringPiece16>(namespaceUri, name), + [](const Attribute& attr, const std::pair<StringPiece16, StringPiece16>& rhs) -> bool { + int cmp = attr.namespaceUri.compare(0, attr.namespaceUri.size(), + rhs.first.data(), rhs.first.size()); + if (cmp < 0) return true; + if (cmp > 0) return false; + cmp = attr.name.compare(0, attr.name.size(), rhs.second.data(), rhs.second.size()); + if (cmp < 0) return true; + return false; + } + ); + + if (iter != endIter && namespaceUri == iter->namespaceUri && name == iter->name) { + return iter; + } + return endIter; +} + +} // namespace aapt + +#endif // AAPT_XML_PULL_PARSER_H diff --git a/tools/aapt2/ZipEntry.cpp b/tools/aapt2/ZipEntry.cpp new file mode 100644 index 0000000..891b4e1 --- /dev/null +++ b/tools/aapt2/ZipEntry.cpp @@ -0,0 +1,745 @@ +/* + * Copyright (C) 2006 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. + */ + +// +// Access to entries in a Zip archive. +// + +#define LOG_TAG "zip" + +#include "ZipEntry.h" +#include <utils/Log.h> + +#include <stdio.h> +#include <string.h> +#include <assert.h> + +namespace aapt { + +using namespace android; + +/* + * Initialize a new ZipEntry structure from a FILE* positioned at a + * CentralDirectoryEntry. + * + * On exit, the file pointer will be at the start of the next CDE or + * at the EOCD. + */ +status_t ZipEntry::initFromCDE(FILE* fp) +{ + status_t result; + long posn; + bool hasDD; + + //ALOGV("initFromCDE ---\n"); + + /* read the CDE */ + result = mCDE.read(fp); + if (result != NO_ERROR) { + ALOGD("mCDE.read failed\n"); + return result; + } + + //mCDE.dump(); + + /* using the info in the CDE, go load up the LFH */ + posn = ftell(fp); + if (fseek(fp, mCDE.mLocalHeaderRelOffset, SEEK_SET) != 0) { + ALOGD("local header seek failed (%ld)\n", + mCDE.mLocalHeaderRelOffset); + return UNKNOWN_ERROR; + } + + result = mLFH.read(fp); + if (result != NO_ERROR) { + ALOGD("mLFH.read failed\n"); + return result; + } + + if (fseek(fp, posn, SEEK_SET) != 0) + return UNKNOWN_ERROR; + + //mLFH.dump(); + + /* + * We *might* need to read the Data Descriptor at this point and + * integrate it into the LFH. If this bit is set, the CRC-32, + * compressed size, and uncompressed size will be zero. In practice + * these seem to be rare. + */ + hasDD = (mLFH.mGPBitFlag & kUsesDataDescr) != 0; + if (hasDD) { + // do something clever + //ALOGD("+++ has data descriptor\n"); + } + + /* + * Sanity-check the LFH. Note that this will fail if the "kUsesDataDescr" + * flag is set, because the LFH is incomplete. (Not a problem, since we + * prefer the CDE values.) + */ + if (!hasDD && !compareHeaders()) { + ALOGW("warning: header mismatch\n"); + // keep going? + } + + /* + * If the mVersionToExtract is greater than 20, we may have an + * issue unpacking the record -- could be encrypted, compressed + * with something we don't support, or use Zip64 extensions. We + * can defer worrying about that to when we're extracting data. + */ + + return NO_ERROR; +} + +/* + * Initialize a new entry. Pass in the file name and an optional comment. + * + * Initializes the CDE and the LFH. + */ +void ZipEntry::initNew(const char* fileName, const char* comment) +{ + assert(fileName != NULL && *fileName != '\0'); // name required + + /* most fields are properly initialized by constructor */ + mCDE.mVersionMadeBy = kDefaultMadeBy; + mCDE.mVersionToExtract = kDefaultVersion; + mCDE.mCompressionMethod = kCompressStored; + mCDE.mFileNameLength = strlen(fileName); + if (comment != NULL) + mCDE.mFileCommentLength = strlen(comment); + mCDE.mExternalAttrs = 0x81b60020; // matches what WinZip does + + if (mCDE.mFileNameLength > 0) { + mCDE.mFileName = new unsigned char[mCDE.mFileNameLength+1]; + strcpy((char*) mCDE.mFileName, fileName); + } + if (mCDE.mFileCommentLength > 0) { + /* TODO: stop assuming null-terminated ASCII here? */ + mCDE.mFileComment = new unsigned char[mCDE.mFileCommentLength+1]; + strcpy((char*) mCDE.mFileComment, comment); + } + + copyCDEtoLFH(); +} + +/* + * Initialize a new entry, starting with the ZipEntry from a different + * archive. + * + * Initializes the CDE and the LFH. + */ +status_t ZipEntry::initFromExternal(const ZipFile* /* pZipFile */, + const ZipEntry* pEntry, const char* storageName) +{ + mCDE = pEntry->mCDE; + if (storageName && *storageName != 0) { + mCDE.mFileNameLength = strlen(storageName); + mCDE.mFileName = new unsigned char[mCDE.mFileNameLength + 1]; + strcpy((char*) mCDE.mFileName, storageName); + } + + // Check whether we got all the memory needed. + if ((mCDE.mFileNameLength > 0 && mCDE.mFileName == NULL) || + (mCDE.mFileCommentLength > 0 && mCDE.mFileComment == NULL) || + (mCDE.mExtraFieldLength > 0 && mCDE.mExtraField == NULL)) { + return NO_MEMORY; + } + + /* construct the LFH from the CDE */ + copyCDEtoLFH(); + + /* + * The LFH "extra" field is independent of the CDE "extra", so we + * handle it here. + */ + assert(mLFH.mExtraField == NULL); + mLFH.mExtraFieldLength = pEntry->mLFH.mExtraFieldLength; + if (mLFH.mExtraFieldLength > 0) { + mLFH.mExtraField = new unsigned char[mLFH.mExtraFieldLength+1]; + if (mLFH.mExtraField == NULL) + return NO_MEMORY; + memcpy(mLFH.mExtraField, pEntry->mLFH.mExtraField, + mLFH.mExtraFieldLength+1); + } + + return NO_ERROR; +} + +/* + * Insert pad bytes in the LFH by tweaking the "extra" field. This will + * potentially confuse something that put "extra" data in here earlier, + * but I can't find an actual problem. + */ +status_t ZipEntry::addPadding(int padding) +{ + if (padding <= 0) + return INVALID_OPERATION; + + //ALOGI("HEY: adding %d pad bytes to existing %d in %s\n", + // padding, mLFH.mExtraFieldLength, mCDE.mFileName); + + if (mLFH.mExtraFieldLength > 0) { + /* extend existing field */ + unsigned char* newExtra; + + newExtra = new unsigned char[mLFH.mExtraFieldLength + padding]; + if (newExtra == NULL) + return NO_MEMORY; + memset(newExtra + mLFH.mExtraFieldLength, 0, padding); + memcpy(newExtra, mLFH.mExtraField, mLFH.mExtraFieldLength); + + delete[] mLFH.mExtraField; + mLFH.mExtraField = newExtra; + mLFH.mExtraFieldLength += padding; + } else { + /* create new field */ + mLFH.mExtraField = new unsigned char[padding]; + memset(mLFH.mExtraField, 0, padding); + mLFH.mExtraFieldLength = padding; + } + + return NO_ERROR; +} + +/* + * Set the fields in the LFH equal to the corresponding fields in the CDE. + * + * This does not touch the LFH "extra" field. + */ +void ZipEntry::copyCDEtoLFH(void) +{ + mLFH.mVersionToExtract = mCDE.mVersionToExtract; + mLFH.mGPBitFlag = mCDE.mGPBitFlag; + mLFH.mCompressionMethod = mCDE.mCompressionMethod; + mLFH.mLastModFileTime = mCDE.mLastModFileTime; + mLFH.mLastModFileDate = mCDE.mLastModFileDate; + mLFH.mCRC32 = mCDE.mCRC32; + mLFH.mCompressedSize = mCDE.mCompressedSize; + mLFH.mUncompressedSize = mCDE.mUncompressedSize; + mLFH.mFileNameLength = mCDE.mFileNameLength; + // the "extra field" is independent + + delete[] mLFH.mFileName; + if (mLFH.mFileNameLength > 0) { + mLFH.mFileName = new unsigned char[mLFH.mFileNameLength+1]; + strcpy((char*) mLFH.mFileName, (const char*) mCDE.mFileName); + } else { + mLFH.mFileName = NULL; + } +} + +/* + * Set some information about a file after we add it. + */ +void ZipEntry::setDataInfo(long uncompLen, long compLen, unsigned long crc32, + int compressionMethod) +{ + mCDE.mCompressionMethod = compressionMethod; + mCDE.mCRC32 = crc32; + mCDE.mCompressedSize = compLen; + mCDE.mUncompressedSize = uncompLen; + mCDE.mCompressionMethod = compressionMethod; + if (compressionMethod == kCompressDeflated) { + mCDE.mGPBitFlag |= 0x0002; // indicates maximum compression used + } + copyCDEtoLFH(); +} + +/* + * See if the data in mCDE and mLFH match up. This is mostly useful for + * debugging these classes, but it can be used to identify damaged + * archives. + * + * Returns "false" if they differ. + */ +bool ZipEntry::compareHeaders(void) const +{ + if (mCDE.mVersionToExtract != mLFH.mVersionToExtract) { + ALOGV("cmp: VersionToExtract\n"); + return false; + } + if (mCDE.mGPBitFlag != mLFH.mGPBitFlag) { + ALOGV("cmp: GPBitFlag\n"); + return false; + } + if (mCDE.mCompressionMethod != mLFH.mCompressionMethod) { + ALOGV("cmp: CompressionMethod\n"); + return false; + } + if (mCDE.mLastModFileTime != mLFH.mLastModFileTime) { + ALOGV("cmp: LastModFileTime\n"); + return false; + } + if (mCDE.mLastModFileDate != mLFH.mLastModFileDate) { + ALOGV("cmp: LastModFileDate\n"); + return false; + } + if (mCDE.mCRC32 != mLFH.mCRC32) { + ALOGV("cmp: CRC32\n"); + return false; + } + if (mCDE.mCompressedSize != mLFH.mCompressedSize) { + ALOGV("cmp: CompressedSize\n"); + return false; + } + if (mCDE.mUncompressedSize != mLFH.mUncompressedSize) { + ALOGV("cmp: UncompressedSize\n"); + return false; + } + if (mCDE.mFileNameLength != mLFH.mFileNameLength) { + ALOGV("cmp: FileNameLength\n"); + return false; + } +#if 0 // this seems to be used for padding, not real data + if (mCDE.mExtraFieldLength != mLFH.mExtraFieldLength) { + ALOGV("cmp: ExtraFieldLength\n"); + return false; + } +#endif + if (mCDE.mFileName != NULL) { + if (strcmp((char*) mCDE.mFileName, (char*) mLFH.mFileName) != 0) { + ALOGV("cmp: FileName\n"); + return false; + } + } + + return true; +} + + +/* + * Convert the DOS date/time stamp into a UNIX time stamp. + */ +time_t ZipEntry::getModWhen(void) const +{ + struct tm parts; + + parts.tm_sec = (mCDE.mLastModFileTime & 0x001f) << 1; + parts.tm_min = (mCDE.mLastModFileTime & 0x07e0) >> 5; + parts.tm_hour = (mCDE.mLastModFileTime & 0xf800) >> 11; + parts.tm_mday = (mCDE.mLastModFileDate & 0x001f); + parts.tm_mon = ((mCDE.mLastModFileDate & 0x01e0) >> 5) -1; + parts.tm_year = ((mCDE.mLastModFileDate & 0xfe00) >> 9) + 80; + parts.tm_wday = parts.tm_yday = 0; + parts.tm_isdst = -1; // DST info "not available" + + return mktime(&parts); +} + +/* + * Set the CDE/LFH timestamp from UNIX time. + */ +void ZipEntry::setModWhen(time_t when) +{ +#if !defined(_WIN32) + struct tm tmResult; +#endif + time_t even; + unsigned short zdate, ztime; + + struct tm* ptm; + + /* round up to an even number of seconds */ + even = (time_t)(((unsigned long)(when) + 1) & (~1)); + + /* expand */ +#if !defined(_WIN32) + ptm = localtime_r(&even, &tmResult); +#else + ptm = localtime(&even); +#endif + + int year; + year = ptm->tm_year; + if (year < 80) + year = 80; + + zdate = (year - 80) << 9 | (ptm->tm_mon+1) << 5 | ptm->tm_mday; + ztime = ptm->tm_hour << 11 | ptm->tm_min << 5 | ptm->tm_sec >> 1; + + mCDE.mLastModFileTime = mLFH.mLastModFileTime = ztime; + mCDE.mLastModFileDate = mLFH.mLastModFileDate = zdate; +} + + +/* + * =========================================================================== + * ZipEntry::LocalFileHeader + * =========================================================================== + */ + +/* + * Read a local file header. + * + * On entry, "fp" points to the signature at the start of the header. + * On exit, "fp" points to the start of data. + */ +status_t ZipEntry::LocalFileHeader::read(FILE* fp) +{ + status_t result = NO_ERROR; + unsigned char buf[kLFHLen]; + + assert(mFileName == NULL); + assert(mExtraField == NULL); + + if (fread(buf, 1, kLFHLen, fp) != kLFHLen) { + result = UNKNOWN_ERROR; + goto bail; + } + + if (ZipEntry::getLongLE(&buf[0x00]) != kSignature) { + ALOGD("whoops: didn't find expected signature\n"); + result = UNKNOWN_ERROR; + goto bail; + } + + mVersionToExtract = ZipEntry::getShortLE(&buf[0x04]); + mGPBitFlag = ZipEntry::getShortLE(&buf[0x06]); + mCompressionMethod = ZipEntry::getShortLE(&buf[0x08]); + mLastModFileTime = ZipEntry::getShortLE(&buf[0x0a]); + mLastModFileDate = ZipEntry::getShortLE(&buf[0x0c]); + mCRC32 = ZipEntry::getLongLE(&buf[0x0e]); + mCompressedSize = ZipEntry::getLongLE(&buf[0x12]); + mUncompressedSize = ZipEntry::getLongLE(&buf[0x16]); + mFileNameLength = ZipEntry::getShortLE(&buf[0x1a]); + mExtraFieldLength = ZipEntry::getShortLE(&buf[0x1c]); + + // TODO: validate sizes + + /* grab filename */ + if (mFileNameLength != 0) { + mFileName = new unsigned char[mFileNameLength+1]; + if (mFileName == NULL) { + result = NO_MEMORY; + goto bail; + } + if (fread(mFileName, 1, mFileNameLength, fp) != mFileNameLength) { + result = UNKNOWN_ERROR; + goto bail; + } + mFileName[mFileNameLength] = '\0'; + } + + /* grab extra field */ + if (mExtraFieldLength != 0) { + mExtraField = new unsigned char[mExtraFieldLength+1]; + if (mExtraField == NULL) { + result = NO_MEMORY; + goto bail; + } + if (fread(mExtraField, 1, mExtraFieldLength, fp) != mExtraFieldLength) { + result = UNKNOWN_ERROR; + goto bail; + } + mExtraField[mExtraFieldLength] = '\0'; + } + +bail: + return result; +} + +/* + * Write a local file header. + */ +status_t ZipEntry::LocalFileHeader::write(FILE* fp) +{ + unsigned char buf[kLFHLen]; + + ZipEntry::putLongLE(&buf[0x00], kSignature); + ZipEntry::putShortLE(&buf[0x04], mVersionToExtract); + ZipEntry::putShortLE(&buf[0x06], mGPBitFlag); + ZipEntry::putShortLE(&buf[0x08], mCompressionMethod); + ZipEntry::putShortLE(&buf[0x0a], mLastModFileTime); + ZipEntry::putShortLE(&buf[0x0c], mLastModFileDate); + ZipEntry::putLongLE(&buf[0x0e], mCRC32); + ZipEntry::putLongLE(&buf[0x12], mCompressedSize); + ZipEntry::putLongLE(&buf[0x16], mUncompressedSize); + ZipEntry::putShortLE(&buf[0x1a], mFileNameLength); + ZipEntry::putShortLE(&buf[0x1c], mExtraFieldLength); + + if (fwrite(buf, 1, kLFHLen, fp) != kLFHLen) + return UNKNOWN_ERROR; + + /* write filename */ + if (mFileNameLength != 0) { + if (fwrite(mFileName, 1, mFileNameLength, fp) != mFileNameLength) + return UNKNOWN_ERROR; + } + + /* write "extra field" */ + if (mExtraFieldLength != 0) { + if (fwrite(mExtraField, 1, mExtraFieldLength, fp) != mExtraFieldLength) + return UNKNOWN_ERROR; + } + + return NO_ERROR; +} + + +/* + * Dump the contents of a LocalFileHeader object. + */ +void ZipEntry::LocalFileHeader::dump(void) const +{ + ALOGD(" LocalFileHeader contents:\n"); + ALOGD(" versToExt=%u gpBits=0x%04x compression=%u\n", + mVersionToExtract, mGPBitFlag, mCompressionMethod); + ALOGD(" modTime=0x%04x modDate=0x%04x crc32=0x%08lx\n", + mLastModFileTime, mLastModFileDate, mCRC32); + ALOGD(" compressedSize=%lu uncompressedSize=%lu\n", + mCompressedSize, mUncompressedSize); + ALOGD(" filenameLen=%u extraLen=%u\n", + mFileNameLength, mExtraFieldLength); + if (mFileName != NULL) + ALOGD(" filename: '%s'\n", mFileName); +} + + +/* + * =========================================================================== + * ZipEntry::CentralDirEntry + * =========================================================================== + */ + +/* + * Read the central dir entry that appears next in the file. + * + * On entry, "fp" should be positioned on the signature bytes for the + * entry. On exit, "fp" will point at the signature word for the next + * entry or for the EOCD. + */ +status_t ZipEntry::CentralDirEntry::read(FILE* fp) +{ + status_t result = NO_ERROR; + unsigned char buf[kCDELen]; + + /* no re-use */ + assert(mFileName == NULL); + assert(mExtraField == NULL); + assert(mFileComment == NULL); + + if (fread(buf, 1, kCDELen, fp) != kCDELen) { + result = UNKNOWN_ERROR; + goto bail; + } + + if (ZipEntry::getLongLE(&buf[0x00]) != kSignature) { + ALOGD("Whoops: didn't find expected signature\n"); + result = UNKNOWN_ERROR; + goto bail; + } + + mVersionMadeBy = ZipEntry::getShortLE(&buf[0x04]); + mVersionToExtract = ZipEntry::getShortLE(&buf[0x06]); + mGPBitFlag = ZipEntry::getShortLE(&buf[0x08]); + mCompressionMethod = ZipEntry::getShortLE(&buf[0x0a]); + mLastModFileTime = ZipEntry::getShortLE(&buf[0x0c]); + mLastModFileDate = ZipEntry::getShortLE(&buf[0x0e]); + mCRC32 = ZipEntry::getLongLE(&buf[0x10]); + mCompressedSize = ZipEntry::getLongLE(&buf[0x14]); + mUncompressedSize = ZipEntry::getLongLE(&buf[0x18]); + mFileNameLength = ZipEntry::getShortLE(&buf[0x1c]); + mExtraFieldLength = ZipEntry::getShortLE(&buf[0x1e]); + mFileCommentLength = ZipEntry::getShortLE(&buf[0x20]); + mDiskNumberStart = ZipEntry::getShortLE(&buf[0x22]); + mInternalAttrs = ZipEntry::getShortLE(&buf[0x24]); + mExternalAttrs = ZipEntry::getLongLE(&buf[0x26]); + mLocalHeaderRelOffset = ZipEntry::getLongLE(&buf[0x2a]); + + // TODO: validate sizes and offsets + + /* grab filename */ + if (mFileNameLength != 0) { + mFileName = new unsigned char[mFileNameLength+1]; + if (mFileName == NULL) { + result = NO_MEMORY; + goto bail; + } + if (fread(mFileName, 1, mFileNameLength, fp) != mFileNameLength) { + result = UNKNOWN_ERROR; + goto bail; + } + mFileName[mFileNameLength] = '\0'; + } + + /* read "extra field" */ + if (mExtraFieldLength != 0) { + mExtraField = new unsigned char[mExtraFieldLength+1]; + if (mExtraField == NULL) { + result = NO_MEMORY; + goto bail; + } + if (fread(mExtraField, 1, mExtraFieldLength, fp) != mExtraFieldLength) { + result = UNKNOWN_ERROR; + goto bail; + } + mExtraField[mExtraFieldLength] = '\0'; + } + + + /* grab comment, if any */ + if (mFileCommentLength != 0) { + mFileComment = new unsigned char[mFileCommentLength+1]; + if (mFileComment == NULL) { + result = NO_MEMORY; + goto bail; + } + if (fread(mFileComment, 1, mFileCommentLength, fp) != mFileCommentLength) + { + result = UNKNOWN_ERROR; + goto bail; + } + mFileComment[mFileCommentLength] = '\0'; + } + +bail: + return result; +} + +/* + * Write a central dir entry. + */ +status_t ZipEntry::CentralDirEntry::write(FILE* fp) +{ + unsigned char buf[kCDELen]; + + ZipEntry::putLongLE(&buf[0x00], kSignature); + ZipEntry::putShortLE(&buf[0x04], mVersionMadeBy); + ZipEntry::putShortLE(&buf[0x06], mVersionToExtract); + ZipEntry::putShortLE(&buf[0x08], mGPBitFlag); + ZipEntry::putShortLE(&buf[0x0a], mCompressionMethod); + ZipEntry::putShortLE(&buf[0x0c], mLastModFileTime); + ZipEntry::putShortLE(&buf[0x0e], mLastModFileDate); + ZipEntry::putLongLE(&buf[0x10], mCRC32); + ZipEntry::putLongLE(&buf[0x14], mCompressedSize); + ZipEntry::putLongLE(&buf[0x18], mUncompressedSize); + ZipEntry::putShortLE(&buf[0x1c], mFileNameLength); + ZipEntry::putShortLE(&buf[0x1e], mExtraFieldLength); + ZipEntry::putShortLE(&buf[0x20], mFileCommentLength); + ZipEntry::putShortLE(&buf[0x22], mDiskNumberStart); + ZipEntry::putShortLE(&buf[0x24], mInternalAttrs); + ZipEntry::putLongLE(&buf[0x26], mExternalAttrs); + ZipEntry::putLongLE(&buf[0x2a], mLocalHeaderRelOffset); + + if (fwrite(buf, 1, kCDELen, fp) != kCDELen) + return UNKNOWN_ERROR; + + /* write filename */ + if (mFileNameLength != 0) { + if (fwrite(mFileName, 1, mFileNameLength, fp) != mFileNameLength) + return UNKNOWN_ERROR; + } + + /* write "extra field" */ + if (mExtraFieldLength != 0) { + if (fwrite(mExtraField, 1, mExtraFieldLength, fp) != mExtraFieldLength) + return UNKNOWN_ERROR; + } + + /* write comment */ + if (mFileCommentLength != 0) { + if (fwrite(mFileComment, 1, mFileCommentLength, fp) != mFileCommentLength) + return UNKNOWN_ERROR; + } + + return NO_ERROR; +} + +/* + * Dump the contents of a CentralDirEntry object. + */ +void ZipEntry::CentralDirEntry::dump(void) const +{ + ALOGD(" CentralDirEntry contents:\n"); + ALOGD(" versMadeBy=%u versToExt=%u gpBits=0x%04x compression=%u\n", + mVersionMadeBy, mVersionToExtract, mGPBitFlag, mCompressionMethod); + ALOGD(" modTime=0x%04x modDate=0x%04x crc32=0x%08lx\n", + mLastModFileTime, mLastModFileDate, mCRC32); + ALOGD(" compressedSize=%lu uncompressedSize=%lu\n", + mCompressedSize, mUncompressedSize); + ALOGD(" filenameLen=%u extraLen=%u commentLen=%u\n", + mFileNameLength, mExtraFieldLength, mFileCommentLength); + ALOGD(" diskNumStart=%u intAttr=0x%04x extAttr=0x%08lx relOffset=%lu\n", + mDiskNumberStart, mInternalAttrs, mExternalAttrs, + mLocalHeaderRelOffset); + + if (mFileName != NULL) + ALOGD(" filename: '%s'\n", mFileName); + if (mFileComment != NULL) + ALOGD(" comment: '%s'\n", mFileComment); +} + +/* + * Copy-assignment operator for CentralDirEntry. + */ +ZipEntry::CentralDirEntry& ZipEntry::CentralDirEntry::operator=(const ZipEntry::CentralDirEntry& src) { + if (this == &src) { + return *this; + } + + // Free up old data. + delete[] mFileName; + delete[] mExtraField; + delete[] mFileComment; + + // Copy scalars. + mVersionMadeBy = src.mVersionMadeBy; + mVersionToExtract = src.mVersionToExtract; + mGPBitFlag = src.mGPBitFlag; + mCompressionMethod = src.mCompressionMethod; + mLastModFileTime = src.mLastModFileTime; + mLastModFileDate = src.mLastModFileDate; + mCRC32 = src.mCRC32; + mCompressedSize = src.mCompressedSize; + mUncompressedSize = src.mUncompressedSize; + mFileNameLength = src.mFileNameLength; + mExtraFieldLength = src.mExtraFieldLength; + mFileCommentLength = src.mFileCommentLength; + mDiskNumberStart = src.mDiskNumberStart; + mInternalAttrs = src.mInternalAttrs; + mExternalAttrs = src.mExternalAttrs; + mLocalHeaderRelOffset = src.mLocalHeaderRelOffset; + + // Copy strings, if necessary. + if (mFileNameLength > 0) { + mFileName = new unsigned char[mFileNameLength + 1]; + if (mFileName != NULL) + strcpy((char*)mFileName, (char*)src.mFileName); + } else { + mFileName = NULL; + } + if (mFileCommentLength > 0) { + mFileComment = new unsigned char[mFileCommentLength + 1]; + if (mFileComment != NULL) + strcpy((char*)mFileComment, (char*)src.mFileComment); + } else { + mFileComment = NULL; + } + if (mExtraFieldLength > 0) { + /* we null-terminate this, though it may not be a string */ + mExtraField = new unsigned char[mExtraFieldLength + 1]; + if (mExtraField != NULL) + memcpy(mExtraField, src.mExtraField, mExtraFieldLength + 1); + } else { + mExtraField = NULL; + } + + return *this; +} + +} // namespace aapt diff --git a/tools/aapt2/ZipEntry.h b/tools/aapt2/ZipEntry.h new file mode 100644 index 0000000..2745a43 --- /dev/null +++ b/tools/aapt2/ZipEntry.h @@ -0,0 +1,350 @@ +/* + * Copyright (C) 2006 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. + */ + +// +// Zip archive entries. +// +// The ZipEntry class is tightly meshed with the ZipFile class. +// +#ifndef __LIBS_ZIPENTRY_H +#define __LIBS_ZIPENTRY_H + +#include <utils/Errors.h> + +#include <stdlib.h> +#include <stdio.h> + +namespace aapt { + +using android::status_t; + +class ZipFile; + +/* + * ZipEntry objects represent a single entry in a Zip archive. + * + * You can use one of these to get or set information about an entry, but + * there are no functions here for accessing the data itself. (We could + * tuck a pointer to the ZipFile in here for convenience, but that raises + * the likelihood of using ZipEntry objects after discarding the ZipFile.) + * + * File information is stored in two places: next to the file data (the Local + * File Header, and possibly a Data Descriptor), and at the end of the file + * (the Central Directory Entry). The two must be kept in sync. + */ +class ZipEntry { +public: + friend class ZipFile; + + ZipEntry(void) + : mDeleted(false), mMarked(false) + {} + ~ZipEntry(void) {} + + /* + * Returns "true" if the data is compressed. + */ + bool isCompressed(void) const { + return mCDE.mCompressionMethod != kCompressStored; + } + int getCompressionMethod(void) const { return mCDE.mCompressionMethod; } + + /* + * Return the uncompressed length. + */ + off_t getUncompressedLen(void) const { return mCDE.mUncompressedSize; } + + /* + * Return the compressed length. For uncompressed data, this returns + * the same thing as getUncompresesdLen(). + */ + off_t getCompressedLen(void) const { return mCDE.mCompressedSize; } + + /* + * Return the offset of the local file header. + */ + off_t getLFHOffset(void) const { return mCDE.mLocalHeaderRelOffset; } + + /* + * Return the absolute file offset of the start of the compressed or + * uncompressed data. + */ + off_t getFileOffset(void) const { + return mCDE.mLocalHeaderRelOffset + + LocalFileHeader::kLFHLen + + mLFH.mFileNameLength + + mLFH.mExtraFieldLength; + } + + /* + * Return the data CRC. + */ + unsigned long getCRC32(void) const { return mCDE.mCRC32; } + + /* + * Return file modification time in UNIX seconds-since-epoch. + */ + time_t getModWhen(void) const; + + /* + * Return the archived file name. + */ + const char* getFileName(void) const { return (const char*) mCDE.mFileName; } + + /* + * Application-defined "mark". Can be useful when synchronizing the + * contents of an archive with contents on disk. + */ + bool getMarked(void) const { return mMarked; } + void setMarked(bool val) { mMarked = val; } + + /* + * Some basic functions for raw data manipulation. "LE" means + * Little Endian. + */ + static inline unsigned short getShortLE(const unsigned char* buf) { + return buf[0] | (buf[1] << 8); + } + static inline unsigned long getLongLE(const unsigned char* buf) { + return buf[0] | (buf[1] << 8) | (buf[2] << 16) | (buf[3] << 24); + } + static inline void putShortLE(unsigned char* buf, short val) { + buf[0] = (unsigned char) val; + buf[1] = (unsigned char) (val >> 8); + } + static inline void putLongLE(unsigned char* buf, long val) { + buf[0] = (unsigned char) val; + buf[1] = (unsigned char) (val >> 8); + buf[2] = (unsigned char) (val >> 16); + buf[3] = (unsigned char) (val >> 24); + } + + /* defined for Zip archives */ + enum { + kCompressStored = 0, // no compression + // shrunk = 1, + // reduced 1 = 2, + // reduced 2 = 3, + // reduced 3 = 4, + // reduced 4 = 5, + // imploded = 6, + // tokenized = 7, + kCompressDeflated = 8, // standard deflate + // Deflate64 = 9, + // lib imploded = 10, + // reserved = 11, + // bzip2 = 12, + }; + + /* + * Deletion flag. If set, the entry will be removed on the next + * call to "flush". + */ + bool getDeleted(void) const { return mDeleted; } + +protected: + /* + * Initialize the structure from the file, which is pointing at + * our Central Directory entry. + */ + status_t initFromCDE(FILE* fp); + + /* + * Initialize the structure for a new file. We need the filename + * and comment so that we can properly size the LFH area. The + * filename is mandatory, the comment is optional. + */ + void initNew(const char* fileName, const char* comment); + + /* + * Initialize the structure with the contents of a ZipEntry from + * another file. If fileName is non-NULL, override the name with fileName. + */ + status_t initFromExternal(const ZipFile* pZipFile, const ZipEntry* pEntry, + const char* fileName); + + /* + * Add some pad bytes to the LFH. We do this by adding or resizing + * the "extra" field. + */ + status_t addPadding(int padding); + + /* + * Set information about the data for this entry. + */ + void setDataInfo(long uncompLen, long compLen, unsigned long crc32, + int compressionMethod); + + /* + * Set the modification date. + */ + void setModWhen(time_t when); + + /* + * Set the offset of the local file header, relative to the start of + * the current file. + */ + void setLFHOffset(off_t offset) { + mCDE.mLocalHeaderRelOffset = (long) offset; + } + + /* mark for deletion; used by ZipFile::remove() */ + void setDeleted(void) { mDeleted = true; } + +private: + /* these are private and not defined */ + ZipEntry(const ZipEntry& src); + ZipEntry& operator=(const ZipEntry& src); + + /* returns "true" if the CDE and the LFH agree */ + bool compareHeaders(void) const; + void copyCDEtoLFH(void); + + bool mDeleted; // set if entry is pending deletion + bool mMarked; // app-defined marker + + /* + * Every entry in the Zip archive starts off with one of these. + */ + class LocalFileHeader { + public: + LocalFileHeader(void) : + mVersionToExtract(0), + mGPBitFlag(0), + mCompressionMethod(0), + mLastModFileTime(0), + mLastModFileDate(0), + mCRC32(0), + mCompressedSize(0), + mUncompressedSize(0), + mFileNameLength(0), + mExtraFieldLength(0), + mFileName(NULL), + mExtraField(NULL) + {} + virtual ~LocalFileHeader(void) { + delete[] mFileName; + delete[] mExtraField; + } + + status_t read(FILE* fp); + status_t write(FILE* fp); + + // unsigned long mSignature; + unsigned short mVersionToExtract; + unsigned short mGPBitFlag; + unsigned short mCompressionMethod; + unsigned short mLastModFileTime; + unsigned short mLastModFileDate; + unsigned long mCRC32; + unsigned long mCompressedSize; + unsigned long mUncompressedSize; + unsigned short mFileNameLength; + unsigned short mExtraFieldLength; + unsigned char* mFileName; + unsigned char* mExtraField; + + enum { + kSignature = 0x04034b50, + kLFHLen = 30, // LocalFileHdr len, excl. var fields + }; + + void dump(void) const; + }; + + /* + * Every entry in the Zip archive has one of these in the "central + * directory" at the end of the file. + */ + class CentralDirEntry { + public: + CentralDirEntry(void) : + mVersionMadeBy(0), + mVersionToExtract(0), + mGPBitFlag(0), + mCompressionMethod(0), + mLastModFileTime(0), + mLastModFileDate(0), + mCRC32(0), + mCompressedSize(0), + mUncompressedSize(0), + mFileNameLength(0), + mExtraFieldLength(0), + mFileCommentLength(0), + mDiskNumberStart(0), + mInternalAttrs(0), + mExternalAttrs(0), + mLocalHeaderRelOffset(0), + mFileName(NULL), + mExtraField(NULL), + mFileComment(NULL) + {} + virtual ~CentralDirEntry(void) { + delete[] mFileName; + delete[] mExtraField; + delete[] mFileComment; + } + + status_t read(FILE* fp); + status_t write(FILE* fp); + + CentralDirEntry& operator=(const CentralDirEntry& src); + + // unsigned long mSignature; + unsigned short mVersionMadeBy; + unsigned short mVersionToExtract; + unsigned short mGPBitFlag; + unsigned short mCompressionMethod; + unsigned short mLastModFileTime; + unsigned short mLastModFileDate; + unsigned long mCRC32; + unsigned long mCompressedSize; + unsigned long mUncompressedSize; + unsigned short mFileNameLength; + unsigned short mExtraFieldLength; + unsigned short mFileCommentLength; + unsigned short mDiskNumberStart; + unsigned short mInternalAttrs; + unsigned long mExternalAttrs; + unsigned long mLocalHeaderRelOffset; + unsigned char* mFileName; + unsigned char* mExtraField; + unsigned char* mFileComment; + + void dump(void) const; + + enum { + kSignature = 0x02014b50, + kCDELen = 46, // CentralDirEnt len, excl. var fields + }; + }; + + enum { + //kDataDescriptorSignature = 0x08074b50, // currently unused + kDataDescriptorLen = 16, // four 32-bit fields + + kDefaultVersion = 20, // need deflate, nothing much else + kDefaultMadeBy = 0x0317, // 03=UNIX, 17=spec v2.3 + kUsesDataDescr = 0x0008, // GPBitFlag bit 3 + }; + + LocalFileHeader mLFH; + CentralDirEntry mCDE; +}; + +}; // namespace aapt + +#endif // __LIBS_ZIPENTRY_H diff --git a/tools/aapt2/ZipFile.cpp b/tools/aapt2/ZipFile.cpp new file mode 100644 index 0000000..268c15e --- /dev/null +++ b/tools/aapt2/ZipFile.cpp @@ -0,0 +1,1306 @@ +/* + * Copyright (C) 2006 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. + */ + +// +// Access to Zip archives. +// + +#define LOG_TAG "zip" + +#include <androidfw/ZipUtils.h> +#include <utils/Log.h> + +#include "ZipFile.h" +#include "Util.h" + +#include <zlib.h> +#define DEF_MEM_LEVEL 8 // normally in zutil.h? + +#include <memory.h> +#include <sys/stat.h> +#include <errno.h> +#include <assert.h> + +namespace aapt { + +using namespace android; + +/* + * Some environments require the "b", some choke on it. + */ +#define FILE_OPEN_RO "rb" +#define FILE_OPEN_RW "r+b" +#define FILE_OPEN_RW_CREATE "w+b" + +/* should live somewhere else? */ +static status_t errnoToStatus(int err) +{ + if (err == ENOENT) + return NAME_NOT_FOUND; + else if (err == EACCES) + return PERMISSION_DENIED; + else + return UNKNOWN_ERROR; +} + +/* + * Open a file and parse its guts. + */ +status_t ZipFile::open(const char* zipFileName, int flags) +{ + bool newArchive = false; + + assert(mZipFp == NULL); // no reopen + + if ((flags & kOpenTruncate)) + flags |= kOpenCreate; // trunc implies create + + if ((flags & kOpenReadOnly) && (flags & kOpenReadWrite)) + return INVALID_OPERATION; // not both + if (!((flags & kOpenReadOnly) || (flags & kOpenReadWrite))) + return INVALID_OPERATION; // not neither + if ((flags & kOpenCreate) && !(flags & kOpenReadWrite)) + return INVALID_OPERATION; // create requires write + + if (flags & kOpenTruncate) { + newArchive = true; + } else { + newArchive = (access(zipFileName, F_OK) != 0); + if (!(flags & kOpenCreate) && newArchive) { + /* not creating, must already exist */ + ALOGD("File %s does not exist", zipFileName); + return NAME_NOT_FOUND; + } + } + + /* open the file */ + const char* openflags; + if (flags & kOpenReadWrite) { + if (newArchive) + openflags = FILE_OPEN_RW_CREATE; + else + openflags = FILE_OPEN_RW; + } else { + openflags = FILE_OPEN_RO; + } + mZipFp = fopen(zipFileName, openflags); + if (mZipFp == NULL) { + int err = errno; + ALOGD("fopen failed: %d\n", err); + return errnoToStatus(err); + } + + status_t result; + if (!newArchive) { + /* + * Load the central directory. If that fails, then this probably + * isn't a Zip archive. + */ + result = readCentralDir(); + } else { + /* + * Newly-created. The EndOfCentralDir constructor actually + * sets everything to be the way we want it (all zeroes). We + * set mNeedCDRewrite so that we create *something* if the + * caller doesn't add any files. (We could also just unlink + * the file if it's brand new and nothing was added, but that's + * probably doing more than we really should -- the user might + * have a need for empty zip files.) + */ + mNeedCDRewrite = true; + result = NO_ERROR; + } + + if (flags & kOpenReadOnly) + mReadOnly = true; + else + assert(!mReadOnly); + + return result; +} + +/* + * Return the Nth entry in the archive. + */ +ZipEntry* ZipFile::getEntryByIndex(int idx) const +{ + if (idx < 0 || idx >= (int) mEntries.size()) + return NULL; + + return mEntries[idx]; +} + +/* + * Find an entry by name. + */ +ZipEntry* ZipFile::getEntryByName(const char* fileName) const +{ + /* + * Do a stupid linear string-compare search. + * + * There are various ways to speed this up, especially since it's rare + * to intermingle changes to the archive with "get by name" calls. We + * don't want to sort the mEntries vector itself, however, because + * it's used to recreate the Central Directory. + * + * (Hash table works, parallel list of pointers in sorted order is good.) + */ + int idx; + + for (idx = mEntries.size()-1; idx >= 0; idx--) { + ZipEntry* pEntry = mEntries[idx]; + if (!pEntry->getDeleted() && + strcmp(fileName, pEntry->getFileName()) == 0) + { + return pEntry; + } + } + + return NULL; +} + +/* + * Empty the mEntries vector. + */ +void ZipFile::discardEntries(void) +{ + int count = mEntries.size(); + + while (--count >= 0) + delete mEntries[count]; + + mEntries.clear(); +} + + +/* + * Find the central directory and read the contents. + * + * The fun thing about ZIP archives is that they may or may not be + * readable from start to end. In some cases, notably for archives + * that were written to stdout, the only length information is in the + * central directory at the end of the file. + * + * Of course, the central directory can be followed by a variable-length + * comment field, so we have to scan through it backwards. The comment + * is at most 64K, plus we have 18 bytes for the end-of-central-dir stuff + * itself, plus apparently sometimes people throw random junk on the end + * just for the fun of it. + * + * This is all a little wobbly. If the wrong value ends up in the EOCD + * area, we're hosed. This appears to be the way that everbody handles + * it though, so we're in pretty good company if this fails. + */ +status_t ZipFile::readCentralDir(void) +{ + status_t result = NO_ERROR; + unsigned char* buf = NULL; + off_t fileLength, seekStart; + long readAmount; + int i; + + fseek(mZipFp, 0, SEEK_END); + fileLength = ftell(mZipFp); + rewind(mZipFp); + + /* too small to be a ZIP archive? */ + if (fileLength < EndOfCentralDir::kEOCDLen) { + ALOGD("Length is %ld -- too small\n", (long)fileLength); + result = INVALID_OPERATION; + goto bail; + } + + buf = new unsigned char[EndOfCentralDir::kMaxEOCDSearch]; + if (buf == NULL) { + ALOGD("Failure allocating %d bytes for EOCD search", + EndOfCentralDir::kMaxEOCDSearch); + result = NO_MEMORY; + goto bail; + } + + if (fileLength > EndOfCentralDir::kMaxEOCDSearch) { + seekStart = fileLength - EndOfCentralDir::kMaxEOCDSearch; + readAmount = EndOfCentralDir::kMaxEOCDSearch; + } else { + seekStart = 0; + readAmount = (long) fileLength; + } + if (fseek(mZipFp, seekStart, SEEK_SET) != 0) { + ALOGD("Failure seeking to end of zip at %ld", (long) seekStart); + result = UNKNOWN_ERROR; + goto bail; + } + + /* read the last part of the file into the buffer */ + if (fread(buf, 1, readAmount, mZipFp) != (size_t) readAmount) { + ALOGD("short file? wanted %ld\n", readAmount); + result = UNKNOWN_ERROR; + goto bail; + } + + /* find the end-of-central-dir magic */ + for (i = readAmount - 4; i >= 0; i--) { + if (buf[i] == 0x50 && + ZipEntry::getLongLE(&buf[i]) == EndOfCentralDir::kSignature) + { + ALOGV("+++ Found EOCD at buf+%d\n", i); + break; + } + } + if (i < 0) { + ALOGD("EOCD not found, not Zip\n"); + result = INVALID_OPERATION; + goto bail; + } + + /* extract eocd values */ + result = mEOCD.readBuf(buf + i, readAmount - i); + if (result != NO_ERROR) { + ALOGD("Failure reading %ld bytes of EOCD values", readAmount - i); + goto bail; + } + //mEOCD.dump(); + + if (mEOCD.mDiskNumber != 0 || mEOCD.mDiskWithCentralDir != 0 || + mEOCD.mNumEntries != mEOCD.mTotalNumEntries) + { + ALOGD("Archive spanning not supported\n"); + result = INVALID_OPERATION; + goto bail; + } + + /* + * So far so good. "mCentralDirSize" is the size in bytes of the + * central directory, so we can just seek back that far to find it. + * We can also seek forward mCentralDirOffset bytes from the + * start of the file. + * + * We're not guaranteed to have the rest of the central dir in the + * buffer, nor are we guaranteed that the central dir will have any + * sort of convenient size. We need to skip to the start of it and + * read the header, then the other goodies. + * + * The only thing we really need right now is the file comment, which + * we're hoping to preserve. + */ + if (fseek(mZipFp, mEOCD.mCentralDirOffset, SEEK_SET) != 0) { + ALOGD("Failure seeking to central dir offset %ld\n", + mEOCD.mCentralDirOffset); + result = UNKNOWN_ERROR; + goto bail; + } + + /* + * Loop through and read the central dir entries. + */ + ALOGV("Scanning %d entries...\n", mEOCD.mTotalNumEntries); + int entry; + for (entry = 0; entry < mEOCD.mTotalNumEntries; entry++) { + ZipEntry* pEntry = new ZipEntry; + + result = pEntry->initFromCDE(mZipFp); + if (result != NO_ERROR) { + ALOGD("initFromCDE failed\n"); + delete pEntry; + goto bail; + } + + mEntries.push_back(pEntry); + } + + + /* + * If all went well, we should now be back at the EOCD. + */ + { + unsigned char checkBuf[4]; + if (fread(checkBuf, 1, 4, mZipFp) != 4) { + ALOGD("EOCD check read failed\n"); + result = INVALID_OPERATION; + goto bail; + } + if (ZipEntry::getLongLE(checkBuf) != EndOfCentralDir::kSignature) { + ALOGD("EOCD read check failed\n"); + result = UNKNOWN_ERROR; + goto bail; + } + ALOGV("+++ EOCD read check passed\n"); + } + +bail: + delete[] buf; + return result; +} + +status_t ZipFile::add(const BigBuffer& buffer, const char* storageName, int compressionMethod, + ZipEntry** ppEntry) { + std::unique_ptr<uint8_t[]> data = util::copy(buffer); + return add(data.get(), buffer.size(), storageName, compressionMethod, ppEntry); +} + + +/* + * Add a new file to the archive. + * + * This requires creating and populating a ZipEntry structure, and copying + * the data into the file at the appropriate position. The "appropriate + * position" is the current location of the central directory, which we + * casually overwrite (we can put it back later). + * + * If we were concerned about safety, we would want to make all changes + * in a temp file and then overwrite the original after everything was + * safely written. Not really a concern for us. + */ +status_t ZipFile::addCommon(const char* fileName, const void* data, size_t size, + const char* storageName, int sourceType, int compressionMethod, + ZipEntry** ppEntry) +{ + ZipEntry* pEntry = NULL; + status_t result = NO_ERROR; + long lfhPosn, startPosn, endPosn, uncompressedLen; + FILE* inputFp = NULL; + unsigned long crc; + time_t modWhen; + + if (mReadOnly) + return INVALID_OPERATION; + + assert(compressionMethod == ZipEntry::kCompressDeflated || + compressionMethod == ZipEntry::kCompressStored); + + /* make sure we're in a reasonable state */ + assert(mZipFp != NULL); + assert(mEntries.size() == mEOCD.mTotalNumEntries); + + /* make sure it doesn't already exist */ + if (getEntryByName(storageName) != NULL) + return ALREADY_EXISTS; + + if (!data) { + inputFp = fopen(fileName, FILE_OPEN_RO); + if (inputFp == NULL) + return errnoToStatus(errno); + } + + if (fseek(mZipFp, mEOCD.mCentralDirOffset, SEEK_SET) != 0) { + result = UNKNOWN_ERROR; + goto bail; + } + + pEntry = new ZipEntry; + pEntry->initNew(storageName, NULL); + + /* + * From here on out, failures are more interesting. + */ + mNeedCDRewrite = true; + + /* + * Write the LFH, even though it's still mostly blank. We need it + * as a place-holder. In theory the LFH isn't necessary, but in + * practice some utilities demand it. + */ + lfhPosn = ftell(mZipFp); + pEntry->mLFH.write(mZipFp); + startPosn = ftell(mZipFp); + + /* + * Copy the data in, possibly compressing it as we go. + */ + if (sourceType == ZipEntry::kCompressStored) { + if (compressionMethod == ZipEntry::kCompressDeflated) { + bool failed = false; + result = compressFpToFp(mZipFp, inputFp, data, size, &crc); + if (result != NO_ERROR) { + ALOGD("compression failed, storing\n"); + failed = true; + } else { + /* + * Make sure it has compressed "enough". This probably ought + * to be set through an API call, but I don't expect our + * criteria to change over time. + */ + long src = inputFp ? ftell(inputFp) : size; + long dst = ftell(mZipFp) - startPosn; + if (dst + (dst / 10) > src) { + ALOGD("insufficient compression (src=%ld dst=%ld), storing\n", + src, dst); + failed = true; + } + } + + if (failed) { + compressionMethod = ZipEntry::kCompressStored; + if (inputFp) rewind(inputFp); + fseek(mZipFp, startPosn, SEEK_SET); + /* fall through to kCompressStored case */ + } + } + /* handle "no compression" request, or failed compression from above */ + if (compressionMethod == ZipEntry::kCompressStored) { + if (inputFp) { + result = copyFpToFp(mZipFp, inputFp, &crc); + } else { + result = copyDataToFp(mZipFp, data, size, &crc); + } + if (result != NO_ERROR) { + // don't need to truncate; happens in CDE rewrite + ALOGD("failed copying data in\n"); + goto bail; + } + } + + // currently seeked to end of file + uncompressedLen = inputFp ? ftell(inputFp) : size; + } else if (sourceType == ZipEntry::kCompressDeflated) { + /* we should support uncompressed-from-compressed, but it's not + * important right now */ + assert(compressionMethod == ZipEntry::kCompressDeflated); + + bool scanResult; + int method; + long compressedLen; + + scanResult = ZipUtils::examineGzip(inputFp, &method, &uncompressedLen, + &compressedLen, &crc); + if (!scanResult || method != ZipEntry::kCompressDeflated) { + ALOGD("this isn't a deflated gzip file?"); + result = UNKNOWN_ERROR; + goto bail; + } + + result = copyPartialFpToFp(mZipFp, inputFp, compressedLen, NULL); + if (result != NO_ERROR) { + ALOGD("failed copying gzip data in\n"); + goto bail; + } + } else { + assert(false); + result = UNKNOWN_ERROR; + goto bail; + } + + /* + * We could write the "Data Descriptor", but there doesn't seem to + * be any point since we're going to go back and write the LFH. + * + * Update file offsets. + */ + endPosn = ftell(mZipFp); // seeked to end of compressed data + + /* + * Success! Fill out new values. + */ + pEntry->setDataInfo(uncompressedLen, endPosn - startPosn, crc, + compressionMethod); + modWhen = getModTime(inputFp ? fileno(inputFp) : fileno(mZipFp)); + pEntry->setModWhen(modWhen); + pEntry->setLFHOffset(lfhPosn); + mEOCD.mNumEntries++; + mEOCD.mTotalNumEntries++; + mEOCD.mCentralDirSize = 0; // mark invalid; set by flush() + mEOCD.mCentralDirOffset = endPosn; + + /* + * Go back and write the LFH. + */ + if (fseek(mZipFp, lfhPosn, SEEK_SET) != 0) { + result = UNKNOWN_ERROR; + goto bail; + } + pEntry->mLFH.write(mZipFp); + + /* + * Add pEntry to the list. + */ + mEntries.push_back(pEntry); + if (ppEntry != NULL) + *ppEntry = pEntry; + pEntry = NULL; + +bail: + if (inputFp != NULL) + fclose(inputFp); + delete pEntry; + return result; +} + +/* + * Add an entry by copying it from another zip file. If "padding" is + * nonzero, the specified number of bytes will be added to the "extra" + * field in the header. + * + * If "ppEntry" is non-NULL, a pointer to the new entry will be returned. + */ +status_t ZipFile::add(const ZipFile* pSourceZip, const ZipEntry* pSourceEntry, + const char* storageName, int padding, ZipEntry** ppEntry) +{ + ZipEntry* pEntry = NULL; + status_t result; + long lfhPosn, endPosn; + + if (mReadOnly) + return INVALID_OPERATION; + + /* make sure we're in a reasonable state */ + assert(mZipFp != NULL); + assert(mEntries.size() == mEOCD.mTotalNumEntries); + + if (fseek(mZipFp, mEOCD.mCentralDirOffset, SEEK_SET) != 0) { + result = UNKNOWN_ERROR; + goto bail; + } + + pEntry = new ZipEntry; + if (pEntry == NULL) { + result = NO_MEMORY; + goto bail; + } + + result = pEntry->initFromExternal(pSourceZip, pSourceEntry, storageName); + if (result != NO_ERROR) { + goto bail; + } + if (padding != 0) { + result = pEntry->addPadding(padding); + if (result != NO_ERROR) + goto bail; + } + + /* + * From here on out, failures are more interesting. + */ + mNeedCDRewrite = true; + + /* + * Write the LFH. Since we're not recompressing the data, we already + * have all of the fields filled out. + */ + lfhPosn = ftell(mZipFp); + pEntry->mLFH.write(mZipFp); + + /* + * Copy the data over. + * + * If the "has data descriptor" flag is set, we want to copy the DD + * fields as well. This is a fixed-size area immediately following + * the data. + */ + if (fseek(pSourceZip->mZipFp, pSourceEntry->getFileOffset(), SEEK_SET) != 0) + { + result = UNKNOWN_ERROR; + goto bail; + } + + off_t copyLen; + copyLen = pSourceEntry->getCompressedLen(); + if ((pSourceEntry->mLFH.mGPBitFlag & ZipEntry::kUsesDataDescr) != 0) + copyLen += ZipEntry::kDataDescriptorLen; + + if (copyPartialFpToFp(mZipFp, pSourceZip->mZipFp, copyLen, NULL) + != NO_ERROR) + { + ALOGW("copy of '%s' failed\n", pEntry->mCDE.mFileName); + result = UNKNOWN_ERROR; + goto bail; + } + + /* + * Update file offsets. + */ + endPosn = ftell(mZipFp); + + /* + * Success! Fill out new values. + */ + pEntry->setLFHOffset(lfhPosn); // sets mCDE.mLocalHeaderRelOffset + mEOCD.mNumEntries++; + mEOCD.mTotalNumEntries++; + mEOCD.mCentralDirSize = 0; // mark invalid; set by flush() + mEOCD.mCentralDirOffset = endPosn; + + /* + * Add pEntry to the list. + */ + mEntries.push_back(pEntry); + if (ppEntry != NULL) + *ppEntry = pEntry; + pEntry = NULL; + + result = NO_ERROR; + +bail: + delete pEntry; + return result; +} + +/* + * Copy all of the bytes in "src" to "dst". + * + * On exit, "srcFp" will be seeked to the end of the file, and "dstFp" + * will be seeked immediately past the data. + */ +status_t ZipFile::copyFpToFp(FILE* dstFp, FILE* srcFp, unsigned long* pCRC32) +{ + unsigned char tmpBuf[32768]; + size_t count; + + *pCRC32 = crc32(0L, Z_NULL, 0); + + while (1) { + count = fread(tmpBuf, 1, sizeof(tmpBuf), srcFp); + if (ferror(srcFp) || ferror(dstFp)) + return errnoToStatus(errno); + if (count == 0) + break; + + *pCRC32 = crc32(*pCRC32, tmpBuf, count); + + if (fwrite(tmpBuf, 1, count, dstFp) != count) { + ALOGD("fwrite %d bytes failed\n", (int) count); + return UNKNOWN_ERROR; + } + } + + return NO_ERROR; +} + +/* + * Copy all of the bytes in "src" to "dst". + * + * On exit, "dstFp" will be seeked immediately past the data. + */ +status_t ZipFile::copyDataToFp(FILE* dstFp, + const void* data, size_t size, unsigned long* pCRC32) +{ + *pCRC32 = crc32(0L, Z_NULL, 0); + if (size > 0) { + *pCRC32 = crc32(*pCRC32, (const unsigned char*)data, size); + if (fwrite(data, 1, size, dstFp) != size) { + ALOGD("fwrite %d bytes failed\n", (int) size); + return UNKNOWN_ERROR; + } + } + + return NO_ERROR; +} + +/* + * Copy some of the bytes in "src" to "dst". + * + * If "pCRC32" is NULL, the CRC will not be computed. + * + * On exit, "srcFp" will be seeked to the end of the file, and "dstFp" + * will be seeked immediately past the data just written. + */ +status_t ZipFile::copyPartialFpToFp(FILE* dstFp, FILE* srcFp, long length, + unsigned long* pCRC32) +{ + unsigned char tmpBuf[32768]; + size_t count; + + if (pCRC32 != NULL) + *pCRC32 = crc32(0L, Z_NULL, 0); + + while (length) { + long readSize; + + readSize = sizeof(tmpBuf); + if (readSize > length) + readSize = length; + + count = fread(tmpBuf, 1, readSize, srcFp); + if ((long) count != readSize) { // error or unexpected EOF + ALOGD("fread %d bytes failed\n", (int) readSize); + return UNKNOWN_ERROR; + } + + if (pCRC32 != NULL) + *pCRC32 = crc32(*pCRC32, tmpBuf, count); + + if (fwrite(tmpBuf, 1, count, dstFp) != count) { + ALOGD("fwrite %d bytes failed\n", (int) count); + return UNKNOWN_ERROR; + } + + length -= readSize; + } + + return NO_ERROR; +} + +/* + * Compress all of the data in "srcFp" and write it to "dstFp". + * + * On exit, "srcFp" will be seeked to the end of the file, and "dstFp" + * will be seeked immediately past the compressed data. + */ +status_t ZipFile::compressFpToFp(FILE* dstFp, FILE* srcFp, + const void* data, size_t size, unsigned long* pCRC32) +{ + status_t result = NO_ERROR; + const size_t kBufSize = 32768; + unsigned char* inBuf = NULL; + unsigned char* outBuf = NULL; + z_stream zstream; + bool atEof = false; // no feof() aviailable yet + unsigned long crc; + int zerr; + + /* + * Create an input buffer and an output buffer. + */ + inBuf = new unsigned char[kBufSize]; + outBuf = new unsigned char[kBufSize]; + if (inBuf == NULL || outBuf == NULL) { + result = NO_MEMORY; + goto bail; + } + + /* + * Initialize the zlib stream. + */ + memset(&zstream, 0, sizeof(zstream)); + zstream.zalloc = Z_NULL; + zstream.zfree = Z_NULL; + zstream.opaque = Z_NULL; + zstream.next_in = NULL; + zstream.avail_in = 0; + zstream.next_out = outBuf; + zstream.avail_out = kBufSize; + zstream.data_type = Z_UNKNOWN; + + zerr = deflateInit2(&zstream, Z_BEST_COMPRESSION, + Z_DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY); + if (zerr != Z_OK) { + result = UNKNOWN_ERROR; + if (zerr == Z_VERSION_ERROR) { + ALOGE("Installed zlib is not compatible with linked version (%s)\n", + ZLIB_VERSION); + } else { + ALOGD("Call to deflateInit2 failed (zerr=%d)\n", zerr); + } + goto bail; + } + + crc = crc32(0L, Z_NULL, 0); + + /* + * Loop while we have data. + */ + do { + size_t getSize; + int flush; + + /* only read if the input buffer is empty */ + if (zstream.avail_in == 0 && !atEof) { + ALOGV("+++ reading %d bytes\n", (int)kBufSize); + if (data) { + getSize = size > kBufSize ? kBufSize : size; + memcpy(inBuf, data, getSize); + data = ((const char*)data) + getSize; + size -= getSize; + } else { + getSize = fread(inBuf, 1, kBufSize, srcFp); + if (ferror(srcFp)) { + ALOGD("deflate read failed (errno=%d)\n", errno); + goto z_bail; + } + } + if (getSize < kBufSize) { + ALOGV("+++ got %d bytes, EOF reached\n", + (int)getSize); + atEof = true; + } + + crc = crc32(crc, inBuf, getSize); + + zstream.next_in = inBuf; + zstream.avail_in = getSize; + } + + if (atEof) + flush = Z_FINISH; /* tell zlib that we're done */ + else + flush = Z_NO_FLUSH; /* more to come! */ + + zerr = deflate(&zstream, flush); + if (zerr != Z_OK && zerr != Z_STREAM_END) { + ALOGD("zlib deflate call failed (zerr=%d)\n", zerr); + result = UNKNOWN_ERROR; + goto z_bail; + } + + /* write when we're full or when we're done */ + if (zstream.avail_out == 0 || + (zerr == Z_STREAM_END && zstream.avail_out != (uInt) kBufSize)) + { + ALOGV("+++ writing %d bytes\n", (int) (zstream.next_out - outBuf)); + if (fwrite(outBuf, 1, zstream.next_out - outBuf, dstFp) != + (size_t)(zstream.next_out - outBuf)) + { + ALOGD("write %d failed in deflate\n", + (int) (zstream.next_out - outBuf)); + goto z_bail; + } + + zstream.next_out = outBuf; + zstream.avail_out = kBufSize; + } + } while (zerr == Z_OK); + + assert(zerr == Z_STREAM_END); /* other errors should've been caught */ + + *pCRC32 = crc; + +z_bail: + deflateEnd(&zstream); /* free up any allocated structures */ + +bail: + delete[] inBuf; + delete[] outBuf; + + return result; +} + +/* + * Mark an entry as deleted. + * + * We will eventually need to crunch the file down, but if several files + * are being removed (perhaps as part of an "update" process) we can make + * things considerably faster by deferring the removal to "flush" time. + */ +status_t ZipFile::remove(ZipEntry* pEntry) +{ + /* + * Should verify that pEntry is actually part of this archive, and + * not some stray ZipEntry from a different file. + */ + + /* mark entry as deleted, and mark archive as dirty */ + pEntry->setDeleted(); + mNeedCDRewrite = true; + return NO_ERROR; +} + +/* + * Flush any pending writes. + * + * In particular, this will crunch out deleted entries, and write the + * Central Directory and EOCD if we have stomped on them. + */ +status_t ZipFile::flush(void) +{ + status_t result = NO_ERROR; + long eocdPosn; + int i, count; + + if (mReadOnly) + return INVALID_OPERATION; + if (!mNeedCDRewrite) + return NO_ERROR; + + assert(mZipFp != NULL); + + result = crunchArchive(); + if (result != NO_ERROR) + return result; + + if (fseek(mZipFp, mEOCD.mCentralDirOffset, SEEK_SET) != 0) + return UNKNOWN_ERROR; + + count = mEntries.size(); + for (i = 0; i < count; i++) { + ZipEntry* pEntry = mEntries[i]; + pEntry->mCDE.write(mZipFp); + } + + eocdPosn = ftell(mZipFp); + mEOCD.mCentralDirSize = eocdPosn - mEOCD.mCentralDirOffset; + + mEOCD.write(mZipFp); + + /* + * If we had some stuff bloat up during compression and get replaced + * with plain files, or if we deleted some entries, there's a lot + * of wasted space at the end of the file. Remove it now. + */ + if (ftruncate(fileno(mZipFp), ftell(mZipFp)) != 0) { + ALOGW("ftruncate failed %ld: %s\n", ftell(mZipFp), strerror(errno)); + // not fatal + } + + /* should we clear the "newly added" flag in all entries now? */ + + mNeedCDRewrite = false; + return NO_ERROR; +} + +/* + * Crunch deleted files out of an archive by shifting the later files down. + * + * Because we're not using a temp file, we do the operation inside the + * current file. + */ +status_t ZipFile::crunchArchive(void) +{ + status_t result = NO_ERROR; + int i, count; + long delCount, adjust; + +#if 0 + printf("CONTENTS:\n"); + for (i = 0; i < (int) mEntries.size(); i++) { + printf(" %d: lfhOff=%ld del=%d\n", + i, mEntries[i]->getLFHOffset(), mEntries[i]->getDeleted()); + } + printf(" END is %ld\n", (long) mEOCD.mCentralDirOffset); +#endif + + /* + * Roll through the set of files, shifting them as appropriate. We + * could probably get a slight performance improvement by sliding + * multiple files down at once (because we could use larger reads + * when operating on batches of small files), but it's not that useful. + */ + count = mEntries.size(); + delCount = adjust = 0; + for (i = 0; i < count; i++) { + ZipEntry* pEntry = mEntries[i]; + long span; + + if (pEntry->getLFHOffset() != 0) { + long nextOffset; + + /* Get the length of this entry by finding the offset + * of the next entry. Directory entries don't have + * file offsets, so we need to find the next non-directory + * entry. + */ + nextOffset = 0; + for (int ii = i+1; nextOffset == 0 && ii < count; ii++) + nextOffset = mEntries[ii]->getLFHOffset(); + if (nextOffset == 0) + nextOffset = mEOCD.mCentralDirOffset; + span = nextOffset - pEntry->getLFHOffset(); + + assert(span >= ZipEntry::LocalFileHeader::kLFHLen); + } else { + /* This is a directory entry. It doesn't have + * any actual file contents, so there's no need to + * move anything. + */ + span = 0; + } + + //printf("+++ %d: off=%ld span=%ld del=%d [count=%d]\n", + // i, pEntry->getLFHOffset(), span, pEntry->getDeleted(), count); + + if (pEntry->getDeleted()) { + adjust += span; + delCount++; + + delete pEntry; + mEntries.erase(mEntries.begin() + i); + + /* adjust loop control */ + count--; + i--; + } else if (span != 0 && adjust > 0) { + /* shuffle this entry back */ + //printf("+++ Shuffling '%s' back %ld\n", + // pEntry->getFileName(), adjust); + result = filemove(mZipFp, pEntry->getLFHOffset() - adjust, + pEntry->getLFHOffset(), span); + if (result != NO_ERROR) { + /* this is why you use a temp file */ + ALOGE("error during crunch - archive is toast\n"); + return result; + } + + pEntry->setLFHOffset(pEntry->getLFHOffset() - adjust); + } + } + + /* + * Fix EOCD info. We have to wait until the end to do some of this + * because we use mCentralDirOffset to determine "span" for the + * last entry. + */ + mEOCD.mCentralDirOffset -= adjust; + mEOCD.mNumEntries -= delCount; + mEOCD.mTotalNumEntries -= delCount; + mEOCD.mCentralDirSize = 0; // mark invalid; set by flush() + + assert(mEOCD.mNumEntries == mEOCD.mTotalNumEntries); + assert(mEOCD.mNumEntries == count); + + return result; +} + +/* + * Works like memmove(), but on pieces of a file. + */ +status_t ZipFile::filemove(FILE* fp, off_t dst, off_t src, size_t n) +{ + if (dst == src || n <= 0) + return NO_ERROR; + + unsigned char readBuf[32768]; + + if (dst < src) { + /* shift stuff toward start of file; must read from start */ + while (n != 0) { + size_t getSize = sizeof(readBuf); + if (getSize > n) + getSize = n; + + if (fseek(fp, (long) src, SEEK_SET) != 0) { + ALOGD("filemove src seek %ld failed\n", (long) src); + return UNKNOWN_ERROR; + } + + if (fread(readBuf, 1, getSize, fp) != getSize) { + ALOGD("filemove read %ld off=%ld failed\n", + (long) getSize, (long) src); + return UNKNOWN_ERROR; + } + + if (fseek(fp, (long) dst, SEEK_SET) != 0) { + ALOGD("filemove dst seek %ld failed\n", (long) dst); + return UNKNOWN_ERROR; + } + + if (fwrite(readBuf, 1, getSize, fp) != getSize) { + ALOGD("filemove write %ld off=%ld failed\n", + (long) getSize, (long) dst); + return UNKNOWN_ERROR; + } + + src += getSize; + dst += getSize; + n -= getSize; + } + } else { + /* shift stuff toward end of file; must read from end */ + assert(false); // write this someday, maybe + return UNKNOWN_ERROR; + } + + return NO_ERROR; +} + + +/* + * Get the modification time from a file descriptor. + */ +time_t ZipFile::getModTime(int fd) +{ + struct stat sb; + + if (fstat(fd, &sb) < 0) { + ALOGD("HEY: fstat on fd %d failed\n", fd); + return (time_t) -1; + } + + return sb.st_mtime; +} + + +#if 0 /* this is a bad idea */ +/* + * Get a copy of the Zip file descriptor. + * + * We don't allow this if the file was opened read-write because we tend + * to leave the file contents in an uncertain state between calls to + * flush(). The duplicated file descriptor should only be valid for reads. + */ +int ZipFile::getZipFd(void) const +{ + if (!mReadOnly) + return INVALID_OPERATION; + assert(mZipFp != NULL); + + int fd; + fd = dup(fileno(mZipFp)); + if (fd < 0) { + ALOGD("didn't work, errno=%d\n", errno); + } + + return fd; +} +#endif + + +#if 0 +/* + * Expand data. + */ +bool ZipFile::uncompress(const ZipEntry* pEntry, void* buf) const +{ + return false; +} +#endif + +// free the memory when you're done +void* ZipFile::uncompress(const ZipEntry* entry) +{ + size_t unlen = entry->getUncompressedLen(); + size_t clen = entry->getCompressedLen(); + + void* buf = malloc(unlen); + if (buf == NULL) { + return NULL; + } + + fseek(mZipFp, 0, SEEK_SET); + + off_t offset = entry->getFileOffset(); + if (fseek(mZipFp, offset, SEEK_SET) != 0) { + goto bail; + } + + switch (entry->getCompressionMethod()) + { + case ZipEntry::kCompressStored: { + ssize_t amt = fread(buf, 1, unlen, mZipFp); + if (amt != (ssize_t)unlen) { + goto bail; + } +#if 0 + printf("data...\n"); + const unsigned char* p = (unsigned char*)buf; + const unsigned char* end = p+unlen; + for (int i=0; i<32 && p < end; i++) { + printf("0x%08x ", (int)(offset+(i*0x10))); + for (int j=0; j<0x10 && p < end; j++) { + printf(" %02x", *p); + p++; + } + printf("\n"); + } +#endif + + } + break; + case ZipEntry::kCompressDeflated: { + if (!ZipUtils::inflateToBuffer(mZipFp, buf, unlen, clen)) { + goto bail; + } + } + break; + default: + goto bail; + } + return buf; + +bail: + free(buf); + return NULL; +} + + +/* + * =========================================================================== + * ZipFile::EndOfCentralDir + * =========================================================================== + */ + +/* + * Read the end-of-central-dir fields. + * + * "buf" should be positioned at the EOCD signature, and should contain + * the entire EOCD area including the comment. + */ +status_t ZipFile::EndOfCentralDir::readBuf(const unsigned char* buf, int len) +{ + /* don't allow re-use */ + assert(mComment == NULL); + + if (len < kEOCDLen) { + /* looks like ZIP file got truncated */ + ALOGD(" Zip EOCD: expected >= %d bytes, found %d\n", + kEOCDLen, len); + return INVALID_OPERATION; + } + + /* this should probably be an assert() */ + if (ZipEntry::getLongLE(&buf[0x00]) != kSignature) + return UNKNOWN_ERROR; + + mDiskNumber = ZipEntry::getShortLE(&buf[0x04]); + mDiskWithCentralDir = ZipEntry::getShortLE(&buf[0x06]); + mNumEntries = ZipEntry::getShortLE(&buf[0x08]); + mTotalNumEntries = ZipEntry::getShortLE(&buf[0x0a]); + mCentralDirSize = ZipEntry::getLongLE(&buf[0x0c]); + mCentralDirOffset = ZipEntry::getLongLE(&buf[0x10]); + mCommentLen = ZipEntry::getShortLE(&buf[0x14]); + + // TODO: validate mCentralDirOffset + + if (mCommentLen > 0) { + if (kEOCDLen + mCommentLen > len) { + ALOGD("EOCD(%d) + comment(%d) exceeds len (%d)\n", + kEOCDLen, mCommentLen, len); + return UNKNOWN_ERROR; + } + mComment = new unsigned char[mCommentLen]; + memcpy(mComment, buf + kEOCDLen, mCommentLen); + } + + return NO_ERROR; +} + +/* + * Write an end-of-central-directory section. + */ +status_t ZipFile::EndOfCentralDir::write(FILE* fp) +{ + unsigned char buf[kEOCDLen]; + + ZipEntry::putLongLE(&buf[0x00], kSignature); + ZipEntry::putShortLE(&buf[0x04], mDiskNumber); + ZipEntry::putShortLE(&buf[0x06], mDiskWithCentralDir); + ZipEntry::putShortLE(&buf[0x08], mNumEntries); + ZipEntry::putShortLE(&buf[0x0a], mTotalNumEntries); + ZipEntry::putLongLE(&buf[0x0c], mCentralDirSize); + ZipEntry::putLongLE(&buf[0x10], mCentralDirOffset); + ZipEntry::putShortLE(&buf[0x14], mCommentLen); + + if (fwrite(buf, 1, kEOCDLen, fp) != kEOCDLen) + return UNKNOWN_ERROR; + if (mCommentLen > 0) { + assert(mComment != NULL); + if (fwrite(mComment, mCommentLen, 1, fp) != mCommentLen) + return UNKNOWN_ERROR; + } + + return NO_ERROR; +} + +/* + * Dump the contents of an EndOfCentralDir object. + */ +void ZipFile::EndOfCentralDir::dump(void) const +{ + ALOGD(" EndOfCentralDir contents:\n"); + ALOGD(" diskNum=%u diskWCD=%u numEnt=%u totalNumEnt=%u\n", + mDiskNumber, mDiskWithCentralDir, mNumEntries, mTotalNumEntries); + ALOGD(" centDirSize=%lu centDirOff=%lu commentLen=%u\n", + mCentralDirSize, mCentralDirOffset, mCommentLen); +} + +} // namespace aapt diff --git a/tools/aapt2/ZipFile.h b/tools/aapt2/ZipFile.h new file mode 100644 index 0000000..9de92dd --- /dev/null +++ b/tools/aapt2/ZipFile.h @@ -0,0 +1,278 @@ +/* + * Copyright (C) 2006 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. + */ + +// +// General-purpose Zip archive access. This class allows both reading and +// writing to Zip archives, including deletion of existing entries. +// +#ifndef __LIBS_ZIPFILE_H +#define __LIBS_ZIPFILE_H + +#include "BigBuffer.h" +#include "ZipEntry.h" + +#include <stdio.h> +#include <utils/Errors.h> +#include <vector> + +namespace aapt { + +using android::status_t; + +/* + * Manipulate a Zip archive. + * + * Some changes will not be visible in the until until "flush" is called. + * + * The correct way to update a file archive is to make all changes to a + * copy of the archive in a temporary file, and then unlink/rename over + * the original after everything completes. Because we're only interested + * in using this for packaging, we don't worry about such things. Crashing + * after making changes and before flush() completes could leave us with + * an unusable Zip archive. + */ +class ZipFile { +public: + ZipFile(void) + : mZipFp(NULL), mReadOnly(false), mNeedCDRewrite(false) + {} + ~ZipFile(void) { + if (!mReadOnly) + flush(); + if (mZipFp != NULL) + fclose(mZipFp); + discardEntries(); + } + + /* + * Open a new or existing archive. + */ + enum { + kOpenReadOnly = 0x01, + kOpenReadWrite = 0x02, + kOpenCreate = 0x04, // create if it doesn't exist + kOpenTruncate = 0x08, // if it exists, empty it + }; + status_t open(const char* zipFileName, int flags); + + /* + * Add a file to the end of the archive. Specify whether you want the + * library to try to store it compressed. + * + * If "storageName" is specified, the archive will use that instead + * of "fileName". + * + * If there is already an entry with the same name, the call fails. + * Existing entries with the same name must be removed first. + * + * If "ppEntry" is non-NULL, a pointer to the new entry will be returned. + */ + status_t add(const char* fileName, int compressionMethod, + ZipEntry** ppEntry) + { + return add(fileName, fileName, compressionMethod, ppEntry); + } + status_t add(const char* fileName, const char* storageName, + int compressionMethod, ZipEntry** ppEntry) + { + return addCommon(fileName, NULL, 0, storageName, + ZipEntry::kCompressStored, + compressionMethod, ppEntry); + } + + /* + * Add a file that is already compressed with gzip. + * + * If "ppEntry" is non-NULL, a pointer to the new entry will be returned. + */ + status_t addGzip(const char* fileName, const char* storageName, + ZipEntry** ppEntry) + { + return addCommon(fileName, NULL, 0, storageName, + ZipEntry::kCompressDeflated, + ZipEntry::kCompressDeflated, ppEntry); + } + + /* + * Add a file from an in-memory data buffer. + * + * If "ppEntry" is non-NULL, a pointer to the new entry will be returned. + */ + status_t add(const void* data, size_t size, const char* storageName, + int compressionMethod, ZipEntry** ppEntry) + { + return addCommon(NULL, data, size, storageName, + ZipEntry::kCompressStored, + compressionMethod, ppEntry); + } + + status_t add(const BigBuffer& data, const char* storageName, + int compressionMethod, ZipEntry** ppEntry); + + /* + * Add an entry by copying it from another zip file. If storageName is + * non-NULL, the entry will be inserted with the name storageName, otherwise + * it will have the same name as the source entry. If "padding" is + * nonzero, the specified number of bytes will be added to the "extra" + * field in the header. + * + * If "ppEntry" is non-NULL, a pointer to the new entry will be returned. + */ + status_t add(const ZipFile* pSourceZip, const ZipEntry* pSourceEntry, + const char* storageName, int padding, ZipEntry** ppEntry); + + /* + * Mark an entry as having been removed. It is not actually deleted + * from the archive or our internal data structures until flush() is + * called. + */ + status_t remove(ZipEntry* pEntry); + + /* + * Flush changes. If mNeedCDRewrite is set, this writes the central dir. + */ + status_t flush(void); + + /* + * Expand the data into the buffer provided. The buffer must hold + * at least <uncompressed len> bytes. Variation expands directly + * to a file. + * + * Returns "false" if an error was encountered in the compressed data. + */ + //bool uncompress(const ZipEntry* pEntry, void* buf) const; + //bool uncompress(const ZipEntry* pEntry, FILE* fp) const; + void* uncompress(const ZipEntry* pEntry); + + /* + * Get an entry, by name. Returns NULL if not found. + * + * Does not return entries pending deletion. + */ + ZipEntry* getEntryByName(const char* fileName) const; + + /* + * Get the Nth entry in the archive. + * + * This will return an entry that is pending deletion. + */ + int getNumEntries(void) const { return mEntries.size(); } + ZipEntry* getEntryByIndex(int idx) const; + +private: + /* these are private and not defined */ + ZipFile(const ZipFile& src); + ZipFile& operator=(const ZipFile& src); + + class EndOfCentralDir { + public: + EndOfCentralDir(void) : + mDiskNumber(0), + mDiskWithCentralDir(0), + mNumEntries(0), + mTotalNumEntries(0), + mCentralDirSize(0), + mCentralDirOffset(0), + mCommentLen(0), + mComment(NULL) + {} + virtual ~EndOfCentralDir(void) { + delete[] mComment; + } + + status_t readBuf(const unsigned char* buf, int len); + status_t write(FILE* fp); + + //unsigned long mSignature; + unsigned short mDiskNumber; + unsigned short mDiskWithCentralDir; + unsigned short mNumEntries; + unsigned short mTotalNumEntries; + unsigned long mCentralDirSize; + unsigned long mCentralDirOffset; // offset from first disk + unsigned short mCommentLen; + unsigned char* mComment; + + enum { + kSignature = 0x06054b50, + kEOCDLen = 22, // EndOfCentralDir len, excl. comment + + kMaxCommentLen = 65535, // longest possible in ushort + kMaxEOCDSearch = kMaxCommentLen + EndOfCentralDir::kEOCDLen, + + }; + + void dump(void) const; + }; + + + /* read all entries in the central dir */ + status_t readCentralDir(void); + + /* crunch deleted entries out */ + status_t crunchArchive(void); + + /* clean up mEntries */ + void discardEntries(void); + + /* common handler for all "add" functions */ + status_t addCommon(const char* fileName, const void* data, size_t size, + const char* storageName, int sourceType, int compressionMethod, + ZipEntry** ppEntry); + + /* copy all of "srcFp" into "dstFp" */ + status_t copyFpToFp(FILE* dstFp, FILE* srcFp, unsigned long* pCRC32); + /* copy all of "data" into "dstFp" */ + status_t copyDataToFp(FILE* dstFp, + const void* data, size_t size, unsigned long* pCRC32); + /* copy some of "srcFp" into "dstFp" */ + status_t copyPartialFpToFp(FILE* dstFp, FILE* srcFp, long length, + unsigned long* pCRC32); + /* like memmove(), but on parts of a single file */ + status_t filemove(FILE* fp, off_t dest, off_t src, size_t n); + /* compress all of "srcFp" into "dstFp", using Deflate */ + status_t compressFpToFp(FILE* dstFp, FILE* srcFp, + const void* data, size_t size, unsigned long* pCRC32); + + /* get modification date from a file descriptor */ + time_t getModTime(int fd); + + /* + * We use stdio FILE*, which gives us buffering but makes dealing + * with files >2GB awkward. Until we support Zip64, we're fine. + */ + FILE* mZipFp; // Zip file pointer + + /* one of these per file */ + EndOfCentralDir mEOCD; + + /* did we open this read-only? */ + bool mReadOnly; + + /* set this when we trash the central dir */ + bool mNeedCDRewrite; + + /* + * One ZipEntry per entry in the zip file. I'm using pointers instead + * of objects because it's easier than making operator= work for the + * classes and sub-classes. + */ + std::vector<ZipEntry*> mEntries; +}; + +}; // namespace aapt + +#endif // __LIBS_ZIPFILE_H diff --git a/tools/aapt2/data/AndroidManifest.xml b/tools/aapt2/data/AndroidManifest.xml new file mode 100644 index 0000000..8533c28 --- /dev/null +++ b/tools/aapt2/data/AndroidManifest.xml @@ -0,0 +1,7 @@ +<?xml version="1.0" encoding="utf-8"?> +<manifest xmlns:android="http://schemas.android.com/apk/res/android" + package="com.android.app"> + <application + android:name=".Activity"> + </application> +</manifest> diff --git a/tools/aapt2/data/Makefile b/tools/aapt2/data/Makefile new file mode 100644 index 0000000..3387135 --- /dev/null +++ b/tools/aapt2/data/Makefile @@ -0,0 +1,83 @@ +## +# Environment dependent variables +## + +AAPT := aapt2 +ZIPALIGN := zipalign -f 4 +FRAMEWORK := ../../../../../out/target/common/obj/APPS/framework-res_intermediates/package-export.apk + +## +# Project depenedent variables +## + +LOCAL_PACKAGE := com.android.app +LOCAL_RESOURCE_DIR := res +LOCAL_LIBS := lib/out/package.apk +LOCAL_OUT := out +LOCAL_GEN := out/gen +LOCAL_PROGUARD := out/proguard.rule + +## +# AAPT2 custom rules. +## + +PRIVATE_APK_UNALIGNED := $(LOCAL_OUT)/package-unaligned.apk +PRIVATE_APK_ALIGNED := $(LOCAL_OUT)/package.apk + +# Eg: framework.apk, etc. +PRIVATE_INCLUDES := $(FRAMEWORK) +$(info PRIVATE_INCLUDES = $(PRIVATE_INCLUDES)) + +# Eg: gen/com/android/app/R.java +PRIVATE_R_JAVA := $(LOCAL_GEN)/$(subst .,/,$(LOCAL_PACKAGE))/R.java +$(info PRIVATE_R_JAVA = $(PRIVATE_R_JAVA)) + +# Eg: res/drawable/icon.png, res/values/styles.xml +PRIVATE_RESOURCES := $(shell find $(LOCAL_RESOURCE_DIR) -mindepth 1 -maxdepth 2 -type f) +$(info PRIVATE_RESOURCES = $(PRIVATE_RESOURCES)) + +# Eg: drawable, values, layouts +PRIVATE_RESOURCE_TYPES := \ + $(patsubst $(LOCAL_RESOURCE_DIR)/%/,%,$(sort $(dir $(PRIVATE_RESOURCES)))) +$(info PRIVATE_RESOURCE_TYPES = $(PRIVATE_RESOURCE_TYPES)) + +# Eg: out/values-v4.apk, out/drawable-xhdpi.apk +PRIVATE_INTERMEDIATE_TABLES := $(patsubst %,$(LOCAL_OUT)/%.apk,$(PRIVATE_RESOURCE_TYPES)) +$(info PRIVATE_INTERMEDIATE_TABLES = $(PRIVATE_INTERMEDIATE_TABLES)) + +# Generates rules for collect phase. +# $1: Resource type (values-v4) +# returns: out/values-v4.apk: res/values-v4/styles.xml res/values-v4/colors.xml +define make-collect-rule +$(LOCAL_OUT)/$1.apk: $(filter $(LOCAL_RESOURCE_DIR)/$1/%,$(PRIVATE_RESOURCES)) + $(AAPT) compile --package $(LOCAL_PACKAGE) -o $$@ $$^ +endef + +# Collect: out/values-v4.apk <- res/values-v4/styles.xml res/values-v4/colors.xml +$(foreach d,$(PRIVATE_RESOURCE_TYPES),$(eval $(call make-collect-rule,$d))) + +# Link: out/package-unaligned.apk <- out/values-v4.apk out/drawable-v4.apk +$(PRIVATE_APK_UNALIGNED): $(PRIVATE_INTERMEDIATE_TABLES) $(PRIVATE_INCLUDES) $(LOCAL_LIBS) AndroidManifest.xml + $(AAPT) link --manifest AndroidManifest.xml $(addprefix -I ,$(PRIVATE_INCLUDES)) --java $(LOCAL_GEN) -o $@ $(PRIVATE_INTERMEDIATE_TABLES) $(LOCAL_LIBS) --proguard $(LOCAL_PROGUARD) -v + +# R.java: gen/com/android/app/R.java <- out/resources.arsc +# No action since R.java is generated when out/resources.arsc is. +$(PRIVATE_R_JAVA): $(PRIVATE_APK_UNALIGNED) + +# Assemble: zip out/resources.arsc AndroidManifest.xml and res/**/* +$(PRIVATE_APK_ALIGNED): $(PRIVATE_APK_UNALIGNED) + $(ZIPALIGN) $< $@ + +# Create the out directory if needed. +dummy := $(shell test -d $(LOCAL_OUT) || mkdir -p $(LOCAL_OUT)) + +.PHONY: java +java: $(PRIVATE_R_JAVA) + +.PHONY: assemble +assemble: $(PRIVATE_APK_ALIGNED) + +.PHONY: all +all: assemble java + +.DEFAULT_GOAL := all diff --git a/tools/aapt2/data/lib/AndroidManifest.xml b/tools/aapt2/data/lib/AndroidManifest.xml new file mode 100644 index 0000000..08b468e --- /dev/null +++ b/tools/aapt2/data/lib/AndroidManifest.xml @@ -0,0 +1,6 @@ +<?xml version="1.0" encoding="utf-8"?> +<manifest xmlns:android="http://schemas.android.com/apk/res/android" + package="android.appcompat"> + + <uses-feature android:name="bloooop" /> +</manifest> diff --git a/tools/aapt2/data/lib/Makefile b/tools/aapt2/data/lib/Makefile new file mode 100644 index 0000000..372c225 --- /dev/null +++ b/tools/aapt2/data/lib/Makefile @@ -0,0 +1,81 @@ +## +# Environment dependent variables +## + +AAPT := aapt2 +ZIPALIGN := zipalign -f 4 +FRAMEWORK := ../../../../../../out/target/common/obj/APPS/framework-res_intermediates/package-export.apk + +## +# Project depenedent variables +## + +LOCAL_PACKAGE := android.appcompat +LOCAL_RESOURCE_DIR := res +LOCAL_OUT := out +LOCAL_GEN := out/gen + +## +# AAPT2 custom rules. +## + +PRIVATE_APK_UNALIGNED := $(LOCAL_OUT)/package-unaligned.apk +PRIVATE_APK_ALIGNED := $(LOCAL_OUT)/package.apk + +# Eg: framework.apk, etc. +PRIVATE_LIBS := $(FRAMEWORK) +$(info PRIVATE_LIBS = $(PRIVATE_LIBS)) + +# Eg: gen/com/android/app/R.java +PRIVATE_R_JAVA := $(LOCAL_GEN)/$(subst .,/,$(LOCAL_PACKAGE))/R.java +$(info PRIVATE_R_JAVA = $(PRIVATE_R_JAVA)) + +# Eg: res/drawable/icon.png, res/values/styles.xml +PRIVATE_RESOURCES := $(shell find $(LOCAL_RESOURCE_DIR) -mindepth 1 -maxdepth 2 -type f) +$(info PRIVATE_RESOURCES = $(PRIVATE_RESOURCES)) + +# Eg: drawable, values, layouts +PRIVATE_RESOURCE_TYPES := \ + $(patsubst $(LOCAL_RESOURCE_DIR)/%/,%,$(sort $(dir $(PRIVATE_RESOURCES)))) +$(info PRIVATE_RESOURCE_TYPES = $(PRIVATE_RESOURCE_TYPES)) + +# Eg: out/values-v4.apk, out/drawable-xhdpi.apk +PRIVATE_INTERMEDIATE_TABLES := $(patsubst %,$(LOCAL_OUT)/%.apk,$(PRIVATE_RESOURCE_TYPES)) +$(info PRIVATE_INTERMEDIATE_TABLES = $(PRIVATE_INTERMEDIATE_TABLES)) + +# Generates rules for collect phase. +# $1: Resource type (values-v4) +# returns: out/values-v4.apk: res/values-v4/styles.xml res/values-v4/colors.xml +define make-collect-rule +$(LOCAL_OUT)/$1.apk: $(filter $(LOCAL_RESOURCE_DIR)/$1/%,$(PRIVATE_RESOURCES)) + $(AAPT) compile --package $(LOCAL_PACKAGE) -o $$@ $$^ +endef + +# Collect: out/values-v4.apk <- res/values-v4/styles.xml res/values-v4/colors.xml +$(foreach d,$(PRIVATE_RESOURCE_TYPES),$(eval $(call make-collect-rule,$d))) + +# Link: out/package-unaligned.apk <- out/values-v4.apk out/drawable-v4.apk +$(PRIVATE_APK_UNALIGNED): $(PRIVATE_INTERMEDIATE_TABLES) $(PRIVATE_LIBS) AndroidManifest.xml + $(AAPT) link --manifest AndroidManifest.xml $(addprefix -I ,$(PRIVATE_LIBS)) --java $(LOCAL_GEN) -o $@ $(PRIVATE_INTERMEDIATE_TABLES) --static-lib + +# R.java: gen/com/android/app/R.java <- out/resources.arsc +# No action since R.java is generated when out/resources.arsc is. +$(PRIVATE_R_JAVA): $(PRIVATE_APK_UNALIGNED) + +# Assemble: zip out/resources.arsc AndroidManifest.xml and res/**/* +$(PRIVATE_APK_ALIGNED): $(PRIVATE_APK_UNALIGNED) + $(ZIPALIGN) $< $@ + +# Create the out directory if needed. +dummy := $(shell test -d $(LOCAL_OUT) || mkdir -p $(LOCAL_OUT)) + +.PHONY: java +java: $(PRIVATE_R_JAVA) + +.PHONY: assemble +assemble: $(PRIVATE_APK_ALIGNED) + +.PHONY: all +all: assemble java + +.DEFAULT_GOAL := all diff --git a/tools/aapt2/data/lib/res/layout/main.xml b/tools/aapt2/data/lib/res/layout/main.xml new file mode 100644 index 0000000..187ed2d --- /dev/null +++ b/tools/aapt2/data/lib/res/layout/main.xml @@ -0,0 +1,4 @@ +<?xml version="1.0" encoding="utf-8"?> +<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" + android:layout_width="match_parent" + android:layout_height="match_parent"/> diff --git a/tools/aapt2/data/lib/res/raw/hello.txt b/tools/aapt2/data/lib/res/raw/hello.txt new file mode 100644 index 0000000..44fc22b --- /dev/null +++ b/tools/aapt2/data/lib/res/raw/hello.txt @@ -0,0 +1 @@ +Oh howdy there diff --git a/tools/aapt2/data/lib/res/values/styles.xml b/tools/aapt2/data/lib/res/values/styles.xml new file mode 100644 index 0000000..4ce6333 --- /dev/null +++ b/tools/aapt2/data/lib/res/values/styles.xml @@ -0,0 +1,8 @@ +<?xml version="1.0" encoding="utf-8"?> +<resources> + <style name="Platform.AppCompat" parent="@android:style/Theme"> + <item name="android:windowNoTitle">true</item> + </style> + + <bool name="allow">true</bool> +</resources> diff --git a/tools/aapt2/data/res/drawable/icon.png b/tools/aapt2/data/res/drawable/icon.png Binary files differnew file mode 100644 index 0000000..4bff9b9 --- /dev/null +++ b/tools/aapt2/data/res/drawable/icon.png diff --git a/tools/aapt2/data/res/drawable/image.xml b/tools/aapt2/data/res/drawable/image.xml new file mode 100644 index 0000000..9b38739 --- /dev/null +++ b/tools/aapt2/data/res/drawable/image.xml @@ -0,0 +1,2 @@ +<?xml version="1.0" encoding="utf-8"?> +<vector /> diff --git a/tools/aapt2/data/res/drawable/test.9.png b/tools/aapt2/data/res/drawable/test.9.png Binary files differnew file mode 100644 index 0000000..33daa11 --- /dev/null +++ b/tools/aapt2/data/res/drawable/test.9.png diff --git a/tools/aapt2/data/res/layout/main.xml b/tools/aapt2/data/res/layout/main.xml new file mode 100644 index 0000000..50a51d9 --- /dev/null +++ b/tools/aapt2/data/res/layout/main.xml @@ -0,0 +1,21 @@ +<?xml version="1.0" encoding="utf-8"?> +<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" + xmlns:support="http://schemas.android.com/apk/res/android.appcompat" + android:id="@+id/view" + android:layout_width="match_parent" + android:layout_height="wrap_content"> + + <fragment class="android.test.sample.App$Inner" /> + + <variable name="user" type="com.android.User" /> + + <View xmlns:app="http://schemas.android.com/apk/res-auto" + android:id="@+id/me" + android:layout_width="1dp" + android:onClick="doClick" + android:text="@{user.name}" + android:layout_height="match_parent" + app:layout_width="@support:bool/allow" + app:flags="complex|weak" + android:colorAccent="#ffffff"/> +</LinearLayout> diff --git a/tools/aapt2/data/res/values-v4/styles.xml b/tools/aapt2/data/res/values-v4/styles.xml new file mode 100644 index 0000000..979a82a --- /dev/null +++ b/tools/aapt2/data/res/values-v4/styles.xml @@ -0,0 +1,7 @@ +<?xml version="1.0" encoding="utf-8"?> +<resources> + <style name="App" parent="android:Theme.Material"> + <item name="android:colorAccent">@color/accent</item> + <item name="android:text">Hey</item> + </style> +</resources> diff --git a/tools/aapt2/data/res/values/colors.xml b/tools/aapt2/data/res/values/colors.xml new file mode 100644 index 0000000..89db5fb --- /dev/null +++ b/tools/aapt2/data/res/values/colors.xml @@ -0,0 +1,6 @@ +<?xml version="1.0" encoding="utf-8"?> +<resources> + <color name="primary">#f44336</color> + <color name="primary_dark">#b71c1c</color> + <color name="accent">#fdd835</color> +</resources> diff --git a/tools/aapt2/data/res/values/styles.xml b/tools/aapt2/data/res/values/styles.xml new file mode 100644 index 0000000..d0b19a3 --- /dev/null +++ b/tools/aapt2/data/res/values/styles.xml @@ -0,0 +1,25 @@ +<?xml version="1.0" encoding="utf-8"?> +<resources xmlns:lib="http://schemas.android.com/apk/res/android.appcompat"> + <style name="App" parent="android.appcompat:Platform.AppCompat"> + <item name="android:background">@color/primary</item> + <item name="android:colorPrimary">@color/primary</item> + <item name="android:colorPrimaryDark">@color/primary_dark</item> + <item name="android:colorAccent">@color/accent</item> + </style> + <attr name="custom" format="reference" /> + <style name="Pop"> + <item name="custom">@drawable/image</item> + <item name="android:focusable">@lib:bool/allow</item> + </style> + <string name="yo">@string/wow</string> + + <declare-styleable name="View"> + <attr name="custom" /> + <attr name="decor"> + <enum name="no-border" value="0"/> + <enum name="border" value="1"/> + <enum name="shadow" value="2"/> + </attr> + </declare-styleable> + +</resources> diff --git a/tools/aapt2/data/res/values/test.xml b/tools/aapt2/data/res/values/test.xml new file mode 100644 index 0000000..d3ead34 --- /dev/null +++ b/tools/aapt2/data/res/values/test.xml @@ -0,0 +1,13 @@ +<?xml version="1.0" encoding="utf-8"?> +<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2"> + <string name="hooha"><font bgcolor="#ffffff">Hey guys!</font> <xliff:g>My</xliff:g> name is <b>Adam</b>. How <b><i>are</i></b> you?</string> + <public name="hooha" type="string" id="0x7f020001"/> + <string name="wow">@android:string/ok</string> + <public name="image" type="drawable" id="0x7f060000" /> + <attr name="layout_width" format="boolean" /> + <attr name="flags"> + <flag name="complex" value="1" /> + <flag name="pub" value="2" /> + <flag name="weak" value="4" /> + </attr> +</resources> diff --git a/tools/aapt2/data/resources.arsc b/tools/aapt2/data/resources.arsc Binary files differnew file mode 100644 index 0000000..6a416df --- /dev/null +++ b/tools/aapt2/data/resources.arsc diff --git a/tools/aapt2/data/resources_base.arsc b/tools/aapt2/data/resources_base.arsc Binary files differnew file mode 100644 index 0000000..f9d0610 --- /dev/null +++ b/tools/aapt2/data/resources_base.arsc diff --git a/tools/aapt2/data/resources_hdpi.arsc b/tools/aapt2/data/resources_hdpi.arsc Binary files differnew file mode 100644 index 0000000..97232a3 --- /dev/null +++ b/tools/aapt2/data/resources_hdpi.arsc diff --git a/tools/aapt2/process.dot b/tools/aapt2/process.dot new file mode 100644 index 0000000..4741952 --- /dev/null +++ b/tools/aapt2/process.dot @@ -0,0 +1,108 @@ +digraph aapt { + out_package [label="out/default/package.apk"]; + out_fr_package [label="out/fr/package.apk"]; + out_table_aligned [label="out/default/resources-aligned.arsc"]; + out_table_fr_aligned [label="out/fr/resources-aligned.arsc"]; + out_res_layout_main_xml [label="out/res/layout/main.xml"]; + out_res_layout_v21_main_xml [color=red,label="out/res/layout-v21/main.xml"]; + out_res_layout_fr_main_xml [label="out/res/layout-fr/main.xml"]; + out_res_layout_fr_v21_main_xml [color=red,label="out/res/layout-fr-v21/main.xml"]; + out_table [label="out/default/resources.arsc"]; + out_fr_table [label="out/fr/resources.arsc"]; + out_values_table [label="out/values/resources.arsc"]; + out_layout_table [label="out/layout/resources.arsc"]; + out_values_fr_table [label="out/values-fr/resources.arsc"]; + out_layout_fr_table [label="out/layout-fr/resources.arsc"]; + res_values_strings_xml [label="res/values/strings.xml"]; + res_values_attrs_xml [label="res/values/attrs.xml"]; + res_layout_main_xml [label="res/layout/main.xml"]; + res_layout_fr_main_xml [label="res/layout-fr/main.xml"]; + res_values_fr_strings_xml [label="res/values-fr/strings.xml"]; + + lib_apk_resources_arsc [label="lib.apk:resources.arsc",color=green]; + lib_apk_res_layout_main_xml [label="lib.apk:res/layout/main.xml",color=green]; + lib_apk_res_drawable_icon_png [label="lib.apk:res/drawable/icon.png",color=green]; + lib_apk_fr_res_layout_main_xml [label="lib.apk:res/layout-fr/main.xml",color=green]; + lib_apk_fr_res_drawable_icon_png [label="lib.apk:res/drawable-fr/icon.png",color=green]; + out_res_layout_lib_main_xml [label="out/res/layout/lib-main.xml"]; + + out_package -> package_default; + out_fr_package -> package_fr; + + package_default [shape=box,label="Assemble",color=blue]; + package_default -> out_table_aligned; + package_default -> out_res_layout_main_xml; + package_default -> out_res_layout_v21_main_xml [color=red]; + package_default -> out_res_layout_lib_main_xml; + + package_fr [shape=box,label="Assemble",color=blue]; + package_fr -> out_table_fr_aligned; + package_fr -> out_res_layout_fr_main_xml; + package_fr -> out_res_layout_fr_v21_main_xml [color=red]; + + out_table_aligned -> align_tables; + out_table_fr_aligned -> align_tables; + + align_tables [shape=box,label="Align",color=blue]; + align_tables -> out_table; + align_tables -> out_fr_table; + + out_table -> link_tables; + + link_tables [shape=box,label="Link",color=blue]; + link_tables -> out_values_table; + link_tables -> out_layout_table; + link_tables -> lib_apk_resources_arsc; + + out_values_table -> compile_values; + + compile_values [shape=box,label="Collect",color=blue]; + compile_values -> res_values_strings_xml; + compile_values -> res_values_attrs_xml; + + out_layout_table -> collect_xml; + + collect_xml [shape=box,label="Collect",color=blue]; + collect_xml -> res_layout_main_xml; + + out_fr_table -> link_fr_tables; + + link_fr_tables [shape=box,label="Link",color=blue]; + link_fr_tables -> out_values_fr_table; + link_fr_tables -> out_layout_fr_table; + link_fr_tables -> lib_apk_resources_arsc; + + out_values_fr_table -> compile_values_fr; + + compile_values_fr [shape=box,label="Collect",color=blue]; + compile_values_fr -> res_values_fr_strings_xml; + + out_layout_fr_table -> collect_xml_fr; + + collect_xml_fr [shape=box,label="Collect",color=blue]; + collect_xml_fr -> res_layout_fr_main_xml; + + compile_res_layout_main_xml [shape=box,label="Compile",color=blue]; + + out_res_layout_main_xml -> compile_res_layout_main_xml; + + out_res_layout_v21_main_xml -> compile_res_layout_main_xml [color=red]; + + compile_res_layout_main_xml -> res_layout_main_xml; + compile_res_layout_main_xml -> out_table_aligned; + + compile_res_layout_fr_main_xml [shape=box,label="Compile",color=blue]; + + out_res_layout_fr_main_xml -> compile_res_layout_fr_main_xml; + + out_res_layout_fr_v21_main_xml -> compile_res_layout_fr_main_xml [color=red]; + + compile_res_layout_fr_main_xml -> res_layout_fr_main_xml; + compile_res_layout_fr_main_xml -> out_table_fr_aligned; + + out_res_layout_lib_main_xml -> compile_res_layout_lib_main_xml; + + compile_res_layout_lib_main_xml [shape=box,label="Compile",color=blue]; + compile_res_layout_lib_main_xml -> out_table_aligned; + compile_res_layout_lib_main_xml -> lib_apk_res_layout_main_xml; +} diff --git a/tools/aapt2/public_attr_map.py b/tools/aapt2/public_attr_map.py new file mode 100644 index 0000000..92136a8 --- /dev/null +++ b/tools/aapt2/public_attr_map.py @@ -0,0 +1,55 @@ +#!/usr/bin/env python + +import sys +import xml.etree.ElementTree as ET + +def findSdkLevelForAttribute(id): + intId = int(id, 16) + packageId = 0x000000ff & (intId >> 24) + typeId = 0x000000ff & (intId >> 16) + entryId = 0x0000ffff & intId + + if packageId != 0x01 or typeId != 0x01: + return 0 + + levels = [(1, 0x021c), (2, 0x021d), (3, 0x0269), (4, 0x028d), + (5, 0x02ad), (6, 0x02b3), (7, 0x02b5), (8, 0x02bd), + (9, 0x02cb), (11, 0x0361), (12, 0x0366), (13, 0x03a6), + (16, 0x03ae), (17, 0x03cc), (18, 0x03da), (19, 0x03f1), + (20, 0x03f6), (21, 0x04ce)] + for level, attrEntryId in levels: + if entryId <= attrEntryId: + return level + return 22 + + +tree = None +with open(sys.argv[1], 'rt') as f: + tree = ET.parse(f) + +attrs = [] +for node in tree.iter('public'): + if node.get('type') == 'attr': + sdkLevel = findSdkLevelForAttribute(node.get('id', '0')) + if sdkLevel > 1 and sdkLevel < 22: + attrs.append("{{ u\"{}\", {} }}".format(node.get('name'), sdkLevel)) + +print "#include <string>" +print "#include <unordered_map>" +print +print "namespace aapt {" +print +print "static std::unordered_map<std::u16string, size_t> sAttrMap = {" +print ",\n ".join(attrs) +print "};" +print +print "size_t findAttributeSdkLevel(const std::u16string& name) {" +print " auto iter = sAttrMap.find(name);" +print " if (iter != sAttrMap.end()) {" +print " return iter->second;" +print " }" +print " return 0;" +print "}" +print +print "} // namespace aapt" +print diff --git a/tools/aapt2/todo.txt b/tools/aapt2/todo.txt new file mode 100644 index 0000000..acc8bfb --- /dev/null +++ b/tools/aapt2/todo.txt @@ -0,0 +1,29 @@ +XML Files +X Collect declared IDs +X Build StringPool +X Flatten + +Resource Table Operations +X Build Resource Table (with StringPool) from XML. +X Modify Resource Table. +X - Copy and transform resources. +X - Pre-17/21 attr correction. +X Perform analysis of types. +X Flatten. +X Assign resource IDs. +X Assign public resource IDs. +X Merge resource tables +- Assign private attributes to different typespace. +- Align resource tables + +Splits +- Collect all resources (ids from layouts). +- Generate resource table from base resources. +- Generate resource table from individual resources of the required type. +- Align resource tables (same type/name = same ID). + +Fat Apk +X Collect all resources (ids from layouts). +X Generate resource tables for all configurations. +- Align individual resource tables. +- Merge resource tables. |
