@koi-design/callkit 2.0.0-beta.3 → 2.0.0-beta.5

package/dist/index.d.ts

@@ -39,6 +39,8 @@ declare class Call {
     callEnd(isUnprompted?: boolean, isError?: boolean): Promise<void>;
     callHold(): Promise<void>;
     callUnhold(): Promise<void>;
+    callMute(): Promise<void>;
+    callUnmute(): Promise<void>;
 }
 
 declare const CallStatus: {
@@ -50,10 +52,6 @@ declare const CallStatus: {
      * Connecting
      */
     connecting: number;
-    /**
-     * Call on hold
-     */
-    holding: number;
     /**
      * Ringing
      */
@@ -144,7 +142,8 @@ declare const KitEvent: {
      * User status change
      */
     USER_STATUS_CHANGE: string;
-    CONNECT_EVENT: string;
+    INCALL_CONNECT_EVENT: string;
+    SIP_CONNECT_EVENT: string;
     SIP_REGISTERER_EVENT: string;
     SIP_SESSION_EVENT: string;
 };
@@ -173,6 +172,14 @@ declare const SocketSendEvent: {
      * Unhold
      */
     UNHOLD: string;
+    /**
+     * Mute
+     */
+    MUTE: string;
+    /**
+     * Unmute
+     */
+    UNMUTE: string;
     /**
      * Call
      */
@@ -249,6 +256,7 @@ declare class Socket {
     private reconnectTimer?;
     private isReconnecting;
     private reconnectAttempts;
+    private socketError;
     constructor(callKit: CallKit);
     init(): void;
     private handleDisconnect;
@@ -264,8 +272,7 @@ declare class Socket {
     private ping;
     private checkPing;
     /**
-     * 重置 socket 连接和所有状态
-     * @param isWaitConfirm Whether need to wait for close confirmation
+     * reset socket connection and all states
      */
     reset(): Promise<void>;
     private attemptReconnect;
@@ -351,11 +358,15 @@ declare class Connect {
     /**
      * Whether muted
      */
-    isMute: boolean;
+    private isMute;
     /**
      * Whether registered
      */
     private isRegister;
+    /**
+     * Whether holding
+     */
+    private isHold;
     constructor(callKit: CallKit);
     reset(): void;
     private getAduioReference;
@@ -424,17 +435,8 @@ declare class Connect {
      */
     getRemoteMediaStream(session: any): any;
     setupRemoteMedia(session: any): void;
-    /**
-     * Update hold
-     * @param hold
-     */
-    setHoldStatus(hold: boolean): void;
     setHold(hold: boolean): Promise<void>;
-    hold(): Promise<void>;
-    unhold(): Promise<void>;
     setMute(mute: boolean): Promise<void>;
-    mute(): Promise<void>;
-    unmute(): Promise<void>;
     refer(referTo: string, extra?: any): Promise<void>;
 }
 
@@ -477,6 +479,8 @@ declare class CallKit {
     hangup(): Promise<void>;
     hold(): void;
     unhold(): void;
+    mute(): void;
+    unmute(): void;
     /**
      * set userstatus
      * @param status

package/dist/index.global.js

@@ -3310,10 +3310,10 @@ var WebCall = (() => {
      * Connecting
      */
     connecting: 2,
-    /**
-     * Call on hold
-     */
-    holding: 3,
+    // /**
+    //  * Call on hold
+    //  */
+    // holding: 3,
     /**
      * Ringing
      */
@@ -3408,7 +3408,8 @@ var WebCall = (() => {
      * User status change
      */
     USER_STATUS_CHANGE: "userStatusChange",
-    CONNECT_EVENT: "CONNECT_EVENT",
+    INCALL_CONNECT_EVENT: "IncallConnectEvent",
+    SIP_CONNECT_EVENT: "sipConnectEvent",
     SIP_REGISTERER_EVENT: "sipRegistererEvent",
     SIP_SESSION_EVENT: "sipSessionEvent"
   };
@@ -3530,6 +3531,14 @@ var WebCall = (() => {
      * Unhold
      */
     UNHOLD: "AGENT_UN_HOLD",
+    /**
+     * Mute
+     */
+    MUTE: "AGENT_MUTE",
+    /**
+     * Unmute
+     */
+    UNMUTE: "AGENT_UN_MUTE",
     /**
      * Call
      */
@@ -3704,28 +3713,58 @@ var WebCall = (() => {
         this.callKit.logger.warn("Current state cannot be held", {
           caller: "Call.callHold",
           content: {
+            isHold: this.callKit.connect.isHolding(),
             isCalling: this.callKit.connect.isCalling()
           }
         });
         return;
       }
-      this.callKit.socket.send(SocketSendEvent.HOLD);
-      this.callKit.connect.setConnectStatus(CallStatus.holding);
+      this.callKit.connect.setHold(true);
     }
     async callUnhold() {
       if (!this.callKit.config.check())
         return;
-      if (!this.callKit.connect.isHolding()) {
+      if (!this.callKit.connect.isCalling()) {
         this.callKit.logger.warn("Current state cannot unhold", {
           caller: "Call.callUnhold",
           content: {
-            isHolding: this.callKit.connect.isHolding()
+            isHold: this.callKit.connect.isHolding(),
+            isCalling: this.callKit.connect.isCalling()
+          }
+        });
+        return;
+      }
+      this.callKit.connect.setHold(false);
+    }
+    async callMute() {
+      if (!this.callKit.config.check())
+        return;
+      if (!this.callKit.connect.isCalling()) {
+        this.callKit.logger.warn("Current state cannot be muted", {
+          caller: "Call.callMute",
+          content: {
+            isMuted: this.callKit.connect.isMuted(),
+            isCalling: this.callKit.connect.isCalling()
+          }
+        });
+        return;
+      }
+      this.callKit.connect.setMute(true);
+    }
+    async callUnmute() {
+      if (!this.callKit.config.check())
+        return;
+      if (!this.callKit.connect.isCalling()) {
+        this.callKit.logger.warn("Current state cannot be unmuted", {
+          caller: "Call.callUnmute",
+          content: {
+            isMuted: this.callKit.connect.isMuted(),
+            isCalling: this.callKit.connect.isCalling()
           }
         });
         return;
       }
-      this.callKit.socket.send(SocketSendEvent.UNHOLD);
-      this.callKit.connect.setConnectStatus(CallStatus.calling);
+      this.callKit.connect.setMute(false);
     }
   };
 
@@ -18433,6 +18472,10 @@ var WebCall = (() => {
      * Whether registered
      */
     isRegister = false;
+    /**
+     * Whether holding
+     */
+    isHold = false;
     constructor(callKit) {
       this.callKit = callKit;
       const { reconnect = {} } = this.callKit.config.getConfig();
@@ -18443,12 +18486,12 @@ var WebCall = (() => {
     }
     reset() {
       if (this.isHolding()) {
-        this.setHoldStatus(false);
+        this.setHold(false);
       }
       if (this.connectStatus !== CallStatus.init) {
         this.setConnectStatus(CallStatus.init);
       }
-      if (this.isRegistered) {
+      if (this.isRegistered()) {
         this.unregister();
       }
       this.currentSession = void 0;
@@ -18518,7 +18561,7 @@ var WebCall = (() => {
      * isHolding
      */
     isHolding() {
-      return this.connectStatus === CallStatus.holding;
+      return this.isHold;
     }
     /**
      * isRegistered
@@ -18552,7 +18595,7 @@ var WebCall = (() => {
         this.heartbeatFlag -= 1;
         if (this.heartbeatFlag <= 0) {
           this.heartbeatFlag = MAX_HEARTBEAT_COUNT;
-          this.callKit.trigger(KitEvent.CONNECT_EVENT, {
+          this.callKit.trigger(KitEvent.SIP_CONNECT_EVENT, {
             event: "OPTIONS_HEARTBEAT_EXPIRED"
           });
         }
@@ -18733,8 +18776,8 @@ var WebCall = (() => {
             this.setRegister(false);
             this.setConnectStatus(CallStatus.init);
             this.callKit.trigger(KitEvent.SIP_REGISTERER_EVENT, {
-              isRegistered: this.isRegistered(),
-              registererState: state
+              registererState: state,
+              isRegistered: this.isRegistered()
             });
             break;
           case RegistererState.Unregistered:
@@ -18749,8 +18792,8 @@ var WebCall = (() => {
             this.setRegister(false);
             this.setConnectStatus(CallStatus.init);
             this.callKit.trigger(KitEvent.SIP_REGISTERER_EVENT, {
-              isRegistered: this.isRegistered(),
-              registererState: state
+              registererState: state,
+              isRegistered: this.isRegistered()
             });
             break;
           default:
@@ -18841,7 +18884,6 @@ var WebCall = (() => {
           };
           if (this.isOutgoing) {
             this.currentSession.accept(options);
-            this.setConnectStatus(CallStatus.connecting);
             this.callKit.trigger(KitEvent.KIT_OUTGOING_INVITE, {
               getInviteData: () => {
                 const { request: request2 } = this.currentSession;
@@ -19205,133 +19247,102 @@ var WebCall = (() => {
         });
       }
     }
-    /**
-     * Update hold
-     * @param hold
-     */
-    setHoldStatus(hold) {
-      this.callKit.logger.info("connect setHold", {
-        caller: "Connect.setHoldStatus",
-        type: "SIP",
-        content: {
-          hold
-        }
-      });
-      this.callKit.trigger(KitEvent.KIT_SET_HOLD, hold);
-    }
     async setHold(hold) {
-      this.setHoldStatus(hold);
-    }
-    async hold() {
-      this.callKit.logger.info("connect hold", {
-        caller: "Connect.hold",
-        type: "SIP",
-        content: {
-          hold: true
-        }
-      });
-      if (this.connectStatus !== CallStatus.calling || !this.currentSession) {
-        this.callKit.logger.error("Current status is not in call", {
-          caller: "Connect.hold",
+      if (this.isHold === hold) {
+        this.callKit.logger.warn("Already holding", {
+          caller: "Connect.setHold",
           type: "SIP",
           content: {
-            errCode: ErrorCode.WEBRTC_HOLE_STATUS_ERROR
+            isHold: this.isHold
           }
         });
+        return;
       }
-    }
-    async unhold() {
-      this.callKit.logger.info("connect unhold", {
-        caller: "Connect.unhold",
+      this.callKit.socket.send(
+        hold ? SocketSendEvent.HOLD : SocketSendEvent.UNHOLD
+      );
+      this.isHold = hold;
+      this.callKit.logger.info("connect setHold", {
+        caller: "Connect.setHold",
         type: "SIP",
         content: {
-          hold: false
+          hold
         }
       });
+      this.callKit.trigger(KitEvent.KIT_SET_HOLD, hold);
     }
+    // /**
+    //  * Set mute
+    //  * @param mute Whether to mute
+    //  * @deprecated just send socket event to server to mute or unmute
+    //  */
+    // async setMute(mute: boolean) {
+    //   this.callKit.logger.info('connect setMute', {
+    //     caller: 'Connect.setMute',
+    //     type: 'SIP',
+    //     content: {
+    //       mute
+    //     }
+    //   });
+    //   if (!this.currentSession) {
+    //     this.callKit.logger.error('No active session', {
+    //       caller: 'Connect.setMute',
+    //       type: 'SIP',
+    //       content: {
+    //         errCode: ErrorCode.WEBRTC_MUTE_STATUS_ERROR
+    //       }
+    //     });
+    //     this.callKit.reset();
+    //     return;
+    //   }
+    //   try {
+    //     // Get SessionDescriptionHandler
+    //     const sdh = this.currentSession.sessionDescriptionHandler;
+    //     if (!sdh || !('peerConnection' in sdh)) {
+    //       throw new Error('Invalid session description handler');
+    //     }
+    //     // Get PeerConnection
+    //     const pc = (sdh as any).peerConnection as RTCPeerConnection;
+    //     // Get local audio track and set status
+    //     const audioSender = pc
+    //       .getSenders()
+    //       .find((sender) => sender.track?.kind === 'audio');
+    //     if (audioSender && audioSender.track) {
+    //       audioSender.track.enabled = !mute;
+    //       // Update status and trigger event
+    //       this.isMute = mute;
+    //       this.callKit.trigger(KitEvent.KIT_SET_MUTE, mute);
+    //     } else {
+    //       throw new Error('No audio track found');
+    //     }
+    //   } catch (error) {
+    //     this.callKit.logger.error('Failed to set mute state', {
+    //       caller: 'Connect.setMute',
+    //       type: 'SIP',
+    //       content: {
+    //         err: error.message,
+    //         errCode: ErrorCode.WEBRTC_MUTE_ERROR
+    //       }
+    //     });
+    //   }
+    // }
     async setMute(mute) {
-      this.callKit.logger.info("connect setMute", {
-        caller: "Connect.setMute",
-        type: "SIP",
-        content: {
-          mute
-        }
-      });
-      if (!this.currentSession) {
-        this.callKit.logger.error("No active session", {
+      if (this.isMute === mute) {
+        this.callKit.logger.warn("Already muted", {
           caller: "Connect.setMute",
           type: "SIP",
           content: {
-            errCode: ErrorCode.WEBRTC_MUTE_STATUS_ERROR
-          }
-        });
-        this.callKit.reset();
-        return;
-      }
-      try {
-        const sdh = this.currentSession.sessionDescriptionHandler;
-        if (!sdh || !("peerConnection" in sdh)) {
-          throw new Error("Invalid session description handler");
-        }
-        const pc = sdh.peerConnection;
-        const audioSender = pc.getSenders().find((sender) => sender.track?.kind === "audio");
-        if (audioSender && audioSender.track) {
-          audioSender.track.enabled = !mute;
-          this.isMute = mute;
-          this.callKit.trigger(KitEvent.KIT_SET_MUTE, mute);
-        } else {
-          throw new Error("No audio track found");
-        }
-      } catch (error) {
-        this.callKit.logger.error("Failed to set mute state", {
-          caller: "Connect.setMute",
-          type: "SIP",
-          content: {
-            err: error.message,
-            errCode: ErrorCode.WEBRTC_MUTE_ERROR
-          }
-        });
-      }
-    }
-    async mute() {
-      this.callKit.logger.info("connect mute", {
-        caller: "Connect.mute",
-        type: "SIP",
-        content: {
-          mute: true
-        }
-      });
-      if (this.connectStatus !== CallStatus.calling || !this.currentSession) {
-        this.callKit.logger.warn("Current status is not in call", {
-          caller: "Connect.mute",
-          type: "SIP",
-          content: {
-            errCode: ErrorCode.WEBRTC_MUTE_STATUS_ERROR
-          }
-        });
-        return;
-      }
-      await this.setMute(true);
-    }
-    async unmute() {
-      this.callKit.logger.info("connect unmute", {
-        caller: "Connect.unmute",
-        type: "SIP",
-        content: {
-          mute: false
-        }
-      });
-      if (this.connectStatus !== CallStatus.calling || !this.currentSession) {
-        this.callKit.logger.warn("Current status is not in call", {
-          caller: "Connect.unmute",
-          type: "SIP",
-          content: {
-            errCode: ErrorCode.WEBRTC_MUTE_STATUS_ERROR
+            isCalling: this.isCalling(),
+            isMuted: this.isMuted()
           }
         });
         return;
       }
-      await this.setMute(false);
+      this.callKit.socket.send(
+        mute ? SocketSendEvent.MUTE : SocketSendEvent.UNMUTE
+      );
+      this.isMute = mute;
+      this.callKit.trigger(KitEvent.KIT_SET_MUTE, mute);
     }
     async refer(referTo, extra) {
       this.callKit.logger.info("connect refer", {
@@ -19353,7 +19364,7 @@ var WebCall = (() => {
   // package/socket.ts
   var RECONNECT_CONFIG = {
     enabled: true,
-    maxAttempts: 1,
+    maxAttempts: 3,
     delay: 500,
     backoffMultiplier: 1.5,
     pingInterval: 3e4,
@@ -19371,6 +19382,7 @@ var WebCall = (() => {
     reconnectTimer;
     isReconnecting = false;
     reconnectAttempts = 0;
+    socketError = false;
     constructor(callKit) {
       this.callKit = callKit;
       const { reconnect } = this.callKit.config.getConfig();
@@ -19394,7 +19406,7 @@ var WebCall = (() => {
       this.isConnected = false;
       if (!this.callKit.config.isLogin() || !this.socketConfig.enabled) {
         this.reset();
-        this.callKit.trigger(KitEvent.CONNECT_EVENT, {
+        this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
           event: "INCALL_NOT_CONNECTED"
         });
         return;
@@ -19414,6 +19426,7 @@ var WebCall = (() => {
         type: "INCALL",
         content: { ev }
       });
+      this.socketError = false;
       this.isConnected = true;
       this.lastPingTime = Date.now();
       this.checkPing();
@@ -19426,7 +19439,7 @@ var WebCall = (() => {
             reconnectAttempts: this.reconnectAttempts
           }
         });
-        this.callKit.trigger(KitEvent.CONNECT_EVENT, {
+        this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
           event: "INCALL_RECONNECT_SUCCESS"
         });
       }
@@ -19446,10 +19459,13 @@ var WebCall = (() => {
         type: "INCALL",
         content: { ev }
       });
-      this.callKit.trigger(KitEvent.CONNECT_EVENT, {
+      this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
         event: "INCALL_CONNECT_ERROR",
         err: ev
       });
+      if (this.socketError) {
+        return;
+      }
       this.handleDisconnect();
     }
     onError(ev) {
@@ -19461,6 +19477,7 @@ var WebCall = (() => {
           data: ev
         }
       });
+      this.socketError = true;
     }
     confirmAck(data) {
       const { ack, messageId } = data;
@@ -19618,7 +19635,7 @@ var WebCall = (() => {
     }
     send(event, message) {
       if (!this.isConnected) {
-        this.callKit.trigger(KitEvent.CONNECT_EVENT, {
+        this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
           event: "INCALL_NOT_CONNECTED"
         });
         this.callKit.logger.error("socket not connected", {
@@ -19677,7 +19694,7 @@ var WebCall = (() => {
     }
     async sendMessage(event, message) {
       if (!this.isConnected) {
-        this.callKit.trigger(KitEvent.CONNECT_EVENT, {
+        this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
           event: "INCALL_NOT_CONNECTED"
         });
         this.callKit.logger.error("socket not connected", {
@@ -19731,8 +19748,7 @@ var WebCall = (() => {
       }, this.socketConfig.pingInterval);
     }
     /**
-     * 重置 socket 连接和所有状态
-     * @param isWaitConfirm Whether need to wait for close confirmation
+     * reset socket connection and all states
      */
     async reset() {
       if (this.pingTimer) {
@@ -19742,6 +19758,7 @@ var WebCall = (() => {
       this.resetReconnectState();
       this.lastPingTime = void 0;
       this.satrtConfirm = false;
+      this.socketError = false;
       if (this.ws && this.isConnected) {
         this.callKit.logger.info("Closing socket connection", {
           caller: "Socket.reset",
@@ -19762,14 +19779,14 @@ var WebCall = (() => {
             reconnectAttempts: this.reconnectAttempts
           }
         });
-        this.callKit.trigger(KitEvent.CONNECT_EVENT, {
+        this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
           event: "INCALL_RECONNECT_ERROR"
         });
         this.reset();
         return;
       }
       if (this.reconnectAttempts === 0) {
-        this.callKit.trigger(KitEvent.CONNECT_EVENT, {
+        this.callKit.trigger(KitEvent.INCALL_CONNECT_EVENT, {
           event: "INCALL_RECONNECT_START"
         });
       }
@@ -20031,6 +20048,28 @@ var WebCall = (() => {
       });
       this.callCenter.callUnhold();
     }
+    mute() {
+      if (!this.config.check())
+        return;
+      this.logger.info("mute", {
+        caller: "CallKit.mute",
+        content: {
+          connectStatus: this.connect.connectStatus
+        }
+      });
+      this.callCenter.callMute();
+    }
+    unmute() {
+      if (!this.config.check())
+        return;
+      this.logger.info("unmute", {
+        caller: "CallKit.unmute",
+        content: {
+          connectStatus: this.connect.connectStatus
+        }
+      });
+      this.callCenter.callUnmute();
+    }
     /**
      * set userstatus
      * @param status