@apocaliss92/scrypted-reolink-native 0.1.30 → 0.1.32

package/src/main.ts

@@ -57,7 +57,10 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
             },
         );
 
-        this.console.log(`[AutoDetect] Detected device type ${detection.type} on transport ${detection.transport}: ${JSON.stringify(detection.deviceInfo)}`);
+        this.console.log(`[AutoDetect] Detected device type: ${detection.type} (transport: ${detection.transport})`);
+
+        // Use the API that was successfully used for detection
+        const detectedApi = detection.api;
 
         // Handle multi-focal device case
         if (detection.type === 'multifocal') {
@@ -69,18 +72,12 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
 
             settings.newCamera ||= name;
 
-            const interfaces = [
-                ScryptedInterface.Settings,
-                ScryptedInterface.DeviceProvider,
-                ScryptedInterface.Reboot,
-            ];
-
-            if (isBattery) {
-                interfaces.push(
-                    ScryptedInterface.Battery,
-                    ScryptedInterface.Sleep
-                );
-            }
+            const { capabilities, objects, presets } = await detectedApi.getDeviceCapabilities();
+
+            const { interfaces } = getDeviceInterfaces({
+                capabilities,
+                logger: this.console,
+            });
 
             await sdk.deviceManager.onDeviceDiscovered({
                 nativeId,
@@ -94,10 +91,13 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
             if (!(device instanceof ReolinkNativeMultiFocalDevice)) {
                 throw new Error('Expected multi-focal device but got different type');
             }
+            device.classes = objects;
+            device.presets = presets;
             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;
         }
@@ -149,22 +149,10 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
 
         settings.newCamera ||= name;
 
-        // Create API connection to get capabilities
-        const api = await createBaichuanApi({
-            inputs: {
-                host: ipAddress,
-                username,
-                password,
-                uid: detection.uid,
-                logger: this.console,
-            },
-            transport: detection.transport,
-        });
-
+        // Use the API that was successfully used for detection
         try {
-            await api.login();
             const rtspChannel = 0;
-            const { capabilities, objects, presets } = await api.getDeviceCapabilities(rtspChannel);
+            const { capabilities, objects, presets } = await detectedApi.getDeviceCapabilities(rtspChannel);
 
             const { interfaces, type } = getDeviceInterfaces({
                 capabilities,
@@ -189,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;
         }
@@ -197,9 +185,6 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
             this.console.error('Error adding Reolink device', e);
             throw e;
         }
-        finally {
-            await api.close();
-        }
     }
 
     async releaseDevice(id: string, nativeId: ScryptedNativeId): Promise<void> {

package/src/multiFocal.ts

@@ -1,6 +1,5 @@
 import type { DeviceCapabilities, DualLensChannelAnalysis, ReolinkSimpleEvent } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
-import sdk, { Device, DeviceProvider, MediaObject, Reboot, ScryptedDeviceType, Setting, Settings, SettingValue } from "@scrypted/sdk";
-import { type BaichuanConnectionCallbacks } from "./baichuan-base";
+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";
@@ -34,49 +33,10 @@ export class ReolinkNativeMultiFocalDevice extends CommonCameraMixin implements
         }
     }
 
-    async reboot(): Promise<void> {
-        const api = await this.ensureBaichuanClient();
-        await api.reboot();
-    }
-
-    takePicture(options?: any): Promise<MediaObject> {
-        throw new Error("Method not implemented.");
-    }
-
-    getPictureOptions(): Promise<any[]> {
-        throw new Error("Method not implemented.");
-    }
-
-    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();
     }
 
-    protected isDebugEnabled(): boolean {
-        return this.storageSettings.values.debugEvents || false;
-    }
-
     protected getDeviceName(): string {
         return this.name || 'Multi-Focal Device';
     }
@@ -148,7 +108,8 @@ export class ReolinkNativeMultiFocalDevice extends CommonCameraMixin implements
 
     getInterfaces(channel: number) {
         const logger = this.getBaichuanLogger();
-        const { capabilities: caps, multifocalInfo } = this.storageSettings.values;
+        const values = this.storageSettings.values as any;
+        const { capabilities: caps, multifocalInfo } = values;
         const channelInfo = (multifocalInfo as DualLensChannelAnalysis).channels.find(c => c.channel === channel);
 
         const capabilities: DeviceCapabilities = {

package/src/nvr.ts

@@ -10,7 +10,7 @@ import { getDeviceInterfaces, updateDeviceInfo } from "./utils";
 
 export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Settings, DeviceDiscovery, DeviceProvider, Reboot {
     storageSettings = new StorageSettings(this, {
-        debugEvents: {
+        debugLogs: {
             title: 'Debug Events',
             type: 'boolean',
             immediate: true,
@@ -68,6 +68,7 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
     lastDevicesStatusCheck: number | undefined;
     cameraNativeMap = new Map<string, ReolinkNativeCamera | ReolinkNativeBatteryCamera>();
     private channelToNativeIdMap = new Map<number, string>();
+    private discoverDevicesPromise: Promise<DiscoveredDevice[]> | undefined;
     processing = false;
     private initReinitTimeout: NodeJS.Timeout | undefined;
 
@@ -116,7 +117,7 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
 
 
     protected isDebugEnabled(): boolean {
-        return this.storageSettings.values.debugEvents || false;
+        return this.storageSettings.values.debugLogs || false;
     }
 
     protected getDeviceName(): string {
@@ -333,11 +334,11 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
 
     async init() {
         const logger = this.getBaichuanLogger();
-        
+
         // Ensure both APIs are ready before proceeding
         const api = await this.ensureClient();
         await this.ensureBaichuanClient();
-        
+
         await this.updateDeviceInfo();
 
         await this.reinitEventSubscriptions();
@@ -356,7 +357,6 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
                 }
 
                 if (!this.lastNvrInfoCheck || now - this.lastNvrInfoCheck > 1000 * 60 * 5) {
-                    logger.log('Starting NVR info data fetch');
                     this.lastNvrInfoCheck = now;
                     const { nvrData } = await api.getNvrInfo();
                     const { devicesData, channelsResponse, response } = await api.getDevicesInfo();
@@ -468,11 +468,11 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
 
     async syncEntitiesFromRemote() {
         const logger = this.getBaichuanLogger();
-        
+
         // Ensure both APIs are ready before syncing
         const api = await this.ensureClient();
         const baichuanApi = await this.ensureBaichuanClient();
-        
+
         // Wait for Baichuan connection to be fully established
         if (baichuanApi?.client) {
             // Check if already connected
@@ -555,10 +555,28 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
     }
 
     async discoverDevices(scan?: boolean): Promise<DiscoveredDevice[]> {
+        // If a discovery is already in progress, return that promise
+        if (this.discoverDevicesPromise) {
+            return await this.discoverDevicesPromise;
+        }
+
+        // If scan is requested, start a new discovery
         if (scan) {
-            await this.syncEntitiesFromRemote();
+            this.discoverDevicesPromise = (async () => {
+                try {
+                    await this.syncEntitiesFromRemote();
+                    return [...this.discoveredDevices.values()].map(d => ({
+                        ...d.device,
+                        description: d.description,
+                    }));
+                } finally {
+                    this.discoverDevicesPromise = undefined;
+                }
+            })();
+            return await this.discoverDevicesPromise;
         }
 
+        // If no scan requested, return cached devices immediately
         return [...this.discoveredDevices.values()].map(d => ({
             ...d.device,
             description: d.description,

package/src/stream-utils.ts

@@ -1,6 +1,7 @@
 import type {
+    CompositeStreamPipOptions,
     ReolinkBaichuanApi,
-    ScryptedRfc4571TcpServer,
+    Rfc4571TcpServer,
     StreamProfile,
     VideoType,
 } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
@@ -29,6 +30,8 @@ export interface StreamManagerOptions {
     };
     /** If true, the stream client is shared with the main connection. Default: false. */
     sharedConnection?: boolean;
+    /** Composite stream options for multifocal cameras */
+    compositeOptions?: CompositeStreamPipOptions;
 }
 
 export function parseStreamProfileFromId(id: string | undefined): StreamProfile | undefined {
@@ -111,6 +114,60 @@ export async function createRfc4571MediaObjectFromStreamManager(params: {
         mso.audio.channels = audio.channels;
     }
 
+    const url = new URL(`tcp://${host}`);
+    url.port = port.toString();
+    if (username) {
+        url.username = username;
+    }
+    if (password) {
+        url.password = password;
+    }
+
+    const rfc = {
+        url,
+        sdp,
+        mediaStreamOptions: mso as ResponseMediaStreamOptions,
+    };
+
+    return await sdk.mediaManager.createMediaObject(Buffer.from(JSON.stringify(rfc)), 'x-scrypted/x-rfc4571', {
+        sourceId,
+    });
+}
+
+export async function createRfc4571CompositeMediaObjectFromStreamManager(params: {
+    streamManager: StreamManager;
+    profile: StreamProfile;
+    streamKey: string;
+    expectedVideoType?: 'H264' | 'H265';
+    selected: UrlMediaStreamOptions;
+    sourceId: string;
+    onDetectedCodec?: (detectedCodec: 'h264' | 'h265') => void;
+}): Promise<MediaObject> {
+    const { streamManager, profile, streamKey, expectedVideoType, selected, sourceId, onDetectedCodec } = params;
+
+    const { host, port, sdp, audio, username, password } = await streamManager.getRfcCompositeStream(profile, streamKey, expectedVideoType);
+
+    // Update cached stream options with the detected codec (helps prebuffer/NVR avoid mismatch).
+    try {
+        const detected = /a=rtpmap:\d+\s+(H26[45])\//.exec(sdp)?.[1];
+        if (detected) {
+            const dc = detected === 'H265' ? 'h265' : 'h264';
+            onDetectedCodec?.(dc);
+        }
+    }
+    catch {
+        // ignore
+    }
+
+    const { url: _ignoredUrl, ...mso }: any = selected;
+    mso.container = 'rtp';
+    if (audio) {
+        mso.audio ||= {};
+        mso.audio.codec = audio.codec;
+        mso.audio.sampleRate = audio.sampleRate;
+        mso.audio.channels = audio.channels;
+    }
+
     // Build URL with credentials: tcp://username:password@host:port
     const encodedUsername = encodeURIComponent(username || '');
     const encodedPassword = encodeURIComponent(password || '');
@@ -137,21 +194,24 @@ type RfcServerInfo = {
 };
 
 export class StreamManager {
-    private nativeRfcServers = new Map<string, ScryptedRfc4571TcpServer>();
+    private nativeRfcServers = new Map<string, Rfc4571TcpServer>();
     private nativeRfcServerCreatePromises = new Map<string, Promise<RfcServerInfo>>();
 
     constructor(private opts: StreamManagerOptions) {
     }
 
     private getLogger() {
-        return this.opts.getLogger() as Console;
+        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) {
@@ -162,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 {
@@ -189,7 +250,7 @@ export class StreamManager {
             }
 
             const api = await this.opts.createStreamClient();
-            const { createScryptedRfc4571TcpServer } = await import('@apocaliss92/reolink-baichuan-js');
+            const { createRfc4571TcpServer } = await import('@apocaliss92/reolink-baichuan-js');
 
             // Use the same credentials as the main connection
             const { username, password } = this.opts.credentials;
@@ -197,15 +258,16 @@ export class StreamManager {
             // If connection is shared, don't close it when stream teardown happens
             const closeApiOnTeardown = !(this.opts.sharedConnection ?? false);
 
-            const created = await createScryptedRfc4571TcpServer({
+            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);
@@ -239,7 +301,20 @@ 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(
+        profile: StreamProfile,
+        streamKey: string,
+        expectedVideoType?: 'H264' | 'H265',
+    ): Promise<RfcServerInfo> {
+        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 {