@apocaliss92/scrypted-reolink-native 0.1.25 → 0.1.26

package/package.json

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

package/src/baichuan-base.ts

@@ -248,11 +248,10 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
                     username: config.username,
                     password: config.password,
                     uid: config.uid,
-                    logger: logger as Console,
+                    logger,
                     debugOptions: config.debugOptions,
                 },
                 transport: config.transport,
-                logger: logger as Console,
             });
 
             await api.login();

package/src/camera-battery.ts

@@ -374,18 +374,12 @@ export class ReolinkNativeBatteryCamera extends CommonCameraMixin {
         }
     }
 
-    async withBaichuanRetry<T>(fn: () => Promise<T>): Promise<T> {
-        return await fn();
-    }
-
     protected async withBaichuanClient<T>(fn: (api: ReolinkBaichuanApi) => Promise<T>): Promise<T> {
         const client = await this.ensureClient();
         return fn(client);
     }
 
     async createStreamClient(): Promise<ReolinkBaichuanApi> {
-        // Reuse the main Baichuan client connection instead of creating a new one
-        // This ensures we use a single session for everything (general + streams)
         return await this.ensureClient();
     }
 }

package/src/camera.ts

@@ -31,8 +31,8 @@ export class ReolinkNativeCamera extends CommonCameraMixin {
 
 
     constructor(
-        nativeId: string, 
-        public plugin: ReolinkNativePlugin, 
+        nativeId: string,
+        public plugin: ReolinkNativePlugin,
         nvrDevice?: ReolinkNativeNvrDevice,
         multiFocalDevice?: ReolinkNativeMultiFocalDevice
     ) {
@@ -67,27 +67,6 @@ export class ReolinkNativeCamera extends CommonCameraMixin {
         }
     }
 
-    async withBaichuanRetry<T>(fn: () => Promise<T>): Promise<T> {
-        try {
-            return await fn();
-        }
-        catch (e) {
-            if (!this.isRecoverableBaichuanError(e)) {
-                throw e;
-            }
-
-            // Reset client and clear cache on recoverable error
-            await this.resetBaichuanClient(e);
-
-            // Important: callers must re-acquire the client inside fn.
-            try {
-                return await fn();
-            } catch (retryError) {
-                throw retryError;
-            }
-        }
-    }
-
 
     async init() {
         this.startPeriodicTasks();
@@ -97,6 +76,7 @@ export class ReolinkNativeCamera extends CommonCameraMixin {
 
     async createStreamClient(): Promise<ReolinkBaichuanApi> {
         const { ipAddress, username, password } = this.storageSettings.values;
+        const logger = this.getBaichuanLogger();
 
         const debugOptions = this.getBaichuanDebugOptions();
         const api = await createBaichuanApi(
@@ -105,11 +85,10 @@ export class ReolinkNativeCamera extends CommonCameraMixin {
                     host: ipAddress,
                     username: username,
                     password: password,
-                    logger: this.console,
+                    logger,
                     debugOptions
                 },
                 transport: 'tcp',
-                logger: this.console,
             },
         );
         await api.login();

package/src/common.ts

@@ -1,14 +1,15 @@
 import type { DeviceCapabilities, PtzCommand, PtzPreset, ReolinkBaichuanApi, ReolinkSimpleEvent, ReolinkSupportedStream, StreamSamplingSelection } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
 import sdk, { BinarySensor, Brightness, Camera, Device, DeviceProvider, Intercom, MediaObject, MediaStreamUrl, ObjectDetectionTypes, ObjectDetector, ObjectsDetected, OnOff, PanTiltZoom, PanTiltZoomCommand, RequestMediaStreamOptions, ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, ScryptedMimeTypes, Setting, Settings, SettingValue, VideoCamera, VideoTextOverlay, VideoTextOverlays } from "@scrypted/sdk";
 import { StorageSettings } from "@scrypted/sdk/storage-settings";
+import path from 'path';
 import type { UrlMediaStreamOptions } from "../../scrypted/plugins/rtsp/src/rtsp";
 import { BaseBaichuanClass, type BaichuanConnectionCallbacks, type BaichuanConnectionConfig } from "./baichuan-base";
 import { normalizeUid, type BaichuanTransport } from "./connect";
 import { convertDebugLogsToApiOptions, DebugLogDisplayNames, DebugLogOption, getApiRelevantDebugLogs, getDebugLogChoices } from "./debug-options";
 import { ReolinkBaichuanIntercom } from "./intercom";
 import ReolinkNativePlugin from "./main";
-import { ReolinkNativeNvrDevice } from "./nvr";
 import { ReolinkNativeMultiFocalDevice } from "./multiFocal";
+import { ReolinkNativeNvrDevice } from "./nvr";
 import { ReolinkPtzPresets } from "./presets";
 import {
     createRfc4571MediaObjectFromStreamManager,
@@ -17,10 +18,9 @@ import {
     selectStreamOption,
     StreamManager
 } from "./stream-utils";
-import { getDeviceInterfaces, updateDeviceInfo } from "./utils";
-import path from 'path';
+import { floodlightSuffix, getDeviceInterfaces, pirSuffix, sirenSuffix, updateDeviceInfo } from "./utils";
 
-export type CameraType = 'battery' | 'regular';
+export type CameraType = 'battery' | 'regular' | 'multi-focal' | 'multi-focal-battery';
 
 export interface CommonCameraMixinOptions {
     type: CameraType;
@@ -197,6 +197,12 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 await this.credentialsChanged();
             }
         },
+        debugEvents: {
+            title: 'Debug Events',
+            type: 'boolean',
+            immediate: true,
+            hide: true,
+        },
         username: {
             type: 'string',
             title: 'Username',
@@ -220,7 +226,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             json: true,
             hide: true,
         },
-        operationChannels: {
+        multifocalInfo: {
             json: true,
             hide: true,
         },
@@ -515,7 +521,6 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     // Abstract init method that subclasses must implement
     abstract init(): Promise<void>;
 
-    abstract withBaichuanRetry<T>(fn: () => Promise<T>): Promise<T>;
     protected withBaichuanClient?<T>(fn: (api: ReolinkBaichuanApi) => Promise<T>): Promise<T>;
     motionTimeout?: NodeJS.Timeout;
     doorbellBinaryTimeout?: NodeJS.Timeout;
@@ -532,13 +537,15 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         public options: CommonCameraMixinOptions
     ) {
         super(nativeId);
-        this.protocol = !options.nvrDevice && !options.multiFocalDevice && options.type === 'battery' ? 'udp' : 'tcp';
 
         // Store NVR device reference if provided
         this.nvrDevice = options.nvrDevice;
         this.multiFocalDevice = options.multiFocalDevice;
         this.thisDevice = sdk.systemManager.getDeviceById<Settings>(this.id);
 
+        const isBattery = options.type === 'battery' || options.type === 'multi-focal-battery';
+        this.protocol = isBattery ? 'udp' : 'tcp';
+
         setTimeout(async () => {
             await this.parentInit();
         }, 2000);
@@ -601,7 +608,31 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         return this.name || 'Camera';
     }
 
-    private async runDiagnostics(): Promise<void> {
+    async withBaichuanRetry<T>(fn: () => Promise<T>): Promise<T> {
+        if (this.protocol === 'udp') {
+            return await fn();
+        } else {
+            try {
+                return await fn();
+            } catch (e) {
+                if (!this.isRecoverableBaichuanError(e)) {
+                    throw e;
+                }
+
+                // Reset client and clear cache on recoverable error
+                await this.resetBaichuanClient(e);
+
+                // Important: callers must re-acquire the client inside fn.
+                try {
+                    return await fn();
+                } catch (retryError) {
+                    throw retryError;
+                }
+            }
+        }
+    }
+
+    async runDiagnostics(): Promise<void> {
         const logger = this.getBaichuanLogger();
         const outputPath = this.storageSettings.values.diagnosticsOutputPath || process.env.SCRYPTED_PLUGIN_VOLUME || "";
 
@@ -654,8 +685,8 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     }
 
     public getAbilities(): DeviceCapabilities {
-        if (this.options.multiFocalDevice) {
-            return this.options.multiFocalDevice.getInterfaces(this.storageSettings.values.rtspChannel).capabilities;
+        if (this.multiFocalDevice) {
+            return this.multiFocalDevice.getInterfaces(this.storageSettings.values.rtspChannel).capabilities;
         } else {
             return this.storageSettings.values.capabilities;
         }
@@ -690,9 +721,7 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
 
     // Event subscription methods
     unsubscribedToEvents(): void {
-        // Use base class unsubscribe
         this.unsubscribeFromEvents().catch(() => {
-            // ignore
         });
 
         if (this.motionDetected) {
@@ -1024,20 +1053,17 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         this.binaryState = false;
     }
 
-    // Report devices (siren, floodlight, PIR)
     async reportDevices(): Promise<void> {
-        if (!this.nativeId || !this.name) {
-            return;
-        }
+        const abilities = this.getAbilities();
 
-        const { hasSiren, hasFloodlight, hasPir } = this.getAbilities();
+        const { hasSiren, hasFloodlight, hasPir } = abilities;
 
         const devices: Device[] = [];
 
         if (hasSiren) {
-            const sirenNativeId = `${this.nativeId}-siren`;
+            const sirenNativeId = `${this.nativeId}${sirenSuffix}`;
             devices.push({
-                providerNativeId: this.plugin?.nativeId,
+                providerNativeId: this.nativeId,
                 name: `${this.name} Siren`,
                 nativeId: sirenNativeId,
                 info: {
@@ -1049,9 +1075,9 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         }
 
         if (hasFloodlight) {
-            const floodlightNativeId = `${this.nativeId}-floodlight`;
+            const floodlightNativeId = `${this.nativeId}${floodlightSuffix}`;
             devices.push({
-                providerNativeId: this.plugin?.nativeId,
+                providerNativeId: this.nativeId,
                 name: `${this.name} Floodlight`,
                 nativeId: floodlightNativeId,
                 info: {
@@ -1063,9 +1089,9 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         }
 
         if (hasPir) {
-            const pirNativeId = `${this.nativeId}-pir`;
+            const pirNativeId = `${this.nativeId}${pirSuffix}`;
             devices.push({
-                providerNativeId: this.plugin?.nativeId,
+                providerNativeId: this.nativeId,
                 name: `${this.name} PIR`,
                 nativeId: pirNativeId,
                 info: {
@@ -1116,8 +1142,8 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
     async updateDeviceInfo(): Promise<void> {
         const logger = this.getBaichuanLogger();
 
-        if (this.options.multiFocalDevice) {
-            this.info = this.options.multiFocalDevice.info;
+        if (this.multiFocalDevice) {
+            this.info = this.multiFocalDevice.info;
             return;
         }
 
@@ -1130,9 +1156,9 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
                 device: this,
                 ipAddress,
                 deviceData,
+                logger,
             });
 
-            logger.log(`Device info updated: ${JSON.stringify(deviceData)}`);
         } catch (e) {
             logger.warn('Failed to fetch device info', e);
         }
@@ -1140,24 +1166,24 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
 
     // Device provider methods
     async getDevice(nativeId: string): Promise<any> {
-        if (nativeId.endsWith('-siren')) {
+        if (nativeId.endsWith(sirenSuffix)) {
             this.siren ||= new ReolinkCameraSiren(this, nativeId);
             return this.siren;
-        } else if (nativeId.endsWith('-floodlight')) {
+        } else if (nativeId.endsWith(floodlightSuffix)) {
             this.floodlight ||= new ReolinkCameraFloodlight(this, nativeId);
             return this.floodlight;
-        } else if (nativeId.endsWith('-pir')) {
+        } else if (nativeId.endsWith(pirSuffix)) {
             this.pirSensor ||= new ReolinkCameraPirSensor(this, nativeId);
             return this.pirSensor;
         }
     }
 
     async releaseDevice(id: string, nativeId: string): Promise<void> {
-        if (nativeId.endsWith('-siren')) {
+        if (nativeId.endsWith(sirenSuffix)) {
             this.siren = undefined;
-        } else if (nativeId.endsWith('-floodlight')) {
+        } else if (nativeId.endsWith(floodlightSuffix)) {
             this.floodlight = undefined;
-        } else if (nativeId.endsWith('-pir')) {
+        } else if (nativeId.endsWith(pirSuffix)) {
             this.pirSensor = undefined;
         }
     }
@@ -1357,7 +1383,8 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         }
 
         if (streams.length) {
-            logger.log('Fetched video stream options', { streams });
+            logger.log('Fetched video stream options', streams.map((s) => s.name).join(', '));
+            logger.debug(JSON.stringify(streams));
             this.cachedVideoStreamOptions = streams;
             return streams;
         }
@@ -1451,41 +1478,41 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
         const channel = this.storageSettings.values.rtspChannel;
 
         try {
-            if (this.options.multiFocalDevice) {
-                // do nothing for now
-            } else {
-                const { capabilities, abilities, support, presets, objects } = await this.withBaichuanRetry(async () => {
-                    const api = await this.ensureClient();
-                    return await api.getDeviceCapabilities(channel);
+            const { capabilities, abilities, support, presets, objects } = await this.withBaichuanRetry(async () => {
+                const api = await this.ensureClient();
+                return await api.getDeviceCapabilities(channel);
+            });
+            this.classes = objects;
+            this.presets = presets;
+            this.ptzPresets.setCachedPtzPresets(presets);
+
+            try {
+                const { interfaces, type } = getDeviceInterfaces({
+                    capabilities,
+                    logger: this.console,
                 });
-                this.classes = objects;
-                this.presets = presets;
-                this.ptzPresets.setCachedPtzPresets(presets);
 
-                try {
-                    const { interfaces, type } = getDeviceInterfaces({
-                        capabilities,
-                        logger: this.console,
-                    });
-
-                    const device: Device = {
-                        nativeId: this.nativeId,
-                        providerNativeId: this.nvrDevice?.nativeId ?? this.plugin?.nativeId,
-                        name: this.name,
-                        interfaces,
-                        type,
-                        info: this.info,
-                    };
-
-                    logger.log(`Updating device interfaces: ${JSON.stringify(device)}`);
-
-                    await sdk.deviceManager.onDeviceDiscovered(device);
-                } catch (e) {
-                    logger.error('Failed to update device interfaces', e);
-                }
+                const device: Device = {
+                    nativeId: this.nativeId,
+                    providerNativeId: this.nvrDevice?.nativeId ??
+                        this.multiFocalDevice?.nativeId ??
+                        this.plugin?.nativeId,
+                    name: this.name,
+                    interfaces,
+                    type,
+                    info: this.info,
+                };
+
+                await sdk.deviceManager.onDeviceDiscovered(device);
 
-                logger.log(`Refreshed device capabilities: ${JSON.stringify({ capabilities, abilities, support, presets })}`);
+                logger.log(`Device interfaces updated`);
+                logger.debug(`${JSON.stringify(device)}`);
+            } catch (e) {
+                logger.error('Failed to update device interfaces', e);
             }
+
+            logger.log(`Refreshed device capabilities: ${JSON.stringify(capabilities)}`);
+            logger.debug(`Refreshed device capabilities: ${JSON.stringify({ abilities, support, presets, objects })}`);
         }
         catch (e) {
             logger.error('Failed to refresh abilities', e);
@@ -1505,65 +1532,28 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             logger.warn('Failed to update device info during init', e);
         }
 
-        try {
-            await this.refreshDeviceState();
-        }
-        catch (e) {
-            logger.warn('Failed to connect/refresh during init', e);
-        }
-
-        try {
-            await this.reportDevices();
-        }
-        catch (e) {
-            logger.warn('Failed to report devices during init', e);
-        }
-
-        const { hasIntercom, hasPtz } = this.getAbilities();
-
-        if (hasIntercom) {
-            this.intercom = new ReolinkBaichuanIntercom(this);
-        }
-
-        if (hasPtz) {
-            const choices = (this.presets || []).map((preset: any) => preset.id + '=' + preset.name);
-
-            this.storageSettings.settings.presets.choices = choices;
-            this.storageSettings.settings.ptzSelectedPreset.choices = choices;
-
-            this.storageSettings.settings.presets.hide = false;
-            this.storageSettings.settings.ptzMoveDurationMs.hide = false;
-            this.storageSettings.settings.ptzZoomStep.hide = false;
-            this.storageSettings.settings.ptzCreatePreset.hide = false;
-            this.storageSettings.settings.ptzSelectedPreset.hide = false;
-            this.storageSettings.settings.ptzUpdateSelectedPreset.hide = false;
-            this.storageSettings.settings.ptzDeleteSelectedPreset.hide = false;
-
-            this.updatePtzCaps();
+        if (!this.multiFocalDevice) {
+            try {
+                await this.refreshDeviceState();
+                await this.reportDevices();
+            }
+            catch (e) {
+                logger.warn('Failed to connect/refresh during init', e);
+            }
         }
 
-        const isBattery = this.options.type === 'battery';
         const { username, password } = this.storageSettings.values;
+        const isCamera = this.options.type === 'regular' || this.options.type === 'battery';
+        const isBatteryCamera = this.options.type === 'battery';
+        const isBatteryMultiFocal = this.options.type === 'multi-focal-battery';
+        const isBattery = isBatteryCamera || isBatteryMultiFocal;
 
-        this.streamManager = new StreamManager({
-            createStreamClient: () => this.createStreamClient(),
-            getLogger: () => logger as Console,
-            credentials: {
-                username,
-                password
-            },
-            // For battery cameras, we use a shared connection
-            sharedConnection: isBattery,
-        });
-
-
-        // this.storageSettings.settings.snapshotCacheMinutes.hide = !isBattery;
         this.storageSettings.settings.uid.hide = !isBattery;
         this.storageSettings.settings.batteryUpdateIntervalMinutes.hide = !isBattery;
         this.storageSettings.settings.lowThresholdBatteryRecording.hide = !isBattery;
         this.storageSettings.settings.highThresholdBatteryRecording.hide = !isBattery;
 
-        if (isBattery && !this.storageSettings.values.mixinsSetup) {
+        if (isBatteryCamera && !this.storageSettings.values.mixinsSetup) {
             try {
                 const device = sdk.systemManager.getDeviceById<Settings>(this.id);
                 if (device) {
@@ -1585,30 +1575,54 @@ export abstract class CommonCameraMixin extends BaseBaichuanClass implements Vid
             logger.warn('Failed to subscribe to Baichuan events', e);
         }
 
+        if (isCamera) {
+            this.streamManager = new StreamManager({
+                createStreamClient: () => this.createStreamClient(),
+                getLogger: () => logger as Console,
+                credentials: {
+                    username,
+                    password
+                },
+                sharedConnection: isBattery,
+            });
+
+            const { hasIntercom, hasPtz } = this.getAbilities();
 
-        if (this.nvrDevice) {
-            this.storageSettings.settings.username.hide = true;
-            this.storageSettings.settings.password.hide = true;
-            this.storageSettings.settings.ipAddress.hide = true;
-            this.storageSettings.settings.uid.hide = true;
+            if (hasIntercom) {
+                this.intercom = new ReolinkBaichuanIntercom(this);
+            }
 
-            this.storageSettings.settings.username.defaultValue = this.nvrDevice.storageSettings.values.username;
-            this.storageSettings.settings.password.defaultValue = this.nvrDevice.storageSettings.values.password;
-            this.storageSettings.settings.ipAddress.defaultValue = this.nvrDevice.storageSettings.values.ipAddress;
+            if (hasPtz) {
+                const choices = (this.presets || []).map((preset: any) => preset.id + '=' + preset.name);
+
+                this.storageSettings.settings.presets.choices = choices;
+                this.storageSettings.settings.ptzSelectedPreset.choices = choices;
+
+                this.storageSettings.settings.presets.hide = false;
+                this.storageSettings.settings.ptzMoveDurationMs.hide = false;
+                this.storageSettings.settings.ptzZoomStep.hide = false;
+                this.storageSettings.settings.ptzCreatePreset.hide = false;
+                this.storageSettings.settings.ptzSelectedPreset.hide = false;
+                this.storageSettings.settings.ptzUpdateSelectedPreset.hide = false;
+                this.storageSettings.settings.ptzDeleteSelectedPreset.hide = false;
+
+                this.updatePtzCaps();
+            }
         }
 
-        if (this.multiFocalDevice) {
+        if (this.nvrDevice || this.multiFocalDevice) {
             this.storageSettings.settings.username.hide = true;
             this.storageSettings.settings.password.hide = true;
             this.storageSettings.settings.ipAddress.hide = true;
             this.storageSettings.settings.uid.hide = true;
 
-            this.storageSettings.settings.username.defaultValue = this.multiFocalDevice.storageSettings.values.username;
-            this.storageSettings.settings.password.defaultValue = this.multiFocalDevice.storageSettings.values.password;
-            this.storageSettings.settings.ipAddress.defaultValue = this.multiFocalDevice.storageSettings.values.ipAddress;
+            this.storageSettings.settings.username.defaultValue = this.nvrDevice.storageSettings.values.username;
+            this.storageSettings.settings.password.defaultValue = this.nvrDevice.storageSettings.values.password;
+            this.storageSettings.settings.ipAddress.defaultValue = this.nvrDevice.storageSettings.values.ipAddress;
         }
 
         await this.init();
+
         this.initComplete = true;
     }
 }

package/src/connect.ts

@@ -19,16 +19,16 @@ export function normalizeUid(uid?: string): string | undefined {
 export async function createBaichuanApi(props: {
     inputs: BaichuanConnectInputs,
     transport: BaichuanTransport,
-    logger: Console,
 }): Promise<ReolinkBaichuanApi> {
-    const { inputs, transport, logger } = props;
+    const { inputs, transport } = props;
+    const { logger } = inputs;
     const { ReolinkBaichuanApi } = await import("@apocaliss92/reolink-baichuan-js");
 
     const base: BaichuanClientOptions = {
         host: inputs.host,
         username: inputs.username,
         password: inputs.password,
-        logger: logger, // Use the logger passed to createBaichuanApi, not inputs.logger
+        logger,
         debugOptions: inputs.debugOptions ?? {}
     };