@apocaliss92/scrypted-reolink-native 0.4.32 → 0.4.34

package/package.json

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

package/src/camera.ts

@@ -16,7 +16,6 @@ import sdk, {
   ChargeState,
   Device,
   DeviceProvider,
-  Intercom,
   MediaObject,
   MediaStreamUrl,
   ObjectDetectionTypes,
@@ -65,7 +64,6 @@ import {
   getApiRelevantDebugLogs,
   getDebugLogChoices,
 } from "./debug-options";
-import { ReolinkBaichuanIntercom } from "./intercom";
 import ReolinkNativePlugin from "./main";
 import { ReolinkNativeMultiFocalDevice } from "./multiFocal";
 import { ReolinkNativeNvrDevice } from "./nvr";
@@ -115,7 +113,6 @@ export class ReolinkCamera
     PanTiltZoom,
     VideoTextOverlays,
     BinarySensor,
-    Intercom,
     Reboot,
     VideoClips
 {
@@ -280,30 +277,6 @@ export class ReolinkCamera
       json: true,
       defaultValue: [],
     },
-    intercomBlocksPerPayload: {
-      group: "Intercom",
-      title: "Blocks Per Payload",
-      description:
-        "Lower reduces latency (more packets). Typical: 1-4. Requires restarting talk session to take effect.",
-      type: "number",
-      defaultValue: 1,
-    },
-    intercomMaxBacklogMs: {
-      group: "Intercom",
-      title: "Max Backlog (ms)",
-      description:
-        "Maximum PCM backlog before dropping old audio to cap latency. Higher improves stability on slow systems but increases latency. Typical: 80-250. Requires restarting talk session to take effect.",
-      type: "number",
-      defaultValue: 120,
-    },
-    intercomGain: {
-      group: "Intercom",
-      title: "Gain",
-      description:
-        "Output gain multiplier applied before encoding. 1.0 = normal, 2.0 ≈ +6dB, 0.5 ≈ -6dB. Requires restarting talk session to take effect.",
-      type: "number",
-      defaultValue: 1.0,
-    },
     // PTZ Presets
     presets: {
       group: "PTZ",
@@ -459,24 +432,6 @@ export class ReolinkCamera
       defaultValue: 60,
       hide: true,
     },
-    lowThresholdBatteryRecording: {
-      title: "Low Threshold Battery Recording (%)",
-      subgroup: "Recording",
-      description:
-        "Battery level threshold below which recording is disabled (default: 15%).",
-      type: "number",
-      defaultValue: 15,
-      hide: true,
-    },
-    highThresholdBatteryRecording: {
-      title: "High Threshold Battery Recording (%)",
-      subgroup: "Recording",
-      description:
-        "Battery level threshold above which recording is enabled (default: 35%).",
-      type: "number",
-      defaultValue: 35,
-      hide: true,
-    },
     diagnosticsOutputPath: {
       title: "Diagnostics Output Path",
       subgroup: "Diagnostics",
@@ -696,7 +651,6 @@ export class ReolinkCamera
   classes: string[] = [];
   presets: PtzPreset[] = [];
   streamManager?: StreamManager;
-  intercom?: ReolinkBaichuanIntercom;
 
   motionSiren?: ReolinkCameraMotionSiren;
   siren?: ReolinkCameraSiren;
@@ -2570,23 +2524,6 @@ export class ReolinkCamera
     return [];
   }
 
-  // Intercom interface methods
-  async startIntercom(media: MediaObject): Promise<void> {
-    if (this.intercom) {
-      await this.intercom.start(media);
-    } else {
-      throw new Error("Intercom not initialized");
-    }
-  }
-
-  async stopIntercom(): Promise<void> {
-    if (this.intercom) {
-      return await this.intercom.stop();
-    } else {
-      throw new Error("Intercom not initialized");
-    }
-  }
-
   async updateDeviceInfo(): Promise<void> {
     const logger = this.getBaichuanLogger();
 
@@ -3301,10 +3238,6 @@ export class ReolinkCamera
 
     this.storageSettings.settings.batteryUpdateIntervalMinutes.hide =
       !this.isBattery;
-    this.storageSettings.settings.lowThresholdBatteryRecording.hide =
-      !this.isBattery;
-    this.storageSettings.settings.highThresholdBatteryRecording.hide =
-      !this.isBattery;
 
     // Show PIP settings only for multifocal devices
     this.storageSettings.settings.pipPosition.hide = !this.isMultiFocal;
@@ -3362,11 +3295,7 @@ export class ReolinkCamera
       );
     }
 
-    const { hasIntercom, hasPtz } = await this.getAbilities();
-
-    if (hasIntercom) {
-      this.intercom = new ReolinkBaichuanIntercom(this);
-    }
+    const { hasPtz } = await this.getAbilities();
 
     if (hasPtz && !this.multiFocalDevice) {
       const choices = (this.presets || []).map(
@@ -3532,44 +3461,6 @@ export class ReolinkCamera
     }
   }
 
-  async checkRecordingAction(newBatteryLevel: number) {
-    const nvrDeviceId = this.plugin.nvrDeviceId;
-    if (nvrDeviceId && this.mixins.includes(nvrDeviceId)) {
-      const logger = this.getBaichuanLogger();
-
-      const settings = await this.thisDevice.getSettings();
-      const isPrivacyEnabled =
-        settings.find((s) => s.key === "prebuffer:privacyMode")?.value ||
-        settings.find((s) => s.key === "recording:privacyMode")?.value ||
-        settings.find((s) => s.key === "snapshot:privacyMode")?.value;
-      const { lowThresholdBatteryRecording, highThresholdBatteryRecording } =
-        this.storageSettings.values;
-
-      if (!isPrivacyEnabled && newBatteryLevel < lowThresholdBatteryRecording) {
-        logger.log(
-          `Battery level is below low threshold (${newBatteryLevel}% < ${lowThresholdBatteryRecording}%), enabling privacy mode`,
-        );
-        await Promise.all([
-          this.thisDevice.putSetting("prebuffer:privacyMode", true),
-          this.thisDevice.putSetting("recording:privacyMode", true),
-          this.thisDevice.putSetting("snapshot:privacyMode", true),
-        ]);
-      } else if (
-        isPrivacyEnabled &&
-        newBatteryLevel > highThresholdBatteryRecording
-      ) {
-        logger.log(
-          `Battery level is above high threshold (${newBatteryLevel}% > ${highThresholdBatteryRecording}%), disabling privacy mode`,
-        );
-        await Promise.all([
-          this.thisDevice.putSetting("prebuffer:privacyMode", false),
-          this.thisDevice.putSetting("recording:privacyMode", false),
-          this.thisDevice.putSetting("snapshot:privacyMode", false),
-        ]);
-      }
-    }
-  }
-
   async updateBatteryInfo(batteryInfoParent?: BatteryInfo) {
     const api = await this.ensureClient();
     const channel = this.storageSettings.values.rtspChannel;
@@ -3603,8 +3494,6 @@ export class ReolinkCamera
         this.chargeState = newChargeState;
       }
 
-      let shouldCheckRecordingAction = true;
-
       // Log only if battery level changed
       if (oldLevel !== batteryInfo.batteryPercent) {
         if (batteryInfo.adapterStatus !== undefined) {
@@ -3625,8 +3514,6 @@ export class ReolinkCamera
         } else {
           logger.log(`Battery level set: ${batteryInfo.batteryPercent}%`);
         }
-      } else {
-        shouldCheckRecordingAction = false;
       }
 
       // Forward battery/charge state changes to Scrypted (plugin, HomeKit, etc.)
@@ -3641,10 +3528,6 @@ export class ReolinkCamera
           void this.onDeviceEvent(ScryptedInterface.Charger, undefined);
         }
       }
-
-      if (shouldCheckRecordingAction) {
-        await this.checkRecordingAction(batteryInfo.batteryPercent);
-      }
     }
 
     return batteryInfo;

package/src/intercom-mixin.ts

@@ -0,0 +1,302 @@
+import type { ReolinkBaichuanApi } from "@apocaliss92/reolink-baichuan-js" with {
+  "resolution-mode": "import",
+};
+import sdk, {
+  Intercom,
+  MediaObject,
+  Setting,
+  Settings,
+  SettingValue,
+} from "@scrypted/sdk";
+import {
+  SettingsMixinDeviceBase,
+  SettingsMixinDeviceOptions,
+} from "@scrypted/sdk/settings-mixin";
+import { StorageSettings } from "@scrypted/sdk/storage-settings";
+import type { BaichuanTransport } from "./connect";
+import type { ReolinkNativeIntercom } from "./intercom-provider";
+import { ReolinkBaichuanIntercom, type IntercomHost } from "./intercom";
+import type { ReolinkCamera } from "./camera";
+
+export class ReolinkNativeIntercomMixin
+  extends SettingsMixinDeviceBase<any>
+  implements Intercom, Settings
+{
+  private intercomEngine?: ReolinkBaichuanIntercom;
+
+  storageSettings = new StorageSettings(this, {
+    // Connection settings (hidden when attached to an internal Reolink Native camera)
+    intercomIpAddress: {
+      group: "Connection",
+      title: "IP Address",
+      description: "Camera IP address for Baichuan connection",
+      type: "string",
+    },
+    intercomUsername: {
+      group: "Connection",
+      title: "Username",
+      type: "string",
+      defaultValue: "admin",
+    },
+    intercomPassword: {
+      group: "Connection",
+      title: "Password",
+      type: "password",
+    },
+    intercomUid: {
+      group: "Connection",
+      title: "UID",
+      description: "Required for battery/UDP cameras",
+      type: "string",
+    },
+    intercomChannel: {
+      group: "Connection",
+      title: "Channel",
+      description: "RTSP channel number (0-based)",
+      type: "number",
+      defaultValue: 0,
+    },
+    intercomTransport: {
+      group: "Connection",
+      title: "Transport",
+      description: "Connection transport protocol",
+      type: "string",
+      choices: ["tcp", "udp"],
+      defaultValue: "tcp",
+    },
+    // Audio pipeline settings (always visible)
+    intercomBlocksPerPayload: {
+      group: "Audio",
+      title: "Blocks Per Payload",
+      description:
+        "Lower reduces latency (more packets). Typical: 1-4. Requires restarting talk session to take effect.",
+      type: "number",
+      defaultValue: 1,
+    },
+    intercomMaxBacklogMs: {
+      group: "Audio",
+      title: "Max Backlog (ms)",
+      description:
+        "Maximum PCM backlog before dropping old audio to cap latency. Higher improves stability on slow systems but increases latency. Typical: 80-250. Requires restarting talk session to take effect.",
+      type: "number",
+      defaultValue: 120,
+    },
+    intercomGain: {
+      group: "Audio",
+      title: "Gain",
+      description:
+        "Output gain multiplier applied before encoding. 1.0 = normal, 2.0 ≈ +6dB, 0.5 ≈ -6dB. Requires restarting talk session to take effect.",
+      type: "number",
+      defaultValue: 1.0,
+    },
+  });
+
+  constructor(
+    options: SettingsMixinDeviceOptions<any>,
+    public provider: ReolinkNativeIntercom,
+  ) {
+    super(options);
+    this.provider.currentMixinsMap[this.id] = this;
+  }
+
+  private getInternalCamera(): ReolinkCamera | undefined {
+    return this.provider.plugin?.camerasMap?.get(this.id);
+  }
+
+  private isReolinkPluginCamera(): boolean {
+    try {
+      const device = sdk.systemManager.getDeviceById(this.id);
+      return device?.pluginId === "@scrypted/reolink";
+    } catch {
+      return false;
+    }
+  }
+
+  private async getReolinkPluginCredentials(): Promise<
+    { host?: string; username?: string; password?: string } | undefined
+  > {
+    if (!this.isReolinkPluginCamera()) return undefined;
+
+    try {
+      const settings: Setting[] = await this.mixinDevice.getSettings();
+      const map = new Map(
+        settings.map((s: Setting) => [s.key, s.value?.toString()]),
+      );
+
+      // Non-NVR cameras use "ip", NVR child cameras use "ipAddress"
+      const host = map.get("ip") || map.get("ipAddress");
+      const username = map.get("username");
+      const password = map.get("password");
+
+      return { host, username, password };
+    } catch {
+      return undefined;
+    }
+  }
+
+  private buildHost(): IntercomHost {
+    const self = this;
+    const internalCamera = this.getInternalCamera();
+
+    if (internalCamera) {
+      return {
+        get blocksPerPayload() {
+          return Math.max(
+            1,
+            Math.min(
+              8,
+              self.storageSettings.values.intercomBlocksPerPayload ?? 1,
+            ),
+          );
+        },
+        get outputGain() {
+          const v = Number(self.storageSettings.values.intercomGain);
+          return Number.isFinite(v) ? Math.max(0.1, Math.min(10, v)) : 1.0;
+        },
+        get maxBacklogMs() {
+          const v = Number(self.storageSettings.values.intercomMaxBacklogMs);
+          return Number.isFinite(v) ? Math.max(20, Math.min(5000, v)) : 120;
+        },
+        get channel() {
+          return internalCamera.storageSettings.values.rtspChannel;
+        },
+        get isBatteryCamera() {
+          return internalCamera.isBattery;
+        },
+        get deviceId() {
+          return internalCamera.nativeId;
+        },
+        get logger() {
+          return internalCamera.getBaichuanLogger();
+        },
+        ensureApi: () => internalCamera.ensureBaichuanClient(),
+        withRetry: (fn) => internalCamera.withBaichuanRetry(fn),
+      };
+    }
+
+    // External path: use shared client from plugin registry
+    return {
+      get blocksPerPayload() {
+        return Math.max(
+          1,
+          Math.min(
+            8,
+            self.storageSettings.values.intercomBlocksPerPayload ?? 1,
+          ),
+        );
+      },
+      get outputGain() {
+        const v = Number(self.storageSettings.values.intercomGain);
+        return Number.isFinite(v) ? Math.max(0.1, Math.min(10, v)) : 1.0;
+      },
+      get maxBacklogMs() {
+        const v = Number(self.storageSettings.values.intercomMaxBacklogMs);
+        return Number.isFinite(v) ? Math.max(20, Math.min(5000, v)) : 120;
+      },
+      get channel() {
+        return self.storageSettings.values.intercomChannel ?? 0;
+      },
+      get isBatteryCamera() {
+        return self.storageSettings.values.intercomTransport === "udp";
+      },
+      get deviceId() {
+        return self.id;
+      },
+      get logger() {
+        return self.console;
+      },
+      ensureApi: () => self.ensureExternalApi(),
+      withRetry: (fn) => fn(),
+    };
+  }
+
+  private async ensureExternalApi(): Promise<ReolinkBaichuanApi> {
+    let { intercomIpAddress, intercomUsername, intercomPassword,
+          intercomUid, intercomTransport } =
+      this.storageSettings.values;
+
+    // Auto-detect credentials from @scrypted/reolink camera settings
+    if (!intercomIpAddress || !intercomUsername || !intercomPassword) {
+      const creds = await this.getReolinkPluginCredentials();
+      if (creds) {
+        intercomIpAddress ||= creds.host;
+        intercomUsername ||= creds.username;
+        intercomPassword ||= creds.password;
+      }
+    }
+
+    if (!intercomIpAddress || !intercomUsername || !intercomPassword) {
+      throw new Error(
+        "Intercom connection settings incomplete: IP, username, and password are required",
+      );
+    }
+
+    const transport: BaichuanTransport =
+      intercomTransport === "udp" ? "udp" : "tcp";
+
+    return await this.provider.plugin.acquireExternalClient(this.id, {
+      host: intercomIpAddress,
+      username: intercomUsername,
+      password: intercomPassword,
+      uid: intercomUid,
+      transport,
+      logger: this.console,
+    });
+  }
+
+  async startIntercom(media: MediaObject): Promise<void> {
+    const host = this.buildHost();
+    this.intercomEngine = new ReolinkBaichuanIntercom(host);
+    await this.intercomEngine.start(media);
+  }
+
+  async stopIntercom(): Promise<void> {
+    if (this.intercomEngine) {
+      await this.intercomEngine.stop();
+      this.intercomEngine = undefined;
+    }
+  }
+
+  async getMixinSettings(): Promise<Setting[]> {
+    const isInternal = !!this.getInternalCamera();
+    const isReolinkPlugin = this.isReolinkPluginCamera();
+    const hideConnection = isInternal || isReolinkPlugin;
+    const settings = await this.storageSettings.getSettings();
+
+    const connectionKeys = new Set([
+      "intercomIpAddress",
+      "intercomUsername",
+      "intercomPassword",
+      "intercomUid",
+      "intercomChannel",
+      "intercomTransport",
+    ]);
+
+    for (const setting of settings) {
+      if (connectionKeys.has(setting.key)) {
+        (setting as any).hide = hideConnection;
+      }
+    }
+
+    return settings;
+  }
+
+  async putMixinSetting(
+    key: string,
+    value: SettingValue,
+  ): Promise<void> {
+    await this.storageSettings.putSetting(key, value);
+  }
+
+  async release(): Promise<void> {
+    if (this.intercomEngine) {
+      await this.intercomEngine.stop();
+      this.intercomEngine = undefined;
+    }
+    // Release external client if not internal
+    if (!this.getInternalCamera()) {
+      await this.provider.plugin?.releaseExternalClient(this.id);
+    }
+    delete this.provider.currentMixinsMap[this.id];
+  }
+}

package/src/intercom-provider.ts

@@ -0,0 +1,130 @@
+import sdk, {
+  MixinProvider,
+  ScryptedDevice,
+  ScryptedDeviceBase,
+  ScryptedDeviceType,
+  ScryptedInterface,
+  Setting,
+  Settings,
+  SettingValue,
+  WritableDeviceState,
+} from "@scrypted/sdk";
+import type ReolinkNativePlugin from "./main";
+import { ReolinkNativeIntercomMixin } from "./intercom-mixin";
+
+export const INTERCOM_PROVIDER_NATIVE_ID = "reolink-native-intercom";
+
+const AUTO_INCLUDE_TOKEN = "v1";
+
+export class ReolinkNativeIntercom
+  extends ScryptedDeviceBase
+  implements MixinProvider, Settings
+{
+  currentMixinsMap: Record<string, ReolinkNativeIntercomMixin> = {};
+  plugin: ReolinkNativePlugin;
+  private hasEnabledMixin: Record<string, string> = {};
+  private pluginsComponent: Promise<any>;
+
+  constructor(nativeId: string) {
+    super(nativeId);
+
+    try {
+      this.hasEnabledMixin = JSON.parse(
+        this.storage.getItem("hasEnabledMixin") || "{}",
+      );
+    } catch {
+      this.hasEnabledMixin = {};
+    }
+
+    this.pluginsComponent = sdk.systemManager.getComponent("plugins");
+
+    // Watch for new device descriptors to auto-enable on newly added devices
+    sdk.systemManager.listen((eventSource, eventDetails) => {
+      if (
+        eventDetails.eventInterface !== ScryptedInterface.ScryptedDevice ||
+        eventDetails.property
+      )
+        return;
+      this.maybeEnableMixin(eventSource);
+    });
+
+    // Check all existing devices on startup
+    process.nextTick(() => {
+      for (const id of Object.keys(sdk.systemManager.getSystemState())) {
+        const device = sdk.systemManager.getDeviceById(id);
+        this.maybeEnableMixin(device);
+      }
+    });
+  }
+
+  private async maybeEnableMixin(device: ScryptedDevice) {
+    if (!device || device.mixins?.includes(this.id)) return;
+
+    // Already auto-enabled once with this token
+    if (this.hasEnabledMixin[device.id] === AUTO_INCLUDE_TOKEN) return;
+
+    const match = await this.canMixin(device.type, device.interfaces);
+    if (!match) return;
+
+    // Only auto-enable for cameras provided by our own plugin
+    if (!this.plugin?.camerasMap?.has(device.id)) return;
+
+    this.console.log(`Auto-enabling intercom mixin for ${device.name}`);
+    const mixins = (device.mixins || []).slice();
+    mixins.push(this.id);
+    const plugins = await this.pluginsComponent;
+    await plugins.setMixins(device.id, mixins);
+
+    this.hasEnabledMixin[device.id] = AUTO_INCLUDE_TOKEN;
+    this.storage.setItem(
+      "hasEnabledMixin",
+      JSON.stringify(this.hasEnabledMixin),
+    );
+  }
+
+  async canMixin(
+    type: ScryptedDeviceType,
+    interfaces: string[],
+  ): Promise<string[] | null> {
+    if (
+      (type === ScryptedDeviceType.Camera ||
+        type === ScryptedDeviceType.Doorbell) &&
+      interfaces.includes(ScryptedInterface.VideoCamera)
+    ) {
+      return [ScryptedInterface.Intercom, ScryptedInterface.Settings];
+    }
+    return null;
+  }
+
+  async getMixin(
+    mixinDevice: any,
+    mixinDeviceInterfaces: ScryptedInterface[],
+    mixinDeviceState: WritableDeviceState,
+  ): Promise<any> {
+    return new ReolinkNativeIntercomMixin(
+      {
+        mixinDevice,
+        mixinDeviceInterfaces,
+        mixinDeviceState,
+        mixinProviderNativeId: this.nativeId,
+        group: "Reolink Native Intercom",
+        groupKey: "reolinkNativeIntercom",
+      },
+      this,
+    );
+  }
+
+  async releaseMixin(id: string, mixinDevice: any): Promise<void> {
+    const mixin = this.currentMixinsMap[id];
+    if (mixin) {
+      await mixin.release();
+      delete this.currentMixinsMap[id];
+    }
+  }
+
+  async getSettings(): Promise<Setting[]> {
+    return [];
+  }
+
+  async putSetting(key: string, value: SettingValue): Promise<void> {}
+}