@apocaliss92/scrypted-reolink-native 0.1.42 → 0.2.1

package/src/nvr.ts

@@ -1,32 +1,33 @@
-import type { EventsResponse, ReolinkBaichuanApi, ReolinkBaichuanDeviceSummary, ReolinkSimpleEvent } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
+import type { ReolinkBaichuanApi, ReolinkBaichuanDeviceSummary, ReolinkSimpleEvent } 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 { ReolinkCamera } from "./camera";
 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";
 
 export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Settings, DeviceDiscovery, DeviceProvider, Reboot {
+    private readonly onSimpleEventBound = (ev: ReolinkSimpleEvent) => this.onSimpleEvent(ev);
+
     storageSettings = new StorageSettings(this, {
         debugLogs: {
             title: 'Debug Events',
             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',
@@ -79,17 +80,14 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
                         this.debugLogsResetTimeout = undefined;
                     }
 
-                    // Defer reset by 2 seconds to allow settings to settle
                     this.debugLogsResetTimeout = setTimeout(async () => {
                         this.debugLogsResetTimeout = undefined;
                         try {
-                            // Force reconnection with new debug options
                             this.baichuanApi = undefined;
                             this.ensureClientPromise = undefined;
-                            // 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 +101,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, ReolinkCamera>();
     private channelToNativeIdMap = new Map<number, string>();
     private discoverDevicesPromise: Promise<DiscoveredDevice[]> | undefined;
     processing = false;
@@ -114,7 +109,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 +137,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);
@@ -152,15 +164,11 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
             onClose: async () => {
                 await this.reinit();
             },
-            onSimpleEvent: (ev) => this.forwardNativeEvent(ev),
-            getEventSubscriptionEnabled: () => {
-                const eventSource = this.storageSettings.values.eventSource || 'Native';
-                return eventSource === 'Native';
-            },
+            onSimpleEvent: this.onSimpleEventBound,
+            getEventSubscriptionEnabled: () => true,
         };
     }
 
-
     protected isDebugEnabled(): boolean {
         return this.storageSettings.values.debugLogs || false;
     }
@@ -170,7 +178,7 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
     }
 
     protected async onBeforeCleanup(): Promise<void> {
-        await this.unsubscribeFromAllEvents();
+        await this.unsubscribeFromEvents();
     }
 
     async reinit() {
@@ -179,7 +187,6 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
             this.initReinitTimeout = undefined;
         }
 
-        // Schedule reinit with debounce
         this.scheduleInit(true);
     }
 
@@ -198,18 +205,12 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
         }, isReinit ? 500 : 2000);
     }
 
-    private forwardNativeEvent(ev: ReolinkSimpleEvent): void {
+    onSimpleEvent(ev: ReolinkSimpleEvent) {
         const logger = this.getBaichuanLogger();
 
-        const eventSource = this.storageSettings.values.eventSource || 'Native';
-        if (eventSource !== 'Native') {
-            return;
-        }
-
         try {
-            logger.debug(`Baichuan event: ${JSON.stringify(ev)}`);
+            logger.debug(`Baichuan event on nvr: ${JSON.stringify(ev)}`);
 
-            // Find camera for this channel
             const channel = ev?.channel;
             if (channel === undefined) {
                 logger.error('Event has no channel, ignoring');
@@ -217,89 +218,26 @@ 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;
             }
 
-            // Convert event to camera's processEvents format
-            const objects: string[] = [];
-            let motion = false;
-            let isSleepingEvent = false;
-            let isOnlineEvent = false;
-
-            switch (ev?.type) {
-                case 'motion':
-                    motion = true;
-                    break;
-                case 'doorbell':
-                    // Handle doorbell if camera supports it
-                    try {
-                        targetCamera.handleDoorbellEvent();
-                    }
-                    catch (e) {
-                        logger.warn(`Error handling doorbell event for camera channel ${channel}`, e);
-                    }
-                    motion = true;
-                    break;
-                case 'people':
-                case 'vehicle':
-                case 'animal':
-                case 'face':
-                case 'package':
-                case 'other':
-                    objects.push(ev.type);
-                    motion = true;
-                    break;
-                case 'awake':
-                case 'sleeping':
-                    isSleepingEvent = true;
-                    break;
-                case 'offline':
-                case 'online':
-                    isOnlineEvent = true;
-                    break;
-                default:
-                    logger.error(`Unknown event type: ${ev?.type}`);
-                    return;
-            }
-
-            if (isSleepingEvent) {
-                (targetCamera as ReolinkNativeBatteryCamera).updateSleepingState({
-                    reason: 'NVR',
-                    state: ev.type === 'sleeping' ? 'sleeping' : 'awake',
-                }).catch(() => { });
-            } if (isSleepingEvent) {
-                (targetCamera 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.onSimpleEvent(ev);
         }
         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();
     }
 
     private async runNvrDiagnostics(): Promise<void> {
@@ -313,117 +251,17 @@ 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;
         }
     }
 
-    async unsubscribeFromAllEvents(): Promise<void> {
-        // Use base class implementation
-        await super.unsubscribeFromEvents();
-    }
-
-    /**
-     * 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}`);
-    }
-
-    /**
-     * Forward events from CGI source to cameras
-     */
-    private forwardCgiEvents(eventsRes: Record<number, EventsResponse>): void {
-        const logger = this.getBaichuanLogger();
-
-        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);
-            }
-        }
-    }
-
     async init() {
-        const logger = this.getBaichuanLogger();
         await this.ensureBaichuanClient();
+        await this.subscribeToEvents();
+        await this.discoverDevices(true);
 
         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);
     }
 
     async updateDeviceInfo(): Promise<void> {
@@ -441,7 +279,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 +296,38 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
         this.cameraNativeMap.delete(nativeId);
     }
 
-    async getDevice(nativeId: string): Promise<ReolinkNativeCamera | ReolinkNativeBatteryCamera> {
+    async getDevice(nativeId: string): Promise<ReolinkCamera> {
         let device = this.cameraNativeMap.get(nativeId);
 
         if (!device) {
-            if (nativeId.endsWith('-battery-cam')) {
-                device = new ReolinkNativeBatteryCamera(nativeId, this.plugin, this);
+            if (nativeId.endsWith(batteryCameraSuffix)) {
+                device = new ReolinkCamera(nativeId, this.plugin, { type: 'battery', nvrDevice: 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);
+                device = new ReolinkCamera(nativeId, this.plugin, { type: 'regular', nvrDevice: this });
+            }
+
+            if (device) {
+                this.cameraNativeMap.set(nativeId, 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,23 +344,31 @@ 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 })}`);
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            await this.syncEntitiesFromRemote();
             return;
         }
 
         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 +384,7 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
                     info: {
                         manufacturer: 'Reolink',
                         model,
-                        serialNumber: uid,
+                        serialNumber,
                     }
                 };
 
@@ -538,7 +395,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 +461,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 +491,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;

package/src/presets.ts

@@ -1,5 +1,5 @@
 import type { PtzPreset } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
-import type { CommonCameraMixin } from "./common";
+import type { ReolinkCamera } from "./camera";
 
 export type PtzCapabilitiesShape = {
     presets?: Record<string, string>;
@@ -7,7 +7,7 @@ export type PtzCapabilitiesShape = {
 };
 
 export class ReolinkPtzPresets {
-    constructor(private camera: CommonCameraMixin & { ptzCapabilities?: any }) { }
+    constructor(private camera: ReolinkCamera & { ptzCapabilities?: any }) { }
 
     private get storageSettings() {
         return this.camera.storageSettings;