Android: Add pseudo module for Android Studio

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 17 matching lines @@
 from util import build_utils
 
 
 _DEFAULT_ANDROID_MANIFEST_PATH = os.path.join(
     host_paths.DIR_SOURCE_ROOT, 'build', 'android', 'AndroidManifest.xml')
 _FILE_DIR = os.path.dirname(__file__)
 _SRCJARS_SUBDIR = 'extracted-srcjars'
 _JNI_LIBS_SUBDIR = 'symlinked-libs'
 _ARMEABI_SUBDIR = 'armeabi'
 _RES_SUBDIR = 'extracted-res'
+_GRADLE_BUILD_FILE = 'build.gradle'
+_PSEUDO_NAME = 'a_pseudo_module'

[agrieve, 2017/04/12 19:36:29]

nit: is the "a" need to be there so it comes alphabetically first? Worth a
comment if so. If not, I'd drop it.

[Peter Wen, 2017/04/13 17:23:16]

Added comment, changed to _all

 
 _DEFAULT_TARGETS = [
     # TODO(agrieve): .build_config seem not quite right for this target
     # because it has resources as deps of android_apk() rather than using an
     #  android_library() intermediate target.
     # '//android_webview:system_webview_apk',
     '//android_webview/test:android_webview_apk',
     '//android_webview/test:android_webview_test_apk',
     '//base:base_junit_tests',
     '//chrome/android:chrome_junit_tests',
@@ skipping 182 matching lines @@
           for p in self.Gradle()['dependent_java_projects'])
       all_entries = set()
       for dep in deps:
         all_entries.update(dep.AllEntries())
       all_entries.add(self)
       self._all_entries = list(all_entries)
     return self._all_entries
 
 
 class _ProjectContextGenerator(object):
+
+  java_dirs = set()

[agrieve, 2017/04/12 19:36:29]

This is a singleton class, so it's a bit confusing to have these as class
variables.

Also as a nit: How about "all_java_dirs", or "seen_java_dirs" (likewise for
prebuilts)

[Peter Wen, 2017/04/13 17:23:17]

Done.

+  prebuilts = set()
+
   """Helper class to generate gradle build files"""
   def __init__(self, project_dir, build_vars, use_gradle_process_resources,
       jinja_processor, split_projects):
     self.project_dir = project_dir
     self.build_vars = build_vars
     self.use_gradle_process_resources = use_gradle_process_resources
     self.jinja_processor = jinja_processor
     self.split_projects = split_projects
 
   def _GenJniLibs(self, root_entry):
@@ skipping 77 matching lines @@
     for entry in self._GetEntries(root_entry):
       generated_inputs.update(entry.GeneratedJavaFiles())
       generated_inputs.update(entry.PrebuiltJars())
     return set(generated_inputs)
 
   def Generate(self, root_entry):
     # TODO(agrieve): Add an option to use interface jars and see if that speeds
     # things up at all.
     variables = {}
     java_dirs, excludes = self._GenJavaDirs(root_entry)
+    java_dirs.append(
+        os.path.join(self.EntryOutputDir(root_entry), _SRCJARS_SUBDIR))
+    self.java_dirs.update(java_dirs)
     java_dirs.sort()
     variables['java_dirs'] = self._Relativize(root_entry, java_dirs)
-    variables['java_dirs'].append(_SRCJARS_SUBDIR)
     variables['java_excludes'] = excludes
     variables['jni_libs'] = self._Relativize(
         root_entry, set(self._GenJniLibs(root_entry)))
     variables['prebuilts'] = [
         p for e in self._GetEntries(root_entry) for p in e.PrebuiltJars()]
+    self.prebuilts.update(variables['prebuilts'])
     variables['res_dirs'] = [
         p for e in self._GetEntries(root_entry) for p in e.ResDirs()]
     for entry in self._GetEntries(root_entry):
       variables['prebuilts'] += entry.PrebuiltJars()
       variables['res_dirs'] += entry.ResDirs()
     variables['prebuilts'] = self._Relativize(
         root_entry, set(variables['prebuilts']))
     variables['res_dirs'] = self._Relativize(
         root_entry, set(variables['res_dirs']))
     variables['res_dirs'].append(_RES_SUBDIR)
@@ skipping 176 matching lines @@
         entry.android_test_entry)
     for key, value in variables['android_test'].iteritems():
       if isinstance(value, list):
         variables['android_test'][key] = list(
             set(value) - set(variables['main'][key]))
 
   return jinja_processor.Render(
       _TemplatePath(target_type.split('_')[0]), variables)
 
 
+def _GeneratePseudoModule(gradle_output_dir, generator, build_vars,
+    jinja_processor):
+  """Returns the data for a pseudo build.gradle of all dirs."""

[agrieve, 2017/04/12 19:36:29]

what makes it pseudo? Is it not a real module? Maybe just drop "pseudo" here.

[Peter Wen, 2017/04/13 17:23:17]

Changed name to "All"

+
+  variables = {
+      'sourceSetName': 'main',
+      'depCompileName': 'compile',
+      'target_name': _PSEUDO_NAME,
+  }
+  target_type = 'android_apk'
+  variables['template_type'] = target_type
+  variables['use_gradle_process_resources'] = (
+      generator.use_gradle_process_resources)
+  source_properties = _ReadPropertiesFile(

[agrieve, 2017/04/12 19:36:29]

Please figure out how to re-use rather than copy & paste. Probably this call
should be lifted out of _GenerateGradleFile() since it's re-reading the same
file for each entry.

[Peter Wen, 2017/04/13 17:23:17]

Done.

+      _RebasePath(os.path.join(build_vars['android_sdk_build_tools'],
+                               'source.properties')))
+  variables['build_tools_version'] = source_properties['Pkg.Revision']
+  variables['compile_sdk_version'] = (
+      'android-%s' % build_vars['android_sdk_version'])
+  def Relativize(paths):
+    return _RebasePath(paths, os.path.join(gradle_output_dir, _PSEUDO_NAME))
+  java_dirs = list(_ProjectContextGenerator.java_dirs)
+  java_dirs.sort()
+  prebuilts = list(_ProjectContextGenerator.prebuilts)
+  prebuilts.sort()
+  variables['main'] = {
+      'android_manifest': Relativize(_DEFAULT_ANDROID_MANIFEST_PATH),
+      'java_dirs': Relativize(java_dirs),
+      'prebuilts': Relativize(prebuilts),
+      'java_excludes': ['**/*.java'],
+      # TODO(wnwen): exclude everything
+  }
+  data = jinja_processor.Render(
+      _TemplatePath(target_type.split('_')[0]), variables)
+  _WriteFile(
+      os.path.join(gradle_output_dir, _PSEUDO_NAME, _GRADLE_BUILD_FILE), data)
+
+
 def _GenerateRootGradle(jinja_processor):
   """Returns the data for the root project's build.gradle."""
   return jinja_processor.Render(_TemplatePath('root'))
 
 
-def _GenerateSettingsGradle(project_entries):
+def _GenerateSettingsGradle(project_entries, avoid_pseudo_module):
   """Returns the data for settings.gradle."""
   project_name = os.path.basename(os.path.dirname(host_paths.DIR_SOURCE_ROOT))
   lines = []
   lines.append('// Generated by //build/android/gradle/generate_gradle.py')
   lines.append('rootProject.name = "%s"' % project_name)
   lines.append('rootProject.projectDir = settingsDir')
   lines.append('')
 
+  if not avoid_pseudo_module:
+    lines.append('include ":{0}"'.format(_PSEUDO_NAME))
+    lines.append(
+        'project(":{0}").projectDir = new File(settingsDir, "{0}")'.format(
+            _PSEUDO_NAME))
   for entry in project_entries:
     # Example target: android_webview:android_webview_java__build_config
     lines.append('include ":%s"' % entry.ProjectName())
     lines.append('project(":%s").projectDir = new File(settingsDir, "%s")' %
                  (entry.ProjectName(), entry.GradleSubdir()))
   return '\n'.join(lines)
 
 
 def _ExtractFile(zip_path, extracted_path):
   logging.info('Extracting %s to %s', zip_path, extracted_path)
@@ skipping 81 matching lines @@
   parser.add_argument('--all',
                       action='store_true',
                       help='Generate all java targets (slows down IDE)')
   parser.add_argument('--use-gradle-process-resources',
                       action='store_true',
                       help='Have gradle generate R.java rather than ninja')
   parser.add_argument('--split-projects',
                       action='store_true',
                       help='Split projects by their gn deps rather than '
                            'combining all the dependencies of each target')
+  parser.add_argument('--avoid-pseudo-module',
+                      action='store_true',
+                      help='Prevent an overall pseudo module from being '

[agrieve, 2017/04/12 19:36:29]

Please explain why you might ever want to do this in the help.

[Peter Wen, 2017/04/13 17:23:16]

Removed.

Hmm... just an escape hatch I added, not really necessary to add the code
complexity for something that should always be done (it results in the "correct"
interpretation of our code in Android Studio with regard to references and
imports).

+                           'generated (not applicable to split projects)')
   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)
 
   # TODO(wnwen): Fix packaging so that gradle resources work in this case.
-  if args.use_gradle_process_resources:
-    assert args.split_projects, (
-        'Gradle resources does not yet work without --split-projects.')
+  if args.split_projects:
+    args.avoid_pseudo_module = True
+    assert not args.use_gradle_process_resources, (
+        'Gradle resources does not work without --split-projects.')
 
   _gradle_output_dir = os.path.abspath(
       args.project_dir.replace('$CHROMIUM_OUTPUT_DIR', output_dir))
   jinja_processor = jinja_template.JinjaProcessor(_FILE_DIR)
   build_vars = _ReadPropertiesFile(os.path.join(output_dir, 'build_vars.txt'))
   generator = _ProjectContextGenerator(_gradle_output_dir, build_vars,
       args.use_gradle_process_resources, jinja_processor, args.split_projects)
   logging.warning('Creating project at: %s', generator.project_dir)
 
   if args.all:
@@ skipping 11 matching lines @@
                for t in targets]
 
   main_entries = [_ProjectEntry.FromGnTarget(t) for t in targets]
 
   logging.warning('Building .build_config files...')
   _RunNinja(output_dir, [e.NinjaBuildConfigTarget() for e in main_entries])
 
   # There are many unused libraries, so restrict to those that are actually used
   # when using --all.
   if args.all:
-    main_entries = [e for e in main_entries if e.GetType() == 'android_apk']
+    main_entries = [e for e in main_entries if (
+        e.GetType() == 'android_apk' or
+        e.GnTarget().endswith('_test_apk__apk') or
+        e.GnTarget().endswith('_junit_tests__java_binary'))]
 
   if args.split_projects:
     main_entries = _FindAllProjectEntries(main_entries)
     logging.info('Found %d dependent build_config targets.', len(main_entries))
   entries = _CombineTestEntries(main_entries)
   logging.info('Creating %d projects for targets.', len(entries))
 
   logging.warning('Writing .gradle files...')
   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:
       project_entries.append(entry)
       # Build all paths references by .gradle that exist within output_dir.
       generated_inputs.extend(generator.GeneratedInputs(entry))
       zip_tuples.extend(
           (s, os.path.join(generator.EntryOutputDir(entry), _SRCJARS_SUBDIR))
           for s in generator.AllSrcjars(entry))
       zip_tuples.extend(
           (s, os.path.join(generator.EntryOutputDir(entry), _RES_SUBDIR))
           for s in generator.AllResZips(entry))
       _WriteFile(
-          os.path.join(generator.EntryOutputDir(entry), 'build.gradle'), data)
+          os.path.join(generator.EntryOutputDir(entry), _GRADLE_BUILD_FILE),
+          data)
 
-  _WriteFile(os.path.join(generator.project_dir, 'build.gradle'),
+  if not args.avoid_pseudo_module:
+    _GeneratePseudoModule(
+        _gradle_output_dir, generator, build_vars, jinja_processor)
+
+  _WriteFile(os.path.join(generator.project_dir, _GRADLE_BUILD_FILE),
              _GenerateRootGradle(jinja_processor))
 
   _WriteFile(os.path.join(generator.project_dir, 'settings.gradle'),
-             _GenerateSettingsGradle(project_entries))
+             _GenerateSettingsGradle(project_entries, args.avoid_pseudo_module))
 
   sdk_path = _RebasePath(build_vars['android_sdk_root'])
   _WriteFile(os.path.join(generator.project_dir, 'local.properties'),
              _GenerateLocalProperties(sdk_path))
 
   if generated_inputs:
     logging.warning('Building generated source files...')
     targets = _RebasePath(generated_inputs, output_dir)
     _RunNinja(output_dir, targets)
 
   if zip_tuples:
     _ExtractZips(generator.project_dir, zip_tuples)
 
   logging.warning('Project created! (%d subprojects)', len(project_entries))
   logging.warning('Generated projects work with Android Studio 2.3')
   logging.warning('For more tips: https://chromium.googlesource.com/chromium'
                   '/src.git/+/master/docs/android_studio.md')
 
 
 if __name__ == '__main__':
   main()