@apocaliss92/scrypted-reolink-native 0.1.15 → 0.1.17

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@apocaliss92/scrypted-reolink-native",
-   "version": "0.1.15",
+   "version": "0.1.17",
    "description": "Use any reolink camera with Scrypted, even older/unsupported models without HTTP protocol support",
    "author": "@apocaliss92",
    "license": "Apache",

package/src/common.ts

@@ -8,6 +8,7 @@ import { convertDebugLogsToApiOptions, DebugLogDisplayNames, DebugLogOption, get
 import { ReolinkBaichuanIntercom } from "./intercom";
 import ReolinkNativePlugin from "./main";
 import { ReolinkNativeNvrDevice } from "./nvr";
+import { ReolinkNativeMultiFocalDevice } from "./multifocal";
 import { ReolinkPtzPresets } from "./presets";
 import {
     buildVideoStreamOptions,
@@ -26,6 +27,7 @@ export type CameraType = 'battery' | 'regular';
 export interface CommonCameraMixinOptions {
     type: CameraType;
     nvrDevice?: ReolinkNativeNvrDevice; // Optional reference to NVR device
+    multiFocalDevice?: ReolinkNativeMultiFocalDevice; // Optional reference to multi-focal device
 }
 
 class ReolinkCameraSiren extends ScryptedDeviceBase implements OnOff {
@@ -230,11 +232,6 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 await this.credentialsChanged();
             }
         },
-        isFromNvr: {
-            type: 'boolean',
-            hide: true,
-            defaultValue: false,
-        },
         mixinsSetup: {
             type: 'boolean',
             hide: true,
@@ -263,6 +260,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             defaultValue: [],
             choices: getDebugLogChoices(),
             onPut: async (ov, value) => {
+                const logger = this.getBaichuanLogger();
                 const oldApiOptions = getApiRelevantDebugLogs(ov || []);
                 const newApiOptions = getApiRelevantDebugLogs(value || []);
 
@@ -288,7 +286,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                             // Trigger reconnection
                             await this.ensureClient();
                         } catch (e) {
-                            this.getBaichuanLogger().warn('Failed to reset client after debug logs change', e);
+                            logger.warn('Failed to reset client after debug logs change', e);
                         }
                     }, 2000);
                 }
@@ -524,14 +522,16 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     resetBaichuanClient?(reason?: any): Promise<void>;
 
     protected nvrDevice?: ReolinkNativeNvrDevice;
+    protected multiFocalDevice?: ReolinkNativeMultiFocalDevice;
     thisDevice: Settings
 
     constructor(nativeId: string, public plugin: ReolinkNativePlugin, public options: CommonCameraMixinOptions) {
         super(nativeId);
-        this.protocol = !options.nvrDevice && options.type === 'battery' ? 'udp' : 'tcp';
+        this.protocol = !options.nvrDevice && !options.multiFocalDevice && options.type === 'battery' ? 'udp' : 'tcp';
 
         // Store NVR device reference if provided
         this.nvrDevice = options.nvrDevice;
+        this.multiFocalDevice = options.multiFocalDevice;
         this.thisDevice = sdk.systemManager.getDeviceById<Settings>(this.id);
 
         setTimeout(async () => {
@@ -691,6 +691,8 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     }
 
     onSimpleEvent = (ev: ReolinkSimpleEvent) => {
+        const logger = this.getBaichuanLogger();
+
         try {
             const logger = this.getBaichuanLogger();
 
@@ -737,12 +739,12 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             });
         }
         catch (e) {
-            this.getBaichuanLogger().warn('Error in onSimpleEvent handler', e);
+            logger.warn('Error in onSimpleEvent handler', e);
         }
     }
 
     async subscribeToEvents(): Promise<void> {
-        if (this.nvrDevice) {
+        if (this.nvrDevice || this.multiFocalDevice) {
             return;
         }
 
@@ -832,6 +834,8 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
 
     // PanTiltZoom interface implementation
     async ptzCommand(command: PanTiltZoomCommand): Promise<void> {
+        const logger = this.getBaichuanLogger();
+
         const client = await this.ensureClient();
         if (!client) {
             return;
@@ -844,13 +848,13 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         if (preset !== undefined && preset !== null) {
             const presetId = Number(preset);
             if (!Number.isFinite(presetId)) {
-                this.getBaichuanLogger().warn(`Invalid PTZ preset id: ${preset}`);
+                logger.warn(`Invalid PTZ preset id: ${preset}`);
                 return;
             }
             if (this.ptzPresets) {
                 await this.ptzPresets.moveToPreset(presetId);
             } else {
-                this.getBaichuanLogger().warn('PTZ presets not available');
+                logger.warn('PTZ presets not available');
             }
             return;
         }
@@ -885,14 +889,14 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
 
             const step = Number(this.storageSettings.values.ptzZoomStep);
             if (!Number.isFinite(step) || step <= 0) {
-                this.getBaichuanLogger().warn('Invalid PTZ zoom step, using default 0.1');
+                logger.warn('Invalid PTZ zoom step, using default 0.1');
                 return;
             }
 
             // Get current zoom factor and apply step
             const info = await client.getZoomFocus(channel);
             if (!info?.zoom) {
-                this.getBaichuanLogger().warn('Zoom command requested but camera did not report zoom support.');
+                logger.warn('Zoom command requested but camera did not report zoom support.');
                 return;
             }
 
@@ -1100,18 +1104,22 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     }
 
     async updateDeviceInfo(): Promise<void> {
+        const logger = this.getBaichuanLogger();
+
         const { ipAddress, rtspChannel } = this.storageSettings.values;
         try {
             const api = await this.ensureClient();
-            const deviceData = await api.getInfo(this.nvrDevice ? rtspChannel : undefined);
+            const deviceData = await api.getInfo((this.nvrDevice || this.multiFocalDevice) ? rtspChannel : undefined);
 
             await updateDeviceInfo({
                 device: this,
                 ipAddress,
                 deviceData,
             });
+
+            logger.log(`Device info updated: ${JSON.stringify(deviceData)}`);
         } catch (e) {
-            this.getBaichuanLogger().warn('Failed to fetch device info', e);
+            logger.warn('Failed to fetch device info', e);
         }
     }
 
@@ -1187,6 +1195,8 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
      * This should be called periodically for regular cameras and once when battery cameras wake up.
      */
     async alignAuxDevicesState(): Promise<void> {
+        const logger = this.getBaichuanLogger();
+
         const api = this.baichuanApi;
         if (!api) return;
 
@@ -1200,7 +1210,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                     const sirenState = await api.getSiren(channel);
                     this.siren.on = sirenState.enabled;
                 } catch (e) {
-                    this.getBaichuanLogger().debug('Failed to align siren state', e);
+                    logger.debug('Failed to align siren state', e);
                 }
             }
 
@@ -1213,7 +1223,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                         this.floodlight.brightness = wl.brightness;
                     }
                 } catch (e) {
-                    this.getBaichuanLogger().debug('Failed to align floodlight state', e);
+                    logger.debug('Failed to align floodlight state', e);
                 }
             }
 
@@ -1237,16 +1247,18 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                         }
                     }
                 } catch (e) {
-                    this.getBaichuanLogger().debug('Failed to align PIR state', e);
+                    logger.debug('Failed to align PIR state', e);
                 }
             }
         } catch (e) {
-            this.getBaichuanLogger().debug('Failed to align auxiliary devices state', e);
+            logger.debug('Failed to align auxiliary devices state', e);
         }
     }
 
     // Video stream helper methods
     protected addRtspCredentials(rtspUrl: string): string {
+        const logger = this.getBaichuanLogger();
+
         const { username, password } = this.storageSettings.values;
         if (!username) {
             return rtspUrl;
@@ -1271,7 +1283,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             return url.toString();
         } catch (e) {
             // If URL parsing fails, return original URL
-            this.getBaichuanLogger().warn('Failed to parse URL for credentials', e);
+            logger.warn('Failed to parse URL for credentials', e);
             return rtspUrl;
         }
     }
@@ -1289,6 +1301,8 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     }
 
     protected async ensureNetPortCache(): Promise<void> {
+        const logger = this.getBaichuanLogger();
+
         if (this.cachedNetPort) {
             return;
         }
@@ -1312,7 +1326,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         } catch (e) {
             // Only log if it's not a recoverable error to avoid spam
             if (!this.isRecoverableBaichuanError?.(e)) {
-                this.getBaichuanLogger().warn('Failed to get net port, using defaults', e);
+                logger.warn('Failed to get net port, using defaults', e);
             }
             // Use defaults if we can't get the ports
             this.cachedNetPort = {
@@ -1368,7 +1382,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         }
 
         if (streams.length) {
-            this.getBaichuanLogger().log('Fetched video stream options', { streams, netPort: this.cachedNetPort });
+            logger.log('Fetched video stream options', { streams, netPort: this.cachedNetPort });
             this.cachedVideoStreamOptions = streams;
             return streams;
         }
@@ -1443,6 +1457,9 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         if (this.nvrDevice) {
             return await this.nvrDevice.ensureBaichuanClient();
         }
+        if (this.multiFocalDevice) {
+            return await this.multiFocalDevice.ensureBaichuanClient();
+        }
 
         // Use base class implementation
         return await this.ensureBaichuanClient();
@@ -1497,14 +1514,14 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                     info: this.info,
                 };
 
-                this.getBaichuanLogger().log(`Updating device interfaces: ${JSON.stringify(device)}`);
+                logger.log(`Updating device interfaces: ${JSON.stringify(device)}`);
 
                 await sdk.deviceManager.onDeviceDiscovered(device);
             } catch (e) {
-                this.getBaichuanLogger().error('Failed to update device interfaces', e);
+                logger.error('Failed to update device interfaces', e);
             }
 
-            this.getBaichuanLogger().log(`Refreshed device capabilities: ${JSON.stringify({ capabilities, abilities, support, presets })}`);
+            logger.log(`Refreshed device capabilities: ${JSON.stringify({ capabilities, abilities, support, presets })}`);
         }
         catch (e) {
             logger.error('Failed to refresh abilities', e);
@@ -1566,7 +1583,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
 
         this.streamManager = new StreamManager({
             createStreamClient: () => this.createStreamClient(),
-            getLogger: () => this.getBaichuanLogger() as Console,
+            getLogger: () => logger as Console,
             credentials: {
                 username,
                 password
@@ -1604,9 +1621,8 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             logger.warn('Failed to subscribe to Baichuan events', e);
         }
 
-        const { isFromNvr } = this.storageSettings.values;
 
-        if (isFromNvr && this.nvrDevice) {
+        if (this.nvrDevice) {
             this.storageSettings.settings.username.hide = true;
             this.storageSettings.settings.password.hide = true;
             this.storageSettings.settings.ipAddress.hide = true;
@@ -1617,6 +1633,17 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             this.storageSettings.settings.ipAddress.defaultValue = this.nvrDevice.storageSettings.values.ipAddress;
         }
 
+        if (this.multiFocalDevice) {
+            this.storageSettings.settings.username.hide = true;
+            this.storageSettings.settings.password.hide = true;
+            this.storageSettings.settings.ipAddress.hide = true;
+            this.storageSettings.settings.uid.hide = true;
+
+            this.storageSettings.settings.username.defaultValue = this.multiFocalDevice.storageSettings.values.username;
+            this.storageSettings.settings.password.defaultValue = this.multiFocalDevice.storageSettings.values.password;
+            this.storageSettings.settings.ipAddress.defaultValue = this.multiFocalDevice.storageSettings.values.ipAddress;
+        }
+
         await this.init();
         this.initComplete = true;
     }

package/src/connect.ts

@@ -1,4 +1,4 @@
-import type { BaichuanClientOptions, ReolinkBaichuanApi } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
+import type { BaichuanClientOptions, ReolinkBaichuanApi, ReolinkDeviceInfo } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
 
 export type BaichuanTransport = "tcp" | "udp";
 
@@ -116,13 +116,13 @@ export type UdpFallbackInfo = {
     tcpError: unknown;
 };
 
-export type DeviceType = 'camera' | 'battery-cam' | 'nvr';
+export type DeviceType = 'camera' | 'battery-cam' | 'nvr' | 'multifocal';
 
 export type AutoDetectResult = {
     type: DeviceType;
     transport: BaichuanTransport;
-    uid?: string;
-    deviceInfo?: Record<string, string>;
+    uid: string;
+    deviceInfo?: ReolinkDeviceInfo;
     channelNum?: number;
 };
 
@@ -134,7 +134,7 @@ async function pingHost(host: string, timeoutMs: number = 3000): Promise<boolean
         const { exec } = require('child_process');
         const platform = process.platform;
         const pingCmd = platform === 'win32' ? `ping -n 1 -w ${timeoutMs} ${host}` : `ping -c 1 -W ${Math.floor(timeoutMs / 1000)} ${host}`;
-        
+
         exec(pingCmd, (error: any) => {
             resolve(!error);
         });
@@ -173,13 +173,26 @@ export async function autoDetectDeviceType(
         });
         await tcpApi.login();
 
-        // Get device info to check if it's an NVR
+        // Get device info to check device type
         const deviceInfo = await tcpApi.getInfo();
         const { support } = await tcpApi.getDeviceCapabilities(0);
         const channelNum = support?.channelNum ?? 1;
 
         logger.log(`[AutoDetect] TCP connection successful. channelNum=${channelNum}`);
 
+        // Multi-focal devices have 2 or 3 channels
+        if (channelNum === 2 || channelNum === 3) {
+            logger.log(`[AutoDetect] Detected multi-focal device (${channelNum} channels, channelNum=${channelNum})`);
+            await tcpApi.close();
+            return {
+                type: 'multifocal',
+                transport: 'tcp',
+                uid: uid || '',
+                deviceInfo,
+                channelNum,
+            };
+        }
+
         // If channelNum > 1, it's likely an NVR
         if (channelNum > 1) {
             logger.log(`[AutoDetect] Detected NVR (${channelNum} channels)`);
@@ -187,6 +200,7 @@ export async function autoDetectDeviceType(
             return {
                 type: 'nvr',
                 transport: 'tcp',
+                uid: uid || '',
                 deviceInfo,
                 channelNum,
             };
@@ -198,6 +212,7 @@ export async function autoDetectDeviceType(
         return {
             type: 'camera',
             transport: 'tcp',
+            uid: uid || '',
             deviceInfo,
             channelNum: 1,
         };
@@ -233,6 +248,23 @@ export async function autoDetectDeviceType(
             await udpApi.login();
 
             const deviceInfo = await udpApi.getInfo();
+            const { support } = await udpApi.getDeviceCapabilities(0);
+            const channelNum = support?.channelNum ?? 1;
+
+            // Multi-focal devices can also be UDP (battery multi-focal cameras)
+            if (channelNum === 2 || channelNum === 3) {
+                logger.log(`[AutoDetect] UDP connection successful. Detected multi-focal device (${channelNum} channels).`);
+                await udpApi.close();
+                return {
+                    type: 'multifocal',
+                    transport: 'udp',
+                    uid: normalizedUid,
+                    deviceInfo,
+                    channelNum,
+                };
+            }
+
+            // Regular battery camera
             logger.log(`[AutoDetect] UDP connection successful. Detected battery camera.`);
             await udpApi.close();
 
@@ -251,47 +283,3 @@ export async function autoDetectDeviceType(
         }
     }
 }
-
-// export async function connectBaichuanWithTcpUdpFallback(
-//     inputs: BaichuanConnectInputs,
-//     onUdpFallback?: (info: UdpFallbackInfo) => void,
-// ): Promise<{ api: ReolinkBaichuanApi; transport: BaichuanTransport }> {
-//     let tcpApi: ReolinkBaichuanApi | undefined;
-//     try {
-//         tcpApi = await createBaichuanApi(inputs, "tcp");
-//         await tcpApi.login();
-//         return { api: tcpApi, transport: "tcp" };
-//     }
-//     catch (e) {
-//         try {
-//             await tcpApi?.close();
-//         }
-//         catch {
-//             // ignore
-//         }
-
-//         if (!isTcpFailureThatShouldFallbackToUdp(e)) {
-//             throw e;
-//         }
-
-//         const uid = normalizeUid(inputs.uid);
-//         const uidMissing = !uid;
-
-//         onUdpFallback?.({
-//             host: inputs.host,
-//             uid,
-//             uidMissing,
-//             tcpError: e,
-//         });
-
-//         if (uidMissing) {
-//             throw new Error(
-//                 `Baichuan TCP failed and this camera likely requires UDP/BCUDP. Set the Reolink UID in settings to continue (ip=${inputs.host}).`,
-//             );
-//         }
-
-//         const udpApi = await createBaichuanApi(inputs, "udp");
-//         await udpApi.login();
-//         return { api: udpApi, transport: "udp" };
-//     }
-// }

package/src/main.ts

@@ -1,12 +1,15 @@
-import sdk, { DeviceCreator, DeviceCreatorSettings, DeviceInformation, DeviceProvider, ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, ScryptedNativeId, Setting } from "@scrypted/sdk";
+import sdk, { DeviceCreator, DeviceCreatorSettings, DeviceInformation, DeviceProvider, ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, ScryptedNativeId, Setting, Settings } from "@scrypted/sdk";
 import { ReolinkNativeCamera } from "./camera";
 import { ReolinkNativeBatteryCamera } from "./camera-battery";
 import { ReolinkNativeNvrDevice } from "./nvr";
-import { autoDetectDeviceType, createBaichuanApi } from "./connect";
-import { getDeviceInterfaces } from "./utils";
+import { ReolinkNativeMultiFocalDevice } from "./multifocal";
+import { autoDetectDeviceType, createBaichuanApi, type BaichuanTransport } from "./connect";
+import { batteryCameraSuffix, cameraSuffix, getDeviceInterfaces, multifocalSuffix, nvrSuffix } from "./utils";
+import { BaseBaichuanClass } from "./baichuan-base";
+import { CommonCameraMixin } from "./common";
 
 class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider, DeviceCreator {
-    devices = new Map<string, ReolinkNativeCamera | ReolinkNativeBatteryCamera | ReolinkNativeNvrDevice>();
+    devices = new Map<string, BaseBaichuanClass>();
     nvrDeviceId: string;
 
     constructor(nativeId: string) {
@@ -20,7 +23,7 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
         return 'Reolink Native camera';
     }
 
-    async getDevice(nativeId: ScryptedNativeId): Promise<ReolinkNativeCamera | ReolinkNativeBatteryCamera | ReolinkNativeNvrDevice> {
+    async getDevice(nativeId: ScryptedNativeId): Promise<BaseBaichuanClass> {
         if (this.devices.has(nativeId)) {
             return this.devices.get(nativeId)!;
         }
@@ -55,12 +58,51 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
 
         this.console.log(`[AutoDetect] Detected device type: ${detection.type} (transport: ${detection.transport})`);
 
+        // 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()}`;
+            nativeId = `${serialNumber}${multifocalSuffix}`;
+
+            settings.newCamera ||= name;
+
+            await sdk.deviceManager.onDeviceDiscovered({
+                nativeId,
+                name,
+                interfaces: [
+                    ScryptedInterface.Settings,
+                    ScryptedInterface.DeviceDiscovery,
+                    ScryptedInterface.DeviceProvider,
+                    ScryptedInterface.Reboot,
+                ],
+                type: ScryptedDeviceType.DeviceProvider,
+                providerNativeId: this.nativeId,
+            });
+
+            const device = await this.getDevice(nativeId);
+            if (!(device instanceof ReolinkNativeMultiFocalDevice)) {
+                throw new Error('Expected multi-focal device but got different type');
+            }
+            device.storageSettings.values.ipAddress = ipAddress;
+            device.storageSettings.values.username = username;
+            device.storageSettings.values.password = password;
+            device.storageSettings.values.uid = detection.uid || '';
+            
+            // Update the protocol based on detection result
+            // Note: This requires updating the protocol property, but it's readonly
+            // The transport is already set in the constructor during createDevice
+            // For now, we'll rely on the constructor parameter
+
+            return nativeId;
+        }
+
         // 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}-nvr`;
+            nativeId = `${serialNumber}${nvrSuffix}`;
 
             settings.newCamera ||= name;
 
@@ -95,9 +137,9 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
 
         // Create nativeId based on device type
         if (detection.type === 'battery-cam') {
-            nativeId = `${serialNumber}-battery-cam`;
+            nativeId = `${serialNumber}${batteryCameraSuffix}`;
         } else {
-            nativeId = `${serialNumber}-cam`;
+            nativeId = `${serialNumber}${cameraSuffix}`;
         }
 
         settings.newCamera ||= name;
@@ -135,13 +177,8 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
                 providerNativeId: this.nativeId,
             });
 
-            const device = await this.getDevice(nativeId);
-            if (device instanceof ReolinkNativeNvrDevice) {
-                // NVR devices are handled separately above
-                throw new Error('NVR device should not reach this code path');
-            }
+            const device = await this.getDevice(nativeId) as CommonCameraMixin;
 
-            // Type guard: device is either ReolinkNativeCamera or ReolinkNativeBatteryCamera
             device.info = deviceInfo;
             device.classes = objects;
             device.presets = presets;
@@ -198,10 +235,16 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
     }
 
     createCamera(nativeId: string) {
-        if (nativeId.endsWith('-battery-cam')) {
+        if (nativeId.endsWith(batteryCameraSuffix)) {
             return new ReolinkNativeBatteryCamera(nativeId, this);
-        } else if (nativeId.endsWith('-nvr')) {
+        } else if (nativeId.endsWith(nvrSuffix)) {
             return new ReolinkNativeNvrDevice(nativeId, this);
+        } else if (nativeId.endsWith(multifocalSuffix)) {
+            // Get transport from device settings if available, otherwise default to TCP
+            // The transport is determined during autoDetect and should be stored
+            // For now, we'll try to infer from UID presence (if UID is set, likely UDP)
+            // Default to TCP for now - the transport will be set correctly during createDevice
+            return new ReolinkNativeMultiFocalDevice(nativeId, this, 'tcp');
         } else {
             return new ReolinkNativeCamera(nativeId, this);
         }