@camera.ui/server 0.0.49 → 0.0.50-internal.0

package/dist/server/src/plugins/runtime/python/proxy/camera_device.py

@@ -0,0 +1,1732 @@
+import asyncio
+from collections.abc import AsyncGenerator
+from copy import deepcopy
+from datetime import datetime
+from typing import Any, Callable, Optional, Union, cast
+
+from cachetools import TTLCache
+from deepdiff.diff import DeepDiff
+from reactivex import operators as ops
+from reactivex.abc import DisposableBase
+from reactivex.subject.behaviorsubject import BehaviorSubject
+from typing_extensions import Literal, overload
+
+from _camera_ui_tools.camera_ui_common.camera_utils.utils import build_target_url
+from _camera_ui_tools.camera_ui_common.common_utils.subscribed import Subscribed
+from _camera_ui_tools.camera_ui_common.logger_service.logger import LoggerService as Logger
+from _camera_ui_tools.camera_ui_rpc_client import ClientInstance
+from _camera_ui_tools.camera_ui_rpc_client.typings import Message
+from _camera_ui_tools.camera_ui_rpc_client.utils.subscriptions import SubscriptionWrapper
+from _camera_ui_tools.camera_ui_types import (
+    AudioSetEvent,
+    AudioState,
+    BatterySetEvent,
+    BatteryState,
+    BoundingBox,
+    Camera,
+    CameraCapabilitiesObservableObject,
+    CameraDetectionSettings,
+    CameraDevice,
+    CameraDeviceCapability,
+    CameraDeviceSource,
+    CameraFrameWorkerSettings,
+    CameraInformation,
+    CameraInput,
+    CameraPropertyObservableObject,
+    CameraPublicProperties,
+    CameraSource,
+    CameraStateChangedObject,
+    CameraType,
+    DecoderFormat,
+    DetectionZone,
+    DoorbellSetEvent,
+    DoorbellState,
+    FMP4ConnectionOptions,
+    FrameData,
+    FrameType,
+    ImageOptions,
+    LightSetEvent,
+    LightState,
+    LoggerService,
+    MotionDetectionFrame,
+    MotionSetEvent,
+    MotionState,
+    ObjectSetEvent,
+    ObjectState,
+    ProbeConfig,
+    ProbeStream,
+    PTZInterface,
+    RTSPConnectionOptions,
+    RTSPUrlOptions,
+    SirenSetEvent,
+    SirenState,
+    SnapshotInterface,
+    StateNames,
+    StateValue,
+    StreamingInterface,
+    WebRTCConnectionOptions,
+)
+from _camera_ui_tools.camera_ui_types import (
+    PluginAPI as PluginAPIInterface,
+)
+from _camera_ui_tools.camera_ui_types import (
+    VideoFrame as VideoFrameInterface,
+)
+from _camera_ui_tools.camera_ui_types.hybrid_observer import HybridObservable
+from camera.python.classes import transform_labels
+from camera.python.interfaces import CameraInterface
+from camera.python.iou import merge_detections
+from camera.python.polygon import are_detections_valid
+from camera.python.typings import (
+    SetValue,
+)
+from camera.python.video_frame import VideoFrame
+from decoder.python.typings import FrameWorkerInterface
+from plugins.runtime.python.namespaces import (
+    CameraFrameWorkerPluginNamespaces,
+    NamespaceManager,
+)
+from plugins.runtime.python.typings import (
+    API_EVENT,
+    CameraDeviceInterface,
+    CameraInterfaces,
+    PluginCapabilities,
+    PluginInfo,
+)
+
+
+class CameraSourceImp(CameraSource):
+    def __init__(self, source: CameraInput, parent: Any):
+        self.__parent: CameraDeviceProxy = parent
+
+        self.id = source["_id"]
+        self.name = source["name"]
+        self.role = source["role"]
+        self.useForSnapshot = source["useForSnapshot"]
+        self.hotMode = source["hotMode"]
+        self.urls = source["urls"]
+
+    async def snapshot(self, force_new: bool | None = None) -> bytes | None:
+        return await self.__parent.snapshot(self.id, force_new)
+
+    async def probe_stream(
+        self, probe_config: Optional[ProbeConfig] = None, refresh: Optional[bool] = False
+    ) -> Optional[ProbeStream]:
+        return await self.__parent.probe_stream(self.id, probe_config, refresh)
+
+
+class CameraDeviceSourceImp(CameraSourceImp, CameraDeviceSource):
+    def __init__(self, source: CameraInput, parent: Any):
+        super().__init__(source, parent)
+        self.__parent: CameraDeviceProxy = parent
+
+    def generate_rtsp_url(self, options: Optional[RTSPUrlOptions]) -> str:
+        return build_target_url(self.urls["rtsp"]["base"], options)
+
+    def create_webrtc_session(self, options: Optional[WebRTCConnectionOptions]) -> None:
+        # Todo: Implement
+        pass
+
+    def create_rtsp_session(self, options: Optional[RTSPConnectionOptions]) -> None:
+        # Todo: Implement
+        pass
+
+    def create_fmp4_session(self, options: Optional[FMP4ConnectionOptions]) -> None:
+        # Todo: Implement
+        pass
+
+
+class CameraDeviceProxy(CameraDevice, Subscribed):
+    def __init__(
+        self,
+        proxy: ClientInstance,
+        api: PluginAPIInterface,
+        camera: Camera,
+        plugin: PluginInfo,
+        logger: LoggerService,
+    ):
+        Subscribed.__init__(self)
+
+        self.__camera_subject = BehaviorSubject(camera)
+        self.__camera_state = BehaviorSubject[bool](False)
+        self.__frame_worker_state = BehaviorSubject[bool](False)
+        self.__light_state = BehaviorSubject[LightState](self.__get_light_state({"state": False}, True))
+        self.__motion_state = BehaviorSubject[MotionState](
+            self.__get_motion_state({"detections": [], "state": False}, True)
+        )
+        self.__audio_state = BehaviorSubject[AudioState](
+            self.__get_audio_state({"state": False, "db": 0}, True)
+        )
+        self.__object_state = BehaviorSubject[ObjectState](self.__get_object_state({"detections": []}, True))
+        self.__doorbell_state = BehaviorSubject[DoorbellState](
+            self.__get_doorbell_state({"state": False}, True)
+        )
+        self.__siren_state = BehaviorSubject[SirenState](
+            self.__get_siren_state({"state": False, "level": 0}, True)
+        )
+        self.__battery_state = BehaviorSubject[BatteryState](
+            self.__get_battery_state({"level": 100, "charging": False, "lowBattery": False}, True)
+        )
+        self.__capabilities = BehaviorSubject[list[PluginCapabilities]]([])
+
+        self.on_connected: HybridObservable[bool] = self.__create_state_observable(self.__camera_state)
+        self.on_frameworker_connected: HybridObservable[bool] = self.__create_state_observable(
+            self.__frame_worker_state
+        )
+        self.on_light_switched: HybridObservable[LightState] = self.__create_state_observable(
+            self.__light_state
+        )
+        self.on_motion_detected: HybridObservable[MotionState] = self.__create_state_observable(
+            self.__motion_state
+        )
+        self.on_audio_detected: HybridObservable[AudioState] = self.__create_state_observable(
+            self.__audio_state
+        )
+        self.on_object_detected: HybridObservable[ObjectState] = self.__create_state_observable(
+            self.__object_state
+        )
+        self.on_doorbell_pressed: HybridObservable[DoorbellState] = self.__create_state_observable(
+            self.__doorbell_state
+        )
+        self.on_siren_detected: HybridObservable[SirenState] = self.__create_state_observable(
+            self.__siren_state
+        )
+        self.on_battery_changed: HybridObservable[BatteryState] = self.__create_state_observable(
+            self.__battery_state
+        )
+
+        if camera["pluginId"] == "native":
+            self.__camera_state.on_next(True)
+
+        self.logger = logger
+
+        self.__api = api
+        self.__proxy = proxy
+        self.__plugin = plugin
+        self.__snapshot_cache = TTLCache[str, bytes](maxsize=100, ttl=self.snapshot_ttl)
+        self.__namespaces: CameraFrameWorkerPluginNamespaces = {
+            **NamespaceManager.camera_namespaces(self.id),
+            **NamespaceManager.frame_worker_namespaces(self.id),
+            **NamespaceManager.plugin_camera_namespaces(self.__plugin["id"], self.id),
+        }
+
+        self.__initialized = False
+        self.__subscription: Optional[SubscriptionWrapper] = None
+
+        self.__camera_interfaces = CameraInterface(self.__proxy, self.__capabilities, self.id, self.plugin_id)
+
+        self.__api.once(API_EVENT.SHUTDOWN.value, self.cleanup)
+
+        self.add_subscriptions(
+            self.on_property_change("name").subscribe(self.__on_name_change),
+        )
+
+    @property
+    def camera_object(self) -> Camera:
+        return deepcopy(self.__camera_subject.value)
+
+    @property
+    def id(self) -> str:
+        return self.__camera_subject.value["_id"]
+
+    @property
+    def native_id(self) -> Optional[str]:
+        return self.__camera_subject.value.get("nativeId")
+
+    @property
+    def plugin_id(self) -> str:
+        return self.__camera_subject.value["pluginId"]
+
+    @property
+    def connected(self) -> bool:
+        return self.__camera_state.value or False
+
+    @property
+    def frameworker_connected(self) -> bool:
+        return self.__frame_worker_state.value or False
+
+    @property
+    def disabled(self) -> bool:
+        return self.__camera_subject.value["disabled"]
+
+    @property
+    def name(self) -> str:
+        return self.__camera_subject.value["name"]
+
+    @property
+    def type(self) -> CameraType:
+        return self.__camera_subject.value["type"]
+
+    @property
+    def info(self) -> CameraInformation:
+        return deepcopy(self.__camera_subject.value["info"])
+
+    @property
+    def is_cloud(self) -> bool:
+        return self.__camera_subject.value["isCloud"]
+
+    @property
+    def has_light(self) -> bool:
+        return self.has_capability(CameraDeviceCapability.Light)
+
+    @property
+    def has_siren(self) -> bool:
+        return self.has_capability(CameraDeviceCapability.Siren)
+
+    @property
+    def has_doorbell(self) -> bool:
+        return self.has_capability(CameraDeviceCapability.Doorbell)
+
+    @property
+    def has_battery(self) -> bool:
+        return self.has_capability(CameraDeviceCapability.Battery)
+
+    @property
+    def has_audio_detector(self) -> bool:
+        return self.has_capability(CameraDeviceCapability.AudioSensor)
+
+    @property
+    def has_motion_detector(self) -> bool:
+        return self.has_capability(CameraDeviceCapability.MotionSensor) or self.has_capability(
+            CameraDeviceCapability.MotionDetector
+        )
+
+    @property
+    def has_object_detector(self) -> bool:
+        return self.has_capability(CameraDeviceCapability.ObjectSensor) or self.has_capability(
+            CameraDeviceCapability.ObjectDetector
+        )
+
+    @property
+    def has_ptz(self) -> bool:
+        return self.has_capability(CameraDeviceCapability.PTZ)
+
+    @property
+    def snapshot_ttl(self) -> int:
+        return self.__camera_subject.value["snapshotTTL"]
+
+    @property
+    def detection_zones(self) -> list[DetectionZone]:
+        return deepcopy(self.__camera_subject.value["detectionZones"])
+
+    @property
+    def detection_settings(self) -> CameraDetectionSettings:
+        return deepcopy(self.__camera_subject.value["detectionSettings"])
+
+    @property
+    def frameworker_settings(self) -> CameraFrameWorkerSettings:
+        return deepcopy(self.__camera_subject.value["frameWorkerSettings"])
+
+    @property
+    def sources(self) -> list[CameraDeviceSource]:
+        sources = deepcopy(self.__camera_subject.value["sources"])
+        return [CameraDeviceSourceImp(source, self) for source in sources]
+
+    @property
+    def stream_source(self) -> CameraDeviceSource:
+        source = self.high_resolution_source or self.mid_resolution_source or self.low_resolution_source
+        return cast(CameraDeviceSource, source)
+
+    @property
+    def snapshot_source(self) -> Optional[CameraSource]:
+        snapshot_source = next((source for source in self.sources if source.role == "snapshot"), None)
+
+        if not snapshot_source:
+            snapshot_source = next((source for source in self.sources if source.useForSnapshot), None)
+
+        return snapshot_source
+
+    @property
+    def high_resolution_source(self) -> Optional[CameraDeviceSource]:
+        return next((source for source in self.sources if source.role == "high-resolution"), None)
+
+    @property
+    def mid_resolution_source(self) -> Optional[CameraDeviceSource]:
+        return next(
+            (source for source in self.sources if "mid-resolution" in source.role == "mid-resolution"), None
+        )
+
+    @property
+    def low_resolution_source(self) -> Optional[CameraDeviceSource]:
+        return next(
+            (source for source in self.sources if "low-resolution" in source.role == "low-resolution"), None
+        )
+
+    @property
+    def interfaces(self) -> CameraInterfaces:
+        return self.__camera_interfaces
+
+    async def init(self) -> None:
+        if self.__initialized:
+            return
+
+        self.__initialized = True
+
+        self.__subscription = await self.__proxy.subscribe(
+            self.__namespaces["cameraSubject"], self.__on_event_message
+        )
+
+        await self.__proxy.register_rpc_handler(
+            self.__namespaces["cameraInterfacesRpc"], self.__camera_interfaces
+        )
+        await self.__refresh_states()
+
+    def extend(self, interfaces: PTZInterface | SnapshotInterface | StreamingInterface) -> None:
+        self.__camera_interfaces.interfaces = interfaces
+
+    async def connect(self) -> None:
+        camera_controller_proxy = await self.__camera_controller_proxy()
+        return await camera_controller_proxy.connect()
+
+    async def disconnect(self) -> None:
+        camera_controller_proxy = await self.__camera_controller_proxy()
+        return await camera_controller_proxy.disconnect()
+
+    @overload  # type: ignore[override]
+    async def get_frames(
+        self, frame_type: Literal["video"], options: Optional[ImageOptions] = None
+    ) -> AsyncGenerator[VideoFrameInterface, None]: ...
+    @overload
+    async def get_frames(
+        self, frame_type: Literal["motion"], options: Optional[ImageOptions] = None
+    ) -> AsyncGenerator[VideoFrameInterface, None]: ...
+    async def get_frames(  # type: ignore[misc]
+        self, frame_type: FrameType, options: Optional[ImageOptions] = None
+    ) -> AsyncGenerator[VideoFrameInterface, None]:
+        subscription: Optional[SubscriptionWrapper] = None
+        current_resolver: Optional[Callable[[Optional[MotionDetectionFrame]], None]] = None
+        cap_subscription: Optional[DisposableBase] = None
+        motion_subscription: Optional[DisposableBase] = None
+        current_type = frame_type
+
+        # For motion sensor only
+        motion_detected: bool = False
+        frameWorkerGenerator: Optional[AsyncGenerator[FrameData, None]] = None
+        pendingFramePromise: Optional[asyncio.Task[Any]] = None
+
+        def is_motion_detector() -> bool:
+            return self.has_motion_detector and self.has_capability(CameraDeviceCapability.MotionDetector)
+
+        def is_motion_sensor_only() -> bool:
+            return (
+                self.has_motion_detector
+                and not self.has_capability(CameraDeviceCapability.MotionDetector)
+                and self.has_capability(CameraDeviceCapability.MotionSensor)
+            )
+
+        async def stop_frameworker_generator() -> None:
+            nonlocal frameWorkerGenerator, pendingFramePromise
+            if frameWorkerGenerator is not None:
+                try:
+                    await frameWorkerGenerator.aclose()
+                except:  # noqa: E722
+                    pass
+                finally:
+                    frameWorkerGenerator = None
+
+            if pendingFramePromise is not None and not pendingFramePromise.done():
+                pendingFramePromise.cancel()
+            pendingFramePromise = None
+
+        try:
+            frame_worker_proxy = await self.__frame_worker_proxy()
+            queue: list[MotionDetectionFrame] = []
+
+            # Subscribe to motion frames if needed for motion detector
+            if current_type == "motion":
+
+                def on_frame(message: Message[MotionDetectionFrame]) -> None:
+                    nonlocal current_resolver
+                    if current_resolver:
+                        current_resolver(message["data"])
+                        current_resolver = None
+                    else:
+                        queue.append(message["data"])
+
+                subscription = await self.__proxy.subscribe(
+                    self.__namespaces["cameraMotionFrameSubject"], on_frame
+                )
+
+                # For motion sensor, subscribe to motion events
+                if is_motion_sensor_only():
+                    # Initialize motion state from current value
+                    motion_detected = self.__motion_state.value.get("state", False)
+
+                    # Subscribe to motion state changes
+                    def on_motion_detected(state: MotionState) -> None:
+                        nonlocal motion_detected, current_resolver
+                        new_motion_state = state.get("state", False)
+                        if new_motion_state != motion_detected:
+                            motion_detected = new_motion_state
+
+                            # If motion just started and we're waiting, resolve to continue the loop
+                            if motion_detected and current_resolver:
+                                current_resolver(None)
+                                current_resolver = None
+
+                    motion_subscription = self.on_motion_detected.subscribe(on_motion_detected)
+
+            # Subscribe to changes in capabilities
+            if frame_type == "motion":
+
+                async def on_capabilities_change(capabilities: CameraCapabilitiesObservableObject) -> None:
+                    nonlocal current_type, current_resolver, frameWorkerGenerator, pendingFramePromise
+
+                    new_capabilities: list[CameraDeviceCapability] = capabilities["new_capabilities"]
+                    old_capabilities: list[CameraDeviceCapability] = capabilities["old_capabilities"]
+
+                    had_motion_detector = CameraDeviceCapability.MotionDetector in old_capabilities
+                    has_motion_detector_now = CameraDeviceCapability.MotionDetector in new_capabilities
+                    has_new_motion_detector = is_motion_detector() or is_motion_sensor_only()
+
+                    # Case 1: Currently in motion mode, but no motion detector available anymore
+                    if current_type == "motion" and not has_new_motion_detector:
+                        self.logger.trace("Switching to stream mode due to missing motion detector")
+
+                        # Reset any motion sensor state
+                        await stop_frameworker_generator()
+
+                        # If we're waiting for motion, resolve to restart the loop
+                        if current_resolver:
+                            current_resolver(None)
+                            current_resolver = None
+
+                    # Case 2: Currently in stream mode, but motion detector available now
+                    elif current_type == "stream" and has_new_motion_detector:
+                        self.logger.trace("Switching to motion mode due to motion detector being available")
+                        current_type = frame_type
+
+                    # Case 3: Currently in motion sensor mode, but motion detector available now
+                    elif current_type == "motion" and not had_motion_detector and has_motion_detector_now:
+                        self.logger.trace("Switching from motion sensor to motion detector")
+
+                        # Reset any motion sensor state
+                        await stop_frameworker_generator()
+
+                        # If we're waiting for motion, resolve to restart the loop
+                        if current_resolver:
+                            current_resolver(None)
+                            current_resolver = None
+
+                    # Case 4: Currently using motion detector, but now switching back to motion sensor
+                    elif (
+                        current_type == "motion"
+                        and had_motion_detector
+                        and not has_motion_detector_now
+                        and is_motion_sensor_only()
+                    ):
+                        self.logger.trace("Switching from motion detector to motion sensor")
+                        # Reset frameWorkerGenerator so it will be re-initialized for motion sensor mode
+                        if frameWorkerGenerator is None and current_resolver:
+                            # If we're waiting for motion (which is likely since motion detector was removed),
+                            # resolve to restart the loop in built-in mode
+                            current_resolver(None)
+                            current_resolver = None
+
+                cap_subscription = self.on_capabilities_change().asubscribe(on_capabilities_change)
+
+            async def get_prebuffered_frame(timestamp: int) -> Optional[FrameData]:
+                try:
+                    return await frame_worker_proxy.getPrebufferedFrame(timestamp, options)
+                except:  # noqa: E722
+                    return None
+
+            async def process_motion_frame(motion_frame: MotionDetectionFrame) -> FrameData:
+                frame_format = motion_frame["frame"]["info"]["format"]
+                frame_width = motion_frame["frame"]["info"]["width"]
+                frame_height = motion_frame["frame"]["info"]["height"]
+
+                requested_format = (
+                    options.get("format", {}).get("to", frame_format) if options else frame_format
+                )
+                requested_width = (
+                    (
+                        options.get("resize", {}).get("width")
+                        or options.get("crop", {}).get("width")
+                        or frame_width
+                    )
+                    if options
+                    else frame_width
+                )
+                requested_height = (
+                    (
+                        options.get("resize", {}).get("height")
+                        or options.get("crop", {}).get("height")
+                        or frame_height
+                    )
+                    if options
+                    else frame_height
+                )
+
+                process_frame = (
+                    requested_format != frame_format
+                    or requested_width != frame_width
+                    or requested_height != frame_height
+                )
+
+                if process_frame and options:
+                    prebuffered_frame = await get_prebuffered_frame(motion_frame["frame"]["timestamp"])
+                    if prebuffered_frame:
+                        return prebuffered_frame
+                    else:
+                        format: Union[DecoderFormat, Literal["rgba", "gray"]] = (
+                            "rgb24" if frame_format == "rgb" else frame_format
+                        )
+                        frame_data = await frame_worker_proxy.processFrame(
+                            motion_frame["frame"]["data"], frame_width, frame_height, format, options
+                        )
+                        return {
+                            "data": frame_data["image"],
+                            "info": frame_data["info"],
+                            "metadata": {
+                                "format": motion_frame["frame"]["metadata"]["format"],
+                                "frameSize": motion_frame["frame"]["metadata"]["frameSize"],
+                                "height": frame_data["info"]["height"],
+                                "width": frame_data["info"]["width"],
+                                "origHeight": motion_frame["frame"]["info"]["height"],
+                                "origWidth": motion_frame["frame"]["info"]["width"],
+                            },
+                            "timestamp": motion_frame["frame"]["timestamp"],
+                        }
+                else:
+                    return motion_frame["frame"]
+
+            while self.__initialized:
+                try:
+                    # Handle motion detector
+                    if current_type == "motion" and is_motion_detector():
+                        if queue:
+                            motion_frame = queue.pop(0)
+                            motion_frame["frame"] = await process_motion_frame(motion_frame)
+                            yield VideoFrame(
+                                motion_frame["frame"],
+                                self.__namespaces["frameWorkerChildRpc"],
+                                self.__proxy,
+                                motion_frame["state"],
+                            )
+                        else:
+                            future: asyncio.Future[Union[MotionDetectionFrame, None]] = asyncio.Future()
+                            current_resolver = future.set_result
+                            motion_frame_exists = await future
+
+                            if not motion_frame_exists:
+                                current_type = "stream"
+                                continue
+
+                            motion_frame = motion_frame_exists
+                            motion_frame["frame"] = await process_motion_frame(motion_frame)
+                            yield VideoFrame(
+                                motion_frame["frame"],
+                                self.__namespaces["frameWorkerChildRpc"],
+                                self.__proxy,
+                                motion_frame["state"],
+                            )
+                    # Handle motion sensor
+                    elif current_type == "motion" and is_motion_sensor_only():
+                        # Initialize frame generator immediately if needed
+                        if frameWorkerGenerator is None:
+                            self.logger.trace("Initializing frame worker generator for motion sensor")
+                            frameWorkerGenerator = frame_worker_proxy.generateFrames(options)
+
+                            # Execute first next() to establish the connection
+                            try:
+                                # Discard the first frame - we just want to establish the connection
+                                await frameWorkerGenerator.__anext__()
+                            except Exception as e:
+                                self.logger.warn(f"Failed to initialize frame worker generator: {str(e)}")
+                                frameWorkerGenerator = None
+                                current_type = "stream"
+                                continue
+
+                        # If no motion detected, wait for it
+                        if not motion_detected:
+                            future = asyncio.Future()
+                            current_resolver = future.set_result
+                            await future
+                            continue
+
+                        # Motion is detected - get the most current frame
+                        try:
+                            frame = await frameWorkerGenerator.__anext__()
+                        except StopAsyncIteration:
+                            # Generator ended, reset and switch to stream
+                            frameWorkerGenerator = None
+                            current_type = "stream"
+                            continue
+
+                        # Create a synthetic motion state for the frame
+                        motion_state: MotionSetEvent = {
+                            "state": True,
+                            "detections": self.__motion_state.value.get("detections", []),
+                        }
+
+                        # Yield the frame with motion state
+                        yield VideoFrame(
+                            frame, self.__namespaces["frameWorkerChildRpc"], self.__proxy, motion_state
+                        )
+                    else:
+                        # Handle regular streaming
+                        # Reset motion sensor resources if switching modes
+                        if frameWorkerGenerator is not None:
+                            frameWorkerGenerator = None
+                            pendingFramePromise = None
+
+                        # Regular stream mode
+                        async for frame in frame_worker_proxy.generateFrames(options):
+                            if (current_type == "motion" and is_motion_detector()) or (
+                                current_type == "motion" and is_motion_sensor_only()
+                            ):
+                                break  # Break stream loop to switch back to motion mode
+                            yield VideoFrame(frame, self.__namespaces["frameWorkerChildRpc"], self.__proxy)
+
+                except (StopAsyncIteration, GeneratorExit):
+                    self.logger.trace("Stopping frame generator")
+                    break
+
+        except Exception as e:
+            if not self.__initialized:
+                return
+
+            raise e
+
+        finally:
+            if subscription:
+                await subscription.unsubscribe()
+            if cap_subscription:
+                cap_subscription.dispose()
+            if motion_subscription:
+                motion_subscription.dispose()
+            if pendingFramePromise and not pendingFramePromise.done():
+                pendingFramePromise.cancel()
+
+    def add_capabilities(self, capabilities: list[CameraDeviceCapability]) -> None:
+        new_capabilities: list[CameraDeviceCapability] = []
+
+        for capability in capabilities:
+            if not self.has_capability(capability):
+                new_capabilities.append(capability)
+
+        if new_capabilities:
+            all_capabilities = deepcopy(self.__capabilities.value)
+            plugin_related_capabilities = next(
+                (cap for cap in all_capabilities if cap["pluginId"] == self.__plugin["id"]), None
+            )
+
+            if plugin_related_capabilities:
+                plugin_related_capabilities["capabilities"].extend(new_capabilities)
+            else:
+                all_capabilities.append({"pluginId": self.__plugin["id"], "capabilities": new_capabilities})
+
+            self.__capabilities.on_next(all_capabilities)
+
+            async def updateCapabilities() -> None:
+                try:
+                    camera_controller_proxy = await self.__camera_controller_proxy()
+                    await camera_controller_proxy.addPluginCapabilities(self.__plugin["id"], new_capabilities)
+                except asyncio.CancelledError:
+                    # Ignore cancellation errors
+                    pass
+                # except Exception as e:
+                #     self.logger.error("Failed to add capabilities:", e)
+                except:  # noqa: E722
+                    pass
+
+            asyncio.create_task(updateCapabilities())
+
+    def remove_capabilities(self, capabilities: list[CameraDeviceCapability]) -> None:
+        all_capabilities = deepcopy(self.__capabilities.value)
+        plugin_related_capabilities = next(
+            (cap for cap in all_capabilities if cap["pluginId"] == self.__plugin["id"]), None
+        )
+
+        if plugin_related_capabilities:
+            plugin_related_capabilities["capabilities"] = (
+                []
+                if len(capabilities) == 0
+                else [cap for cap in plugin_related_capabilities["capabilities"] if cap not in capabilities]
+            )
+
+            if not plugin_related_capabilities["capabilities"]:
+                all_capabilities.remove(plugin_related_capabilities)
+
+            self.__capabilities.on_next(all_capabilities)
+
+            async def updateCapabilities() -> None:
+                try:
+                    camera_controller_proxy = await self.__camera_controller_proxy()
+                    await camera_controller_proxy.removePluginCapabilities(self.__plugin["id"], capabilities)
+                except Exception as e:
+                    if not self.__initialized:
+                        return
+
+                    self.logger.error("Failed to remove capabilities:", e)
+
+            asyncio.create_task(updateCapabilities())
+
+    def get_capabilities(self) -> list[CameraDeviceCapability]:
+        capabilities: list[CameraDeviceCapability] = []
+        for capability in self.__capabilities.value:
+            if capability["capabilities"]:
+                capabilities.extend(capability["capabilities"])
+
+        return capabilities
+
+    def has_capability(self, capability: CameraDeviceCapability) -> bool:
+        capabilities = self.get_capabilities()
+        return capability in capabilities
+
+    @overload
+    def get_value(self, state_name: Literal["light"]) -> LightState: ...
+    @overload
+    def get_value(self, state_name: Literal["motion"]) -> MotionState: ...
+    @overload
+    def get_value(self, state_name: Literal["audio"]) -> AudioState: ...
+    @overload
+    def get_value(self, state_name: Literal["object"]) -> ObjectState: ...
+    @overload
+    def get_value(self, state_name: Literal["doorbell"]) -> DoorbellState: ...
+    @overload
+    def get_value(self, state_name: Literal["siren"]) -> SirenState: ...
+    @overload
+    def get_value(self, state_name: Literal["battery"]) -> BatteryState: ...
+    def get_value(
+        self, state_name: Literal["light", "motion", "audio", "object", "doorbell", "siren", "battery"]
+    ) -> Union[
+        LightState,
+        MotionState,
+        AudioState,
+        ObjectState,
+        DoorbellState,
+        SirenState,
+        BatteryState,
+    ]:
+        if state_name == "light":
+            return deepcopy(self.__light_state.value)
+        elif state_name == "motion":
+            return deepcopy(self.__motion_state.value)
+        elif state_name == "audio":
+            return deepcopy(self.__audio_state.value)
+        elif state_name == "object":
+            return deepcopy(self.__object_state.value)
+        elif state_name == "doorbell":
+            return deepcopy(self.__doorbell_state.value)
+        elif state_name == "siren":
+            return deepcopy(self.__siren_state.value)
+        elif state_name == "battery":
+            return deepcopy(self.__battery_state.value)
+        else:
+            raise Exception(f"Unknown state: {state_name}")
+
+    @overload
+    async def update_state(
+        self,
+        state_name: Literal["light"],
+        event_data: LightSetEvent,
+    ) -> None: ...
+    @overload
+    async def update_state(
+        self,
+        state_name: Literal["motion"],
+        event_data: MotionSetEvent,
+        frame: Optional[VideoFrameInterface] = None,
+    ) -> None: ...
+    @overload
+    async def update_state(
+        self,
+        state_name: Literal["audio"],
+        event_data: AudioSetEvent,
+    ) -> None: ...
+    @overload
+    async def update_state(
+        self,
+        state_name: Literal["object"],
+        event_data: ObjectSetEvent,
+    ) -> None: ...
+    @overload
+    async def update_state(
+        self,
+        state_name: Literal["doorbell"],
+        event_data: DoorbellSetEvent,
+    ) -> None: ...
+    @overload
+    async def update_state(
+        self,
+        state_name: Literal["siren"],
+        event_data: SirenSetEvent,
+    ) -> None: ...
+    @overload
+    async def update_state(
+        self,
+        state_name: Literal["battery"],
+        event_data: BatterySetEvent,
+    ) -> None: ...
+    async def update_state(
+        self, state_name: Any, event_data: Any, frame: Optional[VideoFrameInterface] = None
+    ) -> None:
+        try:
+            can_update = self.__can_update_state_internal(state_name)
+            if not can_update:
+                self.logger.warn(f"State '{state_name}' can only be updated by the corresponding plugin.")
+                return
+
+            changed, event = cast(tuple[bool, Any], self.__check_state_internal(state_name, event_data))
+
+            if not changed:
+                return
+
+            self.__update_state_internal(state_name, event, True)
+
+            if state_name == "motion" and frame and self.has_object_detector:
+                motion_event = cast(MotionSetEvent, event)
+                if motion_event["state"] and "detections" in motion_event and motion_event["detections"]:
+                    motion_frame: MotionDetectionFrame = {
+                        "frame": {
+                            "data": frame.data,
+                            "info": frame.info,
+                            "metadata": frame.metadata,
+                            "timestamp": int(datetime.now().timestamp() * 1000),
+                        },
+                        "state": motion_event,
+                    }
+
+                    await self.__proxy.publish(self.__namespaces["cameraMotionFrameSubject"], motion_frame)
+
+            camera_controller_proxy = await self.__camera_controller_proxy()
+            await camera_controller_proxy.updateState(state_name, event)
+        except Exception as e:
+            if not self.__initialized:
+                return
+
+            raise e
+
+    @overload
+    def on_state_change(
+        self, state_name: Literal["light"]
+    ) -> HybridObservable[CameraStateChangedObject[LightState]]: ...
+    @overload
+    def on_state_change(
+        self, state_name: Literal["motion"]
+    ) -> HybridObservable[CameraStateChangedObject[MotionState]]: ...
+    @overload
+    def on_state_change(
+        self, state_name: Literal["audio"]
+    ) -> HybridObservable[CameraStateChangedObject[AudioState]]: ...
+    @overload
+    def on_state_change(
+        self, state_name: Literal["doorbell"]
+    ) -> HybridObservable[CameraStateChangedObject[DoorbellState]]: ...
+    @overload
+    def on_state_change(
+        self, state_name: Literal["siren"]
+    ) -> HybridObservable[CameraStateChangedObject[SirenState]]: ...
+    @overload
+    def on_state_change(
+        self, state_name: Literal["battery"]
+    ) -> HybridObservable[CameraStateChangedObject[BatteryState]]: ...
+    @overload
+    def on_state_change(
+        self, state_name: Literal["object"]
+    ) -> HybridObservable[CameraStateChangedObject[ObjectState]]: ...
+    def on_state_change(self, state_name: Any) -> Any:
+        state: Union[BehaviorSubject[StateValue], None] = getattr(self, f"{state_name}_state", None)
+
+        if not state:
+            raise Exception(f"{state_name}_state not found")
+
+        def filter_fn(states: tuple[StateValue, StateValue]) -> bool:
+            old_state = states[0]
+            new_state = states[1]
+            return self.__state_changed(old_state, new_state, state_name)
+
+        def map_fn(states: tuple[StateValue, StateValue]) -> CameraStateChangedObject[StateValue]:
+            return {"old_state": states[0], "new_state": states[1]}
+
+        return HybridObservable(
+            state.pipe(
+                ops.pairwise(),
+                ops.filter(filter_fn),
+                ops.map(map_fn),
+                ops.share(),
+            )
+        )
+
+    def on_property_change(
+        self, property: Union[CameraPublicProperties, list[CameraPublicProperties]]
+    ) -> HybridObservable[CameraPropertyObservableObject]:
+        def map_fn(
+            cameras: tuple[Camera, Camera],
+        ) -> list[Any]:
+            properties: list[Any] = property if isinstance(property, list) else [property]
+
+            return [
+                {
+                    "property": prop,
+                    "old_state": cameras[0].get(prop),
+                    "new_state": cameras[1].get(prop),
+                }
+                for prop in properties
+            ]
+
+        def filter_fn(
+            camera: CameraPropertyObservableObject,
+        ) -> bool:
+            return (
+                DeepDiff(
+                    camera["old_state"],
+                    camera["new_state"],
+                    ignore_order=True,
+                )
+                != {}
+            )
+
+        return HybridObservable(
+            self.__camera_subject.pipe(
+                ops.pairwise(),
+                ops.flat_map(map_fn),
+                ops.filter(filter_fn),
+                ops.share(),
+            )
+        )
+
+    def on_capabilities_change(self) -> HybridObservable[CameraCapabilitiesObservableObject]:
+        def filter_fn(
+            capabilities: tuple[list[PluginCapabilities], list[PluginCapabilities]],
+        ) -> bool:
+            return (
+                DeepDiff(
+                    capabilities[0],
+                    capabilities[1],
+                    ignore_order=True,
+                    use_enum_value=True,
+                )
+                != {}
+            )
+
+        def map_fn(
+            capabilities: tuple[list[PluginCapabilities], list[PluginCapabilities]],
+        ) -> CameraCapabilitiesObservableObject:
+            old_capabilities: list[CameraDeviceCapability] = []
+            new_capabilities: list[CameraDeviceCapability] = []
+
+            for capability in capabilities[0]:
+                if capability["capabilities"]:
+                    old_capabilities.extend(capability["capabilities"])
+
+            for capability in capabilities[1]:
+                if capability["capabilities"]:
+                    new_capabilities.extend(capability["capabilities"])
+
+            return {
+                "old_capabilities": old_capabilities,
+                "new_capabilities": new_capabilities,
+            }
+
+        return HybridObservable(
+            self.__capabilities.pipe(
+                ops.pairwise(),
+                ops.filter(filter_fn),
+                ops.map(map_fn),
+                ops.share(),
+            )
+        )
+
+    async def snapshot(self, source_id: str, force_new: Optional[bool] = None) -> Optional[bytes]:
+        from_cache = self.__snapshot_cache.get(source_id) if source_id in self.__snapshot_cache else None
+        if from_cache and not force_new:
+            return from_cache
+        camera_controller_proxy = await self.__camera_controller_proxy()
+        snapshot = await camera_controller_proxy.snapshot(source_id, force_new)
+        if snapshot and len(snapshot) > 0:
+            self.__snapshot_cache[source_id] = snapshot
+            return snapshot
+
+        return None
+
+    async def probe_stream(
+        self, source_id: str, probe_config: Optional[ProbeConfig] = None, refresh: Optional[bool] = False
+    ) -> Optional[ProbeStream]:
+        camera_controller_proxy = await self.__camera_controller_proxy()
+        return await camera_controller_proxy.probeStream(source_id, probe_config, refresh)
+
+    async def cleanup(self) -> None:
+        self.__initialized = False
+        self.__remove_all_listeners()
+        self.unsubscribe()
+        self.__api.remove_listener(API_EVENT.SHUTDOWN.value, self.cleanup)
+        if self.__subscription:
+            await self.__subscription.unsubscribe()
+            self.__subscription = None
+        await self.__disconnect_rpc()
+
+    @overload
+    def __check_state_internal(
+        self,
+        state_name: Literal["light"],
+        event_data: LightSetEvent,
+        skip_detections_check: Optional[bool] = None,
+    ) -> tuple[bool, LightState]: ...
+    @overload
+    def __check_state_internal(
+        self,
+        state_name: Literal["motion"],
+        event_data: MotionSetEvent,
+        skip_detections_check: Optional[bool] = None,
+    ) -> tuple[bool, MotionState]: ...
+    @overload
+    def __check_state_internal(
+        self,
+        state_name: Literal["audio"],
+        event_data: AudioSetEvent,
+        skip_detections_check: Optional[bool] = None,
+    ) -> tuple[bool, AudioState]: ...
+    @overload
+    def __check_state_internal(
+        self,
+        state_name: Literal["object"],
+        event_data: ObjectSetEvent,
+        skip_detections_check: Optional[bool] = None,
+    ) -> tuple[bool, ObjectState]: ...
+    @overload
+    def __check_state_internal(
+        self,
+        state_name: Literal["doorbell"],
+        event_data: DoorbellSetEvent,
+        skip_detections_check: Optional[bool] = None,
+    ) -> tuple[bool, DoorbellState]: ...
+    @overload
+    def __check_state_internal(
+        self,
+        state_name: Literal["siren"],
+        event_data: SirenSetEvent,
+        skip_detections_check: Optional[bool] = None,
+    ) -> tuple[bool, SirenState]: ...
+    @overload
+    def __check_state_internal(
+        self,
+        state_name: Literal["battery"],
+        event_data: BatterySetEvent,
+        skip_detections_check: Optional[bool] = None,
+    ) -> tuple[bool, BatteryState]: ...
+    def __check_state_internal(
+        self,
+        state_name: Literal["light", "motion", "audio", "object", "doorbell", "siren", "battery"],
+        event_data: Union[
+            LightSetEvent,
+            MotionSetEvent,
+            AudioSetEvent,
+            ObjectSetEvent,
+            DoorbellSetEvent,
+            SirenSetEvent,
+            BatterySetEvent,
+        ],
+        skip_detections_check: Optional[bool] = None,
+    ) -> tuple[
+        bool,
+        Union[
+            LightState,
+            MotionState,
+            AudioState,
+            ObjectState,
+            DoorbellState,
+            SirenState,
+            BatteryState,
+        ],
+    ]:
+        changed = False
+        target_state: Optional[StateValue] = None
+
+        if state_name == "audio":
+            audio_event = cast(AudioSetEvent, event_data)
+            target_state = self.__get_audio_state(audio_event)
+            changed = self.__state_changed(self.get_value("audio"), target_state, "audio")
+
+        elif state_name == "light":
+            light_event = cast(LightSetEvent, event_data)
+            target_state = self.__get_light_state(light_event)
+            changed = self.__state_changed(self.get_value("light"), target_state, "light")
+
+        elif state_name == "motion":
+            motion_event = cast(MotionSetEvent, event_data)
+
+            if not motion_event["state"]:
+                motion_event["detections"] = []
+
+            if not skip_detections_check and "detections" in motion_event and motion_event["detections"]:
+                has_detections = len(motion_event["detections"]) > 0
+                motion_event["detections"] = transform_labels(motion_event["detections"])
+                motion_event["detections"] = merge_detections(motion_event["detections"])
+                motion_event["detections"] = are_detections_valid(
+                    motion_event["detections"], self.detection_zones, self.detection_settings
+                )
+                if has_detections and len(motion_event["detections"]) == 0:
+                    motion_event["state"] = False
+
+            # fix bounding box type to to tuple, do we need?
+            if "detections" in motion_event and motion_event["detections"]:
+                for det in motion_event["detections"]:
+                    det["boundingBox"] = cast(tuple[int, int, int, int], tuple(det["boundingBox"]))
+                    det["confidence"] = float(det["confidence"])
+
+            target_state = self.__get_motion_state(motion_event)
+            changed = self.__state_changed(self.get_value("motion"), target_state, "motion", True)
+
+        elif state_name == "object":
+            object_event = cast(ObjectSetEvent, event_data)
+
+            if not skip_detections_check:
+                object_event["detections"] = transform_labels(object_event["detections"])
+                object_event["detections"] = merge_detections(object_event["detections"])
+                object_event["detections"] = are_detections_valid(
+                    object_event["detections"], self.detection_zones, self.detection_settings
+                )
+
+            # fix bounding box type to to tuple
+            for det in object_event["detections"]:
+                det["boundingBox"] = cast(BoundingBox, tuple(det["boundingBox"]))
+                det["confidence"] = float(det["confidence"])
+
+            target_state = self.__get_object_state(object_event)
+            changed = self.__state_changed(self.get_value("object"), target_state, "object")
+
+        elif state_name == "doorbell":
+            doorbell_event = cast(DoorbellSetEvent, event_data)
+            target_state = self.__get_doorbell_state(doorbell_event)
+            changed = self.__state_changed(self.get_value("doorbell"), target_state, "doorbell")
+
+        elif state_name == "siren":
+            siren_event = cast(SirenSetEvent, event_data)
+            target_state = self.__get_siren_state(siren_event)
+            changed = self.__state_changed(self.get_value("siren"), target_state, "siren")
+
+        elif state_name == "battery":
+            battery_event = cast(BatterySetEvent, event_data)
+            target_state = self.__get_battery_state(battery_event)
+            changed = self.__state_changed(self.get_value("battery"), target_state, "battery")
+
+        else:
+            raise Exception(f"Unknown state: {state_name}")
+
+        return changed, target_state
+
+    def __can_update_state_internal(self, state_name: StateNames) -> bool:
+        if state_name == "audio":
+            audio_sensor_capability = next(
+                (
+                    cap
+                    for cap in self.__capabilities.value
+                    if CameraDeviceCapability.AudioSensor in cap["capabilities"]
+                ),
+                None,
+            )
+            return bool(
+                audio_sensor_capability and audio_sensor_capability["pluginId"] == self.__plugin["id"]
+            )
+
+        elif state_name == "motion":
+            motion_sensor_capability = next(
+                (
+                    cap
+                    for cap in self.__capabilities.value
+                    if CameraDeviceCapability.MotionSensor in cap["capabilities"]
+                ),
+                None,
+            )
+            motion_detector_capability = next(
+                (
+                    cap
+                    for cap in self.__capabilities.value
+                    if CameraDeviceCapability.MotionDetector in cap["capabilities"]
+                ),
+                None,
+            )
+            return bool(
+                (motion_sensor_capability and motion_sensor_capability["pluginId"] == self.__plugin["id"])
+                or (
+                    motion_detector_capability
+                    and motion_detector_capability["pluginId"] == self.__plugin["id"]
+                )
+            )
+
+        elif state_name == "object":
+            object_sensor_capability = next(
+                (
+                    cap
+                    for cap in self.__capabilities.value
+                    if CameraDeviceCapability.ObjectSensor in cap["capabilities"]
+                ),
+                None,
+            )
+            object_detector_capability = next(
+                (
+                    cap
+                    for cap in self.__capabilities.value
+                    if CameraDeviceCapability.ObjectDetector in cap["capabilities"]
+                ),
+                None,
+            )
+            return bool(
+                (object_sensor_capability and object_sensor_capability["pluginId"] == self.__plugin["id"])
+                or (
+                    object_detector_capability
+                    and object_detector_capability["pluginId"] == self.__plugin["id"]
+                )
+            )
+
+        elif state_name == "light":
+            light_capability = next(
+                (
+                    cap
+                    for cap in self.__capabilities.value
+                    if CameraDeviceCapability.Light in cap["capabilities"]
+                ),
+                None,
+            )
+            return bool(light_capability and light_capability["pluginId"] == self.__plugin["id"])
+
+        elif state_name == "doorbell":
+            doorbell_capability = next(
+                (
+                    cap
+                    for cap in self.__capabilities.value
+                    if CameraDeviceCapability.Doorbell in cap["capabilities"]
+                ),
+                None,
+            )
+            return bool(doorbell_capability and doorbell_capability["pluginId"] == self.__plugin["id"])
+
+        elif state_name == "siren":
+            siren_capability = next(
+                (
+                    cap
+                    for cap in self.__capabilities.value
+                    if CameraDeviceCapability.Siren in cap["capabilities"]
+                ),
+                None,
+            )
+            return bool(siren_capability and siren_capability["pluginId"] == self.__plugin["id"])
+
+        elif state_name == "battery":
+            battery_capability = next(
+                (
+                    cap
+                    for cap in self.__capabilities.value
+                    if CameraDeviceCapability.Battery in cap["capabilities"]
+                ),
+                None,
+            )
+            return bool(battery_capability and battery_capability["pluginId"] == self.__plugin["id"])
+
+    @overload
+    def __update_state_internal(
+        self,
+        state_name: Literal["light"],
+        event_data: LightSetEvent,
+        skip_check: Optional[bool] = None,
+        skip_detections_check: Optional[bool] = None,
+    ) -> None: ...
+    @overload
+    def __update_state_internal(
+        self,
+        state_name: Literal["motion"],
+        event_data: MotionSetEvent,
+        skip_check: Optional[bool] = None,
+        skip_detections_check: Optional[bool] = None,
+    ) -> None: ...
+    @overload
+    def __update_state_internal(
+        self,
+        state_name: Literal["audio"],
+        event_data: AudioSetEvent,
+        skip_check: Optional[bool] = None,
+        skip_detections_check: Optional[bool] = None,
+    ) -> None: ...
+    @overload
+    def __update_state_internal(
+        self,
+        state_name: Literal["object"],
+        event_data: ObjectSetEvent,
+        skip_check: Optional[bool] = None,
+        skip_detections_check: Optional[bool] = None,
+    ) -> None: ...
+    @overload
+    def __update_state_internal(
+        self,
+        state_name: Literal["doorbell"],
+        event_data: DoorbellSetEvent,
+        skip_check: Optional[bool] = None,
+        skip_detections_check: Optional[bool] = None,
+    ) -> None: ...
+    @overload
+    def __update_state_internal(
+        self,
+        state_name: Literal["siren"],
+        event_data: SirenSetEvent,
+        skip_check: Optional[bool] = None,
+        skip_detections_check: Optional[bool] = None,
+    ) -> None: ...
+    @overload
+    def __update_state_internal(
+        self,
+        state_name: Literal["battery"],
+        event_data: BatterySetEvent,
+        skip_check: Optional[bool] = None,
+        skip_detections_check: Optional[bool] = None,
+    ) -> None: ...
+    def __update_state_internal(
+        self,
+        state_name: Literal["light", "motion", "audio", "object", "doorbell", "siren", "battery"],
+        event_data: Union[
+            LightSetEvent,
+            MotionSetEvent,
+            AudioSetEvent,
+            ObjectSetEvent,
+            DoorbellSetEvent,
+            SirenSetEvent,
+            BatterySetEvent,
+        ],
+        skip_check: Optional[bool] = None,
+        skip_detections_check: Optional[bool] = None,
+    ) -> None:
+        if skip_check:
+            changed = True
+            event = event_data
+        else:
+            changed, event = cast(
+                tuple[
+                    bool,
+                    Union[
+                        LightSetEvent,
+                        MotionSetEvent,
+                        AudioSetEvent,
+                        ObjectSetEvent,
+                        DoorbellSetEvent,
+                        SirenSetEvent,
+                        BatterySetEvent,
+                    ],
+                ],
+                self.__check_state_internal(
+                    cast(Any, state_name), cast(Any, event_data), skip_detections_check
+                ),
+            )
+
+        if not changed:
+            return
+
+        if state_name == "light":
+            self.__light_state.on_next(self.__get_light_state(cast(LightSetEvent, event)))
+        elif state_name == "motion":
+            self.__motion_state.on_next(self.__get_motion_state(cast(MotionSetEvent, event)))
+        elif state_name == "audio":
+            self.__audio_state.on_next(self.__get_audio_state(cast(AudioSetEvent, event)))
+        elif state_name == "object":
+            self.__object_state.on_next(self.__get_object_state(cast(ObjectSetEvent, event)))
+        elif state_name == "doorbell":
+            self.__doorbell_state.on_next(self.__get_doorbell_state(cast(DoorbellSetEvent, event)))
+        elif state_name == "siren":
+            self.__siren_state.on_next(self.__get_siren_state(cast(SirenSetEvent, event)))
+        elif state_name == "battery" and self.has_battery:
+            self.__battery_state.on_next(self.__get_battery_state(cast(BatterySetEvent, event)))
+
+    def __create_state_observable(self, state_subject: BehaviorSubject[Any]) -> HybridObservable[Any]:
+        return HybridObservable(state_subject.pipe(ops.distinct_until_changed(), ops.share()))
+
+    def __update_camera(self, camera: Camera) -> None:
+        if camera["snapshotTTL"] != self.snapshot_ttl:
+            self.__snapshot_cache.clear()
+
+        self.__camera_subject.on_next(camera)
+
+    def __update_camera_state(self, state: bool) -> None:
+        self.__camera_state.on_next(state)
+
+    def __update_frameworker_state(self, state: bool) -> None:
+        self.__frame_worker_state.on_next(state)
+
+    def __update_capabilities(self, capabilities: list[PluginCapabilities]) -> None:
+        converted_capabilities: list[PluginCapabilities] = []
+
+        for plugin_cap in capabilities:
+            converted_plugin_cap = plugin_cap.copy()
+            converted_plugin_cap["capabilities"] = [
+                CameraDeviceCapability(cap_str) for cap_str in plugin_cap["capabilities"]
+            ]
+            converted_capabilities.append(converted_plugin_cap)
+
+        self.__capabilities.on_next(converted_capabilities)
+
+    async def __refresh_states(self) -> None:
+        camera_controller_proxy = await self.__camera_controller_proxy()
+        response = await camera_controller_proxy.refreshStates()
+
+        self.__update_camera(response["camera"])
+        self.__update_camera_state(response["cameraState"])
+        self.__update_frameworker_state(response["frameWorkerState"])
+        self.__update_capabilities(response["capabilities"])
+
+        states = cast(dict[Any, Any], response["states"])
+        for key, value in states.items():
+            self.__update_state_internal(key, value, True)
+
+    def __remove_all_listeners(self) -> None:
+        self.__light_state.on_completed()
+        self.__motion_state.on_completed()
+        self.__audio_state.on_completed()
+        self.__object_state.on_completed()
+        self.__doorbell_state.on_completed()
+        self.__siren_state.on_completed()
+        self.__battery_state.on_completed()
+        self.__camera_subject.on_completed()
+        self.__camera_state.on_completed()
+        self.__frame_worker_state.on_completed()
+        self.__capabilities.on_completed()
+        self.__snapshot_cache.clear()
+
+    def __state_changed(
+        self,
+        old_state: Optional[SetValue],
+        new_state: Optional[SetValue],
+        type_: Optional[StateNames],
+        test: Optional[bool] = False,
+    ) -> bool:
+        if not old_state or not new_state or not type_:
+            return False
+
+        if (
+            (type_ == "audio" and not self.has_audio_detector)
+            or (type_ == "motion" and not self.has_motion_detector)
+            or (type_ == "object" and not self.has_object_detector)
+            or (type_ == "siren" and not self.has_siren)
+            or (type_ == "battery" and not self.has_battery)
+            or (type_ == "doorbell" and not self.has_doorbell)
+            or (type_ == "light" and not self.has_light)
+        ):
+            return False
+
+        clean_old_state = self.__clean_state(old_state)
+        clean_new_state = self.__clean_state(new_state)
+
+        return DeepDiff(clean_old_state, clean_new_state, ignore_order=True) != {}
+
+    def __get_audio_state(
+        self, event: Union[AudioSetEvent, AudioState], ignore_last_event: bool = False
+    ) -> AudioState:
+        last_event: Optional[AudioState] = None
+
+        if ignore_last_event is False:
+            last_event = self.get_value("audio")
+            if last_event and "lastEvent" in last_event:
+                del last_event["lastEvent"]
+
+        if "timestamp" in event:
+            new_state: Any = event
+        else:
+            state = cast(AudioState, event).copy()
+            state["timestamp"] = int(datetime.now().timestamp() * 1000)
+
+            new_state = {
+                **state,
+                "db": event.get("db", None) or last_event.get("db", None) if last_event else 0,
+                "lastEvent": last_event,
+            }
+
+        return new_state
+
+    def __get_motion_state(
+        self, event: Union[MotionSetEvent, MotionState], ignore_last_event: bool = False
+    ) -> MotionState:
+        last_event: Optional[MotionState] = None
+
+        if ignore_last_event is False:
+            last_event = self.get_value("motion")
+            if last_event and "lastEvent" in last_event:
+                del last_event["lastEvent"]
+
+        if "timestamp" in event:
+            new_state: Any = event
+        else:
+            state = cast(MotionState, event).copy()
+            state["timestamp"] = int(datetime.now().timestamp() * 1000)
+
+            new_state = {
+                **state,
+                "lastEvent": last_event,
+            }
+
+        return new_state
+
+    def __get_object_state(
+        self, event: Union[ObjectSetEvent, ObjectState], ignore_last_event: bool = False
+    ) -> ObjectState:
+        last_event: Optional[ObjectState] = None
+
+        if ignore_last_event is False:
+            last_event = self.get_value("object")
+            if last_event and "lastEvent" in last_event:
+                del last_event["lastEvent"]
+
+        if "timestamp" in event:
+            new_state: Any = event
+        else:
+            state = cast(ObjectState, event).copy()
+            state["timestamp"] = int(datetime.now().timestamp() * 1000)
+
+            new_state = {
+                **state,
+                "lastEvent": last_event,
+            }
+
+        return new_state
+
+    def __get_doorbell_state(
+        self, event: Union[DoorbellSetEvent, DoorbellState], ignore_last_event: bool = False
+    ) -> DoorbellState:
+        last_event: Optional[DoorbellState] = None
+
+        if ignore_last_event is False:
+            last_event = self.get_value("doorbell")
+            if last_event and "lastEvent" in last_event:
+                del last_event["lastEvent"]
+
+        if "timestamp" in event:
+            new_state: Any = event
+        else:
+            state = cast(DoorbellState, event).copy()
+            state["timestamp"] = int(datetime.now().timestamp() * 1000)
+
+            new_state = {
+                **state,
+                "lastEvent": last_event,
+            }
+
+        return new_state
+
+    def __get_light_state(
+        self, event: Union[LightSetEvent, LightState], ignore_last_event: bool = False
+    ) -> LightState:
+        last_event: Optional[LightState] = None
+
+        if ignore_last_event is False:
+            last_event = self.get_value("light")
+            if last_event and "lastEvent" in last_event:
+                del last_event["lastEvent"]
+
+        if "timestamp" in event:
+            new_state: Any = event
+        else:
+            state = cast(LightState, event).copy()
+            state["timestamp"] = int(datetime.now().timestamp() * 1000)
+
+            new_state = {
+                **state,
+                "lastEvent": last_event,
+            }
+
+        return new_state
+
+    def __get_siren_state(
+        self, event: Union[SirenSetEvent, SirenState], ignore_last_event: bool = False
+    ) -> SirenState:
+        last_event: Optional[SirenState] = None
+
+        if ignore_last_event is False:
+            last_event = self.get_value("siren")
+            if last_event and "lastEvent" in last_event:
+                del last_event["lastEvent"]
+
+        if "timestamp" in event:
+            new_state: Any = event
+        else:
+            state = cast(SirenState, event).copy()
+            state["timestamp"] = int(datetime.now().timestamp() * 1000)
+
+            new_state = {
+                **state,
+                "level": event.get("level", None) or last_event.get("level", None) if last_event else 0,
+                "lastEvent": last_event,
+            }
+
+        return new_state
+
+    def __get_battery_state(
+        self, event: Union[BatterySetEvent, BatteryState], ignore_last_event: bool = False
+    ) -> BatteryState:
+        last_event: Optional[BatteryState] = None
+
+        if ignore_last_event is False:
+            last_event = self.get_value("battery")
+            if last_event and "lastEvent" in last_event:
+                del last_event["lastEvent"]
+
+        if "timestamp" in event:
+            new_state: Any = event
+        else:
+            state = cast(BatteryState, event).copy()
+            state["timestamp"] = int(datetime.now().timestamp() * 1000)
+
+            new_state = {
+                "level": event["level"],
+                "charging": event.get("charging", None) or last_event.get("charging", None)
+                if last_event
+                else False,
+                "lowBattery": event.get("lowBattery", None) or last_event.get("lowBattery", None)
+                if last_event
+                else False,
+                "timestamp": int(datetime.now().timestamp() * 1000),
+                "lastEvent": last_event,
+            }
+
+        return new_state
+
+    def __clean_state(self, state: Union[StateValue, SetValue]) -> SetValue:
+        state_copy: Any = deepcopy(state)
+
+        if "timestamp" in state_copy:
+            del state_copy["timestamp"]
+
+        if "lastEvent" in state_copy:
+            del state_copy["lastEvent"]
+
+        return state_copy
+
+    def __on_name_change(self, val: Any) -> None:
+        cast(Logger, self.logger).suffix = self.name
+
+    async def __on_event_message(self, event: Message[Any]) -> None:
+        if not self.__initialized:
+            return
+
+        message = event["data"]
+
+        if "type" in message:
+            type = message["type"]
+            if type == "removed":
+                await self.cleanup()
+            elif type == "updated":
+                self.__update_camera(message["data"])
+            elif type == "cameraState":
+                self.__update_camera_state(message["data"])
+            elif type == "frameWorkerState":
+                self.__update_frameworker_state(message["data"])
+            elif type == "capabilities":
+                self.__update_capabilities(message["data"])
+        else:
+            state_name = message["stateName"]
+            new_data = message["data"]["newEvent"]
+
+            self.__update_state_internal(state_name, new_data, True)
+
+    async def __frame_worker_proxy(self) -> FrameWorkerInterface:
+        return await self.__proxy.create_rpc_proxy(
+            FrameWorkerInterface, self.__namespaces["frameWorkerChildRpc"]
+        )
+
+    async def __camera_controller_proxy(self) -> CameraDeviceInterface:
+        return await self.__proxy.create_rpc_proxy(
+            CameraDeviceInterface, self.__namespaces["cameraControllerRpc"]
+        )
+
+    async def __disconnect_rpc(self) -> None:
+        await self.__proxy.unregister_rpc_handler(self.__namespaces["cameraInterfacesRpc"])
+        await self.__proxy.disconnect_rpc_connection(self.__namespaces["cameraControllerRpc"])
+        await self.__proxy.disconnect_rpc_connection(self.__namespaces["frameWorkerChildRpc"])
+        await self.__camera_interfaces.disconnect()