@reactoo/watchtogether-sdk-js 2.7.74 → 2.7.76

package/example/index.html

@@ -29,7 +29,7 @@
 
     <script type="module">
         import WatchTogetherSDK from '../dist/watchtogether-sdk.js';
-        
+
         //https://studio.reactoo.com/room/edf441b3-7415-49c4-9557-273cb93bc746/LJj4W2Cz-nG3U-lb0R-TAaY-o7Thmb8xHSbE
 
         let roomId = "d841ad58-e5a6-4cb8-aeb8-c92499a213a4"; // It will create room automatically if not set
@@ -521,4 +521,4 @@
     </script>
 
 </body>
-</html>
+</html>

package/package.json

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

package/src/models/iot.js

@@ -1,11 +1,12 @@
 'use strict';
 
 let iot = function () {
+
     let __currentTopics = new Set();
     let visibilityChangeHandler = null;
     let keepAliveIntervalId = null;
     let shouldBeConnected = false;
-    let isReconnecting = false;
+    let isConnecting = false;
     let interruptCount = 0;
     let subscriptionFailureCount = 0;
 
@@ -20,12 +21,18 @@ let iot = function () {
         },
 
         __updateCredentials: () => {
+
+            if(isConnecting) {
+                this.__privates.iot.log('Already reconnecting, ignoring update credentials');
+                return Promise.resolve(this.iot.__promise);
+            }
+
             this.__privates.iot.log('Updating Credentials...');
             interruptCount = 0;
             subscriptionFailureCount = 0;
-            isReconnecting = true;
-            this.iot.$emit('isReconnecting', isReconnecting, true);
-            return this.iot.getCredentials()
+            isConnecting = true;
+
+            this.iot.__promise = this.iot.getCredentials()
                 .then(response => this.__privates.iot.updateWebSocketCredentials(
                     response.data.credentials.accessKeyId,
                     response.data.credentials.secretAccessKey,
@@ -33,23 +40,22 @@ let iot = function () {
                     response.data.credentials.expiration
                 ))
                 .then((r) => {
-                    isReconnecting = false;
-                    this.iot.$emit('isReconnecting', isReconnecting, false);
+                    isConnecting = false;
                     this.__privates.iot.log('Credentials updated');
                     return Promise.resolve(r);
                 })
                 .catch(error => {
-                    isReconnecting = false;
-                    this.iot.$emit('isReconnecting', isReconnecting, true);
+                    isConnecting = false;
                     this.__privates.iot.log('Failed to update credentials:', error);
                     return Promise.reject(error);
                 });
+
+            return this.iot.__promise;
         },
 
         getCredentials: () => {
             return this.__privates.auth.__client
                 .then(client => client.apis.auth.iotSignIn({}, {requestBody: {suggestedTopics:true, domain: location.hostname}}))
-
         },
 
         onConnect: (data, connectionId) => {
@@ -57,7 +63,7 @@ let iot = function () {
         },
         onClosed: (data, connectionId) => {
             this.__privates.iot.log('MQTT client closed');
-            if(shouldBeConnected && !isReconnecting) {
+            if(shouldBeConnected && !isConnecting) {
                 this.__privates.iot.log('Connection unexpectedly closed, reconnecting...');
                 this.iot.__createNewWorker();
                 this.iot.__updateCredentials();
@@ -70,7 +76,7 @@ let iot = function () {
             this.__privates.iot.log('MQTT client disconnect');
         },
         onInterrupt: (data, connectionId) => {
-            if(shouldBeConnected && !isReconnecting && interruptCount > 10) {
+            if(shouldBeConnected && !isConnecting && interruptCount > 10) {
                 this.__privates.iot.log('Interrupt count exceeded, reconnecting...');
                 this.iot.__createNewWorker();
                 this.iot.__updateCredentials();
@@ -85,7 +91,7 @@ let iot = function () {
             this.__privates.iot.log('MQTT client connection_success');
         },
         onConnectionFailure: (data, connectionId) => {
-            if(shouldBeConnected && !isReconnecting && interruptCount > 10) {
+            if(shouldBeConnected && !isConnecting && interruptCount > 10) {
                 this.__privates.iot.log('Interrupt count exceeded, reconnecting...');
                 this.iot.__createNewWorker();
                 this.iot.__updateCredentials();
@@ -96,10 +102,17 @@ let iot = function () {
 
         iotLogin: (subscribeToSuggestedTopics = true) => {
 
+            if(isConnecting) {
+                this.__privates.iot.log('Already reconnecting, ignoring login');
+                return this.iot.__promise;
+            }
+
             interruptCount = 0;
             subscriptionFailureCount = 0;
             shouldBeConnected = true;
-            this.__privates.iot.initWorker();
+            isConnecting = true;
+
+            this.iot.__createNewWorker();
             this.iot.__promise = new Promise((resolve, reject) => {
                 this.iot.getCredentials()
                     .then(response => {
@@ -116,8 +129,14 @@ let iot = function () {
                             )
                         ])
                     })
-                    .then(resolve)
-                    .catch(reject)
+                    .then((r) => {
+                        isConnecting = false;
+                        resolve(r);
+                    })
+                    .catch((e) => {
+                        isConnecting = false;
+                        reject(e);
+                    })
             });
 
             __currentTopics.clear();
@@ -200,14 +219,14 @@ let iot = function () {
                         __currentTopics.delete(topic);
 
                         if(error?.cause === -1) {
-                            return Promise.reject('invalid_topic');
+                            return Promise.reject('invalid_topic or worker not initialized');
                         }
 
-                        if(!shouldBeConnected || isReconnecting) {
+                        if(!shouldBeConnected || isConnecting) {
                             return Promise.reject('subscription_failed');
                         }
 
-                        if(shouldBeConnected && !isReconnecting && subscriptionFailureCount > 5) {
+                        if(shouldBeConnected && !isConnecting && subscriptionFailureCount > 5) {
                             this.__privates.iot.log('Subscription failure exceeded, reconnecting...');
                             this.iot.__createNewWorker();
                             this.iot.__updateCredentials();
@@ -268,7 +287,7 @@ let iot = function () {
                         return Promise.resolve();
                     }
 
-                    if(isReconnecting) {
+                    if(isConnecting) {
                         this.__privates.iot.log('Connection check failed, but we are already reconnecting...');
                         return Promise.resolve();
                     }
@@ -293,7 +312,7 @@ let iot = function () {
                             return;
                         }
 
-                        if(shouldBeConnected && !isReconnecting) {
+                        if(shouldBeConnected && !isConnecting) {
                             this.__privates.iot.log('Keepalive failed:', error);
                             this.iot.__createNewWorker();
                             this.iot.__updateCredentials();

package/src/models/user.js

@@ -36,12 +36,12 @@ let user = function () {
                 .then(response => response.data.key)
                 ;
         },
-        uploadVideo: (roomId, files, privateAttributes = {}, customPrice) => {
+        uploadVideo: (roomId, files, privateAttributes = {}, customAttributes = {}, customPrice) => {
             let id = generateUUID();
             return this.__privates.auth.__client
                 .then(client => Promise.all([client, client.apis.video.initiateVideoUpload({id, segmentCount:  files.length || 0})]))
                 .then(([client, response]) => Promise.all([client, response.data.signedUrlSegments.reduce((acc, url, index) => acc.then(() => client.http({url, method: response.data.httpMethod, headers: {"Content-Type":files[index].type}, body:files[index]})), Promise.resolve())]))
-                .then(([client]) => client.apis.video.publishVideo({_id:id, roomId, customPrice}, {requestBody:{_id:id, roomId, privateAttributes, customPrice}}))
+                .then(([client]) => client.apis.video.publishVideo({_id:id, roomId, customPrice}, {requestBody:{_id:id, roomId, privateAttributes, customAttributes, customPrice}}))
         },
 
         publishVideo: (roomId, id, privateAttributes = {}, customPrice) => {
@@ -93,10 +93,11 @@ let user = function () {
                                     items: [...chainResponse.data.items, ...response.data.items],
                                     size: chainResponse.data.size + response.data.size,
                                     startKey: null,
+                                    users: [...chainResponse.data.users, ...(response.data.users ?? [])],
                                 },
                             } : response);
                     });
-                }, Promise.resolve({data: {items: [], size: 0, startKey: null}}));
+                }, Promise.resolve({data: {items: [], size: 0, startKey: null, users: []}}));
         },
         
         deleteVideo: (id) => {

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

@@ -0,0 +1,191 @@
+import { mqtt5, 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 mqtt5.MqttClient(); // Use MQTT 5.0 client
+
+    connection = client.new_connection(config);
+    currentConnectionId++;
+
+    setupConnectionListeners(currentConnectionId);
+
+    connection.connect()
+        .then(() => {
+            console.log('Worker: Connection successful');
+            connection.start(); // Start the client to maintain connectivity
+            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.stop(); // Stop the client before disconnecting
+        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, mqtt5.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, mqtt5.QoS.AtLeastOnce, false, {
+            // Example of adding user properties
+            userProperties: {
+                // Add your properties here
+            }
+        });
+    } else {
+        console.error('Cannot send message: Not connected');
+    }
+}
+
+function setupConnectionListeners(connectionId) {
+    connection.on(mqtt5.Mqtt5Client.ATTEMPTING_CONNECT, () => {
+        console.log('Worker: Attempting to connect');
+    });
+
+    connection.on(mqtt5.Mqtt5Client.CONNECTION_SUCCESS, (event) => {
+        if (connectionId !== currentConnectionId) {
+            console.log('Worker: Connection Id mismatch, ignoring connection success event', connectionId, currentConnectionId);
+            return;
+        }
+        self.postMessage({ type: 'connect', connectionId: connectionId, settings: event.settings });
+    });
+
+    connection.on(mqtt5.Mqtt5Client.CONNECTION_FAILURE, (event) => {
+        if (connectionId !== currentConnectionId) {
+            console.log('Worker: Connection Id mismatch, ignoring connection failure event', connectionId, currentConnectionId);
+            return;
+        }
+        self.postMessage({ type: 'connection_failure', error: event.error });
+    });
+
+    connection.on(mqtt5.Mqtt5Client.DISCONNECTION, (event) => {
+        if (connectionId !== currentConnectionId) {
+            console.log('Worker: Connection Id mismatch, ignoring disconnection event', connectionId, currentConnectionId);
+            return;
+        }
+        self.postMessage({ type: 'disconnect', error: event.error });
+    });
+
+    connection.on(mqtt5.Mqtt5Client.MESSAGE_RECEIVED, (event) => {
+        if (connectionId !== currentConnectionId) {
+            console.log('Worker: Connection Id mismatch, ignoring message event', connectionId, currentConnectionId);
+            return;
+        }
+        self.postMessage({ type: 'message', data: event.message });
+    });
+
+    // Additional events can be added as needed
+}
+
+// Ensure to call close when the worker is terminated or no longer needed
+function cleanup() {
+    if (connection) {
+        connection.close(); // Clean up resources
+        connection = null;
+    }
+}
+
+// Add this at the end of the file
+console.log('Worker: Setup complete');

package/src/modules/wt-iot2.js

@@ -12,6 +12,7 @@ class Iot {
         this.lastConnectParams = null;
         this.subscribedTopics = new Set();
         this.abortController = null;
+        this.worker = null;
 
         if (enableDebugFlag) {
             this.enableDebug();
@@ -103,12 +104,10 @@ class Iot {
             const stamp = new Date().getTime();
 
             const handleDisconnectResult = (event) => {
-
                 if(event.stamp !== stamp) {
                     this.log('disconnect event stamp mismatch', event.stamp, stamp);
                     return;
                 }
-
                 clearTimeout(timeoutId);
                 this.off('worker:disconnect_result', handleDisconnectResult);
                 if (event.success) {
@@ -155,6 +154,10 @@ class Iot {
         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}));
@@ -171,7 +174,7 @@ class Iot {
 
                     this.off('worker:subscribe_result', handleSubscribeResult);
                     if (event.success) {
-                        this.subscribedTopics.add(topic);
+
                         resolve();
                     } else {
                         reject(new Error(event.error));
@@ -190,7 +193,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}));
@@ -209,7 +212,6 @@ class Iot {
 
                     this.off('worker:unsubscribe_result', handleUnsubscribeResult);
                     if (event.success) {
-                        this.subscribedTopics.delete(topic);
                         resolve();
                     } else {
                         reject(new Error(event.error));
@@ -391,19 +393,15 @@ class Iot {
                 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);
-
             if (!suitableTopic) {
                 reject(new Error('No suitable topic found for connection check', {cause: -1}));
                 return;
             }
-
             const testMessage = {
                 type: 'keep_alive',
                 timestamp: Date.now()
             };
-
             const timeoutId = setTimeout(() => {
                 this.off('message', checkMessageHandler);
                 this.abortController.signal.removeEventListener('abort', abort);