@apocaliss92/scrypted-reolink-native 0.1.31 → 0.1.32

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@apocaliss92/scrypted-reolink-native",
-   "version": "0.1.31",
+   "version": "0.1.32",
    "description": "Use any reolink camera with Scrypted, even older/unsupported models without HTTP protocol support",
    "author": "@apocaliss92",
    "license": "Apache",

package/src/camera-battery.ts

@@ -324,7 +324,4 @@ export class ReolinkNativeBatteryCamera extends CommonCameraMixin {
         return fn(client);
     }
 
-    async createStreamClient(): Promise<ReolinkBaichuanApi> {
-        return await this.ensureClient();
-    }
 }

package/src/camera.ts

@@ -74,28 +74,6 @@ export class ReolinkNativeCamera extends CommonCameraMixin {
     }
 
 
-    async createStreamClient(): Promise<ReolinkBaichuanApi> {
-        const { ipAddress, username, password } = this.storageSettings.values;
-        const logger = this.getBaichuanLogger();
-
-        const debugOptions = this.getBaichuanDebugOptions();
-        const api = await createBaichuanApi(
-            {
-                inputs: {
-                    host: ipAddress,
-                    username: username,
-                    password: password,
-                    logger,
-                    debugOptions
-                },
-                transport: 'tcp',
-            },
-        );
-        await api.login();
-
-        return api;
-    }
-
     private passiveRefreshTimer: ReturnType<typeof setTimeout> | undefined;
 
     async release() {

package/src/common.ts

@@ -1,10 +1,10 @@
 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 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 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";
@@ -189,7 +189,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 +250,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: {
@@ -582,7 +594,10 @@ 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;
 
     constructor(
         nativeId: string,
@@ -596,14 +611,34 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         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);
     }
 
+    /**
+     * TODO: Implement video clip fetching using Baichuan/NVR recordings API.
+     */
+    async getVideoClips(options?: VideoClipOptions): Promise<VideoClip[]> {
+        throw new Error("getVideoClips is not implemented yet.");
+    }
+
+    getVideoClip(videoId: string): Promise<MediaObject> {
+        throw new Error("getVideoClip is not implemented yet.");
+    }
+
+    getVideoClipThumbnail(thumbnailId: string, options?: VideoClipThumbnailOptions): Promise<MediaObject> {
+        throw new Error("getVideoClipThumbnail is not implemented yet.");
+    }
+
+    removeVideoClips(...videoClipIds: string[]): Promise<void> {
+        throw new Error("removeVideoClips is not implemented yet.");
+    }
+
     async reboot(): Promise<void> {
         const api = await this.ensureBaichuanClient();
         await api.reboot();
@@ -613,9 +648,9 @@ 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)');
         }
 
@@ -639,8 +674,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 +700,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     }
 
     async withBaichuanRetry<T>(fn: () => Promise<T>): Promise<T> {
-        if (this.protocol === 'udp') {
+        if (this.isBattery) {
             return await fn();
         } else {
             try {
@@ -737,8 +771,38 @@ 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(): 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).
+        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 +814,78 @@ 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: () => this.createStreamClient(),
+            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);
+
+                // 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 +1301,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();
@@ -1666,22 +1800,20 @@ 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.uid.hide = !this.isBattery;
+        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 +1835,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();
 

package/src/main.ts

@@ -96,7 +96,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 +177,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;
         }

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();
     }
@@ -220,53 +195,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) {

package/src/stream-utils.ts

@@ -113,11 +113,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,
@@ -200,11 +204,14 @@ export class StreamManager {
         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> {
         const existingCreate = this.nativeRfcServerCreatePromises.get(streamKey);
         if (existingCreate) {
@@ -215,8 +222,9 @@ export class StreamManager {
             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 {
@@ -252,13 +260,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);
@@ -292,7 +301,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 +311,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,
+        });
     }
 
     /**

package/src/utils.ts

@@ -44,6 +44,7 @@ export const getDeviceInterfaces = (props: {
         ScryptedInterface.AudioSensor,
         ScryptedInterface.MotionSensor,
         ScryptedInterface.VideoTextOverlays,
+        ScryptedInterface.VideoClips,
     ];
 
     try {