[Android] Switch KillAll, StartActivity, and BroadcastIntent to DeviceUtils.

build/android/pylib/device/device_utils.py

 # Copyright 2014 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 a variety of device interactions based on adb.
 
 Eventually, this will be based on adb_wrapper.
 """
 # pylint: disable=W0613
 
+import signal
 import time
 
 import pylib.android_commands
 from pylib.device import adb_wrapper
 from pylib.device import decorators
 from pylib.device import device_errors
 from pylib.utils import apk_helper
 from pylib.utils import parallelizer
 
 _DEFAULT_TIMEOUT = 30
@@ skipping 216 matching lines @@
         out = self.old_interface.Install(apk_path, reinstall=reinstall)
         for line in out.splitlines():
           if 'Failure' in line:
             raise device_errors.CommandFailedError(
                 ['adb', 'install', apk_path], line.strip())
       except AssertionError as e:
         raise device_errors.CommandFailedError(
             ['adb', 'install', apk_path], str(e))
 
   @decorators.WithTimeoutAndRetriesFromInstance()
-  def RunShellCommand(self, cmd, check_return=False, root=False, timeout=None,
-                      retries=None):
+  def RunShellCommand(self, cmd, check_return=False, as_root=False,
+                      timeout=None, retries=None):
     """Run an ADB shell command.
 
     TODO(jbudorick) Switch the default value of check_return to True after
     AndroidCommands is gone.
 
     Args:
       cmd: A list containing the command to run on the device and any arguments.
       check_return: A boolean indicating whether or not the return code should
                     be checked.
+      as_root: A boolean indicating whether the shell command should be run
+               with root privileges.
       timeout: Same as for |IsOnline|.
       retries: Same as for |IsOnline|.
     Raises:
       CommandFailedError if check_return is True and the return code is nozero.
     Returns:
       The output of the command.
     """
-    return self._RunShellCommandImpl(cmd, check_return=check_return, root=root,
-                                     timeout=timeout)
+    return self._RunShellCommandImpl(cmd, check_return=check_return,
+                                     as_root=as_root, timeout=timeout)
 
-  def _RunShellCommandImpl(self, cmd, check_return=False, root=False,
+  def _RunShellCommandImpl(self, cmd, check_return=False, as_root=False,
                            timeout=None):
     """Implementation of RunShellCommand.
 
     This is split from RunShellCommand to allow other DeviceUtils methods to
     call RunShellCommand without spawning a new timeout thread.
 
     TODO(jbudorick) Remove the timeout parameter once this is no longer
     implemented via AndroidCommands.
 
     Args:
       cmd: Same as for |RunShellCommand|.
       check_return: Same as for |RunShellCommand|.
+      as_root: Same as for |RunShellCommand|.
       timeout: Same as for |IsOnline|.
     Raises:
       Same as for |RunShellCommand|.
     Returns:
       Same as for |RunShellCommand|.
     """
     if isinstance(cmd, list):
       cmd = ' '.join(cmd)
-    if root and not self.HasRoot():
+    if as_root and not self.HasRoot():
       cmd = 'su -c %s' % cmd
     if check_return:
       code, output = self.old_interface.GetShellCommandStatusAndOutput(
           cmd, timeout_time=timeout)
       if int(code) != 0:
         raise device_errors.CommandFailedError(
             cmd, 'Nonzero exit code (%d)' % code)
     else:
       output = self.old_interface.RunShellCommand(cmd, timeout_time=timeout)
     return output
 
+  @decorators.WithTimeoutAndRetriesFromInstance()
+  def KillAll(self, process_name, signum=signal.SIGKILL, as_root=False,
+              blocking=False, timeout=None, retries=None):
+    """Kill all processes with the given name on the device.
+

[frankf, 2014/06/20 00:56:56]

Update the docstring to include the exception

[jbudorick, 2014/06/23 16:44:02]

Done.

+    Args:
+      process_name: A string containing the name of the process to kill.
+      signum: An integer containing the signal number to send to kill. Defaults
+              to 9 (SIGKILL).
+      as_root: A boolean indicating whether the kill should be executed with
+               root priveleges.
+      blocking: A boolean indicating whether we should wait until all processes
+                with the given |process_name| are dead.
+      timeout: Same as for |IsOnline|.
+      retries: Same as for |IsOnline|.
+    """
+    pids = self.old_interface.ExtractPid(process_name)
+    if len(pids) == 0:
+      raise device_errors.CommandFailedError(
+          ['adb', 'shell', 'kill'], 'No process "%s"' % process_name)

[frankf, 2014/06/20 00:56:55]

Why does this include such a command list? You haven't run adb shell kill at
this point. Can you use another exception type that doesn't require it?

[jbudorick, 2014/06/23 16:44:02]

Created a new AdbCommandFailedError that derives from CommandFailedError.
AdbCommandFailedError requires the command list and is now largely raised in
adb_wrapper.py, while CommandFailedError does not require the command list and
is largely raised in device_utils.py.

+
+    if blocking:
+      total_killed = self.old_interface.KillAllBlocking(
+          process_name, signum=signum, with_su=as_root, timeout_sec=timeout)
+    else:
+      total_killed = self.old_interface.KillAll(
+          process_name, signum=signum, with_su=as_root)
+    if total_killed == 0:
+      raise device_errors.CommandFailedError(
+          ['adb', 'shell', 'kill'], 'Failed to kill "%s"' % process_name)
+
+  @decorators.WithTimeoutAndRetriesFromInstance()
+  def StartActivity(self, intent, blocking=False, trace_file_name=None,
+                    force_stop=False, timeout=None, retries=None):
+    """Start package's activity on the device.
+
+    Args:
+      intent: An Intent to send.
+      blocking: A boolean indicating whether we should wait for the activity to
+                finish launching.
+      trace_file_name: If present, a string that both indicates that we want to
+                       profile the activity and contains the path to which the
+                       trace should be saved.
+      force_stop: A boolean indicating whether we should stop the activity
+                  before starting it.
+      timeout: Same as for |IsOnline|.
+      retries: Same as for |IsOnline|.
+    """
+    output = self.old_interface.StartActivity(
+        intent.package, intent.activity, wait_for_completion=blocking,
+        action=intent.action, category=intent.category, data=intent.data,
+        extras=intent.extras, trace_file_name=trace_file_name,
+        force_stop=force_stop, flags=intent.flags)
+    for l in output:
+      if l.startswith('Error:'):
+        raise device_errors.CommandFailedError(
+            ['adb', 'shell', 'am', 'start'], l)

[frankf, 2014/06/20 00:56:55]

same here

[jbudorick, 2014/06/23 16:44:02]

using the reworked CommandFailedError, as described above.

+
+  @decorators.WithTimeoutAndRetriesFromInstance()
+  def BroadcastIntent(self, intent, timeout=None, retries=None):
+    """Send a broadcast intent.
+
+    Args:
+      intent: An Intent to broadcast.
+      timeout: Same as for |IsOnline|.
+      retries: Same as for |IsOnline|.
+    """
+    package, old_intent = intent.action.rsplit('.', 1)
+    if intent.extras is None:
+      args = []
+    else:
+      args = ['-e %s%s' % (k, ' "%s"' % v if v else '')
+              for k, v in intent.extras.items() if len(k) > 0]
+    self.old_interface.BroadcastIntent(package, old_intent, *args)
+
   def __str__(self):
     """Returns the device serial."""
     return self.old_interface.GetDevice()
 
   @staticmethod
   def parallel(devices=None, async=False):
     """Creates a Parallelizer to operate over the provided list of devices.
 
     If |devices| is either |None| or an empty list, the Parallelizer will
     operate over all attached devices.
 
     Args:
       devices: A list of either DeviceUtils instances or objects from
                from which DeviceUtils instances can be constructed. If None,
                all attached devices will be used.
       async: If true, returns a Parallelizer that runs operations
              asynchronously.
     Returns:
       A Parallelizer operating over |devices|.
     """
     if not devices or len(devices) == 0:
       devices = pylib.android_commands.GetAttachedDevices()
     parallelizer_type = (parallelizer.Parallelizer if async
                          else parallelizer.SyncParallelizer)
     return parallelizer_type([
         d if isinstance(d, DeviceUtils) else DeviceUtils(d)
         for d in devices])