Use R.txt from AAR to generate R.java for it when building APK.

build/config/android/rules.gni

 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 # Do not add any imports to non-//build directories here.
 # Some projects (e.g. V8) do not have non-build directories DEPS'ed in.
 import("//build/config/android/config.gni")
 import("//build/config/android/internal_rules.gni")
 import("//build/config/compiler/compiler.gni")
 import("//build/config/dcheck_always_on.gni")
@@ skipping 628 matching lines @@
   #   android_manifest: AndroidManifest.xml for this target. Defaults to
   #     //build/android/AndroidManifest.xml.
   #   android_manifest_dep: Target that generates AndroidManifest (if applicable)
   #   custom_package: java package for generated .java files.
   #   v14_skip: If true, don't run v14 resource generator on this. Defaults to
   #     false. (see build/android/gyp/generate_v14_compatible_resources.py)
   #   shared_resources: If true make a resource package that can be loaded by a
   #     different application at runtime to access the package's resources.
   #   app_as_shared_lib: If true make a resource package that can be loaded as
   #     both shared_resources and normal application.
+  #   r_text_file: (optional) path to pre-generated R.txt to be used when
+  #     generating R.java instead of resource-based aapt-generated one.
 
   # Example:
   #   android_resources("foo_resources") {
   #     deps = [":foo_strings_grd"]
   #     resource_dirs = ["res"]
   #     custom_package = "org.chromium.foo"
   #   }
   #
   #   android_resources("foo_resources_overrides") {
   #     deps = [":foo_resources"]
   #     resource_dirs = ["res_overrides"]
   #   }
   template("android_resources") {
     set_sources_assignment_filter([])
     forward_variables_from(invoker, [ "testonly" ])
 
     assert(defined(invoker.resource_dirs))
 
     base_path = "$target_gen_dir/$target_name"
     zip_path = base_path + ".resources.zip"
     srcjar_path = base_path + ".srcjar"
-    r_text_path = base_path + "_R.txt"
+    r_text_out_path = base_path + "_R.txt"
     build_config = base_path + ".build_config"
 
     build_config_target_name = "${target_name}__build_config"
     process_resources_target_name = "${target_name}__process_resources"
     final_target_name = target_name
 
     write_build_config(build_config_target_name) {
       type = "android_resources"
       forward_variables_from(invoker,
                              [
@@ skipping 12 matching lines @@
         possible_config_deps = invoker.deps
       }
       if (defined(invoker.android_manifest_dep)) {
         deps = [
           invoker.android_manifest_dep,
         ]
       }
 
       # No package means resources override their deps.
       if (defined(custom_package) || defined(android_manifest)) {
-        r_text = r_text_path
+        r_text = r_text_out_path
       } else {
         assert(defined(invoker.deps),
                "Must specify deps when custom_package is omitted.")
       }
 
       resources_zip = zip_path
       srcjar = srcjar_path
     }
 
     process_resources(process_resources_target_name) {
@@ skipping 10 matching lines @@
                                "v14_skip",
                              ])
       if (!defined(deps)) {
         deps = []
       }
       deps += [ ":$build_config_target_name" ]
       if (defined(invoker.android_manifest_dep)) {
         deps += [ invoker.android_manifest_dep ]
       }
 
+      if (defined(invoker.r_text_file)) {
+        r_text_in_path = invoker.r_text_file
+      }
+
       # Always generate R.onResourcesLoaded() method, it is required for
       # compiling ResourceRewriter, there is no side effect because the
       # generated R.class isn't used in final apk.
       shared_resources = true
       if (!defined(android_manifest)) {
         android_manifest = "//build/android/AndroidManifest.xml"
       }
     }
 
     group(final_target_name) {
@@ skipping 916 matching lines @@
     process_resources(process_resources_target) {
       forward_variables_from(invoker,
                              [
                                "alternative_android_sdk_jar",
                                "android_aapt_path",
                                "app_as_shared_lib",
                                "include_all_resources",
                                "shared_resources",
                              ])
       srcjar_path = "${target_gen_dir}/${target_name}.srcjar"
-      r_text_path = "${target_gen_dir}/${target_name}_R.txt"
+      r_text_out_path = "${target_gen_dir}/${target_name}_R.txt"
       android_manifest = _android_manifest
       resource_dirs = [ "//build/android/ant/empty/res" ]
       zip_path = resources_zip_path
       all_resources_zip_path = _all_resources_zip_path
       generate_constant_ids = true
       proguard_file = _generated_proguard_config
 
       build_config = _build_config
       deps = _android_manifest_deps + [ ":$build_config_target" ]
       if (defined(invoker.deps)) {
@@ skipping 990 matching lines @@
         rebase_path(_output_path, root_build_dir),
         "--extract",
       ]
       inputs = [
         invoker.aar_path,
       ]
       outputs = [
         "${_output_path}/AndroidManifest.xml",
       ]
 
+      if (_scanned_files.has_r_text_file) {
+        # Certain packages, in particular Play Services have no R.txt even
+        # though its presence is mandated by AAR spec. Such packages cause
+        # spurious rebuilds if this output is specified unconditionally.
+        outputs += [ "${_output_path}/R.txt" ]
+      }
+
       if (_scanned_files.resources != []) {
-        outputs += [ "${_output_path}/R.txt" ]
         outputs += get_path_info(
                 rebase_path(_scanned_files.resources, "", _output_path),
                 "abspath")
       }
       if (_scanned_files.has_classes_jar) {
         outputs += [ "${_output_path}/classes.jar" ]
       }
       outputs +=
           get_path_info(rebase_path(_scanned_files.subjars, "", _output_path),
                         "abspath")
       if (_scanned_files.has_proguard_flags) {
         outputs += [ "${_output_path}/proguard.txt" ]
       }
     }
 
     # Create the android_resources target for resources.
-    if (_scanned_files.resources != []) {
+    if (_scanned_files.resources != [] || _scanned_files.has_r_text_file) {
       _res_target_name = "${target_name}__res"
       android_resources(_res_target_name) {
         forward_variables_from(invoker, [ "deps" ])
         if (!defined(deps)) {
           deps = []
         }
         deps += [ ":$_unpack_target_name" ]
         resource_dirs = []
         generated_resource_dirs = [ "${_output_path}/res" ]
         generated_resource_files =
             rebase_path(_scanned_files.resources, "", _output_path)
         android_manifest_dep = ":$_unpack_target_name"
         android_manifest = "${_output_path}/AndroidManifest.xml"
+        if (_scanned_files.has_r_text_file) {
+          r_text_file = "${_output_path}/R.txt"
+        }
         v14_skip = true
       }
     }
 
     # Create android_java_prebuilt target for extra jars within jars/.
     _subjar_targets = []
     foreach(_tuple, _scanned_files.subjar_tuples) {
       _current_target = "${target_name}__subjar_${_tuple[0]}"
       _subjar_targets += [ ":$_current_target" ]
       java_prebuilt(_current_target) {
@@ skipping 59 matching lines @@
         # because in practice they seem to contain classes required to be in the
         # classpath.
         deps += _subjar_targets
       }
       if (defined(_res_target_name)) {
         deps += [ ":$_res_target_name" ]
       }
     }
   }
 }