@apocaliss92/scrypted-reolink-native 0.1.3 → 0.1.5

package/src/common.ts

@@ -6,23 +6,24 @@ import { createBaichuanApi, normalizeUid, type BaichuanTransport } from "./conne
 import { convertDebugLogsToApiOptions, DebugLogOption, getApiRelevantDebugLogs, getDebugLogChoices } from "./debug-options";
 import { ReolinkBaichuanIntercom } from "./intercom";
 import ReolinkNativePlugin from "./main";
+import { ReolinkNativeNvrDevice } from "./nvr";
 import { ReolinkPtzPresets } from "./presets";
 import {
     buildVideoStreamOptionsFromRtspRtmp,
     createRfc4571MediaObjectFromStreamManager,
     expectedVideoTypeFromUrlMediaStreamOptions,
-    fetchVideoStreamOptionsFromApi,
     isNativeStreamId,
     parseStreamProfileFromId,
     selectStreamOption,
-    StreamManager,
+    StreamManager
 } from "./stream-utils";
-import { getDeviceInterfaces } from "./utils";
+import { getDeviceInterfaces, updateDeviceInfo } from "./utils";
 
 export type CameraType = 'battery' | 'regular';
 
 export interface CommonCameraMixinOptions {
     type: CameraType;
+    nvrDevice?: ReolinkNativeNvrDevice; // Optional reference to NVR device
 }
 
 class ReolinkCameraSiren extends ScryptedDeviceBase implements OnOff {
@@ -138,7 +139,7 @@ class ReolinkCameraPirSensor extends ScryptedDeviceBase implements OnOff, Settin
         await this.storageSettings.putSetting(key, value);
 
         // Apply the new settings to the camera
-        const channel = this.camera.getRtspChannel();
+        const channel = this.camera.storageSettings.values.rtspChannel;
         const enabled = this.on ? 1 : 0;
         const sensitive = this.storageSettings.values.sensitive;
         const reduceAlarm = this.storageSettings.values.reduceAlarm ? 1 : 0;
@@ -166,7 +167,7 @@ class ReolinkCameraPirSensor extends ScryptedDeviceBase implements OnOff, Settin
     }
 
     private async updatePirSettings(): Promise<void> {
-        const channel = this.camera.getRtspChannel();
+        const channel = this.camera.storageSettings.values.rtspChannel;
         const enabled = this.on ? 1 : 0;
         const sensitive = this.storageSettings.values.sensitive;
         const reduceAlarm = this.storageSettings.values.reduceAlarm ? 1 : 0;
@@ -227,24 +228,29 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
                 await this.credentialsChanged();
             }
         },
-        mixinsSetup: {
+        isFromNvr: {
             type: 'boolean',
             hide: true,
+            defaultValue: false,
         },
-        snapshotCacheMinutes: {
-            title: "Snapshot Cache Minutes",
-            subgroup: 'Advanced',
-            description: "Return a cached snapshot if taken within the last N minutes.",
-            type: "number",
-            defaultValue: 5,
+        mixinsSetup: {
+            type: 'boolean',
             hide: true,
         },
+        // snapshotCacheMinutes: {
+        //     title: "Snapshot Cache Minutes",
+        //     subgroup: 'Advanced',
+        //     description: "Return a cached snapshot if taken within the last N minutes.",
+        //     type: "number",
+        //     defaultValue: 60,
+        //     hide: true,
+        // },
         batteryUpdateIntervalMinutes: {
             title: "Battery Update Interval (minutes)",
             subgroup: 'Advanced',
-            description: "How often to wake up the camera and update battery status and snapshot (default: 10 minutes).",
+            description: "How often to wake up the camera and update battery status and snapshot (default: 60 minutes).",
             type: "number",
-            defaultValue: 10,
+            defaultValue: 60,
             hide: true,
         },
         // Regular camera specific
@@ -493,21 +499,15 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
     initComplete?: boolean;
     resetBaichuanClient?(reason?: any): Promise<void>;
 
+    protected nvrDevice?: any; // Optional reference to NVR device
+
     constructor(nativeId: string, public plugin: ReolinkNativePlugin, public options: CommonCameraMixinOptions) {
         super(nativeId);
         // Set protocol based on camera type
-        this.protocol = options.type === 'battery' ? 'udp' : 'tcp';
+        this.protocol = !options.nvrDevice && options.type === 'battery' ? 'udp' : 'tcp';
 
-        this.streamManager = new StreamManager({
-            createStreamClient: () => this.createStreamClient(),
-            getLogger: () => this.getLogger(),
-            credentials: {
-                username: this.storageSettings.values.username || '',
-                password: this.storageSettings.values.password || '',
-            },
-            // For battery cameras, we use a shared connection
-            sharedConnection: options.type === 'battery',
-        });
+        // Store NVR device reference if provided
+        this.nvrDevice = options.nvrDevice;
 
         setTimeout(async () => {
             await this.parentInit();
@@ -517,12 +517,6 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
         throw new Error("Method not implemented.");
     }
 
-    // Common method implementations
-    public getRtspChannel(): number {
-        const channel = this.storageSettings.values.rtspChannel;
-        return channel !== undefined ? Number(channel) : 0;
-    }
-
     public getAbilities(): DeviceCapabilities {
         return this.storageSettings.values.capabilities;
     }
@@ -589,7 +583,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
                 return;
             }
 
-            const channel = this.getRtspChannel();
+            const channel = this.storageSettings.values.rtspChannel;
             if (ev?.channel !== undefined && ev.channel !== channel) {
                 if (this.isEventLogsEnabled()) {
                     logger.debug(`Event channel ${ev.channel} does not match camera channel ${channel}, ignoring`);
@@ -637,6 +631,10 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
     }
 
     async subscribeToEvents(): Promise<void> {
+        if (this.nvrDevice) {
+            return;
+        }
+
         const logger = this.getLogger();
         const selection = Array.from(this.getDispatchEventsSelection?.() ?? new Set()).sort();
         const enabled = selection.length > 0;
@@ -676,7 +674,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
     // VideoTextOverlays interface implementation
     async getVideoTextOverlays(): Promise<Record<string, VideoTextOverlay>> {
         const client = await this.ensureClient();
-        const channel = this.getRtspChannel();
+        const channel = this.storageSettings.values.rtspChannel;
 
         let osd = this.storageSettings.values.cachedOsd;
 
@@ -698,7 +696,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
 
     async setVideoTextOverlay(id: 'osdChannel' | 'osdTime', value: VideoTextOverlay): Promise<void> {
         const client = await this.ensureClient();
-        const channel = this.getRtspChannel();
+        const channel = this.storageSettings.values.rtspChannel;
 
         const osd = await client.getOsd(channel);
 
@@ -728,7 +726,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
             return;
         }
 
-        const channel = this.getRtspChannel();
+        const channel = this.storageSettings.values.rtspChannel;
 
         // Preset navigation.
         const preset = command.preset;
@@ -959,9 +957,10 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
         });
     }
 
-    // Settings methods
     async getSettings(): Promise<Setting[]> {
-        return await this.storageSettings.getSettings();
+        const settings = await this.storageSettings.getSettings();
+
+        return settings;
     }
 
     async putSetting(key: string, value: string): Promise<void> {
@@ -989,29 +988,18 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
         }
     }
 
-    // Device info update
     async updateDeviceInfo(): Promise<void> {
-        const ip = this.storageSettings.values.ipAddress;
+        const { ipAddress, rtspChannel } = this.storageSettings.values;
         try {
             const api = await this.ensureClient();
-            const deviceData = await api.getInfo();
-            const info = this.info || {};
-            info.ip = ip;
-
-            info.serialNumber = deviceData?.serialNumber || deviceData?.itemNo;
-            info.firmware = deviceData?.firmwareVersion || deviceData?.firmVer;
-            info.version = deviceData?.hardwareVersion || deviceData?.boardInfo;
-            info.model = deviceData?.type || deviceData?.typeInfo;
-            info.manufacturer = 'Reolink native';
-            info.managementUrl = `http://${ip}`;
-            this.info = info;
+            const deviceData = await api.getInfo(this.nvrDevice ? rtspChannel : undefined);
+
+            await updateDeviceInfo({
+                device: this,
+                ipAddress,
+                deviceData,
+            });
         } catch (e) {
-            // If API call fails, at least set basic info
-            const info = this.info || {};
-            info.ip = ip;
-            info.manufacturer = 'Reolink native';
-            info.managementUrl = `http://${ip}`;
-            this.info = info;
             this.getLogger().warn('Failed to fetch device info', e);
         }
     }
@@ -1041,7 +1029,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
     }
 
     async setSirenEnabled(enabled: boolean): Promise<void> {
-        const channel = this.getRtspChannel();
+        const channel = this.storageSettings.values.rtspChannel;
 
         await this.withBaichuanRetry(async () => {
             const api = await this.ensureClient();
@@ -1050,7 +1038,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
     }
 
     async setFloodlightState(on?: boolean, brightness?: number): Promise<void> {
-        const channel = this.getRtspChannel();
+        const channel = this.storageSettings.values.rtspChannel;
 
         await this.withBaichuanRetry(async () => {
             const api = await this.ensureClient();
@@ -1059,7 +1047,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
     }
 
     async setPirEnabled(enabled: boolean): Promise<void> {
-        const channel = this.getRtspChannel();
+        const channel = this.storageSettings.values.rtspChannel;
 
         // Get current PIR settings from the sensor if available
         let sensitive: number | undefined;
@@ -1091,7 +1079,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
         const api = this.baichuanApi;
         if (!api) return;
 
-        const channel = this.getRtspChannel();
+        const channel = this.storageSettings.values.rtspChannel;
         const { hasSiren, hasFloodlight, hasPir } = this.getAbilities();
 
         try {
@@ -1234,16 +1222,13 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
             return [];
         }
 
-        // while (this.fetchingStreams) {
-        //     await new Promise((resolve) => setTimeout(resolve, 500));
-        // }
         this.fetchingStreams = true;
 
         let streams: UrlMediaStreamOptions[] = [];
 
         const client = await this.ensureClient();
 
-        const { ipAddress, username, password, rtspChannel } = this.storageSettings.values;
+        const { ipAddress, rtspChannel, isFromNvr } = this.storageSettings.values;
 
         try {
             await this.ensureNetPortCache();
@@ -1255,12 +1240,14 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
 
         try {
             streams = await buildVideoStreamOptionsFromRtspRtmp(
-                client,
-                rtspChannel,
-                ipAddress,
-                username,
-                password,
-                this.cachedNetPort,
+                {
+                    client,
+                    ipAddress,
+                    cachedNetPort: this.cachedNetPort,
+                    isFromNvr,
+                    rtspChannel,
+                    logger,
+                },
             );
         } catch (e) {
             if (!this.isRecoverableBaichuanError?.(e)) {
@@ -1269,12 +1256,8 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
             this.cachedNetPort = undefined;
         }
 
-
-        const nativeStreams = await fetchVideoStreamOptionsFromApi(client, rtspChannel, this.getLogger());
-        streams = [...streams, ...nativeStreams];
-
         if (streams.length) {
-            logger.log('Fetched video stream options', streams);
+            logger.log('Fetched video stream options', { streams, netPort: this.cachedNetPort });
             this.cachedVideoStreamOptions = streams;
             return streams;
         }
@@ -1308,7 +1291,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
         }
 
         const profile = parseStreamProfileFromId(selected.id) || 'main';
-        const channel = this.getRtspChannel();
+        const channel = this.storageSettings.values.rtspChannel;
         const streamKey = `${channel}_${profile}`;
         const expectedVideoType = expectedVideoTypeFromUrlMediaStreamOptions(selected);
 
@@ -1356,10 +1339,6 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
         this.ensureClientPromise = (async () => {
             const { ipAddress, username, password, uid } = this.storageSettings.values;
 
-            if (!ipAddress || !username || !password) {
-                throw new Error('Missing camera credentials');
-            }
-
             // Only tear down previous session if it exists and is not connected
             if (this.baichuanApi) {
                 const isConnected = this.baichuanApi.client.isSocketConnected();
@@ -1409,8 +1388,8 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
                 {
                     inputs: {
                         host: ipAddress,
-                        username,
-                        password,
+                        username: username,
+                        password: password,
                         uid: normalizedUid,
                         logger: this.console,
                         debugOptions,
@@ -1472,7 +1451,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
         this.refreshingState = true;
 
         const logger = this.getLogger();
-        const channel = this.getRtspChannel();
+        const channel = this.storageSettings.values.rtspChannel;
 
         try {
             const { capabilities, abilities, support, presets, objects } = await this.withBaichuanRetry(async () => {
@@ -1492,7 +1471,7 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
 
                 const device: Device = {
                     nativeId: this.nativeId,
-                    providerNativeId: this.plugin?.nativeId,
+                    providerNativeId: this.nvrDevice?.nativeId ?? this.plugin?.nativeId,
                     name: this.name,
                     interfaces,
                     type,
@@ -1564,8 +1543,21 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
         }
 
         const isBattery = this.options.type === 'battery';
+        const { username, password } = this.storageSettings.values;
 
-        this.storageSettings.settings.snapshotCacheMinutes.hide = !isBattery;
+        this.streamManager = new StreamManager({
+            createStreamClient: () => this.createStreamClient(),
+            getLogger: () => this.getLogger(),
+            credentials: {
+                username,
+                password
+            },
+            // For battery cameras, we use a shared connection
+            sharedConnection: isBattery,
+        });
+
+
+        // this.storageSettings.settings.snapshotCacheMinutes.hide = !isBattery;
         this.storageSettings.settings.uid.hide = !isBattery;
         this.storageSettings.settings.batteryUpdateIntervalMinutes.hide = !isBattery;
 
@@ -1591,6 +1583,19 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
             logger.warn('Failed to subscribe to Baichuan events', e);
         }
 
+        const { isFromNvr } = this.storageSettings.values;
+
+        if (isFromNvr && this.nvrDevice) {
+            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.nvrDevice.storageSettings.values.username;
+            this.storageSettings.settings.password.defaultValue = this.nvrDevice.storageSettings.values.password;
+            this.storageSettings.settings.ipAddress.defaultValue = this.nvrDevice.storageSettings.values.ipAddress;
+        }
+
         await this.init();
         this.initComplete = true;
     }

package/src/connect.ts

@@ -117,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).