@apocaliss92/scrypted-reolink-native 0.4.8 → 0.4.10

package/package.json

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

package/src/baichuan-base.ts

@@ -199,6 +199,24 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
    */
   protected abstract getConnectionCallbacks(): BaichuanConnectionCallbacks;
 
+  /**
+   * Check if this is an NVR/Hub device (multiple channels).
+   * Override in subclasses to return true for NVR devices.
+   * This is used for socket pooling to allocate separate sockets per channel.
+   */
+  protected isNvrDevice(): boolean {
+    return false; // Default: standalone camera
+  }
+
+  /**
+   * Check if this is a battery-powered device.
+   * Override in subclasses to return true for battery cameras.
+   * This is used to enable idle disconnect to preserve battery life.
+   */
+  protected isBatteryDevice(): boolean {
+    return false; // Default: AC-powered
+  }
+
   /**
    * Check if debug logging is enabled
    */
@@ -236,8 +254,16 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
    * Ensure Baichuan client is connected and ready
    */
   async ensureBaichuanClient(): Promise<ReolinkBaichuanApi> {
+    const logger = this.getBaichuanLogger();
+    const caller = new Error().stack?.split("\n")[2]?.trim() ?? "unknown";
+
     // Prevent concurrent login storms - check promise first
-    if (this.ensureClientPromise) return await this.ensureClientPromise;
+    if (this.ensureClientPromise) {
+      logger.debug(
+        `ensureBaichuanClient: waiting on existing promise (caller: ${caller})`,
+      );
+      return await this.ensureClientPromise;
+    }
 
     // Reuse existing client if socket is still connected and logged in
     // Check this AFTER checking the promise to avoid race conditions
@@ -247,18 +273,22 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
 
       // Only reuse if both conditions are true
       if (isConnected && isLoggedIn) {
+        logger.debug(
+          `ensureBaichuanClient: reusing existing client (caller: ${caller})`,
+        );
         return this.baichuanApi;
       }
 
       // If socket is not connected or not logged in, cleanup the stale client
       // This prevents leaking connections when the socket appears connected but isn't
-      const logger = this.getBaichuanLogger();
       logger.log(
-        `Stale client detected: connected=${isConnected}, loggedIn=${isLoggedIn}, cleaning up`,
+        `Stale client detected: connected=${isConnected}, loggedIn=${isLoggedIn}, cleaning up (caller: ${caller})`,
       );
       await this.cleanupBaichuanApi();
     }
 
+    logger.log(`ensureBaichuanClient: creating NEW client (caller: ${caller})`);
+
     // IMPORTANT: Assign the promise BEFORE the backoff to prevent parallel reconnections
     this.ensureClientPromise = (async () => {
       // Apply backoff to avoid aggressive reconnection after disconnection
@@ -299,6 +329,16 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
 
         await api.login();
 
+        // Set NVR flag BEFORE any streaming to ensure correct socket pooling
+        // NVR devices need separate sockets per channel
+        api.setIsNvr(this.isNvrDevice());
+
+        // Enable idle disconnect for battery cameras to preserve battery life
+        // AC-powered cameras (including UDP cameras like Elite Floodlight WiFi) don't need it
+        if (this.isBatteryDevice()) {
+          api.setIdleDisconnect(true);
+        }
+
         // Verify socket is connected before returning
         if (!api.client.isSocketConnected()) {
           throw new Error("Socket not connected after login");
@@ -657,8 +697,15 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
             `No events received in the last ${Math.round(timeSinceLastEvent / 60_000)} minutes, restarting event listener`,
           );
           // Restart event subscription
+          logger.debug(
+            "Restarting event listener: calling unsubscribeFromEvents...",
+          );
           await this.unsubscribeFromEvents(true);
+          logger.debug(
+            "Restarting event listener: calling subscribeToEvents...",
+          );
           await this.subscribeToEvents(true);
+          logger.debug("Restarting event listener: done");
         } else if (this.lastEventTime === 0) {
           // If lastEventTime is 0, it means we just subscribed but haven't received any events yet
           // Wait a bit longer before considering it a problem
@@ -667,8 +714,17 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
             logger.log(
               `No events received since subscription (${Math.round(timeSinceSubscription / 60_000)} minutes ago), restarting event listener`,
             );
+            logger.debug(
+              "Restarting event listener (no events since sub): calling unsubscribeFromEvents...",
+            );
             await this.unsubscribeFromEvents(true);
+            logger.debug(
+              "Restarting event listener (no events since sub): calling subscribeToEvents...",
+            );
             await this.subscribeToEvents(true);
+            logger.debug(
+              "Restarting event listener (no events since sub): done",
+            );
           }
         }
       } catch (e) {
@@ -694,6 +750,13 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
   async subscribeToEvents(silent: boolean = false): Promise<void> {
     const logger = this.getBaichuanLogger();
     const callbacks = this.getConnectionCallbacks();
+    const existingClientInfo = this.baichuanApi
+      ? `connected=${this.baichuanApi.client.isSocketConnected()}, loggedIn=${this.baichuanApi.client.loggedIn}`
+      : "no client";
+
+    logger.debug(
+      `subscribeToEvents() called: silent=${silent}, existingClient=[${existingClientInfo}], eventSubscriptionActive=${this.eventSubscriptionActive}`,
+    );
 
     if (!callbacks.onSimpleEvent) {
       return;
@@ -716,7 +779,11 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
     await this.unsubscribeFromEvents(silent);
 
     // Get Baichuan client connection
+    logger.debug("subscribeToEvents: calling ensureBaichuanClient...");
     const api = await this.ensureBaichuanClient();
+    logger.debug(
+      `subscribeToEvents: ensureBaichuanClient returned, reused=${api === this.baichuanApi}`,
+    );
 
     // Verify connection is ready
     if (!api.client.isSocketConnected() || !api.client.loggedIn) {

package/src/camera.ts

@@ -104,8 +104,10 @@ import {
 export type CameraType =
   | "battery"
   | "regular"
+  | "udp" // UDP camera without battery (e.g., Elite Floodlight WiFi)
   | "multi-focal"
-  | "multi-focal-battery";
+  | "multi-focal-battery"
+  | "multi-focal-udp"; // UDP multifocal without battery
 
 export interface ReolinkCameraOptions {
   type: CameraType;
@@ -738,6 +740,7 @@ export class ReolinkCamera
   protected multiFocalDevice?: ReolinkNativeMultiFocalDevice;
   thisDevice: Settings;
   isBattery: boolean;
+  isUdpCamera: boolean; // UDP camera without battery (e.g., Elite Floodlight WiFi)
   isMultiFocal: boolean;
   isOnNvr: boolean;
   protocol: BaichuanTransport;
@@ -769,7 +772,12 @@ export class ReolinkCamera
   ) {
     const isBattery =
       options.type === "battery" || options.type === "multi-focal-battery";
-    const transport = isBattery || !!options.nvrDevice ? "udp" : "tcp";
+    // UDP cameras include: battery cameras, NVR children, and UDP-only cameras (e.g., Elite Floodlight WiFi)
+    const isUdpCamera =
+      options.type === "udp" || options.type === "multi-focal-udp";
+    const transport = isBattery || isUdpCamera ? "udp" : "tcp";
+    // const transport =
+    //   isBattery || isUdpCamera || !!options.nvrDevice ? "udp" : "tcp";
     super(nativeId, transport);
     this.plugin.camerasMap.set(this.id, this);
 
@@ -779,8 +787,11 @@ export class ReolinkCamera
     this.thisDevice = sdk.systemManager.getDeviceById<Settings>(this.id);
 
     this.isBattery = isBattery;
+    this.isUdpCamera = isUdpCamera; // UDP camera without battery (e.g., Elite Floodlight WiFi)
     this.isMultiFocal =
-      options.type === "multi-focal" || options.type === "multi-focal-battery";
+      options.type === "multi-focal" ||
+      options.type === "multi-focal-battery" ||
+      options.type === "multi-focal-udp";
     this.isOnNvr = !!this.nvrDevice || !!this.multiFocalDevice?.nvrDevice;
     this.protocol = transport;
 
@@ -1475,17 +1486,21 @@ export class ReolinkCamera
     const { ipAddress, username, password, uid, discoveryMethod } =
       this.storageSettings.values;
     const debugOptions = this.getBaichuanDebugOptions();
-    const normalizedUid = this.isBattery ? normalizeUid(uid) : undefined;
 
-    if (this.isBattery && !normalizedUid) {
-      throw new Error("UID is required for battery cameras (BCUDP)");
-    }
+    // UDP cameras (battery or UDP-only like Elite Floodlight WiFi) require UID
+    // const requiresUid = this.isBattery || this.isUdpCamera;
+    // const normalizedUid = requiresUid ? normalizeUid(uid) : undefined;
+    const normalizedUid = normalizeUid(uid);
+
+    // if (requiresUid && !normalizedUid) {
+    //   throw new Error("UID is required for UDP cameras (BCUDP)");
+    // }
 
     // Prevent accidental connections to localhost (Node will default host=127.0.0.1 when host is undefined).
     // This shows up as connect ECONNREFUSED 127.0.0.1:9000 and will never recover with socket resets.
-    if (!this.isBattery && !ipAddress) {
-      throw new Error("IP Address is required for TCP devices");
-    }
+    // if (!requiresUid && !ipAddress) {
+    //   throw new Error("IP Address is required for TCP devices");
+    // }
 
     return {
       host: ipAddress,
@@ -1494,8 +1509,9 @@ export class ReolinkCamera
       uid: normalizedUid,
       transport: this.protocol,
       debugOptions,
-      udpDiscoveryMethod:
-        discoveryMethod as BaichuanClientOptions["udpDiscoveryMethod"],
+      udpDiscoveryMethod: discoveryMethod,
+      // NOTE: idleDisconnect is NOT set here - the library handles it internally
+      // based on the battery status detected during connection
     };
   }
 
@@ -1530,6 +1546,10 @@ export class ReolinkCamera
     return this.storageSettings.values.debugLogs;
   }
 
+  protected isBatteryDevice(): boolean {
+    return this.isBattery;
+  }
+
   protected getDeviceName(): string {
     return this.name || "Camera";
   }
@@ -3287,6 +3307,14 @@ export class ReolinkCamera
     const hideUid = !this.isBattery || this.isOnNvr || !!this.multiFocalDevice;
     this.storageSettings.settings.uid.hide = hideUid;
     this.storageSettings.settings.discoveryMethod.hide = hideUid;
+    // Show UID and discovery method for UDP cameras (battery or UDP-only like Elite Floodlight WiFi)
+    // Hide for NVR children or multifocal lenses (they use parent's connection)
+    // const requiresUidSettings =
+    //   (this.isBattery || this.isUdpCamera) &&
+    //   !this.isOnNvr &&
+    //   !this.multiFocalDevice;
+    // this.storageSettings.settings.uid.hide = !requiresUidSettings;
+    // this.storageSettings.settings.discoveryMethod.hide = !requiresUidSettings;
 
     if (this.isBattery && !this.storageSettings.values.mixinsSetup) {
       try {

package/src/connect.ts

@@ -1,89 +1,99 @@
-import type { BaichuanTransport as BaichuanTransportParent, 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 = BaichuanTransportParent;
 
 export type BaichuanConnectInputs = {
-    host: string;
-    username: string;
-    password: string;
-    uid?: string;
-    logger?: Console;
-    debugOptions?: BaichuanClientOptions['debugOptions'];
-    udpDiscoveryMethod?: BaichuanClientOptions["udpDiscoveryMethod"];
+  host: string;
+  username: string;
+  password: string;
+  uid?: string;
+  logger?: Console;
+  debugOptions?: BaichuanClientOptions["debugOptions"];
+  udpDiscoveryMethod?: BaichuanClientOptions["udpDiscoveryMethod"];
 };
 
 export function normalizeUid(uid?: string): string | undefined {
-    const v = uid?.trim();
-    return v ? v : undefined;
+  const v = uid?.trim();
+  return v ? v : undefined;
 }
 
 export async function createBaichuanApi(props: {
-    inputs: BaichuanConnectInputs,
-    transport: BaichuanTransport,
+  inputs: BaichuanConnectInputs;
+  transport: BaichuanTransport;
 }): Promise<ReolinkBaichuanApi> {
-    const { inputs, transport } = props;
-    const { logger } = inputs;
-    const { ReolinkBaichuanApi } = await import("@apocaliss92/reolink-baichuan-js");
+  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,
-        debugOptions: inputs.debugOptions ?? {}
-    };
+  const base: BaichuanClientOptions = {
+    host: inputs.host,
+    username: inputs.username,
+    password: inputs.password,
+    logger,
+    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) => {
-                if (!logger) return;
-                const msg = (err as any)?.message || (err as any)?.toString?.() || String(err);
-                // Only log if it's not a recoverable error to avoid spam
-                if (typeof msg === 'string' && (
-                    msg.includes('Baichuan socket closed') ||
-                    msg.includes('Baichuan UDP stream closed') ||
-                    msg.includes('Not running')
-                )) {
-                    // Silently ignore recoverable socket close errors and "Not running" errors
-                    // "Not running" is common for UDP/battery cameras when sleeping or during initialization
-                    return;
-                }
-                logger.error(`[BaichuanClient] error (${transport}) ${inputs.host}: ${msg}`);
-            });
-
-            // Handle 'close' event to prevent unhandled rejections from pending promises
-            api.client.on("close", () => {
-                // Socket closed - pending promises will be rejected, but we've already handled errors above
-                // This handler prevents the close event from causing issues
-            });
-        } catch {
-            // ignore
+  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) => {
+        if (!logger) return;
+        const msg =
+          (err as any)?.message || (err as any)?.toString?.() || String(err);
+        // Only log if it's not a recoverable error to avoid spam
+        if (
+          typeof msg === "string" &&
+          (msg.includes("Baichuan socket closed") ||
+            msg.includes("Baichuan UDP stream closed") ||
+            msg.includes("Not running"))
+        ) {
+          // Silently ignore recoverable socket close errors and "Not running" errors
+          // "Not running" is common for UDP/battery cameras when sleeping or during initialization
+          return;
         }
-    };
-
-    if (transport === "tcp") {
-        const api = new ReolinkBaichuanApi({
-            ...base,
-            transport: "tcp",
-        });
-        attachErrorHandler(api);
-        return api;
-    }
+        logger.error(
+          `[BaichuanClient] error (${transport}) ${inputs.host}: ${msg}`,
+        );
+      });
 
-    const uid = normalizeUid(inputs.uid);
-    if (!uid) {
-        throw new Error("UID is required for battery cameras (BCUDP)");
+      // Handle 'close' event to prevent unhandled rejections from pending promises
+      api.client.on("close", () => {
+        // Socket closed - pending promises will be rejected, but we've already handled errors above
+        // This handler prevents the close event from causing issues
+      });
+    } catch {
+      // ignore
     }
+  };
 
+  if (transport === "tcp") {
     const api = new ReolinkBaichuanApi({
-        ...base,
-        transport: "udp",
-        uid,
-        idleDisconnect: true,
-        udpDiscoveryMethod: inputs.udpDiscoveryMethod,
+      ...base,
+      transport: "tcp",
     });
     attachErrorHandler(api);
     return api;
+  }
+
+  const uid = normalizeUid(inputs.uid);
+  if (!uid) {
+    throw new Error("UID is required for UDP cameras (BCUDP)");
+  }
+
+  const api = new ReolinkBaichuanApi({
+    ...base,
+    transport: "udp",
+    uid,
+    // NOTE: idleDisconnect is NOT set here - the library handles it internally
+    // based on the battery status detected during connection/autodetect
+    udpDiscoveryMethod: inputs.udpDiscoveryMethod,
+  });
+  attachErrorHandler(api);
+  return api;
 }

package/src/main.ts

@@ -37,6 +37,8 @@ import {
   handleVideoClipRequest,
   multifocalSuffix,
   nvrSuffix,
+  udpCameraSuffix,
+  udpMultifocalSuffix,
 } from "./utils";
 import { randomBytes } from "crypto";
 import { ReolinkCamera } from "./camera";
@@ -135,14 +137,25 @@ class ReolinkNativePlugin
 
     // Handle multi-focal device case
     if (detection.type === "multifocal") {
-      const isBattery = detection.transport === "udp";
-      nativeId = `${identifier}${isBattery ? batteryMultifocalSuffix : multifocalSuffix}`;
-
-      settings.newCamera ||= name;
+      // Determine suffix based on transport and battery capability
+      // UDP transport does NOT always mean battery (e.g., some floodlight cameras use UDP but are AC-powered)
+      const isUdp = detection.transport === "udp";
 
+      // Get capabilities to check if device has battery
       const { capabilities, objects, presets } =
         await detectedApi.getDeviceCapabilities();
 
+      const hasBattery = capabilities?.hasBattery === true;
+
+      // Choose suffix based on transport and battery
+      if (isUdp) {
+        nativeId = `${identifier}${hasBattery ? batteryMultifocalSuffix : udpMultifocalSuffix}`;
+      } else {
+        nativeId = `${identifier}${multifocalSuffix}`;
+      }
+
+      settings.newCamera ||= name;
+
       const { interfaces } = getDeviceInterfaces({
         capabilities,
         logger: this.console,
@@ -201,10 +214,17 @@ class ReolinkNativePlugin
       return nativeId;
     }
 
-    // Create nativeId based on device type
+    // Create nativeId based on device type and transport
+    // UDP transport does NOT always mean battery (e.g., Elite Floodlight WiFi uses UDP but is AC-powered)
+    const isUdp = detection.transport === "udp";
     if (detection.type === "battery-cam") {
+      // Battery camera (always UDP)
       nativeId = `${identifier}${batteryCameraSuffix}`;
+    } else if (isUdp) {
+      // UDP camera without battery (e.g., Elite Floodlight WiFi)
+      nativeId = `${identifier}${udpCameraSuffix}`;
     } else {
+      // Regular TCP camera
       nativeId = `${identifier}${cameraSuffix}`;
     }
 
@@ -315,8 +335,18 @@ class ReolinkNativePlugin
         this,
         "multi-focal-battery",
       );
+    } else if (nativeId.endsWith(udpMultifocalSuffix)) {
+      // UDP multifocal without battery
+      return new ReolinkNativeMultiFocalDevice(
+        nativeId,
+        this,
+        "multi-focal-udp",
+      );
     } else if (nativeId.endsWith(multifocalSuffix)) {
       return new ReolinkNativeMultiFocalDevice(nativeId, this, "multi-focal");
+    } else if (nativeId.endsWith(udpCameraSuffix)) {
+      // UDP camera without battery (e.g., Elite Floodlight WiFi)
+      return new ReolinkCamera(nativeId, this, { type: "udp" });
     } else {
       return new ReolinkCamera(nativeId, this, { type: "regular" });
     }

package/src/nvr.ts

@@ -218,6 +218,10 @@ export class ReolinkNativeNvrDevice
     };
   }
 
+  protected isNvrDevice(): boolean {
+    return true; // NVR/Hub always returns true
+  }
+
   protected isDebugEnabled(): boolean {
     return this.storageSettings.values.debugLogs || false;
   }

package/src/utils.ts

@@ -37,8 +37,10 @@ export type OperationChannelMap = Partial<Record<OperationChannelType, number>>;
 
 export const nvrSuffix = `-nvr`;
 export const batteryCameraSuffix = `-battery-cam`;
+export const udpCameraSuffix = `-udp-cam`; // UDP camera without battery (e.g., Elite Floodlight WiFi)
 export const multifocalSuffix = `-multifocal`;
 export const batteryMultifocalSuffix = `-battery-multifocal`;
+export const udpMultifocalSuffix = `-udp-multifocal`; // UDP multifocal without battery
 export const cameraSuffix = `-cam`;
 export const sirenSuffix = `-siren`;
 export const floodlightSuffix = `-floodlight`;