def SetProperties(device, enable_java_debug, disable_location,
disable_mock_location):
try:
device.EnableRoot()
except device_errors.CommandFailedError as e:
logger.warning(str(e))
if not device.IsUserBuild():
_ConfigureLocalProperties(device, enable_java_debug)
else:
logger.warning('Cannot configure properties in user builds.')
settings.ConfigureContentSettings(device,
settings.DETERMINISTIC_DEVICE_SETTINGS)
if disable_location:
settings.ConfigureContentSettings(device,
settings.DISABLE_LOCATION_SETTINGS)
else:
settings.ConfigureContentSettings(device,
settings.ENABLE_LOCATION_SETTINGS)
if disable_mock_location:
settings.ConfigureContentSettings(
device, settings.DISABLE_MOCK_LOCATION_SETTINGS)
else:
settings.ConfigureContentSettings(
device, settings.ENABLE_MOCK_LOCATION_SETTINGS)
settings.SetLockScreenSettings(device)
# Some device types can momentarily disappear after setting properties.
device.adb.WaitForDevice()
def DisableNetwork(device):
settings.ConfigureContentSettings(
device, settings.NETWORK_DISABLED_SETTINGS)
if device.build_version_sdk >= version_codes.MARSHMALLOW:
# Ensure that NFC is also switched off.
device.RunShellCommand(['svc', 'nfc', 'disable'],
as_root=True, check_return=True)
presentation.device.RunShellCommand(['restorecon', adb_wrapper.ADB_KEYS_FILE],
as_root=True, check_return=True)
def SetProperties(presentation.device, enable_java_debug, disable_location,
disable_mock_location):
try:
presentation.device.EnableRoot()
except device_errors.CommandFailedError as e:
logger.warning(str(e))
if not presentation.device.IsUserBuild():
_ConfigureLocalProperties(presentation.device, enable_java_debug)
else:
logger.warning('Cannot configure properties in user builds.')
settings.ConfigureContentSettings(
presentation.device, settings.DETERMINISTIC_DEVICE_SETTINGS)
if disable_location:
settings.ConfigureContentSettings(
presentation.device, settings.DISABLE_LOCATION_SETTINGS)
else:
settings.ConfigureContentSettings(
presentation.device, settings.ENABLE_LOCATION_SETTINGS)
if disable_mock_location:
settings.ConfigureContentSettings(
presentation.device, settings.DISABLE_MOCK_LOCATION_SETTINGS)
else:
settings.ConfigureContentSettings(
presentation.device, settings.ENABLE_MOCK_LOCATION_SETTINGS)
settings.SetLockScreenSettings(presentation.device)
def Create(self,
force=False,
snapshot=False,
keep=False,
additional_apks=None,
privileged_apk_tuples=None,
cipd_json_output=None,
dry_run=False):
"""Create an instance of the AVD CIPD package.
This method:
- installs the requisite system image
- creates the AVD
- modifies the AVD's ini files to support running chromium tests
in chromium infrastructure
- optionally starts, installs additional apks and/or privileged apks, and
stops the AVD for snapshotting (default no)
- By default creates and uploads an instance of the AVD CIPD package
(can be turned off by dry_run flag).
- optionally deletes the AVD (default yes)
Args:
force: bool indicating whether to force create the AVD.
snapshot: bool indicating whether to snapshot the AVD before creating
the CIPD package.
keep: bool indicating whether to keep the AVD after creating
the CIPD package.
additional_apks: a list of strings contains the paths to the APKs. These
APKs will be installed after AVD is started.
privileged_apk_tuples: a list of (apk_path, device_partition) tuples where
|apk_path| is a string containing the path to the APK, and
|device_partition| is a string indicating the system image partition on
device that contains "priv-app" directory, e.g. "/system", "/product".
cipd_json_output: string path to pass to `cipd create` via -json-output.
dry_run: When set to True, it will skip the CIPD package creation
after creating the AVD.
"""
logging.info('Installing required packages.')
self._InstallCipdPackages(packages=[
self._config.emulator_package,
self._config.system_image_package,
])
android_avd_home = self._avd_home
if not os.path.exists(android_avd_home):
os.makedirs(android_avd_home)
avd_manager = _AvdManagerAgent(avd_home=android_avd_home,
sdk_root=self._emulator_sdk_root)
logging.info('Creating AVD.')
avd_manager.Create(avd_name=self._config.avd_name,
system_image=self._config.system_image_name,
force=force)
try:
logging.info('Modifying AVD configuration.')
# Clear out any previous configuration or state from this AVD.
root_ini = os.path.join(android_avd_home,
'%s.ini' % self._config.avd_name)
features_ini = os.path.join(self._emulator_home,
'advancedFeatures.ini')
avd_dir = self._avd_dir
with ini.update_ini_file(root_ini) as root_ini_contents:
root_ini_contents[
'path.rel'] = 'avd/%s.avd' % self._config.avd_name
with ini.update_ini_file(features_ini) as features_ini_contents:
# features_ini file will not be refreshed by avdmanager during
# creation. So explicitly clear its content to exclude any leftover
# from previous creation.
features_ini_contents.clear()
features_ini_contents.update(
self.avd_settings.advanced_features)
with ini.update_ini_file(
self._config_ini_path) as config_ini_contents:
height = self.avd_settings.screen.height or _DEFAULT_SCREEN_HEIGHT
width = self.avd_settings.screen.width or _DEFAULT_SCREEN_WIDTH
density = self.avd_settings.screen.density or _DEFAULT_SCREEN_DENSITY
config_ini_contents.update({
'disk.dataPartition.size': '4G',
'hw.keyboard': 'yes',
'hw.lcd.density': density,
'hw.lcd.height': height,
'hw.lcd.width': width,
'hw.mainKeys': 'no', # Show nav buttons on screen
})
if self.avd_settings.ram_size:
config_ini_contents[
'hw.ramSize'] = self.avd_settings.ram_size
config_ini_contents['hw.sdCard'] = 'yes'
if self.avd_settings.sdcard.size:
sdcard_path = os.path.join(avd_dir, _SDCARD_NAME)
mksdcard_path = os.path.join(
os.path.dirname(self._emulator_path), 'mksdcard')
cmd_helper.RunCmd([
mksdcard_path,
self.avd_settings.sdcard.size,
sdcard_path,
])
config_ini_contents['hw.sdCard.path'] = sdcard_path
# Start & stop the AVD.
self._Initialize()
instance = _AvdInstance(self._emulator_path, self._emulator_home,
self._config)
# Enable debug for snapshot when it is set to True
debug_tags = 'init,snapshot' if snapshot else None
# Installing privileged apks requires modifying the system image.
writable_system = bool(privileged_apk_tuples)
instance.Start(ensure_system_settings=False,
read_only=False,
writable_system=writable_system,
gpu_mode=_DEFAULT_GPU_MODE,
debug_tags=debug_tags)
assert instance.device is not None, '`instance.device` not initialized.'
# Android devices with full-disk encryption are encrypted on first boot,
# and then get decrypted to continue the boot process (See details in
# https://bit.ly/3agmjcM).
# Wait for this step to complete since it can take a while for old OSs
# like M, otherwise the avd may have "Encryption Unsuccessful" error.
instance.device.WaitUntilFullyBooted(decrypt=True,
timeout=180,
retries=0)
if additional_apks:
for additional_apk in additional_apks:
instance.device.Install(additional_apk,
allow_downgrade=True,
reinstall=True)
if privileged_apk_tuples:
system_app.InstallPrivilegedApps(instance.device,
privileged_apk_tuples)
# Always disable the network to prevent built-in system apps from
# updating themselves, which could take over package manager and
# cause shell command timeout.
logging.info('Disabling the network.')
settings.ConfigureContentSettings(
instance.device, settings.NETWORK_DISABLED_SETTINGS)
if snapshot:
# Reboot so that changes like disabling network can take effect.
instance.device.Reboot()
instance.SaveSnapshot()
instance.Stop()
# The multiinstance lock file seems to interfere with the emulator's
# operation in some circumstances (beyond the obvious -read-only ones),
# and there seems to be no mechanism by which it gets closed or deleted.
# See https://bit.ly/2pWQTH7 for context.
multiInstanceLockFile = os.path.join(avd_dir, 'multiinstance.lock')
if os.path.exists(multiInstanceLockFile):
os.unlink(multiInstanceLockFile)
package_def_content = {
'package':
self._config.avd_package.package_name,
'root':
self._emulator_home,
'install_mode':
'copy',
'data': [{
'dir': os.path.relpath(avd_dir, self._emulator_home)
}, {
'file': os.path.relpath(root_ini, self._emulator_home)
}, {
'file':
os.path.relpath(features_ini, self._emulator_home)
}],
}
logging.info('Creating AVD CIPD package.')
logging.debug('ensure file content: %s',
json.dumps(package_def_content, indent=2))
with tempfile_ext.TemporaryFileName(
suffix='.json') as package_def_path:
with open(package_def_path, 'w') as package_def_file:
json.dump(package_def_content, package_def_file)
logging.info(' %s', self._config.avd_package.package_name)
cipd_create_cmd = [
'cipd',
'create',
'-pkg-def',
package_def_path,
'-tag',
'emulator_version:%s' %
self._config.emulator_package.version,
'-tag',
'system_image_version:%s' %
self._config.system_image_package.version,
]
if cipd_json_output:
cipd_create_cmd.extend([
'-json-output',
cipd_json_output,
])
logging.info('running %r%s', cipd_create_cmd,
' (dry_run)' if dry_run else '')
if not dry_run:
try:
for line in cmd_helper.IterCmdOutputLines(
cipd_create_cmd):
logging.info(' %s', line)
except subprocess.CalledProcessError as e:
# avd.py is executed with python2.
# pylint: disable=W0707
raise AvdException('CIPD package creation failed: %s' %
str(e),
command=cipd_create_cmd)
finally:
if not keep:
logging.info('Deleting AVD.')
avd_manager.Delete(avd_name=self._config.avd_name)
