Merge "AAPT2: Adding basic binding support" (105b8a5f) · Commits · e / os / android_frameworks_base

tools/aapt2/Android.mk

+2 −0

Original line number	Diff line number	Diff line
		@@ -27,6 +27,7 @@ main := Main.cpp
		sources := \
		BigBuffer.cpp \
		BinaryResourceParser.cpp \
		BindingXmlPullParser.cpp \
		ConfigDescription.cpp \
		Files.cpp \
		Flag.cpp \
		@@ -54,6 +55,7 @@ sources := \

		testSources := \
		BigBuffer_test.cpp \
		BindingXmlPullParser_test.cpp \
		Compat_test.cpp \
		ConfigDescription_test.cpp \
		JavaClassGenerator_test.cpp \

tools/aapt2/BindingXmlPullParser.cpp

0 → 100644

+263 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2015 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#include "BindingXmlPullParser.h"
		#include "Util.h"

		#include <iostream>
		#include <sstream>
		#include <string>
		#include <vector>

		namespace aapt {

		constexpr const char16_t* kBindingNamespaceUri = u"http://schemas.android.com/apk/binding";
		constexpr const char16_t* kAndroidNamespaceUri = u"http://schemas.android.com/apk/res/android";
		constexpr const char16_t* kVariableTagName = u"variable";
		constexpr const char* kBindingTagPrefix = "android:binding_";

		BindingXmlPullParser::BindingXmlPullParser(const std::shared_ptr<XmlPullParser>& parser) :
		mParser(parser), mOverride(false), mNextTagId(0) {
		}

		bool BindingXmlPullParser::readVariableDeclaration() {
		VarDecl var;

		const auto endAttrIter = mParser->endAttributes();
		for (auto attrIter = mParser->beginAttributes(); attrIter != endAttrIter; ++attrIter) {
		if (!attrIter->namespaceUri.empty()) {
		continue;
		}

		if (attrIter->name == u"name") {
		var.name = util::utf16ToUtf8(attrIter->value);
		} else if (attrIter->name == u"type") {
		var.type = util::utf16ToUtf8(attrIter->value);
		}
		}

		XmlPullParser::skipCurrentElement(mParser.get());

		if (var.name.empty()) {
		mLastError = "variable declaration missing name";
		return false;
		}

		if (var.type.empty()) {
		mLastError = "variable declaration missing type";
		return false;
		}

		mVarDecls.push_back(std::move(var));
		return true;
		}

		bool BindingXmlPullParser::readExpressions() {
		mOverride = true;
		std::vector<XmlPullParser::Attribute> expressions;
		std::string idValue;

		const auto endAttrIter = mParser->endAttributes();
		for (auto attr = mParser->beginAttributes(); attr != endAttrIter; ++attr) {
		if (attr->namespaceUri == kAndroidNamespaceUri && attr->name == u"id") {
		idValue = util::utf16ToUtf8(attr->value);
		} else {
		StringPiece16 value = util::trimWhitespace(attr->value);
		if (util::stringStartsWith<char16_t>(value, u"@{") &&
		util::stringEndsWith<char16_t>(value, u"}")) {
		// This is attribute's value is an expression of the form
		// @{expression}. We need to capture the expression inside.
		expressions.push_back(XmlPullParser::Attribute{
		attr->namespaceUri,
		attr->name,
		value.substr(2, value.size() - 3).toString()
		});
		} else {
		// This is a normal attribute, use as is.
		mAttributes.emplace_back(*attr);
		}
		}
		}

		// Check if we have any expressions.
		if (!expressions.empty()) {
		// We have expressions, so let's assign the target a tag number
		// and add it to our targets list.
		int32_t targetId = mNextTagId++;
		mTargets.push_back(Target{
		util::utf16ToUtf8(mParser->getElementName()),
		idValue,
		targetId,
		std::move(expressions)
		});

		std::stringstream numGen;
		numGen << kBindingTagPrefix << targetId;
		mAttributes.push_back(XmlPullParser::Attribute{
		std::u16string(kAndroidNamespaceUri),
		std::u16string(u"tag"),
		util::utf8ToUtf16(numGen.str())
		});
		}
		return true;
		}

		XmlPullParser::Event BindingXmlPullParser::next() {
		// Clear old state in preparation for the next event.
		mOverride = false;
		mAttributes.clear();

		while (true) {
		Event event = mParser->next();
		if (event == Event::kStartElement) {
		if (mParser->getElementNamespace().empty() &&
		mParser->getElementName() == kVariableTagName) {
		// This is a variable tag. Record data from it, and
		// then discard the entire element.
		if (!readVariableDeclaration()) {
		// mLastError is set, so getEvent will return kBadDocument.
		return getEvent();
		}
		continue;
		} else {
		// Check for expressions of the form @{} in attribute text.
		const auto endAttrIter = mParser->endAttributes();
		for (auto attr = mParser->beginAttributes(); attr != endAttrIter; ++attr) {
		StringPiece16 value = util::trimWhitespace(attr->value);
		if (util::stringStartsWith<char16_t>(value, u"@{") &&
		util::stringEndsWith<char16_t>(value, u"}")) {
		if (!readExpressions()) {
		return getEvent();
		}
		break;
		}
		}
		}
		} else if (event == Event::kStartNamespace \|\| event == Event::kEndNamespace) {
		if (mParser->getNamespaceUri() == kBindingNamespaceUri) {
		// Skip binding namespace tags.
		continue;
		}
		}
		return event;
		}
		return Event::kBadDocument;
		}

		bool BindingXmlPullParser::writeToFile(std::ostream& out) const {
		out << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n";
		out << "<Layout directory=\"\" layout=\"\" layoutId=\"\">\n";

		// Write the variables.
		out << " <Variables>\n";
		for (const VarDecl& v : mVarDecls) {
		out << " <entries name=\"" << v.name << "\" type=\"" << v.type << "\"/>\n";
		}
		out << " </Variables>\n";

		// Write the imports.

		std::stringstream tagGen;

		// Write the targets.
		out << " <Targets>\n";
		for (const Target& t : mTargets) {
		tagGen.str({});
		tagGen << kBindingTagPrefix << t.tagId;
		out << " <Target boundClass=\"" << t.className << "\" id=\"" << t.id
		<< "\" tag=\"" << tagGen.str() << "\">\n";
		out << " <Expressions>\n";
		for (const XmlPullParser::Attribute& a : t.expressions) {
		out << " <Expression attribute=\"" << a.namespaceUri << ":" << a.name
		<< "\" text=\"" << a.value << "\"/>\n";
		}
		out << " </Expressions>\n";
		out << " </Target>\n";
		}
		out << " </Targets>\n";

		out << "</Layout>\n";
		return bool(out);
		}

		XmlPullParser::const_iterator BindingXmlPullParser::beginAttributes() const {
		if (mOverride) {
		return mAttributes.begin();
		}
		return mParser->beginAttributes();
		}

		XmlPullParser::const_iterator BindingXmlPullParser::endAttributes() const {
		if (mOverride) {
		return mAttributes.end();
		}
		return mParser->endAttributes();
		}

		size_t BindingXmlPullParser::getAttributeCount() const {
		if (mOverride) {
		return mAttributes.size();
		}
		return mParser->getAttributeCount();
		}

		XmlPullParser::Event BindingXmlPullParser::getEvent() const {
		if (!mLastError.empty()) {
		return Event::kBadDocument;
		}
		return mParser->getEvent();
		}

		const std::string& BindingXmlPullParser::getLastError() const {
		if (!mLastError.empty()) {
		return mLastError;
		}
		return mParser->getLastError();
		}

		const std::u16string& BindingXmlPullParser::getComment() const {
		return mParser->getComment();
		}

		size_t BindingXmlPullParser::getLineNumber() const {
		return mParser->getLineNumber();
		}

		size_t BindingXmlPullParser::getDepth() const {
		return mParser->getDepth();
		}

		const std::u16string& BindingXmlPullParser::getText() const {
		return mParser->getText();
		}

		const std::u16string& BindingXmlPullParser::getNamespacePrefix() const {
		return mParser->getNamespacePrefix();
		}

		const std::u16string& BindingXmlPullParser::getNamespaceUri() const {
		return mParser->getNamespaceUri();
		}

		const std::u16string& BindingXmlPullParser::getElementNamespace() const {
		return mParser->getElementNamespace();
		}

		const std::u16string& BindingXmlPullParser::getElementName() const {
		return mParser->getElementName();
		}

		} // namespace aapt

tools/aapt2/BindingXmlPullParser.h

0 → 100644

+88 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2015 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#ifndef AAPT_BINDING_XML_PULL_PARSER_H
		#define AAPT_BINDING_XML_PULL_PARSER_H

		#include "XmlPullParser.h"

		#include <iostream>
		#include <memory>
		#include <string>

		namespace aapt {

		class BindingXmlPullParser : public XmlPullParser {
		public:
		BindingXmlPullParser(const std::shared_ptr<XmlPullParser>& parser);
		BindingXmlPullParser(const BindingXmlPullParser& rhs) = delete;

		Event getEvent() const override;
		const std::string& getLastError() const override;
		Event next() override;

		const std::u16string& getComment() const override;
		size_t getLineNumber() const override;
		size_t getDepth() const override;

		const std::u16string& getText() const override;

		const std::u16string& getNamespacePrefix() const override;
		const std::u16string& getNamespaceUri() const override;

		const std::u16string& getElementNamespace() const override;
		const std::u16string& getElementName() const override;

		const_iterator beginAttributes() const override;
		const_iterator endAttributes() const override;
		size_t getAttributeCount() const override;

		bool writeToFile(std::ostream& out) const;

		private:
		struct VarDecl {
		std::string name;
		std::string type;
		};

		struct Import {
		std::string name;
		std::string type;
		};

		struct Target {
		std::string className;
		std::string id;
		int32_t tagId;

		std::vector<XmlPullParser::Attribute> expressions;
		};

		bool readVariableDeclaration();
		bool readExpressions();

		std::shared_ptr<XmlPullParser> mParser;
		std::string mLastError;
		bool mOverride;
		std::vector<XmlPullParser::Attribute> mAttributes;
		std::vector<VarDecl> mVarDecls;
		std::vector<Target> mTargets;
		int32_t mNextTagId;
		};

		} // namespace aapt

		#endif // AAPT_BINDING_XML_PULL_PARSER_H

tools/aapt2/BindingXmlPullParser_test.cpp

0 → 100644

+110 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2015 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#include "SourceXmlPullParser.h"
		#include "BindingXmlPullParser.h"

		#include <gtest/gtest.h>
		#include <sstream>
		#include <string>

		namespace aapt {

		constexpr const char16_t* kAndroidNamespaceUri = u"http://schemas.android.com/apk/res/android";

		TEST(BindingXmlPullParserTest, SubstituteBindingExpressionsWithTag) {
		std::stringstream input;
		input << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
		<< "<LinearLayout xmlns:android=\"http://schemas.android.com/apk/res/android\"\n"
		<< " xmlns:bind=\"http://schemas.android.com/apk/binding\"\n"
		<< " android:id=\"@+id/content\">\n"
		<< " <variable name=\"user\" type=\"com.android.test.User\"/>\n"
		<< " <TextView android:text=\"@{user.name}\" android:layout_width=\"wrap_content\"\n"
		<< " android:layout_height=\"wrap_content\"/>\n"
		<< "</LinearLayout>\n";
		std::shared_ptr<XmlPullParser> sourceParser = std::make_shared<SourceXmlPullParser>(input);
		BindingXmlPullParser parser(sourceParser);

		ASSERT_EQ(XmlPullParser::Event::kStartNamespace, parser.next());
		EXPECT_EQ(std::u16string(u"http://schemas.android.com/apk/res/android"),
		parser.getNamespaceUri());

		ASSERT_EQ(XmlPullParser::Event::kStartElement, parser.next());
		EXPECT_EQ(std::u16string(u"LinearLayout"), parser.getElementName());

		while (parser.next() == XmlPullParser::Event::kText) {}

		ASSERT_EQ(XmlPullParser::Event::kStartElement, parser.getEvent());
		EXPECT_EQ(std::u16string(u"TextView"), parser.getElementName());

		ASSERT_EQ(3u, parser.getAttributeCount());
		const auto endAttr = parser.endAttributes();
		EXPECT_NE(endAttr, parser.findAttribute(kAndroidNamespaceUri, u"layout_width"));
		EXPECT_NE(endAttr, parser.findAttribute(kAndroidNamespaceUri, u"layout_height"));
		EXPECT_NE(endAttr, parser.findAttribute(kAndroidNamespaceUri, u"tag"));

		while (parser.next() == XmlPullParser::Event::kText) {}

		ASSERT_EQ(XmlPullParser::Event::kEndElement, parser.getEvent());

		while (parser.next() == XmlPullParser::Event::kText) {}

		ASSERT_EQ(XmlPullParser::Event::kEndElement, parser.getEvent());
		ASSERT_EQ(XmlPullParser::Event::kEndNamespace, parser.next());
		}

		TEST(BindingXmlPullParserTest, GenerateVariableDeclarations) {
		std::stringstream input;
		input << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
		<< "<LinearLayout xmlns:android=\"http://schemas.android.com/apk/res/android\"\n"
		<< " xmlns:bind=\"http://schemas.android.com/apk/binding\"\n"
		<< " android:id=\"@+id/content\">\n"
		<< " <variable name=\"user\" type=\"com.android.test.User\"/>\n"
		<< "</LinearLayout>\n";
		std::shared_ptr<XmlPullParser> sourceParser = std::make_shared<SourceXmlPullParser>(input);
		BindingXmlPullParser parser(sourceParser);

		while (XmlPullParser::isGoodEvent(parser.next())) {
		ASSERT_NE(XmlPullParser::Event::kBadDocument, parser.getEvent());
		}

		std::stringstream output;
		ASSERT_TRUE(parser.writeToFile(output));

		std::string result = output.str();
		EXPECT_NE(std::string::npos,
		result.find("<entries name=\"user\" type=\"com.android.test.User\"/>"));
		}

		TEST(BindingXmlPullParserTest, FailOnMissingNameOrTypeInVariableDeclaration) {
		std::stringstream input;
		input << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
		<< "<LinearLayout xmlns:android=\"http://schemas.android.com/apk/res/android\"\n"
		<< " xmlns:bind=\"http://schemas.android.com/apk/binding\"\n"
		<< " android:id=\"@+id/content\">\n"
		<< " <variable name=\"user\"/>\n"
		<< "</LinearLayout>\n";
		std::shared_ptr<XmlPullParser> sourceParser = std::make_shared<SourceXmlPullParser>(input);
		BindingXmlPullParser parser(sourceParser);

		while (XmlPullParser::isGoodEvent(parser.next())) {}

		EXPECT_EQ(XmlPullParser::Event::kBadDocument, parser.getEvent());
		EXPECT_FALSE(parser.getLastError().empty());
		}


		} // namespace aapt

tools/aapt2/Files.cpp

+11 −0

Original line number	Diff line number	Diff line
		@@ -105,6 +105,17 @@ bool mkdirs(const StringPiece& path) {
		return mkdirImpl(path) == 0 \|\| errno == EEXIST;
		}

		std::string getStem(const StringPiece& path) {
		const char* start = path.begin();
		const char* end = path.end();
		for (const char* current = end - 1; current != start - 1; --current) {
		if (*current == sDirSep) {
		return std::string(start, current - start);
		}
		}
		return {};
		}

		bool FileFilter::setPattern(const StringPiece& pattern) {
		mPatternTokens = util::splitAndLowercase(pattern, ':');
		return true;