@apocaliss92/scrypted-reolink-native 0.1.36 → 0.1.38

package/src/nvr.ts

@@ -1,10 +1,11 @@
-import type { DeviceInfoResponse, EnrichedRecordingFile, EventsResponse, ReolinkBaichuanApi, ReolinkCgiApi, ReolinkSimpleEvent } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
+import type { EventsResponse, 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 { convertDebugLogsToApiOptions, getApiRelevantDebugLogs, getDebugLogChoices } from "./debug-options";
 import ReolinkNativePlugin from "./main";
 import { getDeviceInterfaces, updateDeviceInfo } from "./utils";
 
@@ -44,8 +45,8 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
             onPut: async () => await this.reinit()
         },
         diagnosticsRun: {
-            subgroup: 'Diagnostics',
-            title: 'Run NVR Diagnostics',
+            subgroup: 'Advanced',
+            title: 'Run Diagnostics',
             description: 'Collect NVR diagnostics and display results in logs.',
             type: 'button',
             immediate: true,
@@ -53,15 +54,54 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
                 await this.runNvrDiagnostics();
             },
         },
+        socketApiDebugLogs: {
+            subgroup: 'Advanced',
+            title: 'Socket API Debug Logs',
+            description: 'Enable specific debug logs.',
+            multiple: true,
+            combobox: true,
+            immediate: true,
+            defaultValue: [],
+            choices: getDebugLogChoices(),
+            onPut: async (ov, value) => {
+                const logger = this.getBaichuanLogger();
+                const oldApiOptions = getApiRelevantDebugLogs(ov || []);
+                const newApiOptions = getApiRelevantDebugLogs(value || []);
+
+                const oldSel = new Set(oldApiOptions);
+                const newSel = new Set(newApiOptions);
+
+                const changed = oldSel.size !== newSel.size || Array.from(oldSel).some((k) => !newSel.has(k));
+                if (changed) {
+                    // Clear any existing timeout
+                    if (this.debugLogsResetTimeout) {
+                        clearTimeout(this.debugLogsResetTimeout);
+                        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);
+                        }
+                    }, 2000);
+                }
+            },
+        },
     });
     plugin: ReolinkNativePlugin;
-    nvrApi: ReolinkCgiApi | undefined;
-    // baichuanApi, ensureClientPromise, connectionTime inherited from BaseBaichuanClass
     discoveredDevices = new Map<string, {
         device: Device;
         description: string;
         rtspChannel: number;
-        deviceData: DeviceInfoResponse;
+        deviceData: ReolinkBaichuanDeviceSummary;
     }>();
     lastNvrInfoCheck: number | undefined;
     lastErrorsCheck: number | undefined;
@@ -71,6 +111,7 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
     private discoverDevicesPromise: Promise<DiscoveredDevice[]> | undefined;
     processing = false;
     private initReinitTimeout: NodeJS.Timeout | undefined;
+    private debugLogsResetTimeout: NodeJS.Timeout | undefined;
 
     constructor(nativeId: string, plugin: ReolinkNativePlugin) {
         super(nativeId);
@@ -84,27 +125,31 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
         await api.reboot();
     }
 
-    // BaseBaichuanClass abstract methods implementation
     protected getConnectionConfig(): 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',
-            logger: this.console,
+            debugOptions,
         };
     }
 
+    getBaichuanDebugOptions(): any | undefined {
+        const socketDebugLogs = this.storageSettings.values.socketApiDebugLogs || [];
+        return convertDebugLogsToApiOptions(socketDebugLogs);
+    }
+
     protected getConnectionCallbacks(): BaichuanConnectionCallbacks {
         return {
-            onError: undefined, // Use default error handling
             onClose: async () => {
-                // Reinit after cleanup
                 await this.reinit();
             },
             onSimpleEvent: (ev) => this.forwardNativeEvent(ev),
@@ -146,17 +191,6 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
 
         this.initReinitTimeout = setTimeout(async () => {
             if (isReinit) {
-                // Cleanup CGI API
-                if (this.nvrApi) {
-                    try {
-                        await this.nvrApi.logout();
-                    } catch {
-                        // ignore
-                    }
-                }
-                this.nvrApi = undefined;
-
-                // Cleanup Baichuan API (this handles all listeners and connection)
                 await super.cleanupBaichuanApi();
             }
             await this.init();
@@ -164,52 +198,6 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
         }, isReinit ? 500 : 2000);
     }
 
-    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");
-        const logger = this.getBaichuanLogger();
-        this.nvrApi = new ReolinkCgiApi({
-            host: ipAddress,
-            username,
-            password,
-            logger,
-        });
-
-        await this.nvrApi.login();
-        return this.nvrApi;
-    }
-
-    /**
-     * List enriched VOD files (with proper parsing and detection info)
-     * This uses the library's enrichVodFile which handles all parsing correctly
-     */
-    async listEnrichedVodFiles(params: {
-        channel: number;
-        start: Date;
-        end: Date;
-        streamType?: "main" | "sub";
-        autoSearchByDay?: boolean;
-        bypassCache?: boolean;
-    }): Promise<Array<EnrichedRecordingFile>> {
-        const api = await this.ensureClient();
-        return await api.listEnrichedVodFiles({
-            channel: params.channel,
-            start: params.start,
-            end: params.end,
-            streamType: params.streamType,
-            autoSearchByDay: params.autoSearchByDay,
-            bypassCache: params.bypassCache,
-        });
-    }
-
     private forwardNativeEvent(ev: ReolinkSimpleEvent): void {
         const logger = this.getBaichuanLogger();
 
@@ -232,13 +220,15 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
             const targetCamera = nativeId ? this.cameraNativeMap.get(nativeId) : undefined;
 
             if (!targetCamera) {
-                logger.debug(`No camera found for channel ${channel}, ignoring event`);
+                logger.debug(`No camera 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':
@@ -263,15 +253,34 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
                     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;
             }
 
-            // Process events on the target camera
-            targetCamera.processEvents({ motion, objects }).catch((e) => {
-                logger.warn(`Error processing events for camera channel ${channel}`, e);
-            });
+            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);
+                });
+            }
         }
         catch (e) {
             logger.warn('Error in NVR Native event forwarder', e);
@@ -298,15 +307,11 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
         logger.log(`Starting NVR diagnostics...`);
 
         try {
-            const cgiApi = await this.ensureClient();
+            const api = await this.ensureBaichuanClient();
 
-            const diagnostics = await cgiApi.collectNvrDiagnostics({
+            await api.collectNvrDiagnostics({
                 logger: this.console,
             });
-
-            logger.log(`NVR diagnostics completed successfully.`);
-
-            cgiApi.printNvrDiagnostics(diagnostics, this.console);
         } catch (e) {
             logger.error('Failed to run NVR diagnostics', e);
             throw e;
@@ -357,9 +362,6 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
 
     async init() {
         const logger = this.getBaichuanLogger();
-
-        // Ensure both APIs are ready before proceeding
-        const api = await this.ensureClient();
         await this.ensureBaichuanClient();
 
         await this.updateDeviceInfo();
@@ -367,7 +369,7 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
         await this.reinitEventSubscriptions();
 
         setInterval(async () => {
-            if (this.processing || !api) {
+            if (this.processing) {
                 return;
             }
             this.processing = true;
@@ -381,39 +383,41 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
 
                 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 })}`);
+                    // 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);
                 }
 
-                // Only fetch and forward CGI events if CGI is selected as event source
+                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(() => { });
+                    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 {
@@ -427,7 +431,7 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
 
         const { ipAddress } = this.storageSettings.values;
         try {
-            const api = await this.ensureClient();
+            const api = await this.ensureBaichuanClient();
             const deviceData = await api.getInfo();
 
             await updateDeviceInfo({
@@ -492,33 +496,27 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
     async syncEntitiesFromRemote() {
         const logger = this.getBaichuanLogger();
 
-        const cgiApi = await this.ensureClient();
-        const { devicesData, channels } = await cgiApi.getDevicesInfo();
-
-        // const api = await this.ensureBaichuanClient();
-        // const devicesMap = api.getDevicesInfo();
-        // const deviceEntries = Object.entries(devicesMap);
+        const api = await this.ensureBaichuanClient();
+        const { devices, channels } = await api.getDevicesInfo();
+        logger.log(devices, channels);
 
         if (!channels.length) {
-            logger.debug(`No channels found, ${JSON.stringify({ channels, devicesData })}`);
+            logger.debug(`No channels found, ${JSON.stringify({ channels, devices })}`);
             return;
         }
 
         logger.log(`Sync entities from remote for ${channels.length} channels`);
 
-        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);
+        for (const deviceData of devices) {
+            const { isBattery, name, model, isDoorbell, uid, channel } = deviceData
 
+            try {
                 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 type = isDoorbell ? ScryptedDeviceType.Doorbell : ScryptedDeviceType.Camera;
 
                 const device: Device = {
                     nativeId,
@@ -528,7 +526,7 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
                     type,
                     info: {
                         manufacturer: 'Reolink',
-                        model: channelInfo?.typeInfo,
+                        model,
                         serialNumber: uid,
                     }
                 };
@@ -547,7 +545,7 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
                     device,
                     description: `${name} (Channel ${channel})`,
                     rtspChannel: channel,
-                    deviceData: devicesData[channel],
+                    deviceData,
                 });
 
                 logger.debug(`Discovered channel ${channel}: ${name}`);
@@ -556,7 +554,7 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
             }
         }
 
-        logger.debug(`Channel discovery completed. ${JSON.stringify({ devicesData, channels })}`);
+        logger.debug(`Channel discovery completed. ${JSON.stringify({ devices, channels })}`);
     }
 
     async discoverDevices(scan?: boolean): Promise<DiscoveredDevice[]> {
@@ -597,11 +595,10 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
         await this.onDeviceEvent(ScryptedInterface.DeviceDiscovery, await this.discoverDevices());
 
         const isBattery = entry.device.interfaces.includes(ScryptedInterface.Battery);
-        const { channelStatus } = entry.deviceData;
+        const { uid } = 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,
@@ -640,7 +637,7 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
         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.uid = uid;
 
         this.discoveredDevices.delete(adopt.nativeId);
         return device?.id;

package/src/utils.ts

@@ -329,6 +329,53 @@ export async function recordingFileToVideoClip(
     };
 }
 
+/**
+ * Convert an array of RecordingFile or EnrichedRecordingFile to VideoClip array
+ * Uses recordingFileToVideoClip for each recording
+ * Handles both NVR (EnrichedRecordingFile) and device standalone (RecordingFile) cases
+ */
+export async function recordingsToVideoClips(
+    recordings: (RecordingFile | EnrichedRecordingFile)[],
+    options: {
+        /** Fallback start date if recording doesn't have one */
+        fallbackStart: Date;
+        /** API instance to get playback URLs (optional, for device standalone recordings) */
+        api?: ReolinkBaichuanApi;
+        /** Logger for debug messages */
+        logger?: Console;
+        /** Plugin instance for generating webhook URLs */
+        plugin?: ScryptedDeviceBase;
+        /** Device ID for webhook URLs */
+        deviceId?: string;
+        /** Use webhook URLs instead of direct RTMP URLs */
+        useWebhook?: boolean;
+        /** Maximum number of clips to return (optional) */
+        count?: number;
+    }
+): Promise<VideoClip[]> {
+    const { fallbackStart, api, logger, plugin, deviceId, useWebhook, count } = options;
+    const clips: VideoClip[] = [];
+
+    for (const rec of recordings) {
+        try {
+            const clip = await recordingFileToVideoClip(rec, {
+                fallbackStart,
+                api,
+                logger,
+                plugin,
+                deviceId,
+                useWebhook,
+            });
+            clips.push(clip);
+        } catch (e) {
+            logger?.warn(`Failed to convert recording to video clip: fileName=${rec.fileName}`, e);
+        }
+    }
+
+    // Apply count limit if specified
+    return count ? clips.slice(0, count) : clips;
+}
+
 /**
  * Generate webhook URLs for video clips
  */