@apocaliss92/scrypted-reolink-native 0.1.32 → 0.1.33

package/src/common.ts

@@ -1,7 +1,10 @@
-import type { DeviceCapabilities, PtzCommand, PtzPreset, ReolinkBaichuanApi, ReolinkSimpleEvent, ReolinkSupportedStream, StreamSamplingSelection } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
+import type { 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';
+import fs from 'fs';
+import crypto from 'crypto';
+import { spawn } from 'node:child_process';
 import type { UrlMediaStreamOptions } from "../../scrypted/plugins/rtsp/src/rtsp";
 import { BaseBaichuanClass, type BaichuanConnectionCallbacks, type BaichuanConnectionConfig } from "./baichuan-base";
 import { createBaichuanApi, normalizeUid, type BaichuanTransport } from "./connect";
@@ -19,7 +22,7 @@ import {
     selectStreamOption,
     StreamManager
 } from "./stream-utils";
-import { floodlightSuffix, getDeviceInterfaces, pirSuffix, sirenSuffix, updateDeviceInfo } from "./utils";
+import { floodlightSuffix, getDeviceInterfaces, pirSuffix, recordingFileToVideoClip, sirenSuffix, updateDeviceInfo } from "./utils";
 
 export type CameraType = 'battery' | 'regular' | 'multi-focal' | 'multi-focal-battery';
 
@@ -545,6 +548,49 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             type: "string",
             defaultValue: path.join(process.env.SCRYPTED_PLUGIN_VOLUME, 'diagnostics', this.name),
         },
+        enableVideoclips: {
+            title: "Enable Video Clips",
+            subgroup: 'Videoclips',
+            description: "Enable video clips functionality. If disabled, getVideoClips will return empty and all other videoclip settings are ignored.",
+            type: "boolean",
+            defaultValue: false,
+            immediate: true,
+            onPut: async () => {
+                this.updateVideoClipsAutoLoad();
+            },
+        },
+        loadVideoclips: {
+            title: "Auto-load Video Clips",
+            subgroup: 'Videoclips',
+            description: "Automatically fetch today's video clips and download missing thumbnails at regular intervals.",
+            type: "boolean",
+            defaultValue: false,
+            immediate: true,
+            onPut: async () => {
+                this.updateVideoClipsAutoLoad();
+            },
+        },
+        videoclipsRegularChecks: {
+            title: "Video Clips Check Interval (minutes)",
+            subgroup: 'Videoclips',
+            description: "How often to check for new video clips and download thumbnails (default: 30 minutes).",
+            type: "number",
+            defaultValue: 30,
+            onPut: async () => {
+                this.updateVideoClipsAutoLoad();
+            },
+        },
+        downloadVideoclipsLocally: {
+            title: "Download Video Clips Locally",
+            subgroup: 'Videoclips',
+            description: "Automatically download and cache video clips to local filesystem during auto-load.",
+            type: "boolean",
+            defaultValue: false,
+            immediate: true,
+            onPut: async () => {
+                this.updateVideoClipsAutoLoad();
+            },
+        },
         diagnosticsRun: {
             subgroup: 'Diagnostics',
             title: 'Run Diagnostics',
@@ -586,7 +632,6 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     // Abstract init method that subclasses must implement
     abstract init(): Promise<void>;
 
-    protected withBaichuanClient?<T>(fn: (api: ReolinkBaichuanApi) => Promise<T>): Promise<T>;
     motionTimeout?: NodeJS.Timeout;
     doorbellBinaryTimeout?: NodeJS.Timeout;
     initComplete?: boolean;
@@ -598,6 +643,8 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     isBattery: boolean;
     isMultiFocal: boolean;
     private streamManagerRestartTimeout: NodeJS.Timeout | undefined;
+    private videoClipsAutoLoadInterval: NodeJS.Timeout | undefined;
+    private videoClipsAutoLoadInProgress: boolean = false;
 
     constructor(
         nativeId: string,
@@ -605,6 +652,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         public options: CommonCameraMixinOptions
     ) {
         super(nativeId);
+        this.plugin.mixinsMap.set(this.id, this);
 
         // Store NVR device reference if provided
         this.nvrDevice = options.nvrDevice;
@@ -620,25 +668,452 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         }, 2000);
     }
 
+    protected async withBaichuanClient<T>(fn: (api: ReolinkBaichuanApi) => Promise<T>): Promise<T> {
+        const client = await this.ensureClient();
+        return fn(client);
+    }
+
+    async getVideoClips(options?: VideoClipOptions): Promise<VideoClip[]> {
+        // Check if videoclips are enabled
+        if (!this.storageSettings.values.enableVideoclips) {
+            return [];
+        }
+
+        if (this.isBattery && this.sleeping) {
+            const logger = this.getBaichuanLogger();
+            logger.debug('getVideoClips: disabled for battery devices');
+            return [];
+        }
+
+        const logger = this.getBaichuanLogger();
+
+        // Determine time window
+        const nowMs = Date.now();
+        const defaultWindowMs = 60 * 60 * 1000; // last 60 minutes
+
+        const startMs = options?.startTime ?? (nowMs - defaultWindowMs);
+        let endMs = options?.endTime ?? nowMs;
+        const count = options?.count;
+
+        if (endMs > nowMs) {
+            endMs = nowMs;
+        }
+
+        if (endMs <= startMs) {
+            logger.warn('getVideoClips: invalid time window, endTime <= startTime', {
+                startTime: startMs,
+                endTime: endMs,
+            });
+            return [];
+        }
+
+        const start = new Date(startMs);
+        const end = new Date(endMs);
+        start.setHours(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 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: ${JSON.stringify(clips)}`);
+
+            return clips;
+        } catch (e: any) {
+            const message = e instanceof Error ? e.message : String(e);
+
+            if (message?.includes('UID is required to access recordings')) {
+                logger.log('getVideoClips: recordings not available or UID not resolvable for this device', {
+                    error: message,
+                });
+            } else {
+                logger.warn('getVideoClips: failed to list recordings', {
+                    error: message,
+                });
+            }
+            return [];
+        }
+    }
+
     /**
-     * TODO: Implement video clip fetching using Baichuan/NVR recordings API.
+     * Get the cache directory for video clips and thumbnails
      */
-    async getVideoClips(options?: VideoClipOptions): Promise<VideoClip[]> {
-        throw new Error("getVideoClips is not implemented yet.");
+    private getVideoClipCacheDir(): string {
+        const pluginVolume = process.env.SCRYPTED_PLUGIN_VOLUME || '';
+        const cameraId = this.id;
+        return path.join(pluginVolume, 'videoclips', cameraId);
     }
 
-    getVideoClip(videoId: string): Promise<MediaObject> {
-        throw new Error("getVideoClip is not implemented yet.");
+    /**
+     * Get cache file path for a video clip
+     */
+    getVideoClipCachePath(videoId: string): string {
+        // Create a safe filename from videoId using hash
+        const hash = crypto.createHash('md5').update(videoId).digest('hex');
+        // Keep original extension if present, otherwise use .mp4
+        const ext = videoId.includes('.') ? path.extname(videoId) : '.mp4';
+        const cacheDir = this.getVideoClipCacheDir();
+        return path.join(cacheDir, `${hash}${ext}`);
+    }
+
+    async getVideoClip(videoId: string): Promise<MediaObject> {
+        const logger = this.getBaichuanLogger();
+        try {
+            const cacheEnabled = this.storageSettings.values.downloadVideoclipsLocally
+
+            // Always check cache first, even if caching is disabled (in case user enabled it before)
+            const cachePath = this.getVideoClipCachePath(videoId);
+            const cacheDir = this.getVideoClipCacheDir();
+
+            // Check if cached file exists
+            try {
+                await fs.promises.access(cachePath, fs.constants.F_OK);
+                const stats = await fs.promises.stat(cachePath);
+                logger.debug(`[VideoClip] Using cached file: fileId=${videoId}, size=${stats.size} bytes`);
+                // Return cached file as MediaObject
+                const mo = await sdk.mediaManager.createMediaObjectFromUrl(`file://${cachePath}`);
+                return mo;
+            } catch (e) {
+                // File doesn't exist or error accessing it
+                logger.debug(`[VideoClip] Cache miss: fileId=${videoId}, error=${e instanceof Error ? e.message : String(e)}`);
+                if (cacheEnabled) {
+                    logger.debug(`[VideoClip] Will download and cache: fileId=${videoId}`);
+                }
+            }
+
+            // If caching is enabled, ensure cache directory exists
+            if (cacheEnabled) {
+                await fs.promises.mkdir(cacheDir, { recursive: true });
+            }
+
+            const api = await this.ensureClient();
+
+            // videoId is the fileId (fileName or id from the recording)
+            const { rtmpVodUrl } = await api.getRecordingPlaybackUrls({
+                fileName: videoId,
+            });
+
+            if (!rtmpVodUrl) {
+                throw new Error(`No playback URL found for video ${videoId}`);
+            }
+
+            // If caching is enabled, download and cache the video
+            if (cacheEnabled) {
+                const cachePath = this.getVideoClipCachePath(videoId);
+
+                // Download and convert RTMP to MP4 using ffmpeg
+                const ffmpegPath = await sdk.mediaManager.getFFmpegPath();
+                const ffmpegArgs = [
+                    '-i', rtmpVodUrl,
+                    '-c', 'copy', // Copy codecs without re-encoding
+                    '-f', 'mp4',
+                    '-movflags', 'frag_keyframe+empty_moov', // Enable streaming
+                    cachePath,
+                ];
+
+                logger.log(`Downloading video clip to cache: ${cachePath}`);
+
+                await new Promise<void>((resolve, reject) => {
+                    const ffmpeg = spawn(ffmpegPath, ffmpegArgs, {
+                        stdio: ['ignore', 'pipe', 'pipe'],
+                    });
+
+                    let errorOutput = '';
+
+                    ffmpeg.stderr.on('data', (chunk: Buffer) => {
+                        errorOutput += chunk.toString();
+                    });
+
+                    ffmpeg.on('close', (code) => {
+                        if (code !== 0) {
+                            logger.error(`ffmpeg failed to download video clip: ${errorOutput}`);
+                            reject(new Error(`ffmpeg failed with code ${code}: ${errorOutput}`));
+                            return;
+                        }
+
+                        logger.log(`Video clip cached successfully: ${cachePath}`);
+                        resolve();
+                    });
+
+                    ffmpeg.on('error', (error) => {
+                        logger.error(`ffmpeg spawn error for video clip ${videoId}`, error);
+                        reject(error);
+                    });
+
+                    // Timeout after 5 minutes
+                    const timeout = setTimeout(() => {
+                        ffmpeg.kill('SIGKILL');
+                        reject(new Error('Video clip download timeout'));
+                    }, 5 * 60 * 1000);
+
+                    ffmpeg.on('close', () => {
+                        clearTimeout(timeout);
+                    });
+                });
+
+                // Return cached file as MediaObject
+                const mo = await sdk.mediaManager.createMediaObjectFromUrl(`file://${cachePath}`);
+                return mo;
+            } else {
+                // Caching disabled, return RTMP URL directly
+                const mo = await sdk.mediaManager.createMediaObjectFromUrl(rtmpVodUrl);
+                return mo;
+            }
+        } catch (e) {
+            logger.error(`getVideoClip: failed to get video clip ${videoId}`, e);
+            throw e;
+        }
     }
 
-    getVideoClipThumbnail(thumbnailId: string, options?: VideoClipThumbnailOptions): Promise<MediaObject> {
-        throw new Error("getVideoClipThumbnail is not implemented yet.");
+    /**
+     * Get the cache directory for thumbnails (same as video clips)
+     */
+    private getThumbnailCacheDir(): string {
+        // Use the same directory as video clips
+        return this.getVideoClipCacheDir();
+    }
+
+    /**
+     * Get cache file path for a thumbnail
+     */
+    private getThumbnailCachePath(fileId: string): string {
+        // Use the same hash and base name as video clips, but with .jpg extension
+        const hash = crypto.createHash('md5').update(fileId).digest('hex');
+        const cacheDir = this.getThumbnailCacheDir();
+        return path.join(cacheDir, `${hash}.jpg`);
+    }
+
+    async getVideoClipThumbnail(thumbnailId: string, options?: VideoClipThumbnailOptions): Promise<MediaObject> {
+        const logger = this.getBaichuanLogger();
+
+        try {
+            // Check cache first
+            const cachePath = this.getThumbnailCachePath(thumbnailId);
+            const cacheDir = this.getThumbnailCacheDir();
+
+            try {
+                await fs.promises.access(cachePath, fs.constants.F_OK);
+                const stats = await fs.promises.stat(cachePath);
+                logger.debug(`[Thumbnail] Using cached: fileId=${thumbnailId}, size=${stats.size} bytes`);
+                // Return cached thumbnail as MediaObject
+                const mo = await sdk.mediaManager.createMediaObjectFromUrl(`file://${cachePath}`);
+                return mo;
+            } catch {
+                // File doesn't exist, need to generate it
+                logger.debug(`[Thumbnail] Cache miss: fileId=${thumbnailId}`);
+            }
+
+            // Ensure cache directory exists
+            await fs.promises.mkdir(cacheDir, { recursive: true });
+
+            // Check if video clip is already cached locally - use it instead of calling camera
+            const videoCachePath = this.getVideoClipCachePath(thumbnailId);
+            let useLocalVideo = false;
+            try {
+                await fs.promises.access(videoCachePath, fs.constants.F_OK);
+                useLocalVideo = true;
+                logger.debug(`[Thumbnail] Using local video file for thumbnail extraction: fileId=${thumbnailId}`);
+            } catch {
+                // Video not cached locally, will use RTMP URL
+            }
+
+            let thumbnail: MediaObject;
+
+            if (useLocalVideo) {
+                // Extract thumbnail from local video file
+                thumbnail = await this.plugin.generateThumbnail({
+                    deviceId: this.id,
+                    fileId: thumbnailId,
+                    filePath: videoCachePath,
+                    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}`);
+                }
+
+                // Use the plugin's thumbnail generation queue with RTMP URL
+                thumbnail = await this.plugin.generateThumbnail({
+                    deviceId: this.id,
+                    fileId: thumbnailId,
+                    rtmpUrl: rtmpVodUrl,
+                    logger: this.getBaichuanLogger(),
+                });
+            }
+
+            // Cache the thumbnail
+            try {
+                const buffer = await sdk.mediaManager.convertMediaObjectToBuffer(thumbnail, 'image/jpeg');
+                await fs.promises.writeFile(cachePath, buffer);
+                logger.debug(`[Thumbnail] Cached: fileId=${thumbnailId}, size=${buffer.length} bytes`);
+            } catch (e) {
+                logger.warn(`[Thumbnail] Failed to cache: fileId=${thumbnailId}`, e);
+                // Continue even if caching fails
+            }
+
+            return thumbnail;
+        } catch (e) {
+            logger.error(`[Thumbnail] Error: fileId=${thumbnailId}`, e);
+            throw e;
+        }
     }
 
     removeVideoClips(...videoClipIds: string[]): Promise<void> {
         throw new Error("removeVideoClips is not implemented yet.");
     }
 
+    /**
+     * Update video clips auto-load timer based on settings
+     */
+    private updateVideoClipsAutoLoad(): void {
+        // Clear existing interval if any
+        if (this.videoClipsAutoLoadInterval) {
+            clearInterval(this.videoClipsAutoLoadInterval);
+            this.videoClipsAutoLoadInterval = undefined;
+        }
+
+        // Check if videoclips are enabled at all
+        const { enableVideoclips, loadVideoclips, videoclipsRegularChecks } = this.storageSettings.values;
+        if (!enableVideoclips) {
+            return;
+        }
+
+
+        if (!loadVideoclips) {
+            return;
+        }
+
+        const logger = this.getBaichuanLogger();
+        const intervalMs = videoclipsRegularChecks * 60 * 1000;
+
+        logger.log(`Starting video clips auto-load: checking every ${videoclipsRegularChecks} minutes`);
+
+        // Run immediately on start
+        this.loadTodayVideoClipsAndThumbnails();
+
+        // Then run at regular intervals
+        this.videoClipsAutoLoadInterval = setInterval(() => {
+            this.loadTodayVideoClipsAndThumbnails();
+        }, intervalMs);
+    }
+
+    /**
+     * Load today's video clips and download missing thumbnails
+     */
+    private async loadTodayVideoClipsAndThumbnails(): Promise<void> {
+        // Prevent concurrent executions
+        if (this.videoClipsAutoLoadInProgress) {
+            const logger = this.getBaichuanLogger();
+            logger.debug('Video clips auto-load already in progress, skipping...');
+            return;
+        }
+
+        const logger = this.getBaichuanLogger();
+
+        this.videoClipsAutoLoadInProgress = true;
+
+        try {
+            logger.log('Auto-loading today\'s video clips and thumbnails...');
+
+            // 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);
+
+            // Fetch today's video clips
+            const clips = await this.getVideoClips({
+                startTime: startOfToday.getTime(),
+                endTime: now.getTime(),
+            });
+
+            logger.log(`Found ${clips.length} video clips for today`);
+
+            const downloadVideoclipsLocally = this.storageSettings.values.downloadVideoclipsLocally ?? false;
+
+            // Track processed clips to avoid duplicate calls to the camera
+            const processedClips = new Set<string>();
+
+            // Download videos first (if enabled), then thumbnails for each clip
+            for (const clip of clips) {
+                // Skip if already processed (avoid duplicate calls)
+                if (processedClips.has(clip.id)) {
+                    logger.debug(`Skipping already processed clip: ${clip.id}`);
+                    continue;
+                }
+                processedClips.add(clip.id);
+
+                try {
+                    // If downloadVideoclipsLocally is enabled, download the video clip first
+                    // This allows the thumbnail to use the local file instead of calling the camera
+                    if (downloadVideoclipsLocally) {
+                        try {
+                            // Call getVideoClip to trigger download and caching
+                            await this.getVideoClip(clip.id);
+                            logger.debug(`Downloaded video clip: ${clip.id}`);
+                        } catch (e) {
+                            logger.warn(`Failed to download video clip ${clip.id}:`, e instanceof Error ? e.message : String(e));
+                        }
+                    }
+
+                    // Then get the thumbnail - this will use the local video file if available
+                    // or call the camera if the video wasn't downloaded
+                    try {
+                        await this.getVideoClipThumbnail(clip.id);
+                        logger.debug(`Downloaded thumbnail for clip: ${clip.id}`);
+                    } catch (e) {
+                        logger.warn(`Failed to load thumbnail for clip ${clip.id}:`, e instanceof Error ? e.message : String(e));
+                    }
+                } catch (e) {
+                    logger.warn(`Error processing clip ${clip.id}:`, e instanceof Error ? e.message : String(e));
+                }
+            }
+
+            logger.log(`Completed auto-loading video clips and thumbnails`);
+        } catch (e) {
+            logger.error('Error during auto-loading video clips:', e);
+        } finally {
+            this.videoClipsAutoLoadInProgress = false;
+        }
+    }
+
     async reboot(): Promise<void> {
         const api = await this.ensureBaichuanClient();
         await api.reboot();
@@ -654,13 +1129,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: this.console,
+            logger,
             debugOptions,
         };
     }
@@ -700,6 +1176,8 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     }
 
     async withBaichuanRetry<T>(fn: () => Promise<T>): Promise<T> {
+        return await fn();
+
         if (this.isBattery) {
             return await fn();
         } else {
@@ -777,13 +1255,19 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
      * - For TCP devices (regular + multifocal), this creates a new TCP session with its own client.
      * - For UDP/battery devices, this reuses the existing client via ensureClient().
      */
-    async createStreamClient(): Promise<ReolinkBaichuanApi> {
+    async createStreamClient(profile?: StreamProfile): Promise<ReolinkBaichuanApi> {
         // Battery / BCUDP path: reuse the main client to avoid extra wake-ups and sockets.
         if (this.isBattery) {
             return await this.ensureClient();
         }
 
-        // TCP path: create a separate session for streaming (RFC4571/composite/NVR-friendly).
+        // For TCP path: create a new client ONLY for "ext" profile
+        // For other profiles (main, sub), reuse the main client
+        if (profile !== 'ext') {
+            return await this.ensureClient();
+        }
+
+        // TCP path with ext profile: create a separate session for streaming (RFC4571/composite/NVR-friendly).
         const { ipAddress, username, password } = this.storageSettings.values;
         const logger = this.getBaichuanLogger();
 
@@ -825,7 +1309,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         const { username, password } = this.storageSettings.values;
 
         const baseOptions: any = {
-            createStreamClient: () => this.createStreamClient(),
+            createStreamClient: (profile?: StreamProfile) => this.createStreamClient(profile),
             getLogger: () => logger,
             credentials: {
                 username,
@@ -876,6 +1360,13 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 restartLogger.log('Restarting StreamManager due to PIP/composite settings change');
                 this.initStreamManager(restartLogger, true);
 
+                // Invalidate snapshot cache for battery/multifocal-battery so that
+                // the next snapshot reflects the new PIP/composite configuration.
+                if (this.isBattery) {
+                    this.forceNewSnapshot = true;
+                    this.lastPicture = undefined;
+                }
+
                 // Notify consumers (e.g. prebuffer) that stream configuration changed.
                 try {
                     this.onDeviceEvent(ScryptedInterface.VideoCamera, undefined);
@@ -1410,6 +1901,10 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         }
     }
 
+    async release() {
+        this.plugin.mixinsMap.delete(this.id);
+    }
+
     async releaseDevice(id: string, nativeId: string): Promise<void> {
         if (nativeId.endsWith(sirenSuffix)) {
             this.siren = undefined;
@@ -1799,9 +2294,9 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             }
         }
 
-        const { username, password } = this.storageSettings.values;
 
-        this.storageSettings.settings.uid.hide = !this.isBattery;
+        this.storageSettings.settings.videoclipsRegularChecks.defaultValue = this.isBattery ? 120 : 30;
+
         this.storageSettings.settings.batteryUpdateIntervalMinutes.hide = !this.isBattery;
         this.storageSettings.settings.lowThresholdBatteryRecording.hide = !this.isBattery;
         this.storageSettings.settings.highThresholdBatteryRecording.hide = !this.isBattery;
@@ -1865,7 +2360,6 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             this.storageSettings.settings.username.hide = true;
             this.storageSettings.settings.password.hide = true;
             this.storageSettings.settings.ipAddress.hide = true;
-            this.storageSettings.settings.uid.hide = true;
 
             this.storageSettings.settings.username.defaultValue = this.nvrDevice.storageSettings.values.username;
             this.storageSettings.settings.password.defaultValue = this.nvrDevice.storageSettings.values.password;
@@ -1875,6 +2369,9 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         await this.init();
 
         this.initComplete = true;
+
+        // Initialize video clips auto-load if enabled
+        this.updateVideoClipsAutoLoad();
     }
 }
 

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',