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 #ifndef AAPT_JAVA_CLASS_GENERATOR_H
     18 #define AAPT_JAVA_CLASS_GENERATOR_H
     19 
     20 #include <ostream>
     21 #include <string>
     22 
     23 #include "androidfw/StringPiece.h"
     24 
     25 #include "ResourceTable.h"
     26 #include "ResourceValues.h"
     27 #include "process/IResourceTableConsumer.h"
     28 #include "process/SymbolTable.h"
     29 
     30 namespace aapt {
     31 
     32 class AnnotationProcessor;
     33 class ClassDefinition;
     34 class MethodDefinition;
     35 
     36 // Options for generating onResourcesLoaded callback in R.java.
     37 struct OnResourcesLoadedCallbackOptions {
     38   // Other R classes to delegate the same callback to (with the same package ID).
     39   std::vector<std::string> packages_to_callback;
     40 };
     41 
     42 struct JavaClassGeneratorOptions {
     43   // Specifies whether to use the 'final' modifier on resource entries. Default is true.
     44   bool use_final = true;
     45 
     46   // If set, generates code to rewrite the package ID of resources.
     47   // Implies use_final == true. Default is unset.
     48   Maybe<OnResourcesLoadedCallbackOptions> rewrite_callback_options;
     49 
     50   enum class SymbolTypes {
     51     kAll,
     52     kPublicPrivate,
     53     kPublic,
     54   };
     55 
     56   SymbolTypes types = SymbolTypes::kAll;
     57 
     58   // A list of JavaDoc annotations to add to the comments of all generated classes.
     59   std::vector<std::string> javadoc_annotations;
     60 };
     61 
     62 // Generates the R.java file for a resource table and optionally an R.txt file.
     63 class JavaClassGenerator {
     64  public:
     65   JavaClassGenerator(IAaptContext* context, ResourceTable* table,
     66                      const JavaClassGeneratorOptions& options);
     67 
     68   // Writes the R.java file to `out`. Only symbols belonging to `package` are written.
     69   // All symbols technically belong to a single package, but linked libraries will
     70   // have their names mangled, denoting that they came from a different package.
     71   // We need to generate these symbols in a separate file. Returns true on success.
     72   bool Generate(const android::StringPiece& package_name_to_generate, std::ostream* out,
     73                 std::ostream* out_r_txt = nullptr);
     74 
     75   bool Generate(const android::StringPiece& package_name_to_generate,
     76                 const android::StringPiece& output_package_name, std::ostream* out,
     77                 std::ostream* out_r_txt = nullptr);
     78 
     79   const std::string& getError() const;
     80 
     81  private:
     82   bool SkipSymbol(SymbolState state);
     83   bool SkipSymbol(const Maybe<SymbolTable::Symbol>& symbol);
     84 
     85   // Returns the unmangled resource entry name if the unmangled package is the same as
     86   // package_name_to_generate. Returns nothing if the resource should be skipped.
     87   Maybe<std::string> UnmangleResource(const android::StringPiece& package_name,
     88                                       const android::StringPiece& package_name_to_generate,
     89                                       const ResourceEntry& entry);
     90 
     91   bool ProcessType(const android::StringPiece& package_name_to_generate,
     92                    const ResourceTablePackage& package, const ResourceTableType& type,
     93                    ClassDefinition* out_type_class_def, MethodDefinition* out_rewrite_method_def,
     94                    std::ostream* out_r_txt);
     95 
     96   // Writes a resource to the R.java file, optionally writing out a rewrite rule for its package
     97   // ID if `out_rewrite_method` is not nullptr.
     98   void ProcessResource(const ResourceNameRef& name, const ResourceId& id,
     99                        const ResourceEntry& entry, ClassDefinition* out_class_def,
    100                        MethodDefinition* out_rewrite_method, std::ostream* out_r_txt);
    101 
    102   // Writes a styleable resource to the R.java file, optionally writing out a rewrite rule for
    103   // its package ID if `out_rewrite_method` is not nullptr.
    104   // `package_name_to_generate` is the package
    105   void ProcessStyleable(const ResourceNameRef& name, const ResourceId& id,
    106                         const Styleable& styleable,
    107                         const android::StringPiece& package_name_to_generate,
    108                         ClassDefinition* out_class_def, MethodDefinition* out_rewrite_method,
    109                         std::ostream* out_r_txt);
    110 
    111   IAaptContext* context_;
    112   ResourceTable* table_;
    113   JavaClassGeneratorOptions options_;
    114   std::string error_;
    115 };
    116 
    117 inline const std::string& JavaClassGenerator::getError() const {
    118   return error_;
    119 }
    120 
    121 }  // namespace aapt
    122 
    123 #endif  // AAPT_JAVA_CLASS_GENERATOR_H
    124