@apocaliss92/scrypted-reolink-native 0.1.31 → 0.1.33

package/src/common.ts

@@ -1,10 +1,13 @@
-import type { DeviceCapabilities, PtzCommand, PtzPreset, ReolinkBaichuanApi, ReolinkSimpleEvent, ReolinkSupportedStream, 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, VideoTextOverlay, VideoTextOverlays } from "@scrypted/sdk";
+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 { normalizeUid, type BaichuanTransport } from "./connect";
+import { createBaichuanApi, normalizeUid, type BaichuanTransport } from "./connect";
 import { convertDebugLogsToApiOptions, getApiRelevantDebugLogs, getDebugLogChoices } from "./debug-options";
 import { ReolinkBaichuanIntercom } from "./intercom";
 import ReolinkNativePlugin from "./main";
@@ -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';
 
@@ -189,7 +192,7 @@ class ReolinkCameraPirSensor extends ScryptedDeviceBase implements OnOff, Settin
     }
 }
 
-export abstract class CommonCameraMixin extends BaseBaichuanClass implements VideoCamera, Camera, Settings, DeviceProvider, ObjectDetector, PanTiltZoom, VideoTextOverlays, BinarySensor, Intercom, Reboot {
+export abstract class CommonCameraMixin extends BaseBaichuanClass implements VideoCamera, Camera, Settings, DeviceProvider, ObjectDetector, PanTiltZoom, VideoTextOverlays, BinarySensor, Intercom, Reboot, VideoClips {
     storageSettings = new StorageSettings(this, {
         // Basic connection settings
         ipAddress: {
@@ -250,28 +253,40 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             description: 'Relative size of the PIP overlay (0.1 = 10%, 0.3 = 30%, etc.)',
             type: 'number',
             defaultValue: 0.25,
-            hide: true, // Only show for multifocal devices via getAdditionalSettings
+            hide: true,
+            onPut: async () => {
+                this.scheduleStreamManagerRestart('pipSize changed');
+            },
         },
         pipMargin: {
             title: 'PIP Margin',
             description: 'Margin from edge in pixels',
             type: 'number',
             defaultValue: 10,
-            hide: true, // Only show for multifocal devices via getAdditionalSettings
+            hide: true,
+            onPut: async () => {
+                this.scheduleStreamManagerRestart('pipMargin changed');
+            },
         },
         widerChannel: {
             title: 'Wider Channel',
             description: 'Channel number for wider lens (typically 0)',
             type: 'number',
             defaultValue: 0,
-            hide: true, // Only show for multifocal devices via getAdditionalSettings
+            hide: true,
+            onPut: async () => {
+                this.scheduleStreamManagerRestart('widerChannel changed');
+            },
         },
         teleChannel: {
             title: 'Tele Channel',
             description: 'Channel number for tele lens (typically 1)',
             type: 'number',
             defaultValue: 1,
-            hide: true, // Only show for multifocal devices via getAdditionalSettings
+            hide: true,
+            onPut: async () => {
+                this.scheduleStreamManagerRestart('teleChannel changed');
+            },
         },
         // Battery camera specific
         uid: {
@@ -533,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',
@@ -574,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;
@@ -582,7 +639,12 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
 
     protected nvrDevice?: ReolinkNativeNvrDevice;
     protected multiFocalDevice?: ReolinkNativeMultiFocalDevice;
-    thisDevice: Settings
+    thisDevice: Settings;
+    isBattery: boolean;
+    isMultiFocal: boolean;
+    private streamManagerRestartTimeout: NodeJS.Timeout | undefined;
+    private videoClipsAutoLoadInterval: NodeJS.Timeout | undefined;
+    private videoClipsAutoLoadInProgress: boolean = false;
 
     constructor(
         nativeId: string,
@@ -590,20 +652,468 @@ 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;
         this.multiFocalDevice = options.multiFocalDevice;
         this.thisDevice = sdk.systemManager.getDeviceById<Settings>(this.id);
 
-        const isBattery = options.type === 'battery' || options.type === 'multi-focal-battery';
-        this.protocol = isBattery ? 'udp' : 'tcp';
+        this.isBattery = options.type === 'battery' || options.type === 'multi-focal-battery';
+        this.isMultiFocal = options.type === 'multi-focal' || options.type === 'multi-focal-battery';
+        this.protocol = this.isBattery ? 'udp' : 'tcp';
 
         setTimeout(async () => {
             await this.parentInit();
         }, 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 [];
+        }
+    }
+
+    /**
+     * Get the cache directory for video clips and thumbnails
+     */
+    private getVideoClipCacheDir(): string {
+        const pluginVolume = process.env.SCRYPTED_PLUGIN_VOLUME || '';
+        const cameraId = this.id;
+        return path.join(pluginVolume, 'videoclips', cameraId);
+    }
+
+    /**
+     * 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;
+        }
+    }
+
+    /**
+     * 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();
@@ -613,19 +1123,20 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     protected getConnectionConfig(): BaichuanConnectionConfig {
         const { ipAddress, username, password, uid } = this.storageSettings.values;
         const debugOptions = this.getBaichuanDebugOptions();
-        const normalizedUid = this.protocol === 'udp' ? normalizeUid(uid) : undefined;
+        const normalizedUid = this.isBattery ? normalizeUid(uid) : undefined;
 
-        if (this.protocol === 'udp' && !normalizedUid) {
+        if (this.isBattery && !normalizedUid) {
             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,
         };
     }
@@ -639,8 +1150,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 // For battery cameras, don't auto-resubscribe after idle disconnects
                 // (idle disconnects are normal for battery cameras to save power)
                 // Events will be resubscribed when ensureClient() is called for actual operations
-                const isBattery = this.options.type === 'battery';
-                if (!isBattery) {
+                if (!this.isBattery) {
                     // For non-battery cameras, resubscribe to events after reconnection
                     setTimeout(async () => {
                         try {
@@ -666,7 +1176,9 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     }
 
     async withBaichuanRetry<T>(fn: () => Promise<T>): Promise<T> {
-        if (this.protocol === 'udp') {
+        return await fn();
+
+        if (this.isBattery) {
             return await fn();
         } else {
             try {
@@ -737,8 +1249,44 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         }
     }
 
-    createStreamClient(): Promise<ReolinkBaichuanApi> {
-        throw new Error("Method not implemented.");
+    /**
+     * Create a dedicated Baichuan API session for streaming (used by StreamManager).
+     *
+     * - 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(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();
+        }
+
+        // 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();
+
+        const debugOptions = this.getBaichuanDebugOptions();
+        const api = await createBaichuanApi(
+            {
+                inputs: {
+                    host: ipAddress,
+                    username,
+                    password,
+                    logger,
+                    debugOptions,
+                },
+                transport: 'tcp',
+            },
+        );
+
+        await api.login();
+        return api;
     }
 
     public getAbilities(): DeviceCapabilities {
@@ -750,8 +1298,85 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     }
 
     getBaichuanDebugOptions(): any | undefined {
-        const debugLogs = this.storageSettings.values.debugLogs || [];
-        return convertDebugLogsToApiOptions(debugLogs);
+        const socketDebugLogs = this.storageSettings.values.socketApiDebugLogs || [];
+        return convertDebugLogsToApiOptions(socketDebugLogs);
+    }
+
+    /**
+     * Initialize or recreate the StreamManager, taking into account multifocal composite options.
+     */
+    protected initStreamManager(logger: Console, forceRecreate: boolean = false): void {
+        const { username, password } = this.storageSettings.values;
+
+        const baseOptions: any = {
+            createStreamClient: (profile?: StreamProfile) => this.createStreamClient(profile),
+            getLogger: () => logger,
+            credentials: {
+                username,
+                password,
+            },
+            sharedConnection: this.isBattery,
+        };
+
+        if (this.isMultiFocal) {
+            const values: any = this.storageSettings.values;
+            const pipPosition = values.pipPosition || 'bottom-right';
+            const pipSize = values.pipSize ?? 0.25;
+            const pipMargin = values.pipMargin ?? 10;
+            const widerChannel = values.widerChannel ?? 0;
+            const teleChannel = values.teleChannel ?? 1;
+
+            baseOptions.compositeOptions = {
+                widerChannel,
+                teleChannel,
+                pipPosition,
+                pipSize,
+                pipMargin,
+            };
+        }
+
+        if (!this.streamManager || forceRecreate) {
+            this.streamManager = new StreamManager(baseOptions);
+        }
+    }
+
+    /**
+     * Debounced restart of StreamManager when PIP/composite settings change.
+     * Also notifies listeners so that active streams (prebuffer, etc.) restart cleanly.
+     */
+    protected scheduleStreamManagerRestart(reason: string): void {
+        const logger = this.getBaichuanLogger();
+        logger.log(`Scheduling StreamManager restart (${reason})`);
+
+        if (this.streamManagerRestartTimeout) {
+            clearTimeout(this.streamManagerRestartTimeout);
+            this.streamManagerRestartTimeout = undefined;
+        }
+
+        this.streamManagerRestartTimeout = setTimeout(async () => {
+            this.streamManagerRestartTimeout = undefined;
+            const restartLogger = this.getBaichuanLogger();
+            try {
+                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);
+                } catch {
+                    // best-effort
+                }
+            } catch (e) {
+                restartLogger.warn('Failed to restart StreamManager after settings change', e);
+            }
+        }, 500);
     }
 
     isRecoverableBaichuanError(e: any): boolean {
@@ -1167,7 +1792,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     }
 
     async takePicture(options?: RequestPictureOptions) {
-        if (this.protocol === 'tcp') {
+        if (!this.isBattery) {
             try {
                 return this.withBaichuanRetry(async () => {
                     const client = await this.ensureClient();
@@ -1276,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;
@@ -1665,23 +2294,21 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             }
         }
 
-        const { username, password } = this.storageSettings.values;
-        const isBattery = ['multi-focal-battery', 'battery'].includes(this.options.type);
-        const isMultiFocal = ['multi-focal', 'multi-focal'].includes(this.options.type);
 
-        this.storageSettings.settings.uid.hide = !isBattery;
-        this.storageSettings.settings.batteryUpdateIntervalMinutes.hide = !isBattery;
-        this.storageSettings.settings.lowThresholdBatteryRecording.hide = !isBattery;
-        this.storageSettings.settings.highThresholdBatteryRecording.hide = !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;
 
         // Show PIP settings only for multifocal devices
-        this.storageSettings.settings.pipPosition.hide = !isMultiFocal;
-        this.storageSettings.settings.pipSize.hide = !isMultiFocal;
-        this.storageSettings.settings.pipMargin.hide = !isMultiFocal;
-        this.storageSettings.settings.widerChannel.hide = !isMultiFocal;
-        this.storageSettings.settings.teleChannel.hide = !isMultiFocal;
+        this.storageSettings.settings.pipPosition.hide = !this.isMultiFocal;
+        this.storageSettings.settings.pipSize.hide = !this.isMultiFocal;
+        this.storageSettings.settings.pipMargin.hide = !this.isMultiFocal;
+        this.storageSettings.settings.widerChannel.hide = !this.isMultiFocal;
+        this.storageSettings.settings.teleChannel.hide = !this.isMultiFocal;
 
-        if (isBattery && !this.storageSettings.values.mixinsSetup) {
+        if (this.isBattery && !this.storageSettings.values.mixinsSetup) {
             try {
                 const device = sdk.systemManager.getDeviceById<Settings>(this.id);
                 if (device) {
@@ -1703,15 +2330,8 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             logger.warn('Failed to subscribe to Baichuan events', e);
         }
 
-        this.streamManager = new StreamManager({
-            createStreamClient: () => this.createStreamClient(),
-            getLogger: () => logger,
-            credentials: {
-                username,
-                password
-            },
-            sharedConnection: isBattery,
-        });
+        // Initialize StreamManager (with composite options for multifocal devices)
+        this.initStreamManager(logger);
 
         const { hasIntercom, hasPtz } = this.getAbilities();
 
@@ -1740,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;
@@ -1750,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();
     }
 }