Change install_emulator_deps.py to support Arm build

build/android/install_emulator_deps.py

 #!/usr/bin/env python
 # Copyright (c) 2013 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.
 
 """Installs deps for using SDK emulator for testing.
 
 The script will download the SDK and system images, if they are not present, and
 install and enable KVM, if virtualization has been enabled in the BIOS.
 """
 
 
 import logging
 import optparse
 import os
 import re
 import sys
 
 from devil.utils import cmd_helper
 from devil.utils import run_tests_helper
 from pylib import constants
 from pylib import pexpect
 
 # Android API level
 DEFAULT_ANDROID_API_LEVEL = constants.ANDROID_SDK_VERSION
+DEFAULT_ABI = 'x86'

[rnephew (Wrong account), 2016/01/07 21:21:44]

What does abi stand for? Just switching it to architecture might make it more
easily understood.

[Yoland Yan(Google), 2016/01/08 00:00:40]

All the other place in this script and in avd.py/emulator.py uses ABI instead of
ARCH. I am stick with this, but added a comment

 
 # Default Time out for downloading SDK component
 DOWNLOAD_SYSTEM_IMAGE_TIMEOUT = 30
 DOWNLOAD_SDK_PLATFORM_TIMEOUT = 60
 
 def CheckSDK():
   """Check if SDK is already installed.
 
   Returns:
     True if the emulator SDK directory (src/android_emulator_sdk/) exists.
   """
   return os.path.exists(constants.ANDROID_SDK_ROOT)
 
 
-def CheckSDKPlatform(api_level=DEFAULT_ANDROID_API_LEVEL):
+def CheckSDKPlatform(api_level=DEFAULT_ANDROID_API_LEVEL, google=False):
   """Check if the "SDK Platform" for the specified API level is installed.
      This is necessary in order for the emulator to run when the target
      is specified.
 
   Args:
+    abi: target architecture, x86 or arm

[mikecase (-- gone --), 2016/01/07 22:27:30]

s/target architecture/target abi/ ¯\_(ツ)_/¯

[Yoland Yan(Google), 2016/01/08 00:00:40]

You dropped your arm, here \ you g..wait a min..
done.

     api_level: the Android API level to check; defaults to the latest API.
+    google: use Google APIs instead of AOSP build
 
   Returns:
     True if the platform is already installed.
   """
   android_binary = os.path.join(constants.ANDROID_SDK_ROOT, 'tools', 'android')
-  pattern = re.compile('id: [0-9]+ or "android-%d"' % api_level)
+  if google:
+    pattern = re.compile('id: [0-9]+ or "Google Inc.:Google APIs:%s"' %
+                         api_level)
+  else:
+    pattern = re.compile('id: [0-9]+ or "android-%d"' % api_level)
+
   try:
     exit_code, stdout = cmd_helper.GetCmdStatusAndOutput(
         [android_binary, 'list'])
     if exit_code != 0:
       raise Exception('\'android list\' command failed')
     for line in stdout.split('\n'):
       if pattern.match(line):
         return True
     return False
   except OSError:
     logging.exception('Unable to execute \'android list\'')
     return False
 
 
-def CheckX86Image(api_level=DEFAULT_ANDROID_API_LEVEL):
+def CheckSystemImage(abi, api_level=DEFAULT_ANDROID_API_LEVEL, google=False):
   """Check if Android system images have been installed.
 
   Args:
+    abi: target architecture, x86 or arm
     api_level: the Android API level to check for; defaults to the latest API.
+    google: use Google APIs instead of AOSP build
 
   Returns:
     True if x86 image has been previously downloaded.
   """
   api_target = 'android-%d' % api_level
-  return os.path.exists(os.path.join(constants.ANDROID_SDK_ROOT,
-                                     'system-images', api_target, 'default',
-                                     'x86'))
-
+  system_image_root = os.path.join(constants.ANDROID_SDK_ROOT,
+                                   'system-images', api_target)
+  if abi == 'x86':
+    if google:
+      return os.path.exists(os.path.join(system_image_root, 'google_apis',
+                                         'x86'))
+    else:
+      return os.path.exists(os.path.join(system_image_root, 'default', 'x86'))
+  elif abi == 'arm':
+    if google:
+      return os.path.exists(os.path.join(system_image_root, 'google_apis',
+                                         'armeabi-v7a'))
+    else:
+      return os.path.exists(os.path.join(system_image_root, 'default',
+                                         'armeabi-v7a'))
+  else:
+    raise Exception("abi option invalid")
 
 def CheckKVM():
   """Quickly check whether KVM is enabled.
 
   Returns:
     True iff /dev/kvm exists (Linux only).
   """
   return os.path.exists('/dev/kvm')
 
-
 def RunKvmOk():
   """Run kvm-ok as root to check that KVM is properly enabled after installation
      of the required packages.
 
   Returns:
     True iff KVM is enabled (/dev/kvm exists). On failure, returns False
     but also print detailed information explaining why KVM isn't enabled
     (e.g. CPU doesn't support it, or BIOS disabled it).
   """
   try:
@@ skipping 58 matching lines @@
       update_process.sendline('y')
       if update_process.expect(
         'Done. 1 package installed.', timeout=timeout) == 0:
         logging.info('Successfully installed %s for API level %d',
                       package_name, api_level)
         return
       else:
         raise Exception('Failed to install platform update')
   raise Exception('Could not find android-%d update for the SDK!' % api_level)
 
-def GetX86Image(api_level=DEFAULT_ANDROID_API_LEVEL):
-  """Download x86 system image from Intel's website.
+def GetSystemImage(abi, api_level=DEFAULT_ANDROID_API_LEVEL, google=False):
+  """Download system image files using tools/android under third_party

[mikecase (-- gone --), 2016/01/07 22:27:30]

I can see this documentation getting out of date. Maybe just rewrite as
"""Download system image files."""

[Yoland Yan(Google), 2016/01/08 00:00:40]

Done.

 
   Args:
+    abi: target architecture, x86 or arm
     api_level: the Android API level to download for.
+    google: use Google APIs instead of AOSP build

[mikecase (-- gone --), 2016/01/07 22:27:31]

Google build instead of AOSP build?
or
Google APIs instead of AOSP APIs?
or

from you help comment on the arg is sounds like it is...
Google Android image instead of AOSP image.

[Yoland Yan(Google), 2016/01/08 00:00:40]

Done.

   """
   logging.info('Download x86 system image directory into sdk directory.')
 
-  x86_package_pattern = re.compile(
-    r'\s*([0-9]+)- Intel x86 Atom System Image, Android API %d.*' % api_level)
+  if abi == 'x86':
+    if google:
+      package_name = 'Google Intel x86 Atom System Image'
+      pattern = re.compile(
+         r'\s*([0-9]+)- Google APIs Intel x86 Atom System Image, Google Inc.'

[rnephew (Wrong account), 2016/01/07 21:21:44]

These seem very specific. Are we guaranteed they wont change and need constant
maintenance? If so, is there a more general regex that could be used to
differentiate? 

[Yoland Yan(Google), 2016/01/08 00:00:40]

The current ones won't change because these targets are used by others outside
Google with links like
this(https://dl.google.com/android/repository/sys-img/android/sys-img.xml). The
future ones might (it happened before), but it doesn't follow a changing pattern
so it's hard to use regex to generalize.

+        ' API %d.*' % api_level)
+    else:
+      package_name = 'Intel x86 system image'
+      pattern = re.compile(
+        r'\s*([0-9]+)- Intel x86 Atom System Image, Android API %d.*'
+        % api_level)
+  elif abi == 'arm':
+    if google:
+      package_name = 'Google arm system image'
+      pattern = re.compile(
+        r'\s*([0-9]+)- Google APIs ARM EABI v7a System Image, Google Inc. API '
+        '%d.*' % api_level)
+    else:
+      package_name = 'Android arm system image'
+      pattern = re.compile(
+        r'\s*([0-9]+)- ARM EABI v7a System Image, Android API %d.*' % api_level)
+  else:
+    raise Exception('abi option is invalid')
 
-  UpdateSDK(api_level, 'x86 system image', x86_package_pattern,
-            DOWNLOAD_SYSTEM_IMAGE_TIMEOUT)
+  UpdateSDK(api_level, package_name, pattern, DOWNLOAD_SYSTEM_IMAGE_TIMEOUT)
 
-def GetSDKPlatform(api_level=DEFAULT_ANDROID_API_LEVEL):
+def GetSDKPlatform(api_level=DEFAULT_ANDROID_API_LEVEL, google=False):
   """Update the SDK to include the platform specified.
 
   Args:
     api_level: the Android API level to download
+    google: use Google APIs instead of AOSP build
   """
   logging.info('Download SDK Platform directory into sdk directory.')
 
   platform_package_pattern = re.compile(
       r'\s*([0-9]+)- SDK Platform Android [\.,0-9]+, API %d.*' % api_level)
 
   UpdateSDK(api_level, 'SDK Platform', platform_package_pattern,
             DOWNLOAD_SDK_PLATFORM_TIMEOUT)
 
+  if google:
+    google_api_package_pattern = re.compile(
+      r'\s*([0-9]+)- Google APIs, Android API %d.*' % api_level)
+    UpdateSDK(api_level, 'Google APIs', google_api_package_pattern,
+              DOWNLOAD_SDK_PLATFORM_TIMEOUT)
+
 
 def main(argv):
   opt_parser = optparse.OptionParser(
       description='Install dependencies for running the Android emulator')
+  opt_parser.add_option('--abi',
+                        dest='abi',
+                        help='The targeted arch for emulator system image',

[mikecase (-- gone --), 2016/01/07 22:27:31]

s/targeted arch/target abi/ ¯_(ツ)_/¯
Edit

[Yoland Yan(Google), 2016/01/08 00:00:40]

Done.

+                        type='string',
+                        default=DEFAULT_ABI)
   opt_parser.add_option('--api-level',
                         dest='api_level',
                         help=('The API level (e.g., 19 for Android 4.4) to '
                               'ensure is available'),
                         type='int',
                         default=DEFAULT_ANDROID_API_LEVEL)
   opt_parser.add_option('-v',
                         dest='verbosity',
                         default=1,
                         action='count',
                         help='Verbose level (multiple times for more)')
+  opt_parser.add_option('--google',
+                        dest='google',
+                        action='store_true',
+                        default='false',
+                        help='Install Google System Image instead of AOSP')
+
   options, _ = opt_parser.parse_args(argv[1:])
 
   run_tests_helper.SetLogLevel(verbose_count=options.verbosity)
 
+  # TODO(yolandyan), make options.google and options.arm multually exclusive

[mikecase (-- gone --), 2016/01/07 22:27:30]

delete

[Yoland Yan(Google), 2016/01/08 00:00:39]

Done.

+
   # Calls below will download emulator SDK and/or system images only if needed.
   if CheckSDK():
     logging.info('android_emulator_sdk/ exists')
   else:
     logging.critical('ERROR: Emulator SDK not installed in %s'
                      , constants.ANDROID_SDK_ROOT)
     return 1
 
   # Check target. The target has to be installed in order to run the emulator.
-  if CheckSDKPlatform(options.api_level):
+  if CheckSDKPlatform(options.api_level, options.google):
     logging.info('SDK platform android-%d already present, skipping.',
                  options.api_level)
   else:
     logging.info('SDK platform android-%d not present, installing.',
                  options.api_level)
-    GetSDKPlatform(options.api_level)
+    GetSDKPlatform(options.api_level, options.google)
 
-  # Download the x86 system image only if needed.
-  if CheckX86Image(options.api_level):
-    logging.info('x86 image for android-%d already present, skipping.',
+  # Download the system image needed
+  if CheckSystemImage(options.abi, options.api_level, options.google):
+    logging.info('system image for android-%d already present, skipping.',

[mikecase (-- gone --), 2016/01/07 22:27:30]

Might want to add the info about the abi and google to this log.

[Yoland Yan(Google), 2016/01/08 00:00:40]

Done.

                  options.api_level)
   else:
-    GetX86Image(options.api_level)
+    GetSystemImage(options.abi, options.api_level, options.google)
 
   # Make sure KVM packages are installed and enabled.
-  if CheckKVM():
-    logging.info('KVM already installed and enabled.')
-  else:
-    logging.warning('KVM is not installed or enabled.')
+  if options.abi == 'x86':
+    if CheckKVM():
+      logging.info('KVM already installed and enabled.')
+    else:
+      logging.warning('KVM is not installed or enabled.')
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))