Generate custom manifests when letting gradle process resources.

build/android/gradle/generate_gradle.py

 #!/usr/bin/env python
 # Copyright 2016 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.
 
 """Generates an Android Studio project from a GN target."""
 
 import argparse
 import codecs
 import glob
@@ skipping 157 matching lines @@
       path = os.path.join('gen', self.GradleSubdir() + '.build_config')
       self._build_config = build_utils.ReadJson(_RebasePath(path))
     return self._build_config
 
   def DepsInfo(self):
     return self.BuildConfig()['deps_info']
 
   def Gradle(self):
     return self.BuildConfig()['gradle']
 
+  def Javac(self):
+    return self.BuildConfig()['javac']
+
   def GetType(self):
     """Returns the target type from its .build_config."""
     return self.DepsInfo()['type']
 
   def ResZips(self):
     return self.DepsInfo().get('owned_resources_zips')
 
   def JavaFiles(self):
     if self._java_files is None:
       java_sources_file = self.Gradle().get('java_sources_file')
       java_files = []
       if java_sources_file:
         java_sources_file = _RebasePath(java_sources_file)
         java_files = build_utils.ReadSourcesList(java_sources_file)
       self._java_files = java_files
     return self._java_files
 
 
 class _ProjectContextGenerator(object):
   """Helper class to generate gradle build files"""
-  def __init__(self, project_dir, use_gradle_process_resources):
+  def __init__(
+      self, project_dir, use_gradle_process_resources, jinja_processor):
     self.project_dir = project_dir
     self.use_gradle_process_resources = use_gradle_process_resources
+    self.jinja_processor = jinja_processor
 
   def _GenJniLibs(self, entry):
     native_section = entry.BuildConfig().get('native')
     if native_section:
       jni_libs = _CreateJniLibsDir(
           constants.GetOutDirectory(), self.EntryOutputDir(entry),
           native_section.get('libraries'))
     else:
       jni_libs = []
     return jni_libs
 
   def _GenJavaDirs(self, entry):
     java_dirs, excludes = _CreateJavaSourceDir(
         constants.GetOutDirectory(), entry.JavaFiles())
     if self.Srcjars(entry):
       java_dirs.append(
           os.path.join(self.EntryOutputDir(entry), _SRCJARS_SUBDIR))
     return java_dirs, excludes
 
   def _GenResDirs(self, entry):
     res_dirs = list(entry.DepsInfo().get('owned_resources_dirs', []))
     if entry.ResZips():
       res_dirs.append(os.path.join(self.EntryOutputDir(entry), _RES_SUBDIR))
     return res_dirs
 
+  def _GenCustomManifest(self, entry):
+    """Returns the path to the generated AndroidManifest.xml."""
+    javac = entry.Javac()
+    resource_packages = javac['resource_packages']
+    output_file = os.path.join(
+        self.EntryOutputDir(entry), 'AndroidManifest.xml')
+
+    if not resource_packages:
+      logging.error('Target ' + entry.GnTarget() + ' includes resources from '
+          'unknown package. Unable to process with gradle.')
+      return _DEFAULT_ANDROID_MANIFEST_PATH
+    elif len(resource_packages) > 1:
+      logging.error('Target ' + entry.GnTarget() + ' includes resources from '
+          'multiple packages. Unable to process with gradle.')
+      return _DEFAULT_ANDROID_MANIFEST_PATH
+
+    variables = {}
+    variables['package'] = resource_packages[0]
+
+    data = self.jinja_processor.Render(_TemplatePath('manifest'), variables)
+    _WriteFile(output_file, data)
+
+    return output_file
+
   def _Relativize(self, entry, paths):
     return _RebasePath(paths, self.EntryOutputDir(entry))
 
   def EntryOutputDir(self, entry):
     return os.path.join(self.project_dir, entry.GradleSubdir())
 
   def Srcjars(self, entry):
     srcjars = _RebasePath(entry.Gradle().get('bundled_srcjars', []))
     if not self.use_gradle_process_resources:
       srcjars += _RebasePath(entry.BuildConfig()['javac']['srcjars'])
     return srcjars
 
   def GeneratedInputs(self, entry):
     generated_inputs = []
     generated_inputs.extend(self.Srcjars(entry))
     generated_inputs.extend(_RebasePath(entry.ResZips()))
     generated_inputs.extend(
         p for p in entry.JavaFiles() if not p.startswith('..'))
     generated_inputs.extend(entry.Gradle()['dependent_prebuilt_jars'])
     return generated_inputs
 
   def Generate(self, entry):
     variables = {}
-    android_test_manifest = entry.Gradle().get(
-        'android_manifest', _DEFAULT_ANDROID_MANIFEST_PATH)
-    variables['android_manifest'] = self._Relativize(
-        entry, android_test_manifest)
     java_dirs, excludes = self._GenJavaDirs(entry)
     variables['java_dirs'] = self._Relativize(entry, java_dirs)
     variables['java_excludes'] = excludes
     variables['jni_libs'] = self._Relativize(entry, self._GenJniLibs(entry))
     variables['res_dirs'] = self._Relativize(entry, self._GenResDirs(entry))
+    android_manifest = entry.Gradle().get('android_manifest')
+    if not android_manifest:
+      # Gradle uses package id from manifest when generating R.class. So, we
+      # need to generate a custom manifest if we let gradle process resources.

[agrieve, 2017/02/16 15:28:01]

nit: can you add a note that applicationId doesn't work for library targets.

[sakal-chromium, 2017/02/16 15:47:37]

Done.

+      if self.use_gradle_process_resources and variables['res_dirs']:

[agrieve, 2017/02/16 15:28:01]

nit: I think we'll want to do this regardless of use_gradle_process_resources

[sakal-chromium, 2017/02/16 15:47:37]

Done.

+        android_manifest = self._GenCustomManifest(entry)
+      else:
+        android_manifest = _DEFAULT_ANDROID_MANIFEST_PATH
+    variables['android_manifest'] = self._Relativize(entry, android_manifest)
     deps = [_ProjectEntry.FromBuildConfigPath(p)
             for p in entry.Gradle()['dependent_android_projects']]
     variables['android_project_deps'] = [d.ProjectName() for d in deps]
     # TODO(agrieve): Add an option to use interface jars and see if that speeds
     # things up at all.
     variables['prebuilts'] = self._Relativize(
         entry, entry.Gradle()['dependent_prebuilt_jars'])
     deps = [_ProjectEntry.FromBuildConfigPath(p)
             for p in entry.Gradle()['dependent_java_projects']]
     variables['java_project_deps'] = [d.ProjectName() for d in deps]
@@ skipping 269 matching lines @@
   args = parser.parse_args()
   if args.output_directory:
     constants.SetOutputDirectory(args.output_directory)
   constants.CheckOutputDirectory()
   output_dir = constants.GetOutDirectory()
   devil_chromium.Initialize(output_directory=output_dir)
   run_tests_helper.SetLogLevel(args.verbose_count)
 
   _gradle_output_dir = os.path.abspath(
       args.project_dir.replace('$CHROMIUM_OUTPUT_DIR', output_dir))
+  jinja_processor = jinja_template.JinjaProcessor(_FILE_DIR)
   generator = _ProjectContextGenerator(
-      _gradle_output_dir, args.use_gradle_process_resources)
+      _gradle_output_dir, args.use_gradle_process_resources, jinja_processor)
   logging.warning('Creating project at: %s', generator.project_dir)
 
   if args.all:
     # Run GN gen if necessary (faster than running "gn gen" in the no-op case).
     _RunNinja(constants.GetOutDirectory(), ['build.ninja'])
     # Query ninja for all __build_config targets.
     targets = _QueryForAllGnTargets(output_dir)
   else:
     targets = args.targets or _DEFAULT_TARGETS
     targets = [re.sub(r'_test_apk$', '_test_apk__apk', t) for t in targets]
@@ skipping 10 matching lines @@
   # when using --all.
   if args.all:
     main_entries = [e for e in main_entries if e.GetType() == 'android_apk']
 
   all_entries = _FindAllProjectEntries(main_entries)
   logging.info('Found %d dependent build_config targets.', len(all_entries))
   entries = _CombineTestEntries(all_entries)
   logging.info('Creating %d projects for targets.', len(entries))
 
   logging.warning('Writing .gradle files...')
-  jinja_processor = jinja_template.JinjaProcessor(_FILE_DIR)
   build_vars = _ReadBuildVars(output_dir)
   project_entries = []
   zip_tuples = []
   generated_inputs = []
   for entry in entries:
     if entry.GetType() not in ('android_apk', 'java_library', 'java_binary'):
       continue
 
     data = _GenerateGradleFile(entry, generator, build_vars, jinja_processor)
     if data:
@@ skipping 28 matching lines @@
     _ExtractZips(generator.project_dir, zip_tuples)
 
   logging.warning('Project created! (%d subprojects)', len(project_entries))
   logging.warning('Generated projects work best with Android Studio 2.2')
   logging.warning('For more tips: https://chromium.googlesource.com/chromium'
                   '/src.git/+/master/docs/android_studio.md')
 
 
 if __name__ == '__main__':
   main()