| OLD | NEW |
|---|
| (Empty) |
| 1 # Copyright 2013 The Chromium Authors. All rights reserved. | |
| 2 # Use of this source code is governed by a BSD-style license that can be | |
| 3 # found in the LICENSE file. | |
| 4 | |
| 5 """This module wraps Android's adb tool. | |
| 6 | |
| 7 This is a thin wrapper around the adb interface. Any additional complexity | |
| 8 should be delegated to a higher level (ex. DeviceUtils). | |
| 9 """ | |
| 10 | |
| 11 import collections | |
| 12 import errno | |
| 13 import logging | |
| 14 import os | |
| 15 import re | |
| 16 | |
| 17 from pylib import cmd_helper | |
| 18 from pylib import constants | |
| 19 from pylib.device import decorators | |
| 20 from pylib.device import device_errors | |
| 21 from pylib.utils import timeout_retry | |
| 22 | |
| 23 | |
| 24 _DEFAULT_TIMEOUT = 30 | |
| 25 _DEFAULT_RETRIES = 2 | |
| 26 | |
| 27 _EMULATOR_RE = re.compile(r'^emulator-[0-9]+$') | |
| 28 | |
| 29 _READY_STATE = 'device' | |
| 30 | |
| 31 | |
| 32 def _VerifyLocalFileExists(path): | |
| 33 """Verifies a local file exists. | |
| 34 | |
| 35 Args: | |
| 36 path: Path to the local file. | |
| 37 | |
| 38 Raises: | |
| 39 IOError: If the file doesn't exist. | |
| 40 """ | |
| 41 if not os.path.exists(path): | |
| 42 raise IOError(errno.ENOENT, os.strerror(errno.ENOENT), path) | |
| 43 | |
| 44 | |
| 45 DeviceStat = collections.namedtuple('DeviceStat', | |
| 46 ['st_mode', 'st_size', 'st_time']) | |
| 47 | |
| 48 | |
| 49 class AdbWrapper(object): | |
| 50 """A wrapper around a local Android Debug Bridge executable.""" | |
| 51 | |
| 52 def __init__(self, device_serial): | |
| 53 """Initializes the AdbWrapper. | |
| 54 | |
| 55 Args: | |
| 56 device_serial: The device serial number as a string. | |
| 57 """ | |
| 58 if not device_serial: | |
| 59 raise ValueError('A device serial must be specified') | |
| 60 self._device_serial = str(device_serial) | |
| 61 | |
| 62 # pylint: disable=unused-argument | |
| 63 @classmethod | |
| 64 def _BuildAdbCmd(cls, args, device_serial, cpu_affinity=None): | |
| 65 if cpu_affinity is not None: | |
| 66 cmd = ['taskset', '-c', str(cpu_affinity)] | |
| 67 else: | |
| 68 cmd = [] | |
| 69 cmd.append(constants.GetAdbPath()) | |
| 70 if device_serial is not None: | |
| 71 cmd.extend(['-s', device_serial]) | |
| 72 cmd.extend(args) | |
| 73 return cmd | |
| 74 # pylint: enable=unused-argument | |
| 75 | |
| 76 # pylint: disable=unused-argument | |
| 77 @classmethod | |
| 78 @decorators.WithTimeoutAndRetries | |
| 79 def _RunAdbCmd(cls, args, timeout=None, retries=None, device_serial=None, | |
| 80 check_error=True, cpu_affinity=None): | |
| 81 status, output = cmd_helper.GetCmdStatusAndOutputWithTimeout( | |
| 82 cls._BuildAdbCmd(args, device_serial, cpu_affinity=cpu_affinity), | |
| 83 timeout_retry.CurrentTimeoutThread().GetRemainingTime()) | |
| 84 if status != 0: | |
| 85 raise device_errors.AdbCommandFailedError( | |
| 86 args, output, status, device_serial) | |
| 87 # This catches some errors, including when the device drops offline; | |
| 88 # unfortunately adb is very inconsistent with error reporting so many | |
| 89 # command failures present differently. | |
| 90 if check_error and output.startswith('error:'): | |
| 91 raise device_errors.AdbCommandFailedError(args, output) | |
| 92 return output | |
| 93 # pylint: enable=unused-argument | |
| 94 | |
| 95 def _RunDeviceAdbCmd(self, args, timeout, retries, check_error=True): | |
| 96 """Runs an adb command on the device associated with this object. | |
| 97 | |
| 98 Args: | |
| 99 args: A list of arguments to adb. | |
| 100 timeout: Timeout in seconds. | |
| 101 retries: Number of retries. | |
| 102 check_error: Check that the command doesn't return an error message. This | |
| 103 does NOT check the exit status of shell commands. | |
| 104 | |
| 105 Returns: | |
| 106 The output of the command. | |
| 107 """ | |
| 108 return self._RunAdbCmd(args, timeout=timeout, retries=retries, | |
| 109 device_serial=self._device_serial, | |
| 110 check_error=check_error) | |
| 111 | |
| 112 def _IterRunDeviceAdbCmd(self, args, timeout): | |
| 113 """Runs an adb command and returns an iterator over its output lines. | |
| 114 | |
| 115 Args: | |
| 116 args: A list of arguments to adb. | |
| 117 timeout: Timeout in seconds. | |
| 118 | |
| 119 Yields: | |
| 120 The output of the command line by line. | |
| 121 """ | |
| 122 return cmd_helper.IterCmdOutputLines( | |
| 123 self._BuildAdbCmd(args, self._device_serial), timeout=timeout) | |
| 124 | |
| 125 def __eq__(self, other): | |
| 126 """Consider instances equal if they refer to the same device. | |
| 127 | |
| 128 Args: | |
| 129 other: The instance to compare equality with. | |
| 130 | |
| 131 Returns: | |
| 132 True if the instances are considered equal, false otherwise. | |
| 133 """ | |
| 134 return self._device_serial == str(other) | |
| 135 | |
| 136 def __str__(self): | |
| 137 """The string representation of an instance. | |
| 138 | |
| 139 Returns: | |
| 140 The device serial number as a string. | |
| 141 """ | |
| 142 return self._device_serial | |
| 143 | |
| 144 def __repr__(self): | |
| 145 return '%s(\'%s\')' % (self.__class__.__name__, self) | |
| 146 | |
| 147 # pylint: disable=unused-argument | |
| 148 @classmethod | |
| 149 def IsServerOnline(cls): | |
| 150 status, output = cmd_helper.GetCmdStatusAndOutput(['pgrep', 'adb']) | |
| 151 output = [int(x) for x in output.split()] | |
| 152 logging.info('PIDs for adb found: %r', output) | |
| 153 return status == 0 | |
| 154 # pylint: enable=unused-argument | |
| 155 | |
| 156 @classmethod | |
| 157 def KillServer(cls, timeout=_DEFAULT_TIMEOUT, retries=_DEFAULT_RETRIES): | |
| 158 cls._RunAdbCmd(['kill-server'], timeout=timeout, retries=retries) | |
| 159 | |
| 160 @classmethod | |
| 161 def StartServer(cls, timeout=_DEFAULT_TIMEOUT, retries=_DEFAULT_RETRIES): | |
| 162 # CPU affinity is used to reduce adb instability http://crbug.com/268450 | |
| 163 cls._RunAdbCmd(['start-server'], timeout=timeout, retries=retries, | |
| 164 cpu_affinity=0) | |
| 165 | |
| 166 @classmethod | |
| 167 def GetDevices(cls, timeout=_DEFAULT_TIMEOUT, retries=_DEFAULT_RETRIES): | |
| 168 """DEPRECATED. Refer to Devices(...) below.""" | |
| 169 # TODO(jbudorick): Remove this function once no more clients are using it. | |
| 170 return cls.Devices(timeout=timeout, retries=retries) | |
| 171 | |
| 172 @classmethod | |
| 173 def Devices(cls, is_ready=True, timeout=_DEFAULT_TIMEOUT, | |
| 174 retries=_DEFAULT_RETRIES): | |
| 175 """Get the list of active attached devices. | |
| 176 | |
| 177 Args: | |
| 178 is_ready: Whether the devices should be limited to only those that are | |
| 179 ready for use. | |
| 180 timeout: (optional) Timeout per try in seconds. | |
| 181 retries: (optional) Number of retries to attempt. | |
| 182 | |
| 183 Yields: | |
| 184 AdbWrapper instances. | |
| 185 """ | |
| 186 output = cls._RunAdbCmd(['devices'], timeout=timeout, retries=retries) | |
| 187 lines = (line.split() for line in output.splitlines()) | |
| 188 return [AdbWrapper(line[0]) for line in lines | |
| 189 if len(line) == 2 and (not is_ready or line[1] == _READY_STATE)] | |
| 190 | |
| 191 def GetDeviceSerial(self): | |
| 192 """Gets the device serial number associated with this object. | |
| 193 | |
| 194 Returns: | |
| 195 Device serial number as a string. | |
| 196 """ | |
| 197 return self._device_serial | |
| 198 | |
| 199 def Push(self, local, remote, timeout=60*5, retries=_DEFAULT_RETRIES): | |
| 200 """Pushes a file from the host to the device. | |
| 201 | |
| 202 Args: | |
| 203 local: Path on the host filesystem. | |
| 204 remote: Path on the device filesystem. | |
| 205 timeout: (optional) Timeout per try in seconds. | |
| 206 retries: (optional) Number of retries to attempt. | |
| 207 """ | |
| 208 _VerifyLocalFileExists(local) | |
| 209 self._RunDeviceAdbCmd(['push', local, remote], timeout, retries) | |
| 210 | |
| 211 def Pull(self, remote, local, timeout=60*5, retries=_DEFAULT_RETRIES): | |
| 212 """Pulls a file from the device to the host. | |
| 213 | |
| 214 Args: | |
| 215 remote: Path on the device filesystem. | |
| 216 local: Path on the host filesystem. | |
| 217 timeout: (optional) Timeout per try in seconds. | |
| 218 retries: (optional) Number of retries to attempt. | |
| 219 """ | |
| 220 cmd = ['pull', remote, local] | |
| 221 self._RunDeviceAdbCmd(cmd, timeout, retries) | |
| 222 try: | |
| 223 _VerifyLocalFileExists(local) | |
| 224 except IOError: | |
| 225 raise device_errors.AdbCommandFailedError( | |
| 226 cmd, 'File not found on host: %s' % local, device_serial=str(self)) | |
| 227 | |
| 228 def Shell(self, command, expect_status=0, timeout=_DEFAULT_TIMEOUT, | |
| 229 retries=_DEFAULT_RETRIES): | |
| 230 """Runs a shell command on the device. | |
| 231 | |
| 232 Args: | |
| 233 command: A string with the shell command to run. | |
| 234 expect_status: (optional) Check that the command's exit status matches | |
| 235 this value. Default is 0. If set to None the test is skipped. | |
| 236 timeout: (optional) Timeout per try in seconds. | |
| 237 retries: (optional) Number of retries to attempt. | |
| 238 | |
| 239 Returns: | |
| 240 The output of the shell command as a string. | |
| 241 | |
| 242 Raises: | |
| 243 device_errors.AdbCommandFailedError: If the exit status doesn't match | |
| 244 |expect_status|. | |
| 245 """ | |
| 246 if expect_status is None: | |
| 247 args = ['shell', command] | |
| 248 else: | |
| 249 args = ['shell', '%s; echo %%$?;' % command.rstrip()] | |
| 250 output = self._RunDeviceAdbCmd(args, timeout, retries, check_error=False) | |
| 251 if expect_status is not None: | |
| 252 output_end = output.rfind('%') | |
| 253 if output_end < 0: | |
| 254 # causes the status string to become empty and raise a ValueError | |
| 255 output_end = len(output) | |
| 256 | |
| 257 try: | |
| 258 status = int(output[output_end+1:]) | |
| 259 except ValueError: | |
| 260 logging.warning('exit status of shell command %r missing.', command) | |
| 261 raise device_errors.AdbShellCommandFailedError( | |
| 262 command, output, status=None, device_serial=self._device_serial) | |
| 263 output = output[:output_end] | |
| 264 if status != expect_status: | |
| 265 raise device_errors.AdbShellCommandFailedError( | |
| 266 command, output, status=status, device_serial=self._device_serial) | |
| 267 return output | |
| 268 | |
| 269 def IterShell(self, command, timeout): | |
| 270 """Runs a shell command and returns an iterator over its output lines. | |
| 271 | |
| 272 Args: | |
| 273 command: A string with the shell command to run. | |
| 274 timeout: Timeout in seconds. | |
| 275 | |
| 276 Yields: | |
| 277 The output of the command line by line. | |
| 278 """ | |
| 279 args = ['shell', command] | |
| 280 return cmd_helper.IterCmdOutputLines( | |
| 281 self._BuildAdbCmd(args, self._device_serial), timeout=timeout) | |
| 282 | |
| 283 def Ls(self, path, timeout=_DEFAULT_TIMEOUT, retries=_DEFAULT_RETRIES): | |
| 284 """List the contents of a directory on the device. | |
| 285 | |
| 286 Args: | |
| 287 path: Path on the device filesystem. | |
| 288 timeout: (optional) Timeout per try in seconds. | |
| 289 retries: (optional) Number of retries to attempt. | |
| 290 | |
| 291 Returns: | |
| 292 A list of pairs (filename, stat) for each file found in the directory, | |
| 293 where the stat object has the properties: st_mode, st_size, and st_time. | |
| 294 | |
| 295 Raises: | |
| 296 AdbCommandFailedError if |path| does not specify a valid and accessible | |
| 297 directory in the device. | |
| 298 """ | |
| 299 def ParseLine(line): | |
| 300 cols = line.split(None, 3) | |
| 301 filename = cols.pop() | |
| 302 stat = DeviceStat(*[int(num, base=16) for num in cols]) | |
| 303 return (filename, stat) | |
| 304 | |
| 305 cmd = ['ls', path] | |
| 306 lines = self._RunDeviceAdbCmd( | |
| 307 cmd, timeout=timeout, retries=retries).splitlines() | |
| 308 if lines: | |
| 309 return [ParseLine(line) for line in lines] | |
| 310 else: | |
| 311 raise device_errors.AdbCommandFailedError( | |
| 312 cmd, 'path does not specify an accessible directory in the device', | |
| 313 device_serial=self._device_serial) | |
| 314 | |
| 315 def Logcat(self, clear=False, dump=False, filter_specs=None, | |
| 316 logcat_format=None, ring_buffer=None, timeout=None, | |
| 317 retries=_DEFAULT_RETRIES): | |
| 318 """Get an iterable over the logcat output. | |
| 319 | |
| 320 Args: | |
| 321 clear: If true, clear the logcat. | |
| 322 dump: If true, dump the current logcat contents. | |
| 323 filter_specs: If set, a list of specs to filter the logcat. | |
| 324 logcat_format: If set, the format in which the logcat should be output. | |
| 325 Options include "brief", "process", "tag", "thread", "raw", "time", | |
| 326 "threadtime", and "long" | |
| 327 ring_buffer: If set, a list of alternate ring buffers to request. | |
| 328 Options include "main", "system", "radio", "events", "crash" or "all". | |
| 329 The default is equivalent to ["main", "system", "crash"]. | |
| 330 timeout: (optional) If set, timeout per try in seconds. If clear or dump | |
| 331 is set, defaults to _DEFAULT_TIMEOUT. | |
| 332 retries: (optional) If clear or dump is set, the number of retries to | |
| 333 attempt. Otherwise, does nothing. | |
| 334 | |
| 335 Yields: | |
| 336 logcat output line by line. | |
| 337 """ | |
| 338 cmd = ['logcat'] | |
| 339 use_iter = True | |
| 340 if clear: | |
| 341 cmd.append('-c') | |
| 342 use_iter = False | |
| 343 if dump: | |
| 344 cmd.append('-d') | |
| 345 use_iter = False | |
| 346 if logcat_format: | |
| 347 cmd.extend(['-v', logcat_format]) | |
| 348 if ring_buffer: | |
| 349 for buffer_name in ring_buffer: | |
| 350 cmd.extend(['-b', buffer_name]) | |
| 351 if filter_specs: | |
| 352 cmd.extend(filter_specs) | |
| 353 | |
| 354 if use_iter: | |
| 355 return self._IterRunDeviceAdbCmd(cmd, timeout) | |
| 356 else: | |
| 357 timeout = timeout if timeout is not None else _DEFAULT_TIMEOUT | |
| 358 return self._RunDeviceAdbCmd(cmd, timeout, retries).splitlines() | |
| 359 | |
| 360 def Forward(self, local, remote, timeout=_DEFAULT_TIMEOUT, | |
| 361 retries=_DEFAULT_RETRIES): | |
| 362 """Forward socket connections from the local socket to the remote socket. | |
| 363 | |
| 364 Sockets are specified by one of: | |
| 365 tcp:<port> | |
| 366 localabstract:<unix domain socket name> | |
| 367 localreserved:<unix domain socket name> | |
| 368 localfilesystem:<unix domain socket name> | |
| 369 dev:<character device name> | |
| 370 jdwp:<process pid> (remote only) | |
| 371 | |
| 372 Args: | |
| 373 local: The host socket. | |
| 374 remote: The device socket. | |
| 375 timeout: (optional) Timeout per try in seconds. | |
| 376 retries: (optional) Number of retries to attempt. | |
| 377 """ | |
| 378 self._RunDeviceAdbCmd(['forward', str(local), str(remote)], timeout, | |
| 379 retries) | |
| 380 | |
| 381 def JDWP(self, timeout=_DEFAULT_TIMEOUT, retries=_DEFAULT_RETRIES): | |
| 382 """List of PIDs of processes hosting a JDWP transport. | |
| 383 | |
| 384 Args: | |
| 385 timeout: (optional) Timeout per try in seconds. | |
| 386 retries: (optional) Number of retries to attempt. | |
| 387 | |
| 388 Returns: | |
| 389 A list of PIDs as strings. | |
| 390 """ | |
| 391 return [a.strip() for a in | |
| 392 self._RunDeviceAdbCmd(['jdwp'], timeout, retries).split('\n')] | |
| 393 | |
| 394 def Install(self, apk_path, forward_lock=False, reinstall=False, | |
| 395 sd_card=False, timeout=60*2, retries=_DEFAULT_RETRIES): | |
| 396 """Install an apk on the device. | |
| 397 | |
| 398 Args: | |
| 399 apk_path: Host path to the APK file. | |
| 400 forward_lock: (optional) If set forward-locks the app. | |
| 401 reinstall: (optional) If set reinstalls the app, keeping its data. | |
| 402 sd_card: (optional) If set installs on the SD card. | |
| 403 timeout: (optional) Timeout per try in seconds. | |
| 404 retries: (optional) Number of retries to attempt. | |
| 405 """ | |
| 406 _VerifyLocalFileExists(apk_path) | |
| 407 cmd = ['install'] | |
| 408 if forward_lock: | |
| 409 cmd.append('-l') | |
| 410 if reinstall: | |
| 411 cmd.append('-r') | |
| 412 if sd_card: | |
| 413 cmd.append('-s') | |
| 414 cmd.append(apk_path) | |
| 415 output = self._RunDeviceAdbCmd(cmd, timeout, retries) | |
| 416 if 'Success' not in output: | |
| 417 raise device_errors.AdbCommandFailedError( | |
| 418 cmd, output, device_serial=self._device_serial) | |
| 419 | |
| 420 def InstallMultiple(self, apk_paths, forward_lock=False, reinstall=False, | |
| 421 sd_card=False, allow_downgrade=False, partial=False, | |
| 422 timeout=60*2, retries=_DEFAULT_RETRIES): | |
| 423 """Install an apk with splits on the device. | |
| 424 | |
| 425 Args: | |
| 426 apk_paths: Host path to the APK file. | |
| 427 forward_lock: (optional) If set forward-locks the app. | |
| 428 reinstall: (optional) If set reinstalls the app, keeping its data. | |
| 429 sd_card: (optional) If set installs on the SD card. | |
| 430 timeout: (optional) Timeout per try in seconds. | |
| 431 retries: (optional) Number of retries to attempt. | |
| 432 allow_downgrade: (optional) Allow versionCode downgrade. | |
| 433 partial: (optional) Package ID if apk_paths doesn't include all .apks. | |
| 434 """ | |
| 435 for path in apk_paths: | |
| 436 _VerifyLocalFileExists(path) | |
| 437 cmd = ['install-multiple'] | |
| 438 if forward_lock: | |
| 439 cmd.append('-l') | |
| 440 if reinstall: | |
| 441 cmd.append('-r') | |
| 442 if sd_card: | |
| 443 cmd.append('-s') | |
| 444 if allow_downgrade: | |
| 445 cmd.append('-d') | |
| 446 if partial: | |
| 447 cmd.extend(('-p', partial)) | |
| 448 cmd.extend(apk_paths) | |
| 449 output = self._RunDeviceAdbCmd(cmd, timeout, retries) | |
| 450 if 'Success' not in output: | |
| 451 raise device_errors.AdbCommandFailedError( | |
| 452 cmd, output, device_serial=self._device_serial) | |
| 453 | |
| 454 def Uninstall(self, package, keep_data=False, timeout=_DEFAULT_TIMEOUT, | |
| 455 retries=_DEFAULT_RETRIES): | |
| 456 """Remove the app |package| from the device. | |
| 457 | |
| 458 Args: | |
| 459 package: The package to uninstall. | |
| 460 keep_data: (optional) If set keep the data and cache directories. | |
| 461 timeout: (optional) Timeout per try in seconds. | |
| 462 retries: (optional) Number of retries to attempt. | |
| 463 """ | |
| 464 cmd = ['uninstall'] | |
| 465 if keep_data: | |
| 466 cmd.append('-k') | |
| 467 cmd.append(package) | |
| 468 output = self._RunDeviceAdbCmd(cmd, timeout, retries) | |
| 469 if 'Failure' in output: | |
| 470 raise device_errors.AdbCommandFailedError( | |
| 471 cmd, output, device_serial=self._device_serial) | |
| 472 | |
| 473 def Backup(self, path, packages=None, apk=False, shared=False, | |
| 474 nosystem=True, include_all=False, timeout=_DEFAULT_TIMEOUT, | |
| 475 retries=_DEFAULT_RETRIES): | |
| 476 """Write an archive of the device's data to |path|. | |
| 477 | |
| 478 Args: | |
| 479 path: Local path to store the backup file. | |
| 480 packages: List of to packages to be backed up. | |
| 481 apk: (optional) If set include the .apk files in the archive. | |
| 482 shared: (optional) If set buckup the device's SD card. | |
| 483 nosystem: (optional) If set exclude system applications. | |
| 484 include_all: (optional) If set back up all installed applications and | |
| 485 |packages| is optional. | |
| 486 timeout: (optional) Timeout per try in seconds. | |
| 487 retries: (optional) Number of retries to attempt. | |
| 488 """ | |
| 489 cmd = ['backup', '-f', path] | |
| 490 if apk: | |
| 491 cmd.append('-apk') | |
| 492 if shared: | |
| 493 cmd.append('-shared') | |
| 494 if nosystem: | |
| 495 cmd.append('-nosystem') | |
| 496 if include_all: | |
| 497 cmd.append('-all') | |
| 498 if packages: | |
| 499 cmd.extend(packages) | |
| 500 assert bool(packages) ^ bool(include_all), ( | |
| 501 'Provide \'packages\' or set \'include_all\' but not both.') | |
| 502 ret = self._RunDeviceAdbCmd(cmd, timeout, retries) | |
| 503 _VerifyLocalFileExists(path) | |
| 504 return ret | |
| 505 | |
| 506 def Restore(self, path, timeout=_DEFAULT_TIMEOUT, retries=_DEFAULT_RETRIES): | |
| 507 """Restore device contents from the backup archive. | |
| 508 | |
| 509 Args: | |
| 510 path: Host path to the backup archive. | |
| 511 timeout: (optional) Timeout per try in seconds. | |
| 512 retries: (optional) Number of retries to attempt. | |
| 513 """ | |
| 514 _VerifyLocalFileExists(path) | |
| 515 self._RunDeviceAdbCmd(['restore'] + [path], timeout, retries) | |
| 516 | |
| 517 def WaitForDevice(self, timeout=60*5, retries=_DEFAULT_RETRIES): | |
| 518 """Block until the device is online. | |
| 519 | |
| 520 Args: | |
| 521 timeout: (optional) Timeout per try in seconds. | |
| 522 retries: (optional) Number of retries to attempt. | |
| 523 """ | |
| 524 self._RunDeviceAdbCmd(['wait-for-device'], timeout, retries) | |
| 525 | |
| 526 def GetState(self, timeout=_DEFAULT_TIMEOUT, retries=_DEFAULT_RETRIES): | |
| 527 """Get device state. | |
| 528 | |
| 529 Args: | |
| 530 timeout: (optional) Timeout per try in seconds. | |
| 531 retries: (optional) Number of retries to attempt. | |
| 532 | |
| 533 Returns: | |
| 534 One of 'offline', 'bootloader', or 'device'. | |
| 535 """ | |
| 536 return self._RunDeviceAdbCmd(['get-state'], timeout, retries).strip() | |
| 537 | |
| 538 def GetDevPath(self, timeout=_DEFAULT_TIMEOUT, retries=_DEFAULT_RETRIES): | |
| 539 """Gets the device path. | |
| 540 | |
| 541 Args: | |
| 542 timeout: (optional) Timeout per try in seconds. | |
| 543 retries: (optional) Number of retries to attempt. | |
| 544 | |
| 545 Returns: | |
| 546 The device path (e.g. usb:3-4) | |
| 547 """ | |
| 548 return self._RunDeviceAdbCmd(['get-devpath'], timeout, retries) | |
| 549 | |
| 550 def Remount(self, timeout=_DEFAULT_TIMEOUT, retries=_DEFAULT_RETRIES): | |
| 551 """Remounts the /system partition on the device read-write.""" | |
| 552 self._RunDeviceAdbCmd(['remount'], timeout, retries) | |
| 553 | |
| 554 def Reboot(self, to_bootloader=False, timeout=60*5, | |
| 555 retries=_DEFAULT_RETRIES): | |
| 556 """Reboots the device. | |
| 557 | |
| 558 Args: | |
| 559 to_bootloader: (optional) If set reboots to the bootloader. | |
| 560 timeout: (optional) Timeout per try in seconds. | |
| 561 retries: (optional) Number of retries to attempt. | |
| 562 """ | |
| 563 if to_bootloader: | |
| 564 cmd = ['reboot-bootloader'] | |
| 565 else: | |
| 566 cmd = ['reboot'] | |
| 567 self._RunDeviceAdbCmd(cmd, timeout, retries) | |
| 568 | |
| 569 def Root(self, timeout=_DEFAULT_TIMEOUT, retries=_DEFAULT_RETRIES): | |
| 570 """Restarts the adbd daemon with root permissions, if possible. | |
| 571 | |
| 572 Args: | |
| 573 timeout: (optional) Timeout per try in seconds. | |
| 574 retries: (optional) Number of retries to attempt. | |
| 575 """ | |
| 576 output = self._RunDeviceAdbCmd(['root'], timeout, retries) | |
| 577 if 'cannot' in output: | |
| 578 raise device_errors.AdbCommandFailedError( | |
| 579 ['root'], output, device_serial=self._device_serial) | |
| 580 | |
| 581 def Emu(self, cmd, timeout=_DEFAULT_TIMEOUT, | |
| 582 retries=_DEFAULT_RETRIES): | |
| 583 """Runs an emulator console command. | |
| 584 | |
| 585 See http://developer.android.com/tools/devices/emulator.html#console | |
| 586 | |
| 587 Args: | |
| 588 cmd: The command to run on the emulator console. | |
| 589 timeout: (optional) Timeout per try in seconds. | |
| 590 retries: (optional) Number of retries to attempt. | |
| 591 | |
| 592 Returns: | |
| 593 The output of the emulator console command. | |
| 594 """ | |
| 595 if isinstance(cmd, basestring): | |
| 596 cmd = [cmd] | |
| 597 return self._RunDeviceAdbCmd(['emu'] + cmd, timeout, retries) | |
| 598 | |
| 599 @property | |
| 600 def is_emulator(self): | |
| 601 return _EMULATOR_RE.match(self._device_serial) | |
| 602 | |
| 603 @property | |
| 604 def is_ready(self): | |
| 605 try: | |
| 606 return self.GetState() == _READY_STATE | |
| 607 except device_errors.CommandFailedError: | |
| 608 return False | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2392643003:
Removes files from //build that we don't need (Closed)
