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

package/src/api/services/cameras.service.ts

@@ -0,0 +1,671 @@
+import { createSourceName, isEqual, mergeWith } from '@camera.ui/common/utils';
+import TTLCache from '@isaacs/ttlcache';
+import { container, delay, registry } from 'tsyringe';
+
+import { CAMERA_EXTENSIONS } from '../../plugins/types.js';
+import { ConfigService } from '../../services/config/index.js';
+import { Database } from '../database/index.js';
+import { PluginsService } from './plugins.service.js';
+import { UsersService } from './users.service.js';
+
+import type {
+  Camera,
+  CameraExtension,
+  CameraInputSettings,
+  CameraSource,
+  DetectionZone,
+  Go2RtcRTSPSource,
+  Go2RtcSnapshotSource,
+  Go2RtcWSSource,
+  ProbeConfig,
+} from '@camera.ui/types';
+import type { CameraUiAPI } from '../../api.js';
+import type { DeepPartial } from '../../types.js';
+import type { DBCamera } from '../database/types.js';
+import type { Go2RtcApi } from '../go2rtc/index.js';
+import type { CreateStreamData, DeviceSource, DeviceSourceType, Go2RTCProbe } from '../go2rtc/types.js';
+
+const cameraSourceProbeCache = new TTLCache<string, Go2RTCProbe>({ max: 100, ttl: Infinity });
+
+@registry([
+  {
+    token: 'dbs',
+    useValue: delay(() => Database),
+  },
+])
+export class CamerasService {
+  private configService: ConfigService;
+  private api: CameraUiAPI;
+  private dbs: Database;
+  private go2rtcApi: Go2RtcApi;
+
+  private usersService: UsersService;
+  private pluginsService: PluginsService;
+
+  constructor() {
+    this.configService = container.resolve<ConfigService>('configService');
+    this.api = container.resolve<CameraUiAPI>('api');
+    this.dbs = container.resolve<Database>('dbs');
+    this.go2rtcApi = container.resolve<Go2RtcApi>('go2rtcApi');
+
+    this.usersService = new UsersService();
+    this.pluginsService = new PluginsService();
+  }
+
+  public async createCamera(cameraData: DBCamera): Promise<DBCamera> {
+    const cameras = this.dbs.camerasDB.get('cameras') ?? [];
+
+    const plugin = this.pluginsService.getPluginById(cameraData.pluginId);
+    if (plugin) {
+      plugin.contract.extensions.forEach((extensionType) => {
+        if (extensionType !== 'hub') {
+          cameraData.extensions[extensionType] = {
+            id: plugin.id,
+            name: plugin.pluginName,
+          };
+        } else {
+          cameraData.extensions[extensionType] ??= [];
+          cameraData.extensions[extensionType].push({
+            id: plugin.id,
+            name: plugin.pluginName,
+          });
+        }
+      });
+    }
+
+    await this.addCameraSourcesToConfig(cameraData._id, cameraData.name, cameraData.sources);
+
+    cameras.push(cameraData);
+    await this.dbs.camerasDB.put('cameras', cameras);
+
+    const transformedCamera = this.transformCamera(cameraData);
+    await this.api.addCamera(transformedCamera);
+
+    return cameraData;
+  }
+
+  public async patchZones(cameraname: string, zoneData: DetectionZone[]): Promise<DBCamera | undefined> {
+    const cameras = this.dbs.camerasDB.get('cameras') ?? [];
+    const camera = cameras.find((camera) => camera.name === cameraname);
+
+    if (camera) {
+      camera.detectionZones = zoneData;
+      await this.dbs.camerasDB.put('cameras', cameras);
+      this.api.updateCamera(this.transformCamera(camera));
+    }
+
+    return camera;
+  }
+
+  public list(): DBCamera[] {
+    const cameras = this.dbs.camerasDB.get('cameras') ?? [];
+    return cameras;
+  }
+
+  public async discoverCameras(type?: DeviceSourceType, src?: string): Promise<{ sources: DeviceSource[] }> {
+    switch (type?.toLowerCase()) {
+      case 'homekit':
+        return this.go2rtcApi.discoverApi.discoverHomekit();
+      case 'onvif':
+        return this.go2rtcApi.discoverApi.discoverOnvif(src ? { src } : undefined);
+      case 'hass':
+        return this.go2rtcApi.discoverApi.discoverHass();
+      case 'gopro':
+        return this.go2rtcApi.discoverApi.discoverGopro();
+      case 'ffmpeg':
+        return this.go2rtcApi.discoverApi.discoverFFmpeg();
+      case 'dvrip':
+        return this.go2rtcApi.discoverApi.discoverDvrip();
+      case 'webtorrent':
+        return this.go2rtcApi.discoverApi.discoverWebtorrent();
+      default:
+        return this.go2rtcApi.discoverApi.discoverSources();
+    }
+  }
+
+  public listTransformed(): Camera[] {
+    const cameras = this.dbs.camerasDB.get('cameras') ?? [];
+    const transformedCameras = cameras.map((camera) => this.transformCamera(camera));
+    return transformedCameras;
+  }
+
+  public listByPluginId(pluginId: string): DBCamera[] {
+    const cameras = this.dbs.camerasDB.get('cameras') ?? [];
+    return cameras.filter((camera) => camera.pluginId === pluginId);
+  }
+
+  public listTransformedByPluginId(pluginId: string): Camera[] {
+    const cameras = this.dbs.camerasDB.get('cameras') ?? [];
+    const filteredCameras = cameras.filter((camera) => camera.pluginId === pluginId);
+    const transformedCameras = filteredCameras.map((camera) => this.transformCamera(camera));
+    return transformedCameras;
+  }
+
+  public listByExtension(pluginName: string): DBCamera[] {
+    const cameras = this.dbs.camerasDB.get('cameras') ?? [];
+    return cameras.filter((camera) => camera.extensions.plugins.some((p) => p.name === pluginName));
+  }
+
+  public listTransformedByExtension(pluginName: string, extensions: CameraExtension[]): Camera[] {
+    const cameras = this.dbs.camerasDB.get('cameras') ?? [];
+    const camerasMap = new Map<string, Camera>();
+
+    for (const type of extensions) {
+      let dbCameras: DBCamera[] = [];
+
+      if (type === 'hub') {
+        dbCameras = cameras.filter((camera) => camera.extensions[type]?.some((p) => p.name === pluginName));
+      } else {
+        dbCameras = cameras.filter((camera) => camera.extensions[type]?.name === pluginName);
+      }
+
+      dbCameras.forEach((camera) => camerasMap.set(camera._id, this.transformCamera(camera)));
+    }
+
+    return Array.from(camerasMap.values());
+  }
+
+  public findById(id: string): DBCamera | undefined {
+    const cameras = this.dbs.camerasDB.get('cameras') ?? [];
+    return cameras?.find((cameraObj) => cameraObj._id === id);
+  }
+
+  public findTransformedById(id: string): Camera | undefined {
+    const cameras = this.dbs.camerasDB.get('cameras') ?? [];
+    const camera = cameras?.find((cameraObj) => cameraObj._id === id);
+
+    if (camera) {
+      return this.transformCamera(camera);
+    }
+  }
+
+  public findByName(cameraname: string): DBCamera | undefined {
+    const cameras = this.dbs.camerasDB.get('cameras') ?? [];
+    return cameras?.find((cameraObj) => cameraObj.name === cameraname);
+  }
+
+  public findTransformedByName(cameraname: string): Camera | undefined {
+    const cameras = this.dbs.camerasDB.get('cameras') ?? [];
+    const camera = cameras?.find((cameraObj) => cameraObj.name === cameraname);
+
+    if (camera) {
+      return this.transformCamera(camera);
+    }
+  }
+
+  public findByPluginAndName(cameraname: string, pluginId: string): DBCamera | undefined {
+    const cameras = this.dbs.camerasDB.get('cameras') ?? [];
+    return cameras?.find((cameraObj) => cameraObj.name === cameraname && cameraObj.pluginId === pluginId);
+  }
+
+  public findTransformedByPluginAndName(cameraname: string, pluginId: string): Camera | undefined {
+    const cameras = this.dbs.camerasDB.get('cameras') ?? [];
+    const camera = cameras?.find((cameraObj) => cameraObj.name === cameraname && cameraObj.pluginId === pluginId);
+
+    if (camera) {
+      return this.transformCamera(camera);
+    }
+  }
+
+  public async patchCameraByName(cameraname: string, cameraData: DeepPartial<DBCamera>): Promise<DBCamera | undefined> {
+    const cameras = this.dbs.camerasDB.get('cameras') ?? [];
+    const camera = cameras.find((camera) => camera.name === cameraname);
+    const cameraController = this.api.getCamera(camera?._id ?? '');
+    const cameraOld = structuredClone(camera);
+
+    if (camera && cameraOld) {
+      mergeWith(camera, cameraData, (source: any[], target: any, key) => {
+        if (key === 'sources') {
+          return (target as CameraInputSettings[]).map((srcItem) => {
+            const objItem: CameraInputSettings | undefined = source.find((o: any) => o.name === srcItem.name);
+            const sourceId = objItem?._id ?? srcItem._id;
+            return objItem ? { ...objItem, ...srcItem, _id: sourceId, name: objItem.name } : srcItem;
+          });
+        }
+
+        if (key === 'extensions') {
+          return cameraOld.extensions;
+        }
+
+        if (Array.isArray(source)) {
+          return target;
+        }
+      });
+
+      if (!isEqual(cameraOld, camera, true)) {
+        if (cameraOld.name !== camera.name) {
+          await this.removeCameraSourcesFromConfig(cameraOld.name, cameraOld.sources);
+        }
+
+        const orphanedSources = cameraOld.sources.filter((source) => !camera.sources.find((s) => s.name === source.name));
+        await this.removeCameraSourcesFromConfig(camera.name, orphanedSources);
+      }
+
+      await this.addCameraSourcesToConfig(camera._id, camera.name, camera.sources);
+      await this.dbs.camerasDB.put('cameras', cameras);
+
+      const sourcesChanged = !isEqual(cameraOld.sources, camera.sources, true);
+      if (sourcesChanged) {
+        cameraController?.streamInfos.clear();
+      }
+
+      this.api.updateCamera(this.transformCamera(camera));
+    }
+
+    return camera;
+  }
+
+  public async enableExtensionByName(cameraname: string, pluginNameOrId: string, extensionType: CameraExtension): Promise<DBCamera | undefined> {
+    const cameras = this.dbs.camerasDB.get('cameras') ?? [];
+    const plugin = this.pluginsService.getPluginByName(pluginNameOrId) ?? this.pluginsService.getPluginById(pluginNameOrId);
+    const camera = cameras.find((camera) => camera.name === cameraname);
+    const cameraOld = structuredClone(camera);
+
+    if (camera && cameraOld && plugin) {
+      if (
+        CAMERA_EXTENSIONS.includes(extensionType) &&
+        extensionType !== 'hub' &&
+        extensionType !== 'cameraController' &&
+        camera.extensions[extensionType]?.name !== plugin.pluginName &&
+        camera.extensions.plugins.some((p) => p.name === plugin.pluginName)
+      ) {
+        const oldExtension = camera.extensions[extensionType]?.name;
+        const oldPlugin = oldExtension ? this.pluginsService.getPluginByName(oldExtension) : undefined;
+
+        camera.extensions[extensionType] = {
+          id: plugin.id,
+          name: plugin.pluginName,
+        };
+
+        const transformedCamera = this.transformCamera(camera);
+
+        await this.dbs.camerasDB.put('cameras', cameras);
+
+        if (oldPlugin && oldExtension) {
+          await this.api.deselectCamera(oldPlugin.id, transformedCamera, extensionType);
+        }
+
+        this.api.updateCamera(transformedCamera);
+        await this.api.selectCamera(plugin.id, transformedCamera, extensionType);
+      }
+    }
+
+    return camera;
+  }
+
+  public async disableExtensionByName(cameraname: string, pluginNameOrId: string, extensionType: CameraExtension): Promise<DBCamera | undefined> {
+    const cameras = this.dbs.camerasDB.get('cameras') ?? [];
+    const plugin = this.pluginsService.getPluginByName(pluginNameOrId) ?? this.pluginsService.getPluginById(pluginNameOrId);
+    const camera = cameras.find((camera) => camera.name === cameraname);
+    const cameraOld = structuredClone(camera);
+
+    if (camera && cameraOld && plugin) {
+      if (
+        CAMERA_EXTENSIONS.includes(extensionType) &&
+        extensionType !== 'hub' &&
+        extensionType !== 'cameraController' &&
+        camera.extensions[extensionType]?.name === plugin.pluginName &&
+        camera.extensions.plugins.some((p) => p.name === plugin.pluginName)
+      ) {
+        camera.extensions[extensionType] = undefined;
+
+        const transformedCamera = this.transformCamera(camera);
+
+        await this.dbs.camerasDB.put('cameras', cameras);
+        await this.api.deselectCamera(plugin.id, transformedCamera, extensionType);
+        this.api.updateCamera(transformedCamera);
+
+        setTimeout(() => {
+          this.api.resetCameraState(camera._id, extensionType);
+        }, 100);
+      }
+    }
+
+    return camera;
+  }
+
+  public async addExtensionByName(cameraname: string, pluginNameOrId: string, extension: CameraExtension): Promise<DBCamera | undefined> {
+    const cameras = this.dbs.camerasDB.get('cameras') ?? [];
+    const plugin = this.pluginsService.getPluginByName(pluginNameOrId) ?? this.pluginsService.getPluginById(pluginNameOrId);
+    const camera = cameras.find((camera) => camera.name === cameraname);
+    const cameraOld = structuredClone(camera);
+
+    if (camera && cameraOld && plugin && !camera.extensions.plugins.some((p) => p.name === plugin.pluginName)) {
+      camera.extensions.plugins.push({
+        id: plugin.id,
+        name: plugin.pluginName,
+      });
+
+      const addedExtensions: CameraExtension[] = [];
+
+      if (extension !== 'hub') {
+        if (!camera.extensions[extension]) {
+          camera.extensions[extension] = {
+            id: plugin.id,
+            name: plugin.pluginName,
+          };
+          addedExtensions.push(extension);
+        }
+      } else {
+        camera.extensions[extension] ??= [];
+        camera.extensions[extension].push({
+          id: plugin.id,
+          name: plugin.pluginName,
+        });
+        addedExtensions.push(extension);
+      }
+
+      const transformedCamera = this.transformCamera(camera);
+
+      await this.dbs.camerasDB.put('cameras', cameras);
+      this.api.updateCamera(transformedCamera);
+      await Promise.allSettled(addedExtensions.map((extensionType) => this.api.selectCamera(plugin.id, transformedCamera, extensionType)));
+    }
+
+    return camera;
+  }
+
+  public async removeExtensionByName(cameraname: string, pluginNameOrId: string, extension: CameraExtension): Promise<DBCamera | undefined> {
+    const cameras = this.dbs.camerasDB.get('cameras') ?? [];
+    const plugin = this.pluginsService.getPluginByName(pluginNameOrId) ?? this.pluginsService.getPluginById(pluginNameOrId);
+    const camera = cameras.find((camera) => camera.name === cameraname);
+    const cameraOld = structuredClone(camera);
+
+    if (camera && cameraOld && plugin && camera.extensions.plugins.some((p) => p.name === plugin.pluginName)) {
+      camera.extensions.plugins = camera.extensions.plugins.filter((p) => p.name !== plugin.pluginName);
+
+      const removedExtensions = new Set<CameraExtension>();
+
+      if (extension !== 'hub') {
+        if (camera.extensions[extension]?.name === plugin.pluginName) {
+          camera.extensions[extension] = undefined;
+          removedExtensions.add(extension);
+        }
+      } else {
+        camera.extensions[extension] ??= [];
+        camera.extensions[extension] = camera.extensions[extension].filter((p) => p.name !== plugin.pluginName);
+        removedExtensions.add(extension);
+      }
+
+      const transformedCamera = this.transformCamera(camera);
+
+      await this.dbs.camerasDB.put('cameras', cameras);
+      await Promise.allSettled(Array.from(removedExtensions).map((extensionType) => this.api.deselectCamera(plugin.id, transformedCamera, extensionType)));
+      this.api.updateCamera(transformedCamera);
+    }
+
+    return camera;
+  }
+
+  public async removeExtension(pluginNameOrId: string, extension: CameraExtension): Promise<void> {
+    const cameras = this.dbs.camerasDB.get('cameras') ?? [];
+
+    for (const camera of cameras) {
+      const plugin = this.pluginsService.getPluginByName(pluginNameOrId) ?? this.pluginsService.getPluginById(pluginNameOrId);
+
+      if (plugin && camera.extensions.plugins.some((p) => p.name === plugin.pluginName)) {
+        camera.extensions.plugins = camera.extensions.plugins.filter((p) => p.name !== plugin.pluginName);
+
+        const removedExtensions = new Set<CameraExtension>();
+
+        if (extension !== 'hub') {
+          if (camera.extensions[extension]?.name === plugin.pluginName) {
+            camera.extensions[extension] = undefined;
+            removedExtensions.add(extension);
+          }
+        } else {
+          camera.extensions[extension] ??= [];
+          camera.extensions[extension] = camera.extensions[extension].filter((p) => p.name !== plugin.pluginName);
+          removedExtensions.add(extension);
+        }
+
+        const transformedCamera = this.transformCamera(camera);
+        await this.dbs.camerasDB.put('cameras', cameras);
+        await Promise.allSettled(Array.from(removedExtensions).map((extensionType) => this.api.deselectCamera(plugin.id, transformedCamera, extensionType)));
+        this.api.updateCamera(this.transformCamera(camera));
+      }
+    }
+  }
+
+  public async removeByName(cameraname: string): Promise<void> {
+    let cameras = this.dbs.camerasDB.get('cameras') ?? [];
+    const camera = cameras.find((cameraObj) => cameraObj.name === cameraname);
+
+    if (camera) {
+      cameras = cameras.filter((cameraObj) => cameraObj.name !== camera.name);
+
+      for (const source of camera.sources) {
+        cameraSourceProbeCache.delete(source._id);
+      }
+
+      await this.usersService.removeCameraFromPreferences(camera._id);
+      await this.dbs.camerasDB.put('cameras', cameras);
+      await this.removeCameraSourcesFromConfig(camera.name, camera.sources);
+      await this.api.removeCamera(this.transformCamera(camera), camera.extensions);
+    }
+  }
+
+  public async removeById(id: string): Promise<void> {
+    let cameras = this.dbs.camerasDB.get('cameras') ?? [];
+    const camera = cameras.find((cameraObj) => cameraObj._id === id);
+
+    if (camera) {
+      cameras = cameras.filter((cameraObj) => cameraObj.name !== camera.name);
+
+      for (const source of camera.sources) {
+        cameraSourceProbeCache.delete(source._id);
+      }
+
+      await this.usersService.removeCameraFromPreferences(camera._id);
+      await this.dbs.camerasDB.put('cameras', cameras);
+      await this.removeCameraSourcesFromConfig(camera.name, camera.sources);
+      await this.api.removeCamera(this.transformCamera(camera), camera.extensions);
+    }
+  }
+
+  public async removeByPluginName(pluginName: string): Promise<void> {
+    const plugin = this.pluginsService.getPluginDbByName(pluginName);
+
+    if (plugin) {
+      await this.removeByPluginId(plugin._id);
+    }
+  }
+
+  public async removeByPluginId(pluginId: string): Promise<void> {
+    let cameras = this.dbs.camerasDB.get('cameras') ?? [];
+    const camera = cameras.find((cameraObj) => cameraObj.pluginId === pluginId);
+
+    if (camera) {
+      cameras = cameras.filter((cameraObj) => cameraObj._id !== camera._id);
+
+      for (const source of camera.sources) {
+        cameraSourceProbeCache.delete(source._id);
+      }
+
+      await this.usersService.removeCameraFromPreferences(camera._id);
+      await this.dbs.camerasDB.put('cameras', cameras);
+      await this.removeCameraSourcesFromConfig(camera.name, camera.sources);
+      await this.api.removeCamera(this.transformCamera(camera), camera.extensions);
+    }
+  }
+
+  public async removeByPluginIdAndName(cameraname: string, pluginId: string): Promise<void> {
+    let cameras = this.dbs.camerasDB.get('cameras') ?? [];
+    const camera = cameras.find((cameraObj) => cameraObj.name === cameraname && cameraObj.pluginId === pluginId);
+
+    if (camera) {
+      cameras = cameras.filter((cameraObj) => cameraObj._id !== camera._id);
+
+      for (const source of camera.sources) {
+        cameraSourceProbeCache.delete(source._id);
+      }
+
+      await this.usersService.removeCameraFromPreferences(camera._id);
+      await this.dbs.camerasDB.put('cameras', cameras);
+      await this.removeCameraSourcesFromConfig(camera.name, camera.sources);
+      await this.api.removeCamera(this.transformCamera(camera), camera.extensions);
+    }
+  }
+
+  public async removeAll(): Promise<void> {
+    let cameras = this.dbs.camerasDB.get('cameras') ?? [];
+    const camerasToRemove: DBCamera[] = [];
+
+    cameras.forEach((camera) => camerasToRemove.push(camera));
+    cameras = [];
+
+    cameraSourceProbeCache.clear();
+    await this.usersService.resetAllPreferences();
+    await this.dbs.camerasDB.put('cameras', cameras);
+    await Promise.all(camerasToRemove.map((camera) => this.removeCameraSourcesFromConfig(camera.name, camera.sources)));
+    await Promise.all(camerasToRemove.map((camera) => this.api.removeCamera(this.transformCamera(camera), camera.extensions)));
+  }
+
+  public async probeCameraSource(camera: DBCamera, source: CameraSource, probeData?: ProbeConfig): Promise<Go2RTCProbe> {
+    cameraSourceProbeCache.purgeStale();
+
+    const inCache = cameraSourceProbeCache.get(source._id);
+
+    if (inCache) {
+      return inCache;
+    }
+
+    const src = createSourceName(camera.name, source.name);
+    const probe = await this.go2rtcApi.streamsApi.probeStreamSource({ src }, probeData);
+
+    cameraSourceProbeCache.set(source._id, probe);
+    return probe;
+  }
+
+  public transformCamera(camera: DBCamera): Camera {
+    const transformedCamera: Camera = {
+      ...camera,
+      sources: camera.sources.map((source) => ({
+        _id: source._id,
+        name: source.name,
+        role: source.role,
+        useForSnapshot: source.useForSnapshot,
+        hotMode: source.hotMode,
+        urls: {
+          ws: this.generateWsUrls(camera, source),
+          rtsp: this.generateRTSPUrls(camera, source),
+          snapshot: this.generateSnapshotUrls(camera, source),
+        },
+      })),
+    };
+
+    return transformedCamera;
+  }
+
+  private async addCameraSourcesToConfig(cameraId: string, cameraname: string, sources: CameraInputSettings[]): Promise<void> {
+    for (const source of sources) {
+      source.urls = source.urls.map((url) => {
+        if (url.startsWith('cui://')) {
+          url = `cui://127.0.0.1:${this.configService.config.port}/api/cameras/streams/${cameraId}/${source.name}`;
+        }
+        return url;
+      });
+
+      const sourceName = createSourceName(cameraname, source.name);
+      const ffmpegUrl = `ffmpeg:${sourceName}#cameraui#audio=pcma#audio=opus#audio=aac`;
+      const baseUrls = [...source.urls];
+      const cameraSources: CreateStreamData[] = [];
+
+      const hasFFmpegUrl = baseUrls.some((url) => url.startsWith('ffmpeg:') && url.includes('#cameraui'));
+      if (!hasFFmpegUrl && source.role !== 'snapshot') {
+        baseUrls.push(ffmpegUrl);
+      }
+
+      if (!this.sourceExistAndEqual(sourceName, baseUrls)) {
+        cameraSources.push({ name: sourceName, src: baseUrls });
+      }
+
+      this.configService.go2rtcConfig.streams ??= {};
+
+      for (const sourceData of cameraSources) {
+        await this.go2rtcApi.streamsApi.createStream({
+          name: sourceData.name,
+          src: sourceData.src,
+        });
+
+        this.configService.go2rtcConfig.streams[sourceData.name] = sourceData.src;
+      }
+    }
+  }
+
+  private async removeCameraSourcesFromConfig(cameraname: string, oldSources: CameraInputSettings[]): Promise<void> {
+    for (const source of oldSources) {
+      const sourceName = createSourceName(cameraname, source.name);
+      const sourcesToRemove: string[] = [];
+
+      if (this.configService.go2rtcConfig.streams?.[sourceName]) {
+        sourcesToRemove.push(sourceName);
+      }
+
+      this.configService.go2rtcConfig.streams ??= {};
+
+      for (const src of sourcesToRemove) {
+        await this.go2rtcApi.streamsApi.deleteStream({ src });
+        delete this.configService.go2rtcConfig.streams?.[src];
+      }
+
+      if (Object.keys(this.configService.go2rtcConfig.streams).length === 0) {
+        delete this.configService.go2rtcConfig.streams;
+        await this.configService.writeGo2RtcConfigApi();
+      }
+    }
+  }
+
+  private sourceExistAndEqual(sourceName: string, source: string[]): boolean {
+    if (this.configService.go2rtcConfig.streams?.[sourceName]) {
+      let configSource = this.configService.go2rtcConfig.streams[sourceName];
+      configSource = typeof configSource === 'string' ? [configSource] : configSource;
+      return isEqual(configSource, source, true);
+    }
+
+    return false;
+  }
+
+  private generateWsUrls(camera: DBCamera, source: CameraInputSettings): Go2RtcWSSource {
+    const sourceName = createSourceName(camera.name, source.name);
+    const go2rtcAddress = this.configService.go2rtcAddress('ws');
+    const baseWebRtcUrl = `${go2rtcAddress}/api/ws?src=${sourceName}`;
+
+    return {
+      webrtc: baseWebRtcUrl,
+      mse: baseWebRtcUrl,
+    };
+  }
+
+  private generateRTSPUrls(camera: DBCamera, source: CameraInputSettings): Go2RtcRTSPSource {
+    const sourceName = createSourceName(camera.name, source.name);
+    const go2rtcAddress = this.configService.go2rtcAddress('rtsp');
+    const onvifAddress = this.configService.go2rtcAddress('onvif');
+    const baseRtspUrl = `${go2rtcAddress}/${sourceName}`;
+    const baseOnvifUrl = `${onvifAddress}/${sourceName}`;
+
+    return {
+      base: baseRtspUrl,
+      default: `${baseRtspUrl}?video&audio&backchannel=1&timeout=15`,
+      muted: `${baseRtspUrl}?video&timeout=15`,
+      aac: `${baseRtspUrl}?video&audio=aac&backchannel=1&timeout=15`,
+      opus: `${baseRtspUrl}?video&audio=opus&backchannel=1&timeout=15`,
+      pcma: `${baseRtspUrl}?video&audio=pcma&backchannel=1&timeout=15`,
+      onvif: baseOnvifUrl,
+    };
+  }
+
+  private generateSnapshotUrls(camera: DBCamera, source: CameraInputSettings): Go2RtcSnapshotSource {
+    const sourceName = createSourceName(camera.name, source.name);
+    const go2rtcAddress = this.configService.go2rtcAddress('api');
+    const baseMjpegStreamUrl = `${go2rtcAddress}/api/stream.mjpeg?src=${sourceName}`;
+    const baseFrameMp4StreamUrl = `${go2rtcAddress}/api/frame.mp4?src=${sourceName}`;
+    const baseFrameJpegStreamUrl = `${go2rtcAddress}/api/frame.jpeg?src=${sourceName}`;
+
+    return {
+      mp4: baseFrameMp4StreamUrl,
+      jpeg: baseFrameJpegStreamUrl,
+      mjpeg: baseMjpegStreamUrl,
+    };
+  }
+}