[Android] Convert battery utilities to DeviceUtils.

build/android/provision_devices.py

 #!/usr/bin/env python
 #
 # Copyright (c) 2013 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.
 
 """Provisions Android devices with settings required for bots.
 
 Usage:
   ./provision_devices.py [-d <device serial number>]
 """
 
 import argparse
 import logging
 import os
 import re
 import subprocess
 import sys
 import time
 
 from pylib import android_commands
 from pylib import constants
 from pylib import device_settings
 from pylib.device import device_blacklist
 from pylib.device import device_errors
 from pylib.device import device_utils
 from pylib.utils import run_tests_helper
+from pylib.utils import timeout_retry
 
 sys.path.append(os.path.join(constants.DIR_SOURCE_ROOT,
                              'third_party', 'android_testrunner'))
 import errors
 
 
 class _DEFAULT_TIMEOUTS(object):
   # L can take a while to reboot after a wipe.
   LOLLIPOP = 600
   PRE_LOLLIPOP = 180
@@ skipping 39 matching lines @@
     # We can safely ignore the exception because we don't expect adb_reboot
     # to be running.
     pass
   # Push adb_reboot
   logging.info('  Pushing adb_reboot ...')
   adb_reboot = os.path.join(constants.DIR_SOURCE_ROOT,
                             'out/%s/adb_reboot' % target)
   device.PushChangedFiles([(adb_reboot, '/data/local/tmp/')])
   # Launch adb_reboot
   logging.info('  Launching adb_reboot ...')
-  device.old_interface.GetAndroidToolStatusAndOutput(
-      '/data/local/tmp/adb_reboot')
+  device.RunShellCommand([
+      device.GetDevicePieWrapper(),
+      '/data/local/tmp/adb_reboot'])
 
 
 def _ConfigureLocalProperties(device, java_debug=True):
   """Set standard readonly testing device properties prior to reboot."""
   local_props = [
       'persist.sys.usb.config=adb',
       'ro.monkey=1',
       'ro.test_harness=1',
       'ro.audio.silent=1',
       'ro.setupwizard.mode=DISABLED',
@@ skipping 43 matching lines @@
 
 def WipeDeviceIfPossible(device, timeout):
   try:
     device.EnableRoot()
     WipeDeviceData(device)
     device.Reboot(True, timeout=timeout, retries=0)
   except (errors.DeviceUnresponsiveError, device_errors.CommandFailedError):
     pass
 
 
+def ChargeDeviceToLevel(device, level):
+  def device_charged():
+    battery_level = int(device.GetBatteryInfo().get('level', 100))

[perezju, 2015/02/23 10:43:32]

I see this was also on the previous version of the code, but why do we need a
default of 100? Do some devices not return the battery level? Should we at least
log a warning when this is the case?

[jbudorick, 2015/02/24 15:44:53]

I'm not sure when or why the default was added, but I imagine it was something
along those lines. I've added a warning in case battery_level isn't available.

+    logging.info('current battery level: %d', battery_level)
+    return battery_level >= level
+
+  timeout_retry.WaitFor(device_charged, wait_period=60)
+
+
 def ProvisionDevice(device, options):
   if options.reboot_timeout:
     reboot_timeout = options.reboot_timeout
   elif (device.build_version_sdk >=
         constants.ANDROID_SDK_VERSION_CODES.LOLLIPOP):
     reboot_timeout = _DEFAULT_TIMEOUTS.LOLLIPOP
   else:
     reboot_timeout = _DEFAULT_TIMEOUTS.PRE_LOLLIPOP
 
   try:
@@ skipping 10 matching lines @@
       device_settings.ConfigureContentSettings(
           device, device_settings.DISABLE_LOCATION_SETTINGS)
     else:
       device_settings.ConfigureContentSettings(
           device, device_settings.ENABLE_LOCATION_SETTINGS)
     device_settings.SetLockScreenSettings(device)
     if options.disable_network:
       device_settings.ConfigureContentSettings(
           device, device_settings.NETWORK_DISABLED_SETTINGS)
     if options.min_battery_level is not None:
-      try:
-        battery_info = device.old_interface.GetBatteryInfo()
-      except Exception as e:
-        battery_info = {}
-        logging.error('Unable to obtain battery info for %s, %s',
-                      str(device), e)
+      device.SetUsbCharging(True)

[perezju, 2015/02/23 10:43:32]

There seems to be a change of logic w.r.t. previous version:

- we did not try to enable usb charging if either: the device was already
charging somehow (e.g. via AC or wireless), or we did not find suitable commands
to enable usb charging.
- we now try to enable usb charging regardless of the current state, and an
exception is raised if we're an unable to find usb charging commands.

Both changes seem reasonable to me, just wanted to make sure that these are
indeed intended (and we don't expect to see devices where the required usb
commands are not available).

[jbudorick, 2015/02/24 15:44:53]

These changes were both intentional, but on reconsidering (and running locally
with an N7), it's probably better to have provision_devices catch and log the
exception if we can't enable charging. After all, if we don't have the commands,
charging probably wasn't disabled in the first place.

+      ChargeDeviceToLevel(device, options.min_battery_level)
 
-      while int(battery_info.get('level', 100)) < options.min_battery_level:
-        if not device.old_interface.IsDeviceCharging():
-          if device.old_interface.CanControlUsbCharging():
-            device.old_interface.EnableUsbCharging()
-          else:
-            logging.error('Device is not charging')
-            break
-        logging.info('Waiting for device to charge. Current level=%s',
-                     battery_info.get('level', 0))
-        time.sleep(60)
-        battery_info = device.old_interface.GetBatteryInfo()
     if not options.skip_wipe:
       device.Reboot(True, timeout=reboot_timeout, retries=0)
     device.RunShellCommand('date -s %s' % time.strftime('%Y%m%d.%H%M%S',
                                                         time.gmtime()),
                            as_root=True)
     props = device.RunShellCommand('getprop')
     for prop in props:
       logging.info('  %s' % prop)
     if options.auto_reconnect:
       PushAndLaunchAdbReboot(device, options.target)
@@ skipping 67 matching lines @@
                       help='push binary which will reboot the device on adb'
                       ' disconnections')
   args = parser.parse_args()
   constants.SetBuildType(args.target)
 
   return ProvisionDevices(args)
 
 
 if __name__ == '__main__':
   sys.exit(main())