Allow android python shell run script to not stop if multiple devices are connected.

mojo/tools/mopy/android.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.
 
 import atexit
 import itertools
 import json
 import logging
 import os
 import os.path
@@ skipping 87 matching lines @@
     process.kill()
 
 
 class AndroidShell(object):
   """ Allows to set up and run a given mojo shell binary on an Android device.
 
   Args:
     shell_apk_path: path to the shell Android binary
     local_dir: directory where locally build Mojo apps will be served, optional
     adb_path: path to adb, optional if adb is in PATH
+    target_device: device to run on, if multiple devices are connected
   """
-  def __init__(self, shell_apk_path, local_dir=None, adb_path="adb"):
+  def __init__(
+      self, shell_apk_path, local_dir=None, adb_path="adb", target_device=None):
     self.shell_apk_path = shell_apk_path
     self.adb_path = adb_path
     self.local_dir = local_dir
+    self.target_device = target_device
+
+  def _CreateADBCommand(self, args):
+    adb_command = [self.adb_path]
+    if self.target_device:
+      adb_command.extend(['-s', self.target_device])
+    adb_command.extend(args)
+    return adb_command
 
   def _ReadFifo(self, fifo_path, pipe, on_fifo_closed, max_attempts=5):
     """
     Reads |fifo_path| on the device and write the contents to |pipe|. Calls
     |on_fifo_closed| when the fifo is closed. This method will try to find the
     path up to |max_attempts|, waiting 1 second between each attempt. If it
     cannot find |fifo_path|, a exception will be raised.
     """
-    fifo_command = [self.adb_path, 'shell', 'test -e "%s"; echo $?' % fifo_path]
+    fifo_command = self._CreateADBCommand(
+        ['shell', 'test -e "%s"; echo $?' % fifo_path])
 
     def Run():
       def _WaitForFifo():
         for _ in xrange(max_attempts):
           if subprocess.check_output(fifo_command)[0] == '0':
             return
           time.sleep(1)
         if on_fifo_closed:
           on_fifo_closed()
         raise Exception("Unable to find fifo.")
       _WaitForFifo()
-      stdout_cat = subprocess.Popen([self.adb_path,
+      stdout_cat = subprocess.Popen(self._CreateADBCommand([
                                      'shell',
                                      'cat',
-                                     fifo_path],
+                                     fifo_path]),
                                     stdout=pipe)
       atexit.register(_ExitIfNeeded, stdout_cat)
       stdout_cat.wait()
       if on_fifo_closed:
         on_fifo_closed()
 
     thread = threading.Thread(target=Run, name="StdoutRedirector")
     thread.start()
 
   def _MapPort(self, device_port, host_port):
     """
     Maps the device port to the host port. If |device_port| is 0, a random
     available port is chosen. Returns the device port.
     """
     def _FindAvailablePortOnDevice():
-      opened = subprocess.check_output([self.adb_path, 'shell', 'netstat'])
+      opened = subprocess.check_output(
+          self._CreateADBCommand(['shell', 'netstat']))
       opened = [int(x.strip().split()[3].split(':')[1])
                 for x in opened if x.startswith(' tcp')]
       while True:
         port = random.randint(4096, 16384)
         if port not in opened:
           return port
     if device_port == 0:
       device_port = _FindAvailablePortOnDevice()
-    subprocess.Popen([self.adb_path,
+    subprocess.Popen(self._CreateADBCommand([
                       "reverse",
                       "tcp:%d" % device_port,
-                      "tcp:%d" % host_port]).wait()
+                      "tcp:%d" % host_port])).wait()
 
-    unmap_command = [self.adb_path, "reverse", "--remove",
-                     "tcp:%d" % device_port]
+    unmap_command = self._CreateADBCommand(["reverse", "--remove",
+                     "tcp:%d" % device_port])
 
     def _UnmapPort():
       subprocess.Popen(unmap_command)
     atexit.register(_UnmapPort)
     return device_port
 
   def _StartHttpServerForDirectory(self, path, port=0):
     """Starts an http server serving files from |path|. Returns the local
     url."""
     assert path
@@ skipping 40 matching lines @@
       result.append(self._StartHttpServerForOriginMapping(
           value, DEFAULT_BASE_PORT + 1 + i if fixed_port else 0))
     return [MAPPING_PREFIX + ','.join(result)]
 
   def PrepareShellRun(self, origin=None, fixed_port=True):
     """ Prepares for StartShell: runs adb as root and installs the apk.  If no
     --origin is specified, local http server will be set up to serve files from
     the build directory along with port forwarding.
 
     Returns arguments that should be appended to shell argument list."""
-    if 'cannot run as root' in subprocess.check_output([self.adb_path, 'root']):
+    if 'cannot run as root' in subprocess.check_output(
+        self._CreateADBCommand(['root'])):
       raise Exception("Unable to run adb as root.")
     subprocess.check_call(
-        [self.adb_path, 'install', '-r', self.shell_apk_path, '-i',
-         MOJO_SHELL_PACKAGE_NAME])
+        self._CreateADBCommand(['install', '-r', self.shell_apk_path, '-i',
+         MOJO_SHELL_PACKAGE_NAME]))
     atexit.register(self.StopShell)
 
     extra_shell_args = []
     origin_url = origin if origin else self._StartHttpServerForDirectory(
         self.local_dir, DEFAULT_BASE_PORT if fixed_port else 0)
     extra_shell_args.append("--origin=" + origin_url)
 
     return extra_shell_args
 
   def StartShell(self,
                  arguments,
                  stdout=None,
                  on_application_stop=None,
                  fixed_port=True):
     """
     Starts the mojo shell, passing it the given arguments.
 
     The |arguments| list must contain the "--origin=" arg from PrepareShellRun.
     If |stdout| is not None, it should be a valid argument for subprocess.Popen.
     """
     STDOUT_PIPE = "/data/data/%s/stdout.fifo" % MOJO_SHELL_PACKAGE_NAME
 
-    cmd = [self.adb_path,
+    cmd = self._CreateADBCommand([
            'shell',
            'am',
            'start',
            '-S',
            '-a', 'android.intent.action.VIEW',
-           '-n', '%s/.MojoShellActivity' % MOJO_SHELL_PACKAGE_NAME]
+           '-n', '%s/.MojoShellActivity' % MOJO_SHELL_PACKAGE_NAME])
 
     parameters = []
     if stdout or on_application_stop:
-      subprocess.check_call([self.adb_path, 'shell', 'rm', STDOUT_PIPE])
+      subprocess.check_call(self._CreateADBCommand(
+          ['shell', 'rm', STDOUT_PIPE]))
       parameters.append('--fifo-path=%s' % STDOUT_PIPE)
       self._ReadFifo(STDOUT_PIPE, stdout, on_application_stop)
     # The origin has to be specified whether it's local or external.
     assert any("--origin=" in arg for arg in arguments)
 
     # Extract map-origin arguments.
     map_parameters, other_parameters = _Split(arguments, _IsMapOrigin)
     parameters += other_parameters
     parameters += self._StartHttpServerForOriginMappings(map_parameters,
                                                          fixed_port)
 
     if parameters:
       encodedParameters = json.dumps(parameters)
       cmd += ['--es', 'encodedParameters', encodedParameters]
 
     with open(os.devnull, 'w') as devnull:
       subprocess.Popen(cmd, stdout=devnull).wait()
 
   def StopShell(self):
     """
     Stops the mojo shell.
     """
-    subprocess.check_call(
-        [self.adb_path, 'shell', 'am', 'force-stop', MOJO_SHELL_PACKAGE_NAME])
+    subprocess.check_call(self._CreateADBCommand(['shell',
+                                                  'am',
+                                                  'force-stop',
+                                                  MOJO_SHELL_PACKAGE_NAME]))
 
   def CleanLogs(self):
     """
     Cleans the logs on the device.
     """
-    subprocess.check_call([self.adb_path, 'logcat', '-c'])
+    subprocess.check_call(self._CreateADBCommand(['logcat', '-c']))
 
   def ShowLogs(self):
     """
     Displays the log for the mojo shell.
 
     Returns the process responsible for reading the logs.
     """
-    logcat = subprocess.Popen([self.adb_path,
+    logcat = subprocess.Popen(self._CreateADBCommand([
                                'logcat',
                                '-s',
-                               ' '.join(LOGCAT_TAGS)],
+                               ' '.join(LOGCAT_TAGS)]),
                               stdout=sys.stdout)
     atexit.register(_ExitIfNeeded, logcat)
     return logcat