@apocaliss92/scrypted-reolink-native 0.0.1 → 0.0.3

package/package.json

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

package/src/camera.ts

@@ -7,6 +7,7 @@ import { ReolinkBaichuanIntercom } from "./intercom";
 import ReolinkNativePlugin from "./main";
 import { ReolinkPtzPresets } from "./presets";
 import { parseStreamProfileFromId, StreamManager } from './stream-utils';
+import { connectBaichuanWithTcpUdpFallback, createBaichuanApi, maskUid } from './connect';
 
 export const moToB64 = async (mo: MediaObject) => {
     const bufferImage = await sdk.mediaManager.convertMediaObjectToBuffer(mo, 'image/jpeg');
@@ -164,8 +165,7 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
     floodlight: ReolinkCameraFloodlight;
     pirSensor: ReolinkCameraPirSensor;
     private baichuanApi: ReolinkBaichuanApi | undefined;
-    private baichuanInitPromise: Promise<ReolinkBaichuanApi> | undefined;
-    private refreshDeviceStatePromise: Promise<void> | undefined;
+    private refreshingState = false;
 
     private subscribedToEvents = false;
     private onSimpleEvent: ((ev: ReolinkSimpleEvent) => void) | undefined;
@@ -179,6 +179,8 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
     private lastSnapshotTaken: number | undefined;
     private streamManager: StreamManager;
 
+    private udpFallbackAlerted = false;
+
     private dispatchEventsApplyTimer: NodeJS.Timeout | undefined;
     private dispatchEventsApplySeq = 0;
 
@@ -195,6 +197,11 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
             title: 'IP Address',
             type: 'string',
         },
+        uid: {
+            title: 'UID',
+            description: 'Reolink UID (required for battery cameras / BCUDP).',
+            type: 'string',
+        },
         username: {
             type: 'string',
             title: 'Username',
@@ -462,7 +469,6 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
                 }
             }
             this.baichuanApi = undefined;
-            this.baichuanInitPromise = undefined;
             this.subscribedToEvents = false;
             this.eventsApi = undefined;
         }
@@ -494,9 +500,6 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
     async init() {
         const logger = this.getLogger();
 
-        // Migrate older boolean value to the new multi-select format.
-        this.migrateDispatchEventsSetting();
-
         // Initialize Baichuan API
         await this.ensureClient();
 
@@ -507,21 +510,6 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
         this.updateDeviceInfo();
         this.updatePtzCaps();
 
-        const interfaces = await this.getDeviceInterfaces();
-
-        const device: Device = {
-            nativeId: this.nativeId,
-            providerNativeId: this.plugin.nativeId,
-            name: this.name,
-            interfaces,
-            type: this.type as ScryptedDeviceType,
-            info: this.info,
-        };
-
-        logger.log(`Updating device interfaces: ${JSON.stringify(interfaces)}`);
-
-        await sdk.deviceManager.onDeviceDiscovered(device);
-
         // Start event subscription after discovery.
         try {
             if (this.isEventDispatchEnabled()) {
@@ -544,65 +532,67 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
     }
 
     async ensureClient(): Promise<ReolinkBaichuanApi> {
-        if (this.baichuanInitPromise) {
-            return this.baichuanInitPromise;
-        }
-
         if (this.baichuanApi && this.baichuanApi.client.loggedIn) {
             return this.baichuanApi;
         }
 
-        const { ipAddress, username, password } = this.storageSettings.values;
+        const { ipAddress, username, password, uid } = this.storageSettings.values;
 
         if (!ipAddress || !username || !password) {
             throw new Error('Missing camera credentials');
         }
 
-        this.baichuanInitPromise = (async () => {
-            if (this.baichuanApi) {
-                await this.baichuanApi.close();
-            }
+        if (this.baichuanApi) {
+            await this.baichuanApi.close();
+        }
 
-            const { ReolinkBaichuanApi } = await import("@apocaliss92/reolink-baichuan-js");
-            const debugOptions = this.getBaichuanDebugOptions();
-            this.baichuanApi = new ReolinkBaichuanApi({
+        const debugOptions = this.getBaichuanDebugOptions();
+        const { api } = await connectBaichuanWithTcpUdpFallback(
+            {
                 host: ipAddress,
                 username,
                 password,
+                uid,
                 logger: this.console,
                 ...(debugOptions ? { debugOptions } : {}),
-            });
-
-            await this.baichuanApi.login();
-            return this.baichuanApi;
-        })();
+            },
+            ({ 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}).`,
+                    );
+                }
+            },
+        );
 
-        try {
-            return await this.baichuanInitPromise;
-        }
-        finally {
-            // If login failed, allow future retries.
-            if (!this.baichuanApi?.client?.loggedIn) {
-                this.baichuanInitPromise = undefined;
-            }
-        }
+        this.baichuanApi = api;
+        return api;
     }
 
     private async createStreamClient(): Promise<ReolinkBaichuanApi> {
-        const { ipAddress, username, password } = this.storageSettings.values;
+        // Ensure the main client is initialized first so we know if this device needs UDP.
+        const primary = await this.ensureClient();
+        const transport = primary.client.getTransport();
+
+        const { ipAddress, username, password, uid } = this.storageSettings.values;
         if (!ipAddress || !username || !password) {
             throw new Error('Missing camera credentials');
         }
 
-        const { ReolinkBaichuanApi } = await import('@apocaliss92/reolink-baichuan-js');
         const debugOptions = this.getBaichuanDebugOptions();
-        const api = new ReolinkBaichuanApi({
-            host: ipAddress,
-            username,
-            password,
-            logger: this.console,
-            ...(debugOptions ? { debugOptions } : {}),
-        });
+        const api = await createBaichuanApi(
+            {
+                host: ipAddress,
+                username,
+                password,
+                uid,
+                logger: this.console,
+                ...(debugOptions ? { debugOptions } : {}),
+            },
+            transport,
+        );
         await api.login();
         return api;
     }
@@ -612,30 +602,52 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
     }
 
     private async refreshDeviceState(): Promise<void> {
-        if (this.refreshDeviceStatePromise) return this.refreshDeviceStatePromise;
+        if (this.refreshingState) {
+            return;
+        }
+        this.refreshingState = true;
 
-        this.refreshDeviceStatePromise = (async () => {
-            const logger = this.getLogger();
-            const api = await this.ensureClient();
-            const channel = this.getRtspChannel();
+        const logger = this.getLogger();
+        const api = await this.ensureClient();
+        const channel = this.getRtspChannel();
 
-            try {
-                const { capabilities, abilities, support, presets } = await api.getDeviceCapabilities(channel);
-                this.storageSettings.values.capabilities = capabilities;
-                this.ptzPresets.setCachedPtzPresets(presets);
-                this.console.log(`Refreshed device capabilities: ${JSON.stringify({ capabilities, abilities, support, presets })}`);
-            }
-            catch (e) {
-                logger.warn('Failed to refresh abilities', e);
-            }
+        try {
+            const { capabilities, abilities, support, presets } = await api.getDeviceCapabilities(channel);
+            this.storageSettings.values.capabilities = capabilities;
+            this.ptzPresets.setCachedPtzPresets(presets);
+            this.console.log(`Refreshed device capabilities: ${JSON.stringify({ capabilities, abilities, support, presets })}`);
+        }
+        catch (e) {
+            logger.error('Failed to refresh abilities', e);
+        }
 
-            // Best-effort status refreshes.
-            await this.refreshAuxDevicesStatus().catch(() => { });
-        })().finally(() => {
-            this.refreshDeviceStatePromise = undefined;
-        });
+        try {
+            await this.refreshAuxDevicesStatus();
+        }
+        catch (e) {
+            logger.error('Failed to refresh device status', e);
+        }
+
+        try {
+            const interfaces = await this.getDeviceInterfaces();
+
+            const device: Device = {
+                nativeId: this.nativeId,
+                providerNativeId: this.plugin.nativeId,
+                name: this.name,
+                interfaces,
+                type: this.type as ScryptedDeviceType,
+                info: this.info,
+            };
+
+            logger.log(`Updating device interfaces: ${JSON.stringify(interfaces)}`);
 
-        return this.refreshDeviceStatePromise;
+            await sdk.deviceManager.onDeviceDiscovered(device);
+        } catch (e) {
+            logger.error('Failed to update device interfaces', e);
+        }
+
+        this.refreshingState = false;
     }
 
     private async ensureBaichuanEventSubscription(): Promise<void> {
@@ -1088,6 +1100,11 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
         return Boolean(capabilities?.hasBattery);
     }
 
+    hasIntercom() {
+        const capabilities = this.getAbilities();
+        return Boolean(capabilities?.hasIntercom);
+    }
+
     getPtzCapabilities() {
         const capabilities = this.getAbilities();
         const hasZoom = Boolean(capabilities?.hasZoom);
@@ -1120,33 +1137,20 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
         ];
 
         try {
-            // Expose Intercom if the camera supports Baichuan talkback.
-            try {
-                const api = this.getClient();
-                if (api) {
-                    const ability = await api.getTalkAbility(this.getRtspChannel());
-                    if (Array.isArray((ability as any)?.audioConfigList) && (ability as any).audioConfigList.length > 0) {
-                        interfaces.push(ScryptedInterface.Intercom);
-                    }
-                }
-            }
-            catch {
-                // ignore: camera likely doesn't support talkback
-            }
-
             const { hasPtz } = this.getPtzCapabilities();
 
             if (hasPtz) {
                 interfaces.push(ScryptedInterface.PanTiltZoom);
             }
-            if ((await this.getObjectTypes()).classes.length > 0) {
-                interfaces.push(ScryptedInterface.ObjectDetector);
-            }
+            interfaces.push(ScryptedInterface.ObjectDetector);
             if (this.hasSiren() || this.hasFloodlight() || this.hasPirEvents())
                 interfaces.push(ScryptedInterface.DeviceProvider);
             if (this.hasBattery()) {
                 interfaces.push(ScryptedInterface.Battery, ScryptedInterface.Sleep);
             }
+            if (this.hasIntercom()) {
+                interfaces.push(ScryptedInterface.Intercom);
+            }
         } catch (e) {
             this.getLogger().error('Error getting device interfaces', e);
         }
@@ -1283,13 +1287,6 @@ export class ReolinkNativeCamera extends ScryptedDeviceBase implements VideoCame
         return this.getDispatchEventsSelection().has('objects');
     }
 
-    private migrateDispatchEventsSetting(): void {
-        const cur = (this.storageSettings.values as any).dispatchEvents;
-        if (typeof cur === 'boolean') {
-            (this.storageSettings.values as any).dispatchEvents = cur ? ['motion', 'objects'] : [];
-        }
-    }
-
     private scheduleApplyEventDispatchSettings(): void {
         // Debounce to avoid rapid apply loops while editing multi-select.
         this.dispatchEventsApplySeq++;

package/src/connect.ts

@@ -0,0 +1,146 @@
+import type { BaichuanClientOptions, ReolinkBaichuanApi } from "@apocaliss92/reolink-baichuan-js" with { "resolution-mode": "import" };
+
+export type BaichuanTransport = "tcp" | "udp";
+
+export type BaichuanConnectInputs = {
+    host: string;
+    username: string;
+    password: string;
+    uid?: string;
+    logger?: Console;
+    debugOptions?: unknown;
+};
+
+export function normalizeUid(uid?: string): string | undefined {
+    const v = uid?.trim();
+    return v ? v : undefined;
+}
+
+export function maskUid(uid: string): string {
+    const v = uid.trim();
+    if (v.length <= 8) return v;
+    return `${v.slice(0, 4)}…${v.slice(-4)}`;
+}
+
+export function isTcpFailureThatShouldFallbackToUdp(e: unknown): boolean {
+    const message = (e as any)?.message || (e as any)?.toString?.() || "";
+    if (typeof message !== "string") return false;
+
+    // Fallback only on transport/connection style failures.
+    // Wrong credentials won't be fixed by switching to UDP.
+    return (
+        message.includes("ECONNREFUSED") ||
+        message.includes("ETIMEDOUT") ||
+        message.includes("EHOSTUNREACH") ||
+        message.includes("ENETUNREACH") ||
+        message.includes("socket hang up") ||
+        message.includes("TCP connection timeout") ||
+        message.includes("Baichuan socket closed")
+    );
+}
+
+export async function createBaichuanApi(inputs: BaichuanConnectInputs, transport: BaichuanTransport): Promise<ReolinkBaichuanApi> {
+    const { ReolinkBaichuanApi } = await import("@apocaliss92/reolink-baichuan-js");
+
+    const base: BaichuanClientOptions = {
+        host: inputs.host,
+        username: inputs.username,
+        password: inputs.password,
+        logger: inputs.logger,
+        ...(inputs.debugOptions ? { debugOptions: inputs.debugOptions } : {}),
+    };
+
+    const attachErrorHandler = (api: ReolinkBaichuanApi) => {
+        // Critical: BaichuanClient emits 'error'. If nobody listens, Node treats it as an
+        // uncaught exception. Ensure we always have a listener.
+        try {
+            api.client.on("error", (err: unknown) => {
+                const logger = inputs.logger ?? console;
+                const msg = (err as any)?.message || (err as any)?.toString?.() || String(err);
+                logger.error(`[BaichuanClient] error (${transport}) ${inputs.host}: ${msg}`);
+            });
+        } catch {
+            // ignore
+        }
+    };
+
+    if (transport === "tcp") {
+        const api = new ReolinkBaichuanApi({
+            ...base,
+            keepAliveInterval: 10000,
+            tcpSocketKeepAlive: true,
+            transport: "tcp",
+        });
+        attachErrorHandler(api);
+        return api;
+    }
+
+    const uid = normalizeUid(inputs.uid);
+    if (!uid) {
+        throw new Error("UID is required for battery cameras (BCUDP)");
+    }
+
+    const api = new ReolinkBaichuanApi({
+        ...base,
+        transport: "udp",
+        udp: {
+            mode: "uid",
+            uid,
+            host: inputs.host,
+            broadcast: false,
+        },
+    });
+    attachErrorHandler(api);
+    return api;
+}
+
+export type UdpFallbackInfo = {
+    host: string;
+    uid?: string;
+    uidMissing: boolean;
+    tcpError: unknown;
+};
+
+export async function connectBaichuanWithTcpUdpFallback(
+    inputs: BaichuanConnectInputs,
+    onUdpFallback?: (info: UdpFallbackInfo) => void,
+): Promise<{ api: ReolinkBaichuanApi; transport: BaichuanTransport }> {
+    let tcpApi: ReolinkBaichuanApi | undefined;
+    try {
+        tcpApi = await createBaichuanApi(inputs, "tcp");
+        await tcpApi.login();
+        return { api: tcpApi, transport: "tcp" };
+    }
+    catch (e) {
+        try {
+            await tcpApi?.close();
+        }
+        catch {
+            // ignore
+        }
+
+        if (!isTcpFailureThatShouldFallbackToUdp(e)) {
+            throw e;
+        }
+
+        const uid = normalizeUid(inputs.uid);
+        const uidMissing = !uid;
+
+        onUdpFallback?.({
+            host: inputs.host,
+            uid,
+            uidMissing,
+            tcpError: e,
+        });
+
+        if (uidMissing) {
+            throw new Error(
+                `Baichuan TCP failed and this camera likely requires UDP/BCUDP. Set the Reolink UID in settings to continue (ip=${inputs.host}).`,
+            );
+        }
+
+        const udpApi = await createBaichuanApi(inputs, "udp");
+        await udpApi.login();
+        return { api: udpApi, transport: "udp" };
+    }
+}

package/src/main.ts

@@ -1,5 +1,6 @@
 import sdk, { DeviceCreator, DeviceCreatorSettings, DeviceInformation, DeviceProvider, ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, ScryptedNativeId, Setting } from "@scrypted/sdk";
 import { ReolinkNativeCamera } from "./camera";
+import { connectBaichuanWithTcpUdpFallback, maskUid } from "./connect";
 
 class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider, DeviceCreator {
     devices = new Map<string, ReolinkNativeCamera>();
@@ -35,14 +36,24 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
 
         const username = settings.username?.toString();
         const password = settings.password?.toString();
+        const uid = settings.uid?.toString();
 
         if (ipAddress && username && password) {
-            const { ReolinkBaichuanApi } = await import("@apocaliss92/reolink-baichuan-js");
-            const api = new ReolinkBaichuanApi({
-                host: ipAddress,
-                username,
-                password,
-            });
+            const { api } = await connectBaichuanWithTcpUdpFallback(
+                {
+                    host: ipAddress,
+                    username,
+                    password,
+                    uid,
+                    logger: this.console,
+                },
+                ({ uid: normalizedUid, uidMissing }) => {
+                    const uidMsg = !uidMissing && normalizedUid ? `UID ${maskUid(normalizedUid)}` : 'UID MISSING';
+                    this.console.log(
+                        `Baichuan TCP failed during discovery for ${ipAddress}; falling back to UDP/BCUDP (${uidMsg}).`,
+                    );
+                },
+            );
 
             try {
                 const deviceInfo = await api.getInfo();
@@ -70,6 +81,7 @@ class ReolinkNativePlugin extends ScryptedDeviceBase implements DeviceProvider,
                 device.storageSettings.values.password = password;
                 device.storageSettings.values.rtspChannel = rtspChannel;
                 device.storageSettings.values.ipAddress = ipAddress;
+                if (uid) device.storageSettings.values.uid = uid;
                 device.storageSettings.values.capabilities = capabilities;
                 device.updateDeviceInfo();