@reactoo/watchtogether-sdk-js 2.8.48 → 2.8.52

package/src/modules/wt-iot2.js

@@ -1,6 +1,6 @@
 import emitter from './wt-emitter';
 import {decodeJanusDisplay, generateUUID} from "../models/utils";
-import Worker from './wt-iot-worker.worker.js';
+import Worker from './wt-iot-worker5.worker.js';
 
 class Iot {
     constructor(enableDebugFlag) {
@@ -10,7 +10,6 @@ class Iot {
         this.credentialsExpirationCheckIntervalId = null;
         this.currentCredentialsExpirationStamp = null;
         this.lastConnectParams = null;
-        this.subscribedTopics = new Set();
         this.abortController = null;
         this.worker = null;
 
@@ -33,131 +32,123 @@ class Iot {
 
     terminateWorker() {
         this.log('iot terminateWorker');
+		this.worker.onmessage = null;
         this.worker?.terminate();
+		this.worker = null;
     }
 
-    connect(apiMqttUrl, apiMqttClientId, region, accessKeyId, secretAccessKey, sessionToken, expiration) {
-        this.log('iot connect called, we disconnect first just to be sure');
-        return this.disconnect()
-            .catch(() => {
-                // we dont care if disconnect fails
-                return Promise.resolve();
-            })
-            .then(() => {
-                this.log('iot connect');
-
-                if(!this.worker) {
-                    this.log('Worker not initialized');
-                    return Promise.reject(new Error('Worker not initialized', {cause: -1}));
-                }
+   async connect(apiMqttUrl, apiMqttClientId, region, accessKeyId, secretAccessKey, sessionToken, expiration) {
 
-                this.abortController = new AbortController();
-                this.startCredentialsExpirationCheck(expiration);
-                this.lastConnectParams = { apiMqttUrl, apiMqttClientId, region, accessKeyId, secretAccessKey, sessionToken, expiration };
-                return new Promise((resolve, reject) => {
-                    const stamp = new Date().getTime() +'_'+ generateUUID();
-
-                    const handleConnectResult = (event) => {
-
-                        if(event.stamp !== stamp) {
-                            this.log('connect event stamp mismatch, ignoring', event.stamp, stamp);
-                            return;
-                        }
-
-                        clearTimeout(timeoutId);
-                        this.off('worker:connect_result', handleConnectResult);
-                        if (event.success) {
-                            resolve();
-                        } else {
-                            reject(new Error(event.error));
-                        }
-                    };
-
-                    const timeoutId = setTimeout(() => {
-                        this.off('worker:connect_result', handleConnectResult);
-                        reject(new Error('Connection timeout'));
-                    }, 10000);
-
-                    this.on('worker:connect_result', handleConnectResult);
-
-                    this.worker?.postMessage({
-                        type: 'connect',
-                        params: this.lastConnectParams,
-                        stamp: stamp
-                    });
-                });
-            });
-    }
+		await this.disconnect(false).catch(() => {}); // ignore disconnect errors
 
-    disconnect() {
-        this.log('iot disconnect');
-        this.stopCredentialsExpirationCheck();
-        this.abortController?.abort();
+		this.log('iot connect');
 
-        if(!this.worker) {
-            this.log('Worker not initialized');
-            return Promise.reject(new Error('Worker not initialized', {cause: -1}));
-        }
+		this.abortController = new AbortController();
+		this.lastConnectParams = { apiMqttUrl, apiMqttClientId, region, accessKeyId, secretAccessKey, sessionToken, expiration };
 
-        return new Promise((resolve, reject) => {
+		this.initWorker();
+		this.startCredentialsExpirationCheck(expiration);
 
-            const stamp = new Date().getTime()+'_'+ generateUUID();
+		return new Promise((resolve, reject) => {
+			const cleanup = () => {
+				clearTimeout(timeoutId);
+				this.abortController.signal.removeEventListener('abort', onFailure);
+				this.off('connectionSuccess', onSuccess);
+				this.off('connectionFailure', onFailure);
+			};
+			const onSuccess = (event) => {
+				cleanup();
+				resolve();
+			};
+			const onFailure = (event) => {
+				cleanup();
+				reject(event?.error);
+			};
 
-            const handleDisconnectResult = (event) => {
-                if(event.stamp !== stamp) {
-                    this.log('disconnect event stamp mismatch, ignoring', event.stamp, stamp);
-                    return;
-                }
-                clearTimeout(timeoutId);
-                this.off('worker:disconnect_result', handleDisconnectResult);
-                if (event.success) {
-                    resolve();
-                } else {
-                    reject(new Error(event.error));
-                }
-            };
+			const timeoutId = setTimeout(() => {
+				onFailure({ error: 'Connection timeout' });
+			} , 10000);
+			this.abortController.signal.addEventListener('abort', onFailure);
 
-            const timeoutId = setTimeout(() => {
-                this.off('worker:disconnect_result', handleDisconnectResult);
-                reject(new Error('Disconnect timeout'));
-            }, 5000);
+			this.once('connectionSuccess', onSuccess);
+			this.once('connectionFailure', onFailure);
 
-            this.on('worker:disconnect_result', handleDisconnectResult);
-            this.worker?.postMessage({ type: 'disconnect', stamp: stamp });
-        });
+			this.worker?.postMessage({
+				type: 'connect',
+				params: this.lastConnectParams,
+			});
+
+		});
     }
 
-    isConnected() {
+    disconnect(waitForComplete = true) {
+        this.log('iot disconnect');
+
+		this.stopCredentialsExpirationCheck();
+        this.abortController?.abort();
+
+		if(!this.worker) {
+			this.log('Worker not initialized, nothing to disconnect');
+			return Promise.resolve();
+		}
+
+		return new Promise((resolve, reject) => {
+			const cleanup = () => {
+				clearTimeout(timeoutId);
+				this.off('stopped', onSuccess);
+				if(waitForComplete) {
+					this.terminateWorker();
+				}
+			};
+			const onSuccess = (event) => {
+				cleanup();
+				resolve();
+			};
+			const onFailure = (event) => {
+				cleanup();
+				reject(event?.error);
+			};
+
+			const timeoutId = setTimeout(() => {
+				onFailure({ error: 'Timed out' });
+			} , 5000);
+
+			this.once('stopped', onSuccess);
+
+			this.worker?.postMessage({ type: 'disconnect'});
+			if(!waitForComplete) {
+				cleanup();
+				resolve();
+			}
+		});
 
+    }
+
+    isConnected() {
         if(!this.worker) {
             this.log('Worker not initialized');
             return Promise.reject(new Error('Worker not initialized', {cause: -1}));
         }
-
         return new Promise((resolve) => {
+			const stamp = new Date().getTime()+'_'+ generateUUID();
             const handleIsConnectedResult = (event) => {
+				if(event.stamp !== stamp) return
                 this.off('worker:is_connected_result', handleIsConnectedResult);
                 resolve(event.connected);
             };
-
             this.on('worker:is_connected_result', handleIsConnectedResult);
-            this.worker?.postMessage({ type: 'is_connected' });
+            this.worker?.postMessage({ type: 'isConnected' });
         });
     }
 
     clearTopics() {
-        this.subscribedTopics.clear();
-        this.worker?.postMessage({ type: 'clear_topics' });
+        this.worker?.postMessage({ type: 'clearTopics' });
     }
 
     subscribe(topic) {
         this.log('iot subscribe', topic);
         if (typeof topic === 'string' && topic.trim() !== '') {
 
-            if(!this.subscribedTopics.has(topic)) {
-                this.subscribedTopics.add(topic);
-            }
-
             if(!this.worker) {
                 this.log('Worker not initialized');
                 return Promise.reject(new Error('Worker not initialized', {cause: -1}));
@@ -168,7 +159,7 @@ class Iot {
                 const handleSubscribeResult = (event) => {
 
                     if(event.stamp !== stamp) {
-                        this.log('subscribe event stamp mismatch, ignoring', event.stamp, stamp);
+                        // ignoring, not our result
                         return;
                     }
 
@@ -192,7 +183,7 @@ class Iot {
     unsubscribe(topic) {
         this.log('iot unsubscribe', topic);
         if (typeof topic === 'string' && topic.trim() !== '') {
-            this.subscribedTopics.delete(topic);
+
             if(!this.worker) {
                 this.log('Worker not initialized');
                 return Promise.reject(new Error('Worker not initialized', {cause: -1}));
@@ -205,7 +196,7 @@ class Iot {
                 const handleUnsubscribeResult = (event) => {
 
                     if(event.stamp !== stamp) {
-                        this.log('unsubscribe event stamp mismatch, ignoring', event.stamp, stamp);
+                        // ignoring, not our result
                         return;
                     }
 
@@ -237,22 +228,19 @@ class Iot {
     }
 
     handleWorkerMessage(event) {
-        const { type, data, connectionId } = event.data;
+        const { type, data } = event.data;
         switch (type) {
             case 'message':
                 this.handleMessage(data.topic, new Uint8Array(data.payload));
                 break;
-            case 'connect':
-            case 'disconnect':
             case 'error':
-            case 'interrupt':
-            case 'resume':
-            case 'connection_success':
-            case 'connection_failure':
-                this.emit(type, data, connectionId);
+            case 'attemptingConnect':
+            case 'connectionSuccess':
+            case 'connectionFailure':
+            case 'disconnection':
+            case 'stopped':
+                this.emit(type, data);
                 break;
-            case 'connect_result':
-            case 'disconnect_result':
             case 'is_connected_result':
             case 'subscribe_result':
             case 'unsubscribe_result':
@@ -372,11 +360,11 @@ class Iot {
         this.credentialsExpirationCheckIntervalId = null;
     }
 
-    updateWebSocketCredentials(accessKeyId, secretAccessKey, sessionToken, expiration) {
+    updateWebSocketCredentials(accessKeyId, secretAccessKey, sessionToken, expiration, subscribedTopics) {
         this.log('iot updateWebSocketCredentials');
         this.lastConnectParams = {...this.lastConnectParams, accessKeyId, secretAccessKey, sessionToken, expiration };
-        const currentTopics = new Set(this.subscribedTopics);
-        return this.connect(
+        const currentTopics = new Set(subscribedTopics);
+		return this.connect(
             this.lastConnectParams.apiMqttUrl,
             this.lastConnectParams.apiMqttClientId,
             this.lastConnectParams.region,
@@ -386,22 +374,26 @@ class Iot {
             expiration
         ).then(() => {
             // Resubscribe to topics
-            currentTopics.forEach(topic => this.subscribe(topic));
+            currentTopics.forEach(topic => this.subscribe(topic).catch(() => {}));
             return true;
         });
     }
 
-    checkConnection() {
+    checkConnection(subscribedTopics) {
         return new Promise((resolve, reject) => {
-            if (this.subscribedTopics.size === 0) {
+            if (subscribedTopics.size === 0) {
                 reject(new Error('No subscribed topics available for connection check', {cause: -1}));
                 return;
             }
-            let suitableTopic = Array.from(this.subscribedTopics).find(topic => topic.indexOf('user') > -1);
+            let suitableTopic = Array.from(subscribedTopics).find(topic => topic.indexOf('user') > -1);
             if (!suitableTopic) {
                 reject(new Error('No suitable topic found for connection check', {cause: -1}));
                 return;
             }
+			if(!navigator.onLine) {
+				reject(new Error('No internet connection', {cause: -1}));
+				return;
+			}
             const testMessage = {
                 type: 'keep_alive',
                 timestamp: Date.now()

package/src/modules/wt-room-sfu.js

@@ -1195,7 +1195,7 @@ class RoomSession {
 		this.wsOpen = false;
 		this.emit('webSocketsConnectionClosed');
 
-		if (!this.isConnected || this.isConnecting || this.isDisconnecting) {
+		if (!this.isSupposeToBeConnected || this.isRestarting) {
 			return;
 		}
 

package/src/modules/wt-iot-worker.worker.js

@@ -1,203 +0,0 @@
-import { mqtt, iot } from 'aws-iot-device-sdk-v2';
-console.log('Worker: Starting up');
-
-let connection = null;
-let currentConnectionId = 1;
-
-self.onmessage = function(event) {
-    const { type, params, topic, message, stamp } = event.data;
-    console.log(`Worker: Received message of type: ${type}`);
-
-    switch (type) {
-        case 'connect':
-            connect(params, stamp);
-            break;
-        case 'disconnect':
-            disconnect(stamp);
-            break;
-        case 'is_connected':
-            isConnected();
-            break;
-        case 'clear_topics':
-            // No action needed in the worker
-            break;
-        case 'subscribe':
-            subscribe(topic, stamp);
-            break;
-        case 'unsubscribe':
-            unsubscribe(topic, stamp);
-            break;
-        case 'send':
-            send(topic, message);
-            break;
-    }
-};
-
-function connect(params, stamp) {
-    console.log('Worker: Attempting to connect');
-    const { apiMqttUrl, apiMqttClientId, region, accessKeyId, secretAccessKey, sessionToken } = params;
-
-    const configBuilder = iot.AwsIotMqttConnectionConfigBuilder.new_with_websockets();
-
-    configBuilder.with_clean_session(true);
-    configBuilder.with_client_id(apiMqttClientId);
-    configBuilder.with_endpoint(apiMqttUrl);
-    configBuilder.with_credentials(region, accessKeyId, secretAccessKey, sessionToken);
-    configBuilder.with_keep_alive_seconds(30);
-    configBuilder.with_ping_timeout_ms(3000);
-    configBuilder.with_reconnect_max_sec(5);
-    configBuilder.with_reconnect_min_sec(1);
-
-    const config = configBuilder.build();
-    const client = new mqtt.MqttClient();
-
-    connection = client.new_connection(config);
-    // increment connection id
-    currentConnectionId++;
-
-    setupConnectionListeners(currentConnectionId);
-
-    connection.connect()
-        .then(() => {
-            console.log('Worker: Connection successful');
-            self.postMessage({ type: 'connect_result', data: {success: true, connectionId: currentConnectionId, stamp} });
-        })
-        .catch((error) => {
-            console.error('Worker: Connection failed', error);
-            self.postMessage({ type: 'connect_result', data: {success: false, error: error.message, stamp} });
-        });
-}
-
-function disconnect(stamp) {
-    if (connection) {
-        const connectionId = currentConnectionId;
-        connection.disconnect()
-            .then(() => {
-                if(connectionId !== currentConnectionId) {
-                    console.log('Worker: Connection Id mismatch, ignoring disconnect result', connectionId, currentConnectionId);
-                    return;
-                }
-                self.postMessage({ type: 'disconnect_result', data: {success: true, stamp} });
-            })
-            .catch((error) => {
-                if(connectionId !== currentConnectionId) {
-                    console.log('Worker: Connection Id mismatch, ignoring disconnect result', connectionId, currentConnectionId);
-                    return;
-                }
-                self.postMessage({ type: 'disconnect_result', data: { success: false, error: error.message, stamp} });
-            });
-        connection = null;
-    } else {
-        self.postMessage({ type: 'disconnect_result', data: {success: true, stamp} });
-    }
-}
-
-function isConnected() {
-    const connected = connection && connection.currentState === 0 && connection.desiredState === 0;
-    self.postMessage({ type: 'is_connected_result', data:{connected} });
-}
-
-function subscribe(topic, stamp) {
-    if (connection && connection.currentState === 0 && connection.desiredState === 0) {
-        connection.subscribe(topic, mqtt.QoS.AtLeastOnce)
-            .then(() => {
-                self.postMessage({ type: 'subscribe_result', data: {success: true, stamp} });
-            })
-            .catch((error) => {
-                self.postMessage({ type: 'subscribe_result', data: {success: false, error: error.message, stamp} });
-            });
-    } else {
-        self.postMessage({ type: 'subscribe_result', data: {success: false, error: 'Not connected', stamp} });
-    }
-}
-
-function unsubscribe(topic, stamp) {
-    if (connection && connection.currentState === 0 && connection.desiredState === 0) {
-        connection.unsubscribe(topic)
-            .then(() => {
-                self.postMessage({ type: 'unsubscribe_result', data: {success: true, stamp} });
-            })
-            .catch((error) => {
-                self.postMessage({ type: 'unsubscribe_result', data: {success: false, error: error.message, stamp} });
-            });
-    } else {
-        self.postMessage({ type: 'unsubscribe_result', data: {success: false, error: 'Not connected', stamp} });
-    }
-}
-
-function send(topic, message) {
-    if (connection && connection.currentState === 0 && connection.desiredState === 0) {
-        connection.publish(topic, message, mqtt.QoS.AtLeastOnce, false);
-    } else {
-        console.error('Cannot send message: Not connected');
-    }
-}
-
-function setupConnectionListeners(connectionId) {
-    connection.on('connect', () => {
-        if(connectionId !== currentConnectionId) {
-            console.log('Worker: Connection Id mismatch, ignoring connect event', connectionId, currentConnectionId);
-            return;
-        }
-        self.postMessage({ type: 'connect', connectionId: connectionId});
-    });
-
-    connection.on('disconnect', () => {
-        if(connectionId !== currentConnectionId) {
-            console.log('Worker: Connection Id mismatch, ignoring disconnect event', connectionId, currentConnectionId);
-            return;
-        }
-        self.postMessage({ type: 'disconnect', connectionId: connectionId });
-    });
-
-    connection.on('error', (error) => {
-        if(connectionId !== currentConnectionId) {
-            console.log('Worker: Connection Id mismatch, ignoring error event', connectionId, currentConnectionId);
-            return;
-        }
-        self.postMessage({ type: 'error', data: error });
-    });
-
-    connection.on('interrupt', (error) => {
-        if(connectionId !== currentConnectionId) {
-            console.log('Worker: Connection Id mismatch, ignoring interrupt event', connectionId, currentConnectionId);
-            return;
-        }
-        self.postMessage({ type: 'interrupt', data: error, connectionId: connectionId });
-    });
-
-    connection.on('resume', (error) => {
-        if(connectionId !== currentConnectionId) {
-            console.log('Worker: Connection Id mismatch, ignoring resume event', connectionId, currentConnectionId);
-            return;
-        }
-        self.postMessage({ type: 'resume', data: error, connectionId: connectionId });
-    });
-
-    connection.on('message', (topic, payload) => {
-        if(connectionId !== currentConnectionId) {
-            console.log('Worker: Connection Id mismatch, ignoring message event', connectionId, currentConnectionId);
-            return;
-        }
-        self.postMessage({ type: 'message', data: { topic, payload }, connectionId: connectionId });
-    });
-
-    connection.on('connection_success', (error) => {
-        if(connectionId !== currentConnectionId) {
-            console.log('Worker: Connection Id mismatch, ignoring connection_success event', connectionId, currentConnectionId);
-            return;
-        }
-        self.postMessage({ type: 'connection_success', data: error, connectionId: connectionId });
-    });
-
-    connection.on('connection_failure', (error) => {
-        if(connectionId !== currentConnectionId) {
-            console.log('Worker: Connection Id mismatch, ignoring connection_failure event', connectionId, currentConnectionId);
-            return;
-        }
-        self.postMessage({ type: 'connection_failure', data: error, connectionId: connectionId });
-    });
-}
-
-// Add this at the end of the file
-console.log('Worker: Setup complete');