@apocaliss92/scrypted-reolink-native 0.1.17 → 0.1.18

package/package.json

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

package/src/connect.ts

@@ -175,7 +175,7 @@ export async function autoDetectDeviceType(
 
         // Get device info to check device type
         const deviceInfo = await tcpApi.getInfo();
-        const { support } = await tcpApi.getDeviceCapabilities(0);
+        const { support } = await tcpApi.getDeviceCapabilities();
         const channelNum = support?.channelNum ?? 1;
 
         logger.log(`[AutoDetect] TCP connection successful. channelNum=${channelNum}`);
@@ -248,7 +248,7 @@ export async function autoDetectDeviceType(
             await udpApi.login();
 
             const deviceInfo = await udpApi.getInfo();
-            const { support } = await udpApi.getDeviceCapabilities(0);
+            const { support } = await udpApi.getDeviceCapabilities();
             const channelNum = support?.channelNum ?? 1;
 
             // Multi-focal devices can also be UDP (battery multi-focal cameras)

package/src/multifocal.ts

@@ -61,15 +61,14 @@ export class ReolinkNativeMultiFocalDevice extends BaseBaichuanClass implements
     cameraNativeMap = new Map<string, ReolinkNativeCamera | ReolinkNativeBatteryCamera>();
     private channelToNativeIdMap = new Map<number, string>();
     processing = false;
+    private initReinitTimeout: NodeJS.Timeout | undefined;
 
     constructor(nativeId: string, plugin: ReolinkNativePlugin, transport: BaichuanTransport = 'tcp') {
         super(nativeId);
         this.plugin = plugin;
         this.protocol = transport;
 
-        setTimeout(async () => {
-            await this.init();
-        }, 2000);
+        this.scheduleInit();
     }
 
     async reboot(): Promise<void> {
@@ -121,10 +120,31 @@ export class ReolinkNativeMultiFocalDevice extends BaseBaichuanClass implements
     }
 
     async reinit(): Promise<void> {
-        const logger = this.getBaichuanLogger();
-        logger.log('Reinitializing multi-focal device...');
-        await this.cleanupBaichuanApi();
-        await this.init();
+        // Cancel any pending init/reinit
+        if (this.initReinitTimeout) {
+            clearTimeout(this.initReinitTimeout);
+            this.initReinitTimeout = undefined;
+        }
+
+        // Schedule reinit with debounce
+        this.scheduleInit(true);
+    }
+
+    private scheduleInit(isReinit: boolean = false): void {
+        // Cancel any pending init/reinit
+        if (this.initReinitTimeout) {
+            clearTimeout(this.initReinitTimeout);
+        }
+
+        this.initReinitTimeout = setTimeout(async () => {
+            const logger = this.getBaichuanLogger();
+            if (isReinit) {
+                logger.log('Reinitializing multi-focal device...');
+                await this.cleanupBaichuanApi();
+            }
+            await this.init();
+            this.initReinitTimeout = undefined;
+        }, isReinit ? 500 : 2000);
     }
 
     async init(): Promise<void> {
@@ -132,13 +152,29 @@ export class ReolinkNativeMultiFocalDevice extends BaseBaichuanClass implements
         try {
             // Update UID setting visibility based on transport
             this.storageSettings.settings.uid.hide = this.protocol === 'tcp';
-            
+
+            logger.debug('Initializing: ensuring Baichuan client...');
             await this.ensureBaichuanClient();
+
+            logger.debug('Initializing: updating device info...');
             await this.updateDeviceInfo();
+
+            logger.debug('Initializing: subscribing to events...');
             await this.subscribeToEvents();
+
+            logger.debug('Initializing: discovering devices...');
             await this.discoverDevices(true);
+
+            logger.log('Initialization completed successfully');
         } catch (e) {
             logger.error('Failed to initialize multi-focal device', e);
+            // Log more details about the error
+            if (e instanceof Error) {
+                logger.error(`Error message: ${e.message}`);
+                logger.error(`Error stack: ${e.stack}`);
+            } else {
+                logger.error(`Error details: ${JSON.stringify(e)}`);
+            }
         }
     }
 
@@ -164,61 +200,76 @@ export class ReolinkNativeMultiFocalDevice extends BaseBaichuanClass implements
         const api = await this.ensureBaichuanClient();
         const logger = this.getBaichuanLogger();
 
-        const { devicesData, channels } = await (api as any).getDevicesInfo();
-        logger.log(`Sync entities from remote for ${channels.length} channels`);
-
-        // Process each channel that was successfully discovered
-        for (const channel of channels) {
-            try {
-                const { channelStatus, channelInfo, abilities } = devicesData[channel];
-                const name = channelStatus?.name || `Channel ${channel}`;
-                const uid = channelStatus?.uid;
-                const isBattery = !!(abilities?.battery?.ver ?? 0);
-
-                const nativeId = this.buildNativeId(channel, uid, isBattery);
-                const interfaces = [ScryptedInterface.VideoCamera];
-                if (isBattery) {
-                    interfaces.push(ScryptedInterface.Battery);
-                }
-                const type = abilities.supportDoorbellLight ? ScryptedDeviceType.Doorbell : ScryptedDeviceType.Camera;
-
-                const device: Device = {
-                    nativeId,
-                    name,
-                    providerNativeId: this.nativeId,
-                    interfaces,
-                    type,
-                    info: {
-                        manufacturer: 'Reolink',
-                        model: channelInfo?.typeInfo,
-                        serialNumber: uid,
-                    }
-                };
-
-                this.channelToNativeIdMap.set(channel, nativeId);
-
-                if (sdk.deviceManager.getNativeIds().includes(nativeId)) {
-                    continue;
-                }
-
-                if (this.discoveredDevices.has(nativeId)) {
-                    continue;
-                }
-
-                this.discoveredDevices.set(nativeId, {
-                    device,
-                    description: `${name} (Channel ${channel})`,
-                    rtspChannel: channel,
-                    deviceData: devicesData[channel],
-                });
-
-                logger.debug(`Discovered channel ${channel}: ${name}`);
-            } catch (e: any) {
-                logger.debug(`Error processing channel ${channel}: ${e?.message || String(e)}`);
+        try {
+            const channelsInfo = await api.getNvrChannelsInfo();
+            const deviceInfo = await api.getInfo();
+            const { support } = await api.getDeviceCapabilities();
+            const channelNum = support?.channelNum ?? 1;
+            logger.log(`Sync entities from remote for ${channelNum} channels`);
+            const channels = Array.from({ length: channelNum }, (_, i) => i + 1);
+
+            logger.log(JSON.stringify({ channelsInfo, deviceInfo, channels }));
+
+            // for (const channel of channels) {
+            //     try {
+            //         const name = deviceInfo?.name || `Channel ${channel}`;
+            //         const uid = deviceInfo?.uid;
+            //         const isBattery = !!(abilities?.battery?.ver ?? 0);
+
+            //         const nativeId = this.buildNativeId(channel, uid, isBattery);
+            //         const interfaces = [ScryptedInterface.VideoCamera];
+            //         if (isBattery) {
+            //             interfaces.push(ScryptedInterface.Battery);
+            //         }
+            //         const type = abilities.supportDoorbellLight ? ScryptedDeviceType.Doorbell : ScryptedDeviceType.Camera;
+
+            //         const device: Device = {
+            //             nativeId,
+            //             name,
+            //             providerNativeId: this.nativeId,
+            //             interfaces,
+            //             type,
+            //             info: {
+            //                 manufacturer: 'Reolink',
+            //                 model: channelInfo?.typeInfo,
+            //                 serialNumber: uid,
+            //             }
+            //         };
+
+            //         this.channelToNativeIdMap.set(channel, nativeId);
+
+            //         if (sdk.deviceManager.getNativeIds().includes(nativeId)) {
+            //             continue;
+            //         }
+
+            //         if (this.discoveredDevices.has(nativeId)) {
+            //             continue;
+            //         }
+
+            //         this.discoveredDevices.set(nativeId, {
+            //             device,
+            //             description: `${name} (Channel ${channel})`,
+            //             rtspChannel: channel,
+            //             deviceData: devicesData[channel],
+            //         });
+
+            //         logger.debug(`Discovered channel ${channel}: ${name}`);
+            //     } catch (e: any) {
+            //         logger.debug(`Error processing channel ${channel}: ${e?.message || String(e)}`);
+            //     }
+            // }
+
+            // logger.log(`Channel discovery completed. ${JSON.stringify({ devicesData, channels })}`);
+        } catch (e) {
+            logger.error('Failed to sync entities from remote', e);
+            if (e instanceof Error) {
+                logger.error(`Error in syncEntitiesFromRemote: ${e.message}`);
+                logger.error(`Stack: ${e.stack}`);
+            } else {
+                logger.error(`Error details: ${JSON.stringify(e)}`);
             }
+            throw e;
         }
-
-        logger.log(`Channel discovery completed. ${JSON.stringify({ devicesData, channels })}`);
     }
 
     async discoverDevices(scan?: boolean): Promise<DiscoveredDevice[]> {
@@ -278,7 +329,7 @@ export class ReolinkNativeMultiFocalDevice extends BaseBaichuanClass implements
             device.storageSettings.values.password = this.storageSettings.values.password;
             device.storageSettings.values.rtspChannel = entry.rtspChannel;
             // Set multiFocalDevice reference through options (similar to how NVR does it)
-            (device as any).options = { ...(device as any).options, multiFocalDevice: this, nvrDevice: undefined };
+            (device).options = { ...(device).options, multiFocalDevice: this, nvrDevice: undefined };
             device.classes = objects;
             device.presets = presets;
         }
@@ -386,7 +437,7 @@ export class ReolinkNativeMultiFocalDevice extends BaseBaichuanClass implements
             });
 
             logger.log(`NVR diagnostics completed successfully.`);
-            
+
             // Print diagnostics to console
             cgiApi.printNvrDiagnostics(diagnostics, this.console);
         } catch (e) {

package/src/nvr.ts

@@ -69,14 +69,13 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
     cameraNativeMap = new Map<string, ReolinkNativeCamera | ReolinkNativeBatteryCamera>();
     private channelToNativeIdMap = new Map<number, string>();
     processing = false;
+    private initReinitTimeout: NodeJS.Timeout | undefined;
 
     constructor(nativeId: string, plugin: ReolinkNativePlugin) {
         super(nativeId);
         this.plugin = plugin;
 
-        setTimeout(async () => {
-            await this.init();
-        }, 2000);
+        this.scheduleInit();
     }
 
     async reboot(): Promise<void> {
@@ -130,18 +129,40 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
     }
 
     async reinit() {
-        // Cleanup CGI API
-        if (this.nvrApi) {
-            try {
-                await this.nvrApi.logout();
-            } catch {
-                // ignore
-            }
+        // Cancel any pending init/reinit
+        if (this.initReinitTimeout) {
+            clearTimeout(this.initReinitTimeout);
+            this.initReinitTimeout = undefined;
+        }
+
+        // Schedule reinit with debounce
+        this.scheduleInit(true);
+    }
+
+    private scheduleInit(isReinit: boolean = false): void {
+        // Cancel any pending init/reinit
+        if (this.initReinitTimeout) {
+            clearTimeout(this.initReinitTimeout);
         }
-        this.nvrApi = undefined;
 
-        // Cleanup Baichuan API (this handles all listeners and connection)
-        await super.cleanupBaichuanApi();
+        this.initReinitTimeout = setTimeout(async () => {
+            if (isReinit) {
+                // Cleanup CGI API
+                if (this.nvrApi) {
+                    try {
+                        await this.nvrApi.logout();
+                    } catch {
+                        // ignore
+                    }
+                }
+                this.nvrApi = undefined;
+
+                // Cleanup Baichuan API (this handles all listeners and connection)
+                await super.cleanupBaichuanApi();
+            }
+            await this.init();
+            this.initReinitTimeout = undefined;
+        }, isReinit ? 500 : 2000);
     }
 
     async ensureClient(): Promise<ReolinkCgiApi> {