def uninstall_app(self, app_name, reboot=False, timeout=None):
"""Uninstalls an app on the device.
:param str app_name: The name of the app to be
uninstalled.
:param bool reboot: Flag indicating that the device should
be rebooted after the app is uninstalled. No reboot occurs
if the app is not installed.
:param timeout: The maximum time in
seconds for any spawned adb process to complete before
throwing an ADBTimeoutError.
This timeout is per adb call. The total time spent
may exceed this value. If it is not specified, the value
set in the ADB constructor is used.
:type timeout: integer or None
:raises: * ADBTimeoutError
* ADBError
"""
if self.is_app_installed(app_name, timeout=timeout):
data = self.command_output(["uninstall", app_name],
timeout=timeout)
if data.find('Success') == -1:
self._logger.debug('uninstall_app failed: %s' % data)
raise ADBError("uninstall failed for %s. Got: %s" %
(app_name, data))
if reboot:
self.reboot(timeout=timeout)
def get_memory_total(self, timeout=None):
"""Returns the total memory available with units.
:param timeout: optional integer specifying the maximum time in
seconds for any spawned adb process to complete before
throwing an ADBTimeoutError.
This timeout is per adb call. The total time spent
may exceed this value. If it is not specified, the value
set in the ADBDevice constructor is used.
:returns: memory total with units.
:raises: * ADBTimeoutError
* ADBError
"""
meminfo = {}
with mozfile.NamedTemporaryFile() as tf:
self.pull('/proc/meminfo', tf.name, timeout=timeout)
try:
with open(tf.name) as tf2:
for line in tf2.read().splitlines():
key, value = line.split(':')
meminfo[key] = value.strip()
except Exception as e:
raise ADBError(
traceback.format_exception_only(type(e), e)[0].strip())
return meminfo['MemTotal']
def launch_application(self,
app_name,
activity_name,
intent,
url=None,
extras=None,
wait=True,
fail_if_running=True,
timeout=None):
"""Launches an Android application
:param app_name: Name of application (e.g. `com.android.chrome`)
:param activity_name: Name of activity to launch (e.g. `.Main`)
:param intent: Intent to launch application with
:param url: URL to open
:param extras: Dictionary of extra arguments for application.
:param wait: If True, wait for application to start before
returning.
:param fail_if_running: Raise an exception if instance of
application is already running.
:param timeout: optional integer specifying the maximum time in
seconds for any spawned adb process to complete before
throwing an ADBTimeoutError.
This timeout is per adb call. The total time spent
may exceed this value. If it is not specified, the value
set in the ADB constructor is used.
:raises: * ADBTimeoutError
* ADBError
"""
# If fail_if_running is True, we throw an exception here. Only one
# instance of an application can be running at once on Android,
# starting a new instance may not be what we want depending on what
# we want to do
if fail_if_running and self.process_exist(app_name, timeout=timeout):
raise ADBError(
"Only one instance of an application may be running "
"at once")
acmd = [ "am", "start" ] + \
["-W" if wait else '', "-n", "%s/%s" % (app_name, activity_name)]
if intent:
acmd.extend(["-a", intent])
if extras:
for (key, val) in extras.iteritems():
if type(val) is int:
extra_type_param = "--ei"
elif type(val) is bool:
extra_type_param = "--ez"
else:
extra_type_param = "--es"
acmd.extend([extra_type_param, str(key), str(val)])
if url:
acmd.extend(["-d", url])
cmd = self._escape_command_line(acmd)
self.shell_output(cmd, timeout=timeout)
def install_app(self, apk_path, timeout=None):
"""Installs an app on the device.
:param str apk_path: The apk file name to be installed.
:param timeout: The maximum time in
seconds for any spawned adb process to complete before
throwing an ADBTimeoutError.
This timeout is per adb call. The total time spent
may exceed this value. If it is not specified, the value
set in the ADB constructor is used.
:type timeout: integer or None
:raises: * ADBTimeoutError
* ADBError
"""
data = self.command_output(["install", apk_path], timeout=timeout)
if data.find('Success') == -1:
raise ADBError("install failed for %s. Got: %s" % (apk_path, data))
def stop_application(self, app_name, timeout=None, root=False):
"""Stops the specified application
For Android 3.0+, we use the "am force-stop" to do this, which
is reliable and does not require root. For earlier versions of
Android, we simply try to manually kill the processes started
by the app repeatedly until none is around any more. This is
less reliable and does require root.
:param str app_name: Name of application (e.g. `com.android.chrome`)
:param timeout: The maximum time in
seconds for any spawned adb process to complete before
throwing an ADBTimeoutError.
This timeout is per adb call. The total time spent
may exceed this value. If it is not specified, the value
set in the ADB constructor is used.
:type timeout: integer or None
:param bool root: Flag specifying if the command should be
executed as root.
:raises: * ADBTimeoutError
* ADBError
"""
version = self.shell_output("getprop ro.build.version.release",
timeout=timeout,
root=root)
if StrictVersion(version) >= StrictVersion('3.0'):
self.shell_output("am force-stop %s" % app_name,
timeout=timeout,
root=root)
else:
num_tries = 0
max_tries = 5
while self.process_exist(app_name, timeout=timeout):
if num_tries > max_tries:
raise ADBError("Couldn't successfully kill %s after %s "
"tries" % (app_name, max_tries))
self.pkill(app_name, timeout=timeout, root=root)
num_tries += 1
# sleep for a short duration to make sure there are no
# additional processes in the process of being launched
# (this is not 100% guaranteed to work since it is inherently
# racey, but it's the best we can do)
time.sleep(1)
def is_app_installed(self, app_name, timeout=None):
"""Returns True if an app is installed on the device.
:param str app_name: The name of the app to be checked.
:param timeout: The maximum time in
seconds for any spawned adb process to complete before
throwing an ADBTimeoutError.
This timeout is per adb call. The total time spent
may exceed this value. If it is not specified, the value
set in the ADB constructor is used.
:type timeout: integer or None
:raises: * ADBTimeoutError
* ADBError
"""
pm_error_string = 'Error: Could not access the Package Manager'
data = self.shell_output("pm list package %s" % app_name, timeout=timeout)
if pm_error_string in data:
raise ADBError(pm_error_string)
if app_name not in data:
return False
return True
def get_battery_percentage(self, timeout=None):
"""Returns the battery charge as a percentage.
:param timeout: optional integer specifying the maximum time in
seconds for any spawned adb process to complete before
throwing an ADBTimeoutError.
This timeout is per adb call. The total time spent
may exceed this value. If it is not specified, the value
set in the ADBDevice constructor is used.
:returns: battery charge as a percentage.
:raises: * ADBTimeoutError
* ADBError
"""
with mozfile.NamedTemporaryFile() as tf:
self.pull('/sys/class/power_supply/battery/capacity',
tf.name,
timeout=timeout)
try:
with open(tf.name) as tf2:
return tf2.read().splitlines()[0]
except Exception as e:
raise ADBError(
traceback.format_exception_only(type(e), e)[0].strip())
def launch_application(self,
app_name,
activity_name,
intent,
url=None,
extras=None,
wait=True,
fail_if_running=True,
timeout=None):
"""Launches an Android application
:param str app_name: Name of application (e.g. `com.android.chrome`)
:param str activity_name: Name of activity to launch (e.g. `.Main`)
:param str intent: Intent to launch application with
:param url: URL to open
:type url: str or None
:param extras: Extra arguments for application.
:type extras: dict or None
:param bool wait: If True, wait for application to start before
returning.
:param bool fail_if_running: Raise an exception if instance of
application is already running.
:param timeout: The maximum time in
seconds for any spawned adb process to complete before
throwing an ADBTimeoutError.
This timeout is per adb call. The total time spent
may exceed this value. If it is not specified, the value
set in the ADB constructor is used.
:type timeout: integer or None
:raises: * ADBTimeoutError
* ADBError
"""
# If fail_if_running is True, we throw an exception here. Only one
# instance of an application can be running at once on Android,
# starting a new instance may not be what we want depending on what
# we want to do
if fail_if_running and self.process_exist(app_name, timeout=timeout):
raise ADBError(
"Only one instance of an application may be running "
"at once")
acmd = ["am", "start"] + \
["-W" if wait else '', "-n", "%s/%s" % (app_name, activity_name)]
if intent:
acmd.extend(["-a", intent])
# Note that isinstance(True, int) and isinstance(False, int)
# is True. This means we must test the type of the value
# against bool prior to testing it against int in order to
# prevent falsely identifying a bool value as an int.
if extras:
for (key, val) in extras.iteritems():
if isinstance(val, bool):
extra_type_param = "--ez"
elif isinstance(val, int):
extra_type_param = "--ei"
else:
extra_type_param = "--es"
acmd.extend([extra_type_param, str(key), str(val)])
if url:
acmd.extend(["-d", url])
cmd = self._escape_command_line(acmd)
self._logger.info('launch_application: %s' % cmd)
self.shell_output(cmd, timeout=timeout)