Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 4d3a9876 authored by Adam Lesinski's avatar Adam Lesinski
Browse files

AAPT2: Adding basic binding support 

This is incomplete. Still requires:

- filling in layout information in the resulting .bind.xml
- processing elements with <view class=""/>
- processing imports

Change-Id: Ie5d4c5e6435591bbed3248129a548736244894eb
parent a826c4b7

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;