Add support to run emulator without ui on bots

build/android/pylib/utils/emulator.py

 # 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.
 
   Emulator: The class provides the methods to launch/shutdown the emulator with
             the android virtual device named 'avd_armeabi' .
 """
 
@@ skipping 140 matching lines @@
                if a.is_emulator]
   for emulator in emulators:
     used_ports.append(emulator.adb.GetDeviceSerial().split('-')[1])
   for port in PortPool.port_range():
     if str(port) not in used_ports:
       return port
 
 
 def LaunchTempEmulators(emulator_count, abi, api_level, enable_kvm=False,
                         kill_and_launch=True, sdcard_size=DEFAULT_SDCARD_SIZE,
-                        storage_size=DEFAULT_STORAGE_SIZE, wait_for_boot=True):
+                        storage_size=DEFAULT_STORAGE_SIZE, wait_for_boot=True,
+                        headless=False):
   """Create and launch temporary emulators and wait for them to boot.
 
   Args:
     emulator_count: number of emulators to launch.
     abi: the emulator target platform
     api_level: the api level (e.g., 19 for Android v4.4 - KitKat release)
     wait_for_boot: whether or not to wait for emulators to boot up
+    headless: running emulator with no ui
 
   Returns:
     List of emulators.
   """
   emulators = []
   for n in xrange(emulator_count):
     t = time_profile.TimeProfile('Emulator launch %d' % n)
     # Creates a temporary AVD.
     avd_name = 'run_tests_avd_%d' % n
     logging.info('Emulator launch %d with avd_name=%s and api=%d',
         n, avd_name, api_level)
     emulator = Emulator(avd_name, abi, enable_kvm=enable_kvm,
-                        sdcard_size=sdcard_size, storage_size=storage_size)
+                        sdcard_size=sdcard_size, storage_size=storage_size,
+                        headless=headless)
     emulator.CreateAVD(api_level)
     emulator.Launch(kill_all_emulators=(n == 0 and kill_and_launch))
     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
 
 
 def LaunchEmulator(avd_name, abi, kill_and_launch=True, enable_kvm=False,
                    sdcard_size=DEFAULT_SDCARD_SIZE,
-                   storage_size=DEFAULT_STORAGE_SIZE):
+                   storage_size=DEFAULT_STORAGE_SIZE, headless=False):
   """Launch an existing emulator with name avd_name.
 
   Args:
     avd_name: name of existing emulator
     abi: the emulator target platform
+    headless: running emulator with no ui
 
   Returns:
     emulator object.
   """
   logging.info('Specified emulator named avd_name=%s launched', avd_name)
   emulator = Emulator(avd_name, abi, enable_kvm=enable_kvm,
-                      sdcard_size=sdcard_size, storage_size=storage_size)
+                      sdcard_size=sdcard_size, storage_size=storage_size,
+                      headless=headless)
   emulator.Launch(kill_all_emulators=kill_and_launch)
   emulator.ConfirmLaunch(True)
   return emulator
 
 
 class Emulator(object):
   """Provides the methods to launch/shutdown the emulator.
 
   The emulator has the android virtual device named 'avd_armeabi'.
 
@@ skipping 17 matching lines @@
 
   # 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, avd_name, abi, enable_kvm=False,
                sdcard_size=DEFAULT_SDCARD_SIZE,
-               storage_size=DEFAULT_STORAGE_SIZE):
+               storage_size=DEFAULT_STORAGE_SIZE, headless=False):
     """Init an Emulator.
 
     Args:
       avd_name: name of the AVD to create
       abi: target platform for emulator being created, defaults to x86
     """
     android_sdk_root = constants.ANDROID_SDK_ROOT
     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_serial = None
     self.abi = abi
     self.avd_name = avd_name
     self.sdcard_size = sdcard_size
     self.storage_size = storage_size
     self.enable_kvm = enable_kvm
+    self.headless = headless
 
   @staticmethod
   def _DeviceName():
     """Return our device name."""
     port = _GetAvailablePort()
     return ('emulator-%d' % port, port)
 
   def CreateAVD(self, api_level):
     """Creates an AVD with the given name.
 
@@ skipping 96 matching lines @@
     """
     if kill_all_emulators:
       KillAllEmulators()  # just to be sure
     self._AggressiveImageCleanup()
     (self.device_serial, port) = self._DeviceName()
     self.ResizeAndWipeAvd(storage_size=self.storage_size)
     emulator_command = [
         self.emulator,
         # Speed up emulator launch by 40%.  Really.
         '-no-boot-anim',
+        ]
+    if self.headless:
+      emulator_command.extend([
+        '-no-skin',
+        '-no-audio',
+        '-no-window'
+        ])
+    emulator_command.extend([
         # Use a familiar name and port.
         '-avd', self.avd_name,
         '-port', str(port),
         # Enable GPU by default.
         '-gpu', 'on',
+        # all the argument after qemu are sub arguments for qemu
         '-qemu', '-m', '1024',
-        ]
+        ])
     if self.abi == 'x86' and self.enable_kvm:
       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)
@@ skipping 66 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)