@reactoo/watchtogether-sdk-js 2.7.21 → 2.7.24

package/src/modules/wt-iot.js

@@ -1,189 +1,172 @@
-
-import {device} from 'aws-iot-device-sdk';
 import emitter from './wt-emitter';
-import {decodeJanusDisplay} from "./wt-utils";
+import { decodeJanusDisplay } from "./wt-utils";
+import { mqtt, iot } from 'aws-iot-device-sdk-v2';
 
 class Iot {
-    
     constructor(enableDebugFlag) {
         Object.assign(this, emitter());
-        this.device = null;
         this.decoder = new TextDecoder('utf-8');
         this.connectionActive = false;
         this.log = Iot.noop;
-        this.debugFlag = enableDebugFlag;
+        // Remove: this.debugFlag = enableDebugFlag;
         this.credentialsExpirationCheckIntervalId = null;
-        this.currentCredentialsExpirationStamp = null
-        if(enableDebugFlag) {
+        this.currentCredentialsExpirationStamp = null;
+        this.lastConnectParams = null;
+        this.connection = null;
+        this.subscribedTopics = new Set();
+
+        if (enableDebugFlag) {
             this.enableDebug();
         }
     }
-    
+
     static noop() {}
-    
+
     enableDebug() {
         this.log = console.log.bind(console);
     }
-    
-    startCredentialsExpirationCheck(expiration) {
-        this.stopCredentialsExpirationCheck();
-        this.currentCredentialsExpirationStamp = new Date(expiration).getTime();
-        this.credentialsExpirationCheckIntervalId = setInterval(() => {
-            const curentTimeStamp = new Date().getTime();
-            if(this.currentCredentialsExpirationStamp - curentTimeStamp <= 300000) {
-                this.emit('updateCredentials');
-            }
-        }, 5000);
-    }
-    
-    stopCredentialsExpirationCheck() {
-        clearInterval(this.credentialsExpirationCheckIntervalId);
-        this.credentialsExpirationCheckIntervalId = null;
-    }
-    
-    updateWebSocketCredentials(accessKeyId, secretAccessKey, sessionToken, expiration) {
-        this.log('iot updateWebSocketCredentials');
-        if(this.device) {
-            this.device.updateWebSocketCredentials(accessKeyId, secretAccessKey, sessionToken);
-            this.startCredentialsExpirationCheck(expiration);
-        }
-    }
-    
-    connect(apiMqttUrl, apiMqttClientId, region, accessKeyId, secretAccessKey, sessionToken, expiration, forceDisconnect = false) {
-        this.log('iot connect');
-        return this.disconnect(forceDisconnect).then(() => {
-            return new Promise((resolve, reject) => {
-                this.device = device({
-                    protocol:'wss',
-                    clientId: apiMqttClientId,
-                    region,
-                    host: apiMqttUrl,
-                    accessKeyId: accessKeyId,
-                    secretKey: secretAccessKey,
-                    sessionToken: sessionToken,
-                    keepalive: 30,
-                    maximumReconnectTimeMs: 8000,
-                    enableMetrics: false,
-                    debug: this.debugFlag,
-                    autoResubscribe: true
+
+    connect(apiMqttUrl, apiMqttClientId, region, accessKeyId, secretAccessKey, sessionToken, expiration) {
+        this.log('iot connect called, we disconnect first just to be sure');
+        return this.disconnect()
+            .finally(() => {
+                this.log('iot connect');
+                this.lastConnectParams = { apiMqttUrl, apiMqttClientId, region, accessKeyId, secretAccessKey, sessionToken, expiration };
+
+                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();
+                this.connection = client.new_connection(config);
+
+                this.connection.on('connect', () => {
+                    this.connectionActive = true;
+                    this.emit('connect');
                 });
-                
-                this.startCredentialsExpirationCheck(expiration);
-                
-                let __s = () => {
-                    this.device?.off('connect', __s);
-                    this.device?.off('error', __e);
-                    resolve(this.device)
-                };
-                
-                let __e = (e) => {
-                    this.device?.off('connect', __s);
-                    this.device?.off('error', __e);
-                    reject(e);
-                };
-                
-                this.device.once('connect', __s);
-                this.device.once('error', __e);
-                
-                this.device.on('message', this.__messageCb.bind(this));
-                this.device.on('connect', this.__connectCb.bind(this));
-                this.device.on('reconnect', this.__reconnectCb.bind(this));
-                this.device.on('error', this.__failureCb.bind(this));
-                this.device.on('close', this.__closeCb.bind(this));
-                this.device.on('offline', this.__offlineCb.bind(this));
-                
-            })
-        })
-        
+
+                this.connection.on('disconnect', () => {
+                    this.connectionActive = false;
+                    this.emit('disconnect');
+                });
+
+                this.connection.on('error', (error) => {
+                    this.connectionActive = false;
+                    this.emit('error', error);
+                });
+
+                this.connection.on('interrupt', (error) => {
+                    this.connectionActive = false;
+                    this.emit('interrupt', error);
+                });
+
+                this.connection.on('resume', (error) => {
+                    this.connectionActive = true;
+                    this.emit('resume', error);
+                });
+
+                this.connection.on('message', (topic, payload) => {
+                    this.handleMessage(topic, new Uint8Array(payload));
+                });
+
+                this.connection.on('connection_success', (error) => {
+                    this.connectionActive = true;
+                    this.emit('connection_success', error);
+                });
+
+                this.connection.on('connection_failure', (error) => {
+                    this.connectionActive = false;
+                    this.emit('connection_failure', error);
+                });
+
+                this.connection.on('closed', (error) => {
+                    this.connectionActive = false;
+                    this.emit('closed', error);
+                });
+
+                return this.connection.connect()
+                    .then(() => {
+                        this.startCredentialsExpirationCheck(expiration);
+                    });
+
+            });
     }
-    
-    disconnect(force = false) {
-        
+
+
+    disconnect() {
+        this.log('iot disconnect');
         this.stopCredentialsExpirationCheck();
-        
-        return new Promise((resolve, reject) => {
-            if(!this.device) {
-                resolve();
-                return;
-            }
-            let __i = null;
-            let __c = () => {
-                clearTimeout(__i);
-                this.device = null;
-                resolve();
-            };
-            __i = setTimeout(__c, 4000);
-            this.device.off('message', this.__messageCb.bind(this));
-            this.device.off('connect', this.__connectCb.bind(this));
-            this.device.off('reconnect', this.__reconnectCb.bind(this));
-            this.device.off('error', this.__failureCb.bind(this));
-            this.device.off('close', this.__closeCb.bind(this));
-            this.device.off('offline', this.__offlineCb.bind(this));
-            this.device.end(force, __c);
-        });
+        if (this.connection) {
+            this.connectionActive = false;
+            return this.connection.disconnect();
+        } else return Promise.resolve();
     }
-    
+
     isConnected() {
         return this.connectionActive;
     }
-    
+
     subscribe(topic) {
         this.log('iot subscribe', topic);
-        return this.device && this.device.subscribe(topic);
+        if (this.connection && typeof topic === 'string' && topic.trim() !== '') {
+            this.connection.subscribe(topic, mqtt.QoS.AtLeastOnce);
+            this.subscribedTopics.add(topic);
+        } else {
+            this.log('Invalid topic or not connected:', topic);
+        }
     }
-    
+
     unsubscribe(topic) {
         this.log('iot unsubscribe', topic);
-        return this.device && this.device.unsubscribe(topic);
+        if (this.connection && typeof topic === 'string' && topic.trim() !== '') {
+            this.connection.unsubscribe(topic);
+            this.subscribedTopics.delete(topic);
+        } else {
+            this.log('Invalid topic or not connected:', topic);
+        }
     }
-    
+
     send(topic, message) {
         this.log('iot send', topic, message);
         let msg = typeof message === 'object' ? JSON.stringify(message) : message;
-        return this.device && this.device.publish(topic, msg);
-    }
-    
-    __reconnectCb() {
-        this.log('iot reconnect');
-        this.emit('reconnect');
-    }
-    __connectCb() {
-        this.log('iot connect');
-        this.connectionActive = true;
-        this.emit('connect');
-    }
-    __failureCb(err) {
-        this.log('iot failure');
-        this.emit('error', err);
-    }
-    __closeCb(responseObject) {
-        this.log('iot close');
-        this.connectionActive = false;
-        this.emit('close');
-    }
-    __offlineCb(responseObject) {
-        this.log('iot offline');
-        this.emit('offline');
+        if (this.connection) {
+            this.connection.publish(topic, msg, mqtt.QoS.AtLeastOnce, false);
+        }
     }
-    
-    __messageCb(t, message, packet) {
-        const topic = t.split('/');
-        let payload = JSON.parse(this.decoder.decode(message));
 
-        if(payload.display) {
-            const decodedDisplay = decodeJanusDisplay(payload.display);
+    handleMessage(topic, payload) {
+        const topicParts = topic.split('/');
+        let message;
+        try {
+            message = JSON.parse(this.decoder.decode(payload));
+        } catch (error) {
+            this.log('Error parsing message:', error);
+            return;
+        }
+
+        if(message.display) {
+            const decodedDisplay = decodeJanusDisplay(message.display);
             if(decodedDisplay.userId) {
-                payload = {...payload, userId: decodedDisplay.userId, role: decodedDisplay.role, start: decodedDisplay.start};
+                message = {...message, userId: decodedDisplay.userId, role: decodedDisplay.role, start: decodedDisplay.start};
             }
         }
 
-        if(topic[0] === 'user') { // user
-            const userId = topic[1].replace("_", ':');
-            this.emit('message', {userId, ...payload, event: payload.event ? `user:${payload.event}` : 'user'});
-        } else if(topic[0] === 'wt') {
-            const event = payload.event;
-            const roomId = topic[2];
-            if(topic[1] === 'room') { // room
+        if(topicParts[0] === 'user') { // user
+            const userId = topicParts[1].replace("_", ':');
+            this.emit('message', {userId, ...message, event: message.event ? `user:${message.event}` : 'user'});
+        } else if(topicParts[0] === 'wt') {
+            const event = message.event;
+            const roomId = topicParts[2];
+            if(topicParts[1] === 'room') { // room
                 if(
                     event === 'message' ||
                     event === 'template_updated' ||
@@ -221,36 +204,123 @@ class Iot {
                     event === 'handsCleared' ||
                     event === 'volume_set'
                 ) {
-                    this.emit('message', {event, ...payload, roomId})
+                    this.emit('message', {event, ...message, roomId})
                 }
                 else if(event === 'joined' || event === 'leaving') {
-                    this.emit('message', {event, ...payload, isObserver:!!payload.isObserver, roomId});
+                    this.emit('message', {event, ...message, isObserver:!!message.isObserver, roomId});
                 }
             }
-            else if(topic[1] === 'instanceroom') { // instance
+            else if(topicParts[1] === 'instanceroom') { // instance
                 if(event === 'add_room' || event === 'remove_room' || event === 'set_room' || event === "instance_homepage_changed" || event === 'instance_settings_changed') {
-                    this.emit('message', {event, ...payload});
+                    this.emit('message', {event, ...message});
                 }
             }
-            else if(topic[1] === 'externalmix') {
-                const event = payload.event;
-                this.emit('message', {event, ...payload});
+            else if(topicParts[1] === 'externalmix') {
+                const event = message.event;
+                this.emit('message', {event, ...message});
             }
-            else if(topic[1] === 'asset') {
-                this.emit('message',  {event: 'asset', assetId: topic[2], ...payload});
+            else if(topicParts[1] === 'asset') {
+                this.emit('message',  {event: 'asset', assetId: topicParts[2], ...message});
             }
-        } else if(topic[0] === 'wtr' || topic[0] === 'gwtr') {
-            const recorderId = topic[1];
-            const sessionId = topic[2];
-            if(topic[3] === 'control') {
-                this.emit('message', {event: 'recorder_control', ...payload, recorderId, sessionId});
+        } else if(topicParts[0] === 'wtr' || topicParts[0] === 'gwtr') {
+            const recorderId = topicParts[1];
+            const sessionId = topicParts[2];
+            if(topicParts[3] === 'control') {
+                this.emit('message', {event: 'recorder_control', ...message, recorderId, sessionId});
             } // recorder control
-            else if(topic[3] === 'monitor') {
-                this.emit('message', {event: 'recorder_monitor', ...payload, recorderId, sessionId});
+            else if(topicParts[3] === 'monitor') {
+                this.emit('message', {event: 'recorder_monitor', ...message, recorderId, sessionId});
             } // recorder monitor
         }
     }
-}
 
+    startCredentialsExpirationCheck(expiration) {
+        this.stopCredentialsExpirationCheck();
+        this.currentCredentialsExpirationStamp = new Date(expiration).getTime();
+        this.credentialsExpirationCheckIntervalId = setInterval(() => {
+            const currentTimeStamp = new Date().getTime();
+            if(this.currentCredentialsExpirationStamp - currentTimeStamp <= 300000) {
+                this.emit('updateCredentials');
+            }
+        }, 5000);
+    }
+
+    stopCredentialsExpirationCheck() {
+        clearInterval(this.credentialsExpirationCheckIntervalId);
+        this.credentialsExpirationCheckIntervalId = null;
+    }
+
+    updateWebSocketCredentials(accessKeyId, secretAccessKey, sessionToken, expiration) {
+        this.log('iot updateWebSocketCredentials');
+        this.lastConnectParams = {...this.lastConnectParams, accessKeyId, secretAccessKey, sessionToken, expiration };
+        const currentTopics = new Set(this.subscribedTopics);
+        return this.disconnect()
+            .then(() => this.connect(
+                this.lastConnectParams.apiMqttUrl,
+                this.lastConnectParams.apiMqttClientId,
+                this.lastConnectParams.region,
+                accessKeyId,
+                secretAccessKey,
+                sessionToken,
+                expiration
+            ))
+            .then(() => {
+                // Resubscribe to topics
+                currentTopics.forEach(topic => this.subscribe(topic));
+                this.startCredentialsExpirationCheck(expiration);
+        })
+    }
+
+    checkConnection() {
+        return new Promise((resolve, reject) => {
+            if (!this.connection || !this.connectionActive) {
+                reject(new Error('Not connected'));
+                return;
+            }
+
+            if (this.subscribedTopics.size === 0) {
+                reject(new Error('No subscribed topics available for connection check'));
+                return;
+            }
+
+            // Find a suitable topic for the connection check
+            const suitableTopic = Array.from(this.subscribedTopics).find(topic => topic !== 'wt/instanceroom/reactooDemo');
+
+            if (!suitableTopic) {
+                reject(new Error('No suitable topic found for connection check'));
+                return;
+            }
+
+            const testMessage = {
+                type: 'connection_check',
+                timestamp: Date.now()
+            };
+
+            const timeoutId = setTimeout(() => {
+                this.off('message', checkMessageHandler);
+                reject(new Error('Connection check timeout'));
+            }, 5000); // 5 seconds timeout
+
+            const checkMessageHandler = (message) => {
+                if (message.type === 'connection_check' && message.timestamp === testMessage.timestamp) {
+                    clearTimeout(timeoutId);
+                    this.off('message', checkMessageHandler);
+                    resolve();
+                }
+            };
+
+            this.on('message', checkMessageHandler);
+
+            try {
+                this.send(suitableTopic, testMessage);
+            } catch (error) {
+                clearTimeout(timeoutId);
+                this.off('message', checkMessageHandler);
+                reject(new Error(`Publish error: ${error.message}`));
+            }
+        });
+    }
+}
 
 export default Iot;
+

package/src/modules/wt-room.js

@@ -95,10 +95,10 @@ class RoomSession {
 			"watchparty": ['participant', 'talkback'],
 			"studio": ['participant', 'talkback', 'host', 'observer'],
 			"commentary": ['participant', 'talkback', 'host'],
-			"intercom": ['host', 'talkback', 'observer', 'observerSolo1', 'observerSolo2', 'observerSolo3'],
-			"videowall": ['host', 'talkback', 'observer', 'observerSolo1', 'observerSolo2', 'observerSolo3'],
-			"videowall-queue": ['host', 'talkback', 'observer', 'observerSolo1', 'observerSolo2', 'observerSolo3'],
-			"videowall-queue-video": ['host', 'talkback', 'observer', 'observerSolo1', 'observerSolo2', 'observerSolo3']
+			"intercom": ['host', 'talkback', 'observer', 'observerSolo1', 'observerSolo2', 'observerSolo3', 'observerSolo4', 'observerSolo5'],
+			"videowall": ['host', 'talkback', 'observer', 'observerSolo1', 'observerSolo2', 'observerSolo3', 'observerSolo4', 'observerSolo5'],
+			"videowall-queue": ['host', 'talkback', 'observer', 'observerSolo1', 'observerSolo2', 'observerSolo3', 'observerSolo4', 'observerSolo5'],
+			"videowall-queue-video": ['host', 'talkback', 'observer', 'observerSolo1', 'observerSolo2', 'observerSolo3', 'observerSolo4', 'observerSolo5']
 		},
 		monitor: {
 			"watchparty": ['participant', 'host'],
@@ -154,6 +154,24 @@ class RoomSession {
 			"videowall-queue": ['participant'],
 			"videowall-queue-video": ['participant'],
 		},
+		observerSolo4: {
+			"watchparty": ['participant'],
+			"studio": ['participant'],
+			"commentary": ['participant'],
+			"intercom": ['participant'],
+			"videowall": ['participant'],
+			"videowall-queue": ['participant'],
+			"videowall-queue-video": ['participant'],
+		},
+		observerSolo5: {
+			"watchparty": ['participant'],
+			"studio": ['participant'],
+			"commentary": ['participant'],
+			"intercom": ['participant'],
+			"videowall": ['participant'],
+			"videowall-queue": ['participant'],
+			"videowall-queue-video": ['participant'],
+		},
 		host: {
 			"watchparty": [],
 			"studio": [],
@@ -324,6 +342,8 @@ class RoomSession {
 			case 'observerSolo1':
 			case 'observerSolo2':
 			case 'observerSolo3':
+			case 'observerSolo4':
+			case 'observerSolo5':
 				return 'addRemoteObserver';
 			case 'host':
 				return 'addRemoteInstructor';
@@ -361,6 +381,8 @@ class RoomSession {
 			case 'observerSolo1':
 			case 'observerSolo2':
 			case 'observerSolo3':
+			case 'observerSolo4':
+			case 'observerSolo5':
 				return 'removeRemoteObserver';
 			case 'host':
 				return 'removeRemoteInstructor';

package/webpack.config.js

@@ -1,75 +1,74 @@
 /* global __dirname, require, module*/
 
-var PACKAGE = require('./package.json');
-var banner = ' ' + PACKAGE.name + ' \n @version ' + PACKAGE.version;
-
 const path = require('path');
 const webpack = require('webpack');
-const env = require('yargs').argv.env; // use --env with webpack 2
-const pkg = require('./package.json');
 const TerserPlugin = require('terser-webpack-plugin');
+const pkg = require('./package.json');
 
-let libraryName = 'watchtogether-sdk';
-
-let outputFile, mode;
-
-if (env === 'build') {
-  mode = 'production';
-  outputFile = libraryName + '.min.js';
-} else {
-  mode = 'development';
-  outputFile = libraryName + '.js';
-}
+const banner = ` ${pkg.name} \n @version ${pkg.version}`;
+const libraryName = 'watchtogether-sdk';
 
+module.exports = (env, argv) => {
+  const mode = argv.mode || 'development';
+  const outputFile = mode === 'production' ? `${libraryName}.min.js` : `${libraryName}.js`;
 
-module.exports = {
-  mode: mode,
-  entry: __dirname + '/src/index.js',
-  plugins: [
-    new webpack.BannerPlugin(banner)
-  ],
-  output: {
-    jsonpFunction: 'watchtogethersdkloader',
-    path: path.resolve(__dirname, 'dist'),
-    filename: outputFile,
-    library: 'WatchTogetherSDK',
-    libraryTarget: 'umd',
-    libraryExport: "default",
-    umdNamedDefine: true,
-    globalObject: "typeof self !== 'undefined' ? self : this"
-  },
-  module: {
-    rules: [
-      {
-        test: /\.(js)$/,
-        use: 'babel-loader'
-      }
-    ]
-  },
-  optimization: {
-    minimizer: [new TerserPlugin({
-      parallel: 2,
-      terserOptions: {
-        warnings: false,
-        parse: {},
-        compress: {},
-        mangle: true,
-        output: {
-          comments: /@version/i
+  return {
+    mode,
+    entry: './src/index.js',
+    output: {
+      path: path.resolve(__dirname, 'dist'),
+      filename: outputFile,
+      library: 'WatchTogetherSDK',
+      libraryTarget: 'umd',
+      libraryExport: 'default',
+      umdNamedDefine: true,
+      globalObject: "typeof self !== 'undefined' ? self : this"
+    },
+    // Remove the experiments section
+    module: {
+      rules: [
+        {
+          test: /\.js$/,
+          exclude: /node_modules/,
+          use: {
+            loader: 'babel-loader'
+          }
         },
-        toplevel: false,
-        nameCache: null,
-        ie8: false,
-        keep_fnames: true,
-      },
-    })],
-  },
-  resolve: {
-    modules: ['node_modules', path.resolve('./src')],
-    extensions: ['.json', '.js']
-  },
-  node: {
-    fs: 'empty',
-    tls: 'empty'
-  }
+        {
+          test: /\.worker\.js$/,
+          use: { loader: 'worker-loader' }
+        }
+      ]
+    },
+    plugins: [
+      new webpack.BannerPlugin(banner),
+      new webpack.ProvidePlugin({
+        process: 'process/browser',
+      }),
+    ],
+    optimization: {
+      minimizer: [
+        new TerserPlugin({
+          terserOptions: {
+            output: {
+              comments: /@version/i
+            }
+          },
+          extractComments: false
+        })
+      ]
+    },
+    resolve: {
+      modules: ['node_modules', path.resolve('./src')],
+      extensions: ['.js', '.json'],
+      fallback: {
+        "util": require.resolve("util/"),
+        "stream": require.resolve("stream-browserify"),
+        "buffer": require.resolve("buffer/"),
+        "crypto": require.resolve("crypto-browserify"),
+        "process": require.resolve("process/browser"),
+      }
+    },
+    devtool: mode === 'development' ? 'source-map' : false,
+  };
 };