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'
+# This needs to come first alphabetically among all modules.
+_MODULE_ALL = '_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 190 matching lines @@
 
 class _ProjectContextGenerator(object):
   """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
+    self.processed_java_dirs = set()
+    self.processed_prebuilts = set()
 
   def _GenJniLibs(self, root_entry):
     libraries = []
     for entry in self._GetEntries(root_entry):
       libraries += entry.BuildConfig().get('native', {}).get('libraries', [])
     if libraries:
       return _CreateJniLibsDir(constants.GetOutDirectory(),
           self.EntryOutputDir(root_entry), libraries)
     return []
 
@@ skipping 69 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.processed_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()]
-    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)
+    prebuilts = set(
+        p for e in self._GetEntries(root_entry) for p in e.PrebuiltJars())
+    self.processed_prebuilts.update(prebuilts)
+    variables['prebuilts'] = self._Relativize(root_entry, prebuilts)
+    res_dirs = set(
+        p for e in self._GetEntries(root_entry) for p in e.ResDirs())
+    res_dirs.add(
+        os.path.join(self.EntryOutputDir(root_entry), _RES_SUBDIR))
+    variables['res_dirs'] = self._Relativize(root_entry, res_dirs)
     android_manifest = root_entry.Gradle().get('android_manifest')
     if not android_manifest:
       android_manifest = self._GenCustomManifest(root_entry)
     variables['android_manifest'] = self._Relativize(
         root_entry, android_manifest)
     if self.split_projects:
       deps = [_ProjectEntry.FromBuildConfigPath(p)
               for p in root_entry.Gradle()['dependent_android_projects']]
       variables['android_project_deps'] = [d.ProjectName() for d in deps]
       deps = [_ProjectEntry.FromBuildConfigPath(p)
@@ skipping 110 matching lines @@
 
 
 def _GenerateLocalProperties(sdk_dir):
   """Returns the data for project.properties as a string."""
   return '\n'.join([
       '# Generated by //build/android/gradle/generate_gradle.py',
       'sdk.dir=%s' % sdk_dir,
       ''])
 
 
-def _GenerateGradleFile(entry, generator, build_vars, jinja_processor):
+def _GenerateBaseVars(generator, build_vars, source_properties):
+  variables = {
+      'sourceSetName': 'main',
+      'depCompileName': 'compile',
+  }
+  variables['build_tools_version'] = source_properties['Pkg.Revision']
+  variables['compile_sdk_version'] = (
+      'android-%s' % build_vars['android_sdk_version'])
+  variables['use_gradle_process_resources'] = (
+      generator.use_gradle_process_resources)
+  return variables
+
+
+def _GenerateGradleFile(entry, generator, build_vars, source_properties,
+    jinja_processor):
   """Returns the data for a project's build.gradle."""
   deps_info = entry.DepsInfo()
   gradle = entry.Gradle()
 
-  variables = {
-      'sourceSetName': 'main',
-      'depCompileName': 'compile',
-  }
+  variables = _GenerateBaseVars(generator, build_vars, source_properties)
   if deps_info['type'] == 'android_apk':
     target_type = 'android_apk'
   elif deps_info['type'] == 'java_library':
     if deps_info['is_prebuilt'] or deps_info['gradle_treat_as_prebuilt']:
       return None
     elif deps_info['requires_android']:
       target_type = 'android_library'
     else:
       target_type = 'java_library'
   elif deps_info['type'] == 'java_binary':
     if gradle['main_class'] == 'org.chromium.testing.local.JunitTestMain':
       target_type = 'android_junit'
       variables['sourceSetName'] = 'test'
       variables['depCompileName'] = 'testCompile'
     else:
       target_type = 'java_binary'
       variables['main_class'] = gradle['main_class']
   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)
-  source_properties = _ReadPropertiesFile(
-      _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'])
   variables['main'] = generator.Generate(entry)
   bootclasspath = gradle.get('bootclasspath')
   if bootclasspath:
     # Must use absolute path here.
     variables['bootclasspath'] = _RebasePath(bootclasspath)
   if entry.android_test_entry:
     variables['android_test'] = generator.Generate(
         entry.android_test_entry)
     for key, value in variables['android_test'].iteritems():
       if isinstance(value, list):
-        variables['android_test'][key] = list(
+        variables['android_test'][key] = sorted(
             set(value) - set(variables['main'][key]))
 
   return jinja_processor.Render(
       _TemplatePath(target_type.split('_')[0]), variables)
 
 
+def _GenerateModuleAll(gradle_output_dir, generator, build_vars,
+    source_properties, jinja_processor):
+  """Returns the data for a pseudo build.gradle of all dirs.
+
+  See //docs/android_studio.md for more details."""
+  variables = _GenerateBaseVars(generator, build_vars, source_properties)
+  target_type = 'android_apk'
+  variables['target_name'] = _MODULE_ALL
+  variables['template_type'] = target_type
+  java_dirs = sorted(generator.processed_java_dirs)
+  prebuilts = sorted(generator.processed_prebuilts)
+  def Relativize(paths):
+    return _RebasePath(paths, os.path.join(gradle_output_dir, _MODULE_ALL))
+  variables['main'] = {
+      'android_manifest': Relativize(_DEFAULT_ANDROID_MANIFEST_PATH),
+      'java_dirs': Relativize(java_dirs),
+      'prebuilts': Relativize(prebuilts),
+      'java_excludes': ['**/*.java'],
+  }
+  data = jinja_processor.Render(
+      _TemplatePath(target_type.split('_')[0]), variables)
+  _WriteFile(
+      os.path.join(gradle_output_dir, _MODULE_ALL, _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):
   """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('')
 
+  lines.append('include ":{0}"'.format(_MODULE_ALL))
+  lines.append(
+      'project(":{0}").projectDir = new File(settingsDir, "{0}")'.format(
+          _MODULE_ALL))
   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 90 matching lines @@
                            'combining all the dependencies of each target')
   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:
+    assert not args.use_gradle_process_resources, (

[sakal-chromium, 2017/05/04 09:11:00]

Why did the meaning of this check change? Now it asserts that
use_gradle_process_resouces is not set when using split_projects. I think this
is a bug?

[Peter Wen, 2017/05/04 10:19:58]

Yes, you are correct, it's a bug. I'll fix it in a follow-up CL.

+        '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'))
+  source_properties = _ReadPropertiesFile(
+      _RebasePath(os.path.join(build_vars['android_sdk_build_tools'],
+                               'source.properties')))
   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:
     # 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
     if args.extra_targets:
       targets.extend(args.extra_targets)
     targets = [re.sub(r'_test_apk$', '_test_apk__apk', t) for t in targets]
     # TODO(wnwen): Utilize Gradle's test constructs for our junit tests?
     targets = [re.sub(r'_junit_tests$', '_junit_tests__java_binary', t)
                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)
+    data = _GenerateGradleFile(entry, generator, build_vars, source_properties,
+        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'),
+  _GenerateModuleAll(_gradle_output_dir, generator, build_vars,
+      source_properties, 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))
 
   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()