MayoStainHelper/core/camera/camera_manager.py

from PySide6.QtCore import QObject, Signal, QRunnable, QThreadPool, QThread
from PySide6.QtGui import QPixmap

from .camera_controller import CameraController
from .gphoto_camera import GPhotoCamera
from .opencv_camera import OpenCvCamera
from .base_camera import BaseCamera


class CameraDetectionWorker(QRunnable):
    """
    Worker thread for detecting cameras to avoid blocking the GUI.
    """
    class WorkerSignals(QObject):
        finished = Signal(list)
        error = Signal(str)

    def __init__(self):
        super().__init__()
        self.signals = self.WorkerSignals()

    def run(self) -> None:
        """The main work of the worker."""
        detected_cameras = []
        
        try:
            gphoto_cameras = GPhotoCamera.detect()
            for index, info in gphoto_cameras.items():
                detected_cameras.append({
                    "id": f"gphoto_{index}",
                    "name": f"{info['name']} ({info['port']})",
                    "type": "gphoto",
                    "index": index
                })
        except Exception as e:
            self.signals.error.emit(f"Błąd podczas wykrywania kamer GPhoto: {e}")

        try:
            opencv_cameras = OpenCvCamera.detect()
            for index, info in opencv_cameras.items():
                detected_cameras.append({
                    "id": f"opencv_{index}",
                    "name": f"OpenCV: {info['name']}",
                    "type": "opencv",
                    "index": index
                })
        except Exception as e:
            self.signals.error.emit(f"Błąd podczas wykrywania kamer OpenCV: {e}")

        self.signals.finished.emit(detected_cameras)


class CameraManager(QObject):
    """
    Zarządza wszystkimi operacjami związanymi z kamerami,
    stanowiąc fasadę dla reszty aplikacji.
    """
    # --- Public API Signals ---
    frame_ready = Signal(QPixmap)
    error_occurred = Signal(str)
    detection_started = Signal()
    cameras_detected = Signal(list)
    camera_started = Signal()
    camera_stopped = Signal()

    # --- Internal signals to communicate with worker thread ---
    _request_set_camera = Signal(BaseCamera, int)
    _request_start_camera = Signal()
    _request_stop_camera = Signal()
    _request_start_stream = Signal()
    _request_stop_stream = Signal()

    def __init__(self, parent: QObject | None = None) -> None:
        super().__init__(parent)
        
        self._camera_thread = QThread()
        self._camera_controller = CameraController()
        self._camera_controller.moveToThread(self._camera_thread)

        # --- Connections ---
        # Connect signals from controller to be re-emitted by manager
        self._camera_controller.frame_ready.connect(self.frame_ready)
        self._camera_controller.error_occurred.connect(self.error_occurred)
        
        # Connect internal requests to controller slots
        self._request_set_camera.connect(self._camera_controller.set_camera)
        self._request_start_camera.connect(self._camera_controller.start_camera)
        self._request_stop_camera.connect(self._camera_controller.stop_camera)
        self._request_start_stream.connect(self._camera_controller.start_stream)
        self._request_stop_stream.connect(self._camera_controller.stop_stream)

        # Connect thread management
        self._camera_thread.started.connect(self._camera_controller.run)
        
        self._camera_thread.start()

        self._detected_cameras: list[dict] = []
        self._active_camera_info: dict | None = None
        self.thread_pool = QThreadPool.globalInstance() # For detection worker

    def detect_cameras(self) -> None:
        self.detection_started.emit()
        worker = CameraDetectionWorker()
        worker.signals.finished.connect(self._on_detection_finished)
        worker.signals.error.connect(self.error_occurred)
        self.thread_pool.start(worker)

    def _on_detection_finished(self, detected_cameras: list):
        self._detected_cameras = detected_cameras
        self.cameras_detected.emit(self._detected_cameras)

    def get_detected_cameras(self) -> list[dict]:
        return self._detected_cameras

    def start_camera(self, camera_id: str, fps: int = 15) -> None:
        if self._active_camera_info and self._active_camera_info['id'] == camera_id:
            return

        if self._active_camera_info:
            self.stop_camera()

        camera_info = next((c for c in self._detected_cameras if c['id'] == camera_id), None)

        if not camera_info:
            self.error_occurred.emit(f"Nie znaleziono kamery o ID: {camera_id}")
            return

        camera_type = camera_info['type']
        camera_index = camera_info['index']

        camera_instance: BaseCamera | None = None
        if camera_type == "gphoto":
            camera_instance = GPhotoCamera()
        elif camera_type == "opencv":
            camera_instance = OpenCvCamera()
        else:
            self.error_occurred.emit(f"Nieznany typ kamery: {camera_type}")
            return
        
        self._active_camera_info = camera_info
        
        # Emit signals to trigger slots in the worker thread
        self._request_set_camera.emit(camera_instance, fps)
        self._request_start_camera.emit()
        self._request_start_stream.emit()
        self.camera_started.emit()

    def stop_camera(self) -> None:
        if self._active_camera_info:
            # Emit signals to trigger slots in the worker thread
            self._request_stop_stream.emit()
            self._request_stop_camera.emit()
            self._active_camera_info = None
            self.camera_stopped.emit()

    def get_active_camera_info(self) -> dict | None:
        return self._active_camera_info

    def shutdown(self) -> None:
        if self._camera_thread.isRunning():
            self._camera_thread.quit()
            if not self._camera_thread.wait(5000):
                print("Camera thread did not finish gracefully, terminating.")
                self._camera_thread.terminate()
                self._camera_thread.wait()