@apocaliss92/scrypted-reolink-native 0.1.32 → 0.1.33

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;
+        const isProcessing = this.thumbnailProcessing;
+        request.logger.log(`[Thumbnail] Adding to queue: fileId=${request.fileId}, queueLength=${queueLength}, processing=${isProcessing}`);
+
+        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);
+                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

@@ -222,9 +222,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);

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,
             };
         })();