Add new method to disable android device charging.

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
 
 import collections
+import contextlib
 import itertools
 import logging
 import multiprocessing
 import os
 import re
 import sys
 import tempfile
 import time
 import zipfile
 
@@ skipping 40 matching lines @@
     'enable_command': (
         'echo 0x4A > /sys/kernel/debug/bq24192/INPUT_SRC_CONT && '
         'echo 1 > /sys/class/power_supply/usb/online'),
     'disable_command': (
         'echo 0xCA > /sys/kernel/debug/bq24192/INPUT_SRC_CONT && '
         'chmod 644 /sys/class/power_supply/usb/online && '
         'echo 0 > /sys/class/power_supply/usb/online'),
   },
 ]
 
-
 @decorators.WithExplicitTimeoutAndRetries(
     _DEFAULT_TIMEOUT, _DEFAULT_RETRIES)
 def GetAVDs():
   """Returns a list of Android Virtual Devices.
 
   Returns:
     A list containing the configured AVDs.
   """
   lines = cmd_helper.GetCmdOutput([
       os.path.join(constants.ANDROID_SDK_ROOT, 'tools', 'android'),
@@ skipping 1324 matching lines @@
       timeout: timeout in seconds
       retries: number of retries
     Returns:
       A dict containing various battery information as reported by dumpsys
       battery.
     """
     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()
+      # If usb charging has been disabled, an extra line of header exists.
+      if 'UPDATES STOPPED' in line:
+        logging.warning('Dumpsys battery not receiving updates. '
+                        'Run dumpsys battery reset if this is in error.')
+      elif ':' not in line:
+        logging.warning('Unknown line found in dumpsys battery.')
+        logging.warning(line)
+      else:
+        k, v = line.split(': ', 1)
+        result[k.strip()] = v.strip()
     return result
 
   @decorators.WithTimeoutAndRetriesFromInstance()
   def GetCharging(self, timeout=None, retries=None):
     """Gets the charging state of the device.
 
     Args:
       timeout: timeout in seconds
       retries: number of retries
     Returns:
@@ skipping 30 matching lines @@
     else:
       command = self._cache['charging_config']['disable_command']
 
     def set_and_verify_charging():
       self.RunShellCommand(command, check_return=True)
       return self.GetCharging() == enabled
 
     timeout_retry.WaitFor(set_and_verify_charging, wait_period=1)
 
   @decorators.WithTimeoutAndRetriesFromInstance()
+  def _ResetBatteryData(self, timeout=None, retries=None):
+    def reset_battery_data():
+      self.RunShellCommand(['dumpsys', 'batterystats', '--reset'],
+                           check_return=True)
+      # Test that battery data was reset.
+      battery_data = self.RunShellCommand(
+          ['dumpsys', 'batterystats', '--charged',
+          '--checkin'], check_return=True)
+      for line in battery_data:
+        l = line.split(',')
+        if l[3] == 'pwi' and l[1] != 0:
+          return False
+      return True
+
+    timeout_retry.WaitFor(reset_battery_data, wait_period=1)
+
+  @decorators.WithTimeoutAndRetriesFromInstance()
+  def _DisableBatteryUpdates(self, timeout=None, retries=None):

[perezju, 2015/03/13 10:19:06]

Thanks, this is looking a lot better. I'm still a bit puzzled, however, about
the intended interaction between the retries and the wait-fors. Do we really
need to re-run the command to, say, disable usb while waiting for GetCharging to
return False?

In other words, I think we should be using WaitFor to wait for expected things
to happen (if they don't tend to happen immediately), not to retry running
commands when the expected thing doesn't seem to be happening.

Maybe something like this would be better?

    @decorators.WithTimeoutAndRetriesFromInstance()
    def _DisableBatteryUpdates(self, ...):
      def battery_updates_disabled():
        return self.GetCharging() is False

      self.RunShellCommand(...) # dumpsys batterystats --reset
      battery_data = # dumpsys batterystats --charged --checkin
      if some_non_zero_pwi_found:
         raise device_errors.CommandFailedError(...)
      self.RunShellCommand(...) # dumpsys battery reset
      timeout_retry.WaitFor(battery_updates_disabled, wait_period=1)

This way we try to set up everything as needed once, and then just repeatedly
query the device until charging becomes off. If everything works as expected,
each command is run once and we're done.

Now if something doesn't work as expected---one of the commands failed, we found
a non_zero_pwi after resetting stats, or we waited for charging to become off
but it didn't happen before the timeout---an exception will be raised, and the
retry mechanism will try to re-run the whole sequence again.

Does that make sense, or am I missing something?

[rnephew (Wrong account), 2015/03/16 16:33:40]

Done.

+    def disable_battery_updates():
+      self.RunShellCommand(['dumpsys', 'battery', 'set', 'usb', '0'],
+                            check_return=True)
+      return self.GetCharging() is False
+
+    timeout_retry.WaitFor(disable_battery_updates, wait_period=1)
+
+  @decorators.WithTimeoutAndRetriesFromInstance()
+  def _EnableBatteryUpdates(self, timeout=None, retries=None):
+    def enable_battery_updates():
+      self.RunShellCommand(['dumpsys', 'battery', 'reset'], check_return=True)

[perezju, 2015/03/13 10:19:07]

ditto as above

[rnephew (Wrong account), 2015/03/16 16:33:40]

Done.

+      return self.GetCharging() is True
+
+    timeout_retry.WaitFor(enable_battery_updates, wait_period=1)
+
+  @contextlib.contextmanager
+  def BatteryMeasurement(self, timeout=None, retries=None):
+    """Context manager that enables battery data collection when in.
+    Only for devices L and higher.
+

[perezju, 2015/03/13 10:19:06]

nit: maybe the example would look a bit better with some annotations:

Example usage:

    with device.BatteryMeasurement():
      browser_actions()
      get_power_data() # reports usage within this block

[rnephew (Wrong account), 2015/03/16 16:33:40]

Done.

+    with BatteryMeasurement():
+      browser_actions()
+      get_power_data()
+    no_longer_collecting_data
+
+    Args:
+      timeout: timeout in seconds
+      retries: number of retries
+    """
+    if self.build_version_sdk <  constants.ANDROID_SDK_VERSION_CODES.LOLLIPOP:

[perezju, 2015/03/13 10:19:07]

nit: extra space after '<'

[rnephew (Wrong account), 2015/03/16 16:33:40]

Done.

+      raise device_errors.CommandFailedError('Device must be L or higher.')
+    try:
+      self._ResetBatteryData(timeout=timeout, retries=retries)
+      self._DisableBatteryUpdates(timeout=timeout, retries=retries)
+      yield
+    finally:
+      self._EnableBatteryUpdates(timeout=timeout, retries=retries)
+
+  @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.
 
     This is exposed publicly to allow clients to write scripts using run_pie
@@ skipping 40 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)