@apocaliss92/scrypted-reolink-native 0.1.36 → 0.1.38

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@apocaliss92/scrypted-reolink-native",
-   "version": "0.1.36",
+   "version": "0.1.38",
    "description": "Use any reolink camera with Scrypted, even older/unsupported models without HTTP protocol support",
    "author": "@apocaliss92",
    "license": "Apache",

package/src/baichuan-base.ts

@@ -1,4 +1,4 @@
-import type { ReolinkBaichuanApi, ReolinkSimpleEvent } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
+import type { BaichuanClientOptions, ReolinkBaichuanApi, ReolinkSimpleEvent } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
 import { ScryptedDeviceBase } from "@scrypted/sdk";
 import { createBaichuanApi, type BaichuanTransport } from "./connect";
 
@@ -8,8 +8,8 @@ export interface BaichuanConnectionConfig {
     password: string;
     uid?: string;
     transport: BaichuanTransport;
-    logger: Console;
     debugOptions?: any;
+    udpDiscoveryMethod?: BaichuanClientOptions["udpDiscoveryMethod"];
 }
 
 export interface BaichuanConnectionCallbacks {
@@ -259,6 +259,7 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
                     uid: config.uid,
                     logger,
                     debugOptions: config.debugOptions,
+                    udpDiscoveryMethod: config.udpDiscoveryMethod,
                 },
                 transport: config.transport,
             });

package/src/camera-battery.ts

@@ -128,7 +128,22 @@ export class ReolinkNativeBatteryCamera extends CommonCameraMixin {
             }
         } catch (e) {
             // Silently ignore errors in sleep check to avoid spam
-            this.getBaichuanLogger().debug('Error in checkSleepingState:', e);
+            this.getBaichuanLogger().debug('Error in updateSleepingState:', e);
+        }
+    }
+
+    async updateOnlineState(isOnline: boolean): Promise<void> {
+        try {
+            if (this.isDebugEnabled()) {
+                this.getBaichuanLogger().debug('updateOnlineState result:', isOnline);
+            }
+
+            if (isOnline !== this.online) {
+                this.online = isOnline;
+            }
+        } catch (e) {
+            // Silently ignore errors in sleep check to avoid spam
+            this.getBaichuanLogger().debug('Error in updateOnlineState:', e);
         }
     }
 

package/src/common.ts

@@ -1,4 +1,4 @@
-import type { DeviceCapabilities, PtzCommand, PtzPreset, ReolinkBaichuanApi, ReolinkSimpleEvent, ReolinkSupportedStream, StreamProfile, StreamSamplingSelection } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
+import type { BaichuanClientOptions, DeviceCapabilities, PtzCommand, PtzPreset, ReolinkBaichuanApi, ReolinkSimpleEvent, ReolinkSupportedStream, StreamProfile, StreamSamplingSelection } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
 import sdk, { BinarySensor, Brightness, Camera, Device, DeviceProvider, Intercom, MediaObject, MediaStreamUrl, ObjectDetectionTypes, ObjectDetector, ObjectsDetected, OnOff, PanTiltZoom, PanTiltZoomCommand, Reboot, RequestMediaStreamOptions, RequestPictureOptions, ResponsePictureOptions, ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, ScryptedMimeTypes, Setting, Settings, SettingValue, VideoCamera, VideoClip, VideoClipOptions, VideoClips, VideoClipThumbnailOptions, VideoTextOverlay, VideoTextOverlays } from "@scrypted/sdk";
 import { StorageSettings } from "@scrypted/sdk/storage-settings";
 import path from 'path';
@@ -24,7 +24,7 @@ import {
     selectStreamOption,
     StreamManager
 } from "./stream-utils";
-import { floodlightSuffix, getDeviceInterfaces, getVideoClipWebhookUrls, pirSuffix, recordingFileToVideoClip, sanitizeFfmpegOutput, sirenSuffix, updateDeviceInfo, vodSearchResultsToVideoClips } from "./utils";
+import { floodlightSuffix, getDeviceInterfaces, getVideoClipWebhookUrls, pirSuffix, recordingsToVideoClips, sanitizeFfmpegOutput, sirenSuffix, updateDeviceInfo, vodSearchResultsToVideoClips } from "./utils";
 
 export type CameraType = 'battery' | 'regular' | 'multi-focal' | 'multi-focal-battery';
 
@@ -300,6 +300,17 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 await this.credentialsChanged();
             }
         },
+        discoveryMethod: {
+            title: 'Discovery Method',
+            description: 'UDP discovery method for battery cameras (BCUDP).',
+            type: 'string',
+            choices: ['local', 'remote', 'map', 'relay'],
+            defaultValue: 'local',
+            hide: true,
+            onPut: async () => {
+                await this.credentialsChanged();
+            }
+        },
         debugLogs: {
             title: 'Debug logs',
             type: 'boolean',
@@ -664,6 +675,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     private streamManagerRestartTimeout: NodeJS.Timeout | undefined;
     private videoClipsAutoLoadInterval: NodeJS.Timeout | undefined;
     private videoClipsAutoLoadInProgress: boolean = false;
+    private videoClipsAutoLoadMode: boolean = false;
 
     constructor(
         nativeId: string,
@@ -698,7 +710,8 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             return [];
         }
 
-        if (this.isBattery && this.sleeping) {
+        // Skip sleeping check during auto-load to allow auto-load to start for battery cameras
+        if (!this.videoClipsAutoLoadMode && this.isBattery && this.sleeping) {
             const logger = this.getBaichuanLogger();
             logger.debug('getVideoClips: disabled for battery devices');
             return [];
@@ -728,13 +741,14 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
 
         const start = new Date(startMs);
         const end = new Date(endMs);
-        // Use UTC to match API's dateToReolinkTime conversion
-        start.setUTCHours(0, 0, 0, 0);
+        start.setHours(0, 0, 0, 0);
 
         try {
             const { clipsSource } = this.storageSettings.values;
             const useNvr = clipsSource === "NVR" && this.nvrDevice;
 
+            const api = await this.ensureClient();
+
             if (useNvr) {
                 // Fetch from NVR using listEnrichedVodFiles (library handles parsing correctly)
                 const channel = this.storageSettings.values.rtspChannel ?? 0;
@@ -742,106 +756,49 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 // Use listEnrichedVodFiles which properly parses filenames and extracts detection info
                 logger.debug(`[NVR VOD] Searching for video clips: channel=${channel}, start=${start.toISOString()}, end=${end.toISOString()}`);
                 // Filter to only include recordings within the requested time window
-                const enrichedRecordings = await this.nvrDevice.listEnrichedVodFiles({
+                const enrichedRecordings = await api.listNvrRecordings({
                     channel,
                     start,
                     end,
                     streamType: "main",
-                    autoSearchByDay: false, // Disable autoSearchByDay to avoid searching past days
-                    bypassCache: false,
                 });
 
                 logger.debug(`[NVR VOD] Found ${enrichedRecordings.length} enriched recordings from NVR`);
 
-                // Log sample of enriched recordings to see what the library returned
-                if (enrichedRecordings.length > 0) {
-                    const sampleSize = Math.min(3, enrichedRecordings.length);
-                    for (let i = 0; i < sampleSize; i++) {
-                        const rec = enrichedRecordings[i];
-                        logger.debug(`[NVR VOD] Sample enriched recording ${i + 1}/${enrichedRecordings.length}:`, {
-                            fileName: rec.fileName,
-                            startTimeMs: rec.startTimeMs,
-                            endTimeMs: rec.endTimeMs,
-                            durationMs: rec.durationMs,
-                            hasPerson: rec.hasPerson,
-                            hasVehicle: rec.hasVehicle,
-                            hasAnimal: rec.hasAnimal,
-                            hasFace: rec.hasFace,
-                            hasMotion: rec.hasMotion,
-                            hasDoorbell: rec.hasDoorbell,
-                            hasPackage: rec.hasPackage,
-                            recordType: rec.recordType,
-                            parsedFileName: rec.parsedFileName ? {
-                                start: rec.parsedFileName.start?.toISOString(),
-                                end: rec.parsedFileName.end?.toISOString(),
-                                flags: rec.parsedFileName.flags,
-                            } : null,
-                        });
-                    }
-                }
-
-                // Convert enriched recordings to VideoClip array
-                const clips: VideoClip[] = [];
-
-                for (const rec of enrichedRecordings) {
-                    // Log detection flags before conversion
-                    const flags = {
-                        hasPerson: 'hasPerson' in rec ? rec.hasPerson : false,
-                        hasVehicle: 'hasVehicle' in rec ? rec.hasVehicle : false,
-                        hasAnimal: 'hasAnimal' in rec ? rec.hasAnimal : false,
-                        hasFace: 'hasFace' in rec ? rec.hasFace : false,
-                        hasMotion: 'hasMotion' in rec ? rec.hasMotion : false,
-                        hasDoorbell: 'hasDoorbell' in rec ? rec.hasDoorbell : false,
-                        hasPackage: 'hasPackage' in rec ? rec.hasPackage : false,
-                        recordType: rec.recordType || 'none',
-                    };
-                    logger.debug(`[NVR VOD] Processing recording: fileName=${rec.fileName}, flags=${JSON.stringify(flags)}`);
-
-                    const clip = await recordingFileToVideoClip(rec, {
-                        fallbackStart: start,
-                        logger,
-                        plugin: this,
-                        deviceId: this.id,
-                        useWebhook: true,
-                    });
-
-                    // Log detection classes in the final clip
-                    logger.debug(`[NVR VOD] Generated clip: id=${clip.id}, detectionClasses=${clip.detectionClasses?.join(',') || 'none'}`);
-                    clips.push(clip);
-                }
+                // Convert enriched recordings to VideoClip array using the shared parser
+                const clips = await recordingsToVideoClips(enrichedRecordings, {
+                    fallbackStart: start,
+                    logger,
+                    plugin: this,
+                    deviceId: this.id,
+                    useWebhook: true,
+                    count,
+                });
 
-                // Apply count limit if specified
-                const finalClips = count ? clips.slice(0, count) : clips;
-                logger.debug(`[NVR VOD] Converted ${finalClips.length} video clips (limit: ${count || 'none'})`);
+                logger.debug(`[NVR VOD] Converted ${clips.length} video clips (limit: ${count || 'none'})`);
 
-                return finalClips;
+                return clips;
             } else {
-                // Fetch directly from device using Baichuan API
-                const api = await this.ensureClient();
-
-                const recordings = await api.listEnrichedRecordingsByTime({
+                const recordings = await api.listDeviceRecordings({
                     start,
                     end,
                     count,
                     channel: this.storageSettings.values.rtspChannel,
                     streamType: 'mainStream',
                     httpFallback: false,
-                    fetchRtmpUrls: true
+                    fetchRtmpUrls: false
                 });
 
-                const clips: VideoClip[] = [];
-
-                for (const rec of recordings) {
-                    const clip = await recordingFileToVideoClip(rec, {
-                        fallbackStart: start,
-                        api,
-                        logger,
-                        plugin: this,
-                        deviceId: this.id,
-                        useWebhook: true,
-                    });
-                    clips.push(clip);
-                }
+                // Convert recordings to VideoClip array using the shared parser
+                const clips = await recordingsToVideoClips(recordings, {
+                    fallbackStart: start,
+                    api,
+                    logger,
+                    plugin: this,
+                    deviceId: this.id,
+                    useWebhook: true,
+                    count,
+                });
 
                 logger.debug(`Videoclips found: ${clips.length}`);
 
@@ -1166,12 +1123,12 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
 
         if (useNvr) {
             logger.debug(`[getVideoClipRtmpUrl] Using NVR API for fileId="${fileId}", forThumbnail=${forThumbnail}`);
-            const nvrApi = await this.nvrDevice.ensureClient();
+            const api = await this.ensureClient();
             const channel = this.storageSettings.values.rtspChannel ?? 0;
 
             try {
                 logger.debug(`[getVideoClipRtmpUrl] Trying getVodUrl with Download requestType...`);
-                const url = await nvrApi.getVodUrl(fileId, channel, {
+                const url = await api.getVodUrl(fileId, channel, {
                     requestType: "Download",
                     streamType: "main",
                 });
@@ -1250,6 +1207,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         const logger = this.getBaichuanLogger();
 
         this.videoClipsAutoLoadInProgress = true;
+        this.videoClipsAutoLoadMode = true;
 
         try {
             const daysToPreload = this.storageSettings.values.videoclipsDaysToPreload ?? 1;
@@ -1315,6 +1273,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             logger.error('Error during auto-loading video clips:', e);
         } finally {
             this.videoClipsAutoLoadInProgress = false;
+            this.videoClipsAutoLoadMode = false;
         }
     }
 
@@ -1325,7 +1284,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
 
     // BaseBaichuanClass abstract methods implementation
     protected getConnectionConfig(): BaichuanConnectionConfig {
-        const { ipAddress, username, password, uid } = this.storageSettings.values;
+        const { ipAddress, username, password, uid, discoveryMethod } = this.storageSettings.values;
         const debugOptions = this.getBaichuanDebugOptions();
         const normalizedUid = this.isBattery ? normalizeUid(uid) : undefined;
 
@@ -1333,15 +1292,14 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             throw new Error('UID is required for battery cameras (BCUDP)');
         }
 
-        const logger = this.getBaichuanLogger();
         return {
             host: ipAddress,
             username,
             password,
             uid: normalizedUid,
             transport: this.protocol,
-            logger,
             debugOptions,
+            udpDiscoveryMethod: discoveryMethod as BaichuanClientOptions["udpDiscoveryMethod"],
         };
     }
 
@@ -1424,12 +1382,17 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
 
         try {
             const api = await this.ensureClient();
+            const { ipAddress, username, password } = this.storageSettings.values;
 
             const result = await api.runAllDiagnosticsConsecutively({
+                host: ipAddress,
+                username,
+                password,
                 outDir: outputPath,
                 channel,
                 durationSeconds,
                 selection,
+                api,
             });
 
             logger.log(`Diagnostics completed successfully. Output directory: ${result.runDir}`);
@@ -2497,6 +2460,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 logger.warn('Failed to connect/refresh during init', e);
             }
         }
+        this.storageSettings.settings.socketApiDebugLogs.hide = !!this.nvrDevice;
         this.storageSettings.settings.clipsSource.hide = !this.nvrDevice;
         this.storageSettings.settings.clipsSource.defaultValue = this.nvrDevice ? "NVR" : "Device";
 
@@ -2513,6 +2477,9 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         this.storageSettings.settings.widerChannel.hide = !this.isMultiFocal;
         this.storageSettings.settings.teleChannel.hide = !this.isMultiFocal;
 
+        this.storageSettings.settings.uid.hide = !this.isBattery;
+        this.storageSettings.settings.discoveryMethod.hide = !this.isBattery;
+
         if (this.isBattery && !this.storageSettings.values.mixinsSetup) {
             try {
                 const device = sdk.systemManager.getDeviceById<Settings>(this.id);

package/src/connect.ts

@@ -9,6 +9,7 @@ export type BaichuanConnectInputs = {
     uid?: string;
     logger?: Console;
     debugOptions?: BaichuanClientOptions['debugOptions'];
+    udpDiscoveryMethod?: "local" | "remote" | "map" | "relay";
 };
 
 export function normalizeUid(uid?: string): string | undefined {
@@ -81,6 +82,7 @@ export async function createBaichuanApi(props: {
         transport: "udp",
         uid,
         idleDisconnect: true,
+        udpDiscoveryMethod: inputs.udpDiscoveryMethod,
     });
     attachErrorHandler(api);
     return api;

package/src/main.ts

@@ -200,6 +200,7 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
             device.storageSettings.values.ipAddress = ipAddress;
             device.storageSettings.values.capabilities = capabilities;
             device.storageSettings.values.uid = uid;
+            device.storageSettings.values.discoveryMethod = detection.udpDiscoveryMethod;
 
             return nativeId;
         }