react-jssip-kit 0.6.9 → 0.7.0

package/dist/index.cjs

@@ -1,12 +1,13 @@
 'use strict';
 
 var JsSIP = require('jssip');
-var react = require('react');
+var React = require('react');
 var jsxRuntime = require('react/jsx-runtime');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var JsSIP__default = /*#__PURE__*/_interopDefault(JsSIP);
+var React__default = /*#__PURE__*/_interopDefault(React);
 
 // src/jssip-lib/sip/debugger.ts
 var SipDebugger = class {
@@ -679,6 +680,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 +904,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 +943,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 });
@@ -931,6 +965,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();
   }
@@ -942,6 +984,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)
@@ -1012,6 +1069,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);
@@ -1037,11 +1097,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: [],
@@ -1102,6 +1165,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);
   }
@@ -1160,6 +1238,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;
@@ -1251,8 +1406,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;
@@ -1277,9 +1430,9 @@ function createSipEventManager(client) {
     }
   };
 }
-var SipContext = react.createContext(null);
+var SipContext = React.createContext(null);
 function useSip() {
-  const ctx = react.useContext(SipContext);
+  const ctx = React.useContext(SipContext);
   if (!ctx)
     throw new Error("Must be used within SipProvider");
   return ctx;
@@ -1288,16 +1441,16 @@ function useSip() {
 // src/hooks/useSipState.ts
 function useSipState() {
   const { client } = useSip();
-  const subscribe = react.useCallback(
+  const subscribe = React.useCallback(
     (onStoreChange) => client.onChange(onStoreChange),
     [client]
   );
-  const getSnapshot = react.useCallback(() => client.state, [client]);
-  return react.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  const getSnapshot = React.useCallback(() => client.state, [client]);
+  return React.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
 }
 function useSipActions() {
   const { client } = useSip();
-  return react.useMemo(
+  return React.useMemo(
     () => ({
       call: (...args) => client.call(...args),
       answer: (...args) => client.answerSession(...args),
@@ -1310,6 +1463,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)
@@ -1325,7 +1480,7 @@ function useSipSessions() {
 }
 function useSipEvent(event, handler) {
   const { sipEventManager } = useSip();
-  react.useEffect(() => {
+  React.useEffect(() => {
     if (!handler)
       return;
     return sipEventManager.onUA(event, handler);
@@ -1333,7 +1488,7 @@ function useSipEvent(event, handler) {
 }
 function useSipSessionEvent(sessionId, event, handler) {
   const { sipEventManager } = useSip();
-  react.useEffect(() => {
+  React.useEffect(() => {
     if (!handler)
       return;
     return sipEventManager.onSession(sessionId, event, handler);
@@ -1431,8 +1586,8 @@ function createCallPlayer(audioEl) {
 }
 function CallPlayer({ sessionId }) {
   const { client } = useSip();
-  const audioRef = react.useRef(null);
-  react.useEffect(() => {
+  const audioRef = React.useRef(null);
+  React.useEffect(() => {
     if (!audioRef.current)
       return;
     const player = createCallPlayer(audioRef.current);
@@ -1448,13 +1603,17 @@ function CallPlayer({ sessionId }) {
 function SipProvider({
   client,
   children,
-  sipEventManager
+  sipEventManager,
+  requestMicrophoneStream
 }) {
-  const manager = react.useMemo(
+  const manager = React.useMemo(
     () => sipEventManager ?? createSipEventManager(client),
     [client, sipEventManager]
   );
-  const contextValue = react.useMemo(() => ({ client, sipEventManager: manager }), [client, manager]);
+  React__default.default.useEffect(() => {
+    client.setMicrophoneProvider(requestMicrophoneStream);
+  }, [client, requestMicrophoneStream]);
+  const contextValue = React.useMemo(() => ({ client, sipEventManager: manager }), [client, manager]);
   return /* @__PURE__ */ jsxRuntime.jsx(SipContext.Provider, { value: contextValue, children });
 }