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

package/dist/server/src/camera/controller.js

@@ -7,50 +7,60 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var _a;
 import { generateSdp } from '@camera.ui/common/camera';
-import { createSourceName, isEqual, sleep } from '@camera.ui/common/utils';
-import { rpc } from '@camera.ui/rpc-common';
-import { pathExists } from 'fs-extra/esm';
-import { createWriteStream, ftruncate, read, rmSync } from 'node:fs';
-import { open, stat } from 'node:fs/promises';
-import { join } from 'node:path';
-import { promisify } from 'node:util';
-import { filter, pairwise } from 'rxjs/operators';
+import { isEqual, sleep } from '@camera.ui/common/utils';
+import { RPCClass, RPCMethod } from '@camera.ui/rpc';
+import { API_EVENT, filter, pairwise, SensorType, Subject } from '@camera.ui/sdk';
 import { container } from 'tsyringe';
-import { Agent } from 'undici';
-import { API_EVENT } from '../api.js';
 import { PLUGIN_STATUS } from '../plugins/types.js';
 import { NamespaceManager } from '../rpc/namespaces.js';
-import { CameraDevice } from './device.js';
-import { FrameWorker } from './frameWorker.js';
-import { CameraInterface } from './interfaces.js';
+import { buildSnapshotUrl, buildTargetUrl, createSourceName } from '../utils/camera.js';
+import { FrameWorker } from './decoder/worker.js';
+import { CameraDevice } from './index.js';
+import { SensorController } from './sensors/controller.js';
+import { getMultiProviderTypes, SENSOR_TYPE_CONFIG } from './sensors/types.js';
+import { Fmp4Session } from './streaming/fmp4-session.js';
+import { RtpSession } from './streaming/rtp-session.js';
 import { generateAudioStreamInfo, generateVideoStreamInfo } from './utils.js';
-const truncatePromise = promisify(ftruncate);
-const readPromise = promisify(read);
-export class CameraController extends CameraDevice {
+let CameraController = class CameraController extends CameraDevice {
     frameWorker;
     streamInfos = new Map();
-    logStream;
-    cameraInterfaces;
-    initialized = true;
+    sensorController;
+    #sensorAddedSubject = new Subject();
+    #sensorRemovedSubject = new Subject();
+    #detectionEventSubject = new Subject();
+    onSensorAdded = this.#sensorAddedSubject.asObservable();
+    onSensorRemoved = this.#sensorRemovedSubject.asObservable();
+    onDetectionEvent = this.#detectionEventSubject.asObservable();
     proxy;
     namespaces;
-    motionTimeout;
-    objectTimeout;
-    objectTimeoutDuration = 5;
-    audioTimeout;
-    audioTimeoutDuration = 5;
-    blockMotionResetEvents = false;
-    proxyServer;
     go2rtcApi;
-    configService;
+    loggerService;
     api;
-    truncateInterval;
-    truncateIntervalMs = 1000 * 60 * 60 * 2;
-    pluginIds = new Set();
+    closeProxy;
+    detectionEventUnsub;
+    autoRefreshInterval;
+    constructor(camera, logger) {
+        super(camera, logger);
+        this.api = container.resolve('api');
+        this.go2rtcApi = container.resolve('go2rtcApi');
+        this.loggerService = container.resolve('logger');
+        this.proxy = container.resolve('proxy').proxy;
+        this.frameWorker = new FrameWorker(this);
+        this.sensorController = new SensorController(this, this.frameWorker, this.proxy);
+        this.namespaces = {
+            ...NamespaceManager.cameraNamespaces(camera._id),
+            ...NamespaceManager.frameWorkerDetectionNamespaces(camera._id),
+        };
+        this.addSubscriptions(this.subscribeToCameraState(), this.subscribeToFrameWorkerState(), this.subscribeToCameraChanges());
+        this.api.setMaxListeners(this.api.getMaxListeners() + 1);
+        this.api.once(API_EVENT.SHUTDOWN, () => {
+            this.cleanup();
+        });
+        this.initialized.next(true);
+    }
     get logPath() {
-        return join(this.configService.LOGS_PATH, `camera-${this.id}.log`);
+        return this.loggerService.getCameraLogPath(this.id) ?? '';
     }
     get streamSource() {
         return (this.highResolutionSource ?? this.midResolutionSource ?? this.lowResolutionSource);
@@ -58,47 +68,80 @@ export class CameraController extends CameraDevice {
     get camera() {
         return this.cameraObject;
     }
-    constructor(camera, logger) {
-        const proxyServer = container.resolve('proxy');
-        const namespaces = {
-            ...NamespaceManager.cameraNamespaces(camera._id),
-            ...NamespaceManager.frameWorkerNamespaces(camera._id),
-        };
-        super(camera, proxyServer.proxy, namespaces, logger);
-        this.proxyServer = proxyServer;
-        this.api = container.resolve('api');
-        this.go2rtcApi = container.resolve('go2rtcApi');
-        this.configService = container.resolve('configService');
-        this.logStream = createWriteStream(this.logPath, { flags: 'a' });
-        this.writeHeader();
-        this.truncateInterval = setInterval(() => this.truncateLog(), this.truncateIntervalMs);
-        this.truncateLog();
-        this.logger.logStream = this.logStream;
-        this.proxy = this.proxyServer.proxy;
-        this.frameWorker = new FrameWorker(this);
-        this.cameraInterfaces = new CameraInterface(this.proxy, this.capabilities, this.camera._id);
-        this.namespaces = namespaces;
-        this.addSubscriptions(this.subscribeToCameraState(), this.subscribeToFrameWorkerState(), this.subscribeToCameraChanges(), this.subscribeToCapabilityChanges(), this.subscribeToStateChanges('light', this.lightState), this.subscribeToStateChanges('motion', this.motionState), this.subscribeToStateChanges('audio', this.audioState), this.subscribeToStateChanges('object', this.objectState), this.subscribeToStateChanges('doorbell', this.doorbellState), this.subscribeToStateChanges('siren', this.sirenState), this.onPropertyChange('name').subscribe(() => {
-            this.logger.prefix = this.camera.name;
-        }));
-        this.api.setMaxListeners(this.api.getMaxListeners() + 1);
-        this.api.once(API_EVENT.SHUTDOWN, () => {
-            this.cleanup();
+    get cameraDeviceProxy() {
+        const pluginId = this.camera.pluginInfo?.id;
+        if (!pluginId) {
+            return undefined;
+        }
+        const namespace = NamespaceManager.pluginCameraNamespaces(pluginId, this.id);
+        return this.proxy.createProxy(namespace.cameraImplRpc);
+    }
+    get sources() {
+        const sources = JSON.parse(JSON.stringify(this.cameraSubject.getValue().sources));
+        return sources.map((source) => {
+            return {
+                ...source,
+                generateRTSPUrl: (options) => {
+                    return buildTargetUrl(source.urls.rtsp.base, options);
+                },
+                generateSnapshotUrl: (options) => {
+                    return buildSnapshotUrl(this.name, source.name, source.urls.snapshot.jpeg, options);
+                },
+                snapshot: (forceNew) => {
+                    return this.snapshot(source._id, forceNew);
+                },
+                probeStream: (probeConfig, refresh = false) => {
+                    return this.probeStream(source._id, probeConfig, refresh);
+                },
+                getStreamStatus: () => {
+                    return this.getStreamStatus(source._id);
+                },
+                createRtpSession: (urlOrOptions) => {
+                    return new RtpSession(this, source, urlOrOptions);
+                },
+                createFmp4Session: (urlOrOptions) => {
+                    return new Fmp4Session(this, source, urlOrOptions);
+                },
+            };
         });
-        this.preloadSources();
     }
     async init() {
-        await this.proxy.registerRPCHandler(this.namespaces.cameraControllerRpc, this);
-        await this.frameWorker.start();
+        this.closeProxy = await this.proxy.registerHandler(this.namespaces.cameraControllerRpc, this, { isolatedConnection: true });
+        await this.sensorController.init();
+        // Bridge: subscribe to NATS detection events published by the EventManager
+        // (which lives in the FrameWorker child process) and forward them to the
+        // local `onDetectionEvent` Observable. Existing in-process consumers
+        // (automations, plugin runtime cameraDevice proxy) read from the Observable
+        // and need no changes.
+        const detectionEventSubject = NamespaceManager.detectionEventNamespaces(this.id).detectionEventSubject;
+        this.detectionEventUnsub = await this.proxy.subscribe(detectionEventSubject, (msg) => {
+            this.#detectionEventSubject.next({ type: msg.type, event: msg.data });
+        });
+        if (this.disabled) {
+            this.logger.log('Camera is disabled — skipping preload, auto-refresh, and stream startup');
+            return;
+        }
+        // Non-plugin cameras: preload go2rtc sources, then mark as connected.
+        // FrameWorker starts reactively via the onConnected subscriber.
+        // Plugin cameras stay disconnected until the plugin calls connect().
+        if (!this.pluginInfo) {
+            await this.initialPreload();
+            this.cameraState.next(true);
+        }
+        this.startAutoRefresh();
+        this.preloadSources();
     }
-    extend() {
-        // ignore
+    removePluginSensors(pluginId) {
+        this.sensorController.removePluginSensors(pluginId);
     }
-    addCapabilities() {
-        // ignore
+    getSensorByType(sensorType) {
+        return this.sensorController.getSensorByType(sensorType);
     }
-    removeCapabilities() {
-        // ignore
+    createStorage() {
+        throw new Error('Method not implemented.');
+    }
+    async implement() {
+        throw new Error('Method not implemented.');
     }
     async connect() {
         this.cameraState.next(true);
@@ -106,70 +149,71 @@ export class CameraController extends CameraDevice {
     async disconnect() {
         this.cameraState.next(false);
     }
-    async updateState(stateName, eventData, frame, override) {
-        if (!override && stateName === 'motion' && this.blockMotionResetEvents && !eventData.state) {
-            eventData.state = true;
-            eventData.detections = [];
-        }
-        super.updateStateInternal(stateName, eventData);
-    }
     async snapshot(sourceId, forceNew) {
         this.snapshotCache.purgeStale();
         const fromCache = this.snapshotCache.get(sourceId);
         if (!forceNew && fromCache) {
             return fromCache;
         }
-        try {
-            if (this.cameraObject.pluginInfo) {
-                try {
-                    const snapshotFromPlugin = await this.cameraInterfaces.snapshot(sourceId, forceNew);
-                    if (snapshotFromPlugin && snapshotFromPlugin.byteLength > 0) {
-                        this.snapshotCache.set(sourceId, snapshotFromPlugin);
-                        return snapshotFromPlugin;
-                    }
-                }
-                catch {
-                    //
+        const source = this.sources.find((source) => source._id === sourceId);
+        if (!source) {
+            throw new Error('Source not found');
+        }
+        const fetchSnapshotFromSource = async (s) => {
+            try {
+                const sourceName = createSourceName(this.name, s.name);
+                const snapshot = await this.go2rtcApi.snapshotRoute.jpeg({ src: sourceName });
+                if (snapshot.byteLength > 0) {
+                    this.snapshotCache.set(s._id, snapshot);
                 }
+                return snapshot;
             }
-            const source = this.sources.find((source) => source._id === sourceId);
-            if (!source) {
-                throw new Error('Source not found');
+            catch (error) {
+                if (error.name === 'AbortError' || error.message?.includes('aborted')) {
+                    this.logger.debug('Snapshot request timed out for', this.name);
+                }
+                else {
+                    this.logger.error('Error while fetching snapshot:', error.message);
+                }
             }
-            const snapshotUrl = source.urls.snapshot.jpeg;
-            const controller = new AbortController();
-            const timeout = setTimeout(() => controller.abort(), 20000);
-            const response = await fetch(snapshotUrl, {
-                signal: controller.signal,
-                // @ts-ignore
-                dispatcher: new Agent({
-                    connect: {
-                        cert: this.configService.ssl.cert,
-                        key: this.configService.ssl.key,
-                        ca: this.configService.ssl.ca,
-                        rejectUnauthorized: false,
-                    },
-                }),
-            });
-            clearTimeout(timeout);
-            if (!response.ok) {
-                throw new Error('Status Code: ' + response.status);
+        };
+        const fetchSnapshotFromPlugin = async (s) => {
+            try {
+                const pluginSnapshot = await this.cameraDeviceProxy?.snapshot?.(s._id, forceNew);
+                if (pluginSnapshot && pluginSnapshot.byteLength > 0) {
+                    this.snapshotCache.set(s._id, pluginSnapshot);
+                    return pluginSnapshot;
+                }
             }
-            const snapshot = await response.arrayBuffer();
-            if (snapshot.byteLength > 0) {
-                this.snapshotCache.set(source._id, snapshot);
+            catch {
+                // Ignore plugin errors; fall back to go2rtc.
             }
+        };
+        if (source.role === 'snapshot' || source.useForSnapshot) {
+            const snapshot = await fetchSnapshotFromSource(source);
             return snapshot;
         }
-        catch (error) {
-            this.logger.error('Error while fetching snapshot', error);
+        else {
+            const pluginSnapshot = await fetchSnapshotFromPlugin(source);
+            if (pluginSnapshot) {
+                return pluginSnapshot;
+            }
+            else {
+                const snapshot = await fetchSnapshotFromSource(source);
+                return snapshot;
+            }
         }
     }
-    addPluginCapabilities(pluginId, capabilities) {
-        super.addCapabilitiesInternal(pluginId, capabilities);
+    async streamUrl(sourceId) {
+        return this.cameraDeviceProxy?.streamUrl?.(sourceId);
     }
-    removePluginCapabilities(pluginId, capabilities = []) {
-        super.removeCapabilitiesInternal(pluginId, capabilities);
+    async registerSensor(sensor, pluginId) {
+        return this.sensorController.registerSensor(sensor, pluginId);
+    }
+    unregisterSensor(sensorId) {
+        // No DetectionCoordinator notify needed for individual removal — plugin
+        // unregistration happens via removePluginSensors when the plugin exits.
+        this.sensorController.unregisterSensor(sensorId);
     }
     async probeStream(sourceId, probeConfig, refresh = false) {
         let streamInfo = this.streamInfos.get(sourceId);
@@ -182,7 +226,7 @@ export class CameraController extends CameraDevice {
         }
         try {
             const src = createSourceName(this.name, cameraSource?.name);
-            const probe = await this.go2rtcApi.streamsApi.probeStreamSource({ src }, probeConfig);
+            const probe = await this.go2rtcApi.streamsRoute.probeStreamSource({ src }, probeConfig);
             const videoStreamInfo = generateVideoStreamInfo(probe.producers);
             const audioStreamInfo = generateAudioStreamInfo(probe.producers);
             const sdp = generateSdp(videoStreamInfo, audioStreamInfo);
@@ -194,65 +238,185 @@ export class CameraController extends CameraDevice {
             this.streamInfos.set(sourceId, streamInfo);
         }
         catch (err) {
-            this.logger.error('Error while probing stream source', err);
+            this.logger.error('Error while probing stream source', err.message.split('\n')[0]);
         }
         return streamInfo;
     }
+    async getStreamStatus(sourceId) {
+        const source = this.sources.find((s) => s._id === sourceId);
+        if (!source)
+            return 'idle';
+        try {
+            const sourceName = createSourceName(this.name, source.name);
+            const statuses = await this.go2rtcApi.streamsRoute.getStreamsStatus();
+            return statuses[sourceName] ?? 'idle';
+        }
+        catch {
+            return 'idle';
+        }
+    }
     async refreshStates() {
         return {
             camera: this.camera,
             cameraState: this.connected,
             frameWorkerState: this.frameWorker.status === PLUGIN_STATUS.STARTED,
-            capabilities: this.capabilities.getValue(),
-            states: {
-                light: this.getValue('light'),
-                motion: this.getValue('motion'),
-                audio: this.getValue('audio'),
-                object: this.getValue('object'),
-                doorbell: this.getValue('doorbell'),
-                siren: this.getValue('siren'),
-                battery: this.getValue('battery'),
-            },
+            sensorStates: this.sensorController.getSensorStates(),
         };
     }
+    getSensors() {
+        return this.sensorController.getAllSensors();
+    }
+    getSensor(sensorId) {
+        return this.sensorController.getSensor(sensorId, { activatedOnly: true });
+    }
+    getSensorsByType(type) {
+        return this.sensorController.getSensorsByType(type);
+    }
+    async addSensor(sensor) {
+        const sensorJSON = sensor.toJSON();
+        this.sensorController.registerSensor(sensorJSON, sensor.pluginId ?? '');
+    }
+    async removeSensor(sensorId) {
+        this.sensorController.unregisterSensor(sensorId);
+    }
     updateCamera(updatedCamera) {
+        const oldAssignments = this.camera.assignments;
         super.updateCamera(updatedCamera);
+        this.detectAndNotifyAssignmentChanges(oldAssignments, updatedCamera.assignments);
     }
     updateFrameWorkerState(state) {
         super.updateFrameWorkerState(state);
     }
+    updateSensorState(sensorId, type, addedOrRemoved) {
+        if (addedOrRemoved === 'added') {
+            this.#sensorAddedSubject.next({ sensorId, sensorType: type });
+        }
+        else {
+            this.#sensorRemovedSubject.next({ sensorId, sensorType: type });
+        }
+    }
     async cleanup() {
+        this.stopAutoRefresh();
+        this.detectionEventUnsub?.();
         await this.frameWorker.close();
-        this.closeLogStream();
+        await this.sensorController.destroy();
         this.removeAllListeners();
         this.unsubscribe();
-        this.clearTimers();
-        await this.disconnectRpc();
+        await this.closeProxy?.();
     }
     async stop() {
-        this.initialized = false;
+        this.initialized.next(false);
         await this.cleanup();
-        this.removeLogStream();
+        this.loggerService.removeCameraLogger(this.id);
         this.triggerProxyEvent('removed');
     }
-    writeLog(...args) {
-        this.safeWriteLog(args.join(' ').replace(/\r?\n*$/, '\n'));
-    }
-    async storageProxy(pluginId) {
-        this.pluginIds.add(pluginId);
+    storageProxy(pluginId) {
         const namespaces = NamespaceManager.pluginCameraNamespaces(pluginId, this.id);
-        return this.proxy.createRPCProxy(namespaces.cameraStorageRpc);
+        return this.proxy.createProxy(namespaces.cameraStorageRpc);
+    }
+    sensorStorageProxy(pluginId, sensorId) {
+        const namespaces = NamespaceManager.pluginSensorNamespaces(pluginId, this.id, sensorId);
+        return this.proxy.createProxy(namespaces.sensorStorageRpc);
+    }
+    detectAndNotifyAssignmentChanges(oldAssignments, newAssignments) {
+        const multiProviderSet = new Set(getMultiProviderTypes());
+        for (const [sensorTypeStr, config] of Object.entries(SENSOR_TYPE_CONFIG)) {
+            const sensorType = sensorTypeStr;
+            const key = config.assignmentKey;
+            if (multiProviderSet.has(sensorType)) {
+                const oldPlugins = oldAssignments[key] ?? [];
+                const newPlugins = newAssignments[key] ?? [];
+                const oldIds = new Set(oldPlugins.map((p) => p.id));
+                const newIds = new Set(newPlugins.map((p) => p.id));
+                for (const oldId of oldIds) {
+                    if (!newIds.has(oldId)) {
+                        this.sensorController.onAssignmentChanged(oldId, sensorType, false);
+                    }
+                }
+                for (const newId of newIds) {
+                    if (!oldIds.has(newId)) {
+                        this.sensorController.onAssignmentChanged(newId, sensorType, true);
+                    }
+                }
+            }
+            else {
+                const oldPlugin = oldAssignments[key];
+                const newPlugin = newAssignments[key];
+                const oldId = oldPlugin?.id;
+                const newId = newPlugin?.id;
+                if (oldId !== newId) {
+                    if (oldId) {
+                        this.sensorController.onAssignmentChanged(oldId, sensorType, false);
+                    }
+                    if (newId) {
+                        this.sensorController.onAssignmentChanged(newId, sensorType, true);
+                    }
+                }
+            }
+        }
+    }
+    async onDisabled() {
+        this.logger.log('Camera disabled — stopping FrameWorker, preloads, and auto-refresh');
+        this.stopAutoRefresh();
+        await this.frameWorker.close();
+        await this.stopAllPreloads();
+    }
+    async onSnoozed() {
+        this.logger.log('Camera snoozed — stopping FrameWorker (detections paused)');
+        await this.frameWorker.close();
+    }
+    async onUnsnoozed() {
+        this.logger.log('Camera unsnoozed — resuming detections');
+        if (this.connected && !this.disabled) {
+            this.frameWorker.start();
+        }
+    }
+    async onEnabled() {
+        this.logger.log('Camera enabled — resuming preloads, auto-refresh, and stream startup');
+        if (!this.pluginInfo) {
+            await this.initialPreload();
+            if (!this.connected) {
+                this.cameraState.next(true);
+            }
+        }
+        this.startAutoRefresh();
+        this.preloadSources();
+        // onConnected fires on state change, not on current state — start FrameWorker
+        // explicitly when the camera is already connected.
+        if (this.connected) {
+            this.frameWorker.start();
+        }
+    }
+    async initialPreload() {
+        for (const source of this.sources) {
+            if (!source.hotMode)
+                continue;
+            try {
+                const sourceName = createSourceName(this.name, source.name);
+                await this.go2rtcApi.streamsRoute.addPreloadStream({ src: sourceName }, { video: true, audio: true, microphone: true });
+            }
+            catch {
+                // Non-fatal: go2rtc might not be ready yet, 30s loop will retry
+            }
+        }
     }
     async preloadSources() {
-        while (this.initialized) {
+        while (this.initialized.value) {
+            if (this.disabled) {
+                await this.stopAllPreloads();
+                return;
+            }
             if (this.connected) {
                 for (const source of this.sources) {
                     try {
-                        if (source.hotMode) {
-                            await this.go2rtcApi.streamsApi.startStopPreloadStream({ src: createSourceName(this.name, source.name) }, 'start');
+                        const preloadInfo = await this.go2rtcApi.streamsRoute.getPreloadStream({ src: createSourceName(this.name, source.name) });
+                        if (source.hotMode && preloadInfo.status === 'stopped') {
+                            this.logger.debug(`Preloading source "${source.name}" for camera "${this.name}"`);
+                            await this.go2rtcApi.streamsRoute.addPreloadStream({ src: createSourceName(this.name, source.name) }, { video: true, audio: true, microphone: true });
                         }
-                        else {
-                            await this.go2rtcApi.streamsApi.startStopPreloadStream({ src: createSourceName(this.name, source.name) }, 'stop');
+                        else if (!source.hotMode && preloadInfo.status === 'started') {
+                            this.logger.debug(`Stopping preload for source "${source.name}" for camera "${this.name}"`);
+                            await this.go2rtcApi.streamsRoute.deletePreloadStream({ src: createSourceName(this.name, source.name) });
                         }
                     }
                     catch {
@@ -260,240 +424,218 @@ export class CameraController extends CameraDevice {
                     }
                 }
             }
-            await sleep(5000);
+            await sleep(30000);
+        }
+    }
+    async stopAllPreloads() {
+        for (const source of this.sources) {
+            try {
+                const src = createSourceName(this.name, source.name);
+                const preloadInfo = await this.go2rtcApi.streamsRoute.getPreloadStream({ src });
+                if (preloadInfo.status === 'started') {
+                    this.logger.debug(`Stopping preload for source "${source.name}" (camera disabled)`);
+                    await this.go2rtcApi.streamsRoute.deletePreloadStream({ src });
+                }
+            }
+            catch {
+                //
+            }
+        }
+    }
+    startAutoRefresh() {
+        this.stopAutoRefresh();
+        const settings = this.snapshotSettings;
+        if (!settings.autoRefresh)
+            return;
+        const interval = Math.max(10, Math.min(60, settings.interval)) * 1000;
+        this.logger.debug(`Starting snapshot auto-refresh with interval ${settings.interval}s`);
+        this.autoRefreshInterval = setInterval(async () => {
+            if (!this.connected)
+                return;
+            const source = this.getSnapshotSourceForAutoRefresh();
+            if (!source)
+                return;
+            try {
+                const snapshot = await this.snapshot(source._id, true);
+                if (snapshot && snapshot.byteLength > 0) {
+                    this.triggerProxyEvent('snapshot:updated', { sourceId: source._id, snapshot });
+                }
+            }
+            catch (error) {
+                this.logger.debug('Auto-refresh snapshot failed:', error.message);
+            }
+        }, interval);
+    }
+    getSnapshotSourceForAutoRefresh() {
+        const snapshotSource = this.sources.find((s) => s.role === 'snapshot');
+        if (snapshotSource)
+            return snapshotSource;
+        const useForSnapshot = this.sources.find((s) => s.useForSnapshot);
+        if (useForSnapshot)
+            return useForSnapshot;
+        // Fallback priority: low → mid → high → stream.
+        return this.lowResolutionSource ?? this.midResolutionSource ?? this.highResolutionSource ?? this.streamSource;
+    }
+    stopAutoRefresh() {
+        if (this.autoRefreshInterval) {
+            clearInterval(this.autoRefreshInterval);
+            this.autoRefreshInterval = undefined;
         }
     }
     subscribeToCameraState() {
         return this.cameraState
             .pipe(pairwise(), filter(([oldState, newState]) => oldState !== newState))
-            .subscribe(([, newState]) => this.triggerProxyEvent('cameraState', newState));
+            .subscribe(([, newState]) => {
+            this.logger.log(`Camera ${newState ? 'connected' : 'disconnected'}`);
+            this.triggerProxyEvent('cameraState', newState);
+            try {
+                const bus = container.resolve('internalBus');
+                bus.emitEvent(newState ? 'camera:connected' : 'camera:disconnected', { cameraId: this.id, cameraName: this.name });
+            }
+            catch {
+                // ignore
+            }
+        });
     }
     subscribeToFrameWorkerState() {
         return this.frameWorkerState
             .pipe(pairwise(), filter(([oldState, newState]) => oldState !== newState))
-            .subscribe(([, newState]) => this.triggerProxyEvent('frameWorkerState', newState));
-    }
-    subscribeToCameraChanges() {
-        return this.cameraSubject
-            .pipe(pairwise(), filter(([oldCamera, newCamera]) => !isEqual(oldCamera, newCamera, true)))
-            .subscribe(([, newCamera]) => this.triggerProxyEvent('updated', newCamera));
-    }
-    subscribeToCapabilityChanges() {
-        return this.capabilities
-            .pipe(pairwise(), filter(([oldCapabilities, newCapabilities]) => !isEqual(oldCapabilities, newCapabilities, true)))
-            .subscribe(([, newCapabilities]) => {
-            this.triggerProxyEvent('capabilities', newCapabilities);
-        });
-    }
-    subscribeToStateChanges(stateName, stateSubject) {
-        return stateSubject
-            .pipe(pairwise(), filter(([oldState, newState]) => {
-            return this.stateChanged(oldState, newState, stateName);
-        }))
             .subscribe(([oldState, newState]) => {
-            this.triggerProxyEvent(stateName, newState, oldState);
-            switch (stateName) {
-                case 'motion':
-                    this.motionStateChange(oldState, newState);
-                    break;
-                case 'object':
-                    this.objectStateChange(oldState, newState);
-                    break;
-                case 'audio':
-                    this.audioStateChange(oldState, newState);
-                    break;
-                case 'doorbell':
-                    this.doorbellStateChange(oldState, newState);
-                    break;
+            this.logger.log(`FrameWorker ${newState ? 'started' : 'stopped'}`);
+            this.triggerProxyEvent('frameWorkerState', newState);
+            try {
+                const bus = container.resolve('internalBus');
+                bus.emitEvent(newState ? 'camera:frameworker:started' : 'camera:frameworker:stopped', { cameraId: this.id, cameraName: this.name });
             }
+            catch {
+                // ignore
+            }
+            // SensorController handles detection plugin reconciliation (false→true)
+            // and cascade state reset (true→false).
+            this.sensorController.onFrameWorkerStateChanged(oldState, newState);
         });
     }
-    motionStateChange(oldState, newState) {
-        if (oldState.state !== newState.state) {
-            this.logger.log('Motion state changed:', newState.state);
-            clearTimeout(this.motionTimeout);
-            if (newState.state) {
-                this.blockMotionResetEvents = true;
-                const timeout = this.detectionSettings.motion.timeout;
-                this.logger.trace(`Blocking motion reset events for ${timeout}s`);
-                this.motionTimeout = setTimeout(async () => {
-                    this.logger.trace(`Motion timeout reached after ${timeout}s, unblocking motion reset events and resetting motion state`);
-                    this.blockMotionResetEvents = false;
-                    super.updateStateInternal('motion', { detections: [], state: false }, true);
-                }, timeout * 1000);
-            }
-            else {
-                if (this.blockMotionResetEvents) {
-                    this.logger.trace('Overriding motion reset event block, unblocking motion reset events');
-                    this.blockMotionResetEvents = false;
+    subscribeToCameraChanges() {
+        return this.cameraSubject
+            .pipe(pairwise(), filter(([oldCamera, newCamera]) => !isEqual(oldCamera, newCamera, true)))
+            .subscribe(([oldCamera, newCamera]) => {
+            this.triggerProxyEvent('updated', newCamera);
+            try {
+                const bus = container.resolve('internalBus');
+                const watchedProps = [
+                    'name',
+                    'sources',
+                    'detectionSettings',
+                    'ptzAutotrack',
+                    'detectionZones',
+                    'detectionLines',
+                    'frameWorkerSettings',
+                    'interfaceSettings',
+                ];
+                for (const prop of watchedProps) {
+                    if (!isEqual(oldCamera[prop], newCamera[prop], true)) {
+                        bus.emitEvent('camera:property:changed', { cameraId: this.id, cameraName: this.name, property: prop });
+                    }
                 }
             }
-        }
-    }
-    objectStateChange(oldState, newState) {
-        const lastEventLabels = Array.from(new Set(oldState.lastEvent?.detections.map((detection) => detection.label).filter(Boolean)));
-        const oldLabels = Array.from(new Set(oldState.detections.map((detection) => detection.label).filter(Boolean)));
-        const newLabels = Array.from(new Set(newState.detections.map((detection) => detection.label).filter(Boolean)));
-        const equalLabels = isEqual(oldLabels, newLabels, true);
-        const equalLastEventLabels = isEqual(lastEventLabels, newLabels, true);
-        if (!equalLabels && !equalLastEventLabels) {
-            if (newLabels.length) {
-                this.logger.log('Objects detected:', newLabels.join(', '));
+            catch {
+                // ignore
             }
-            else {
-                // this.logger.log('No objects detected');
+            if (oldCamera.name !== newCamera.name) {
+                this.logger.prefix = newCamera.name;
             }
-        }
-        clearTimeout(this.objectTimeout);
-        if (newState.detections.length > 0) {
-            const timeout = this.objectTimeoutDuration;
-            this.objectTimeout = setTimeout(async () => {
-                super.updateStateInternal('object', { detections: [] }, true);
-            }, timeout * 1000);
-        }
-    }
-    audioStateChange(oldState, newState) {
-        this.logger.log('Audio state changed:', newState.state);
-        clearTimeout(this.audioTimeout);
-        if (newState.state) {
-            const timeout = this.audioTimeoutDuration;
-            this.audioTimeout = setTimeout(async () => {
-                super.updateStateInternal('audio', { state: false, db: 0 }, true);
-            }, timeout * 1000);
-        }
-    }
-    doorbellStateChange(oldState, newState) {
-        this.logger.log('Doorbell state changed:', newState.state);
-        if (newState.state) {
-            super.updateStateInternal('doorbell', { state: false }, true);
-        }
-    }
-    triggerProxyEvent(stateName, newEvent, oldEvent) {
-        if (this.isCameraEvent(stateName)) {
-            this.proxyServer.publishCameraEvent(this.id, stateName, newEvent);
-        }
-        else {
-            this.proxyServer.publishCameraEvent(this.id, stateName, { newEvent, oldEvent });
-        }
-    }
-    isCameraEvent(stateName) {
-        return stateName === 'updated' || stateName === 'removed' || stateName === 'cameraState' || stateName === 'frameWorkerState' || stateName === 'capabilities';
-    }
-    clearTimers() {
-        clearTimeout(this.motionTimeout);
-        clearTimeout(this.objectTimeout);
-        clearTimeout(this.audioTimeout);
-    }
-    writeHeader() {
-        const date = new Date().toLocaleString('en-US');
-        const content = `${date}: ${this.name}`;
-        const lineLength = content.length + 3;
-        const line = '-'.repeat(lineLength);
-        this.safeWriteLog(`\n${line}\n`);
-        this.safeWriteLog(content.padEnd(lineLength));
-        this.safeWriteLog(`\n${line}\n\n`);
-    }
-    closeLogStream() {
-        clearInterval(this.truncateInterval);
-        this.logStream?.close();
-        this.logger.logStream = undefined;
-    }
-    removeLogStream() {
-        this.closeLogStream();
-        rmSync(this.logPath);
-    }
-    async disconnectRpc() {
-        await this.proxy.unregisterRPCHandler(this.namespaces.cameraControllerRpc);
-        await Promise.allSettled(Array.from(this.pluginIds).map((pluginId) => this.proxy.disconnectRPCConnection(NamespaceManager.pluginCameraNamespaces(pluginId, this.id).cameraStorageRpc)));
-        await this.cameraInterfaces.disconnect();
-    }
-    async truncateLog() {
-        if (!(await pathExists(this.logPath))) {
-            return;
-        }
-        const maxSize = 1000000; // ~1 MB
-        const truncateSize = 200000; // ~0.2 MB
-        try {
-            const logStats = await stat(this.logPath);
-            if (logStats.size < maxSize) {
-                // this.logger.debug(`Log file size is less than ${maxSize} bytes, skipping truncate`);
-                return;
+            if (oldCamera.disabled !== newCamera.disabled) {
+                if (newCamera.disabled) {
+                    this.onDisabled();
+                }
+                else {
+                    this.onEnabled();
+                }
             }
-            // this.logger.debug(`Truncating log file to ${truncateSize} bytes...`);
-            const logStartPosition = logStats.size - truncateSize;
-            const logBuffer = Buffer.alloc(truncateSize);
-            const fileHandle = await open(this.logPath, 'r+');
-            try {
-                await readPromise(fileHandle.fd, logBuffer, 0, truncateSize, logStartPosition);
-                await truncatePromise(fileHandle.fd, 0);
-                await fileHandle.write(logBuffer, 0, truncateSize, 0);
+            // Snooze only affects FrameWorker/detections.
+            if (oldCamera.detectionSettings?.snooze !== newCamera.detectionSettings?.snooze) {
+                if (newCamera.detectionSettings?.snooze) {
+                    this.onSnoozed();
+                }
+                else {
+                    this.onUnsnoozed();
+                }
             }
-            finally {
-                await fileHandle.close();
+            if (!newCamera.disabled) {
+                const oldSettings = oldCamera.snapshotSettings;
+                const newSettings = newCamera.snapshotSettings;
+                if (oldSettings.autoRefresh !== newSettings.autoRefresh || oldSettings.interval !== newSettings.interval) {
+                    if (newSettings.autoRefresh) {
+                        this.startAutoRefresh();
+                    }
+                    else {
+                        this.stopAutoRefresh();
+                    }
+                }
             }
-            // this.logger.debug('Log file truncated successfully');
-        }
-        catch (e) {
-            this.logger.error(`Failed to truncate log file: ${e.message}`);
-        }
+        });
     }
-    safeWriteLog(message) {
-        if (this.logStream?.writable) {
-            try {
-                this.logStream?.write(message);
-            }
-            catch {
-                // Ignore
-            }
-        }
+    triggerProxyEvent(stateName, data) {
+        this.proxy.publish(this.namespaces.cameraSubject, { type: stateName, data });
     }
-}
+};
 __decorate([
-    rpc({ public: true }),
+    RPCMethod,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Promise)
 ], CameraController.prototype, "connect", null);
 __decorate([
-    rpc({ public: true }),
+    RPCMethod,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Promise)
 ], CameraController.prototype, "disconnect", null);
 __decorate([
-    rpc({ public: true }),
+    RPCMethod,
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [typeof (_a = typeof T !== "undefined" && T) === "function" ? _a : Object, Object, void 0, Boolean]),
+    __metadata("design:paramtypes", [String, Boolean]),
     __metadata("design:returntype", Promise)
-], CameraController.prototype, "updateState", null);
+], CameraController.prototype, "snapshot", null);
 __decorate([
-    rpc({ public: true }),
+    RPCMethod,
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Boolean]),
+    __metadata("design:paramtypes", [String]),
     __metadata("design:returntype", Promise)
-], CameraController.prototype, "snapshot", null);
+], CameraController.prototype, "streamUrl", null);
 __decorate([
-    rpc({ public: true }),
+    RPCMethod,
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Array]),
-    __metadata("design:returntype", void 0)
-], CameraController.prototype, "addPluginCapabilities", null);
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Promise)
+], CameraController.prototype, "registerSensor", null);
 __decorate([
-    rpc({ public: true }),
+    RPCMethod,
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Array]),
+    __metadata("design:paramtypes", [String]),
     __metadata("design:returntype", void 0)
-], CameraController.prototype, "removePluginCapabilities", null);
+], CameraController.prototype, "unregisterSensor", null);
 __decorate([
-    rpc({ public: true }),
+    RPCMethod,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Object, Object]),
     __metadata("design:returntype", Promise)
 ], CameraController.prototype, "probeStream", null);
 __decorate([
-    rpc({ public: true }),
+    RPCMethod,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], CameraController.prototype, "getStreamStatus", null);
+__decorate([
+    RPCMethod,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Promise)
 ], CameraController.prototype, "refreshStates", null);
+CameraController = __decorate([
+    RPCClass,
+    __metadata("design:paramtypes", [Object, Function])
+], CameraController);
+export { CameraController };
 //# sourceMappingURL=controller.js.map