@apocaliss92/scrypted-reolink-native 0.1.25 → 0.1.27

package/src/main.ts

@@ -4,10 +4,9 @@ import { ReolinkNativeCamera } from "./camera";
 import { ReolinkNativeBatteryCamera } from "./camera-battery";
 import { CommonCameraMixin } from "./common";
 import { createBaichuanApi } from "./connect";
-import { ReolinkNativeMultiFocalDevice } from "./multiFocal";
 import { ReolinkNativeNvrDevice } from "./nvr";
-import { batteryCameraSuffix, cameraSuffix, getDeviceInterfaces, multifocalSuffix, nvrSuffix } from "./utils";
-import { BaichuanTransport } from "./connect";
+import { batteryCameraSuffix, batteryMultifocalSuffix, cameraSuffix, getDeviceInterfaces, multifocalSuffix, nvrSuffix } from "./utils";
+import { ReolinkNativeMultiFocalDevice } from "./multiFocal";
 
 class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider, DeviceCreator {
     devices = new Map<string, BaseBaichuanClass>();
@@ -65,18 +64,28 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
             const deviceInfo = detection.deviceInfo || {};
             const name = deviceInfo.name || 'Reolink Multi-Focal';
             const serialNumber = deviceInfo.serialNumber || deviceInfo.itemNo || `multifocal-${Date.now()}`;
-            nativeId = `${serialNumber}${multifocalSuffix}`;
+            const isBattery = detection.transport === 'udp';
+            nativeId = `${serialNumber}${isBattery ? batteryMultifocalSuffix : multifocalSuffix}`;
 
             settings.newCamera ||= name;
 
+            const interfaces = [
+                ScryptedInterface.Settings,
+                ScryptedInterface.DeviceProvider,
+                ScryptedInterface.Reboot,
+            ];
+
+            if (isBattery) {
+                interfaces.push(
+                    ScryptedInterface.Battery,
+                    ScryptedInterface.Sleep
+                );
+            }
+
             await sdk.deviceManager.onDeviceDiscovered({
                 nativeId,
                 name,
-                interfaces: [
-                    ScryptedInterface.Settings,
-                    ScryptedInterface.DeviceProvider,
-                    ScryptedInterface.Reboot,
-                ],
+                interfaces,
                 type: ScryptedDeviceType.DeviceProvider,
                 providerNativeId: this.nativeId,
             });
@@ -89,7 +98,6 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
             device.storageSettings.values.username = username;
             device.storageSettings.values.password = password;
             device.storageSettings.values.uid = detection.uid || '';
-            device.storageSettings.values.protocol = detection.transport || 'tcp' as BaichuanTransport;
 
             return nativeId;
         }
@@ -151,15 +159,12 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
                 logger: this.console,
             },
             transport: detection.transport,
-            logger: this.console,
         });
 
         try {
             await api.login();
             const rtspChannel = 0;
-            const { abilities, capabilities, objects, presets } = await api.getDeviceCapabilities(rtspChannel);
-
-            this.console.log(nativeId, JSON.stringify({ abilities, capabilities, deviceInfo }));
+            const { capabilities, objects, presets } = await api.getDeviceCapabilities(rtspChannel);
 
             const { interfaces, type } = getDeviceInterfaces({
                 capabilities,
@@ -175,7 +180,6 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
             });
 
             const device = await this.getDevice(nativeId) as CommonCameraMixin;
-            this.console.log(name, interfaces, type, device);
 
             device.info = deviceInfo;
             device.classes = objects;
@@ -214,10 +218,12 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
                 key: 'ip',
                 title: 'IP Address',
                 placeholder: '192.168.2.222',
+                value: '192.168.',
             },
             {
                 key: 'username',
                 title: 'Username',
+                value: 'admin',
             },
             {
                 key: 'password',
@@ -237,8 +243,10 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
             return new ReolinkNativeBatteryCamera(nativeId, this);
         } else if (nativeId.endsWith(nvrSuffix)) {
             return new ReolinkNativeNvrDevice(nativeId, this);
+        } else if (nativeId.endsWith(batteryMultifocalSuffix)) {
+            return new ReolinkNativeMultiFocalDevice(nativeId, this, "multi-focal-battery");
         } else if (nativeId.endsWith(multifocalSuffix)) {
-            return new ReolinkNativeMultiFocalDevice(nativeId, this);
+            return new ReolinkNativeMultiFocalDevice(nativeId, this, "multi-focal");
         } else {
             return new ReolinkNativeCamera(nativeId, this);
         }

package/src/multiFocal.ts

@@ -1,110 +1,50 @@
 import type { DeviceCapabilities, DualLensChannelAnalysis, ReolinkSimpleEvent } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
-import sdk, { Device, DeviceProvider, Reboot, ScryptedDeviceType, Setting, Settings, SettingValue } from "@scrypted/sdk";
-import { StorageSettings } from "@scrypted/sdk/storage-settings";
-import { BaseBaichuanClass, type BaichuanConnectionCallbacks, type BaichuanConnectionConfig } from "./baichuan-base";
+import sdk, { Device, DeviceProvider, MediaObject, Reboot, ScryptedDeviceType, Setting, Settings, SettingValue } from "@scrypted/sdk";
+import { type BaichuanConnectionCallbacks } from "./baichuan-base";
 import { ReolinkNativeCamera } from "./camera";
 import { ReolinkNativeBatteryCamera } from "./camera-battery";
-import { normalizeUid } from "./connect";
+import { CameraType, CommonCameraMixin } from "./common";
 import ReolinkNativePlugin from "./main";
 import { batteryCameraSuffix, cameraSuffix, getDeviceInterfaces, updateDeviceInfo } from "./utils";
 
-export class ReolinkNativeMultiFocalDevice extends BaseBaichuanClass implements Settings, DeviceProvider, Reboot {
-    storageSettings = new StorageSettings(this, {
-        debugEvents: {
-            title: 'Debug Events',
-            type: 'boolean',
-            immediate: true,
-        },
-        ipAddress: {
-            title: 'IP address',
-            type: 'string',
-            onPut: async () => await this.reinit()
-        },
-        username: {
-            title: 'Username',
-            placeholder: 'admin',
-            defaultValue: 'admin',
-            type: 'string',
-            onPut: async () => await this.reinit()
-        },
-        password: {
-            title: 'Password',
-            type: 'password',
-            onPut: async () => await this.reinit()
-        },
-        uid: {
-            title: 'UID',
-            description: 'Reolink UID (required for UDP/battery multi-focal devices)',
-            type: 'string',
-            hide: true,
-            onPut: async () => await this.reinit()
-        },
-        protocol: {
-            type: 'string',
-            hide: true,
-        },
-        diagnosticsRun: {
-            subgroup: 'Diagnostics',
-            title: 'Run Diagnostics',
-            description: 'Collect diagnostics and display results in logs.',
-            type: 'button',
-            immediate: true,
-            onPut: async () => {
-                await this.runDiagnostics();
-            },
-        },
-        multifocalInfo: {
-            json: true,
-            hide: true,
-        },
-        capabilities: {
-            json: true,
-            hide: true,
-        }
-    });
-
+export class ReolinkNativeMultiFocalDevice extends CommonCameraMixin implements Settings, DeviceProvider, Reboot {
     plugin: ReolinkNativePlugin;
     cameraNativeMap = new Map<string, ReolinkNativeCamera | ReolinkNativeBatteryCamera>();
     private channelToNativeIdMap = new Map<number, string>();
     private initReinitTimeout: NodeJS.Timeout | undefined;
     isBattery: boolean;
 
-    constructor(nativeId: string, plugin: ReolinkNativePlugin) {
-        super(nativeId);
+    constructor(nativeId: string, plugin: ReolinkNativePlugin, type: CameraType) {
+        super(nativeId, plugin, { type });
         this.plugin = plugin;
 
-        this.isBattery = this.storageSettings.values.protocol === 'udp';
-
         this.scheduleInit();
     }
 
+    getAbilities(): DeviceCapabilities {
+        const { capabilities } = this.storageSettings.values;
+
+        return {
+            ...capabilities,
+            hasPan: false,
+            hasTilt: false,
+            hasZoom: false,
+            hasPresets: false,
+            hasIntercom: false,
+        }
+    }
+
     async reboot(): Promise<void> {
         const api = await this.ensureBaichuanClient();
         await api.reboot();
     }
 
-    protected getConnectionConfig(): BaichuanConnectionConfig {
-        const { ipAddress, username, password, uid } = this.storageSettings.values;
-        if (!ipAddress || !username || !password) {
-            throw new Error('Missing device credentials');
-        }
-
-        const { protocol } = this.storageSettings.values;
-
-        const normalizedUid = this.isBattery ? normalizeUid(uid) : undefined;
-
-        if (protocol === 'udp' && !normalizedUid) {
-            throw new Error('UID is required for UDP multi-focal devices (BCUDP)');
-        }
+    takePicture(options?: any): Promise<MediaObject> {
+        throw new Error("Method not implemented.");
+    }
 
-        return {
-            host: ipAddress,
-            username,
-            password,
-            uid: normalizedUid,
-            transport: protocol,
-            logger: this.console,
-        };
+    getPictureOptions(): Promise<any[]> {
+        throw new Error("Method not implemented.");
     }
 
     protected getConnectionCallbacks(): BaichuanConnectionCallbacks {
@@ -134,7 +74,7 @@ export class ReolinkNativeMultiFocalDevice extends BaseBaichuanClass implements
     }
 
     protected isDebugEnabled(): boolean {
-        return this.storageSettings.values.debugEvents;
+        return this.storageSettings.values.debugEvents || false;
     }
 
     protected getDeviceName(): string {
@@ -199,9 +139,8 @@ export class ReolinkNativeMultiFocalDevice extends BaseBaichuanClass implements
                 device: this,
                 deviceData,
                 ipAddress: this.storageSettings.values.ipAddress,
+                logger,
             });
-
-            logger.log(`Device info updated: ${JSON.stringify(deviceData)}`);
         } catch (e) {
             logger.warn('Failed to fetch device info', e);
         }
@@ -242,13 +181,15 @@ export class ReolinkNativeMultiFocalDevice extends BaseBaichuanClass implements
         this.storageSettings.values.multifocalInfo = multifocalInfo;
         this.storageSettings.values.capabilities = capabilities;
 
-        logger.debug(`Multichannel info: ${JSON.stringify({ multifocalInfo, capabilities, support, abilities, features, objects, presets })}`);
+        // TODO: Remove this after debugging
+        logger.log(`Multichannel info: ${JSON.stringify({ multifocalInfo, capabilities, support, abilities, features, objects, presets })}`);
+        // logger.debug(`Multichannel info: ${JSON.stringify({ multifocalInfo, capabilities, support, abilities, features, objects, presets })}`);
 
         for (const channelInfo of multifocalInfo?.channels ?? []) {
             const { channel, lensType } = channelInfo;
 
             const name = `${this.name} - ${lensType}`;
-            const nativeId = this.buildNativeId(channel);
+            const nativeId = `${this.nativeId}-channel${channel}${this.isBattery ? batteryCameraSuffix : cameraSuffix}`;
 
             this.channelToNativeIdMap.set(channel, nativeId);
             const { interfaces, capabilities: deviceCapabilities } = this.getInterfaces(channel);
@@ -270,6 +211,9 @@ export class ReolinkNativeMultiFocalDevice extends BaseBaichuanClass implements
 
             await sdk.deviceManager.onDeviceDiscovered(device);
 
+            // TODO: Remove this after debugging
+            logger.log(`Discovering lens device ${nativeId}: ${JSON.stringify({ interfaces, deviceCapabilities })}`);
+
             const camera = await this.getDevice(nativeId);
 
             camera.storageSettings.values.rtspChannel = channel;
@@ -286,16 +230,19 @@ export class ReolinkNativeMultiFocalDevice extends BaseBaichuanClass implements
     }
 
     async getDevice(nativeId: string) {
-        let device = this.cameraNativeMap.get(nativeId);
-        if (!device) {
-            if (nativeId.endsWith(batteryCameraSuffix)) {
-                device = new ReolinkNativeBatteryCamera(nativeId, this.plugin, undefined, this);
-            } else {
-                device = new ReolinkNativeCamera(nativeId, this.plugin, undefined, this);
+        if (nativeId.endsWith(cameraSuffix) || nativeId.endsWith(batteryCameraSuffix)) {
+            let device = this.cameraNativeMap.get(nativeId);
+            if (!device) {
+                if (nativeId.endsWith(batteryCameraSuffix)) {
+                    device = new ReolinkNativeBatteryCamera(nativeId, this.plugin, undefined, this);
+                } else {
+                    device = new ReolinkNativeCamera(nativeId, this.plugin, undefined, this);
+                }
             }
+            return device;
+        } else {
+            return super.getDevice(nativeId);
         }
-
-        return device;
     }
 
     async getSettings(): Promise<Setting[]> {
@@ -309,11 +256,7 @@ export class ReolinkNativeMultiFocalDevice extends BaseBaichuanClass implements
 
     async releaseDevice(id: string, nativeId: string) {
         this.cameraNativeMap.delete(nativeId);
-    }
-
-    buildNativeId(channel: number): string {
-        const { protocol } = this.storageSettings.values;
-        return `${this.nativeId}-channel${channel}${protocol === "udp" ? batteryCameraSuffix : cameraSuffix}`;
+        super.releaseDevice(id, nativeId);
     }
 
     forwardNativeEvent(ev: ReolinkSimpleEvent): void {
@@ -337,16 +280,14 @@ export class ReolinkNativeMultiFocalDevice extends BaseBaichuanClass implements
             return;
         }
 
-        // Forward event to camera
-        if (camera.onSimpleEvent) {
-            camera.onSimpleEvent(ev);
-        }
+        camera.onSimpleEvent(ev);
     }
+
     async unsubscribeFromAllEvents(): Promise<void> {
         await super.unsubscribeFromEvents();
     }
 
-    private async runDiagnostics(): Promise<void> {
+    public async runDiagnostics(): Promise<void> {
         const logger = this.getBaichuanLogger();
         logger.log(`Starting Multifocal diagnostics...`);
 

package/src/nvr.ts

@@ -360,7 +360,8 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
                     this.lastNvrInfoCheck = now;
                     const { nvrData } = await api.getNvrInfo();
                     const { devicesData, channelsResponse, response } = await api.getDevicesInfo();
-                    logger.log(`NVR info data fetched: ${JSON.stringify({ nvrData, devicesData, channelsResponse, response })}`);
+                    logger.log(`NVR info data fetched`);
+                    logger.debug(`${JSON.stringify({ nvrData, devicesData, channelsResponse, response })}`);
 
                     await this.discoverDevices(true);
                 }
@@ -372,7 +373,6 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
                     this.forwardCgiEvents(eventsRes.parsed);
                 }
 
-                // Always fetch battery info (not event-related)
                 const { batteryInfoData, response } = await api.getAllChannelsBatteryInfo();
 
                 logger.debug(`Battery info call result: ${JSON.stringify({ batteryInfoData, response })}`);
@@ -411,9 +411,8 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
                 device: this,
                 ipAddress,
                 deviceData,
+                logger
             });
-
-            logger.log(`Device info updated: ${JSON.stringify(deviceData)}`);
         } catch (e) {
             logger.warn('Failed to fetch device info', e);
         }
@@ -552,7 +551,7 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
             }
         }
 
-        logger.log(`Channel discovery completed. ${JSON.stringify({ devicesData, channels })}`);
+        logger.debug(`Channel discovery completed. ${JSON.stringify({ devicesData, channels })}`);
     }
 
     async discoverDevices(scan?: boolean): Promise<DiscoveredDevice[]> {
@@ -606,7 +605,8 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
 
         const device = await this.getDevice(adopt.nativeId);
         const logger = this.getBaichuanLogger();
-        logger.log('Adopted device', entry, device?.name);
+        logger.log('Adopted device', device?.name);
+        logger.log(JSON.stringify(entry));
         const { username, password, ipAddress } = this.storageSettings.values;
 
         device.storageSettings.values.rtspChannel = entry.rtspChannel;

package/src/utils.ts

@@ -1,5 +1,5 @@
 import type { DeviceCapabilities, ReolinkDeviceInfo } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
-import { DeviceBase, ScryptedDeviceType, ScryptedInterface } from "@scrypted/sdk";
+import sdk, { Device, DeviceBase, ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface } from "@scrypted/sdk";
 
 /**
  * Enumeration of operation types that may require specific channel assignments
@@ -23,7 +23,11 @@ export type OperationChannelMap = Partial<Record<OperationChannelType, number>>;
 export const nvrSuffix = `-nvr`;
 export const batteryCameraSuffix = `-battery-cam`;
 export const multifocalSuffix = `-multifocal`;
+export const batteryMultifocalSuffix = `-battery-multifocal`;
 export const cameraSuffix = `-cam`;
+export const sirenSuffix = `-siren`;
+export const floodlightSuffix = `-floodlight`;
+export const pirSuffix = `-pir`;
 
 export const getDeviceInterfaces = (props: {
     capabilities: DeviceCapabilities,
@@ -78,9 +82,10 @@ export const getDeviceInterfaces = (props: {
 export const updateDeviceInfo = async (props: {
     device: DeviceBase,
     ipAddress: string,
-    deviceData: ReolinkDeviceInfo
+    deviceData: ReolinkDeviceInfo,
+    logger: Console
 }) => {
-    const { device, ipAddress, deviceData } = props;
+    const { device, ipAddress, deviceData, logger } = props;
     try {
         const info = device.info || {};
 
@@ -101,5 +106,9 @@ export const updateDeviceInfo = async (props: {
         device.info = info;
 
         throw e;
+    } finally {
+
+        logger.log(`Device info updated`);
+        logger.debug(`${JSON.stringify({ newInfo: device.info, deviceData })}`);
     }
 }