@koi-design/callkit 2.1.0-beta.2 → 2.1.0-beta.3

package/dist/index.d.ts

@@ -292,6 +292,14 @@ declare const KitEvent: {
     SIP_CONNECT_EVENT: string;
     SIP_REGISTERER_EVENT: string;
     SIP_SESSION_EVENT: string;
+    /**
+     * Refering change
+     */
+    KIT_REFERING_CHANGE: string;
+    /**
+     * In call refering change
+     */
+    KIT_IN_CALL_REFERING_CHANGE: string;
 };
 declare const SocketSendEvent: {
     /**
@@ -419,7 +427,11 @@ declare class Connect {
     /**
      *@description  Whether it's a referring
      */
-    isRefering: boolean;
+    private _isRefering;
+    /**
+     *@description  Whether it's in call refering dealwith disconnect recovery
+     */
+    private _isInCallRefering;
     /**
      *@description  Whether it's an outgoing call
      */
@@ -442,11 +454,22 @@ declare class Connect {
     };
     private currentCallId;
     getCurrentCallId(): string | null;
+    /**
+     *@description  Whether the SIP socket is error
+     */
+    private _isError;
+    get isError(): boolean;
+    /**
+     *@description  Set whether it's in call refering dealwith disconnect recovery
+     */
+    private setInCallRefering;
     setRefering(refering: boolean): void;
     private setIsReConnected;
     setOutgoing(outgoing: boolean): void;
     setCallId(callId: string | null): void;
-    reset(): Promise<void>;
+    reset({ force }?: {
+        force?: boolean;
+    }): Promise<void>;
     private getAduioReference;
     permission(): Promise<void>;
     /**
@@ -475,6 +498,14 @@ declare class Connect {
      * isMute
      */
     isMuted(): boolean;
+    /**
+     * isRefering
+     */
+    isRefering(): boolean;
+    /**
+     * isInCallRefering
+     */
+    isInCallRefering(): boolean;
     /**
      * Call ended, call not started
      * @returns
@@ -519,6 +550,7 @@ declare class Connect {
     setHold(hold: boolean): Promise<void>;
     setMute(mute: boolean): Promise<void>;
     refer(referTo: string, extra?: any): Promise<void>;
+    private referInCall;
 }
 
 interface CallKitConfig {

package/dist/index.global.js

@@ -3483,7 +3483,15 @@ var WebCall = (() => {
     INCALL_CONNECT_EVENT: "IncallConnectEvent",
     SIP_CONNECT_EVENT: "sipConnectEvent",
     SIP_REGISTERER_EVENT: "sipRegistererEvent",
-    SIP_SESSION_EVENT: "sipSessionEvent"
+    SIP_SESSION_EVENT: "sipSessionEvent",
+    /**
+     * Refering change
+     */
+    KIT_REFERING_CHANGE: "referingChange",
+    /**
+     * In call refering change
+     */
+    KIT_IN_CALL_REFERING_CHANGE: "inCallReferingChange"
   };
   var ErrorCode = {
     /**
@@ -3870,7 +3878,7 @@ var WebCall = (() => {
   // package.json
   var package_default = {
     name: "@koi-design/callkit",
-    version: "2.1.0-beta.2",
+    version: "2.1.0-beta.3",
     description: "callkit",
     author: "koi",
     license: "ISC",
@@ -18657,7 +18665,11 @@ ${log}` : log;
     /**
      *@description  Whether it's a referring
      */
-    isRefering = false;
+    _isRefering = false;
+    /**
+     *@description  Whether it's in call refering dealwith disconnect recovery
+     */
+    _isInCallRefering = false;
     // sipConnected = false;
     /**
      *@description  Whether it's an outgoing call
@@ -18682,8 +18694,30 @@ ${log}` : log;
     getCurrentCallId() {
       return this.currentCallId;
     }
+    /**
+     *@description  Whether the SIP socket is error
+     */
+    _isError = false;
+    get isError() {
+      return this._isError;
+    }
+    /**
+     *@description  Set whether it's in call refering dealwith disconnect recovery
+     */
+    setInCallRefering(refering) {
+      if (this._isInCallRefering === refering)
+        return;
+      this.callKit.logger.info("setIsInCallRefering", {
+        caller: "Connect.setIsInCallRefering",
+        content: {
+          refering
+        }
+      });
+      this._isInCallRefering = refering;
+      this.callKit.trigger(KitEvent.KIT_IN_CALL_REFERING_CHANGE);
+    }
     setRefering(refering) {
-      if (this.isRefering === refering)
+      if (this._isRefering === refering)
         return;
       this.callKit.logger.info("setRefering", {
         caller: "Connect.setRefering",
@@ -18691,7 +18725,8 @@ ${log}` : log;
           refering
         }
       });
-      this.isRefering = refering;
+      this._isRefering = refering;
+      this.callKit.trigger(KitEvent.KIT_REFERING_CHANGE);
     }
     setIsReConnected(isReConnected) {
       if (this.isReConnected === isReConnected)
@@ -18725,13 +18760,19 @@ ${log}` : log;
       this.currentCallId = callId;
       this.callKit.trigger(KitEvent.KIT_CALL_ID_CHANGE, callId);
     }
-    async reset() {
+    async reset({ force = false } = { force: false }) {
       this.setOutgoing(false);
       this.isUnprompted = false;
       this.hasInvite = false;
-      if (this.isRefering) {
+      if (force) {
+        this._isError = false;
+      }
+      if (this._isRefering) {
         this.setRefering(false);
       }
+      if (this._isInCallRefering) {
+        this.setInCallRefering(false);
+      }
       if (this.isReConnected) {
         this.setIsReConnected(false);
       }
@@ -18827,6 +18868,18 @@ ${log}` : log;
     isMuted() {
       return this.isMute;
     }
+    /**
+     * isRefering
+     */
+    isRefering() {
+      return this._isRefering;
+    }
+    /**
+     * isInCallRefering
+     */
+    isInCallRefering() {
+      return this._isInCallRefering;
+    }
     /**
      * Call ended, call not started
      * @returns
@@ -18876,7 +18929,9 @@ ${log}` : log;
               }
             });
             this.setRegister(false);
-            this.setConnectStatus(CallStatus.init);
+            if (!this.isInCallRefering()) {
+              this.setConnectStatus(CallStatus.init);
+            }
             this.callKit.trigger(KitEvent.SIP_REGISTERER_EVENT, {
               registererState: state,
               isRegistered: this.isRegistered()
@@ -18907,7 +18962,7 @@ ${log}` : log;
                     }
                   }
                 );
-                this.refer(selfUri).catch((err) => {
+                this.referInCall(selfUri).catch((err) => {
                   this.callKit.logger.error(err, {
                     caller: "Connect.setupRegisterer.registererStateChange",
                     type: "SIP",
@@ -18945,14 +19000,18 @@ ${log}` : log;
               type: "SIP",
               content: {
                 registererState: state,
-                isRegistered: this.isRegistered()
+                isRegistered: this.isRegistered(),
+                isInCallRefering: this.isInCallRefering()
               }
             });
             this.setRegister(false);
-            this.setConnectStatus(CallStatus.init);
+            if (!this.isInCallRefering()) {
+              this.setConnectStatus(CallStatus.init);
+            }
             this.callKit.trigger(KitEvent.SIP_REGISTERER_EVENT, {
               registererState: state,
-              isRegistered: this.isRegistered()
+              isRegistered: this.isRegistered(),
+              isInCallRefering: this.isInCallRefering()
             });
             break;
           case RegistererState.Unregistered:
@@ -18961,14 +19020,18 @@ ${log}` : log;
               type: "SIP",
               content: {
                 isRegistered: this.isRegistered(),
-                registererState: state
+                registererState: state,
+                isInCallRefering: this.isInCallRefering()
               }
             });
             this.setRegister(false);
-            this.setConnectStatus(CallStatus.init);
+            if (!this.isInCallRefering()) {
+              this.setConnectStatus(CallStatus.init);
+            }
             this.callKit.trigger(KitEvent.SIP_REGISTERER_EVENT, {
               registererState: state,
-              isRegistered: this.isRegistered()
+              isRegistered: this.isRegistered(),
+              isInCallRefering: this.isInCallRefering()
             });
             break;
           default:
@@ -19135,14 +19198,17 @@ ${log}` : log;
                   caller: "Connect.register.onInvite",
                   type: "SIP",
                   content: {
-                    sessionState: state
+                    sessionState: state,
+                    isInCallRefering: this.isInCallRefering()
                   }
                 });
-                this.setConnectStatus(CallStatus.ringing);
-                this.callKit.trigger(KitEvent.SIP_SESSION_EVENT, {
-                  sessionState: state,
-                  isRegistered: this.isRegistered()
-                });
+                if (!this.isInCallRefering()) {
+                  this.setConnectStatus(CallStatus.ringing);
+                  this.callKit.trigger(KitEvent.SIP_SESSION_EVENT, {
+                    sessionState: state,
+                    isRegistered: this.isRegistered()
+                  });
+                }
                 break;
               case SessionState2.Established:
                 this.callKit.logger.info("connect Established", {
@@ -19152,17 +19218,20 @@ ${log}` : log;
                     sessionState: state
                   }
                 });
-                this.callKit.connect.setConnectStatus(CallStatus.calling);
-                this.callKit.trigger(KitEvent.SIP_SESSION_EVENT, {
-                  sessionState: state,
-                  isRegistered: this.isRegistered()
-                });
+                if (!this.isInCallRefering()) {
+                  this.callKit.connect.setConnectStatus(CallStatus.calling);
+                  this.callKit.trigger(KitEvent.SIP_SESSION_EVENT, {
+                    sessionState: state,
+                    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(),
+                  isInCallRefering: this.isInCallRefering()
                 });
                 break;
               case SessionState2.Terminated:
@@ -19170,7 +19239,8 @@ ${log}` : log;
                   caller: "Connect.register.onInvite",
                   type: "SIP",
                   content: {
-                    sessionState: state
+                    sessionState: state,
+                    isInCallRefering: this.isInCallRefering()
                   }
                 });
                 this.hasInvite = false;
@@ -19180,7 +19250,8 @@ ${log}` : log;
                 this.isUnprompted = false;
                 this.callKit.trigger(KitEvent.SIP_SESSION_EVENT, {
                   sessionState: state,
-                  isRegistered: this.isRegistered()
+                  isRegistered: this.isRegistered(),
+                  isInCallRefering: this.isInCallRefering()
                 });
                 break;
               default:
@@ -19230,9 +19301,9 @@ ${log}` : log;
               }
             });
           }
-          if (this.isRefering) {
+          if (this.isInCallRefering()) {
             this.currentSession.accept(options);
-            this.setRefering(false);
+            this.setInCallRefering(false);
             return;
           }
           if (this.isOutgoing) {
@@ -19319,7 +19390,10 @@ ${log}` : log;
     reconnectTimer;
     reconnectAttempts = 0;
     startReconnectTimer() {
+      if (this._isError)
+        return;
       if (this.reconnectAttempts >= this.reconnectConfig.maxAttempts && this.callKit.config.isLogin()) {
+        this._isError = true;
         this.callKit.reset();
         this.callKit.logger.error("Reconnect failed max attempts", {
           caller: "Connect.startReconnectTimer",
@@ -19342,10 +19416,10 @@ ${log}` : log;
         }
       });
       this.reconnectAttempts += 1;
+      this.setIsReConnected(true);
       this.reconnectTimer = setTimeout(() => {
         if (this.reconnectTimer && this.callKit.config.isLogin()) {
           this.userAgent?.reconnect();
-          this.setIsReConnected(true);
           this.callKit.logger.info("Reconnect attempt", {
             caller: "Connect.startReconnectTimer",
             type: "SIP",
@@ -19658,6 +19732,35 @@ ${log}` : log;
       }
       this.currentSession.refer(target, extra?.sessionReferOptions);
     }
+    async referInCall(referTo, extra) {
+      if (!this.currentSession) {
+        const errorMsg = "Cannot refer in call: currentSession is not available";
+        this.callKit.logger.warn(errorMsg, {
+          caller: "Connect.referInCall",
+          type: "SIP",
+          content: {
+            errCode: ErrorCode.WEBRTC_CALL_INVITE_ERROR,
+            referTo
+          }
+        });
+        return;
+      }
+      this.setInCallRefering(true);
+      this.callKit.logger.info("connect referInCall", {
+        caller: "Connect.referInCall",
+        type: "SIP",
+        content: {
+          referTo,
+          extra,
+          sessionState: this.currentSession.state
+        }
+      });
+      let target;
+      if (referTo) {
+        target = UserAgent.makeURI(referTo);
+      }
+      this.currentSession.refer(target, extra?.sessionReferOptions);
+    }
   };
 
   // core/socket.ts
@@ -19965,14 +20068,10 @@ ${log}` : log;
           this.callKit.connect.socketTriggerHangup(callUuid);
         }
       }
-      this.callKit.trigger(
-        KitEvent.SERVER_SOCKET_EVENT,
-        {
-          ...data,
-          callUuid
-        },
-        true
-      );
+      this.callKit.trigger(KitEvent.SERVER_SOCKET_EVENT, {
+        ...data,
+        callUuid
+      });
     }
     send(event, message) {
       if (!this.connectAuthState.isConnected) {
@@ -20207,7 +20306,7 @@ ${log}` : log;
           encryptionPassword
         }
       });
-      if (this.socket.isError) {
+      if (this.socket.isError || this.connect.isError) {
         this.logger.warn("socket is error", {
           caller: "CallKit.login",
           content: { username, password, extra, socketError: this.socket.isError }
@@ -20445,7 +20544,7 @@ ${log}` : log;
       if (this.connect.isCalling()) {
         await this.hangup();
       }
-      await this.connect.reset();
+      await this.connect.reset({ force });
       if (this.config.isLogin()) {
         await this.logout({ isReset: false });
       } else {