@apocaliss92/scrypted-reolink-native 0.1.3 → 0.1.5

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,143 @@ 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;
 
-            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;
+
+            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 +172,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 +184,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 +192,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);
     }
 }
 

package/src/nvr.ts

@@ -0,0 +1,367 @@
+import type { DeviceInfoResponse, DeviceInputData, ReolinkCgiApi } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
+import sdk, { AdoptDevice, Device, DeviceDiscovery, DeviceProvider, DiscoveredDevice, Reboot, ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, Setting, Settings, SettingValue } from "@scrypted/sdk";
+import { StorageSettings } from "@scrypted/sdk/storage-settings";
+import { ReolinkNativeCamera } from "./camera";
+import { ReolinkNativeBatteryCamera } from "./camera-battery";
+import { normalizeUid } from "./connect";
+import ReolinkNativePlugin from "./main";
+import { getDeviceInterfaces, updateDeviceInfo } from "./utils";
+
+export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settings, DeviceDiscovery, DeviceProvider, Reboot {
+    storageSettings = new StorageSettings(this, {
+        debugEvents: {
+            title: 'Debug Events',
+            type: 'boolean',
+            immediate: true,
+        },
+        ipAddress: {
+            title: 'IP address',
+            type: 'string',
+            onPut: async () => await this.reinit()
+        },
+        username: {
+            title: 'Username',
+            placeholder: 'admin',
+            defaultValue: 'admin',
+            type: 'string',
+            onPut: async () => await this.reinit()
+        },
+        password: {
+            title: 'Password',
+            type: 'password',
+            onPut: async () => await this.reinit()
+        },
+    });
+    plugin: ReolinkNativePlugin;
+    nvrApi: ReolinkCgiApi | undefined;
+    discoveredDevices = new Map<string, {
+        device: Device;
+        description: string;
+        rtspChannel: number;
+        deviceData: DeviceInfoResponse;
+    }>();
+    lastHubInfoCheck: number | undefined;
+    lastErrorsCheck: number | undefined;
+    lastDevicesStatusCheck: number | undefined;
+    cameraNativeMap = new Map<string, ReolinkNativeCamera | ReolinkNativeBatteryCamera>();
+    processing = false;
+
+    constructor(nativeId: string, plugin: ReolinkNativePlugin) {
+        super(nativeId);
+        this.plugin = plugin;
+
+        setTimeout(async () => {
+            await this.init();
+        }, 5000);
+    }
+
+    async reboot(): Promise<void> {
+        const api = await this.ensureClient();
+        await api.Reboot();
+    }
+
+    getLogger() {
+        return this.console;
+    }
+
+    async reinit() {
+        if (this.nvrApi) {
+            try {
+                await this.nvrApi.logout();
+            } catch {
+                // ignore
+            }
+        }
+        this.nvrApi = undefined;
+    }
+
+    async ensureClient(): Promise<ReolinkCgiApi> {
+        if (this.nvrApi) {
+            return this.nvrApi;
+        }
+
+        const { ipAddress, username, password } = this.storageSettings.values;
+        if (!ipAddress || !username || !password) {
+            throw new Error('Missing NVR credentials');
+        }
+
+        const { ReolinkCgiApi } = await import("@apocaliss92/reolink-baichuan-js");
+        this.nvrApi = new ReolinkCgiApi({
+            host: ipAddress,
+            username,
+            password,
+        });
+
+        await this.nvrApi.login();
+        return this.nvrApi;
+    }
+
+    async init() {
+        const api = await this.ensureClient();
+        const logger = this.getLogger();
+        await this.updateDeviceInfo();
+
+        setInterval(async () => {
+            if (this.processing || !api) {
+                return;
+            }
+            this.processing = true;
+            try {
+                const now = Date.now();
+
+                if (!this.lastErrorsCheck || (now - this.lastErrorsCheck > 60 * 1000)) {
+                    this.lastErrorsCheck = now;
+                    // Note: ReolinkCgiApi doesn't have checkErrors, skip for now
+                }
+
+                if (!this.lastHubInfoCheck || now - this.lastHubInfoCheck > 1000 * 60 * 5) {
+                    logger.log('Starting Hub info data fetch');
+                    this.lastHubInfoCheck = now;
+                    const { hubData } = await api.getHubInfo();
+                    const { devicesData, channelsResponse, response } = await api.getDevicesInfo();
+                    logger.log('Hub info data fetched');
+                    if (this.storageSettings.values.debugEvents) {
+                        logger.log(`${JSON.stringify({ hubData, devicesData, channelsResponse, response })}`);
+                    }
+
+                    await this.discoverDevices(true);
+                }
+
+                const eventsRes = await api.getAllChannelsEvents();
+
+                if (this.storageSettings.values.debugEvents) {
+                    logger.debug(`Events call result: ${JSON.stringify(eventsRes)}`);
+                }
+                this.cameraNativeMap.forEach((camera) => {
+                    if (camera) {
+                        const channel = camera.storageSettings.values.rtspChannel;
+                        const cameraEventsData = eventsRes?.parsed[channel];
+                        if (cameraEventsData) {
+                            camera.processEvents(cameraEventsData);
+                        }
+                    }
+                });
+
+                const { batteryInfoData, response } = await api.getAllChannelsBatteryInfo();
+
+                if (this.storageSettings.values.debugEvents) {
+                    logger.debug(`Battery info call result: ${JSON.stringify({ batteryInfoData, response })}`);
+                }
+
+                this.cameraNativeMap.forEach((camera) => {
+                    if (camera) {
+                        const channel = camera.storageSettings.values.rtspChannel;
+                        const cameraBatteryData = batteryInfoData[channel];
+                        if (cameraBatteryData) {
+                            (camera as ReolinkNativeBatteryCamera).updateSleepingState({
+                                reason: 'NVR',
+                                state: cameraBatteryData.sleeping ? 'sleeping' : 'awake',
+                                idleMs: 0,
+                                lastRxAtMs: 0,
+                            }).catch(() => { });
+                        }
+                    }
+                });
+            } catch (e) {
+                this.console.error('Error on events flow', e);
+            } finally {
+                this.processing = false;
+            }
+        }, 1000);
+    }
+
+    async updateDeviceInfo(): Promise<void> {
+        const { ipAddress } = this.storageSettings.values;
+        try {
+            const api = await this.ensureClient();
+            const deviceData = await api.getInfo();
+
+            await updateDeviceInfo({
+                device: this,
+                ipAddress,
+                deviceData,
+            });
+        } catch (e) {
+            this.getLogger().warn('Failed to fetch device info', e);
+        }
+    }
+
+    async getSettings(): Promise<Setting[]> {
+        const settings = await this.storageSettings.getSettings();
+        return settings;
+    }
+
+    async putSetting(key: string, value: SettingValue): Promise<void> {
+        return this.storageSettings.putSetting(key, value);
+    }
+
+    async releaseDevice(id: string, nativeId: string) {
+        this.cameraNativeMap.delete(nativeId);
+    }
+
+    async getDevice(nativeId: string): Promise<ReolinkNativeCamera | ReolinkNativeBatteryCamera> {
+        let device = this.cameraNativeMap.get(nativeId);
+
+        if (!device) {
+            if (nativeId.endsWith('-battery-cam')) {
+                device = new ReolinkNativeBatteryCamera(nativeId, this.plugin, this);
+            } else {
+                device = new ReolinkNativeCamera(nativeId, this.plugin, this);
+            }
+            this.cameraNativeMap.set(nativeId, device);
+        }
+
+        return device;
+    }
+
+    buildNativeId(channel: number, serialNumber?: string, isBattery?: boolean): string {
+        const suffix = isBattery ? '-battery-cam' : '-cam';
+        if (serialNumber) {
+            return `${this.nativeId}-ch${channel}-${serialNumber}${suffix}`;
+        }
+        return `${this.nativeId}-ch${channel}${suffix}`;
+    }
+
+    getCameraInterfaces() {
+        return [
+            ScryptedInterface.VideoCameraConfiguration,
+            ScryptedInterface.Camera,
+            ScryptedInterface.MotionSensor,
+            ScryptedInterface.VideoTextOverlays,
+            ScryptedInterface.VideoCamera,
+            ScryptedInterface.Settings,
+            ScryptedInterface.ObjectDetector,
+        ];
+    }
+
+    async syncEntitiesFromRemote() {
+        const api = await this.ensureClient();
+        const logger = this.getLogger();
+
+        logger.log('Starting channels discovery using getDevicesInfo...');
+
+        const { devicesData, channels } = await api.getDevicesInfo();
+
+        logger.log(`getDevicesInfo completed. Found ${channels.length} channels.`);
+
+        // Process each channel that was successfully discovered
+        for (const channel of channels) {
+            try {
+                const { channelStatus, channelInfo, abilities } = devicesData[channel];
+                const name = channelStatus?.name;
+                const uid = channelStatus?.uid;
+                const isBattery = !!(abilities?.battery?.ver ?? 0);
+
+                const nativeId = this.buildNativeId(channel, uid, isBattery);
+                const interfaces = [ScryptedInterface.VideoCamera];
+                if (isBattery) {
+                    interfaces.push(ScryptedInterface.Battery);
+                }
+                const type = abilities.supportDoorbellLight ? ScryptedDeviceType.Doorbell : ScryptedDeviceType.Camera;
+
+                const device: Device = {
+                    nativeId,
+                    name,
+                    providerNativeId: this.nativeId,
+                    interfaces,
+                    type,
+                    info: {
+                        manufacturer: 'Reolink',
+                        model: channelInfo?.typeInfo,
+                        serialNumber: uid,
+                    }
+                };
+
+                if (sdk.deviceManager.getNativeIds().includes(nativeId)) {
+                    continue;
+                }
+
+                if (this.discoveredDevices.has(nativeId)) {
+                    continue;
+                }
+
+                this.discoveredDevices.set(nativeId, {
+                    device,
+                    description: `${name} (Channel ${channel})`,
+                    rtspChannel: channel,
+                    deviceData: devicesData[channel],
+                });
+
+                logger.debug(`Discovered channel ${channel}: ${name}`);
+            } catch (e: any) {
+                logger.debug(`Error processing channel ${channel}: ${e?.message || String(e)}`);
+            }
+        }
+
+        logger.log(`Channel discovery completed. Found ${this.discoveredDevices.size} devices.`);
+    }
+
+    async discoverDevices(scan?: boolean): Promise<DiscoveredDevice[]> {
+        if (scan) {
+            await this.syncEntitiesFromRemote();
+        }
+
+        return [...this.discoveredDevices.values()].map(d => ({
+            ...d.device,
+            description: d.description,
+        }));
+    }
+
+    async adoptDevice(adopt: AdoptDevice): Promise<string> {
+        const entry = this.discoveredDevices.get(adopt.nativeId);
+
+        if (!entry)
+            throw new Error('device not found');
+
+        await this.onDeviceEvent(ScryptedInterface.DeviceDiscovery, await this.discoverDevices());
+
+        const isBattery = entry.device.interfaces.includes(ScryptedInterface.Battery);
+        const { channelStatus } = entry.deviceData;
+
+        const { ReolinkBaichuanApi } = await import("@apocaliss92/reolink-baichuan-js");
+        const transport = 'tcp';
+        const uid = channelStatus?.uid;
+        const normalizedUid = isBattery && uid ? normalizeUid(uid) : undefined;
+        const baichuanApi = new ReolinkBaichuanApi({
+            host: this.storageSettings.values.ipAddress,
+            username: this.storageSettings.values.username,
+            password: this.storageSettings.values.password,
+            transport,
+            channel: entry.rtspChannel,
+            ...(normalizedUid ? { uid: normalizedUid } : {}),
+        });
+        await baichuanApi.login();
+        const { capabilities, objects, presets } = await baichuanApi.getDeviceCapabilities(entry.rtspChannel);
+        const { interfaces, type } = getDeviceInterfaces({
+            capabilities,
+            logger: this.console,
+        });
+
+        const actualDevice: Device = {
+            ...entry.device,
+            interfaces,
+            type
+        };
+
+        await sdk.deviceManager.onDeviceDiscovered(actualDevice);
+
+        const device = await this.getDevice(adopt.nativeId);
+        this.console.log('Adopted device', entry, device?.name);
+        const { username, password, ipAddress } = this.storageSettings.values;
+
+        device.storageSettings.values.rtspChannel = entry.rtspChannel;
+        device.classes = objects;
+        device.presets = presets;
+        device.storageSettings.values.username = username;
+        device.storageSettings.values.password = password;
+        device.storageSettings.values.rtspChannel = entry.rtspChannel;
+        device.storageSettings.values.ipAddress = ipAddress;
+        device.storageSettings.values.capabilities = capabilities;
+        device.storageSettings.values.uid = entry.deviceData.channelStatus.uid;
+        device.storageSettings.values.isFromNvr = true;
+
+        this.discoveredDevices.delete(adopt.nativeId);
+        return device?.id;
+    }
+}
+