@apocaliss92/scrypted-reolink-native 0.1.22 → 0.1.24

package/package.json

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

package/src/camera-battery.ts

@@ -9,6 +9,8 @@ import {
 } from "./common";
 import { DebugLogOption } from "./debug-options";
 import type ReolinkNativePlugin from "./main";
+import { ReolinkNativeNvrDevice } from "./nvr";
+import { ReolinkNativeMultiFocalDevice } from "./multiFocal";
 
 export class ReolinkNativeBatteryCamera extends CommonCameraMixin {
     private lastPicture: { mo: MediaObject; atMs: number } | undefined;
@@ -28,10 +30,16 @@ export class ReolinkNativeBatteryCamera extends CommonCameraMixin {
         return debugLogs.includes(DebugLogOption.BatteryInfo);
     }
 
-    constructor(nativeId: string, public plugin: ReolinkNativePlugin, nvrDevice?: any) {
+    constructor(
+        nativeId: string, 
+        public plugin: ReolinkNativePlugin, 
+        nvrDevice?: ReolinkNativeNvrDevice,
+        multiFocalDevice?: ReolinkNativeMultiFocalDevice
+    ) {
         super(nativeId, plugin, {
             type: 'battery',
             nvrDevice,
+            multiFocalDevice,
         });
     }
 

package/src/camera.ts

@@ -6,6 +6,8 @@ import {
 } from "./common";
 import { createBaichuanApi } from './connect';
 import ReolinkNativePlugin from "./main";
+import { ReolinkNativeNvrDevice } from "./nvr";
+import { ReolinkNativeMultiFocalDevice } from "./multiFocal";
 
 export const moToB64 = async (mo: MediaObject) => {
     const bufferImage = await sdk.mediaManager.convertMediaObjectToBuffer(mo, 'image/jpeg');
@@ -28,10 +30,16 @@ export class ReolinkNativeCamera extends CommonCameraMixin {
     private statusPollTimer: NodeJS.Timeout | undefined;
 
 
-    constructor(nativeId: string, public plugin: ReolinkNativePlugin, nvrDevice?: any) {
+    constructor(
+        nativeId: string, 
+        public plugin: ReolinkNativePlugin, 
+        nvrDevice?: ReolinkNativeNvrDevice,
+        multiFocalDevice?: ReolinkNativeMultiFocalDevice
+    ) {
         super(nativeId, plugin, {
             type: 'regular',
             nvrDevice,
+            multiFocalDevice,
         });
     }
 
@@ -109,10 +117,6 @@ export class ReolinkNativeCamera extends CommonCameraMixin {
         return api;
     }
 
-    getClient(): ReolinkBaichuanApi | undefined {
-        return this.baichuanApi;
-    }
-
     private passiveRefreshTimer: ReturnType<typeof setTimeout> | undefined;
 
     async release() {

package/src/common.ts

@@ -8,7 +8,7 @@ import { convertDebugLogsToApiOptions, DebugLogDisplayNames, DebugLogOption, get
 import { ReolinkBaichuanIntercom } from "./intercom";
 import ReolinkNativePlugin from "./main";
 import { ReolinkNativeNvrDevice } from "./nvr";
-import { ReolinkNativeMultiFocalDevice } from "./multifocal";
+import { ReolinkNativeMultiFocalDevice } from "./multiFocal";
 import { ReolinkPtzPresets } from "./presets";
 import {
     createRfc4571MediaObjectFromStreamManager,
@@ -526,7 +526,11 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     protected multiFocalDevice?: ReolinkNativeMultiFocalDevice;
     thisDevice: Settings
 
-    constructor(nativeId: string, public plugin: ReolinkNativePlugin, public options: CommonCameraMixinOptions) {
+    constructor(
+        nativeId: string, 
+        public plugin: ReolinkNativePlugin, 
+        public options: CommonCameraMixinOptions
+    ) {
         super(nativeId);
         this.protocol = !options.nvrDevice && !options.multiFocalDevice && options.type === 'battery' ? 'udp' : 'tcp';
 
@@ -644,12 +648,17 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             }
         }
     }
+
     createStreamClient(): Promise<ReolinkBaichuanApi> {
         throw new Error("Method not implemented.");
     }
 
     public getAbilities(): DeviceCapabilities {
-        return this.storageSettings.values.capabilities;
+        if(this.options.multiFocalDevice) {
+            return this.options.multiFocalDevice.getInterfaces(this.storageSettings.values.rtspChannel).capabilities;
+        } else {
+            return this.storageSettings.values.capabilities;
+        }
     }
 
     getBaichuanDebugOptions(): any | undefined {
@@ -1357,21 +1366,16 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         const vsos = await this.getVideoStreamOptions();
         const selected = selectStreamOption(vsos, vso);
 
-        // Check if this is a native stream (prefixed with "native_")
-
-        // If stream has RTSP/RTMP URL (not native), add credentials and create MediaStreamUrl
         if (selected.url && (selected.container === 'rtsp' || selected.container === 'rtmp')) {
             const urlWithCredentials = this.addRtspCredentials(selected.url);
             const ret: MediaStreamUrl = {
                 container: selected.container,
-                // url: selected.url,
                 url: urlWithCredentials,
                 mediaStreamOptions: selected,
             };
             return await this.createMediaObject(ret, ScryptedMimeTypes.MediaStreamUrl);
         }
 
-        // Use streamManager for native Baichuan streams (native_* or streams without URL)
         if (!this.streamManager) {
             throw new Error('StreamManager not initialized');
         }
@@ -1406,9 +1410,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         return await this.withBaichuanRetry(createStreamFn);
     }
 
-    // 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();
         }

package/src/connect.ts

@@ -1,6 +1,6 @@
-import type { BaichuanClientOptions, ReolinkBaichuanApi } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
+import type { BaichuanTransport as BaichuanTransportParent, BaichuanClientOptions, ReolinkBaichuanApi } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
 
-export type BaichuanTransport = "tcp" | "udp";
+export type BaichuanTransport = BaichuanTransportParent;
 
 export type BaichuanConnectInputs = {
     host: string;

package/src/main.ts

@@ -4,9 +4,10 @@ import { ReolinkNativeCamera } from "./camera";
 import { ReolinkNativeBatteryCamera } from "./camera-battery";
 import { CommonCameraMixin } from "./common";
 import { createBaichuanApi } from "./connect";
-import { ReolinkNativeMultiFocalDevice } from "./multifocal";
+import { ReolinkNativeMultiFocalDevice } from "./multiFocal";
 import { ReolinkNativeNvrDevice } from "./nvr";
 import { batteryCameraSuffix, cameraSuffix, getDeviceInterfaces, multifocalSuffix, nvrSuffix } from "./utils";
+import { BaichuanTransport } from "./connect";
 
 class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider, DeviceCreator {
     devices = new Map<string, BaseBaichuanClass>();
@@ -73,7 +74,6 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
                 name,
                 interfaces: [
                     ScryptedInterface.Settings,
-                    ScryptedInterface.DeviceDiscovery,
                     ScryptedInterface.DeviceProvider,
                     ScryptedInterface.Reboot,
                 ],
@@ -89,6 +89,7 @@ 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;
         }
@@ -237,7 +238,7 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
         } else if (nativeId.endsWith(nvrSuffix)) {
             return new ReolinkNativeNvrDevice(nativeId, this);
         } else if (nativeId.endsWith(multifocalSuffix)) {
-            return new ReolinkNativeMultiFocalDevice(nativeId, this, 'tcp');
+            return new ReolinkNativeMultiFocalDevice(nativeId, this);
         } else {
             return new ReolinkNativeCamera(nativeId, this);
         }

package/src/multiFocal.ts

@@ -0,0 +1,371 @@
+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 { ReolinkNativeCamera } from "./camera";
+import { ReolinkNativeBatteryCamera } from "./camera-battery";
+import { normalizeUid } from "./connect";
+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,
+        }
+    });
+
+    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);
+        this.plugin = plugin;
+
+        this.isBattery = this.storageSettings.values.protocol === 'udp';
+
+        this.scheduleInit();
+    }
+
+    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)');
+        }
+
+        return {
+            host: ipAddress,
+            username,
+            password,
+            uid: normalizedUid,
+            transport: protocol,
+            logger: this.console,
+        };
+    }
+
+    protected getConnectionCallbacks(): BaichuanConnectionCallbacks {
+        return {
+            onError: undefined, // Use default error handling
+            onClose: async () => {
+                // Reinit after cleanup
+                await this.reinit();
+                if (!this.isBattery) {
+                    setTimeout(async () => {
+                        try {
+                            await this.subscribeToEvents();
+                        } catch (e) {
+                            const logger = this.getBaichuanLogger();
+                            logger.warn('Failed to resubscribe to events after reconnection', e);
+                        }
+                    }, 1000);
+                }
+            },
+            onSimpleEvent: (ev) => this.forwardNativeEvent(ev),
+            getEventSubscriptionEnabled: () => true,
+        };
+    }
+
+    protected async onBeforeCleanup(): Promise<void> {
+        await this.unsubscribeFromAllEvents();
+    }
+
+    protected isDebugEnabled(): boolean {
+        return this.storageSettings.values.debugEvents;
+    }
+
+    protected getDeviceName(): string {
+        return this.name || 'Multi-Focal Device';
+    }
+
+    async reinit(): Promise<void> {
+        // 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> {
+        const logger = this.getBaichuanLogger();
+        try {
+            this.storageSettings.settings.uid.hide = !this.isBattery;
+
+            await this.ensureBaichuanClient();
+            await this.updateDeviceInfo();
+            await this.reportDevices();
+            await this.subscribeToEvents();
+        } catch (e) {
+            logger.error('Failed to initialize multi-focal device', e);
+            if (e instanceof Error) {
+                logger.error(`Error message: ${e.message}`);
+                logger.error(`Error stack: ${e.stack}`);
+            } else {
+                logger.error(`Error details: ${JSON.stringify(e)}`);
+            }
+        }
+    }
+
+    async updateDeviceInfo(): Promise<void> {
+        const logger = this.getBaichuanLogger();
+        try {
+            const api = await this.ensureBaichuanClient();
+            const deviceData = await api.getInfo();
+
+            await updateDeviceInfo({
+                device: this,
+                deviceData,
+                ipAddress: this.storageSettings.values.ipAddress,
+            });
+
+            logger.log(`Device info updated: ${JSON.stringify(deviceData)}`);
+        } catch (e) {
+            logger.warn('Failed to fetch device info', e);
+        }
+    }
+
+    getInterfaces(channel: number) {
+        const logger = this.getBaichuanLogger();
+        const { capabilities: caps, multifocalInfo } = this.storageSettings.values;
+        const channelInfo = (multifocalInfo as DualLensChannelAnalysis).channels.find(c => c.channel === channel);
+
+        const capabilities: DeviceCapabilities = {
+            ...caps,
+            hasPan: channelInfo.hasPan,
+            hasTilt: channelInfo.hasTilt,
+            hasZoom: channelInfo.hasZoom,
+            hasPresets: channelInfo.hasPresets,
+            hasIntercom: channelInfo.hasIntercom,
+        };
+
+        const { interfaces } = getDeviceInterfaces({
+            capabilities,
+            logger,
+        });
+
+        return { interfaces, capabilities };
+    }
+
+    async reportDevices(): Promise<void> {
+        const api = await this.ensureBaichuanClient();
+        const logger = this.getBaichuanLogger();
+        const { protocol, username, password, ipAddress, uid } = this.storageSettings.values;
+
+        const { capabilities, support, abilities, features, objects, presets } = await api.getDeviceCapabilities();
+
+        const multifocalInfo = await api.getDualLensChannelInfo();
+        logger.log(`Sync entities from remote for ${multifocalInfo.channels.length} channels`);
+
+        this.storageSettings.values.multifocalInfo = multifocalInfo;
+        this.storageSettings.values.capabilities = capabilities;
+
+        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);
+
+            this.channelToNativeIdMap.set(channel, nativeId);
+            const { interfaces, capabilities: deviceCapabilities } = this.getInterfaces(channel);
+
+            const device: Device = {
+                providerNativeId: this.nativeId,
+                name,
+                nativeId,
+                info: {
+                    ...this.info,
+                    metadata: {
+                        channel,
+                        lensType
+                    }
+                },
+                interfaces,
+                type: ScryptedDeviceType.Camera,
+            };
+
+            await sdk.deviceManager.onDeviceDiscovered(device);
+
+            const camera = await this.getDevice(nativeId);
+
+            camera.storageSettings.values.rtspChannel = channel;
+            camera.classes = objects;
+            camera.presets = presets;
+            camera.storageSettings.values.username = username;
+            camera.storageSettings.values.password = password;
+            camera.storageSettings.values.ipAddress = ipAddress;
+            camera.storageSettings.values.capabilities = deviceCapabilities;
+            if (this.isBattery) {
+                camera.storageSettings.values.uid = uid;
+            }
+        }
+    }
+
+    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);
+            }
+        }
+
+        return device;
+    }
+
+    async getSettings(): Promise<Setting[]> {
+        const settings = await this.storageSettings.getSettings();
+        return settings;
+    }
+
+    async putSetting(key: string, value: SettingValue): Promise<void> {
+        return this.storageSettings.putSetting(key, value);
+    }
+
+    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}`;
+    }
+
+    forwardNativeEvent(ev: ReolinkSimpleEvent): void {
+        const logger = this.getBaichuanLogger();
+        const channel = ev?.channel;
+
+        if (channel === undefined) {
+            logger.debug('Event missing channel, ignoring');
+            return;
+        }
+
+        const nativeId = this.channelToNativeIdMap.get(channel);
+        if (!nativeId) {
+            logger.debug(`No camera found for channel ${channel}, ignoring event`);
+            return;
+        }
+
+        const camera = this.cameraNativeMap.get(nativeId);
+        if (!camera) {
+            logger.debug(`Camera ${nativeId} not yet initialized, ignoring event`);
+            return;
+        }
+
+        // Forward event to camera
+        if (camera.onSimpleEvent) {
+            camera.onSimpleEvent(ev);
+        }
+    }
+    async unsubscribeFromAllEvents(): Promise<void> {
+        await super.unsubscribeFromEvents();
+    }
+
+    private async runDiagnostics(): Promise<void> {
+        const logger = this.getBaichuanLogger();
+        logger.log(`Starting Multifocal diagnostics...`);
+
+        try {
+            const { ipAddress, username, password } = this.storageSettings.values;
+            if (!ipAddress || !username || !password) {
+                throw new Error('Missing device credentials');
+            }
+
+            const api = await this.ensureBaichuanClient();
+
+            const multifocalDiagnostics = await api.collectMultifocalDiagnostics(logger);
+
+            logger.log(`NVR diagnostics completed successfully.`);
+            logger.log(JSON.stringify(multifocalDiagnostics));
+        } catch (e) {
+            logger.error('Failed to run NVR diagnostics', e);
+            throw e;
+        }
+    }
+}
+

package/src/nvr.ts

@@ -124,12 +124,10 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
     }
 
     protected async onBeforeCleanup(): Promise<void> {
-        // Unsubscribe from events if needed
         await this.unsubscribeFromAllEvents();
     }
 
     async reinit() {
-        // Cancel any pending init/reinit
         if (this.initReinitTimeout) {
             clearTimeout(this.initReinitTimeout);
             this.initReinitTimeout = undefined;
@@ -307,7 +305,6 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
         if (eventSource !== 'Native') {
             await this.unsubscribeFromAllEvents();
         } else {
-
             this.subscribeToAllEvents().catch((e) => {
                 logger.warn('Failed to subscribe to Native events', e);
             });
@@ -343,7 +340,6 @@ export class ReolinkNativeNvrDevice extends BaseBaichuanClass implements Setting
         
         await this.updateDeviceInfo();
 
-        // Initialize event subscriptions based on selected source
         await this.reinitEventSubscriptions();
 
         setInterval(async () => {