@koi-design/callkit 2.3.0-beta.8 → 2.3.1-beta.1

package/dist/index.mjs

@@ -45,7 +45,7 @@ var Api = class {
       const res = await this.post({
         url: "/auth/agentUser/login",
         method: "post",
-        data: params
+        data: { ...params, browserVersion: navigator.userAgent }
       });
       return res;
     } finally {
@@ -508,7 +508,11 @@ var SocketReceiveEvent = {
   ERROR: "ERROR",
   SESSION_ERROR: "SESSION_ERROR",
   WAITING_QUEUE: "WAITING_QUEUE",
-  CUSTOMER_MATCH_BLACK_PHONE: "CUSTOMER_MATCH_BLACK_PHONE"
+  CUSTOMER_MATCH_BLACK_PHONE: "CUSTOMER_MATCH_BLACK_PHONE",
+  /**
+   * Agent RTP loss
+   */
+  AGENT_RTP_LOSS: "AGENT_RTP_LOSS"
 };
 var EncryptionMethod = {
   NONE: "NONE",
@@ -697,7 +701,7 @@ var Call = class {
 // package.json
 var package_default = {
   name: "@koi-design/callkit",
-  version: "2.3.0-beta.8",
+  version: "2.3.1-beta.1",
   description: "callkit",
   author: "koi",
   license: "ISC",
@@ -15797,8 +15801,6 @@ var Connect = class {
       });
       return;
     }
-    const { userInfo } = this.callKit.config.getConfig();
-    const { userPart, fsIp, fsPort } = userInfo;
     const { registererOptions = {} } = this.reconnectConfig;
     this.registerer = new Registerer(this.userAgent, registererOptions);
     this.registerer.stateChange.addListener((state) => {
@@ -15832,27 +15834,26 @@ var Connect = class {
           });
           this.setRegister(true);
           if (this.isReConnected) {
-            if (this.currentSession && (this.currentSession.state === SessionState2.Established || this.currentSession.state === SessionState2.Establishing) && this.isCalling()) {
-              const selfUri = `sip:manualCallAgent${userPart}@${fsIp}:${fsPort}`;
+            if (this.canReferInCallToSelf()) {
               this.callKit.logger.info(
                 "Reconnected, referring active session to self",
                 {
                   caller: "Connect.setupRegisterer.registererStateChange",
                   type: "SIP",
                   content: {
-                    selfUri,
+                    selfUri: this.getSelfReferUri(),
                     sessionState: this.currentSession.state,
                     connectStatus: this.connectStatus
                   }
                 }
               );
-              this.referInCall(selfUri).catch((err) => {
+              this.referInCallToSelf().catch((err) => {
                 this.callKit.logger.error(err, {
                   caller: "Connect.setupRegisterer.registererStateChange",
                   type: "SIP",
                   content: {
                     errCode: ErrorCode.WEBRTC_CALL_INVITE_ERROR,
-                    selfUri
+                    selfUri: this.getSelfReferUri()
                   }
                 });
               });
@@ -15958,7 +15959,7 @@ var Connect = class {
       this.mediaStream = await navigator.mediaDevices.getUserMedia(constrains);
       return this.mediaStream;
     };
-    const { userPart, fsIp, fsPort, iceInfo, wsUrl } = userInfo;
+    const { userPart, fsIp, fsPort, fsPassword, iceInfo, wsUrl } = userInfo;
     const connectConfig = {
       uri: UserAgent.makeURI(`sip:${userPart}@${fsIp}:${fsPort}`),
       displayName: userPart,
@@ -15968,6 +15969,8 @@ var Connect = class {
       },
       logLevel: "error",
       allowLegacyNotifications: true,
+      authorizationPassword: fsPassword,
+      authorizationUsername: userPart,
       contactName: userPart,
       contactParams: { transport: "wss" },
       sessionDescriptionHandlerFactory: web_exports.defaultSessionDescriptionHandlerFactory(localStreamFactory),
@@ -16681,6 +16684,199 @@ var Connect = class {
     }
     this.currentSession.refer(target, extra?.sessionReferOptions);
   }
+  /**
+   * Get the SIP URI for "refer to self" (same as reconnection refer logic).
+   * Shared by referInCallToSelf and internal reconnection refer.
+   */
+  getSelfReferUri() {
+    const { userInfo } = this.callKit.config.getConfig();
+    const { userPart, fsIp, fsPort } = userInfo;
+    return `sip:manualCallAgent${userPart}@${fsIp}:${fsPort}`;
+  }
+  /**
+   * Whether we can refer the current call to self (has active session in Established/Establishing and is calling).
+   * Shared by reconnection logic and referInCallToSelf.
+   */
+  canReferInCallToSelf() {
+    return !!this.currentSession && (this.currentSession.state === SessionState2.Established || this.currentSession.state === SessionState2.Establishing) && this.isCalling();
+  }
+  /**
+   * Refer the current call to self (e.g. Agent RTP loss recovery, post-reconnect recovery).
+   * Socket and other callers can use this without constructing referTo.
+   */
+  async referInCallToSelf(callUuid, extra) {
+    if (callUuid && this.currentCallId !== callUuid) {
+      this.callKit.logger.warn(
+        "Cannot refer in call to self: callUuid mismatch",
+        {
+          caller: "Connect.referInCallToSelf",
+          type: "SIP",
+          content: {
+            currentCallId: this.currentCallId,
+            callUuid
+          }
+        }
+      );
+      return;
+    }
+    if (!this.canReferInCallToSelf()) {
+      this.callKit.logger.warn(
+        "Cannot refer in call to self: preconditions not met",
+        {
+          caller: "Connect.referInCallToSelf",
+          type: "SIP",
+          content: {
+            hasCurrentSession: !!this.currentSession,
+            sessionState: this.currentSession?.state,
+            isCalling: this.isCalling()
+          }
+        }
+      );
+      return;
+    }
+    const selfUri = this.getSelfReferUri();
+    return this.referInCall(selfUri, extra);
+  }
+};
+
+// core/heartbeat-worker.ts
+var workerCode = `
+let timer = null;
+let interval = 30000;
+
+self.onmessage = function(e) {
+  const { type, interval: newInterval } = e.data;
+  
+  if (type === 'start') {
+    if (timer) {
+      clearInterval(timer);
+    }
+    interval = newInterval || interval;
+    timer = setInterval(() => {
+      self.postMessage({ type: 'tick' });
+    }, interval);
+  }
+  
+  if (type === 'stop') {
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  }
+  
+  if (type === 'updateInterval') {
+    interval = newInterval;
+    if (timer) {
+      clearInterval(timer);
+      timer = setInterval(() => {
+        self.postMessage({ type: 'tick' });
+      }, interval);
+    }
+  }
+};
+`;
+function createHeartbeatWorker() {
+  try {
+    const blob = new Blob([workerCode], { type: "application/javascript" });
+    const workerUrl = URL.createObjectURL(blob);
+    const worker = new Worker(workerUrl);
+    URL.revokeObjectURL(workerUrl);
+    return worker;
+  } catch {
+    return null;
+  }
+}
+var HeartbeatManager = class {
+  worker = null;
+  fallbackTimer = null;
+  interval = 3e4;
+  onTick = null;
+  isRunning = false;
+  constructor() {
+    this.worker = createHeartbeatWorker();
+    if (this.worker) {
+      this.worker.onmessage = (e) => {
+        if (e.data.type === "tick" && this.onTick) {
+          this.onTick();
+        }
+      };
+    }
+  }
+  /**
+   * Start the heartbeat
+   * @param interval - Interval in milliseconds
+   * @param onTick - Callback function to execute on each tick
+   */
+  start(interval, onTick) {
+    this.stop();
+    this.interval = interval;
+    this.onTick = onTick;
+    this.isRunning = true;
+    if (this.worker) {
+      this.worker.postMessage({
+        type: "start",
+        interval
+      });
+    } else {
+      this.fallbackTimer = setInterval(() => {
+        if (this.onTick) {
+          this.onTick();
+        }
+      }, interval);
+    }
+  }
+  /**
+   * Stop the heartbeat
+   */
+  stop() {
+    this.isRunning = false;
+    this.onTick = null;
+    if (this.worker) {
+      this.worker.postMessage({ type: "stop" });
+    }
+    if (this.fallbackTimer) {
+      clearInterval(this.fallbackTimer);
+      this.fallbackTimer = null;
+    }
+  }
+  /**
+   * Update the heartbeat interval
+   * @param interval - New interval in milliseconds
+   */
+  updateInterval(interval) {
+    this.interval = interval;
+    if (!this.isRunning)
+      return;
+    if (this.worker) {
+      this.worker.postMessage({
+        type: "updateInterval",
+        interval
+      });
+    } else if (this.fallbackTimer && this.onTick) {
+      clearInterval(this.fallbackTimer);
+      this.fallbackTimer = setInterval(() => {
+        if (this.onTick) {
+          this.onTick();
+        }
+      }, interval);
+    }
+  }
+  /**
+   * Destroy the heartbeat manager and release resources
+   */
+  destroy() {
+    this.stop();
+    if (this.worker) {
+      this.worker.terminate();
+      this.worker = null;
+    }
+  }
+  /**
+   * Check if using Web Worker
+   */
+  isUsingWorker() {
+    return this.worker !== null;
+  }
 };
 
 // core/socket.ts
@@ -16688,7 +16884,7 @@ var Socket = class {
   callKit;
   ws;
   lastPingTime = void 0;
-  pingTimer;
+  heartbeatManager;
   /**
    * @description reconnect timer
    */
@@ -16721,9 +16917,32 @@ var Socket = class {
   }
   constructor(callKit) {
     this.callKit = callKit;
+    this.heartbeatManager = new HeartbeatManager();
+  }
+  get isUserSetPingTryCount() {
+    const { userInfo } = this.callKit.config.getConfig();
+    const { pingTryCount } = userInfo;
+    return Number.isInteger(pingTryCount) && pingTryCount > 0;
   }
   get reconnectConfig() {
-    return this.callKit.config.getReconnectConfig("incall");
+    const incallConfig = this.callKit.config.getReconnectConfig("incall");
+    const { userInfo } = this.callKit.config.getConfig();
+    const { pingTryCount, pingTryCountInterval } = userInfo;
+    if (pingTryCount > 0) {
+      return {
+        ...incallConfig,
+        maxAttempts: pingTryCount,
+        interval: pingTryCountInterval * 1e3
+      };
+    }
+    return incallConfig;
+  }
+  get pingInterval() {
+    const { keepaliveInterval } = this.callKit.config.getConfig().userInfo;
+    if (Number.isInteger(keepaliveInterval) && keepaliveInterval > 0) {
+      return keepaliveInterval * 1e3;
+    }
+    return this.reconnectConfig.pingInterval;
   }
   isConnected() {
     return this.connectAuthState.isConnected;
@@ -16748,7 +16967,17 @@ var Socket = class {
     this.setConnectAuthState("isConnected", false);
     const { enabled } = this.reconnectConfig;
     if (!this.callKit.config.isLogin() || !enabled) {
-      this.callKit.reset();
+      if (this.callKit.connect.isCalling()) {
+        this.callKit.logger.warn("Disconnect during call, delay reset", {
+          caller: "Socket.handleDisconnect",
+          type: "INCALL",
+          content: {
+            connectStatus: this.callKit.connect.connectStatus
+          }
+        });
+      } else {
+        this.callKit.reset();
+      }
       this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
         event: "INCALL_NOT_CONNECTED"
       });
@@ -16906,6 +17135,28 @@ var Socket = class {
       this.setConnectAuthState("startConfirm", true);
       this.cleanReconnectState();
     }
+    if (data.event === SocketReceiveEvent.AGENT_RTP_LOSS) {
+      this.callKit.logger.warn("Agent RTP loss", {
+        caller: "Socket.onMessage",
+        type: "INCALL",
+        content: {
+          data: {
+            callUuid,
+            ...content
+          },
+          event: SocketReceiveEvent.AGENT_RTP_LOSS
+        }
+      });
+      if (callUuid) {
+        this.callKit.connect.referInCallToSelf(callUuid).catch((err) => {
+          this.callKit.logger.error(err, {
+            caller: "Socket.onMessage:AGENT_RTP_LOSS",
+            type: "INCALL",
+            content: { callUuid, event: SocketReceiveEvent.AGENT_RTP_LOSS }
+          });
+        });
+      }
+    }
     if (data.event === SocketReceiveEvent.CUSTOMER_RINGING) {
       this.callKit.trigger(KitEvent.CALL_RINGING, {
         time: /* @__PURE__ */ new Date(),
@@ -16954,6 +17205,18 @@ var Socket = class {
       this.send(SocketSendEvent.END, { agentId: userInfo.agentId, callUuid });
     }
     if (data.event === SocketReceiveEvent.ERROR) {
+      if (this.callKit.connect.isCalling()) {
+        this.callKit.logger.warn("socket onMessage error during call, ignore", {
+          caller: "Socket.onMessage",
+          type: "INCALL",
+          content: {
+            errCode: ErrorCode.SOCKET_CONNECT_ERROR,
+            isCalling: this.callKit.connect.isCalling(),
+            data: content
+          }
+        });
+        return;
+      }
       this.setConnectAuthState("isError", true);
       this.callKit.reset();
       this.callKit.logger.error(data.msg, {
@@ -16962,20 +17225,24 @@ var Socket = class {
         content: {
           errCode: ErrorCode.SOKET_SERVER_ERROR,
           data: content,
-          callUuid
+          callUuid,
+          delayReset: this.callKit.connect.isCalling()
         }
       });
     }
     if (data.event === SocketReceiveEvent.SESSION_ERROR) {
       this.setConnectAuthState("isError", true);
-      this.callKit.reset();
+      if (!this.callKit.connect.isCalling()) {
+        this.callKit.reset();
+      }
       this.callKit.logger.error(data.msg, {
         caller: `Socket.onMessage:${data.event}`,
         type: "INCALL",
         content: {
           data: content,
           event: SocketReceiveEvent.SESSION_ERROR,
-          callUuid
+          callUuid,
+          delayReset: this.callKit.connect.isCalling()
         }
       });
     }
@@ -17007,6 +17274,18 @@ var Socket = class {
       this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
         event: "INCALL_NOT_CONNECTED"
       });
+      if (this.callKit.connect.isCalling()) {
+        this.callKit.logger.warn("socket send during call, ignore", {
+          caller: "Socket.onMessage",
+          type: "INCALL",
+          content: {
+            errCode: ErrorCode.SOCKET_CONNECT_ERROR,
+            isCalling: this.callKit.connect.isCalling(),
+            data: message
+          }
+        });
+        return;
+      }
       this.callKit.reset();
       this.callKit.logger.error("socket not connected", {
         caller: "Socket.send",
@@ -17059,8 +17338,8 @@ var Socket = class {
       return;
     this.send(SocketSendEvent.PING);
     const now = Date.now();
-    const { pingInterval, pingTimeout } = this.reconnectConfig;
-    if (now - this.lastPingTime > pingInterval + pingTimeout) {
+    const { pingTimeout } = this.reconnectConfig;
+    if (now - this.lastPingTime > this.pingInterval + pingTimeout) {
       this.callKit.logger.warn("Ping timeout not connected", {
         caller: "Socket.ping",
         type: "INCALL",
@@ -17072,26 +17351,48 @@ var Socket = class {
       this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
         event: "INCALL_PING_TIMEOUT"
       });
+      if (this.isUserSetPingTryCount) {
+        this.handlePingTimeout();
+      }
     }
   }
+  handlePingTimeout() {
+    const { userInfo } = this.callKit.config.getConfig();
+    const { pingTryCount, pingTryCountInterval } = userInfo;
+    this.callKit.logger.warn("Ping timeout, user set ping try count", {
+      caller: "Socket.handlePingTimeout",
+      type: "INCALL",
+      content: {
+        errCode: ErrorCode.SOCKET_PING_TIMEOUT,
+        isUserSetPingTryCount: this.isUserSetPingTryCount,
+        pingTryCount,
+        pingTryCountInterval
+      }
+    });
+    this.attemptReconnect();
+  }
   checkPing() {
-    if (this.pingTimer) {
-      clearInterval(this.pingTimer);
-    }
-    const { pingInterval } = this.reconnectConfig;
-    this.pingTimer = setInterval(() => {
+    this.heartbeatManager.start(this.pingInterval, () => {
       this.ping();
-    }, pingInterval);
+    });
+    this.callKit.logger.info(
+      `Heartbeat started with Worker: ${this.heartbeatManager.isUsingWorker()}`,
+      {
+        caller: "Socket.checkPing",
+        type: "INCALL",
+        content: {
+          pingInterval: this.pingInterval,
+          usingWorker: this.heartbeatManager.isUsingWorker()
+        }
+      }
+    );
   }
   /**
    * reset socket connection and all states
    */
   async reset(config) {
     const { force = false } = config || {};
-    if (this.pingTimer) {
-      clearInterval(this.pingTimer);
-      this.pingTimer = void 0;
-    }
+    this.heartbeatManager.stop();
     if (force) {
       this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
         event: "INCALL_RESET"
@@ -17102,6 +17403,12 @@ var Socket = class {
     this.setConnectAuthState("startConfirm", false);
     this.clearWebSocket();
   }
+  /**
+   * Destroy the heartbeat manager
+   */
+  destroyHeartbeat() {
+    this.heartbeatManager.destroy();
+  }
   attemptReconnect() {
     if (this.reconnectTimer) {
       clearTimeout(this.reconnectTimer);
@@ -17109,19 +17416,40 @@ var Socket = class {
     }
     const { maxAttempts } = this.reconnectConfig;
     if (this.reconnectAttempts >= maxAttempts) {
+      if (this.callKit.connect.isCalling()) {
+        this.callKit.logger.warn("reconnect during call, ignore", {
+          caller: "Socket.attemptReconnect",
+          type: "INCALL",
+          content: {
+            errCode: ErrorCode.SOCKET_RECONNECT_FAILED,
+            isCalling: this.callKit.connect.isCalling(),
+            reconnectAttempts: this.reconnectAttempts
+          }
+        });
+        return;
+      }
+      if (this.isUserSetPingTryCount) {
+        this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
+          event: "INCALL_PING_TIMEOUT_RECONNECT_FAILED_MAX_ATTEMPTS"
+        });
+      }
       this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
         event: "INCALL_RECONNECT_ERROR"
       });
       this.setConnectAuthState("isError", true);
       this.callKit.reset();
-      this.callKit.logger.error("Maximum reconnection attempts reached", {
-        caller: "Socket.attemptReconnect",
-        type: "INCALL",
-        content: {
-          errCode: ErrorCode.SOCKET_RECONNECT_FAILED,
-          reconnectAttempts: this.reconnectAttempts
+      this.callKit.logger.warn(
+        "Maximum reconnection attempts reached, trigger reset",
+        {
+          caller: "Socket.attemptReconnect",
+          type: "INCALL",
+          content: {
+            errCode: ErrorCode.SOCKET_RECONNECT_FAILED,
+            reconnectAttempts: this.reconnectAttempts,
+            delayReset: this.callKit.connect.isCalling()
+          }
         }
-      });
+      );
       return;
     }
     if (this.reconnectAttempts === 0) {
@@ -17227,6 +17555,7 @@ var CallKit = class {
       content: {
         username,
         password,
+        ua: navigator.userAgent,
         encryptionMethod,
         encryptionPassword
       }
@@ -17260,6 +17589,9 @@ var CallKit = class {
           iceInfo: user.iceInfo,
           iceGatheringTimeout: user.iceGatheringTimeout,
           logGather: user.logGather,
+          keepaliveInterval: user.keepaliveInterval,
+          pingTryCount: user?.pingTryCount,
+          pingTryCountInterval: user?.pingTryCountInterval,
           phoneType: user.phoneType,
           // encryptionType is in extra
           ...extra
@@ -17357,7 +17689,10 @@ var CallKit = class {
       caller: "CallKit.register",
       content: {}
     });
-    this.connect.register();
+    const { userInfo } = this.config.getConfig();
+    if (userInfo.phoneType === PhoneTypeEnum.SIP) {
+      this.connect.register();
+    }
   }
   async unregister() {
     if (!this.config.check())
@@ -17467,10 +17802,13 @@ var CallKit = class {
         force
       }
     });
-    if (this.connect.isCalling()) {
-      await this.hangup();
+    const { userInfo } = this.config.getConfig();
+    if (userInfo.phoneType === PhoneTypeEnum.SIP) {
+      if (this.connect.isCalling()) {
+        await this.hangup();
+      }
+      await this.connect.reset({ force });
     }
-    await this.connect.reset({ force });
     if (this.config.isLogin()) {
       await this.logout({ isReset: false });
     } else {