@vgroup/dialbox 0.7.56 → 0.7.57

package/fesm2020/vgroup-dialbox.mjs

@@ -1487,11 +1487,23 @@ class TwilioService {
         this.pendingIncomingDevices = new Map();
         this.extraDevices = new Map();
         this.incomingCallsMap = new Map();
+        this.tokenRefreshInProgress = false;
+        this.recoveryAttempts = 0;
+        this.recoveryTimer = null;
         // User-controlled switch (in the call-progress UI). When ON, a new incoming
         // call's built-in Twilio ringtone is silenced so it does not disturb the
         // ongoing call. Source of truth so newly created (spare) devices inherit it.
         this.isIncomingMuted = false;
         this.initializeToken();
+        // Safety net for long idle/sleep periods: the signaling socket can die silently
+        // (OS suspends timers, tab is backgrounded) without ever firing 'error'/'unregistered'.
+        // Re-check device health whenever the app becomes active/online again.
+        document.addEventListener('visibilitychange', () => {
+            if (document.visibilityState === 'visible') {
+                this.ensureDeviceHealthy();
+            }
+        });
+        window.addEventListener('online', () => this.ensureDeviceHealthy());
     }
     initializeToken() {
         if (this.tokenInitialized) {
@@ -1534,6 +1546,14 @@ class TwilioService {
         this.device = new Device(this.incomingCallToken, { allowIncomingWhileBusy: true });
         this.device.on('registered', () => {
             console.log('Twilio Device registered successfully');
+            this.recoveryAttempts = 0;
+        });
+        // Twilio fires this ~3 minutes before the access token expires. Swap in a
+        // fresh one via updateToken() so the signaling connection never has to drop
+        // in the first place (this is the main cause of "idle for a while, BE still
+        // notifies but Twilio incoming event never fires").
+        this.device.on('tokenWillExpire', () => {
+            this.refreshDeviceToken();
         });
         this.device.on('incoming', (call) => {
             if (this.acceptedCallList.length > 0 || this.primaryHasCall) {
@@ -1574,16 +1594,81 @@ class TwilioService {
             console.error('Twilio Device Error:', error);
             this.isShowIncomingCall = false;
             this.tokenInitialized = false;
+            this.scheduleDeviceRecovery();
         });
         this.device.on('unregistered', () => {
             console.log('Twilio Device unregistered');
             this.isShowIncomingCall = false;
             this.tokenInitialized = false;
+            this.scheduleDeviceRecovery();
         });
         // Register AFTER attaching all listeners
         this.device.register();
         console.log('device created', this.device);
     }
+    // Proactively swap in a fresh access token ahead of expiry (see 'tokenWillExpire'
+    // above) so the Device's signaling connection survives long idle periods.
+    refreshDeviceToken() {
+        if (this.tokenRefreshInProgress) {
+            return;
+        }
+        this.tokenRefreshInProgress = true;
+        this.extensionService.getIncomingCallToken(this.deviceId).subscribe({
+            next: (data) => {
+                this.tokenRefreshInProgress = false;
+                this.incomingCallToken = data.token;
+                localStorage.setItem('in-token', data.token);
+                this.tokenInitialized = true;
+                try {
+                    this.device?.updateToken(this.incomingCallToken);
+                }
+                catch (err) {
+                    console.error('Failed to apply refreshed Twilio token:', err);
+                }
+            },
+            error: (err) => {
+                this.tokenRefreshInProgress = false;
+                console.error('Failed to refresh Twilio token ahead of expiry:', err);
+            }
+        });
+    }
+    // Self-heal after the Device dies (expired token, dropped signaling socket while
+    // idle/asleep, etc). Never runs while a call is actually active, and backs off so a
+    // genuinely logged-out/offline user doesn't retry forever.
+    scheduleDeviceRecovery() {
+        if (this.acceptedCallList.length > 0 || this.recoveryTimer) {
+            return;
+        }
+        const delay = Math.min(30000, 2000 * Math.pow(2, this.recoveryAttempts));
+        this.recoveryAttempts++;
+        this.recoveryTimer = setTimeout(() => {
+            this.recoveryTimer = null;
+            const authToken = localStorage.getItem('ext_token');
+            if (!authToken || authToken === 'logout') {
+                this.recoveryAttempts = 0;
+                return;
+            }
+            this.tokenInitialized = false;
+            this.initializeToken().subscribe({
+                error: (err) => console.error('Twilio device recovery attempt failed:', err)
+            });
+        }, delay);
+    }
+    // Safety net for the case where the underlying socket dies silently during a long
+    // sleep/idle period without ever firing 'error'/'unregistered' (the OS can suspend
+    // timers/sockets outright) — re-check device health whenever the app wakes up.
+    ensureDeviceHealthy() {
+        if (this.acceptedCallList.length > 0) {
+            return;
+        }
+        if (!this.device || this.device.state !== 'registered') {
+            console.log('Twilio device unhealthy after wake/visibility change, re-initializing');
+            this.tokenInitialized = false;
+            this.initializeToken().subscribe({
+                error: (err) => console.error('Twilio device recovery failed:', err)
+            });
+        }
+    }
     saveContact(payload) {
         const httpOptions = { headers: new HttpHeaders({ 'Content-Type': 'application/json', 'Auth-Key': "Bearer " + localStorage.getItem('ext_token') }) };
         return this.http.post(environment.apiUrl + '/utilities/phonebook/add/contacts/manually', payload, httpOptions);
@@ -2769,6 +2854,9 @@ class CallProgressComponent {
                             deviceId: this.deviceId,
                             clientSid: this.call?.parameters['CallSid']
                         });
+                        if (addClientParticipantRes?.status != 200) {
+                            swal("Error", response?.message.join("<br/>"), "error");
+                        }
                         this.addRes = await this.addParticipantToCall({
                             from: callData?.from,
                             route: "OUTGOING",
@@ -3209,10 +3297,13 @@ class CallProgressComponent {
                 mute: ourNumberInfo?.mute || false
             };
             this.extensionService.holdParticipant(payload).subscribe((res) => {
+                console.log('holdParticipant res', res);
                 if (res?.status != 200) {
                     swal("Error", res?.message?.join?.("<br/>") || 'Internal Server Error', "error");
                 }
-                this.add(incomingCallInfo, ourNumberInfo);
+                else {
+                    this.add(incomingCallInfo, ourNumberInfo);
+                }
             });
             this.isConferenceCallHold = true;
         }
@@ -4371,11 +4462,9 @@ class DialboxComponent {
         // intercepted with a custom modal. Triggers the native confirmation so the
         // user does not lose the call accidentally. (Browser controls the wording.)
         if (this.isCallInProgress || this.incomingCallsList?.length) {
-            //  $event.preventDefault();
             const confirmationMessage = 'Reloading this page will disconnect your active call. Are you sure you want to continue?';
             $event.returnValue = confirmationMessage;
             $event.preventDefault();
-            // this.confirmReloadDuringCall();
             return confirmationMessage;
         }
         return undefined;
@@ -4385,27 +4474,7 @@ class DialboxComponent {
         if (this.isReloadConfirmed) {
             return;
         }
-        // Fires only after the user confirmed the native reload/navigation. Remove
-        // the conference participants using a keepalive request so it survives the
-        // page being torn down (a normal HttpClient call would be cancelled).
-        if (this.isCallInProgress || this.incomingCallsList?.length) {
-            // this.removeParticipantsOnUnload();
-        }
     }
-    // private removeParticipantsOnUnload() {
-    //   const conferenceId = this.incomingCallsList?.[0]?.conferenceId;
-    //   if (!conferenceId) {
-    //     return;
-    //   }
-    //   try {
-    //     fetch(
-    //       `${environment.apiUrl}/utilities/ext/ur/remove/participant/all/${conferenceId}`,
-    //       { method: 'GET', keepalive: true }
-    //     );
-    //   } catch {
-    //     // Best-effort cleanup during unload; nothing else we can do here.
-    //   }
-    // }
     constructor(twilioService, extService, ipService, extensionService, cdk, router, incomeingCallSocketService) {
         this.twilioService = twilioService;
         this.extService = extService;
@@ -4476,6 +4545,7 @@ class DialboxComponent {
         // Set once the user confirms an intentional reload via our custom modal,
         // so the native beforeunload prompt is not shown on top of it.
         this.isReloadConfirmed = false;
+        this.nullParticipantCallList = [];
         this.contactNameForLoader = '';
         this.contactImgForLoader = 'assets/images/user.jpg';
         this.incomingFromImage = '';
@@ -4487,9 +4557,6 @@ class DialboxComponent {
         }
         this.incomeingCallSocketService.createAudioBase();
     }
-    async getRemoveParticipants(participantId, conferenceId) {
-        return await this.extensionService.getRemoveParticipants(participantId, conferenceId).toPromise();
-    }
     initializeTwilio() {
         if (!this.isInitialized) {
             this.token = localStorage.getItem('ext_token') || '';
@@ -4525,7 +4592,11 @@ class DialboxComponent {
                 const socketConferenceIds = incomingCallData.map((c) => c.conferenceId);
                 incomingCallData.forEach((callInfo) => {
                     // Check if WE are an active participant in this conference
-                    const ourNumber = callInfo.participants.find((resData) => ((this.deviceNumberList.includes(resData?.from) && resData?.direction == 'outgoing-call' && resData?.client) ||
+                    if (!callInfo?.participants?.length && !this.nullParticipantCallList.includes(callInfo?.conferenceId)) {
+                        this.nullParticipantCallList.push(callInfo?.conferenceId);
+                        swal("Error", 'Call not connected facing some issue', "error");
+                    }
+                    const ourNumber = callInfo?.participants.find((resData) => ((this.deviceNumberList.includes(resData?.from) && resData?.direction == 'outgoing-call' && resData?.client) ||
                         (this.deviceNumberList.includes(resData?.to) && resData?.direction == 'incoming-call' && resData?.client &&
                             resData?.callStatus !== 'completed' &&
                             (resData?.callStatus == 'participant-join' || resData?.callStatus == 'participant-mute' ||