react-jssip-kit 0.6.9 → 0.7.0

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,11 +188,16 @@ declare class SipClient extends EventTargetEmitter<JsSIPEventMap> {
     private maxSessionCount;
     private sessionManager;
     private lifecycle;
+    private micRecovery;
+    private requestMicrophoneStream?;
+    private micRecoveryEnabled;
+    private micRecoveryDefaults;
     private unloadHandler?;
     private stateLogOff?;
     get state(): SipState;
     constructor(options?: SipClientOptions);
     connect(uri: string, password: string, config: SipConfiguration): void;
+    setMicrophoneProvider(fn?: () => Promise<MediaStream>): void;
     registerUA(): void;
     disconnect(): void;
     call(target: string, callOptions?: CallOptions): void;
@@ -210,6 +231,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;
@@ -252,6 +275,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;
@@ -268,10 +293,11 @@ declare function CallPlayer({ sessionId }: {
     sessionId?: string;
 }): react_jsx_runtime.JSX.Element;
 
-declare function SipProvider({ client, children, sipEventManager, }: {
+declare function SipProvider({ client, children, sipEventManager, requestMicrophoneStream, }: {
     sipEventManager?: SipEventManager;
     client: SipClient;
     children: react__default.ReactNode;
+    requestMicrophoneStream?: () => Promise<MediaStream>;
 }): react_jsx_runtime.JSX.Element;
 
 export { type CallDirection, type CallDirection as CallDirectionType, CallPlayer, CallStatus, CallStatus as CallStatusType, type JsSIPEventMap, type JsSIPEventName, type SessionEventName, type SessionEventPayload, type SipConfiguration, SipContext, type SipContextType, type SipEventHandlers, type SipEventManager, SipProvider, type SipSessionState, type SipState, SipStatus, SipStatus as SipStatusType, type UAEventName, type UAEventPayload, createSipClientInstance, createSipEventManager, useSip, useSipActions, useSipEvent, useSipSessionEvent, useSipSessions, useSipState };

package/dist/index.js

@@ -1,6 +1,6 @@
 import JsSIP from 'jssip';
 export { WebSocketInterface } from 'jssip';
-import { createContext, useContext, useCallback, useSyncExternalStore, useMemo, useEffect, useRef } from 'react';
+import React, { createContext, useContext, useCallback, useSyncExternalStore, useMemo, useEffect, useRef } from 'react';
 import { jsx } from 'react/jsx-runtime';
 
 // src/jssip-lib/sip/debugger.ts
@@ -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 });
@@ -926,6 +959,14 @@ var SipClient = class extends EventTargetEmitter {
     this.attachBeforeUnload();
     this.syncDebugInspector(debug);
   }
+  setMicrophoneProvider(fn) {
+    this.requestMicrophoneStream = fn;
+    if (fn && this.micRecoveryEnabled) {
+      this.sessionManager.getSessions().forEach(({ id }) => {
+        this.enableMicrophoneRecovery(id);
+      });
+    }
+  }
   registerUA() {
     this.userAgent.register();
   }
@@ -937,6 +978,21 @@ var SipClient = class extends EventTargetEmitter {
     this.stateStore.reset();
   }
   call(target, callOptions = {}) {
+    if (!callOptions.mediaStream && this.requestMicrophoneStream) {
+      void this.requestMicrophoneStream().then((stream) => {
+        if (!stream)
+          throw new Error("microphone stream unavailable");
+        this.call(target, { ...callOptions, mediaStream: stream });
+      }).catch((e) => {
+        const err = this.emitError(
+          e,
+          "MICROPHONE_FAILED",
+          "microphone failed"
+        );
+        this.stateStore.batchSet({ error: err.cause });
+      });
+      return;
+    }
     try {
       const opts = this.ensureMediaConstraints(callOptions);
       if (opts.mediaStream)
@@ -1007,6 +1063,9 @@ var SipClient = class extends EventTargetEmitter {
       if (h)
         session.on(ev, h);
     });
+    if (this.requestMicrophoneStream && this.micRecoveryEnabled) {
+      this.enableMicrophoneRecovery(sessionId);
+    }
   }
   detachSessionHandlers(sessionId, session) {
     const handlers = this.sessionHandlers.get(sessionId);
@@ -1032,11 +1091,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: [],
@@ -1097,6 +1159,21 @@ var SipClient = class extends EventTargetEmitter {
   answerSession(sessionId, options = {}) {
     if (!sessionId || !this.sessionExists(sessionId))
       return false;
+    if (!options.mediaStream && this.requestMicrophoneStream) {
+      void this.requestMicrophoneStream().then((stream) => {
+        if (!stream)
+          throw new Error("microphone stream unavailable");
+        this.answerSession(sessionId, { ...options, mediaStream: stream });
+      }).catch((e) => {
+        const err = this.emitError(
+          e,
+          "MICROPHONE_FAILED",
+          "microphone failed"
+        );
+        this.stateStore.batchSet({ error: err.cause });
+      });
+      return true;
+    }
     const opts = this.ensureMediaConstraints(options);
     return this.sessionManager.answer(sessionId, opts);
   }
@@ -1155,6 +1232,83 @@ var SipClient = class extends EventTargetEmitter {
   setSessionMedia(sessionId, stream) {
     this.sessionManager.setSessionMedia(sessionId, stream);
   }
+  enableMicrophoneRecovery(sessionId, options = {}) {
+    const resolved = this.resolveExistingSessionId(sessionId);
+    if (!resolved)
+      return () => {
+      };
+    if (!this.requestMicrophoneStream)
+      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;
+      retries += 1;
+      let nextStream;
+      try {
+        if (!this.requestMicrophoneStream)
+          return;
+        nextStream = await this.requestMicrophoneStream();
+      } 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,8 +1400,6 @@ 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;
@@ -1305,6 +1457,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)
@@ -1443,12 +1597,16 @@ function CallPlayer({ sessionId }) {
 function SipProvider({
   client,
   children,
-  sipEventManager
+  sipEventManager,
+  requestMicrophoneStream
 }) {
   const manager = useMemo(
     () => sipEventManager ?? createSipEventManager(client),
     [client, sipEventManager]
   );
+  React.useEffect(() => {
+    client.setMicrophoneProvider(requestMicrophoneStream);
+  }, [client, requestMicrophoneStream]);
   const contextValue = useMemo(() => ({ client, sipEventManager: manager }), [client, manager]);
   return /* @__PURE__ */ jsx(SipContext.Provider, { value: contextValue, children });
 }