Add script to download SDK, system images and create and start AVDs for testing.

build/android/pylib/utils/emulator.py

 #!/usr/bin/env python
 #
 # Copyright (c) 2012 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.
 
 """Provides an interface to start and stop Android emulator.
 
 Assumes system environment ANDROID_NDK_ROOT has been set.
 
   Emulator: The class provides the methods to launch/shutdown the emulator with
             the android virtual device named 'avd_armeabi' .
 """
 
 import logging
 import os
 import signal
 import subprocess
 import sys
 import time
 
 import time_profile
 # TODO(craigdh): Move these pylib dependencies to pylib/utils/.
 from pylib import android_commands
 from pylib import cmd_helper
+from pylib import constants
 
-# adb_interface.py is under ../../third_party/android_testrunner/
-sys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)), '..',
-   '..', 'third_party', 'android_testrunner'))
-import adb_interface
 import errors
 import run_command
 
+# Android API level
+API_TARGET = 'android-%s' % constants.ANDROID_SDK_VERSION
+
+
 class EmulatorLaunchException(Exception):
   """Emulator failed to launch."""
   pass
 
 def _KillAllEmulators():
   """Kill all running emulators that look like ones we started.
 
   There are odd 'sticky' cases where there can be no emulator process
   running but a device slot is taken.  A little bot trouble and and
   we're out of room forever.
@@ skipping 50 matching lines @@
   """Returns an available TCP port for the console."""
   used_ports = []
   emulators = android_commands.GetEmulators()
   for emulator in emulators:
     used_ports.append(emulator.split('-')[1])
   for port in PortPool.port_range():
     if str(port) not in used_ports:
       return port
 
 
-def LaunchEmulators(emulator_count, wait_for_boot=True):
+def LaunchEmulators(emulator_count, abi, wait_for_boot=True):
   """Launch multiple emulators and wait for them to boot.
 
   Args:
     emulator_count: number of emulators to launch.
+    abi: the emulator target platform
+    wait_for_boot: whether or not to wait for emulators to boot up
 
   Returns:
     List of emulators.
   """
   emulators = []
   for n in xrange(emulator_count):
     t = time_profile.TimeProfile('Emulator launch %d' % n)
-    avd_name = None
-    if n > 0:
-      # Creates a temporary AVD for the extra emulators.
-      avd_name = 'run_tests_avd_%d' % n
+    # Creates a temporary AVD.
+    avd_name = 'run_tests_avd_%d' % n
     logging.info('Emulator launch %d with avd_name=%s', n, avd_name)
-    emulator = Emulator(avd_name)
+    emulator = Emulator(avd_name, abi)
     emulator.Launch(kill_all_emulators=n == 0)
     t.Stop()
     emulators.append(emulator)
   # Wait for all emulators to boot completed.
   if wait_for_boot:
     for emulator in emulators:
       emulator.ConfirmLaunch(True)
   return emulators
 
 
@@ skipping 20 matching lines @@
   # the time to launch the emulator and a wait-for-device command.
   _LAUNCH_TIMEOUT = 120
 
   # Timeout interval of wait-for-device command before bouncing to a a
   # process life check.
   _WAITFORDEVICE_TIMEOUT = 5
 
   # Time to wait for a "wait for boot complete" (property set on device).
   _WAITFORBOOT_TIMEOUT = 300
 
-  def __init__(self, new_avd_name):
+  def __init__(self, avd_name, abi='x86'):
     """Init an Emulator.
 
     Args:
-      nwe_avd_name: If set, will create a new temporary AVD.
+      avd_name: name of the AVD to create
+      abi: target platform for emulator being created
     """
-    try:
-      android_sdk_root = os.environ['ANDROID_SDK_ROOT']
-    except KeyError:
-      logging.critical('The ANDROID_SDK_ROOT must be set to run the test on '
-                       'emulator.')
-      raise
+    android_sdk_root = os.path.join(constants.EMULATOR_SDK_ROOT,
+                                    'android_tools', 'sdk')
     self.emulator = os.path.join(android_sdk_root, 'tools', 'emulator')
     self.android = os.path.join(android_sdk_root, 'tools', 'android')
     self.popen = None
     self.device = None
-    self.default_avd = True
-    self.abi = 'armeabi-v7a'
-    self.avd = 'avd_armeabi'
-    if 'x86' in os.environ.get('TARGET_PRODUCT', ''):
-      self.abi = 'x86'
-      self.avd = 'avd_x86'
-    if new_avd_name:
-      self.default_avd = False
-      self.avd = self._CreateAVD(new_avd_name)
+    self.abi = abi
+    self.avd_name = avd_name
+    self._CreateAVD()
 
   def _DeviceName(self):
     """Return our device name."""
     port = _GetAvailablePort()
     return ('emulator-%d' % port, port)
 
-  def _CreateAVD(self, avd_name):
+  def _CreateAVD(self):
     """Creates an AVD with the given name.
 
     Return avd_name.
     """
     avd_command = [
         self.android,
         '--silent',
         'create', 'avd',
-        '--name', avd_name,
+        '--name', self.avd_name,
         '--abi', self.abi,
-        '--target', 'android-16',
+        '--target', API_TARGET,
         '-c', '128M',
         '--force',
     ]
     avd_process = subprocess.Popen(args=avd_command,
                                    stdin=subprocess.PIPE,
                                    stdout=subprocess.PIPE,
                                    stderr=subprocess.STDOUT)
     avd_process.stdin.write('no\n')
     avd_process.wait()
     logging.info('Create AVD command: %s', ' '.join(avd_command))
-    return avd_name
+    return self.avd_name
 
   def _DeleteAVD(self):
     """Delete the AVD of this emulator."""
     avd_command = [
         self.android,
         '--silent',
         'delete',
         'avd',
         '--name', self.avd,
     ]
@@ skipping 13 matching lines @@
       _KillAllEmulators()  # just to be sure
     self._AggressiveImageCleanup()
     (self.device, port) = self._DeviceName()
     emulator_command = [
         self.emulator,
         # Speed up emulator launch by 40%.  Really.
         '-no-boot-anim',
         # The default /data size is 64M.
         # That's not enough for 8 unit test bundles and their data.
         '-partition-size', '512',
+        # Use a familiar name and port.
+        '-avd', self.avd_name,
+        '-port', str(port),
+        # Wipe the data.  We've seen cases where an emulator gets 'stuck' if we
+        # don't do this (every thousand runs or so).
+        '-wipe-data',
         # Enable GPU by default.
         '-gpu', 'on',
-        # Use a familiar name and port.
-        '-avd', self.avd,
-        '-port', str(port)]
-    emulator_command.extend([
-        # Wipe the data.  We've seen cases where an emulator
-        # gets 'stuck' if we don't do this (every thousand runs or
-        # so).
-        '-wipe-data',
-        ])
+        '-qemu', '-m', '1024',
+        ]
+    if self.abi == 'x86':
+      emulator_command.extend([
+          # For x86 emulator --enable-kvm will fail early, avoiding accidental
+          # runs in a slow mode (i.e. without hardware virtualization support).
+          '--enable-kvm',
+          ])
+
     logging.info('Emulator launch command: %s', ' '.join(emulator_command))
     self.popen = subprocess.Popen(args=emulator_command,
                                   stderr=subprocess.STDOUT)
     self._InstallKillHandler()
 
   def _AggressiveImageCleanup(self):
     """Aggressive cleanup of emulator images.
 
     Experimentally it looks like our current emulator use on the bot
     leaves image files around in /tmp/android-$USER.  If a "random"
@@ skipping 40 matching lines @@
       raise EmulatorLaunchException('TIMEOUT with wait-for-device')
     logging.info('Seconds waited on wait-for-device: %d', seconds_waited)
     if wait_for_boot:
       # Now that we checked for obvious problems, wait for a boot complete.
       # Waiting for the package manager is sometimes problematic.
       a = android_commands.AndroidCommands(self.device)
       a.WaitForSystemBootCompleted(self._WAITFORBOOT_TIMEOUT)
 
   def Shutdown(self):
     """Shuts down the process started by launch."""
-    if not self.default_avd:
-      self._DeleteAVD()
+    self._DeleteAVD()
     if self.popen:
       self.popen.poll()
       if self.popen.returncode == None:
         self.popen.kill()
       self.popen = None
 
   def _ShutdownOnSignal(self, signum, frame):
     logging.critical('emulator _ShutdownOnSignal')
     for sig in self._SIGNALS:
       signal.signal(sig, signal.SIG_DFL)
     self.Shutdown()
     raise KeyboardInterrupt  # print a stack
 
   def _InstallKillHandler(self):
     """Install a handler to kill the emulator when we exit unexpectedly."""
     for sig in self._SIGNALS:
       signal.signal(sig, self._ShutdownOnSignal)