[NOT FOR COMMIT] Added GN support for Android .AAR packaged libraries

build/android/gyp/write_build_config.py

 #!/usr/bin/env python
 #
 # 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.
 
 """Writes a build_config file.
 
 The build_config file for a target is a json file containing information about
 how to build that target based on the target's dependencies. This includes
@@ skipping 21 matching lines @@
 import sys
 import xml.dom.minidom
 
 from util import build_utils
 from util import md5_check
 
 import write_ordered_libraries
 
 
 # Types that should never be used as a dependency of another build config.
-_ROOT_TYPES = ('android_apk', 'deps_dex', 'java_binary', 'resource_rewriter')
+_ROOT_TYPES = ('android_apk', 'deps_dex', 'java_binary', 'resource_rewriter',
+    'android_aar')
 # Types that should not allow code deps to pass through.
-_RESOURCE_TYPES = ('android_assets', 'android_resources')
+_RESOURCE_TYPES = ('android_assets', 'android_resources', 'android_aar')

[agrieve, 2016/06/16 02:00:04]

aar matches the name here, but not the comment. This will prevent one aar from
depending on another. I think maybe the thing to do is to not add to this list
and rename the variable to "_NON_CODE_TYPES" or something similar.

 
 
 class AndroidManifest(object):
   def __init__(self, path):
     self.path = path
     dom = xml.dom.minidom.parse(path)
     manifests = dom.getElementsByTagName('manifest')
     assert len(manifests) == 1
     self.manifest = manifests[0]
 
@@ skipping 58 matching lines @@
     self.all_deps_configs = [
         GetDepConfig(p) for p in self.all_deps_config_paths]
     self.direct_deps_config_paths = direct_deps_config_paths
 
   def All(self, wanted_type=None):
     if type is None:
       return self.all_deps_configs
     return DepsOfType(wanted_type, self.all_deps_configs)
 
   def Direct(self, wanted_type=None):
+    additional_deps = []
     if wanted_type is None:
       return self.direct_deps_configs
-    return DepsOfType(wanted_type, self.direct_deps_configs)
+    if wanted_type in ['java_library', 'android_resources']:

[agrieve, 2016/06/16 02:00:03]

an android_aar may or may not have resources / assets, so it might make more
sense to do:

def DepsOfType(wanted_types, config):
  return [c for c in configs if wanted_type in c['effective_types']]

And then have all targets types have:
deps_info.effective_types = [deps_info.type]

and then have aar add in the types based on what's in the .aar file.

+      additional_deps = DepsOfType('android_aar', self.direct_deps_configs)
+    return additional_deps + DepsOfType(wanted_type, self.direct_deps_configs)
 
   def AllConfigPaths(self):
     return self.all_deps_config_paths
 
   def RemoveNonDirectDep(self, path):
     if path in self.direct_deps_config_paths:
       raise Exception('Cannot remove direct dep.')
     self.all_deps_config_paths.remove(path)
     self.all_deps_configs.remove(GetDepConfig(path))
 
@@ skipping 115 matching lines @@
 
   if args:
     parser.error('No positional arguments should be given.')
 
   required_options_map = {
       'java_binary': ['build_config', 'jar_path'],
       'java_library': ['build_config', 'jar_path'],
       'android_assets': ['build_config'],
       'android_resources': ['build_config', 'resources_zip'],
       'android_apk': ['build_config', 'jar_path', 'dex_path', 'resources_zip'],
+      'android_aar': ['build_config', 'jar_path', 'resources_zip'],
       'deps_dex': ['build_config', 'dex_path'],
       'resource_rewriter': ['build_config'],
       'group': ['build_config'],
   }
   required_options = required_options_map.get(options.type)
   if not required_options:
     raise Exception('Unknown type: <%s>' % options.type)
 
   if options.native_libs:
     required_options.append('readelf_path')
@@ skipping 56 matching lines @@
   config = {
     'deps_info': {
       'name': os.path.basename(options.build_config),
       'path': options.build_config,
       'type': options.type,
       'deps_configs': direct_deps_config_paths
     }
   }
   deps_info = config['deps_info']
 
-  if (options.type in ('java_binary', 'java_library') and
+  if (options.type in ('java_binary', 'java_library', 'android_aar') and
       not options.bypass_platform_checks):
     deps_info['requires_android'] = options.requires_android
     deps_info['supports_android'] = options.supports_android
 
     deps_require_android = (all_resources_deps +
         [d['name'] for d in all_library_deps if d['requires_android']])
     deps_not_support_android = (
         [d['name'] for d in all_library_deps if not d['supports_android']])
 
     if deps_require_android and not options.requires_android:
       raise Exception('Some deps require building for the Android platform: ' +
           str(deps_require_android))
 
     if deps_not_support_android and options.supports_android:
       raise Exception('Not all deps support the Android platform: ' +
           str(deps_not_support_android))
 
-  if options.type in ('java_binary', 'java_library', 'android_apk'):
+  if options.type in ('java_binary', 'java_library', 'android_apk',
+      'android_aar'):
     javac_classpath = [c['jar_path'] for c in direct_library_deps]
     java_full_classpath = [c['jar_path'] for c in all_library_deps]
     deps_info['resources_deps'] = [c['path'] for c in all_resources_deps]
     deps_info['jar_path'] = options.jar_path
     if options.type == 'android_apk' or options.supports_android:
       deps_info['dex_path'] = options.dex_path
     if options.type == 'android_apk':
       deps_info['apk_path'] = options.apk_path
       deps_info['incremental_apk_path'] = options.incremental_apk_path
       deps_info['incremental_install_script_path'] = (
           options.incremental_install_script_path)
 
     # Classpath values filled in below (after applying tested_apk_config).
     config['javac'] = {}
 
-  if options.type in ('java_binary', 'java_library'):
+  if options.type in ('java_binary', 'java_library', 'android_aar'):
     # Only resources might have srcjars (normal srcjar targets are listed in
     # srcjar_deps). A resource's srcjar contains the R.java file for those
     # resources, and (like Android's default build system) we allow a library to
     # refer to the resources in any of its dependents.
     config['javac']['srcjars'] = [
         c['srcjar'] for c in direct_resources_deps if 'srcjar' in c]
 
     # Used to strip out R.class for android_prebuilt()s.
-    if options.type == 'java_library':
+    if options.type in ('java_library', 'android_aar'):
       config['javac']['resource_packages'] = [
           c['package_name'] for c in all_resources_deps if 'package_name' in c]
 
   if options.type == 'android_apk':
     # Apks will get their resources srcjar explicitly passed to the java step.
     config['javac']['srcjars'] = []
 
   if options.type == 'android_assets':

[agrieve, 2016/06/16 02:00:03]

might want to add a TODO for allowing aars with assets.

     all_asset_sources = []
     if options.asset_renaming_sources:
       all_asset_sources.extend(
           build_utils.ParseGypList(options.asset_renaming_sources))
     if options.asset_sources:
       all_asset_sources.extend(build_utils.ParseGypList(options.asset_sources))
 
     deps_info['assets'] = {
         'sources': all_asset_sources
     }
     if options.asset_renaming_destinations:
       deps_info['assets']['outputs'] = (
           build_utils.ParseGypList(options.asset_renaming_destinations))
     if options.disable_asset_compression:
       deps_info['assets']['disable_compression'] = True
 
-  if options.type == 'android_resources':
+  if options.type in ('android_resources', 'android_aar'):

[agrieve, 2016/06/16 02:00:03]

Should probably update package_resources.py to not extract the entire resource
zip, but instread just the res/ directory. build_utils.ExtractAll(filter=) can
be used for this.

     deps_info['resources_zip'] = options.resources_zip
     if options.srcjar:
       deps_info['srcjar'] = options.srcjar
     if options.android_manifest:

[agrieve, 2016/06/16 02:00:03]

I think you want to pass this flag as well from the .gni.

       manifest = AndroidManifest(options.android_manifest)
       deps_info['package_name'] = manifest.GetPackageName()
     if options.package_name:
       deps_info['package_name'] = options.package_name
     if options.r_text:

[agrieve, 2016/06/16 02:00:03]

Is this being set for aar?

       deps_info['r_text'] = options.r_text
     if options.is_locale_resource:
       deps_info['is_locale_resource'] = True
 
-  if options.type in ('android_resources','android_apk', 'resource_rewriter'):
+  if options.type in ('android_resources', 'android_apk', 'resource_rewriter',
+      'android_aar'):
     config['resources'] = {}
     config['resources']['dependency_zips'] = [
         c['resources_zip'] for c in all_resources_deps]
     config['resources']['extra_package_names'] = []
     config['resources']['extra_r_text_files'] = []
 
   if options.type == 'android_apk' or options.type == 'resource_rewriter':
     config['resources']['extra_package_names'] = [
         c['package_name'] for c in all_resources_deps if 'package_name' in c]
     config['resources']['extra_r_text_files'] = [
         c['r_text'] for c in all_resources_deps if 'r_text' in c]
 
   if options.type in ['android_apk', 'deps_dex']:
     deps_dex_files = [c['dex_path'] for c in all_library_deps]
 
   proguard_enabled = options.proguard_enabled
   if options.type == 'android_apk':
     deps_info['proguard_enabled'] = proguard_enabled
 
   if proguard_enabled:
     deps_info['proguard_info'] = options.proguard_info
     config['proguard'] = {}
     proguard_config = config['proguard']
     proguard_config['input_paths'] = [options.jar_path] + java_full_classpath

[agrieve, 2016/06/16 02:00:03]

Might want to add a TODO here to support adding the path of an .aar's
proguard.txt

 
   # An instrumentation test apk should exclude the dex files that are in the apk
   # under test.
   if options.type == 'android_apk' and options.tested_apk_config:
     tested_apk_library_deps = tested_apk_deps.All('java_library')
     tested_apk_deps_dex_files = [c['dex_path'] for c in tested_apk_library_deps]
     # Include in the classpath classes that are added directly to the apk under
     # test (those that are not a part of a java_library).
     tested_apk_config = GetDepConfig(options.tested_apk_config)
     javac_classpath.append(tested_apk_config['jar_path'])
     # Exclude dex files from the test apk that exist within the apk under test.
     deps_dex_files = [
         p for p in deps_dex_files if not p in tested_apk_deps_dex_files]
 
     expected_tested_package = tested_apk_config['package_name']
     AndroidManifest(options.android_manifest).CheckInstrumentation(
         expected_tested_package)
     if tested_apk_config['proguard_enabled']:
       assert proguard_enabled, ('proguard must be enabled for instrumentation'
           ' apks if it\'s enabled for the tested apk')
 
   # Dependencies for the final dex file of an apk or a 'deps_dex'.
   if options.type in ['android_apk', 'deps_dex']:
     config['final_dex'] = {}
     dex_config = config['final_dex']
     dex_config['dependency_dex_files'] = deps_dex_files
 
-  if options.type in ('java_binary', 'java_library', 'android_apk'):
+  if options.type in ('java_binary', 'java_library', 'android_apk',
+      'android_aar'):
     config['javac']['classpath'] = javac_classpath
     config['javac']['interface_classpath'] = [
         _AsInterfaceJar(p) for p in javac_classpath]
     config['java'] = {
       'full_classpath': java_full_classpath
     }
 
   if options.type == 'android_apk':
     dependency_jars = [c['jar_path'] for c in all_library_deps]
     all_interface_jars = [
@@ skipping 48 matching lines @@
         _MergeAssets(deps.All('android_assets')))
 
   build_utils.WriteJson(config, options.build_config, only_if_changed=True)
 
   if options.depfile:
     build_utils.WriteDepfile(options.depfile, all_inputs)
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))