@apocaliss92/scrypted-reolink-native 0.1.8 → 0.1.10

package/src/nvr.ts

@@ -1,19 +1,31 @@
-import type { DeviceInfoResponse, DeviceInputData, ReolinkBaichuanApi, ReolinkCgiApi, ReolinkSimpleEvent } 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 { 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',
             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,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;
@@ -46,15 +57,8 @@ 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 onSimpleEventHandler?: (ev: ReolinkSimpleEvent) => void;
-    private closeListener?: () => void;
-    private errorListener?: (err: unknown) => void;
-    private lastDisconnectTime: number = 0;
-    private lastErrorBeforeClose: { error: string; timestamp: number } | undefined;
-    private readonly reconnectBackoffMs: number = 2000; // 2 seconds minimum between reconnects
-    private resubscribeTimeout?: NodeJS.Timeout;
 
     constructor(nativeId: string, plugin: ReolinkNativePlugin) {
         super(nativeId);
@@ -70,11 +74,53 @@ export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settin
         await api.Reboot();
     }
 
-    getLogger() {
-        return this.console;
+    // BaseBaichuanClass abstract methods implementation
+    protected getConnectionConfig(): BaichuanConnectionConfig {
+        const { ipAddress, username, password } = this.storageSettings.values;
+        if (!ipAddress || !username || !password) {
+            throw new Error('Missing NVR credentials');
+        }
+
+        return {
+            host: ipAddress,
+            username,
+            password,
+            transport: 'tcp',
+            logger: this.console,
+        };
+    }
+
+    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';
+            },
+        };
+    }
+
+
+    protected isDebugEnabled(): boolean {
+        return this.storageSettings.values.debugEvents || false;
+    }
+
+    protected getDeviceName(): string {
+        return this.name || 'NVR';
+    }
+
+    protected async onBeforeCleanup(): Promise<void> {
+        // Unsubscribe from events if needed
+        await this.unsubscribeFromAllEvents();
     }
 
     async reinit() {
+        // Cleanup CGI API
         if (this.nvrApi) {
             try {
                 await this.nvrApi.logout();
@@ -84,48 +130,8 @@ export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settin
         }
         this.nvrApi = undefined;
 
-        // Clear any pending resubscribe timeout
-        if (this.resubscribeTimeout) {
-            clearTimeout(this.resubscribeTimeout);
-            this.resubscribeTimeout = undefined;
-        }
-
-        // Unsubscribe from events first
-        await this.unsubscribeFromAllEvents();
-
-        if (this.baichuanApi) {
-            // Remove close listener
-            if (this.closeListener) {
-                try {
-                    this.baichuanApi.client.off("close", this.closeListener);
-                }
-                catch {
-                    // ignore
-                }
-                this.closeListener = undefined;
-            }
-            
-            // Remove error listener
-            if (this.errorListener) {
-                try {
-                    this.baichuanApi.client.off("error", this.errorListener);
-                }
-                catch {
-                    // ignore
-                }
-                this.errorListener = undefined;
-            }
-
-            try {
-                if (this.baichuanApi.client.isSocketConnected()) {
-                    await this.baichuanApi.close();
-                }
-            } catch {
-                // ignore
-            }
-        }
-        this.baichuanApi = undefined;
-        this.baichuanApiPromise = undefined;
+        // Cleanup Baichuan API (this handles all listeners and connection)
+        await super.cleanupBaichuanApi();
     }
 
     async ensureClient(): Promise<ReolinkCgiApi> {
@@ -149,372 +155,146 @@ export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settin
         return this.nvrApi;
     }
 
-    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;
+    private forwardNativeEvent(ev: ReolinkSimpleEvent): void {
+        const logger = this.getBaichuanLogger();
 
-        this.baichuanApiPromise = (async () => {
-            const { ipAddress, username, password } = this.storageSettings.values;
-            if (!ipAddress || !username || !password) {
-                throw new Error('Missing NVR credentials');
-            }
+        const eventSource = this.storageSettings.values.eventSource || 'Native';
+        if (eventSource !== 'Native') {
+            return;
+        }
 
-            // Clean up old client if exists
-            if (this.baichuanApi) {
-                // Remove close listener from old client
-                if (this.closeListener) {
-                    try {
-                        this.baichuanApi.client.off("close", this.closeListener);
-                    }
-                    catch {
-                        // ignore
-                    }
-                    this.closeListener = undefined;
-                }
-                
-                // Remove error listener from old client
-                if (this.errorListener) {
-                    try {
-                        this.baichuanApi.client.off("error", this.errorListener);
-                    }
-                    catch {
-                        // ignore
-                    }
-                    this.errorListener = undefined;
-                }
+        try {
+            logger.debug(`Baichuan event: ${JSON.stringify(ev)}`);
 
-                try {
-                    if (this.baichuanApi.client.isSocketConnected()) {
-                        await this.baichuanApi.close();
-                    }
-                }
-                catch {
-                    // ignore
-                }
+            // Find camera for this channel
+            const channel = ev?.channel;
+            if (channel === undefined) {
+                logger.debug('Event has no channel, ignoring');
+                return;
             }
 
-            // 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(),
-                // rebootAfterDisconnectionsPerMinute: 5,
-            });
-
-            await this.baichuanApi.login();
+            const nativeId = this.channelToNativeIdMap.get(channel);
+            const targetCamera = nativeId ? this.cameraNativeMap.get(nativeId) : undefined;
 
-            // Verify socket is connected before returning
-            if (!this.baichuanApi.client.isSocketConnected()) {
-                throw new Error('Socket not connected after login');
+            if (!targetCamera) {
+                logger.debug(`No camera found for channel ${channel}, ignoring event`);
+                return;
             }
 
-            // Listen for errors to understand why socket might close
-            this.errorListener = (err: unknown) => {
-                const logger = this.getLogger();
-                const msg = (err as any)?.message || (err as any)?.toString?.() || String(err);
-                
-                // Store last error before close
-                this.lastErrorBeforeClose = {
-                    error: msg,
-                    timestamp: Date.now()
-                };
-
-                // 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')
-                )) {
-                    // Log even recoverable errors for debugging
-                    logger.debug(`[NVR BaichuanClient] error (recoverable): ${msg}`);
-                    return;
-                }
-                logger.error(`[NVR BaichuanClient] error: ${msg}`);
-            };
-            this.baichuanApi.client.on("error", this.errorListener);
+            // Convert event to camera's processEvents format
+            const objects: string[] = [];
+            let motion = false;
 
-            // Listen for socket disconnection to reset client state
-            this.closeListener = () => {
-                const logger = this.getLogger();
-                const now = Date.now();
-                const timeSinceLastDisconnect = now - this.lastDisconnectTime;
-                this.lastDisconnectTime = now;
-
-                // Log detailed information about the close
-                const errorInfo = this.lastErrorBeforeClose 
-                    ? ` (last error: ${this.lastErrorBeforeClose.error} at ${new Date(this.lastErrorBeforeClose.timestamp).toISOString()}, ${now - this.lastErrorBeforeClose.timestamp}ms before close)`
-                    : '';
-                
-                logger.log(`[NVR BaichuanClient] Socket closed, resetting client state (last disconnect ${timeSinceLastDisconnect}ms ago)${errorInfo}`);
-                
-                // Log connection state before close
-                try {
-                    const wasConnected = this.baichuanApi?.client.isSocketConnected();
-                    const wasLoggedIn = this.baichuanApi?.client.loggedIn;
-                    logger.log(`[NVR BaichuanClient] Connection state before close: connected=${wasConnected}, loggedIn=${wasLoggedIn}`);
-                    
-                    // Try to get last message info if available
-                    const client = this.baichuanApi?.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}`);
-                }
-                
-                // Clear any pending resubscribe timeout
-                if (this.resubscribeTimeout) {
-                    clearTimeout(this.resubscribeTimeout);
-                    this.resubscribeTimeout = undefined;
-                }
-
-                const wasSubscribed = this.eventSubscriptionActive;
-                const api = this.baichuanApi; // Save reference before clearing
-                
-                // Reset state
-                this.baichuanApi = undefined;
-                this.baichuanApiPromise = undefined;
-                this.eventSubscriptionActive = false;
-                this.onSimpleEventHandler = undefined;
-                
-                // Remove event handler from closed client
-                if (api && this.onSimpleEventHandler) {
+            switch (ev?.type) {
+                case 'motion':
+                    motion = true;
+                    break;
+                case 'doorbell':
+                    // Handle doorbell if camera supports it
                     try {
-                        api.offSimpleEvent(this.onSimpleEventHandler);
-                    }
-                    catch {
-                        // ignore
-                    }
-                }
-                
-                // Remove close listener (it will be re-added on next connection)
-                if (api && this.closeListener) {
-                    try {
-                        api.client.off("close", this.closeListener);
-                    }
-                    catch {
-                        // ignore
-                    }
-                }
-                
-                // Remove error listener
-                if (api && this.errorListener) {
-                    try {
-                        api.client.off("error", this.errorListener);
+                        if (typeof (targetCamera as any).handleDoorbellEvent === 'function') {
+                            (targetCamera as any).handleDoorbellEvent();
+                        }
                     }
-                    catch {
-                        // ignore
+                    catch (e) {
+                        logger.warn(`Error handling doorbell event for camera channel ${channel}`, e);
                     }
-                }
-                
-                this.closeListener = undefined;
-                this.errorListener = undefined;
-                this.lastErrorBeforeClose = undefined;
-                
-                // Try to resubscribe when connection is restored (async, don't block)
-                // Only if we had an active subscription and enough time has passed
-                if (wasSubscribed && timeSinceLastDisconnect >= this.reconnectBackoffMs) {
-                    this.resubscribeTimeout = setTimeout(async () => {
-                        this.resubscribeTimeout = undefined;
-                        try {
-                            await this.subscribeToAllEvents();
-                        }
-                        catch (e) {
-                            logger.warn('Failed to resubscribe to events after reconnection', e);
-                        }
-                    }, this.reconnectBackoffMs); // Wait for backoff period before resubscribing
-                }
-            };
-            this.baichuanApi.client.on("close", this.closeListener);
-
-            return this.baichuanApi;
-        })();
+                    motion = true;
+                    break;
+                case 'people':
+                case 'vehicle':
+                case 'animal':
+                case 'face':
+                case 'package':
+                case 'other':
+                    objects.push(ev.type);
+                    motion = true;
+                    break;
+                default:
+                    logger.debug(`Unknown event type: ${ev?.type}`);
+                    return;
+            }
 
-        try {
-            return await this.baichuanApiPromise;
+            // Process events on the target camera
+            targetCamera.processEvents({ motion, objects }).catch((e) => {
+                logger.warn(`Error processing events for camera channel ${channel}`, e);
+            });
         }
-        finally {
-            // Allow future reconnects and avoid pinning rejected promises
-            this.baichuanApiPromise = undefined;
+        catch (e) {
+            logger.warn('Error in NVR Native event forwarder', e);
         }
     }
 
-    async subscribeToAllEvents(): Promise<void> {
-        const logger = this.getLogger();
-        
-        // 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;
-        //         logger.log(`[NVR] Waiting ${waitTime}ms before subscribing to events (backoff)`);
-        //         await new Promise(resolve => setTimeout(resolve, waitTime));
-        //     }
-        // }
-
-        // If already subscribed, return
-        if (this.eventSubscriptionActive && this.onSimpleEventHandler && this.baichuanApi) {
-            // Verify connection is still valid
-            if (this.baichuanApi.client.isSocketConnected() && this.baichuanApi.client.loggedIn) {
-                logger.log('Event subscription already active');
-                return;
-            }
-            // Connection is invalid, unsubscribe first
-            try {
-                this.baichuanApi.offSimpleEvent(this.onSimpleEventHandler);
-            }
-            catch {
-                // ignore
-            }
-            this.eventSubscriptionActive = false;
-            this.onSimpleEventHandler = undefined;
-        }
+    async ensureBaichuanClient(): Promise<ReolinkBaichuanApi> {
+        // Use base class implementation
+        return await super.ensureBaichuanClient();
+    }
 
-        // Unsubscribe first if handler exists
-        if (this.onSimpleEventHandler && this.baichuanApi) {
-            try {
-                this.baichuanApi.offSimpleEvent(this.onSimpleEventHandler);
-            }
-            catch {
-                // ignore
-            }
-        }
+    async subscribeToAllEvents(): Promise<void> {
+        const logger = this.getBaichuanLogger();
+        const eventSource = this.storageSettings.values.eventSource || 'Native';
 
-        // 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');
+        // Only subscribe if Native is selected
+        if (eventSource !== 'Native') {
+            await this.unsubscribeFromAllEvents();
             return;
         }
 
-        // Create event handler that distributes events to cameras
-        this.onSimpleEventHandler = (ev: ReolinkSimpleEvent) => {
-            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;
-                }
-
-                // Find camera with matching channel
-                let targetCamera: ReolinkNativeCamera | ReolinkNativeBatteryCamera | undefined;
-                for (const camera of this.cameraNativeMap.values()) {
-                    if (camera && camera.storageSettings.values.rtspChannel === channel) {
-                        targetCamera = camera;
-                        break;
-                    }
-                }
+        // Use base class implementation
+        await super.subscribeToEvents();
+        logger.log('Subscribed to all events for NVR cameras');
+    }
 
-                if (!targetCamera) {
-                    if (this.storageSettings.values.debugEvents) {
-                        logger.debug(`No camera found for channel ${channel}, ignoring event`);
-                    }
-                    return;
-                }
+    async unsubscribeFromAllEvents(): Promise<void> {
+        // Use base class implementation
+        await super.unsubscribeFromEvents();
+    }
 
-                // 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;
-                }
+    /**
+     * Reinitialize event subscriptions based on selected event source
+     */
+    private async reinitEventSubscriptions(): Promise<void> {
+        const logger = this.getBaichuanLogger();
+        const { eventSource } = this.storageSettings.values;
 
-                // 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 onSimpleEvent handler', e);
-            }
-        };
+        // Unsubscribe from Native events if switching away
+        if (eventSource !== 'Native') {
+            await this.unsubscribeFromAllEvents();
+        } else {
 
-        // 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;
-            this.onSimpleEventHandler = undefined;
+            this.subscribeToAllEvents().catch((e) => {
+                logger.warn('Failed to subscribe to Native events', e);
+            });
         }
+
+        logger.log(`Event source set to: ${eventSource}`);
     }
 
-    async unsubscribeFromAllEvents(): Promise<void> {
-        const logger = this.getLogger();
-        
-        if (this.onSimpleEventHandler && this.baichuanApi) {
-            try {
-                this.baichuanApi.offSimpleEvent(this.onSimpleEventHandler);
-                logger.log('Unsubscribed from all events');
-            }
-            catch (e) {
-                logger.warn('Error unsubscribing from events', e);
+    /**
+     * Forward events from CGI source to cameras
+     */
+    private forwardCgiEvents(eventsRes: Record<number, EventsResponse>): void {
+        const logger = this.getBaichuanLogger();
+
+        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);
             }
         }
-        
-        this.eventSubscriptionActive = false;
-        this.onSimpleEventHandler = undefined;
     }
 
     async init() {
         const api = await this.ensureClient();
-        const logger = this.getLogger();
+        const logger = this.getBaichuanLogger();
         await this.updateDeviceInfo();
 
-        // Subscribe to events for all cameras
-        this.subscribeToAllEvents().catch((e) => {
-            logger.warn('Failed to subscribe to events during init', e);
-        });
+        // Initialize event subscriptions based on selected source
+        await this.reinitEventSubscriptions();
 
         setInterval(async () => {
             if (this.processing || !api) {
@@ -535,33 +315,22 @@ 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);
                 }
 
-                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) {
-                    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) {
@@ -578,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;
             }
@@ -597,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);
         }
     }
 
@@ -651,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...');
 
@@ -687,6 +456,8 @@ export class ReolinkNativeNvrDevice extends ScryptedDeviceBase implements Settin
                     }
                 };
 
+                this.channelToNativeIdMap.set(channel, nativeId);
+
                 if (sdk.deviceManager.getNativeIds().includes(nativeId)) {
                     continue;
                 }
@@ -761,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;