@apocaliss92/scrypted-reolink-native 0.0.4 → 0.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@apocaliss92/scrypted-reolink-native",
-   "version": "0.0.4",
+   "version": "0.0.6",
    "description": "Reolink Native plugin for Scrypted",
    "author": "@apocaliss92",
    "license": "Apache",

package/src/camera.ts

@@ -2,7 +2,7 @@ import type { BatteryInfo, DebugOptions, DeviceCapabilities, PtzCommand, Reolink
 import sdk, { BinarySensor, Brightness, Camera, Device, DeviceProvider, Intercom, MediaObject, ObjectDetectionTypes, ObjectDetector, ObjectsDetected, OnOff, PanTiltZoom, PanTiltZoomCommand, RequestMediaStreamOptions, RequestPictureOptions, ResponseMediaStreamOptions, ResponsePictureOptions, ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, Setting, Settings, Sleep, VideoCamera, VideoTextOverlay, VideoTextOverlays } from "@scrypted/sdk";
 import { StorageSettings } from '@scrypted/sdk/storage-settings';
 import { UrlMediaStreamOptions } from "../../scrypted/plugins/rtsp/src/rtsp";
-import { BaichuanTransport, connectBaichuanWithTcpUdpFallback, createBaichuanApi, maskUid } from './connect';
+import { createBaichuanApi, maskUid, normalizeUid, type BaichuanTransport } from './connect';
 import { ReolinkBaichuanIntercom } from "./intercom";
 import ReolinkNativePlugin from "./main";
 import { ReolinkPtzPresets } from "./presets";
@@ -166,6 +166,7 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
     floodlight: ReolinkCameraFloodlight;
     pirSensor: ReolinkCameraPirSensor;
     private baichuanApi: ReolinkBaichuanApi | undefined;
+    private ensureClientPromise: Promise<ReolinkBaichuanApi> | undefined;
     private connectionTime: number | undefined;
     private refreshingState = false;
 
@@ -176,7 +177,7 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
     private lastSnapshotTaken: number | undefined;
     private streamManager: StreamManager;
 
-    private udpFallbackAlerted = false;
+    private uidMissingAlerted = false;
 
     private intercom: ReolinkBaichuanIntercom;
 
@@ -230,7 +231,7 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
             combobox: true,
             immediate: true,
             defaultValue: [],
-            choices: ['enabled', 'debugRtsp', 'traceStream', 'traceTalk', 'debugH264', 'debugParamSets', 'eventLogs'],
+            choices: ['enabled', 'debugRtsp', 'traceStream', 'traceTalk', 'traceEvents', 'debugH264', 'debugParamSets', 'eventLogs'],
             onPut: async (ov, value) => {
                 // Only reconnect if Baichuan-client flags changed; toggling event logs should be immediate.
                 const oldSel = new Set(ov);
@@ -238,7 +239,7 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
                 oldSel.delete('eventLogs');
                 newSel.delete('eventLogs');
 
-                const changed = oldSel.size !== newSel.size;
+                const changed = oldSel.size !== newSel.size || Array.from(oldSel).some((k) => !newSel.has(k));
                 if (changed) {
                     await this.resetBaichuanClient('debugLogs changed');
                 }
@@ -458,6 +459,7 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
         finally {
             this.baichuanApi = undefined;
             this.connectionTime = undefined;
+            this.ensureClientPromise = undefined;
         }
 
         if (reason) {
@@ -517,72 +519,73 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
     }
 
     async ensureClient(): Promise<ReolinkBaichuanApi> {
-        if (this.baichuanApi && this.baichuanApi.client.loggedIn) {
-            return this.baichuanApi;
-        }
+        if (this.baichuanApi && this.baichuanApi.client.loggedIn) return this.baichuanApi;
 
-        const { ipAddress, username, password, uid, useUdp } = this.storageSettings.values;
+        // Prevent concurrent login storms. Multiple callers (init, options queries, refresh, events)
+        // may race here and otherwise create multiple Baichuan sessions in parallel.
+        if (this.ensureClientPromise) return await this.ensureClientPromise;
 
-        if (!ipAddress || !username || !password) {
-            throw new Error('Missing camera credentials');
-        }
+        this.ensureClientPromise = (async () => {
+            if (this.baichuanApi && this.baichuanApi.client.loggedIn) return this.baichuanApi;
 
-        if (this.baichuanApi) {
-            await this.baichuanApi.close();
-        }
+            const { ipAddress, username, password, uid } = this.storageSettings.values;
 
-        const debugOptions = this.getBaichuanDebugOptions();
+            if (!ipAddress || !username || !password) {
+                throw new Error('Missing camera credentials');
+            }
+
+            if (this.baichuanApi) {
+                await this.baichuanApi.close();
+            }
+
+            const debugOptions = this.getBaichuanDebugOptions();
+
+            // Transport selection is deterministic: battery cameras use UDP/BCUDP, others use TCP.
+            // No automatic fallback between transports.
+            const isBattery = this.hasBattery();
+            const transport: BaichuanTransport = isBattery ? 'udp' : 'tcp';
+            const normalizedUid = normalizeUid(uid);
+
+            if (transport === 'udp' && !normalizedUid) {
+                if (!this.uidMissingAlerted) {
+                    this.uidMissingAlerted = true;
+                    this.log.a(
+                        `Battery camera ${this.name} (${ipAddress}) requires Reolink UID for UDP/BCUDP. Please set the UID in settings.`,
+                    );
+                }
+                throw new Error('UID is required for battery cameras (BCUDP)');
+            }
+
+            if (transport === 'udp') {
+                this.getLogger().log(
+                    `Connecting via UDP/BCUDP (battery detected, uid=${normalizedUid ? maskUid(normalizedUid) : 'missing'})`,
+                );
+            }
 
-        // Se useUdp è impostato, usa direttamente UDP senza provare TCP
-        if (useUdp) {
-            this.getLogger().log(`Using UDP transport directly (useUdp=${useUdp})`);
             const api = await createBaichuanApi(
                 {
                     host: ipAddress,
                     username,
                     password,
-                    uid,
+                    uid: normalizedUid,
                     logger: this.console,
                     ...(debugOptions ? { debugOptions } : {}),
                 },
-                'udp',
+                transport,
             );
             await api.login();
             this.baichuanApi = api;
             this.connectionTime = Date.now();
             return api;
-        }
+        })();
 
-        // Altrimenti prova TCP con fallback a UDP
-        const { api, transport } = await connectBaichuanWithTcpUdpFallback(
-            {
-                host: ipAddress,
-                username,
-                password,
-                uid,
-                logger: this.console,
-                ...(debugOptions ? { debugOptions } : {}),
-            },
-            ({ uid: normalizedUid, uidMissing }) => {
-                const uidMsg = !uidMissing && normalizedUid ? `UID ${maskUid(normalizedUid)}` : 'UID MISSING';
-                if (!this.udpFallbackAlerted) {
-                    this.udpFallbackAlerted = true;
-                    this.log.a(
-                        `Baichuan TCP failed for camera ${this.name} (${ipAddress}). This appears to be a battery camera: UID is required and UDP/BCUDP will be used (${uidMsg}).`,
-                    );
-                }
-            },
-        );
-
-        // Se il fallback ha usato UDP, salva la setting per usare sempre UDP in futuro
-        if (transport === 'udp') {
-            await this.storageSettings.putSetting('useUdp', 'true');
-            this.getLogger().log(`TCP fallback to UDP detected. Saving useUdp setting for future connections.`);
+        try {
+            return await this.ensureClientPromise;
+        }
+        finally {
+            // Allow future reconnects (e.g. after close/reset) and avoid pinning rejected promises.
+            this.ensureClientPromise = undefined;
         }
-
-        this.baichuanApi = api;
-        this.connectionTime = Date.now();
-        return api;
     }
 
     private getBaichuanDebugOptions(): any | undefined {
@@ -591,7 +594,7 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
 
         const debugOptions: DebugOptions = {};
         // Only pass through Baichuan client debug flags.
-        const clientKeys = new Set(['enabled', 'debugRtsp', 'traceStream', 'traceTalk', 'debugH264', 'debugParamSets']);
+        const clientKeys = new Set(['enabled', 'debugRtsp', 'traceStream', 'traceTalk', 'traceEvents', 'debugH264', 'debugParamSets']);
         for (const k of sel) {
             if (!clientKeys.has(k)) continue;
             debugOptions[k] = true;
@@ -600,17 +603,22 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
     }
 
     private async createStreamClient(): Promise<ReolinkBaichuanApi> {
-        const { ipAddress, username, password, uid, useUdp } = this.storageSettings.values;
+        const { ipAddress, username, password, uid } = this.storageSettings.values;
         if (!ipAddress || !username || !password) {
             throw new Error('Missing camera credentials');
         }
 
-        // Usa la setting useUdp per determinare il transport invece di ottenere dal client primario
-        // Questo garantisce che lo stream client usi lo stesso transport del client principale
-        const transport: BaichuanTransport = useUdp ? 'udp' : 'tcp';
-
-        if (useUdp) {
-            this.getLogger().log(`Creating stream client with UDP transport (useUdp=${useUdp})`);
+        const isBattery = this.hasBattery();
+        const transport: BaichuanTransport = isBattery ? 'udp' : 'tcp';
+        const normalizedUid = normalizeUid(uid);
+        if (transport === 'udp' && !normalizedUid) {
+            if (!this.uidMissingAlerted) {
+                this.uidMissingAlerted = true;
+                this.log.a(
+                    `Battery camera ${this.name} (${ipAddress}) requires Reolink UID for UDP/BCUDP. Please set the UID in settings.`,
+                );
+            }
+            throw new Error('UID is required for battery cameras (BCUDP)');
         }
 
         const debugOptions = this.getBaichuanDebugOptions();
@@ -619,7 +627,7 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
                 host: ipAddress,
                 username,
                 password,
-                uid,
+                uid: normalizedUid,
                 logger: this.console,
                 ...(debugOptions ? { debugOptions } : {}),
             },
@@ -654,7 +662,7 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
 
 
             try {
-                const interfaces = getDeviceInterfaces({
+                const { interfaces, type } = getDeviceInterfaces({
                     capabilities,
                     logger: this.console,
                 });
@@ -664,7 +672,7 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
                     providerNativeId: this.plugin.nativeId,
                     name: this.name,
                     interfaces,
-                    type: this.type as ScryptedDeviceType,
+                    type,
                     info: this.info,
                 };
 
@@ -708,12 +716,13 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
                     motion = this.shouldDispatchMotion();
                     break;
                 case 'doorbell':
-                    this.binaryState = true;
-                    if (this.doorbellBinaryTimeout) clearTimeout(this.doorbellBinaryTimeout);
-                    this.doorbellBinaryTimeout = setTimeout(() => {
-                        this.binaryState = false;
-                        this.doorbellBinaryTimeout = undefined;
-                    }, 2000);
+                    if (!this.doorbellBinaryTimeout) {
+                        this.binaryState = true;
+                        this.doorbellBinaryTimeout = setTimeout(() => {
+                            this.binaryState = false;
+                            this.doorbellBinaryTimeout = undefined;
+                        }, 2000);
+                    }
 
                     motion = this.shouldDispatchMotion();
                     break;

package/src/main.ts

@@ -54,11 +54,10 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
                 this.console.log(JSON.stringify({ abilities, capabilities, deviceInfo }));
 
                 nativeId = deviceInfo.serialNumber;
-                const type = capabilities.isDoorbell ? ScryptedDeviceType.DataSource : ScryptedDeviceType.Camera;
 
                 settings.newCamera ||= name;
 
-                const interfaces = getDeviceInterfaces({
+                const { interfaces, type } = getDeviceInterfaces({
                     capabilities,
                     logger: this.console,
                 });

package/src/utils.ts

@@ -1,5 +1,5 @@
 import type { DeviceCapabilities } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
-import { ScryptedInterface } from "@scrypted/sdk";
+import { ScryptedDeviceType, ScryptedInterface } from "@scrypted/sdk";
 
 export const getDeviceInterfaces = (props: {
     capabilities: DeviceCapabilities,
@@ -48,5 +48,5 @@ export const getDeviceInterfaces = (props: {
         logger.error('Error getting device interfaces', e);
     }
 
-    return interfaces;
+    return { interfaces, type: capabilities.isDoorbell ? ScryptedDeviceType.Doorbell : ScryptedDeviceType.Camera };
 }