@apocaliss92/scrypted-reolink-native 0.1.7 → 0.1.9

package/package.json

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

package/src/camera-battery.ts

@@ -36,10 +36,15 @@ export class ReolinkNativeBatteryCamera extends CommonCameraMixin {
     }
 
     async takePicture(options?: RequestPictureOptions): Promise<MediaObject> {
-        // const { snapshotCacheMinutes = 5 } = this.storageSettings.values;
-        // const cacheMs = snapshotCacheMinutes * 60_000;
-        // if (!this.forceNewSnapshot && cacheMs > 0 && this.lastPicture && Date.now() - this.lastPicture.atMs < cacheMs) {
-        if (!this.forceNewSnapshot && this.lastPicture) {
+        // Allow new snapshot if:
+        // 1. forceNewSnapshot is true, OR
+        // 2. Camera is awake AND last snapshot was taken at least 10 seconds ago
+        const minSnapshotIntervalMs = 10_000; // 10 seconds
+        const now = Date.now();
+        const shouldTakeNewSnapshot = this.forceNewSnapshot || 
+            (!this.sleeping && this.lastPicture && (now - this.lastPicture.atMs >= minSnapshotIntervalMs));
+
+        if (!shouldTakeNewSnapshot && this.lastPicture) {
             this.console.log(`Returning cached snapshot, taken at ${new Date(this.lastPicture.atMs).toLocaleString()}`);
             return this.lastPicture.mo;
         }

package/src/camera.ts

@@ -209,7 +209,7 @@ export class ReolinkNativeCamera extends CommonCameraMixin {
         try {
             return this.withBaichuanRetry(async () => {
                 const client = await this.ensureClient();
-                const snapshotBuffer = await client.getSnapshot();
+                const snapshotBuffer = await client.getSnapshot(this.storageSettings.values.rtspChannel);
                 const mo = await this.createMediaObject(snapshotBuffer, 'image/jpeg');
 
                 return mo;

package/src/common.ts

@@ -487,6 +487,8 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
     protected ensureClientPromise: Promise<ReolinkBaichuanApi> | undefined;
     protected connectionTime: number | undefined;
     private closeListener?: () => void;
+    private lastDisconnectTime: number = 0;
+    private readonly reconnectBackoffMs: number = 2000; // 2 seconds minimum between reconnects
     protected readonly protocol: BaichuanTransport;
     private debugLogsResetTimeout: NodeJS.Timeout | undefined;
 
@@ -1329,6 +1331,11 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
 
     // Client management
     async ensureClient(): Promise<ReolinkBaichuanApi> {
+        // If camera is connected to NVR, use NVR's shared Baichuan connection
+        if (this.nvrDevice) {
+            return await this.nvrDevice.ensureBaichuanClient();
+        }
+
         // 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;
@@ -1337,6 +1344,17 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
         // Prevent concurrent login storms
         if (this.ensureClientPromise) return await this.ensureClientPromise;
 
+        // Apply backoff to avoid aggressive reconnection after disconnection
+        if (this.lastDisconnectTime > 0) {
+            const timeSinceDisconnect = Date.now() - this.lastDisconnectTime;
+            if (timeSinceDisconnect < this.reconnectBackoffMs) {
+                const waitTime = this.reconnectBackoffMs - timeSinceDisconnect;
+                const logger = this.getLogger();
+                logger.log(`[BaichuanClient] Waiting ${waitTime}ms before reconnection (backoff)`);
+                await new Promise(resolve => setTimeout(resolve, waitTime));
+            }
+        }
+
         this.ensureClientPromise = (async () => {
             const { ipAddress, username, password, uid } = this.storageSettings.values;
 
@@ -1355,11 +1373,8 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
 
                 const isConnected = this.baichuanApi.client.isSocketConnected();
                 if (!isConnected) {
-                    // Socket is closed, clean up
                     try {
-                        if (this.onSimpleEvent) {
-                            this.baichuanApi.offSimpleEvent(this.onSimpleEvent);
-                        }
+                        this.baichuanApi.offSimpleEvent(this.onSimpleEvent);
                     }
                     catch {
                         // ignore
@@ -1425,21 +1440,45 @@ export abstract class CommonCameraMixin extends ScryptedDeviceBase implements Vi
             this.closeListener = () => {
                 const logger = this.getLogger();
                 if (this.baichuanApi === api) {
-                    logger.log(`[BaichuanClient] Socket closed, resetting client state for reconnection`);
+                    const now = Date.now();
+                    const timeSinceLastDisconnect = now - this.lastDisconnectTime;
+                    this.lastDisconnectTime = now;
+
+                    logger.log(`[BaichuanClient] Socket closed, resetting client state for reconnection (last disconnect ${timeSinceLastDisconnect}ms ago)`);
+
+                    // Reset client state
                     this.baichuanApi = undefined;
                     this.ensureClientPromise = undefined;
                     this.closeListener = undefined;
+
+                    // Remove event handler to prevent operations during reconnection
+                    try {
+                        if (this.onSimpleEvent) {
+                            api.offSimpleEvent(this.onSimpleEvent);
+                        }
+                    }
+                    catch {
+                        // ignore
+                    }
                 }
             };
             api.client.on("close", this.closeListener);
 
             // Re-attach event handler if enabled
+            // Note: We don't reattach here immediately to avoid operations being called
+            // during reconnection. subscribeToEvents() will be called when needed.
+            // However, if events were already subscribed, we need to reattach them.
+            // We'll let subscribeToEvents() handle this, but we can also try here if needed.
             if (this.isEventDispatchEnabled?.() && this.onSimpleEvent) {
                 try {
-                    api.onSimpleEvent(this.onSimpleEvent);
+                    // Verify connection is fully ready before subscribing
+                    if (api.client.isSocketConnected() && api.client.loggedIn) {
+                        api.onSimpleEvent(this.onSimpleEvent);
+                    }
                 }
-                catch {
-                    // ignore
+                catch (e) {
+                    const logger = this.getLogger();
+                    logger.warn(`[BaichuanClient] Failed to reattach event handler after reconnection, will retry via subscribeToEvents()`, e);
                 }
             }
             return api;

package/src/nvr.ts

@@ -1,4 +1,4 @@
-import type { DeviceInfoResponse, DeviceInputData, ReolinkCgiApi } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
+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 { ReolinkNativeCamera } from "./camera";
@@ -14,6 +14,17 @@ export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settin
             type: 'boolean',
             immediate: true,
         },
+        eventSource: {
+            title: 'Event Source',
+            description: 'Select the source for camera events: Native (Baichuan) or CGI (HTTP polling)',
+            type: 'string',
+            choices: ['Native', 'CGI'],
+            defaultValue: 'Native',
+            immediate: true,
+            onPut: async () => {
+                await this.reinitEventSubscriptions();
+            }
+        },
         ipAddress: {
             title: 'IP address',
             type: 'string',
@@ -34,6 +45,8 @@ export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settin
     });
     plugin: ReolinkNativePlugin;
     nvrApi: ReolinkCgiApi | undefined;
+    baichuanApi: ReolinkBaichuanApi | undefined;
+    baichuanApiPromise: Promise<ReolinkBaichuanApi> | undefined;
     discoveredDevices = new Map<string, {
         device: Device;
         description: string;
@@ -44,7 +57,11 @@ export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settin
     lastErrorsCheck: number | undefined;
     lastDevicesStatusCheck: number | undefined;
     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);
@@ -64,7 +81,98 @@ export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settin
         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
+        }
+
+        // Reset state
+        this.baichuanApi = undefined;
+        this.baichuanApiPromise = undefined;
+    }
+
+    /**
+     * 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}`);
+        };
+
+        // 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();
+        };
+
+        // Attach listeners
+        api.client.on("error", this.errorListener);
+        api.client.on("close", this.closeListener);
+    }
+
     async reinit() {
+        // Cleanup CGI API
         if (this.nvrApi) {
             try {
                 await this.nvrApi.logout();
@@ -73,6 +181,9 @@ export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settin
             }
         }
         this.nvrApi = undefined;
+
+        // Cleanup Baichuan API (this handles all listeners and connection)
+        await this.cleanupBaichuanApi();
     }
 
     async ensureClient(): Promise<ReolinkCgiApi> {
@@ -96,11 +207,242 @@ export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settin
         return this.nvrApi;
     }
 
+    private forwardNativeEvent(ev: ReolinkSimpleEvent): void {
+        const logger = this.getLogger();
+
+        const eventSource = this.storageSettings.values.eventSource || 'Native';
+        if (eventSource !== 'Native') {
+            return;
+        }
+
+        try {
+            if (this.storageSettings.values.debugEvents) {
+                logger.log(`NVR 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');
+                }
+                return;
+            }
+
+            const nativeId = this.channelToNativeIdMap.get(channel);
+            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`);
+                }
+                return;
+            }
+
+            // Convert event to camera's processEvents format
+            const objects: string[] = [];
+            let motion = false;
+
+            switch (ev?.type) {
+                case 'motion':
+                    motion = true;
+                    break;
+                case 'doorbell':
+                    // Handle doorbell if camera supports it
+                    try {
+                        if (typeof (targetCamera as any).handleDoorbellEvent === 'function') {
+                            (targetCamera as any).handleDoorbellEvent();
+                        }
+                    }
+                    catch (e) {
+                        logger.warn(`Error handling doorbell event for camera channel ${channel}`, e);
+                    }
+                    motion = true;
+                    break;
+                case 'people':
+                case 'vehicle':
+                case 'animal':
+                case 'face':
+                case 'package':
+                case 'other':
+                    objects.push(ev.type);
+                    motion = true;
+                    break;
+                default:
+                    if (this.storageSettings.values.debugEvents) {
+                        logger.debug(`Unknown event type: ${ev?.type}`);
+                    }
+                    return;
+            }
+
+            // Process events on the target camera
+            targetCamera.processEvents({ motion, objects }).catch((e) => {
+                logger.warn(`Error processing events for camera channel ${channel}`, e);
+            });
+        }
+        catch (e) {
+            logger.warn('Error in NVR Native event forwarder', e);
+        }
+    }
+
+    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;
+        }
+    }
+
+    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();
+
+        // Verify connection is ready
+        if (!api.client.isSocketConnected() || !api.client.loggedIn) {
+            logger.warn('Cannot subscribe to events: connection not ready');
+            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;
+        }
+    }
+
+    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;
+    }
+
+    /**
+     * Reinitialize event subscriptions based on selected event source
+     */
+    private async reinitEventSubscriptions(): Promise<void> {
+        const logger = this.getLogger();
+        const { eventSource } = this.storageSettings.values;
+
+        // Unsubscribe from Native events if switching away
+        if (eventSource !== 'Native') {
+            await this.unsubscribeFromAllEvents();
+        } else {
+
+            this.subscribeToAllEvents().catch((e) => {
+                logger.warn('Failed to subscribe to Native events', e);
+            });
+        }
+
+        logger.log(`Event source set to: ${eventSource}`);
+    }
+
+    /**
+     * Forward events from CGI source to cameras
+     */
+    private forwardCgiEvents(eventsRes: Record<number, EventsResponse>): void {
+        const logger = this.getLogger();
+
+        if (this.storageSettings.values.debugEvents) {
+            logger.debug(`CGI Events call result: ${JSON.stringify(eventsRes)}`);
+        }
+
+        // Use channel map for efficient lookup
+        for (const [channel, nativeId] of this.channelToNativeIdMap.entries()) {
+            const targetCamera = nativeId ? this.cameraNativeMap.get(nativeId) : undefined;
+            const cameraEventsData = eventsRes[channel];
+            if (cameraEventsData && targetCamera) {
+                targetCamera.processEvents(cameraEventsData);
+            }
+        }
+    }
+
     async init() {
         const api = await this.ensureClient();
         const logger = this.getLogger();
         await this.updateDeviceInfo();
 
+        // Initialize event subscriptions based on selected source
+        await this.reinitEventSubscriptions();
+
         setInterval(async () => {
             if (this.processing || !api) {
                 return;
@@ -127,21 +469,14 @@ export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settin
                     await this.discoverDevices(true);
                 }
 
-                const eventsRes = await api.getAllChannelsEvents();
-
-                if (this.storageSettings.values.debugEvents) {
-                    logger.debug(`Events call result: ${JSON.stringify(eventsRes)}`);
+                // Only fetch and forward CGI events if CGI is selected as event source
+                const { eventSource } = this.storageSettings.values;
+                if (eventSource === 'CGI') {
+                    const eventsRes = await api.getAllChannelsEvents();
+                    this.forwardCgiEvents(eventsRes.parsed);
                 }
-                this.cameraNativeMap.forEach((camera) => {
-                    if (camera) {
-                        const channel = camera.storageSettings.values.rtspChannel;
-                        const cameraEventsData = eventsRes?.parsed[channel];
-                        if (cameraEventsData) {
-                            camera.processEvents(cameraEventsData);
-                        }
-                    }
-                });
 
+                // Always fetch battery info (not event-related)
                 const { batteryInfoData, response } = await api.getAllChannelsBatteryInfo();
 
                 if (this.storageSettings.values.debugEvents) {
@@ -272,6 +607,8 @@ export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settin
                     }
                 };
 
+                this.channelToNativeIdMap.set(channel, nativeId);
+
                 if (sdk.deviceManager.getNativeIds().includes(nativeId)) {
                     continue;
                 }