@apocaliss92/scrypted-reolink-native 0.4.0 → 0.4.2

package/package.json

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

package/src/accessories/autotracking.ts

@@ -0,0 +1,150 @@
+import {
+  OnOff,
+  ScryptedDeviceBase,
+  Setting,
+  Settings,
+  SettingValue,
+} from "@scrypted/sdk";
+import { StorageSettings } from "@scrypted/sdk/storage-settings";
+import type { ReolinkCamera } from "../camera";
+
+/**
+ * Autotracking: controls PTZ auto-tracking (smart track)
+ * This accessory controls the PTZ auto-tracking feature on compatible cameras.
+ */
+export class ReolinkCameraAutotracking
+  extends ScryptedDeviceBase
+  implements OnOff, Settings
+{
+  private get logger(): Console {
+    return this.camera.getBaichuanLogger();
+  }
+
+  storageSettings = new StorageSettings(this, {
+    smartTrackType: {
+      title: "Track Types",
+      description: "Types of objects to track",
+      type: "string",
+      defaultValue: "people",
+      choices: [
+        "people",
+        "vehicle",
+        "dog_cat",
+        "people,vehicle",
+        "people,dog_cat",
+        "vehicle,dog_cat",
+        "people,vehicle,dog_cat",
+      ],
+    },
+    smartTrackObjectStopDelay: {
+      title: "Stop Delay",
+      description:
+        "Seconds to wait before stopping tracking when object stops moving",
+      type: "number",
+      defaultValue: 20,
+      range: [5, 60],
+    },
+    smartTrackObjectDisappearDelay: {
+      title: "Disappear Delay",
+      description:
+        "Seconds to wait before stopping tracking when object disappears",
+      type: "number",
+      defaultValue: 10,
+      range: [5, 60],
+    },
+  });
+
+  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);
+
+    // Always apply settings to camera when changed
+    await this.applySettings();
+  }
+
+  private async applySettings(): Promise<void> {
+    const channel = this.camera.storageSettings.values.rtspChannel;
+    const smartTrackType = this.storageSettings.values.smartTrackType;
+    const stopDelay = this.storageSettings.values.smartTrackObjectStopDelay;
+    const disappearDelay =
+      this.storageSettings.values.smartTrackObjectDisappearDelay;
+
+    this.logger.log(
+      `Autotracking applySettings: trackType=${smartTrackType}, stopDelay=${stopDelay}, disappearDelay=${disappearDelay}`,
+    );
+
+    try {
+      await this.camera.withBaichuanRetry(async () => {
+        const api = await this.camera.ensureClient();
+        await api.setAutotrackingSettings(channel, {
+          smartTrackType,
+          smartTrackObjectStopDelay: stopDelay,
+          smartTrackObjectDisappearDelay: disappearDelay,
+        });
+      });
+      this.logger.log(`Autotracking applySettings: success`);
+    } catch (e: any) {
+      this.logger.error(
+        `Autotracking applySettings: failed`,
+        e?.message || String(e),
+      );
+      throw e;
+    }
+  }
+
+  async turnOff(): Promise<void> {
+    this.logger.log(`Autotracking toggle: turnOff (device=${this.nativeId})`);
+    this.on = false;
+    this.camera.auxDeviceCooldowns.autotracking = Date.now();
+    try {
+      const channel = this.camera.storageSettings.values.rtspChannel;
+      await this.camera.withBaichuanRetry(async () => {
+        const api = await this.camera.ensureClient();
+        await api.setAutotracking(false, channel);
+      });
+      this.logger.log(
+        `Autotracking toggle: turnOff ok (device=${this.nativeId})`,
+      );
+    } catch (e: any) {
+      this.on = true; // Revert on failure
+      this.logger.error(
+        `Autotracking toggle: turnOff failed (device=${this.nativeId})`,
+        e?.message || String(e),
+      );
+      throw e;
+    }
+  }
+
+  async turnOn(): Promise<void> {
+    this.logger.log(`Autotracking toggle: turnOn (device=${this.nativeId})`);
+    this.on = true;
+    this.camera.auxDeviceCooldowns.autotracking = Date.now();
+    try {
+      const channel = this.camera.storageSettings.values.rtspChannel;
+      await this.camera.withBaichuanRetry(async () => {
+        const api = await this.camera.ensureClient();
+        await api.setAutotracking(true, channel);
+      });
+      this.logger.log(
+        `Autotracking toggle: turnOn ok (device=${this.nativeId})`,
+      );
+    } catch (e: any) {
+      this.on = false; // Revert on failure
+      this.logger.error(
+        `Autotracking toggle: turnOn failed (device=${this.nativeId})`,
+        e?.message || String(e),
+      );
+      throw e;
+    }
+  }
+}

package/src/accessories/floodlight.ts

@@ -0,0 +1,92 @@
+import { Brightness, OnOff, ScryptedDeviceBase } from "@scrypted/sdk";
+import type { ReolinkCamera } from "../camera";
+
+/**
+ * Floodlight: direct control (not motion-based)
+ * This accessory directly controls the floodlight on/off state and brightness.
+ */
+export class ReolinkCameraFloodlight
+  extends ScryptedDeviceBase
+  implements OnOff, Brightness
+{
+  private get logger(): Console {
+    return this.camera.getBaichuanLogger();
+  }
+
+  constructor(
+    public camera: ReolinkCamera,
+    nativeId: string,
+  ) {
+    super(nativeId);
+  }
+
+  async setBrightness(brightness: number): Promise<void> {
+    this.logger.log(
+      `Floodlight toggle: setBrightness (device=${this.nativeId} brightness=${brightness})`,
+    );
+    this.brightness = brightness;
+    try {
+      const channel = this.camera.storageSettings.values.rtspChannel;
+      await this.camera.withBaichuanRetry(async () => {
+        const api = await this.camera.ensureClient();
+        await api.setWhiteLedState(channel, undefined, brightness);
+        // Trust the set operation
+      });
+      this.logger.log(
+        `Floodlight toggle: setBrightness ok (device=${this.nativeId} brightness=${brightness})`,
+      );
+    } catch (e: any) {
+      this.logger.warn(
+        `Floodlight toggle: setBrightness failed (device=${this.nativeId} brightness=${brightness})`,
+        e?.message || String(e),
+      );
+      throw e;
+    }
+  }
+
+  async turnOff(): Promise<void> {
+    this.logger.log(`Floodlight toggle: turnOff (device=${this.nativeId})`);
+    this.on = false;
+    this.camera.auxDeviceCooldowns.floodlight = Date.now();
+    try {
+      const channel = this.camera.storageSettings.values.rtspChannel;
+      await this.camera.withBaichuanRetry(async () => {
+        const api = await this.camera.ensureClient();
+        await api.setWhiteLedState(channel, false);
+        // Trust the set operation - don't read back immediately as camera may have delay
+      });
+      this.logger.log(
+        `Floodlight toggle: turnOff ok (device=${this.nativeId})`,
+      );
+    } catch (e: any) {
+      this.on = true; // Revert on failure
+      this.logger.warn(
+        `Floodlight toggle: turnOff failed (device=${this.nativeId})`,
+        e?.message || String(e),
+      );
+      throw e;
+    }
+  }
+
+  async turnOn(): Promise<void> {
+    this.logger.log(`Floodlight toggle: turnOn (device=${this.nativeId})`);
+    this.on = true;
+    this.camera.auxDeviceCooldowns.floodlight = Date.now();
+    try {
+      const channel = this.camera.storageSettings.values.rtspChannel;
+      await this.camera.withBaichuanRetry(async () => {
+        const api = await this.camera.ensureClient();
+        await api.setWhiteLedState(channel, true);
+        // Trust the set operation - don't read back immediately as camera may have delay
+      });
+      this.logger.log(`Floodlight toggle: turnOn ok (device=${this.nativeId})`);
+    } catch (e: any) {
+      this.on = false; // Revert on failure
+      this.logger.warn(
+        `Floodlight toggle: turnOn failed (device=${this.nativeId})`,
+        e?.message || String(e),
+      );
+      throw e;
+    }
+  }
+}

package/src/accessories/index.ts

@@ -0,0 +1,7 @@
+// Accessory devices for Reolink cameras
+export { ReolinkCameraMotionSiren } from "./motion-siren";
+export { ReolinkCameraSiren } from "./siren";
+export { ReolinkCameraMotionFloodlight } from "./motion-floodlight";
+export { ReolinkCameraFloodlight } from "./floodlight";
+export { ReolinkCameraPirSensor } from "./pir-sensor";
+export { ReolinkCameraAutotracking } from "./autotracking";

package/src/accessories/motion-floodlight.ts

@@ -0,0 +1,171 @@
+import {
+  Brightness,
+  OnOff,
+  ScryptedDeviceBase,
+  Setting,
+  Settings,
+  SettingValue,
+} from "@scrypted/sdk";
+import { StorageSettings } from "@scrypted/sdk/storage-settings";
+import type { ReolinkCamera } from "../camera";
+
+/**
+ * Motion-floodlight: controls motion detection light (MD light)
+ * This accessory controls the floodlight that turns on when motion is detected.
+ */
+export class ReolinkCameraMotionFloodlight
+  extends ScryptedDeviceBase
+  implements OnOff, Brightness, Settings
+{
+  private get logger(): Console {
+    return this.camera.getBaichuanLogger();
+  }
+
+  storageSettings = new StorageSettings(this, {
+    duration: {
+      title: "Light Duration",
+      description: "How long the light stays on after motion (in seconds)",
+      type: "number",
+      defaultValue: 180,
+      range: [1, 600],
+    },
+    detectType: {
+      title: "Detection Types",
+      description: "Types of objects that trigger the light",
+      type: "string",
+      defaultValue: "people,vehicle,dog_cat",
+      choices: [
+        "people",
+        "vehicle",
+        "dog_cat",
+        "people,vehicle",
+        "people,dog_cat",
+        "vehicle,dog_cat",
+        "people,vehicle,dog_cat",
+      ],
+    },
+  });
+
+  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);
+    // Always apply settings to camera when changed
+    await this.applySettings();
+  }
+
+  private async applySettings(): Promise<void> {
+    const channel = this.camera.storageSettings.values.rtspChannel;
+    const duration = this.storageSettings.values.duration;
+    const detectType = this.storageSettings.values.detectType;
+
+    this.logger.log(
+      `Motion-floodlight applySettings: duration=${duration}, detectType=${detectType}`,
+    );
+
+    try {
+      await this.camera.withBaichuanRetry(async () => {
+        const api = await this.camera.ensureClient();
+        await api.setFloodlightSettings(channel, { duration, detectType });
+      });
+      this.logger.log(`Motion-floodlight applySettings: success`);
+    } catch (e: any) {
+      this.logger.error(
+        `Motion-floodlight applySettings: failed`,
+        e?.message || String(e),
+      );
+      throw e;
+    }
+  }
+
+  async setBrightness(brightness: number): Promise<void> {
+    this.logger.log(
+      `Motion-floodlight toggle: setBrightness (device=${this.nativeId} brightness=${brightness})`,
+    );
+    this.brightness = brightness;
+    try {
+      const channel = this.camera.storageSettings.values.rtspChannel;
+      await this.camera.withBaichuanRetry(async () => {
+        const api = await this.camera.ensureClient();
+        await api.setWhiteLedState(channel, undefined, brightness);
+        // Trust the set operation
+      });
+      this.logger.log(
+        `Motion-floodlight toggle: setBrightness ok (device=${this.nativeId} brightness=${brightness})`,
+      );
+    } catch (e: any) {
+      this.logger.warn(
+        `Motion-floodlight toggle: setBrightness failed (device=${this.nativeId} brightness=${brightness})`,
+        e?.message || String(e),
+      );
+      throw e;
+    }
+  }
+
+  async turnOff(): Promise<void> {
+    this.logger.log(
+      `Motion-floodlight toggle: turnOff (device=${this.nativeId})`,
+    );
+    this.on = false;
+    this.camera.auxDeviceCooldowns.motionFloodlight = Date.now();
+    try {
+      const channel = this.camera.storageSettings.values.rtspChannel;
+      await this.camera.withBaichuanRetry(async () => {
+        const api = await this.camera.ensureClient();
+        // Use setFloodlightOnMotion (cmdId=290 FloodlightTask) for motion-triggered floodlight
+        await api.setFloodlightOnMotion(false, channel);
+        // Trust the set operation - don't read back immediately as camera may have delay
+      });
+      this.logger.log(
+        `Motion-floodlight toggle: turnOff ok (device=${this.nativeId})`,
+      );
+    } catch (e: any) {
+      this.on = true; // Revert on failure
+      this.logger.warn(
+        `Motion-floodlight toggle: turnOff failed (device=${this.nativeId})`,
+        e?.message || String(e),
+      );
+      throw e;
+    }
+  }
+
+  async turnOn(): Promise<void> {
+    this.logger.log(
+      `Motion-floodlight toggle: turnOn (device=${this.nativeId})`,
+    );
+    this.on = true;
+    this.camera.auxDeviceCooldowns.motionFloodlight = Date.now();
+    try {
+      const channel = this.camera.storageSettings.values.rtspChannel;
+      const duration = this.storageSettings.values.duration;
+      const detectType = this.storageSettings.values.detectType;
+      await this.camera.withBaichuanRetry(async () => {
+        const api = await this.camera.ensureClient();
+        // Use setFloodlightOnMotion (cmdId=290 FloodlightTask) for motion-triggered floodlight
+        await api.setFloodlightOnMotion(true, channel);
+        // Apply settings (duration, detectType)
+        await api.setFloodlightSettings(channel, { duration, detectType });
+        // Trust the set operation - don't read back immediately as camera may have delay
+      });
+      this.logger.log(
+        `Motion-floodlight toggle: turnOn ok (device=${this.nativeId})`,
+      );
+    } catch (e: any) {
+      this.on = false; // Revert on failure
+      this.logger.warn(
+        `Motion-floodlight toggle: turnOn failed (device=${this.nativeId})`,
+        e?.message || String(e),
+      );
+      throw e;
+    }
+  }
+}

package/src/accessories/motion-siren.ts

@@ -0,0 +1,165 @@
+import {
+  OnOff,
+  ScryptedDeviceBase,
+  Setting,
+  Settings,
+  SettingValue,
+} from "@scrypted/sdk";
+import { StorageSettings } from "@scrypted/sdk/storage-settings";
+import type { ReolinkCamera } from "../camera";
+
+/**
+ * Motion-siren: controls motion detection alarm (MD alarm)
+ * This accessory triggers the siren when motion is detected based on configured detection types.
+ */
+export class ReolinkCameraMotionSiren
+  extends ScryptedDeviceBase
+  implements OnOff, Settings
+{
+  private get logger(): Console {
+    return this.camera.getBaichuanLogger();
+  }
+
+  storageSettings = new StorageSettings(this, {
+    detectTypes: {
+      title: "Detection Types",
+      description: "Types of motion events that trigger the siren",
+      type: "string",
+      defaultValue: "MD,people,vehicle,dog_cat",
+      choices: [
+        "MD",
+        "people",
+        "vehicle",
+        "dog_cat",
+        "MD,people",
+        "MD,vehicle",
+        "MD,dog_cat",
+        "people,vehicle",
+        "people,dog_cat",
+        "vehicle,dog_cat",
+        "MD,people,vehicle",
+        "MD,people,dog_cat",
+        "MD,vehicle,dog_cat",
+        "people,vehicle,dog_cat",
+        "MD,people,vehicle,dog_cat",
+      ],
+    },
+  });
+
+  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);
+    // Always apply settings to camera when changed (only if siren is enabled)
+    if (this.on) {
+      await this.applySettings();
+    }
+  }
+
+  private async applySettings(): Promise<void> {
+    const channel = this.camera.storageSettings.values.rtspChannel;
+    const typeScheduleList = this.buildTypeScheduleList();
+
+    this.logger.log(
+      `Motion-siren applySettings: detectTypes=${this.storageSettings.values.detectTypes}`,
+    );
+
+    try {
+      await this.camera.withBaichuanRetry(async () => {
+        const api = await this.camera.ensureClient();
+        await api.setSirenOnMotion({ enable: 1, typeScheduleList }, channel);
+      });
+      this.logger.log(`Motion-siren applySettings: success`);
+    } catch (e: any) {
+      this.logger.error(
+        `Motion-siren applySettings: failed`,
+        e?.message || String(e),
+      );
+      throw e;
+    }
+  }
+
+  private buildTypeScheduleList(): Array<{
+    type: string;
+    valueTable: string;
+  }> {
+    const detectTypes = this.storageSettings.values.detectTypes || "";
+    const types = detectTypes.split(",").map((t: string) => t.trim());
+    const allOn = "1".repeat(168);
+    const allOff = "0".repeat(168);
+
+    // Build schedule list for each type
+    return [
+      { type: "MD", valueTable: types.includes("MD") ? allOn : allOff },
+      { type: "people", valueTable: types.includes("people") ? allOn : allOff },
+      {
+        type: "vehicle",
+        valueTable: types.includes("vehicle") ? allOn : allOff,
+      },
+      {
+        type: "dog_cat",
+        valueTable: types.includes("dog_cat") ? allOn : allOff,
+      },
+    ];
+  }
+
+  async turnOff(): Promise<void> {
+    this.logger.log(`Motion-siren toggle: turnOff (device=${this.nativeId})`);
+    this.on = false;
+    this.camera.auxDeviceCooldowns.motionSiren = Date.now();
+    try {
+      const channel = this.camera.storageSettings.values.rtspChannel;
+      await this.camera.withBaichuanRetry(async () => {
+        const api = await this.camera.ensureClient();
+        // Use setSirenOnMotion (cmdId=231 AudioTask) for motion-triggered siren
+        await api.setSirenOnMotion({ enable: 0 }, channel);
+        // Trust the set operation - don't read back immediately as camera may have delay
+      });
+      this.logger.log(
+        `Motion-siren toggle: turnOff ok (device=${this.nativeId})`,
+      );
+    } catch (e: any) {
+      this.on = true; // Revert on failure
+      this.logger.error(
+        `Motion-siren toggle: turnOff failed (device=${this.nativeId})`,
+        e?.message || String(e),
+      );
+      throw e;
+    }
+  }
+
+  async turnOn(): Promise<void> {
+    this.logger.log(`Motion-siren toggle: turnOn (device=${this.nativeId})`);
+    this.on = true;
+    this.camera.auxDeviceCooldowns.motionSiren = Date.now();
+    try {
+      const channel = this.camera.storageSettings.values.rtspChannel;
+      const typeScheduleList = this.buildTypeScheduleList();
+      await this.camera.withBaichuanRetry(async () => {
+        const api = await this.camera.ensureClient();
+        // Use setSirenOnMotion (cmdId=231 AudioTask) for motion-triggered siren
+        await api.setSirenOnMotion({ enable: 1, typeScheduleList }, channel);
+        // Trust the set operation - don't read back immediately as camera may have delay
+      });
+      this.logger.log(
+        `Motion-siren toggle: turnOn ok (device=${this.nativeId})`,
+      );
+    } catch (e: any) {
+      this.on = false; // Revert on failure
+      this.logger.error(
+        `Motion-siren toggle: turnOn failed (device=${this.nativeId})`,
+        e?.message || String(e),
+      );
+      throw e;
+    }
+  }
+}