@camera.ui/server 0.0.49 → 0.0.50-internal.0

package/src/camera/index.ts

@@ -0,0 +1,679 @@
+import { Subscribed, isEqual, structuredClone } from '@camera.ui/common/utils';
+import { CameraDeviceCapability } from '@camera.ui/types';
+import TTLCache from '@isaacs/ttlcache';
+import { BehaviorSubject, ReplaySubject } from 'rxjs';
+import { distinctUntilChanged, filter, map, mergeMap, pairwise, share } from 'rxjs/operators';
+
+import { transformLabels } from './classes.js';
+import { mergeDetections } from './iou.js';
+import { areDetectionsValid } from './polygon.js';
+
+import type {
+  AudioSetEvent,
+  AudioState,
+  BatterySetEvent,
+  BatteryState,
+  Camera,
+  CameraDetectionSettings,
+  CameraFrameWorkerSettings,
+  CameraInformation,
+  CameraSource,
+  CameraType,
+  DetectionZone,
+  DoorbellSetEvent,
+  DoorbellState,
+  LightSetEvent,
+  LightState,
+  LoggerService,
+  MotionSetEvent,
+  MotionState,
+  ObjectSetEvent,
+  ObjectState,
+  SetValues,
+  SirenSetEvent,
+  SirenState,
+  StateValues,
+} from '@camera.ui/types';
+import type { Observable } from 'rxjs';
+import type { CameraInterfaces, PluginCapabilities, Sets, States } from './types.js';
+
+export abstract class BaseCameraDevice extends Subscribed {
+  public readonly logger: LoggerService;
+
+  protected snapshotCache: TTLCache<string, ArrayBuffer>;
+
+  // Internal
+  public readonly cameraSubject: BehaviorSubject<Camera>;
+  public readonly cameraState = new BehaviorSubject<boolean>(false);
+  public readonly frameWorkerState = new BehaviorSubject<boolean>(false);
+  public readonly lightState = new BehaviorSubject<LightState>(this.#getLightState({ state: false }, true));
+  public readonly motionState = new BehaviorSubject<MotionState>(this.#getMotionState({ detections: [], state: false }, true));
+  public readonly audioState = new BehaviorSubject<AudioState>(this.#getAudioState({ state: false, db: 0 }, true));
+  public readonly objectState = new BehaviorSubject<ObjectState>(this.#getObjectState({ detections: [] }, true));
+  public readonly doorbellState = new BehaviorSubject<DoorbellState>(this.#getDoorbellState({ state: false }, true));
+  public readonly sirenState = new BehaviorSubject<SirenState>(this.#getSirenState({ state: false, level: 0 }, true));
+  public readonly batteryState = new BehaviorSubject<BatteryState>(this.#getBatteryState({ level: 100, charging: false, lowBattery: false }, true));
+  public readonly capabilities = new BehaviorSubject<PluginCapabilities[]>([]);
+
+  public readonly onConnected = this.#createStateObservable(this.cameraState);
+  public readonly onFrameWorkerConnected = this.#createStateObservable(this.frameWorkerState);
+  public readonly onLightSwitched = this.#createStateObservable(this.lightState);
+  public readonly onMotionDetected = this.#createStateObservable(this.motionState);
+  public readonly onAudioDetected = this.#createStateObservable(this.audioState);
+  public readonly onObjectDetected = this.#createStateObservable(this.objectState);
+  public readonly onDoorbellPressed = this.#createStateObservable(this.doorbellState);
+  public readonly onSirenDetected = this.#createStateObservable(this.sirenState);
+  public readonly onBatteryChanged = this.#createStateObservable(this.batteryState);
+
+  protected abstract cameraInterfaces: CameraInterfaces;
+
+  protected get cameraObject(): Camera {
+    return structuredClone(this.cameraSubject.getValue());
+  }
+
+  get id(): string {
+    return this.cameraSubject.getValue()._id;
+  }
+
+  get nativeId(): string | undefined {
+    return this.cameraSubject.getValue().nativeId;
+  }
+
+  get pluginId(): string {
+    return this.cameraSubject.getValue().pluginId;
+  }
+
+  get connected(): boolean {
+    return this.cameraState.getValue();
+  }
+
+  get frameWorkerConnected(): boolean {
+    return this.frameWorkerState.getValue();
+  }
+
+  get disabled(): boolean {
+    return this.cameraSubject.getValue().disabled;
+  }
+
+  get name(): string {
+    return this.cameraSubject.getValue().name;
+  }
+
+  get type(): CameraType {
+    return this.cameraSubject.getValue().type;
+  }
+
+  get info(): CameraInformation {
+    return structuredClone(this.cameraSubject.getValue().info);
+  }
+
+  get isCloud(): boolean {
+    return this.cameraSubject.getValue().isCloud;
+  }
+
+  get hasLight(): boolean {
+    return this.hasCapability(CameraDeviceCapability.Light);
+  }
+
+  get hasSiren(): boolean {
+    return this.hasCapability(CameraDeviceCapability.Siren);
+  }
+
+  get hasDoorbell(): boolean {
+    return this.hasCapability(CameraDeviceCapability.Doorbell);
+  }
+
+  get hasBattery(): boolean {
+    return this.hasCapability(CameraDeviceCapability.Battery);
+  }
+
+  get hasAudioDetector(): boolean {
+    return this.hasCapability(CameraDeviceCapability.AudioSensor);
+  }
+
+  get hasMotionDetector(): boolean {
+    return this.hasCapability(CameraDeviceCapability.MotionSensor) || this.hasCapability(CameraDeviceCapability.MotionDetector);
+  }
+
+  get hasObjectDetector(): boolean {
+    return this.hasCapability(CameraDeviceCapability.ObjectSensor) || this.hasCapability(CameraDeviceCapability.ObjectDetector);
+  }
+
+  get hasPtz(): boolean {
+    return this.hasCapability(CameraDeviceCapability.PTZ);
+  }
+
+  get snapshotTTL(): number {
+    return this.cameraSubject.getValue().snapshotTTL;
+  }
+
+  get detectionZones(): DetectionZone[] {
+    return structuredClone(this.cameraSubject.getValue().detectionZones);
+  }
+
+  get detectionSettings(): CameraDetectionSettings {
+    return structuredClone(this.cameraSubject.getValue().detectionSettings);
+  }
+
+  get frameWorkerSettings(): CameraFrameWorkerSettings {
+    return structuredClone(this.cameraSubject.getValue().frameWorkerSettings);
+  }
+
+  get streamSource(): CameraSource {
+    return (this.highResolutionSource ?? this.midResolutionSource ?? this.lowResolutionSource)!;
+  }
+
+  get snapshotSource(): CameraSource | undefined {
+    return this.sources.find((source) => source.role == 'snapshot') ?? this.sources.find((source) => source.useForSnapshot);
+  }
+
+  get highResolutionSource(): CameraSource | undefined {
+    return this.sources.find((source) => source.role === 'high-resolution');
+  }
+
+  get midResolutionSource(): CameraSource | undefined {
+    return this.sources.find((source) => source.role === 'mid-resolution');
+  }
+
+  get lowResolutionSource(): CameraSource | undefined {
+    return this.sources.find((source) => source.role === 'low-resolution');
+  }
+
+  get interfaces(): CameraInterfaces {
+    return this.cameraInterfaces;
+  }
+
+  abstract get sources(): CameraSource[];
+
+  constructor(camera: Camera, logger: LoggerService) {
+    super();
+
+    this.logger = logger;
+    this.cameraSubject = new BehaviorSubject(camera);
+
+    this.snapshotCache = new TTLCache({
+      max: 100,
+      ttl: this.snapshotTTL * 1000,
+    });
+
+    if (camera.pluginId === 'native') {
+      this.cameraState.next(true);
+    }
+  }
+
+  public getCapabilities(): CameraDeviceCapability[] {
+    return structuredClone(
+      this.capabilities
+        .getValue()
+        .map((capability) => capability.capabilities)
+        .flat(),
+    );
+  }
+
+  public hasCapability(capability: CameraDeviceCapability): boolean {
+    const capabilities = this.getCapabilities();
+    return capabilities.some((cap) => cap === capability);
+  }
+
+  public getValue<T extends keyof StateValues>(stateName: T): StateValues[T] {
+    switch (stateName) {
+      case 'light':
+        return structuredClone(this.lightState.getValue()) as StateValues[T];
+      case 'motion':
+        return structuredClone(this.motionState.getValue()) as StateValues[T];
+      case 'audio':
+        return structuredClone(this.audioState.getValue()) as StateValues[T];
+      case 'object':
+        return structuredClone(this.objectState.getValue()) as StateValues[T];
+      case 'doorbell':
+        return structuredClone(this.doorbellState.getValue()) as StateValues[T];
+      case 'siren':
+        return structuredClone(this.sirenState.getValue()) as StateValues[T];
+      case 'battery':
+        return structuredClone(this.batteryState.getValue()) as StateValues[T];
+      default:
+        throw new Error(`Unknown state: ${stateName}`);
+    }
+  }
+
+  public onStateChange<T extends keyof StateValues>(stateName: T): Observable<{ newState: StateValues[T]; oldState: StateValues[T] }> {
+    const state = this[`${stateName}State`] as unknown as BehaviorSubject<StateValues[T]>;
+
+    return state.pipe(
+      pairwise(),
+      filter(([oldState, newState]) => {
+        return this.stateChanged(oldState, newState, stateName);
+      }),
+      map(([oldState, newState]) => ({ oldState, newState })),
+      share({ connector: () => new ReplaySubject(1) }),
+    );
+  }
+
+  public onPropertyChange<T extends keyof Camera>(property: T | T[]): Observable<{ property: T; oldData: Camera[T]; newData: Camera[T] }> {
+    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) }),
+    );
+  }
+
+  public onCapabilitiesChange(): Observable<{ oldCapabilities: CameraDeviceCapability[]; newCapabilities: CameraDeviceCapability[] }> {
+    return this.capabilities.pipe(
+      pairwise(),
+      filter(([oldCapabilities, newCapabilities]) => !isEqual(oldCapabilities, newCapabilities, true)),
+      map(([oldCapabilities, newCapabilities]) => ({
+        oldCapabilities: oldCapabilities.map((capability) => capability.capabilities).flat(),
+        newCapabilities: newCapabilities.map((capability) => capability.capabilities).flat(),
+      })),
+      share({ connector: () => new ReplaySubject(1) }),
+    );
+  }
+
+  protected abstract cleanup(): void;
+
+  protected removeAllListeners(): void {
+    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();
+    this.frameWorkerState.complete();
+    this.capabilities.complete();
+    this.snapshotCache.clear();
+  }
+
+  protected updateCamera(updatedCamera: Camera): void {
+    if (updatedCamera.snapshotTTL !== this.snapshotTTL) {
+      this.snapshotCache.clear();
+    }
+
+    this.cameraSubject.next(updatedCamera);
+  }
+
+  protected updateCameraState(state: boolean): void {
+    this.cameraState.next(state);
+  }
+
+  protected updateFrameWorkerState(state: boolean): void {
+    this.frameWorkerState.next(state);
+  }
+
+  protected updateCapabilities(capabilities: PluginCapabilities[]): void {
+    this.capabilities.next(capabilities);
+  }
+
+  protected updateStateInternal<T extends keyof SetValues>(stateName: T, eventData: SetValues[T], skipCheck?: boolean, skipDetectionsCheck?: boolean): void {
+    let changed = false;
+    let event: SetValues[T];
+
+    if (skipCheck) {
+      changed = true;
+      event = eventData;
+    } else {
+      const states = this.checkStateInternal(stateName, eventData, skipDetectionsCheck);
+      changed = states.changed;
+      event = states.event;
+    }
+
+    if (!changed) {
+      return;
+    }
+
+    switch (stateName) {
+      case 'light':
+        this.lightState.next(this.#getLightState(event as LightSetEvent));
+        break;
+      case 'motion':
+        this.motionState.next(this.#getMotionState(event as MotionSetEvent));
+        break;
+      case 'audio':
+        this.audioState.next(this.#getAudioState(event as AudioSetEvent));
+        break;
+      case 'object':
+        this.objectState.next(this.#getObjectState(event as ObjectSetEvent));
+        break;
+      case 'doorbell':
+        this.doorbellState.next(this.#getDoorbellState(event as DoorbellSetEvent));
+        break;
+      case 'siren':
+        this.sirenState.next(this.#getSirenState(event as SirenSetEvent));
+        break;
+      case 'battery':
+        this.batteryState.next(this.#getBatteryState(event as BatterySetEvent));
+        break;
+    }
+  }
+
+  protected checkStateInternal<T extends keyof SetValues>(stateName: T, event: SetValues[T], skipDetectionsCheck?: boolean): { changed: boolean; event: StateValues[T] } {
+    let changed = false;
+    let targetState: any;
+
+    switch (stateName) {
+      case 'audio':
+        const audioEvent = event as AudioSetEvent;
+        targetState = this.#getAudioState(audioEvent);
+        changed = this.stateChanged(this.getValue('audio'), targetState, 'audio');
+        break;
+      case 'light':
+        const lightEvent = event as LightSetEvent;
+        targetState = this.#getLightState(lightEvent);
+        changed = this.stateChanged(this.getValue('light'), targetState, 'light');
+        break;
+      case 'motion':
+        const motionEvent = event as MotionSetEvent;
+        if (!motionEvent.state) {
+          motionEvent.detections = [];
+        }
+
+        if (!skipDetectionsCheck && motionEvent.detections) {
+          const hasDetections = motionEvent.detections.length > 0;
+          motionEvent.detections = transformLabels(motionEvent.detections);
+          motionEvent.detections = mergeDetections(motionEvent.detections);
+          motionEvent.detections = areDetectionsValid(motionEvent.detections, this.detectionZones, this.detectionSettings);
+          if (hasDetections && motionEvent.detections.length === 0) {
+            motionEvent.state = false;
+          }
+        }
+        targetState = this.#getMotionState(motionEvent);
+        changed = this.stateChanged(this.getValue('motion'), targetState, 'motion');
+        break;
+      case 'object':
+        const objectEvent = event as ObjectSetEvent;
+        if (!skipDetectionsCheck) {
+          objectEvent.detections = transformLabels(objectEvent.detections);
+          objectEvent.detections = mergeDetections(objectEvent.detections);
+          objectEvent.detections = areDetectionsValid(objectEvent.detections, this.detectionZones, this.detectionSettings);
+        }
+        targetState = this.#getObjectState(objectEvent);
+        changed = this.stateChanged(this.getValue('object'), targetState, 'object');
+        break;
+      case 'doorbell':
+        const doorbellEvent = event as DoorbellSetEvent;
+        targetState = this.#getDoorbellState(doorbellEvent);
+        changed = this.stateChanged(this.getValue('doorbell'), targetState, 'doorbell');
+        break;
+      case 'siren':
+        const sirenEvent = event as SirenSetEvent;
+        targetState = this.#getSirenState(sirenEvent);
+        changed = this.stateChanged(this.getValue('siren'), targetState, 'siren');
+        break;
+      case 'battery':
+        const batteryEvent = event as BatterySetEvent;
+        targetState = this.#getBatteryState(batteryEvent);
+        changed = this.stateChanged(this.getValue('battery'), targetState, 'battery');
+        break;
+      default:
+        throw new Error(`Unknown state: ${stateName}`);
+    }
+
+    return { changed, event: targetState };
+  }
+
+  protected stateChanged<T extends keyof SetValues>(oldState?: SetValues[T], newState?: SetValues[T], type?: keyof StateValues): boolean {
+    if (oldState === undefined || newState === undefined || type === undefined) {
+      return false;
+    }
+
+    if (type === 'audio' && !this.hasAudioDetector) {
+      return false;
+    } else if (type === 'motion' && !this.hasMotionDetector) {
+      return false;
+    } else if (type === 'object' && !this.hasObjectDetector) {
+      return false;
+    } else if (type === 'siren' && !this.hasSiren) {
+      return false;
+    } else if (type === 'battery' && !this.hasBattery) {
+      return false;
+    } else if (type === 'doorbell' && !this.hasDoorbell) {
+      return false;
+    } else if (type === 'light' && !this.hasLight) {
+      return false;
+    }
+
+    const cleanOldState = this.#cleanState(oldState);
+    const cleanNewState = this.#cleanState(newState);
+
+    return !isEqual(cleanOldState, cleanNewState, true);
+  }
+
+  #getAudioState(event: AudioSetEvent, ignoreLastEvet = false): AudioState {
+    let lastEvent: AudioState | undefined = undefined;
+
+    if (!ignoreLastEvet) {
+      lastEvent = this.getValue('audio');
+      if (lastEvent && lastEvent.lastEvent) {
+        delete lastEvent.lastEvent;
+      }
+    }
+
+    let newState: AudioState;
+
+    if (this.#isStateEvent(event)) {
+      newState = event;
+    } else {
+      const state = {
+        ...event,
+        timestamp: Date.now(),
+      };
+
+      newState = {
+        ...state,
+        db: state.db ?? lastEvent?.db ?? 0,
+        lastEvent: lastEvent,
+      };
+    }
+
+    return newState;
+  }
+
+  #getMotionState(event: MotionSetEvent, ignoreLastEvet = false): MotionState {
+    let lastEvent: MotionState | undefined = undefined;
+
+    if (!ignoreLastEvet) {
+      lastEvent = this.getValue('motion');
+      if (lastEvent?.lastEvent) {
+        delete lastEvent.lastEvent;
+      }
+    }
+
+    let newState: MotionState;
+
+    if (this.#isStateEvent(event)) {
+      newState = event;
+    } else {
+      const state = {
+        ...event,
+        timestamp: Date.now(),
+      };
+
+      newState = {
+        ...state,
+        lastEvent: lastEvent,
+      };
+    }
+
+    return newState;
+  }
+
+  #getObjectState(event: ObjectSetEvent, ignoreLastEvet = false): ObjectState {
+    let lastEvent: ObjectState | undefined = undefined;
+
+    if (!ignoreLastEvet) {
+      lastEvent = this.getValue('object');
+      if (lastEvent && lastEvent.lastEvent) {
+        delete lastEvent.lastEvent;
+      }
+    }
+
+    let newState: ObjectState;
+
+    if (this.#isStateEvent(event)) {
+      newState = event;
+    } else {
+      const state = {
+        ...event,
+        timestamp: Date.now(),
+      };
+
+      newState = {
+        ...state,
+        lastEvent: lastEvent,
+      };
+    }
+
+    return newState;
+  }
+
+  #getDoorbellState(event: DoorbellSetEvent, ignoreLastEvet = false): DoorbellState {
+    let lastEvent: DoorbellState | undefined = undefined;
+
+    if (!ignoreLastEvet) {
+      lastEvent = this.getValue('doorbell');
+      if (lastEvent && lastEvent.lastEvent) {
+        delete lastEvent.lastEvent;
+      }
+    }
+
+    let newState: DoorbellState;
+
+    if (this.#isStateEvent(event)) {
+      newState = event;
+    } else {
+      const state = {
+        ...event,
+        timestamp: Date.now(),
+      };
+
+      newState = {
+        ...state,
+        lastEvent: lastEvent,
+      };
+    }
+
+    return newState;
+  }
+
+  #getLightState(event: LightSetEvent, ignoreLastEvet = false): LightState {
+    let lastEvent: LightState | undefined = undefined;
+
+    if (!ignoreLastEvet) {
+      lastEvent = this.getValue('light');
+      if (lastEvent && lastEvent.lastEvent) {
+        delete lastEvent.lastEvent;
+      }
+    }
+
+    let newState: LightState;
+
+    if (this.#isStateEvent(event)) {
+      newState = event;
+    } else {
+      const state = {
+        ...event,
+        timestamp: Date.now(),
+      };
+
+      newState = {
+        ...state,
+        lastEvent: lastEvent,
+      };
+    }
+
+    return newState;
+  }
+
+  #getSirenState(event: SirenSetEvent, ignoreLastEvet = false): SirenState {
+    let lastEvent: SirenState | undefined = undefined;
+
+    if (!ignoreLastEvet) {
+      lastEvent = this.getValue('siren');
+      if (lastEvent && lastEvent.lastEvent) {
+        delete lastEvent.lastEvent;
+      }
+    }
+
+    let newState: SirenState;
+
+    if (this.#isStateEvent(event)) {
+      newState = event;
+    } else {
+      const state = {
+        ...event,
+        timestamp: Date.now(),
+      };
+
+      newState = {
+        ...state,
+        level: state.level ?? lastEvent?.level ?? 0,
+        lastEvent: lastEvent,
+      };
+    }
+
+    return newState;
+  }
+
+  #getBatteryState(event: BatterySetEvent, ignoreLastEvet = false): BatteryState {
+    let lastEvent: BatteryState | undefined = undefined;
+
+    if (!ignoreLastEvet) {
+      lastEvent = this.getValue('battery');
+      if (lastEvent && lastEvent.lastEvent) {
+        delete lastEvent.lastEvent;
+      }
+    }
+
+    let newState: BatteryState;
+
+    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,
+      };
+    }
+
+    return newState;
+  }
+
+  #cleanState<T extends keyof StateValues>(state: StateValues[T] | SetValues[T]): SetValues[T] {
+    const stateCopy = structuredClone(state) as any;
+
+    if ('timestamp' in stateCopy) {
+      delete stateCopy.timestamp;
+    }
+
+    if ('lastEvent' in stateCopy) {
+      delete stateCopy.lastEvent;
+    }
+
+    return stateCopy;
+  }
+
+  #isStateEvent(state: States | Sets): state is States {
+    return 'timestamp' in state;
+  }
+
+  #createStateObservable<T extends States | boolean | Camera>(stateSubject: BehaviorSubject<T>): Observable<T> {
+    return stateSubject.pipe(distinctUntilChanged(), share({ connector: () => new ReplaySubject(1) }));
+  }
+}