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 ::aapt::text::IsJavaIdentifier;
     30 
     31 namespace aapt {
     32 
     33 static Maybe<std::string> ExtractJavaIdentifier(IDiagnostics* diag, const Source& source,
     34                                                 const std::string& value) {
     35   std::string result = value;
     36   size_t pos = value.rfind('.');
     37   if (pos != std::string::npos) {
     38     result = result.substr(pos + 1);
     39   }
     40 
     41   // Normalize only the java identifier, leave the original value unchanged.
     42   if (result.find("-") != std::string::npos) {
     43     result = JavaClassGenerator::TransformToFieldName(result);
     44   }
     45 
     46   if (result.empty()) {
     47     diag->Error(DiagMessage(source) << "empty symbol");
     48     return {};
     49   }
     50 
     51   if (!IsJavaIdentifier(result)) {
     52     diag->Error(DiagMessage(source) << "invalid Java identifier '" << result << "'");
     53     return {};
     54   }
     55   return result;
     56 }
     57 
     58 static bool WriteSymbol(const Source& source, IDiagnostics* diag, xml::Element* el,
     59                         ClassDefinition* class_def) {
     60   xml::Attribute* attr = el->FindAttribute(xml::kSchemaAndroid, "name");
     61   if (!attr) {
     62     diag->Error(DiagMessage(source) << "<" << el->name << "> must define 'android:name'");
     63     return false;
     64   }
     65 
     66   Maybe<std::string> result =
     67       ExtractJavaIdentifier(diag, source.WithLine(el->line_number), attr->value);
     68   if (!result) {
     69     return false;
     70   }
     71 
     72   std::unique_ptr<StringMember> string_member =
     73       util::make_unique<StringMember>(result.value(), attr->value);
     74   string_member->GetCommentBuilder()->AppendComment(el->comment);
     75 
     76   if (class_def->AddMember(std::move(string_member)) == ClassDefinition::Result::kOverridden) {
     77     diag->Warn(DiagMessage(source.WithLine(el->line_number))
     78                << "duplicate definitions of '" << result.value() << "', overriding previous");
     79   }
     80   return true;
     81 }
     82 
     83 std::unique_ptr<ClassDefinition> GenerateManifestClass(IDiagnostics* diag, xml::XmlResource* res) {
     84   xml::Element* el = xml::FindRootElement(res->root.get());
     85   if (!el) {
     86     diag->Error(DiagMessage(res->file.source) << "no root tag defined");
     87     return {};
     88   }
     89 
     90   if (el->name != "manifest" && !el->namespace_uri.empty()) {
     91     diag->Error(DiagMessage(res->file.source) << "no <manifest> root tag defined");
     92     return {};
     93   }
     94 
     95   std::unique_ptr<ClassDefinition> permission_class =
     96       util::make_unique<ClassDefinition>("permission", ClassQualifier::kStatic, false);
     97   std::unique_ptr<ClassDefinition> permission_group_class =
     98       util::make_unique<ClassDefinition>("permission_group", ClassQualifier::kStatic, false);
     99 
    100   bool error = false;
    101   std::vector<xml::Element*> children = el->GetChildElements();
    102   for (xml::Element* child_el : children) {
    103     if (child_el->namespace_uri.empty()) {
    104       if (child_el->name == "permission") {
    105         error |= !WriteSymbol(res->file.source, diag, child_el, permission_class.get());
    106       } else if (child_el->name == "permission-group") {
    107         error |= !WriteSymbol(res->file.source, diag, child_el, permission_group_class.get());
    108       }
    109     }
    110   }
    111 
    112   if (error) {
    113     return {};
    114   }
    115 
    116   std::unique_ptr<ClassDefinition> manifest_class =
    117       util::make_unique<ClassDefinition>("Manifest", ClassQualifier::kNone, false);
    118   manifest_class->AddMember(std::move(permission_class));
    119   manifest_class->AddMember(std::move(permission_group_class));
    120   return manifest_class;
    121 }
    122 
    123 }  // namespace aapt
    124