[Android] Switch to DeviceUtils versions of Ls, SetJavaAsserts, GetProp, and SetProp.

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=W0613
 
@@ skipping 528 matching lines @@
       CommandFailedError if the file could not be written on the device.
     """
     if as_root:
       if not self.old_interface.CanAccessProtectedFileContents():
         raise device_errors.CommandFailedError(
             'Cannot write to %s with root priveleges.' % device_path)
       self.old_interface.SetProtectedFileContents(device_path, contents)
     else:
       self.old_interface.SetFileContents(device_path, contents)
 
+  @decorators.WithTimeoutAndRetriesFromInstance()
+  def Ls(self, device_path, as_root=False, timeout=None, retries=None):
+    """Lists the contents of a directory on the device.
+
+    Args:
+      device_path: A string containing the path of the directory on the device
+                   to list.
+      as_root: A boolean inidcating whether the ls should be executed with root
+               priveleges.
+      timeout: Same as for |IsOnline|.
+      retries: Same as for |IsOnline|.
+    Returns:
+      The contents of the directory specified by |device_path|.
+    """
+    return self.old_interface.ListPathContents(device_path)
+
+  @decorators.WithTimeoutAndRetriesFromInstance()
+  def SetJavaAsserts(self, enabled, timeout=None, retries=None):
+    """Enables or disables Java asserts.
+
+    Args:
+      enabled: A boolean indicating whether Java asserts should be enabled
+               or disabled.
+      timeout: Same as for |IsOnline|.
+      retries: Same as for |IsOnline|.
+    """
+    self.old_interface.SetJavaAssertsEnabled(enabled)
+
+  @decorators.WithTimeoutAndRetriesFromInstance()
+  def GetProp(self, property_name, timeout=None, retries=None):
+    """Gets a property from the device.
+
+    Args:
+      property_name: A string containing the name of the property to get from
+                     the device.
+      timeout: Same as for |IsOnline|.
+      retries: Same as for |IsOnline|.
+    Returns:
+      The value of the device's |property_name| property.
+    """
+    return self.old_interface.system_properties[property_name]

[tonyg, 2014/07/07 15:22:56]

Really up to you, but I thought it'd be more pythonic to expose the
system_properties dict directly and let users use it like a dict.

[jbudorick, 2014/07/07 16:12:45]

I think I prefer GetProp / SetProp over the dict interface for two reasons:
 1) they mirror the actual adb shell commands
 2) the dict interface seems likely to imply to the user that we aren't hitting
the device

That said, I'm interested in hearing other opinions on this.

[frankf, 2014/07/07 17:29:03]

I agree with John, explicit setter/getter in this case seems more appropriate.

On 2014/07/07 16:12:45, jbudorick wrote:

+
+  @decorators.WithTimeoutAndRetriesFromInstance()
+  def SetProp(self, property_name, value, timeout=None, retries=None):
+    """Sets a property on the device.
+
+    Args:
+      property_name: A string containing the name of the property to set on
+                     the device.
+      value: A string containing the value to set to the property on the
+             device.
+      timeout: Same as for |IsOnline|.
+      retries: Same as for |IsOnline|.
+    """
+    self.old_interface.system_properties[property_name] = value
+
   def __str__(self):
     """Returns the device serial."""
     return self.old_interface.GetDevice()
 
   @staticmethod
   def parallel(devices=None, async=False):
     """Creates a Parallelizer to operate over the provided list of devices.
 
     If |devices| is either |None| or an empty list, the Parallelizer will
     operate over all attached devices.
 
     Args:
       devices: A list of either DeviceUtils instances or objects from
                from which DeviceUtils instances can be constructed. If None,
                all attached devices will be used.
       async: If true, returns a Parallelizer that runs operations
              asynchronously.
     Returns:
       A Parallelizer operating over |devices|.
     """
     if not devices or len(devices) == 0:
       devices = pylib.android_commands.GetAttachedDevices()
     parallelizer_type = (parallelizer.Parallelizer if async
                          else parallelizer.SyncParallelizer)
     return parallelizer_type([
         d if isinstance(d, DeviceUtils) else DeviceUtils(d)
         for d in devices])