camera.ui3 0.0.30-alpha.0

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

@@ -0,0 +1,1599 @@
+import asyncio
+import inspect
+import traceback
+from collections.abc import AsyncGenerator
+from contextlib import suppress
+from copy import deepcopy
+from datetime import datetime
+from typing import Any, Optional, Union, cast
+from uuid import uuid4
+
+import aiohttp
+from cachetools import LRUCache, cached
+from camera.iou import merge_detections
+from camera.polygon import are_motion_detections_valid, are_object_detections_valid
+from camera.video_frame import MotionFrame, VideoFrame
+from camera_ui_types import (
+    AudioSetEvent,
+    AudioState,
+    BatterySetEvent,
+    BatteryState,
+    Camera,
+    CameraActivitySettings,
+    CameraConfigInputSettings,
+    CameraConfigInputSettingsPartial,
+    CameraDelegate,
+    CameraDelegateMethodNames,
+    CameraFrameWorkerSettings,
+    CameraInformation,
+    CameraInput,
+    CameraPrebufferDelegate,
+    CameraPrebufferDelegateMethodNames,
+    CameraPropertyObservableObject,
+    CameraPTZDelegate,
+    CameraPTZDelegateMethodNames,
+    CameraPublicProperties,
+    CameraType,
+    Container,
+    DetectionZone,
+    DoorbellSetEvent,
+    DoorbellState,
+    FrameData,
+    FrameMetadata,
+    FrameState,
+    LightSetEvent,
+    LightState,
+    MotionSetEvent,
+    MotionState,
+    ObjectSetEvent,
+    ObjectState,
+    PrebufferState,
+    SetValue,
+    SirenSetEvent,
+    SirenState,
+    StateNames,
+    StateValue,
+    StreamInfo,
+)
+from decoder.typings import AuthConfig, PingMessage, PongMessage, SignalingRequest, SignalingResponse
+from deepdiff import DeepDiff
+from message_queue import MessageQueue
+from nats.aio.msg import Msg
+from plugin_api import PluginAPI
+from plugin_logger import PluginLogger
+from reactivex import Observable
+from reactivex import operators as ops
+from reactivex.subject.behaviorsubject import BehaviorSubject
+from typing_extensions import Literal, overload
+from typings import (
+    CameraDeviceProxyMethodNames,
+    ClientType,
+    Delegates,
+    DeserializedError,
+    FrameSubscribtion,
+    PluginInfo,
+    ProxyMessageStructure,
+)
+from utilities.connection import ProxyConnection
+from utilities.packer import pack, unpack
+from utilities.subscriptions import ProxySubscription
+from utilities.task import TaskSet
+
+
+class CameraSource:
+    def __init__(self, source: CameraInput, parent: Any):
+        self.__parent: CameraDeviceProxy = parent
+
+        self.id = source["_id"]
+        self.name = source["name"]
+        self.roles = source["roles"]
+        self.urls = source["urls"]
+
+    async def get_prebuffering_state(self, container: Container) -> Optional[PrebufferState]:
+        return await self.__parent.prebufferDelegate.getPrebufferingState(self.name, container)
+
+    async def get_stream_info(self) -> Optional[StreamInfo]:
+        return await self.__parent.prebufferDelegate.getStreamInfo(self.name)
+
+
+class CameraDeviceProxy:
+    def __init__(
+        self,
+        api: PluginAPI,
+        logger: PluginLogger,
+        camera: Camera,
+        plugin: PluginInfo,
+        proxy_endpoints: list[str],
+        auth: AuthConfig,
+    ):
+        self.snapshot_cache = LRUCache(maxsize=100)
+        self.camera_subject = BehaviorSubject(camera)
+
+        self.camera_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.__frame_state = BehaviorSubject[FrameState](
+            {
+                "timestamp": int(datetime.now().timestamp() * 1000),
+                "detections": [],
+                "frameData": cast(FrameData, {}),
+                "metadata": cast(FrameMetadata, {}),
+            },
+        )
+
+        self.on_connected: Observable[bool] = self.__create_state_observable(self.camera_state)
+        self.on_light_switched: Observable[LightState] = self.__create_state_observable(self.light_state)
+        self.on_motion_detected: Observable[MotionState] = self.__create_state_observable(self.motion_state)
+        self.on_audio_detected: Observable[AudioState] = self.__create_state_observable(self.audio_state)
+        self.on_object_detected: Observable[ObjectState] = self.__create_state_observable(self.object_state)
+        self.on_doorbell_pressed: Observable[DoorbellState] = self.__create_state_observable(
+            self.doorbell_state
+        )
+        self.on_siren_detected: Observable[SirenState] = self.__create_state_observable(self.siren_state)
+        self.on_battery_changed: Observable[BatteryState] = self.__create_state_observable(self.battery_state)
+        self.__on_frame: Observable[FrameState] = self.__create_motion_frame_observable()
+
+        if camera["pluginId"] == "native":
+            self.camera_state.on_next(True)
+
+        self.initialized = False
+
+        self.api = api
+        self.logger = logger
+
+        self.auth = auth
+        self.proxy_endpoints = proxy_endpoints
+        self.plugin = plugin
+
+        from camera.interfaces.camera import CameraInterface
+        from camera.interfaces.prebuffer import CameraPrebufferInterface
+        from camera.interfaces.ptz import CameraPTZInterface
+
+        self.cameraDelegate = CameraInterface(self, logger)
+        self.ptzDelegate = CameraPTZInterface(self, logger)
+        self.prebufferDelegate = CameraPrebufferInterface(self, logger)
+
+        self.subject = f"{self.plugin['id']}.camera.{self.id}"
+        self.camera_subscriber_subject = f"{self.id}.camera"
+        self.camera_plugin_subscriber_subject = f"{self.id}.camera.{self.plugin['id']}"
+        self.frame_subject = f"{self.id}.frameReceiver"
+        self.motion_frame_subject = f"{self.id}.frameGenerator.motionFrame"
+        self.signaling_subject = f"{self.plugin['id']}.camera.{self.id}.signaling"
+        self.signaling_target_subject = f"{self.id}.frameGenerator.signaling"
+
+        self.publisher: Optional[ProxyConnection] = None
+        self.camera_publisher: Optional[ProxyConnection] = None
+        self.frame_publisher: Optional[ProxyConnection] = None
+        self.motion_frame_publisher: Optional[ProxyConnection] = None
+        self.signaling_publisher: Optional[ProxyConnection] = None
+
+        self.subscriber: Optional[ProxySubscription] = None
+        self.camera_subscriber: Optional[ProxySubscription] = None
+        self.camera_plugin_subscriber: Optional[ProxySubscription] = None
+        self.signaling_subscriber: Optional[ProxySubscription] = None
+        self.frame_subscribers: list[FrameSubscribtion] = []
+        self.motion_frame_subscribers: list[FrameSubscribtion] = []
+
+        self.tasks: TaskSet = TaskSet(f"{self.plugin['name']} - {self.name} - CameraDeviceProxy")
+        self.message_queue: Optional[MessageQueue] = None
+        self.active_requests: set[str] = set()
+        self.active_motion_requests: set[str] = set()
+
+        # print(("INIT camera device with clientSubject", self.subject))
+
+        self.__on_frame.subscribe(self.__on_motion_frame)
+
+        self.api.once("shutdown", self.cleanup)
+
+    @property
+    def camera_object(self) -> Camera:
+        return deepcopy(self.camera_subject.value)
+
+    @property
+    def id(self) -> str:
+        return self.camera_subject.value.get("_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.get("pluginId")
+
+    @property
+    def connected(self) -> bool:
+        return self.camera_state.value or False
+
+    @property
+    def disabled(self) -> bool:
+        return self.camera_subject.value.get("disabled")
+
+    @property
+    def name(self) -> str:
+        return self.camera_subject.value.get("name")
+
+    @property
+    def type(self) -> CameraType:
+        return self.camera_subject.value.get("type")
+
+    @property
+    def info(self) -> CameraInformation:
+        return deepcopy(self.camera_subject.value.get("info"))
+
+    @property
+    def is_cloud_camera(self) -> bool:
+        return self.camera_subject.value.get("isCloud")
+
+    @property
+    def has_light(self) -> bool:
+        return self.camera_subject.value.get("hasLight")
+
+    @property
+    def has_siren(self) -> bool:
+        return self.camera_subject.value.get("hasSiren")
+
+    @property
+    def has_binary_sensor(self) -> bool:
+        return self.camera_subject.value.get("hasBinarySensor")
+
+    @property
+    def has_battery(self) -> bool:
+        return self.camera_subject.value.get("hasBattery")
+
+    @property
+    def has_motion_detector(self) -> bool:
+        return self.camera_subject.value.get("hasMotionDetector")
+
+    @property
+    def has_audio_detector(self) -> bool:
+        return self.camera_subject.value.get("hasAudioDetector")
+
+    @property
+    def has_object_detector(self) -> bool:
+        return self.camera_subject.value.get("hasObjectDetector")
+
+    @property
+    def has_ptz(self) -> bool:
+        return self.camera_subject.value.get("hasPtz")
+
+    @property
+    def has_prebuffer(self) -> bool:
+        return self.camera_subject.value.get("hasPrebuffer")
+
+    @property
+    def activity_zones(self) -> list[DetectionZone]:
+        return deepcopy(self.camera_subject.value.get("activityZones"))
+
+    @property
+    def activity_settings(self) -> CameraActivitySettings:
+        return deepcopy(self.camera_subject.value.get("activitySettings"))
+
+    @property
+    def frameworker_settings(self) -> CameraFrameWorkerSettings:
+        return deepcopy(self.camera_subject.value.get("frameWorkerSettings"))
+
+    @property
+    def sources(self) -> list[CameraSource]:
+        sources = deepcopy(self.camera_subject.value.get("sources"))
+        return [CameraSource(source, self) for source in sources]
+
+    @property
+    def stream_source(self) -> CameraSource:
+        source = self.high_resolution_source or self.mid_resolution_source or self.low_resolution_source
+        return cast(CameraSource, source)
+
+    @property
+    def snapshot_source(self) -> Optional[CameraSource]:
+        return next(source for source in self.sources if "snapshot" in source.roles)
+
+    @property
+    def high_resolution_source(self) -> Optional[CameraSource]:
+        return next(source for source in self.sources if "high-resolution" in source.roles)
+
+    @property
+    def mid_resolution_source(self) -> Optional[CameraSource]:
+        return next(source for source in self.sources if "mid-resolution" in source.roles)
+
+    @property
+    def low_resolution_source(self) -> Optional[CameraSource]:
+        return next(source for source in self.sources if "low-resolution" in source.roles)
+
+    @property
+    def ptz(self) -> CameraPTZDelegate:
+        return self.ptzDelegate
+
+    async def init(self):
+        if self.initialized:
+            return
+
+        self.initialized = True
+
+        self.publisher = ProxyConnection(self.subject, self.proxy_endpoints, self.auth)
+        await self.publisher.connect()
+
+        self.camera_publisher = ProxyConnection(
+            self.camera_subscriber_subject, self.proxy_endpoints, self.auth
+        )
+        await self.camera_publisher.connect()
+
+        self.signaling_publisher = ProxyConnection(self.signaling_subject, self.proxy_endpoints, self.auth)
+        await self.signaling_publisher.connect()
+
+        self.frame_publisher = ProxyConnection(self.frame_subject, self.proxy_endpoints, self.auth)
+        await self.frame_publisher.connect()
+
+        self.motion_frame_publisher = ProxyConnection(
+            self.motion_frame_subject, self.proxy_endpoints, self.auth
+        )
+        await self.motion_frame_publisher.connect()
+
+        self.subscriber = await self.publisher.subscribe(subject=self.subject)
+        self.message_queue = MessageQueue(
+            self.logger,
+            self.publisher,
+            self.subscriber,
+            self.__request_handler,
+        )
+
+        self.signaling_subscriber = await self.signaling_publisher.subscribe(subject=self.signaling_subject)
+        self.signaling_subscriber.on("message", self.__on_signaling_message)
+
+        self.camera_subscriber = await self.camera_publisher.subscribe(subject=self.camera_subscriber_subject)
+        self.camera_subscriber.on("message", self.__on_proxy_message)
+
+        self.camera_plugin_subscriber = await self.camera_publisher.subscribe(
+            subject=self.camera_plugin_subscriber_subject
+        )
+        self.camera_plugin_subscriber.on("message", self.__on_proxy_message)
+
+        await self.refresh_states()
+
+    @overload
+    def set_delegate(self, name: Literal["cameraDelegate"], delegate: CameraDelegate) -> None: ...
+    @overload
+    def set_delegate(self, name: Literal["prebufferDelegate"], delegate: CameraPrebufferDelegate) -> None: ...
+    @overload
+    def set_delegate(self, name: Literal["ptzDelegate"], delegate: CameraPTZDelegate) -> None: ...
+    def set_delegate(self, name: Delegates, delegate: Any) -> None:
+        delegate = getattr(self, name, None)
+
+        if delegate:
+            delegate.delegate = delegate
+
+    async def connect(self) -> None:
+        return await self.on_request("cameraFn", "connect")
+
+    async def disconnect(self) -> None:
+        return await self.on_request("cameraFn", "disconnect")
+
+    @cached(cache=lambda self: self.snapshot_cache)  # type: ignore
+    async def snapshot(self, force_new: Optional[bool] = None) -> Optional[bytes]:
+        source = self.snapshot_source or self.stream_source
+        cache_key = source.id
+
+        snapshot_url = source.urls["www"]["jpegSnapshot"]
+        from_cache: Any = self.snapshot_cache.get(snapshot_url) if cache_key in self.snapshot_cache else None
+
+        if from_cache and not force_new:
+            return from_cache
+
+        if "snapshot" not in source.roles and self.camera_object["pluginId"] != "native":
+            snapshot = await self.cameraDelegate.snapshot()
+
+            if snapshot and len(snapshot) > 0:
+                self.snapshot_cache[cache_key] = snapshot
+
+            return snapshot
+
+        async with aiohttp.ClientSession() as session, session.get(snapshot_url) as response:
+            if response.status != 200:
+                raise Exception(f"Status Code: {response.status}")
+
+            snapshot = await response.read()
+
+            if len(snapshot) > 0:
+                self.snapshot_cache[cache_key] = snapshot
+
+            return snapshot
+
+    async def get_frames(self, prebuffer_duration: int = 0) -> AsyncGenerator[VideoFrame, None]:
+        if not self.frame_publisher:
+            raise Exception("Frame Publisher is not initialized")
+
+        request_type: Literal["frame", "prebuffer"] = "frame"
+        prebuffer_duration = abs(prebuffer_duration)
+
+        if prebuffer_duration > 0:
+            request_type = "prebuffer"
+            prebuffer_duration = min(prebuffer_duration, 5)
+
+        request_id = f"{str(uuid4())}-{request_type}"
+
+        try:
+            metadata = await self.__connect_to_decoder(request_id)
+            frame_subscriber = await self.frame_publisher.subscribe(self.frame_subject)
+
+            self.frame_subscribers.append({"request_id": request_id, "subscriber": frame_subscriber})
+
+            try:
+                async for msg in frame_subscriber.subscriber.messages:
+                    if (
+                        not self.initialized
+                        or len(self.active_requests) == 0
+                        or request_id not in self.active_requests
+                    ):
+                        return
+
+                    if len(msg.data) == 0:
+                        continue
+
+                    frame_data: FrameData = unpack(msg.data)
+
+                    yield VideoFrame(self.id, self.frame_publisher, frame_data, metadata, prebuffer_duration)
+
+            except GeneratorExit:
+                return
+
+        except asyncio.CancelledError:
+            return
+        except Exception as e:
+            if self.initialized:
+                self.logger.error("Error while generating frames:", e)
+            raise
+        finally:
+            await self.__disconnect_from_decoder(request_id)
+
+    async def get_motion_frames(self) -> AsyncGenerator[MotionFrame, None]:
+        if not self.motion_frame_publisher:
+            raise Exception("Motion Frame Publisher is not initialized")
+
+        request_id = f"{str(uuid4())}-motion"
+
+        try:
+            self.active_motion_requests.add(request_id)
+
+            motion_frame_subscriber = await self.motion_frame_publisher.subscribe(self.motion_frame_subject)
+
+            self.motion_frame_subscribers.append(
+                {"request_id": request_id, "subscriber": motion_frame_subscriber}
+            )
+
+            try:
+                async for msg in motion_frame_subscriber.subscriber.messages:
+                    if (
+                        not self.initialized
+                        or len(self.active_motion_requests) == 0
+                        or request_id not in self.active_motion_requests
+                    ):
+                        break
+
+                    if not msg or not msg.data or len(msg.data) == 0:
+                        continue
+
+                    motion_frame: FrameState = unpack(msg.data)
+                    motion_state: MotionState = {
+                        "timestamp": motion_frame["timestamp"],
+                        "detections": motion_frame["detections"],
+                        "lastEvent": motion_frame.get("lastEvent", None),
+                        "state": motion_frame.get("state", False),
+                    }
+
+                    yield MotionFrame(
+                        self.id,
+                        self.motion_frame_publisher,
+                        motion_frame["frameData"],
+                        motion_state,
+                        motion_frame["metadata"],
+                    )
+
+            except GeneratorExit:
+                return
+
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            if self.initialized:
+                self.logger.error("Error while generating motion frames:", e)
+            raise
+        finally:
+            if request_id in self.active_motion_requests:
+                self.active_motion_requests.remove(request_id)
+
+            motion_frame_subscribtion = next(
+                (sub for sub in self.motion_frame_subscribers if sub["request_id"] == request_id), None
+            )
+
+            if motion_frame_subscribtion:
+                self.motion_frame_subscribers.remove(motion_frame_subscribtion)
+                await motion_frame_subscribtion["subscriber"].close()
+
+            if len(self.motion_frame_subscribers) == 0:
+                await self.__close_motion_frame_subscribers()
+
+    @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: str
+    ) -> 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[VideoFrame] = 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: Literal["light", "motion", "audio", "object", "doorbell", "siren", "battery"],
+        event_data: Union[
+            LightSetEvent,
+            MotionSetEvent,
+            AudioSetEvent,
+            ObjectSetEvent,
+            DoorbellSetEvent,
+            SirenSetEvent,
+            BatterySetEvent,
+        ],
+        frame: Optional[VideoFrame] = None,
+    ) -> None:
+        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)),
+        )
+
+        if not changed:
+            return
+
+        if state_name == "motion" and frame:
+            motion_event = cast(MotionState, event)
+            self.__frame_state.on_next(
+                {**motion_event, "frameData": frame.frame_data, "metadata": frame.metadata}
+            )
+
+        self.__update_state_internal(cast(Any, state_name), cast(Any, event), True)
+        await self.on_request("cameraFn", "updateState", [state_name, event], 0)
+
+    async def add_camera_source(self, source: CameraConfigInputSettings) -> None:
+        return await self.on_request("cameraFn", "addCameraSource", [source])
+
+    async def update_camera_source(self, source_id: str, source: CameraConfigInputSettingsPartial) -> None:
+        return await self.on_request("cameraFn", "updateCameraSource", [source_id, source])
+
+    async def remove_camera_source(self, source_id: str) -> None:
+        return await self.on_request("cameraFn", "removeCameraSource", [source_id])
+
+    async def refresh_states(self) -> None:
+        response = await self.on_request("cameraFn", "refreshStates")
+
+        self.update_camera(response["camera"])
+        self.update_camera_state(response["cameraState"])
+
+        for key, value in response["states"].items():
+            self.__update_state_internal(key, value, True)
+
+    def update_camera(self, camera: Camera) -> None:
+        self.camera_subject.on_next(camera)
+
+    def update_camera_state(self, state: bool) -> None:
+        self.camera_state.on_next(state)
+
+    def remove_all_listeners(self) -> None:
+        self.__frame_state.on_completed()
+        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()
+
+    async def cleanup(self) -> None:
+        self.initialized = False
+        self.remove_all_listeners()
+        self.api.remove_listener("shutdown", self.cleanup)
+        self.active_requests.clear()
+
+        if self.message_queue:
+            self.message_queue.abort_queue()
+
+        with suppress(Exception):
+            if self.publisher:
+                await self.publisher.close()
+
+            if self.camera_publisher:
+                await self.camera_publisher.close()
+
+            if self.signaling_publisher:
+                await self.signaling_publisher.close()
+
+            if self.frame_publisher:
+                await self.frame_publisher.close()
+
+            if self.motion_frame_publisher:
+                await self.motion_frame_publisher.close()
+
+    @overload
+    def on_state_change(self, state_name: Literal["light"]) -> Observable[tuple[LightState, LightState]]: ...
+    @overload
+    def on_state_change(
+        self, state_name: Literal["motion"]
+    ) -> Observable[tuple[MotionState, MotionState]]: ...
+    @overload
+    def on_state_change(self, state_name: Literal["audio"]) -> Observable[tuple[AudioState, AudioState]]: ...
+    @overload
+    def on_state_change(
+        self, state_name: Literal["doorbell"]
+    ) -> Observable[tuple[DoorbellState, DoorbellState]]: ...
+    @overload
+    def on_state_change(self, state_name: Literal["siren"]) -> Observable[tuple[SirenState, SirenState]]: ...
+    @overload
+    def on_state_change(
+        self, state_name: Literal["battery"]
+    ) -> Observable[tuple[BatteryState, BatteryState]]: ...
+    @overload
+    def on_state_change(
+        self, state_name: Literal["object"]
+    ) -> Observable[tuple[ObjectState, ObjectState]]: ...
+    def on_state_change(self, state_name: StateNames) -> Observable[tuple[StateValue, StateValue]]:
+        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]
+
+            if isinstance(old_state, bool) or isinstance(new_state, bool):
+                return old_state != new_state
+            else:
+                return self.__state_changed(old_state, new_state, state_name)
+
+        return state.pipe(
+            ops.pairwise(),
+            ops.filter(filter_fn),
+            ops.share(),
+        )
+
+    def on_property_change(
+        self, property: Union[CameraPublicProperties, list[CameraPublicProperties]]
+    ) -> Observable[CameraPropertyObservableObject]:
+        def map_fn(
+            cameras: tuple[Camera, Camera],
+        ) -> list[Any]:
+            properties = 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(
+            cameras: tuple[CameraPropertyObservableObject, CameraPropertyObservableObject],
+        ) -> bool:
+            return (
+                DeepDiff(
+                    cameras[0]["old_state"],
+                    cameras[1]["new_state"],
+                    ignore_order=True,
+                )
+                != {}
+            )
+
+        return self.camera_subject.pipe(
+            ops.pairwise(),
+            ops.flat_map(map_fn),
+            ops.filter(filter_fn),
+            ops.share(),
+        )
+
+    def __on_motion_frame(self, motion_frame: FrameState) -> None:
+        if not self.frame_publisher:
+            return
+
+        self.tasks.add(self.__send_motion_frame(motion_frame))
+
+    async def __send_motion_frame(self, frame: FrameState) -> None:
+        if not self.frame_publisher:
+            return
+
+        await self.frame_publisher.publish(self.motion_frame_subject, frame)
+
+    @overload
+    def __check_state_internal(
+        self, state_name: Literal["light"], event_data: LightSetEvent
+    ) -> tuple[bool, LightState]: ...
+    @overload
+    def __check_state_internal(
+        self, state_name: Literal["motion"], event_data: MotionSetEvent
+    ) -> tuple[bool, MotionState]: ...
+    @overload
+    def __check_state_internal(
+        self, state_name: Literal["audio"], event_data: AudioSetEvent
+    ) -> tuple[bool, AudioState]: ...
+    @overload
+    def __check_state_internal(
+        self, state_name: Literal["object"], event_data: ObjectSetEvent
+    ) -> tuple[bool, ObjectState]: ...
+    @overload
+    def __check_state_internal(
+        self, state_name: Literal["doorbell"], event_data: DoorbellSetEvent
+    ) -> tuple[bool, DoorbellState]: ...
+    @overload
+    def __check_state_internal(
+        self, state_name: Literal["siren"], event_data: SirenSetEvent
+    ) -> tuple[bool, SirenState]: ...
+    @overload
+    def __check_state_internal(
+        self, state_name: Literal["battery"], event_data: BatterySetEvent
+    ) -> 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,
+        ],
+    ) -> tuple[
+        bool,
+        Union[
+            LightState,
+            MotionState,
+            AudioState,
+            ObjectState,
+            DoorbellState,
+            SirenState,
+            BatteryState,
+        ],
+    ]:
+        changed = False
+        target_state = 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 motion_event.get("state", None) is not None:
+                motion_event["detections"] = []
+
+            # fix bounding box type to to tuple, do we need?
+            for det in motion_event["detections"]:
+                det["boundingBox"] = cast(tuple[int, int, int, int], tuple(det["boundingBox"]))
+                det["confidence"] = float(det["confidence"])
+
+            motion_event["detections"] = merge_detections(motion_event["detections"])
+
+            motion_event["detections"] = are_motion_detections_valid(
+                motion_event["detections"], self.activity_zones, self.activity_settings
+            )
+
+            target_state = self.__get_motion_state(motion_event)
+            changed = self.__state_changed(self.get_value("motion"), target_state, "motion")
+
+        elif state_name == "object":
+            object_event = cast(ObjectSetEvent, event_data)
+
+            # fix bounding box type to to tuple
+            for det in object_event["detections"]:
+                det["boundingBox"] = tuple(det["boundingBox"])  # type: ignore
+                det["confidence"] = float(det["confidence"])
+
+            object_event["detections"] = are_object_detections_valid(
+                object_event["detections"], self.activity_zones, self.activity_settings
+            )
+
+            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
+
+    @overload
+    def __update_state_internal(
+        self, state_name: Literal["light"], event_data: LightSetEvent, skip_check: Optional[bool] = None
+    ) -> None: ...
+    @overload
+    def __update_state_internal(
+        self, state_name: Literal["motion"], event_data: MotionSetEvent, skip_check: Optional[bool] = None
+    ) -> None: ...
+    @overload
+    def __update_state_internal(
+        self, state_name: Literal["audio"], event_data: AudioSetEvent, skip_check: Optional[bool] = None
+    ) -> None: ...
+    @overload
+    def __update_state_internal(
+        self, state_name: Literal["object"], event_data: ObjectSetEvent, skip_check: Optional[bool] = None
+    ) -> None: ...
+    @overload
+    def __update_state_internal(
+        self, state_name: Literal["doorbell"], event_data: DoorbellSetEvent, skip_check: Optional[bool] = None
+    ) -> None: ...
+    @overload
+    def __update_state_internal(
+        self, state_name: Literal["siren"], event_data: SirenSetEvent, skip_check: Optional[bool] = None
+    ) -> None: ...
+    @overload
+    def __update_state_internal(
+        self, state_name: Literal["battery"], event_data: BatterySetEvent, skip_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,
+    ) -> 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)),
+            )
+
+        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_motion_frame_observable(self) -> Observable[FrameState]:
+        return self.__frame_state.pipe(ops.share())
+
+    def __create_state_observable(self, state_subject: BehaviorSubject[Any]) -> Observable[Any]:
+        return state_subject.pipe(ops.share())
+
+    def __state_changed(
+        self,
+        old_state: Optional[SetValue],
+        new_state: Optional[SetValue],
+        type: Optional[StateNames],
+    ) -> bool:
+        if not old_state or not new_state or not type:
+            return False
+
+        if type == "audio":
+            if not self.has_audio_detector:
+                return False
+
+            old_state = cast(AudioSetEvent, old_state)
+            new_state = cast(AudioSetEvent, new_state)
+
+            return old_state["state"] != new_state["state"] or old_state.get("db") != new_state.get("db")
+        elif type == "motion":
+            if not self.has_motion_detector:
+                return False
+
+            old_state = cast(MotionSetEvent, old_state)
+            new_state = cast(MotionSetEvent, new_state)
+
+            if new_state.get("state", None) is not None:
+                return old_state.get("state", False) != new_state.get("state", False)
+
+            # if len(new_state["detections"]) == 0:
+            #     return False
+
+            return (
+                DeepDiff(
+                    old_state["detections"],
+                    new_state["detections"],
+                    ignore_order=True,
+                )
+                != {}
+            )
+        elif type == "object":
+            if not self.has_object_detector:
+                return False
+
+            old_state = cast(ObjectSetEvent, old_state)
+            new_state = cast(ObjectSetEvent, new_state)
+
+            # if len(new_state["detections"]) == 0:
+            #     return False
+
+            return (
+                DeepDiff(
+                    old_state["detections"],
+                    new_state["detections"],
+                    ignore_order=True,
+                )
+                != {}
+            )
+        elif type == "siren":
+            if not self.has_siren:
+                return False
+
+            old_state = cast(SirenSetEvent, old_state)
+            new_state = cast(SirenSetEvent, new_state)
+
+            return old_state["state"] != new_state["state"] or old_state.get("level") != new_state.get(
+                "level"
+            )
+        elif type == "battery":
+            if not self.has_battery:
+                return False
+
+            old_state = cast(BatterySetEvent, old_state)
+            new_state = cast(BatterySetEvent, new_state)
+
+            return (
+                old_state["level"] != new_state["level"]
+                or old_state.get("lowBattery") != new_state.get("lowBattery")
+                or old_state.get("charging") != new_state.get("charging")
+            )
+        elif type == "doorbell":
+            if not self.has_binary_sensor:
+                return False
+
+            old_state = cast(DoorbellSetEvent, old_state)
+            new_state = cast(DoorbellSetEvent, new_state)
+
+            return old_state["state"] != new_state["state"]
+        elif type == "light":
+            if not self.has_light:
+                return False
+
+            old_state = cast(LightSetEvent, old_state)
+            new_state = cast(LightSetEvent, new_state)
+
+            return old_state["state"] != new_state["state"]
+        else:
+            return False
+
+    def __get_audio_state(self, event: AudioSetEvent, ignore_last_event: bool = False) -> AudioState:
+        last_event: Optional[AudioState] = None
+
+        if ignore_last_event is False:
+            last_state = self.get_value("audio")
+
+            if last_state["state"]:
+                last_event = last_state
+            elif "lastEvent" in last_state and last_state["lastEvent"] and last_state["lastEvent"]["state"]:
+                last_event = last_state["lastEvent"]  # type: ignore
+
+            if last_event and "lastEvent" in last_event:
+                del last_event["lastEvent"]
+
+        new_state: AudioState
+
+        if "timestamp" in event:
+            new_state = event
+        else:
+            state = cast(AudioState, event).copy()
+            state["timestamp"] = int(datetime.now().timestamp() * 1000)
+
+            new_state = {
+                "state": event["state"],
+                "db": event.get("db", None) or last_event.get("db", None) if last_event else 0,
+                "timestamp": int(datetime.now().timestamp() * 1000),
+                "lastEvent": last_event if last_event else state if state["state"] else None,
+            }
+
+        return new_state
+
+    def __get_motion_state(self, event: MotionSetEvent, ignore_last_event: bool = False) -> MotionState:
+        last_event: Optional[MotionState] = None
+
+        if ignore_last_event is False:
+            last_state = self.get_value("motion")
+
+            if len(last_state["detections"]) > 0:
+                last_event = last_state
+            elif (
+                "lastEvent" in last_state
+                and last_state["lastEvent"] is not None
+                and len(last_state["lastEvent"]["detections"]) > 0
+            ):
+                last_event = last_state["lastEvent"]  # type: ignore
+
+            if last_event and "lastEvent" in last_event:
+                del last_event["lastEvent"]
+
+        new_state: MotionState
+
+        if "timestamp" in event:
+            new_state = event
+        else:
+            state = cast(MotionState, event).copy()
+            state["timestamp"] = int(datetime.now().timestamp() * 1000)
+
+            new_state = {
+                "detections": event["detections"],
+                "timestamp": int(datetime.now().timestamp() * 1000),
+                "lastEvent": last_event if last_event else state if len(state["detections"]) > 0 else None,
+            }
+
+        return new_state
+
+    def __get_object_state(self, event: ObjectSetEvent, ignore_last_event: bool = False) -> ObjectState:
+        last_event: Optional[ObjectState] = None
+
+        if ignore_last_event is False:
+            last_state = self.get_value("object")
+
+            if len(last_state["detections"]) > 0:
+                last_event = last_state
+            elif (
+                "lastEvent" in last_state
+                and last_state["lastEvent"]
+                and len(last_state["lastEvent"]["detections"]) > 0
+            ):
+                last_event = last_state["lastEvent"]  # type: ignore
+
+            if last_event and "lastEvent" in last_event:
+                del last_event["lastEvent"]
+
+        new_state: ObjectState
+
+        if "timestamp" in event:
+            new_state = event
+        else:
+            state = cast(ObjectState, event).copy()
+            state["timestamp"] = int(datetime.now().timestamp() * 1000)
+
+            new_state = {
+                "detections": event["detections"],
+                "timestamp": int(datetime.now().timestamp() * 1000),
+                "lastEvent": last_event if last_event else state if len(state["detections"]) > 0 else None,
+            }
+
+        return new_state
+
+    def __get_doorbell_state(self, event: DoorbellSetEvent, ignore_last_event: bool = False) -> DoorbellState:
+        last_event: Optional[DoorbellState] = None
+
+        if ignore_last_event is False:
+            last_state = self.get_value("doorbell")
+
+            if last_state["state"]:
+                last_event = last_state
+            elif "lastEvent" in last_state and last_state["lastEvent"] and last_state["lastEvent"]["state"]:
+                last_event = last_state["lastEvent"]  # type: ignore
+
+            if last_event and "lastEvent" in last_event:
+                del last_event["lastEvent"]
+
+        new_state: DoorbellState
+
+        if "timestamp" in event:
+            new_state = event
+        else:
+            state = cast(DoorbellState, event).copy()
+            state["timestamp"] = int(datetime.now().timestamp() * 1000)
+
+            new_state = {
+                "state": event["state"],
+                "timestamp": int(datetime.now().timestamp() * 1000),
+                "lastEvent": last_event if last_event else state if state["state"] else None,
+            }
+
+        return new_state
+
+    def __get_light_state(self, event: LightSetEvent, ignore_last_event: bool = False) -> LightState:
+        last_event: Optional[LightState] = None
+
+        if ignore_last_event is False:
+            last_state = self.get_value("light")
+
+            if last_state["state"]:
+                last_event = last_state
+            elif "lastEvent" in last_state and last_state["lastEvent"] and last_state["lastEvent"]["state"]:
+                last_event = last_state["lastEvent"]  # type: ignore
+
+            if last_event and "lastEvent" in last_event:
+                del last_event["lastEvent"]
+
+        new_state: LightState
+
+        if "timestamp" in event:
+            new_state = event
+        else:
+            state = cast(LightState, event).copy()
+            state["timestamp"] = int(datetime.now().timestamp() * 1000)
+
+            new_state = {
+                **state,
+                "lastEvent": last_event if last_event else state if state["state"] else None,
+            }
+
+        return new_state
+
+    def __get_siren_state(self, event: SirenSetEvent, ignore_last_event: bool = False) -> SirenState:
+        last_event: Optional[SirenState] = None
+
+        if ignore_last_event is False:
+            last_state = self.get_value("siren")
+
+            if last_state["state"]:
+                last_event = last_state
+            elif "lastEvent" in last_state and last_state["lastEvent"] and last_state["lastEvent"]["state"]:
+                last_event = last_state["lastEvent"]  # type: ignore
+
+            if last_event and "lastEvent" in last_event:
+                del last_event["lastEvent"]
+
+        new_state: SirenState
+
+        if "timestamp" in event:
+            new_state = event
+        else:
+            state = cast(SirenState, event).copy()
+            state["timestamp"] = int(datetime.now().timestamp() * 1000)
+
+            new_state = {
+                "state": event["state"],
+                "level": event.get("level", None) or last_event.get("level", None) if last_event else 0,
+                "timestamp": int(datetime.now().timestamp() * 1000),
+                "lastEvent": last_event if last_event else state if state["state"] else None,
+            }
+
+        return new_state
+
+    def __get_battery_state(self, event: BatterySetEvent, ignore_last_event: bool = False) -> BatteryState:
+        last_event: Optional[BatteryState] = None
+
+        if ignore_last_event is False:
+            last_state = self.get_value("battery")
+
+            if self.__state_changed(last_state, event, "battery"):
+                last_event = last_state
+            elif (
+                "lastEvent" in last_state
+                and last_state["lastEvent"]
+                and self.__state_changed(last_state["lastEvent"], event, "battery")
+            ):
+                last_event = last_state["lastEvent"]  # type: ignore
+
+            if last_event and "lastEvent" in last_event:
+                del last_event["lastEvent"]
+
+        new_state: BatteryState
+
+        if "timestamp" in event:
+            new_state = 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 if last_event else state,
+            }
+
+        return new_state
+
+    async def __connect_to_decoder(self, request_id: str) -> FrameMetadata:
+        if not self.signaling_publisher:
+            raise Exception("Signaling Publisher not initialized")
+
+        message: SignalingRequest = {
+            "type": "connect",
+            "requestId": request_id,
+            "cameraId": self.id,
+            "pluginId": self.plugin["id"],
+        }
+
+        await self.signaling_publisher.publish(self.signaling_target_subject, message)
+
+        self.active_requests.add(request_id)
+
+        metadata = await self.__get_metadata(request_id, 60)
+
+        if not metadata:
+            raise Exception("Invalid metadata response")
+
+        return metadata
+
+    async def __get_metadata(self, request_id: str, timeout: int) -> Union[FrameMetadata, None]:
+        if not self.signaling_publisher:
+            raise Exception("Signaling Publisher not initialized")
+
+        try:
+            metadata_request: SignalingRequest = {
+                "type": "metadata",
+                "requestId": request_id,
+                "cameraId": self.id,
+                "pluginId": self.plugin["id"],
+            }
+
+            metadata_response: SignalingResponse = await self.signaling_publisher.request(
+                self.signaling_target_subject,
+                metadata_request,
+                timeout=timeout,
+            )
+
+            metadata = metadata_response.get("metadata")
+
+            return metadata
+        except Exception as e:
+            self.logger.error("Failed to get metadata! Frame Worker FFmpeg process might not be running", e)
+
+    async def __disconnect_from_decoder(self, request_id: str) -> None:
+        if request_id in self.active_requests:
+            self.active_requests.remove(request_id)
+
+        frame_subscription = next(
+            (sub for sub in self.frame_subscribers if sub["request_id"] == request_id), None
+        )
+
+        if frame_subscription:
+            self.frame_subscribers.remove(frame_subscription)
+            await frame_subscription["subscriber"].close()
+
+        if self.signaling_publisher:
+            message: SignalingRequest = {
+                "type": "disconnect",
+                "requestId": request_id,
+                "cameraId": self.id,
+                "pluginId": self.plugin["id"],
+            }
+
+            await self.signaling_publisher.publish(self.signaling_target_subject, message)
+
+    async def __close_frame_subscribers(self) -> None:
+        self.active_requests.clear()
+
+        for sub in self.frame_subscribers:
+            with suppress(Exception):
+                await sub["subscriber"].close()
+
+        self.frame_subscribers.clear()
+
+    async def __close_motion_frame_subscribers(self) -> None:
+        self.active_motion_requests.clear()
+
+        for sub in self.motion_frame_subscribers:
+            with suppress(Exception):
+                await sub["subscriber"].close()
+
+        self.motion_frame_subscribers.clear()
+
+    async def __request_handler(self, message: ProxyMessageStructure) -> None:
+        if not self.message_queue:
+            raise Exception("Message queue not initialized")
+
+        reply = message.copy()
+        reply["type"] = "reply"
+
+        try:
+            if (
+                message["client"] == "cameraDelegate"
+                or message["client"] == "prebufferDelegate"
+                or message["client"] == "ptzDelegate"
+            ):
+                delegate = getattr(self, message["client"], None)
+
+                if not delegate:
+                    raise Exception(f"Delegate not set: {message['client']}")
+
+                fn: Any = message.get("fn")
+                args = message.get("args", [])
+
+                if not hasattr(delegate, fn) and not callable(getattr(delegate, fn)):
+                    raise Exception(f"Unknown delegate function: {message['client']} ({fn})")
+
+                method_to_call = getattr(delegate, fn)
+
+                if inspect.iscoroutinefunction(method_to_call):
+                    reply["response"] = await method_to_call(*args)
+                else:
+                    reply["response"] = method_to_call(*args)
+            elif message.get("client") == "cameraFn":
+                fn: Any = message.get("fn")
+                args = message.get("args", [])
+
+                if not hasattr(self, fn) and not callable(getattr(self, fn)):
+                    raise Exception(f"Unknown camera function: {fn}")
+
+                method_to_call = getattr(self, fn)
+
+                if inspect.iscoroutinefunction(method_to_call):
+                    reply["response"] = await method_to_call(*args)
+                else:
+                    reply["response"] = method_to_call(*args)
+            else:
+                raise Exception(f"Unknown client: {message['client']}")
+
+        except Exception as e:
+            deserialized_error: DeserializedError = {
+                "name": type(e).__name__,
+                "message": str(e),
+                "stack": traceback.format_exc(),
+            }
+
+            reply["error"] = deserialized_error
+
+        if reply["timeout"] == 0:
+            return
+        else:
+            await self.message_queue.enqueue(reply)
+
+    async def __on_proxy_message(self, msg: Msg) -> None:
+        if not self.initialized:
+            return
+
+        message = unpack(msg.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"])
+        else:
+            state_name = message["stateName"]
+            new_data = message["data"]["newEvent"]
+
+            self.__update_state_internal(state_name, new_data, True)
+
+    async def __on_signaling_message(self, msg: Msg) -> None:
+        if not self.initialized:
+            return
+
+        message: Union[SignalingResponse, PingMessage] = unpack(msg.data)
+
+        if message["type"] == "ping":
+            if message["requestId"] in self.active_requests:
+                self.tasks.add(self.__respond_to_signaling_message(msg, message))
+
+        elif message["type"] == "disconnect":
+            if message["requestId"] in self.active_requests:
+                self.active_requests.remove(message["requestId"])
+
+            frame_subscribtion = next(
+                (sub for sub in self.frame_subscribers if sub["request_id"] == message["requestId"]), None
+            )
+
+            if frame_subscribtion:
+                self.frame_subscribers.remove(frame_subscribtion)
+                await frame_subscribtion["subscriber"].close()
+
+            if len(self.active_requests) == 0:
+                self.tasks.add(self.__close_frame_subscribers())
+
+    async def __respond_to_signaling_message(self, msg: Msg, message: PingMessage) -> None:
+        try:
+            pong_message: PongMessage = {
+                "type": "pong",
+                "requestId": message["requestId"],
+            }
+
+            await msg.respond(pack(pong_message))
+        except Exception as e:
+            if self.initialized:
+                self.logger.error("Error while processing singaling respond:", e)
+
+    @overload
+    async def on_request(
+        self,
+        client: Literal["cameraFn"],
+        fn: CameraDeviceProxyMethodNames,
+        args: list[Any] = [],
+        timeout: int = 5000,
+    ) -> Any: ...
+    @overload
+    async def on_request(
+        self,
+        client: Literal["cameraDelegate"],
+        fn: CameraDelegateMethodNames,
+        args: list[Any] = [],
+        timeout: int = 5000,
+    ) -> Any: ...
+    @overload
+    async def on_request(
+        self,
+        client: Literal["prebufferDelegate"],
+        fn: CameraPrebufferDelegateMethodNames,
+        args: list[Any] = [],
+        timeout: int = 5000,
+    ) -> Any: ...
+    @overload
+    async def on_request(
+        self,
+        client: Literal["ptzDelegate"],
+        fn: CameraPTZDelegateMethodNames,
+        args: list[Any] = [],
+        timeout: int = 5000,
+    ) -> Any: ...
+    async def on_request(
+        self,
+        client: ClientType,
+        fn: Any,
+        args: list[Any] = [],
+        timeout: int = 5000,
+    ) -> Any:
+        if not self.message_queue:
+            raise Exception("Message queue not initialized")
+
+        message: ProxyMessageStructure = {
+            "requestId": str(uuid4()),
+            "targetId": self.subject,
+            "targetName": self.name,
+            "pluginId": self.plugin["id"],
+            "cameraId": self.id,
+            "type": "request",
+            "proxy": "camera",
+            "client": "cameraFn",
+            "fn": fn,
+            "args": args,
+            "timestamp": int(datetime.now().timestamp() * 1000),
+            "timeout": timeout,
+        }
+
+        return await self.message_queue.enqueue(message)