@reactoo/watchtogether-sdk-js 2.7.21 → 2.7.24

package/example/index.html

@@ -161,6 +161,14 @@
             Instance.room.getSessionByConstructId(constructId).toggleVideo()
         }
 
+        function checkConnection() {
+            return Instance.iot.checkConnection()
+        }
+
+        function disconnect() {
+            return Instance.iot.disconnect()
+        }
+
         function toggleAudio() {
             Instance.room.getSessionByConstructId(constructId).toggleAudio()
         }

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@reactoo/watchtogether-sdk-js",
-  "version": "2.7.21",
+  "version": "2.7.24",
   "description": "Javascript SDK for Reactoo",
   "main": "src/index.js",
   "unpkg": "dist/watchtogether-sdk.min.js",
   "scripts": {
-    "build": "webpack --env dev && webpack --env build",
-    "dev": "webpack --progress --colors --watch --env dev"
+    "build": "webpack --mode=production",
+    "dev": "webpack --mode=development --watch"
   },
   "repository": {
     "type": "git",
@@ -25,24 +25,27 @@
   },
   "homepage": "https://github.com/picitujeromanov/WR-SDK",
   "devDependencies": {
-    "@babel/core": "^7.16.5",
-    "@babel/plugin-proposal-class-properties": "^7.16.5",
-    "@babel/plugin-proposal-optional-chaining": "^7.16.5",
-    "@babel/plugin-proposal-private-property-in-object": "^7.16.5",
-    "@babel/preset-env": "^7.16.5",
-    "acorn": "^6.4.2",
-    "babel-core": "^6.26.3",
-    "babel-loader": "^8.2.3",
-    "babel-plugin-add-module-exports": "^1.0.4",
-    "babel-preset-env": "^1.7.0",
-    "babel-preset-minify": "^0.5.1",
-    "terser-webpack-plugin": "^1.4.5",
-    "webpack": "^4.46.0",
-    "webpack-cli": "^3.3.12",
-    "yargs": "^10.1.2"
+    "@babel/core": "^7.22.10",
+    "@babel/plugin-proposal-class-properties": "^7.18.6",
+    "@babel/plugin-proposal-optional-chaining": "^7.21.0",
+    "@babel/plugin-proposal-private-property-in-object": "^7.21.11",
+    "@babel/preset-env": "^7.22.10",
+    "babel-loader": "^9.1.3",
+    "buffer": "^6.0.3",
+    "clean-webpack-plugin": "^4.0.0",
+    "crypto-browserify": "^3.12.0",
+    "process": "^0.11.10",
+    "stream-browserify": "^3.0.0",
+    "terser-webpack-plugin": "^5.3.9",
+    "util": "^0.12.4",
+    "webpack": "^5.88.2",
+    "webpack-cli": "^5.1.4",
+    "worker-loader": "^3.0.8",
+    "yargs": "^17.7.2"
   },
   "dependencies": {
     "aws-iot-device-sdk": "^2.2.15",
+    "aws-iot-device-sdk-v2": "^1.21.1",
     "serialize-error": "9.1.0",
     "swagger-client": "3.18.0",
     "webrtc-adapter": "^9.0.1"

package/src/models/iot.js

@@ -1,28 +1,26 @@
 'use strict';
 
 let iot = function () {
-    let __currentTopics = [];
-    let __ = null;
+    let __currentTopics = new Set();
+    let visibilityChangeHandler = null;
+
     return {
         
         __promise: null,
-        
-        __reconnect: (err) => {
-            
-            this.__privates.iot.log('MQTT Error:', err, `Is event error: ${err instanceof Event}`);
-            
-            if(err instanceof Event && err.type === 'error')  {
-                this.__privates.iot.log('SDK MQTT Reconnection attempt');
-                clearTimeout(__);
-                __ = setTimeout(() => {
-                    this.iot.iotLogin(true, true).catch((e) => this.__privates.iot.log('MQTT Connection Error:', e))
-                }, 1000);
-            }
-        },
-        
+
         __updateCredentials: () => {
-            this.iot.getCredentials()
-                .then(response => this.__privates.iot.updateWebSocketCredentials(response.data.credentials.accessKeyId, response.data.credentials.secretAccessKey, response.data.credentials.sessionToken, response.data.credentials.expiration));
+            return this.iot.getCredentials()
+                .then(response => this.__privates.iot.updateWebSocketCredentials(
+                    response.data.credentials.accessKeyId, 
+                    response.data.credentials.secretAccessKey, 
+                    response.data.credentials.sessionToken, 
+                    response.data.credentials.expiration
+                ))
+                .catch(error => {
+                    this.__privates.iot.log('Failed to update credentials:', error);
+                    // Let the error propagate to be handled by the Iot class
+                    throw error;
+                });
         },
         
         getCredentials: () => {
@@ -31,48 +29,87 @@ let iot = function () {
             
         },
         
-        iotLogin: (subscribeToSuggestedTopics = true, forceDisconnect = false) => {
-            this.iot.$off('error', this.iot.__reconnect, this);
+        iotLogin: (subscribeToSuggestedTopics = true) => {
             this.iot.__promise = new Promise((resolve, reject) => {
                 this.iot.getCredentials()
                     .then(response => {
                         return Promise.all([
                             response.data.suggestedTopics,
-                            this.__privates.iot.connect(response.data.endpoint, response.data.clientId, response.data.region, response.data.credentials.accessKeyId, response.data.credentials.secretAccessKey, response.data.credentials.sessionToken, response.data.credentials.expiration, forceDisconnect)
+                            this.__privates.iot.connect(
+                                response.data.endpoint,
+                                response.data.clientId,
+                                response.data.region,
+                                response.data.credentials.accessKeyId,
+                                response.data.credentials.secretAccessKey,
+                                response.data.credentials.sessionToken,
+                                response.data.credentials.expiration,
+                            )
                         ])
                     })
                     .then(resolve)
                     .catch(reject)
             });
             
-            let __currentTopicsCopy = [...__currentTopics];
-            __currentTopics.length = 0;
-            
+            let __currentTopicsCopy = new Set(__currentTopics); // Keep this line
+            __currentTopics.clear();
+
+            this.iot.$on('connect', () => {
+                this.__privates.iot.log('MQTT client connected');
+                this.iot.setupVisibilityChangeListener();
+            });
+
+            this.iot.$on('closed', () => {
+                this.__privates.iot.log('MQTT client closed');
+                this.iot.disableVisibilityChangeListener();
+            });
+
+            this.iot.$on('error', () => {
+                this.__privates.iot.log('MQTT client error');
+            });
+
+            this.iot.$on('disconnect', () => {
+                this.__privates.iot.log('MQTT client disconnect');
+            });
+
+            this.iot.$on('interrupt', () => {
+                this.__privates.iot.log('MQTT client interrupt');
+            });
+
+            this.iot.$on('resume', () => {
+                this.__privates.iot.log('MQTT client resume');
+            });
+
+            this.iot.$on('connection_success', () => {
+                this.__privates.iot.log('MQTT client connection_success');
+            });
+
+            this.iot.$on('connection_failure', () => {
+                this.__privates.iot.log('MQTT client connection_failure');
+            });
+
             this.iot.__promise
                 .then(([suggestedTopic, instance]) => {
                     if(!subscribeToSuggestedTopics) {
                         return  Promise.resolve(instance)
                     }
-                    let topics = [...suggestedTopic, ...__currentTopicsCopy];
-                    topics = topics.filter((c, index) => {
-                        return topics.indexOf(c) === index;
-                    });
-                    return Promise.all(topics.map(topic => this.iot.subscribe(topic))).then(() => instance)
+                    let topics = new Set([...suggestedTopic, ...__currentTopicsCopy]); // Filter out any undefined or null topics
+                    return Promise.all(Array.from(topics).map(topic => this.iot.subscribe(topic))).then(() => instance)
                 })
                 .then((instance) => {
-                    this.iot.$on('error', this.iot.__reconnect, this);
                     this.iot.$on('updateCredentials', this.iot.__updateCredentials, this);
                     return instance;
+                })
+                .catch((error) => {
+                    this.__privates.iot.log('MQTT Login Error:', error);
+                    throw error;
                 });
-            
+
             return this.iot.__promise;
         },
         
         iotLogout: (keepCurrentTopics = false) => {
-            this.iot.$off('error', this.iot.__reconnect, this);
-            this.iot.$off('updateCredentials', this.iot.__updateCredentials, this);
             if(!keepCurrentTopics) {
-                __currentTopics.length = 0;
+                __currentTopics.clear();
             }
             return this.__privates.iot.disconnect()
                 .then(() => {
@@ -86,16 +123,15 @@ let iot = function () {
         },
         
         subscribe: (topic) => {
-            if(__currentTopics.indexOf(topic) === -1) {
-                __currentTopics.push(topic);
+            if(!__currentTopics.has(topic)) {
+                __currentTopics.add(topic);
                 if(!this.iot.__promise) return Promise.resolve('not_connected');
                 return this.iot.__promise.then(() => this.__privates.iot.subscribe(topic));
             }
         },
         
         unsubscribe: (topic) => {
-            let index = __currentTopics.indexOf(topic);
-            (index > -1) && __currentTopics.splice(index, 1);
+            __currentTopics.delete(topic);
             if(!this.iot.__promise) return Promise.resolve('not_connected');
             return this.iot.__promise.then(() => this.__privates.iot.unsubscribe(topic));
         },
@@ -118,6 +154,34 @@ let iot = function () {
         
         $clear: () => {
             return this.__privates.iot.clear();
+        },
+        
+        checkConnection: () => {
+            return this.__privates.iot.checkConnection()
+                .catch(error => {
+                    this.__privates.iot.log('Connection check failed:', error);
+                    return this.iot.__updateCredentials();
+                });
+        },
+        
+        setupVisibilityChangeListener: () => {
+            if (visibilityChangeHandler) {
+                // Listener is already set up
+                return;
+            }
+            visibilityChangeHandler = () => {
+                if (!document.hidden) {
+                    this.iot.checkConnection();
+                }
+            };
+            document.addEventListener('visibilitychange', visibilityChangeHandler);
+        },
+
+        disableVisibilityChangeListener: () => {
+            if (visibilityChangeHandler) {
+                document.removeEventListener('visibilitychange', visibilityChangeHandler);
+                visibilityChangeHandler = null;
+            }
         }
     };
 };

package/src/models/room.js

@@ -147,14 +147,15 @@ let room = function () {
 					}
 				}))
 		},
-		
-		getInviteUrl: (roomId, domain, url) => {
+
+		getInviteUrl: ({roomId, domain, url, autologin}) => {
 			return this.__privates.auth.__client
 				.then(client => client.apis.wt.invite({}, {
 					requestBody: {
 						roomId,
 						domain: domain || location.host,
-						url: url || location.href
+						url: url || location.href,
+						...(autologin && {autologin}),
 					}
 				}))
 		},
@@ -210,11 +211,11 @@ let room = function () {
 
 		},
 
-		roomRecorder: ({roomId, operation = 'get', config, outputs, destinationIds, destinations, screenWidth, screenHeight, payload} = {}) => {
+		roomRecorder: ({roomId, operation = 'get', config, outputs, destinationIds, destinations, screenWidth, screenHeight, payload, requestId} = {}) => {
 			return this.__privates.auth.__client
 				.then(client => client.apis.wt.recordRoom({}, {
 					requestBody: {
-						roomId, operation, config, outputs, destinationIds, destinations, screenWidth, screenHeight, payload
+						roomId, operation, config, outputs, destinationIds, destinations, screenWidth, screenHeight, payload, requestId
 					}
 				}))
 		},

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

@@ -0,0 +1,84 @@
+import { mqtt, iot } from 'aws-iot-device-sdk-v2';
+
+let connection = null;
+
+self.onmessage = function(e) {
+	const { action, payload } = e.data;
+
+	switch (action) {
+		case 'connect':
+			connect(payload);
+			break;
+		case 'disconnect':
+			disconnect();
+			break;
+		case 'subscribe':
+			subscribe(payload.topic);
+			break;
+		case 'unsubscribe':
+			unsubscribe(payload.topic);
+			break;
+		case 'send':
+			send(payload.topic, payload.message);
+			break;
+	}
+};
+
+function connect({ apiMqttUrl, apiMqttClientId, region, accessKeyId, secretAccessKey, sessionToken }) {
+	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);
+
+	const config = configBuilder.build();
+
+	const client = new mqtt.MqttClient();
+	connection = client.new_connection(config);
+
+	connection.on('connect', () => {
+		self.postMessage({ event: 'connect' });
+	});
+
+	connection.on('disconnect', () => {
+		self.postMessage({ event: 'disconnect' });
+	});
+
+	connection.on('error', (error) => {
+		self.postMessage({ event: 'error', error: error.toString() });
+	});
+
+	connection.on('message', (topic, payload) => {
+		self.postMessage({ event: 'message', topic, payload: new Uint8Array(payload) });
+	});
+
+	connection.connect();
+}
+
+function disconnect() {
+	if (connection) {
+		connection.disconnect();
+		connection = null;
+	}
+}
+
+function subscribe(topic) {
+	if (connection) {
+		connection.subscribe(topic, mqtt.QoS.AtLeastOnce);
+	}
+}
+
+function unsubscribe(topic) {
+	if (connection) {
+		connection.unsubscribe(topic);
+	}
+}
+
+function send(topic, message) {
+	if (connection) {
+		connection.publish(topic, message, mqtt.QoS.AtLeastOnce);
+	}
+}