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')
@@ skipping 28 matching lines @@
       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, jinja_processor):
+    """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 = 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):
+  def Generate(self, entry, jinja_processor):

[Peter Wen, 2017/02/16 14:21:15]

Rather than passing this in, can you pull it out to initialize the
_ProjectContextGenerator with the jinja processor?

[sakal-chromium, 2017/02/16 14:31:35]

Done.

     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', None)

[Peter Wen, 2017/02/16 14:21:15]

None is default, no need to specify it

[sakal-chromium, 2017/02/16 14:31:35]

Done.

+    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.
+      if self.use_gradle_process_resources and variables['res_dirs']:
+        android_manifest = self._GenCustomManifest(entry, jinja_processor)
+      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 144 matching lines @@
   else:
     return None
 
   variables['target_name'] = os.path.splitext(deps_info['name'])[0]
   variables['template_type'] = target_type
   variables['use_gradle_process_resources'] = (
       generator.use_gradle_process_resources)
   variables['build_tools_version'] = (
       build_vars['android_sdk_build_tools_version'])
   variables['compile_sdk_version'] = build_vars['android_sdk_version']
-  variables['main'] = generator.Generate(entry)
+  variables['main'] = generator.Generate(entry, jinja_processor)
   if entry.android_test_entry:
     variables['android_test'] = generator.Generate(
-        entry.android_test_entry)
+        entry.android_test_entry, jinja_processor)
 
   return jinja_processor.Render(
       _TemplatePath(target_type.split('_')[0]), variables)
 
 
 def _GenerateRootGradle(jinja_processor):
   """Returns the data for the root project's build.gradle."""
   return jinja_processor.Render(_TemplatePath('root'))
 
 
@@ skipping 182 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()