blob: 781b9fe8bc29e87044f16d305e84bd82f62c8b4e [file] [log] [blame]
/*
* Copyright (C) 2015 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "format/binary/XmlFlattener.h"
#include <algorithm>
#include <map>
#include <vector>
#include "android-base/logging.h"
#include "android-base/macros.h"
#include "androidfw/ResourceTypes.h"
#include "utils/misc.h"
#include "ResourceUtils.h"
#include "SdkConstants.h"
#include "ValueVisitor.h"
#include "format/binary/ChunkWriter.h"
#include "format/binary/ResourceTypeExtensions.h"
#include "xml/XmlDom.h"
using namespace android;
using ::aapt::ResourceUtils::StringBuilder;
namespace aapt {
namespace {
constexpr uint32_t kLowPriority = 0xffffffffu;
static bool cmp_xml_attribute_by_id(const xml::Attribute* a, const xml::Attribute* b) {
if (a->compiled_attribute && a->compiled_attribute.value().id) {
if (b->compiled_attribute && b->compiled_attribute.value().id) {
return a->compiled_attribute.value().id.value() < b->compiled_attribute.value().id.value();
}
return true;
} else if (!b->compiled_attribute) {
int diff = a->namespace_uri.compare(b->namespace_uri);
if (diff < 0) {
return true;
} else if (diff > 0) {
return false;
}
return a->name < b->name;
}
return false;
}
class XmlFlattenerVisitor : public xml::ConstVisitor {
public:
using xml::ConstVisitor::Visit;
StringPool pool;
std::map<uint8_t, StringPool> package_pools;
struct StringFlattenDest {
StringPool::Ref ref;
ResStringPool_ref* dest;
};
std::vector<StringFlattenDest> string_refs;
XmlFlattenerVisitor(BigBuffer* buffer, XmlFlattenerOptions options)
: buffer_(buffer), options_(options) {
}
void Visit(const xml::Text* node) override {
if (util::TrimWhitespace(node->text).empty()) {
// Skip whitespace only text nodes.
return;
}
ChunkWriter writer(buffer_);
ResXMLTree_node* flat_node = writer.StartChunk<ResXMLTree_node>(RES_XML_CDATA_TYPE);
flat_node->lineNumber = util::HostToDevice32(node->line_number);
flat_node->comment.index = util::HostToDevice32(-1);
ResXMLTree_cdataExt* flat_text = writer.NextBlock<ResXMLTree_cdataExt>();
// Process plain strings to make sure they get properly escaped.
StringBuilder builder;
builder.AppendText(node->text);
AddString(builder.to_string(), kLowPriority, &flat_text->data);
writer.Finish();
}
void Visit(const xml::Element* node) override {
for (const xml::NamespaceDecl& decl : node->namespace_decls) {
// Skip dedicated tools namespace.
if (decl.uri != xml::kSchemaTools) {
WriteNamespace(decl, android::RES_XML_START_NAMESPACE_TYPE);
}
}
{
ChunkWriter start_writer(buffer_);
ResXMLTree_node* flat_node =
start_writer.StartChunk<ResXMLTree_node>(RES_XML_START_ELEMENT_TYPE);
flat_node->lineNumber = util::HostToDevice32(node->line_number);
flat_node->comment.index = util::HostToDevice32(-1);
ResXMLTree_attrExt* flat_elem = start_writer.NextBlock<ResXMLTree_attrExt>();
// A missing namespace must be null, not an empty string. Otherwise the runtime complains.
AddString(node->namespace_uri, kLowPriority, &flat_elem->ns,
true /* treat_empty_string_as_null */);
AddString(node->name, kLowPriority, &flat_elem->name, true /* treat_empty_string_as_null */);
flat_elem->attributeStart = util::HostToDevice16(sizeof(*flat_elem));
flat_elem->attributeSize = util::HostToDevice16(sizeof(ResXMLTree_attribute));
WriteAttributes(node, flat_elem, &start_writer);
start_writer.Finish();
}
xml::ConstVisitor::Visit(node);
{
ChunkWriter end_writer(buffer_);
ResXMLTree_node* flat_end_node =
end_writer.StartChunk<ResXMLTree_node>(RES_XML_END_ELEMENT_TYPE);
flat_end_node->lineNumber = util::HostToDevice32(node->line_number);
flat_end_node->comment.index = util::HostToDevice32(-1);
ResXMLTree_endElementExt* flat_end_elem = end_writer.NextBlock<ResXMLTree_endElementExt>();
AddString(node->namespace_uri, kLowPriority, &flat_end_elem->ns,
true /* treat_empty_string_as_null */);
AddString(node->name, kLowPriority, &flat_end_elem->name);
end_writer.Finish();
}
for (auto iter = node->namespace_decls.rbegin(); iter != node->namespace_decls.rend(); ++iter) {
// Skip dedicated tools namespace.
if (iter->uri != xml::kSchemaTools) {
WriteNamespace(*iter, android::RES_XML_END_NAMESPACE_TYPE);
}
}
}
private:
DISALLOW_COPY_AND_ASSIGN(XmlFlattenerVisitor);
// We are adding strings to a StringPool whose strings will be sorted and merged with other
// string pools. That means we can't encode the ID of a string directly. Instead, we defer the
// writing of the ID here, until after the StringPool is merged and sorted.
void AddString(const StringPiece& str, uint32_t priority, android::ResStringPool_ref* dest,
bool treat_empty_string_as_null = false) {
if (str.empty() && treat_empty_string_as_null) {
// Some parts of the runtime treat null differently than empty string.
dest->index = util::DeviceToHost32(-1);
} else {
string_refs.push_back(
StringFlattenDest{pool.MakeRef(str, StringPool::Context(priority)), dest});
}
}
// We are adding strings to a StringPool whose strings will be sorted and merged with other
// string pools. That means we can't encode the ID of a string directly. Instead, we defer the
// writing of the ID here, until after the StringPool is merged and sorted.
void AddString(const StringPool::Ref& ref, android::ResStringPool_ref* dest) {
string_refs.push_back(StringFlattenDest{ref, dest});
}
void WriteNamespace(const xml::NamespaceDecl& decl, uint16_t type) {
ChunkWriter writer(buffer_);
ResXMLTree_node* flatNode = writer.StartChunk<ResXMLTree_node>(type);
flatNode->lineNumber = util::HostToDevice32(decl.line_number);
flatNode->comment.index = util::HostToDevice32(-1);
ResXMLTree_namespaceExt* flat_ns = writer.NextBlock<ResXMLTree_namespaceExt>();
AddString(decl.prefix, kLowPriority, &flat_ns->prefix);
AddString(decl.uri, kLowPriority, &flat_ns->uri);
writer.Finish();
}
void WriteAttributes(const xml::Element* node, ResXMLTree_attrExt* flat_elem,
ChunkWriter* writer) {
filtered_attrs_.clear();
filtered_attrs_.reserve(node->attributes.size());
// Filter the attributes.
for (const xml::Attribute& attr : node->attributes) {
if (attr.namespace_uri != xml::kSchemaTools) {
filtered_attrs_.push_back(&attr);
}
}
if (filtered_attrs_.empty()) {
return;
}
const ResourceId kIdAttr(0x010100d0);
std::sort(filtered_attrs_.begin(), filtered_attrs_.end(), cmp_xml_attribute_by_id);
flat_elem->attributeCount = util::HostToDevice16(filtered_attrs_.size());
ResXMLTree_attribute* flat_attr =
writer->NextBlock<ResXMLTree_attribute>(filtered_attrs_.size());
uint16_t attribute_index = 1;
for (const xml::Attribute* xml_attr : filtered_attrs_) {
// Assign the indices for specific attributes.
if (xml_attr->compiled_attribute && xml_attr->compiled_attribute.value().id &&
xml_attr->compiled_attribute.value().id.value() == kIdAttr) {
flat_elem->idIndex = util::HostToDevice16(attribute_index);
} else if (xml_attr->namespace_uri.empty()) {
if (xml_attr->name == "class") {
flat_elem->classIndex = util::HostToDevice16(attribute_index);
} else if (xml_attr->name == "style") {
flat_elem->styleIndex = util::HostToDevice16(attribute_index);
}
}
attribute_index++;
// Add the namespaceUri to the list of StringRefs to encode. Use null if the namespace
// is empty (doesn't exist).
AddString(xml_attr->namespace_uri, kLowPriority, &flat_attr->ns,
true /* treat_empty_string_as_null */);
flat_attr->rawValue.index = util::HostToDevice32(-1);
if (!xml_attr->compiled_attribute || !xml_attr->compiled_attribute.value().id) {
// The attribute has no associated ResourceID, so the string order doesn't matter.
AddString(xml_attr->name, kLowPriority, &flat_attr->name);
} else {
// Attribute names are stored without packages, but we use
// their StringPool index to lookup their resource IDs.
// This will cause collisions, so we can't dedupe
// attribute names from different packages. We use separate
// pools that we later combine.
//
// Lookup the StringPool for this package and make the reference there.
const xml::AaptAttribute& aapt_attr = xml_attr->compiled_attribute.value();
StringPool::Ref name_ref = package_pools[aapt_attr.id.value().package_id()].MakeRef(
xml_attr->name, StringPool::Context(aapt_attr.id.value().id));
// Add it to the list of strings to flatten.
AddString(name_ref, &flat_attr->name);
}
std::string processed_str;
Maybe<StringPiece> compiled_text;
if (xml_attr->compiled_value != nullptr) {
// Make sure we're not flattening a String. A String can be referencing a string from
// a different StringPool than we're using here to build the binary XML.
String* string_value = ValueCast<String>(xml_attr->compiled_value.get());
if (string_value != nullptr) {
// Mark the String's text as needing to be serialized.
compiled_text = StringPiece(*string_value->value);
} else {
// Serialize this compiled value safely.
CHECK(xml_attr->compiled_value->Flatten(&flat_attr->typedValue));
}
} else {
// There is no compiled value, so treat the raw string as compiled, once it is processed to
// make sure escape sequences are properly interpreted.
processed_str =
StringBuilder(true /*preserve_spaces*/).AppendText(xml_attr->value).to_string();
compiled_text = StringPiece(processed_str);
}
if (compiled_text) {
// Write out the compiled text and raw_text.
flat_attr->typedValue.dataType = android::Res_value::TYPE_STRING;
AddString(compiled_text.value(), kLowPriority,
reinterpret_cast<ResStringPool_ref*>(&flat_attr->typedValue.data));
if (options_.keep_raw_values) {
AddString(xml_attr->value, kLowPriority, &flat_attr->rawValue);
} else {
AddString(compiled_text.value(), kLowPriority, &flat_attr->rawValue);
}
} else if (options_.keep_raw_values && !xml_attr->value.empty()) {
AddString(xml_attr->value, kLowPriority, &flat_attr->rawValue);
}
flat_attr->typedValue.size = util::HostToDevice16(sizeof(flat_attr->typedValue));
flat_attr++;
}
}
BigBuffer* buffer_;
XmlFlattenerOptions options_;
// Scratch vector to filter attributes. We avoid allocations making this a member.
std::vector<const xml::Attribute*> filtered_attrs_;
};
} // namespace
bool XmlFlattener::Flatten(IAaptContext* context, const xml::Node* node) {
BigBuffer node_buffer(1024);
XmlFlattenerVisitor visitor(&node_buffer, options_);
node->Accept(&visitor);
// Merge the package pools into the main pool.
for (auto& package_pool_entry : visitor.package_pools) {
visitor.pool.Merge(std::move(package_pool_entry.second));
}
// Sort the string pool so that attribute resource IDs show up first.
visitor.pool.Sort([](const StringPool::Context& a, const StringPool::Context& b) -> int {
return util::compare(a.priority, b.priority);
});
// Now we flatten the string pool references into the correct places.
for (const auto& ref_entry : visitor.string_refs) {
ref_entry.dest->index = util::HostToDevice32(ref_entry.ref.index());
}
// Write the XML header.
ChunkWriter xml_header_writer(buffer_);
xml_header_writer.StartChunk<ResXMLTree_header>(RES_XML_TYPE);
// Flatten the StringPool.
if (options_.use_utf16) {
StringPool::FlattenUtf16(buffer_, visitor.pool);
} else {
StringPool::FlattenUtf8(buffer_, visitor.pool);
}
{
// Write the array of resource IDs, indexed by StringPool order.
ChunkWriter res_id_map_writer(buffer_);
res_id_map_writer.StartChunk<ResChunk_header>(RES_XML_RESOURCE_MAP_TYPE);
for (const auto& str : visitor.pool.strings()) {
ResourceId id(str->context.priority);
if (str->context.priority == kLowPriority || !id.is_valid()) {
// When we see the first non-resource ID, we're done.
break;
}
*res_id_map_writer.NextBlock<uint32_t>() = util::HostToDevice32(id.id);
}
res_id_map_writer.Finish();
}
// Move the nodeBuffer and append it to the out buffer.
buffer_->AppendBuffer(std::move(node_buffer));
// Finish the xml header.
xml_header_writer.Finish();
return true;
}
bool XmlFlattener::Consume(IAaptContext* context, const xml::XmlResource* resource) {
if (!resource->root) {
return false;
}
return Flatten(context, resource->root.get());
}
} // namespace aapt