[android] Create Battery Utils to seperate power functionality

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 150 matching lines @@
       self.old_interface = pylib.android_commands.AndroidCommands(str(device))
     elif isinstance(device, pylib.android_commands.AndroidCommands):
       self.adb = adb_wrapper.AdbWrapper(device.GetDevice())
       self.old_interface = device
     else:
       raise ValueError('Unsupported device value: %r' % device)
     self._commands_installed = None
     self._default_timeout = default_timeout
     self._default_retries = default_retries
     self._cache = {}
+    self._client_caches = {}
     assert hasattr(self, decorators.DEFAULT_TIMEOUT_ATTR)
     assert hasattr(self, decorators.DEFAULT_RETRIES_ATTR)
 
   def __str__(self):
     """Returns the device serial."""
     return self.adb.GetDeviceSerial()
 
   @decorators.WithTimeoutAndRetriesFromInstance()
   def IsOnline(self, timeout=None, retries=None):
     """Checks whether the device is online.
@@ skipping 218 matching lines @@
       retries: number of retries
 
     Raises:
       CommandTimeoutError on timeout.
       DeviceUnreachableError on missing device.
     """
     def device_offline():
       return not self.IsOnline()
 
     self.adb.Reboot()
-    self._cache = {}
+    self._ClearCache()
     timeout_retry.WaitFor(device_offline, wait_period=1)
     if block:
       self.WaitUntilFullyBooted(wifi=wifi)
 
   INSTALL_DEFAULT_TIMEOUT = 4 * _DEFAULT_TIMEOUT
   INSTALL_DEFAULT_RETRIES = _DEFAULT_RETRIES
 
   @decorators.WithTimeoutAndRetriesDefaults(
       INSTALL_DEFAULT_TIMEOUT,
       INSTALL_DEFAULT_RETRIES)
@@ skipping 1011 matching lines @@
 
     Parameters passed to this function are passed directly to
     |logcat_monitor.LogcatMonitor| and are documented there.
 
     Args:
       timeout: timeout in seconds
       retries: number of retries
     """
     return logcat_monitor.LogcatMonitor(self.adb, *args, **kwargs)
 
+  # TODO(rnephew): Remove when battery_utils is switched to.
   @decorators.WithTimeoutAndRetriesFromInstance()
   def GetBatteryInfo(self, timeout=None, retries=None):
     """Gets battery info for the device.
 
     Args:
       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:]:
       # 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
 
+  # TODO(rnephew): Remove when battery_utils is switched to.
   @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:
       True if the device is charging, false otherwise.
     """
     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
 
+  # TODO(rnephew): Remove when battery_utils is switched to.
   @decorators.WithTimeoutAndRetriesFromInstance()
   def SetCharging(self, enabled, timeout=None, retries=None):
     """Enables or disables charging on the device.
 
     Args:
       enabled: A boolean indicating whether charging should be enabled or
         disabled.
       timeout: timeout in seconds
       retries: number of retries
     """
@@ skipping 10 matching lines @@
       command = self._cache['charging_config']['enable_command']
     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)
 
-  # TODO(rnephew): Make private when all use cases can use the context manager.
+  # TODO(rnephew): Remove when battery_utils is switched to.
   @decorators.WithTimeoutAndRetriesFromInstance()
   def DisableBatteryUpdates(self, timeout=None, retries=None):
     """ Resets battery data and makes device appear like it is not
     charging so that it will collect power data since last charge.
 
     Args:
       timeout: timeout in seconds
       retries: number of retries
     """
     def battery_updates_disabled():
       return self.GetCharging() is False
 
     self.RunShellCommand(
         ['dumpsys', 'batterystats', '--reset'], check_return=True)
     battery_data = self.RunShellCommand(
         ['dumpsys', 'batterystats', '--charged', '--checkin'],
         check_return=True)
     ROW_TYPE_INDEX = 3
     PWI_POWER_INDEX = 5
     for line in battery_data:
       l = line.split(',')
       if (len(l) > PWI_POWER_INDEX and l[ROW_TYPE_INDEX] == 'pwi'
           and l[PWI_POWER_INDEX] != 0):
         raise device_errors.CommandFailedError(
             'Non-zero pmi value found after reset.')
     self.RunShellCommand(['dumpsys', 'battery', 'set', 'usb', '0'],
                          check_return=True)
     timeout_retry.WaitFor(battery_updates_disabled, wait_period=1)
 
-  # TODO(rnephew): Make private when all use cases can use the context manager.
+  # TODO(rnephew): Remove when battery_utils is switched to.
   @decorators.WithTimeoutAndRetriesFromInstance()
   def EnableBatteryUpdates(self, timeout=None, retries=None):
     """ Restarts device charging so that dumpsys no longer collects power data.
 
     Args:
       timeout: timeout in seconds
       retries: number of retries
     """
     def battery_updates_enabled():
       return self.GetCharging() is True
 
     self.RunShellCommand(['dumpsys', 'battery', 'set', 'usb', '1'],
                          check_return=True)
     self.RunShellCommand(['dumpsys', 'battery', 'reset'], check_return=True)
     timeout_retry.WaitFor(battery_updates_enabled, wait_period=1)
 
+  # TODO(rnephew): Remove when battery_utils is switched to.
   @contextlib.contextmanager
   def BatteryMeasurement(self, timeout=None, retries=None):
     """Context manager that enables battery data collection. It makes
     the device appear to stop charging so that dumpsys will start collecting
     power data since last charge. Once the with block is exited, charging is
     resumed and power data since last charge is no longer collected.
 
     Only for devices L and higher.
 
     Example usage:
@@ skipping 69 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)
+
+  def GetClientCache(self, client_name):
+    """Returns client cache."""
+    if client_name not in self._client_caches:
+      self._client_caches[client_name] = {}
+    return self._client_caches[client_name]
+
+  def _ClearCache(self):
+    """Clears all caches."""
+    for client in self._client_caches:
+      self._client_caches[client].clear()
+    self._cache.clear()