@apocaliss92/scrypted-reolink-native 0.1.33 → 0.1.35

package/package.json

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

package/src/baichuan-base.ts

@@ -219,9 +219,9 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
             
             // Only reuse if both conditions are true
             if (isConnected && isLoggedIn) {
-                return this.baichuanApi;
-            }
-            
+            return this.baichuanApi;
+        }
+
             // If socket is not connected or not logged in, cleanup the stale client
             // This prevents leaking connections when the socket appears connected but isn't
             const logger = this.getBaichuanLogger();
@@ -358,7 +358,7 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
                 // Only cleanup if this is still the current API instance
                 // This prevents cleanup of a new connection that was created
                 // while the old one was closing
-                await this.cleanupBaichuanApi();
+            await this.cleanupBaichuanApi();
             }
 
             // Call custom close handler if provided

package/src/common.ts

@@ -22,7 +22,7 @@ import {
     selectStreamOption,
     StreamManager
 } from "./stream-utils";
-import { floodlightSuffix, getDeviceInterfaces, pirSuffix, recordingFileToVideoClip, sirenSuffix, updateDeviceInfo } from "./utils";
+import { floodlightSuffix, getDeviceInterfaces, getVideoClipWebhookUrls, pirSuffix, recordingFileToVideoClip, sirenSuffix, updateDeviceInfo, vodSearchResultsToVideoClips } from "./utils";
 
 export type CameraType = 'battery' | 'regular' | 'multi-focal' | 'multi-focal-battery';
 
@@ -559,6 +559,14 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 this.updateVideoClipsAutoLoad();
             },
         },
+        clipsSource: {
+            title: "Clips Source",
+            subgroup: 'Videoclips',
+            description: "Source for fetching video clips: NVR (fetch from NVR device) or Device (fetch directly from camera).",
+            type: "string",
+            choices: ["NVR", "Device"],
+            immediate: true,
+        },
         loadVideoclips: {
             title: "Auto-load Video Clips",
             subgroup: 'Videoclips',
@@ -709,36 +717,126 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
 
         const start = new Date(startMs);
         const end = new Date(endMs);
-        start.setHours(0, 0, 0, 0);
+        // Use UTC to match API's dateToReolinkTime conversion
+        start.setUTCHours(0, 0, 0, 0);
 
         try {
-            const api = await this.ensureClient();
-            const recordings = await api.listEnrichedRecordingsByTime({
-                start,
-                end,
-                count,
-                streamType: 'mainStream',
-                httpFallback: false,
-                fetchRtmpUrls: true
-            });
+            const { clipsSource } = this.storageSettings.values;
+            const useNvr = clipsSource === "NVR" && this.nvrDevice;
+
+            if (useNvr) {
+                // Fetch from NVR using listEnrichedVodFiles (library handles parsing correctly)
+                const channel = this.storageSettings.values.rtspChannel ?? 0;
+                logger.debug(`Fetching video clips from NVR for channel ${channel}`);
+
+                // Use listEnrichedVodFiles which properly parses filenames and extracts detection info
+                logger.log(`[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({
+                    channel,
+                    start,
+                    end,
+                    streamType: "main",
+                    autoSearchByDay: false, // Disable autoSearchByDay to avoid searching past days
+                    bypassCache: false,
+                });
 
-            const clips: VideoClip[] = [];
+                logger.log(`[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.log(`[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,
+                        });
+                    }
+                }
 
-            for (const rec of recordings) {
-                const clip = await recordingFileToVideoClip(rec, {
-                    fallbackStart: start,
-                    api,
-                    logger,
-                    plugin: this,
-                    deviceId: this.id,
-                    useWebhook: true,
+                // 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);
+                }
+
+                // Apply count limit if specified
+                const finalClips = count ? clips.slice(0, count) : clips;
+                logger.log(`[NVR VOD] Converted ${finalClips.length} video clips (limit: ${count || 'none'})`);
+
+                return finalClips;
+            } else {
+                // Fetch directly from device using Baichuan API
+                const api = await this.ensureClient();
+
+                const recordings = await api.listEnrichedRecordingsByTime({
+                    start,
+                    end,
+                    count,
+                    channel: this.storageSettings.values.rtspChannel,
+                    streamType: 'mainStream',
+                    httpFallback: false,
+                    fetchRtmpUrls: true
                 });
-                clips.push(clip);
-            }
 
-            logger.debug(`Videoclips found: ${JSON.stringify(clips)}`);
+                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);
+                }
+
+                logger.debug(`Videoclips found: ${clips.length}`);
 
-            return clips;
+                return clips;
+            }
         } catch (e: any) {
             const message = e instanceof Error ? e.message : String(e);
 
@@ -948,26 +1046,9 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                     logger: this.getBaichuanLogger(),
                 });
             } else {
-                // Ensure client is connected and logged in (reuses existing connection if available)
-                // This ensures no new sessions are created during thumbnail operations
-                const api = await this.ensureClient();
-
-                if (!api.client.isSocketConnected() || !api.client.loggedIn) {
-                    logger.warn(`[Thumbnail] Client not ready, waiting for connection: fileId=${thumbnailId}`);
-                    // ensureClient should have already handled connection, but wait a bit if needed
-                    await new Promise(resolve => setTimeout(resolve, 500));
-                }
-
-                // Get RTMP URL from fileId
-                // Note: getRecordingPlaybackUrls internally calls login(), but it should be idempotent
-                // if ensureClient() already established the connection
-                const { rtmpVodUrl } = await api.getRecordingPlaybackUrls({
-                    fileName: thumbnailId,
-                });
-
-                if (!rtmpVodUrl) {
-                    throw new Error(`No playback URL found for video ${thumbnailId}`);
-                }
+                // Get RTMP URL using the appropriate API (NVR or Baichuan)
+                // Use forThumbnail=true to prefer Download over Playback (better for ffmpeg)
+                const rtmpVodUrl = await this.getVideoClipRtmpUrl(thumbnailId, true);
 
                 // Use the plugin's thumbnail generation queue with RTMP URL
                 thumbnail = await this.plugin.generateThumbnail({
@@ -995,6 +1076,56 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         }
     }
 
+    /**
+     * Get RTMP URL for a video clip file
+     * Handles both NVR source (full path) and Device source (filename only)
+     * @param fileId - The file ID or full path
+     * @param forThumbnail - If true, prefer Download over Playback (better for ffmpeg thumbnail extraction)
+     */
+    async getVideoClipRtmpUrl(fileId: string, forThumbnail: boolean = false): Promise<string> {
+        const logger = this.getBaichuanLogger();
+        const { clipsSource } = this.storageSettings.values;
+        const useNvr = clipsSource === "NVR" && this.nvrDevice && fileId.includes('/');
+
+        if (useNvr) {
+            logger.log(`[getVideoClipRtmpUrl] Using NVR API for fileId="${fileId}", forThumbnail=${forThumbnail}`);
+            const nvrApi = await this.nvrDevice.ensureClient();
+            const channel = this.storageSettings.values.rtspChannel ?? 0;
+            
+            // For both thumbnails and video streaming, try Download first
+            // Download might return MP4 format which is better supported than FLV from Playback
+            const requestTypes = ["Download", "Playback"];
+            
+            for (const requestType of requestTypes) {
+                try {
+                    logger.log(`[getVideoClipRtmpUrl] Trying getVodUrl with ${requestType} requestType...`);
+                    const url = await nvrApi.getVodUrl(fileId, channel, {
+                        requestType: requestType as "Playback" | "Download",
+                        streamType: "main",
+                    });
+                    logger.log(`[getVideoClipRtmpUrl] NVR getVodUrl ${requestType} URL received: url="${url || 'none'}"`);
+                    if (url) return url;
+                } catch (e: any) {
+                    logger.debug(`[getVideoClipRtmpUrl] getVodUrl ${requestType} failed: ${e.message}`);
+                }
+            }
+            
+            throw new Error(`No streaming URL found from NVR for file ${fileId} after trying Playback and Download methods`);
+        } else {
+            // Camera standalone: DEVE usare RTMP da Baichuan API
+            logger.log(`[getVideoClipRtmpUrl] Getting RTMP URL from Baichuan API for fileId="${fileId}" (camera standalone)`);
+            const api = await this.ensureClient();
+            const result = await api.getRecordingPlaybackUrls({
+                fileName: fileId,
+            });
+            logger.log(`[getVideoClipRtmpUrl] Baichuan RTMP URL received: rtmpVodUrl="${result.rtmpVodUrl || 'none'}"`);
+            if (!result.rtmpVodUrl) {
+                throw new Error(`No RTMP URL found from Baichuan API for file ${fileId}`);
+            }
+            return result.rtmpVodUrl;
+        }
+    }
+
     removeVideoClips(...videoClipIds: string[]): Promise<void> {
         throw new Error("removeVideoClips is not implemented yet.");
     }
@@ -1055,8 +1186,8 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             // Get today's date range (start of today to now)
             const now = new Date();
             const startOfToday = new Date(now);
-            startOfToday.setHours(0, 0, 0, 0);
-            startOfToday.setMinutes(0, 0, 0);
+            startOfToday.setUTCHours(0, 0, 0, 0);
+            startOfToday.setUTCMinutes(0, 0, 0);
 
             // Fetch today's video clips
             const clips = await this.getVideoClips({
@@ -2293,7 +2424,8 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 logger.warn('Failed to connect/refresh during init', e);
             }
         }
-
+        this.storageSettings.settings.clipsSource.hide = !this.nvrDevice;
+        this.storageSettings.settings.clipsSource.defaultValue = this.nvrDevice ? "NVR" : "Device";
 
         this.storageSettings.settings.videoclipsRegularChecks.defaultValue = this.isBattery ? 120 : 30;
 

package/src/main.ts

@@ -347,8 +347,7 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
      */
     async generateThumbnail(request: ThumbnailRequestInput): Promise<MediaObject> {
         const queueLength = this.thumbnailQueue.length;
-        const isProcessing = this.thumbnailProcessing;
-        request.logger.log(`[Thumbnail] Adding to queue: fileId=${request.fileId}, queueLength=${queueLength}, processing=${isProcessing}`);
+        request.logger.log(`[Thumbnail] Download start: fileId=${request.fileId}, queuePosition=${queueLength + 1}`);
 
         return new Promise((resolve, reject) => {
             this.thumbnailQueue.push({
@@ -376,6 +375,7 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
 
             try {
                 const thumbnail = await extractThumbnailFromVideo(request);
+                logger.log(`[Thumbnail] OK: fileId=${request.fileId}`);
                 request.resolve(thumbnail);
             } catch (error) {
                 logger.error(`[Thumbnail] Error: fileId=${request.fileId}`, error);

package/src/nvr.ts

@@ -1,7 +1,7 @@
-import type { DeviceInfoResponse, DeviceInputData, EventsResponse, ReolinkBaichuanApi, ReolinkCgiApi, ReolinkSimpleEvent } 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 type { DeviceInfoResponse, EnrichedRecordingFile, EventsResponse, ReolinkBaichuanApi, ReolinkCgiApi, 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 BaichuanConnectionConfig, type BaichuanConnectionCallbacks } from "./baichuan-base";
+import { BaseBaichuanClass, type BaichuanConnectionCallbacks, type BaichuanConnectionConfig } from "./baichuan-base";
 import { ReolinkNativeCamera } from "./camera";
 import { ReolinkNativeBatteryCamera } from "./camera-battery";
 import { normalizeUid } from "./connect";
@@ -80,8 +80,8 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
     }
 
     async reboot(): Promise<void> {
-        const api = await this.ensureClient();
-        await api.Reboot();
+        const api = await this.ensureBaichuanClient();
+        await api.reboot();
     }
 
     // BaseBaichuanClass abstract methods implementation
@@ -175,16 +175,41 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
         }
 
         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();
 
@@ -467,33 +492,15 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
     async syncEntitiesFromRemote() {
         const logger = this.getBaichuanLogger();
 
-        // Ensure both APIs are ready before syncing
-        const api = await this.ensureClient();
-        const baichuanApi = await this.ensureBaichuanClient();
-
-        // Wait for Baichuan connection to be fully established
-        if (baichuanApi?.client) {
-            // Check if already connected
-            if (!baichuanApi.client.isSocketConnected()) {
-                logger.debug('Waiting for Baichuan connection to be established...');
-                // Wait up to 5 seconds for connection
-                let attempts = 0;
-                while (!baichuanApi.client.isSocketConnected() && attempts < 50) {
-                    await new Promise(resolve => setTimeout(resolve, 100));
-                    attempts++;
-                }
-                if (!baichuanApi.client.isSocketConnected()) {
-                    logger.warn('Baichuan connection not established after waiting, proceeding anyway');
-                } else {
-                    logger.debug('Baichuan connection established');
-                }
-            }
-        }
+        const cgiApi = await this.ensureClient();
+        const { devicesData, channels } = await cgiApi.getDevicesInfo();
 
-        const { devicesData, channels } = await api.getDevicesInfo();
+        // const api = await this.ensureBaichuanClient();
+        // const devicesMap = api.getDevicesInfo();
+        // const deviceEntries = Object.entries(devicesMap);
 
         if (!channels.length) {
-            logger.debug(`No channels found, ${JSON.stringify({ devicesData, channels })}`);
+            logger.debug(`No channels found, ${JSON.stringify({ channels, devicesData })}`);
             return;
         }