def FinishProvisioning(device, options):
# The lockscreen can't be disabled on user builds, so send a keyevent
# to unlock it.
if device.IsUserBuild():
device.SendKeyEvent(keyevent.KEYCODE_MENU)
if options.min_battery_level is not None:
try:
battery = battery_utils.BatteryUtils(device)
battery.ChargeDeviceToLevel(options.min_battery_level)
except device_errors.CommandFailedError:
logging.exception('Unable to charge device to specified level.')
if options.max_battery_temp is not None:
try:
battery = battery_utils.BatteryUtils(device)
battery.LetBatteryCoolToTemperature(options.max_battery_temp)
except device_errors.CommandFailedError:
logging.exception('Unable to let battery cool to specified temperature.')
def _set_and_verify_date():
if device.build_version_sdk >= version_codes.MARSHMALLOW:
date_format = '%m%d%H%M%Y.%S'
set_date_command = ['date']
else:
date_format = '%Y%m%d.%H%M%S'
set_date_command = ['date', '-s']
strgmtime = time.strftime(date_format, time.gmtime())
set_date_command.append(strgmtime)
device.RunShellCommand(set_date_command, as_root=True, check_return=True)
device_time = device.RunShellCommand(
['date', '+"%Y%m%d.%H%M%S"'], as_root=True,
single_line=True).replace('"', '')
device_time = datetime.datetime.strptime(device_time, "%Y%m%d.%H%M%S")
correct_time = datetime.datetime.strptime(strgmtime, date_format)
tdelta = (correct_time - device_time).seconds
if tdelta <= 1:
logging.info('Date/time successfully set on %s', device)
return True
else:
logging.error('Date mismatch. Device: %s Correct: %s',
device_time.isoformat(), correct_time.isoformat())
return False
# Sometimes the date is not set correctly on the devices. Retry on failure.
if device.IsUserBuild():
# TODO(bpastene): Figure out how to set the date & time on user builds.
pass
else:
if not timeout_retry.WaitFor(
_set_and_verify_date, wait_period=1, max_tries=2):
raise device_errors.CommandFailedError(
'Failed to set date & time.', device_serial=str(device))
props = device.RunShellCommand('getprop', check_return=True)
for prop in props:
logging.info(' %s', prop)
if options.auto_reconnect:
_PushAndLaunchAdbReboot(device, options.target)
def WaitForCharge(device, min_battery_level):
battery = battery_utils.BatteryUtils(device)
try:
battery.ChargeDeviceToLevel(min_battery_level)
except device_errors.DeviceChargingError:
device.Reboot()
battery.ChargeDeviceToLevel(min_battery_level)
def StartAgentTracing(self, options, _, timeout=None):
"""Starts tracing.
Args:
options: Tracing options.
Raises:
RuntimeError: If trace already in progress.
"""
if options.update_map or not path.isfile(options.serial_map):
battor_device_mapping.GenerateSerialMapFile(
options.serial_map, options.hub_types)
self._battor_wrapper = battor_wrapper.BattorWrapper(
target_platform=options.target,
android_device=options.device_serial_number,
battor_path=options.battor_path,
battor_map_file=options.serial_map)
dev_utils = device_utils.DeviceUtils(options.device_serial_number)
self._battery_utils = battery_utils.BatteryUtils(dev_utils)
self._battery_utils.SetCharging(False)
atexit.register(_reenable_charging_if_needed, self._battery_utils)
self._battor_wrapper.StartShell()
self._battor_wrapper.StartTracing()
return True
def WaitForBatteryTemperature(device, max_battery_temp):
try:
battery = battery_utils.BatteryUtils(device)
battery.LetBatteryCoolToTemperature(max_battery_temp)
except device_errors.CommandFailedError:
logger.exception(
'Unable to let battery cool to specified temperature.')
def setUp(self):
self.adb = device_utils_test._AdbWrapperMock('0123456789abcdef')
self.device = device_utils.DeviceUtils(
self.adb, default_timeout=10, default_retries=0)
self.watchMethodCalls(self.call.adb, ignore=['GetDeviceSerial'])
self.battery = battery_utils.BatteryUtils(
self.device, default_timeout=10, default_retries=0)
def __init__(self, device):
assert device, (
'AndroidPlatformBackend can only be initialized from remote device')
super(AndroidPlatformBackend, self).__init__(device)
self._device = device_utils.DeviceUtils(device.device_id)
# Trying to root the device, if possible.
if not self._device.HasRoot():
try:
self._device.EnableRoot()
except device_errors.CommandFailedError:
logging.warning('Unable to root %s', str(self._device))
self._can_elevate_privilege = (
self._device.HasRoot() or self._device.NeedsSU())
assert self._can_elevate_privilege, (
'Android device must have root access to run Telemetry')
self._battery = battery_utils.BatteryUtils(self._device)
self._enable_performance_mode = device.enable_performance_mode
self._surface_stats_collector = None
self._perf_tests_setup = perf_control.PerfControl(self._device)
self._thermal_throttle = thermal_throttle.ThermalThrottle(self._device)
self._raw_display_frame_rate_measurements = []
self._device_copy_script = None
self._power_monitor = (
android_power_monitor_controller.AndroidPowerMonitorController([
android_temperature_monitor.AndroidTemperatureMonitor(self._device),
android_dumpsys_power_monitor.DumpsysPowerMonitor(
self._battery, self),
sysfs_power_monitor.SysfsPowerMonitor(self, standalone=True),
android_fuelgauge_power_monitor.FuelGaugePowerMonitor(
self._battery),
], self._battery))
self._video_recorder = None
self._system_ui = None
_FixPossibleAdbInstability()
def __init__(
self, env, test_instance, device, index, tests, retries=3, timeout=None):
super(DeviceTestShard, self).__init__(
env, test_instance, tests, retries, timeout)
self._battery = battery_utils.BatteryUtils(device) if device else None
self._device = device
self._index = index
def __init__(self, device, require_root):
assert device, (
'AndroidPlatformBackend can only be initialized from remote device')
super(AndroidPlatformBackend, self).__init__(device)
self._device = device_utils.DeviceUtils(device.device_id)
self._require_root = require_root
if self._require_root:
# Trying to root the device, if possible.
if not self._device.HasRoot():
try:
self._device.EnableRoot()
except device_errors.CommandFailedError:
logging.warning('Unable to root %s', str(self._device))
self._can_elevate_privilege = (
self._device.HasRoot() or self._device.NeedsSU())
assert self._can_elevate_privilege, (
'Android device must have root access to run Telemetry')
self._enable_performance_mode = device.enable_performance_mode
else:
self._enable_performance_mode = False
self._battery = battery_utils.BatteryUtils(self._device)
self._surface_stats_collector = None
self._perf_tests_setup = perf_control.PerfControl(self._device)
self._thermal_throttle = thermal_throttle.ThermalThrottle(self._device)
self._raw_display_frame_rate_measurements = []
self._device_copy_script = None
self._system_ui = None
_FixPossibleAdbInstability()
def __init__(self, device, require_root):
assert device, (
'AndroidPlatformBackend can only be initialized from remote device'
)
super(AndroidPlatformBackend, self).__init__(device)
self._device = device_utils.DeviceUtils(device.device_id)
self._can_elevate_privilege = False
self._require_root = require_root
if self._require_root:
# Trying to root the device, if possible.
if not self._device.HasRoot():
try:
self._device.EnableRoot()
except device_errors.CommandFailedError:
logging.warning('Unable to root %s', str(self._device))
self._can_elevate_privilege = (self._device.HasRoot()
or self._device.NeedsSU())
assert self._can_elevate_privilege, (
'Android device must have root access to run Telemetry')
self._battery = battery_utils.BatteryUtils(self._device)
self._surface_stats_collector = None
self._perf_tests_setup = perf_control.PerfControl(self._device)
self._thermal_throttle = thermal_throttle.ThermalThrottle(self._device)
self._raw_display_frame_rate_measurements = []
self._device_copy_script = None
self._system_ui = None
self._device_host_clock_offset = None
self._video_recorder = None
# TODO(https://crbug.com/1026296): Remove this once --chromium-output-dir
# has a default value we can use.
self._build_dir = util.GetUsedBuildDirectory()
_FixPossibleAdbInstability()
def StartAgentTracing(self, config, timeout=None):
"""Starts tracing.
Args:
config: Tracing config.
Raises:
RuntimeError: If trace already in progress.
AssertionError: If There is no BattOr path given and more
than one BattOr is attached.
"""
battor_path = self._FindBattOrPath(config)
self._battor_wrapper = battor_wrapper.BattOrWrapper(
target_platform=config.target,
android_device=config.device_serial_number,
battor_path=battor_path,
battor_map_file=config.serial_map)
dev_utils = device_utils.DeviceUtils(config.device_serial_number)
self._battery_utils = battery_utils.BatteryUtils(dev_utils)
self._battery_utils.SetCharging(False)
atexit.register(_reenable_charging_if_needed, self._battery_utils)
self._battor_wrapper.StartShell()
self._battor_wrapper.StartTracing()
return True
def __init__(self, device, finder_options):
assert device, (
'AndroidPlatformBackend can only be initialized from remote device'
)
super(AndroidPlatformBackend, self).__init__(device)
self._device = device_utils.DeviceUtils(device.device_id)
installed_prebuilt_tools = _SetupPrebuiltTools(self._device)
if not installed_prebuilt_tools:
logging.error(
'%s detected, however prebuilt android tools could not '
'be used. To run on Android you must build them first:\n'
' $ ninja -C out/Release android_tools' % device.name)
raise exceptions.PlatformError()
# Trying to root the device, if possible.
if not self._device.HasRoot():
try:
self._device.EnableRoot()
except device_errors.CommandFailedError:
logging.warning('Unable to root %s', str(self._device))
self._battery = battery_utils.BatteryUtils(self._device)
self._enable_performance_mode = device.enable_performance_mode
self._surface_stats_collector = None
self._perf_tests_setup = perf_control.PerfControl(self._device)
self._thermal_throttle = thermal_throttle.ThermalThrottle(self._device)
self._raw_display_frame_rate_measurements = []
try:
self._can_access_protected_file_contents = (self._device.HasRoot()
or
self._device.NeedsSU())
except Exception:
logging.exception('New exception caused by DeviceUtils conversion')
raise
self._device_copy_script = None
self._power_monitor = (
android_power_monitor_controller.AndroidPowerMonitorController([
android_temperature_monitor.AndroidTemperatureMonitor(
self._device),
monsoon_power_monitor.MonsoonPowerMonitor(self._device, self),
android_dumpsys_power_monitor.DumpsysPowerMonitor(
self._battery, self),
sysfs_power_monitor.SysfsPowerMonitor(self, standalone=True),
android_fuelgauge_power_monitor.FuelGaugePowerMonitor(
self._battery, self),
], self._battery))
self._video_recorder = None
self._installed_applications = None
self._wpr_ca_cert_path = None
self._device_cert_util = None
self._is_test_ca_installed = False
self._use_rndis_forwarder = (
finder_options.android_rndis
or finder_options.browser_options.netsim
or platform.GetHostPlatform().GetOSName() != 'linux')
_FixPossibleAdbInstability()
def __init__(self, platform_backend):
super(BattOrTracingAgent, self).__init__(platform_backend)
self._platform_backend = platform_backend
android_device = (platform_backend.device if
platform_backend.GetOSName() == 'android' else None)
self._battery = (battery_utils.BatteryUtils(platform_backend.device) if
platform_backend.GetOSName() == 'android' else None)
self._battor = battor_wrapper.BattorWrapper(
platform_backend.GetOSName(), android_device=android_device)
def _BatteryStatus(device, denylist):
battery_info = {}
try:
battery = battery_utils.BatteryUtils(device)
battery_info = battery.GetBatteryInfo(timeout=5)
battery_level = int(battery_info.get('level', 100))
if battery_level < 15:
logger.error('Critically low battery level (%d)', battery_level)
battery = battery_utils.BatteryUtils(device)
if not battery.GetCharging():
battery.SetCharging(True)
if denylist:
denylist.Extend([device.adb.GetDeviceSerial()], reason='low_battery')
except (device_errors.CommandFailedError,
device_errors.DeviceUnreachableError):
logger.exception('Failed to get battery information for %s', str(device))
return battery_info
def _BatteryStatus(device, blacklist):
battery_info = {}
try:
battery = battery_utils.BatteryUtils(device)
battery_info = battery.GetBatteryInfo(timeout=5)
battery_level = int(battery_info.get('level', 100))
if battery_level < 15:
logging.error('Critically low battery level (%d)', battery_level)
battery = battery_utils.BatteryUtils(device)
if not battery.GetCharging():
battery.SetCharging(True)
if blacklist:
blacklist.Extend([device.adb.GetDeviceSerial()])
except device_errors.CommandFailedError:
logging.exception('Failed to get battery information for %s',
str(device))
return battery_info
def __init__(self, platform_backend):
super(BattOrTracingAgent, self).__init__(platform_backend)
self._platform_backend = platform_backend
android_device = (platform_backend.device if
platform_backend.GetOSName() == 'android' else None)
self._battery = (battery_utils.BatteryUtils(platform_backend.device) if
platform_backend.GetOSName() == 'android' else None)
self._battor = battor_wrapper.BattorWrapper(
platform_backend.GetOSName(),
android_device=android_device,
serial_log_bucket=cloud_storage.TELEMETRY_OUTPUT)
def usable_devices(self, executive):
if self._usable_devices:
return self._usable_devices
if self._default_devices:
self._usable_devices = [
device_utils.DeviceUtils(d)
for d in self._default_devices]
return self._usable_devices
devices = device_utils.DeviceUtils.HealthyDevices()
self._usable_devices = [
d for d in devices
if (battery_utils.BatteryUtils(d).GetBatteryInfo().get('level', 0)
>= AndroidDevices.MINIMUM_BATTERY_PERCENTAGE
and d.IsScreenOn())]
return self._usable_devices
def testComposition(self, _):
class P1(power_monitor.PowerMonitor):
def StartMonitoringPower(self, browser):
raise NotImplementedError()
def StopMonitoringPower(self):
raise NotImplementedError()
class P2(power_monitor.PowerMonitor):
def __init__(self, value):
super(P2, self).__init__()
self._value = {'P2': value}
def CanMonitorPower(self):
return True
def StartMonitoringPower(self, browser):
pass
def StopMonitoringPower(self):
return self._value
class P3(power_monitor.PowerMonitor):
def __init__(self, value):
super(P3, self).__init__()
self._value = {'P3': value}
def CanMonitorPower(self):
return True
def StartMonitoringPower(self, browser):
pass
def StopMonitoringPower(self):
return self._value
battery = battery_utils.BatteryUtils(None)
controller = power_monitor_controller.PowerMonitorController(
[P1(), P2(1), P3(2)], battery)
self.assertEqual(controller.CanMonitorPower(), True)
controller.StartMonitoringPower(None)
controller_returns = controller.StopMonitoringPower()
self.assertEqual(controller_returns['P2'], 1)
self.assertEqual(controller_returns['P3'], 2)
def __init__(self, test_options, device, shard_index, max_shard, tests,
flaky_tests):
"""A TestRunner instance runs a perf test on a single device.
Args:
test_options: A PerfOptions object.
device: Device to run the tests.
shard_index: the index of this device.
max_shards: the maximum shard index.
tests: a dict mapping test_name to command.
flaky_tests: a list of flaky test_name.
"""
super(TestRunner, self).__init__(device, None)
self._options = test_options
self._shard_index = shard_index
self._max_shard = max_shard
self._tests = tests
self._flaky_tests = flaky_tests
self._output_dir = None
self._device_battery = battery_utils.BatteryUtils(self.device)
def get_device_status_unsafe(device):
"""Polls the given device for various info.
Returns: A dict of the following format:
{
'battery': {
'level': 100,
'temperature': 123
},
'build': {
'build.id': 'ABC12D',
'product.device': 'chickenofthesea'
},
'imei': 123456789,
'mem': {
'avail': 1000000,
'total': 1234567,
},
'processes': 123,
'state': 'good',
'temp': {
'some_sensor': 30
},
'uptime': 1234.56,
}
"""
status = collections.defaultdict(dict)
# Battery
battery = battery_utils.BatteryUtils(device)
battery_info = battery.GetBatteryInfo()
try:
level = int(battery_info.get('level'))
except (KeyError, TypeError, ValueError):
level = None
if level and level >= 0 and level <= 100:
status['battery']['level'] = level
try:
temperature = int(battery_info.get('temperature'))
except (KeyError, TypeError, ValueError):
temperature = None
if temperature:
status['battery']['temperature'] = temperature
# Build
status['build']['build.id'] = device.build_id
status['build']['product.device'] = device.build_product
# Memory
mem_info = ''
try:
mem_info = device.ReadFile('/proc/meminfo')
except device_errors.AdbShellCommandFailedError:
logging.exception('Unable to read /proc/meminfo')
for line in mem_info.splitlines():
match = MEM_INFO_REGEX.match(line)
if match:
try:
value = int(match.group(1))
except ValueError:
continue
key = line.split(':')[0].strip()
if 'MemTotal' == key:
status['mem']['total'] = value
elif 'MemFree' == key:
status['mem']['free'] = value
# Process
try:
status['processes'] = len(device.ListProcesses())
except device_errors.AdbCommandFailedError:
logging.exception('Unable to count process list.')
# CPU Temps
# Find a thermal sensor that matches one in CPU_TEMP_SENSORS and read its
# temperature.
files = []
try:
files = device.RunShellCommand(
'grep -lE "%s" /sys/class/thermal/thermal_zone*/type' % '|'.join(
CPU_TEMP_SENSORS), shell=True, check_return=True)
except device_errors.AdbShellCommandFailedError:
logging.exception('Unable to list thermal sensors.')
for f in files:
try:
sensor_name = device.ReadFile(f).strip()
temp = float(device.ReadFile(f[:-4] + 'temp').strip()) # s/type^/temp
status['temp'][sensor_name] = temp
except (device_errors.AdbShellCommandFailedError, ValueError):
logging.exception('Unable to read thermal sensor %s', f)
# Uptime
try:
uptimes = device.ReadFile('/proc/uptime').split()
status['uptime'] = float(uptimes[0]) # Take the first field (actual uptime)
except (device_errors.AdbShellCommandFailedError, ValueError):
logging.exception('Unable to read /proc/uptime')
try:
status['imei'] = device.GetIMEI()
except device_errors.CommandFailedError:
logging.exception('Unable to read IMEI')
status['imei'] = 'unknown'
status['state'] = 'available'
return status
def testReenableCharingIfNeeded(self, mock_battery):
battery = battery_utils.BatteryUtils(None)
battery.GetCharging.return_value = False
power_monitor_controller._ReenableChargingIfNeeded(battery)
def testInitWithDeviceUtil(self):
serial = '0fedcba987654321'
d = device_utils.DeviceUtils(serial)
b = battery_utils.BatteryUtils(d)
self.assertEqual(d, b._device)
def FinishProvisioning(device, options):
# The lockscreen can't be disabled on user builds, so send a keyevent
# to unlock it.
if device.IsUserBuild():
device.SendKeyEvent(keyevent.KEYCODE_MENU)
if options.min_battery_level is not None:
battery = battery_utils.BatteryUtils(device)
try:
battery.ChargeDeviceToLevel(options.min_battery_level)
except device_errors.DeviceChargingError:
device.Reboot()
battery.ChargeDeviceToLevel(options.min_battery_level)
if options.max_battery_temp is not None:
try:
battery = battery_utils.BatteryUtils(device)
battery.LetBatteryCoolToTemperature(options.max_battery_temp)
except device_errors.CommandFailedError:
logging.exception('Unable to let battery cool to specified temperature.')
def _set_and_verify_date():
if device.build_version_sdk >= version_codes.MARSHMALLOW:
date_format = '%m%d%H%M%Y.%S'
set_date_command = ['date', '-u']
get_date_command = ['date', '-u']
else:
date_format = '%Y%m%d.%H%M%S'
set_date_command = ['date', '-s']
get_date_command = ['date']
# TODO(jbudorick): This is wrong on pre-M devices -- get/set are
# dealing in local time, but we're setting based on GMT.
strgmtime = time.strftime(date_format, time.gmtime())
set_date_command.append(strgmtime)
device.RunShellCommand(set_date_command, as_root=True, check_return=True)
get_date_command.append('+"%Y%m%d.%H%M%S"')
device_time = device.RunShellCommand(
get_date_command, as_root=True, single_line=True).replace('"', '')
device_time = datetime.datetime.strptime(device_time, "%Y%m%d.%H%M%S")
correct_time = datetime.datetime.strptime(strgmtime, date_format)
tdelta = (correct_time - device_time).seconds
if tdelta <= 1:
logging.info('Date/time successfully set on %s', device)
return True
else:
logging.error('Date mismatch. Device: %s Correct: %s',
device_time.isoformat(), correct_time.isoformat())
return False
if options.disable_selinux:
device.RunShellCommand("su -c setenforce 0", as_root=True)
if options.force_battery_status:
device.RunShellCommand("dumpsys battery set status 5", as_root=True)
device.RunShellCommand("dumpsys battery set level 100", as_root=True)
if options.disable_predictive_keyboard:
DisablePredictiveKeyboard(device)
# Sometimes the date is not set correctly on the devices. Retry on failure.
if device.IsUserBuild():
# TODO(bpastene): Figure out how to set the date & time on user builds.
pass
else:
# FIXME: Some samsung devices can not set the date and time. so we skip this.
if False and not timeout_retry.WaitFor(_set_and_verify_date, wait_period=1,
max_tries=2):
raise device_errors.CommandFailedError(
'Failed to set date & time.', device_serial=str(device))
props = device.RunShellCommand('getprop', check_return=True)
for prop in props:
logging.info(' %s', prop)
if options.auto_reconnect:
_PushAndLaunchAdbReboot(device, options.target)
def testInitWithMissing_fails(self):
with self.assertRaises(TypeError):
battery_utils.BatteryUtils(None)
with self.assertRaises(TypeError):
battery_utils.BatteryUtils('')
presentation.device.RunShellCommand(
['chmod', '644', presentation.device.LOCAL_PROPERTIES_PATH],
as_root=True, check_return=True)
except device_errors.CommandFailedError:
logger.exception('Failed to configure local properties.')
def FinishProvisioning(presentation.device):
# The lockscreen can't be disabled on user builds, so send a keyevent
# to unlock it.
if presentation.device.IsUserBuild():
presentation.device.SendKeyEvent(keyevent.KEYCODE_MENU)
def WaitForCharge(presentation.device, min_battery_level):
battery = battery_utils.BatteryUtils(presentation.device)
try:
battery.ChargeDeviceToLevel(min_battery_level)
except device_errors.DeviceChargingError:
presentation.device.Reboot()
battery.ChargeDeviceToLevel(min_battery_level)
def WaitForTemperature(presentation.device, max_battery_temp):
try:
battery = battery_utils.BatteryUtils(presentation.device)
battery.LetBatteryCoolToTemperature(max_battery_temp)
except device_errors.CommandFailedError:
logger.exception('Unable to let battery cool to specified temperature.')