Make install_emulator_deps.py more flexible

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 shutil
 import sys
 
 from pylib import cmd_helper
 from pylib import constants
+from pylib import pexpect
 from pylib.utils import run_tests_helper
 
+# Android API level
+DEFAULT_ANDROID_API_LEVEL = constants.ANDROID_SDK_VERSION
+
 # From the Android Developer's website.
+# Keep this up to date; the user can install older API levels as necessary.
 SDK_BASE_URL = 'http://dl.google.com/android/adt'
-SDK_ZIP = 'adt-bundle-linux-x86_64-20130729.zip'
+SDK_ZIP = 'adt-bundle-linux-x86_64-20131030.zip'
 
 # Android x86 system image from the Intel website:
 # http://software.intel.com/en-us/articles/intel-eula-x86-android-4-2-jelly-bean-bin
-X86_IMG_URL = 'http://download-software.intel.com/sites/landingpage/android/sysimg_x86-18_r01.zip'
-
-# Android API level
-API_TARGET = 'android-%s' % constants.ANDROID_SDK_VERSION
-
+# These don't exist prior to Android-15.
+# As of 08 Nov 2013, Android-19 is not yet available either.
+X86_IMG_URLS = {
+  15: 'http://download-software.intel.com/sites/landingpage/android/sysimg_x86-15_r01.zip',
+  16: 'http://download-software.intel.com/sites/landingpage/android/sysimg_x86-16_r01.zip',
+  17: 'http://download-software.intel.com/sites/landingpage/android/sysimg_x86-17_r01.zip',
+  18: 'http://download-software.intel.com/sites/landingpage/android/sysimg_x86-18_r01.zip'}
 
 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.EMULATOR_SDK_ROOT)
 
 
-def CheckX86Image():
+def CheckSDKPlatform(api_level=DEFAULT_ANDROID_API_LEVEL):
+  """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:
+    api_level: the Android API level to check; defaults to the latest API.
+
+  Returns:
+    True if the platform is already installed.
+  """
+  android_binary = os.path.join(constants.EMULATOR_SDK_ROOT,
+                                'sdk', 'tools', 'android')
+  pattern = re.compile('id: [0-9]+ or "android-%d"' % api_level)
+  try:
+    exit_code, stdout = cmd_helper.GetCmdStatusAndOutput([android_binary, 'list'])

[navabi, 2013/11/11 22:08:19]

line length should be < 80 characters.
(except for the top where we have the long URLs).

[Andrew Hayden (chromium.org), 2013/11/12 14:42:16]

I feel that the code lines that are > 80 characters are made less readable by
separating onto multiple lines. Philosophically, the 80 line thing is an
anachronism that needs to die. If you have a strong objection, please let me
know; otherwise I am inclined to leave the lines of code as they are (I
shortened several of them based on Maria's feedback already; I'm not being
dismissive here, there has already been one pass on 80-char lines).

I will fix the comment lines since they are just english language flow.

+    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):
   """Check if Android system images have been installed.
 
+  Args:
+    api_level: the Android API level to check for; defaults to the latest API.
+
   Returns:
-    True if sdk/system-images/<API TARGET>/x86 exists inside EMULATOR_SDK_ROOT.
+    True if sdk/system-images/android-<api_level>/x86 exists inside EMULATOR_SDK_ROOT.

[navabi, 2013/11/11 22:08:19]

line length here and other places.

[Andrew Hayden (chromium.org), 2013/11/12 14:42:16]

See above, repaired in comments and leaving the rest alone as it would do things
like convert this:

    exit_code, stdout = cmd_helper.GetCmdStatusAndOutput([android_binary,
'list'])
... to this:
    exit_code, stdout = cmd_helper.GetCmdStatusAndOutput([android_binary,
                                                          'list'])

   """
+  api_target = 'android-%d' % api_level
   return os.path.exists(os.path.join(constants.EMULATOR_SDK_ROOT,
                                      'sdk', 'system-images',
-                                     API_TARGET, 'x86'))
+                                     api_target, 'x86'))
 
 
 def CheckKVM():
   """Check if KVM is enabled.
 
   Returns:
     True if kvm-ok returns 0 (already enabled)
   """
   try:
     return not cmd_helper.RunCmd(['kvm-ok'])
@@ skipping 34 matching lines @@
     logging.critical('ERROR: Did not add KVM module to Linux Kernal. Make sure '
                      'hardware virtualization is enabled in BIOS.')
   # Now check to ensure KVM acceleration can be used.
   rc = cmd_helper.RunCmd(['kvm-ok'])
   if rc:
     logging.critical('ERROR: Can not use KVM acceleration. Make sure hardware '
                      'virtualization is enabled in BIOS (i.e. Intel VT-x or '
                      'AMD SVM).')
 
 
-def GetX86Image():
-  """Download x86 system image from Intel's website."""
+def GetX86Image(api_level=DEFAULT_ANDROID_API_LEVEL):
+  """Download x86 system image from Intel's website.
+
+  Args:
+    api_level: the Android API level to download for; defaults to the latest API.
+  """
   logging.info('Download x86 system image directory into sdk directory.')
+  # TODO(andrewhayden): Use python tempfile lib instead

[navabi, 2013/11/11 22:08:19]

I'm not sure you can use python's tempfile lib. I wanted to originally, but I
don't know how to curl into a python tempfile.

Also, I had problems using the python zip library and that is why I used unzip
below. The problem was the python zip library did not preserve permissions when
extracting. Neither here nor there, but thought I would mention it.

[Andrew Hayden (chromium.org), 2013/11/12 14:42:16]

Thanks for the context!

I think the only thing that the tempfile lib gets you is the ability to make a
temp file that has a safe name. Presumably we could just overwrite it with "curl
-o" the same way you do now. Running unzip seems fine to me.

+  temp_file = '/tmp/x86_img_android-%d.zip' % api_level
+  if api_level not in X86_IMG_URLS:
+    raise Exception('ERROR: no URL known for x86 image for android-%s' % api_level)
   try:
-    cmd_helper.RunCmd(['curl', '-o', '/tmp/x86_img.zip', X86_IMG_URL])
-    rc = cmd_helper.RunCmd(['unzip', '-o', '/tmp/x86_img.zip', '-d', '/tmp/'])
+    cmd_helper.RunCmd(['curl', '-o', temp_file, X86_IMG_URLS[api_level]])
+    rc = cmd_helper.RunCmd(['unzip', '-o', temp_file, '-d', '/tmp/'])
     if rc:
       raise Exception('ERROR: Could not download/unzip image zip.')
+    api_target = 'android-%d' % api_level
     sys_imgs = os.path.join(constants.EMULATOR_SDK_ROOT, 'sdk',
-                            'system-images', API_TARGET, 'x86')
+                            'system-images', api_target, 'x86')
+    logging.info('Deploying system image to %s' % sys_imgs)
     shutil.move('/tmp/x86', sys_imgs)
   finally:
-    os.unlink('/tmp/x86_img.zip')
+    os.unlink(temp_file)
+
+
+def GetSDKPlatform(api_level=DEFAULT_ANDROID_API_LEVEL):
+  """Update the SDK to include the platform specified.
+
+  Args:
+    api_level: the Android API level to download
+  """
+  android_binary = os.path.join(constants.EMULATOR_SDK_ROOT, 'sdk', 'tools', 'android')
+  pattern = re.compile('\s*([0-9]+)- SDK Platform Android [\.,0-9]+, API %d.*'  % api_level)
+  # Example:
+  #   2- SDK Platform Android 4.3, API 18, revision 2
+  exit_code, stdout = cmd_helper.GetCmdStatusAndOutput([android_binary, 'list', 'sdk'])
+  if exit_code != 0:
+    raise Exception('\'android list sdk\' command return %d' % exit_code)
+  for line in stdout.split('\n'):
+    match = pattern.match(line)
+    if match:
+      index = match.group(1)
+      print('package %s corresponds to platform level %d' % (index, api_level))
+      # update sdk --no-ui --filter $INDEX
+      update_command = [android_binary,
+                        'update', 'sdk', '--no-ui', '--filter', index]
+      update_command_str = ' '.join(update_command)
+      logging.info('running update command: %s' % update_command_str)
+      update_process = pexpect.spawn(update_command_str)
+      # TODO(andrewhayden): Do we need to bug the user about this?
+      if update_process.expect('Do you accept the license') != 0:
+        raise Exception('License agreement check failed')
+      update_process.sendline('y')
+      if update_process.expect('Done. 1 package installed.') == 0:
+        print('Successfully installed platform for API level %d' % 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 main(argv):
+  opt_parser = optparse.OptionParser(description='Install dependencies for running the Android emulator')
+  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='verbose', action='store_true',
+                        help='enable verbose logging')
+  options, _ = opt_parser.parse_args(argv[1:])
+
+  # run_tests_helper will set logging to INFO or DEBUG
+  # We achieve verbose output by configuring it with 2 (==DEBUG)
+  verbosity = 1
+  if (options.verbose):
+    verbosity = 2
   logging.basicConfig(level=logging.INFO,
                       format='# %(asctime)-15s: %(message)s')
-  run_tests_helper.SetLogLevel(verbose_count=1)
+  run_tests_helper.SetLogLevel(verbose_count=verbosity)
 
   # Calls below will download emulator SDK and/or system images only if needed.
   if CheckSDK():
     logging.info('android_emulator_sdk/ already exists, skipping download.')
   else:
     GetSDK()
 
+  # Check target. The target has to be installed in order for the emulator to start.
+  if CheckSDKPlatform(options.api_level):
+    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)
+
   # Download the x86 system image only if needed.
-  if CheckX86Image():
-    logging.info('The x86 image is already present, skipping download.')
+  if CheckX86Image(options.api_level):
+    logging.info('x86 image for android-%d already present, skipping.' % options.api_level)
   else:
-    GetX86Image()
+    GetX86Image(options.api_level)
 
   # Make sure KVM packages are installed and enabled.
   if CheckKVM():
     logging.info('KVM already installed and enabled.')
   else:
     InstallKVM()
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))