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

package/src/plugins/runtime/node/pluginApi.ts

@@ -1,27 +0,0 @@
-import { EventEmitter } from 'node:events';
-
-import { CoreManagerProxy } from './proxy/coreManager.js';
-import { DeviceManagerProxy } from './proxy/deviceManager.js';
-import { StorageController } from './storageController.js';
-
-import type { Logger } from '@camera.ui/common';
-import type { ClientInstance } from '@camera.ui/rpc-client';
-import type { PluginAPI as PluginAPIInterface } from '@camera.ui/types';
-import type { RootDatabase } from 'lmdb';
-import type { PluginInfo } from '../../types.js';
-
-export class PluginAPI extends EventEmitter implements PluginAPIInterface {
-  readonly coreManager: CoreManagerProxy;
-  readonly deviceManager: DeviceManagerProxy;
-  readonly storageController: StorageController;
-  readonly storagePath: string;
-
-  constructor(proxy: ClientInstance, plugin: PluginInfo, storagePath: string, logger: Logger, pluginDb: RootDatabase<Record<string, any>, 'config'>) {
-    super();
-
-    this.storagePath = storagePath;
-    this.storageController = new StorageController(this, proxy, plugin, pluginDb);
-    this.coreManager = new CoreManagerProxy(proxy, this, plugin);
-    this.deviceManager = new DeviceManagerProxy(proxy, this, this.storageController, plugin, logger);
-  }
-}

package/src/plugins/runtime/node/proxy/cameraDevice.ts

@@ -1,299 +0,0 @@
-import { CameraDeviceCapability } from '@camera.ui/types';
-
-import { API_EVENT } from '../../../../api.js';
-import { CameraDevice } from '../../../../camera/device.js';
-import { CameraInterface } from '../../../../camera/interfaces.js';
-import { NamespaceManager } from '../../../../rpc/namespaces.js';
-
-import type { Logger } from '@camera.ui/common';
-import type { ClientInstance } from '@camera.ui/rpc-client';
-import type { Message, Promisify, SubscriptionWrapper } from '@camera.ui/rpc-common';
-import type {
-  Camera,
-  MotionDetectionFrame,
-  MotionSetEvent,
-  ProbeConfig,
-  PTZInterface,
-  SetValues,
-  SnapshotInterface,
-  StateValues,
-  StreamingInterface,
-} from '@camera.ui/types';
-import type { EventEmitter } from 'node:events';
-import type { CameraDeviceInterface } from '../../../../camera/types.js';
-import type { VideoFrame } from '../../../../camera/videoFrame.js';
-import type { CameraNamespaces, FrameWorkerNamespaces, PluginCameraNamespaces } from '../../../../rpc/namespaces.js';
-import type { CameraDeviceListenerMessagePayload, CameraDeviceListenerStatePayload, RefreshedStates } from '../../../../rpc/types.js';
-import type { PluginInfo } from '../../../types.js';
-import type { PluginAPI } from '../pluginApi.js';
-
-export class CameraDeviceProxy extends CameraDevice {
-  protected cameraInterfaces: CameraInterface;
-  protected initialized = false;
-
-  #proxy: ClientInstance;
-  #namespaces: CameraNamespaces & FrameWorkerNamespaces & PluginCameraNamespaces;
-
-  #api: EventEmitter;
-  #plugin: PluginInfo;
-  #subscription?: SubscriptionWrapper;
-
-  constructor(proxy: ClientInstance, api: PluginAPI, camera: Camera, plugin: PluginInfo, logger: Logger) {
-    const namespaces = {
-      ...NamespaceManager.cameraNamespaces(camera._id),
-      ...NamespaceManager.frameWorkerNamespaces(camera._id),
-      ...NamespaceManager.pluginCameraNamespaces(plugin.id, camera._id),
-    };
-
-    super(camera, proxy, namespaces, logger);
-
-    this.#api = api;
-    this.#plugin = plugin;
-    this.#proxy = proxy;
-    this.#namespaces = namespaces;
-
-    this.cameraInterfaces = new CameraInterface(this.#proxy, this.capabilities, this.id, this.pluginId);
-
-    this.#api.once(API_EVENT.SHUTDOWN, this.cleanup.bind(this));
-    this.#api.setMaxListeners(this.#api.getMaxListeners() + 1);
-
-    this.addSubscriptions(
-      this.onPropertyChange('name').subscribe(() => {
-        (this.logger as Logger).suffix = this.name;
-      }),
-    );
-  }
-
-  public async init(): Promise<void> {
-    if (this.initialized) {
-      return;
-    }
-
-    this.initialized = true;
-
-    this.#subscription = this.#proxy.subscribe<CameraDeviceListenerStatePayload<keyof StateValues> | CameraDeviceListenerMessagePayload>(
-      this.#namespaces.cameraSubject,
-      this.#onEventMessage.bind(this),
-    );
-
-    await this.#proxy.registerRPCHandler(this.#namespaces.cameraInterfacesRpc, this.cameraInterfaces);
-    await this.#refreshStates();
-  }
-
-  public extend(interfaces: PTZInterface | SnapshotInterface | StreamingInterface): void {
-    this.cameraInterfaces.interfaces = interfaces;
-  }
-
-  public async connect(): Promise<void> {
-    if (this.pluginId !== this.#plugin.id) {
-      throw new Error('Camera plugin ID does not match the current plugin ID.');
-    }
-
-    const cameraControllerProxy = await this.#cameraControllerProxy();
-    return cameraControllerProxy.connect();
-  }
-
-  public async disconnect(): Promise<void> {
-    if (this.pluginId !== this.#plugin.id) {
-      throw new Error('Camera plugin ID does not match the current plugin ID.');
-    }
-
-    const cameraControllerProxy = await this.#cameraControllerProxy();
-    return cameraControllerProxy.disconnect();
-  }
-
-  public addCapabilities(capabilities: CameraDeviceCapability[]): void {
-    const changed = super.addCapabilitiesInternal(this.#plugin.id, capabilities);
-
-    if (changed) {
-      const updateCapabilities = async () => {
-        try {
-          const cameraControllerProxy = await this.#cameraControllerProxy();
-          return cameraControllerProxy.addPluginCapabilities(this.#plugin.id, capabilities);
-        } catch {
-          // this.logger.error('Failed to add capabilities:', error);
-        }
-      };
-
-      updateCapabilities();
-    }
-  }
-
-  public removeCapabilities(capabilities: CameraDeviceCapability[]): void {
-    const changed = super.removeCapabilitiesInternal(this.#plugin.id, capabilities);
-
-    if (changed) {
-      const updateCapabilities = async () => {
-        try {
-          const cameraControllerProxy = await this.#cameraControllerProxy();
-          return cameraControllerProxy.removePluginCapabilities(this.#plugin.id, capabilities);
-        } catch (error) {
-          this.logger.error('Failed to remove capabilities:', error);
-        }
-      };
-
-      updateCapabilities();
-    }
-  }
-
-  public async updateState<T extends keyof SetValues>(stateName: T, eventData: SetValues[T], frame?: VideoFrame): Promise<void> {
-    try {
-      const canUpdate = this.#canUpdateStateInternal(stateName);
-      if (!canUpdate) {
-        this.logger.warn(`State "${stateName}" can only be updated by the corresponding plugin.`);
-        return;
-      }
-
-      const { changed, event } = super.checkStateInternal(stateName, eventData);
-
-      if (!changed) {
-        return;
-      }
-
-      super.updateStateInternal(stateName as any, event as any, true, true); // remove if updating state only allowed for corresponding plugin
-
-      if (stateName === 'motion' && frame && this.hasObjectDetector) {
-        const motionEvent = eventData as MotionSetEvent;
-        if (motionEvent.state && motionEvent.detections?.length) {
-          const motionFrame: MotionDetectionFrame = {
-            frame: {
-              data: frame.data,
-              info: frame.info,
-              metadata: frame.metadata,
-              timestamp: Date.now(),
-            },
-            state: motionEvent,
-          };
-
-          this.#proxy.publish<MotionDetectionFrame>(this.#namespaces.cameraMotionFrameSubject, motionFrame);
-        }
-      }
-
-      const cameraControllerProxy = await this.#cameraControllerProxy();
-      return cameraControllerProxy.updateState(stateName as any, eventData as any);
-    } catch (error) {
-      if (!this.initialized) {
-        return;
-      }
-
-      throw error;
-    }
-  }
-
-  public async cleanup(): Promise<void> {
-    this.initialized = false;
-    this.removeAllListeners();
-    this.unsubscribe();
-    this.#api.removeListener('shutdown', this.cleanup.bind(this));
-    this.#api.setMaxListeners(this.#api.getMaxListeners() - 1);
-    this.#subscription?.unsubscribe();
-    this.#subscription = undefined;
-    await this.#disconnectRpc();
-  }
-
-  protected async snapshot(sourceId: string, forceNew?: boolean): Promise<ArrayBuffer | undefined> {
-    const fromCache = this.snapshotCache.get(sourceId);
-    if (!forceNew && fromCache) {
-      return fromCache;
-    }
-
-    const cameraControllerProxy = await this.#cameraControllerProxy();
-    const snapshot = await cameraControllerProxy.snapshot(sourceId, forceNew);
-    if (snapshot && snapshot.byteLength > 0) {
-      this.snapshotCache.set(sourceId, snapshot);
-      return snapshot;
-    }
-  }
-
-  protected async probeStream(sourceId: string, probeConfig?: ProbeConfig, refresh = false) {
-    const cameraControllerProxy = await this.#cameraControllerProxy();
-    return cameraControllerProxy.probeStream(sourceId, probeConfig, refresh);
-  }
-
-  async #refreshStates(): Promise<void> {
-    const cameraControllerProxy = await this.#cameraControllerProxy();
-    const response: RefreshedStates = await cameraControllerProxy.refreshStates();
-
-    super.updateCamera(response.camera);
-    super.updateCameraState(response.cameraState);
-    super.updateFrameWorkerState(response.frameWorkerState);
-    super.updateCapabilities(response.capabilities);
-
-    for (const [key, value] of Object.entries(response.states)) {
-      super.updateStateInternal(key as keyof StateValues, value, true);
-    }
-  }
-
-  #canUpdateStateInternal<T extends keyof SetValues>(stateName: T): boolean {
-    switch (stateName) {
-      case 'audio':
-        const audioSensorCapability = this.capabilities.value.find((cap) => cap.capabilities.includes(CameraDeviceCapability.AudioSensor));
-        return audioSensorCapability?.pluginId === this.#plugin.id;
-      case 'motion':
-        const motionSensorCapability = this.capabilities.value.find((cap) => cap.capabilities.includes(CameraDeviceCapability.MotionSensor));
-        const motionDetectionCapability = this.capabilities.value.find((cap) => cap.capabilities.includes(CameraDeviceCapability.MotionDetector));
-        return motionSensorCapability?.pluginId === this.#plugin.id || motionDetectionCapability?.pluginId === this.#plugin.id;
-      case 'object':
-        const objectSensorCapability = this.capabilities.value.find((cap) => cap.capabilities.includes(CameraDeviceCapability.ObjectSensor));
-        const objectDetectionCapability = this.capabilities.value.find((cap) => cap.capabilities.includes(CameraDeviceCapability.ObjectDetector));
-        return objectSensorCapability?.pluginId === this.#plugin.id || objectDetectionCapability?.pluginId === this.#plugin.id;
-      case 'light':
-        const lightCapability = this.capabilities.value.find((cap) => cap.capabilities.includes(CameraDeviceCapability.Light));
-        return lightCapability?.pluginId === this.#plugin.id;
-      case 'doorbell':
-        const doorbellCapability = this.capabilities.value.find((cap) => cap.capabilities.includes(CameraDeviceCapability.Doorbell));
-        return doorbellCapability?.pluginId === this.#plugin.id;
-      case 'siren':
-        const sirenCapability = this.capabilities.value.find((cap) => cap.capabilities.includes(CameraDeviceCapability.Siren));
-        return sirenCapability?.pluginId === this.#plugin.id;
-      case 'battery':
-        const batteryCapability = this.capabilities.value.find((cap) => cap.capabilities.includes(CameraDeviceCapability.Battery));
-        return batteryCapability?.pluginId === this.#plugin.id;
-      default:
-        return false;
-    }
-  }
-
-  async #onEventMessage(event: Message<CameraDeviceListenerStatePayload<keyof StateValues> | CameraDeviceListenerMessagePayload>): Promise<void> {
-    if (!this.initialized) {
-      return;
-    }
-
-    const message = event.data;
-
-    if ('type' in message) {
-      switch (message.type) {
-        case 'removed':
-          this.cleanup();
-          break;
-        case 'updated':
-          super.updateCamera(message.data);
-          break;
-        case 'cameraState':
-          super.updateCameraState(message.data);
-          break;
-        case 'frameWorkerState':
-          super.updateFrameWorkerState(message.data);
-          break;
-        case 'capabilities':
-          super.updateCapabilities(message.data);
-      }
-    } else {
-      const stateName = message.stateName;
-      const newData = message.data.newEvent;
-
-      super.updateStateInternal(stateName, newData, true);
-    }
-  }
-
-  async #cameraControllerProxy(): Promise<Promisify<CameraDeviceInterface>> {
-    return await this.#proxy.createRPCProxy<CameraDeviceInterface>(this.#namespaces.cameraControllerRpc);
-  }
-
-  async #disconnectRpc(): Promise<void> {
-    await this.#proxy.unregisterRPCHandler(this.#namespaces.cameraInterfacesRpc);
-    await this.#proxy.disconnectRPCConnection(this.#namespaces.cameraControllerRpc);
-    await this.#proxy.disconnectRPCConnection(this.#namespaces.frameWorkerChildRpc);
-    await this.cameraInterfaces.disconnect();
-  }
-}

package/src/plugins/runtime/node/proxy/coreManager.ts

@@ -1,128 +0,0 @@
-import { EventEmitter } from 'node:events';
-
-import { API_EVENT } from '../../../../api.js';
-import { NamespaceManager } from '../../../../rpc/namespaces.js';
-
-import type { ClientInstance } from '@camera.ui/rpc-client';
-import type { Message, Promisify, RPCConnection, SubscriptionWrapper } from '@camera.ui/rpc-common';
-import type { CoreManager, CuiPlugin, FfmpegArgs, HWAccelOptions, IceServer } from '@camera.ui/types';
-import type { CoreManagerInterface } from '../../../../manager/types.js';
-import type { CoreManagerNamespaces, PluginNamespaces } from '../../../../rpc/namespaces.js';
-import type { CoreManagerListenerMessagePayload } from '../../../../rpc/types.js';
-import type { PluginInfo } from '../../../types.js';
-import type { PluginAPI } from '../pluginApi.js';
-
-export class CoreManagerProxy extends EventEmitter implements CoreManager {
-  #api: PluginAPI;
-  #proxy: ClientInstance;
-  #plugin: PluginInfo;
-
-  #initialized = false;
-
-  #subscription?: SubscriptionWrapper;
-  #namespaces: CoreManagerNamespaces & PluginNamespaces;
-
-  #rpcConnections = new Map<string, RPCConnection>();
-
-  constructor(proxy: ClientInstance, api: PluginAPI, plugin: PluginInfo) {
-    super();
-
-    this.#api = api;
-    this.#proxy = proxy;
-    this.#plugin = plugin;
-    this.#namespaces = {
-      ...NamespaceManager.coreManagerNamespaces(),
-      ...NamespaceManager.pluginNamespaces(this.#plugin.id),
-    };
-
-    this.#api.once(API_EVENT.SHUTDOWN, this.#close.bind(this));
-  }
-
-  public async init(): Promise<void> {
-    if (this.#initialized) {
-      return;
-    }
-
-    this.#initialized = true;
-    this.#subscription = this.#proxy.subscribe<CoreManagerListenerMessagePayload>(this.#namespaces.coreManagerSubject, this.#onEventMessage.bind(this));
-  }
-
-  public async connectToPlugin(pluginName: string): Promise<CuiPlugin | undefined> {
-    try {
-      const coreManagerProxy = await this.#coreManagerProxy();
-      const plugin = await coreManagerProxy.getPlugin(pluginName);
-
-      if (!plugin) {
-        return;
-      }
-
-      const namespaces = NamespaceManager.pluginNamespaces(plugin.id);
-      let rpcConnection: RPCConnection | undefined;
-
-      if (this.#rpcConnections.has(namespaces.pluginChildRpc)) {
-        rpcConnection = this.#rpcConnections.get(namespaces.pluginChildRpc)!;
-        await rpcConnection.connect();
-      } else {
-        rpcConnection = await this.#proxy.createRPCConnection(namespaces.pluginChildRpc);
-        this.#rpcConnections.set(namespaces.pluginChildRpc, rpcConnection);
-      }
-
-      return rpcConnection.createProxy<CuiPlugin>();
-    } catch {
-      return undefined;
-    }
-  }
-
-  public async getFFmpegPath(): Promise<string> {
-    const coreManagerProxy = await this.#coreManagerProxy();
-    return await coreManagerProxy.getFFmpegPath();
-  }
-
-  public async getHwaccelInfo(options: HWAccelOptions): Promise<FfmpegArgs[]> {
-    const coreManagerProxy = await this.#coreManagerProxy();
-    return await coreManagerProxy.getHwaccelInfo(options);
-  }
-
-  public async getServerAddresses(): Promise<string[]> {
-    const coreManagerProxy = await this.#coreManagerProxy();
-    return await coreManagerProxy.getServerAddresses();
-  }
-
-  public async getIceServers(): Promise<IceServer[]> {
-    const coreManagerProxy = await this.#coreManagerProxy();
-    return await coreManagerProxy.getIceServers();
-  }
-
-  public emit(): boolean {
-    return true;
-  }
-
-  async #coreManagerProxy(): Promise<Promisify<CoreManagerInterface>> {
-    return await this.#proxy.createRPCProxy<CoreManagerInterface>(this.#namespaces.coreManagerRpc);
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  async #onEventMessage(message: Message<CoreManagerListenerMessagePayload>): Promise<void> {
-    // switch (message.type) {
-    //   case 'systemUpdated': {
-    //     const { system }: CoreManagerProxyEvents['systemUpdated'] = message.data;
-    //     super.emit(message.type, system);
-    //     break;
-    //   }
-    // }
-  }
-
-  async #close(): Promise<void> {
-    this.#initialized = false;
-    this.removeAllListeners();
-    this.#api.removeListener('shutdown', this.#close.bind(this));
-    this.#subscription?.unsubscribe();
-    this.#subscription = undefined;
-    await this.#disconnectRpc();
-  }
-
-  async #disconnectRpc(): Promise<void> {
-    await this.#proxy.disconnectRPCConnection(this.#namespaces.coreManagerRpc);
-    await Promise.allSettled(Array.from(this.#rpcConnections.values()).map((rpcConnection) => rpcConnection.disconnect()));
-  }
-}

package/src/plugins/runtime/node/proxy/deviceManager.ts

@@ -1,187 +0,0 @@
-import { EventEmitter } from 'node:events';
-
-import { API_EVENT } from '../../../../api.js';
-import { NamespaceManager } from '../../../../rpc/namespaces.js';
-import { CameraDeviceProxy } from './cameraDevice.js';
-
-import type { Logger } from '@camera.ui/common';
-import type { ClientInstance } from '@camera.ui/rpc-client';
-import type { Message, Promisify, SubscriptionWrapper } from '@camera.ui/rpc-common';
-import type { Camera, CameraConfig, CameraDevice, DeviceManager } from '@camera.ui/types';
-import type { DeviceManagerInterface } from '../../../../manager/types.js';
-import type { DeviceManagerNamespaces, PluginNamespaces } from '../../../../rpc/namespaces.js';
-import type { DeviceManagerListenerMessagePayload, DeviceManagerProxyEvents } from '../../../../rpc/types.js';
-import type { PluginInfo } from '../../../types.js';
-import type { PluginAPI } from '../pluginApi.js';
-import type { StorageController } from '../storageController.js';
-
-export class DeviceManagerProxy extends EventEmitter implements DeviceManager {
-  #api: PluginAPI;
-  #proxy: ClientInstance;
-  #storageController: StorageController;
-  #logger: Logger;
-  #plugin: PluginInfo;
-
-  #initialized = false;
-
-  #requests?: SubscriptionWrapper;
-  #namespaces: DeviceManagerNamespaces & PluginNamespaces;
-
-  #devices = new Map<string, CameraDeviceProxy>();
-
-  constructor(proxy: ClientInstance, api: PluginAPI, storageController: StorageController, plugin: PluginInfo, logger: Logger) {
-    super();
-
-    this.#api = api;
-    this.#proxy = proxy;
-    this.#storageController = storageController;
-    this.#logger = logger;
-    this.#plugin = plugin;
-    this.#namespaces = {
-      ...NamespaceManager.deviceManagerNamespaces(),
-      ...NamespaceManager.pluginNamespaces(this.#plugin.id),
-    };
-
-    this.#api.once(API_EVENT.SHUTDOWN, this.#close.bind(this));
-  }
-
-  public async init(): Promise<void> {
-    if (this.#initialized) {
-      return;
-    }
-
-    this.#initialized = true;
-    this.#requests = this.#proxy.handleRequest<DeviceManagerListenerMessagePayload>(this.#namespaces.pluginDeviceManagerSubject, this.#onEventMessage.bind(this));
-  }
-
-  public async getCamera(cameraIdOrName: string): Promise<CameraDevice | undefined> {
-    let cameraDevice = await this.#getCameraDevice(cameraIdOrName);
-
-    if (!cameraDevice) {
-      const deviceManagerProxy = await this.#deviceManagerProxy();
-      const camera = await deviceManagerProxy.getCamera(cameraIdOrName, this.#plugin.id);
-
-      if (camera) {
-        cameraDevice = await this.#getCameraDevice(camera);
-      }
-    }
-
-    return cameraDevice;
-  }
-
-  public async createCamera(cameraConfig: CameraConfig): Promise<CameraDevice> {
-    const deviceManagerProxy = await this.#deviceManagerProxy();
-    const camera = await deviceManagerProxy.createCamera(cameraConfig, this.#plugin.id);
-    const cameraDevice = await this.#getCameraDevice(camera);
-    return cameraDevice;
-  }
-
-  public async updateCamera(cameraIdOrName: string, cameraConfig: Partial<CameraConfig>): Promise<CameraDevice> {
-    const deviceManagerProxy = await this.#deviceManagerProxy();
-    const camera = await deviceManagerProxy.updateCamera(cameraIdOrName, cameraConfig, this.#plugin.id);
-    const cameraDevice = await this.#getCameraDevice(camera);
-    return cameraDevice;
-  }
-
-  public async removeCamera(cameraIdOrName: string): Promise<void> {
-    const deviceManagerProxy = await this.#deviceManagerProxy();
-    const camera = await deviceManagerProxy.getCamera(cameraIdOrName, this.#plugin.id);
-
-    if (camera) {
-      await deviceManagerProxy.removeCamera(cameraIdOrName, this.#plugin.id);
-      this.#devices.delete(camera._id);
-    }
-  }
-
-  public emit(): boolean {
-    return true;
-  }
-
-  public async configureCameras(cameraDevices: CameraDeviceProxy[]): Promise<void> {
-    await Promise.all(cameraDevices.map((cameraDevice) => this.#getCameraDevice(cameraDevice)));
-  }
-
-  async #deviceManagerProxy(): Promise<Promisify<DeviceManagerInterface>> {
-    return await this.#proxy.createRPCProxy<DeviceManagerInterface>(this.#namespaces.deviceManagerRpc);
-  }
-
-  async #onEventMessage(event: Message<DeviceManagerListenerMessagePayload>): Promise<void> {
-    const message = event.data;
-    switch (message.type) {
-      case 'cameraSelected': {
-        const { camera, extension }: DeviceManagerProxyEvents['cameraSelected'] = message.data;
-        const cameraDevice = await this.#getCameraDevice(camera);
-
-        super.emit(message.type, cameraDevice, extension);
-        break;
-      }
-      case 'cameraDeselected': {
-        const { camera, extension }: DeviceManagerProxyEvents['cameraDeselected'] = message.data;
-        super.emit(message.type, camera._id, extension);
-
-        const cameraDevice = this.#devices.get(camera._id);
-        await cameraDevice?.cleanup();
-        await this.#removeCameraStorage(camera._id);
-        this.#devices.delete(camera._id);
-        break;
-      }
-    }
-  }
-
-  #getCameraDevice(camera: Camera): Promise<CameraDeviceProxy>;
-  #getCameraDevice(cameraDevice: CameraDeviceProxy): Promise<CameraDeviceProxy>;
-  #getCameraDevice(identifier: string): Promise<CameraDeviceProxy | undefined>;
-  async #getCameraDevice(cameraOrIdentifier: Camera | CameraDeviceProxy | string): Promise<CameraDeviceProxy | undefined> {
-    let cameraDevice: CameraDeviceProxy | undefined;
-
-    if (typeof cameraOrIdentifier === 'string') {
-      cameraDevice = Array.from(this.#devices.values()).find((cameraDevice) => cameraDevice.id === cameraOrIdentifier || cameraDevice.name === cameraOrIdentifier);
-    } else if (cameraOrIdentifier instanceof CameraDeviceProxy) {
-      cameraDevice = cameraOrIdentifier;
-
-      if (this.#devices.has(cameraDevice.id)) {
-        cameraDevice = this.#devices.get(cameraDevice.id)!;
-      } else {
-        this.#devices.set(cameraDevice.id, cameraDevice);
-      }
-    } else {
-      const camera = cameraOrIdentifier;
-
-      if (this.#devices.has(camera._id)) {
-        cameraDevice = this.#devices.get(camera._id)!;
-      } else {
-        const cameraLogger = this.#logger.createLogger({ suffix: camera.name, loggerId: camera._id });
-        cameraDevice = new CameraDeviceProxy(this.#proxy, this.#api, camera, this.#plugin, cameraLogger);
-        this.#devices.set(camera._id, cameraDevice);
-      }
-    }
-
-    if (cameraDevice) {
-      await this.#createCameraStorage(cameraDevice.id);
-      await cameraDevice?.init();
-    }
-
-    return cameraDevice;
-  }
-
-  async #createCameraStorage(cameraId: string): Promise<void> {
-    await this.#storageController.createStorage('camera', cameraId);
-  }
-
-  async #removeCameraStorage(cameraId: string): Promise<void> {
-    await this.#storageController.removeStorage('camera', cameraId);
-  }
-
-  async #close(): Promise<void> {
-    this.#initialized = false;
-    this.removeAllListeners();
-    this.#api.removeListener('shutdown', this.#close.bind(this));
-    this.#requests?.unsubscribe();
-    this.#requests = undefined;
-    await this.#disconnectRpc();
-  }
-
-  async #disconnectRpc(): Promise<void> {
-    await this.#proxy.disconnectRPCConnection(this.#namespaces.deviceManagerRpc);
-  }
-}