@reactoo/watchtogether-sdk-js 2.7.55 → 2.7.57

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactoo/watchtogether-sdk-js",
-  "version": "2.7.55",
+  "version": "2.7.57",
   "description": "Javascript SDK for Reactoo",
   "main": "dist/watchtogether-sdk.min.js",
   "module": "dist/watchtogether-sdk.min.js",

package/src/models/iot.js

@@ -44,37 +44,42 @@ let iot = function () {
             
         },
 
-        onConnect: () => {
+        onConnect: (data, connectionId) => {
             this.__privates.iot.log('MQTT client connected');
         },
-        onClosed: () => {
+        onClosed: (data, connectionId) => {
             this.__privates.iot.log('MQTT client closed');
             if(shouldBeConnected && !isReconnecting) {
                 this.__privates.iot.log('Connection unexpectedly closed, reconnecting...');
                 this.iot.__updateCredentials();
             }
         },
-        onError: () => {
+        onError: (data, connectionId) => {
             this.__privates.iot.log('MQTT client error');
         },
-        onDisconnect: () => {
+        onDisconnect: (data, connectionId) => {
             this.__privates.iot.log('MQTT client disconnect');
         },
-        onInterrupt: () => {
-            if(shouldBeConnected && !isReconnecting && !document.hidden && interruptCount > 10) {
+        onInterrupt: (data, connectionId) => {
+            if(shouldBeConnected && !isReconnecting && interruptCount > 10) {
                 this.__privates.iot.log('Interrupt count exceeded, reconnecting...');
                 this.iot.__updateCredentials();
             }
             interruptCount++;
             this.__privates.iot.log('MQTT client interrupt');
         },
-        onResume: () => {
+        onResume: (data, connectionId) => {
             this.__privates.iot.log('MQTT client resume');
         },
-        onConnectionSuccess: () => {
+        onConnectionSuccess: (data, connectionId) => {
             this.__privates.iot.log('MQTT client connection_success');
         },
-        onConnectionFailure: () => {
+        onConnectionFailure: (data, connectionId) => {
+            if(shouldBeConnected && !isReconnecting && interruptCount > 10) {
+                this.__privates.iot.log('Interrupt count exceeded, reconnecting...');
+                this.iot.__updateCredentials();
+            }
+            interruptCount++;
             this.__privates.iot.log('MQTT client connection_failure');
         },
         

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

@@ -2,6 +2,7 @@ import { mqtt, iot } from 'aws-iot-device-sdk-v2';
 console.log('Worker: Starting up');
 
 let connection = null;
+let currentConnectionId = null;
 
 self.onmessage = function(event) {
     const { type, params, topic, message } = event.data;
@@ -48,16 +49,18 @@ function connect(params) {
     configBuilder.with_reconnect_min_sec(1);
 
     const config = configBuilder.build();
-
     const client = new mqtt.MqttClient();
+
     connection = client.new_connection(config);
+    // generate random connection id
+    currentConnectionId = Math.floor(Math.random() * 1000000);
 
-    setupConnectionListeners();
+    setupConnectionListeners(currentConnectionId);
 
     connection.connect()
         .then(() => {
             console.log('Worker: Connection successful');
-            self.postMessage({ type: 'connect_result', data: {success: true} });
+            self.postMessage({ type: 'connect_result', data: {success: true, connectionId: currentConnectionId} });
         })
         .catch((error) => {
             console.error('Worker: Connection failed', error);
@@ -120,43 +123,69 @@ function send(topic, message) {
     }
 }
 
-function setupConnectionListeners() {
+function setupConnectionListeners(connectionId) {
     connection.on('connect', () => {
-        self.postMessage({ type: 'connect' });
+        if(connectionId !== currentConnectionId) {
+            console.log('Worker: Connection Id mismatch, ignoring connect event');
+            return;
+        }
+        self.postMessage({ type: 'connect', connectionId: connectionId});
     });
 
     connection.on('disconnect', () => {
-        self.postMessage({ type: 'disconnect' });
+        if(connectionId !== currentConnectionId) {
+            console.log('Worker: Connection Id mismatch, ignoring disconnect event');
+            return;
+        }
+        self.postMessage({ type: 'disconnect', connectionId: connectionId });
     });
 
     connection.on('error', (error) => {
+        if(connectionId !== currentConnectionId) {
+            console.log('Worker: Connection Id mismatch, ignoring error event');
+            return;
+        }
         self.postMessage({ type: 'error', data: error });
     });
 
     connection.on('interrupt', (error) => {
-        self.postMessage({ type: 'interrupt', data: error });
+        if(connectionId !== currentConnectionId) {
+            console.log('Worker: Connection Id mismatch, ignoring interrupt event');
+            return;
+        }
+        self.postMessage({ type: 'interrupt', data: error, connectionId: connectionId });
     });
 
     connection.on('resume', (error) => {
-        self.postMessage({ type: 'resume', data: error });
+        if(connectionId !== currentConnectionId) {
+            console.log('Worker: Connection Id mismatch, ignoring resume event');
+            return;
+        }
+        self.postMessage({ type: 'resume', data: error, connectionId: connectionId });
     });
 
     connection.on('message', (topic, payload) => {
-        self.postMessage({ type: 'message', data: { topic, payload } });
+        if(connectionId !== currentConnectionId) {
+            console.log('Worker: Connection Id mismatch, ignoring message event');
+            return;
+        }
+        self.postMessage({ type: 'message', data: { topic, payload }, connectionId: connectionId });
     });
 
     connection.on('connection_success', (error) => {
-        self.postMessage({ type: 'connection_success', data: error });
+        if(connectionId !== currentConnectionId) {
+            console.log('Worker: Connection Id mismatch, ignoring connection_success event');
+            return;
+        }
+        self.postMessage({ type: 'connection_success', data: error, connectionId: connectionId });
     });
 
     connection.on('connection_failure', (error) => {
-        self.postMessage({ type: 'connection_failure', data: error });
-    });
-
-    // Add a general error handler for uncaught exceptions
-    self.addEventListener('error', (error) => {
-        console.error('Worker: Uncaught error', error);
-        self.postMessage({ type: 'uncaught_error', error: error.message });
+        if(connectionId !== currentConnectionId) {
+            console.log('Worker: Connection Id mismatch, ignoring connection_failure event');
+            return;
+        }
+        self.postMessage({ type: 'connection_failure', data: error, connectionId: connectionId });
     });
 }
 

package/src/modules/wt-iot2.js

@@ -11,6 +11,7 @@ class Iot {
         this.currentCredentialsExpirationStamp = null;
         this.lastConnectParams = null;
         this.subscribedTopics = new Set();
+        this.currentConnectionId = null;
         this.initWorker();
 
         if (enableDebugFlag) {
@@ -51,6 +52,7 @@ class Iot {
                         clearTimeout(timeoutId);
                         this.off('worker:connect_result', handleConnectResult);
                         if (event.success) {
+                            this.currentConnectionId = event.connectionId;
                             resolve();
                         } else {
                             reject(new Error(event.error));
@@ -160,7 +162,7 @@ class Iot {
     }
 
     handleWorkerMessage(event) {
-        const { type, data } = event.data;
+        const { type, data, connectionId } = event.data;
         switch (type) {
             case 'message':
                 this.handleMessage(data.topic, new Uint8Array(data.payload));
@@ -172,7 +174,7 @@ class Iot {
             case 'resume':
             case 'connection_success':
             case 'connection_failure':
-                this.emit(type, data);
+                this.emit(type, data, connectionId);
                 break;
             case 'connect_result':
             case 'disconnect_result':