@camera.ui/server 2.0.22 → 2.0.24

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

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 from typing import Any
 
 from _camera_ui_tools.camera_ui_common import (
     LoggerService,
+    TaskSet,
 )
 from _camera_ui_tools.camera_ui_rpc import CloseHandler, RPCClient
 from _camera_ui_tools.camera_ui_sdk import (
@@ -27,6 +29,7 @@ from plugins.runtime.python.storage_controller import StorageController
 from plugins.runtime.python.typings import PluginInfo
 
 from .camera_device import CameraDeviceProxy
+from .sensor_manager import SensorManagerProxy
 
 
 class DeviceManagerProxy(DeviceManager):
@@ -34,6 +37,7 @@ class DeviceManagerProxy(DeviceManager):
         self,
         proxy: RPCClient,
         storage_controller: StorageController,
+        sensor_manager: SensorManagerProxy,
         logger: LoggerService,
         plugin: PluginInfo,
     ):
@@ -42,11 +46,14 @@ class DeviceManagerProxy(DeviceManager):
 
         self.__proxy = proxy
         self.__storage_controller = storage_controller
+        self.__sensor_manager = sensor_manager
         self.__logger = logger
         self.__plugin = plugin
         self.__close_request: CloseHandler | None = None
+        self.__event_lock = asyncio.Lock()
 
         self.__devices: dict[str, CameraDeviceProxy] = {}
+        self.__tasks = TaskSet(name=f"DeviceManager:{plugin['id']}")
         self.__namespaces: tuple[DeviceManagerNamespaces, PluginNamespaces, DiscoveryManagerNamespaces] = (
             NamespaceManager.device_manager_namespaces(),
             NamespaceManager.plugin_namespaces(self.__plugin["id"]),
@@ -72,7 +79,8 @@ class DeviceManagerProxy(DeviceManager):
 
         self.__initialized = True
         self.__close_request = await self.__proxy.on_request(
-            self.__namespaces[1].plugin_device_manager_subject, self.__on_event_message
+            self.__namespaces[1].plugin_device_manager_subject,
+            self.__on_event_serialized,
         )
 
     async def getCamera(self, cameraIdOrName: str) -> CameraDeviceProxy | None:
@@ -92,9 +100,15 @@ class DeviceManagerProxy(DeviceManager):
     async def configureCameras(self, camera_devices: list[CameraDeviceProxy]) -> None:
         await asyncio.gather(*[self.__get_camera_device(camera_device) for camera_device in camera_devices])
 
+    def on_rpc_reconnected(self) -> None:
+        if not self.__initialized:
+            return
+        self.__tasks.add(self.__refresh_all_devices())
+
     async def close(self) -> None:
         """Internal method to close the device manager proxy and cleanup resources."""
         self.__initialized = False
+        self.__tasks.remove_all()
         if self.__close_request:
             await self.__close_request()
 
@@ -102,6 +116,15 @@ class DeviceManagerProxy(DeviceManager):
             await device.cleanup()
         self.__devices.clear()
 
+    async def __refresh_all_devices(self) -> None:
+        for device in list(self.__devices.values()):
+            with contextlib.suppress(Exception):
+                await device._refresh_states()  # pyright: ignore[reportPrivateUsage]
+
+    async def __on_event_serialized(self, event: Any) -> None:
+        async with self.__event_lock:
+            await self.__on_event_message(event)
+
     async def __on_event_message(self, event: Any) -> None:
         if not self.__plugin_instance:
             self.__logger.warn("Plugin instance not set, cannot handle lifecycle event")
@@ -132,7 +155,7 @@ class DeviceManagerProxy(DeviceManager):
             if camera_device:
                 await camera_device.cleanup()
 
-            await self.__remove_camera_storage(camera_id)
+            await self.__storage_controller.releaseCameraStorage(camera_id)
 
             if camera_id in self.__devices:
                 del self.__devices[camera_id]
@@ -170,6 +193,7 @@ class DeviceManagerProxy(DeviceManager):
                 camera_device = CameraDeviceProxy(
                     self.__proxy,
                     self.__storage_controller,
+                    self.__sensor_manager,
                     camera,
                     self.__plugin,
                     camera_logger,
@@ -185,6 +209,3 @@ class DeviceManagerProxy(DeviceManager):
 
     async def __create_camera_storage(self, camera_id: str) -> None:
         await self.__storage_controller.createStorage("camera", camera_id)
-
-    async def __remove_camera_storage(self, camera_id: str) -> None:
-        await self.__storage_controller.removeStorage("camera", camera_id)

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

@@ -9,26 +9,36 @@ from _camera_ui_tools.camera_ui_sdk import (
     SensorType,
     Subject,
 )
+from _camera_ui_tools.camera_ui_sdk.internal import SensorJSON
 from plugins.runtime.python.namespaces import NamespaceManager
-from plugins.runtime.python.typings import SensorRefreshedState, StoredSensorData
+from plugins.runtime.python.typings import (
+    SensorRefreshedState,
+    SensorRegistration,
+    StoredSensorData,
+)
 
 
+# Cross-process consumer proxy: caches sensor state from broadcasts, forwards Control writes via RPC.
 class SensorProxy(SensorLike):
-    def __init__(
-        self, data: StoredSensorData, proxy: RPCClient, owner_namespace: str, camera_id: str
-    ) -> None:
+    def __init__(self, data: StoredSensorData, proxy: RPCClient, owner_namespace: str) -> None:
         self._id = data["id"]
         self._type = data["type"]
         self._name = data["name"]
         self._display_name = data.get("displayName", data["name"])
+        self._native_id = data.get("nativeId")
         self._owner_id = data["pluginId"]
-        self._camera_id = camera_id
+        self._assigned_camera_ids: list[str] = list(data.get("assignedCameraIds", []))
+        self._assignment_locked = data.get("boundCameraId") is not None
+        self._exposed = data.get("exposed", False)
+        self._connected = data.get("connected", False)
         self._proxy = proxy
         self._properties: dict[str, Any] = dict(data.get("properties", {}))
         self._capabilities: list[str] = list(data.get("capabilities", []))
         self._rpc_proxy = proxy.create_proxy(owner_namespace)
         self._property_changed_subject: Subject[SensorPropertyChangeData] = Subject()
         self._capabilities_changed_subject: Subject[list[str]] = Subject()
+        self._connected_changed_subject: Subject[bool] = Subject()
+        self._assignment_changed_subject: Subject[list[str]] = Subject()
         self._event_subscription: CloseHandler | None = None
 
     @property
@@ -51,10 +61,30 @@ class SensorProxy(SensorLike):
     def displayName(self, value: str) -> None:
         self._display_name = value
 
+    @property
+    def nativeId(self) -> str | None:
+        return self._native_id
+
     @property
     def pluginId(self) -> str:
         return self._owner_id
 
+    @property
+    def assignedCameraIds(self) -> list[str]:
+        return self._assigned_camera_ids.copy()
+
+    @property
+    def assignmentLocked(self) -> bool:
+        return self._assignment_locked
+
+    @property
+    def connected(self) -> bool:
+        return self._connected
+
+    @property
+    def exposed(self) -> bool:
+        return self._exposed
+
     @property
     def capabilities(self) -> list[str]:
         return self._capabilities.copy()
@@ -79,10 +109,24 @@ class SensorProxy(SensorLike):
     def onCapabilitiesChanged(self) -> Observable[list[str]]:
         return self._capabilities_changed_subject.as_observable()
 
+    @property
+    def onConnectedChanged(self) -> Observable[bool]:
+        return self._connected_changed_subject.as_observable()
+
+    @property
+    def onAssignmentChanged(self) -> Observable[list[str]]:
+        return self._assignment_changed_subject.as_observable()
+
     def _update_cached_value(self, property: str, value: Any, timestamp: int | None = None) -> None:
+        if self._properties.get(property) == value:
+            return
         self._properties[property] = value
         self._property_changed_subject.next(
-            {"property": property, "value": value, "timestamp": timestamp or int(time.time() * 1000)}
+            {
+                "property": property,
+                "value": value,
+                "timestamp": timestamp or int(time.time() * 1000),
+            }
         )
 
     def _set_display_name(self, display_name: str) -> None:
@@ -92,18 +136,36 @@ class SensorProxy(SensorLike):
         self._capabilities = capabilities
         self._capabilities_changed_subject.next(capabilities)
 
+    def _set_connected(self, connected: bool) -> None:
+        if self._connected == connected:
+            return
+        self._connected = connected
+        self._connected_changed_subject.next(connected)
+
+    def _set_assigned_cameras(self, camera_ids: list[str]) -> None:
+        self._assigned_camera_ids = list(camera_ids)
+        self._assignment_changed_subject.next(self._assigned_camera_ids.copy())
+
+    def _set_exposed(self, exposed: bool) -> None:
+        self._exposed = exposed
+
     def _apply_refreshed_state(self, state: SensorRefreshedState) -> None:
-        self._capabilities = list(state["capabilities"])
-        if "displayName" in state:
-            self._display_name = state["displayName"]
-        for key, value in state.get("properties", {}).items():
-            self._update_cached_value(key, value)
+        display_name = state.get("displayName")
+        if display_name:
+            self._set_display_name(display_name)
+
+        capabilities = list(state.get("capabilities", []))
+        if sorted(capabilities) != sorted(self._capabilities):
+            self._update_capabilities(capabilities)
+
+        for property, value in state.get("properties", {}).items():
+            self._update_cached_value(property, value)
 
     async def _subscribe_to_events(self) -> None:
         if self._event_subscription is not None:
             return  # Already subscribed
 
-        namespace = NamespaceManager.sensor_event_namespaces(self._camera_id, self._id)
+        namespace = NamespaceManager.sensor_event_namespaces(self._id)
         self._event_subscription = await self._proxy.subscribe(
             namespace.sensor_subject, self._handle_sensor_event
         )
@@ -133,9 +195,14 @@ class SensorProxy(SensorLike):
             "name": self._name,
             "displayName": self._display_name,
             "pluginId": self._owner_id,
+            "assignedCameraIds": self.assignedCameraIds,
+            "exposed": self._exposed,
+            "connected": self._connected,
             "properties": self.getValues(),
             "capabilities": self._capabilities,
         }
+        if self._native_id:
+            data["nativeId"] = self._native_id
 
         return data
 
@@ -144,20 +211,22 @@ class SensorProxy(SensorLike):
         return self._id != ""
 
 
-class SensorControllerInterface(Protocol):
-    async def registerSensor(self, sensor: dict[str, Any], plugin_id: str) -> bool: ...
+class SensorRegistryInterface(Protocol):
+    async def registerSensor(
+        self, sensor: SensorJSON, plugin_id: str, options: dict[str, Any] | None = None
+    ) -> SensorRegistration: ...
+    async def resolveSensor(
+        self, sensor: SensorJSON, plugin_id: str, options: dict[str, Any] | None = None
+    ) -> str: ...
     async def unregisterSensor(self, sensor_id: str) -> None: ...
     async def updatePropertyValues(self, sensor_id: str, properties: dict[str, Any]) -> None: ...
     async def updateCapabilities(self, sensor_id: str, capabilities: list[str]) -> None: ...
     async def getPropertyValue(self, sensor_id: str, property: str) -> Any: ...
     async def getAllPropertyValues(self, sensor_id: str) -> dict[str, Any]: ...
-    async def getSensorState(self, sensor_id: str) -> SensorRefreshedState: ...
+    async def getSensorState(self, sensor_id: str) -> SensorRefreshedState | None: ...
     async def getSensorStates(self) -> dict[str, SensorRefreshedState]: ...
     async def getSensors(self, plugin_id: str | None = None) -> list[StoredSensorData]: ...
-    async def getSensor(self, sensor_id: str, plugin_id: str | None = None) -> StoredSensorData | None: ...
-    async def getSensorByType(
-        self, sensor_type: SensorType, plugin_id: str | None = None
-    ) -> StoredSensorData | None: ...
+    async def getSensorRpc(self, sensor_id: str, plugin_id: str | None = None) -> StoredSensorData | None: ...
     async def setDisplayName(self, sensor_id: str, display_name: str) -> None: ...
 
 
@@ -165,5 +234,3 @@ class DetectionCoordinatorRPC(Protocol):
     async def reportSensorWrite(
         self, sensor_id: str, sensor_type: SensorType, properties: dict[str, Any]
     ) -> None: ...
-
-    async def unregisterSensor(self, sensor_id: str) -> None: ...

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

@@ -0,0 +1,386 @@
+from __future__ import annotations
+
+import contextlib
+from typing import TYPE_CHECKING, Any, cast
+
+from _camera_ui_tools.camera_ui_common import TaskSet
+from _camera_ui_tools.camera_ui_sdk import BasePlugin, Sensor, SensorLike, SensorType
+from plugins.runtime.python.namespaces import NamespaceManager
+from plugins.runtime.python.proxy.sensor import (
+    DetectionCoordinatorRPC,
+    SensorProxy,
+    SensorRegistryInterface,
+)
+
+if TYPE_CHECKING:
+    from _camera_ui_tools.camera_ui_common import LoggerService
+    from _camera_ui_tools.camera_ui_rpc import CloseHandler, RPCClient
+    from plugins.runtime.python.storage_controller import StorageController
+    from plugins.runtime.python.typings import (
+        PluginInfo,
+        SensorAddedEvent,
+        SensorAssignmentChangedEvent,
+        SensorConnectedChangedEvent,
+        SensorDeletedEvent,
+        SensorEventMessage,
+        SensorExposedChangedEvent,
+        StoredSensorData,
+    )
+
+DETECTION_SENSOR_TYPES: frozenset[SensorType] = frozenset(
+    {
+        SensorType.Motion,
+        SensorType.Audio,
+        SensorType.Object,
+        SensorType.ObjectAssist,
+        SensorType.Face,
+        SensorType.LicensePlate,
+        SensorType.Classifier,
+        SensorType.Clip,
+    }
+)
+
+
+class SensorManagerProxy:
+    def __init__(
+        self,
+        proxy: RPCClient,
+        storage_controller: StorageController,
+        plugin: PluginInfo,
+        logger: LoggerService,
+    ) -> None:
+        self._proxy = proxy
+        self._storage_controller = storage_controller
+        self._plugin = plugin
+        self._logger = logger
+        self._plugin_instance: BasePlugin | None = None
+
+        self._owned: dict[str, Sensor[Any, Any, Any]] = {}
+        self._cleanups: dict[str, CloseHandler] = {}
+        self._external: dict[str, Sensor[Any, Any, Any]] = {}
+        self._consumed: dict[str, SensorProxy] = {}
+        self._global_unsubscribe: CloseHandler | None = None
+        self._closed = False
+
+        self._tasks = TaskSet(name=f"SensorManager:{plugin['id']}")
+
+    def set_plugin(self, plugin: BasePlugin) -> None:
+        self._plugin_instance = plugin
+
+    @property
+    def _registry_proxy(self) -> SensorRegistryInterface:
+        ns = NamespaceManager.sensor_registry_namespaces()
+        return self._proxy.create_proxy(ns.sensors_rpc)
+
+    @property
+    def _consumes_something(self) -> bool:
+        return len(self._plugin["contract"].get("consumes", [])) > 0
+
+    async def init(self) -> None:
+        if not self._consumes_something:
+            return
+
+        await self._ensure_global_subscription()
+
+        try:
+            sensors = await self._registry_proxy.getSensors(self._plugin["id"])
+            for data in sensors:
+                if not self._is_consumable(data):
+                    continue
+                self._add_consumed(data)
+        except Exception:
+            # registry not reachable yet, sensors arrive via events
+            pass
+
+        for sensor_proxy in self._consumed.values():
+            await sensor_proxy._subscribe_to_events()  # pyright: ignore[reportPrivateUsage]
+
+        if self._plugin_instance:
+            await self._plugin_instance.configureSensors(
+                cast("list[SensorLike]", list(self._consumed.values()))
+            )
+
+    async def addSensor(self, sensor: Sensor[Any, Any, Any]) -> None:
+        # pre-standalone SDK: its toJSON reads the removed cameraId getter and throws, drop the guard with the stub window
+        if not callable(getattr(sensor, "_setId", None)):
+            self._logger.warn(
+                f'Plugin "{self._plugin["id"]}" uses a pre-standalone SDK, sensor "{sensor.name}" stays unavailable. Update the plugin.'
+            )
+            return
+
+        # producers need the global stream too: assignment changes must reach
+        # owned sensors, their detection fan-out reads assignedCameraIds
+        await self._ensure_global_subscription()
+
+        plugin_id = self._plugin["id"]
+        sensor._setPluginId(plugin_id)  # pyright: ignore[reportPrivateUsage]
+
+        sensor_json = sensor.toJSON()
+        sensor_json["requiresFrames"] = getattr(sensor, "_requires_frames", False) is True
+
+        # resolve the durable id first and wire storage with it, so registration
+        # data (modelSpec) can read sensor storage
+        sensor_id = await self._registry_proxy.resolveSensor(sensor_json, plugin_id)
+        sensor._setId(sensor_id)  # pyright: ignore[reportPrivateUsage]
+        sensor_json["id"] = sensor_id
+
+        storage = self._storage_controller.createSensorStorage(plugin_id, sensor.id, sensor.storage_schema)
+        await storage.register_storage()
+        sensor._setStorage(storage)  # pyright: ignore[reportPrivateUsage]
+
+        model_spec = getattr(sensor, "modelSpec", None)
+        if model_spec:
+            sensor_json["modelSpec"] = model_spec
+
+        registration = await self._registry_proxy.registerSensor(sensor_json, plugin_id)
+        sensor._setAssignedCameras(registration["assignedCameraIds"])  # pyright: ignore[reportPrivateUsage]
+
+        sensor_namespace = NamespaceManager.sensor_provider_namespaces(plugin_id, sensor.id).sensor_rpc
+
+        sensor_type = sensor.type
+        sensor._init(  # pyright: ignore[reportPrivateUsage]
+            lambda properties: self._on_sensor_state_write(sensor, sensor_type, properties)
+        )
+        sensor._initCapabilities(lambda caps: self._on_sensor_capabilities_changed(sensor.id, caps))  # pyright: ignore[reportPrivateUsage]
+
+        rpc_cleanup = await self._proxy.register_handler(sensor_namespace, sensor, without_decorators=True)
+
+        event_ns = NamespaceManager.sensor_event_namespaces(sensor.id)
+
+        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")
+                if prop is not None:
+                    sensor._onBackendPropertyChanged(  # pyright: ignore[reportPrivateUsage]
+                        prop, change_data.get("value"), change_data.get("timestamp")
+                    )
+
+        unsubscribe_events = await self._proxy.subscribe(event_ns.sensor_subject, handle_backend_event)
+
+        async def cleanup() -> None:
+            await unsubscribe_events()
+            await rpc_cleanup()
+
+        self._owned[sensor.id] = sensor
+        self._cleanups[sensor.id] = cleanup
+
+        sensor._setActive(True)  # pyright: ignore[reportPrivateUsage]
+
+    async def removeSensor(self, sensor: Sensor[Any, Any, Any]) -> None:
+        try:
+            await self._registry_proxy.unregisterSensor(sensor.id)
+        except Exception as e:
+            self._logger.warn(f"Failed to unregister sensor {sensor.id}: {e}")
+
+        cleanup = self._cleanups.pop(sensor.id, None)
+        if cleanup:
+            await cleanup()
+
+        self._owned.pop(sensor.id, None)
+        sensor._cleanup()  # pyright: ignore[reportPrivateUsage]
+
+    def getSensors(self) -> list[Sensor[Any, Any, Any]]:
+        return list(self._owned.values())
+
+    # keeps a camera-registered sensor's assignedCameraIds in sync with the global stream
+    async def track_camera_sensor(self, sensor: Sensor[Any, Any, Any]) -> None:
+        await self._ensure_global_subscription()
+        self._external[sensor.id] = sensor
+
+    def untrack_camera_sensor(self, sensor_id: str) -> None:
+        self._external.pop(sensor_id, None)
+
+    def on_rpc_reconnected(self) -> None:
+        if self._closed:
+            return
+        self._tasks.add(self._resync_all_consumed())
+
+    async def close(self) -> None:
+        self._closed = True
+
+        if self._global_unsubscribe:
+            with contextlib.suppress(Exception):
+                await self._global_unsubscribe()
+            self._global_unsubscribe = None
+
+        for sensor_proxy in self._consumed.values():
+            with contextlib.suppress(Exception):
+                await sensor_proxy._unsubscribe_from_events()  # pyright: ignore[reportPrivateUsage]
+        self._consumed.clear()
+        self._external.clear()
+
+        for cleanup in list(self._cleanups.values()):
+            with contextlib.suppress(Exception):
+                await cleanup()
+        self._cleanups.clear()
+
+        for sensor in self._owned.values():
+            sensor._cleanup()  # pyright: ignore[reportPrivateUsage]
+        self._owned.clear()
+
+        self._tasks.remove_all()
+
+    async def _ensure_global_subscription(self) -> None:
+        if self._global_unsubscribe is not None:
+            return
+
+        ns = NamespaceManager.sensor_registry_namespaces()
+        self._global_unsubscribe = await self._proxy.subscribe(
+            ns.sensors_subject, self._on_global_sensor_event
+        )
+
+    async def _resync_all_consumed(self) -> None:
+        for sensor_id in list(self._consumed):
+            await self._resync_consumed(sensor_id)
+
+    async def _resync_consumed(self, sensor_id: str) -> None:
+        sensor_proxy = self._consumed.get(sensor_id)
+        if not sensor_proxy:
+            return
+
+        try:
+            state = await self._registry_proxy.getSensorState(sensor_id)
+        except Exception:
+            # owner or registry unreachable, the next re-announce carries the state
+            return
+
+        if state:
+            sensor_proxy._apply_refreshed_state(state)  # pyright: ignore[reportPrivateUsage]
+
+    def _is_consumable(self, data: StoredSensorData) -> bool:
+        if data["id"] in self._owned or data["pluginId"] == self._plugin["id"]:
+            return False
+        if not data.get("exposed", False):
+            return False
+        return data["type"] in self._plugin["contract"].get("consumes", [])
+
+    def _add_consumed(self, data: StoredSensorData) -> SensorProxy:
+        owner_namespace = NamespaceManager.sensor_provider_namespaces(data["pluginId"], data["id"]).sensor_rpc
+        sensor_proxy = SensorProxy(data, self._proxy, owner_namespace)
+        self._consumed[data["id"]] = sensor_proxy
+        return sensor_proxy
+
+    async def _release_consumed(self, sensor_id: str) -> None:
+        sensor_proxy = self._consumed.pop(sensor_id, None)
+        if not sensor_proxy:
+            return
+
+        with contextlib.suppress(Exception):
+            await sensor_proxy._unsubscribe_from_events()  # pyright: ignore[reportPrivateUsage]
+
+        if self._plugin_instance:
+            with contextlib.suppress(Exception):
+                await self._plugin_instance.onSensorReleased(sensor_id)
+
+    def _on_global_sensor_event(self, message: SensorEventMessage) -> None:
+        async def handle() -> None:
+            try:
+                await self._handle_global_sensor_event(message)
+            except Exception as e:
+                self._logger.warn(f"Sensor event handling failed: {e}")
+
+        self._tasks.add(handle())
+
+    async def _handle_global_sensor_event(self, message: SensorEventMessage) -> None:
+        event_type = message.get("type")
+
+        if event_type == "sensor:added":
+            added = cast("SensorAddedEvent", message.get("data"))
+            data = added["sensor"]
+            for owned in (self._owned.get(data["id"]), self._external.get(data["id"])):
+                if owned:
+                    owned._setAssignedCameras(data["assignedCameraIds"])  # pyright: ignore[reportPrivateUsage]
+            consumed = self._consumed.get(data["id"])
+            if consumed is not None:
+                # re-announced while we already hold it: the payload is authoritative, our cache may be stale
+                consumed._apply_refreshed_state(added["state"])  # pyright: ignore[reportPrivateUsage]
+                return
+            if not self._is_consumable(data):
+                return
+            sensor_proxy = self._add_consumed(data)
+            await sensor_proxy._subscribe_to_events()  # pyright: ignore[reportPrivateUsage]
+            if self._plugin_instance:
+                await self._plugin_instance.onSensorAdded(sensor_proxy)
+
+        elif event_type == "sensor:deleted":
+            deleted = cast("SensorDeletedEvent", message.get("data"))
+            await self._release_consumed(deleted["sensorId"])
+
+        elif event_type == "sensor:connected:changed":
+            connected = cast("SensorConnectedChangedEvent", message.get("data"))
+            consumed = self._consumed.get(connected["sensorId"])
+            if consumed:
+                consumed._set_connected(connected["connected"])  # pyright: ignore[reportPrivateUsage]
+                if connected["connected"]:
+                    # the owner was away, whatever it published in the meantime never reached us
+                    self._tasks.add(self._resync_consumed(connected["sensorId"]))
+
+        elif event_type == "sensor:exposed:changed":
+            exposed = cast("SensorExposedChangedEvent", message.get("data"))
+            if not exposed["exposed"]:
+                await self._release_consumed(exposed["sensorId"])
+                return
+            if exposed["sensorId"] in self._consumed:
+                return
+            fetched = await self._registry_proxy.getSensorRpc(exposed["sensorId"], self._plugin["id"])
+            if not fetched or not self._is_consumable(fetched):
+                return
+            sensor_proxy = self._add_consumed(fetched)
+            await sensor_proxy._subscribe_to_events()  # pyright: ignore[reportPrivateUsage]
+            if self._plugin_instance:
+                await self._plugin_instance.onSensorAdded(sensor_proxy)
+
+        elif event_type == "sensor:assignment:changed":
+            assignment = cast("SensorAssignmentChangedEvent", message.get("data"))
+            targets: list[Sensor[Any, Any, Any] | SensorProxy] = []
+            for candidate in (
+                self._owned.get(assignment["sensorId"]),
+                self._external.get(assignment["sensorId"]),
+                self._consumed.get(assignment["sensorId"]),
+            ):
+                if candidate is not None:
+                    targets.append(candidate)
+            for target in targets:
+                cameras = set(target.assignedCameraIds)
+                if assignment["assigned"]:
+                    cameras.add(assignment["cameraId"])
+                else:
+                    cameras.discard(assignment["cameraId"])
+                if isinstance(target, SensorProxy):
+                    target._set_assigned_cameras(list(cameras))  # pyright: ignore[reportPrivateUsage]
+                else:
+                    target._setAssignedCameras(list(cameras))  # pyright: ignore[reportPrivateUsage]
+
+    def _on_sensor_state_write(
+        self,
+        sensor: Sensor[Any, Any, Any],
+        sensor_type: SensorType,
+        properties: dict[str, Any],
+    ) -> None:
+        if sensor_type in DETECTION_SENSOR_TYPES:
+            # external detection provider: fan the write into every assigned camera's coordinator
+            async def notify_coordinators() -> None:
+                for camera_id in sensor.assignedCameraIds:
+                    detection_ns = NamespaceManager.frame_worker_detection_namespaces(camera_id)
+                    coordinator: DetectionCoordinatorRPC = self._proxy.create_proxy(
+                        detection_ns.detection_rpc
+                    )
+                    with contextlib.suppress(Exception):
+                        await coordinator.reportSensorWrite(sensor.id, sensor_type, properties)
+
+            self._tasks.add(notify_coordinators())
+            return
+
+        async def notify_registry() -> None:
+            with contextlib.suppress(Exception):
+                await self._registry_proxy.updatePropertyValues(sensor.id, properties)
+
+        self._tasks.add(notify_registry())
+
+    def _on_sensor_capabilities_changed(self, sensor_id: str, capabilities: list[str]) -> None:
+        async def notify() -> None:
+            with contextlib.suppress(Exception):
+                await self._registry_proxy.updateCapabilities(sensor_id, capabilities)
+
+        self._tasks.add(notify())