@apocaliss92/scrypted-reolink-native 0.5.26 → 0.5.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apocaliss92/scrypted-reolink-native",
-  "version": "0.5.26",
+  "version": "0.5.28",
   "description": "Use any reolink camera with Scrypted, even older/unsupported models without HTTP protocol support",
   "author": "@apocaliss92",
   "license": "Apache",
@@ -44,7 +44,7 @@
     ]
   },
   "dependencies": {
-    "@apocaliss92/nodelink-js": "^0.4.31",
+    "@apocaliss92/nodelink-js": "^0.4.32",
     "@scrypted/common": "file:../../scrypted/common",
     "@scrypted/rtsp": "file:../../scrypted/plugins/rtsp",
     "@scrypted/sdk": "^0.3.118"

package/src/baichuan-base.ts

@@ -15,6 +15,13 @@ export interface BaichuanConnectionConfig {
   transport: BaichuanTransport;
   debugOptions?: any;
   udpDiscoveryMethod?: BaichuanClientOptions["udpDiscoveryMethod"];
+  /**
+   * When set, the api auto-bridges the global email-push bus into
+   * its own `simpleEventListeners` so SMTP motion lands on the same
+   * `onSimpleEvent` stream as native Baichuan push. Standalone
+   * (non-NVR-child, non-multifocal-lens) cameras only.
+   */
+  emailPushCameraId?: string;
 }
 
 export interface BaichuanConnectionCallbacks {
@@ -349,6 +356,9 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
             logger,
             debugOptions: config.debugOptions,
             udpDiscoveryMethod: config.udpDiscoveryMethod,
+            ...(config.emailPushCameraId
+              ? { emailPushCameraId: config.emailPushCameraId }
+              : {}),
           },
           transport: config.transport,
         });

package/src/camera.ts

@@ -1,7 +1,6 @@
 import type {
   BatteryInfo,
   DeviceCapabilities,
-  EmailPushEvent,
   NativeVideoStreamVariant,
   PtzCommand,
   PtzPreset,
@@ -809,9 +808,11 @@ export class ReolinkCamera
   private periodicStarted = false;
   private statusPollTimer: NodeJS.Timeout | undefined;
   // Off-handle for the global email-push bus subscription. Tied to
-  // the camera lifecycle (init → release), NOT to the Baichuan api
-  // lifetime — battery cams drop the api when they sleep, so an
-  // api-scoped subscription would be dead by the next motion email.
+  // the camera (Scrypted device) lifecycle, NOT to the Baichuan api
+  // — the plugin destroys the api on every idle_disconnect (battery
+  // cams every ~30s), and an api-scoped bridge would be dead in
+  // that window. The camera-scoped subscription stays alive across
+  // every reconnect cycle so SMTP motion always finds a listener.
   private emailPushBusOff?: () => void;
 
   // Cooldown timestamps to prevent alignAuxDevicesState from overwriting recently set states
@@ -1563,6 +1564,15 @@ export class ReolinkCamera
     //   throw new Error("IP Address is required for TCP devices");
     // }
 
+    // The lib's `emailPushCameraId` auto-bridge would die every time
+    // the plugin calls `cleanupBaichuanApi` (every idle_disconnect on
+    // battery cams — every ~30s of idle). In that window SMTP motion
+    // events emitted on the global bus have no listener and are lost.
+    // Instead, the camera subscribes to the bus directly in `init()`
+    // via `subscribeToEmailPushBus()` — that subscription is tied to
+    // the camera (Scrypted device) lifecycle, not to the api object,
+    // so it survives every api recreate / idle disconnect / wake.
+
     return {
       host: ipAddress,
       username,
@@ -2118,6 +2128,17 @@ export class ReolinkCamera
       this.processEvents({ motion, objects }).catch((e) => {
         logger.warn("Error processing events", e?.message || String(e));
       });
+
+      // Battery cams cache `lastPicture` aggressively because waking
+      // the device for a snapshot is expensive. When motion fires the
+      // cam is, by definition, awake right now — proactively refresh
+      // the cache so the Snapshot mixin → MQTT image entity / HA
+      // discovery serves the trigger frame on the next `takePicture`
+      // call instead of the previous cached one. Wired cams don't
+      // need this (Snapshot mixin always gets fresh data anyway).
+      if (motion && this.isBattery && !this.multiFocalDevice) {
+        void this.refreshSnapshotOnMotion(ev.timestamp ?? Date.now());
+      }
     } catch (e) {
       logger.warn("Error in onSimpleEvent handler", e?.message || String(e));
     }
@@ -2741,13 +2762,17 @@ export class ReolinkCamera
   }
 
   /**
-   * Subscribe to the lib's global email-push bus and translate each
-   * matching event into a synthetic motion `ReolinkSimpleEvent` fed
-   * to this camera's existing `onSimpleEvent` handler — so the same
-   * code path that flips `motionDetected` for native Baichuan push
-   * fires for SMTP-delivered alerts too. Lives on the camera (not on
-   * the api) so the subscription survives api closes for battery
-   * cams. Idempotent: returns early if already subscribed.
+   * Subscribe to the lib's global email-push bus and translate every
+   * matching SMTP delivery into a synthetic `ReolinkSimpleEvent` fed
+   * to this camera's `onSimpleEvent` — same code path used by native
+   * Baichuan push so `motionDetected` flips uniformly.
+   *
+   * Subscription lifetime is tied to the camera (init → release), NOT
+   * to the Baichuan api: the plugin destroys the api on every
+   * idle_disconnect (battery cams sleep every ~30s of idle), and a
+   * lib-level api auto-bridge would be dead in that window. The
+   * camera-level subscription stays alive across every reconnect so
+   * SMTP motion always finds a listener and lands on `onSimpleEvent`.
    */
   private async subscribeToEmailPushBus(): Promise<void> {
     if (this.emailPushBusOff) return;
@@ -2761,26 +2786,23 @@ export class ReolinkCamera
       );
       this.emailPushBusOff = onEmailPushEvent((event) => {
         if (event.cameraId !== ownNativeId) return;
+        const channel = this.storageSettings.values.rtspChannel ?? 0;
+        const mapped = mapEmailPushInferredType(event.inferredType);
         logger.log(
-          `E-mail Push event received (type=${event.inferredType}) → dispatching motion`,
+          `E-mail Push event received (type=${event.inferredType}) → dispatching ${mapped}`,
         );
         try {
           this.onSimpleEvent({
-            type: mapEmailPushInferredType(event.inferredType),
-            channel: this.storageSettings.values.rtspChannel ?? 0,
+            type: mapped,
+            channel,
             timestamp: event.receivedAtMs,
           });
-          // Mirror the api-side fan-out: when the camera signalled an
-          // AI sub-type (people / vehicle / …), also raise a generic
-          // motion event so motion-only consumers light up.
-          if (
-            event.inferredType !== "motion" &&
-            event.inferredType !== "doorbell" &&
-            event.inferredType !== "other"
-          ) {
+          // Fan out a generic motion for AI sub-types so motion-only
+          // consumers still flip — mirrors lib's per-api behaviour.
+          if (mapped !== "motion" && mapped !== "doorbell") {
             this.onSimpleEvent({
               type: "motion",
-              channel: this.storageSettings.values.rtspChannel ?? 0,
+              channel,
               timestamp: event.receivedAtMs,
             });
           }
@@ -2789,14 +2811,6 @@ export class ReolinkCamera
             `E-mail Push: onSimpleEvent dispatch threw: ${e?.message || String(e)}`,
           );
         }
-        // Fire-and-forget snapshot fetch; runs in parallel with the
-        // motion dispatch so consumers reading `takePicture` right
-        // after motion get the fresh frame.
-        void this.handleEmailPushSnapshot(event).catch((e) => {
-          logger.warn(
-            `E-mail Push: snapshot fetch threw: ${e?.message || String(e)}`,
-          );
-        });
       });
       logger.log("E-mail Push: subscribed to global bus");
     } catch (e) {
@@ -2816,34 +2830,37 @@ export class ReolinkCamera
   }
 
   /**
-   * Called from `subscribeToEmailPushBus` for every matching event.
-   * We don't use the e-mail's image attachment — Reolink firmwares
-   * vary on quality/encoding and we'd be reimplementing the snapshot
-   * pipeline. Instead we leverage the fact that the camera is
-   * *guaranteed awake* right now (it just pushed an e-mail) and call
-   * the live Baichuan snapshot API: it returns a fresh frame in
-   * milliseconds without forcing an extra wake-up cycle. The result
-   * is stashed in `lastPicture` so the Snapshot mixin → MQTT image
-   * entity (and any other consumer that calls `takePicture()` on the
-   * back of the motion event) serves the trigger frame instead of
-   * the previous cached one.
+   * Refresh the `lastPicture` cache by fetching a live snapshot via
+   * the Baichuan API. Used on motion events for battery cameras: the
+   * cam is guaranteed awake at that moment (just sent native push or
+   * SMTP), so the round-trip is cheap, and downstream consumers
+   * (Snapshot mixin → MQTT image entity, HA discovery) reading
+   * `takePicture()` on the back of the motion get the trigger frame
+   * instead of the previous cached one. Fire-and-forget; per-camera
+   * debounce so an event burst doesn't trigger overlapping fetches.
    */
-  private async handleEmailPushSnapshot(
-    event: EmailPushEvent,
-  ): Promise<void> {
+  private lastMotionSnapshotAtMs = 0;
+  private motionSnapshotInFlight = false;
+  private async refreshSnapshotOnMotion(timestampMs: number): Promise<void> {
+    if (this.motionSnapshotInFlight) return;
+    if (timestampMs - this.lastMotionSnapshotAtMs < 5_000) return;
+    this.motionSnapshotInFlight = true;
+    this.lastMotionSnapshotAtMs = timestampMs;
     const logger = this.getBaichuanLogger();
     try {
       const client = await this.ensureClient();
       const mo = await this.takePictureInternal(client);
-      this.lastPicture = { mo, atMs: event.receivedAtMs };
+      this.lastPicture = { mo, atMs: timestampMs };
       this.forceNewSnapshot = false;
       logger.log(
-        `E-mail Push snapshot fetched live (type=${event.inferredType}) — next takePicture will serve it`,
+        `Motion snapshot refreshed — next takePicture will serve the trigger frame`,
       );
     } catch (e) {
       logger.warn(
-        `E-mail Push: live snapshot fetch failed: ${e?.message || String(e)}`,
+        `Motion snapshot refresh failed: ${e?.message || String(e)}`,
       );
+    } finally {
+      this.motionSnapshotInFlight = false;
     }
   }
 
@@ -3675,9 +3692,10 @@ export class ReolinkCamera
 
     this.startPeriodicTasks();
 
-    // Subscribe BEFORE ensureClient so battery cams whose api fails to
-    // connect on first try still pick up incoming SMTP motion events.
-    // The subscription is idempotent — safe across re-inits.
+    // Subscribe to the lib's email-push bus BEFORE ensureClient so
+    // SMTP motion is never lost during the api's connection window.
+    // Lifetime is tied to the camera (released in `release()`) so it
+    // survives every `cleanupBaichuanApi` cycle on battery cams.
     await this.subscribeToEmailPushBus();
 
     await this.ensureClient();

package/src/connect.ts

@@ -14,6 +14,18 @@ export type BaichuanConnectInputs = {
   logger?: Console;
   debugOptions?: BaichuanClientOptions["debugOptions"];
   udpDiscoveryMethod?: BaichuanClientOptions["udpDiscoveryMethod"];
+  /**
+   * When set, the lib api auto-bridges the global email-push bus into
+   * its own `simpleEventListeners`, so SMTP motion lands on the same
+   * `onSimpleEvent` stream as native Baichuan push. Bridge survives
+   * TCP transient disconnects (it's a pure JS fan-out). For Reolink
+   * cameras this should be the camera's plugin-side nativeId — the
+   * `EmailPushServerDevice` resolves `cam-<nativeId>@<domain>` against
+   * the same string, so the round-trip is symmetric.
+   */
+  emailPushCameraId?: string;
+  /** Channel reported on the synthesised event. Default 0. */
+  emailPushChannel?: number;
 };
 
 export function normalizeUid(uid?: string): string | undefined {
@@ -38,6 +50,21 @@ export async function createBaichuanApi(props: {
     debugOptions: inputs.debugOptions ?? {},
   };
 
+  // The lib's auto-bridge fields belong on the second positional arg
+  // of `new ReolinkBaichuanApi(opts)` alongside `nativeOnly` etc.; we
+  // build a small `extras` bag and spread it at construction time
+  // below for both tcp + udp paths.
+  const extras: {
+    emailPushCameraId?: string;
+    emailPushChannel?: number;
+  } = {};
+  if (inputs.emailPushCameraId) {
+    extras.emailPushCameraId = inputs.emailPushCameraId;
+    if (inputs.emailPushChannel !== undefined) {
+      extras.emailPushChannel = inputs.emailPushChannel;
+    }
+  }
+
   const attachErrorHandler = (api: ReolinkBaichuanApi) => {
     // Critical: BaichuanClient emits 'error'. If nobody listens, Node treats it as an
     // uncaught exception. Ensure we always have a listener.
@@ -75,6 +102,7 @@ export async function createBaichuanApi(props: {
   if (transport === "tcp") {
     const api = new ReolinkBaichuanApi({
       ...base,
+      ...extras,
       transport: "tcp",
     });
     attachErrorHandler(api);
@@ -88,6 +116,7 @@ export async function createBaichuanApi(props: {
 
   const api = new ReolinkBaichuanApi({
     ...base,
+    ...extras,
     transport: "udp",
     uid,
     // NOTE: idleDisconnect is NOT set here - the library handles it internally