[Android] Change object types from AndroidCommands to DeviceUtils in build/android/.

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.
 
 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 time
 
 # TODO(craigdh): Move these pylib dependencies to pylib/utils/.
 from pylib import android_commands
 from pylib import cmd_helper
 from pylib import constants
 from pylib import pexpect
+from pylib.device import device_utils
 from pylib.utils import time_profile
 
 import errors
 import run_command
 
 # SD card size
 SDCARD_SIZE = '512M'
 
 # Template used to generate config.ini files for the emulator
 CONFIG_TEMPLATE = """avd.ini.encoding=ISO-8859-1
@@ skipping 67 matching lines @@
       return
     time.sleep(1)
 
 
 def DeleteAllTempAVDs():
   """Delete all temporary AVDs which are created for tests.
 
   If the test exits abnormally and some temporary AVDs created when testing may
   be left in the system. Clean these AVDs.
   """
-  avds = android_commands.GetAVDs()
+  avds = device_utils.GetAVDs()
   if not avds:
     return
   for avd_name in avds:
     if 'run_tests_avd' in avd_name:
       cmd = ['android', '-s', 'delete', 'avd', '--name', avd_name]
       cmd_helper.RunCmd(cmd)
       logging.info('Delete AVD %s' % avd_name)
 
 
 class PortPool(object):
@@ skipping 109 matching lines @@
     """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 = os.path.join(constants.EMULATOR_SDK_ROOT, '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.device_serial = None
     self.abi = abi
     self.avd_name = avd_name
 
   @staticmethod
   def _DeviceName():
     """Return our device name."""
     port = _GetAvailablePort()
     return ('emulator-%d' % port, port)
 
   def CreateAVD(self, api_level):
@@ skipping 77 matching lines @@
 
   def Launch(self, kill_all_emulators):
     """Launches the emulator asynchronously. Call ConfirmLaunch() to ensure the
     emulator is ready for use.
 
     If fails, an exception will be raised.
     """
     if kill_all_emulators:
       _KillAllEmulators()  # just to be sure
     self._AggressiveImageCleanup()
-    (self.device, port) = self._DeviceName()
+    (self.device_serial, 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),
@@ skipping 38 matching lines @@
   def ConfirmLaunch(self, wait_for_boot=False):
     """Confirm the emulator launched properly.
 
     Loop on a wait-for-device with a very small timeout.  On each
     timeout, check the emulator process is still alive.
     After confirming a wait-for-device can be successful, make sure
     it returns the right answer.
     """
     seconds_waited = 0
     number_of_waits = 2  # Make sure we can wfd twice
-    adb_cmd = "adb -s %s %s" % (self.device, 'wait-for-device')
+    adb_cmd = "adb -s %s %s" % (self.device_serial, 'wait-for-device')
     while seconds_waited < self._LAUNCH_TIMEOUT:
       try:
         run_command.RunCommand(adb_cmd,
                                timeout_time=self._WAITFORDEVICE_TIMEOUT,
                                retry_count=1)
         number_of_waits -= 1
         if not number_of_waits:
           break
       except errors.WaitForResponseTimedOutError:
         seconds_waited += self._WAITFORDEVICE_TIMEOUT
-        adb_cmd = "adb -s %s %s" % (self.device, 'kill-server')
+        adb_cmd = "adb -s %s %s" % (self.device_serial, 'kill-server')
         run_command.RunCommand(adb_cmd)
       self.popen.poll()
       if self.popen.returncode != None:
         raise EmulatorLaunchException('EMULATOR DIED')
     if seconds_waited >= self._LAUNCH_TIMEOUT:
       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)
+      d = device_utils.DeviceUtils(self.device_serial)
+      d.old_interface.WaitForSystemBootCompleted(self._WAITFORBOOT_TIMEOUT)
 
   def Shutdown(self):
     """Shuts down the process started by launch."""
     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)