@apocaliss92/scrypted-reolink-native 0.1.42 → 0.2.0

package/src/nvr.ts

@@ -1,13 +1,16 @@
-import type { EventsResponse, ReolinkBaichuanApi, ReolinkBaichuanDeviceSummary, ReolinkSimpleEvent } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
+import type { EventsResponse, NativeVideoStreamVariant, ReolinkBaichuanApi, ReolinkBaichuanDeviceSummary, ReolinkSimpleEvent, StreamProfile } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
 import sdk, { AdoptDevice, Device, DeviceDiscovery, DeviceProvider, DiscoveredDevice, Reboot, ScryptedDeviceType, ScryptedInterface, Setting, Settings, SettingValue } from "@scrypted/sdk";
 import { StorageSettings } from "@scrypted/sdk/storage-settings";
 import { BaseBaichuanClass, type BaichuanConnectionCallbacks, type BaichuanConnectionConfig } from "./baichuan-base";
 import { ReolinkNativeCamera } from "./camera";
 import { ReolinkNativeBatteryCamera } from "./camera-battery";
-import { normalizeUid } from "./connect";
+import { CommonCameraMixin } from "./common";
 import { convertDebugLogsToApiOptions, getApiRelevantDebugLogs, getDebugLogChoices } from "./debug-options";
 import ReolinkNativePlugin from "./main";
-import { getDeviceInterfaces, updateDeviceInfo } from "./utils";
+import { ReolinkNativeMultiFocalDevice } from "./multiFocal";
+import { batteryCameraSuffix, batteryMultifocalSuffix, cameraSuffix, getDeviceInterfaces, multifocalSuffix, updateDeviceInfo } from "./utils";
+import { createBaichuanApi } from "./connect";
+import { parseStreamProfileFromId } from "./stream-utils";
 
 export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Settings, DeviceDiscovery, DeviceProvider, Reboot {
     storageSettings = new StorageSettings(this, {
@@ -16,17 +19,17 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
             type: 'boolean',
             immediate: true,
         },
-        eventSource: {
-            title: 'Event Source',
-            description: 'Select the source for camera events: Native (Baichuan) or CGI (HTTP polling)',
-            type: 'string',
-            choices: ['Native', 'CGI'],
-            defaultValue: 'Native',
-            immediate: true,
-            onPut: async () => {
-                await this.reinitEventSubscriptions();
-            }
-        },
+        // eventSource: {
+        //     title: 'Event Source',
+        //     description: 'Select the source for camera events: Native (Baichuan) or CGI (HTTP polling)',
+        //     type: 'string',
+        //     choices: ['Native', 'CGI'],
+        //     defaultValue: 'Native',
+        //     immediate: true,
+        //     onPut: async () => {
+        //         await this.reinitEventSubscriptions();
+        //     }
+        // },
         ipAddress: {
             title: 'IP address',
             type: 'string',
@@ -89,7 +92,7 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
                             // Trigger reconnection
                             await this.ensureBaichuanClient();
                         } catch (e) {
-                            logger.warn('Failed to reset client after debug logs change', e);
+                            logger.warn('Failed to reset client after debug logs change', e?.message || String(e));
                         }
                     }, 2000);
                 }
@@ -103,10 +106,7 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
         rtspChannel: number;
         deviceData: ReolinkBaichuanDeviceSummary;
     }>();
-    lastNvrInfoCheck: number | undefined;
-    lastErrorsCheck: number | undefined;
-    lastDevicesStatusCheck: number | undefined;
-    cameraNativeMap = new Map<string, ReolinkNativeCamera | ReolinkNativeBatteryCamera>();
+    cameraNativeMap = new Map<string, CommonCameraMixin>();
     private channelToNativeIdMap = new Map<number, string>();
     private discoverDevicesPromise: Promise<DiscoveredDevice[]> | undefined;
     processing = false;
@@ -114,7 +114,7 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
     private debugLogsResetTimeout: NodeJS.Timeout | undefined;
 
     constructor(nativeId: string, plugin: ReolinkNativePlugin) {
-        super(nativeId);
+        super(nativeId, "tcp");
         this.plugin = plugin;
 
         this.scheduleInit();
@@ -142,6 +142,23 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
         };
     }
 
+    protected getStreamClientInputs(): BaichuanConnectionConfig {
+        const { ipAddress, username, password } = this.storageSettings.values;
+        if (!ipAddress || !username || !password) {
+            throw new Error('Missing NVR credentials');
+        }
+
+        const debugOptions = this.getBaichuanDebugOptions();
+
+        return {
+            host: ipAddress,
+            username,
+            password,
+            transport: 'tcp',
+            debugOptions,
+        };
+    }
+
     getBaichuanDebugOptions(): any | undefined {
         const socketDebugLogs = this.storageSettings.values.socketApiDebugLogs || [];
         return convertDebugLogsToApiOptions(socketDebugLogs);
@@ -153,14 +170,14 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
                 await this.reinit();
             },
             onSimpleEvent: (ev) => this.forwardNativeEvent(ev),
-            getEventSubscriptionEnabled: () => {
-                const eventSource = this.storageSettings.values.eventSource || 'Native';
-                return eventSource === 'Native';
-            },
+            getEventSubscriptionEnabled: () => true,
+            // getEventSubscriptionEnabled: () => {
+            //     const eventSource = this.storageSettings.values.eventSource || 'Native';
+            //     return eventSource === 'Native';
+            // },
         };
     }
 
-
     protected isDebugEnabled(): boolean {
         return this.storageSettings.values.debugLogs || false;
     }
@@ -198,18 +215,24 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
         }, isReinit ? 500 : 2000);
     }
 
+    /**
+     * Forward events received from Baichuan to the appropriate child device (Camera or MultiFocal).
+     * This ensures that only NVR (root device) subscribes to events, and events are forwarded down the hierarchy:
+     * - NVR → MultiFocal → Camera
+     * - NVR → Camera (directly)
+     */
     private forwardNativeEvent(ev: ReolinkSimpleEvent): void {
         const logger = this.getBaichuanLogger();
 
-        const eventSource = this.storageSettings.values.eventSource || 'Native';
-        if (eventSource !== 'Native') {
-            return;
-        }
+        // const eventSource = this.storageSettings.values.eventSource || 'Native';
+        // if (eventSource !== 'Native') {
+        //     return;
+        // }
 
         try {
             logger.debug(`Baichuan event: ${JSON.stringify(ev)}`);
 
-            // Find camera for this channel
+            // Find device (camera or multifocal) for this channel
             const channel = ev?.channel;
             if (channel === undefined) {
                 logger.error('Event has no channel, ignoring');
@@ -217,10 +240,16 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
             }
 
             const nativeId = this.channelToNativeIdMap.get(channel);
-            const targetCamera = nativeId ? this.cameraNativeMap.get(nativeId) : undefined;
+            const targetDevice = nativeId ? this.cameraNativeMap.get(nativeId) : undefined;
 
-            if (!targetCamera) {
-                logger.debug(`No camera found for channel ${channel} (nativeId: ${nativeId}), ignoring event`);
+            if (!targetDevice) {
+                logger.debug(`No device found for channel ${channel} (nativeId: ${nativeId}), ignoring event`);
+                return;
+            }
+
+            // If target is a MultiFocal device, forward the event to it (it will forward to its camera children)
+            if (targetDevice instanceof ReolinkNativeMultiFocalDevice) {
+                targetDevice.forwardNativeEvent(ev);
                 return;
             }
 
@@ -237,10 +266,10 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
                 case 'doorbell':
                     // Handle doorbell if camera supports it
                     try {
-                        targetCamera.handleDoorbellEvent();
+                        targetDevice.handleDoorbellEvent();
                     }
                     catch (e) {
-                        logger.warn(`Error handling doorbell event for camera channel ${channel}`, e);
+                        logger.warn(`Error handling doorbell event for camera channel ${channel}`, e?.message || String(e));
                     }
                     motion = true;
                     break;
@@ -267,41 +296,44 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
             }
 
             if (isSleepingEvent) {
-                (targetCamera as ReolinkNativeBatteryCamera).updateSleepingState({
+                targetDevice.updateSleepingState({
                     reason: 'NVR',
                     state: ev.type === 'sleeping' ? 'sleeping' : 'awake',
                 }).catch(() => { });
-            } if (isSleepingEvent) {
-                (targetCamera as ReolinkNativeBatteryCamera).updateOnlineState(
+            } else if (isOnlineEvent) {
+                (targetDevice as ReolinkNativeBatteryCamera).updateOnlineState(
                     ev.type === 'online' ? true : false
                 ).catch(() => { });
             } else {
                 // Process events on the target camera
-                targetCamera.processEvents({ motion, objects }).catch((e) => {
-                    logger.warn(`Error processing events for camera channel ${channel}`, e);
+                targetDevice.processEvents({ motion, objects }).catch((e) => {
+                    logger.warn(`Error processing events for camera channel ${channel}`, e?.message || String(e));
                 });
             }
         }
         catch (e) {
-            logger.warn('Error in NVR Native event forwarder', e);
+            logger.warn('Error in NVR Native event forwarder', e?.message || String(e));
         }
     }
 
     async ensureBaichuanClient(): Promise<ReolinkBaichuanApi> {
-        // Use base class implementation
         return await super.ensureBaichuanClient();
     }
 
-    async subscribeToAllEvents(): Promise<void> {
-        const eventSource = this.storageSettings.values.eventSource || 'Native';
-
-        if (eventSource !== 'Native') {
-            await this.unsubscribeFromAllEvents();
-        } else {
-            await super.subscribeToEvents();
-        }
+    async ensureClient(): Promise<ReolinkBaichuanApi> {
+        return await this.ensureBaichuanClient();
     }
 
+    // async subscribeToAllEvents(): Promise<void> {
+    // const eventSource = this.storageSettings.values.eventSource || 'Native';
+
+    // if (eventSource !== 'Native') {
+    // await this.unsubscribeFromAllEvents();
+    // } else {
+    // await super.subscribeToEvents();
+    // }
+    // }
+
     private async runNvrDiagnostics(): Promise<void> {
         const logger = this.getBaichuanLogger();
         logger.log(`Starting NVR diagnostics...`);
@@ -313,7 +345,7 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
                 logger: this.console,
             });
         } catch (e) {
-            logger.error('Failed to run NVR diagnostics', e);
+            logger.error('Failed to run NVR diagnostics', e?.message || String(e));
             throw e;
         }
     }
@@ -326,104 +358,88 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
     /**
      * Reinitialize event subscriptions based on selected event source
      */
-    private async reinitEventSubscriptions(): Promise<void> {
-        const logger = this.getBaichuanLogger();
-        const { eventSource } = this.storageSettings.values;
-
-        // Unsubscribe from Native events if switching away
-        if (eventSource !== 'Native') {
-            await this.unsubscribeFromAllEvents();
-        } else {
-            this.subscribeToAllEvents().catch((e) => {
-                logger.warn('Failed to subscribe to Native events', e);
-            });
-        }
-
-        logger.log(`Event source set to: ${eventSource}`);
-    }
+    // private async reinitEventSubscriptions(): Promise<void> {
+    //     const logger = this.getBaichuanLogger();
+    // const { eventSource } = this.storageSettings.values;
+
+    // // Unsubscribe from Native events if switching away
+    // if (eventSource !== 'Native') {
+    //     await this.unsubscribeFromAllEvents();
+    // } else {
+    // this.subscribeToAllEvents().catch((e) => {
+    //     logger.warn('Failed to subscribe to Native events', e?.message || String(e));
+    // });
+    // }
+
+    // logger.log(`Event source set to: ${eventSource}`);
+    // }
 
     /**
      * Forward events from CGI source to cameras
      */
-    private forwardCgiEvents(eventsRes: Record<number, EventsResponse>): void {
-        const logger = this.getBaichuanLogger();
+    // private forwardCgiEvents(eventsRes: Record<number, EventsResponse>): void {
+    //     const logger = this.getBaichuanLogger();
 
-        logger.debug(`CGI Events call result: ${JSON.stringify(eventsRes)}`);
+    //     logger.debug(`CGI Events call result: ${JSON.stringify(eventsRes)}`);
 
-        // Use channel map for efficient lookup
-        for (const [channel, nativeId] of this.channelToNativeIdMap.entries()) {
-            const targetCamera = nativeId ? this.cameraNativeMap.get(nativeId) : undefined;
-            const cameraEventsData = eventsRes[channel];
-            if (cameraEventsData && targetCamera) {
-                targetCamera.processEvents(cameraEventsData);
-            }
-        }
-    }
+    //     // Use channel map for efficient lookup
+    //     for (const [channel, nativeId] of this.channelToNativeIdMap.entries()) {
+    //         const targetCamera = nativeId ? this.cameraNativeMap.get(nativeId) : undefined;
+    //         const cameraEventsData = eventsRes[channel];
+    //         if (cameraEventsData && targetCamera) {
+    //             targetCamera.processEvents(cameraEventsData);
+    //         }
+    //     }
+    // }
 
     async init() {
-        const logger = this.getBaichuanLogger();
+        // const logger = this.getBaichuanLogger();
         await this.ensureBaichuanClient();
 
         await this.updateDeviceInfo();
-
-        await this.reinitEventSubscriptions();
-
-        setInterval(async () => {
-            if (this.processing) {
-                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.lastNvrInfoCheck || now - this.lastNvrInfoCheck > 1000 * 60 * 5) {
-                    this.lastNvrInfoCheck = now;
-                    // const { nvrData } = await api.getNvrInfo();
-                    // const { devicesData, channelsResponse, response } = await api.getDevicesInfo();
-                    // logger.log(`NVR info data fetched`);
-                    // logger.debug(`${JSON.stringify({ nvrData, devicesData, channelsResponse, response })}`);
-
-                    await this.discoverDevices(true);
-                }
-
-                const api = await this.ensureBaichuanClient();
-
-                const { eventSource } = this.storageSettings.values;
-
-                if (eventSource === 'CGI') {
-                    const eventsRes = await api.getAllChannelsEvents();
-                    this.forwardCgiEvents(eventsRes.parsed);
-
-                    const { batteryInfoData, response } = await api.getAllChannelsBatteryInfo();
-
-                    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) {
-                logger.error('Error on events flow', e);
-            } finally {
-                this.processing = false;
-            }
-        }, 1000);
+        await this.subscribeToEvents();
+
+        // await this.reinitEventSubscriptions();
+
+        // setInterval(async () => {
+        //     if (this.processing) {
+        //         return;
+        //     }
+        //     this.processing = true;
+        //     try {
+        //         const api = await this.ensureBaichuanClient();
+
+        // const { eventSource } = this.storageSettings.values;
+
+        // if (eventSource === 'CGI') {
+        //     const eventsRes = await api.getAllChannelsEvents();
+        //     this.forwardCgiEvents(eventsRes.parsed);
+
+        //     const { batteryInfoData, response } = await api.getAllChannelsBatteryInfo();
+
+        //     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.updateSleepingState({
+        //                     reason: 'NVR',
+        //                     state: cameraBatteryData.sleeping ? 'sleeping' : 'awake',
+        //                     idleMs: 0,
+        //                     lastRxAtMs: 0,
+        //                 }).catch(() => { });
+        //             }
+        //         }
+        //     });
+        // }
+        //         } catch (e) {
+        //             logger.error('Error on events flow', e?.message || String(e));
+        //         } finally {
+        //             this.processing = false;
+        //         }
+        //     }, 1000);
     }
 
     async updateDeviceInfo(): Promise<void> {
@@ -441,7 +457,7 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
                 logger
             });
         } catch (e) {
-            logger.warn('Failed to fetch device info', e);
+            logger.warn('Failed to fetch device info', e?.message || String(e));
         }
     }
 
@@ -458,27 +474,38 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
         this.cameraNativeMap.delete(nativeId);
     }
 
-    async getDevice(nativeId: string): Promise<ReolinkNativeCamera | ReolinkNativeBatteryCamera> {
+    async getDevice(nativeId: string): Promise<CommonCameraMixin> {
         let device = this.cameraNativeMap.get(nativeId);
 
         if (!device) {
-            if (nativeId.endsWith('-battery-cam')) {
+            if (nativeId.endsWith(batteryCameraSuffix)) {
                 device = new ReolinkNativeBatteryCamera(nativeId, this.plugin, this);
+            } else if (nativeId.endsWith(batteryMultifocalSuffix)) {
+                device = new ReolinkNativeMultiFocalDevice(nativeId, this.plugin, "multi-focal-battery", this);
+            } else if (nativeId.endsWith(multifocalSuffix)) {
+                device = new ReolinkNativeMultiFocalDevice(nativeId, this.plugin, "multi-focal", this);
             } else {
                 device = new ReolinkNativeCamera(nativeId, this.plugin, this);
             }
-            this.cameraNativeMap.set(nativeId, device);
+
+            if (device) {
+                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}`;
+    buildNativeId(props: {
+        identifier?: string, isBattery?: boolean, isMultifocal?: boolean
+    }): string {
+        const { identifier, isBattery, isMultifocal } = props;
+
+        const suffix = isBattery ?
+            (isMultifocal ? batteryMultifocalSuffix : batteryCameraSuffix) :
+            (isMultifocal ? multifocalSuffix : cameraSuffix)
+
+        return `${this.nativeId}-${identifier}${suffix}`;
     }
 
     getCameraInterfaces() {
@@ -495,10 +522,10 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
 
     async syncEntitiesFromRemote() {
         const logger = this.getBaichuanLogger();
+        // const { ipAddress } = this.storageSettings.values;
 
         const api = await this.ensureBaichuanClient();
-        const { devices, channels } = await api.getDevicesInfo();
-        logger.log(devices, channels);
+        const { devices, channels } = await api.getNvrChannelsSummary({ source: "cgi" });
 
         if (!channels.length) {
             logger.debug(`No channels found, ${JSON.stringify({ channels, devices })}`);
@@ -508,10 +535,16 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
         logger.log(`Sync entities from remote for ${channels.length} channels`);
 
         for (const deviceData of devices) {
-            const { isBattery, serialNumber, name, model, isDoorbell, uid, channel } = deviceData
+            const { isBattery, serialNumber, name, model, isDoorbell, uid, channel, isMultifocal } = deviceData;
+            const identifier = uid || name || `channel-${channel}`;
+            // const identifier = uid || mac || (ip !== ipAddress ? ip : undefined) || name || randomBytes(4).toString('hex');
 
             try {
-                const nativeId = this.buildNativeId(channel, uid, isBattery);
+                const nativeId = this.buildNativeId({
+                    isBattery,
+                    isMultifocal,
+                    identifier,
+                });
                 const interfaces = [ScryptedInterface.VideoCamera];
                 if (isBattery) {
                     interfaces.push(ScryptedInterface.Battery);
@@ -527,7 +560,7 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
                     info: {
                         manufacturer: 'Reolink',
                         model,
-                        serialNumber: uid,
+                        serialNumber,
                     }
                 };
 
@@ -538,7 +571,10 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
                 if (
                     allNativeIds.some(
                         nid => nid.includes(uid) ||
-                            nid.includes(serialNumber) ||
+                            nid.includes(`channel-${channel}`) ||
+                            // nid.includes(mac) ||
+                            // nid.includes(ip) ||
+                            nid.includes(name) ||
                             nid === nativeId)
                 ) {
                     continue;
@@ -601,29 +637,28 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
 
         await this.onDeviceEvent(ScryptedInterface.DeviceDiscovery, await this.discoverDevices());
 
-        const isBattery = entry.device.interfaces.includes(ScryptedInterface.Battery);
         const { uid } = entry.deviceData;
 
         const { ReolinkBaichuanApi } = await import("@apocaliss92/reolink-baichuan-js");
         const transport = 'tcp';
-        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 } : {}),
+            uid,
         });
         await baichuanApi.login();
         const { capabilities, objects, presets } = await baichuanApi.getDeviceCapabilities(entry.rtspChannel);
         const { interfaces, type } = getDeviceInterfaces({
             capabilities,
-            logger: this.console,
+            logger: this.getBaichuanLogger(),
         });
 
         const actualDevice: Device = {
             ...entry.device,
+            providerNativeId: this.nativeId,
             interfaces,
             type
         };
@@ -632,8 +667,7 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
 
         const device = await this.getDevice(adopt.nativeId);
         const logger = this.getBaichuanLogger();
-        logger.log('Adopted device', device?.name);
-        logger.log(JSON.stringify(entry));
+        logger.log('Adopted device', device?.name, JSON.stringify(actualDevice));
         const { username, password, ipAddress } = this.storageSettings.values;
 
         device.storageSettings.values.rtspChannel = entry.rtspChannel;