@apocaliss92/scrypted-reolink-native 0.1.2 → 0.1.4

package/src/connect.ts

@@ -86,8 +86,6 @@ export async function createBaichuanApi(props: {
         }
     };
 
-    logger.log('Connecting with options:', JSON.stringify(base, null, 2));
-
     if (transport === "tcp") {
         const api = new ReolinkBaichuanApi({
             ...base,
@@ -119,6 +117,142 @@ export type UdpFallbackInfo = {
     tcpError: unknown;
 };
 
+export type DeviceType = 'camera' | 'battery-cam' | 'nvr';
+
+export type AutoDetectResult = {
+    type: DeviceType;
+    transport: BaichuanTransport;
+    uid?: string;
+    deviceInfo?: Record<string, string>;
+    channelNum?: number;
+};
+
+/**
+ * Simple ping check to verify IP is reachable
+ */
+async function pingHost(host: string, timeoutMs: number = 3000): Promise<boolean> {
+    return new Promise((resolve) => {
+        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);
+        });
+    });
+}
+
+/**
+ * Auto-detect device type by trying TCP first, then UDP if needed.
+ * - First: Ping the IP to verify it's reachable
+ * - TCP success: Check if NVR (multiple channels) or regular camera
+ * - TCP failure: Try UDP (always battery camera)
+ */
+export async function autoDetectDeviceType(
+    inputs: BaichuanConnectInputs,
+    logger: Console,
+): Promise<AutoDetectResult> {
+    const { host, username, password, uid } = inputs;
+
+    // Ping the host first to verify it's reachable
+    logger.log(`[AutoDetect] Pinging ${host}...`);
+    const isReachable = await pingHost(host);
+    if (!isReachable) {
+        logger.warn(`[AutoDetect] Host ${host} is not reachable via ping, but continuing with connection attempt...`);
+    } else {
+        logger.log(`[AutoDetect] Host ${host} is reachable`);
+    }
+
+    // Try TCP first
+    let tcpApi: ReolinkBaichuanApi | undefined;
+    try {
+        logger.log(`[AutoDetect] Trying TCP connection to ${host}...`);
+        tcpApi = await createBaichuanApi({
+            inputs: { host, username, password, logger },
+            transport: 'tcp',
+            logger,
+        });
+        await tcpApi.login();
+
+        // Get device info to check if it's an NVR
+        const deviceInfo = await tcpApi.getInfo();
+        const { support } = await tcpApi.getDeviceCapabilities(0);
+        const channelNum = support?.channelNum ?? 1;
+
+        logger.log(`[AutoDetect] TCP connection successful. channelNum=${channelNum}`);
+
+        // If channelNum > 1, it's likely an NVR
+        if (channelNum > 1) {
+            logger.log(`[AutoDetect] Detected NVR (${channelNum} channels)`);
+            await tcpApi.close();
+            return {
+                type: 'nvr',
+                transport: 'tcp',
+                deviceInfo,
+                channelNum,
+            };
+        }
+
+        // Single channel device - regular camera
+        logger.log(`[AutoDetect] Detected regular camera (single channel)`);
+        await tcpApi.close();
+        return {
+            type: 'camera',
+            transport: 'tcp',
+            deviceInfo,
+            channelNum: 1,
+        };
+    } catch (tcpError) {
+        // TCP failed, try UDP (battery camera)
+        if (tcpApi) {
+            try {
+                await tcpApi.close();
+            } catch {
+                // ignore
+            }
+        }
+
+        if (!isTcpFailureThatShouldFallbackToUdp(tcpError)) {
+            // Not a transport error, rethrow
+            throw tcpError;
+        }
+
+        logger.log(`[AutoDetect] TCP failed, trying UDP (battery camera)...`);
+        const normalizedUid = normalizeUid(uid);
+        if (!normalizedUid) {
+            throw new Error(
+                `TCP connection failed and device likely requires UDP/BCUDP. UID is required for battery cameras (ip=${host}).`
+            );
+        }
+
+        try {
+            const udpApi = await createBaichuanApi({
+                inputs: { host, username, password, uid: normalizedUid, logger },
+                transport: 'udp',
+                logger,
+            });
+            await udpApi.login();
+
+            const deviceInfo = await udpApi.getInfo();
+            logger.log(`[AutoDetect] UDP connection successful. Detected battery camera.`);
+            await udpApi.close();
+
+            return {
+                type: 'battery-cam',
+                transport: 'udp',
+                uid: normalizedUid,
+                deviceInfo,
+                channelNum: 1,
+            };
+        } catch (udpError) {
+            logger.error(`[AutoDetect] Both TCP and UDP failed. TCP error: ${tcpError}, UDP error: ${udpError}`);
+            throw new Error(
+                `Failed to connect via both TCP and UDP. TCP: ${(tcpError as any)?.message || tcpError}, UDP: ${(udpError as any)?.message || udpError}`
+            );
+        }
+    }
+}
+
 // export async function connectBaichuanWithTcpUdpFallback(
 //     inputs: BaichuanConnectInputs,
 //     onUdpFallback?: (info: UdpFallbackInfo) => void,

package/src/intercom.ts

@@ -39,7 +39,7 @@ export class ReolinkBaichuanIntercom {
         );
 
         await this.stop();
-        const channel = this.camera.getRtspChannel();
+        const channel = this.camera.storageSettings.values.rtspChannel;
 
         // Best-effort: log codec requirements exposed by the camera.
         // This mirrors neolink's source of truth: TalkAbility (cmd_id=10).

package/src/main.ts

@@ -1,19 +1,20 @@
-import sdk, { DeviceCreator, DeviceCreatorSettings, DeviceInformation, DeviceProvider, ScryptedDeviceBase, ScryptedDeviceType, ScryptedNativeId, Setting } from "@scrypted/sdk";
+import sdk, { DeviceCreator, DeviceCreatorSettings, DeviceInformation, DeviceProvider, ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, ScryptedNativeId, Setting } from "@scrypted/sdk";
 import { ReolinkNativeCamera } from "./camera";
 import { ReolinkNativeBatteryCamera } from "./camera-battery";
-import { createBaichuanApi } from "./connect";
+import { ReolinkNativeNvrDevice } from "./nvr";
+import { autoDetectDeviceType, createBaichuanApi } from "./connect";
 import { getDeviceInterfaces } from "./utils";
 
 class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider, DeviceCreator {
-    devices = new Map<string, ReolinkNativeCamera | ReolinkNativeBatteryCamera>();
+    devices = new Map<string, ReolinkNativeCamera | ReolinkNativeBatteryCamera | ReolinkNativeNvrDevice>();
 
     getScryptedDeviceCreator(): string {
         return 'Reolink Native camera';
     }
 
-    async getDevice(nativeId: ScryptedNativeId): Promise<ReolinkNativeCamera | ReolinkNativeBatteryCamera> {
+    async getDevice(nativeId: ScryptedNativeId): Promise<ReolinkNativeCamera | ReolinkNativeBatteryCamera | ReolinkNativeNvrDevice> {
         if (this.devices.has(nativeId)) {
-            return this.devices.get(nativeId);
+            return this.devices.get(nativeId)!;
         }
 
         const newCamera = this.createCamera(nativeId);
@@ -23,88 +24,145 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
 
     async createDevice(settings: DeviceCreatorSettings, nativeId?: string): Promise<string> {
         const ipAddress = settings.ip?.toString();
-        let info: DeviceInformation = {};
-
         const username = settings.username?.toString();
         const password = settings.password?.toString();
         const uid = settings.uid?.toString();
-        const isBatteryCam = settings.isBatteryCam === true || settings.isBatteryCam?.toString() === 'true';
 
-        if (isBatteryCam && !uid) {
-            throw new Error('UID is required for battery cameras (BCUDP)');
+        if (!ipAddress || !username || !password) {
+            throw new Error('IP address, username, and password are required');
         }
 
-        if (ipAddress && username && password) {
-            const api = await createBaichuanApi(
-                {
-                    transport: isBatteryCam ? 'udp' : 'tcp',
-                    logger: this.console,
-                    inputs: {
-                        host: ipAddress,
-                        username,
-                        password,
-                        uid,
-                        logger: this.console,
-                    }
-                }
-            );
+        // Auto-detect device type (camera, battery-cam, or nvr)
+        this.console.log(`[AutoDetect] Starting device type detection for ${ipAddress}...`);
+        const detection = await autoDetectDeviceType(
+            {
+                host: ipAddress,
+                username,
+                password,
+                uid,
+                logger: this.console,
+            },
+            this.console
+        );
+
+        this.console.log(`[AutoDetect] Detected device type: ${detection.type} (transport: ${detection.transport})`);
+
+        // 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`;
+
+            settings.newCamera ||= name;
+
+            await sdk.deviceManager.onDeviceDiscovered({
+                nativeId,
+                name,
+                interfaces: [
+                    ScryptedInterface.Settings,
+                    ScryptedInterface.DeviceDiscovery,
+                    ScryptedInterface.DeviceProvider,
+                    ScryptedInterface.Reboot,
+                ],
+                type: ScryptedDeviceType.Builtin,
+                providerNativeId: this.nativeId,
+            });
+
+            const device = await this.getDevice(nativeId);
+            if (!(device instanceof ReolinkNativeNvrDevice)) {
+                throw new Error('Expected NVR device but got different type');
+            }
+            device.storageSettings.values.ipAddress = ipAddress;
+            device.storageSettings.values.username = username;
+            device.storageSettings.values.password = password;
+            device.updateDeviceInfo(deviceInfo);
 
-            await api.login();
+            return nativeId;
+        }
 
-            try {
-                const deviceInfo = await api.getInfo();
-                const name = deviceInfo?.name;
-                const rtspChannel = 0;
-                const { abilities, capabilities, objects, presets } = await api.getDeviceCapabilities(rtspChannel);
-
-                this.console.log(JSON.stringify({ abilities, capabilities, deviceInfo }));
-
-                nativeId = `${deviceInfo.serialNumber}${isBatteryCam ? '-battery-cam' : '-cam'}`;
-
-                settings.newCamera ||= name;
-
-                const { interfaces, type } = getDeviceInterfaces({
-                    capabilities,
-                    logger: this.console,
-                });
-
-                await sdk.deviceManager.onDeviceDiscovered({
-                    nativeId,
-                    name,
-                    interfaces,
-                    type,
-                    providerNativeId: this.nativeId,
-                });
-
-                const device = await this.getDevice(nativeId);
-                device.info = info;
-                device.classes = objects;
-                device.presets = presets;
-                device.storageSettings.values.username = username;
-                device.storageSettings.values.password = password;
-                device.storageSettings.values.rtspChannel = rtspChannel;
-                device.storageSettings.values.ipAddress = ipAddress;
-                if (isBatteryCam && uid) (device as ReolinkNativeBatteryCamera).storageSettings.values.uid = uid;
-                device.storageSettings.values.capabilities = capabilities;
-                device.updateDeviceInfo();
-
-                return nativeId;
-            }
-            catch (e) {
-                this.console.error('Error adding Reolink camera', e);
-                await api.close();
-                throw e;
-            }
-            finally {
-                await api.close();
+        // 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}-battery-cam`;
+        } else {
+            nativeId = `${serialNumber}-cam`;
+        }
+
+        settings.newCamera ||= name;
+
+        // Create API connection to get capabilities
+        const api = await createBaichuanApi({
+            inputs: {
+                host: ipAddress,
+                username,
+                password,
+                uid: detection.uid,
+                logger: this.console,
+            },
+            transport: detection.transport,
+            logger: this.console,
+        });
+
+        try {
+            await api.login();
+            const rtspChannel = 0;
+            const { abilities, capabilities, objects, presets } = await api.getDeviceCapabilities(rtspChannel);
+
+            this.console.log(JSON.stringify({ abilities, capabilities, deviceInfo }));
+
+            const { interfaces, type } = getDeviceInterfaces({
+                capabilities,
+                logger: this.console,
+            });
+
+            await sdk.deviceManager.onDeviceDiscovered({
+                nativeId,
+                name,
+                interfaces,
+                type,
+                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');
             }
+
+            // Type guard: device is either ReolinkNativeCamera or ReolinkNativeBatteryCamera
+            device.info = deviceInfo;
+            device.classes = objects;
+            device.presets = presets;
+            device.storageSettings.values.username = username;
+            device.storageSettings.values.password = password;
+            device.storageSettings.values.rtspChannel = rtspChannel;
+            device.storageSettings.values.ipAddress = ipAddress;
+            device.storageSettings.values.capabilities = capabilities;
+            device.storageSettings.values.uid = detection.uid;
+            device.updateDeviceInfo();
+
+            return nativeId;
+        }
+        catch (e) {
+            this.console.error('Error adding Reolink device', e);
+            throw e;
+        }
+        finally {
+            await api.close();
         }
     }
 
     async releaseDevice(id: string, nativeId: ScryptedNativeId): Promise<void> {
         if (this.devices.has(nativeId)) {
             const device = this.devices.get(nativeId);
-            await device.release();
+            if (device && 'release' in device && typeof device.release === 'function') {
+                await device.release();
+            }
             this.devices.delete(nativeId);
         }
     }
@@ -116,12 +174,6 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
                 title: 'IP Address',
                 placeholder: '192.168.2.222',
             },
-            {
-                key: 'isBatteryCam',
-                title: 'Is Battery Camera',
-                description: 'Enable for Reolink battery cameras. Uses UDP/BCUDP for discovery and streaming. Requires UID.',
-                type: 'boolean',
-            },
             {
                 key: 'username',
                 title: 'Username',
@@ -134,7 +186,7 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
             {
                 key: 'uid',
                 title: 'UID',
-                description: 'Reolink UID (required for battery cameras)',
+                description: 'Reolink UID (optional, required for battery cameras if TCP connection fails)',
             }
         ]
     }
@@ -142,8 +194,11 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
     createCamera(nativeId: string) {
         if (nativeId.endsWith('-battery-cam')) {
             return new ReolinkNativeBatteryCamera(nativeId, this);
+        } else if (nativeId.endsWith('-nvr')) {
+            return new ReolinkNativeNvrDevice(nativeId, this);
+        } else {
+            return new ReolinkNativeCamera(nativeId, this);
         }
-        return new ReolinkNativeCamera(nativeId, this);
     }
 }