Home | History | Annotate | Download | only in java 
      1 /*
      2  * Copyright (C) 2015 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #include "java/ManifestClassGenerator.h"
     18 
     19 #include <algorithm>
     20 
     21 #include "Source.h"
     22 #include "java/AnnotationProcessor.h"
     23 #include "java/ClassDefinition.h"
     24 #include "java/JavaClassGenerator.h"
     25 #include "text/Unicode.h"
     26 #include "util/Maybe.h"
     27 #include "xml/XmlDom.h"
     28 
     29 using ::android::StringPiece;
     30 using ::aapt::text::IsJavaIdentifier;
     31 
     32 namespace aapt {
     33 
     34 static Maybe<StringPiece> ExtractJavaIdentifier(IDiagnostics* diag, const Source& source,
     35                                                 const std::string& value) {
     36   StringPiece result = value;
     37   size_t pos = value.rfind('.');
     38   if (pos != std::string::npos) {
     39     result = result.substr(pos + 1);
     40   }
     41 
     42   // Normalize only the java identifier, leave the original value unchanged.
     43   if (result.contains("-")) {
     44     result = JavaClassGenerator::TransformToFieldName(result);
     45   }
     46 
     47   if (result.empty()) {
     48     diag->Error(DiagMessage(source) << "empty symbol");
     49     return {};
     50   }
     51 
     52   if (!IsJavaIdentifier(result)) {
     53     diag->Error(DiagMessage(source) << "invalid Java identifier '" << result << "'");
     54     return {};
     55   }
     56   return result;
     57 }
     58 
     59 static bool WriteSymbol(const Source& source, IDiagnostics* diag, xml::Element* el,
     60                         ClassDefinition* class_def) {
     61   xml::Attribute* attr = el->FindAttribute(xml::kSchemaAndroid, "name");
     62   if (!attr) {
     63     diag->Error(DiagMessage(source) << "<" << el->name << "> must define 'android:name'");
     64     return false;
     65   }
     66 
     67   Maybe<StringPiece> result =
     68       ExtractJavaIdentifier(diag, source.WithLine(el->line_number), attr->value);
     69   if (!result) {
     70     return false;
     71   }
     72 
     73   std::unique_ptr<StringMember> string_member =
     74       util::make_unique<StringMember>(result.value(), attr->value);
     75   string_member->GetCommentBuilder()->AppendComment(el->comment);
     76 
     77   if (class_def->AddMember(std::move(string_member)) == ClassDefinition::Result::kOverridden) {
     78     diag->Warn(DiagMessage(source.WithLine(el->line_number))
     79                << "duplicate definitions of '" << result.value() << "', overriding previous");
     80   }
     81   return true;
     82 }
     83 
     84 std::unique_ptr<ClassDefinition> GenerateManifestClass(IDiagnostics* diag, xml::XmlResource* res) {
     85   xml::Element* el = xml::FindRootElement(res->root.get());
     86   if (!el) {
     87     diag->Error(DiagMessage(res->file.source) << "no root tag defined");
     88     return {};
     89   }
     90 
     91   if (el->name != "manifest" && !el->namespace_uri.empty()) {
     92     diag->Error(DiagMessage(res->file.source) << "no <manifest> root tag defined");
     93     return {};
     94   }
     95 
     96   std::unique_ptr<ClassDefinition> permission_class =
     97       util::make_unique<ClassDefinition>("permission", ClassQualifier::kStatic, false);
     98   std::unique_ptr<ClassDefinition> permission_group_class =
     99       util::make_unique<ClassDefinition>("permission_group", ClassQualifier::kStatic, false);
    100 
    101   bool error = false;
    102   std::vector<xml::Element*> children = el->GetChildElements();
    103   for (xml::Element* child_el : children) {
    104     if (child_el->namespace_uri.empty()) {
    105       if (child_el->name == "permission") {
    106         error |= !WriteSymbol(res->file.source, diag, child_el, permission_class.get());
    107       } else if (child_el->name == "permission-group") {
    108         error |= !WriteSymbol(res->file.source, diag, child_el, permission_group_class.get());
    109       }
    110     }
    111   }
    112 
    113   if (error) {
    114     return {};
    115   }
    116 
    117   std::unique_ptr<ClassDefinition> manifest_class =
    118       util::make_unique<ClassDefinition>("Manifest", ClassQualifier::kNone, false);
    119   manifest_class->AddMember(std::move(permission_class));
    120   manifest_class->AddMember(std::move(permission_group_class));
    121   return manifest_class;
    122 }
    123 
    124 }  // namespace aapt
    125