@apocaliss92/scrypted-reolink-native 0.1.42 → 0.2.0

package/src/intercom.ts

@@ -63,7 +63,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 +81,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 +221,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

@@ -6,6 +6,7 @@ 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";
 
 interface ThumbnailRequest {
     deviceId: string;
@@ -29,6 +30,7 @@ interface ThumbnailRequestInput {
 
 class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider, DeviceCreator {
     devices = new Map<string, BaseBaichuanClass>();
+    private deviceCreationPromises = new Map<string, Promise<BaseBaichuanClass>>();
     mixinsMap = new Map<string, CommonCameraMixin>();
     nvrDeviceId: string;
     private thumbnailQueue: ThumbnailRequest[] = [];
@@ -46,13 +48,36 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
     }
 
     async getDevice(nativeId: ScryptedNativeId): Promise<BaseBaichuanClass> {
+        // Return existing device if available
         if (this.devices.has(nativeId)) {
             return this.devices.get(nativeId)!;
         }
 
-        const newCamera = this.createCamera(nativeId);
-        this.devices.set(nativeId, newCamera);
-        return newCamera;
+        // Check if device creation is already in progress to prevent race conditions
+        const existingPromise = this.deviceCreationPromises.get(nativeId);
+        if (existingPromise) {
+            return existingPromise;
+        }
+
+        // Create device creation promise to handle concurrent requests
+        const creationPromise = (async () => {
+            try {
+                // Double-check after async operation
+                if (this.devices.has(nativeId)) {
+                    return this.devices.get(nativeId)!;
+                }
+
+                const newCamera = this.createCamera(nativeId);
+                this.devices.set(nativeId, newCamera);
+                return newCamera;
+            } finally {
+                // Clean up the promise after creation completes
+                this.deviceCreationPromises.delete(nativeId);
+            }
+        })();
+
+        this.deviceCreationPromises.set(nativeId, creationPromise);
+        return creationPromise;
     }
 
     async createDevice(settings: DeviceCreatorSettings, nativeId?: string): Promise<string> {
@@ -65,7 +90,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 +102,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 +151,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 +179,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;
@@ -205,8 +222,8 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
             return nativeId;
         }
         catch (e) {
-            this.console.error('Error adding Reolink device', e);
-            throw e;
+            this.console.error('Error adding Reolink device', e?.message || String(e));
+            throw e;    
         }
     }
 

package/src/multiFocal.ts

@@ -1,36 +1,24 @@
-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 type { DeviceCapabilities, DualLensChannelAnalysis, NativeVideoStreamVariant, ReolinkBaichuanApi, ReolinkSimpleEvent, SleepStatus, StreamProfile } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
+import type { BaichuanConnectionConfig } from "./baichuan-base";
+import sdk, { Device, DeviceProvider, Reboot, ScryptedDeviceType, Settings } from "@scrypted/sdk";
 import { ReolinkNativeCamera } from "./camera";
 import { ReolinkNativeBatteryCamera } from "./camera-battery";
 import { CameraType, CommonCameraMixin } from "./common";
 import ReolinkNativePlugin from "./main";
-import { batteryCameraSuffix, cameraSuffix, getDeviceInterfaces, updateDeviceInfo } from "./utils";
+import { batteryCameraSuffix, cameraSuffix, getDeviceInterfaces } from "./utils";
+import { ReolinkNativeNvrDevice } from "./nvr";
+import { createBaichuanApi } from "./connect";
 
 export class ReolinkNativeMultiFocalDevice extends CommonCameraMixin implements Settings, DeviceProvider, Reboot {
     plugin: ReolinkNativePlugin;
     cameraNativeMap = new Map<string, ReolinkNativeCamera | ReolinkNativeBatteryCamera>();
     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,141 +29,123 @@ 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);
-    }
-
-    private scheduleInit(isReinit: boolean = false): void {
-        // Cancel any pending init/reinit
-        if (this.initReinitTimeout) {
-            clearTimeout(this.initReinitTimeout);
-        }
-
-        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);
-    }
-
     async init(): Promise<void> {
         const logger = this.getBaichuanLogger();
+
         try {
             this.storageSettings.settings.uid.hide = !this.isBattery;
 
-            await this.ensureBaichuanClient();
-            await this.reportDevices();
+            await this.ensureClient();
+            // subscribeToEvents in common.ts will check if this device has a parent (nvrDevice)
+            // and skip subscription if needed - events will be forwarded from parent
             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)}`);
-            }
+            logger.error('Failed to initialize multi-focal device', e?.message || String(e));
         }
     }
 
-    getInterfaces(channel: number) {
+    getInterfaces(lensType?: NativeVideoStreamVariant) {
         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,
-        };
+
+        let capabilities: DeviceCapabilities = { ...caps };
+
+        if (lensType) {
+            const channelInfo = (multifocalInfo as DualLensChannelAnalysis).channels.find(c => c.variantType === lensType);
+
+            const hasPtz = channelInfo?.hasPan || channelInfo?.hasTilt || channelInfo?.hasZoom;
+
+            capabilities = {
+                ...capabilities,
+                hasPan: channelInfo.hasPan,
+                hasTilt: channelInfo.hasTilt,
+                hasZoom: channelInfo?.hasZoom,
+                hasPresets: channelInfo?.hasPresets || hasPtz,
+                hasIntercom: channelInfo?.hasIntercom,
+                hasPtz,
+            };
+        }
 
         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 })}`);
-
-            const camera = await this.getDevice(nativeId);
-
-            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) {
@@ -199,34 +169,122 @@ export class ReolinkNativeMultiFocalDevice extends CommonCameraMixin implements
         super.releaseDevice(id, nativeId);
     }
 
+    /**
+     * Forward events received from parent (NVR if child, or directly from Baichuan if standalone)
+     * to the MultiFocal device itself AND to ALL lens devices (camera children) of this MultiFocal.
+     * This ensures that:
+     * 1. The MultiFocal device itself receives events (it can have event handling capabilities)
+     * 2. All lenses receive the events, even if they share the same channel
+     *    (e.g., wide and tele on the same channel on NVR).
+     * Only the root device (NVR or standalone MultiFocal) subscribes to events,
+     * and events are forwarded down the hierarchy.
+     */
     forwardNativeEvent(ev: ReolinkSimpleEvent): void {
         const logger = this.getBaichuanLogger();
-        const channel = ev?.channel;
+        const eventChannel = ev?.channel;
 
-        if (channel === undefined) {
-            logger.debug('Event missing channel, ignoring');
-            return;
+        // First, forward event to the MultiFocal device itself
+        try {
+            this.onSimpleEvent(ev);
+        } catch (e) {
+            logger.warn(`Error forwarding event to MultiFocal device itself:`, e?.message || String(e));
         }
 
-        const nativeId = this.channelToNativeIdMap.get(channel);
-        if (!nativeId) {
-            logger.debug(`No camera found for channel ${channel}, ignoring event`);
+        // Then, forward event to all lens devices (camera children) of this MultiFocal
+        // Even if event has a specific channel, we forward to all lenses because:
+        // 1. On NVR, wide and tele lenses can share the same channel
+        // 2. Events might be relevant to all lenses of the MultiFocal device
+        const lensDevices = Array.from(this.cameraNativeMap.values());
+        const forwardedCount = lensDevices.length;
+        
+        if (forwardedCount === 0) {
+            logger.debug(`No lens devices found for MultiFocal, event forwarded only to MultiFocal itself`);
             return;
         }
 
-        const camera = this.cameraNativeMap.get(nativeId);
-        if (!camera) {
-            logger.debug(`Camera ${nativeId} not yet initialized, ignoring event`);
-            return;
-        }
+        logger.debug(`Forwarding event (channel=${eventChannel}) to MultiFocal itself and ${forwardedCount} lens device(s)`);
 
-        camera.onSimpleEvent(ev);
+        // Forward event to all camera children (lens devices)
+        for (const camera of lensDevices) {
+            try {
+                // Each lens device will filter events based on its own channel if needed
+                camera.onSimpleEvent(ev);
+            } catch (e) {
+                logger.warn(`Error forwarding event to lens device ${camera.nativeId}:`, e?.message || String(e));
+            }
+        }
     }
 
     async unsubscribeFromAllEvents(): Promise<void> {
         await super.unsubscribeFromEvents();
     }
 
+    /**
+     * Update sleeping state for the MultiFocal device itself and propagate to all lens devices.
+     * This ensures that when the MultiFocal receives a sleeping/awake state update (from events or API calls),
+     * the state is synchronized across the MultiFocal and all its lens children.
+     */
+    async updateSleepingState(sleepStatus: SleepStatus): Promise<void> {
+        const logger = this.getBaichuanLogger();
+        
+        // First, update the MultiFocal device's own sleeping state
+        await super.updateSleepingState(sleepStatus);
+
+        // Then, propagate the state to all lens devices (camera children)
+        const lensDevices = Array.from(this.cameraNativeMap.values());
+        
+        if (lensDevices.length === 0) {
+            logger.debug(`No lens devices found for MultiFocal, sleeping state updated only for MultiFocal itself`);
+            return;
+        }
+
+        logger.debug(`Propagating sleeping state (state=${sleepStatus.state}) to ${lensDevices.length} lens device(s)`);
+
+        // Propagate sleeping state to all lens devices
+        await Promise.allSettled(
+            lensDevices.map(async (camera) => {
+                try {
+                    await camera.updateSleepingState(sleepStatus);
+                } catch (e) {
+                    logger.warn(`Error propagating sleeping state to lens device ${camera.nativeId}:`, e?.message || String(e));
+                }
+            })
+        );
+    }
+
+    /**
+     * Update online state for the MultiFocal device itself and propagate to all lens devices.
+     * This ensures that when the MultiFocal receives an online/offline state update (from events or API calls),
+     * the state is synchronized across the MultiFocal and all its lens children.
+     */
+    async updateOnlineState(isOnline: boolean): Promise<void> {
+        const logger = this.getBaichuanLogger();
+        
+        // First, update the MultiFocal device's own online state
+        await super.updateOnlineState(isOnline);
+
+        // Then, propagate the state to all lens devices (camera children)
+        const lensDevices = Array.from(this.cameraNativeMap.values());
+        
+        if (lensDevices.length === 0) {
+            logger.debug(`No lens devices found for MultiFocal, online state updated only for MultiFocal itself`);
+            return;
+        }
+
+        logger.debug(`Propagating online state (isOnline=${isOnline}) to ${lensDevices.length} lens device(s)`);
+
+        // Propagate online state to all lens devices
+        await Promise.allSettled(
+            lensDevices.map(async (camera) => {
+                try {
+                    await camera.updateOnlineState(isOnline);
+                } catch (e) {
+                    logger.warn(`Error propagating online state to lens device ${camera.nativeId}:`, e?.message || String(e));
+                }
+            })
+        );
+    }
+
     public async runDiagnostics(): Promise<void> {
         const logger = this.getBaichuanLogger();
         logger.log(`Starting Multifocal diagnostics...`);
@@ -237,16 +295,52 @@ 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);
+    }
 }