fix: used multiprocessing to fix UI freeze

Author: Animesh404

openadapt/app/tray.py

@@ -21,14 +21,13 @@
 from datetime import datetime
 from functools import partial
 from pprint import pformat
-from threading import Event, Thread
+from threading import Thread
 from typing import Any, Callable
 import inspect
 import multiprocessing
-import time
 
 from pyqttoast import Toast, ToastButtonAlignment, ToastIcon, ToastPosition, ToastPreset
-from PySide6.QtCore import QMargins, QObject, QSize, Qt, QThread, QTimer, Signal
+from PySide6.QtCore import QMargins, QObject, QSize, Qt, QThread, Signal
 from PySide6.QtGui import QAction, QColor, QFont, QIcon, QPixmap
 from PySide6.QtWidgets import (
     QApplication,
@@ -46,7 +45,6 @@
     QVBoxLayout,
     QWidget,
 )
-import requests
 
 from openadapt.app import FPATH, quick_record, stop_record
 from openadapt.app.dashboard.run import cleanup as cleanup_dashboard
@@ -112,109 +110,6 @@ def run(self) -> None:
                 self.data.emit(data)
 
 
-class DashboardMonitor(QObject):
-    """Monitor dashboard initialization."""
-
-    ready = Signal()
-
-    def __init__(self, app: QApplication = None, port: int = 5173) -> None:
-        """Initializes the DashboardMonitor.
-
-        Args:
-            app (QApplication, optional): The QApplication instance. Defaults to None.
-            port (int, optional): The port number for the dashboard. Defaults to 5173.
-
-        Attributes:
-            stop_flag (Event): An event flag to signal stopping the monitor.
-            port (int): The port number for the dashboard.
-            _is_ready (bool): A flag indicating if the monitor is ready.
-            monitor_thread (QThread or None): The thread for monitoring.
-        """
-        super().__init__()
-        self.stop_flag = Event()
-        self.port = port
-        self._is_ready = False
-
-        if app is not None:
-            self.monitor_thread = QThread()
-            self.moveToThread(self.monitor_thread)
-            self.monitor_thread.started.connect(self.monitor_startup)
-            self.monitor_thread.finished.connect(self.on_thread_finished)
-        else:
-            self.monitor_thread = None
-
-        print("DEBUG(DashboardMonitor): Signal ready created")
-
-        # Connect to our own ready signal to update state
-        self.ready.connect(self._update_ready_state)
-
-    def _update_ready_state(self) -> None:
-        """Update internal ready state when signal is emitted."""
-        self._is_ready = True
-        print("DEBUG(DashboardMonitor): Ready state updated")
-
-    def on_thread_finished(self) -> None:
-        """Handle thread finished signal."""
-        logger.info("Dashboard monitor thread finished")
-
-    def monitor_startup(self) -> None:
-        """Monitor dashboard startup process."""
-        logger.info("Starting dashboard monitoring")
-        start_time = time.time()
-        try:
-            while not self.stop_flag.is_set():
-                try:
-                    elapsed_time = time.time() - start_time
-                    print(
-                        "DEBUG(DashboardMonitor): Checking dashboard. Elapsed:"
-                        f" {elapsed_time:.2f}s"
-                    )
-
-                    response = requests.get(f"http://localhost:{self.port}", timeout=1)
-                    if response.status_code == 200:
-                        logger.info("Dashboard is ready!")
-
-                        # Emit signal in main thread
-                        QTimer.singleShot(0, self.on_dashboard_ready)
-                        break
-                except requests.RequestException as e:
-                    logger.debug(f"Connection attempt failed: {e}")
-                    time.sleep(0.5)
-
-                if time.time() - start_time > 30:
-                    logger.warning("Monitoring timeout")
-                    break
-        finally:
-            self.monitor_thread.quit()
-
-    def on_dashboard_ready(self) -> None:
-        """Handle dashboard being ready."""
-        try:
-            self.ready.emit()
-            logger.info("Emitting ready signal")
-        except Exception as e:
-            logger.error(f"Error emitting signal: {e}")
-
-    def check_ready_state(self) -> None:
-        """Check if dashboard is ready and re-emit if necessary."""
-        if self._is_ready:
-            QTimer.singleShot(0, self.on_dashboard_ready)
-
-    def stop(self) -> None:
-        """Stop monitoring and cleanup thread."""
-        logger.info("Stopping dashboard monitor")
-        self.stop_flag.set()
-
-        if self.monitor_thread and self.monitor_thread.isRunning():
-            try:
-                self.monitor_thread.quit()
-                if not self.monitor_thread.wait(1000):
-                    logger.warning("Dashboard monitor thread did not stop cleanly")
-                    self.monitor_thread.terminate()
-            except Exception as e:
-                logger.error(f"Error stopping dashboard monitor thread: {e}")
-
-
 class SystemTrayIcon:
     """System tray icon for OpenAdapt."""
 
@@ -225,13 +120,11 @@ class SystemTrayIcon:
     # storing actions is required to prevent garbage collection
     recording_actions = {"visualize": [], "replay": []}
 
-    def __init__(self, app: QApplication = None) -> None:
+    def __init__(self) -> None:
         """Initialize the system tray icon."""
-        if app is None:
+        self.app = QApplication.instance()
+        if not self.app:
             self.app = QApplication([])
-        else:
-            self.app = app
-
         if sys.platform == "darwin":
             # hide Dock icon while allowing focus on dialogs
             # (must come after QApplication())
@@ -613,36 +506,13 @@ def populate_menu(self, menu: QMenu, action: Callable, action_type: str) -> None
 
     def launch_dashboard(self) -> None:
         """Launch the web dashboard."""
-        try:
-            if self.dashboard_thread:
-                if is_running_from_executable():
-                    return
-                cleanup_dashboard()
-                self.dashboard_thread.join()
-
-            # Start dashboard
-            self.dashboard_thread = run_dashboard()
-            self.dashboard_thread.start()
-            logger.info("Dashboard thread started")
-
-            # Initialize dashboard monitor
-            self.dashboard_monitor = DashboardMonitor(app=self.app)
-
-            # Connect ready signal BEFORE starting monitoring
-            self.dashboard_monitor.ready.connect(
-                self.on_dashboard_ready, Qt.ConnectionType.QueuedConnection
-            )
-
-            # Start monitoring
-            self.dashboard_monitor.monitor_startup()
-            logger.info("Dashboard monitor started")
-
-        except Exception as e:
-            logger.error(f"Launch dashboard error: {e}")
-
-    def on_dashboard_ready(self) -> None:
-        """Handle dashboard being ready."""
-        logger.info("Dashboard is ready - performing final setup")
+        if self.dashboard_thread:
+            if is_running_from_executable():
+                return
+            cleanup_dashboard()
+            self.dashboard_thread.join()
+        self.dashboard_thread = run_dashboard()
+        self.dashboard_thread.start()
 
     def run(self) -> None:
         """Run the system tray icon."""