@koi-design/callkit 2.0.0-beta.3 → 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
      */
@@ -351,11 +357,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 +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>;
 }
 
@@ -477,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);
     }
   };
 
@@ -18433,6 +18471,10 @@ var WebCall = (() => {
      * Whether registered
      */
     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);
@@ -18518,7 +18560,7 @@ var WebCall = (() => {
      * isHolding
      */
     isHolding() {
-      return this.connectStatus === CallStatus.holding;
+      return this.isHold;
     }
     /**
      * isRegistered
@@ -18716,10 +18758,6 @@ var WebCall = (() => {
               }
             });
             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", {
@@ -18732,10 +18770,6 @@ var WebCall = (() => {
             });
             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", {
@@ -18748,10 +18782,6 @@ var WebCall = (() => {
             });
             this.setRegister(false);
             this.setConnectStatus(CallStatus.init);
-            this.callKit.trigger(KitEvent.SIP_REGISTERER_EVENT, {
-              isRegistered: this.isRegistered(),
-              registererState: state
-            });
             break;
           default:
             break;
@@ -19205,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", {
+      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
+            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", {
@@ -20031,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