android-env 1.2.1__py3-none-any.whl → 1.2.3__py3-none-any.whl

android_env/components/simulators/emulator/emulator_launcher.py

@@ -1,5 +1,5 @@
 # coding=utf-8
-# Copyright 2022 DeepMind Technologies Limited.
+# Copyright 2024 DeepMind Technologies Limited.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,66 +15,27 @@
 
 """Prepares and launches an emulator process."""
 
+import glob
 import os
 import subprocess
 import tempfile
-from typing import Optional
 
 from absl import logging
+from android_env.components import config_classes
 
 
-class EmulatorLauncher():
+class EmulatorLauncher:
   """Handles launching an emulator."""
 
   def __init__(
       self,
-      adb_port: Optional[int] = None,
-      adb_server_port: Optional[int] = None,
-      emulator_console_port: Optional[int] = None,
-      grpc_port: int = -1,
-      emulator_path: str = '',
-      android_sdk_root: str = '',
-      avd_name: str = '',
-      android_avd_home: str = '',
-      run_headless: bool = False,
-      kvm_device: str = '/dev/kvm',
-      gpu_mode: str = 'swiftshader_indirect',
-      tmp_dir: str = '',
-      snapshot_name: str = '',
-      restrict_network: bool = False):
-    """Launches an emulator.
-
-    Args:
-      adb_port: ADB port for the Android device.
-      adb_server_port: Port of the ADB server deamon.
-      emulator_console_port: Port for telnet communication with the emulator.
-      grpc_port: Port for gRPC communication with the emulator.
-      emulator_path: Path to the emulator binary.
-      android_sdk_root: Root directory of the Android SDK.
-      avd_name: Name of the AVD.
-      android_avd_home: Local directory for AVDs.
-      run_headless: Whether to run in headless mode.
-      kvm_device: Path to the KVM device.
-      gpu_mode: GPU mode override. Supported values are listed at:
-        https://developer.android.com/studio/run/emulator-acceleration#accel-graphics
-      tmp_dir: Path to directory which will hold temporary files.
-      snapshot_name: Name of the snapshot to load.
-      restrict_network: if True, will disable networking on the device. This
-        option is only available for emulator version > 31.3.9 (June 2022).
-    """
-    self._adb_port = adb_port
-    self._adb_server_port = adb_server_port
-    self._emulator_console_port = emulator_console_port
-    self._grpc_port = grpc_port
-    self._emulator_path = emulator_path
-    self._android_sdk_root = android_sdk_root
-    self._avd_name = avd_name
-    self._android_avd_home = android_avd_home
-    self._run_headless = run_headless
-    self._kvm_device = kvm_device
-    self._gpu_mode = gpu_mode
-    self._snapshot_name = snapshot_name
-    self._restrict_network = restrict_network
+      config: config_classes.EmulatorLauncherConfig,
+      adb_controller_config: config_classes.AdbControllerConfig,
+  ):
+    """Launches an emulator."""
+
+    self._config = config
+    self._adb_controller_config = adb_controller_config
 
     self._emulator = None
     self._emulator_output = None
@@ -82,9 +43,10 @@ class EmulatorLauncher():
 
     # Create directory for tmp files.
     # Note: this will be deleted once EmulatorLauncher instance is cleaned up.
-    os.makedirs(tmp_dir, exist_ok=True)
+    os.makedirs(config.tmp_dir, exist_ok=True)
     self._local_tmp_dir_handle = tempfile.TemporaryDirectory(
-        dir=tmp_dir, prefix='simulator_instance_')
+        dir=config.tmp_dir, prefix='simulator_instance_'
+    )
     self._local_tmp_dir = self._local_tmp_dir_handle.name
     self._logfile_path = os.path.join(self._local_tmp_dir, 'emulator_output')
     logging.info('Simulator local_tmp_dir: %s', self._local_tmp_dir)
@@ -95,22 +57,28 @@ class EmulatorLauncher():
   def launch_emulator_process(self) -> None:
     """Launches the emulator."""
 
-    logging.info('Booting new emulator [%s]', self._emulator_path)
+    logging.info('Booting new emulator: %s', self._config.emulator_path)
 
     # Set necessary environment variables.
-    base_lib_dir = self._emulator_path[:-8] + 'lib64/'
+    base_lib_dir = self._config.emulator_path[:-8] + 'lib64/'
     ld_library_path = ':'.join([
         base_lib_dir + 'x11/', base_lib_dir + 'qt/lib/',
         base_lib_dir + 'gles_swiftshader/', base_lib_dir
     ])
     extra_env_vars = {
         'ANDROID_HOME': '',
-        'ANDROID_SDK_ROOT': self._android_sdk_root,
-        'ANDROID_AVD_HOME': self._android_avd_home,
-        'ANDROID_EMULATOR_KVM_DEVICE': self._kvm_device,
-        'ANDROID_ADB_SERVER_PORT': str(self._adb_server_port),
+        'ANDROID_SDK_ROOT': self._config.android_sdk_root,
+        'ANDROID_AVD_HOME': self._config.android_avd_home,
+        'ANDROID_EMULATOR_KVM_DEVICE': self._config.kvm_device,
+        'ANDROID_ADB_SERVER_PORT': str(
+            self._adb_controller_config.adb_server_port
+        ),
         'LD_LIBRARY_PATH': ld_library_path,
-        'QT_XKB_CONFIG_ROOT': str(self._emulator_path[:-8] + 'qt_config/'),
+        'QT_XKB_CONFIG_ROOT': str(
+            self._config.emulator_path[:-8] + 'qt_config/'
+        ),
+        'ANDROID_EMU_ENABLE_CRASH_REPORTING': '1',
+        'SHOW_PERF_STATS': str(1 if self._config.show_perf_stats else 0),
     }
     logging.info('extra_env_vars: %s',
                  ' '.join(f'{k}={v}' for k, v in extra_env_vars.items()))
@@ -118,31 +86,52 @@ class EmulatorLauncher():
     env_vars.update(extra_env_vars)
 
     # Compile command.
-    grpc_port = ['-grpc', str(self._grpc_port)] if self._grpc_port >= 0 else []
-    run_headless = ['-no-skin', '-no-window'] if self._run_headless else []
-    ports = ['-ports', '%s,%s' % (self._emulator_console_port, self._adb_port)]
+    grpc_port = (
+        ['-grpc', str(self._config.grpc_port)]
+        if self._config.grpc_port >= 0
+        else []
+    )
+    run_headless = (
+        ['-no-skin', '-no-window'] if self._config.run_headless else []
+    )
+    ports = [
+        '-ports',
+        '%s,%s' % (self._config.emulator_console_port, self._config.adb_port),
+    ]
     snapshot = [
-        '-snapshot', self._snapshot_name, '-feature',
-        'AllowSnapshotMigration,MigratableSnapshotSave'
+        '-snapshot',
+        self._config.snapshot_name,
+        '-feature',
+        'AllowSnapshotMigration,MigratableSnapshotSave',
     ]
-    snapshot = snapshot if self._snapshot_name else ['-no-snapshot']
+    snapshot = snapshot if self._config.snapshot_name else ['-no-snapshot']
     restrict_network_args = [
         '-network-user-mode-options', 'restrict=y', '-wifi-user-mode-options',
         'restrict=y'
     ]
-    network_args = restrict_network_args if self._restrict_network else []
-    command = [
-        self._emulator_path,
-        '-gpu',
-        self._gpu_mode,
-        '-no-audio',
-        '-show-kernel',
-        '-verbose',
-        '-avd',
-        self._avd_name,
-    ] + grpc_port + run_headless + ports + snapshot + network_args
+    network_args = (
+        restrict_network_args if self._config.restrict_network else []
+    )
+    command = (
+        [
+            self._config.emulator_path,
+            '-adb-path',
+            self._adb_controller_config.adb_path,
+            '-gpu',
+            self._config.gpu_mode,
+            '-no-audio',
+            '-show-kernel',
+            '-verbose',
+            '-avd',
+            self._config.avd_name,
+        ]
+        + grpc_port
+        + run_headless
+        + ports
+        + snapshot
+        + network_args
+    )
     logging.info('Emulator launch command: %s', ' '.join(command))
-
     # Prepare logfile.
     self._emulator_output = open(self._logfile_path, 'wb')
 
@@ -172,6 +161,7 @@ class EmulatorLauncher():
   def close(self):
     """Clean up launcher files and processes."""
     if not self._is_closed:
+      self._local_tmp_dir_handle.cleanup()
       self.confirm_shutdown()
       self._is_closed = True
 

android_env/components/simulators/emulator/emulator_launcher_test.py

@@ -1,5 +1,5 @@
 # coding=utf-8
-# Copyright 2022 DeepMind Technologies Limited.
+# Copyright 2024 DeepMind Technologies Limited.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -22,17 +22,18 @@ import tempfile
 from unittest import mock
 
 from absl.testing import absltest
+from absl.testing import parameterized
+from android_env.components import config_classes
 from android_env.components.simulators.emulator import emulator_launcher
 
 
-class EmulatorLauncherTest(absltest.TestCase):
+class EmulatorLauncherTest(parameterized.TestCase):
 
   def setUp(self):
     super().setUp()
 
-    mock.patch.object(os, 'makedirs').start()
-
     self._emulator_path = 'fake/path/emulator'
+    self._adb_path = 'fake/path/adb'
     self._adb_port = 5554
     self._adb_server_port = 1234
     self._emulator_console_port = 5555
@@ -40,14 +41,17 @@ class EmulatorLauncherTest(absltest.TestCase):
 
     self._expected_command = [
         self._emulator_path,
+        '-adb-path',
+        'fake/path/adb',
         '-gpu',
-        'swiftshader_indirect',
+        'swangle_indirect',
         '-no-audio',
         '-show-kernel',
         '-verbose',
         '-avd',
         self._avd_name,
     ]
+    self._headless = ['-no-skin', '-no-window']
     self._ports = ['-ports', f'{self._emulator_console_port},{self._adb_port}']
     self._snapshot = ['-no-snapshot']
 
@@ -57,116 +61,208 @@ class EmulatorLauncherTest(absltest.TestCase):
         base_lib_dir + 'gles_swiftshader/', base_lib_dir
     ])
 
+    # Instantiate the config to extract default values.
+    config = config_classes.EmulatorLauncherConfig()
     self._expected_env_vars = {
         'ANDROID_HOME': '',
-        'ANDROID_SDK_ROOT': '',
-        'ANDROID_AVD_HOME': '',
+        'ANDROID_SDK_ROOT': config.android_sdk_root,
+        'ANDROID_AVD_HOME': config.android_avd_home,
         'ANDROID_EMULATOR_KVM_DEVICE': '/dev/kvm',
         'ANDROID_ADB_SERVER_PORT': '1234',
         'LD_LIBRARY_PATH': ld_library_path,
         'QT_XKB_CONFIG_ROOT': str(self._emulator_path[:-8] + 'qt_config/'),
+        'ANDROID_EMU_ENABLE_CRASH_REPORTING': '1',
     }
 
+  @parameterized.named_parameters([
+      ('hide_perf_stats', False),
+      ('show_perf_stats', True),
+  ])
+  @mock.patch.object(os, 'makedirs')
   @mock.patch.object(os, 'environ', autospec=True, return_value=dict())
   @mock.patch.object(tempfile, 'TemporaryDirectory', instance=True)
-    def test_launch(self, mock_tmp_dir, os_environ):
-      del os_environ
-
+  def test_launch(
+      self,
+      show_perf_stats: bool,
+      mock_tmp_dir,
+      unused_os_environ,
+      unused_os_makedirs,
+  ):
     mock_tmp_dir.return_value.name.return_value = 'local_tmp_dir'
 
-    launcher = emulator_launcher.EmulatorLauncher(
+    config = config_classes.EmulatorLauncherConfig(
         adb_port=self._adb_port,
-        adb_server_port=self._adb_server_port,
         emulator_console_port=self._emulator_console_port,
         emulator_path=self._emulator_path,
         avd_name=self._avd_name,
-        grpc_port=-1)
+        grpc_port=-1,
+        show_perf_stats=show_perf_stats,
+    )
+    adb_controller_config = config_classes.AdbControllerConfig(
+        adb_path=self._adb_path,
+        adb_server_port=self._adb_server_port,
+    )
+    launcher = emulator_launcher.EmulatorLauncher(
+        config=config, adb_controller_config=adb_controller_config
+    )
+
+    expected_env_vars = self._expected_env_vars
+    expected_env_vars['SHOW_PERF_STATS'] = '1' if show_perf_stats else '0'
 
     with mock.patch.object(
-        subprocess, 'Popen', autospec=True) as emulator_init, \
-        mock.patch.object(builtins, 'open', autospec=True) as f:
+        subprocess, 'Popen', autospec=True
+    ) as emulator_init, mock.patch.object(builtins, 'open', autospec=True) as f:
       f.return_value.__enter__ = f()
       launcher.launch_emulator_process()
       emulator_init.assert_called_once_with(
-          args=self._expected_command + self._ports + self._snapshot,
-          env=self._expected_env_vars,
+          args=self._expected_command
+          + self._headless
+          + self._ports
+          + self._snapshot,
+          env=expected_env_vars,
           stdout=f(),
-          stderr=f())
+          stderr=f(),
+      )
 
+  @parameterized.named_parameters([
+      ('hide_perf_stats', False),
+      ('show_perf_stats', True),
+  ])
+  @mock.patch.object(os, 'makedirs')
   @mock.patch.object(os, 'environ', autospec=True, return_value=dict())
   @mock.patch.object(tempfile, 'TemporaryDirectory', instance=True)
-    def test_grpc_port(self, mock_tmp_dir, os_environ):
-      del os_environ
-
+  def test_grpc_port(
+      self,
+      show_perf_stats: bool,
+      mock_tmp_dir,
+      unused_os_environ,
+      unused_os_makedirs,
+  ):
     mock_tmp_dir.return_value.name.return_value = 'local_tmp_dir'
 
-    launcher = emulator_launcher.EmulatorLauncher(
+    config = config_classes.EmulatorLauncherConfig(
         adb_port=self._adb_port,
-        adb_server_port=self._adb_server_port,
         emulator_console_port=self._emulator_console_port,
         emulator_path=self._emulator_path,
         avd_name=self._avd_name,
-        grpc_port=8554)
+        grpc_port=8554,
+        show_perf_stats=show_perf_stats,
+    )
+    adb_controller_config = config_classes.AdbControllerConfig(
+        adb_path=self._adb_path,
+        adb_server_port=self._adb_server_port,
+    )
+    launcher = emulator_launcher.EmulatorLauncher(
+        config=config, adb_controller_config=adb_controller_config
+    )
+
+    expected_env_vars = self._expected_env_vars
+    expected_env_vars['SHOW_PERF_STATS'] = '1' if show_perf_stats else '0'
 
     with mock.patch.object(
-        subprocess, 'Popen', autospec=True) as emulator_init, \
-        mock.patch.object(builtins, 'open', autospec=True) as f:
+        subprocess, 'Popen', autospec=True
+    ) as emulator_init, mock.patch.object(builtins, 'open', autospec=True) as f:
       f.return_value.__enter__ = f()
       launcher.launch_emulator_process()
       emulator_init.assert_called_once_with(
-          args=self._expected_command + ['-grpc', '8554'] + self._ports +
-          self._snapshot,
-          env=self._expected_env_vars,
+          args=self._expected_command
+          + ['-grpc', '8554']
+          + self._headless
+          + self._ports
+          + self._snapshot,
+          env=expected_env_vars,
           stdout=f(),
-          stderr=f())
+          stderr=f(),
+      )
 
+  @parameterized.named_parameters([
+      ('hide_perf_stats', False),
+      ('show_perf_stats', True),
+  ])
+  @mock.patch.object(os, 'makedirs')
   @mock.patch.object(os, 'environ', autospec=True, return_value=dict())
   @mock.patch.object(tempfile, 'TemporaryDirectory', instance=True)
-    def test_snapshot(self, mock_tmp_dir, os_environ):
-      del os_environ
-
+  def test_snapshot(
+      self,
+      show_perf_stats: bool,
+      mock_tmp_dir,
+      unused_os_environ,
+      unused_os_makedirs,
+  ):
     mock_tmp_dir.return_value.name.return_value = 'local_tmp_dir'
 
-    launcher = emulator_launcher.EmulatorLauncher(
+    config = config_classes.EmulatorLauncherConfig(
         adb_port=self._adb_port,
-        adb_server_port=self._adb_server_port,
         emulator_console_port=self._emulator_console_port,
         emulator_path=self._emulator_path,
         avd_name=self._avd_name,
         grpc_port=-1,
-        snapshot_name='my_snapshot')
+        snapshot_name='my_snapshot',
+        show_perf_stats=show_perf_stats,
+    )
+    adb_controller_config = config_classes.AdbControllerConfig(
+        adb_path=self._adb_path,
+        adb_server_port=self._adb_server_port,
+    )
+    launcher = emulator_launcher.EmulatorLauncher(
+        config=config, adb_controller_config=adb_controller_config
+    )
 
     expected_snapshot = [
         '-snapshot', 'my_snapshot', '-feature',
         'AllowSnapshotMigration,MigratableSnapshotSave'
     ]
 
+    expected_env_vars = self._expected_env_vars
+    expected_env_vars['SHOW_PERF_STATS'] = '1' if show_perf_stats else '0'
+
     with mock.patch.object(
         subprocess, 'Popen', autospec=True) as emulator_init, \
         mock.patch.object(builtins, 'open', autospec=True) as f:
       f.return_value.__enter__ = f()
       launcher.launch_emulator_process()
       emulator_init.assert_called_once_with(
-          args=self._expected_command + self._ports + expected_snapshot,
-          env=self._expected_env_vars,
+          args=self._expected_command
+          + self._headless
+          + self._ports
+          + expected_snapshot,
+          env=expected_env_vars,
           stdout=f(),
-          stderr=f())
+          stderr=f(),
+      )
 
+  @parameterized.named_parameters([
+      ('hide_perf_stats', False),
+      ('show_perf_stats', True),
+  ])
+  @mock.patch.object(os, 'makedirs')
   @mock.patch.object(os, 'environ', autospec=True, return_value=dict())
   @mock.patch.object(tempfile, 'TemporaryDirectory', instance=True)
-    def test_snapshot(self, mock_tmp_dir, os_environ):
-      del os_environ
-
+  def test_network_restrict(
+      self,
+      show_perf_stats: bool,
+      mock_tmp_dir,
+      unused_os_environ,
+      unused_os_makedirs,
+  ):
     mock_tmp_dir.return_value.name.return_value = 'local_tmp_dir'
 
-    launcher = emulator_launcher.EmulatorLauncher(
+    config = config_classes.EmulatorLauncherConfig(
         adb_port=self._adb_port,
-        adb_server_port=self._adb_server_port,
         emulator_console_port=self._emulator_console_port,
         emulator_path=self._emulator_path,
         avd_name=self._avd_name,
         grpc_port=-1,
-        restrict_network=True)
+        restrict_network=True,
+        show_perf_stats=show_perf_stats,
+    )
+    adb_controller_config = config_classes.AdbControllerConfig(
+        adb_path=self._adb_path,
+        adb_server_port=self._adb_server_port,
+    )
+    launcher = emulator_launcher.EmulatorLauncher(
+        config=config, adb_controller_config=adb_controller_config
+    )
 
     expected_snapshot = ['-no-snapshot']
     expected_network_restrict = [
@@ -174,17 +270,25 @@ class EmulatorLauncherTest(absltest.TestCase):
         'restrict=y'
     ]
 
+    expected_env_vars = self._expected_env_vars
+    expected_env_vars['SHOW_PERF_STATS'] = '1' if show_perf_stats else '0'
+
     with mock.patch.object(
         subprocess, 'Popen', autospec=True) as emulator_init, \
         mock.patch.object(builtins, 'open', autospec=True) as f:
       f.return_value.__enter__ = f()
       launcher.launch_emulator_process()
       emulator_init.assert_called_once_with(
-          self._expected_command + self._ports + expected_snapshot +
-          expected_network_restrict,
-          env=self._expected_env_vars,
+          self._expected_command
+          + self._headless
+          + self._ports
+          + expected_snapshot
+          + expected_network_restrict,
+          env=expected_env_vars,
           stdout=f(),
-          stderr=f())
+          stderr=f(),
+      )
+
 
 if __name__ == '__main__':
   absltest.main()