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

package/src/camera/controller.ts

@@ -0,0 +1,579 @@
+import { generateSdp } from '@camera.ui/common/camera';
+import { createSourceName, isEqual } 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 { container } from 'tsyringe';
+import { Agent } from 'undici';
+import { PLUGIN_STATUS } from '../plugins/types.js';
+import { NamespaceManager } from '../rpc/namespaces.js';
+import { CameraDevice } from './device.js';
+import { CameraInterface } from './interfaces.js';
+
+import { API_EVENT } from '../api.js';
+import { FrameWorker } from './frameWorker.js';
+import { SessionController } from './session.js';
+import { generateAudioStreamInfo, generateVideoStreamInfo } from './utils.js';
+
+import type { Logger } from '@camera.ui/common/logger';
+import type { Promisify, RPCBase } from '@camera.ui/rpc-common';
+import type {
+  AudioState,
+  AudioStreamInfo,
+  Camera,
+  CameraDeviceCapability,
+  CameraDeviceSource,
+  DeviceStorage,
+  DoorbellState,
+  MotionSetEvent,
+  MotionState,
+  ObjectState,
+  ProbeConfig,
+  ProbeStream,
+  SetValues,
+  StateValues,
+  VideoStreamInfo,
+} from '@camera.ui/types';
+import type { WriteStream } from 'node:fs';
+import type { BehaviorSubject, Subscription } from 'rxjs';
+import type { CameraUiAPI } from '../api.js';
+import type { Go2RtcApi } from '../api/go2rtc/index.js';
+import type { ProxyServer } from '../rpc/index.js';
+import type { CameraNamespaces, FrameWorkerNamespaces } from '../rpc/namespaces.js';
+import type { CameraDeviceListenerMessagePayload, RefreshedStates } from '../rpc/types.js';
+import type { ConfigService } from '../services/config/index.js';
+import type { CameraDeviceInterface, PluginCapabilities } from './types.js';
+
+const truncatePromise = promisify(ftruncate);
+const readPromise = promisify(read);
+
+export class CameraController extends CameraDevice implements CameraDeviceInterface {
+  public readonly frameWorker: FrameWorker;
+  public readonly sessionController: SessionController;
+  public readonly streamInfos = new Map<string, ProbeStream>();
+  public readonly logStream?: WriteStream;
+
+  protected cameraInterfaces: CameraInterface;
+  protected initialized = true;
+
+  private proxy: RPCBase;
+  private namespaces: CameraNamespaces & FrameWorkerNamespaces;
+
+  private motionTimeout?: NodeJS.Timeout;
+  private objectTimeout?: NodeJS.Timeout;
+  private objectTimeoutDuration = 5;
+  private audioTimeout?: NodeJS.Timeout;
+  private audioTimeoutDuration = 5;
+  private blockMotionResetEvents = false;
+
+  private proxyServer: ProxyServer;
+  private go2rtcApi: Go2RtcApi;
+  private configService: ConfigService;
+  private api: CameraUiAPI;
+
+  private truncateInterval?: NodeJS.Timeout;
+  private truncateIntervalMs: number = 1000 * 60 * 60 * 2;
+
+  private pluginIds = new Set<string>();
+
+  get logPath(): string {
+    return join(this.configService.LOGS_PATH, `camera-${this.id}.log`);
+  }
+
+  get streamSource(): CameraDeviceSource {
+    return (this.highResolutionSource ?? this.midResolutionSource ?? this.lowResolutionSource)!;
+  }
+
+  get camera(): Camera {
+    return this.cameraObject;
+  }
+
+  constructor(camera: Camera, logger: Logger) {
+    const proxyServer = container.resolve<ProxyServer>('proxy');
+    const namespaces = {
+      ...NamespaceManager.cameraNamespaces(camera._id),
+      ...NamespaceManager.frameWorkerNamespaces(camera._id),
+    };
+
+    super(camera, proxyServer.proxy, namespaces, logger);
+
+    this.proxyServer = proxyServer;
+    this.api = container.resolve<CameraUiAPI>('api');
+    this.go2rtcApi = container.resolve<Go2RtcApi>('go2rtcApi');
+    this.configService = container.resolve<ConfigService>('configService');
+
+    this.logStream = createWriteStream(this.logPath, { flags: 'a' });
+    this.writeHeader();
+
+    this.truncateInterval = setInterval(() => this.truncateLog(), this.truncateIntervalMs);
+    this.truncateLog();
+
+    (this.logger as Logger).logStream = this.logStream;
+    this.proxy = this.proxyServer.proxy;
+
+    this.frameWorker = new FrameWorker(this);
+    this.sessionController = new SessionController(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 as Logger).prefix = this.camera.name;
+      }),
+    );
+
+    this.api.setMaxListeners(this.api.getMaxListeners() + 1);
+    this.api.once(API_EVENT.SHUTDOWN, () => {
+      this.cleanup();
+    });
+  }
+
+  public async init(): Promise<void> {
+    await this.proxy.registerRPCHandler(this.namespaces.cameraControllerRpc, this);
+    await this.frameWorker.start();
+    this.sessionController.start(this.sources);
+  }
+
+  public extend(): void {
+    throw new Error('Method not implemented.');
+  }
+
+  public addCapabilities(): void {
+    throw new Error('Method not implemented.');
+  }
+
+  public removeCapabilities(): void {
+    throw new Error('Method not implemented.');
+  }
+
+  @rpc({ public: true })
+  public async connect(): Promise<void> {
+    this.cameraState.next(true);
+  }
+
+  @rpc({ public: true })
+  public async disconnect(): Promise<void> {
+    this.cameraState.next(false);
+  }
+
+  @rpc({ public: true })
+  public async updateState<T extends keyof SetValues>(stateName: T, eventData: SetValues[T], frame?: undefined, override?: boolean): Promise<void> {
+    if (!override && stateName === 'motion' && this.blockMotionResetEvents && !(eventData as MotionSetEvent).state) {
+      (eventData as MotionSetEvent).state = true;
+      (eventData as MotionSetEvent).detections = [];
+    }
+
+    super.updateStateInternal(stateName as any, eventData as any);
+  }
+
+  @rpc({ public: true })
+  public async snapshot(sourceId: string, forceNew?: boolean): Promise<ArrayBuffer | undefined> {
+    const fromCache = this.snapshotCache.get(sourceId);
+    if (!forceNew && fromCache) {
+      return fromCache;
+    }
+
+    try {
+      if (this.cameraObject.pluginId !== 'native') {
+        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 snapshotUrl = source.urls.snapshot.jpeg;
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 5000);
+
+      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,
+          },
+        }),
+      });
+      clearTimeout(timeout);
+
+      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;
+    } catch (error) {
+      this.logger.error('Error while fetching snapshot', error);
+    }
+  }
+
+  @rpc({ public: true })
+  public addPluginCapabilities(pluginId: string, capabilities: CameraDeviceCapability[]): void {
+    super.addCapabilitiesInternal(pluginId, capabilities);
+  }
+
+  @rpc({ public: true })
+  public removePluginCapabilities(pluginId: string, capabilities: CameraDeviceCapability[] = []): void {
+    super.removeCapabilitiesInternal(pluginId, capabilities);
+  }
+
+  @rpc({ public: true })
+  public async probeStream(sourceId: string, probeConfig?: ProbeConfig, refresh = false): Promise<ProbeStream | undefined> {
+    let streamInfo = this.streamInfos.get(sourceId);
+    if (streamInfo && !refresh) {
+      return Promise.resolve(streamInfo);
+    }
+
+    const cameraSource = this.sources.find((source) => source._id === sourceId);
+    if (!cameraSource) {
+      return;
+    }
+
+    try {
+      const src = createSourceName(this.name, cameraSource?.name);
+      const probe = await this.go2rtcApi.streamsApi.probeStreamSource({ src }, probeConfig);
+
+      const videoStreamInfo: VideoStreamInfo[] = generateVideoStreamInfo(probe.producers);
+      const audioStreamInfo: AudioStreamInfo[] = generateAudioStreamInfo(probe.producers);
+      const sdp = generateSdp(videoStreamInfo, audioStreamInfo);
+
+      streamInfo = {
+        sdp,
+        video: videoStreamInfo,
+        audio: audioStreamInfo,
+      };
+
+      this.streamInfos.set(sourceId, streamInfo);
+    } catch (err) {
+      this.logger.error('Error while probing stream source', err);
+    }
+
+    return streamInfo;
+  }
+
+  @rpc({ public: true })
+  public async refreshStates(): Promise<RefreshedStates> {
+    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'),
+      },
+    };
+  }
+
+  public updateCamera(updatedCamera: Camera): void {
+    super.updateCamera(updatedCamera);
+    this.sessionController.start(this.sources);
+  }
+
+  public updateFrameWorkerState(state: boolean): void {
+    super.updateFrameWorkerState(state);
+  }
+
+  public async cleanup(): Promise<void> {
+    await this.frameWorker.close();
+    this.sessionController.stop();
+    this.closeLogStream();
+    this.removeAllListeners();
+    this.unsubscribe();
+    this.clearTimers();
+    await this.disconnectRpc();
+  }
+
+  public async stop(): Promise<void> {
+    await this.cleanup();
+    this.removeLogStream();
+    this.triggerProxyEvent('removed');
+  }
+
+  public writeLog(...args: any[]): void {
+    this.safeWriteLog(args.join(' ').replace(/\r?\n*$/, '\n'));
+  }
+
+  public async storageProxy(pluginId: string): Promise<Promisify<DeviceStorage>> {
+    this.pluginIds.add(pluginId);
+    const namespaces = NamespaceManager.pluginCameraNamespaces(pluginId, this.id);
+    return this.proxy.createRPCProxy<DeviceStorage>(namespaces.cameraStorageRpc);
+  }
+
+  private subscribeToCameraState(): Subscription {
+    return this.cameraState
+      .pipe(
+        pairwise(),
+        filter(([oldState, newState]) => oldState !== newState),
+      )
+      .subscribe(([, newState]) => this.triggerProxyEvent('cameraState', newState));
+  }
+
+  private subscribeToFrameWorkerState(): Subscription {
+    return this.frameWorkerState
+      .pipe(
+        pairwise(),
+        filter(([oldState, newState]) => oldState !== newState),
+      )
+      .subscribe(([, newState]) => this.triggerProxyEvent('frameWorkerState', newState));
+  }
+
+  private subscribeToCameraChanges(): Subscription {
+    return this.cameraSubject
+      .pipe(
+        pairwise(),
+        filter(([oldCamera, newCamera]) => !isEqual(oldCamera, newCamera, true)),
+      )
+      .subscribe(([, newCamera]) => this.triggerProxyEvent('updated', newCamera));
+  }
+
+  private subscribeToCapabilityChanges(): Subscription {
+    return this.capabilities
+      .pipe(
+        pairwise(),
+        filter(([oldCapabilities, newCapabilities]) => !isEqual(oldCapabilities, newCapabilities, true)),
+      )
+      .subscribe(([, newCapabilities]) => {
+        this.triggerProxyEvent('capabilities', newCapabilities);
+      });
+  }
+
+  private subscribeToStateChanges<T extends keyof StateValues>(stateName: T, stateSubject: BehaviorSubject<StateValues[T]>): Subscription {
+    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 as MotionState, newState as MotionState);
+            break;
+          case 'object':
+            this.objectStateChange(oldState as ObjectState, newState as ObjectState);
+            break;
+          case 'audio':
+            this.audioStateChange(oldState as AudioState, newState as AudioState);
+            break;
+          case 'doorbell':
+            this.doorbellStateChange(oldState as DoorbellState, newState as DoorbellState);
+            break;
+        }
+      });
+  }
+
+  private motionStateChange(oldState: MotionState, newState: MotionState): void {
+    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;
+        }
+      }
+    }
+  }
+
+  private objectStateChange(oldState: ObjectState, newState: ObjectState): void {
+    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(', '));
+      } else {
+        // this.logger.log('No objects detected');
+      }
+    }
+
+    clearTimeout(this.objectTimeout);
+
+    if (newState.detections.length > 0) {
+      const timeout = this.objectTimeoutDuration;
+      this.objectTimeout = setTimeout(async () => {
+        super.updateStateInternal('object', { detections: [] }, true);
+      }, timeout * 1000);
+    }
+  }
+
+  private audioStateChange(oldState: AudioState, newState: AudioState): void {
+    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);
+    }
+  }
+
+  private doorbellStateChange(oldState: DoorbellState, newState: DoorbellState): void {
+    this.logger.log('Doorbell state changed:', newState.state);
+
+    if (newState.state) {
+      super.updateStateInternal('doorbell', { state: false }, true);
+    }
+  }
+
+  private triggerProxyEvent(stateName: CameraDeviceListenerMessagePayload['type'], newEvent?: Camera | PluginCapabilities[] | boolean): void;
+  private triggerProxyEvent<T extends keyof StateValues>(stateName: T, newEvent: StateValues[T], oldEvent: StateValues[T]): void;
+  private triggerProxyEvent(
+    stateName: keyof StateValues | CameraDeviceListenerMessagePayload['type'],
+    newEvent?: StateValues[keyof StateValues] | Camera | PluginCapabilities[] | boolean,
+    oldEvent?: StateValues[keyof StateValues] | Camera,
+  ): void {
+    if (this.isCameraEvent(stateName as CameraDeviceListenerMessagePayload['type'])) {
+      this.proxyServer.publishCameraEvent(this.id, stateName as CameraDeviceListenerMessagePayload['type'], newEvent);
+    } else {
+      this.proxyServer.publishCameraEvent(this.id, stateName as any, { newEvent, oldEvent });
+    }
+  }
+
+  private isCameraEvent(stateName: CameraDeviceListenerMessagePayload['type']): stateName is CameraDeviceListenerMessagePayload['type'] {
+    return stateName === 'updated' || stateName === 'removed' || stateName === 'cameraState' || stateName === 'frameWorkerState' || stateName === 'capabilities';
+  }
+
+  private clearTimers(): void {
+    clearTimeout(this.motionTimeout);
+    clearTimeout(this.objectTimeout);
+    clearTimeout(this.audioTimeout);
+  }
+
+  private writeHeader(): void {
+    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`);
+  }
+
+  private closeLogStream(): void {
+    clearInterval(this.truncateInterval);
+    this.logStream?.close();
+    (this.logger as Logger).logStream = undefined;
+  }
+
+  private removeLogStream(): void {
+    this.closeLogStream();
+    rmSync(this.logPath);
+  }
+
+  private async disconnectRpc(): Promise<void> {
+    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();
+  }
+
+  private async truncateLog(): Promise<void> {
+    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;
+      }
+
+      // 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);
+      } finally {
+        await fileHandle.close();
+      }
+
+      // this.logger.debug('Log file truncated successfully');
+    } catch (e) {
+      this.logger.error(`Failed to truncate log file: ${e.message}`);
+    }
+  }
+
+  private safeWriteLog(message: string): void {
+    if (this.logStream?.writable) {
+      try {
+        this.logStream?.write(message);
+      } catch {
+        // Ignore
+      }
+    }
+  }
+}