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

android_env/components/{utils_test.py → pixel_fns_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.
@@ -13,11 +13,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""Tests for android_env.components.utils."""
+"""Tests for pixel_fns."""
 
 from absl.testing import absltest
 from absl.testing import parameterized
-from android_env.components import utils
+from android_env.components import pixel_fns
 from dm_env import specs
 import numpy as np
 
@@ -32,38 +32,42 @@ class UtilsTest(parameterized.TestCase):
       )
   def test_touch_position_to_pixel_position(
       self, touch_pos, width_height, pixel_pos):
-    self.assertEqual(utils.touch_position_to_pixel_position(
-        np.array(touch_pos), width_height), pixel_pos)
+    self.assertEqual(
+        pixel_fns.touch_position_to_pixel_position(
+            np.array(touch_pos), width_height
+        ),
+        pixel_pos,
+    )
 
   def test_transpose_pixels(self):
     image = np.reshape(np.array(range(12)), (3, 2, 2))
     expected = [[[0, 1], [4, 5], [8, 9]], [[2, 3], [6, 7], [10, 11]]]
-    self.assertEqual(utils.transpose_pixels(image).shape, (2, 3, 2))
-    self.assertTrue((utils.transpose_pixels(image) == expected).all())
+    self.assertEqual(pixel_fns.transpose_pixels(image).shape, (2, 3, 2))
+    self.assertTrue((pixel_fns.transpose_pixels(image) == expected).all())
 
   def test_orient_pixels(self):
     image = np.reshape(np.array(range(12)), (3, 2, 2))
 
     expected_90 = [[[8, 9], [4, 5], [0, 1]], [[10, 11], [6, 7], [2, 3]]]
     rot_90 = 1  # LANDSCAPE_90
-    rotated = utils.orient_pixels(image, rot_90)
+    rotated = pixel_fns.orient_pixels(image, rot_90)
     self.assertEqual(rotated.shape, (2, 3, 2))
     self.assertTrue((rotated == expected_90).all())
 
     expected_180 = [[[10, 11], [8, 9]], [[6, 7], [4, 5]], [[2, 3], [0, 1]]]
     rot_180 = 2  # PORTRAIT_180
-    rotated = utils.orient_pixels(image, rot_180)
+    rotated = pixel_fns.orient_pixels(image, rot_180)
     self.assertEqual(rotated.shape, (3, 2, 2))
     self.assertTrue((rotated == expected_180).all())
 
     expected_270 = [[[2, 3], [6, 7], [10, 11]], [[0, 1], [4, 5], [8, 9]]]
     rot_270 = 3  # LANDSCAPE_270
-    rotated = utils.orient_pixels(image, rot_270)
+    rotated = pixel_fns.orient_pixels(image, rot_270)
     self.assertEqual(rotated.shape, (2, 3, 2))
     self.assertTrue((rotated == expected_270).all())
 
     rot_0 = 0  # PORTRAIT_0
-    rotated = utils.orient_pixels(image, rot_0)
+    rotated = pixel_fns.orient_pixels(image, rot_0)
     self.assertEqual(rotated.shape, (3, 2, 2))
     self.assertTrue((rotated == image).all())
 
@@ -75,15 +79,16 @@ class UtilsTest(parameterized.TestCase):
         maximum=[5, 5, 20, 2],
         name='bounded_array')
     data = np.array([2, 2, 10, 0], dtype=np.int32)
-    float_data = utils.convert_int_to_float(data, spec, np.float64)
+    float_data = pixel_fns.convert_int_to_float(data, spec)
     np.testing.assert_equal(
-        np.array([2. / 5., 1. / 4., 0., 0.5], dtype=np.float64), float_data)
+        np.array([2.0 / 5.0, 1.0 / 4.0, 0.0, 0.5], dtype=np.float32), float_data
+    )
 
   def test_convert_int_to_float_bounded_array_broadcast(self):
     spec = specs.BoundedArray(
         shape=(3,), dtype=np.int16, minimum=2, maximum=4, name='bounded_array')
     data = np.array([2, 3, 4], dtype=np.int16)
-    float_data = utils.convert_int_to_float(data, spec, np.float32)
+    float_data = pixel_fns.convert_int_to_float(data, spec)
     np.testing.assert_equal(
         np.array([0.0, 0.5, 1.0], dtype=np.float32), float_data)
 
@@ -93,7 +98,7 @@ class UtilsTest(parameterized.TestCase):
         dtype=np.int8,  # int8 implies min=-128, max=127
         name='bounded_array')
     data = np.array([-128, 0, 127], dtype=np.int16)
-    float_data = utils.convert_int_to_float(data, spec, np.float32)
+    float_data = pixel_fns.convert_int_to_float(data, spec)
     np.testing.assert_equal(
         np.array([0.0, 128. / 255., 1.0], dtype=np.float32), float_data)
 

android_env/components/setup_step_interpreter.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,9 +15,10 @@
 
 """A component that parses and processes SetupSteps."""
 
+from collections.abc import Sequence
 import copy
 import time
-from typing import Any, Dict, Optional, Sequence
+from typing import Any
 
 from absl import logging
 from android_env.components import adb_call_parser as adb_call_parser_lib
@@ -27,7 +28,7 @@ from android_env.proto import adb_pb2
 from android_env.proto import task_pb2
 
 
-class SetupStepInterpreter():
+class SetupStepInterpreter:
   """An interpreter for SetupSteps."""
 
   def __init__(self, adb_call_parser: adb_call_parser_lib.AdbCallParser):
@@ -45,7 +46,7 @@ class SetupStepInterpreter():
         'total_time_waiting_for_app_screen': 0
     }
 
-  def stats(self) -> Dict[str, Any]:
+  def stats(self) -> dict[str, Any]:
     return copy.deepcopy(self._stats)
 
   def interpret(self, setup_steps: Sequence[task_pb2.SetupStep]) -> None:
@@ -110,45 +111,52 @@ class SetupStepInterpreter():
         f'Step failed: [{step_cmd}]') from latest_error
 
   def _execute_step_cmd(
-      self, step_cmd: task_pb2.SetupStep,
-      step_type: Optional[str]) -> Optional[adb_pb2.AdbResponse]:
+      self, step_cmd: task_pb2.SetupStep, step_type: str | None
+  ) -> adb_pb2.AdbResponse | None:
     """Executes a step command of given type."""
-    if not step_type:
-      return
 
-    if step_type == 'sleep':
-      time.sleep(step_cmd.sleep.time_sec)
-    elif step_type == 'adb_request':
-      response = self._adb_call_parser.parse(step_cmd.adb_request)
-      if response.status != adb_pb2.AdbResponse.Status.OK:
-        raise errors.AdbControllerError(
-            f'Failed to execute AdbRequest [{step_cmd.adb_request}].\n'
-            f'Status: {response.status}\n'
-            f'Error: {response.error_message}')
-      return response
-    else:
-      raise NotImplementedError('No step command of type [%s].' % step_type)
-
-  def _check_success(self,
-                     success_check: Optional[str],
-                     success_condition: task_pb2.SuccessCondition) -> None:
+    match step_type:
+      case None:
+        return None
+      case 'sleep':
+        time.sleep(step_cmd.sleep.time_sec)
+        return None
+      case 'adb_request':
+        response = self._adb_call_parser.parse(step_cmd.adb_request)
+        if response.status != adb_pb2.AdbResponse.Status.OK:
+          raise errors.AdbControllerError(
+              f'Failed to execute AdbRequest [{step_cmd.adb_request}].\n'
+              f'Status: {response.status}\n'
+              f'Error: {response.error_message}'
+          )
+        return response
+      case _:
+        raise NotImplementedError(f'No step command of type [{step_type}].')
+
+  def _check_success(
+      self,
+      success_check: str | None,
+      success_condition: task_pb2.SuccessCondition,
+  ) -> None:
     """Checks whether the given success condition was met."""
 
-    if not success_check:
-      return
-
-    if success_check == 'wait_for_app_screen':
-      wait_for_app_screen = success_condition.wait_for_app_screen
-      screen_checker = app_screen_checker.AppScreenChecker(
-          adb_call_parser=self._adb_call_parser,
-          expected_app_screen=wait_for_app_screen.app_screen)
-      wait_time = screen_checker.wait_for_app_screen(
-          timeout_sec=wait_for_app_screen.timeout_sec)
-      self._stats['total_time_waiting_for_app_screen'] += wait_time
-    elif success_check == 'check_install':
-      self._check_install(success_condition.check_install)
-    else:
-      raise NotImplementedError('No success check called [%s].' % success_check)
+    match success_check:
+      case None:
+        return None
+      case 'wait_for_app_screen':
+        wait_for_app_screen = success_condition.wait_for_app_screen
+        screen_checker = app_screen_checker.AppScreenChecker(
+            adb_call_parser=self._adb_call_parser,
+            expected_app_screen=wait_for_app_screen.app_screen,
+        )
+        wait_time = screen_checker.wait_for_app_screen(
+            timeout_sec=wait_for_app_screen.timeout_sec
+        )
+        self._stats['total_time_waiting_for_app_screen'] += wait_time
+      case 'check_install':
+        self._check_install(success_condition.check_install)
+      case _:
+        raise NotImplementedError(f'No success check called [{success_check}].')
 
   def _check_install(self, check_install: task_pb2.CheckInstall) -> None:
     """Checks that the given package is installed."""

android_env/components/setup_step_interpreter_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.
@@ -57,14 +57,14 @@ class SetupStepInterpreterTest(absltest.TestCase):
     interpreter = setup_step_interpreter.SetupStepInterpreter(
         adb_call_parser=self._parser)
     # Empty setup steps should be ignored.
-    interpreter.interpret([None])
+    interpreter.interpret([])
 
   def test_invalid_setup_step(self):
     interpreter = setup_step_interpreter.SetupStepInterpreter(
         adb_call_parser=self._parser)
     # Empty setup steps should be ignored.
-    with self.assertRaises(AssertionError):
-      interpreter.interpret([_to_proto(task_pb2.SetupStep, '')])
+    self.assertRaises(AssertionError, interpreter.interpret,
+                      [task_pb2.SetupStep()])
 
   def test_adb_install_apk_filesystem(self):
     self._parser.parse.return_value = adb_pb2.AdbResponse(

android_env/components/simulators/__init__.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.

android_env/components/simulators/base_simulator.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.
@@ -16,34 +16,23 @@
 """A base class for talking to different types of Android simulators."""
 
 import abc
-from typing import List, Tuple
+from collections.abc import Callable
+import threading
+import time
 
 from absl import logging
 from android_env.components import adb_controller
+from android_env.components import config_classes
 from android_env.components import errors
 from android_env.components import log_stream
+from android_env.proto import state_pb2
 import numpy as np
 
 
-def _print_logs_on_exception(func):
-  """Decorator function for printing simulator logs upon any exception."""
-  def wrapper(*args, **kwargs):
-    try:
-      return func(*args, **kwargs)
-    except Exception as error:
-      # Calls self.get_logs since self is the first arg.
-      for line in args[0].get_logs().splitlines():
-        logging.error(line)
-      raise errors.SimulatorError(
-          'Exception caught in simulator. Please see the simulator logs '
-          'above for more details.') from error
-  return wrapper
-
-
 class BaseSimulator(metaclass=abc.ABCMeta):
   """An interface for communicating with an Android simulator."""
 
-  def __init__(self, verbose_logs: bool = False):
+  def __init__(self, config: config_classes.SimulatorConfig):
     """Instantiates a BaseSimulator object.
 
     The simulator may be an emulator, virtual machine or even a physical device.
@@ -51,14 +40,14 @@ class BaseSimulator(metaclass=abc.ABCMeta):
     bookkeeping.
 
     Args:
-      verbose_logs: If true, the log stream of the simulator will be verbose.
+      config: Settings for this simulator.
     """
 
-    self._verbose_logs = verbose_logs
-    self._launched = False
+    self._config = config
+    self._interaction_thread: InteractionThread | None = None
 
-  def is_launched(self) -> bool:
-    return self._launched
+    # An increasing number that tracks the attempt at launching the simulator.
+    self._num_launch_attempts: int = 0
 
   def get_logs(self) -> str:
     """Returns logs recorded by the simulator (if provided)."""
@@ -76,20 +65,42 @@ class BaseSimulator(metaclass=abc.ABCMeta):
   def create_log_stream(self) -> log_stream.LogStream:
     """Creates a stream of logs from the simulator."""
 
-  @abc.abstractmethod
-  def _restart_impl(self) -> None:
-    """Platform specific restart implementation."""
+  def launch(self) -> None:
+    """Starts the simulator."""
+
+    # Stop screenshot thread if it's enabled.
+    if self._interaction_thread is not None:
+      self._interaction_thread.stop()
+      self._interaction_thread.join()
+
+    self._num_launch_attempts += 1
+    try:
+      self._launch_impl()
+    except Exception as error:
+      for line in self.get_logs().splitlines():
+        logging.error(line)
+      raise errors.SimulatorError(
+          'Exception caught in simulator. Please see the simulator logs '
+          'above for more details.'
+      ) from error
+
+    # Start interaction thread.
+    if self._config.interaction_rate_sec > 0:
+      self._interaction_thread = InteractionThread(
+          self._get_screenshot_impl, self._config.interaction_rate_sec
+      )
+      self._interaction_thread.start()
 
   @abc.abstractmethod
   def _launch_impl(self) -> None:
     """Platform specific launch implementation."""
 
   @abc.abstractmethod
-  def send_touch(self, touches: List[Tuple[int, int, bool, int]]) -> None:
+  def send_touch(self, touches: list[tuple[int, int, bool, int]]) -> None:
     """Sends a touch event to be executed on the simulator.
 
     Args:
-      touches: A list of touch events. Each elemet in the list corresponds to a
+      touches: A list of touch events. Each element in the list corresponds to a
           single touch event. Each touch event tuple should have:
           0 x: The horizontal coordinate of this event.
           1 y: The vertical coordinate of this event.
@@ -107,25 +118,48 @@ class BaseSimulator(metaclass=abc.ABCMeta):
       event_type: Type of key event to be sent.
     """
 
-  @_print_logs_on_exception
-  def launch(self) -> None:
-    """Launches the simulator."""
-    if not self._launched:
-      self._launched = True
-      self._launch_impl()
-    else:
-      self.restart()
+  def load_state(
+      self, request: state_pb2.LoadStateRequest
+  ) -> state_pb2.LoadStateResponse:
+    """Loads a state.
 
-  @_print_logs_on_exception
-  def restart(self) -> None:
-    """Restarts the simulator."""
-    logging.info('Restarting the simulator...')
-    self._restart_impl()
-    logging.info('Done restarting the simulator.')
+    Args:
+      request: A `LoadStateRequest` containing any parameters necessary to
+        specify how/what state to load.
+
+    Returns:
+      A `LoadStateResponse` containing the status, error message (if
+      applicable), and any other relevant information.
+    """
+    raise NotImplementedError('This simulator does not support load_state()')
+
+  def save_state(
+      self, request: state_pb2.SaveStateRequest
+  ) -> state_pb2.SaveStateResponse:
+    """Saves a state.
+
+    Args:
+      request: A `SaveStateRequest` containing any parameters necessary to
+        specify how/what state to save.
+
+    Returns:
+      A `SaveStateResponse` containing the status, error message (if
+      applicable), and any other relevant information.
+    """
+    raise NotImplementedError('This simulator does not support save_state()')
 
-  @abc.abstractmethod
   def get_screenshot(self) -> np.ndarray:
-    """Returns pixels representing the current screenshot of the simulator.
+    """Returns pixels representing the current screenshot of the simulator."""
+
+    if self._config.interaction_rate_sec > 0:
+      assert self._interaction_thread is not None
+      return self._interaction_thread.screenshot()  # Async mode.
+    else:
+      return self._get_screenshot_impl()  # Sync mode.
+
+  @abc.abstractmethod
+  def _get_screenshot_impl(self) -> np.ndarray:
+    """Actual implementation of `get_screenshot()`.
 
     The output numpy array should have shape [height, width, num_channels] and
     can be loaded into PIL using Image.fromarray(img, mode='RGB') and be saved
@@ -134,3 +168,41 @@ class BaseSimulator(metaclass=abc.ABCMeta):
 
   def close(self):
     """Frees up resources allocated by this object."""
+
+    if self._interaction_thread is not None:
+      self._interaction_thread.stop()
+      self._interaction_thread.join()
+
+
+class InteractionThread(threading.Thread):
+  """A thread that gets screenshot in the background."""
+
+  def __init__(
+      self,
+      get_screenshot_fn: Callable[[], np.ndarray],
+      interaction_rate_sec: float,
+  ):
+    super().__init__()
+    self._get_screenshot_fn = get_screenshot_fn
+    self._interaction_rate_sec = interaction_rate_sec
+    self._should_stop = threading.Event()
+    self._screenshot = self._get_screenshot_fn()
+
+  def run(self):
+    last_read = time.time()
+    while not self._should_stop.is_set():
+      self._screenshot = self._get_screenshot_fn()
+      now = time.time()
+      elapsed = now - last_read
+      last_read = now
+      sleep_time = self._interaction_rate_sec - elapsed
+      if sleep_time > 0.0:
+        time.sleep(sleep_time)
+    logging.info('InteractionThread.run() finished.')
+
+  def stop(self):
+    logging.info('Stopping InteractionThread.')
+    self._should_stop.set()
+
+  def screenshot(self) -> np.ndarray:
+    return self._screenshot

android_env/components/simulators/base_simulator_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.
@@ -13,14 +13,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""Tests for base_simulator."""
-
+import itertools
+import time
 from unittest import mock
 
 from absl.testing import absltest
+from android_env.components import config_classes
 from android_env.components import errors
 # fake_simulator.FakeSimulator inherits from BaseSimulator, so there's no need
 # to import it here explicitly.
+from android_env.components.simulators import base_simulator
 from android_env.components.simulators.fake import fake_simulator
 import numpy as np
 
@@ -28,19 +30,25 @@ import numpy as np
 class BaseSimulatorTest(absltest.TestCase):
 
   def test_launch(self):
-    simulator = fake_simulator.FakeSimulator(screen_dimensions=(640, 480))
+    simulator = fake_simulator.FakeSimulator(
+        config_classes.FakeSimulatorConfig(screen_dimensions=(640, 480))
+    )
     # The simulator should launch and not crash.
     simulator.launch()
 
   def test_launch_close(self):
-    simulator = fake_simulator.FakeSimulator()
+    simulator = fake_simulator.FakeSimulator(
+        config_classes.FakeSimulatorConfig()
+    )
     # The simulator should launch and not crash.
     simulator.launch()
     # Closing the simulator should also not crash.
     simulator.close()
 
   def test_get_screenshot(self):
-    simulator = fake_simulator.FakeSimulator(screen_dimensions=(640, 480))
+    simulator = fake_simulator.FakeSimulator(
+        config_classes.FakeSimulatorConfig(screen_dimensions=(640, 480))
+    )
     # The simulator should launch and not crash.
     simulator.launch()
 
@@ -48,12 +56,126 @@ class BaseSimulatorTest(absltest.TestCase):
     np.testing.assert_equal(screenshot.shape, [640, 480, 3])
 
   def test_print_logs_on_exception(self):
-    simulator = fake_simulator.FakeSimulator()
-    with mock.patch.object(simulator, 'get_logs') as mock_get_logs, \
-         mock.patch.object(simulator, '_launch_impl', autospec=True) as mock_launch:
+    simulator = fake_simulator.FakeSimulator(
+        config_classes.FakeSimulatorConfig()
+    )
+    with mock.patch.object(
+        simulator, 'get_logs'
+    ) as mock_get_logs, mock.patch.object(
+        simulator, '_launch_impl', autospec=True
+    ) as mock_launch:
       mock_launch.side_effect = ValueError('Oh no!')
       self.assertRaises(errors.SimulatorError, simulator.launch)
       mock_get_logs.assert_called_once()
 
+  def test_get_screenshot_error_async(self):
+    """An exception in the underlying interaction thread should bubble up."""
+
+    # Arrange.
+    mock_interaction_thread = mock.create_autospec(
+        base_simulator.InteractionThread
+    )
+    mock_interaction_thread.screenshot.side_effect = (
+        errors.ReadObservationError()
+    )
+    simulator = fake_simulator.FakeSimulator(
+        config_classes.FakeSimulatorConfig(interaction_rate_sec=0.5)
+    )
+    with mock.patch.object(
+        base_simulator,
+        'InteractionThread',
+        autospec=True,
+        return_value=mock_interaction_thread,
+    ):
+      simulator.launch()
+
+    # Act & Assert.
+    self.assertRaises(errors.ReadObservationError, simulator.get_screenshot)
+
+    # Cleanup.
+    simulator.close()
+
+  def test_get_screenshot_faster_than_screenshot_impl(self):
+    """Return same screenshot when step is faster than the interaction rate."""
+
+    # Arrange.
+    slow_rate = 0.5
+    simulator = fake_simulator.FakeSimulator(
+        config_classes.FakeSimulatorConfig(interaction_rate_sec=slow_rate)
+    )
+
+    # Act.
+    with mock.patch.object(
+        simulator, '_get_screenshot_impl', autospec=True
+    ) as mock_get_screenshot_impl:
+      mock_get_screenshot_impl.side_effect = (
+          np.array(i, ndmin=3) for i in itertools.count(0, 1)
+      )
+      simulator.launch()
+      # Get two screenshots one after the other without pausing.
+      screenshot1 = simulator.get_screenshot()
+      screenshot2 = simulator.get_screenshot()
+
+    # Assert.
+    self.assertAlmostEqual(screenshot1[0][0][0], screenshot2[0][0][0])
+
+    # Cleanup.
+    simulator.close()
+
+  def test_get_screenshot_slower_than_screenshot_impl(self):
+    """Return different screenshots when step slower than the interaction rate."""
+
+    # Arrange.
+    fast_rate = 0.01
+    simulator = fake_simulator.FakeSimulator(
+        config_classes.FakeSimulatorConfig(interaction_rate_sec=fast_rate)
+    )
+
+    # Act.
+    with mock.patch.object(
+        simulator, '_get_screenshot_impl', autospec=True
+    ) as mock_get_screenshot_impl:
+      mock_get_screenshot_impl.side_effect = (
+          np.array(i, ndmin=3) for i in itertools.count(0, 1)
+      )
+      simulator.launch()
+      # Sleep for 500ms between two screenshots.
+      screenshot1 = simulator.get_screenshot()
+      time.sleep(0.5)
+      screenshot2 = simulator.get_screenshot()
+
+    # Assert.
+    self.assertNotEqual(screenshot1[0][0][0], screenshot2[0][0][0])
+
+    # Cleanup.
+    simulator.close()
+
+  def test_interaction_thread_closes_upon_relaunch(self):
+    """Async interaction should kill the InteractionThread when relaunching."""
+
+    # Arrange.
+    simulator = fake_simulator.FakeSimulator(
+        config_classes.FakeSimulatorConfig(interaction_rate_sec=0.01)
+    )
+    mock_interaction_thread = mock.create_autospec(
+        base_simulator.InteractionThread
+    )
+
+    # Act & Assert.
+    with mock.patch.object(
+        base_simulator,
+        'InteractionThread',
+        autospec=True,
+        return_value=mock_interaction_thread,
+    ):
+      simulator.launch()
+      mock_interaction_thread.stop.assert_not_called()
+      mock_interaction_thread.join.assert_not_called()
+      simulator.launch()
+      mock_interaction_thread.stop.assert_called_once()
+      mock_interaction_thread.join.assert_called_once()
+      simulator.close()
+
+
 if __name__ == '__main__':
   absltest.main()

android_env/components/simulators/emulator/__init__.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.