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

package/src/camera/controller.ts

@@ -1,579 +0,0 @@
-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
-      }
-    }
-  }
-}