camera.ui3 0.0.30-alpha.0

package/dist/server/src/camera/index.d.ts

@@ -0,0 +1,90 @@
+import { LRUCache } from 'lru-cache';
+import { BehaviorSubject } from 'rxjs';
+import { Subscribed } from '../utils/subscribed.js';
+import type { Observable } from 'rxjs';
+import type { Camera, CameraActivitySettings, CameraFrameWorkerSettings, CameraInformation, CameraType } from '../api/database/types.js';
+import type { AudioSetEvent, AudioState, BaseLogger, BatterySetEvent, BatteryState, CameraDelegate, CameraPTZDelegate, CameraPrebufferDelegate, CameraSource, DetectionZone, DoorbellSetEvent, DoorbellState, LightSetEvent, LightState, MotionSetEvent, MotionState, ObjectSetEvent, ObjectState, SetValues, SirenSetEvent, SirenState, StateValues } from './types.js';
+export declare abstract class BaseCameraDevice extends Subscribed {
+    protected logger: BaseLogger;
+    protected snapshotCache: LRUCache<string, ArrayBuffer, unknown>;
+    protected cameraSubject: BehaviorSubject<Camera>;
+    protected cameraState: BehaviorSubject<boolean>;
+    protected lightState: BehaviorSubject<LightState>;
+    protected motionState: BehaviorSubject<MotionState>;
+    protected audioState: BehaviorSubject<AudioState>;
+    protected objectState: BehaviorSubject<ObjectState>;
+    protected doorbellState: BehaviorSubject<DoorbellState>;
+    protected sirenState: BehaviorSubject<SirenState>;
+    protected batteryState: BehaviorSubject<BatteryState>;
+    readonly onConnected: Observable<boolean>;
+    readonly onLightSwitched: Observable<LightState>;
+    readonly onMotionDetected: Observable<MotionState>;
+    readonly onAudioDetected: Observable<AudioState>;
+    readonly onObjectDetected: Observable<ObjectState>;
+    readonly onDoorbellPressed: Observable<DoorbellState>;
+    readonly onSirenDetected: Observable<SirenState>;
+    readonly onBatteryChanged: Observable<BatteryState>;
+    protected abstract cameraDelegate: CameraDelegate;
+    protected abstract ptzDelegate: CameraPTZDelegate;
+    protected abstract prebufferDelegate: CameraPrebufferDelegate;
+    protected get cameraObject(): Camera;
+    get id(): string;
+    get nativeId(): string | undefined;
+    get pluginId(): string;
+    get connected(): boolean;
+    get disabled(): boolean;
+    get name(): string;
+    get type(): CameraType;
+    get info(): CameraInformation;
+    get isCloud(): boolean;
+    get hasLight(): boolean;
+    get hasSiren(): boolean;
+    get hasBinarySensor(): boolean;
+    get hasBattery(): boolean;
+    get hasMotionDetector(): boolean;
+    get hasAudioDetector(): boolean;
+    get hasObjectDetector(): boolean;
+    get hasPtz(): boolean;
+    get hasPrebuffer(): boolean;
+    get activityZones(): DetectionZone[];
+    get activitySettings(): CameraActivitySettings;
+    get frameWorkerSettings(): CameraFrameWorkerSettings;
+    get streamSource(): CameraSource;
+    get snapshotSource(): CameraSource | undefined;
+    get highResolutionSource(): CameraSource | undefined;
+    get midResolutionSource(): CameraSource | undefined;
+    get lowResolutionSource(): CameraSource | undefined;
+    get ptz(): CameraPTZDelegate;
+    abstract get sources(): CameraSource[];
+    constructor(camera: Camera, logger: BaseLogger);
+    protected abstract cleanup(): void;
+    getValue<T extends keyof StateValues>(stateName: T): StateValues[T];
+    snapshot(forceNew?: boolean): Promise<ArrayBuffer | undefined>;
+    onStateChange<T extends keyof StateValues>(stateName: T): Observable<{
+        newState: StateValues[T];
+        oldState: StateValues[T];
+    }>;
+    onPropertyChange<T extends keyof Camera>(property: T | T[]): Observable<{
+        property: T;
+        oldData: Camera[T];
+        newData: Camera[T];
+    }>;
+    protected removeAllListeners(): void;
+    protected updateCamera(updatedCamera: Camera): void;
+    protected updateCameraState(state: boolean): void;
+    protected updateStateInternal<T extends keyof SetValues>(stateName: T, eventData: SetValues[T], skipCheck?: boolean): void;
+    protected checkStateInternal<T extends keyof SetValues>(stateName: T, event: SetValues[T]): {
+        changed: boolean;
+        event: StateValues[T];
+    };
+    protected stateChanged<T extends keyof SetValues>(oldState?: SetValues[T], newState?: SetValues[T], type?: keyof StateValues): boolean;
+    protected getAudioState(event: AudioSetEvent, ignoreLastEvet?: boolean): AudioState;
+    protected getMotionState(event: MotionSetEvent, ignoreLastEvet?: boolean): MotionState;
+    protected getObjectState(event: ObjectSetEvent, ignoreLastEvet?: boolean): ObjectState;
+    protected getDoorbellState(event: DoorbellSetEvent, ignoreLastEvet?: boolean): DoorbellState;
+    protected getLightState(event: LightSetEvent, ignoreLastEvet?: boolean): LightState;
+    protected getSirenState(event: SirenSetEvent, ignoreLastEvet?: boolean): SirenState;
+    protected getBatteryState(event: BatterySetEvent, ignoreLastEvet?: boolean): BatteryState;
+    private isStateEvent;
+    private createStateObservable;
+}

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

@@ -0,0 +1,581 @@
+import { LRUCache } from 'lru-cache';
+import { BehaviorSubject, ReplaySubject } from 'rxjs';
+import { filter, map, mergeMap, pairwise, share } from 'rxjs/operators';
+import { Subscribed } from '../utils/subscribed.js';
+import { isEqual, structuredClone } from '../utils/utils.js';
+import { mergeDetections } from './iou.js';
+import { areMotionDetectionsValid, areObjectDetectionsValid } from './polygon.js';
+export class BaseCameraDevice extends Subscribed {
+    logger;
+    snapshotCache = new LRUCache({ max: 100, ttl: 1000 * 60 * 5 });
+    cameraSubject;
+    cameraState = new BehaviorSubject(false);
+    lightState = new BehaviorSubject(this.getLightState({ state: false }, true));
+    motionState = new BehaviorSubject(this.getMotionState({ detections: [], state: false }, true));
+    audioState = new BehaviorSubject(this.getAudioState({ state: false, db: 0 }, true));
+    objectState = new BehaviorSubject(this.getObjectState({ detections: [] }, true));
+    doorbellState = new BehaviorSubject(this.getDoorbellState({ state: false }, true));
+    sirenState = new BehaviorSubject(this.getSirenState({ state: false, level: 0 }, true));
+    batteryState = new BehaviorSubject(this.getBatteryState({ level: 100, charging: false, lowBattery: false }, true));
+    onConnected = this.createStateObservable(this.cameraState);
+    onLightSwitched = this.createStateObservable(this.lightState);
+    onMotionDetected = this.createStateObservable(this.motionState);
+    onAudioDetected = this.createStateObservable(this.audioState);
+    onObjectDetected = this.createStateObservable(this.objectState);
+    onDoorbellPressed = this.createStateObservable(this.doorbellState);
+    onSirenDetected = this.createStateObservable(this.sirenState);
+    onBatteryChanged = this.createStateObservable(this.batteryState);
+    get cameraObject() {
+        return structuredClone(this.cameraSubject.getValue());
+    }
+    get id() {
+        return this.cameraSubject.getValue()._id;
+    }
+    get nativeId() {
+        return this.cameraSubject.getValue().nativeId;
+    }
+    get pluginId() {
+        return this.cameraSubject.getValue().pluginId;
+    }
+    get connected() {
+        return this.cameraState.getValue();
+    }
+    get disabled() {
+        return this.cameraSubject.getValue().disabled;
+    }
+    get name() {
+        return this.cameraSubject.getValue().name;
+    }
+    get type() {
+        return this.cameraSubject.getValue().type;
+    }
+    get info() {
+        return structuredClone(this.cameraSubject.getValue().info);
+    }
+    get isCloud() {
+        return this.cameraSubject.getValue().isCloud;
+    }
+    get hasLight() {
+        return this.cameraSubject.getValue().hasLight;
+    }
+    get hasSiren() {
+        return this.cameraSubject.getValue().hasSiren;
+    }
+    get hasBinarySensor() {
+        return this.cameraSubject.getValue().hasBinarySensor;
+    }
+    get hasBattery() {
+        return this.cameraSubject.getValue().hasBattery;
+    }
+    get hasMotionDetector() {
+        return this.cameraSubject.getValue().hasMotionDetector;
+    }
+    get hasAudioDetector() {
+        return this.cameraSubject.getValue().hasAudioDetector;
+    }
+    get hasObjectDetector() {
+        return this.cameraSubject.getValue().hasObjectDetector;
+    }
+    get hasPtz() {
+        return this.cameraSubject.getValue().hasPtz;
+    }
+    get hasPrebuffer() {
+        return this.cameraSubject.getValue().hasPrebuffer;
+    }
+    get activityZones() {
+        return structuredClone(this.cameraSubject.getValue().activityZones);
+    }
+    get activitySettings() {
+        return structuredClone(this.cameraSubject.getValue().activitySettings);
+    }
+    get frameWorkerSettings() {
+        return structuredClone(this.cameraSubject.getValue().frameWorkerSettings);
+    }
+    get streamSource() {
+        return (this.highResolutionSource || this.midResolutionSource || this.lowResolutionSource);
+    }
+    get snapshotSource() {
+        return this.sources.find((source) => source.roles.includes('snapshot'));
+    }
+    get highResolutionSource() {
+        return this.sources.find((source) => source.roles.includes('high-resolution'));
+    }
+    get midResolutionSource() {
+        return this.sources.find((source) => source.roles.includes('mid-resolution'));
+    }
+    get lowResolutionSource() {
+        return this.sources.find((source) => source.roles.includes('low-resolution'));
+    }
+    get ptz() {
+        return this.ptzDelegate;
+    }
+    constructor(camera, logger) {
+        super();
+        this.logger = logger;
+        this.cameraSubject = new BehaviorSubject(camera);
+        this.updateCamera(camera);
+        if (camera.pluginId === 'native') {
+            this.cameraState.next(true);
+        }
+    }
+    getValue(stateName) {
+        switch (stateName) {
+            case 'light':
+                return structuredClone(this.lightState.getValue());
+            case 'motion':
+                return structuredClone(this.motionState.getValue());
+            case 'audio':
+                return structuredClone(this.audioState.getValue());
+            case 'object':
+                return structuredClone(this.objectState.getValue());
+            case 'doorbell':
+                return structuredClone(this.doorbellState.getValue());
+            case 'siren':
+                return structuredClone(this.sirenState.getValue());
+            case 'battery':
+                return structuredClone(this.batteryState.getValue());
+            default:
+                throw new Error(`Unknown state: ${stateName}`);
+        }
+    }
+    async snapshot(forceNew) {
+        const source = this.snapshotSource || this.streamSource;
+        const snapshotUrl = source.urls.www.jpegSnapshot;
+        const fromCache = this.snapshotCache.get(source._id);
+        if (!forceNew && fromCache) {
+            return fromCache;
+        }
+        if (!source.roles.includes('snapshot') && this.cameraObject.pluginId !== 'native') {
+            const snapshot = await this.cameraDelegate.snapshot();
+            if (snapshot && snapshot.byteLength > 0) {
+                this.snapshotCache.set(source._id, snapshot);
+            }
+            return snapshot;
+        }
+        const response = await fetch(snapshotUrl);
+        if (!response.ok) {
+            throw new Error('Status Code: ' + response.status);
+        }
+        const snapshot = await response.arrayBuffer();
+        if (snapshot.byteLength > 0) {
+            this.snapshotCache.set(source._id, snapshot);
+        }
+        return snapshot;
+    }
+    onStateChange(stateName) {
+        const state = this[`${stateName}State`];
+        return state.pipe(pairwise(), filter(([oldState, newState]) => {
+            if (typeof oldState === 'boolean' || typeof newState === 'boolean') {
+                return oldState !== newState;
+            }
+            else {
+                return this.stateChanged(oldState, newState, stateName);
+            }
+        }), map(([oldState, newState]) => ({ oldState, newState })), share({ connector: () => new ReplaySubject(1) }));
+    }
+    onPropertyChange(property) {
+        return this.cameraSubject.pipe(pairwise(), mergeMap(([oldCamera, newCamera]) => {
+            const properties = Array.isArray(property) ? property : [property];
+            return properties.map((prop) => ({
+                property: prop,
+                oldData: oldCamera[prop],
+                newData: newCamera[prop],
+            }));
+        }), filter(({ oldData, newData }) => !isEqual(oldData, newData, true)), share({ connector: () => new ReplaySubject(1) }));
+    }
+    removeAllListeners() {
+        this.lightState.complete();
+        this.motionState.complete();
+        this.audioState.complete();
+        this.objectState.complete();
+        this.doorbellState.complete();
+        this.sirenState.complete();
+        this.batteryState.complete();
+        this.cameraSubject.complete();
+        this.cameraState.complete();
+    }
+    updateCamera(updatedCamera) {
+        this.cameraSubject.next(updatedCamera);
+    }
+    updateCameraState(state) {
+        this.cameraState.next(state);
+    }
+    updateStateInternal(stateName, eventData, skipCheck) {
+        let changed = false;
+        let event;
+        if (skipCheck) {
+            changed = true;
+            event = eventData;
+        }
+        else {
+            const states = this.checkStateInternal(stateName, eventData);
+            changed = states.changed;
+            event = states.event;
+        }
+        if (!changed) {
+            return;
+        }
+        switch (stateName) {
+            case 'light':
+                this.lightState.next(this.getLightState(event));
+                break;
+            case 'motion':
+                this.motionState.next(this.getMotionState(event));
+                break;
+            case 'audio':
+                this.audioState.next(this.getAudioState(event));
+                break;
+            case 'object':
+                this.objectState.next(this.getObjectState(event));
+                break;
+            case 'doorbell':
+                this.doorbellState.next(this.getDoorbellState(event));
+                break;
+            case 'siren':
+                this.sirenState.next(this.getSirenState(event));
+                break;
+            case 'battery':
+                this.batteryState.next(this.getBatteryState(event));
+                break;
+            default:
+                throw new Error(`Unknown state: ${stateName}`);
+        }
+    }
+    checkStateInternal(stateName, event) {
+        let changed = false;
+        let targetState;
+        switch (stateName) {
+            case 'audio':
+                const audioEvent = event;
+                targetState = this.getAudioState(audioEvent);
+                changed = this.stateChanged(this.getValue('audio'), targetState, 'audio');
+                break;
+            case 'light':
+                const lightEvent = event;
+                targetState = this.getLightState(lightEvent);
+                changed = this.stateChanged(this.getValue('light'), targetState, 'light');
+                break;
+            case 'motion':
+                const motionEvent = event;
+                if (motionEvent.state !== undefined)
+                    motionEvent.detections = [];
+                motionEvent.detections = mergeDetections(motionEvent.detections);
+                motionEvent.detections = areMotionDetectionsValid(motionEvent.detections, this.activityZones, this.activitySettings);
+                targetState = this.getMotionState(motionEvent);
+                changed = this.stateChanged(this.getValue('motion'), targetState, 'motion');
+                break;
+            case 'object':
+                const objectEvent = event;
+                objectEvent.detections = areObjectDetectionsValid(objectEvent.detections, this.activityZones, this.activitySettings);
+                targetState = this.getObjectState(objectEvent);
+                changed = this.stateChanged(this.getValue('object'), targetState, 'object');
+                break;
+            case 'doorbell':
+                const doorbellEvent = event;
+                targetState = this.getDoorbellState(doorbellEvent);
+                changed = this.stateChanged(this.getValue('doorbell'), targetState, 'doorbell');
+                break;
+            case 'siren':
+                const sirenEvent = event;
+                targetState = this.getSirenState(sirenEvent);
+                changed = this.stateChanged(this.getValue('siren'), targetState, 'siren');
+                break;
+            case 'battery':
+                const batteryEvent = event;
+                targetState = this.getBatteryState(batteryEvent);
+                changed = this.stateChanged(this.getValue('battery'), targetState, 'battery');
+                break;
+            default:
+                throw new Error(`Unknown state: ${stateName}`);
+        }
+        return { changed, event: targetState };
+    }
+    stateChanged(oldState, newState, type) {
+        if (!oldState || !newState || !type) {
+            return false;
+        }
+        if (type == 'audio') {
+            if (!this.hasAudioDetector) {
+                return false;
+            }
+            const _oldState = oldState;
+            const _newState = newState;
+            return _oldState.state !== _newState.state || _oldState.db !== _newState.db;
+        }
+        else if (type == 'motion') {
+            if (!this.hasMotionDetector) {
+                return false;
+            }
+            const _oldState = oldState;
+            const _newState = newState;
+            if (_newState.state !== undefined) {
+                return _oldState.state !== _newState.state;
+            }
+            return !isEqual(_oldState.detections, _newState.detections, true);
+        }
+        else if (type == 'object') {
+            if (!this.hasObjectDetector) {
+                return false;
+            }
+            const _oldState = oldState;
+            const _newState = newState;
+            return !isEqual(_oldState.detections, _newState.detections, true);
+        }
+        else if (type == 'siren') {
+            if (!this.hasSiren) {
+                return false;
+            }
+            const _oldState = oldState;
+            const _newState = newState;
+            return _oldState.state !== _newState.state || _oldState.level !== _newState.level;
+        }
+        else if (type == 'battery') {
+            if (!this.hasBattery) {
+                return false;
+            }
+            const _oldState = oldState;
+            const _newState = newState;
+            return _oldState.level !== _newState.level || _oldState.lowBattery !== _newState.lowBattery || _oldState.charging !== _newState.charging;
+        }
+        else if (type == 'doorbell') {
+            if (!this.hasBinarySensor) {
+                return false;
+            }
+            const _oldState = oldState;
+            const _newState = newState;
+            return _oldState.state !== _newState.state;
+        }
+        else if (type == 'light') {
+            if (!this.hasLight) {
+                return false;
+            }
+            const _oldState = oldState;
+            const _newState = newState;
+            return _oldState.state !== _newState.state;
+        }
+        else {
+            return false;
+        }
+    }
+    getAudioState(event, ignoreLastEvet = false) {
+        let lastEvent = undefined;
+        if (!ignoreLastEvet) {
+            const lastState = this.getValue('audio');
+            if (lastState.state) {
+                lastEvent = lastState;
+            }
+            else if (lastState.lastEvent?.state) {
+                lastEvent = lastState.lastEvent;
+            }
+            if (lastEvent) {
+                delete lastEvent.lastEvent;
+            }
+        }
+        let newState;
+        if (this.isStateEvent(event)) {
+            newState = event;
+        }
+        else {
+            const state = {
+                ...event,
+                timestamp: Date.now(),
+            };
+            newState = {
+                ...state,
+                db: state.db || lastEvent?.db || 0,
+                lastEvent: lastEvent ? lastEvent : state.state ? state : undefined,
+            };
+        }
+        return newState;
+    }
+    getMotionState(event, ignoreLastEvet = false) {
+        let lastEvent = undefined;
+        if (!ignoreLastEvet) {
+            const lastState = this.getValue('motion');
+            if (lastState.detections.length) {
+                lastEvent = lastState;
+            }
+            else if (lastState.lastEvent?.detections.length) {
+                lastEvent = lastState.lastEvent;
+            }
+            if (lastEvent) {
+                delete lastEvent.lastEvent;
+            }
+        }
+        let newState;
+        if (this.isStateEvent(event)) {
+            newState = event;
+        }
+        else {
+            const state = {
+                ...event,
+                timestamp: Date.now(),
+            };
+            newState = {
+                ...state,
+                lastEvent: lastEvent ? lastEvent : state.detections.length ? state : undefined,
+            };
+        }
+        return newState;
+    }
+    getObjectState(event, ignoreLastEvet = false) {
+        let lastEvent = undefined;
+        if (!ignoreLastEvet) {
+            const lastState = this.getValue('object');
+            if (lastState.detections.length) {
+                lastEvent = lastState;
+            }
+            else if (lastState.lastEvent?.detections.length) {
+                lastEvent = lastState.lastEvent;
+            }
+            if (lastEvent) {
+                delete lastEvent.lastEvent;
+            }
+        }
+        let newState;
+        if (this.isStateEvent(event)) {
+            newState = event;
+        }
+        else {
+            const state = {
+                ...event,
+                timestamp: Date.now(),
+            };
+            newState = {
+                ...state,
+                lastEvent: lastEvent ? lastEvent : state.detections.length ? state : undefined,
+            };
+        }
+        return newState;
+    }
+    getDoorbellState(event, ignoreLastEvet = false) {
+        let lastEvent = undefined;
+        if (!ignoreLastEvet) {
+            const lastState = this.getValue('doorbell');
+            if (lastState.state) {
+                lastEvent = lastState;
+            }
+            else if (lastState.lastEvent?.state) {
+                lastEvent = lastState.lastEvent;
+            }
+            if (lastEvent) {
+                delete lastEvent.lastEvent;
+            }
+        }
+        let newState;
+        if (this.isStateEvent(event)) {
+            newState = event;
+        }
+        else {
+            const state = {
+                ...event,
+                timestamp: Date.now(),
+            };
+            newState = {
+                ...state,
+                lastEvent: lastEvent ? lastEvent : state.state ? state : undefined,
+            };
+        }
+        return newState;
+    }
+    getLightState(event, ignoreLastEvet = false) {
+        let lastEvent = undefined;
+        if (!ignoreLastEvet) {
+            const lastState = this.getValue('light');
+            if (lastState.state) {
+                lastEvent = lastState;
+            }
+            else if (lastState.lastEvent?.state) {
+                lastEvent = lastState.lastEvent;
+            }
+            if (lastEvent) {
+                delete lastEvent.lastEvent;
+            }
+        }
+        let newState;
+        if (this.isStateEvent(event)) {
+            newState = event;
+        }
+        else {
+            const state = {
+                ...event,
+                timestamp: Date.now(),
+            };
+            newState = {
+                ...state,
+                lastEvent: lastEvent ? lastEvent : state.state ? state : undefined,
+            };
+        }
+        return newState;
+    }
+    getSirenState(event, ignoreLastEvet = false) {
+        let lastEvent = undefined;
+        if (!ignoreLastEvet) {
+            const lastState = this.getValue('siren');
+            if (lastState.state) {
+                lastEvent = lastState;
+            }
+            else if (lastState.lastEvent?.state) {
+                lastEvent = lastState.lastEvent;
+            }
+            if (lastEvent) {
+                delete lastEvent.lastEvent;
+            }
+        }
+        let newState;
+        if (this.isStateEvent(event)) {
+            newState = event;
+        }
+        else {
+            const state = {
+                ...event,
+                timestamp: Date.now(),
+            };
+            newState = {
+                ...state,
+                level: state.level || lastEvent?.level || 0,
+                lastEvent: lastEvent ? lastEvent : state.state ? state : undefined,
+            };
+        }
+        return newState;
+    }
+    getBatteryState(event, ignoreLastEvet = false) {
+        let lastEvent = undefined;
+        if (!ignoreLastEvet) {
+            const lastState = this.getValue('battery');
+            if (this.stateChanged(lastState, event, 'battery')) {
+                lastEvent = lastState;
+            }
+            else if (lastState.lastEvent && this.stateChanged(lastState.lastEvent, event, 'battery')) {
+                lastEvent = lastState.lastEvent;
+            }
+            if (lastEvent) {
+                delete lastEvent.lastEvent;
+            }
+        }
+        let newState;
+        if (this.isStateEvent(event)) {
+            newState = event;
+        }
+        else {
+            const state = {
+                ...event,
+                timestamp: Date.now(),
+            };
+            newState = {
+                ...state,
+                charging: event.charging || lastEvent?.charging || false,
+                lowBattery: event.lowBattery || lastEvent?.lowBattery || false,
+                lastEvent: lastEvent || state,
+            };
+        }
+        return newState;
+    }
+    isStateEvent(state) {
+        return 'timestamp' in state;
+    }
+    createStateObservable(stateSubject) {
+        return stateSubject.pipe(share({ connector: () => new ReplaySubject(1) }));
+    }
+}
+//# sourceMappingURL=index.js.map