@vgroup/dialbox 0.0.83 → 0.0.85

package/fesm2020/vgroup-dialbox.mjs

@@ -2,11 +2,11 @@ import * as i0 from '@angular/core';
 import { Injectable, EventEmitter, Component, Input, Output, ViewChild, Inject, NgModule } from '@angular/core';
 import swal from 'sweetalert2';
 import { AsYouType } from 'libphonenumber-js';
-import { throwError, BehaviorSubject, interval, Subscription } from 'rxjs';
+import { throwError, BehaviorSubject, of, Subscription, filter, interval } from 'rxjs';
 import * as i1 from '@angular/common/http';
 import { HttpHeaders, HttpParams, HttpClientModule } from '@angular/common/http';
+import { catchError, switchMap, map, tap, shareReplay } from 'rxjs/operators';
 import { Device } from '@twilio/voice-sdk';
-import { catchError, switchMap, map } from 'rxjs/operators';
 import * as i3$1 from '@angular/material/dialog';
 import { MAT_DIALOG_DATA } from '@angular/material/dialog';
 import * as i5 from '@angular/router';
@@ -1387,85 +1387,60 @@ class TwilioService {
         this.isAvailableNumber = new BehaviorSubject(false);
         this.callerIdList = new BehaviorSubject([]);
         this.triggerSMSReload = new BehaviorSubject(false);
-        this.deviceInitialized = false;
-        this.initializationInProgress = false;
-        // Initialize immediately if token exists
-        this.token = localStorage.getItem('ext_token');
-        if (this.token) {
-            this.initializeTwilioDevice();
-        }
-        // Set up a polling mechanism to check for token availability
-        this.startTokenCheck();
-    }
-    startTokenCheck() {
-        // Check every 2 seconds if we have a token
-        this.tokenCheckInterval = setInterval(() => {
-            const currentToken = localStorage.getItem('ext_token');
-            if (currentToken && currentToken !== this.token) {
-                this.token = currentToken;
-                this.initializeTwilioDevice();
-            }
-        }, 2000);
+        this.tokenInitialized = false;
+        this.tokenInitialization$ = null;
+        this.lastCallSid = null;
+        this.lastCallTime = 0;
+        this.CALL_DEBOUNCE_MS = 1000; // 1 second debounce
+        this.initializeToken();
+    }
+    initializeToken() {
+        if (this.tokenInitialized) {
+            return this.tokenInitialization$ || of(null);
+        }
+        this.tokenInitialization$ = this.extensionService.getIncomingCallToken().pipe(tap((data) => {
+            this.incomingCallToken = data.token;
+            localStorage.setItem('in-token', data.token);
+            this.tokenInitialized = true;
+            this.initializeDevice();
+        }), catchError(error => {
+            console.error('Error initializing Twilio token:', error);
+            return throwError(() => error);
+        }), shareReplay(1) // Cache the result for subsequent subscribers
+        );
+        return this.tokenInitialization$;
     }
-    ngOnDestroy() {
-        if (this.tokenCheckInterval) {
-            clearInterval(this.tokenCheckInterval);
+    initializeTwilioDevice() {
+        if (this.tokenInitialized && this.incomingCallToken) {
+            this.initializeDevice();
+        }
+        else {
+            this.initializeToken().subscribe();
         }
+    }
+    initializeDevice() {
         if (this.device) {
             this.device.destroy();
         }
-    }
-    initializeTwilioDevice() {
-        // Prevent multiple initializations
-        if (this.deviceInitialized || this.initializationInProgress || !this.token) {
+        if (!this.incomingCallToken) {
+            console.error('No Twilio token available');
             return;
         }
-        this.initializationInProgress = true;
-        this.extensionService.getIncomingCallToken().subscribe({
-            next: (data) => {
-                try {
-                    this.incomingCallToken = data.token;
-                    localStorage.setItem('in-token', data.token);
-                    // Destroy existing device if it exists
-                    if (this.device) {
-                        this.device.destroy();
-                    }
-                    // Initialize Twilio Device with required options
-                    const deviceOptions = {
-                        allowIncomingWhileBusy: true,
-                        closeProtection: true
-                    };
-                    // Only add debug in development
-                    if (!environment.production) {
-                        deviceOptions.debug = false;
-                    }
-                    this.device = new Device(this.incomingCallToken, deviceOptions);
-                    this.device.register();
-                    this.deviceInitialized = true;
-                    this.initializationInProgress = false;
-                    console.log('Twilio Device initialized successfully');
-                    this.setupDeviceEventHandlers();
-                }
-                catch (error) {
-                    console.error('Error initializing Twilio Device:', error);
-                    this.initializationInProgress = false;
-                    // Retry after a delay
-                    setTimeout(() => this.initializeTwilioDevice(), 5000);
-                }
-            },
-            error: (error) => {
-                console.error('Error getting Twilio token:', error);
-                this.initializationInProgress = false;
-                // Retry after a delay
-                setTimeout(() => this.initializeTwilioDevice(), 5000);
-            }
+        this.device = new Device(this.incomingCallToken, {
+            allowIncomingWhileBusy: true,
+            closeProtection: true
         });
-    }
-    setupDeviceEventHandlers() {
-        if (!this.device)
-            return;
+        this.device.register();
         this.device.on('incoming', (call) => {
-            console.log('Incoming call received:', call.parameters);
+            const callSid = call.parameters?.['CallSid'];
+            const now = Date.now();
+            // Skip if this is a duplicate call within the debounce window
+            if (callSid && callSid === this.lastCallSid && (now - this.lastCallTime) < this.CALL_DEBOUNCE_MS) {
+                console.log('Skipping duplicate call:', callSid);
+                return;
+            }
+            this.lastCallSid = callSid;
+            this.lastCallTime = now;
             this.currentCall.next(call);
             this.callType.next('INCOMING');
             this.currentCallState.next('incoming');
@@ -1473,20 +1448,15 @@ class TwilioService {
         });
         this.device.on('error', (error) => {
             console.error('Twilio Device Error:', error);
-            this.deviceInitialized = false;
-            // Attempt to reinitialize on error
-            if (error.code === 31201 || error.code === 20101) {
-                console.log('Authentication error, reinitializing device...');
-                this.initializeTwilioDevice();
-            }
+            // Reset initialization state on error to allow retry
+            this.tokenInitialized = false;
         });
         this.device.on('registered', () => {
-            console.log('Twilio Device registered');
-            this.deviceInitialized = true;
+            console.log('Twilio Device registered successfully');
         });
         this.device.on('unregistered', () => {
             console.log('Twilio Device unregistered');
-            this.deviceInitialized = false;
+            this.tokenInitialized = false;
         });
     }
     // onIncomingCall(){
@@ -1610,43 +1580,63 @@ class IncomingCallComponent {
         this.closeIncomingCallDiv = new EventEmitter();
         this.incomingCallsNewList = new EventEmitter();
         this.selectedIncomingCallInfo = new EventEmitter();
+        this.subscription = new Subscription();
+        this.callHandled = new Set(); // Track handled calls by CallSid
     }
     ngOnInit() {
-        // this.twilioService.currentCall.subscribe((call: any) => {
-        //   if (call) {
-        //     this.twilioCallData = call;
-        //     this.notificationSerivce.showNotification(call);
-        //     // Handle the call UI
-        //   }
-        // });
         try {
-            this.twilioService.currentCall.subscribe(call => {
-                if (call) {
-                    this.twilioCallData = call;
-                    this.twilioAuthId = call.customParameters.get('twilioAuthId');
-                    if (!call.parameters) {
-                        call.parameters = {};
-                    }
-                    this.sendIPforIncomingCall(this.twilioAuthId, '');
-                    call.on('cancel', () => {
-                        if (this.incomingCallData && this.incomingCallData.parameters && this.incomingCallData.parameters.CallSid) {
-                            this.newIncomingCallsList = this.newIncomingCallsList.filter((item) => item.parameters && item.parameters.CallSid !== this.incomingCallData.parameters.CallSid);
-                        }
-                        this.rejectCallFromList(call);
-                    });
-                    call.on('disconnect', () => {
-                        if (this.incomingCallData && this.incomingCallData.parameters && this.incomingCallData.parameters.CallSid) {
-                            this.newIncomingCallsList = this.newIncomingCallsList.filter((item) => item.parameters && item.parameters.CallSid !== this.incomingCallData.parameters.CallSid);
-                        }
-                        this.rejectCallFromList(call);
-                    });
-                }
-            });
+            // Only handle the call if we have incomingCallData
+            if (this.incomingCallData) {
+                this.handleIncomingCall(this.incomingCallData);
+            }
+            // Subscribe to new calls
+            this.subscription.add(this.twilioService.currentCall.pipe(
+            // Filter out duplicate calls that we've already handled
+            filter((call) => {
+                if (!call)
+                    return false;
+                const callSid = call.parameters['CallSid'];
+                return callSid && !this.callHandled.has(callSid);
+            })).subscribe(call => {
+                this.handleIncomingCall(call);
+            }));
         }
         catch (e) {
-            console.log(e);
+            console.error('Error in incoming call handling:', e);
         }
     }
+    handleIncomingCall(call) {
+        if (!call)
+            return;
+        const callSid = call.parameters?.CallSid;
+        if (!callSid || this.callHandled.has(callSid)) {
+            return; // Skip if no CallSid or already handled
+        }
+        this.callHandled.add(callSid);
+        this.twilioCallData = call;
+        this.twilioAuthId = call.customParameters?.get('twilioAuthId');
+        if (!call.parameters) {
+            call.parameters = {};
+        }
+        // Send IP for the incoming call
+        this.sendIPforIncomingCall(this.twilioAuthId, '');
+        // Setup call event handlers
+        const handleCallEnd = () => {
+            if (callSid) {
+                this.callHandled.delete(callSid);
+                if (this.newIncomingCallsList) {
+                    this.newIncomingCallsList = this.newIncomingCallsList.filter((item) => item.parameters?.CallSid !== callSid);
+                }
+            }
+            this.rejectCallFromList(call);
+        };
+        call.on('cancel', handleCallEnd);
+        call.on('disconnect', handleCallEnd);
+    }
+    ngOnDestroy() {
+        this.subscription.unsubscribe();
+        this.callHandled.clear();
+    }
     acceptCallFromList(data) {
         data.accept();
         // data.parameters['isCallConnected'] = true;
@@ -2283,28 +2273,7 @@ class DialboxComponent {
             return;
         this.token = localStorage.getItem('ext_token') || '';
         if (!this.token) {
-            console.warn('No authentication token found. Will retry initializing Twilio when token is available.');
-            // Clear any existing interval to prevent multiple intervals
-            if (this.twilioInitializationInterval) {
-                clearInterval(this.twilioInitializationInterval);
-            }
-            // Set up a check for when token becomes available
-            this.twilioInitializationInterval = setInterval(() => {
-                const newToken = localStorage.getItem('ext_token');
-                if (newToken) {
-                    clearInterval(this.twilioInitializationInterval);
-                    this.token = newToken;
-                    this.initializeTwilio();
-                }
-            }, 2000);
-            // Add cleanup for this interval
-            this.subscriptions.add({
-                unsubscribe: () => {
-                    if (this.twilioInitializationInterval) {
-                        clearInterval(this.twilioInitializationInterval);
-                    }
-                }
-            });
+            console.error('No authentication token found');
             return;
         }
         this.isInitialized = true;
@@ -2423,10 +2392,8 @@ class DialboxComponent {
     // }
     ngOnInit() {
         try {
-            // Initialize Twilio when component loads
-            this.initializeTwilio();
-            // Get token and load initial data
             this.token = localStorage.getItem('ext_token') || '';
+            //this.isCallInProgress = true; 
             this.getContactList();
             this.getUserCallSetting();
             const sub1 = this.twilioService.dialNumberFromOtherModule.subscribe((contact) => {
@@ -3285,13 +3252,6 @@ class DialboxComponent {
             if (this.subscriptions) {
                 this.subscriptions.unsubscribe();
             }
-            // Clear any active intervals
-            if (this.tokenCheckInterval) {
-                clearInterval(this.tokenCheckInterval);
-            }
-            if (this.twilioInitializationInterval) {
-                clearInterval(this.twilioInitializationInterval);
-            }
             // Clean up Twilio device when component is destroyed
             if (this.twilioService['device']) {
                 this.twilioService['device'].destroy();