@camera.ui/server 0.0.22-alpha.0 → 0.0.22-alpha.2

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

@@ -1,1677 +0,0 @@
-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,
-)
-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 update_prebuffer_state(self, container: Container, state: PrebufferState) -> None:
-        return await self.__parent.prebufferDelegate.updatePrebufferState(self.id, container, state)
-
-    def get_prebuffering_state(self, container: Container) -> PrebufferState:
-        return self.__parent.camera_source_prebuffer_state(self.id, container)
-
-    def on_prebuffering(self, container: Container) -> Observable[PrebufferState]:
-        return self.__parent.create_prebuffer_state_observable(self.id, container)
-
-    async def get_stream_info(self):
-        return await self.__parent.prebufferDelegate.getStreamInfo(self.id)
-
-
-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.prebuffer_state_subjects: dict[str, dict[str, BehaviorSubject[PrebufferState]]] = {}
-
-        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)
-
-        for source_id, states in response["prebufferStates"].items():
-            self.update_prebuffer(source_id, "mp4", states["mp4"])
-            self.update_prebuffer(source_id, "mpegts", states["mpegts"])
-
-    def update_camera(self, camera: Camera) -> None:
-        self.camera_subject.on_next(camera)
-        self.update_camera_sources_state()
-
-    def update_prebuffer(self, source_id: str, container: Container, state: PrebufferState) -> None:
-        if (
-            source_id in self.prebuffer_state_subjects
-            and container in self.prebuffer_state_subjects[source_id]
-        ):
-            prebuffer_state: PrebufferState = {
-                "state": state["state"],
-                "url": state.get("url", None),
-                "duration": state["duration"],
-            }
-
-            self.prebuffer_state_subjects[source_id][container].on_next(prebuffer_state)
-
-    def update_camera_state(self, state: bool) -> None:
-        self.camera_state.on_next(state)
-
-    def update_camera_sources_state(self) -> None:
-        sources = self.camera_subject.value.get("sources")
-        source_ids_to_remove: list[str] = []
-
-        for source_id in self.prebuffer_state_subjects:
-            if not any(source["_id"] == source_id for source in sources):
-                for container in self.prebuffer_state_subjects[source_id]:
-                    self.prebuffer_state_subjects[source_id][container].on_completed()
-
-                source_ids_to_remove.append(source_id)
-
-        for source_id in source_ids_to_remove:
-            del self.prebuffer_state_subjects[source_id]
-
-    def camera_source_prebuffer_state(self, source_id: str, container: Container) -> PrebufferState:
-        prebuffer_state: PrebufferState = {"state": False, "duration": 0}
-
-        if (
-            source_id in self.prebuffer_state_subjects
-            and container in self.prebuffer_state_subjects[source_id]
-        ):
-            prebuffer_state = self.prebuffer_state_subjects[source_id][container].value
-
-        return prebuffer_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 create_prebuffer_state_observable(
-        self, source_id: str, container: Container
-    ) -> Observable[PrebufferState]:
-        if source_id not in self.prebuffer_state_subjects:
-            self.prebuffer_state_subjects[source_id] = {}
-
-        if container not in self.prebuffer_state_subjects[source_id]:
-            self.prebuffer_state_subjects[source_id][container] = BehaviorSubject(
-                {"state": False, "duration": 0}
-            )
-
-        return self.prebuffer_state_subjects[source_id][container].pipe(
-            ops.distinct_until_changed(comparer=self.__prebuffer_state_comperator),
-            ops.share(),
-        )
-
-    def __prebuffer_state_comperator(
-        self, previous_state: PrebufferState, current_state: PrebufferState
-    ) -> bool:
-        return previous_state["state"] == current_state["state"] and previous_state.get(
-            "url"
-        ) == current_state.get("url")
-
-    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"])
-            elif type == "prebufferState":
-                self.update_prebuffer(
-                    message["data"]["sourceId"],
-                    message["data"]["container"],
-                    message["data"]["state"],
-                )
-        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)