Chromium roll (https://codereview.chromium.org/976353002)

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=unused-argument
 
@@ skipping 11 matching lines @@
 import pylib.android_commands
 from pylib import cmd_helper
 from pylib import constants
 from pylib.device import adb_wrapper
 from pylib.device import decorators
 from pylib.device import device_errors
 from pylib.device import intent
 from pylib.device import logcat_monitor
 from pylib.device.commands import install_commands
 from pylib.utils import apk_helper
+from pylib.utils import base_error
 from pylib.utils import device_temp_file
 from pylib.utils import host_utils
 from pylib.utils import md5sum
 from pylib.utils import parallelizer
 from pylib.utils import timeout_retry
 from pylib.utils import zip_utils
 
 _DEFAULT_TIMEOUT = 30
 _DEFAULT_RETRIES = 3
 
 # A sentinel object for default values
 # TODO(jbudorick,perezju): revisit how default values are handled by
 # the timeout_retry decorators.
 DEFAULT = object()
 
-_CONTROL_USB_CHARGING_COMMANDS = [
+_CONTROL_CHARGING_COMMANDS = [
   {
     # Nexus 4
     'witness_file': '/sys/module/pm8921_charger/parameters/disabled',
     'enable_command': 'echo 0 > /sys/module/pm8921_charger/parameters/disabled',
     'disable_command':
         'echo 1 > /sys/module/pm8921_charger/parameters/disabled',
   },
   {
     # Nexus 5
     # Setting the HIZ bit of the bq24192 causes the charger to actually ignore
@@ skipping 122 matching lines @@
       retries: number of retries
 
     Returns:
       True if the device is online, False otherwise.
 
     Raises:
       CommandTimeoutError on timeout.
     """
     try:
       return self.adb.GetState() == 'device'
-    except device_errors.BaseError as exc:
+    except base_error.BaseError as exc:
       logging.info('Failed to get state: %s', exc)
       return False
 
   @decorators.WithTimeoutAndRetriesFromInstance()
   def HasRoot(self, timeout=None, retries=None):
     """Checks whether or not adbd has root privileges.
 
     Args:
       timeout: timeout in seconds
       retries: number of retries
@@ skipping 1210 matching lines @@
     """
     result = {}
     # Skip the first line, which is just a header.
     for line in self.RunShellCommand(
         ['dumpsys', 'battery'], check_return=True)[1:]:
       k, v = line.split(': ', 1)
       result[k.strip()] = v.strip()
     return result
 
   @decorators.WithTimeoutAndRetriesFromInstance()
-  def GetUsbCharging(self, timeout=None, retries=None):
-    """Gets the USB charging state of the device.
+  def GetCharging(self, timeout=None, retries=None):
+    """Gets the charging state of the device.
 
     Args:
       timeout: timeout in seconds
       retries: number of retries
     Returns:
-      True if the device is charging via USB, false otherwise.
+      True if the device is charging, false otherwise.
     """
-    return (self.GetBatteryInfo().get('USB powered', '').lower()
-            in ('true', '1', 'yes'))
+    battery_info = self.GetBatteryInfo()
+    for k in ('AC powered', 'USB powered', 'Wireless powered'):
+      if (k in battery_info and
+          battery_info[k].lower() in ('true', '1', 'yes')):
+        return True
+    return False
 
   @decorators.WithTimeoutAndRetriesFromInstance()
-  def SetUsbCharging(self, enabled, timeout=None, retries=None):
-    """Enables or disables USB charging on the device.
+  def SetCharging(self, enabled, timeout=None, retries=None):
+    """Enables or disables charging on the device.
 
     Args:
-      enabled: A boolean indicating whether USB charging should be enabled or
+      enabled: A boolean indicating whether charging should be enabled or
         disabled.
       timeout: timeout in seconds
       retries: number of retries
     """
-    if 'usb_charging_config' not in self._cache:
-      for c in _CONTROL_USB_CHARGING_COMMANDS:
+    if 'charging_config' not in self._cache:
+      for c in _CONTROL_CHARGING_COMMANDS:
         if self.FileExists(c['witness_file']):
-          self._cache['usb_charging_config'] = c
+          self._cache['charging_config'] = c
           break
       else:
         raise device_errors.CommandFailedError(
             'Unable to find charging commands.')
 
     if enabled:
-      command = self._cache['usb_charging_config']['enable_command']
+      command = self._cache['charging_config']['enable_command']
     else:
-      command = self._cache['usb_charging_config']['disable_command']
+      command = self._cache['charging_config']['disable_command']
 
-    def set_and_verify_usb_charging():
-      self.RunShellCommand(command)
-      return self.GetUsbCharging() == enabled
+    def set_and_verify_charging():
+      self.RunShellCommand(command, check_return=True)
+      return self.GetCharging() == enabled
 
-    timeout_retry.WaitFor(set_and_verify_usb_charging, wait_period=1)
+    timeout_retry.WaitFor(set_and_verify_charging, wait_period=1)
 
   @decorators.WithTimeoutAndRetriesFromInstance()
   def GetDevicePieWrapper(self, timeout=None, retries=None):
     """Gets the absolute path to the run_pie wrapper on the device.
 
     We have to build our device executables to be PIE, but they need to be able
     to run on versions of android that don't support PIE (i.e. ICS and below).
     To do so, we push a wrapper to the device that lets older android versions
     run PIE executables. This method pushes that wrapper to the device if
     necessary and returns the path to it.
@@ skipping 42 matching lines @@
     """
     if not devices:
       devices = adb_wrapper.AdbWrapper.GetDevices()
       if not devices:
         raise device_errors.NoDevicesError()
     devices = [d if isinstance(d, cls) else cls(d) for d in devices]
     if async:
       return parallelizer.Parallelizer(devices)
     else:
       return parallelizer.SyncParallelizer(devices)