@apocaliss92/scrypted-reolink-native 0.5.22 → 0.5.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apocaliss92/scrypted-reolink-native",
-  "version": "0.5.22",
+  "version": "0.5.24",
   "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.29",
+    "@apocaliss92/nodelink-js": "^0.4.31",
     "@scrypted/common": "file:../../scrypted/common",
     "@scrypted/rtsp": "file:../../scrypted/plugins/rtsp",
     "@scrypted/sdk": "^0.3.118"

package/src/baichuan-base.ts

@@ -1,5 +1,6 @@
 import type {
   BaichuanClientOptions,
+  EmailPushEvent,
   ReolinkBaichuanApi,
   ReolinkSimpleEvent,
 } from "@apocaliss92/nodelink-js" with { "resolution-mode": "import" };
@@ -32,6 +33,16 @@ export interface BaichuanConnectionCallbacks {
    * leave undefined on NVR children where email-push isn't meaningful.
    */
   emailPushCameraId?: () => string;
+  /**
+   * Optional. When the email-push event carries an image attachment
+   * (typical for `attachmentType=picture` on motion), the camera
+   * receives the full event so it can republish the snapshot —
+   * usually by updating its `lastPicture` cache so subsequent
+   * `takePicture()` calls return the fresh thumbnail without waking
+   * the camera. Invoked AFTER the simple-event dispatch so any motion
+   * listener has already fired.
+   */
+  onEmailPushEvent?: (event: EmailPushEvent) => void;
 }
 
 /**
@@ -908,6 +919,9 @@ export abstract class BaseBaichuanClass extends ScryptedDeviceBase {
           this.currentEmailPushOff = api.subscribeEmailPushEvents({
             cameraId: callbacks.emailPushCameraId(),
             channel: 0,
+            ...(callbacks.onEmailPushEvent
+              ? { onEvent: callbacks.onEmailPushEvent }
+              : {}),
           });
           logger.debug("Bridged email-push bus to onSimpleEvent");
         } catch (e) {

package/src/camera.ts

@@ -1,6 +1,7 @@
 import type {
   BatteryInfo,
   DeviceCapabilities,
+  EmailPushEvent,
   NativeVideoStreamVariant,
   PtzCommand,
   PtzPreset,
@@ -1614,6 +1615,14 @@ export class ReolinkCamera
       // (singleton under the provider) maps `cam-<nativeId>@<domain>`
       // RCPT addresses back to this `nativeId`.
       emailPushCameraId: () => this.nativeId ?? "",
+      // When the e-mail carries the snapshot Reolink sends with
+      // `attachmentType=picture`, hand it to the camera's `lastPicture`
+      // cache. Downstream consumers (Snapshot mixin → MQTT image
+      // entity, Advanced Notifier, HA discovery) call `takePicture()`
+      // on the back of the motion event; for battery cams that returns
+      // the cached value, so dropping the fresh snapshot in here makes
+      // the trigger frame surface in MQTT/HA without waking the camera.
+      onEmailPushEvent: (event) => this.handleEmailPushSnapshot(event),
     };
   }
 
@@ -2734,6 +2743,38 @@ export class ReolinkCamera
     }
   }
 
+  /**
+   * Called from `baichuan-base.subscribeToEvents` when a per-camera
+   * email-push event lands on the bus. 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.
+   */
+  private async handleEmailPushSnapshot(
+    event: EmailPushEvent,
+  ): Promise<void> {
+    const logger = this.getBaichuanLogger();
+    try {
+      const client = await this.ensureClient();
+      const mo = await this.takePictureInternal(client);
+      this.lastPicture = { mo, atMs: event.receivedAtMs };
+      this.forceNewSnapshot = false;
+      logger.log(
+        `E-mail Push snapshot fetched live (type=${event.inferredType}) — next takePicture will serve it`,
+      );
+    } catch (e) {
+      logger.warn(
+        `E-mail Push: live snapshot fetch failed: ${e?.message || String(e)}`,
+      );
+    }
+  }
+
   async takePictureInternal(client: ReolinkBaichuanApi) {
     const { rtspChannel, variantType } = this.storageSettings.values;
     const logger = this.getBaichuanLogger();

package/src/email-push-server-device.ts

@@ -214,7 +214,13 @@ export class EmailPushServerDevice
       managerHost,
       managerPort: cfg.port,
       domain: cfg.domain,
-      recipientLocalPart: nativeId,
+      // The lib's `resolveCameraIdFromRecipient` matches `^cam-(.+)$`
+      // and feeds the captured group to `cameraResolver`. We MUST send
+      // the recipient with the `cam-` prefix so the camera-side
+      // MAIL FROM produces `cam-<nativeId>@<domain>`; without it every
+      // delivery is rejected with `550 Unknown recipient` and motion
+      // events never reach Scrypted.
+      recipientLocalPart: `cam-${nativeId}`,
       sendNickname: cam.name ?? nativeId,
       ...(cfg.requireAuth
         ? {
@@ -536,7 +542,9 @@ export class EmailPushServerDevice
           managerHost,
           managerPort: cfg.port,
           domain: cfg.domain,
-          recipientLocalPart: nativeId,
+          // See `getManagerSetupParamsForCamera` for why the `cam-`
+          // prefix is mandatory.
+          recipientLocalPart: `cam-${nativeId}`,
           sendNickname: cam.name ?? nativeId,
           attachmentType: "picture",
           triggerTypes: ["MD", "people", "vehicle"],