@apocaliss92/scrypted-reolink-native 0.4.32 → 0.4.34

package/src/intercom.ts

@@ -7,7 +7,22 @@ import sdk, {
   ScryptedMimeTypes,
 } from "@scrypted/sdk";
 import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
-import { ReolinkCamera } from "./camera";
+
+/**
+ * Abstraction over the camera-specific dependencies needed by the intercom engine.
+ * Both ReolinkCamera (internal) and IntercomMixin (standalone) can implement this.
+ */
+export interface IntercomHost {
+  readonly blocksPerPayload: number;
+  readonly outputGain: number;
+  readonly maxBacklogMs: number;
+  readonly channel: number;
+  readonly isBatteryCamera: boolean;
+  readonly deviceId: string;
+  readonly logger: Console;
+  ensureApi(): Promise<ReolinkBaichuanApi>;
+  withRetry<T>(fn: () => Promise<T>): Promise<T>;
+}
 
 // Keep this low: Reolink blocks are ~64ms at 16kHz (1025 samples).
 // A small backlog avoids multi-second latency when the pipeline stalls.
@@ -33,28 +48,10 @@ export class ReolinkBaichuanIntercom {
 
   private lastBacklogClampLogAtMs = 0;
 
-  constructor(private camera: ReolinkCamera) {}
-
-  get blocksPerPayload(): number {
-    return Math.max(
-      1,
-      Math.min(
-        8,
-        this.camera.storageSettings.values.intercomBlocksPerPayload ?? 1,
-      ),
-    );
-  }
-
-  private get outputGain(): number {
-    const configured = Number(this.camera.storageSettings.values.intercomGain);
-    // Keep safe bounds: too high can clip and distort.
-    if (Number.isFinite(configured))
-      return Math.max(0.1, Math.min(10, configured));
-    return 1.0;
-  }
+  constructor(private host: IntercomHost) {}
 
   async start(media: MediaObject): Promise<void> {
-    const logger = this.camera.getBaichuanLogger();
+    const logger = this.host.logger;
 
     const ffmpegInput =
       await sdk.mediaManager.convertMediaObjectToJSON<FFmpegInput>(
@@ -63,12 +60,12 @@ export class ReolinkBaichuanIntercom {
       );
 
     await this.stop();
-    const channel = this.camera.storageSettings.values.rtspChannel;
+    const channel = this.host.channel;
 
     try {
       // Get the main API - library manages dedicated sockets internally
-      const api = await this.camera.withBaichuanRetry(async () => {
-        return await this.camera.ensureBaichuanClient();
+      const api = await this.host.withRetry(async () => {
+        return await this.host.ensureApi();
       });
 
       // Best-effort: log codec requirements exposed by the camera.
@@ -91,7 +88,7 @@ export class ReolinkBaichuanIntercom {
       }
 
       // For UDP/battery cameras, wake up the camera if it's sleeping before creating talk session
-      if (this.camera.options?.type === "battery") {
+      if (this.host.isBatteryCamera) {
         try {
           const sleepStatus = api.getSleepStatus({ channel });
           if (sleepStatus.state === "sleeping") {
@@ -110,11 +107,12 @@ export class ReolinkBaichuanIntercom {
 
       // Use createDedicatedTalkSession - library manages dedicated socket internally
       // with auto-teardown on idle or when stop() is called
-      const session = await this.camera.withBaichuanRetry(async () => {
+      const blocksPerPayload = this.host.blocksPerPayload;
+      const session = await this.host.withRetry(async () => {
         return await api.createDedicatedTalkSession(channel, {
-          blocksPerPayload: this.blocksPerPayload,
+          blocksPerPayload,
           idleTimeoutMs: 30000, // Auto-teardown if no audio for 30s
-          deviceId: this.camera.nativeId,
+          deviceId: this.host.deviceId,
           logger,
         });
       });
@@ -130,9 +128,7 @@ export class ReolinkBaichuanIntercom {
       // Configurable backlog to trade latency vs stability.
       // If the pipeline (ffmpeg decode + encode + send) can't keep up,
       // dropping old audio avoids accumulating multi-second latency.
-      const configuredBacklog = Number(
-        this.camera.storageSettings.values.intercomMaxBacklogMs,
-      );
+      const configuredBacklog = Number(this.host.maxBacklogMs);
       if (Number.isFinite(configuredBacklog)) {
         this.maxBacklogMs = Math.max(20, Math.min(5000, configuredBacklog));
       } else {
@@ -177,12 +173,12 @@ export class ReolinkBaichuanIntercom {
         bytesNeeded,
         maxBacklogMs: this.maxBacklogMs,
         maxBacklogBytes: this.maxBacklogBytes,
-        blocksPerPayload: this.blocksPerPayload,
+        blocksPerPayload,
       });
 
       // IMPORTANT: incoming audio from Scrypted/WebRTC is typically Opus.
       // We must decode to PCM before IMA ADPCM encoding, otherwise it will be noise.
-      const gain = this.outputGain;
+      const gain = this.host.outputGain;
       const ffmpegArgs = this.buildFfmpegPcmArgs(ffmpegInput, {
         sampleRate,
         channels: 1,
@@ -260,7 +256,7 @@ export class ReolinkBaichuanIntercom {
     if (this.stopping) return this.stopping;
 
     this.stopping = (async () => {
-      const logger = this.camera.getBaichuanLogger();
+      const logger = this.host.logger;
 
       const ffmpeg = this.ffmpeg;
       this.ffmpeg = undefined;
@@ -329,7 +325,7 @@ export class ReolinkBaichuanIntercom {
     bytesNeeded: number,
     blockSize: number,
   ): void {
-    const logger = this.camera.getBaichuanLogger();
+    const logger = this.host.logger;
 
     if (this.session !== session) return;
 

package/src/main.ts

@@ -11,7 +11,7 @@ if (typeof globalThis.File === "undefined") {
   };
 }
 
-import type { AutoDetectMode } from "@apocaliss92/reolink-baichuan-js" with {
+import type { AutoDetectMode, ReolinkBaichuanApi } from "@apocaliss92/reolink-baichuan-js" with {
   "resolution-mode": "import"
 };
 import sdk, {
@@ -29,6 +29,11 @@ import sdk, {
 import { randomBytes } from "crypto";
 import { BaseBaichuanClass } from "./baichuan-base";
 import { ReolinkCamera } from "./camera";
+import { createBaichuanApi, normalizeUid, type BaichuanTransport } from "./connect";
+import {
+  ReolinkNativeIntercom,
+  INTERCOM_PROVIDER_NATIVE_ID,
+} from "./intercom-provider";
 import { ReolinkNativeMultiFocalDevice } from "./multiFocal";
 import { ReolinkNativeNvrDevice } from "./nvr";
 import {
@@ -49,19 +54,92 @@ class ReolinkNativePlugin
   devices = new Map<string, BaseBaichuanClass>();
   camerasMap = new Map<string, ReolinkCamera>();
   nvrDeviceId: string;
+  private intercomProvider?: ReolinkNativeIntercom;
+
+  // Shared Baichuan API connections for external devices (non-Reolink Native cameras).
+  // Keyed by Scrypted device ID. Multiple mixins on the same device share one connection.
+  private externalClients = new Map<
+    string,
+    { api: ReolinkBaichuanApi; refCount: number }
+  >();
 
   constructor(nativeId: string) {
     super(nativeId);
 
     const nvrDevice = sdk.systemManager.getDeviceByName("Scrypted NVR");
     this.nvrDeviceId = nvrDevice?.id;
+
+    // Register the intercom MixinProvider as a sub-device
+    sdk.deviceManager.onDeviceDiscovered({
+      nativeId: INTERCOM_PROVIDER_NATIVE_ID,
+      name: "Reolink Native Intercom",
+      interfaces: [ScryptedInterface.MixinProvider, ScryptedInterface.Settings],
+      type: ScryptedDeviceType.API,
+      providerNativeId: this.nativeId,
+    });
+  }
+
+  async acquireExternalClient(
+    deviceId: string,
+    config: {
+      host: string;
+      username: string;
+      password: string;
+      uid?: string;
+      transport: BaichuanTransport;
+      logger?: Console;
+    },
+  ): Promise<ReolinkBaichuanApi> {
+    const existing = this.externalClients.get(deviceId);
+    if (existing?.api?.isReady) {
+      existing.refCount++;
+      return existing.api;
+    }
+    // Close stale client if any
+    if (existing?.api) {
+      try {
+        await existing.api.close();
+      } catch {}
+    }
+    const api = await createBaichuanApi({
+      inputs: {
+        host: config.host,
+        username: config.username,
+        password: config.password,
+        uid: normalizeUid(config.uid),
+        logger: config.logger,
+      },
+      transport: config.transport,
+    });
+    this.externalClients.set(deviceId, { api, refCount: 1 });
+    return api;
+  }
+
+  async releaseExternalClient(deviceId: string): Promise<void> {
+    const entry = this.externalClients.get(deviceId);
+    if (!entry) return;
+    entry.refCount--;
+    if (entry.refCount <= 0) {
+      this.externalClients.delete(deviceId);
+      try {
+        await entry.api.close();
+      } catch {}
+    }
   }
 
   getScryptedDeviceCreator(): string {
     return "Reolink Native camera";
   }
 
-  async getDevice(nativeId: ScryptedNativeId): Promise<BaseBaichuanClass> {
+  async getDevice(nativeId: ScryptedNativeId): Promise<any> {
+    if (nativeId === INTERCOM_PROVIDER_NATIVE_ID) {
+      if (!this.intercomProvider) {
+        this.intercomProvider = new ReolinkNativeIntercom(nativeId);
+        this.intercomProvider.plugin = this;
+      }
+      return this.intercomProvider;
+    }
+
     if (this.devices.has(nativeId)) {
       return this.devices.get(nativeId)!;
     }

package/src/utils.ts

@@ -78,7 +78,6 @@ export const getDeviceInterfaces = (props: {
       hasFloodlight,
       hasPir,
       hasBattery,
-      hasIntercom,
       isDoorbell,
     } = capabilities;
 
@@ -91,9 +90,6 @@ export const getDeviceInterfaces = (props: {
     if (hasBattery) {
       interfaces.push(ScryptedInterface.Battery, ScryptedInterface.Sleep, ScryptedInterface.Charger);
     }
-    if (hasIntercom) {
-      interfaces.push(ScryptedInterface.Intercom);
-    }
     if (isDoorbell) {
       interfaces.push(ScryptedInterface.BinarySensor);
     }