react-jssip-kit 0.6.9 → 0.7.1

package/dist/index.cjs

@@ -679,6 +679,23 @@ var WebRTCSessionController = class {
       old.stop();
     return true;
   }
+  async replaceAudioTrack(nextAudioTrack) {
+    const pc = this.getPC();
+    if (!pc)
+      return false;
+    if (!this.mediaStream)
+      this.mediaStream = new MediaStream();
+    const old = this.mediaStream.getAudioTracks()[0];
+    this.mediaStream.addTrack(nextAudioTrack);
+    if (old)
+      this.mediaStream.removeTrack(old);
+    const sender = pc.getSenders?.().find((s) => s.track?.kind === "audio");
+    if (sender)
+      await sender.replaceTrack(nextAudioTrack);
+    if (old && old !== nextAudioTrack)
+      old.stop();
+    return true;
+  }
 };
 
 // src/jssip-lib/sip/sessionManager.ts
@@ -886,6 +903,12 @@ var SipClient = class extends EventTargetEmitter {
     this.sessionHandlers = /* @__PURE__ */ new Map();
     this.maxSessionCount = Infinity;
     this.sessionManager = new SessionManager();
+    this.micRecovery = /* @__PURE__ */ new Map();
+    this.micRecoveryEnabled = false;
+    this.micRecoveryDefaults = {
+      intervalMs: 2e3,
+      maxRetries: Infinity
+    };
     this.errorHandler = options.errorHandler ?? new SipErrorHandler({
       formatter: options.formatError,
       messages: options.errorMessages
@@ -919,11 +942,21 @@ var SipClient = class extends EventTargetEmitter {
     this.stateStore.setState({ sipStatus: SipStatus.Connecting });
     const {
       debug: cfgDebug,
+      enableMicRecovery,
+      micRecoveryIntervalMs,
+      micRecoveryMaxRetries,
       maxSessionCount,
       pendingMediaTtlMs,
       ...uaCfg
     } = config;
     this.maxSessionCount = typeof maxSessionCount === "number" ? maxSessionCount : Infinity;
+    this.micRecoveryEnabled = Boolean(enableMicRecovery);
+    if (typeof micRecoveryIntervalMs === "number") {
+      this.micRecoveryDefaults.intervalMs = micRecoveryIntervalMs;
+    }
+    if (typeof micRecoveryMaxRetries === "number") {
+      this.micRecoveryDefaults.maxRetries = micRecoveryMaxRetries;
+    }
     this.sessionManager.setPendingMediaTtl(pendingMediaTtlMs);
     const debug = cfgDebug ?? this.getPersistedDebug() ?? this.debugPattern;
     this.userAgent.start(uri, password, uaCfg, { debug });
@@ -1012,6 +1045,9 @@ var SipClient = class extends EventTargetEmitter {
       if (h)
         session.on(ev, h);
     });
+    if (this.micRecoveryEnabled) {
+      this.enableMicrophoneRecovery(sessionId);
+    }
   }
   detachSessionHandlers(sessionId, session) {
     const handlers = this.sessionHandlers.get(sessionId);
@@ -1037,11 +1073,14 @@ var SipClient = class extends EventTargetEmitter {
   cleanupSession(sessionId, session) {
     const targetSession = session ?? this.sessionManager.getSession(sessionId) ?? this.sessionManager.getRtc(sessionId)?.currentSession;
     this.detachSessionHandlers(sessionId, targetSession);
+    this.disableMicrophoneRecovery(sessionId);
     this.sessionManager.cleanupSession(sessionId);
     removeSessionState(this.stateStore, sessionId);
   }
   cleanupAllSessions() {
     this.sessionManager.cleanupAllSessions();
+    this.micRecovery.forEach((entry) => entry.stop());
+    this.micRecovery.clear();
     this.sessionHandlers.clear();
     this.stateStore.setState({
       sessions: [],
@@ -1103,6 +1142,9 @@ var SipClient = class extends EventTargetEmitter {
     if (!sessionId || !this.sessionExists(sessionId))
       return false;
     const opts = this.ensureMediaConstraints(options);
+    if (opts.mediaStream) {
+      this.sessionManager.setSessionMedia(sessionId, opts.mediaStream);
+    }
     return this.sessionManager.answer(sessionId, opts);
   }
   hangupSession(sessionId, options) {
@@ -1160,6 +1202,92 @@ var SipClient = class extends EventTargetEmitter {
   setSessionMedia(sessionId, stream) {
     this.sessionManager.setSessionMedia(sessionId, stream);
   }
+  enableMicrophoneRecovery(sessionId, options = {}) {
+    const resolved = this.resolveExistingSessionId(sessionId);
+    if (!resolved)
+      return () => {
+      };
+    this.disableMicrophoneRecovery(resolved);
+    const intervalMs = options.intervalMs ?? this.micRecoveryDefaults.intervalMs;
+    const maxRetries = options.maxRetries ?? this.micRecoveryDefaults.maxRetries;
+    let retries = 0;
+    let stopped = false;
+    const tick = async () => {
+      if (stopped || retries >= maxRetries)
+        return;
+      const rtc = this.sessionManager.getRtc(resolved);
+      const session2 = this.sessionManager.getSession(resolved);
+      if (!rtc || !session2)
+        return;
+      const sessionState = this.stateStore.getState().sessions.find((s) => s.id === resolved);
+      if (sessionState?.muted)
+        return;
+      const stream = rtc.mediaStream;
+      const track = stream?.getAudioTracks?.()[0];
+      const sender = session2?.connection?.getSenders?.().find((s) => s.track?.kind === "audio");
+      const trackLive = track?.readyState === "live";
+      const senderLive = sender?.track?.readyState === "live";
+      if (trackLive && senderLive)
+        return;
+      this.emitError(
+        {
+          cause: "microphone dropped",
+          trackLive,
+          senderLive
+        },
+        "MICROPHONE_DROPPED",
+        "microphone dropped"
+      );
+      retries += 1;
+      if (trackLive && !senderLive && track) {
+        await rtc.replaceAudioTrack(track);
+        return;
+      }
+      let nextStream;
+      try {
+        const deviceId = track?.getSettings?.().deviceId ?? sender?.track?.getSettings?.().deviceId;
+        nextStream = await this.requestMicrophoneStreamInternal(deviceId);
+      } catch (err) {
+        console.warn("[sip] mic recovery failed to get stream", err);
+        return;
+      }
+      const nextTrack = nextStream.getAudioTracks()[0];
+      if (!nextTrack)
+        return;
+      await rtc.replaceAudioTrack(nextTrack);
+      this.sessionManager.setSessionMedia(resolved, nextStream);
+    };
+    const timer = setInterval(() => {
+      void tick();
+    }, intervalMs);
+    void tick();
+    const session = this.sessionManager.getSession(resolved);
+    const pc = session?.connection;
+    const onIceChange = () => {
+      const state = pc?.iceConnectionState;
+      if (state === "failed" || state === "disconnected")
+        void tick();
+    };
+    pc?.addEventListener?.("iceconnectionstatechange", onIceChange);
+    const stop = () => {
+      stopped = true;
+      clearInterval(timer);
+      pc?.removeEventListener?.("iceconnectionstatechange", onIceChange);
+    };
+    this.micRecovery.set(resolved, { stop });
+    return stop;
+  }
+  disableMicrophoneRecovery(sessionId) {
+    const resolved = this.resolveExistingSessionId(sessionId);
+    if (!resolved)
+      return false;
+    const entry = this.micRecovery.get(resolved);
+    if (!entry)
+      return false;
+    entry.stop();
+    this.micRecovery.delete(resolved);
+    return true;
+  }
   switchCameraSession(sessionId, track) {
     if (!this.sessionExists(sessionId))
       return false;
@@ -1251,13 +1379,28 @@ var SipClient = class extends EventTargetEmitter {
       const persisted = window.sessionStorage.getItem(SESSION_DEBUG_KEY);
       if (!persisted)
         return void 0;
-      if (persisted === "true")
-        return true;
       return persisted;
     } catch {
       return void 0;
     }
   }
+  async requestMicrophoneStreamInternal(deviceId) {
+    if (typeof navigator === "undefined" || !navigator.mediaDevices?.getUserMedia) {
+      throw new Error("getUserMedia not available");
+    }
+    const audio = deviceId && deviceId !== "default" ? { deviceId: { exact: deviceId } } : true;
+    try {
+      return await navigator.mediaDevices.getUserMedia({ audio });
+    } catch (err) {
+      const cause = err?.name || "getUserMedia failed";
+      this.emitError(
+        { raw: err, cause },
+        "MICROPHONE_UNAVAILABLE",
+        "microphone unavailable"
+      );
+      throw err;
+    }
+  }
 };
 function createSipClientInstance(options) {
   return new SipClient(options);
@@ -1310,6 +1453,8 @@ function useSipActions() {
       getSessionIds: () => client.getSessionIds(),
       getSessions: () => client.getSessions(),
       setSessionMedia: (...args) => client.setSessionMedia(...args),
+      enableMicrophoneRecovery: (...args) => client.enableMicrophoneRecovery(...args),
+      disableMicrophoneRecovery: (...args) => client.disableMicrophoneRecovery(...args),
       switchCamera: (...args) => client.switchCameraSession(...args),
       enableVideo: (...args) => client.enableVideoSession(...args),
       disableVideo: (...args) => client.disableVideoSession(...args)