react-jssip-kit 0.6.9 → 0.7.1

package/dist/index.d.ts

@@ -41,6 +41,18 @@ type SipConfiguration = Omit<UAConfiguration, "password" | "uri"> & {
      * Enable JsSIP debug logging. If string, treated as debug pattern.
      */
     debug?: boolean | string;
+    /**
+     * Enable automatic microphone recovery for sessions.
+     */
+    enableMicRecovery?: boolean;
+    /**
+     * Interval between recovery attempts in milliseconds.
+     */
+    micRecoveryIntervalMs?: number;
+    /**
+     * Maximum number of recovery attempts per session.
+     */
+    micRecoveryMaxRetries?: number;
     /**
      * Maximum allowed concurrent sessions. Additional sessions are rejected.
      */
@@ -161,6 +173,10 @@ type SipClientOptions = {
     errorHandler?: SipErrorHandler;
     debug?: boolean | string;
 };
+type MicrophoneRecoveryOptions = {
+    intervalMs?: number;
+    maxRetries?: number;
+};
 declare class SipClient extends EventTargetEmitter<JsSIPEventMap> {
     readonly userAgent: SipUserAgent;
     readonly stateStore: SipStateStore;
@@ -172,6 +188,9 @@ declare class SipClient extends EventTargetEmitter<JsSIPEventMap> {
     private maxSessionCount;
     private sessionManager;
     private lifecycle;
+    private micRecovery;
+    private micRecoveryEnabled;
+    private micRecoveryDefaults;
     private unloadHandler?;
     private stateLogOff?;
     get state(): SipState;
@@ -210,6 +229,8 @@ declare class SipClient extends EventTargetEmitter<JsSIPEventMap> {
     sendDTMFSession(sessionId: string, tones: string | number, options?: DTMFOptions): boolean;
     transferSession(sessionId: string, target: string, options?: ReferOptions): boolean;
     setSessionMedia(sessionId: string, stream: MediaStream): void;
+    enableMicrophoneRecovery(sessionId: string, options?: MicrophoneRecoveryOptions): () => void;
+    disableMicrophoneRecovery(sessionId: string): boolean;
     switchCameraSession(sessionId: string, track: MediaStreamTrack): false | Promise<boolean>;
     enableVideoSession(sessionId: string): boolean;
     disableVideoSession(sessionId: string): boolean;
@@ -225,6 +246,7 @@ declare class SipClient extends EventTargetEmitter<JsSIPEventMap> {
     private toggleStateLogger;
     private diffState;
     private getPersistedDebug;
+    private requestMicrophoneStreamInternal;
 }
 declare function createSipClientInstance(options?: SipClientOptions): SipClient;
 declare function createSipEventManager(client: SipClient): SipEventManager;
@@ -252,6 +274,8 @@ declare function useSipActions(): {
         session: jssip_src_RTCSession.RTCSession;
     }[];
     setSessionMedia: (sessionId: string, stream: MediaStream) => void;
+    enableMicrophoneRecovery: (sessionId: string, options?: MicrophoneRecoveryOptions | undefined) => () => void;
+    disableMicrophoneRecovery: (sessionId: string) => boolean;
     switchCamera: (sessionId: string, track: MediaStreamTrack) => false | Promise<boolean>;
     enableVideo: (sessionId: string) => boolean;
     disableVideo: (sessionId: string) => boolean;

package/dist/index.js

@@ -674,6 +674,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
@@ -881,6 +898,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
@@ -914,11 +937,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 });
@@ -1007,6 +1040,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);
@@ -1032,11 +1068,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: [],
@@ -1098,6 +1137,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) {
@@ -1155,6 +1197,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;
@@ -1246,13 +1374,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);
@@ -1305,6 +1448,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)