def Start(self, read_only=True, snapshot_save=False, window=False):
"""Starts the emulator running an instance of the given AVD."""
with tempfile_ext.TemporaryFileName() as socket_path, (
contextlib.closing(socket.socket(socket.AF_UNIX))) as sock:
sock.bind(socket_path)
emulator_cmd = [
self._emulator_path,
'-avd',
self._avd_name,
'-report-console',
'unix:%s' % socket_path,
]
if read_only:
emulator_cmd.append('-read-only')
if not snapshot_save:
emulator_cmd.append('-no-snapshot-save')
emulator_env = {}
if self._emulator_home:
emulator_env['ANDROID_EMULATOR_HOME'] = self._emulator_home
if window:
if 'DISPLAY' in os.environ:
emulator_env['DISPLAY'] = os.environ.get('DISPLAY')
else:
raise AvdException(
'Emulator failed to start: DISPLAY not defined')
else:
emulator_cmd.append('-no-window')
sock.listen(1)
logging.info('Starting emulator.')
# TODO(jbudorick): Add support for logging emulator stdout & stderr at
# higher logging levels.
self._sink = open('/dev/null', 'w')
self._emulator_proc = cmd_helper.Popen(emulator_cmd,
stdout=self._sink,
stderr=self._sink,
env=emulator_env)
# Waits for the emulator to report its serial as requested via
# -report-console. See http://bit.ly/2lK3L18 for more.
def listen_for_serial(s):
logging.info('Waiting for connection from emulator.')
with contextlib.closing(s.accept()[0]) as conn:
val = conn.recv(1024)
return 'emulator-%d' % int(val)
try:
self._emulator_serial = timeout_retry.Run(listen_for_serial,
timeout=30,
retries=0,
args=[sock])
logging.info('%s started', self._emulator_serial)
except Exception as e:
self.Stop()
raise AvdException('Emulator failed to start: %s' % str(e))
def Start(self):
"""Start recording video."""
self._recorder_stdout = tempfile.mkstemp()[1]
self._recorder = cmd_helper.Popen(self._args,
stdout=open(self._recorder_stdout,
'w'))
if not self._device.GetPids('screenrecord'):
raise RuntimeError(
'Recording failed. Is your device running Android '
'KitKat or later?')
def _StartInstance(self):
"""Starts an AVD instance.
Returns:
A (Popen, str) 2-tuple that includes the process and serial.
"""
# Start up the AVD.
with tempfile_ext.TemporaryFileName() as socket_path, (
contextlib.closing(socket.socket(socket.AF_UNIX))) as sock:
sock.bind(socket_path)
emulator_cmd = [
self._emulator_path,
'-avd',
self._avd_name,
'-report-console',
'unix:%s' % socket_path,
'-read-only',
'-no-window',
]
emulator_env = {}
if self._emulator_home:
emulator_env['ANDROID_EMULATOR_HOME'] = self._emulator_home
sock.listen(1)
emulator_proc = cmd_helper.Popen(emulator_cmd, env=emulator_env)
def listen_for_serial(s):
logging.info('Waiting for connection from emulator.')
with contextlib.closing(s.accept()[0]) as conn:
val = conn.recv(1024)
return 'emulator-%d' % int(val)
try:
emulator_serial = timeout_retry.Run(listen_for_serial,
timeout=30,
retries=0,
args=[sock])
except Exception:
emulator_proc.terminate()
raise
return (emulator_proc, emulator_serial)
def Create(self, avd_name, system_image, force=False):
"""Call `avdmanager create`.
Args:
avd_name: name of the AVD to create.
system_image: system image to use for the AVD.
force: whether to force creation, overwriting any existing
AVD with the same name.
"""
create_cmd = [
_DEFAULT_AVDMANAGER_PATH,
'-v',
'create',
'avd',
'-n',
avd_name,
'-k',
system_image,
]
if force:
create_cmd += ['--force']
create_proc = cmd_helper.Popen(
create_cmd,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
env=self._env)
output, error = create_proc.communicate(input='\n')
if create_proc.returncode != 0:
raise AvdException(
'AVD creation failed',
command=create_cmd,
stdout=output,
stderr=error)
for line in output.splitlines():
logging.info(' %s', line)
def Start(self,
ensure_system_settings=True,
read_only=True,
window=False,
writable_system=False,
gpu_mode=_DEFAULT_GPU_MODE,
wipe_data=False,
debug_tags=None):
"""Starts the emulator running an instance of the given AVD.
Note when ensure_system_settings is True, the program will wait until the
emulator is fully booted, and then update system settings.
"""
is_slow_start = False
# Force to load system snapshot if detected.
if self.HasSystemSnapshot():
if not writable_system:
logging.info(
'System snapshot found. Set "writable_system=True" '
'to load it properly.')
writable_system = True
if read_only:
logging.info('System snapshot found. Set "read_only=False" '
'to load it properly.')
read_only = False
elif writable_system:
is_slow_start = True
logging.warning(
'Emulator will be slow to start, as '
'"writable_system=True" but system snapshot not found.')
self._writable_system = writable_system
with tempfile_ext.TemporaryFileName() as socket_path, (
contextlib.closing(socket.socket(socket.AF_UNIX))) as sock:
sock.bind(socket_path)
emulator_cmd = [
self._emulator_path,
'-avd',
self._avd_name,
'-report-console',
'unix:%s' % socket_path,
'-no-boot-anim',
# Explicitly prevent emulator from auto-saving to snapshot on exit.
'-no-snapshot-save',
# Explicitly set the snapshot name for auto-load
'-snapshot',
self.GetSnapshotName(),
]
if wipe_data:
emulator_cmd.append('-wipe-data')
if read_only:
emulator_cmd.append('-read-only')
if writable_system:
emulator_cmd.append('-writable-system')
# Note when "--gpu-mode" is set to "host":
# * It needs a valid DISPLAY env, even if "--emulator-window" is false.
# Otherwise it may throw errors like "Failed to initialize backend
# EGL display". See the code in https://bit.ly/3ruiMlB as an example
# to setup the DISPLAY env with xvfb.
# * It will not work under remote sessions like chrome remote desktop.
if gpu_mode:
emulator_cmd.extend(['-gpu', gpu_mode])
if debug_tags:
emulator_cmd.extend(['-debug', debug_tags])
emulator_env = {}
if self._emulator_home:
emulator_env['ANDROID_EMULATOR_HOME'] = self._emulator_home
if 'DISPLAY' in os.environ:
emulator_env['DISPLAY'] = os.environ.get('DISPLAY')
if window:
if 'DISPLAY' not in emulator_env:
raise AvdException(
'Emulator failed to start: DISPLAY not defined')
else:
emulator_cmd.append('-no-window')
sock.listen(1)
logging.info('Starting emulator...')
logging.info(
' With environments: %s',
' '.join(['%s=%s' % (k, v) for k, v in emulator_env.items()]))
logging.info(' With commands: %s', ' '.join(emulator_cmd))
# TODO(jbudorick): Add support for logging emulator stdout & stderr at
# higher logging levels.
# Enable the emulator log when debug_tags is set.
if not debug_tags:
self._sink = open('/dev/null', 'w')
self._emulator_proc = cmd_helper.Popen(emulator_cmd,
stdout=self._sink,
stderr=self._sink,
env=emulator_env)
# Waits for the emulator to report its serial as requested via
# -report-console. See http://bit.ly/2lK3L18 for more.
def listen_for_serial(s):
logging.info('Waiting for connection from emulator.')
with contextlib.closing(s.accept()[0]) as conn:
val = conn.recv(1024)
return 'emulator-%d' % int(val)
try:
self._emulator_serial = timeout_retry.Run(listen_for_serial,
timeout=30,
retries=0,
args=[sock])
logging.info('%s started', self._emulator_serial)
except Exception as e:
self.Stop()
# avd.py is executed with python2.
# pylint: disable=W0707
raise AvdException('Emulator failed to start: %s' % str(e))
# Set the system settings in "Start" here instead of setting in "Create"
# because "Create" is used during AVD creation, and we want to avoid extra
# turn-around on rolling AVD.
if ensure_system_settings:
assert self.device is not None, '`instance.device` not initialized.'
self.device.WaitUntilFullyBooted(
timeout=120 if is_slow_start else 30)
_EnsureSystemSettings(self.device)
def Start(self,
read_only=True,
snapshot_save=False,
window=False,
writable_system=False):
"""Starts the emulator running an instance of the given AVD."""
with tempfile_ext.TemporaryFileName() as socket_path, (contextlib.closing(
socket.socket(socket.AF_UNIX))) as sock:
sock.bind(socket_path)
emulator_cmd = [
self._emulator_path,
'-avd',
self._avd_name,
'-report-console',
'unix:%s' % socket_path,
'-no-boot-anim',
]
android_avd_home = os.path.join(self._emulator_home, 'avd')
avd_dir = os.path.join(android_avd_home, '%s.avd' % self._avd_name)
hardware_qemu_path = os.path.join(avd_dir, 'hardware-qemu.ini')
if os.path.exists(hardware_qemu_path):
with open(hardware_qemu_path) as hardware_qemu_file:
hardware_qemu_contents = ini.load(hardware_qemu_file)
else:
hardware_qemu_contents = {}
if read_only:
emulator_cmd.append('-read-only')
if not snapshot_save:
emulator_cmd.append('-no-snapshot-save')
if writable_system:
emulator_cmd.append('-writable-system')
emulator_env = {}
if self._emulator_home:
emulator_env['ANDROID_EMULATOR_HOME'] = self._emulator_home
if window:
if 'DISPLAY' in os.environ:
emulator_env['DISPLAY'] = os.environ.get('DISPLAY')
else:
raise AvdException('Emulator failed to start: DISPLAY not defined')
else:
emulator_cmd.append('-no-window')
hardware_qemu_contents['hw.sdCard'] = 'true'
if self._avd_config.avd_settings.sdcard.size:
sdcard_path = os.path.join(self._emulator_home, 'avd',
'%s.avd' % self._avd_name, 'cr-sdcard.img')
if not os.path.exists(sdcard_path):
mksdcard_path = os.path.join(
os.path.dirname(self._emulator_path), 'mksdcard')
mksdcard_cmd = [
mksdcard_path,
self._avd_config.avd_settings.sdcard.size,
sdcard_path,
]
cmd_helper.RunCmd(mksdcard_cmd)
emulator_cmd.extend(['-sdcard', sdcard_path])
hardware_qemu_contents['hw.sdCard.path'] = sdcard_path
with open(hardware_qemu_path, 'w') as hardware_qemu_file:
ini.dump(hardware_qemu_contents, hardware_qemu_file)
sock.listen(1)
logging.info('Starting emulator.')
# TODO(jbudorick): Add support for logging emulator stdout & stderr at
# higher logging levels.
self._sink = open('/dev/null', 'w')
self._emulator_proc = cmd_helper.Popen(
emulator_cmd, stdout=self._sink, stderr=self._sink, env=emulator_env)
# Waits for the emulator to report its serial as requested via
# -report-console. See http://bit.ly/2lK3L18 for more.
def listen_for_serial(s):
logging.info('Waiting for connection from emulator.')
with contextlib.closing(s.accept()[0]) as conn:
val = conn.recv(1024)
return 'emulator-%d' % int(val)
try:
self._emulator_serial = timeout_retry.Run(
listen_for_serial, timeout=30, retries=0, args=[sock])
logging.info('%s started', self._emulator_serial)
except Exception as e:
self.Stop()
raise AvdException('Emulator failed to start: %s' % str(e))
def RunTests(self, results):
wrapper_path = os.path.join(constants.GetOutDirectory(), 'bin',
'helper', self._test_instance.suite)
# This avoids searching through the classparth jars for tests classes,
# which takes about 1-2 seconds.
# Do not shard when a test filter is present since we do not know at this
# point which tests will be filtered out.
if (self._test_instance.shards == 1 or self._test_instance.test_filter
or self._test_instance.suite in _EXCLUDED_SUITES):
test_classes = []
shards = 1
else:
test_classes = _GetTestClasses(wrapper_path)
shards = ChooseNumOfShards(test_classes,
self._test_instance.shards)
logging.info('Running tests on %d shard(s).', shards)
group_test_list = GroupTestsForShard(shards, test_classes)
with tempfile_ext.NamedTemporaryDirectory() as temp_dir:
cmd_list = [[wrapper_path] for _ in range(shards)]
json_result_file_paths = [
os.path.join(temp_dir, 'results%d.json' % i)
for i in range(shards)
]
jar_args_list = self._CreateJarArgsList(json_result_file_paths,
group_test_list, shards)
for i in range(shards):
cmd_list[i].extend(
['--jar-args',
'"%s"' % ' '.join(jar_args_list[i])])
jvm_args = self._CreateJvmArgsList()
if jvm_args:
for cmd in cmd_list:
cmd.extend(['--jvm-args', '"%s"' % ' '.join(jvm_args)])
AddPropertiesJar(cmd_list, temp_dir,
self._test_instance.resource_apk)
procs = []
temp_files = []
for index, cmd in enumerate(cmd_list):
# First process prints to stdout, the rest write to files.
if index == 0:
sys.stdout.write('\nShard 0 output:\n')
procs.append(
cmd_helper.Popen(
cmd,
stdout=sys.stdout,
stderr=subprocess.STDOUT,
))
else:
temp_file = tempfile.TemporaryFile()
temp_files.append(temp_file)
procs.append(
cmd_helper.Popen(
cmd,
stdout=temp_file,
stderr=temp_file,
))
PrintProcessesStdout(procs, temp_files)
results_list = []
try:
for json_file_path in json_result_file_paths:
with open(json_file_path, 'r') as f:
results_list += json_results.ParseResultsFromJson(
json.loads(f.read()))
except IOError:
# In the case of a failure in the JUnit or Robolectric test runner
# the output json file may never be written.
results_list = [
base_test_result.BaseTestResult(
'Test Runner Failure',
base_test_result.ResultType.UNKNOWN)
]
test_run_results = base_test_result.TestRunResults()
test_run_results.AddResults(results_list)
results.append(test_run_results)
