Wait for launched window stability before capture

Author: ok-oldking

ok/gui/StartController.py

@@ -13,6 +13,10 @@
 
 
 class StartController(QObject):
+    STARTED_WINDOW_MIN_SIZE = (100, 100)
+    STARTED_WINDOW_STABLE_SECONDS = 10
+    STARTED_WINDOW_POLL_INTERVAL = 0.2
+
     def __init__(self, app_config, exit_event):
         super().__init__()
         self.config = app_config
@@ -119,6 +123,37 @@ def _wait_until_device_ready(self):
             time.sleep(2)
         return False
 
+    def _wait_until_started_window_stable(self):
+        wait_until = time.monotonic() + self.start_timeout
+        stable_size = None
+        stable_since = None
+        min_width, min_height = self.STARTED_WINDOW_MIN_SIZE
+
+        while not self.exit_event.is_set():
+            hwnd_window = getattr(og.device_manager, 'hwnd_window', None)
+            if hwnd_window is not None:
+                hwnd_window.do_update_window_size()
+                size = (hwnd_window.width, hwnd_window.height)
+                if hwnd_window.hwnd and size[0] >= min_width and size[1] >= min_height:
+                    now = time.monotonic()
+                    if size != stable_size:
+                        logger.info(f'waiting for started window to stabilize, current size {size[0]}x{size[1]}')
+                        stable_size = size
+                        stable_since = now
+                    elif now - stable_since >= self.STARTED_WINDOW_STABLE_SECONDS:
+                        logger.info(f'started window size stable for {self.STARTED_WINDOW_STABLE_SECONDS}s: {size[0]}x{size[1]}')
+                        return True
+                else:
+                    stable_size = None
+                    stable_since = None
+
+            remaining_time = wait_until - time.monotonic()
+            if remaining_time <= 0:
+                communicate.starting_emulator.emit(True, self.tr('Start game timeout!'), 0)
+                return False
+            time.sleep(self.STARTED_WINDOW_POLL_INTERVAL)
+        return False
+
     def start_device(self):
         device = og.device_manager.get_preferred_device()
         logger.info(f'start_device: {device}')
@@ -140,6 +175,8 @@ def start_device(self):
                 if not execute(path, arguments=args):
                     communicate.starting_emulator.emit(True, self.tr("Start game failed, please start game first"), 0)
                     return False
+                if device['device'] == "windows" and not self._wait_until_started_window_stable():
+                    return False
                 if not self._wait_until_device_ready():
                     return False
             else:

tests/test_start_controller.py

@@ -0,0 +1,105 @@
+import threading
+import unittest
+from types import SimpleNamespace
+from unittest.mock import Mock, patch
+
+import ok.gui.StartController as start_controller_module
+from ok.gui.StartController import StartController
+
+
+class FakeClock:
+    def __init__(self):
+        self.value = 0
+
+    def monotonic(self):
+        return self.value
+
+    def sleep(self, seconds):
+        self.value += seconds
+
+
+class FakeWindow:
+    def __init__(self, sizes):
+        self.sizes = iter(sizes)
+        self.hwnd = 0
+        self.width = 0
+        self.height = 0
+        self.updates = 0
+
+    def do_update_window_size(self):
+        self.width, self.height = next(self.sizes)
+        self.hwnd = 1
+        self.updates += 1
+
+
+class TestStartController(unittest.TestCase):
+    def make_controller(self):
+        controller = StartController.__new__(StartController)
+        controller.exit_event = threading.Event()
+        controller.start_timeout = 20
+        controller.STARTED_WINDOW_STABLE_SECONDS = 2
+        controller.STARTED_WINDOW_POLL_INTERVAL = 1
+        return controller
+
+    def test_started_window_must_be_usable_and_stable_before_continuing(self):
+        controller = self.make_controller()
+        window = FakeWindow([(80, 80), (120, 120), (140, 120), (140, 120), (140, 120)])
+        clock = FakeClock()
+        fake_og = SimpleNamespace(device_manager=SimpleNamespace(hwnd_window=window))
+
+        with patch.object(start_controller_module, 'og', fake_og), \
+                patch.object(start_controller_module.time, 'monotonic', clock.monotonic), \
+                patch.object(start_controller_module.time, 'sleep', clock.sleep):
+            self.assertTrue(controller._wait_until_started_window_stable())
+
+        self.assertEqual(5, window.updates)
+
+    def test_started_window_wait_does_not_restart_countdown(self):
+        controller = self.make_controller()
+        controller.STARTED_WINDOW_STABLE_SECONDS = 1
+        controller.STARTED_WINDOW_POLL_INTERVAL = 0.2
+        window = FakeWindow([(120, 120)] * 6)
+        clock = FakeClock()
+        fake_og = SimpleNamespace(device_manager=SimpleNamespace(hwnd_window=window))
+        emit = Mock()
+        fake_communicate = SimpleNamespace(starting_emulator=SimpleNamespace(emit=emit))
+
+        with patch.object(start_controller_module, 'og', fake_og), \
+                patch.object(start_controller_module, 'communicate', fake_communicate), \
+                patch.object(start_controller_module.time, 'monotonic', clock.monotonic), \
+                patch.object(start_controller_module.time, 'sleep', clock.sleep):
+            self.assertTrue(controller._wait_until_started_window_stable())
+
+        emit.assert_not_called()
+
+    def test_started_windows_wait_for_stability_before_capture_readiness(self):
+        controller = self.make_controller()
+        device_manager = Mock()
+        device_manager.get_preferred_device.return_value = {
+            'connected': False,
+            'device': 'windows',
+        }
+        device_manager.get_exe_path.return_value = r'C:\game.exe'
+        fake_og = SimpleNamespace(
+            device_manager=device_manager,
+            global_config=Mock(),
+        )
+        fake_og.global_config.get_config.return_value = None
+
+        call_order = []
+        controller._wait_until_started_window_stable = Mock(
+            side_effect=lambda: call_order.append('stable') or True)
+        controller._wait_until_device_ready = Mock(
+            side_effect=lambda: call_order.append('ready') or True)
+
+        with patch.object(start_controller_module, 'og', fake_og), \
+                patch.object(start_controller_module, 'is_admin', return_value=True), \
+                patch.object(start_controller_module, 'execute',
+                             side_effect=lambda *args, **kwargs: call_order.append('execute') or True):
+            self.assertTrue(controller.start_device())
+
+        self.assertEqual(['execute', 'stable', 'ready'], call_order)
+
+
+if __name__ == '__main__':
+    unittest.main()