@apocaliss92/scrypted-reolink-native 0.1.32 → 0.1.35

package/src/debug-options.ts

@@ -8,6 +8,8 @@ export enum DebugLogOption {
     General = 'general',
     /** RTSP proxy/server debug logs */
     DebugRtsp = 'debugRtsp',
+    /** Low-level tracing for recording-related commands */
+    TraceRecordings = 'traceRecordings',
     /** Stream command tracing */
     TraceStream = 'traceStream',
     /** Talkback tracing */
@@ -27,6 +29,7 @@ export function mapDebugLogToApiOption(option: DebugLogOption): keyof DebugOptio
     const mapping: Record<DebugLogOption, keyof DebugOptions | null> = {
         [DebugLogOption.General]: 'general',
         [DebugLogOption.DebugRtsp]: 'debugRtsp',
+        [DebugLogOption.TraceRecordings]: 'traceRecordings',
         [DebugLogOption.TraceStream]: 'traceStream',
         [DebugLogOption.TraceTalk]: 'traceTalk',
         [DebugLogOption.TraceEvents]: 'traceEvents',
@@ -77,6 +80,7 @@ export function getApiRelevantDebugLogs(debugLogs: string[]): string[] {
 export const DebugLogDisplayNames: Record<DebugLogOption, string> = {
     [DebugLogOption.General]: 'General',
     [DebugLogOption.DebugRtsp]: 'RTSP',
+    [DebugLogOption.TraceRecordings]: 'Trace recordings',
     [DebugLogOption.TraceStream]: 'Trace stream',
     [DebugLogOption.TraceTalk]: 'Trace talk',
     [DebugLogOption.TraceEvents]: 'Trace events XML',

package/src/main.ts

@@ -1,16 +1,36 @@
-import sdk, { DeviceCreator, DeviceCreatorSettings, DeviceProvider, ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, ScryptedNativeId, Setting } from "@scrypted/sdk";
+import sdk, { DeviceCreator, DeviceCreatorSettings, DeviceProvider, HttpRequest, HttpResponse, MediaObject, ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, ScryptedMimeTypes, ScryptedNativeId, Setting, VideoClips } from "@scrypted/sdk";
 import { BaseBaichuanClass } from "./baichuan-base";
 import { ReolinkNativeCamera } from "./camera";
 import { ReolinkNativeBatteryCamera } from "./camera-battery";
 import { CommonCameraMixin } from "./common";
-import { createBaichuanApi } from "./connect";
-import { ReolinkNativeNvrDevice } from "./nvr";
-import { batteryCameraSuffix, batteryMultifocalSuffix, cameraSuffix, getDeviceInterfaces, multifocalSuffix, nvrSuffix } from "./utils";
 import { ReolinkNativeMultiFocalDevice } from "./multiFocal";
+import { ReolinkNativeNvrDevice } from "./nvr";
+import { batteryCameraSuffix, batteryMultifocalSuffix, cameraSuffix, extractThumbnailFromVideo, getDeviceInterfaces, handleVideoClipRequest, multifocalSuffix, nvrSuffix } from "./utils";
+
+interface ThumbnailRequest {
+    deviceId: string;
+    fileId: string;
+    rtmpUrl?: string;
+    filePath?: string;
+    logger: Console;
+    resolve: (mo: MediaObject) => void;
+    reject: (error: Error) => void;
+}
+
+interface ThumbnailRequestInput {
+    deviceId: string;
+    fileId: string;
+    rtmpUrl?: string;
+    filePath?: string;
+    logger: Console;
+}
 
 class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider, DeviceCreator {
     devices = new Map<string, BaseBaichuanClass>();
+    mixinsMap = new Map<string, CommonCameraMixin>();
     nvrDeviceId: string;
+    private thumbnailQueue: ThumbnailRequest[] = [];
+    private thumbnailProcessing = false;
 
     constructor(nativeId: string) {
         super(nativeId);
@@ -236,6 +256,140 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
             return new ReolinkNativeCamera(nativeId, this);
         }
     }
+
+    async onRequest(request: HttpRequest, response: HttpResponse): Promise<void> {
+        const logger = this.console;
+        const url = new URL(`http://localhost${request.url}`);
+
+        try {
+            // Parse webhook path: /.../webhook/{type}/{deviceId}/{fileId}
+            // The path may include prefix like /endpoint/@apocaliss92/scrypted-reolink-native/public/webhook/...
+            const pathParts = url.pathname.split('/').filter(p => p);
+
+            // Find the index of 'webhook' in the path
+            const webhookIndex = pathParts.indexOf('webhook');
+            if (webhookIndex === -1 || pathParts.length < webhookIndex + 4) {
+                response.send('Invalid webhook path', { code: 404 });
+                return;
+            }
+
+            // Extract type, deviceId, and fileId after 'webhook'
+            const type = pathParts[webhookIndex + 1];
+            const encodedDeviceId = pathParts[webhookIndex + 2];
+            // fileId may contain slashes, so join all remaining parts
+            const encodedFileId = pathParts.slice(webhookIndex + 3).join('/');
+            const deviceId = decodeURIComponent(encodedDeviceId);
+            let fileId = decodeURIComponent(encodedFileId);
+
+            // Restore leading slash if the original fileId had it (we removed it during encoding)
+            // The API expects fileId with leading slash for absolute paths
+            if (!fileId.startsWith('/') && !fileId.startsWith('http')) {
+                // If it looks like an absolute path (starts with common path prefixes), add slash
+                if (fileId.startsWith('mnt/') || fileId.startsWith('var/') || fileId.startsWith('tmp/')) {
+                    fileId = `/${fileId}`;
+                }
+            }
+
+            // logger.log(`Webhook request: type=${type}, deviceId=${deviceId}, fileId=${fileId}`);
+
+            // Get the device
+            const device = this.mixinsMap.get(deviceId);
+            if (!device) {
+                response.send('Device not found', { code: 404 });
+                return;
+            }
+
+            if (type === 'video') {
+                await handleVideoClipRequest({
+                    device,
+                    deviceId,
+                    fileId,
+                    request,
+                    response,
+                    logger,
+                });
+                return;
+            } else if (type === 'thumbnail') {
+                // Get thumbnail MediaObject
+                const mo = await device.getVideoClipThumbnail(fileId);
+
+                // Convert to buffer
+                const buffer = await sdk.mediaManager.convertMediaObjectToBuffer(mo, 'image/jpeg');
+
+                // Send image
+                response.send(buffer, {
+                    code: 200,
+                    headers: {
+                        'Content-Type': 'image/jpeg',
+                        'Cache-Control': 'max-age=31536000',
+                    },
+                });
+                return;
+            } else {
+                response.send('Invalid webhook type', { code: 404 });
+                return;
+            }
+        } catch (e: any) {
+            logger.error('Error in onRequest', e);
+            response.send(`Error: ${e.message}`, {
+                code: 500,
+            });
+            return;
+        }
+    }
+
+    onPush(request: HttpRequest): Promise<void> {
+        return this.onRequest(request, undefined);
+    }
+
+    /**
+     * Add a thumbnail generation request to the queue
+     */
+    async generateThumbnail(request: ThumbnailRequestInput): Promise<MediaObject> {
+        const queueLength = this.thumbnailQueue.length;
+        request.logger.log(`[Thumbnail] Download start: fileId=${request.fileId}, queuePosition=${queueLength + 1}`);
+
+        return new Promise((resolve, reject) => {
+            this.thumbnailQueue.push({
+                ...request,
+                resolve,
+                reject,
+            });
+            this.processThumbnailQueue();
+        });
+    }
+
+    /**
+     * Process the thumbnail queue sequentially
+     */
+    private async processThumbnailQueue(): Promise<void> {
+        if (this.thumbnailProcessing || this.thumbnailQueue.length === 0) {
+            return;
+        }
+
+        this.thumbnailProcessing = true;
+
+        while (this.thumbnailQueue.length > 0) {
+            const request = this.thumbnailQueue.shift()!;
+            const logger = request.logger;
+
+            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);
+                request.reject(error instanceof Error ? error : new Error(String(error)));
+            }
+
+            // Add 2 second delay between thumbnails (except after the last one)
+            if (this.thumbnailQueue.length > 0) {
+                await new Promise(resolve => setTimeout(resolve, 2000));
+            }
+        }
+
+        this.thumbnailProcessing = false;
+    }
 }
 
 export default ReolinkNativePlugin;

package/src/multiFocal.ts

@@ -75,7 +75,6 @@ export class ReolinkNativeMultiFocalDevice extends CommonCameraMixin implements
             this.storageSettings.settings.uid.hide = !this.isBattery;
 
             await this.ensureBaichuanClient();
-            await this.updateDeviceInfo();
             await this.reportDevices();
             await this.subscribeToEvents();
         } catch (e) {
@@ -89,27 +88,9 @@ export class ReolinkNativeMultiFocalDevice extends CommonCameraMixin implements
         }
     }
 
-    async updateDeviceInfo(): Promise<void> {
-        const logger = this.getBaichuanLogger();
-        try {
-            const api = await this.ensureBaichuanClient();
-            const deviceData = await api.getInfo();
-
-            await updateDeviceInfo({
-                device: this,
-                deviceData,
-                ipAddress: this.storageSettings.values.ipAddress,
-                logger,
-            });
-        } catch (e) {
-            logger.warn('Failed to fetch device info', e);
-        }
-    }
-
     getInterfaces(channel: number) {
         const logger = this.getBaichuanLogger();
-        const values = this.storageSettings.values as any;
-        const { capabilities: caps, multifocalInfo } = values;
+        const { capabilities: caps, multifocalInfo } = this.storageSettings.values;
         const channelInfo = (multifocalInfo as DualLensChannelAnalysis).channels.find(c => c.channel === channel);
 
         const capabilities: DeviceCapabilities = {
@@ -213,15 +194,6 @@ export class ReolinkNativeMultiFocalDevice extends CommonCameraMixin implements
         }
     }
 
-    async getSettings(): Promise<Setting[]> {
-        const settings = await this.storageSettings.getSettings();
-        return settings;
-    }
-
-    async putSetting(key: string, value: SettingValue): Promise<void> {
-        return this.storageSettings.putSetting(key, value);
-    }
-
     async releaseDevice(id: string, nativeId: string) {
         this.cameraNativeMap.delete(nativeId);
         super.releaseDevice(id, nativeId);

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();
 
@@ -222,9 +247,7 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
                 case 'doorbell':
                     // Handle doorbell if camera supports it
                     try {
-                        if (typeof (targetCamera as any).handleDoorbellEvent === 'function') {
-                            (targetCamera as any).handleDoorbellEvent();
-                        }
+                        targetCamera.handleDoorbellEvent();
                     }
                     catch (e) {
                         logger.warn(`Error handling doorbell event for camera channel ${channel}`, e);
@@ -469,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;
         }
 

package/src/stream-utils.ts

@@ -17,8 +17,9 @@ export interface StreamManagerOptions {
     /**
      * Creates a dedicated Baichuan session for streaming.
      * Required to support concurrent main+ext streams on firmwares where streamType overlaps.
+     * @param profile The stream profile (main, sub, ext) - used to determine if a new client is needed.
      */
-    createStreamClient: () => Promise<ReolinkBaichuanApi>;
+    createStreamClient: (profile?: StreamProfile) => Promise<ReolinkBaichuanApi>;
     getLogger: () => Console;
     /**
      * Credentials to include in the TCP stream (username, password).
@@ -201,7 +202,7 @@ export class StreamManager {
     }
 
     private getLogger() {
-        return this.opts.getLogger() ;
+        return this.opts.getLogger();
     }
 
     private async ensureRfcServer(
@@ -213,11 +214,27 @@ export class StreamManager {
             compositeOptions?: CompositeStreamPipOptions;
         },
     ): Promise<RfcServerInfo> {
+        // Check for existing promise first to prevent duplicate server creation
         const existingCreate = this.nativeRfcServerCreatePromises.get(streamKey);
         if (existingCreate) {
             return await existingCreate;
         }
 
+        // Double-check: if server already exists and is listening, return it immediately
+        const existingServer = this.nativeRfcServers.get(streamKey);
+        if (existingServer?.server?.listening) {
+            if (!expectedVideoType || existingServer.videoType === expectedVideoType) {
+                return {
+                    host: existingServer.host,
+                    port: existingServer.port,
+                    sdp: existingServer.sdp,
+                    audio: existingServer.audio,
+                    username: existingServer.username || this.opts.credentials.username,
+                    password: existingServer.password || this.opts.credentials.password,
+                };
+            }
+        }
+
         const createPromise = (async () => {
             const cached = this.nativeRfcServers.get(streamKey);
             if (cached?.server?.listening) {
@@ -233,8 +250,8 @@ export class StreamManager {
                         port: cached.port,
                         sdp: cached.sdp,
                         audio: cached.audio,
-                        username: (cached as any).username || this.opts.credentials.username,
-                        password: (cached as any).password || this.opts.credentials.password,
+                        username: cached.username || this.opts.credentials.username,
+                        password: cached.password || this.opts.credentials.password,
                     };
                 }
             }
@@ -249,7 +266,7 @@ export class StreamManager {
                 this.nativeRfcServers.delete(streamKey);
             }
 
-            const api = await this.opts.createStreamClient();
+            const api = await this.opts.createStreamClient(profile);
             const { createRfc4571TcpServer } = await import('@apocaliss92/reolink-baichuan-js');
 
             // Use the same credentials as the main connection
@@ -281,8 +298,8 @@ export class StreamManager {
                 port: created.port,
                 sdp: created.sdp,
                 audio: created.audio,
-                username: (created as any).username || this.opts.credentials.username,
-                password: (created as any).password || this.opts.credentials.password,
+                username: created.username || this.opts.credentials.username,
+                password: created.password || this.opts.credentials.password,
             };
         })();