@apocaliss92/scrypted-reolink-native 0.4.35 → 0.4.37

package/package.json

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

package/src/accessories/chime.ts

@@ -0,0 +1,131 @@
+import {
+  OnOff,
+  ScryptedDeviceBase,
+  Setting,
+  Settings,
+  SettingValue,
+} from "@scrypted/sdk";
+import { StorageSettings } from "@scrypted/sdk/storage-settings";
+import type { ReolinkCamera } from "../camera";
+
+/**
+ * Chime: enable/disable the hardwired chime on the doorbell.
+ * turnOn() enables the chime; turnOff() disables (mutes) it.
+ * Additional parameters (chime type, timing) are configurable via Settings.
+ */
+export class ReolinkCameraChime
+  extends ScryptedDeviceBase
+  implements OnOff, Settings
+{
+  private get logger(): Console {
+    return this.camera.getBaichuanLogger();
+  }
+
+  storageSettings = new StorageSettings(this, {
+    chimeType: {
+      title: "Chime Type",
+      description:
+        'Chime type string reported by the device (e.g. "dingdong", "single", "dual"). Leave empty to use the current device value.',
+      type: "string",
+      defaultValue: "",
+    },
+    time: {
+      title: "Chime Duration",
+      description:
+        "Chime timing/duration value (device-specific). Leave 0 to use the current device value.",
+      type: "number",
+      defaultValue: 0,
+    },
+  });
+
+  constructor(
+    public camera: ReolinkCamera,
+    nativeId: string,
+  ) {
+    super(nativeId);
+  }
+
+  async getSettings(): Promise<Setting[]> {
+    return this.storageSettings.getSettings();
+  }
+
+  async putSetting(key: string, value: SettingValue): Promise<void> {
+    await this.storageSettings.putSetting(key, value);
+    await this.applySettings();
+  }
+
+  private async applySettings(): Promise<void> {
+    const channel = this.camera.storageSettings.values.rtspChannel;
+    const chimeType = this.storageSettings.values.chimeType || undefined;
+    const time = this.storageSettings.values.time || undefined;
+    try {
+      await this.camera.withBaichuanRetry(async () => {
+        const api = await this.camera.ensureClient();
+        await api.setHardwiredChime(
+          { enabled: !!this.on, type: chimeType, time },
+          channel,
+        );
+      });
+    } catch (e: any) {
+      this.logger.error(
+        `Chime: applySettings failed (device=${this.nativeId})`,
+        e?.message || String(e),
+      );
+      throw e;
+    }
+  }
+
+  async turnOn(): Promise<void> {
+    const channel = this.camera.storageSettings.values.rtspChannel;
+    this.logger.log(`Chime: enable (device=${this.nativeId})`);
+    this.on = true;
+    this.camera.auxDeviceCooldowns.chime = Date.now();
+    try {
+      const chimeType = this.storageSettings.values.chimeType || undefined;
+      const time = this.storageSettings.values.time || undefined;
+      await this.camera.withBaichuanRetry(async () => {
+        const api = await this.camera.ensureClient();
+        const state = await api.setHardwiredChime(
+          { enabled: true, type: chimeType, time },
+          channel,
+        );
+        this.on = state.enabled;
+      });
+      this.logger.log(`Chime: enable ok (device=${this.nativeId})`);
+    } catch (e: any) {
+      this.on = false;
+      this.logger.error(
+        `Chime: enable failed (device=${this.nativeId})`,
+        e?.message || String(e),
+      );
+      throw e;
+    }
+  }
+
+  async turnOff(): Promise<void> {
+    const channel = this.camera.storageSettings.values.rtspChannel;
+    this.logger.log(`Chime: disable (device=${this.nativeId})`);
+    this.on = false;
+    this.camera.auxDeviceCooldowns.chime = Date.now();
+    try {
+      const chimeType = this.storageSettings.values.chimeType || undefined;
+      const time = this.storageSettings.values.time || undefined;
+      await this.camera.withBaichuanRetry(async () => {
+        const api = await this.camera.ensureClient();
+        const state = await api.setHardwiredChime(
+          { enabled: false, type: chimeType, time },
+          channel,
+        );
+        this.on = state.enabled;
+      });
+      this.logger.log(`Chime: disable ok (device=${this.nativeId})`);
+    } catch (e: any) {
+      this.on = true;
+      this.logger.error(
+        `Chime: disable failed (device=${this.nativeId})`,
+        e?.message || String(e),
+      );
+      throw e;
+    }
+  }
+}

package/src/accessories/index.ts

@@ -5,3 +5,4 @@ export { ReolinkCameraMotionFloodlight } from "./motion-floodlight";
 export { ReolinkCameraFloodlight } from "./floodlight";
 export { ReolinkCameraPirSensor } from "./pir-sensor";
 export { ReolinkCameraAutotracking } from "./autotracking";
+export { ReolinkCameraChime } from "./chime";

package/src/camera.ts

@@ -47,6 +47,7 @@ import path from "path";
 import type { UrlMediaStreamOptions } from "../../scrypted/plugins/rtsp/src/rtsp";
 import {
   ReolinkCameraAutotracking,
+  ReolinkCameraChime,
   ReolinkCameraFloodlight,
   ReolinkCameraMotionFloodlight,
   ReolinkCameraMotionSiren,
@@ -76,6 +77,7 @@ import {
 } from "./stream-utils";
 import {
   autotrackingSuffix,
+  chimeSuffix,
   floodlightSuffix,
   getDeviceInterfaces,
   getVideoClipWebhookUrls,
@@ -658,6 +660,7 @@ export class ReolinkCamera
   floodlight?: ReolinkCameraFloodlight;
   pirSensor?: ReolinkCameraPirSensor;
   autotracking?: ReolinkCameraAutotracking;
+  chime?: ReolinkCameraChime;
 
   private lastPicture: { mo: MediaObject; atMs: number } | undefined;
   private takePictureInFlight: Promise<MediaObject> | undefined;
@@ -706,6 +709,7 @@ export class ReolinkCamera
     floodlight?: number;
     pir?: number;
     autotracking?: number;
+    chime?: number;
   } = {};
 
   constructor(
@@ -1693,6 +1697,7 @@ export class ReolinkCamera
         hasPir: false,
         hasAutotracking: false,
         isDoorbell: false,
+        hasChime: false,
       };
     }
   }
@@ -2275,7 +2280,7 @@ export class ReolinkCamera
     const logger = this.getBaichuanLogger();
     logger.debug(`Reporting devices: ${JSON.stringify(abilities)}`);
 
-    const { hasSiren, hasFloodlight, hasPir, hasAutotracking } = abilities;
+    const { hasSiren, hasFloodlight, hasPir, hasAutotracking, hasChime } = abilities;
 
     // Define native IDs for all sub-devices
     const motionSirenNativeId = `${this.nativeId}${motionSirenSuffix}`;
@@ -2284,6 +2289,7 @@ export class ReolinkCamera
     const floodlightNativeId = `${this.nativeId}${floodlightSuffix}`;
     const pirNativeId = `${this.nativeId}${pirSuffix}`;
     const autotrackingNativeId = `${this.nativeId}${autotrackingSuffix}`;
+    const chimeNativeId = `${this.nativeId}${chimeSuffix}`;
 
     // Helper to safely remove a device only if it exists
     const safeRemoveDevice = (nativeId: string) => {
@@ -2413,6 +2419,24 @@ export class ReolinkCamera
       safeRemoveDevice(autotrackingNativeId);
       this.autotracking = undefined;
     }
+
+    // Create chime device (ring paired wireless chime)
+    if (hasChime) {
+      const device: Device = {
+        providerNativeId: this.nativeId,
+        name: `${this.name} Chime`,
+        nativeId: chimeNativeId,
+        info: {
+          ...(this.info || {}),
+        },
+        interfaces: [ScryptedInterface.OnOff, ScryptedInterface.Settings],
+        type: ScryptedDeviceType.Switch,
+      };
+      sdk.deviceManager.onDeviceDiscovered(device);
+    } else {
+      safeRemoveDevice(chimeNativeId);
+      this.chime = undefined;
+    }
   }
 
   async getSettings(): Promise<Setting[]> {
@@ -2573,6 +2597,9 @@ export class ReolinkCamera
     } else if (nativeId.endsWith(autotrackingSuffix)) {
       this.autotracking ||= new ReolinkCameraAutotracking(this, nativeId);
       return this.autotracking;
+    } else if (nativeId.endsWith(chimeSuffix)) {
+      this.chime ||= new ReolinkCameraChime(this, nativeId);
+      return this.chime;
     }
   }
 
@@ -2597,6 +2624,8 @@ export class ReolinkCamera
       this.pirSensor = undefined;
     } else if (nativeId.endsWith(autotrackingSuffix)) {
       this.autotracking = undefined;
+    } else if (nativeId.endsWith(chimeSuffix)) {
+      this.chime = undefined;
     }
   }
 
@@ -2637,7 +2666,7 @@ export class ReolinkCamera
     const api = await this.ensureClient();
 
     const channel = this.storageSettings.values.rtspChannel;
-    const { hasSiren, hasFloodlight, hasPir, hasAutotracking } =
+    const { hasSiren, hasFloodlight, hasPir, hasAutotracking, hasChime } =
       await this.getAbilities();
 
     // Cooldown period: 15 seconds after a manual state change
@@ -2768,6 +2797,29 @@ export class ReolinkCamera
         }
       }
     }
+
+    // Align chime state
+    if (hasChime && this.chime) {
+      if (isInCooldown(this.auxDeviceCooldowns.chime)) {
+        logger.log(`[alignAuxDevicesState] Skipping chime (in cooldown)`);
+      } else {
+        try {
+          const chimeState = await api.getHardwiredChime(channel);
+          this.chime.on = chimeState.enabled;
+          if (chimeState.type) {
+            this.chime.storageSettings.values.chimeType = chimeState.type;
+          }
+          if (chimeState.time) {
+            this.chime.storageSettings.values.time = chimeState.time;
+          }
+        } catch (e) {
+          logger.warn(
+            "Failed to align chime state",
+            e?.message || String(e),
+          );
+        }
+      }
+    }
   }
 
   // Video stream helper methods

package/src/intercom.ts

@@ -458,18 +458,28 @@ export class ReolinkBaichuanIntercom {
         : [];
 
     return [
+      "-hide_banner",
+
+      // Pre-input low-latency flags: these MUST be before -i to affect
+      // the input demuxer. Placing them after -i only affects output.
+      "-analyzeduration",
+      "0",
+      "-probesize",
+      "512",
+      "-fflags",
+      "nobuffer",
+      "-flags",
+      "low_delay",
+
       ...sanitizedArgs,
       "-i",
       url,
+
       // Ensure we only decode the first input's audio stream.
       "-map",
       "0:a:0?",
 
-      // Low-latency decode settings.
-      "-fflags",
-      "nobuffer",
-      "-flags",
-      "low_delay",
+      // Output low-latency settings.
       "-flush_packets",
       "1",
 

package/src/utils.ts

@@ -48,6 +48,7 @@ export const motionSirenSuffix = `-motion-siren`;
 export const motionFloodlightSuffix = `-motion-floodlight`;
 export const pirSuffix = `-pir`;
 export const autotrackingSuffix = `-autotracking`;
+export const chimeSuffix = `-chime`;
 
 export const getDeviceInterfaces = (props: {
   capabilities: DeviceCapabilities;