def GetRemoteDevices(banner, endpoints, default_timeout_ms, auth_timeout_ms,
on_error=None, as_root=False):
"""Returns the list of devices available.
Caller MUST call CloseDevices(devices) on the return value or call .Close() on
each element to close the TCP handles.
Arguments:
- banner: authentication banner associated with the RSA keys. It's better to
use a constant.
- endpoints: list of ip[:port] endpoints of devices to connect to via TCP.
- default_timeout_ms: default I/O operation timeout.
- auth_timeout_ms: timeout for the user to accept the public key.
- on_error: callback when an internal failure occurs.
- as_root: if True, restarts adbd as root if possible.
Returns one of:
- list of HighDevice instances.
- None if adb is unavailable.
"""
with _ADB_KEYS_LOCK:
if not _ADB_KEYS:
return []
# Create unopened handles for all remote devices.
handles = [common.TcpHandle(endpoint) for endpoint in endpoints]
return _ConnectFromHandles(handles, banner=banner,
default_timeout_ms=default_timeout_ms,
auth_timeout_ms=auth_timeout_ms, on_error=on_error,
as_root=as_root)
def _Find(self, use_serial):
"""Initializes self._handle from self.port_path.
The handle is left unopened.
"""
assert not self._handle
assert not self._adb_cmd
# TODO(maruel): Add support for TCP/IP communication.
try:
if self.port_path:
previous_port_path = self._port_path
if use_serial:
assert self._serial
self._handle = common.UsbHandle.Find(
adb_commands.DeviceIsAvailable,
serial=self._serial,
timeout_ms=self._default_timeout_ms)
# Update the new found port path.
self._port_path = self._handle.port_path_str
else:
self._handle = common.UsbHandle.Find(
adb_commands.DeviceIsAvailable,
port_path=self.port_path,
timeout_ms=self._default_timeout_ms)
_LOG.info('%s._Find(%s) %s = %s', previous_port_path,
use_serial, self._serial,
self.port_path if self._handle else 'None')
else:
self._handle = common.TcpHandle(self._serial)
except (common.usb1.USBError, usb_exceptions.DeviceNotFoundError) as e:
_LOG.debug('%s._Find(%s) %s : %s', self.port_path, use_serial,
self._serial, e)
return bool(self._handle)
def ConnectDevice(self,
port_path=None,
serial=None,
default_timeout_ms=None,
**kwargs):
"""Convenience function to setup a transport handle for the adb device from
usb path or serial then connect to it.
Args:
port_path: The filename of usb port to use.
serial: The serial number of the device to use.
default_timeout_ms: The default timeout in milliseconds to use.
kwargs: handle: Device handle to use (instance of common.TcpHandle or common.UsbHandle)
banner: Connection banner to pass to the remote device
rsa_keys: List of AuthSigner subclass instances to be used for
authentication. The device can either accept one of these via the Sign
method, or we will send the result of GetPublicKey from the first one
if the device doesn't accept any of them.
auth_timeout_ms: Timeout to wait for when sending a new public key. This
is only relevant when we send a new public key. The device shows a
dialog and this timeout is how long to wait for that dialog. If used
in automation, this should be low to catch such a case as a failure
quickly; while in interactive settings it should be high to allow
users to accept the dialog. We default to automation here, so it's low
by default.
If serial specifies a TCP address:port, then a TCP connection is
used instead of a USB connection.
"""
# If there isnt a handle override (used by tests), build one here
if 'handle' in kwargs:
self._handle = kwargs.pop('handle')
else:
# if necessary, convert serial to a unicode string
if isinstance(serial, (bytes, bytearray)):
serial = serial.decode('utf-8')
if serial and ':' in serial:
self._handle = common.TcpHandle(serial,
timeout_ms=default_timeout_ms)
else:
self._handle = common.UsbHandle.FindAndOpen(
DeviceIsAvailable,
port_path=port_path,
serial=serial,
timeout_ms=default_timeout_ms)
self._Connect(**kwargs)
return self
def FindDevice(on_error, serial, timeout_ms=1000): # pragma: no cover
"""Finds a device with serial if relevant, otherwise take the device connect
if there is exactly one.
"""
# Find the usb path for this device, so the next operations are done with
# the usb path.
if ':' in serial:
handle = common.TcpHandle(serial, timeout_ms=timeout_ms)
else:
handle = common.UsbHandle.Find(adb_commands_safe.DeviceIsAvailable,
serial=serial,
timeout_ms=timeout_ms)
if handle:
path = '/'.join(map(str, handle.port_path))
logging.info('Automatically selected %s : %s', path, serial)
return path
on_error('Didn\'t find device with serial %s' % serial)
def ConnectDevice(
cls, port_path=None, serial=None, default_timeout_ms=None, **kwargs):
"""Convenience function to get an adb device from usb path or serial.
Args:
port_path: The filename of usb port to use.
serial: The serial number of the device to use.
default_timeout_ms: The default timeout in milliseconds to use.
If serial specifies a TCP address:port, then a TCP connection is
used instead of a USB connection.
"""
if serial and ':' in serial:
handle = common.TcpHandle(serial)
else:
handle = common.UsbHandle.FindAndOpen(
DeviceIsAvailable, port_path=port_path, serial=serial,
timeout_ms=default_timeout_ms)
return cls.Connect(handle, **kwargs)
