@vgroup/dialbox 0.0.81 → 0.0.83

package/fesm2020/vgroup-dialbox.mjs

@@ -1387,30 +1387,107 @@ class TwilioService {
         this.isAvailableNumber = new BehaviorSubject(false);
         this.callerIdList = new BehaviorSubject([]);
         this.triggerSMSReload = new BehaviorSubject(false);
-        this.initializeTwilioDevice();
+        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);
+    }
+    ngOnDestroy() {
+        if (this.tokenCheckInterval) {
+            clearInterval(this.tokenCheckInterval);
+        }
+        if (this.device) {
+            this.device.destroy();
+        }
     }
     initializeTwilioDevice() {
-        if (this.token) {
-            this.extensionService.getIncomingCallToken().subscribe((data) => {
-                this.incomingCallToken = data.token;
-                localStorage.setItem('in-token', data.token);
-                this.device = new Device(this.incomingCallToken, {
-                    allowIncomingWhileBusy: true,
-                    // Add any other necessary options
-                });
-                this.device.register();
-                this.device.on('incoming', (call) => {
-                    this.currentCall.next(call);
-                    this.callType.next('INCOMING');
-                    this.currentCallState.next('incoming');
-                    this.notificationSerivce.showNotification(call);
-                });
-                this.device.on('error', (error) => {
-                    console.error('Twilio Device Error:', error);
-                    // Add error handling and reconnection logic
-                });
-            });
+        // Prevent multiple initializations
+        if (this.deviceInitialized || this.initializationInProgress || !this.token) {
+            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);
+            }
+        });
+    }
+    setupDeviceEventHandlers() {
+        if (!this.device)
+            return;
+        this.device.on('incoming', (call) => {
+            console.log('Incoming call received:', call.parameters);
+            this.currentCall.next(call);
+            this.callType.next('INCOMING');
+            this.currentCallState.next('incoming');
+            this.notificationSerivce.showNotification(call);
+        });
+        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();
+            }
+        });
+        this.device.on('registered', () => {
+            console.log('Twilio Device registered');
+            this.deviceInitialized = true;
+        });
+        this.device.on('unregistered', () => {
+            console.log('Twilio Device unregistered');
+            this.deviceInitialized = false;
+        });
     }
     // onIncomingCall(){
     //   this.device.on('incoming', (call:any) => {
@@ -2206,7 +2283,28 @@ class DialboxComponent {
             return;
         this.token = localStorage.getItem('ext_token') || '';
         if (!this.token) {
-            console.error('No authentication token found');
+            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);
+                    }
+                }
+            });
             return;
         }
         this.isInitialized = true;
@@ -2325,8 +2423,10 @@ 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) => {
@@ -3185,6 +3285,13 @@ 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();