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
 
-# 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
 
 class EmulatorLaunchException(Exception):
   """Emulator failed to launch."""
   pass
 
 def _KillAllEmulators():
   """Kill all running emulators that look like ones we started.
 
@@ skipping 53 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.

[navabi, 2013/03/14 02:39:47]

need to add abi to arg list.

[pasko-google - do not use, 2013/03/14 15:46:28]

I assume you are going to do it? Or there a dedicated Armand clone to do code
reviews that does not necessarily come to an agreement? Funny.

[navabi, 2013/03/20 21:40:16]

Haha. Yeah, I'm still in the process of arguing with the Armand clone regarding
this comment. I really don't think I need to add abi to the arg list. That
dude's a jerk.

+    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='armeabi-v7a'):
     """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

[navabi, 2013/03/14 02:39:47]

should make default abi x86, since that is the more reliable, faster emulator.

[navabi, 2013/03/20 21:40:16]

Done.

     """
     try:
       android_sdk_root = os.environ['ANDROID_SDK_ROOT']

[navabi, 2013/03/20 21:40:16]

While the emulator requires this to be set, I have removed this dependence on
env var ANDROID_SDK_ROOT, and pass the directory to the constructor.

     except KeyError:
       logging.critical('The ANDROID_SDK_ROOT must be set to run the test on '
                        'emulator.')
       raise
     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 = abi
+    if 'ia32' in os.environ.get('target_arch', ''):

[pasko-google - do not use, 2013/03/14 15:46:28]

For future CLs: I may want to override this setting, it is quite non-obvious
that build target setup in the environment overrides which emulator to use.

The ultimate goal is to be able to run without sourcing envsetup.sh. If it is
not elegant I would be curious to know why.

[navabi, 2013/03/20 21:40:16]

Done. We actually don't need this here. The avd.py script specifies the abi.
There is no need to override the avd.py option.

It should be fine to be in an environment for x86 and launch an ARM emulator.

       self.abi = 'x86'
-      self.avd = 'avd_x86'
-    if new_avd_name:
-      self.default_avd = False
-      self.avd = self._CreateAVD(new_avd_name)
+    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.
     """
+    print 'self.android: ' + self.android
     avd_command = [
         self.android,
         '--silent',
         'create', 'avd',
-        '--name', avd_name,
+        '--name', self.avd_name,
         '--abi', self.abi,
-        '--target', 'android-16',
+        '--target', 'android-17',
         '-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', '512',

[pasko-google - do not use, 2013/03/14 15:46:28]

1024

[navabi, 2013/03/20 21:40:16]

Done.

+        ]
+    print 'self.abi = %s' % self.abi
+    if self.abi == 'x86':
+      emulator_command.extend([
+          # For x86 emulator --enable-kvm will makes explicit as to whether or
+          # not Intel's virtualization support is being used.

[pasko-google - do not use, 2013/03/14 15:46:28]

It is not quite clear what the word "explicit" means, a better comment would be:
"With --enable-kvm the x86 emulator will fail early. With that we prevent
accidental runs in a slow mode."

[navabi, 2013/03/20 21:40:16]

Done.

+          '--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 59 matching lines @@
     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)