Scripts to generate Android.mk for framework Skia.

platform_tools/android/bin/gyp_to_android.py

+#!/usr/bin/python
+
+# Copyright 2014 Google Inc.
+#
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""
+Script for generating the Android framework's version of Skia from gyp
+files.
+"""
+
+import android_framework_gyp
+import os
+import shutil
+import sys
+import tempfile
+
+# Find the top of trunk
+SCRIPT_DIR = os.path.abspath(os.path.dirname(__file__))
+SKIA_DIR = os.path.normpath(os.path.join(SCRIPT_DIR, os.pardir, os.pardir,
+                                         os.pardir))
+
+# Find the directory with our helper files, and add it to the path.
+GYP_GEN_DIR = os.path.join(SKIA_DIR, 'platform_tools', 'android', 'gyp_gen')
+sys.path.append(GYP_GEN_DIR)
+
+import gypd_parser
+import makefile_writer
+import variables
+import vars_dict_lib
+
+# Folder containing all gyp files and generated gypd files.
+GYP_FOLDER = 'gyp'
+
+def clean_gypd_files(folder):
+  """
+  Remove the gypd files generated by android_framework_gyp.main().
+  @param folder Folder in which to delete all files ending with 'gypd'.
+  """
+  assert os.path.isdir(folder)
+  files = os.listdir(folder)
+  for f in files:
+    if f.endswith('gypd'):
+      os.remove(os.path.join(folder, f))
+
+def main(target_dir=None):
+  """
+  Read gyp files and create Android.mk for the Android framework's
+  external/skia.
+  @param target_dir Directory in which to place 'Android.mk'. If None, the file
+                    will be placed in skia's root directory.
+  """
+  # Create a temporary folder to hold gyp and gypd files. Create it in SKIA_DIR
+  # so that it is a sibling of gyp/, so the relationships between gyp files and
+  # other files (e.g. platform_tools/android/gyp/dependencies.gypi, referenced
+  # by android_deps.gyp as a relative path) is unchanged.
+  # Use mkdtemp to find an unused folder name, but then delete it so copytree
+  # can be called with a non-existent directory.
+  tmp_folder = tempfile.mkdtemp(dir=SKIA_DIR)
+  os.rmdir(tmp_folder)
+  shutil.copytree(os.path.join(SKIA_DIR, GYP_FOLDER), tmp_folder)
+
+  try:
+    main_gyp_file = 'android_framework_lib.gyp'
+    main_gypd_file = os.path.join(tmp_folder, main_gyp_file + 'd')
+
+    print 'Creating Android.mk',
+
+    # Call the script to generate gypd files, first using a non-existant

[epoger, 2014/02/03 17:26:32]

If the following writeup is accurate, I think it might be helpful to paste into
the code at this point:

# Generate a separate VarsDict for each architecture type.  For each archtype:
# 1. call android_framework_gyp.main() to generate gypd files
# 2. call parse_gypd to read those gypd files into the VarsDict
# 3. delete the gypd files
#
# Once we have the VarsDict for each architecture type, we combine them all into
# a single Android.mk file, which can build targets of any architecture type.

[scroggo, 2014/02/03 23:22:31]

Done.

+    # archtype.
+    android_framework_gyp.main(tmp_folder, main_gyp_file, 'other', False)

[epoger, 2014/02/03 17:26:32]

If my writeup above is true, maybe you could reduce the copy-paste here as
follows:

default_var_dict = generate_var_dict('other', False)
arm_var_dict = generate_var_dict('arm', False)
arm_neon_var_dict = generate_var_dict('arm', True)

... and hide the per-architecture repetitive details within generate_var_dict()

[scroggo, 2014/02/03 23:22:31]

Done.

+    # And store its variables in the default dict
+    default_var_dict = vars_dict_lib.VarsDict()
+    gypd_parser.parse_gypd(default_var_dict, main_gypd_file)
+    clean_gypd_files(tmp_folder)
+
+    print '.',
+
+    # Now do the same for Arm. arm_var_dict will contain all the variable
+    # definitions needed to build with arm (meaning that it will share most
+    # with default_var_dict).
+    android_framework_gyp.main(tmp_folder, main_gyp_file, 'arm', False)
+    arm_var_dict = vars_dict_lib.VarsDict()
+    gypd_parser.parse_gypd(arm_var_dict, main_gypd_file)
+    clean_gypd_files(tmp_folder)
+
+    print '.',
+
+    # Now do the same for Arm/Neon.
+    android_framework_gyp.main(tmp_folder, main_gyp_file, 'arm', True)
+    arm_neon_var_dict = vars_dict_lib.VarsDict()
+    gypd_parser.parse_gypd(arm_neon_var_dict, main_gypd_file)
+    clean_gypd_files(tmp_folder)
+
+    print '.'
+
+    # Now do the same for x86.
+    x86_var_dict = vars_dict_lib.VarsDict()
+    if variables.INCLUDE_X86_OPTS:
+      android_framework_gyp.main(tmp_folder, main_gyp_file, 'x86', False)
+      gypd_parser.parse_gypd(x86_var_dict, main_gypd_file)
+      clean_gypd_files(tmp_folder)
+
+    # Compute the intersection of all targets. All the files in the intersection
+    # should be part of the makefile always. Each dict will now contain trimmed
+    # lists containing only variable definitions specific to that configuration.
+    var_dict_list = [default_var_dict, arm_var_dict, arm_neon_var_dict]
+    if variables.INCLUDE_X86_OPTS:
+      var_dict_list.append(x86_var_dict)
+    common = vars_dict_lib.intersect(var_dict_list)
+
+    # Further trim arm_neon_var_dict with arm_var_dict. After this call,
+    # arm_var_dict (which will now be the intersection) includes all definitions
+    # used by both arm and arm + neon, and arm_neon_var_dict will only contain
+    # those specific to arm + neon.
+    arm_var_dict = vars_dict_lib.intersect([arm_var_dict, arm_neon_var_dict])

[epoger, 2014/02/03 17:26:32]

So, after this call, does arm_neon_var_dict somehow know that it depends on
arm_var_dict?  (i.e. that it contains just the variances from arm_var_dict, like
how x86_var_dict and arm_var_dict contain just the variances from common)

Edit: Looking at write_android_mk(), I see that this is an inherent distinction
for the armNeon parameter.  I'm OK with that, but it's somewhat confusing that
all the VarsDicts passed into write_android_mk() are *almost* but not quite
equivalent (arm, x86, and default are variations from common; armNeon is
variations from arm).

I think write_android_mk()'s interface would be more elegant if it took a
variable-length list of VarsDicts, all "peers" at the same level of abstraction,
each of which was paired with the 'ifeq' blocking information that should be
used around it.

On the other hand, I guess that would make it harder to see just the
neon-vs-noneon distinctions within the Android.mk file

All in all, I think the way you have it now is fine, but when we add more
archtypes we may want to re-evaluate.

[scroggo, 2014/02/03 23:22:31]

Leaving as is, and adding a TODO in makefile_writer.

+
+    makefile_writer.write_android_mk(target_dir, common, arm_var_dict,

[epoger, 2014/02/03 17:26:32]

please use named parameters

makefile_writer.write_android_mk(target_dir=target_dir, common=common,
arm=arm_var_dict, ...)

Given that many of the parameters are the same type but correspond to different
platforms, I fear it would be too easy for them to get out of order and we
wouldn't discover it for a while.

[scroggo, 2014/02/03 23:22:31]

Done.

+                                     arm_neon_var_dict, x86_var_dict,
+                                     default_var_dict)
+
+  finally:
+    shutil.rmtree(tmp_folder)
+
+if __name__ == '__main__':
+  main()