Merge "Filter products during compile phase"

13 files changed, 473 insertions, 290 deletions

diff --git a/tools/aapt2/Diagnostics.h b/tools/aapt2/Diagnostics.h
index d20ae1b92191..7ea26b3ed0df 100644
--- a/tools/aapt2/Diagnostics.h
+++ b/tools/aapt2/Diagnostics.h
@@ -51,12 +51,6 @@ public:
         mMessage << value;
         return *this;
     }
-/*
-    template <typename T> DiagMessage& operator<<(
-            const ::std::function<::std::ostream&(::std::ostream&)>& f) {
-        f(mMessage);
-        return *this;
-    }*/
 
     DiagMessageActual build() const {
         return DiagMessageActual{ mSource, mMessage.str() };
@@ -72,6 +66,8 @@ struct IDiagnostics {
 };
 
 struct StdErrDiagnostics : public IDiagnostics {
+    size_t mNumErrors = 0;
+
     void emit(const DiagMessage& msg, const char* tag) {
         DiagMessageActual actual = msg.build();
         if (!actual.source.path.empty()) {
@@ -81,7 +77,10 @@ struct StdErrDiagnostics : public IDiagnostics {
     }
 
     void error(const DiagMessage& msg) override {
-        emit(msg, "error: ");
+        if (mNumErrors < 20) {
+            emit(msg, "error: ");
+        }
+        mNumErrors++;
     }
 
     void warn(const DiagMessage& msg) override {
diff --git a/tools/aapt2/Resource.h b/tools/aapt2/Resource.h
index 31fe298670ae..7ef18973d89b 100644
--- a/tools/aapt2/Resource.h
+++ b/tools/aapt2/Resource.h
@@ -78,6 +78,9 @@ struct ResourceName {
     ResourceType type;
     std::u16string entry;
 
+    ResourceName() = default;
+    ResourceName(const StringPiece16& p, ResourceType t, const StringPiece16& e);
+
     bool isValid() const;
     bool operator<(const ResourceName& rhs) const;
     bool operator==(const ResourceName& rhs) const;
@@ -226,6 +229,10 @@ inline ::std::ostream& operator<<(::std::ostream& out, const ResourceType& val)
 // ResourceName implementation.
 //
 
+inline ResourceName::ResourceName(const StringPiece16& p, ResourceType t, const StringPiece16& e) :
+        package(p.toString()), type(t), entry(e.toString()) {
+}
+
 inline bool ResourceName::isValid() const {
     return !package.empty() && !entry.empty();
 }
diff --git a/tools/aapt2/ResourceParser.cpp b/tools/aapt2/ResourceParser.cpp
index 5e5fc5338e29..63629f0d6c10 100644
--- a/tools/aapt2/ResourceParser.cpp
+++ b/tools/aapt2/ResourceParser.cpp
@@ -49,8 +49,9 @@ static Maybe<StringPiece16> findNonEmptyAttribute(XmlPullParser* parser,
 }
 
 ResourceParser::ResourceParser(IDiagnostics* diag, ResourceTable* table, const Source& source,
-                               const ConfigDescription& config) :
-        mDiag(diag), mTable(table), mSource(source), mConfig(config) {
+                               const ConfigDescription& config,
+                               const ResourceParserOptions& options) :
+        mDiag(diag), mTable(table), mSource(source), mConfig(config), mOptions(options) {
 }
 
 /**
@@ -157,7 +158,62 @@ bool ResourceParser::parse(XmlPullParser* parser) {
     return !error;
 }
 
+static bool shouldStripResource(XmlPullParser* parser, const Maybe<std::u16string> productToMatch) {
+    assert(parser->getEvent() == XmlPullParser::Event::kStartElement);
+
+    if (Maybe<StringPiece16> maybeProduct = findNonEmptyAttribute(parser, u"product")) {
+        if (!productToMatch) {
+            if (maybeProduct.value() != u"default" && maybeProduct.value() != u"phone") {
+                // We didn't specify a product and this is not a default product, so skip.
+                return true;
+            }
+        } else {
+            if (productToMatch && maybeProduct.value() != productToMatch.value()) {
+                // We specified a product, but they don't match.
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+/**
+ * A parsed resource ready to be added to the ResourceTable.
+ */
+struct ParsedResource {
+    ResourceName name;
+    Source source;
+    ResourceId id;
+    bool markPublic = false;
+    std::unique_ptr<Value> value;
+    std::list<ParsedResource> childResources;
+};
+
+// Recursively adds resources to the ResourceTable.
+static bool addResourcesToTable(ResourceTable* table, const ConfigDescription& config,
+                                IDiagnostics* diag, ParsedResource* res) {
+    if (res->markPublic && !table->markPublic(res->name, res->id, res->source, diag)) {
+        return false;
+    }
+
+    if (!res->value) {
+        return true;
+    }
+
+    if (!table->addResource(res->name, res->id, config, res->source, std::move(res->value), diag)) {
+        return false;
+    }
+
+    bool error = false;
+    for (ParsedResource& child : res->childResources) {
+        error |= !addResourcesToTable(table, config, diag, &child);
+    }
+    return !error;
+}
+
 bool ResourceParser::parseResources(XmlPullParser* parser) {
+    std::set<ResourceName> strippedResources;
+
     bool error = false;
     std::u16string comment;
     const size_t depth = parser->getDepth();
@@ -198,9 +254,8 @@ bool ResourceParser::parseResources(XmlPullParser* parser) {
             continue;
         }
 
-        // Copy because our iterator will go out of scope when
-        // we parse more XML.
-        std::u16string name = maybeName.value().toString();
+        // Check if we should skip this product.
+        const bool stripResource = shouldStripResource(parser, mOptions.product);
 
         if (elementName == u"item") {
             // Items simply have their type encoded in the type attribute.
@@ -214,48 +269,85 @@ bool ResourceParser::parseResources(XmlPullParser* parser) {
             }
         }
 
-        if (elementName == u"id") {
-            error |= !mTable->addResource(ResourceNameRef{ {}, ResourceType::kId, name },
-                                          {}, mSource.withLine(parser->getLineNumber()),
-                                          util::make_unique<Id>(), mDiag);
+        ParsedResource parsedResource;
+        parsedResource.name.entry = maybeName.value().toString();
+        parsedResource.source = mSource.withLine(parser->getLineNumber());
 
+        bool result = true;
+        if (elementName == u"id") {
+            parsedResource.name.type = ResourceType::kId;
+            parsedResource.value = util::make_unique<Id>();
         } else if (elementName == u"string") {
-            error |= !parseString(parser, ResourceNameRef{ {}, ResourceType::kString, name });
+            parsedResource.name.type = ResourceType::kString;
+            result = parseString(parser, &parsedResource);
         } else if (elementName == u"color") {
-            error |= !parseColor(parser, ResourceNameRef{ {}, ResourceType::kColor, name });
+            parsedResource.name.type = ResourceType::kColor;
+            result = parseColor(parser, &parsedResource);
         } else if (elementName == u"drawable") {
-            error |= !parseColor(parser, ResourceNameRef{ {}, ResourceType::kDrawable, name });
+            parsedResource.name.type = ResourceType::kDrawable;
+            result = parseColor(parser, &parsedResource);
         } else if (elementName == u"bool") {
-            error |= !parsePrimitive(parser, ResourceNameRef{ {}, ResourceType::kBool, name });
+            parsedResource.name.type = ResourceType::kBool;
+            result = parsePrimitive(parser, &parsedResource);
         } else if (elementName == u"integer") {
-            error |= !parsePrimitive(parser, ResourceNameRef{ {}, ResourceType::kInteger, name });
+            parsedResource.name.type = ResourceType::kInteger;
+            result = parsePrimitive(parser, &parsedResource);
         } else if (elementName == u"dimen") {
-            error |= !parsePrimitive(parser, ResourceNameRef{ {}, ResourceType::kDimen, name });
+            parsedResource.name.type = ResourceType::kDimen;
+            result = parsePrimitive(parser, &parsedResource);
         } else if (elementName == u"style") {
-            error |= !parseStyle(parser, ResourceNameRef{ {}, ResourceType::kStyle, name });
+            parsedResource.name.type = ResourceType::kStyle;
+            result = parseStyle(parser, &parsedResource);
         } else if (elementName == u"plurals") {
-            error |= !parsePlural(parser, ResourceNameRef{ {}, ResourceType::kPlurals, name });
+            parsedResource.name.type = ResourceType::kPlurals;
+            result = parsePlural(parser, &parsedResource);
         } else if (elementName == u"array") {
-            error |= !parseArray(parser, ResourceNameRef{ {}, ResourceType::kArray, name },
-                                 android::ResTable_map::TYPE_ANY);
+            parsedResource.name.type = ResourceType::kArray;
+            result = parseArray(parser, &parsedResource, android::ResTable_map::TYPE_ANY);
         } else if (elementName == u"string-array") {
-            error |= !parseArray(parser, ResourceNameRef{ {}, ResourceType::kArray, name },
-                                 android::ResTable_map::TYPE_STRING);
+            parsedResource.name.type = ResourceType::kArray;
+            result = parseArray(parser, &parsedResource, android::ResTable_map::TYPE_STRING);
         } else if (elementName == u"integer-array") {
-            error |= !parseArray(parser, ResourceNameRef{ {}, ResourceType::kArray, name },
-                                 android::ResTable_map::TYPE_INTEGER);
-        } else if (elementName == u"public") {
-            error |= !parsePublic(parser, name);
+            parsedResource.name.type = ResourceType::kIntegerArray;
+            result = parseArray(parser, &parsedResource, android::ResTable_map::TYPE_INTEGER);
         } else if (elementName == u"declare-styleable") {
-            error |= !parseDeclareStyleable(parser,
-                                            ResourceNameRef{ {}, ResourceType::kStyleable, name });
+            parsedResource.name.type = ResourceType::kStyleable;
+            result = parseDeclareStyleable(parser, &parsedResource);
         } else if (elementName == u"attr") {
-            error |= !parseAttr(parser, ResourceNameRef{ {}, ResourceType::kAttr, name });
+            parsedResource.name.type = ResourceType::kAttr;
+            result = parseAttr(parser, &parsedResource);
+        } else if (elementName == u"public") {
+            result = parsePublic(parser, &parsedResource);
         } else {
             mDiag->warn(DiagMessage(mSource.withLine(parser->getLineNumber()))
                         << "unknown resource type '" << elementName << "'");
         }
+
+        if (result) {
+            // We successfully parsed the resource.
+
+            if (stripResource) {
+                // Record that we stripped out this resource name.
+                // We will check that at least one variant of this resource was included.
+                strippedResources.insert(parsedResource.name);
+            } else {
+                error |= !addResourcesToTable(mTable, mConfig, mDiag, &parsedResource);
+            }
+        } else {
+            error = true;
+        }
     }
+
+    // Check that we included at least one variant of each stripped resource.
+    for (const ResourceName& strippedResource : strippedResources) {
+        if (!mTable->findResource(strippedResource)) {
+            // Failed to find the resource.
+            mDiag->error(DiagMessage(mSource) << "resource '" << strippedResource << "' "
+                         "was filtered out but no product variant remains");
+            error = true;
+        }
+    }
+
     return !error;
 }
 
@@ -322,53 +414,43 @@ std::unique_ptr<Item> ResourceParser::parseXml(XmlPullParser* parser, uint32_t t
     return {};
 }
 
-bool ResourceParser::parseString(XmlPullParser* parser, const ResourceNameRef& resourceName) {
+bool ResourceParser::parseString(XmlPullParser* parser, ParsedResource* outResource) {
     const Source source = mSource.withLine(parser->getLineNumber());
 
     // TODO(adamlesinski): Read "untranslateable" attribute.
 
-    if (Maybe<StringPiece16> maybeProduct = findAttribute(parser, u"product")) {
-        if (maybeProduct.value() != u"default" && maybeProduct.value() != u"phone") {
-            // TODO(adamlesinski): Actually match product.
-            return true;
-        }
-    }
-
-    std::unique_ptr<Item> processedItem = parseXml(parser, android::ResTable_map::TYPE_STRING,
-                                                   kNoRawString);
-    if (!processedItem) {
+    outResource->value = parseXml(parser, android::ResTable_map::TYPE_STRING, kNoRawString);
+    if (!outResource->value) {
         mDiag->error(DiagMessage(source) << "not a valid string");
         return false;
     }
-    return mTable->addResource(resourceName, mConfig, source, std::move(processedItem),
-                               mDiag);
+    return true;
 }
 
-bool ResourceParser::parseColor(XmlPullParser* parser, const ResourceNameRef& resourceName) {
+bool ResourceParser::parseColor(XmlPullParser* parser, ParsedResource* outResource) {
     const Source source = mSource.withLine(parser->getLineNumber());
 
-    std::unique_ptr<Item> item = parseXml(parser, android::ResTable_map::TYPE_COLOR, kNoRawString);
-    if (!item) {
+    outResource->value = parseXml(parser, android::ResTable_map::TYPE_COLOR, kNoRawString);
+    if (!outResource->value) {
         mDiag->error(DiagMessage(source) << "invalid color");
         return false;
     }
-    return mTable->addResource(resourceName, mConfig, source, std::move(item),
-                               mDiag);
+    return true;
 }
 
-bool ResourceParser::parsePrimitive(XmlPullParser* parser, const ResourceNameRef& resourceName) {
+bool ResourceParser::parsePrimitive(XmlPullParser* parser, ParsedResource* outResource) {
     const Source source = mSource.withLine(parser->getLineNumber());
 
     uint32_t typeMask = 0;
-    switch (resourceName.type) {
+    switch (outResource->name.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;
+                  | android::ResTable_map::TYPE_FLOAT
+                  | android::ResTable_map::TYPE_FRACTION;
         break;
 
     case ResourceType::kBool:
@@ -380,16 +462,15 @@ bool ResourceParser::parsePrimitive(XmlPullParser* parser, const ResourceNameRef
         break;
     }
 
-    std::unique_ptr<Item> item = parseXml(parser, typeMask, kNoRawString);
-    if (!item) {
-        mDiag->error(DiagMessage(source) << "invalid " << resourceName.type);
+    outResource->value = parseXml(parser, typeMask, kNoRawString);
+    if (!outResource->value) {
+        mDiag->error(DiagMessage(source) << "invalid " << outResource->name.type);
         return false;
     }
-    return mTable->addResource(resourceName, mConfig, source, std::move(item),
-                               mDiag);
+    return true;
 }
 
-bool ResourceParser::parsePublic(XmlPullParser* parser, const StringPiece16& name) {
+bool ResourceParser::parsePublic(XmlPullParser* parser, ParsedResource* outResource) {
     const Source source = mSource.withLine(parser->getLineNumber());
 
     Maybe<StringPiece16> maybeType = findNonEmptyAttribute(parser, u"type");
@@ -405,27 +486,28 @@ bool ResourceParser::parsePublic(XmlPullParser* parser, const StringPiece16& nam
         return false;
     }
 
-    ResourceNameRef resourceName { {}, *parsedType, name };
-    ResourceId resourceId;
+    outResource->name.type = *parsedType;
 
     if (Maybe<StringPiece16> maybeId = findNonEmptyAttribute(parser, u"id")) {
         android::Res_value val;
         bool result = android::ResTable::stringToInt(maybeId.value().data(),
                                                      maybeId.value().size(), &val);
-        resourceId.id = val.data;
+        ResourceId resourceId(val.data);
         if (!result || !resourceId.isValid()) {
             mDiag->error(DiagMessage(source) << "invalid resource ID '" << maybeId.value()
                          << "' in <public>");
             return false;
         }
+        outResource->id = resourceId;
     }
 
     if (*parsedType == ResourceType::kId) {
         // An ID marked as public is also the definition of an ID.
-        mTable->addResource(resourceName, {}, source, util::make_unique<Id>(),
-                            mDiag);
+        outResource->value = util::make_unique<Id>();
     }
-    return mTable->markPublic(resourceName, resourceId, source, mDiag);
+
+    outResource->markPublic = true;
+    return true;
 }
 
 static uint32_t parseFormatType(const StringPiece16& piece) {
@@ -455,20 +537,13 @@ static uint32_t parseFormatAttribute(const StringPiece16& str) {
     return mask;
 }
 
-bool ResourceParser::parseAttr(XmlPullParser* parser, const ResourceNameRef& resourceName) {
-    const Source source = mSource.withLine(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),
-                               mDiag);
+
+bool ResourceParser::parseAttr(XmlPullParser* parser, ParsedResource* outResource) {
+    outResource->source = mSource.withLine(parser->getLineNumber());
+    return parseAttrImpl(parser, outResource, false);
 }
 
-std::unique_ptr<Attribute> ResourceParser::parseAttrImpl(XmlPullParser* parser,
-                                                         ResourceName* resourceName,
-                                                         bool weak) {
+bool ResourceParser::parseAttrImpl(XmlPullParser* parser, ParsedResource* outResource, bool weak) {
     uint32_t typeMask = 0;
 
     Maybe<StringPiece16> maybeFormat = findAttribute(parser, u"format");
@@ -477,7 +552,7 @@ std::unique_ptr<Attribute> ResourceParser::parseAttrImpl(XmlPullParser* parser,
         if (typeMask == 0) {
             mDiag->error(DiagMessage(mSource.withLine(parser->getLineNumber()))
                          << "invalid attribute format '" << maybeFormat.value() << "'");
-            return {};
+            return false;
         }
     }
 
@@ -486,10 +561,10 @@ std::unique_ptr<Attribute> ResourceParser::parseAttrImpl(XmlPullParser* parser,
     // No format attribute is allowed.
     if (weak && !maybeFormat) {
         StringPiece16 package, type, name;
-        ResourceUtils::extractResourceName(resourceName->entry, &package, &type, &name);
+        ResourceUtils::extractResourceName(outResource->name.entry, &package, &type, &name);
         if (type.empty() && !package.empty()) {
-            resourceName->package = package.toString();
-            resourceName->entry = name.toString();
+            outResource->name.package = package.toString();
+            outResource->name.entry = name.toString();
         }
     }
 
@@ -526,14 +601,12 @@ std::unique_ptr<Attribute> ResourceParser::parseAttrImpl(XmlPullParser* parser,
             }
 
             if (Maybe<Attribute::Symbol> s = parseEnumOrFlagItem(parser, elementName)) {
-                if (mTable->addResource(s.value().symbol.name.value(), mConfig,
-                                        mSource.withLine(parser->getLineNumber()),
-                                        util::make_unique<Id>(),
-                                        mDiag)) {
-                    items.push_back(std::move(s.value()));
-                } else {
-                    error = true;
-                }
+                ParsedResource childResource;
+                childResource.name = s.value().symbol.name.value();
+                childResource.source = mSource.withLine(parser->getLineNumber());
+                childResource.value = util::make_unique<Id>();
+                outResource->childResources.push_back(std::move(childResource));
+                items.push_back(std::move(s.value()));
             } else {
                 error = true;
             }
@@ -548,13 +621,14 @@ std::unique_ptr<Attribute> ResourceParser::parseAttrImpl(XmlPullParser* parser,
     }
 
     if (error) {
-        return {};
+        return false;
     }
 
     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;
+    outResource->value = std::move(attr);
+    return true;
 }
 
 Maybe<Attribute::Symbol> ResourceParser::parseEnumOrFlagItem(XmlPullParser* parser,
@@ -582,8 +656,8 @@ Maybe<Attribute::Symbol> ResourceParser::parseEnumOrFlagItem(XmlPullParser* pars
     }
 
     return Attribute::Symbol{
-            Reference(ResourceName{ {}, ResourceType::kId, maybeName.value().toString() }),
-            val.data };
+        Reference(ResourceName{ {}, ResourceType::kId, maybeName.value().toString() }),
+                val.data };
 }
 
 static Maybe<ResourceName> parseXmlAttributeName(StringPiece16 str) {
@@ -604,7 +678,7 @@ static Maybe<ResourceName> parseXmlAttributeName(StringPiece16 str) {
     }
 
     return ResourceName{ package.toString(), ResourceType::kAttr,
-                         name.empty() ? str.toString() : name.toString() };
+        name.empty() ? str.toString() : name.toString() };
 }
 
 
@@ -637,7 +711,7 @@ bool ResourceParser::parseStyleItem(XmlPullParser* parser, Style* style) {
     return true;
 }
 
-bool ResourceParser::parseStyle(XmlPullParser* parser, const ResourceNameRef& resourceName) {
+bool ResourceParser::parseStyle(XmlPullParser* parser, ParsedResource* outResource) {
     const Source source = mSource.withLine(parser->getLineNumber());
     std::unique_ptr<Style> style = util::make_unique<Style>();
 
@@ -660,12 +734,12 @@ bool ResourceParser::parseStyle(XmlPullParser* parser, const ResourceNameRef& re
 
     } else {
         // No parent was specified, so try inferring it from the style name.
-        std::u16string styleName = resourceName.entry.toString();
+        std::u16string styleName = outResource->name.entry;
         size_t pos = styleName.find_last_of(u'.');
         if (pos != std::string::npos) {
             style->parentInferred = true;
-            style->parent = Reference(ResourceName{
-                {}, ResourceType::kStyle, styleName.substr(0, pos) });
+            style->parent = Reference(
+                    ResourceName({}, ResourceType::kStyle, styleName.substr(0, pos)));
         }
     }
 
@@ -697,11 +771,12 @@ bool ResourceParser::parseStyle(XmlPullParser* parser, const ResourceNameRef& re
     if (error) {
         return false;
     }
-    return mTable->addResource(resourceName, mConfig, source, std::move(style),
-                               mDiag);
+
+    outResource->value = std::move(style);
+    return true;
 }
 
-bool ResourceParser::parseArray(XmlPullParser* parser, const ResourceNameRef& resourceName,
+bool ResourceParser::parseArray(XmlPullParser* parser, ParsedResource* outResource,
                                 uint32_t typeMask) {
     const Source source = mSource.withLine(parser->getLineNumber());
     std::unique_ptr<Array> array = util::make_unique<Array>();
@@ -741,11 +816,12 @@ bool ResourceParser::parseArray(XmlPullParser* parser, const ResourceNameRef& re
     if (error) {
         return false;
     }
-    return mTable->addResource(resourceName, mConfig, source, std::move(array),
-                               mDiag);
+
+    outResource->value = std::move(array);
+    return true;
 }
 
-bool ResourceParser::parsePlural(XmlPullParser* parser, const ResourceNameRef& resourceName) {
+bool ResourceParser::parsePlural(XmlPullParser* parser, ParsedResource* outResource) {
     const Source source = mSource.withLine(parser->getLineNumber());
     std::unique_ptr<Plural> plural = util::make_unique<Plural>();
 
@@ -816,11 +892,12 @@ bool ResourceParser::parsePlural(XmlPullParser* parser, const ResourceNameRef& r
     if (error) {
         return false;
     }
-    return mTable->addResource(resourceName, mConfig, source, std::move(plural), mDiag);
+
+    outResource->value = std::move(plural);
+    return true;
 }
 
-bool ResourceParser::parseDeclareStyleable(XmlPullParser* parser,
-                                           const ResourceNameRef& resourceName) {
+bool ResourceParser::parseDeclareStyleable(XmlPullParser* parser, ParsedResource* outResource) {
     const Source source = mSource.withLine(parser->getLineNumber());
     std::unique_ptr<Styleable> styleable = util::make_unique<Styleable>();
 
@@ -844,22 +921,17 @@ bool ResourceParser::parseDeclareStyleable(XmlPullParser* parser,
                 continue;
             }
 
-            // Copy because our iterator will be invalidated.
-            ResourceName attrResourceName = { {}, ResourceType::kAttr, attrIter->value };
+            ParsedResource childResource;
+            childResource.name = ResourceName({}, ResourceType::kAttr, attrIter->value);
+            childResource.source = mSource.withLine(parser->getLineNumber());
 
-            std::unique_ptr<Attribute> attr = parseAttrImpl(parser, &attrResourceName, true);
-            if (!attr) {
+            if (!parseAttrImpl(parser, &childResource, true)) {
                 error = true;
                 continue;
             }
 
-            styleable->entries.emplace_back(attrResourceName);
-
-            // Add the attribute to the resource table. Since it is weakly defined,
-            // it won't collide.
-            error |= !mTable->addResource(attrResourceName, mConfig,
-                                          mSource.withLine(parser->getLineNumber()),
-                                          std::move(attr), mDiag);
+            styleable->entries.push_back(Reference(childResource.name));
+            outResource->childResources.push_back(std::move(childResource));
 
         } else if (elementNamespace.empty() &&
                 (elementName == u"skip" || elementName == u"eat-comment")) {
@@ -875,7 +947,9 @@ bool ResourceParser::parseDeclareStyleable(XmlPullParser* parser,
     if (error) {
         return false;
     }
-    return mTable->addResource(resourceName, mConfig, source, std::move(styleable), mDiag);
+
+    outResource->value = std::move(styleable);
+    return true;
 }
 
 } // namespace aapt
diff --git a/tools/aapt2/ResourceParser.h b/tools/aapt2/ResourceParser.h
index 514e55852407..5ccd47f2b6a7 100644
--- a/tools/aapt2/ResourceParser.h
+++ b/tools/aapt2/ResourceParser.h
@@ -31,13 +31,24 @@
 
 namespace aapt {
 
+struct ParsedResource;
+
+struct ResourceParserOptions {
+    /**
+     * Optional product name by which to filter resources.
+     * This is like a preprocessor definition in that we strip out resources
+     * that don't match before we compile them.
+     */
+    Maybe<std::u16string> product;
+};
+
 /*
  * Parses an XML file for resources and adds them to a ResourceTable.
  */
 class ResourceParser {
 public:
     ResourceParser(IDiagnostics* diag, ResourceTable* table, const Source& source,
-                   const ConfigDescription& config);
+                   const ConfigDescription& config, const ResourceParserOptions& options = {});
 
     ResourceParser(const ResourceParser&) = delete; // No copy.
 
@@ -62,25 +73,24 @@ private:
     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 parseString(XmlPullParser* parser, ParsedResource* outResource);
+    bool parseColor(XmlPullParser* parser, ParsedResource* outResource);
+    bool parsePrimitive(XmlPullParser* parser, ParsedResource* outResource);
+    bool parsePublic(XmlPullParser* parser, ParsedResource* outResource);
+    bool parseAttr(XmlPullParser* parser, ParsedResource* outResource);
+    bool parseAttrImpl(XmlPullParser* parser, ParsedResource* outResource, bool weak);
     Maybe<Attribute::Symbol> parseEnumOrFlagItem(XmlPullParser* parser, const StringPiece16& tag);
-    bool parseStyle(XmlPullParser* parser, const ResourceNameRef& resourceName);
+    bool parseStyle(XmlPullParser* parser, ParsedResource* outResource);
     bool parseStyleItem(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);
+    bool parseDeclareStyleable(XmlPullParser* parser, ParsedResource* outResource);
+    bool parseArray(XmlPullParser* parser, ParsedResource* outResource, uint32_t typeMask);
+    bool parsePlural(XmlPullParser* parser, ParsedResource* outResource);
 
     IDiagnostics* mDiag;
     ResourceTable* mTable;
     Source mSource;
     ConfigDescription mConfig;
+    ResourceParserOptions mOptions;
 };
 
 } // namespace aapt
diff --git a/tools/aapt2/ResourceParser_test.cpp b/tools/aapt2/ResourceParser_test.cpp
index cb98afd18c5a..a7e9d390ef4a 100644
--- a/tools/aapt2/ResourceParser_test.cpp
+++ b/tools/aapt2/ResourceParser_test.cpp
@@ -48,10 +48,12 @@ struct ResourceParserTest : public ::testing::Test {
         mContext = test::ContextBuilder().build();
     }
 
-    ::testing::AssertionResult testParse(const StringPiece& str) {
+    ::testing::AssertionResult testParse(const StringPiece& str,
+                                         Maybe<std::u16string> product = {}) {
         std::stringstream input(kXmlPreamble);
         input << "<resources>\n" << str << "\n</resources>" << std::endl;
-        ResourceParser parser(mContext->getDiagnostics(), &mTable, Source{ "test" }, {});
+        ResourceParser parser(mContext->getDiagnostics(), &mTable, Source{ "test" }, {},
+                              ResourceParserOptions{ product });
         XmlPullParser xmlParser(input);
         if (parser.parse(&xmlParser)) {
             return ::testing::AssertionSuccess();
@@ -314,6 +316,9 @@ TEST_F(ResourceParserTest, ParseAttributesDeclareStyleable) {
     std::string input = "<declare-styleable name=\"foo\">\n"
                         "  <attr name=\"bar\" />\n"
                         "  <attr name=\"bat\" format=\"string|reference\"/>\n"
+                        "  <attr name=\"baz\">\n"
+                        "    <enum name=\"foo\" value=\"1\"/>\n"
+                        "  </attr>\n"
                         "</declare-styleable>";
     ASSERT_TRUE(testParse(input));
 
@@ -325,9 +330,16 @@ TEST_F(ResourceParserTest, ParseAttributesDeclareStyleable) {
     ASSERT_NE(attr, nullptr);
     EXPECT_TRUE(attr->isWeak());
 
+    attr = test::getValue<Attribute>(&mTable, u"@attr/baz");
+    ASSERT_NE(attr, nullptr);
+    EXPECT_TRUE(attr->isWeak());
+    EXPECT_EQ(1u, attr->symbols.size());
+
+    EXPECT_NE(nullptr, test::getValue<Id>(&mTable, u"@id/foo"));
+
     Styleable* styleable = test::getValue<Styleable>(&mTable, u"@styleable/foo");
     ASSERT_NE(styleable, nullptr);
-    ASSERT_EQ(2u, styleable->entries.size());
+    ASSERT_EQ(3u, styleable->entries.size());
 
     EXPECT_EQ(test::parseNameOrDie(u"@attr/bar"), styleable->entries[0].name.value());
     EXPECT_EQ(test::parseNameOrDie(u"@attr/bat"), styleable->entries[1].name.value());
@@ -350,6 +362,14 @@ TEST_F(ResourceParserTest, ParseArray) {
     EXPECT_NE(nullptr, valueCast<BinaryPrimitive>(array->items[2].get()));
 }
 
+TEST_F(ResourceParserTest, ParseStringArray) {
+    std::string input = "<string-array name=\"foo\">\n"
+                        "  <item>\"Werk\"</item>\n"
+                        "</string-array>\n";
+    ASSERT_TRUE(testParse(input));
+    EXPECT_NE(nullptr, test::getValue<Array>(&mTable, u"@array/foo"));
+}
+
 TEST_F(ResourceParserTest, ParsePlural) {
     std::string input = "<plurals name=\"foo\">\n"
                         "  <item quantity=\"other\">apples</item>\n"
@@ -385,4 +405,24 @@ TEST_F(ResourceParserTest, ParsePublicIdAsDefinition) {
     ASSERT_NE(nullptr, id);
 }
 
+TEST_F(ResourceParserTest, FilterProductsThatDontMatch) {
+    std::string input = "<string name=\"foo\" product=\"phone\">hi</string>\n"
+                        "<string name=\"foo\" product=\"no-sdcard\">ho</string>\n"
+                        "<string name=\"bar\" product=\"\">wee</string>\n"
+                        "<string name=\"baz\">woo</string>\n";
+    ASSERT_TRUE(testParse(input, std::u16string(u"no-sdcard")));
+
+    String* fooStr = test::getValue<String>(&mTable, u"@string/foo");
+    ASSERT_NE(nullptr, fooStr);
+    EXPECT_EQ(StringPiece16(u"ho"), *fooStr->value);
+
+    EXPECT_NE(nullptr, test::getValue<String>(&mTable, u"@string/bar"));
+    EXPECT_NE(nullptr, test::getValue<String>(&mTable, u"@string/baz"));
+}
+
+TEST_F(ResourceParserTest, FailWhenProductFilterStripsOutAllVersionsOfResource) {
+    std::string input = "<string name=\"foo\" product=\"tablet\">hello</string>\n";
+    ASSERT_FALSE(testParse(input, std::u16string(u"phone")));
+}
+
 } // namespace aapt
diff --git a/tools/aapt2/ResourceTable.cpp b/tools/aapt2/ResourceTable.cpp
index a1e7d36d91d9..e32fb5ee22ea 100644
--- a/tools/aapt2/ResourceTable.cpp
+++ b/tools/aapt2/ResourceTable.cpp
@@ -62,17 +62,17 @@ ResourceTablePackage* ResourceTable::findPackageById(uint8_t id) {
     return nullptr;
 }
 
-ResourceTablePackage* ResourceTable::createPackage(const StringPiece16& name, uint8_t id) {
+ResourceTablePackage* ResourceTable::createPackage(const StringPiece16& name, Maybe<uint8_t> id) {
     ResourceTablePackage* package = findOrCreatePackage(name);
-    if (!package->id) {
+    if (id && !package->id) {
         package->id = id;
         return package;
     }
 
-    if (package->id.value() == id) {
-        return package;
+    if (id && package->id && package->id.value() != id.value()) {
+        return nullptr;
     }
-    return nullptr;
+    return package;
 }
 
 ResourceTablePackage* ResourceTable::findOrCreatePackage(const StringPiece16& name) {
diff --git a/tools/aapt2/ResourceTable.h b/tools/aapt2/ResourceTable.h
index a00c14276aa4..60fed2f0e26b 100644
--- a/tools/aapt2/ResourceTable.h
+++ b/tools/aapt2/ResourceTable.h
@@ -176,9 +176,9 @@ public:
     bool markPublicAllowMangled(const ResourceNameRef& name, const ResourceId resId,
                                 const Source& source, IDiagnostics* diag);
     struct SearchResult {
-	ResourceTablePackage* package;
-	ResourceTableType* type;
-	ResourceEntry* entry;
+        ResourceTablePackage* package;
+        ResourceTableType* type;
+        ResourceEntry* entry;
     };
 
     Maybe<SearchResult> findResource(const ResourceNameRef& name);
@@ -208,7 +208,7 @@ public:
 
     ResourceTablePackage* findPackageById(uint8_t id);
 
-    ResourceTablePackage* createPackage(const StringPiece16& name, uint8_t id);
+    ResourceTablePackage* createPackage(const StringPiece16& name, Maybe<uint8_t> id = {});
 
 private:
     ResourceTablePackage* findOrCreatePackage(const StringPiece16& name);
diff --git a/tools/aapt2/compile/Compile.cpp b/tools/aapt2/compile/Compile.cpp
index 498bc9c162d3..0bc5dce13cbd 100644
--- a/tools/aapt2/compile/Compile.cpp
+++ b/tools/aapt2/compile/Compile.cpp
@@ -102,6 +102,7 @@ static Maybe<ResourcePathData> extractResourcePathData(const std::string& path,
 
 struct CompileOptions {
     std::string outputPath;
+    Maybe<std::u16string> product;
     bool verbose = false;
 };
 
@@ -121,8 +122,6 @@ static std::string buildIntermediateFilename(const std::string outDir,
 static bool compileTable(IAaptContext* context, const CompileOptions& options,
                          const ResourcePathData& pathData, const std::string& outputPath) {
     ResourceTable table;
-    table.createPackage(u"", 0x7f);
-
     {
         std::ifstream fin(pathData.source.path, std::ifstream::binary);
         if (!fin) {
@@ -134,7 +133,7 @@ static bool compileTable(IAaptContext* context, const CompileOptions& options,
         // Parse the values file from XML.
         XmlPullParser xmlParser(fin);
         ResourceParser resParser(context->getDiagnostics(), &table, pathData.source,
-                                 pathData.config);
+                                 pathData.config, ResourceParserOptions{ options.product });
         if (!resParser.parse(&xmlParser)) {
             return false;
         }
@@ -142,6 +141,12 @@ static bool compileTable(IAaptContext* context, const CompileOptions& options,
         fin.close();
     }
 
+    ResourceTablePackage* pkg = table.createPackage(context->getCompilationPackage());
+    if (!pkg->id) {
+        // If no package ID was set while parsing (public identifiers), auto assign an ID.
+        pkg->id = context->getPackageId();
+    }
+
     // Assign IDs to prepare the table for flattening.
     IdAssigner idAssigner;
     if (!idAssigner.consume(context, &table)) {
@@ -325,7 +330,7 @@ public:
     }
 
     uint8_t getPackageId() override {
-       return 0x7f;
+       return 0x0;
     }
 
     ISymbolTable* getExternalSymbols() override {
@@ -340,13 +345,19 @@ public:
 int compile(const std::vector<StringPiece>& args) {
     CompileOptions options;
 
+    Maybe<std::string> product;
     Flags flags = Flags()
             .requiredFlag("-o", "Output path", &options.outputPath)
+            .optionalFlag("--product", "Product type to compile", &product)
             .optionalSwitch("-v", "Enables verbose logging", &options.verbose);
     if (!flags.parse("aapt2 compile", args, &std::cerr)) {
         return 1;
     }
 
+    if (product) {
+        options.product = util::utf8ToUtf16(product.value());
+    }
+
     CompileContext context;
 
     std::vector<ResourcePathData> inputData;
diff --git a/tools/aapt2/flatten/TableFlattener.cpp b/tools/aapt2/flatten/TableFlattener.cpp
index 427ab18567bd..75cbd5d7baa1 100644
--- a/tools/aapt2/flatten/TableFlattener.cpp
+++ b/tools/aapt2/flatten/TableFlattener.cpp
@@ -23,9 +23,9 @@
 #include "flatten/TableFlattener.h"
 #include "util/BigBuffer.h"
 
+#include <base/macros.h>
 #include <type_traits>
 #include <numeric>
-#include <utils/misc.h>
 
 using namespace android;
 
@@ -59,20 +59,32 @@ struct FlatEntry {
     uint32_t sourceLine;
 };
 
-struct SymbolWriter {
+class SymbolWriter {
+public:
     struct Entry {
         StringPool::Ref name;
         size_t offset;
     };
 
-    StringPool pool;
     std::vector<Entry> symbols;
 
+    explicit SymbolWriter(StringPool* pool) : mPool(pool) {
+    }
+
     void addSymbol(const ResourceNameRef& name, size_t offset) {
-        symbols.push_back(Entry{ pool.makeRef(name.package.toString() + u":" +
-                                              toString(name.type).toString() + u"/" +
-                                              name.entry.toString()), offset });
+        symbols.push_back(Entry{ mPool->makeRef(name.package.toString() + u":" +
+                                               toString(name.type).toString() + u"/" +
+                                               name.entry.toString()), offset });
+    }
+
+    void shiftAllOffsets(size_t offset) {
+        for (Entry& entry : symbols) {
+            entry.offset += offset;
+        }
     }
+
+private:
+    StringPool* mPool;
 };
 
 struct MapFlattenVisitor : public RawValueVisitor {
@@ -226,15 +238,59 @@ struct MapFlattenVisitor : public RawValueVisitor {
     }
 };
 
-struct PackageFlattener {
+class PackageFlattener {
+public:
+    PackageFlattener(IDiagnostics* diag, TableFlattenerOptions options,
+                     ResourceTablePackage* package, SymbolWriter* symbolWriter,
+                     StringPool* sourcePool) :
+            mDiag(diag), mOptions(options), mPackage(package), mSymbols(symbolWriter),
+            mSourcePool(sourcePool) {
+    }
+
+    bool flattenPackage(BigBuffer* buffer) {
+        ChunkWriter pkgWriter(buffer);
+        ResTable_package* pkgHeader = pkgWriter.startChunk<ResTable_package>(
+                RES_TABLE_PACKAGE_TYPE);
+        pkgHeader->id = util::hostToDevice32(mPackage->id.value());
+
+        if (mPackage->name.size() >= arraysize(pkgHeader->name)) {
+            mDiag->error(DiagMessage() <<
+                         "package name '" << mPackage->name << "' is too long");
+            return false;
+        }
+
+        // Copy the package name in device endianness.
+        strcpy16_htod(pkgHeader->name, arraysize(pkgHeader->name), mPackage->name);
+
+        // Serialize the types. We do this now so that our type and key strings
+        // are populated. We write those first.
+        BigBuffer typeBuffer(1024);
+        flattenTypes(&typeBuffer);
+
+        pkgHeader->typeStrings = util::hostToDevice32(pkgWriter.size());
+        StringPool::flattenUtf16(pkgWriter.getBuffer(), mTypePool);
+
+        pkgHeader->keyStrings = util::hostToDevice32(pkgWriter.size());
+        StringPool::flattenUtf16(pkgWriter.getBuffer(), mKeyPool);
+
+        // Add the ResTable_package header/type/key strings to the offset.
+        mSymbols->shiftAllOffsets(pkgWriter.size());
+
+        // Append the types.
+        buffer->appendBuffer(std::move(typeBuffer));
+
+        pkgWriter.finish();
+        return true;
+    }
+
+private:
     IDiagnostics* mDiag;
     TableFlattenerOptions mOptions;
-    ResourceTable* mTable;
     ResourceTablePackage* mPackage;
-    SymbolWriter mSymbols;
     StringPool mTypePool;
     StringPool mKeyPool;
-    StringPool mSourcePool;
+    SymbolWriter* mSymbols;
+    StringPool* mSourcePool;
 
     template <typename T>
     T* writeEntry(FlatEntry* entry, BigBuffer* buffer) {
@@ -278,8 +334,8 @@ struct PackageFlattener {
             if (Reference* ref = valueCast<Reference>(entry->value)) {
                 if (!ref->id) {
                     assert(ref->name && "reference must have at least a name");
-                    mSymbols.addSymbol(ref->name.value(),
-                                       buffer->size() + offsetof(Res_value, data));
+                    mSymbols->addSymbol(ref->name.value(),
+                                        buffer->size() + offsetof(Res_value, data));
                 }
             }
             Res_value* outValue = buffer->nextBlock<Res_value>();
@@ -289,12 +345,12 @@ struct PackageFlattener {
         } else {
             const size_t beforeEntry = buffer->size();
             ResTable_entry_ext* outEntry = writeEntry<ResTable_entry_ext>(entry, buffer);
-            MapFlattenVisitor visitor(&mSymbols, entry, buffer);
+            MapFlattenVisitor visitor(mSymbols, entry, buffer);
             entry->value->accept(&visitor);
             outEntry->count = util::hostToDevice32(visitor.mEntryCount);
             if (visitor.mParentName) {
-                mSymbols.addSymbol(visitor.mParentName.value(),
-                                   beforeEntry + offsetof(ResTable_entry_ext, parent));
+                mSymbols->addSymbol(visitor.mParentName.value(),
+                                    beforeEntry + offsetof(ResTable_entry_ext, parent));
             } else if (visitor.mParentIdent) {
                 outEntry->parent.ident = util::hostToDevice32(visitor.mParentIdent.value());
             }
@@ -430,7 +486,7 @@ struct PackageFlattener {
                 publicEntry->entryId = util::hostToDevice32(entry->id.value());
                 publicEntry->key.index = util::hostToDevice32(mKeyPool.makeRef(
                         entry->name).getIndex());
-                publicEntry->source.index = util::hostToDevice32(mSourcePool.makeRef(
+                publicEntry->source.index = util::hostToDevice32(mSourcePool->makeRef(
                         util::utf8ToUtf16(entry->publicStatus.source.path)).getIndex());
                 if (entry->publicStatus.source.line) {
                     publicEntry->sourceLine = util::hostToDevice32(
@@ -487,7 +543,7 @@ struct PackageFlattener {
                 for (auto& configValue : entry->values) {
                    configToEntryListMap[configValue.config].push_back(FlatEntry{
                             entry, configValue.value.get(), (uint32_t) keyIndex,
-                            (uint32_t)(mSourcePool.makeRef(util::utf8ToUtf16(
+                            (uint32_t)(mSourcePool->makeRef(util::utf8ToUtf16(
                                     configValue.source.path)).getIndex()),
                             (uint32_t)(configValue.source.line
                                     ? configValue.source.line.value() : 0)
@@ -504,141 +560,113 @@ struct PackageFlattener {
         }
         return true;
     }
+};
 
-    bool flattenPackage(BigBuffer* buffer) {
-        // We must do this before writing the resources, since the string pool IDs may change.
-        mTable->stringPool.sort([](const StringPool::Entry& a, const StringPool::Entry& b) -> bool {
-            int diff = a.context.priority - b.context.priority;
-            if (diff < 0) return true;
-            if (diff > 0) return false;
-            diff = a.context.config.compare(b.context.config);
-            if (diff < 0) return true;
-            if (diff > 0) return false;
-            return a.value < b.value;
-        });
-        mTable->stringPool.prune();
-
-        const size_t beginningIndex = buffer->size();
+} // namespace
 
-        BigBuffer typeBuffer(1024);
-        if (!flattenTypes(&typeBuffer)) {
+bool TableFlattener::consume(IAaptContext* context, ResourceTable* table) {
+    // We must do this before writing the resources, since the string pool IDs may change.
+    table->stringPool.sort([](const StringPool::Entry& a, const StringPool::Entry& b) -> bool {
+        int diff = a.context.priority - b.context.priority;
+        if (diff < 0) return true;
+        if (diff > 0) return false;
+        diff = a.context.config.compare(b.context.config);
+        if (diff < 0) return true;
+        if (diff > 0) return false;
+        return a.value < b.value;
+    });
+    table->stringPool.prune();
+
+    // Write the ResTable header.
+    ChunkWriter tableWriter(mBuffer);
+    ResTable_header* tableHeader = tableWriter.startChunk<ResTable_header>(RES_TABLE_TYPE);
+    tableHeader->packageCount = util::hostToDevice32(table->packages.size());
+
+    // Flatten the values string pool.
+    StringPool::flattenUtf8(tableWriter.getBuffer(), table->stringPool);
+
+    // If we have a reference to a symbol that doesn't exist, we don't know its resource ID.
+    // We encode the name of the symbol along with the offset of where to include the resource ID
+    // once it is found.
+    StringPool symbolPool;
+    std::vector<SymbolWriter::Entry> symbolOffsets;
+
+    // String pool holding the source paths of each value.
+    StringPool sourcePool;
+
+    BigBuffer packageBuffer(1024);
+
+    // Flatten each package.
+    for (auto& package : table->packages) {
+        const size_t beforePackageSize = packageBuffer.size();
+
+        // All packages will share a single global symbol pool.
+        SymbolWriter packageSymbolWriter(&symbolPool);
+
+        PackageFlattener flattener(context->getDiagnostics(), mOptions, package.get(),
+                                   &packageSymbolWriter, &sourcePool);
+        if (!flattener.flattenPackage(&packageBuffer)) {
             return false;
         }
 
-        ChunkWriter tableWriter(buffer);
-        ResTable_header* tableHeader = tableWriter.startChunk<ResTable_header>(RES_TABLE_TYPE);
-        tableHeader->packageCount = util::hostToDevice32(1);
+        // The symbols are offset only from their own Package start. Offset them from the
+        // start of the packageBuffer.
+        packageSymbolWriter.shiftAllOffsets(beforePackageSize);
+
+        // Extract all the symbols to offset
+        symbolOffsets.insert(symbolOffsets.end(),
+                             std::make_move_iterator(packageSymbolWriter.symbols.begin()),
+                             std::make_move_iterator(packageSymbolWriter.symbols.end()));
+    }
 
-        SymbolTable_entry* symbolEntryData = nullptr;
-        if (mOptions.useExtendedChunks && !mSymbols.symbols.empty()) {
+    SymbolTable_entry* symbolEntryData = nullptr;
+    if (mOptions.useExtendedChunks) {
+        if (!symbolOffsets.empty()) {
             // Sort the offsets so we can scan them linearly.
-            std::sort(mSymbols.symbols.begin(), mSymbols.symbols.end(),
+            std::sort(symbolOffsets.begin(), symbolOffsets.end(),
                       [](const SymbolWriter::Entry& a, const SymbolWriter::Entry& b) -> bool {
                           return a.offset < b.offset;
                       });
 
+            // Write the Symbol header.
             ChunkWriter symbolWriter(tableWriter.getBuffer());
             SymbolTable_header* symbolHeader = symbolWriter.startChunk<SymbolTable_header>(
                     RES_TABLE_SYMBOL_TABLE_TYPE);
-            symbolHeader->count = util::hostToDevice32(mSymbols.symbols.size());
+            symbolHeader->count = util::hostToDevice32(symbolOffsets.size());
 
-            symbolEntryData = symbolWriter.nextBlock<SymbolTable_entry>(mSymbols.symbols.size());
-            StringPool::flattenUtf8(symbolWriter.getBuffer(), mSymbols.pool);
+            symbolEntryData = symbolWriter.nextBlock<SymbolTable_entry>(symbolOffsets.size());
+            StringPool::flattenUtf8(symbolWriter.getBuffer(), symbolPool);
             symbolWriter.finish();
         }
 
-        if (mOptions.useExtendedChunks && mSourcePool.size() > 0) {
+        if (sourcePool.size() > 0) {
             // Write out source pool.
             ChunkWriter srcWriter(tableWriter.getBuffer());
             srcWriter.startChunk<ResChunk_header>(RES_TABLE_SOURCE_POOL_TYPE);
-            StringPool::flattenUtf8(srcWriter.getBuffer(), mSourcePool);
+            StringPool::flattenUtf8(srcWriter.getBuffer(), sourcePool);
             srcWriter.finish();
         }
-
-        StringPool::flattenUtf8(tableWriter.getBuffer(), mTable->stringPool);
-
-        ChunkWriter pkgWriter(tableWriter.getBuffer());
-        ResTable_package* pkgHeader = pkgWriter.startChunk<ResTable_package>(
-                RES_TABLE_PACKAGE_TYPE);
-        pkgHeader->id = util::hostToDevice32(mPackage->id.value());
-
-        if (mPackage->name.size() >= NELEM(pkgHeader->name)) {
-            mDiag->error(DiagMessage() <<
-                         "package name '" << mPackage->name << "' is too long");
-            return false;
-        }
-
-        strcpy16_htod(pkgHeader->name, NELEM(pkgHeader->name), mPackage->name);
-
-        pkgHeader->typeStrings = util::hostToDevice32(pkgWriter.size());
-        StringPool::flattenUtf16(pkgWriter.getBuffer(), mTypePool);
-
-        pkgHeader->keyStrings = util::hostToDevice32(pkgWriter.size());
-        StringPool::flattenUtf16(pkgWriter.getBuffer(), mKeyPool);
-
-        // Actually write out the symbol entries if we have symbols.
-        if (symbolEntryData) {
-            for (auto& entry : mSymbols.symbols) {
-                symbolEntryData->stringIndex = util::hostToDevice32(entry.name.getIndex());
-
-                // The symbols were all calculated with the typeBuffer offset. We need to
-                // add the beginning of the output buffer.
-                symbolEntryData->offset = util::hostToDevice32(
-                        (pkgWriter.getBuffer()->size() - beginningIndex) + entry.offset);
-
-                symbolEntryData++;
-            }
-        }
-
-        // Write out the types and entries.
-        pkgWriter.getBuffer()->appendBuffer(std::move(typeBuffer));
-
-        pkgWriter.finish();
-        tableWriter.finish();
-        return true;
     }
-};
-
-} // namespace
 
-bool TableFlattener::consume(IAaptContext* context, ResourceTable* table) {
-    for (auto& package : table->packages) {
-        // Only support flattening one package. Since the StringPool is shared between packages
-        // in ResourceTable, we must fail if other packages are present, since their strings
-        // will be included in the final ResourceTable.
-        if (context->getCompilationPackage() != package->name) {
-            context->getDiagnostics()->error(DiagMessage()
-                                             << "resources for package '" << package->name
-                                             << "' can't be flattened when compiling package '"
-                                             << context->getCompilationPackage() << "'");
-            return false;
-        }
+    const size_t beforePackagesSize = tableWriter.size();
 
-        if (!package->id || package->id.value() != context->getPackageId()) {
-            context->getDiagnostics()->error(DiagMessage()
-                                             << "package '" << package->name << "' must have "
-                                             << "package id "
-                                             << std::hex << context->getPackageId() << std::dec);
-            return false;
-        }
+    // Finally merge all the packages into the main buffer.
+    tableWriter.getBuffer()->appendBuffer(std::move(packageBuffer));
 
-        PackageFlattener flattener = {
-                context->getDiagnostics(),
-                mOptions,
-                table,
-                package.get()
-        };
+    // Update the offsets to their final values.
+    if (symbolEntryData) {
+        for (SymbolWriter::Entry& entry : symbolOffsets) {
+            symbolEntryData->stringIndex = util::hostToDevice32(entry.name.getIndex());
 
-        if (!flattener.flattenPackage(mBuffer)) {
-            return false;
+            // The symbols were all calculated with the packageBuffer offset. We need to
+            // add the beginning of the output buffer.
+            symbolEntryData->offset = util::hostToDevice32(entry.offset + beforePackagesSize);
+            symbolEntryData++;
         }
-        return true;
     }
 
-    context->getDiagnostics()->error(DiagMessage()
-                                     << "compilation package '" << context->getCompilationPackage()
-                                     << "' not found");
-    return false;
+    tableWriter.finish();
+    return true;
 }
 
 } // namespace aapt
diff --git a/tools/aapt2/link/Link.cpp b/tools/aapt2/link/Link.cpp
index 2b4c4d20b791..fa321a01d303 100644
--- a/tools/aapt2/link/Link.cpp
+++ b/tools/aapt2/link/Link.cpp
@@ -52,6 +52,7 @@ struct LinkOptions {
     bool staticLib = false;
     bool verbose = false;
     bool outputToDirectory = false;
+    Maybe<std::string> privateSymbols;
 };
 
 struct LinkContext : public IAaptContext {
@@ -400,7 +401,13 @@ struct LinkCommand {
 
         mContext.mNameMangler = util::make_unique<NameMangler>(
                 NameManglerPolicy{ mContext.mCompilationPackage });
-        mContext.mPackageId = 0x7f;
+
+        if (mContext.mCompilationPackage == u"android") {
+            mContext.mPackageId = 0x01;
+        } else {
+            mContext.mPackageId = 0x7f;
+        }
+
         mContext.mSymbols = createSymbolTableFromIncludePaths();
         if (!mContext.mSymbols) {
             return 1;
@@ -689,6 +696,9 @@ int link(const std::vector<StringPiece>& args) {
                             "by -o",
                             &options.outputToDirectory)
             .optionalSwitch("--static-lib", "Generate a static Android library", &options.staticLib)
+            .optionalFlag("--private-symbols", "Package name to use when generating R.java for "
+                          "private symbols. If not specified, public and private symbols will "
+                          "use the application's package name", &options.privateSymbols)
             .optionalSwitch("-v", "Enables verbose logging", &options.verbose);
 
     if (!flags.parse("aapt2 link", args, &std::cerr)) {
diff --git a/tools/aapt2/link/TableMerger.cpp b/tools/aapt2/link/TableMerger.cpp
index d5fd1fc49c85..0d63b976936e 100644
--- a/tools/aapt2/link/TableMerger.cpp
+++ b/tools/aapt2/link/TableMerger.cpp
@@ -39,7 +39,7 @@ bool TableMerger::merge(const Source& src, ResourceTable* table) {
     bool error = false;
     for (auto& package : table->packages) {
         // Warn of packages with an unrelated ID.
-        if (package->id && package->id.value() != desiredPackageId) {
+        if (package->id && package->id.value() != 0x0 && package->id.value() != desiredPackageId) {
             mContext->getDiagnostics()->warn(DiagMessage(src)
                                              << "ignoring package " << package->name);
             continue;
diff --git a/tools/aapt2/test/Common.h b/tools/aapt2/test/Common.h
index b41c5683c77a..6fdaebba6897 100644
--- a/tools/aapt2/test/Common.h
+++ b/tools/aapt2/test/Common.h
@@ -18,6 +18,7 @@
 #define AAPT_TEST_COMMON_H
 
 #include "ConfigDescription.h"
+#include "Debug.h"
 #include "ResourceTable.h"
 #include "ResourceUtils.h"
 #include "ValueVisitor.h"
diff --git a/tools/aapt2/unflatten/BinaryResourceParser.cpp b/tools/aapt2/unflatten/BinaryResourceParser.cpp
index 992a45cb34f4..ac91865e9e39 100644
--- a/tools/aapt2/unflatten/BinaryResourceParser.cpp
+++ b/tools/aapt2/unflatten/BinaryResourceParser.cpp
@@ -27,7 +27,7 @@
 
 #include <androidfw/ResourceTypes.h>
 #include <androidfw/TypeWrappers.h>
-#include <utils/misc.h>
+#include <base/macros.h>
 
 #include <map>
 #include <string>
@@ -289,7 +289,7 @@ bool BinaryResourceParser::parsePackage(const ResChunk_header* chunk) {
     }
 
     // Extract the package name.
-    size_t len = strnlen16((const char16_t*) packageHeader->name, NELEM(packageHeader->name));
+    size_t len = strnlen16((const char16_t*) packageHeader->name, arraysize(packageHeader->name));
     std::u16string packageName;
     packageName.resize(len);
     for (size_t i = 0; i < len; i++) {
@@ -416,13 +416,11 @@ bool BinaryResourceParser::parsePublic(const ResourceTablePackage* package,
             return false;
         }
 
-        const ResourceId resId = {
-                package->id.value(), header->typeId, util::deviceToHost16(entry->entryId) };
+        const ResourceId resId(package->id.value(), header->typeId,
+                               util::deviceToHost16(entry->entryId));
 
-        const ResourceName name = {
-                package->name,
-                *parsedType,
-                util::getString(mKeyPool, entry->key.index).toString() };
+        const ResourceName name(package->name, *parsedType,
+                                util::getString(mKeyPool, entry->key.index).toString());
 
         Source source;
         if (mSourcePool.getError() == NO_ERROR) {
@@ -516,13 +514,11 @@ bool BinaryResourceParser::parseType(const ResourceTablePackage* package,
             continue;
         }
 
-        const ResourceName name = {
-                package->name,
-                *parsedType,
-                util::getString(mKeyPool, util::deviceToHost32(entry->key.index)).toString() };
+        const ResourceName name(package->name, *parsedType,
+                                util::getString(mKeyPool,
+                                                util::deviceToHost32(entry->key.index)).toString());
 
-        const ResourceId resId =
-                { package->id.value(), type->id, static_cast<uint16_t>(it.index()) };
+        const ResourceId resId(package->id.value(), type->id, static_cast<uint16_t>(it.index()));
 
         std::unique_ptr<Value> resourceValue;
         const ResTable_entry_source* sourceBlock = nullptr;
@@ -598,7 +594,9 @@ std::unique_ptr<Item> BinaryResourceParser::parseValue(const ResourceNameRef& na
         StringPiece16 str = util::getString(mValuePool, data);
 
         const ResStringPool_span* spans = mValuePool.styleAt(data);
-        if (spans != nullptr) {
+
+        // Check if the string has a valid style associated with it.
+        if (spans != nullptr && spans->name.index != ResStringPool_span::END) {
             StyleString styleStr = { str.toString() };
             while (spans->name.index != ResStringPool_span::END) {
                 styleStr.spans.push_back(Span{
@@ -662,8 +660,12 @@ std::unique_ptr<Value> BinaryResourceParser::parseMapEntry(const ResourceNameRef
     switch (name.type) {
         case ResourceType::kStyle:
             return parseStyle(name, config, map);
+        case ResourceType::kAttrPrivate:
+            // fallthrough
         case ResourceType::kAttr:
             return parseAttr(name, config, map);
+        case ResourceType::kIntegerArray:
+            // fallthrough
         case ResourceType::kArray:
             return parseArray(name, config, map);
         case ResourceType::kStyleable:
@@ -671,6 +673,7 @@ std::unique_ptr<Value> BinaryResourceParser::parseMapEntry(const ResourceNameRef
         case ResourceType::kPlurals:
             return parsePlural(name, config, map);
         default:
+            assert(false && "unknown map type");
             break;
     }
     return {};