@camera.ui/server 0.0.70 → 0.0.71-dev.0

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

@@ -1,968 +1,397 @@
-import asyncio
-from collections.abc import AsyncGenerator
+from __future__ import annotations
+
+import contextlib
 from copy import deepcopy
-from datetime import datetime
-from typing import Any, Callable, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, Protocol, cast
 
-from cachetools import TTLCache
 from deepdiff.diff import DeepDiff
-from reactivex import operators as ops
-from reactivex.abc import DisposableBase
-from reactivex.subject.behaviorsubject import BehaviorSubject
-from typing_extensions import Literal, overload
-
-from _camera_ui_tools.camera_ui_common.camera_utils.utils import build_target_url
-from _camera_ui_tools.camera_ui_common.common_utils.subscribed import Subscribed
-from _camera_ui_tools.camera_ui_common.logger_service.logger import LoggerService as Logger
-from _camera_ui_tools.camera_ui_rpc_client import ClientInstance
-from _camera_ui_tools.camera_ui_rpc_client.typings import Message
-from _camera_ui_tools.camera_ui_rpc_client.utils.subscriptions import SubscriptionWrapper
-from _camera_ui_tools.camera_ui_types import (
-    AudioSetEvent,
-    AudioState,
-    BatterySetEvent,
-    BatteryState,
-    BoundingBox,
+
+from _camera_ui_tools.camera_ui_common import Subscribed, TaskSet
+from _camera_ui_tools.camera_ui_rpc import CloseHandler, RPCClient
+from _camera_ui_tools.camera_ui_sdk import (
+    API_EVENT,
+    BehaviorSubject,
     Camera,
-    CameraCapabilitiesObservableObject,
     CameraDetectionSettings,
-    CameraDevice,
-    CameraDeviceCapability,
     CameraDeviceSource,
     CameraFrameWorkerSettings,
+    CameraImplementation,
     CameraInformation,
     CameraInput,
     CameraPluginInfo,
     CameraPropertyObservableObject,
     CameraPublicProperties,
+    CameraRole,
     CameraSource,
-    CameraStateChangedObject,
     CameraType,
-    DecoderFormat,
+    CameraUiSettings,
+    DetectionEventPayload,
+    DetectionLine,
     DetectionZone,
-    DoorbellSetEvent,
-    DoorbellState,
-    FMP4ConnectionOptions,
-    FrameData,
-    FrameType,
-    ImageOptions,
-    LightSetEvent,
-    LightState,
+    Disposable,
     LoggerService,
-    MotionDetectionFrame,
-    MotionSetEvent,
-    MotionState,
-    ObjectSetEvent,
-    ObjectState,
+    Observable,
+    PluginContract,
     ProbeConfig,
     ProbeStream,
-    PTZInterface,
-    RTSPConnectionOptions,
+    PtzAutotrackSettings,
     RTSPUrlOptions,
-    SirenSetEvent,
-    SirenState,
-    SnapshotInterface,
-    StateNames,
-    StateValue,
-    StreamingInterface,
-    WebRTCConnectionOptions,
-)
-from _camera_ui_tools.camera_ui_types import (
-    PluginAPI as PluginAPIInterface,
+    Sensor,
+    SensorEventData,
+    SensorLike,
+    SensorType,
+    SnapshotSettings,
+    SnapshotUrlOptions,
+    StreamUrls,
+    Subject,
+    distinct_until_changed,
+    filter_op,
+    merge_map,
+    pairwise,
+    share,
 )
-from _camera_ui_tools.camera_ui_types import (
-    VideoFrame as VideoFrameInterface,
-)
-from _camera_ui_tools.camera_ui_types.hybrid_observer import HybridObservable
-from camera.python.classes import transform_labels
-from camera.python.interfaces import CameraInterface
-from camera.python.iou import merge_detections
-from camera.python.polygon import are_detections_valid
-from camera.python.typings import (
-    SetValue,
-)
-from camera.python.video_frame import VideoFrame
-from decoder.python.typings import FrameWorkerInterface
+from _camera_ui_tools.camera_ui_sdk import CameraDevice as CameraDeviceInterface
+from _camera_ui_tools.camera_ui_sdk.internal import SensorJSON
+from plugins.runtime.python.camera.utils import build_snapshot_url, build_target_url
 from plugins.runtime.python.namespaces import (
-    CameraFrameWorkerPluginNamespaces,
+    CameraNamespaces,
+    FrameWorkerDetectionNamespaces,
+    FrameWorkerNamespaces,
     NamespaceManager,
+    PluginCameraNamespaces,
+    SensorControllerNamespaces,
+)
+from plugins.runtime.python.proxy.sensor import (
+    DetectionCoordinatorRPC,
+    SensorControllerInterface,
+    SensorProxy,
 )
 from plugins.runtime.python.typings import (
-    API_EVENT,
-    CameraDeviceInterface,
-    CameraInterfaces,
-    PluginCapabilities,
+    CameraEventMessage,
     PluginInfo,
+    SensorAddedEvent,
+    SensorAssignmentChangedEvent,
+    SensorEventMessage,
+    SensorRemovedEvent,
+    StoredSensorData,
 )
 
+if TYPE_CHECKING:
+    from plugins.runtime.python.plugin_api import PluginAPI
+    from plugins.runtime.python.storage_controller import StorageController
 
-class CameraSourceImp(CameraSource):
-    def __init__(self, source: CameraInput, parent: Any):
-        self.__parent: CameraDeviceProxy = parent
-
-        self.id = source["_id"]
-        self.name = source["name"]
-        self.role = source["role"]
-        self.useForSnapshot = source["useForSnapshot"]
-        self.hotMode = source["hotMode"]
-        self.preload = source["preload"]
-        self.urls = source["urls"]
-
-    async def snapshot(self, force_new: bool | None = None) -> bytes | None:
-        return await self.__parent.snapshot(self.id, force_new)
-
-    async def probe_stream(
-        self, probe_config: Optional[ProbeConfig] = None, refresh: Optional[bool] = False
-    ) -> Optional[ProbeStream]:
-        return await self.__parent.probe_stream(self.id, probe_config, refresh)
 
+DETECTION_SENSOR_TYPES: frozenset[SensorType] = frozenset(
+    {
+        SensorType.Motion,
+        SensorType.Audio,
+        SensorType.Object,
+        SensorType.Face,
+        SensorType.LicensePlate,
+        SensorType.Classifier,
+    }
+)
 
-class CameraDeviceSourceImp(CameraSourceImp, CameraDeviceSource):
-    def __init__(self, source: CameraInput, parent: Any):
-        super().__init__(source, parent)
-        self.__parent: CameraDeviceProxy = parent
 
-    def generate_rtsp_url(self, options: Optional[RTSPUrlOptions]) -> str:
+class CameraControllerInterface(Protocol):
+    async def connect(self) -> None: ...
+    async def disconnect(self) -> None: ...
+    async def snapshot(self, source_id: str, force_new: bool | None = None) -> bytes | None: ...
+    async def probeStream(
+        self, source_id: str, probe_config: ProbeConfig | None = None, refresh: bool | None = False
+    ) -> ProbeStream | None: ...
+    async def refreshStates(self) -> dict[str, Any]: ...
+    async def registerSensor(self, sensor: SensorJSON, plugin_id: str) -> bool: ...
+    async def unregisterSensor(self, sensor_id: str) -> None: ...
+    async def streamUrl(self, source_id: str) -> str | None: ...
+    async def getStreamStatus(self, source_id: str) -> str: ...
+
+
+class CameraSourceImpl(CameraSource):
+    def __init__(self, source: CameraInput, parent: CameraDeviceProxy) -> None:
+        self._parent = parent
+        self._id: str = source["_id"]
+        self.name: str = source["name"]
+        self.role: CameraRole = source["role"]
+        self.useForSnapshot: bool = source["useForSnapshot"]
+        self.hotMode: bool = source["hotMode"]
+        self.preload: bool = source["preload"]
+        self.prebuffer: bool = source["prebuffer"]
+        self.urls: StreamUrls = source["urls"]
+        self.childSourceId: str | None = source.get("childSourceId")
+
+    async def snapshot(self, forceNew: bool | None = None) -> bytes | None:
+        return await self._parent._snapshot(self._id, forceNew)  # pyright: ignore[reportPrivateUsage]
+
+    async def probeStream(
+        self, probeConfig: ProbeConfig | None = None, refresh: bool | None = False
+    ) -> ProbeStream | None:
+        return await self._parent._probe_stream(self._id, probeConfig, refresh)  # pyright: ignore[reportPrivateUsage]
+
+    async def getStreamStatus(self) -> str:
+        return await self._parent._get_stream_status(self._id)  # pyright: ignore[reportPrivateUsage]
+
+
+class CameraDeviceSourceImpl(CameraSourceImpl, CameraDeviceSource):
+    def generateRTSPUrl(self, options: RTSPUrlOptions | None = None) -> str:
         return build_target_url(self.urls["rtsp"]["base"], options)
 
-    def create_webrtc_session(self, options: Optional[WebRTCConnectionOptions]) -> None:
-        # Todo: Implement
-        pass
-
-    def create_rtsp_session(self, options: Optional[RTSPConnectionOptions]) -> None:
-        # Todo: Implement
-        pass
+    def generateSnapshotUrl(self, options: SnapshotUrlOptions | None = None) -> str:
+        return build_snapshot_url(self._parent.name, self.name, self.urls["snapshot"]["jpeg"], options)
 
-    def create_fmp4_session(self, options: Optional[FMP4ConnectionOptions]) -> None:
-        # Todo: Implement
-        pass
 
-
-class CameraDeviceProxy(CameraDevice, Subscribed):
+class CameraDeviceProxy(Subscribed, CameraDeviceInterface):
     def __init__(
         self,
-        proxy: ClientInstance,
-        api: PluginAPIInterface,
+        proxy: RPCClient,
+        api: PluginAPI,
+        storage_controller: StorageController,
         camera: Camera,
         plugin: PluginInfo,
         logger: LoggerService,
-    ):
-        Subscribed.__init__(self)
-
-        self.__camera_subject = BehaviorSubject(camera)
-        self.__camera_state = BehaviorSubject[bool](False)
-        self.__frame_worker_state = BehaviorSubject[bool](False)
-        self.__light_state = BehaviorSubject[LightState](self.__get_light_state({"state": False}, True))
-        self.__motion_state = BehaviorSubject[MotionState](
-            self.__get_motion_state({"detections": [], "state": False}, True)
-        )
-        self.__audio_state = BehaviorSubject[AudioState](
-            self.__get_audio_state({"state": False, "db": 0}, True)
-        )
-        self.__object_state = BehaviorSubject[ObjectState](self.__get_object_state({"detections": []}, True))
-        self.__doorbell_state = BehaviorSubject[DoorbellState](
-            self.__get_doorbell_state({"state": False}, True)
-        )
-        self.__siren_state = BehaviorSubject[SirenState](
-            self.__get_siren_state({"state": False, "level": 0}, True)
-        )
-        self.__battery_state = BehaviorSubject[BatteryState](
-            self.__get_battery_state({"level": 100, "charging": False, "lowBattery": False}, True)
-        )
-        self.__capabilities = BehaviorSubject[list[PluginCapabilities]]([])
-
-        self.on_connected: HybridObservable[bool] = self.__create_state_observable(self.__camera_state)
-        self.on_frameworker_connected: HybridObservable[bool] = self.__create_state_observable(
-            self.__frame_worker_state
-        )
-        self.on_light_switched: HybridObservable[LightState] = self.__create_state_observable(
-            self.__light_state
-        )
-        self.on_motion_detected: HybridObservable[MotionState] = self.__create_state_observable(
-            self.__motion_state
-        )
-        self.on_audio_detected: HybridObservable[AudioState] = self.__create_state_observable(
-            self.__audio_state
-        )
-        self.on_object_detected: HybridObservable[ObjectState] = self.__create_state_observable(
-            self.__object_state
-        )
-        self.on_doorbell_pressed: HybridObservable[DoorbellState] = self.__create_state_observable(
-            self.__doorbell_state
-        )
-        self.on_siren_detected: HybridObservable[SirenState] = self.__create_state_observable(
-            self.__siren_state
-        )
-        self.on_battery_changed: HybridObservable[BatteryState] = self.__create_state_observable(
-            self.__battery_state
-        )
-
-        if not camera.get("pluginInfo", None):
-            self.__camera_state.on_next(True)
-
-        self.logger = logger
+    ) -> None:
+        super().__init__()
 
-        self.__api = api
-        self.__proxy = proxy
-        self.__plugin = plugin
-        self.__snapshot_cache = TTLCache[str, bytes](maxsize=100, ttl=self.snapshot_ttl)
-        self.__namespaces: CameraFrameWorkerPluginNamespaces = {
-            **NamespaceManager.camera_namespaces(self.id),
-            **NamespaceManager.frame_worker_namespaces(self.id),
-            **NamespaceManager.plugin_camera_namespaces(self.__plugin["id"], self.id),
-        }
+        self._camera_subject = BehaviorSubject(camera)
+        self._camera_state = BehaviorSubject[bool](False)
+        self._frame_worker_state = BehaviorSubject[bool](False)
+        self._initialized = BehaviorSubject[bool](False)
 
-        self.__initialized = False
-        self.__subscription: Optional[SubscriptionWrapper] = None
+        self._onConnected: Observable[bool] = self._create_state_observable(self._camera_state)
+        self._onFrameworkerConnected: Observable[bool] = self._create_state_observable(
+            self._frame_worker_state
+        )
 
-        self.__camera_interfaces = CameraInterface(
-            self.__proxy, self.__capabilities, self.id, self.plugin_info
+        self._logger = logger
+        self._api: PluginAPI = api
+        self._proxy = proxy
+        self._plugin = plugin
+        self._contract: PluginContract = plugin["contract"]
+        self._storage_controller: StorageController = storage_controller
+
+        self._sensor_added_subject: Subject[SensorEventData] = Subject()
+        self._sensor_removed_subject: Subject[SensorEventData] = Subject()
+        self._detection_event_subject: Subject[DetectionEventPayload] = Subject()
+
+        self._close_subscription: CloseHandler | None = None
+        self._close_sensor_subscription: CloseHandler | None = None
+        self._close_detection_subscription: CloseHandler | None = None
+
+        self._sensors: dict[str, SensorProxy] = {}
+        self._owned_sensors: dict[str, tuple[Sensor[Any, Any, Any], SensorType]] = {}
+        self._sensor_cleanup_functions: dict[str, CloseHandler] = {}
+
+        self._impl_cleanup_function: CloseHandler | None = None
+
+        self._tasks = TaskSet(name=f"CameraDevice:{camera['_id']}")
+
+        self._namespaces: tuple[
+            CameraNamespaces,
+            FrameWorkerNamespaces,
+            PluginCameraNamespaces,
+            SensorControllerNamespaces,
+            FrameWorkerDetectionNamespaces,
+        ] = (
+            NamespaceManager.camera_namespaces(self.id),
+            NamespaceManager.frame_worker_namespaces(self.id),
+            NamespaceManager.plugin_camera_namespaces(self._plugin["id"], self.id),
+            NamespaceManager.sensor_controller_namespaces(self.id),
+            NamespaceManager.frame_worker_detection_namespaces(self.id),
         )
 
-        self.__api.once(API_EVENT.SHUTDOWN.value, self.cleanup)
+        self._api.once(API_EVENT.SHUTDOWN.value, self.cleanup)
 
-        self.add_subscriptions(
-            self.on_property_change("name").subscribe(self.__on_name_change),
-        )
+    @property
+    def _cameraObject(self) -> Camera:
+        return deepcopy(self._camera_subject.value)
 
     @property
-    def camera_object(self) -> Camera:
-        return deepcopy(self.__camera_subject.value)
+    def logger(self) -> LoggerService:
+        return self._logger
 
     @property
     def id(self) -> str:
-        return self.__camera_subject.value["_id"]
+        return self._camera_subject.value["_id"]
 
     @property
-    def native_id(self) -> Optional[str]:
-        return self.__camera_subject.value.get("nativeId")
+    def nativeId(self) -> str | None:
+        return self._camera_subject.value.get("nativeId")
 
     @property
-    def plugin_info(self) -> Optional[CameraPluginInfo]:
-        return self.__camera_subject.value.get("pluginInfo")
+    def pluginInfo(self) -> CameraPluginInfo | None:
+        plugin_info = self._camera_subject.value.get("pluginInfo")
+        if not plugin_info:
+            return None
+
+        return deepcopy(self._camera_subject.value.get("pluginInfo"))
 
     @property
     def connected(self) -> bool:
-        return self.__camera_state.value or False
+        return self._camera_state.value or False
+
+    @property
+    def frameWorkerConnected(self) -> bool:
+        return self._frame_worker_state.value or False
+
+    @property
+    def onConnected(self) -> Observable[bool]:
+        return self._onConnected
 
     @property
-    def frameworker_connected(self) -> bool:
-        return self.__frame_worker_state.value or False
+    def onFrameWorkerConnected(self) -> Observable[bool]:
+        return self._onFrameworkerConnected
 
     @property
     def disabled(self) -> bool:
-        return self.__camera_subject.value["disabled"]
+        return self._camera_subject.value["disabled"]
 
     @property
     def name(self) -> str:
-        return self.__camera_subject.value["name"]
+        return self._camera_subject.value["name"]
 
     @property
-    def type(self) -> CameraType:
-        return self.__camera_subject.value["type"]
+    def room(self) -> str:
+        return self._camera_subject.value.get("room", "Default")
 
     @property
-    def info(self) -> CameraInformation:
-        return deepcopy(self.__camera_subject.value["info"])
+    def type(self) -> CameraType:
+        return self._camera_subject.value["type"]
 
     @property
-    def is_cloud(self) -> bool:
-        return self.__camera_subject.value["isCloud"]
+    def info(self) -> CameraInformation:
+        return deepcopy(self._camera_subject.value["info"])
 
     @property
-    def has_light(self) -> bool:
-        return self.has_capability(CameraDeviceCapability.Light)
+    def isCloud(self) -> bool:
+        return self._camera_subject.value["isCloud"]
 
     @property
-    def has_siren(self) -> bool:
-        return self.has_capability(CameraDeviceCapability.Siren)
+    def snapshotSettings(self) -> SnapshotSettings:
+        return deepcopy(self._camera_subject.value["snapshotSettings"])
 
     @property
-    def has_doorbell(self) -> bool:
-        return self.has_capability(CameraDeviceCapability.Doorbell)
+    def detectionZones(self) -> list[DetectionZone]:
+        return deepcopy(self._camera_subject.value["detectionZones"])
 
     @property
-    def has_battery(self) -> bool:
-        return self.has_capability(CameraDeviceCapability.Battery)
+    def detectionLines(self) -> list[DetectionLine]:
+        return deepcopy(self._camera_subject.value["detectionLines"])
 
     @property
-    def has_audio_detector(self) -> bool:
-        return self.has_capability(CameraDeviceCapability.AudioSensor)
+    def detectionSettings(self) -> CameraDetectionSettings:
+        return deepcopy(self._camera_subject.value["detectionSettings"])
 
     @property
-    def has_motion_detector(self) -> bool:
-        return self.has_capability(CameraDeviceCapability.MotionSensor) or self.has_capability(
-            CameraDeviceCapability.MotionDetector
-        )
+    def ptzAutotrack(self) -> PtzAutotrackSettings:
+        return deepcopy(self._camera_subject.value["ptzAutotrack"])
 
     @property
-    def has_object_detector(self) -> bool:
-        return self.has_capability(CameraDeviceCapability.ObjectSensor) or self.has_capability(
-            CameraDeviceCapability.ObjectDetector
-        )
+    def snooze(self) -> bool:
+        return bool(self._camera_subject.value["detectionSettings"].get("snooze", False))
 
     @property
-    def has_ptz(self) -> bool:
-        return self.has_capability(CameraDeviceCapability.PTZ)
+    def frameWorkerSettings(self) -> CameraFrameWorkerSettings:
+        return deepcopy(self._camera_subject.value["frameWorkerSettings"])
 
     @property
-    def snapshot_ttl(self) -> int:
-        return self.__camera_subject.value["snapshotTTL"]
+    def interfaceSettings(self) -> CameraUiSettings:
+        return deepcopy(self._camera_subject.value["interfaceSettings"])
 
     @property
-    def detection_zones(self) -> list[DetectionZone]:
-        return deepcopy(self.__camera_subject.value["detectionZones"])
+    def sources(self) -> list[CameraDeviceSource]:
+        sources = deepcopy(self._camera_subject.value["sources"])
+        return [CameraDeviceSourceImpl(source, self) for source in sources]
 
     @property
-    def detection_settings(self) -> CameraDetectionSettings:
-        return deepcopy(self.__camera_subject.value["detectionSettings"])
+    def streamSource(self) -> CameraDeviceSource:
+        return cast(
+            CameraDeviceSource,
+            self.highResolutionSource or self.midResolutionSource or self.lowResolutionSource,
+        )
 
     @property
-    def frameworker_settings(self) -> CameraFrameWorkerSettings:
-        return deepcopy(self.__camera_subject.value["frameWorkerSettings"])
+    def highResolutionSource(self) -> CameraDeviceSource | None:
+        return next((s for s in self.sources if s.role == "high-resolution"), None)
 
     @property
-    def sources(self) -> list[CameraDeviceSource]:
-        sources = deepcopy(self.__camera_subject.value["sources"])
-        return [CameraDeviceSourceImp(source, self) for source in sources]
+    def midResolutionSource(self) -> CameraDeviceSource | None:
+        return next((s for s in self.sources if s.role == "mid-resolution"), None)
 
     @property
-    def stream_source(self) -> CameraDeviceSource:
-        source = self.high_resolution_source or self.mid_resolution_source or self.low_resolution_source
-        return cast(CameraDeviceSource, source)
+    def lowResolutionSource(self) -> CameraDeviceSource | None:
+        return next((s for s in self.sources if s.role == "low-resolution"), None)
 
     @property
-    def snapshot_source(self) -> Optional[CameraSource]:
-        snapshot_source = next((source for source in self.sources if source.role == "snapshot"), None)
-
+    def snapshotSource(self) -> CameraDeviceSource | None:
+        snapshot_source = next((s for s in self.sources if s.role == "snapshot"), None)
         if not snapshot_source:
-            snapshot_source = next((source for source in self.sources if source.useForSnapshot), None)
-
+            snapshot_source = next((s for s in self.sources if s.useForSnapshot), None)
         return snapshot_source
 
     @property
-    def high_resolution_source(self) -> Optional[CameraDeviceSource]:
-        return next((source for source in self.sources if source.role == "high-resolution"), None)
+    def _camera_controller_proxy(self) -> CameraControllerInterface:
+        return self._proxy.create_proxy(self._namespaces[0].camera_controller_rpc)
 
     @property
-    def mid_resolution_source(self) -> Optional[CameraDeviceSource]:
-        return next(
-            (source for source in self.sources if "mid-resolution" in source.role == "mid-resolution"), None
-        )
+    def _sensor_controller_proxy(self) -> SensorControllerInterface:
+        return self._proxy.create_proxy(self._namespaces[3].sensor_rpc)
 
     @property
-    def low_resolution_source(self) -> Optional[CameraDeviceSource]:
-        return next(
-            (source for source in self.sources if "low-resolution" in source.role == "low-resolution"), None
-        )
+    def _detection_coordinator_proxy(self) -> DetectionCoordinatorRPC:
+        return self._proxy.create_proxy(self._namespaces[4].detection_rpc)
 
-    @property
-    def interfaces(self) -> CameraInterfaces:
-        return self.__camera_interfaces
+    def getSourceById(self, id: str) -> CameraDeviceSource | None:
+        return next((s for s in self.sources if s._id == id), None)
+
+    def _can_access_sensor(self, sensor: StoredSensorData) -> bool:
+        # Own sensors are always accessible
+        if sensor.get("pluginId") == self._plugin["id"]:
+            return True
+
+        # Foreign sensors require consumes declaration
+        return "consumes" in self._contract and sensor["type"] in self._contract["consumes"]
 
     async def init(self) -> None:
-        if self.__initialized:
+        if self._initialized.value:
             return
 
-        self.__initialized = True
+        self._initialized.next(True)
 
-        self.__subscription = await self.__proxy.subscribe(
-            self.__namespaces["cameraSubject"], self.__on_event_message
+        self._close_subscription = await self._proxy.subscribe(
+            self._namespaces[0].camera_subject, self._on_event_message
         )
 
-        await self.__proxy.register_rpc_handler(
-            self.__namespaces["cameraInterfacesRpc"], self.__camera_interfaces
+        self._close_sensor_subscription = await self._proxy.subscribe(
+            self._namespaces[3].sensor_subject, self._on_global_sensor_event
         )
-        await self.__refresh_states()
-
-    def extend(self, interfaces: PTZInterface | SnapshotInterface | StreamingInterface) -> None:
-        self.__camera_interfaces.interfaces = interfaces
-
-    async def connect(self) -> None:
-        if self.plugin_info and self.plugin_info["id"] == self.__plugin["id"]:
-            raise Exception("Camera plugin ID does not match the current plugin ID.")
-
-        camera_controller_proxy = await self.__camera_controller_proxy()
-        return await camera_controller_proxy.connect()
-
-    async def disconnect(self) -> None:
-        if self.plugin_info and self.plugin_info["id"] == self.__plugin["id"]:
-            raise Exception("Camera plugin ID does not match the current plugin ID.")
-
-        camera_controller_proxy = await self.__camera_controller_proxy()
-        return await camera_controller_proxy.disconnect()
-
-    @overload  # type: ignore[override]
-    async def get_frames(
-        self, frame_type: Literal["video"], options: Optional[ImageOptions] = None
-    ) -> AsyncGenerator[VideoFrameInterface, None]: ...
-    @overload
-    async def get_frames(
-        self, frame_type: Literal["motion"], options: Optional[ImageOptions] = None
-    ) -> AsyncGenerator[VideoFrameInterface, None]: ...
-    async def get_frames(  # type: ignore[misc]
-        self, frame_type: FrameType, options: Optional[ImageOptions] = None
-    ) -> AsyncGenerator[VideoFrameInterface, None]:
-        subscription: Optional[SubscriptionWrapper] = None
-        current_resolver: Optional[Callable[[Optional[MotionDetectionFrame]], None]] = None
-        cap_subscription: Optional[DisposableBase] = None
-        motion_subscription: Optional[DisposableBase] = None
-        current_type = frame_type
-
-        # For motion sensor only
-        motion_detected: bool = False
-        frameWorkerGenerator: Optional[AsyncGenerator[FrameData, None]] = None
-        pendingFramePromise: Optional[asyncio.Task[Any]] = None
-
-        def is_motion_detector() -> bool:
-            return self.has_motion_detector and self.has_capability(CameraDeviceCapability.MotionDetector)
-
-        def is_motion_sensor_only() -> bool:
-            return (
-                self.has_motion_detector
-                and not self.has_capability(CameraDeviceCapability.MotionDetector)
-                and self.has_capability(CameraDeviceCapability.MotionSensor)
-            )
-
-        async def stop_frameworker_generator() -> None:
-            nonlocal frameWorkerGenerator, pendingFramePromise
-            if frameWorkerGenerator is not None:
-                try:
-                    await frameWorkerGenerator.aclose()
-                except:  # noqa: E722
-                    pass
-                finally:
-                    frameWorkerGenerator = None
 
-            if pendingFramePromise is not None and not pendingFramePromise.done():
-                pendingFramePromise.cancel()
-            pendingFramePromise = None
+        ns = NamespaceManager.detection_event_namespaces(self.id)
 
-        try:
-            frame_worker_proxy = await self.__frame_worker_proxy()
-            queue: list[MotionDetectionFrame] = []
-
-            # Subscribe to motion frames if needed for motion detector
-            if current_type == "motion":
-
-                def on_frame(message: Message[MotionDetectionFrame]) -> None:
-                    nonlocal current_resolver
-                    if current_resolver:
-                        current_resolver(message["data"])
-                        current_resolver = None
-                    else:
-                        queue.append(message["data"])
-
-                subscription = await self.__proxy.subscribe(
-                    self.__namespaces["cameraMotionFrameSubject"], on_frame
-                )
+        def _handle_detection_msg(msg: dict[str, Any]) -> None:
+            self._detection_event_subject.next({"type": msg["type"], "event": msg["data"]})
 
-                # For motion sensor, subscribe to motion events
-                if is_motion_sensor_only():
-                    # Initialize motion state from current value
-                    motion_detected = self.__motion_state.value.get("state", False)
-
-                    # Subscribe to motion state changes
-                    def on_motion_detected(state: MotionState) -> None:
-                        nonlocal motion_detected, current_resolver
-                        new_motion_state = state.get("state", False)
-                        if new_motion_state != motion_detected:
-                            motion_detected = new_motion_state
-
-                            # If motion just started and we're waiting, resolve to continue the loop
-                            if motion_detected and current_resolver:
-                                current_resolver(None)
-                                current_resolver = None
-
-                    motion_subscription = self.on_motion_detected.subscribe(on_motion_detected)
-
-            # Subscribe to changes in capabilities
-            if frame_type == "motion":
-
-                async def on_capabilities_change(capabilities: CameraCapabilitiesObservableObject) -> None:
-                    nonlocal current_type, current_resolver, frameWorkerGenerator, pendingFramePromise
-
-                    new_capabilities: list[CameraDeviceCapability] = capabilities["new_capabilities"]
-                    old_capabilities: list[CameraDeviceCapability] = capabilities["old_capabilities"]
-
-                    had_motion_detector = CameraDeviceCapability.MotionDetector in old_capabilities
-                    has_motion_detector_now = CameraDeviceCapability.MotionDetector in new_capabilities
-                    has_new_motion_detector = is_motion_detector() or is_motion_sensor_only()
-
-                    # Case 1: Currently in motion mode, but no motion detector available anymore
-                    if current_type == "motion" and not has_new_motion_detector:
-                        self.logger.trace("Switching to stream mode due to missing motion detector")
-
-                        # Reset any motion sensor state
-                        await stop_frameworker_generator()
-
-                        # If we're waiting for motion, resolve to restart the loop
-                        if current_resolver:
-                            current_resolver(None)
-                            current_resolver = None
-
-                    # Case 2: Currently in stream mode, but motion detector available now
-                    elif current_type == "stream" and has_new_motion_detector:
-                        self.logger.trace("Switching to motion mode due to motion detector being available")
-                        current_type = frame_type
-
-                    # Case 3: Currently in motion sensor mode, but motion detector available now
-                    elif current_type == "motion" and not had_motion_detector and has_motion_detector_now:
-                        self.logger.trace("Switching from motion sensor to motion detector")
-
-                        # Reset any motion sensor state
-                        await stop_frameworker_generator()
-
-                        # If we're waiting for motion, resolve to restart the loop
-                        if current_resolver:
-                            current_resolver(None)
-                            current_resolver = None
-
-                    # Case 4: Currently using motion detector, but now switching back to motion sensor
-                    elif (
-                        current_type == "motion"
-                        and had_motion_detector
-                        and not has_motion_detector_now
-                        and is_motion_sensor_only()
-                    ):
-                        self.logger.trace("Switching from motion detector to motion sensor")
-                        # Reset frameWorkerGenerator so it will be re-initialized for motion sensor mode
-                        if frameWorkerGenerator is None and current_resolver:
-                            # If we're waiting for motion (which is likely since motion detector was removed),
-                            # resolve to restart the loop in built-in mode
-                            current_resolver(None)
-                            current_resolver = None
-
-                cap_subscription = self.on_capabilities_change().asubscribe(on_capabilities_change)
-
-            async def get_prebuffered_frame(timestamp: int) -> Optional[FrameData]:
-                try:
-                    return await frame_worker_proxy.getPrebufferedFrame(timestamp, options)
-                except:  # noqa: E722
-                    return None
-
-            async def process_motion_frame(motion_frame: MotionDetectionFrame) -> FrameData:
-                frame_format = motion_frame["frame"]["info"]["format"]
-                frame_width = motion_frame["frame"]["info"]["width"]
-                frame_height = motion_frame["frame"]["info"]["height"]
-
-                requested_format = (
-                    options.get("format", {}).get("to", frame_format) if options else frame_format
-                )
-                requested_width = (
-                    (
-                        options.get("resize", {}).get("width")
-                        or options.get("crop", {}).get("width")
-                        or frame_width
-                    )
-                    if options
-                    else frame_width
-                )
-                requested_height = (
-                    (
-                        options.get("resize", {}).get("height")
-                        or options.get("crop", {}).get("height")
-                        or frame_height
-                    )
-                    if options
-                    else frame_height
-                )
-
-                process_frame = (
-                    requested_format != frame_format
-                    or requested_width != frame_width
-                    or requested_height != frame_height
-                )
-
-                if process_frame and options:
-                    prebuffered_frame = await get_prebuffered_frame(motion_frame["frame"]["timestamp"])
-                    if prebuffered_frame:
-                        return prebuffered_frame
-                    else:
-                        format: Union[DecoderFormat, Literal["rgba", "gray"]] = (
-                            "rgb24" if frame_format == "rgb" else frame_format
-                        )
-                        frame_data = await frame_worker_proxy.processFrame(
-                            motion_frame["frame"]["data"], frame_width, frame_height, format, options
-                        )
-                        return {
-                            "data": frame_data["image"],
-                            "info": frame_data["info"],
-                            "metadata": {
-                                "format": motion_frame["frame"]["metadata"]["format"],
-                                "frameSize": motion_frame["frame"]["metadata"]["frameSize"],
-                                "height": frame_data["info"]["height"],
-                                "width": frame_data["info"]["width"],
-                                "origHeight": motion_frame["frame"]["info"]["height"],
-                                "origWidth": motion_frame["frame"]["info"]["width"],
-                            },
-                            "timestamp": motion_frame["frame"]["timestamp"],
-                        }
-                else:
-                    return motion_frame["frame"]
-
-            while self.__initialized:
-                try:
-                    # Handle motion detector
-                    if current_type == "motion" and is_motion_detector():
-                        if queue:
-                            motion_frame = queue.pop(0)
-                            motion_frame["frame"] = await process_motion_frame(motion_frame)
-                            yield VideoFrame(
-                                motion_frame["frame"],
-                                self.__namespaces["frameWorkerChildRpc"],
-                                self.__proxy,
-                                motion_frame["state"],
-                            )
-                        else:
-                            future: asyncio.Future[Union[MotionDetectionFrame, None]] = asyncio.Future()
-                            current_resolver = future.set_result
-                            motion_frame_exists = await future
-
-                            if not motion_frame_exists:
-                                current_type = "stream"
-                                continue
-
-                            motion_frame = motion_frame_exists
-                            motion_frame["frame"] = await process_motion_frame(motion_frame)
-                            yield VideoFrame(
-                                motion_frame["frame"],
-                                self.__namespaces["frameWorkerChildRpc"],
-                                self.__proxy,
-                                motion_frame["state"],
-                            )
-                    # Handle motion sensor
-                    elif current_type == "motion" and is_motion_sensor_only():
-                        # Initialize frame generator immediately if needed
-                        if frameWorkerGenerator is None:
-                            self.logger.trace("Initializing frame worker generator for motion sensor")
-                            frameWorkerGenerator = frame_worker_proxy.generateFrames(options)
-
-                            # Execute first next() to establish the connection
-                            try:
-                                # Discard the first frame - we just want to establish the connection
-                                await frameWorkerGenerator.__anext__()
-                            except Exception as e:
-                                self.logger.warn(f"Failed to initialize frame worker generator: {str(e)}")
-                                frameWorkerGenerator = None
-                                current_type = "stream"
-                                continue
-
-                        # If no motion detected, wait for it
-                        if not motion_detected:
-                            future = asyncio.Future()
-                            current_resolver = future.set_result
-                            await future
-                            continue
-
-                        # Motion is detected - get the most current frame
-                        try:
-                            frame = await frameWorkerGenerator.__anext__()
-                        except StopAsyncIteration:
-                            # Generator ended, reset and switch to stream
-                            frameWorkerGenerator = None
-                            current_type = "stream"
-                            continue
-
-                        # Create a synthetic motion state for the frame
-                        motion_state: MotionSetEvent = {
-                            "state": True,
-                            "detections": self.__motion_state.value.get("detections", []),
-                        }
-
-                        # Yield the frame with motion state
-                        yield VideoFrame(
-                            frame, self.__namespaces["frameWorkerChildRpc"], self.__proxy, motion_state
-                        )
-                    else:
-                        # Handle regular streaming
-                        # Reset motion sensor resources if switching modes
-                        if frameWorkerGenerator is not None:
-                            frameWorkerGenerator = None
-                            pendingFramePromise = None
-
-                        # Regular stream mode
-                        async for frame in frame_worker_proxy.generateFrames(options):
-                            if (current_type == "motion" and is_motion_detector()) or (
-                                current_type == "motion" and is_motion_sensor_only()
-                            ):
-                                break  # Break stream loop to switch back to motion mode
-                            yield VideoFrame(frame, self.__namespaces["frameWorkerChildRpc"], self.__proxy)
-
-                except (StopAsyncIteration, GeneratorExit):
-                    self.logger.trace("Stopping frame generator")
-                    break
-
-        except Exception as e:
-            if not self.__initialized:
-                return
-
-            raise e
-
-        finally:
-            if subscription:
-                await subscription.unsubscribe()
-            if cap_subscription:
-                cap_subscription.dispose()
-            if motion_subscription:
-                motion_subscription.dispose()
-            if pendingFramePromise and not pendingFramePromise.done():
-                pendingFramePromise.cancel()
-
-    def add_capabilities(self, capabilities: list[CameraDeviceCapability]) -> None:
-        new_capabilities: list[CameraDeviceCapability] = []
-
-        for capability in capabilities:
-            if not self.has_capability(capability):
-                new_capabilities.append(capability)
-
-        if new_capabilities:
-            all_capabilities = deepcopy(self.__capabilities.value)
-            plugin_related_capabilities = next(
-                (cap for cap in all_capabilities if cap["pluginId"] == self.__plugin["id"]), None
-            )
-
-            if plugin_related_capabilities:
-                plugin_related_capabilities["capabilities"].extend(new_capabilities)
-            else:
-                all_capabilities.append({"pluginId": self.__plugin["id"], "capabilities": new_capabilities})
-
-            self.__capabilities.on_next(all_capabilities)
-
-            async def updateCapabilities() -> None:
-                try:
-                    camera_controller_proxy = await self.__camera_controller_proxy()
-                    await camera_controller_proxy.addPluginCapabilities(self.__plugin["id"], new_capabilities)
-                except asyncio.CancelledError:
-                    # Ignore cancellation errors
-                    pass
-                # except Exception as e:
-                #     self.logger.error("Failed to add capabilities:", e)
-                except:  # noqa: E722
-                    pass
-
-            asyncio.create_task(updateCapabilities())
-
-    def remove_capabilities(self, capabilities: list[CameraDeviceCapability]) -> None:
-        all_capabilities = deepcopy(self.__capabilities.value)
-        plugin_related_capabilities = next(
-            (cap for cap in all_capabilities if cap["pluginId"] == self.__plugin["id"]), None
+        self._close_detection_subscription = await self._proxy.subscribe(
+            ns.detection_event_subject, _handle_detection_msg
         )
 
-        if plugin_related_capabilities:
-            plugin_related_capabilities["capabilities"] = (
-                []
-                if len(capabilities) == 0
-                else [cap for cap in plugin_related_capabilities["capabilities"] if cap not in capabilities]
-            )
-
-            if not plugin_related_capabilities["capabilities"]:
-                all_capabilities.remove(plugin_related_capabilities)
-
-            self.__capabilities.on_next(all_capabilities)
+        await self._refresh_states()
+        await self._initialize_sensors()
 
-            async def updateCapabilities() -> None:
-                try:
-                    camera_controller_proxy = await self.__camera_controller_proxy()
-                    await camera_controller_proxy.removePluginCapabilities(self.__plugin["id"], capabilities)
-                except Exception as e:
-                    if not self.__initialized:
-                        return
-
-                    self.logger.error("Failed to remove capabilities:", e)
-
-            asyncio.create_task(updateCapabilities())
-
-    def get_capabilities(self) -> list[CameraDeviceCapability]:
-        capabilities: list[CameraDeviceCapability] = []
-        for capability in self.__capabilities.value:
-            if capability["capabilities"]:
-                capabilities.extend(capability["capabilities"])
-
-        return capabilities
-
-    def has_capability(self, capability: CameraDeviceCapability) -> bool:
-        capabilities = self.get_capabilities()
-        return capability in capabilities
-
-    @overload
-    def get_value(self, state_name: Literal["light"]) -> LightState: ...
-    @overload
-    def get_value(self, state_name: Literal["motion"]) -> MotionState: ...
-    @overload
-    def get_value(self, state_name: Literal["audio"]) -> AudioState: ...
-    @overload
-    def get_value(self, state_name: Literal["object"]) -> ObjectState: ...
-    @overload
-    def get_value(self, state_name: Literal["doorbell"]) -> DoorbellState: ...
-    @overload
-    def get_value(self, state_name: Literal["siren"]) -> SirenState: ...
-    @overload
-    def get_value(self, state_name: Literal["battery"]) -> BatteryState: ...
-    def get_value(
-        self, state_name: Literal["light", "motion", "audio", "object", "doorbell", "siren", "battery"]
-    ) -> Union[
-        LightState,
-        MotionState,
-        AudioState,
-        ObjectState,
-        DoorbellState,
-        SirenState,
-        BatteryState,
-    ]:
-        if state_name == "light":
-            return deepcopy(self.__light_state.value)
-        elif state_name == "motion":
-            return deepcopy(self.__motion_state.value)
-        elif state_name == "audio":
-            return deepcopy(self.__audio_state.value)
-        elif state_name == "object":
-            return deepcopy(self.__object_state.value)
-        elif state_name == "doorbell":
-            return deepcopy(self.__doorbell_state.value)
-        elif state_name == "siren":
-            return deepcopy(self.__siren_state.value)
-        elif state_name == "battery":
-            return deepcopy(self.__battery_state.value)
-        else:
-            raise Exception(f"Unknown state: {state_name}")
-
-    @overload
-    async def update_state(
-        self,
-        state_name: Literal["light"],
-        event_data: LightSetEvent,
-    ) -> None: ...
-    @overload
-    async def update_state(
-        self,
-        state_name: Literal["motion"],
-        event_data: MotionSetEvent,
-        frame: Optional[VideoFrameInterface] = None,
-    ) -> None: ...
-    @overload
-    async def update_state(
-        self,
-        state_name: Literal["audio"],
-        event_data: AudioSetEvent,
-    ) -> None: ...
-    @overload
-    async def update_state(
-        self,
-        state_name: Literal["object"],
-        event_data: ObjectSetEvent,
-    ) -> None: ...
-    @overload
-    async def update_state(
-        self,
-        state_name: Literal["doorbell"],
-        event_data: DoorbellSetEvent,
-    ) -> None: ...
-    @overload
-    async def update_state(
-        self,
-        state_name: Literal["siren"],
-        event_data: SirenSetEvent,
-    ) -> None: ...
-    @overload
-    async def update_state(
-        self,
-        state_name: Literal["battery"],
-        event_data: BatterySetEvent,
-    ) -> None: ...
-    async def update_state(
-        self, state_name: Any, event_data: Any, frame: Optional[VideoFrameInterface] = None
-    ) -> None:
-        try:
-            can_update = self.__can_update_state_internal(state_name)
-            if not can_update:
-                self.logger.warn(f"State '{state_name}' can only be updated by the corresponding plugin.")
-                return
+    async def connect(self) -> None:
+        if not self.pluginInfo or self.pluginInfo["id"] != self._plugin["id"]:
+            return
 
-            changed, event = cast(tuple[bool, Any], self.__check_state_internal(state_name, event_data))
+        await self._camera_controller_proxy.connect()
 
-            if not changed:
-                return
-
-            self.__update_state_internal(state_name, event, True)
-
-            if state_name == "motion" and frame and self.has_object_detector:
-                motion_event = cast(MotionSetEvent, event)
-                if motion_event["state"] and "detections" in motion_event and motion_event["detections"]:
-                    motion_frame: MotionDetectionFrame = {
-                        "frame": {
-                            "data": frame.data,
-                            "info": frame.info,
-                            "metadata": frame.metadata,
-                            "timestamp": int(datetime.now().timestamp() * 1000),
-                        },
-                        "state": motion_event,
-                    }
-
-                    await self.__proxy.publish(self.__namespaces["cameraMotionFrameSubject"], motion_frame)
-
-            camera_controller_proxy = await self.__camera_controller_proxy()
-            await camera_controller_proxy.updateState(state_name, event)
-        except Exception as e:
-            if not self.__initialized:
-                return
+    async def disconnect(self) -> None:
+        if not self.pluginInfo or self.pluginInfo["id"] != self._plugin["id"]:
+            return
 
-            raise e
-
-    @overload
-    def on_state_change(
-        self, state_name: Literal["light"]
-    ) -> HybridObservable[CameraStateChangedObject[LightState]]: ...
-    @overload
-    def on_state_change(
-        self, state_name: Literal["motion"]
-    ) -> HybridObservable[CameraStateChangedObject[MotionState]]: ...
-    @overload
-    def on_state_change(
-        self, state_name: Literal["audio"]
-    ) -> HybridObservable[CameraStateChangedObject[AudioState]]: ...
-    @overload
-    def on_state_change(
-        self, state_name: Literal["doorbell"]
-    ) -> HybridObservable[CameraStateChangedObject[DoorbellState]]: ...
-    @overload
-    def on_state_change(
-        self, state_name: Literal["siren"]
-    ) -> HybridObservable[CameraStateChangedObject[SirenState]]: ...
-    @overload
-    def on_state_change(
-        self, state_name: Literal["battery"]
-    ) -> HybridObservable[CameraStateChangedObject[BatteryState]]: ...
-    @overload
-    def on_state_change(
-        self, state_name: Literal["object"]
-    ) -> HybridObservable[CameraStateChangedObject[ObjectState]]: ...
-    def on_state_change(self, state_name: Any) -> Any:
-        state: Union[BehaviorSubject[StateValue], None] = getattr(self, f"{state_name}_state", None)
-
-        if not state:
-            raise Exception(f"{state_name}_state not found")
-
-        def filter_fn(states: tuple[StateValue, StateValue]) -> bool:
-            old_state = states[0]
-            new_state = states[1]
-            return self.__state_changed(old_state, new_state, state_name)
-
-        def map_fn(states: tuple[StateValue, StateValue]) -> CameraStateChangedObject[StateValue]:
-            return {"old_state": states[0], "new_state": states[1]}
-
-        return HybridObservable(
-            state.pipe(
-                ops.pairwise(),
-                ops.filter(filter_fn),
-                ops.map(map_fn),
-                ops.share(),
-            )
-        )
+        await self._camera_controller_proxy.disconnect()
 
-    def on_property_change(
-        self, property: Union[CameraPublicProperties, list[CameraPublicProperties]]
-    ) -> HybridObservable[CameraPropertyObservableObject]:
+    def onPropertyChange(
+        self, property: CameraPublicProperties | list[CameraPublicProperties]
+    ) -> Observable[CameraPropertyObservableObject]:
         def map_fn(
             cameras: tuple[Camera, Camera],
         ) -> list[Any]:
@@ -989,758 +418,399 @@ class CameraDeviceProxy(CameraDevice, Subscribed):
                 != {}
             )
 
-        return HybridObservable(
-            self.__camera_subject.pipe(
-                ops.pairwise(),
-                ops.flat_map(map_fn),
-                ops.filter(filter_fn),
-                ops.share(),
-            )
+        return self._camera_subject.pipe(
+            pairwise(),
+            merge_map(lambda cameras, _idx: map_fn(cameras)),
+            filter_op(filter_fn),
+            share(),
         )
 
-    def on_capabilities_change(self) -> HybridObservable[CameraCapabilitiesObservableObject]:
-        def filter_fn(
-            capabilities: tuple[list[PluginCapabilities], list[PluginCapabilities]],
-        ) -> bool:
-            return (
-                DeepDiff(
-                    capabilities[0],
-                    capabilities[1],
-                    ignore_order=True,
-                    use_enum_value=True,
-                )
-                != {}
-            )
+    def createStorage(self, schemas: list[Any]) -> Any:
+        return self._storage_controller.createCameraStorage(self.id, schemas)
 
-        def map_fn(
-            capabilities: tuple[list[PluginCapabilities], list[PluginCapabilities]],
-        ) -> CameraCapabilitiesObservableObject:
-            old_capabilities: list[CameraDeviceCapability] = []
-            new_capabilities: list[CameraDeviceCapability] = []
-
-            for capability in capabilities[0]:
-                if capability["capabilities"]:
-                    old_capabilities.extend(capability["capabilities"])
-
-            for capability in capabilities[1]:
-                if capability["capabilities"]:
-                    new_capabilities.extend(capability["capabilities"])
-
-            return {
-                "old_capabilities": old_capabilities,
-                "new_capabilities": new_capabilities,
-            }
-
-        return HybridObservable(
-            self.__capabilities.pipe(
-                ops.pairwise(),
-                ops.filter(filter_fn),
-                ops.map(map_fn),
-                ops.share(),
-            )
+    def getSensors(self) -> list[SensorLike]:
+        owned_sensors = [entry[0] for entry in self._owned_sensors.values()]
+        proxy_sensors = list(self._sensors.values())
+        return [*owned_sensors, *proxy_sensors]
+
+    def getSensor(self, sensorId: str) -> SensorLike | None:
+        # Check if we own this sensor - return the real sensor
+        owned = self._owned_sensors.get(sensorId)
+        if owned:
+            return owned[0]
+        # Return proxy for foreign sensors
+        return self._sensors.get(sensorId)
+
+    def getSensorsByType(self, sensorType: SensorType) -> list[SensorLike]:
+        return [s for s in self.getSensors() if s.type == sensorType]
+
+    async def addSensor(self, sensor: Sensor[Any, Any, Any]) -> None:
+        plugin_id = self._plugin["id"]
+
+        sensor._setCameraId(self.id)  # pyright: ignore[reportPrivateUsage]
+        sensor._setPluginId(plugin_id)  # pyright: ignore[reportPrivateUsage]
+
+        sensor_type = sensor.type
+        sensor._init(  # pyright: ignore[reportPrivateUsage]
+            lambda properties: self._on_sensor_state_write(sensor.id, sensor_type, properties)
         )
 
-    async def snapshot(self, source_id: str, force_new: Optional[bool] = None) -> Optional[bytes]:
-        self.__snapshot_cache.expire()
+        sensor._initCapabilities(lambda caps: self._on_sensor_capabilities_changed(sensor.id, caps))  # pyright: ignore[reportPrivateUsage]
 
-        from_cache = self.__snapshot_cache.get(source_id) if source_id in self.__snapshot_cache else None
-        if from_cache and not force_new:
-            return from_cache
+        schemas = sensor.storage_schema
+        storage = self._storage_controller.createSensorStorage(
+            self.id,
+            sensor.type,
+            plugin_id,
+            sensor.name,
+            sensor.id,
+            schemas,
+        )
+        await storage.register_storage()
 
-        camera_controller_proxy = await self.__camera_controller_proxy()
+        saved_display_name = storage.values.get("_displayName")
+        sensor.displayName = saved_display_name if saved_display_name else sensor.name
 
-        snapshot = await camera_controller_proxy.snapshot(source_id, force_new)
-        if snapshot and len(snapshot) > 0:
-            self.__snapshot_cache[source_id] = snapshot
-            return snapshot
+        sensor._setStorage(storage)  # pyright: ignore[reportPrivateUsage]
 
-        return None
+        sensor_namespace = NamespaceManager.sensor_provider_namespaces(
+            plugin_id, self.id, sensor.id
+        ).sensor_rpc
 
-    async def probe_stream(
-        self, source_id: str, probe_config: Optional[ProbeConfig] = None, refresh: Optional[bool] = False
-    ) -> Optional[ProbeStream]:
-        camera_controller_proxy = await self.__camera_controller_proxy()
-        return await camera_controller_proxy.probeStream(source_id, probe_config, refresh)
+        requires_frames = getattr(sensor, "_requires_frames", False)
+        model_spec = getattr(sensor, "modelSpec", None)
 
-    async def cleanup(self) -> None:
-        self.__initialized = False
-        self.__remove_all_listeners()
-        self.unsubscribe()
-        self.__api.remove_listener(API_EVENT.SHUTDOWN.value, self.cleanup)
-        if self.__subscription:
-            await self.__subscription.unsubscribe()
-            self.__subscription = None
-        await self.__disconnect_rpc()
-
-    @overload
-    def __check_state_internal(
-        self,
-        state_name: Literal["light"],
-        event_data: LightSetEvent,
-        skip_detections_check: Optional[bool] = None,
-    ) -> tuple[bool, LightState]: ...
-    @overload
-    def __check_state_internal(
-        self,
-        state_name: Literal["motion"],
-        event_data: MotionSetEvent,
-        skip_detections_check: Optional[bool] = None,
-    ) -> tuple[bool, MotionState]: ...
-    @overload
-    def __check_state_internal(
-        self,
-        state_name: Literal["audio"],
-        event_data: AudioSetEvent,
-        skip_detections_check: Optional[bool] = None,
-    ) -> tuple[bool, AudioState]: ...
-    @overload
-    def __check_state_internal(
-        self,
-        state_name: Literal["object"],
-        event_data: ObjectSetEvent,
-        skip_detections_check: Optional[bool] = None,
-    ) -> tuple[bool, ObjectState]: ...
-    @overload
-    def __check_state_internal(
-        self,
-        state_name: Literal["doorbell"],
-        event_data: DoorbellSetEvent,
-        skip_detections_check: Optional[bool] = None,
-    ) -> tuple[bool, DoorbellState]: ...
-    @overload
-    def __check_state_internal(
-        self,
-        state_name: Literal["siren"],
-        event_data: SirenSetEvent,
-        skip_detections_check: Optional[bool] = None,
-    ) -> tuple[bool, SirenState]: ...
-    @overload
-    def __check_state_internal(
-        self,
-        state_name: Literal["battery"],
-        event_data: BatterySetEvent,
-        skip_detections_check: Optional[bool] = None,
-    ) -> tuple[bool, BatteryState]: ...
-    def __check_state_internal(
-        self,
-        state_name: Literal["light", "motion", "audio", "object", "doorbell", "siren", "battery"],
-        event_data: Union[
-            LightSetEvent,
-            MotionSetEvent,
-            AudioSetEvent,
-            ObjectSetEvent,
-            DoorbellSetEvent,
-            SirenSetEvent,
-            BatterySetEvent,
-        ],
-        skip_detections_check: Optional[bool] = None,
-    ) -> tuple[
-        bool,
-        Union[
-            LightState,
-            MotionState,
-            AudioState,
-            ObjectState,
-            DoorbellState,
-            SirenState,
-            BatteryState,
-        ],
-    ]:
-        changed = False
-        target_state: Optional[StateValue] = None
-
-        if state_name == "audio":
-            audio_event = cast(AudioSetEvent, event_data)
-            target_state = self.__get_audio_state(audio_event)
-            changed = self.__state_changed(self.get_value("audio"), target_state, "audio")
-
-        elif state_name == "light":
-            light_event = cast(LightSetEvent, event_data)
-            target_state = self.__get_light_state(light_event)
-            changed = self.__state_changed(self.get_value("light"), target_state, "light")
-
-        elif state_name == "motion":
-            motion_event = cast(MotionSetEvent, event_data)
-
-            if not motion_event["state"]:
-                motion_event["detections"] = []
-
-            if not skip_detections_check and "detections" in motion_event and motion_event["detections"]:
-                has_detections = len(motion_event["detections"]) > 0
-                motion_event["detections"] = transform_labels(motion_event["detections"])
-                motion_event["detections"] = merge_detections(motion_event["detections"])
-                motion_event["detections"] = are_detections_valid(
-                    motion_event["detections"], self.detection_zones, self.detection_settings
-                )
-                if has_detections and len(motion_event["detections"]) == 0:
-                    motion_event["state"] = False
-
-            # fix bounding box type to to tuple, do we need?
-            if "detections" in motion_event and motion_event["detections"]:
-                for det in motion_event["detections"]:
-                    det["boundingBox"] = cast(tuple[int, int, int, int], tuple(det["boundingBox"]))
-                    det["confidence"] = float(det["confidence"])
-
-            target_state = self.__get_motion_state(motion_event)
-            changed = self.__state_changed(self.get_value("motion"), target_state, "motion", True)
-
-        elif state_name == "object":
-            object_event = cast(ObjectSetEvent, event_data)
-
-            if not skip_detections_check:
-                object_event["detections"] = transform_labels(object_event["detections"])
-                object_event["detections"] = merge_detections(object_event["detections"])
-                object_event["detections"] = are_detections_valid(
-                    object_event["detections"], self.detection_zones, self.detection_settings
-                )
+        cleanup = await self._proxy.register_handler(sensor_namespace, sensor, without_decorators=True)
+        self._sensor_cleanup_functions[sensor.id] = cleanup
 
-            # fix bounding box type to to tuple
-            for det in object_event["detections"]:
-                det["boundingBox"] = cast(BoundingBox, tuple(det["boundingBox"]))
-                det["confidence"] = float(det["confidence"])
+        sensor_json = sensor.toJSON()
+        sensor_json["requiresFrames"] = requires_frames
+        if model_spec:
+            sensor_json["modelSpec"] = model_spec
 
-            target_state = self.__get_object_state(object_event)
-            changed = self.__state_changed(self.get_value("object"), target_state, "object")
+        is_assigned = await self._camera_controller_proxy.registerSensor(sensor_json, plugin_id)
+        sensor._setAssigned(is_assigned)  # pyright: ignore[reportPrivateUsage]
+        self._owned_sensors[sensor.id] = (sensor, sensor.type)
 
-        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")
+        sensor_event_ns = NamespaceManager.sensor_event_namespaces(self.id, sensor.id)
 
-        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")
+        async def handle_backend_event(event: dict[str, Any]) -> None:
+            if event.get("type") == "property:changed":
+                change_data = event.get("data", {})
+                prop = change_data.get("property")
+                value = change_data.get("value")
+                timestamp = change_data.get("timestamp")
+                if prop is not None:
+                    sensor._onBackendPropertyChanged(prop, value, timestamp)  # pyright: ignore[reportPrivateUsage]
 
-        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")
+        unsubscribe_backend = await self._proxy.subscribe(
+            sensor_event_ns.sensor_subject, handle_backend_event
+        )
+
+        existing_cleanup = self._sensor_cleanup_functions.get(sensor.id)
+        if existing_cleanup:
+
+            async def combined_cleanup() -> None:
+                await unsubscribe_backend()
+                await existing_cleanup()
 
+            self._sensor_cleanup_functions[sensor.id] = combined_cleanup
         else:
-            raise Exception(f"Unknown state: {state_name}")
-
-        return changed, target_state
-
-    def __can_update_state_internal(self, state_name: StateNames) -> bool:
-        if state_name == "audio":
-            audio_sensor_capability = next(
-                (
-                    cap
-                    for cap in self.__capabilities.value
-                    if CameraDeviceCapability.AudioSensor in cap["capabilities"]
-                ),
-                None,
-            )
-            return bool(
-                audio_sensor_capability and audio_sensor_capability["pluginId"] == self.__plugin["id"]
-            )
+            self._sensor_cleanup_functions[sensor.id] = unsubscribe_backend
 
-        elif state_name == "motion":
-            motion_sensor_capability = next(
-                (
-                    cap
-                    for cap in self.__capabilities.value
-                    if CameraDeviceCapability.MotionSensor in cap["capabilities"]
-                ),
-                None,
-            )
-            motion_detector_capability = next(
-                (
-                    cap
-                    for cap in self.__capabilities.value
-                    if CameraDeviceCapability.MotionDetector in cap["capabilities"]
-                ),
-                None,
-            )
-            return bool(
-                (motion_sensor_capability and motion_sensor_capability["pluginId"] == self.__plugin["id"])
-                or (
-                    motion_detector_capability
-                    and motion_detector_capability["pluginId"] == self.__plugin["id"]
-                )
-            )
+    async def removeSensor(self, sensorId: str) -> None:
+        await self._camera_controller_proxy.unregisterSensor(sensorId)
 
-        elif state_name == "object":
-            object_sensor_capability = next(
-                (
-                    cap
-                    for cap in self.__capabilities.value
-                    if CameraDeviceCapability.ObjectSensor in cap["capabilities"]
-                ),
-                None,
-            )
-            object_detector_capability = next(
-                (
-                    cap
-                    for cap in self.__capabilities.value
-                    if CameraDeviceCapability.ObjectDetector in cap["capabilities"]
-                ),
-                None,
-            )
-            return bool(
-                (object_sensor_capability and object_sensor_capability["pluginId"] == self.__plugin["id"])
-                or (
-                    object_detector_capability
-                    and object_detector_capability["pluginId"] == self.__plugin["id"]
-                )
-            )
+        cleanup = self._sensor_cleanup_functions.pop(sensorId, None)
+        if cleanup:
+            await cleanup()
 
-        elif state_name == "light":
-            light_capability = next(
-                (
-                    cap
-                    for cap in self.__capabilities.value
-                    if CameraDeviceCapability.Light in cap["capabilities"]
-                ),
-                None,
-            )
-            return bool(light_capability and light_capability["pluginId"] == self.__plugin["id"])
-
-        elif state_name == "doorbell":
-            doorbell_capability = next(
-                (
-                    cap
-                    for cap in self.__capabilities.value
-                    if CameraDeviceCapability.Doorbell in cap["capabilities"]
-                ),
-                None,
-            )
-            return bool(doorbell_capability and doorbell_capability["pluginId"] == self.__plugin["id"])
-
-        elif state_name == "siren":
-            siren_capability = next(
-                (
-                    cap
-                    for cap in self.__capabilities.value
-                    if CameraDeviceCapability.Siren in cap["capabilities"]
-                ),
-                None,
-            )
-            return bool(siren_capability and siren_capability["pluginId"] == self.__plugin["id"])
-
-        elif state_name == "battery":
-            battery_capability = next(
-                (
-                    cap
-                    for cap in self.__capabilities.value
-                    if CameraDeviceCapability.Battery in cap["capabilities"]
-                ),
-                None,
-            )
-            return bool(battery_capability and battery_capability["pluginId"] == self.__plugin["id"])
+        owned = self._owned_sensors.pop(sensorId, None)
+        if owned:
+            owned[0]._cleanup()  # pyright: ignore[reportPrivateUsage]
 
-    @overload
-    def __update_state_internal(
-        self,
-        state_name: Literal["light"],
-        event_data: LightSetEvent,
-        skip_check: Optional[bool] = None,
-        skip_detections_check: Optional[bool] = None,
-    ) -> None: ...
-    @overload
-    def __update_state_internal(
-        self,
-        state_name: Literal["motion"],
-        event_data: MotionSetEvent,
-        skip_check: Optional[bool] = None,
-        skip_detections_check: Optional[bool] = None,
-    ) -> None: ...
-    @overload
-    def __update_state_internal(
-        self,
-        state_name: Literal["audio"],
-        event_data: AudioSetEvent,
-        skip_check: Optional[bool] = None,
-        skip_detections_check: Optional[bool] = None,
-    ) -> None: ...
-    @overload
-    def __update_state_internal(
-        self,
-        state_name: Literal["object"],
-        event_data: ObjectSetEvent,
-        skip_check: Optional[bool] = None,
-        skip_detections_check: Optional[bool] = None,
-    ) -> None: ...
-    @overload
-    def __update_state_internal(
-        self,
-        state_name: Literal["doorbell"],
-        event_data: DoorbellSetEvent,
-        skip_check: Optional[bool] = None,
-        skip_detections_check: Optional[bool] = None,
-    ) -> None: ...
-    @overload
-    def __update_state_internal(
-        self,
-        state_name: Literal["siren"],
-        event_data: SirenSetEvent,
-        skip_check: Optional[bool] = None,
-        skip_detections_check: Optional[bool] = None,
-    ) -> None: ...
-    @overload
-    def __update_state_internal(
-        self,
-        state_name: Literal["battery"],
-        event_data: BatterySetEvent,
-        skip_check: Optional[bool] = None,
-        skip_detections_check: Optional[bool] = None,
-    ) -> None: ...
-    def __update_state_internal(
-        self,
-        state_name: Literal["light", "motion", "audio", "object", "doorbell", "siren", "battery"],
-        event_data: Union[
-            LightSetEvent,
-            MotionSetEvent,
-            AudioSetEvent,
-            ObjectSetEvent,
-            DoorbellSetEvent,
-            SirenSetEvent,
-            BatterySetEvent,
-        ],
-        skip_check: Optional[bool] = None,
-        skip_detections_check: Optional[bool] = None,
-    ) -> None:
-        if skip_check:
-            changed = True
-            event = event_data
-        else:
-            changed, event = cast(
-                tuple[
-                    bool,
-                    Union[
-                        LightSetEvent,
-                        MotionSetEvent,
-                        AudioSetEvent,
-                        ObjectSetEvent,
-                        DoorbellSetEvent,
-                        SirenSetEvent,
-                        BatterySetEvent,
-                    ],
-                ],
-                self.__check_state_internal(
-                    cast(Any, state_name), cast(Any, event_data), skip_detections_check
-                ),
-            )
+        proxy = self._sensors.get(sensorId)
+        if proxy:
+            await proxy._unsubscribe_from_events()  # pyright: ignore[reportPrivateUsage]
+            self._sensors.pop(sensorId, None)
 
-        if not changed:
-            return
+    @property
+    def onSensorAdded(self) -> Observable[SensorEventData]:
+        return self._sensor_added_subject.as_observable()
 
-        if state_name == "light":
-            self.__light_state.on_next(self.__get_light_state(cast(LightSetEvent, event)))
-        elif state_name == "motion":
-            self.__motion_state.on_next(self.__get_motion_state(cast(MotionSetEvent, event)))
-        elif state_name == "audio":
-            self.__audio_state.on_next(self.__get_audio_state(cast(AudioSetEvent, event)))
-        elif state_name == "object":
-            self.__object_state.on_next(self.__get_object_state(cast(ObjectSetEvent, event)))
-        elif state_name == "doorbell":
-            self.__doorbell_state.on_next(self.__get_doorbell_state(cast(DoorbellSetEvent, event)))
-        elif state_name == "siren":
-            self.__siren_state.on_next(self.__get_siren_state(cast(SirenSetEvent, event)))
-        elif state_name == "battery" and self.has_battery:
-            self.__battery_state.on_next(self.__get_battery_state(cast(BatterySetEvent, event)))
-
-    def __create_state_observable(self, state_subject: BehaviorSubject[Any]) -> HybridObservable[Any]:
-        return HybridObservable(state_subject.pipe(ops.distinct_until_changed(), ops.share()))
-
-    def __update_camera(self, camera: Camera) -> None:
-        if camera["snapshotTTL"] != self.snapshot_ttl:
-            self.__snapshot_cache = TTLCache[str, bytes](maxsize=100, ttl=self.snapshot_ttl)
-
-        self.__camera_subject.on_next(camera)
-
-    def __update_camera_state(self, state: bool) -> None:
-        self.__camera_state.on_next(state)
-
-    def __update_frameworker_state(self, state: bool) -> None:
-        self.__frame_worker_state.on_next(state)
-
-    def __update_capabilities(self, capabilities: list[PluginCapabilities]) -> None:
-        converted_capabilities: list[PluginCapabilities] = []
-
-        for plugin_cap in capabilities:
-            converted_plugin_cap = plugin_cap.copy()
-            converted_plugin_cap["capabilities"] = [
-                CameraDeviceCapability(cap_str) for cap_str in plugin_cap["capabilities"]
-            ]
-            converted_capabilities.append(converted_plugin_cap)
-
-        self.__capabilities.on_next(converted_capabilities)
-
-    async def __refresh_states(self) -> None:
-        camera_controller_proxy = await self.__camera_controller_proxy()
-        response = await camera_controller_proxy.refreshStates()
-
-        self.__update_camera(response["camera"])
-        self.__update_camera_state(response["cameraState"])
-        self.__update_frameworker_state(response["frameWorkerState"])
-        self.__update_capabilities(response["capabilities"])
-
-        states = cast(dict[Any, Any], response["states"])
-        for key, value in states.items():
-            self.__update_state_internal(key, value, True)
-
-    def __remove_all_listeners(self) -> None:
-        self.__light_state.on_completed()
-        self.__motion_state.on_completed()
-        self.__audio_state.on_completed()
-        self.__object_state.on_completed()
-        self.__doorbell_state.on_completed()
-        self.__siren_state.on_completed()
-        self.__battery_state.on_completed()
-        self.__camera_subject.on_completed()
-        self.__camera_state.on_completed()
-        self.__frame_worker_state.on_completed()
-        self.__capabilities.on_completed()
-        self.__snapshot_cache.clear()
-
-    def __state_changed(
+    @property
+    def onSensorRemoved(self) -> Observable[SensorEventData]:
+        return self._sensor_removed_subject.as_observable()
+
+    def onSensorProperty(
         self,
-        old_state: Optional[SetValue],
-        new_state: Optional[SetValue],
-        type_: Optional[StateNames],
-        test: Optional[bool] = False,
-    ) -> bool:
-        if not old_state or not new_state or not type_:
-            return False
-
-        if (
-            (type_ == "audio" and not self.has_audio_detector)
-            or (type_ == "motion" and not self.has_motion_detector)
-            or (type_ == "object" and not self.has_object_detector)
-            or (type_ == "siren" and not self.has_siren)
-            or (type_ == "battery" and not self.has_battery)
-            or (type_ == "doorbell" and not self.has_doorbell)
-            or (type_ == "light" and not self.has_light)
-        ):
-            return False
-
-        clean_old_state = self.__clean_state(old_state)
-        clean_new_state = self.__clean_state(new_state)
-
-        return DeepDiff(clean_old_state, clean_new_state, ignore_order=True) != {}
-
-    def __get_audio_state(
-        self, event: Union[AudioSetEvent, AudioState], ignore_last_event: bool = False
-    ) -> AudioState:
-        last_event: Optional[AudioState] = None
-
-        if ignore_last_event is False:
-            last_event = self.get_value("audio")
-            if last_event and "lastEvent" in last_event:
-                del last_event["lastEvent"]
-
-        if "timestamp" in event:
-            new_state: Any = event
-        else:
-            state = cast(AudioState, event).copy()
-            state["timestamp"] = int(datetime.now().timestamp() * 1000)
+        sensor_type: SensorType,
+        property: str,
+        callback: Any,
+    ) -> Disposable:
+        property_sub: Disposable | None = None
+
+        def subscribe_to(sensor: SensorLike) -> None:
+            nonlocal property_sub
+            if property_sub is not None:
+                property_sub.dispose()
+            property_sub = sensor.onPropertyChanged.subscribe(
+                lambda e: callback(e["value"], e["timestamp"], sensor) if e["property"] == property else None
+            )
 
-            new_state = {
-                **state,
-                "db": event.get("db", None) or last_event.get("db", None) if last_event else 0,
-                "lastEvent": last_event,
-            }
+        existing = self.getSensorsByType(sensor_type)
+        if existing:
+            subscribe_to(existing[0])
 
-        return new_state
+        added_sub = self.onSensorAdded.subscribe(
+            lambda e: (
+                subscribe_to(self.getSensorsByType(sensor_type)[0])
+                if e["sensorType"] == sensor_type and self.getSensorsByType(sensor_type)
+                else None
+            )
+        )
 
-    def __get_motion_state(
-        self, event: Union[MotionSetEvent, MotionState], ignore_last_event: bool = False
-    ) -> MotionState:
-        last_event: Optional[MotionState] = None
+        def on_removed(e: SensorEventData) -> None:
+            nonlocal property_sub
+            if e["sensorType"] == sensor_type and property_sub is not None:
+                property_sub.dispose()
+                property_sub = None
 
-        if ignore_last_event is False:
-            last_event = self.get_value("motion")
-            if last_event and "lastEvent" in last_event:
-                del last_event["lastEvent"]
+        removed_sub = self.onSensorRemoved.subscribe(on_removed)
 
-        if "timestamp" in event:
-            new_state: Any = event
-        else:
-            state = cast(MotionState, event).copy()
-            state["timestamp"] = int(datetime.now().timestamp() * 1000)
+        def teardown() -> None:
+            nonlocal property_sub
+            if property_sub is not None:
+                property_sub.dispose()
+            added_sub.dispose()
+            removed_sub.dispose()
 
-            new_state = {
-                **state,
-                "lastEvent": last_event,
-            }
+        return Disposable(teardown)
 
-        return new_state
+    @property
+    def onDetectionEvent(self) -> Observable[DetectionEventPayload]:
+        return self._detection_event_subject.as_observable()
+
+    async def implement(self, impl: CameraImplementation) -> None:
+        plugin_id = self._plugin["id"]
+        namespace = NamespaceManager.plugin_camera_namespaces(plugin_id, self.id)
+        self._impl_cleanup_function = await self._proxy.register_handler(
+            namespace.camera_impl_rpc, impl, without_decorators=True
+        )
 
-    def __get_object_state(
-        self, event: Union[ObjectSetEvent, ObjectState], ignore_last_event: bool = False
-    ) -> ObjectState:
-        last_event: Optional[ObjectState] = None
+    async def streamUrl(self, source_id: str) -> str | None:
+        return await self._camera_controller_proxy.streamUrl(source_id)
 
-        if ignore_last_event is False:
-            last_event = self.get_value("object")
-            if last_event and "lastEvent" in last_event:
-                del last_event["lastEvent"]
+    async def _snapshot(self, source_id: str, force_new: bool | None = None) -> bytes | None:
+        return await self._camera_controller_proxy.snapshot(source_id, force_new)
 
-        if "timestamp" in event:
-            new_state: Any = event
-        else:
-            state = cast(ObjectState, event).copy()
-            state["timestamp"] = int(datetime.now().timestamp() * 1000)
+    async def _probe_stream(
+        self, source_id: str, probe_config: ProbeConfig | None = None, refresh: bool | None = False
+    ) -> ProbeStream | None:
+        return await self._camera_controller_proxy.probeStream(source_id, probe_config, refresh)
 
-            new_state = {
-                **state,
-                "lastEvent": last_event,
-            }
+    async def _get_stream_status(self, source_id: str) -> str:
+        try:
+            return await self._camera_controller_proxy.getStreamStatus(source_id)
+        except Exception:
+            return "idle"
 
-        return new_state
+    async def cleanup(self) -> None:
+        self._initialized.next(False)
 
-    def __get_doorbell_state(
-        self, event: Union[DoorbellSetEvent, DoorbellState], ignore_last_event: bool = False
-    ) -> DoorbellState:
-        last_event: Optional[DoorbellState] = None
+        self.unsubscribe()
 
-        if ignore_last_event is False:
-            last_event = self.get_value("doorbell")
-            if last_event and "lastEvent" in last_event:
-                del last_event["lastEvent"]
+        self._api.removeListener(API_EVENT.SHUTDOWN.value, self.cleanup)
 
-        if "timestamp" in event:
-            new_state: Any = event
-        else:
-            state = cast(DoorbellState, event).copy()
-            state["timestamp"] = int(datetime.now().timestamp() * 1000)
+        self._tasks.remove_all()
 
-            new_state = {
-                **state,
-                "lastEvent": last_event,
-            }
+        if self._close_subscription:
+            await self._close_subscription()
+            self._close_subscription = None
 
-        return new_state
+        if self._close_sensor_subscription:
+            await self._close_sensor_subscription()
+            self._close_sensor_subscription = None
 
-    def __get_light_state(
-        self, event: Union[LightSetEvent, LightState], ignore_last_event: bool = False
-    ) -> LightState:
-        last_event: Optional[LightState] = None
+        if self._close_detection_subscription:
+            await self._close_detection_subscription()
+            self._close_detection_subscription = None
 
-        if ignore_last_event is False:
-            last_event = self.get_value("light")
-            if last_event and "lastEvent" in last_event:
-                del last_event["lastEvent"]
+        if self._impl_cleanup_function:
+            with contextlib.suppress(Exception):
+                await self._impl_cleanup_function()
+            self._impl_cleanup_function = None
 
-        if "timestamp" in event:
-            new_state: Any = event
-        else:
-            state = cast(LightState, event).copy()
-            state["timestamp"] = int(datetime.now().timestamp() * 1000)
+        for cleanup in list(self._sensor_cleanup_functions.values()):
+            with contextlib.suppress(Exception):
+                await cleanup()
+        self._sensor_cleanup_functions.clear()
 
-            new_state = {
-                **state,
-                "lastEvent": last_event,
-            }
+        for sensor_proxy in list(self._sensors.values()):
+            await sensor_proxy._unsubscribe_from_events()  # pyright: ignore[reportPrivateUsage]
 
-        return new_state
+        for owned_sensor, _ in list(self._owned_sensors.values()):
+            owned_sensor._cleanup()  # pyright: ignore[reportPrivateUsage]
 
-    def __get_siren_state(
-        self, event: Union[SirenSetEvent, SirenState], ignore_last_event: bool = False
-    ) -> SirenState:
-        last_event: Optional[SirenState] = None
+        self._sensors.clear()
+        self._owned_sensors.clear()
 
-        if ignore_last_event is False:
-            last_event = self.get_value("siren")
-            if last_event and "lastEvent" in last_event:
-                del last_event["lastEvent"]
+        self._camera_subject.complete()
+        self._camera_state.complete()
+        self._frame_worker_state.complete()
+        self._initialized.complete()
+        self._sensor_added_subject.complete()
+        self._sensor_removed_subject.complete()
+        self._detection_event_subject.complete()
 
-        if "timestamp" in event:
-            new_state: Any = event
-        else:
-            state = cast(SirenState, event).copy()
-            state["timestamp"] = int(datetime.now().timestamp() * 1000)
+    async def _refresh_states(self) -> None:
+        response = await self._camera_controller_proxy.refreshStates()
 
-            new_state = {
-                **state,
-                "level": event.get("level", None) or last_event.get("level", None) if last_event else 0,
-                "lastEvent": last_event,
-            }
+        self._camera_subject.next(response["camera"])
+        self._camera_state.next(response["cameraState"])
+        self._frame_worker_state.next(response["frameWorkerState"])
 
-        return new_state
+    async def _initialize_sensors(self) -> None:
+        try:
+            sensors = await self._sensor_controller_proxy.getSensors(self._plugin["id"])
+            newly_added: list[SensorProxy] = []
+
+            for sensor_data in sensors:
+                if sensor_data["id"] in self._sensors:
+                    continue
+
+                if sensor_data["id"] in self._owned_sensors:
+                    continue
+
+                plugin_id = sensor_data.get("pluginId", self._plugin["id"])
+                owner_ns = NamespaceManager.sensor_provider_namespaces(
+                    plugin_id, self.id, sensor_data["id"]
+                ).sensor_rpc
+                proxy = SensorProxy(sensor_data, self._proxy, owner_ns, self.id)
+                self._sensors[sensor_data["id"]] = proxy
+                newly_added.append(proxy)
+
+            current_ids = {s["id"] for s in sensors}
+            for sensor_id in list(self._sensors.keys()):
+                if sensor_id not in current_ids:
+                    sensor = self._sensors.get(sensor_id)
+                    if sensor:
+                        await sensor._unsubscribe_from_events()  # pyright: ignore[reportPrivateUsage]
+                    self._sensors.pop(sensor_id, None)
+
+            if newly_added:
+                await self._get_sensor_states(newly_added)
+                # Subscribe each sensor to its own per-sensor namespace
+                for sensor in newly_added:
+                    await sensor._subscribe_to_events()  # pyright: ignore[reportPrivateUsage]
+
+        except Exception:
+            # SensorController not available yet
+            pass
+
+    async def _get_sensor_states(self, sensors: list[SensorProxy]) -> None:
+        try:
+            states = await self._sensor_controller_proxy.getSensorStates()
+            for sensor in sensors:
+                state = states.get(sensor.id)
+                if state:
+                    sensor._apply_refreshed_state(state)  # pyright: ignore[reportPrivateUsage]
+        except Exception:
+            pass
+
+    async def _on_event_message(self, event: CameraEventMessage) -> None:
+        if not self._initialized.value:
+            return
 
-    def __get_battery_state(
-        self, event: Union[BatterySetEvent, BatteryState], ignore_last_event: bool = False
-    ) -> BatteryState:
-        last_event: Optional[BatteryState] = None
+        event_type = event.get("type")
+        data = event.get("data")
 
-        if ignore_last_event is False:
-            last_event = self.get_value("battery")
-            if last_event and "lastEvent" in last_event:
-                del last_event["lastEvent"]
+        if event_type == "removed":
+            await self.cleanup()
+        elif event_type == "updated" and data is not None:
+            self._camera_subject.next(cast(Camera, data))
+        elif event_type == "cameraState" and data is not None:
+            self._camera_state.next(cast(bool, data))
+        elif event_type == "frameWorkerState" and data is not None:
+            self._frame_worker_state.next(cast(bool, data))
 
-        if "timestamp" in event:
-            new_state: Any = event
-        else:
-            state = cast(BatteryState, event).copy()
-            state["timestamp"] = int(datetime.now().timestamp() * 1000)
+    async def _on_global_sensor_event(self, event: SensorEventMessage) -> None:
+        if not self._initialized.value:
+            return
 
-            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,
-            }
+        event_type = event.get("type")
+
+        if event_type == "sensor:added":
+            added_data = cast(SensorAddedEvent, event.get("data"))
+            sensor_data = added_data["sensor"]
+            # Only add if not already in cache and not our own sensor
+            if sensor_data["id"] not in self._sensors and sensor_data["id"] not in self._owned_sensors:
+                # Check if plugin can access this sensor based on contract.consumes
+                if not self._can_access_sensor(sensor_data):
+                    return  # Skip - sensor type not in contract.consumes
+                plugin_id = sensor_data.get("pluginId", self._plugin["id"])
+                owner_ns = NamespaceManager.sensor_provider_namespaces(
+                    plugin_id, self.id, sensor_data["id"]
+                ).sensor_rpc
+                proxy = SensorProxy(sensor_data, self._proxy, owner_ns, self.id)
+                await proxy._subscribe_to_events()  # pyright: ignore[reportPrivateUsage]
+                self._sensors[sensor_data["id"]] = proxy
+
+            self._sensor_added_subject.next(
+                {"sensorId": sensor_data["id"], "sensorType": sensor_data["type"]}
+            )
 
-        return new_state
+        elif event_type == "sensor:removed":
+            removed_data = cast(SensorRemovedEvent, event.get("data"))
+            sensor = self._sensors.get(removed_data["sensorId"])
+            if sensor:
+                await sensor._unsubscribe_from_events()  # pyright: ignore[reportPrivateUsage]
+            self._sensors.pop(removed_data["sensorId"], None)
 
-    def __clean_state(self, state: Union[StateValue, SetValue]) -> SetValue:
-        state_copy: Any = deepcopy(state)
+            self._sensor_removed_subject.next(
+                {"sensorId": removed_data["sensorId"], "sensorType": removed_data["sensorType"]}
+            )
 
-        if "timestamp" in state_copy:
-            del state_copy["timestamp"]
+        elif event_type == "sensor:assignment:changed":
+            assign_data = cast(SensorAssignmentChangedEvent, event.get("data"))
+            sensor_type = assign_data["sensorType"]
+            is_assigned = assign_data["assigned"]
 
-        if "lastEvent" in state_copy:
-            del state_copy["lastEvent"]
+            if assign_data["pluginId"] == self._plugin["id"]:
+                for _, (owned_sensor, s_type) in self._owned_sensors.items():
+                    if s_type == sensor_type:
+                        owned_sensor._setAssigned(is_assigned)  # pyright: ignore[reportPrivateUsage]
 
-        return state_copy
+    def _on_sensor_state_write(
+        self, sensor_id: str, sensor_type: SensorType, properties: dict[str, Any]
+    ) -> None:
+        if sensor_type in DETECTION_SENSOR_TYPES:
+            if not (self._frame_worker_state.value or False):
+                return
 
-    def __on_name_change(self, val: Any) -> None:
-        cast(Logger, self.logger).suffix = self.name
+            async def notify_coordinator() -> None:
+                try:
+                    await self._detection_coordinator_proxy.reportSensorWrite(
+                        sensor_id, sensor_type, properties
+                    )
+                except Exception as e:
+                    self._logger.warn(f"Failed to forward sensor write to coordinator for {sensor_id}: {e}")
 
-    async def __on_event_message(self, event: Message[Any]) -> None:
-        if not self.__initialized:
+            self._tasks.add(notify_coordinator())
             return
 
-        message = event["data"]
-
-        if "type" in message:
-            type = message["type"]
-            if type == "removed":
-                await self.cleanup()
-            elif type == "updated":
-                self.__update_camera(message["data"])
-            elif type == "cameraState":
-                self.__update_camera_state(message["data"])
-            elif type == "frameWorkerState":
-                self.__update_frameworker_state(message["data"])
-            elif type == "capabilities":
-                self.__update_capabilities(message["data"])
-        else:
-            state_name = message["stateName"]
-            new_data = message["data"]["newEvent"]
+        async def notify_controller() -> None:
+            with contextlib.suppress(Exception):
+                await self._sensor_controller_proxy.updatePropertyValues(sensor_id, properties)
 
-            self.__update_state_internal(state_name, new_data, True)
+        self._tasks.add(notify_controller())
 
-    async def __frame_worker_proxy(self) -> FrameWorkerInterface:
-        return await self.__proxy.create_rpc_proxy(
-            FrameWorkerInterface, self.__namespaces["frameWorkerChildRpc"]
-        )
+    def _on_sensor_capabilities_changed(self, sensor_id: str, capabilities: list[str]) -> None:
+        async def notify() -> None:
+            with contextlib.suppress(Exception):
+                await self._sensor_controller_proxy.updateCapabilities(sensor_id, capabilities)
 
-    async def __camera_controller_proxy(self) -> CameraDeviceInterface:
-        return await self.__proxy.create_rpc_proxy(
-            CameraDeviceInterface, self.__namespaces["cameraControllerRpc"]
-        )
+        self._tasks.add(notify())
 
-    async def __disconnect_rpc(self) -> None:
-        await self.__proxy.unregister_rpc_handler(self.__namespaces["cameraInterfacesRpc"])
-        await self.__proxy.disconnect_rpc_connection(self.__namespaces["cameraControllerRpc"])
-        await self.__proxy.disconnect_rpc_connection(self.__namespaces["frameWorkerChildRpc"])
-        await self.__camera_interfaces.disconnect()
+    def _create_state_observable(self, state_subject: BehaviorSubject[Any]) -> Observable[Any]:
+        return state_subject.pipe(distinct_until_changed(), share())