@apocaliss92/scrypted-reolink-native 0.1.42 → 0.2.1

package/src/intercom.ts

@@ -1,9 +1,7 @@
 import type { ReolinkBaichuanApi } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
 import sdk, { FFmpegInput, MediaObject, ScryptedMimeTypes } from "@scrypted/sdk";
 import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
-
-import type { ReolinkNativeCamera } from "./camera";
-import { CommonCameraMixin } from "./common";
+import { ReolinkCamera } from "./camera";
 
 // Keep this low: Reolink blocks are ~64ms at 16kHz (1025 samples).
 // A small backlog avoids multi-second latency when the pipeline stalls.
@@ -23,7 +21,7 @@ export class ReolinkBaichuanIntercom {
     private sendChain: Promise<void> = Promise.resolve();
     private pcmBuffer: Buffer = Buffer.alloc(0);
 
-    constructor(private camera: CommonCameraMixin) {
+    constructor(private camera: ReolinkCamera) {
     }
 
     get blocksPerPayload(): number {
@@ -63,7 +61,7 @@ export class ReolinkBaichuanIntercom {
                 });
             }
             catch (e) {
-                logger.warn("Intercom: unable to fetch TalkAbility", e);
+                logger.warn("Intercom: unable to fetch TalkAbility", e?.message || String(e));
             }
         }
 
@@ -81,7 +79,7 @@ export class ReolinkBaichuanIntercom {
                         await new Promise(resolve => setTimeout(resolve, 1000));
                     }
                 } catch (e) {
-                    logger.debug('Failed to check/wake camera for intercom, proceeding anyway', e);
+                    logger.debug('Failed to check/wake camera for intercom, proceeding anyway', e?.message || String(e));
                 }
             }
             
@@ -221,7 +219,7 @@ export class ReolinkBaichuanIntercom {
                     await Promise.race([session.stop(), sleepMs(2000)]);
                 }
                 catch (e) {
-                    logger.warn("Intercom session stop error", e);
+                    logger.warn("Intercom session stop error", e?.message || String(e));
                 }
             }
         })().finally(() => {

package/src/main.ts

@@ -1,11 +1,10 @@
 import sdk, { DeviceCreator, DeviceCreatorSettings, DeviceProvider, HttpRequest, HttpResponse, MediaObject, ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, ScryptedMimeTypes, ScryptedNativeId, Setting, VideoClips } from "@scrypted/sdk";
 import { BaseBaichuanClass } from "./baichuan-base";
-import { ReolinkNativeCamera } from "./camera";
-import { ReolinkNativeBatteryCamera } from "./camera-battery";
-import { CommonCameraMixin } from "./common";
 import { ReolinkNativeMultiFocalDevice } from "./multiFocal";
 import { ReolinkNativeNvrDevice } from "./nvr";
 import { batteryCameraSuffix, batteryMultifocalSuffix, cameraSuffix, extractThumbnailFromVideo, getDeviceInterfaces, handleVideoClipRequest, multifocalSuffix, nvrSuffix } from "./utils";
+import { randomBytes } from "crypto";
+import { ReolinkCamera } from "./camera";
 
 interface ThumbnailRequest {
     deviceId: string;
@@ -13,7 +12,7 @@ interface ThumbnailRequest {
     rtmpUrl?: string;
     filePath?: string;
     logger?: Console;
-    device?: CommonCameraMixin;
+    device?: ReolinkCamera;
     resolve: (mo: MediaObject) => void;
     reject: (error: Error) => void;
 }
@@ -24,12 +23,12 @@ interface ThumbnailRequestInput {
     rtmpUrl?: string;
     filePath?: string;
     logger?: Console;
-    device?: CommonCameraMixin;
+    device?: ReolinkCamera;
 }
 
 class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider, DeviceCreator {
     devices = new Map<string, BaseBaichuanClass>();
-    mixinsMap = new Map<string, CommonCameraMixin>();
+    camerasMap = new Map<string, ReolinkCamera>();
     nvrDeviceId: string;
     private thumbnailQueue: ThumbnailRequest[] = [];
     private thumbnailProcessing = false;
@@ -65,7 +64,6 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
             throw new Error('IP address, username, and password are required');
         }
 
-        // Auto-detect device type (camera, battery-cam, or nvr)
         this.console.log(`[AutoDetect] Starting device type detection for ${ipAddress}...`);
         const { autoDetectDeviceType } = await import("@apocaliss92/reolink-baichuan-js");
 
@@ -78,19 +76,20 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
                 logger: this.console,
             },
         );
+        const { ip, mac } = detection.hostNetworkInfo ?? {}
 
         this.console.log(`[AutoDetect] Detected device type: ${detection.type} (transport: ${detection.transport}). Device info: ${JSON.stringify(detection.deviceInfo)}`);
 
         // Use the API that was successfully used for detection
         const detectedApi = detection.api;
+        const deviceInfo = detection.deviceInfo || {};
+        const name = deviceInfo?.name || `Reolink ${detection.type}`;
+        const identifier = uid || mac || ip || name || randomBytes(4).toString('hex');
 
         // Handle multi-focal device case
         if (detection.type === 'multifocal') {
-            const deviceInfo = detection.deviceInfo || {};
-            const name = deviceInfo.name || 'Reolink Multi-Focal';
-            const serialNumber = deviceInfo.serialNumber || deviceInfo.itemNo || `multifocal-${Date.now()}`;
             const isBattery = detection.transport === 'udp';
-            nativeId = `${serialNumber}${isBattery ? batteryMultifocalSuffix : multifocalSuffix}`;
+            nativeId = `${identifier}${isBattery ? batteryMultifocalSuffix : multifocalSuffix}`;
 
             settings.newCamera ||= name;
 
@@ -126,10 +125,7 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
 
         // Handle NVR case
         if (detection.type === 'nvr') {
-            const deviceInfo = detection.deviceInfo || {};
-            const name = deviceInfo?.name || 'Reolink NVR';
-            const serialNumber = deviceInfo?.serialNumber || deviceInfo?.itemNo || `nvr-${Date.now()}`;
-            nativeId = `${serialNumber}${nvrSuffix}`;
+            nativeId = `${identifier}${nvrSuffix}`;
 
             settings.newCamera ||= name;
 
@@ -157,16 +153,11 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
             return nativeId;
         }
 
-        // For camera and battery-cam, create the device
-        const deviceInfo = detection.deviceInfo || {};
-        const name = deviceInfo?.name || 'Reolink Camera';
-        const serialNumber = deviceInfo?.serialNumber || deviceInfo?.itemNo || `unknown-${Date.now()}`;
-
         // Create nativeId based on device type
         if (detection.type === 'battery-cam') {
-            nativeId = `${serialNumber}${batteryCameraSuffix}`;
+            nativeId = `${identifier}${batteryCameraSuffix}`;
         } else {
-            nativeId = `${serialNumber}${cameraSuffix}`;
+            nativeId = `${identifier}${cameraSuffix}`;
         }
 
         settings.newCamera ||= name;
@@ -189,7 +180,7 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
                 providerNativeId: this.nativeId,
             });
 
-            const device = await this.getDevice(nativeId) as CommonCameraMixin;
+            const device = await this.getDevice(nativeId) as ReolinkCamera;
 
             device.info = deviceInfo;
             device.classes = objects;
@@ -205,7 +196,7 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
             return nativeId;
         }
         catch (e) {
-            this.console.error('Error adding Reolink device', e);
+            this.console.error('Error adding Reolink device', e?.message || String(e));
             throw e;
         }
     }
@@ -248,7 +239,7 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
 
     createCamera(nativeId: string) {
         if (nativeId.endsWith(batteryCameraSuffix)) {
-            return new ReolinkNativeBatteryCamera(nativeId, this);
+            return new ReolinkCamera(nativeId, this, { type: 'battery' });
         } else if (nativeId.endsWith(nvrSuffix)) {
             return new ReolinkNativeNvrDevice(nativeId, this);
         } else if (nativeId.endsWith(batteryMultifocalSuffix)) {
@@ -256,7 +247,7 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
         } else if (nativeId.endsWith(multifocalSuffix)) {
             return new ReolinkNativeMultiFocalDevice(nativeId, this, "multi-focal");
         } else {
-            return new ReolinkNativeCamera(nativeId, this);
+            return new ReolinkCamera(nativeId, this, { type: 'regular' });
         }
     }
 
@@ -296,7 +287,7 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
             // logger.log(`Webhook request: type=${type}, deviceId=${deviceId}, fileId=${fileId}`);
 
             // Get the device
-            const device = this.mixinsMap.get(deviceId);
+            const device = this.camerasMap.get(deviceId);
             if (!device) {
                 response.send('Device not found', { code: 404 });
                 return;

package/src/multiFocal.ts

@@ -1,36 +1,20 @@
-import type { DeviceCapabilities, DualLensChannelAnalysis, ReolinkSimpleEvent } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
-import sdk, { Device, DeviceProvider, Reboot, ScryptedDeviceType, Setting, Settings, SettingValue } from "@scrypted/sdk";
-import { ReolinkNativeCamera } from "./camera";
-import { ReolinkNativeBatteryCamera } from "./camera-battery";
-import { CameraType, CommonCameraMixin } from "./common";
+import type { BatteryInfo, DeviceCapabilities, DualLensChannelAnalysis, NativeVideoStreamVariant, ReolinkBaichuanApi, ReolinkSimpleEvent, SleepStatus } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
+import sdk, { Device, DeviceProvider, Reboot, ScryptedDeviceType, Settings } from "@scrypted/sdk";
+import type { BaichuanConnectionConfig } from "./baichuan-base";
+import { CameraType, ReolinkCamera } from "./camera";
 import ReolinkNativePlugin from "./main";
-import { batteryCameraSuffix, cameraSuffix, getDeviceInterfaces, updateDeviceInfo } from "./utils";
+import { ReolinkNativeNvrDevice } from "./nvr";
+import { batteryCameraSuffix, cameraSuffix, getDeviceInterfaces } from "./utils";
 
-export class ReolinkNativeMultiFocalDevice extends CommonCameraMixin implements Settings, DeviceProvider, Reboot {
+export class ReolinkNativeMultiFocalDevice extends ReolinkCamera implements Settings, DeviceProvider, Reboot {
     plugin: ReolinkNativePlugin;
-    cameraNativeMap = new Map<string, ReolinkNativeCamera | ReolinkNativeBatteryCamera>();
+    lensDevicesMap = new Map<string, ReolinkCamera>();
     private channelToNativeIdMap = new Map<number, string>();
-    private initReinitTimeout: NodeJS.Timeout | undefined;
-    isBattery: boolean;
 
-    constructor(nativeId: string, plugin: ReolinkNativePlugin, type: CameraType) {
-        super(nativeId, plugin, { type });
-        this.plugin = plugin;
-
-        this.scheduleInit();
-    }
+    constructor(nativeId: string, plugin: ReolinkNativePlugin, type: CameraType, nvrDevice?: ReolinkNativeNvrDevice) {
+        super(nativeId, plugin, { type, nvrDevice });
 
-    getAbilities(): DeviceCapabilities {
-        const { capabilities } = this.storageSettings.values;
-
-        return {
-            ...capabilities,
-            hasPan: false,
-            hasTilt: false,
-            hasZoom: false,
-            hasPresets: false,
-            hasIntercom: false,
-        }
+        this.plugin = plugin;
     }
 
     protected async onBeforeCleanup(): Promise<void> {
@@ -41,153 +25,127 @@ export class ReolinkNativeMultiFocalDevice extends CommonCameraMixin implements
         return this.name || 'Multi-Focal Device';
     }
 
-    async reinit(): Promise<void> {
-        // Cancel any pending init/reinit
-        if (this.initReinitTimeout) {
-            clearTimeout(this.initReinitTimeout);
-            this.initReinitTimeout = undefined;
-        }
-
-        // Schedule reinit with debounce
-        this.scheduleInit(true);
-    }
+    getInterfaces(lensType?: NativeVideoStreamVariant) {
+        const logger = this.getBaichuanLogger();
+        const { capabilities: caps, multifocalInfo } = this.storageSettings.values;
 
-    private scheduleInit(isReinit: boolean = false): void {
-        // Cancel any pending init/reinit
-        if (this.initReinitTimeout) {
-            clearTimeout(this.initReinitTimeout);
-        }
+        let capabilities: DeviceCapabilities = { ...caps };
 
-        this.initReinitTimeout = setTimeout(async () => {
-            const logger = this.getBaichuanLogger();
-            if (isReinit) {
-                logger.log('Reinitializing multi-focal device...');
-                await this.cleanupBaichuanApi();
-            }
-            await this.init();
-            this.initReinitTimeout = undefined;
-        }, isReinit ? 500 : 2000);
-    }
+        if (lensType) {
+            const channelInfo = (multifocalInfo as DualLensChannelAnalysis).channels.find(c => c.variantType === lensType);
 
-    async init(): Promise<void> {
-        const logger = this.getBaichuanLogger();
-        try {
-            this.storageSettings.settings.uid.hide = !this.isBattery;
+            const hasPtz = channelInfo?.hasPan || channelInfo?.hasTilt || channelInfo?.hasZoom;
 
-            await this.ensureBaichuanClient();
-            await this.reportDevices();
-            await this.subscribeToEvents();
-        } catch (e) {
-            logger.error('Failed to initialize multi-focal device', e);
-            if (e instanceof Error) {
-                logger.error(`Error message: ${e.message}`);
-                logger.error(`Error stack: ${e.stack}`);
-            } else {
-                logger.error(`Error details: ${JSON.stringify(e)}`);
-            }
+            capabilities = {
+                ...capabilities,
+                hasPan: channelInfo.hasPan,
+                hasTilt: channelInfo.hasTilt,
+                hasZoom: channelInfo?.hasZoom,
+                hasPresets: channelInfo?.hasPresets || hasPtz,
+                hasIntercom: channelInfo?.hasIntercom,
+                hasPtz,
+            };
         }
-    }
-
-    getInterfaces(channel: number) {
-        const logger = this.getBaichuanLogger();
-        const { capabilities: caps, multifocalInfo } = this.storageSettings.values;
-        const channelInfo = (multifocalInfo as DualLensChannelAnalysis).channels.find(c => c.channel === channel);
-
-        const capabilities: DeviceCapabilities = {
-            ...caps,
-            hasPan: channelInfo.hasPan,
-            hasTilt: channelInfo.hasTilt,
-            hasZoom: channelInfo.hasZoom,
-            hasPresets: channelInfo.hasPresets,
-            hasIntercom: channelInfo.hasIntercom,
-        };
 
         const { interfaces } = getDeviceInterfaces({
             capabilities,
             logger,
         });
 
+        // logger.debug(`Interfaces found for lens ${lensType}: ${JSON.stringify({ interfaces, capabilities, multifocalInfo })}`);
+
         return { interfaces, capabilities };
     }
 
     async reportDevices(): Promise<void> {
-        const api = await this.ensureBaichuanClient();
-        const logger = this.getBaichuanLogger();
-        const { username, password, ipAddress, uid } = this.storageSettings.values;
-
-        const { capabilities, support, abilities, features, objects, presets } = await api.getDeviceCapabilities();
-
-        const multifocalInfo = await api.getDualLensChannelInfo();
-        logger.log(`Sync entities from remote for ${multifocalInfo.channels.length} channels`);
-
-        this.storageSettings.values.multifocalInfo = multifocalInfo;
-        this.storageSettings.values.capabilities = capabilities;
-
-        // TODO: Remove this after debugging
-        logger.log(`Multichannel info: ${JSON.stringify({ multifocalInfo, capabilities, support, abilities, features, objects, presets })}`);
-        // logger.debug(`Multichannel info: ${JSON.stringify({ multifocalInfo, capabilities, support, abilities, features, objects, presets })}`);
-
-        for (const channelInfo of multifocalInfo?.channels ?? []) {
-            const { channel, lensType } = channelInfo;
-
-            const name = `${this.name} - ${lensType}`;
-            const nativeId = `${this.nativeId}-channel${channel}${this.isBattery ? batteryCameraSuffix : cameraSuffix}`;
-
-            this.channelToNativeIdMap.set(channel, nativeId);
-            const { interfaces, capabilities: deviceCapabilities } = this.getInterfaces(channel);
-
-            const device: Device = {
-                providerNativeId: this.nativeId,
-                name,
-                nativeId,
-                info: {
-                    ...this.info,
-                    metadata: {
-                        channel,
-                        lensType
-                    }
-                },
-                interfaces,
-                type: ScryptedDeviceType.Camera,
-            };
-
-            await sdk.deviceManager.onDeviceDiscovered(device);
-
-            // TODO: Remove this after debugging
-            logger.log(`Discovering lens device ${nativeId}: ${JSON.stringify({ interfaces, deviceCapabilities })}`);
+        await super.reportDevices();
 
-            const camera = await this.getDevice(nativeId);
+        const logger = this.getBaichuanLogger();
 
-            if (!camera) {
-                logger.error(`Failed to get device ${nativeId}`);
-                continue;
-            }
+        try {
+            const api = await this.ensureClient();
+            const { username, password, ipAddress, uid, rtspChannel } = this.storageSettings.values;
+
+            const { capabilities, objects, presets } = await api.getDeviceCapabilities(rtspChannel, {
+                mergeDualLensOnSameChannel: true,
+            });
+            const multifocalInfo = await api.getDualLensChannelInfo(rtspChannel, {
+                onNvr: !!this.nvrDevice
+            });
+            logger.log(`Discovering ${multifocalInfo.channels.length} lenses`);
+            logger.debug({ multifocalInfo, capabilities });
+
+            this.storageSettings.values.multifocalInfo = multifocalInfo;
+            this.storageSettings.values.capabilities = capabilities;
+
+            for (const channelInfo of multifocalInfo?.channels ?? []) {
+                const { channel, lensType, variantType } = channelInfo;
+
+                const name = `${this.name} - ${lensType}`;
+                const nativeId = `${this.nativeId}-${lensType}${this.isBattery ? batteryCameraSuffix : cameraSuffix}`;
+
+                this.channelToNativeIdMap.set(channel, nativeId);
+                const { interfaces, capabilities: deviceCapabilities } = this.getInterfaces();
+
+                const device: Device = {
+                    providerNativeId: this.nativeId,
+                    name,
+                    nativeId,
+                    info: {
+                        ...this.info,
+                        metadata: {
+                            channel,
+                            lensType
+                        }
+                    },
+                    interfaces,
+                    type: ScryptedDeviceType.Camera,
+                };
+
+                await sdk.deviceManager.onDeviceDiscovered(device);
+
+                logger.log(`Discovering lens ${lensType}`);
+                logger.debug(`${JSON.stringify({ interfaces, deviceCapabilities })}`)
+
+                const camera = await this.getDevice(nativeId);
+
+                if (!camera) {
+                    logger.error(`Failed to get device ${nativeId}`);
+                    continue;
+                }
 
-            camera.storageSettings.values.rtspChannel = channel;
-            camera.classes = objects;
-            camera.presets = presets;
-            camera.storageSettings.values.username = username;
-            camera.storageSettings.values.password = password;
-            camera.storageSettings.values.ipAddress = ipAddress;
-            camera.storageSettings.values.capabilities = deviceCapabilities;
-            if (this.isBattery) {
+                camera.storageSettings.values.rtspChannel = channel;
+                camera.classes = objects;
+                camera.presets = presets;
+                camera.storageSettings.values.username = username;
+                camera.storageSettings.values.password = password;
+                camera.storageSettings.values.ipAddress = ipAddress;
+                camera.storageSettings.values.variantType = variantType;
+                camera.storageSettings.values.rtspChannel = channel;
+                camera.storageSettings.values.capabilities = deviceCapabilities;
                 camera.storageSettings.values.uid = uid;
             }
+        } catch (e) {
+            logger.error('Failed to report devices', e?.message || String(e));
+            throw e;
         }
-
-        await super.reportDevices();
     }
 
     async getDevice(nativeId: string) {
         if (nativeId.endsWith(cameraSuffix) || nativeId.endsWith(batteryCameraSuffix)) {
-            let device = this.cameraNativeMap.get(nativeId);
+            let device = this.lensDevicesMap.get(nativeId);
             if (!device) {
                 if (nativeId.endsWith(batteryCameraSuffix)) {
-                    device = new ReolinkNativeBatteryCamera(nativeId, this.plugin, undefined, this);
+                    device = new ReolinkCamera(nativeId, this.plugin, { type: 'battery', multiFocalDevice: this });
                 } else {
-                    device = new ReolinkNativeCamera(nativeId, this.plugin, undefined, this);
+                    device = new ReolinkCamera(nativeId, this.plugin, { type: 'regular', multiFocalDevice: this });
                 }
             }
+
+            if (device) {
+                this.lensDevicesMap.set(nativeId, device);
+            }
+
             return device;
         } else {
             return super.getDevice(nativeId);
@@ -195,34 +153,10 @@ export class ReolinkNativeMultiFocalDevice extends CommonCameraMixin implements
     }
 
     async releaseDevice(id: string, nativeId: string) {
-        this.cameraNativeMap.delete(nativeId);
+        this.lensDevicesMap.delete(nativeId);
         super.releaseDevice(id, nativeId);
     }
 
-    forwardNativeEvent(ev: ReolinkSimpleEvent): void {
-        const logger = this.getBaichuanLogger();
-        const channel = ev?.channel;
-
-        if (channel === undefined) {
-            logger.debug('Event missing channel, ignoring');
-            return;
-        }
-
-        const nativeId = this.channelToNativeIdMap.get(channel);
-        if (!nativeId) {
-            logger.debug(`No camera found for channel ${channel}, ignoring event`);
-            return;
-        }
-
-        const camera = this.cameraNativeMap.get(nativeId);
-        if (!camera) {
-            logger.debug(`Camera ${nativeId} not yet initialized, ignoring event`);
-            return;
-        }
-
-        camera.onSimpleEvent(ev);
-    }
-
     async unsubscribeFromAllEvents(): Promise<void> {
         await super.unsubscribeFromEvents();
     }
@@ -237,16 +171,104 @@ export class ReolinkNativeMultiFocalDevice extends CommonCameraMixin implements
                 throw new Error('Missing device credentials');
             }
 
-            const api = await this.ensureBaichuanClient();
+            const api = await this.ensureClient();
 
             const multifocalDiagnostics = await api.collectMultifocalDiagnostics(logger);
 
             logger.log(`NVR diagnostics completed successfully.`);
-            logger.log(JSON.stringify(multifocalDiagnostics));
+            logger.debug(JSON.stringify(multifocalDiagnostics));
         } catch (e) {
-            logger.error('Failed to run NVR diagnostics', e);
+            logger.error('Failed to run NVR diagnostics', e?.message || String(e));
             throw e;
         }
     }
+
+    async ensureClient(): Promise<ReolinkBaichuanApi> {
+        if (this.nvrDevice) {
+            return await this.nvrDevice.ensureBaichuanClient();
+        }
+
+        // Use base class implementation
+        return await this.ensureBaichuanClient();
+    }
+
+    protected getStreamClientInputs(): BaichuanConnectionConfig {
+        const { ipAddress, username, password } = this.storageSettings.values;
+        const debugOptions = this.getBaichuanDebugOptions();
+
+        return {
+            host: ipAddress,
+            username,
+            password,
+            transport: this.transport,
+            debugOptions,
+        };
+    }
+
+    /**
+     * Create a dedicated Baichuan API session for streaming (used by StreamManager).
+     * MultiFocal creates its own socket for stream clients, or delegates to NVR if on NVR.
+     */
+    async createStreamClient(streamKey: string): Promise<ReolinkBaichuanApi> {
+        // If on NVR, delegate to NVR to create the socket
+        if (this.nvrDevice) {
+            return await this.nvrDevice.createStreamClient(streamKey);
+        }
+
+        // Otherwise, use base class createStreamClient which manages stream clients per streamKey
+        return await super.createStreamClient(streamKey);
+    }
+
+    getLensDevices() {
+        const devices = Array.from(this.lensDevicesMap.values());
+        // const logger = this.getBaichuanLogger();
+        // logger.debug(`Found ${devices.length} lens devices: ${devices.map(d => d.nativeId).join(', ')}`);
+
+        return devices;
+    }
+
+    async updateBatteryInfo() {
+        const batteryInfo = await super.updateBatteryInfo();
+        const lensDevices = this.getLensDevices();
+
+        for (const camera of lensDevices) {
+            await camera.updateBatteryInfo(batteryInfo);
+        }
+
+        return batteryInfo;
+    }
+
+    onSimpleEvent(ev: ReolinkSimpleEvent) {
+        super.onSimpleEvent(ev);
+        const logger = this.getBaichuanLogger();
+        const lensDevices = this.getLensDevices();
+
+        for (const camera of lensDevices) {
+            logger.debug(`Forward ${ev.type} event to lens device ${camera.nativeId}`);
+            camera.onSimpleEvent(ev);
+        }
+    }
+
+    async updateSleepingState(sleepStatus: SleepStatus) {
+        const logger = this.getBaichuanLogger();
+        await super.updateSleepingState(sleepStatus);
+        const lensDevices = this.getLensDevices();
+
+        for (const camera of lensDevices) {
+            logger.debug(`Forward ${JSON.stringify(sleepStatus)} sleeping state to lens device ${camera.nativeId}`);
+            await camera.updateSleepingState(sleepStatus);
+        }
+    }
+
+    async updateOnlineState(isOnline: boolean) {
+        const logger = this.getBaichuanLogger();
+        await super.updateOnlineState(isOnline);
+        const lensDevices = this.getLensDevices();
+
+        for (const camera of lensDevices) {
+            logger.debug(`Forward ${isOnline ? 'online' : 'offline'} state to lens device ${camera.nativeId}`);
+            await camera.updateOnlineState(isOnline);
+        }
+    }
 }