@apocaliss92/scrypted-reolink-native 0.1.31 → 0.1.33

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);
@@ -96,7 +116,7 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
             device.storageSettings.values.ipAddress = ipAddress;
             device.storageSettings.values.username = username;
             device.storageSettings.values.password = password;
-            device.storageSettings.values.uid = detection.uid || '';
+            device.storageSettings.values.uid = uid;
             device.storageSettings.values.capabilities = capabilities;
 
             return nativeId;
@@ -177,7 +197,7 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
             device.storageSettings.values.rtspChannel = rtspChannel;
             device.storageSettings.values.ipAddress = ipAddress;
             device.storageSettings.values.capabilities = capabilities;
-            device.storageSettings.values.uid = detection.uid;
+            device.storageSettings.values.uid = uid;
 
             return 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

@@ -1,12 +1,9 @@
-import type { DeviceCapabilities, DualLensChannelAnalysis, ReolinkSimpleEvent, ReolinkSupportedStream } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
-import sdk, { Device, DeviceProvider, MediaObject, Reboot, RequestMediaStreamOptions, ScryptedDeviceType, Setting, Settings, SettingValue } from "@scrypted/sdk";
-import { type BaichuanConnectionCallbacks } from "./baichuan-base";
+import type { DeviceCapabilities, DualLensChannelAnalysis, ReolinkSimpleEvent } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
+import sdk, { Device, DeviceProvider, Reboot, ScryptedDeviceType, Setting, Settings, SettingValue } from "@scrypted/sdk";
 import { ReolinkNativeCamera } from "./camera";
 import { ReolinkNativeBatteryCamera } from "./camera-battery";
 import { CameraType, CommonCameraMixin } from "./common";
 import ReolinkNativePlugin from "./main";
-import { StreamManager } from "./stream-utils";
-import type { UrlMediaStreamOptions } from "../../scrypted/plugins/rtsp/src/rtsp";
 import { batteryCameraSuffix, cameraSuffix, getDeviceInterfaces, updateDeviceInfo } from "./utils";
 
 export class ReolinkNativeMultiFocalDevice extends CommonCameraMixin implements Settings, DeviceProvider, Reboot {
@@ -36,28 +33,6 @@ export class ReolinkNativeMultiFocalDevice extends CommonCameraMixin implements
         }
     }
 
-    protected getConnectionCallbacks(): BaichuanConnectionCallbacks {
-        return {
-            onError: undefined, // Use default error handling
-            onClose: async () => {
-                // Reinit after cleanup
-                await this.reinit();
-                if (!this.isBattery) {
-                    setTimeout(async () => {
-                        try {
-                            await this.subscribeToEvents();
-                        } catch (e) {
-                            const logger = this.getBaichuanLogger();
-                            logger.warn('Failed to resubscribe to events after reconnection', e);
-                        }
-                    }, 1000);
-                }
-            },
-            onSimpleEvent: (ev) => this.forwardNativeEvent(ev),
-            getEventSubscriptionEnabled: () => true,
-        };
-    }
-
     protected async onBeforeCleanup(): Promise<void> {
         await this.unsubscribeFromAllEvents();
     }
@@ -100,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) {
@@ -114,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 = {
@@ -220,53 +176,6 @@ export class ReolinkNativeMultiFocalDevice extends CommonCameraMixin implements
         }
 
         await super.reportDevices();
-
-        // Initialize StreamManager with composite options for multifocal device
-        // Use saved settings or defaults
-        const values = this.storageSettings.values as any;
-        const pipPosition = (values.pipPosition || 'bottom-right') as any;
-        const pipSize = values.pipSize ?? 0.25;
-        const pipMargin = values.pipMargin ?? 10;
-        const widerChannel = values.widerChannel ?? 0;
-        const teleChannel = values.teleChannel ?? 1;
-
-        if (!this.streamManager) {
-            this.streamManager = new StreamManager({
-                createStreamClient: () => this.createStreamClient(),
-                getLogger: () => logger,
-                credentials: {
-                    username,
-                    password
-                },
-                sharedConnection: this.isBattery,
-                compositeOptions: {
-                    widerChannel,
-                    teleChannel,
-                    pipPosition: pipPosition as any,
-                    pipSize,
-                    pipMargin,
-                },
-            });
-        } else {
-            // Recreate StreamManager with new settings if they changed
-            // StreamManager doesn't expose opts, so we need to recreate it
-            this.streamManager = new StreamManager({
-                createStreamClient: () => this.createStreamClient(),
-                getLogger: () => logger,
-                credentials: {
-                    username,
-                    password
-                },
-                sharedConnection: this.isBattery,
-                compositeOptions: {
-                    widerChannel,
-                    teleChannel,
-                    pipPosition: pipPosition as any,
-                    pipSize,
-                    pipMargin,
-                },
-            });
-        }
     }
 
     async getDevice(nativeId: string) {
@@ -285,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).
@@ -113,11 +114,15 @@ export async function createRfc4571MediaObjectFromStreamManager(params: {
         mso.audio.sampleRate = audio.sampleRate;
         mso.audio.channels = audio.channels;
     }
-    const url = new URL(host);
+
+    const url = new URL(`tcp://${host}`);
     url.port = port.toString();
-    url.protocol = 'tcp';
-    url.username = username;
-    url.password = password;
+    if (username) {
+        url.username = username;
+    }
+    if (password) {
+        url.password = password;
+    }
 
     const rfc = {
         url,
@@ -197,26 +202,46 @@ export class StreamManager {
     }
 
     private getLogger() {
-        return this.opts.getLogger() ;
+        return this.opts.getLogger();
     }
 
-    private async ensureNativeRfcServer(
+    private async ensureRfcServer(
         streamKey: string,
-        channel: number,
         profile: StreamProfile,
-        expectedVideoType?: 'H264' | 'H265',
+        expectedVideoType: 'H264' | 'H265' | undefined,
+        options: {
+            channel?: number;
+            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) {
                 if (expectedVideoType && cached.videoType !== expectedVideoType) {
+                    const kind = options.channel === undefined ? 'composite' : 'native';
                     this.getLogger().warn(
-                        `Native RFC cache codec mismatch for ${streamKey}: cached=${cached.videoType} expected=${expectedVideoType}; recreating server.`,
+                        `Native RFC ${kind} cache codec mismatch for ${streamKey}: cached=${cached.videoType} expected=${expectedVideoType}; recreating server.`,
                     );
                 }
                 else {
@@ -225,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,
                     };
                 }
             }
@@ -241,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
@@ -252,13 +277,14 @@ export class StreamManager {
 
             const created = await createRfc4571TcpServer({
                 api,
-                channel,
+                channel: options.channel,
                 profile,
                 logger: this.getLogger(),
                 expectedVideoType: expectedVideoType as VideoType | undefined,
                 closeApiOnTeardown,
                 username,
                 password,
+                ...(options.compositeOptions ? { compositeOptions: options.compositeOptions } : {}),
             });
 
             this.nativeRfcServers.set(streamKey, created);
@@ -272,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,
             };
         })();
 
@@ -292,7 +318,9 @@ export class StreamManager {
         streamKey: string,
         expectedVideoType?: 'H264' | 'H265',
     ): Promise<RfcServerInfo> {
-        return await this.ensureNativeRfcServer(streamKey, channel, profile, expectedVideoType);
+        return await this.ensureRfcServer(streamKey, profile, expectedVideoType, {
+            channel,
+        });
     }
 
     async getRfcCompositeStream(
@@ -300,85 +328,10 @@ export class StreamManager {
         streamKey: string,
         expectedVideoType?: 'H264' | 'H265',
     ): Promise<RfcServerInfo> {
-        const existingCreate = this.nativeRfcServerCreatePromises.get(streamKey);
-        if (existingCreate) {
-            return await existingCreate;
-        }
-
-        const createPromise = (async () => {
-            const cached = this.nativeRfcServers.get(streamKey);
-            if (cached?.server?.listening) {
-                if (expectedVideoType && cached.videoType !== expectedVideoType) {
-                    this.getLogger().warn(
-                        `Native RFC composite cache codec mismatch for ${streamKey}: cached=${cached.videoType} expected=${expectedVideoType}; recreating server.`,
-                    );
-                }
-                else {
-                    return {
-                        host: cached.host,
-                        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,
-                    };
-                }
-            }
-
-            if (cached) {
-                try {
-                    await cached.close('recreate');
-                }
-                catch {
-                    // ignore
-                }
-                this.nativeRfcServers.delete(streamKey);
-            }
-
-            const api = await this.opts.createStreamClient();
-            const { createRfc4571TcpServer } = await import('@apocaliss92/reolink-baichuan-js');
-
-            // Use the same credentials as the main connection
-            const { username, password } = this.opts.credentials;
-
-            // If connection is shared, don't close it when stream teardown happens
-            const closeApiOnTeardown = !(this.opts.sharedConnection ?? false);
-
-            const created = await createRfc4571TcpServer({
-                api,
-                channel: undefined, // Undefined channel indicates composite stream
-                profile,
-                logger: this.getLogger(),
-                expectedVideoType: expectedVideoType as VideoType | undefined,
-                closeApiOnTeardown,
-                username,
-                password,
-                compositeOptions: this.opts.compositeOptions,
-            });
-
-            this.nativeRfcServers.set(streamKey, created);
-            created.server.once('close', () => {
-                const current = this.nativeRfcServers.get(streamKey);
-                if (current?.server === created.server) this.nativeRfcServers.delete(streamKey);
-            });
-
-            return {
-                host: created.host,
-                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,
-            };
-        })();
-
-        this.nativeRfcServerCreatePromises.set(streamKey, createPromise);
-        try {
-            return await createPromise;
-        }
-        finally {
-            this.nativeRfcServerCreatePromises.delete(streamKey);
-        }
+        return await this.ensureRfcServer(streamKey, profile, expectedVideoType, {
+            channel: undefined, // Undefined channel indicates composite stream
+            compositeOptions: this.opts.compositeOptions,
+        });
     }
 
     /**