@koi-design/callkit 2.0.0-beta.2 → 2.0.0-beta.4

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
      */
@@ -173,6 +171,14 @@ declare const SocketSendEvent: {
      * Unhold
      */
     UNHOLD: string;
+    /**
+     * Mute
+     */
+    MUTE: string;
+    /**
+     * Unmute
+     */
+    UNMUTE: string;
     /**
      * Call
      */
@@ -267,7 +273,7 @@ declare class Socket {
      * 重置 socket 连接和所有状态
      * @param isWaitConfirm Whether need to wait for close confirmation
      */
-    reset(isWaitConfirm?: boolean): Promise<void>;
+    reset(): Promise<void>;
     private attemptReconnect;
 }
 
@@ -351,11 +357,15 @@ declare class Connect {
     /**
      * Whether muted
      */
-    isMute: boolean;
+    private isMute;
     /**
      * Whether registered
      */
-    isRegistered: boolean;
+    private isRegister;
+    /**
+     * Whether holding
+     */
+    private isHold;
     constructor(callKit: CallKit);
     reset(): void;
     private getAduioReference;
@@ -375,9 +385,17 @@ declare class Connect {
      */
     isRinging(): boolean;
     /**
-     *
+     * isHolding
      */
     isHolding(): boolean;
+    /**
+     * isRegistered
+     */
+    isRegistered(): boolean;
+    /**
+     * isMute
+     */
+    isMuted(): boolean;
     /**
      * Call ended, call not started
      * @returns
@@ -416,17 +434,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>;
 }
 
@@ -469,6 +478,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
      */
@@ -3530,6 +3530,14 @@ var WebCall = (() => {
      * Unhold
      */
     UNHOLD: "AGENT_UN_HOLD",
+    /**
+     * Mute
+     */
+    MUTE: "AGENT_MUTE",
+    /**
+     * Unmute
+     */
+    UNMUTE: "AGENT_UN_MUTE",
     /**
      * Call
      */
@@ -3704,28 +3712,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(true);
+    }
+    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);
     }
   };
 
@@ -18432,7 +18470,11 @@ var WebCall = (() => {
     /**
      * Whether registered
      */
-    isRegistered = false;
+    isRegister = false;
+    /**
+     * Whether holding
+     */
+    isHold = false;
     constructor(callKit) {
       this.callKit = callKit;
       const { reconnect = {} } = this.callKit.config.getConfig();
@@ -18443,7 +18485,7 @@ var WebCall = (() => {
     }
     reset() {
       if (this.isHolding()) {
-        this.setHoldStatus(false);
+        this.setHold(false);
       }
       if (this.connectStatus !== CallStatus.init) {
         this.setConnectStatus(CallStatus.init);
@@ -18472,6 +18514,7 @@ var WebCall = (() => {
           });
         }
       }
+      this.callKit.config.reset();
       this.setConnectStatus(CallStatus.init);
       this.clearObserveOptionsHeartbeatInterval();
     }
@@ -18514,10 +18557,22 @@ var WebCall = (() => {
       return this.connectStatus === CallStatus.ringing;
     }
     /**
-     *
+     * isHolding
      */
     isHolding() {
-      return this.connectStatus === CallStatus.holding;
+      return this.isHold;
+    }
+    /**
+     * isRegistered
+     */
+    isRegistered() {
+      return this.isRegister;
+    }
+    /**
+     * isMute
+     */
+    isMuted() {
+      return this.isMute;
     }
     /**
      * Call ended, call not started
@@ -18547,7 +18602,7 @@ var WebCall = (() => {
     }
     async register() {
       if (this.connectStatus !== CallStatus.init) {
-        if (this.isRegistered) {
+        if (this.isRegistered()) {
           this.callKit.logger.warn("connectStatus is registered", {
             caller: "Connect.register",
             content: {
@@ -18683,14 +18738,14 @@ var WebCall = (() => {
               type: "SIP",
               content: {
                 registererState: state,
-                isRegistered: this.isRegistered
+                isRegistered: this.isRegistered()
               }
             });
             this.setRegister(false);
             this.setConnectStatus(CallStatus.init);
             this.callKit.trigger(KitEvent.SIP_REGISTERER_EVENT, {
               registererState: state,
-              isRegistered: this.isRegistered
+              isRegistered: this.isRegistered()
             });
             break;
           case RegistererState.Registered:
@@ -18699,14 +18754,10 @@ var WebCall = (() => {
               type: "SIP",
               content: {
                 registererState: state,
-                isRegistered: this.isRegistered
+                isRegistered: this.isRegistered()
               }
             });
             this.setRegister(true);
-            this.callKit.trigger(KitEvent.SIP_REGISTERER_EVENT, {
-              registererState: state,
-              isRegistered: this.isRegistered
-            });
             break;
           case RegistererState.Terminated:
             this.callKit.logger.info("registerer stateChange Terminated", {
@@ -18714,31 +18765,23 @@ var WebCall = (() => {
               type: "SIP",
               content: {
                 registererState: state,
-                isRegistered: this.isRegistered
+                isRegistered: this.isRegistered()
               }
             });
             this.setRegister(false);
             this.setConnectStatus(CallStatus.init);
-            this.callKit.trigger(KitEvent.SIP_REGISTERER_EVENT, {
-              isRegistered: this.isRegistered,
-              registererState: state
-            });
             break;
           case RegistererState.Unregistered:
             this.callKit.logger.info("registerer stateChange Unregistered", {
               caller: "Connect.register.registererStateChange",
               type: "SIP",
               content: {
-                isRegistered: this.isRegistered,
+                isRegistered: this.isRegistered(),
                 registererState: state
               }
             });
             this.setRegister(false);
             this.setConnectStatus(CallStatus.init);
-            this.callKit.trigger(KitEvent.SIP_REGISTERER_EVENT, {
-              isRegistered: this.isRegistered,
-              registererState: state
-            });
             break;
           default:
             break;
@@ -18751,7 +18794,7 @@ var WebCall = (() => {
             caller: "Connect.register.onInvite",
             content: {
               invite,
-              isRegistered: this.isRegistered
+              isRegistered: this.isRegistered()
             }
           });
           this.currentSession = invite;
@@ -18771,7 +18814,7 @@ var WebCall = (() => {
                 this.setConnectStatus(CallStatus.ringing);
                 this.callKit.trigger(KitEvent.SIP_SESSION_EVENT, {
                   sessionState: state,
-                  isRegistered: this.isRegistered
+                  isRegistered: this.isRegistered()
                 });
                 break;
               case SessionState2.Established:
@@ -18785,14 +18828,14 @@ var WebCall = (() => {
                 this.callKit.connect.setConnectStatus(CallStatus.calling);
                 this.callKit.trigger(KitEvent.SIP_SESSION_EVENT, {
                   sessionState: state,
-                  isRegistered: this.isRegistered
+                  isRegistered: this.isRegistered()
                 });
                 setupRemoteMedia(this.currentSession);
                 break;
               case SessionState2.Terminating:
                 this.callKit.trigger(KitEvent.SIP_SESSION_EVENT, {
                   sessionState: state,
-                  isRegistered: this.isRegistered
+                  isRegistered: this.isRegistered()
                 });
                 break;
               case SessionState2.Terminated:
@@ -18813,7 +18856,7 @@ var WebCall = (() => {
                 this.isUnprompted = false;
                 this.callKit.trigger(KitEvent.SIP_SESSION_EVENT, {
                   sessionState: state,
-                  isRegistered: this.isRegistered
+                  isRegistered: this.isRegistered()
                 });
                 break;
               default:
@@ -19000,11 +19043,10 @@ var WebCall = (() => {
         caller: "Connect.unregister",
         type: "SIP",
         content: {
-          isRegistered: this.isRegistered,
-          registerer: this.registerer
+          isRegistered: this.isRegistered()
         }
       });
-      if (!this.isRegistered || !this.registerer) {
+      if (!this.isRegistered() || !this.registerer) {
         this.callKit.logger.warn("No registerer to unregister.", {
           caller: "Connect.unregister",
           type: "SIP",
@@ -19034,7 +19076,7 @@ var WebCall = (() => {
         }
       });
       this.isOutgoing = true;
-      if (!this.isRegistered) {
+      if (!this.isRegistered()) {
         await this.register();
       }
       this.setConnectStatus(CallStatus.connecting);
@@ -19054,7 +19096,7 @@ var WebCall = (() => {
           register
         }
       });
-      this.isRegistered = register;
+      this.isRegister = register;
       this.callKit.trigger(KitEvent.KIT_REGISTER_CHANGE, register);
     }
     /**
@@ -19193,133 +19235,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", {
-          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", {
+      if (this.isMute === mute) {
+        this.callKit.logger.warn("Already muted", {
           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
+            isCalling: this.isCalling(),
+            isMuted: this.isMuted()
           }
         });
         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
-          }
-        });
-        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", {
@@ -19616,7 +19627,6 @@ var WebCall = (() => {
             errCode: ErrorCode.SOCKET_CONNECT_ERROR
           }
         });
-        this.callKit.config.reset();
         this.callKit.reset();
         return;
       }
@@ -19723,7 +19733,7 @@ var WebCall = (() => {
      * 重置 socket 连接和所有状态
      * @param isWaitConfirm Whether need to wait for close confirmation
      */
-    async reset(isWaitConfirm = true) {
+    async reset() {
       if (this.pingTimer) {
         clearInterval(this.pingTimer);
         this.pingTimer = void 0;
@@ -19735,9 +19745,7 @@ var WebCall = (() => {
         this.callKit.logger.info("Closing socket connection", {
           caller: "Socket.reset",
           type: "INCALL",
-          content: {
-            isWaitConfirm
-          }
+          content: {}
         });
         this.ws.close();
         this.isConnected = false;
@@ -19909,8 +19917,8 @@ var WebCall = (() => {
         }
       }
       await this.hangup();
-      this.socket.reset(false);
       this.connect.reset();
+      this.socket.reset();
       this.config.reset();
       this.trigger(KitEvent.KIT_LOGIN_CHANGE, false);
     }
@@ -20022,6 +20030,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