@apocaliss92/scrypted-reolink-native 0.1.9 → 0.1.11

package/src/intercom.ts

@@ -31,7 +31,7 @@ export class ReolinkBaichuanIntercom {
     }
 
     async start(media: MediaObject): Promise<void> {
-        const logger = this.camera.getLogger();
+        const logger = this.camera.getBaichuanLogger();
 
         const ffmpegInput = await sdk.mediaManager.convertMediaObjectToJSON<FFmpegInput>(
             media,
@@ -177,7 +177,7 @@ export class ReolinkBaichuanIntercom {
         if (this.stopping) return this.stopping;
 
         this.stopping = (async () => {
-            const logger = this.camera.getLogger();
+            const logger = this.camera.getBaichuanLogger();
 
             const ffmpeg = this.ffmpeg;
             this.ffmpeg = undefined;
@@ -243,7 +243,7 @@ export class ReolinkBaichuanIntercom {
         bytesNeeded: number,
         blockSize: number,
     ): void {
-        const logger = this.camera.getLogger();
+        const logger = this.camera.getBaichuanLogger();
 
         this.sendChain = this.sendChain
             .then(async () => {

package/src/nvr.ts

@@ -1,13 +1,14 @@
 import type { DeviceInfoResponse, DeviceInputData, EventsResponse, ReolinkBaichuanApi, ReolinkCgiApi, ReolinkSimpleEvent } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
 import sdk, { AdoptDevice, Device, DeviceDiscovery, DeviceProvider, DiscoveredDevice, Reboot, ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, Setting, Settings, SettingValue } from "@scrypted/sdk";
 import { StorageSettings } from "@scrypted/sdk/storage-settings";
+import { BaseBaichuanClass, type BaichuanConnectionConfig, type BaichuanConnectionCallbacks } from "./baichuan-base";
 import { ReolinkNativeCamera } from "./camera";
 import { ReolinkNativeBatteryCamera } from "./camera-battery";
 import { normalizeUid } from "./connect";
 import ReolinkNativePlugin from "./main";
 import { getDeviceInterfaces, updateDeviceInfo } from "./utils";
 
-export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settings, DeviceDiscovery, DeviceProvider, Reboot {
+export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Settings, DeviceDiscovery, DeviceProvider, Reboot {
     storageSettings = new StorageSettings(this, {
         debugEvents: {
             title: 'Debug Events',
@@ -45,8 +46,7 @@ export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settin
     });
     plugin: ReolinkNativePlugin;
     nvrApi: ReolinkCgiApi | undefined;
-    baichuanApi: ReolinkBaichuanApi | undefined;
-    baichuanApiPromise: Promise<ReolinkBaichuanApi> | undefined;
+    // baichuanApi, ensureClientPromise, connectionTime inherited from BaseBaichuanClass
     discoveredDevices = new Map<string, {
         device: Device;
         description: string;
@@ -59,9 +59,6 @@ export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settin
     cameraNativeMap = new Map<string, ReolinkNativeCamera | ReolinkNativeBatteryCamera>();
     private channelToNativeIdMap = new Map<number, string>();
     processing = false;
-    private eventSubscriptionActive = false;
-    private errorListener?: (err: unknown) => void;
-    private closeListener?: () => void;
 
     constructor(nativeId: string, plugin: ReolinkNativePlugin) {
         super(nativeId);
@@ -77,98 +74,49 @@ export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settin
         await api.Reboot();
     }
 
-    getLogger() {
-        return this.console;
-    }
-
-    /**
-     * Centralized cleanup method for Baichuan API
-     * Removes all listeners, closes connection, and resets state
-     */
-    private async cleanupBaichuanApi(): Promise<void> {
-        if (!this.baichuanApi) {
-            return;
-        }
-
-        const api = this.baichuanApi;
-
-        // Unsubscribe from events first
-        await this.unsubscribeFromAllEvents();
-
-        // Remove all listeners
-        try {
-            api.client.off("close", this.closeListener);
-        } catch {
-            // ignore
-        }
-
-        try {
-            api.client.off("error", this.errorListener);
-        } catch {
-            // ignore
-        }
-
-        // Close connection if still connected
-        try {
-            if (api.client.isSocketConnected()) {
-                await api.close();
-            }
-        } catch {
-            // ignore
+    // BaseBaichuanClass abstract methods implementation
+    protected getConnectionConfig(): BaichuanConnectionConfig {
+        const { ipAddress, username, password } = this.storageSettings.values;
+        if (!ipAddress || !username || !password) {
+            throw new Error('Missing NVR credentials');
         }
 
-        // Reset state
-        this.baichuanApi = undefined;
-        this.baichuanApiPromise = undefined;
+        return {
+            host: ipAddress,
+            username,
+            password,
+            transport: 'tcp',
+            logger: this.console,
+        };
     }
 
-    /**
-     * Attach error and close listeners to Baichuan API
-     */
-    private attachBaichuanListeners(api: ReolinkBaichuanApi): void {
-        const logger = this.getLogger();
-
-        // Error listener
-        this.errorListener = (err: unknown) => {
-            const msg = (err as any)?.message || (err as any)?.toString?.() || String(err);
-
-            // Only log if it's not a recoverable error to avoid spam
-            if (typeof msg === 'string' && (
-                msg.includes('Baichuan socket closed') ||
-                msg.includes('Baichuan UDP stream closed') ||
-                msg.includes('Not running')
-            )) {
-                logger.debug(`[NVR BaichuanClient] error (recoverable): ${msg}`);
-                return;
-            }
-            logger.error(`[NVR BaichuanClient] error: ${msg}`);
+    protected getConnectionCallbacks(): BaichuanConnectionCallbacks {
+        return {
+            onError: undefined, // Use default error handling
+            onClose: async () => {
+                // Reinit after cleanup
+                await this.reinit();
+            },
+            onSimpleEvent: (ev) => this.forwardNativeEvent(ev),
+            getEventSubscriptionEnabled: () => {
+                const eventSource = this.storageSettings.values.eventSource || 'Native';
+                return eventSource === 'Native';
+            },
         };
+    }
 
-        // Close listener
-        this.closeListener = async () => {
-            try {
-                const wasConnected = api.client.isSocketConnected();
-                const wasLoggedIn = api.client.loggedIn;
-                logger.log(`[NVR BaichuanClient] Connection state before close: connected=${wasConnected}, loggedIn=${wasLoggedIn}`);
-
-                // Try to get last message info if available
-                const client = api.client as any;
-                if (client?.lastRx || client?.lastTx) {
-                    logger.log(`[NVR BaichuanClient] Last message info: lastRx=${JSON.stringify(client.lastRx)}, lastTx=${JSON.stringify(client.lastTx)}`);
-                }
-            }
-            catch (e) {
-                logger.debug(`[NVR BaichuanClient] Could not get connection state: ${e}`);
-            }
 
-            // Cleanup and reinit
-            await this.cleanupBaichuanApi();
-            await this.reinit();
-        };
+    protected isDebugEnabled(): boolean {
+        return this.storageSettings.values.debugEvents || false;
+    }
+
+    protected getDeviceName(): string {
+        return this.name || 'NVR';
+    }
 
-        // Attach listeners
-        api.client.on("error", this.errorListener);
-        api.client.on("close", this.closeListener);
+    protected async onBeforeCleanup(): Promise<void> {
+        // Unsubscribe from events if needed
+        await this.unsubscribeFromAllEvents();
     }
 
     async reinit() {
@@ -183,7 +131,7 @@ export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settin
         this.nvrApi = undefined;
 
         // Cleanup Baichuan API (this handles all listeners and connection)
-        await this.cleanupBaichuanApi();
+        await super.cleanupBaichuanApi();
     }
 
     async ensureClient(): Promise<ReolinkCgiApi> {
@@ -208,7 +156,7 @@ export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settin
     }
 
     private forwardNativeEvent(ev: ReolinkSimpleEvent): void {
-        const logger = this.getLogger();
+        const logger = this.getBaichuanLogger();
 
         const eventSource = this.storageSettings.values.eventSource || 'Native';
         if (eventSource !== 'Native') {
@@ -216,16 +164,12 @@ export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settin
         }
 
         try {
-            if (this.storageSettings.values.debugEvents) {
-                logger.log(`NVR Baichuan event: ${JSON.stringify(ev)}`);
-            }
+            logger.debug(`Baichuan event: ${JSON.stringify(ev)}`);
 
             // Find camera for this channel
             const channel = ev?.channel;
             if (channel === undefined) {
-                if (this.storageSettings.values.debugEvents) {
-                    logger.debug('Event has no channel, ignoring');
-                }
+                logger.debug('Event has no channel, ignoring');
                 return;
             }
 
@@ -233,9 +177,7 @@ export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settin
             const targetCamera = nativeId ? this.cameraNativeMap.get(nativeId) : undefined;
 
             if (!targetCamera) {
-                if (this.storageSettings.values.debugEvents) {
-                    logger.debug(`No camera found for channel ${channel}, ignoring event`);
-                }
+                logger.debug(`No camera found for channel ${channel}, ignoring event`);
                 return;
             }
 
@@ -269,9 +211,7 @@ export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settin
                     motion = true;
                     break;
                 default:
-                    if (this.storageSettings.values.debugEvents) {
-                        logger.debug(`Unknown event type: ${ev?.type}`);
-                    }
+                    logger.debug(`Unknown event type: ${ev?.type}`);
                     return;
             }
 
@@ -285,121 +225,36 @@ export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settin
         }
     }
 
-    async onSimpleEventHandler(ev: ReolinkSimpleEvent) {
-        this.forwardNativeEvent(ev);
-    }
-
     async ensureBaichuanClient(): Promise<ReolinkBaichuanApi> {
-        // Reuse existing client if socket is still connected and logged in
-        if (this.baichuanApi && this.baichuanApi.client.isSocketConnected() && this.baichuanApi.client.loggedIn) {
-            return this.baichuanApi;
-        }
-
-        // Prevent concurrent login storms
-        if (this.baichuanApiPromise) return await this.baichuanApiPromise;
-
-        this.baichuanApiPromise = (async () => {
-            const { ipAddress, username, password } = this.storageSettings.values;
-            if (!ipAddress || !username || !password) {
-                throw new Error('Missing NVR credentials');
-            }
-
-            // Clean up old client if exists
-            if (this.baichuanApi) {
-                await this.cleanupBaichuanApi();
-            }
-
-            // Create new Baichuan client
-            const { ReolinkBaichuanApi } = await import("@apocaliss92/reolink-baichuan-js");
-            this.baichuanApi = new ReolinkBaichuanApi({
-                host: ipAddress,
-                username,
-                password,
-                transport: 'tcp',
-                logger: this.getLogger(),
-            });
-
-            await this.baichuanApi.login();
-
-            // Verify socket is connected before returning
-            if (!this.baichuanApi.client.isSocketConnected()) {
-                throw new Error('Socket not connected after login');
-            }
-
-            // Attach listeners (error and close)
-            this.attachBaichuanListeners(this.baichuanApi);
-
-            return this.baichuanApi;
-        })();
-
-        try {
-            return await this.baichuanApiPromise;
-        }
-        finally {
-            // Allow future reconnects and avoid pinning rejected promises
-            this.baichuanApiPromise = undefined;
-        }
+        // Use base class implementation
+        return await super.ensureBaichuanClient();
     }
 
     async subscribeToAllEvents(): Promise<void> {
-        const logger = this.getLogger();
-
-        // If already subscribed and connection is valid, return
-        if (this.eventSubscriptionActive && this.baichuanApi) {
-            if (this.baichuanApi.client.isSocketConnected() && this.baichuanApi.client.loggedIn) {
-                logger.log('Event subscription already active');
-                return;
-            }
-            // Connection is invalid, reset subscription state
-            this.eventSubscriptionActive = false;
-        }
-
-        // Unsubscribe first if handler exists (idempotent)
-        await this.unsubscribeFromAllEvents();
-
-        // Get Baichuan client connection
-        const api = await this.ensureBaichuanClient();
+        const logger = this.getBaichuanLogger();
+        const eventSource = this.storageSettings.values.eventSource || 'Native';
 
-        // Verify connection is ready
-        if (!api.client.isSocketConnected() || !api.client.loggedIn) {
-            logger.warn('Cannot subscribe to events: connection not ready');
+        // Only subscribe if Native is selected
+        if (eventSource !== 'Native') {
+            await this.unsubscribeFromAllEvents();
             return;
         }
 
-        // Subscribe to events
-        try {
-            await api.onSimpleEvent(this.onSimpleEventHandler);
-            this.eventSubscriptionActive = true;
-            logger.log('Subscribed to all events for NVR cameras');
-        }
-        catch (e) {
-            logger.warn('Failed to subscribe to events', e);
-            this.eventSubscriptionActive = false;
-        }
+        // Use base class implementation
+        await super.subscribeToEvents();
+        logger.log('Subscribed to all events for NVR cameras');
     }
 
     async unsubscribeFromAllEvents(): Promise<void> {
-        const logger = this.getLogger();
-
-        // Only unsubscribe if we have an active subscription
-        if (this.eventSubscriptionActive && this.baichuanApi) {
-            try {
-                this.baichuanApi.offSimpleEvent(this.onSimpleEventHandler);
-                logger.log('Unsubscribed from all events');
-            }
-            catch (e) {
-                logger.warn('Error unsubscribing from events', e);
-            }
-        }
-
-        this.eventSubscriptionActive = false;
+        // Use base class implementation
+        await super.unsubscribeFromEvents();
     }
 
     /**
      * Reinitialize event subscriptions based on selected event source
      */
     private async reinitEventSubscriptions(): Promise<void> {
-        const logger = this.getLogger();
+        const logger = this.getBaichuanLogger();
         const { eventSource } = this.storageSettings.values;
 
         // Unsubscribe from Native events if switching away
@@ -419,11 +274,9 @@ export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settin
      * Forward events from CGI source to cameras
      */
     private forwardCgiEvents(eventsRes: Record<number, EventsResponse>): void {
-        const logger = this.getLogger();
+        const logger = this.getBaichuanLogger();
 
-        if (this.storageSettings.values.debugEvents) {
-            logger.debug(`CGI Events call result: ${JSON.stringify(eventsRes)}`);
-        }
+        logger.debug(`CGI Events call result: ${JSON.stringify(eventsRes)}`);
 
         // Use channel map for efficient lookup
         for (const [channel, nativeId] of this.channelToNativeIdMap.entries()) {
@@ -437,7 +290,7 @@ export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settin
 
     async init() {
         const api = await this.ensureClient();
-        const logger = this.getLogger();
+        const logger = this.getBaichuanLogger();
         await this.updateDeviceInfo();
 
         // Initialize event subscriptions based on selected source
@@ -462,9 +315,7 @@ export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settin
                     const { hubData } = await api.getHubInfo();
                     const { devicesData, channelsResponse, response } = await api.getDevicesInfo();
                     logger.log('Hub info data fetched');
-                    if (this.storageSettings.values.debugEvents) {
-                        logger.log(`${JSON.stringify({ hubData, devicesData, channelsResponse, response })}`);
-                    }
+                    logger.debug(`${JSON.stringify({ hubData, devicesData, channelsResponse, response })}`);
 
                     await this.discoverDevices(true);
                 }
@@ -479,9 +330,7 @@ export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settin
                 // Always fetch battery info (not event-related)
                 const { batteryInfoData, response } = await api.getAllChannelsBatteryInfo();
 
-                if (this.storageSettings.values.debugEvents) {
-                    logger.debug(`Battery info call result: ${JSON.stringify({ batteryInfoData, response })}`);
-                }
+                logger.debug(`Battery info call result: ${JSON.stringify({ batteryInfoData, response })}`);
 
                 this.cameraNativeMap.forEach((camera) => {
                     if (camera) {
@@ -498,7 +347,7 @@ export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settin
                     }
                 });
             } catch (e) {
-                this.console.error('Error on events flow', e);
+                logger.error('Error on events flow', e);
             } finally {
                 this.processing = false;
             }
@@ -517,7 +366,7 @@ export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settin
                 deviceData,
             });
         } catch (e) {
-            this.getLogger().warn('Failed to fetch device info', e);
+            this.getBaichuanLogger().warn('Failed to fetch device info', e);
         }
     }
 
@@ -571,7 +420,7 @@ export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settin
 
     async syncEntitiesFromRemote() {
         const api = await this.ensureClient();
-        const logger = this.getLogger();
+        const logger = this.getBaichuanLogger();
 
         logger.log('Starting channels discovery using getDevicesInfo...');
 
@@ -683,7 +532,7 @@ export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settin
         await sdk.deviceManager.onDeviceDiscovered(actualDevice);
 
         const device = await this.getDevice(adopt.nativeId);
-        this.console.log('Adopted device', entry, device?.name);
+        this.getBaichuanLogger().debug('Adopted device', entry, device?.name);
         const { username, password, ipAddress } = this.storageSettings.values;
 
         device.storageSettings.values.rtspChannel = entry.rtspChannel;

package/src/stream-utils.ts

@@ -12,6 +12,7 @@ import sdk, {
 } from "@scrypted/sdk";
 
 import type { UrlMediaStreamOptions } from "../../scrypted/plugins/rtsp/src/rtsp";
+import { ReolinkNativeNvrDevice } from "./nvr";
 
 export interface StreamManagerOptions {
     /**
@@ -101,12 +102,12 @@ export async function buildVideoStreamOptionsFromRtspRtmp(
         client: ReolinkBaichuanApi,
         ipAddress: string,
         cachedNetPort: { rtsp?: { port?: number; enable?: number }; rtmp?: { port?: number; enable?: number } },
-        isFromNvr: boolean,
+        nvrDevice?: ReolinkNativeNvrDevice,
         rtspChannel: number,
         logger: Console
     },
 ): Promise<UrlMediaStreamOptions[]> {
-    const { client, ipAddress, cachedNetPort, rtspChannel, logger } = props;
+    const { client, ipAddress, cachedNetPort, rtspChannel, logger, nvrDevice } = props;
     const rtspStreams: UrlMediaStreamOptions[] = [];
     const rtmpStreams: UrlMediaStreamOptions[] = [];
 
@@ -179,11 +180,21 @@ export async function buildVideoStreamOptionsFromRtspRtmp(
 
     const nativeStreams = await fetchVideoStreamOptionsFromApi(client, rtspChannel, logger);
 
-    const streams: UrlMediaStreamOptions[] = [
-        ...rtspStreams,
-        ...rtmpStreams,
-        ...nativeStreams,
-    ];
+    let streams: UrlMediaStreamOptions[] = [];
+
+    if (nvrDevice && nvrDevice.info.model === 'HOMEHUB') {
+        streams = [
+            ...nativeStreams,
+            ...rtspStreams,
+            ...rtmpStreams,
+        ];
+    } else {
+        streams = [
+            ...rtspStreams,
+            ...rtmpStreams,
+            ...nativeStreams,
+        ];
+    }
 
     return streams;
 }
@@ -274,7 +285,7 @@ export class StreamManager {
     }
 
     private getLogger() {
-        return this.opts.getLogger();
+        return this.opts.getLogger() as Console;
     }
 
     private async ensureNativeRfcServer(