Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

AAPT2: Add Inline Complex XML support

Browse Source 
See: https://developer.android.com/guide/topics/resources/complex-xml-resources.html

Change-Id: I8274c85e25cabf90423141c228697e873167d136
This commit is contained in:
Adam Lesinski
2016-08-25 12:26:56 -07:00
parent 79758c8e77
commit 5eeaaddffd
29 changed files with 1162 additions and 364 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
tools/aapt2/Android.mk
View File

@@ -23,6 +23,7 @@ LOCAL_PATH:= $(call my-dir)
main := Main.cpp
sources := \
compile/IdAssigner.cpp \
compile/InlineXmlFormatParser.cpp \
compile/Png.cpp \
compile/PseudolocaleGenerator.cpp \
compile/Pseudolocalizer.cpp \
@@ -31,6 +32,7 @@ sources := \
flatten/Archive.cpp \
flatten/TableFlattener.cpp \
flatten/XmlFlattener.cpp \
io/File.cpp \
io/FileSystem.cpp \
io/ZipArchive.cpp \
link/AutoVersioner.cpp \
@@ -77,6 +79,7 @@ sources += Format.proto
testSources := \
compile/IdAssigner_test.cpp \
compile/InlineXmlFormatParser_test.cpp \
compile/PseudolocaleGenerator_test.cpp \
compile/Pseudolocalizer_test.cpp \
compile/XmlIdCollector_test.cpp \

54
tools/aapt2/Debug.cpp
View File

@@ -247,5 +247,59 @@ void Debug::dumpHex(const void* data, size_t len) {
}
}
namespace {
class XmlPrinter : public xml::Visitor {
public:
using xml::Visitor::visit;
void visit(xml::Element* el) override {
std::cerr << mPrefix;
std::cerr << "E: ";
if (!el->namespaceUri.empty()) {
std::cerr << el->namespaceUri << ":";
}
std::cerr << el->name << " (line=" << el->lineNumber << ")\n";
for (const xml::Attribute& attr : el->attributes) {
std::cerr << mPrefix << " A: ";
if (!attr.namespaceUri.empty()) {
std::cerr << attr.namespaceUri << ":";
}
std::cerr << attr.name << "=" << attr.value << "\n";
}
const size_t previousSize = mPrefix.size();
mPrefix += " ";
xml::Visitor::visit(el);
mPrefix.resize(previousSize);
}
void visit(xml::Namespace* ns) override {
std::cerr << mPrefix;
std::cerr << "N: " << ns->namespacePrefix << "=" << ns->namespaceUri
<< " (line=" << ns->lineNumber << ")\n";
const size_t previousSize = mPrefix.size();
mPrefix += " ";
xml::Visitor::visit(ns);
mPrefix.resize(previousSize);
}
void visit(xml::Text* text) override {
std::cerr << mPrefix;
std::cerr << "T: '" << text->text << "'\n";
}
private:
std::string mPrefix;
};
} // namespace
void Debug::dumpXml(xml::XmlResource* doc) {
XmlPrinter printer;
doc->root->accept(&printer);
}
} // namespace aapt

2
tools/aapt2/Debug.h
View File

@@ -19,6 +19,7 @@
#include "Resource.h"
#include "ResourceTable.h"
#include "xml/XmlDom.h"
// Include for printf-like debugging.
#include <iostream>
@@ -34,6 +35,7 @@ struct Debug {
static void printStyleGraph(ResourceTable* table,
const ResourceName& targetStyle);
static void dumpHex(const void* data, size_t len);
static void dumpXml(xml::XmlResource* doc);
};
} // namespace aapt

2
tools/aapt2/Format.proto
View File

@@ -34,7 +34,7 @@ message CompiledFile {
optional string resource_name = 1;
optional uint32 line_no = 2;
}
optional string resource_name = 1;
optional ConfigDescription config = 2;
optional string source_path = 3;

33
tools/aapt2/ResourceParser.cpp
View File

@@ -925,35 +925,6 @@ Maybe<Attribute::Symbol> ResourceParser::parseEnumOrFlagItem(xml::XmlPullParser*
Reference(ResourceNameRef({}, ResourceType::kId, maybeName.value())), val.data };
}
static Maybe<Reference> parseXmlAttributeName(StringPiece str) {
str = util::trimWhitespace(str);
const char* start = str.data();
const char* const end = start + str.size();
const char* p = start;
Reference ref;
if (p != end && *p == '*') {
ref.privateReference = true;
start++;
p++;
}
StringPiece package;
StringPiece name;
while (p != end) {
if (*p == ':') {
package = StringPiece(start, p - start);
name = StringPiece(p + 1, end - (p + 1));
break;
}
p++;
}
ref.name = ResourceName(package.toString(), ResourceType::kAttr,
name.empty() ? str.toString() : name.toString());
return Maybe<Reference>(std::move(ref));
}
bool ResourceParser::parseStyleItem(xml::XmlPullParser* parser, Style* style) {
const Source source = mSource.withLine(parser->getLineNumber());
@@ -963,7 +934,7 @@ bool ResourceParser::parseStyleItem(xml::XmlPullParser* parser, Style* style) {
return false;
}
Maybe<Reference> maybeKey = parseXmlAttributeName(maybeName.value());
Maybe<Reference> maybeKey = ResourceUtils::parseXmlAttributeName(maybeName.value());
if (!maybeKey) {
mDiag->error(DiagMessage(source) << "invalid attribute name '" << maybeName.value() << "'");
return false;
@@ -1226,7 +1197,7 @@ bool ResourceParser::parseDeclareStyleable(xml::XmlPullParser* parser,
// If this is a declaration, the package name may be in the name. Separate these out.
// Eg. <attr name="android:text" />
Maybe<Reference> maybeRef = parseXmlAttributeName(maybeName.value());
Maybe<Reference> maybeRef = ResourceUtils::parseXmlAttributeName(maybeName.value());
if (!maybeRef) {
mDiag->error(DiagMessage(itemSource) << "<attr> tag has invalid name '"
<< maybeName.value() << "'");

2
tools/aapt2/ResourceTable.cpp
View File

@@ -327,7 +327,7 @@ bool ResourceTable::addFileReferenceImpl(const ResourceNameRef& name,
fileRef->setSource(source);
fileRef->file = file;
return addResourceImpl(name, ResourceId{}, config, StringPiece{}, std::move(fileRef),
kValidNameChars, resolveValueCollision, diag);
validChars, resolveValueCollision, diag);
}
bool ResourceTable::addResourceAllowMangled(const ResourceNameRef& name,

16
tools/aapt2/ResourceTable.h
View File

@@ -290,14 +290,6 @@ public:
private:
ResourceTablePackage* findOrCreatePackage(const StringPiece& name);
bool addFileReferenceImpl(const ResourceNameRef& name,
const ConfigDescription& config,
const Source& source,
const StringPiece& path,
io::IFile* file,
const char* validChars,
IDiagnostics* diag);
bool addResourceImpl(const ResourceNameRef& name,
const ResourceId& resId,
const ConfigDescription& config,
@@ -307,6 +299,14 @@ private:
const CollisionResolverFunc& conflictResolver,
IDiagnostics* diag);
bool addFileReferenceImpl(const ResourceNameRef& name,
const ConfigDescription& config,
const Source& source,
const StringPiece& path,
io::IFile* file,
const char* validChars,
IDiagnostics* diag);
bool setSymbolStateImpl(const ResourceNameRef& name,
const ResourceId& resId,
const Symbol& symbol,

29
tools/aapt2/ResourceUtils.cpp
View File

@@ -268,6 +268,35 @@ Maybe<Reference> parseStyleParentReference(const StringPiece& str, std::string*
return result;
}
Maybe<Reference> parseXmlAttributeName(const StringPiece& str) {
StringPiece trimmedStr = util::trimWhitespace(str);
const char* start = trimmedStr.data();
const char* const end = start + trimmedStr.size();
const char* p = start;
Reference ref;
if (p != end && *p == '*') {
ref.privateReference = true;
start++;
p++;
}
StringPiece package;
StringPiece name;
while (p != end) {
if (*p == ':') {
package = StringPiece(start, p - start);
name = StringPiece(p + 1, end - (p + 1));
break;
}
p++;
}
ref.name = ResourceName(package.toString(), ResourceType::kAttr,
name.empty() ? trimmedStr.toString() : name.toString());
return Maybe<Reference>(std::move(ref));
}
std::unique_ptr<Reference> tryParseReference(const StringPiece& str, bool* outCreate) {
ResourceNameRef ref;
bool privateRef = false;

8
tools/aapt2/ResourceUtils.h
View File

@@ -110,6 +110,14 @@ Maybe<int> parseSdkVersion(const StringPiece& str);
*/
Maybe<Reference> parseStyleParentReference(const StringPiece& str, std::string* outError);
/*
* Returns a Reference if the string `str` was parsed as a valid XML attribute name.
* The valid format for an XML attribute name is:
*
* package:entry
*/
Maybe<Reference> parseXmlAttributeName(const StringPiece& str);
/*
* 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

134
tools/aapt2/compile/Compile.cpp
View File

@@ -20,6 +20,7 @@
#include "ResourceParser.h"
#include "ResourceTable.h"
#include "compile/IdAssigner.h"
#include "compile/InlineXmlFormatParser.h"
#include "compile/Png.h"
#include "compile/PseudolocaleGenerator.h"
#include "compile/XmlIdCollector.h"
@@ -39,6 +40,9 @@
#include <fstream>
#include <string>
using google::protobuf::io::CopyingOutputStreamAdaptor;
using google::protobuf::io::ZeroCopyOutputStream;
namespace aapt {
struct ResourcePathData {
@@ -238,13 +242,14 @@ static bool compileTable(IAaptContext* context, const CompileOptions& options,
return false;
}
std::unique_ptr<pb::ResourceTable> pbTable = serializeTableToPb(&table);
// Wrap our IArchiveWriter with an adaptor that implements the ZeroCopyOutputStream interface.
// Make sure CopyingOutputStreamAdaptor is deleted before we call writer->finishEntry().
{
google::protobuf::io::CopyingOutputStreamAdaptor adaptor(writer);
// Wrap our IArchiveWriter with an adaptor that implements the ZeroCopyOutputStream
// interface.
CopyingOutputStreamAdaptor copyingAdaptor(writer);
if (!pbTable->SerializeToZeroCopyStream(&adaptor)) {
std::unique_ptr<pb::ResourceTable> pbTable = serializeTableToPb(&table);
if (!pbTable->SerializeToZeroCopyStream(&copyingAdaptor)) {
context->getDiagnostics()->error(DiagMessage(outputPath) << "failed to write");
return false;
}
@@ -266,21 +271,23 @@ static bool writeHeaderAndBufferToWriter(const StringPiece& outputPath, const Re
return false;
}
// Create the header.
std::unique_ptr<pb::CompiledFile> pbCompiledFile = serializeCompiledFileToPb(file);
// Make sure CopyingOutputStreamAdaptor is deleted before we call writer->finishEntry().
{
// The stream must be destroyed before we finish the entry, or else
// some data won't be flushed.
// Wrap our IArchiveWriter with an adaptor that implements the ZeroCopyOutputStream
// interface.
google::protobuf::io::CopyingOutputStreamAdaptor adaptor(writer);
CompiledFileOutputStream outputStream(&adaptor, pbCompiledFile.get());
for (const BigBuffer::Block& block : buffer) {
if (!outputStream.Write(block.buffer.get(), block.size)) {
diag->error(DiagMessage(outputPath) << "failed to write data");
return false;
}
CopyingOutputStreamAdaptor copyingAdaptor(writer);
CompiledFileOutputStream outputStream(&copyingAdaptor);
// Number of CompiledFiles.
outputStream.WriteLittleEndian32(1);
std::unique_ptr<pb::CompiledFile> compiledFile = serializeCompiledFileToPb(file);
outputStream.WriteCompiledFile(compiledFile.get());
outputStream.WriteData(&buffer);
if (outputStream.HadError()) {
diag->error(DiagMessage(outputPath) << "failed to write data");
return false;
}
}
@@ -300,17 +307,21 @@ static bool writeHeaderAndMmapToWriter(const StringPiece& outputPath, const Reso
return false;
}
// Create the header.
std::unique_ptr<pb::CompiledFile> pbCompiledFile = serializeCompiledFileToPb(file);
// Make sure CopyingOutputStreamAdaptor is deleted before we call writer->finishEntry().
{
// The stream must be destroyed before we finish the entry, or else
// some data won't be flushed.
// Wrap our IArchiveWriter with an adaptor that implements the ZeroCopyOutputStream
// interface.
google::protobuf::io::CopyingOutputStreamAdaptor adaptor(writer);
CompiledFileOutputStream outputStream(&adaptor, pbCompiledFile.get());
if (!outputStream.Write(map.getDataPtr(), map.getDataLength())) {
CopyingOutputStreamAdaptor copyingAdaptor(writer);
CompiledFileOutputStream outputStream(&copyingAdaptor);
// Number of CompiledFiles.
outputStream.WriteLittleEndian32(1);
std::unique_ptr<pb::CompiledFile> compiledFile = serializeCompiledFileToPb(file);
outputStream.WriteCompiledFile(compiledFile.get());
outputStream.WriteData(map.getDataPtr(), map.getDataLength());
if (outputStream.HadError()) {
diag->error(DiagMessage(outputPath) << "failed to write data");
return false;
}
@@ -323,6 +334,28 @@ static bool writeHeaderAndMmapToWriter(const StringPiece& outputPath, const Reso
return true;
}
static bool flattenXmlToOutStream(IAaptContext* context, const StringPiece& outputPath,
xml::XmlResource* xmlRes,
CompiledFileOutputStream* out) {
BigBuffer buffer(1024);
XmlFlattenerOptions xmlFlattenerOptions;
xmlFlattenerOptions.keepRawValues = true;
XmlFlattener flattener(&buffer, xmlFlattenerOptions);
if (!flattener.consume(context, xmlRes)) {
return false;
}
std::unique_ptr<pb::CompiledFile> pbCompiledFile = serializeCompiledFileToPb(xmlRes->file);
out->WriteCompiledFile(pbCompiledFile.get());
out->WriteData(&buffer);
if (out->HadError()) {
context->getDiagnostics()->error(DiagMessage(outputPath) << "failed to write data");
return false;
}
return true;
}
static bool compileXml(IAaptContext* context, const CompileOptions& options,
const ResourcePathData& pathData, IArchiveWriter* writer,
const std::string& outputPath) {
@@ -344,26 +377,55 @@ static bool compileXml(IAaptContext* context, const CompileOptions& options,
return false;
}
xmlRes->file.name = ResourceName({}, *parseResourceType(pathData.resourceDir), pathData.name);
xmlRes->file.config = pathData.config;
xmlRes->file.source = pathData.source;
// Collect IDs that are defined here.
XmlIdCollector collector;
if (!collector.consume(context, xmlRes.get())) {
return false;
}
xmlRes->file.name = ResourceName({}, *parseResourceType(pathData.resourceDir), pathData.name);
xmlRes->file.config = pathData.config;
xmlRes->file.source = pathData.source;
BigBuffer buffer(1024);
XmlFlattenerOptions xmlFlattenerOptions;
xmlFlattenerOptions.keepRawValues = true;
XmlFlattener flattener(&buffer, xmlFlattenerOptions);
if (!flattener.consume(context, xmlRes.get())) {
// Look for and process any <aapt:attr> tags and create sub-documents.
InlineXmlFormatParser inlineXmlFormatParser;
if (!inlineXmlFormatParser.consume(context, xmlRes.get())) {
return false;
}
if (!writeHeaderAndBufferToWriter(outputPath, xmlRes->file, buffer, writer,
context->getDiagnostics())) {
// Start the entry so we can write the header.
if (!writer->startEntry(outputPath, 0)) {
context->getDiagnostics()->error(DiagMessage(outputPath) << "failed to open file");
return false;
}
// Make sure CopyingOutputStreamAdaptor is deleted before we call writer->finishEntry().
{
// Wrap our IArchiveWriter with an adaptor that implements the ZeroCopyOutputStream
// interface.
CopyingOutputStreamAdaptor copyingAdaptor(writer);
CompiledFileOutputStream outputStream(&copyingAdaptor);
std::vector<std::unique_ptr<xml::XmlResource>>& inlineDocuments =
inlineXmlFormatParser.getExtractedInlineXmlDocuments();
// Number of CompiledFiles.
outputStream.WriteLittleEndian32(1 + inlineDocuments.size());
if (!flattenXmlToOutStream(context, outputPath, xmlRes.get(), &outputStream)) {
return false;
}
for (auto& inlineXmlDoc : inlineDocuments) {
if (!flattenXmlToOutStream(context, outputPath, inlineXmlDoc.get(), &outputStream)) {
return false;
}
}
}
if (!writer->finishEntry()) {
context->getDiagnostics()->error(DiagMessage(outputPath)
<< "failed to finish writing data");
return false;
}
return true;

190
tools/aapt2/compile/InlineXmlFormatParser.cpp Normal file
View File

@@ -0,0 +1,190 @@
/*
* Copyright (C) 2016 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 "ResourceUtils.h"
#include "compile/InlineXmlFormatParser.h"
#include "util/Util.h"
#include "xml/XmlDom.h"
#include "xml/XmlUtil.h"
#include <android-base/macros.h>
#include <sstream>
#include <string>
namespace aapt {
namespace {
/**
* XML Visitor that will find all <aapt:attr> elements for extraction.
*/
class Visitor : public xml::PackageAwareVisitor {
public:
using xml::PackageAwareVisitor::visit;
struct InlineDeclaration {
xml::Element* el;
std::string attrNamespaceUri;
std::string attrName;
};
explicit Visitor(IAaptContext* context, xml::XmlResource* xmlResource) :
mContext(context), mXmlResource(xmlResource) {
}
void visit(xml::Element* el) override {
if (el->namespaceUri != xml::kSchemaAapt || el->name != "attr") {
xml::PackageAwareVisitor::visit(el);
return;
}
const Source& src = mXmlResource->file.source.withLine(el->lineNumber);
xml::Attribute* attr = el->findAttribute({}, "name");
if (!attr) {
mContext->getDiagnostics()->error(DiagMessage(src) << "missing 'name' attribute");
mError = true;
return;
}
Maybe<Reference> ref = ResourceUtils::parseXmlAttributeName(attr->value);
if (!ref) {
mContext->getDiagnostics()->error(DiagMessage(src) << "invalid XML attribute '"
<< attr->value << "'");
mError = true;
return;
}
const ResourceName& name = ref.value().name.value();
// Use an empty string for the compilation package because we don't want to default to
// the local package if the user specified name="style" or something. This should just
// be the default namespace.
Maybe<xml::ExtractedPackage> maybePkg = transformPackageAlias(name.package, {});
if (!maybePkg) {
mContext->getDiagnostics()->error(DiagMessage(src) << "invalid namespace prefix '"
<< name.package << "'");
mError = true;
return;
}
const xml::ExtractedPackage& pkg = maybePkg.value();
const bool privateNamespace = pkg.privateNamespace || ref.value().privateReference;
InlineDeclaration decl;
decl.el = el;
decl.attrName = name.entry;
if (!pkg.package.empty()) {
decl.attrNamespaceUri = xml::buildPackageNamespace(pkg.package, privateNamespace);
}
mInlineDeclarations.push_back(std::move(decl));
}
const std::vector<InlineDeclaration>& getInlineDeclarations() const {
return mInlineDeclarations;
}
bool hasError() const {
return mError;
}
private:
DISALLOW_COPY_AND_ASSIGN(Visitor);
IAaptContext* mContext;
xml::XmlResource* mXmlResource;
std::vector<InlineDeclaration> mInlineDeclarations;
bool mError = false;
};
} // namespace
bool InlineXmlFormatParser::consume(IAaptContext* context, xml::XmlResource* doc) {
Visitor visitor(context, doc);
doc->root->accept(&visitor);
if (visitor.hasError()) {
return false;
}
size_t nameSuffixCounter = 0;
for (const Visitor::InlineDeclaration& decl : visitor.getInlineDeclarations()) {
auto newDoc = util::make_unique<xml::XmlResource>();
newDoc->file.config = doc->file.config;
newDoc->file.source = doc->file.source.withLine(decl.el->lineNumber);
newDoc->file.name = doc->file.name;
// Modify the new entry name. We need to suffix the entry with a number to avoid
// local collisions, then mangle it with the empty package, such that it won't show up
// in R.java.
newDoc->file.name.entry = NameMangler::mangleEntry(
{}, newDoc->file.name.entry + "__" + std::to_string(nameSuffixCounter));
// Extracted elements must be the only child of <aapt:attr>.
// Make sure there is one root node in the children (ignore empty text).
for (auto& child : decl.el->children) {
const Source childSource = doc->file.source.withLine(child->lineNumber);
if (xml::Text* t = xml::nodeCast<xml::Text>(child.get())) {
if (!util::trimWhitespace(t->text).empty()) {
context->getDiagnostics()->error(DiagMessage(childSource)
<< "can't extract text into its own resource");
return false;
}
} else if (newDoc->root) {
context->getDiagnostics()->error(DiagMessage(childSource)
<< "inline XML resources must have a single root");
return false;
} else {
newDoc->root = std::move(child);
newDoc->root->parent = nullptr;
}
}
// Walk up and find the parent element.
xml::Node* node = decl.el;
xml::Element* parentEl = nullptr;
while (node->parent && (parentEl = xml::nodeCast<xml::Element>(node->parent)) == nullptr) {
node = node->parent;
}
if (!parentEl) {
context->getDiagnostics()->error(DiagMessage(newDoc->file.source)
<< "no suitable parent for inheriting attribute");
return false;
}
// Add the inline attribute to the parent.
parentEl->attributes.push_back(xml::Attribute{
decl.attrNamespaceUri, decl.attrName, "@" + newDoc->file.name.toString() });
// Delete the subtree.
for (auto iter = parentEl->children.begin(); iter != parentEl->children.end(); ++iter) {
if (iter->get() == node) {
parentEl->children.erase(iter);
break;
}
}
mQueue.push_back(std::move(newDoc));
nameSuffixCounter++;
}
return true;
}
} // namespace aapt

65
tools/aapt2/compile/InlineXmlFormatParser.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* Copyright (C) 2016 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_COMPILE_INLINEXMLFORMATPARSER_H
#define AAPT_COMPILE_INLINEXMLFORMATPARSER_H
#include "process/IResourceTableConsumer.h"
#include <android-base/macros.h>
#include <memory>
#include <vector>
namespace aapt {
/**
* Extracts Inline XML definitions into their own xml::XmlResource objects.
*
* Inline XML looks like:
*
* <animated-vector xmlns:android="http://schemas.android.com/apk/res/android"
* xmlns:aapt="http://schemas.android.com/aapt" >
* <aapt:attr name="android:drawable" >
* <vector
* android:height="64dp"
* android:width="64dp"
* android:viewportHeight="600"
* android:viewportWidth="600"/>
* </aapt:attr>
* </animated-vector>
*
* The <vector> will be extracted into its own XML file and <animated-vector> will
* gain an attribute 'android:drawable' set to a reference to the extracted <vector> resource.
*/
class InlineXmlFormatParser : public IXmlResourceConsumer {
public:
explicit InlineXmlFormatParser() = default;
bool consume(IAaptContext* context, xml::XmlResource* doc) override;
std::vector<std::unique_ptr<xml::XmlResource>>& getExtractedInlineXmlDocuments() {
return mQueue;
}
private:
DISALLOW_COPY_AND_ASSIGN(InlineXmlFormatParser);
std::vector<std::unique_ptr<xml::XmlResource>> mQueue;
};
} // namespace aapt
#endif /* AAPT_COMPILE_INLINEXMLFORMATPARSER_H */

138
tools/aapt2/compile/InlineXmlFormatParser_test.cpp Normal file
View File

@@ -0,0 +1,138 @@
/*
* Copyright (C) 2016 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 "compile/InlineXmlFormatParser.h"
#include "test/Test.h"
namespace aapt {
TEST(InlineXmlFormatParserTest, PassThrough) {
std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
std::unique_ptr<xml::XmlResource> doc = test::buildXmlDom(R"EOF(
<View xmlns:android="http://schemas.android.com/apk/res/android">
<View android:text="hey">
<View android:id="hi" />
</View>
</View>)EOF");
InlineXmlFormatParser parser;
ASSERT_TRUE(parser.consume(context.get(), doc.get()));
EXPECT_EQ(0u, parser.getExtractedInlineXmlDocuments().size());
}
TEST(InlineXmlFormatParserTest, ExtractOneXmlResource) {
std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
std::unique_ptr<xml::XmlResource> doc = test::buildXmlDom(R"EOF(
<View1 xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:aapt="http://schemas.android.com/aapt">
<aapt:attr name="android:text">
<View2 android:text="hey">
<View3 android:id="hi" />
</View2>
</aapt:attr>
</View1>)EOF");
doc->file.name = test::parseNameOrDie("layout/main");
InlineXmlFormatParser parser;
ASSERT_TRUE(parser.consume(context.get(), doc.get()));
// One XML resource should have been extracted.
EXPECT_EQ(1u, parser.getExtractedInlineXmlDocuments().size());
xml::Element* el = xml::findRootElement(doc.get());
ASSERT_NE(nullptr, el);
EXPECT_EQ("View1", el->name);
// The <aapt:attr> tag should be extracted.
EXPECT_EQ(nullptr, el->findChild(xml::kSchemaAapt, "attr"));
// The 'android:text' attribute should be set with a reference.
xml::Attribute* attr = el->findAttribute(xml::kSchemaAndroid, "text");
ASSERT_NE(nullptr, attr);
ResourceNameRef nameRef;
ASSERT_TRUE(ResourceUtils::parseReference(attr->value, &nameRef));
xml::XmlResource* extractedDoc = parser.getExtractedInlineXmlDocuments()[0].get();
ASSERT_NE(nullptr, extractedDoc);
// Make sure the generated reference is correct.
EXPECT_EQ(nameRef.package, extractedDoc->file.name.package);
EXPECT_EQ(nameRef.type, extractedDoc->file.name.type);
EXPECT_EQ(nameRef.entry, extractedDoc->file.name.entry);
// Verify the structure of the extracted XML.
el = xml::findRootElement(extractedDoc);
ASSERT_NE(nullptr, el);
EXPECT_EQ("View2", el->name);
EXPECT_NE(nullptr, el->findChild({}, "View3"));
}
TEST(InlineXmlFormatParserTest, ExtractTwoXmlResources) {
std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
std::unique_ptr<xml::XmlResource> doc = test::buildXmlDom(R"EOF(
<View1 xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:aapt="http://schemas.android.com/aapt">
<aapt:attr name="android:text">
<View2 android:text="hey">
<View3 android:id="hi" />
</View2>
</aapt:attr>
<aapt:attr name="android:drawable">
<vector />
</aapt:attr>
</View1>)EOF");
doc->file.name = test::parseNameOrDie("layout/main");
InlineXmlFormatParser parser;
ASSERT_TRUE(parser.consume(context.get(), doc.get()));
ASSERT_EQ(2u, parser.getExtractedInlineXmlDocuments().size());
xml::Element* el = xml::findRootElement(doc.get());
ASSERT_NE(nullptr, el);
EXPECT_EQ("View1", el->name);
xml::Attribute* attrText = el->findAttribute(xml::kSchemaAndroid, "text");
ASSERT_NE(nullptr, attrText);
xml::Attribute* attrDrawable = el->findAttribute(xml::kSchemaAndroid, "drawable");
ASSERT_NE(nullptr, attrDrawable);
// The two extracted resources should have different names.
EXPECT_NE(attrText->value, attrDrawable->value);
// The child <aapt:attr> elements should be gone.
EXPECT_EQ(nullptr, el->findChild(xml::kSchemaAapt, "attr"));
xml::XmlResource* extractedDocText = parser.getExtractedInlineXmlDocuments()[0].get();
ASSERT_NE(nullptr, extractedDocText);
el = xml::findRootElement(extractedDocText);
ASSERT_NE(nullptr, el);
EXPECT_EQ("View2", el->name);
xml::XmlResource* extractedDocDrawable = parser.getExtractedInlineXmlDocuments()[1].get();
ASSERT_NE(nullptr, extractedDocDrawable);
el = xml::findRootElement(extractedDocDrawable);
ASSERT_NE(nullptr, el);
EXPECT_EQ("vector", el->name);
}
} // namespace aapt

25
tools/aapt2/dump/Dump.cpp
View File

@@ -37,6 +37,7 @@ void dumpCompiledFile(const pb::CompiledFile& pbFile, const void* data, size_t l
std::unique_ptr<ResourceFile> file = deserializeCompiledFileFromPb(pbFile, source,
context->getDiagnostics());
if (!file) {
context->getDiagnostics()->warn(DiagMessage() << "failed to read compiled file");
return;
}
@@ -112,9 +113,27 @@ void tryDumpFile(IAaptContext* context, const std::string& filePath) {
if (!table) {
// Try as a compiled file.
CompiledFileInputStream input(fileMap->getDataPtr(), fileMap->getDataLength());
if (const pb::CompiledFile* pbFile = input.CompiledFile()) {
dumpCompiledFile(*pbFile, input.data(), input.size(), Source(filePath), context);
return;
uint32_t numFiles = 0;
if (!input.ReadLittleEndian32(&numFiles)) {
return;
}
for (uint32_t i = 0; i < numFiles; i++) {
pb::CompiledFile compiledFile;
if (!input.ReadCompiledFile(&compiledFile)) {
context->getDiagnostics()->warn(DiagMessage() << "failed to read compiled file");
return;
}
uint64_t offset, len;
if (!input.ReadDataMetaData(&offset, &len)) {
context->getDiagnostics()->warn(DiagMessage() << "failed to read meta data");
return;
}
const void* data = static_cast<const uint8_t*>(fileMap->getDataPtr()) + offset;
dumpCompiledFile(compiledFile, data, len, Source(filePath), context);
}
}
}

3
tools/aapt2/flatten/Archive.h
View File

@@ -41,7 +41,8 @@ struct ArchiveEntry {
size_t uncompressedSize;
};
struct IArchiveWriter : public google::protobuf::io::CopyingOutputStream {
class IArchiveWriter : public google::protobuf::io::CopyingOutputStream {
public:
virtual ~IArchiveWriter() = default;
virtual bool startEntry(const StringPiece& path, uint32_t flags) = 0;

10
tools/aapt2/integration-tests/AppOne/res/layout/special.xml Normal file
View File

@@ -0,0 +1,10 @@
<?xml version="1.0" encoding="utf-8"?>
<View xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="wrap_content"
android:layout_height="wrap_content">
<include>
<aapt:attr name="layout" xmlns:aapt="http://schemas.android.com/aapt">
<RelativeLayout android:id="@+id/hello" />
</aapt:attr>
</include>
</View>

26
tools/aapt2/io/Data.h
View File

@@ -17,9 +17,9 @@
#ifndef AAPT_IO_DATA_H
#define AAPT_IO_DATA_H
#include <utils/FileMap.h>
#include <android-base/macros.h>
#include <memory>
#include <utils/FileMap.h>
namespace aapt {
namespace io {
@@ -35,6 +35,28 @@ public:
virtual size_t size() const = 0;
};
class DataSegment : public IData {
public:
explicit DataSegment(std::unique_ptr<IData> data, size_t offset, size_t len) :
mData(std::move(data)), mOffset(offset), mLen(len) {
}
const void* data() const override {
return static_cast<const uint8_t*>(mData->data()) + mOffset;
}
size_t size() const override {
return mLen;
}
private:
DISALLOW_COPY_AND_ASSIGN(DataSegment);
std::unique_ptr<IData> mData;
size_t mOffset;
size_t mLen;
};
/**
* Implementation of IData that exposes a memory mapped file. The mmapped file is owned by this
* object.

43
tools/aapt2/io/File.cpp Normal file
View File

@@ -0,0 +1,43 @@
/*
* Copyright (C) 2016 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 "io/File.h"
#include <memory>
namespace aapt {
namespace io {
IFile* IFile::createFileSegment(size_t offset, size_t len) {
FileSegment* fileSegment = new FileSegment(this, offset, len);
mSegments.push_back(std::unique_ptr<IFile>(fileSegment));
return fileSegment;
}
std::unique_ptr<IData> FileSegment::openAsData() {
std::unique_ptr<IData> data = mFile->openAsData();
if (!data) {
return {};
}
if (mOffset <= data->size() - mLen) {
return util::make_unique<DataSegment>(std::move(data), mOffset, mLen);
}
return {};
}
} // namespace io
} // namespace aapt

34
tools/aapt2/io/File.h
View File

@@ -19,7 +19,10 @@
#include "Source.h"
#include "io/Data.h"
#include "util/Util.h"
#include <android-base/macros.h>
#include <list>
#include <memory>
#include <vector>
@@ -50,6 +53,37 @@ public:
* a ZIP archive from the path to the containing ZIP archive.
*/
virtual const Source& getSource() const = 0;
IFile* createFileSegment(size_t offset, size_t len);
private:
// Any segments created from this IFile need to be owned by this IFile, so keep them
// in a list. This will never be read, so we prefer better insertion performance
// than cache locality, hence the list.
std::list<std::unique_ptr<IFile>> mSegments;
};
/**
* An IFile that wraps an underlying IFile but limits it to a subsection of that file.
*/
class FileSegment : public IFile {
public:
explicit FileSegment(IFile* file, size_t offset, size_t len) :
mFile(file), mOffset(offset), mLen(len) {
}
std::unique_ptr<IData> openAsData() override;
const Source& getSource() const override {
return mFile->getSource();
}
private:
DISALLOW_COPY_AND_ASSIGN(FileSegment);
IFile* mFile;
size_t mOffset;
size_t mLen;
};
class IFileCollectionIterator {

273
tools/aapt2/link/Link.cpp
View File

@@ -48,10 +48,13 @@
#include <google/protobuf/io/coded_stream.h>
#include <fstream>
#include <queue>
#include <sys/stat.h>
#include <unordered_map>
#include <vector>
using google::protobuf::io::CopyingOutputStreamAdaptor;
namespace aapt {
struct LinkOptions {
@@ -166,19 +169,7 @@ static bool copyFileToArchive(io::IFile* file, const std::string& outPath,
}
const uint8_t* buffer = reinterpret_cast<const uint8_t*>(data->data());
size_t bufferSize = data->size();
// If the file ends with .flat, we must strip off the CompiledFileHeader from it.
if (util::stringEndsWith(file->getSource().path, ".flat")) {
CompiledFileInputStream inputStream(data->data(), data->size());
if (!inputStream.CompiledFile()) {
context->getDiagnostics()->error(DiagMessage(file->getSource())
<< "invalid compiled file header");
return false;
}
buffer = reinterpret_cast<const uint8_t*>(inputStream.data());
bufferSize = inputStream.size();
}
const size_t bufferSize = data->size();
if (context->verbose()) {
context->getDiagnostics()->note(DiagMessage() << "writing " << outPath << " to archive");
@@ -255,42 +246,6 @@ static std::unique_ptr<xml::XmlResource> loadXml(const std::string& path, IDiagn
return xml::inflate(&fin, diag, Source(path));
}
static std::unique_ptr<xml::XmlResource> loadBinaryXmlSkipFileExport(const Source& source,
const void* data, size_t len,
IDiagnostics* diag) {
CompiledFileInputStream inputStream(data, len);
if (!inputStream.CompiledFile()) {
diag->error(DiagMessage(source) << "invalid compiled file header");
return {};
}
const uint8_t* xmlData = reinterpret_cast<const uint8_t*>(inputStream.data());
const size_t xmlDataLen = inputStream.size();
std::unique_ptr<xml::XmlResource> xmlRes = xml::inflate(xmlData, xmlDataLen, diag, source);
if (!xmlRes) {
return {};
}
return xmlRes;
}
static std::unique_ptr<ResourceFile> loadFileExportHeader(const Source& source,
const void* data, size_t len,
IDiagnostics* diag) {
CompiledFileInputStream inputStream(data, len);
const pb::CompiledFile* pbFile = inputStream.CompiledFile();
if (!pbFile) {
diag->error(DiagMessage(source) << "invalid compiled file header");
return {};
}
std::unique_ptr<ResourceFile> resFile = deserializeCompiledFileFromPb(*pbFile, source, diag);
if (!resFile) {
return {};
}
return resFile;
}
struct ResourceFileFlattenerOptions {
bool noAutoVersion = false;
bool noVersionVectors = false;
@@ -312,16 +267,26 @@ public:
private:
struct FileOperation {
ConfigDescription config;
// The entry this file came from.
const ResourceEntry* entry;
// The file to copy as-is.
io::IFile* fileToCopy;
// The XML to process and flatten.
std::unique_ptr<xml::XmlResource> xmlToFlatten;
// The destination to write this file to.
std::string dstPath;
bool skipVersion = false;
};
uint32_t getCompressionFlags(const StringPiece& str);
bool linkAndVersionXmlFile(const ResourceEntry* entry, const ResourceFile& fileDesc,
io::IFile* file, ResourceTable* table, FileOperation* outFileOp);
bool linkAndVersionXmlFile(ResourceTable* table, FileOperation* fileOp,
std::queue<FileOperation>* outFileOpQueue);
ResourceFileFlattenerOptions mOptions;
IAaptContext* mContext;
@@ -341,52 +306,28 @@ uint32_t ResourceFileFlattener::getCompressionFlags(const StringPiece& str) {
return ArchiveEntry::kCompress;
}
bool ResourceFileFlattener::linkAndVersionXmlFile(const ResourceEntry* entry,
const ResourceFile& fileDesc,
io::IFile* file,
ResourceTable* table,
FileOperation* outFileOp) {
const StringPiece srcPath = file->getSource().path;
bool ResourceFileFlattener::linkAndVersionXmlFile(ResourceTable* table,
FileOperation* fileOp,
std::queue<FileOperation>* outFileOpQueue) {
xml::XmlResource* doc = fileOp->xmlToFlatten.get();
const Source& src = doc->file.source;
if (mContext->verbose()) {
mContext->getDiagnostics()->note(DiagMessage() << "linking " << srcPath);
mContext->getDiagnostics()->note(DiagMessage() << "linking " << src.path);
}
std::unique_ptr<io::IData> data = file->openAsData();
if (!data) {
mContext->getDiagnostics()->error(DiagMessage(file->getSource()) << "failed to open file");
return false;
}
if (util::stringEndsWith(srcPath, ".flat")) {
outFileOp->xmlToFlatten = loadBinaryXmlSkipFileExport(file->getSource(),
data->data(), data->size(),
mContext->getDiagnostics());
} else {
outFileOp->xmlToFlatten = xml::inflate(data->data(), data->size(),
mContext->getDiagnostics(),
file->getSource());
}
if (!outFileOp->xmlToFlatten) {
return false;
}
// Copy the the file description header.
outFileOp->xmlToFlatten->file = fileDesc;
XmlReferenceLinker xmlLinker;
if (!xmlLinker.consume(mContext, outFileOp->xmlToFlatten.get())) {
if (!xmlLinker.consume(mContext, doc)) {
return false;
}
if (mOptions.updateProguardSpec && !proguard::collectProguardRules(
outFileOp->xmlToFlatten->file.source, outFileOp->xmlToFlatten.get(), mKeepSet)) {
if (mOptions.updateProguardSpec && !proguard::collectProguardRules(src, doc, mKeepSet)) {
return false;
}
if (mOptions.noXmlNamespaces) {
XmlNamespaceRemover namespaceRemover;
if (!namespaceRemover.consume(mContext, outFileOp->xmlToFlatten.get())) {
if (!namespaceRemover.consume(mContext, doc)) {
return false;
}
}
@@ -394,51 +335,58 @@ bool ResourceFileFlattener::linkAndVersionXmlFile(const ResourceEntry* entry,
if (!mOptions.noAutoVersion) {
if (mOptions.noVersionVectors) {
// Skip this if it is a vector or animated-vector.
xml::Element* el = xml::findRootElement(outFileOp->xmlToFlatten.get());
xml::Element* el = xml::findRootElement(doc);
if (el && el->namespaceUri.empty()) {
if (el->name == "vector" || el->name == "animated-vector") {
// We are NOT going to version this file.
outFileOp->skipVersion = true;
fileOp->skipVersion = true;
return true;
}
}
}
const ConfigDescription& config = fileOp->config;
// Find the first SDK level used that is higher than this defined config and
// not superseded by a lower or equal SDK level resource.
const int minSdkVersion = mContext->getMinSdkVersion();
for (int sdkLevel : xmlLinker.getSdkLevels()) {
if (sdkLevel > minSdkVersion
&& sdkLevel > outFileOp->xmlToFlatten->file.config.sdkVersion) {
if (!shouldGenerateVersionedResource(entry, outFileOp->xmlToFlatten->file.config,
sdkLevel)) {
if (sdkLevel > minSdkVersion && sdkLevel > config.sdkVersion) {
if (!shouldGenerateVersionedResource(fileOp->entry, config, sdkLevel)) {
// If we shouldn't generate a versioned resource, stop checking.
break;
}
ResourceFile versionedFileDesc = outFileOp->xmlToFlatten->file;
ResourceFile versionedFileDesc = doc->file;
versionedFileDesc.config.sdkVersion = (uint16_t) sdkLevel;
FileOperation newFileOp;
newFileOp.xmlToFlatten = util::make_unique<xml::XmlResource>(
versionedFileDesc, doc->root->clone());
newFileOp.config = versionedFileDesc.config;
newFileOp.entry = fileOp->entry;
newFileOp.dstPath = ResourceUtils::buildResourceFileName(
versionedFileDesc, mContext->getNameMangler());
if (mContext->verbose()) {
mContext->getDiagnostics()->note(DiagMessage(versionedFileDesc.source)
<< "auto-versioning resource from config '"
<< outFileOp->xmlToFlatten->file.config
<< config
<< "' -> '"
<< versionedFileDesc.config << "'");
}
std::string genPath = ResourceUtils::buildResourceFileName(
versionedFileDesc, mContext->getNameMangler());
bool added = table->addFileReferenceAllowMangled(versionedFileDesc.name,
versionedFileDesc.config,
versionedFileDesc.source,
genPath,
file,
newFileOp.dstPath,
nullptr,
mContext->getDiagnostics());
if (!added) {
return false;
}
outFileOpQueue->push(std::move(newFileOp));
break;
}
}
@@ -458,12 +406,11 @@ bool ResourceFileFlattener::flatten(ResourceTable* table, IArchiveWriter* archiv
for (auto& type : pkg->types) {
// Sort by config and name, so that we get better locality in the zip file.
configSortedFiles.clear();
for (auto& entry : type->entries) {
// Iterate via indices because auto generated values can be inserted ahead of
// the value being processed.
for (size_t i = 0; i < entry->values.size(); i++) {
ResourceConfigValue* configValue = entry->values[i].get();
std::queue<FileOperation> fileOperations;
// Populate the queue with all files in the ResourceTable.
for (auto& entry : type->entries) {
for (auto& configValue : entry->values) {
FileReference* fileRef = valueCast<FileReference>(configValue->value.get());
if (!fileRef) {
continue;
@@ -477,35 +424,67 @@ bool ResourceFileFlattener::flatten(ResourceTable* table, IArchiveWriter* archiv
}
FileOperation fileOp;
fileOp.entry = entry.get();
fileOp.dstPath = *fileRef->path;
fileOp.config = configValue->config;
const StringPiece srcPath = file->getSource().path;
if (type->type != ResourceType::kRaw &&
(util::stringEndsWith(srcPath, ".xml.flat") ||
util::stringEndsWith(srcPath, ".xml"))) {
ResourceFile fileDesc;
fileDesc.config = configValue->config;
fileDesc.name = ResourceName(pkg->name, type->type, entry->name);
fileDesc.source = fileRef->getSource();
if (!linkAndVersionXmlFile(entry.get(), fileDesc, file, table, &fileOp)) {
error = true;
continue;
std::unique_ptr<io::IData> data = file->openAsData();
if (!data) {
mContext->getDiagnostics()->error(DiagMessage(file->getSource())
<< "failed to open file");
return false;
}
fileOp.xmlToFlatten = xml::inflate(data->data(), data->size(),
mContext->getDiagnostics(),
file->getSource());
if (!fileOp.xmlToFlatten) {
return false;
}
fileOp.xmlToFlatten->file.config = configValue->config;
fileOp.xmlToFlatten->file.source = fileRef->getSource();
fileOp.xmlToFlatten->file.name =
ResourceName(pkg->name, type->type, entry->name);
// Enqueue the XML files to be processed.
fileOperations.push(std::move(fileOp));
} else {
fileOp.fileToCopy = file;
}
// NOTE(adamlesinski): Explicitly construct a StringPiece16 here, or else
// we end up copying the string in the std::make_pair() method, then creating
// a StringPiece16 from the copy, which would cause us to end up referencing
// garbage in the map.
const StringPiece entryName(entry->name);
configSortedFiles[std::make_pair(configValue->config, entryName)] =
std::move(fileOp);
// NOTE(adamlesinski): Explicitly construct a StringPiece here, or else
// we end up copying the string in the std::make_pair() method, then
// creating a StringPiece from the copy, which would cause us to end up
// referencing garbage in the map.
const StringPiece entryName(entry->name);
configSortedFiles[std::make_pair(configValue->config, entryName)] =
std::move(fileOp);
}
}
}
// Now process the XML queue
for (; !fileOperations.empty(); fileOperations.pop()) {
FileOperation& fileOp = fileOperations.front();
if (!linkAndVersionXmlFile(table, &fileOp, &fileOperations)) {
error = true;
continue;
}
// NOTE(adamlesinski): Explicitly construct a StringPiece here, or else
// we end up copying the string in the std::make_pair() method, then creating
// a StringPiece from the copy, which would cause us to end up referencing
// garbage in the map.
const StringPiece entryName(fileOp.entry->name);
configSortedFiles[std::make_pair(fileOp.config, entryName)] = std::move(fileOp);
}
if (error) {
return false;
}
@@ -518,10 +497,8 @@ bool ResourceFileFlattener::flatten(ResourceTable* table, IArchiveWriter* archiv
if (fileOp.xmlToFlatten) {
Maybe<size_t> maxSdkLevel;
if (!mOptions.noAutoVersion && !fileOp.skipVersion) {
maxSdkLevel =
std::max<size_t>(
std::max<size_t>(config.sdkVersion, 1u),
mContext->getMinSdkVersion());
maxSdkLevel = std::max<size_t>(std::max<size_t>(config.sdkVersion, 1u),
mContext->getMinSdkVersion());
}
bool result = flattenXml(fileOp.xmlToFlatten.get(), fileOp.dstPath, maxSdkLevel,
@@ -866,13 +843,13 @@ public:
return false;
}
std::unique_ptr<pb::ResourceTable> pbTable = serializeTableToPb(table);
// Wrap our IArchiveWriter with an adaptor that implements the ZeroCopyOutputStream
// interface.
// Make sure CopyingOutputStreamAdaptor is deleted before we call writer->finishEntry().
{
google::protobuf::io::CopyingOutputStreamAdaptor adaptor(writer);
// Wrap our IArchiveWriter with an adaptor that implements the ZeroCopyOutputStream
// interface.
CopyingOutputStreamAdaptor adaptor(writer);
std::unique_ptr<pb::ResourceTable> pbTable = serializeTableToPb(table);
if (!pbTable->SerializeToZeroCopyStream(&adaptor)) {
mContext->getDiagnostics()->error(DiagMessage() << "failed to write");
return false;
@@ -1109,7 +1086,9 @@ public:
bool mergeCompiledFile(io::IFile* file, ResourceFile* fileDesc, bool override) {
if (mContext->verbose()) {
mContext->getDiagnostics()->note(DiagMessage() << "merging compiled file "
mContext->getDiagnostics()->note(DiagMessage()
<< "merging '" << fileDesc->name
<< "' from compiled file "
<< file->getSource());
}
@@ -1230,12 +1209,40 @@ public:
return false;
}
std::unique_ptr<ResourceFile> resourceFile = loadFileExportHeader(
src, data->data(), data->size(), mContext->getDiagnostics());
if (resourceFile) {
return mergeCompiledFile(file, resourceFile.get(), override);
CompiledFileInputStream inputStream(data->data(), data->size());
uint32_t numFiles = 0;
if (!inputStream.ReadLittleEndian32(&numFiles)) {
mContext->getDiagnostics()->error(DiagMessage(src) << "failed read num files");
return false;
}
return false;
for (uint32_t i = 0; i < numFiles; i++) {
pb::CompiledFile compiledFile;
if (!inputStream.ReadCompiledFile(&compiledFile)) {
mContext->getDiagnostics()->error(DiagMessage(src)
<< "failed to read compiled file header");
return false;
}
uint64_t offset, len;
if (!inputStream.ReadDataMetaData(&offset, &len)) {
mContext->getDiagnostics()->error(DiagMessage(src)
<< "failed to read data meta data");
return false;
}
std::unique_ptr<ResourceFile> resourceFile = deserializeCompiledFileFromPb(
compiledFile, file->getSource(), mContext->getDiagnostics());
if (!resourceFile) {
return false;
}
if (!mergeCompiledFile(file->createFileSegment(offset, len), resourceFile.get(),
override)) {
return false;
}
}
return true;
}
// Ignore non .flat files. This could be classes.dex or something else that happens

2
tools/aapt2/process/IResourceTableConsumer.h
View File

@@ -51,7 +51,7 @@ struct IResourceTableConsumer {
};
namespace xml {
struct XmlResource;
class XmlResource;
}
struct IXmlResourceConsumer {

68
tools/aapt2/proto/ProtoSerialize.h
View File

@@ -28,6 +28,40 @@
namespace aapt {
class CompiledFileOutputStream {
public:
explicit CompiledFileOutputStream(google::protobuf::io::ZeroCopyOutputStream* out);
void WriteLittleEndian32(uint32_t value);
void WriteCompiledFile(const pb::CompiledFile* compiledFile);
void WriteData(const BigBuffer* buffer);
void WriteData(const void* data, size_t len);
bool HadError();
private:
DISALLOW_COPY_AND_ASSIGN(CompiledFileOutputStream);
void ensureAlignedWrite();
google::protobuf::io::CodedOutputStream mOut;
};
class CompiledFileInputStream {
public:
explicit CompiledFileInputStream(const void* data, size_t size);
bool ReadLittleEndian32(uint32_t* outVal);
bool ReadCompiledFile(pb::CompiledFile* outVal);
bool ReadDataMetaData(uint64_t* outOffset, uint64_t* outLen);
private:
DISALLOW_COPY_AND_ASSIGN(CompiledFileInputStream);
void ensureAlignedRead();
google::protobuf::io::CodedInputStream mIn;
};
std::unique_ptr<pb::ResourceTable> serializeTableToPb(ResourceTable* table);
std::unique_ptr<ResourceTable> deserializeTableFromPb(const pb::ResourceTable& pbTable,
const Source& source,
@@ -38,40 +72,6 @@ std::unique_ptr<ResourceFile> deserializeCompiledFileFromPb(const pb::CompiledFi
const Source& source,
IDiagnostics* diag);
class CompiledFileOutputStream : public google::protobuf::io::CopyingOutputStream {
public:
CompiledFileOutputStream(google::protobuf::io::ZeroCopyOutputStream* out,
pb::CompiledFile* pbFile);
bool Write(const void* data, int size) override;
bool Finish();
private:
bool ensureFileWritten();
google::protobuf::io::CodedOutputStream mOut;
pb::CompiledFile* mPbFile;
DISALLOW_COPY_AND_ASSIGN(CompiledFileOutputStream);
};
class CompiledFileInputStream {
public:
CompiledFileInputStream(const void* data, size_t size);
const pb::CompiledFile* CompiledFile();
const void* data();
size_t size();
private:
google::protobuf::io::CodedInputStream mIn;
std::unique_ptr<pb::CompiledFile> mPbFile;
const uint8_t* mData;
size_t mSize;
DISALLOW_COPY_AND_ASSIGN(CompiledFileInputStream);
};
} // namespace aapt
#endif /* AAPT_FLATTEN_TABLEPROTOSERIALIZER_H */

48
tools/aapt2/proto/TableProtoDeserializer.cpp
View File

@@ -468,52 +468,4 @@ std::unique_ptr<ResourceFile> deserializeCompiledFileFromPb(const pb::CompiledFi
return file;
}
CompiledFileInputStream::CompiledFileInputStream(const void* data, size_t size) :
mIn(static_cast<const uint8_t*>(data), size), mPbFile(),
mData(static_cast<const uint8_t*>(data)), mSize(size) {
}
const pb::CompiledFile* CompiledFileInputStream::CompiledFile() {
if (!mPbFile) {
std::unique_ptr<pb::CompiledFile> pbFile = util::make_unique<pb::CompiledFile>();
uint64_t pbSize = 0u;
if (!mIn.ReadLittleEndian64(&pbSize)) {
return nullptr;
}
mIn.PushLimit(static_cast<int>(pbSize));
if (!pbFile->ParsePartialFromCodedStream(&mIn)) {
return nullptr;
}
const size_t padding = 4 - (pbSize & 0x03);
const size_t offset = sizeof(uint64_t) + pbSize + padding;
if (offset > mSize) {
return nullptr;
}
mData += offset;
mSize -= offset;
mPbFile = std::move(pbFile);
}
return mPbFile.get();
}
const void* CompiledFileInputStream::data() {
if (!mPbFile) {
if (!CompiledFile()) {
return nullptr;
}
}
return mData;
}
size_t CompiledFileInputStream::size() {
if (!mPbFile) {
if (!CompiledFile()) {
return 0;
}
}
return mSize;
}
} // namespace aapt

126
tools/aapt2/proto/TableProtoSerializer.cpp
View File

@@ -22,6 +22,10 @@
#include "proto/ProtoSerialize.h"
#include "util/BigBuffer.h"
using google::protobuf::io::CodedOutputStream;
using google::protobuf::io::CodedInputStream;
using google::protobuf::io::ZeroCopyOutputStream;
namespace aapt {
namespace {
@@ -210,7 +214,7 @@ std::unique_ptr<pb::ResourceTable> serializeTableToPb(ResourceTable* table) {
});
table->stringPool.prune();
std::unique_ptr<pb::ResourceTable> pbTable = util::make_unique<pb::ResourceTable>();
auto pbTable = util::make_unique<pb::ResourceTable>();
serializeStringPoolToPb(table->stringPool, pbTable->mutable_string_pool());
StringPool sourcePool, symbolPool;
@@ -274,7 +278,7 @@ std::unique_ptr<pb::ResourceTable> serializeTableToPb(ResourceTable* table) {
}
std::unique_ptr<pb::CompiledFile> serializeCompiledFileToPb(const ResourceFile& file) {
std::unique_ptr<pb::CompiledFile> pbFile = util::make_unique<pb::CompiledFile>();
auto pbFile = util::make_unique<pb::CompiledFile>();
pbFile->set_resource_name(file.name.toString());
pbFile->set_source_path(file.source.path);
serializeConfig(file.config, pbFile->mutable_config());
@@ -287,36 +291,112 @@ std::unique_ptr<pb::CompiledFile> serializeCompiledFileToPb(const ResourceFile&
return pbFile;
}
CompiledFileOutputStream::CompiledFileOutputStream(google::protobuf::io::ZeroCopyOutputStream* out,
pb::CompiledFile* pbFile) :
mOut(out), mPbFile(pbFile) {
CompiledFileOutputStream::CompiledFileOutputStream(ZeroCopyOutputStream* out) : mOut(out) {
}
bool CompiledFileOutputStream::ensureFileWritten() {
if (mPbFile) {
const uint64_t pbSize = mPbFile->ByteSize();
mOut.WriteLittleEndian64(pbSize);
mPbFile->SerializeWithCachedSizes(&mOut);
const size_t padding = 4 - (pbSize & 0x03);
if (padding > 0) {
uint32_t zero = 0u;
mOut.WriteRaw(&zero, padding);
}
mPbFile = nullptr;
void CompiledFileOutputStream::ensureAlignedWrite() {
const int padding = mOut.ByteCount() % 4;
if (padding > 0) {
uint32_t zero = 0u;
mOut.WriteRaw(&zero, padding);
}
return !mOut.HadError();
}
bool CompiledFileOutputStream::Write(const void* data, int size) {
if (!ensureFileWritten()) {
void CompiledFileOutputStream::WriteLittleEndian32(uint32_t val) {
ensureAlignedWrite();
mOut.WriteLittleEndian32(val);
}
void CompiledFileOutputStream::WriteCompiledFile(const pb::CompiledFile* compiledFile) {
ensureAlignedWrite();
mOut.WriteLittleEndian64(static_cast<uint64_t>(compiledFile->ByteSize()));
compiledFile->SerializeWithCachedSizes(&mOut);
}
void CompiledFileOutputStream::WriteData(const BigBuffer* buffer) {
ensureAlignedWrite();
mOut.WriteLittleEndian64(static_cast<uint64_t>(buffer->size()));
for (const BigBuffer::Block& block : *buffer) {
mOut.WriteRaw(block.buffer.get(), block.size);
}
}
void CompiledFileOutputStream::WriteData(const void* data, size_t len) {
ensureAlignedWrite();
mOut.WriteLittleEndian64(static_cast<uint64_t>(len));
mOut.WriteRaw(data, len);
}
bool CompiledFileOutputStream::HadError() {
return mOut.HadError();
}
CompiledFileInputStream::CompiledFileInputStream(const void* data, size_t size) :
mIn(static_cast<const uint8_t*>(data), size) {
}
void CompiledFileInputStream::ensureAlignedRead() {
const int padding = mIn.CurrentPosition() % 4;
if (padding > 0) {
// Reads are always 4 byte aligned.
mIn.Skip(padding);
}
}
bool CompiledFileInputStream::ReadLittleEndian32(uint32_t* outVal) {
ensureAlignedRead();
return mIn.ReadLittleEndian32(outVal);
}
bool CompiledFileInputStream::ReadCompiledFile(pb::CompiledFile* outVal) {
ensureAlignedRead();
uint64_t pbSize = 0u;
if (!mIn.ReadLittleEndian64(&pbSize)) {
return false;
}
mOut.WriteRaw(data, size);
return !mOut.HadError();
CodedInputStream::Limit l = mIn.PushLimit(static_cast<int>(pbSize));
// Check that we haven't tried to read past the end.
if (static_cast<uint64_t>(mIn.BytesUntilLimit()) != pbSize) {
mIn.PopLimit(l);
mIn.PushLimit(0);
return false;
}
if (!outVal->ParsePartialFromCodedStream(&mIn)) {
mIn.PopLimit(l);
mIn.PushLimit(0);
return false;
}
mIn.PopLimit(l);
return true;
}
bool CompiledFileOutputStream::Finish() {
return ensureFileWritten();
bool CompiledFileInputStream::ReadDataMetaData(uint64_t* outOffset, uint64_t* outLen) {
ensureAlignedRead();
uint64_t pbSize = 0u;
if (!mIn.ReadLittleEndian64(&pbSize)) {
return false;
}
// Check that we aren't trying to read past the end.
if (pbSize > static_cast<uint64_t>(mIn.BytesUntilLimit())) {
mIn.PushLimit(0);
return false;
}
uint64_t offset = static_cast<uint64_t>(mIn.CurrentPosition());
if (!mIn.Skip(pbSize)) {
return false;
}
*outOffset = offset;
*outLen = pbSize;
return true;
}
} // namespace aapt

87
tools/aapt2/proto/TableProtoSerializer_test.cpp
View File

@@ -18,6 +18,8 @@
#include "proto/ProtoSerialize.h"
#include "test/Test.h"
using namespace google::protobuf::io;
namespace aapt {
TEST(TableProtoSerializer, SerializeSinglePackage) {
@@ -115,33 +117,66 @@ TEST(TableProtoSerializer, SerializeFileHeader) {
f.source.path = "res/layout-hdpi-v9/main.xml";
f.exportedSymbols.push_back(SourcedResourceName{ test::parseNameOrDie("id/unchecked"), 23u });
const std::string expectedData = "1234";
std::unique_ptr<pb::CompiledFile> pbFile = serializeCompiledFileToPb(f);
const std::string expectedData1 = "123";
const std::string expectedData2 = "1234";
std::string outputStr;
{
google::protobuf::io::StringOutputStream outStream(&outputStr);
CompiledFileOutputStream outFileStream(&outStream, pbFile.get());
std::unique_ptr<pb::CompiledFile> pbFile1 = serializeCompiledFileToPb(f);
ASSERT_TRUE(outFileStream.Write(expectedData.data(), expectedData.size()));
ASSERT_TRUE(outFileStream.Finish());
f.name.entry = "__" + f.name.entry + "$0";
std::unique_ptr<pb::CompiledFile> pbFile2 = serializeCompiledFileToPb(f);
StringOutputStream outStream(&outputStr);
CompiledFileOutputStream outFileStream(&outStream);
outFileStream.WriteLittleEndian32(2);
outFileStream.WriteCompiledFile(pbFile1.get());
outFileStream.WriteData(expectedData1.data(), expectedData1.size());
outFileStream.WriteCompiledFile(pbFile2.get());
outFileStream.WriteData(expectedData2.data(), expectedData2.size());
ASSERT_FALSE(outFileStream.HadError());
}
CompiledFileInputStream inFileStream(outputStr.data(), outputStr.size());
const pb::CompiledFile* newPbFile = inFileStream.CompiledFile();
ASSERT_NE(nullptr, newPbFile);
uint32_t numFiles = 0;
ASSERT_TRUE(inFileStream.ReadLittleEndian32(&numFiles));
ASSERT_EQ(2u, numFiles);
std::unique_ptr<ResourceFile> file = deserializeCompiledFileFromPb(*newPbFile, Source("test"),
// Read the first compiled file.
pb::CompiledFile newPbFile;
ASSERT_TRUE(inFileStream.ReadCompiledFile(&newPbFile));
std::unique_ptr<ResourceFile> file = deserializeCompiledFileFromPb(newPbFile, Source("test"),
context->getDiagnostics());
ASSERT_NE(nullptr, file);
std::string actualData((const char*)inFileStream.data(), inFileStream.size());
EXPECT_EQ(expectedData, actualData);
EXPECT_EQ(0u, reinterpret_cast<uintptr_t>(inFileStream.data()) & 0x03);
uint64_t offset, len;
ASSERT_TRUE(inFileStream.ReadDataMetaData(&offset, &len));
std::string actualData(outputStr.data() + offset, len);
EXPECT_EQ(expectedData1, actualData);
// Expect the data to be aligned.
EXPECT_EQ(0u, offset & 0x03);
ASSERT_EQ(1u, file->exportedSymbols.size());
EXPECT_EQ(test::parseNameOrDie("id/unchecked"), file->exportedSymbols[0].name);
// Read the second compiled file.
ASSERT_TRUE(inFileStream.ReadCompiledFile(&newPbFile));
file = deserializeCompiledFileFromPb(newPbFile, Source("test"), context->getDiagnostics());
ASSERT_NE(nullptr, file);
ASSERT_TRUE(inFileStream.ReadDataMetaData(&offset, &len));
actualData = std::string(outputStr.data() + offset, len);
EXPECT_EQ(expectedData2, actualData);
// Expect the data to be aligned.
EXPECT_EQ(0u, offset & 0x03);
}
TEST(TableProtoSerializer, DeserializeCorruptHeaderSafely) {
@@ -152,19 +187,27 @@ TEST(TableProtoSerializer, DeserializeCorruptHeaderSafely) {
std::string outputStr;
{
google::protobuf::io::StringOutputStream outStream(&outputStr);
CompiledFileOutputStream outFileStream(&outStream, pbFile.get());
ASSERT_TRUE(outFileStream.Write(expectedData.data(), expectedData.size()));
ASSERT_TRUE(outFileStream.Finish());
StringOutputStream outStream(&outputStr);
CompiledFileOutputStream outFileStream(&outStream);
outFileStream.WriteLittleEndian32(1);
outFileStream.WriteCompiledFile(pbFile.get());
outFileStream.WriteData(expectedData.data(), expectedData.size());
ASSERT_FALSE(outFileStream.HadError());
}
outputStr[0] = 0xff;
outputStr[4] = 0xff;
CompiledFileInputStream inFileStream(outputStr.data(), outputStr.size());
EXPECT_EQ(nullptr, inFileStream.CompiledFile());
EXPECT_EQ(nullptr, inFileStream.data());
EXPECT_EQ(0u, inFileStream.size());
uint32_t numFiles = 0;
EXPECT_TRUE(inFileStream.ReadLittleEndian32(&numFiles));
EXPECT_EQ(1u, numFiles);
pb::CompiledFile newPbFile;
EXPECT_FALSE(inFileStream.ReadCompiledFile(&newPbFile));
uint64_t offset, len;
EXPECT_FALSE(inFileStream.ReadDataMetaData(&offset, &len));
}
} // namespace aapt

45
tools/aapt2/xml/XmlDom.cpp
View File

@@ -322,6 +322,21 @@ std::unique_ptr<XmlResource> inflate(const void* data, size_t dataLen, IDiagnost
return util::make_unique<XmlResource>(ResourceFile{}, std::move(root));
}
std::unique_ptr<Node> Namespace::clone() {
auto ns = util::make_unique<Namespace>();
ns->comment = comment;
ns->lineNumber = lineNumber;
ns->columnNumber = columnNumber;
ns->namespacePrefix = namespacePrefix;
ns->namespaceUri = namespaceUri;
ns->children.reserve(children.size());
for (const std::unique_ptr<xml::Node>& child : children) {
ns->addChild(child->clone());
}
return std::move(ns);
}
Element* findRootElement(XmlResource* doc) {
return findRootElement(doc->root.get());
}
@@ -406,6 +421,36 @@ std::vector<Element*> Element::getChildElements() {
return elements;
}
std::unique_ptr<Node> Element::clone() {
auto el = util::make_unique<Element>();
el->comment = comment;
el->lineNumber = lineNumber;
el->columnNumber = columnNumber;
el->name = name;
el->namespaceUri = namespaceUri;
el->attributes.reserve(attributes.size());
for (xml::Attribute& attr : attributes) {
// Don't copy compiled values or attributes.
el->attributes.push_back(xml::Attribute{ attr.namespaceUri, attr.name, attr.value });
}
el->children.reserve(children.size());
for (const std::unique_ptr<xml::Node>& child : children) {
el->addChild(child->clone());
}
return std::move(el);
}
std::unique_ptr<Node> Text::clone() {
auto t = util::make_unique<Text>();
t->comment = comment;
t->lineNumber = lineNumber;
t->columnNumber = columnNumber;
t->text = text;
return std::move(t);
}
void PackageAwareVisitor::visit(Namespace* ns) {
bool added = false;
if (Maybe<ExtractedPackage> maybePackage = extractPackageFromNamespace(ns->namespaceUri)) {

49
tools/aapt2/xml/XmlDom.h
View File

@@ -32,12 +32,13 @@
namespace aapt {
namespace xml {
struct RawVisitor;
class RawVisitor;
/**
* Base class for all XML nodes.
*/
struct Node {
class Node {
public:
Node* parent = nullptr;
size_t lineNumber = 0;
size_t columnNumber = 0;
@@ -48,6 +49,7 @@ struct Node {
void addChild(std::unique_ptr<Node> child);
virtual void accept(RawVisitor* visitor) = 0;
virtual std::unique_ptr<Node> clone() = 0;
};
/**
@@ -55,16 +57,20 @@ struct Node {
* subclass of Node.
*/
template <typename Derived>
struct BaseNode : public Node {
class BaseNode : public Node {
public:
virtual void accept(RawVisitor* visitor) override;
};
/**
* A Namespace XML node. Can only have one child.
*/
struct Namespace : public BaseNode<Namespace> {
class Namespace : public BaseNode<Namespace> {
public:
std::string namespacePrefix;
std::string namespaceUri;
std::unique_ptr<Node> clone() override;
};
struct AaptAttribute {
@@ -87,7 +93,8 @@ struct Attribute {
/**
* An Element XML node.
*/
struct Element : public BaseNode<Element> {
class Element : public BaseNode<Element> {
public:
std::string namespaceUri;
std::string name;
std::vector<Attribute> attributes;
@@ -99,19 +106,24 @@ struct Element : public BaseNode<Element> {
const StringPiece& attrName,
const StringPiece& attrValue);
std::vector<xml::Element*> getChildElements();
std::unique_ptr<Node> clone() override;
};
/**
* A Text (CDATA) XML node. Can not have any children.
*/
struct Text : public BaseNode<Text> {
class Text : public BaseNode<Text> {
public:
std::string text;
std::unique_ptr<Node> clone() override;
};
/**
* An XML resource with a source, name, and XML tree.
*/
struct XmlResource {
class XmlResource {
public:
ResourceFile file;
std::unique_ptr<xml::Node> root;
};
@@ -136,7 +148,8 @@ Element* findRootElement(Node* node);
* A visitor interface for the different XML Node subtypes. This will not traverse into
* children. Use Visitor for that.
*/
struct RawVisitor {
class RawVisitor {
public:
virtual ~RawVisitor() = default;
virtual void visit(Namespace* node) {}
@@ -147,7 +160,8 @@ struct RawVisitor {
/**
* Visitor whose default implementation visits the children nodes of any node.
*/
struct Visitor : public RawVisitor {
class Visitor : public RawVisitor {
public:
using RawVisitor::visit;
void visit(Namespace* node) override {
@@ -173,6 +187,13 @@ struct Visitor : public RawVisitor {
* An XML DOM visitor that will record the package name for a namespace prefix.
*/
class PackageAwareVisitor : public Visitor, public IPackageDeclStack {
public:
using Visitor::visit;
void visit(Namespace* ns) override;
Maybe<ExtractedPackage> transformPackageAlias(
const StringPiece& alias, const StringPiece& localPackage) const override;
private:
struct PackageDecl {
std::string prefix;
@@ -180,13 +201,6 @@ private:
};
std::vector<PackageDecl> mPackageDecls;
public:
using Visitor::visit;
void visit(Namespace* ns) override;
Maybe<ExtractedPackage> transformPackageAlias(
const StringPiece& alias, const StringPiece& localPackage) const override;
};
// Implementations
@@ -197,7 +211,8 @@ void BaseNode<Derived>::accept(RawVisitor* visitor) {
}
template <typename T>
struct NodeCastImpl : public RawVisitor {
class NodeCastImpl : public RawVisitor {
public:
using RawVisitor::visit;
T* value = nullptr;

4
tools/aapt2/xml/XmlUtil.cpp
View File

@@ -23,8 +23,8 @@
namespace aapt {
namespace xml {
std::string buildPackageNamespace(const StringPiece& package) {
std::string result = kSchemaPublicPrefix;
std::string buildPackageNamespace(const StringPiece& package, bool privateReference) {
std::string result = privateReference ? kSchemaPrivatePrefix : kSchemaPublicPrefix;
result.append(package.data(), package.size());
return result;
}

7
tools/aapt2/xml/XmlUtil.h
View File

@@ -30,6 +30,7 @@ constexpr const char* kSchemaPublicPrefix = "http://schemas.android.com/apk/res/
constexpr const char* kSchemaPrivatePrefix = "http://schemas.android.com/apk/prv/res/";
constexpr const char* kSchemaAndroid = "http://schemas.android.com/apk/res/android";
constexpr const char* kSchemaTools = "http://schemas.android.com/tools";
constexpr const char* kSchemaAapt = "http://schemas.android.com/aapt";
/**
* Result of extracting a package name from a namespace URI declaration.
@@ -62,8 +63,12 @@ Maybe<ExtractedPackage> extractPackageFromNamespace(const std::string& namespace
* Returns an XML Android namespace for the given package of the form:
*
* http://schemas.android.com/apk/res/<package>
*
* If privateReference == true, the package will be of the form:
*
* http://schemas.android.com/apk/prv/res/<package>
*/
std::string buildPackageNamespace(const StringPiece& package);
std::string buildPackageNamespace(const StringPiece& package, bool privateReference=false);
/**
* Interface representing a stack of XML namespace declarations. When looking up the package