@reactoo/watchtogether-sdk-js 2.7.96 → 2.7.97

package/example/index.html

@@ -529,14 +529,10 @@
         }
 
         window.asset = function () {
-            const test = Instance.asset.getAssetList({  ids: ['6304b890-321a-494b-b0e6-b0cee48026cd'], instanceType: 'reactooBackup', type:'ids'})
+            Instance.asset.getAssetList({  ids: ['6304b890-321a-494b-b0e6-b0cee48026cd'], instanceType: 'reactooBackup', type:'ids'})
                     .then(r => {
                         console.log(r);
-                        return r;
                     })
-            test.then(r => {
-                console.log(r);
-            })
         }
 
     </script>

package/package.json

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

package/src/models/asset.js

@@ -66,8 +66,7 @@ let asset =  function() {
 						if (onProgress && xhr.upload) {
 							xhr.upload.onprogress = (event) => {
 								if (event.lengthComputable) {
-									const percentComplete = (event.loaded / event.total) * 100;
-									onProgress(percentComplete, event.loaded, event.total);
+									onProgress(event.loaded, event.total);
 								}
 							};
 						}
@@ -106,6 +105,11 @@ let asset =  function() {
 	    downloadAsset: (url, options = {}) => {
 		    return this.__privates.auth.__client
 			    .then(client => client.http({url, method: 'GET', ...options}))
+	    },
+
+		createStreamAsset: (id, streamType, title, regionalPreference, ingestType, source, profile) => {
+			return this.__privates.auth.__client
+				.then(client => client.apis.asset.publishAsset({id}, {requestBody: {assetType: 'stream', streamType, title, regionalPreference, ingestType, source, profile}}));
 	    }
     }
 };

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

@@ -1,7 +1,7 @@
 import { mqtt5, iot } from 'aws-iot-device-sdk-v2';
 console.log('Worker: Starting up');
 
-let connection = null;
+let client = null;
 let currentConnectionId = 1;
 
 self.onmessage = function(event) {
@@ -37,29 +37,29 @@ 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();
+    const configBuilder = iot.AwsIotMqtt5ClientConfigBuilder.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);
+    configBuilder.with_connect_properties({
+        keepAliveIntervalSeconds: 30,
+        sessionExpiryIntervalSeconds: 300
+    });
 
     const config = configBuilder.build();
-    const client = new mqtt5.MqttClient(); // Use MQTT 5.0 client
 
-    connection = client.new_connection(config);
+    // MQTT5 uses a single client instance
+    client = new mqtt5.Mqtt5Client(config);
     currentConnectionId++;
 
     setupConnectionListeners(currentConnectionId);
 
-    connection.connect()
+    client.start()
         .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) => {
@@ -69,38 +69,42 @@ function connect(params, stamp) {
 }
 
 function disconnect(stamp) {
-    if (connection) {
+    if (client) {
         const connectionId = currentConnectionId;
-        connection.stop(); // Stop the client before disconnecting
-        connection.disconnect()
+        client.stop()
             .then(() => {
-                if (connectionId !== currentConnectionId) {
+                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) {
+                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;
+        client = null;
     } else {
         self.postMessage({ type: 'disconnect_result', data: {success: true, stamp} });
     }
 }
 
 function isConnected() {
-    const connected = connection && connection.currentState === 0 && connection.desiredState === 0;
+    const connected = client && client.getIsConnected();
     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)
+    if (client && client.getIsConnected()) {
+        const subscription = {
+            qos: mqtt5.QoS.AtLeastOnce,
+            topicFilter: topic
+        };
+
+        client.subscribe(subscription)
             .then(() => {
                 self.postMessage({ type: 'subscribe_result', data: {success: true, stamp} });
             })
@@ -113,8 +117,8 @@ function subscribe(topic, stamp) {
 }
 
 function unsubscribe(topic, stamp) {
-    if (connection && connection.currentState === 0 && connection.desiredState === 0) {
-        connection.unsubscribe(topic)
+    if (client && client.getIsConnected()) {
+        client.unsubscribe({ topicFilter: topic })
             .then(() => {
                 self.postMessage({ type: 'unsubscribe_result', data: {success: true, stamp} });
             })
@@ -127,65 +131,80 @@ function unsubscribe(topic, 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
-            }
-        });
+    if (client && client.getIsConnected()) {
+        const publish = {
+            qos: mqtt5.QoS.AtLeastOnce,
+            topicName: topic,
+            payload: message,
+            retain: false
+        };
+        client.publish(publish);
     } 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);
+    client.on('connectionSuccess', (eventData) => {
+        if(connectionId !== currentConnectionId) {
+            console.log('Worker: Connection Id mismatch, ignoring connectionSuccess event', connectionId, currentConnectionId);
             return;
         }
-        self.postMessage({ type: 'connect', connectionId: connectionId, settings: event.settings });
+        self.postMessage({
+            type: 'connection_success',
+            data: {
+                sessionPresent: eventData.sessionPresent,
+                negotiatedSettings: eventData.negotiatedSettings
+            },
+            connectionId: connectionId
+        });
     });
 
-    connection.on(mqtt5.Mqtt5Client.CONNECTION_FAILURE, (event) => {
-        if (connectionId !== currentConnectionId) {
-            console.log('Worker: Connection Id mismatch, ignoring connection failure event', connectionId, currentConnectionId);
+    client.on('connectionFailure', (error) => {
+        if(connectionId !== currentConnectionId) {
+            console.log('Worker: Connection Id mismatch, ignoring connectionFailure event', connectionId, currentConnectionId);
             return;
         }
-        self.postMessage({ type: 'connection_failure', error: event.error });
+        self.postMessage({ type: 'connection_failure', data: error, connectionId: connectionId });
     });
 
-    connection.on(mqtt5.Mqtt5Client.DISCONNECTION, (event) => {
-        if (connectionId !== currentConnectionId) {
-            console.log('Worker: Connection Id mismatch, ignoring disconnection event', connectionId, currentConnectionId);
+    client.on('disconnection', (eventData) => {
+        if(connectionId !== currentConnectionId) {
+            console.log('Worker: Connection Id mismatch, ignoring disconnect event', connectionId, currentConnectionId);
             return;
         }
-        self.postMessage({ type: 'disconnect', error: event.error });
+        self.postMessage({
+            type: 'disconnect',
+            data: { reason: eventData.errorCode },
+            connectionId: connectionId
+        });
     });
 
-    connection.on(mqtt5.Mqtt5Client.MESSAGE_RECEIVED, (event) => {
-        if (connectionId !== currentConnectionId) {
+    client.on('messageReceived', (eventData) => {
+        if(connectionId !== currentConnectionId) {
             console.log('Worker: Connection Id mismatch, ignoring message event', connectionId, currentConnectionId);
             return;
         }
-        self.postMessage({ type: 'message', data: event.message });
+        self.postMessage({
+            type: 'message',
+            data: {
+                topic: eventData.message.topicName,
+                payload: eventData.message.payload,
+                qos: eventData.message.qos,
+                retain: eventData.message.retain,
+                properties: eventData.message.properties
+            },
+            connectionId: connectionId
+        });
     });
 
-    // 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;
-    }
+    client.on('error', (error) => {
+        if(connectionId !== currentConnectionId) {
+            console.log('Worker: Connection Id mismatch, ignoring error event', connectionId, currentConnectionId);
+            return;
+        }
+        self.postMessage({ type: 'error', data: error });
+    });
 }
 
-// Add this at the end of the file
 console.log('Worker: Setup complete');