@reactoo/watchtogether-sdk-js 2.5.73 → 2.5.75

package/example/bulk_join_room/bulk_join_room.html

@@ -183,7 +183,7 @@
 	}
 
 	function joinRoom(participantData) {
-		return participantData.sdkInstance.auth.deviceLogin(participantData.id)
+		return participantData.sdkInstance.auth.deviceLogin(false, participantData.id)
 			.then(() => participantData.sdkInstance.room.createSession({roomId, pinHash}))
 			.then(session => {
 				participantData.session = session;

package/example/index.html

@@ -17,6 +17,7 @@
         <button onclick="unpublish()">unpublish</button>
         <button onclick="toggleVideo()">toggle video</button>
         <button onclick="toggleAudio()">toggle audio</button>
+        <button onclick="hento()">sign to goole</button>
     </div>
 
 </div>
@@ -41,6 +42,14 @@
         //     });
         // }
 
+        function hento() {
+            Instance.auth.socialAuth({provider: 'youtube', action: 'generateAuthUrl'})
+                    .then(r => {
+                        window.open(r.data.redirectUrl);
+                    })
+
+        }
+
         function createParticipant(data, isRemote = false) {
 
             let id = `part_${data.id}`;
@@ -97,7 +106,7 @@
             Instance.room.getSessionByConstructId(constructId).toggleAudio()
         }
 
-        let Instance = WatchTogetherSDK({debug:true, apiUrl: 'https://api.reactoo.com/dev3/swagger.json'})({instanceType:'reactooDemo'});
+        let Instance = WatchTogetherSDK({debug:true, apiUrl: 'https://api.reactoo.com/stefan/swagger.json'})({instanceType:'reactooDemo'});
 
         Instance.auth.$on('login', () => {
             console.log('We are in');
@@ -122,9 +131,7 @@
         Instance.auth.deviceLogin(true) // login as browser
             .then(r => Instance.iot.iotLogin()) // login to mqtt
             .then(r => {
-
                 if(roomId) {
-                    console.log(roomId);
                     return Instance.room.getRoomById(roomId, pinHash).then((r) => {
                         Instance.iot?.subscribe(r.data.iotTopic);
                         return {roomId, pinHash}
@@ -136,9 +143,6 @@
                     .then(r => r.data.items.length ? r.data.items[0] : Instance.room.createRoom({title:'Demo Room'}).then(r => r.data))
                     .then(r => Instance.room.getInviteUrl(r._id)) // getting info about invite params
                     .then((r) => {
-
-
-
                         roomId = r.data.roomId;
 
                         console.log('-----------------------------------------------------');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactoo/watchtogether-sdk-js",
-  "version": "2.5.73",
+  "version": "2.5.75",
   "description": "Javascript SDK for Reactoo",
   "main": "src/index.js",
   "unpkg": "dist/watchtogether-sdk.min.js",

package/src/models/auth.js

@@ -90,6 +90,11 @@ let auth = function () {
                 .then(client => client.apis.auth.confirmForgotPassword({},{requestBody:{password, confirmationCode, username}}))
         },
 
+        socialAuth: (data = {}) => {
+            return this.__privates.auth.__client
+                .then(client => client.apis.auth.socialAuth(data))
+        },
+
         $on: (key, callback, that) => {
             return this.__privates.auth.on(key, callback, that || this);
         },

package/src/modules/wt-auth.js

@@ -109,12 +109,12 @@ class Auth {
 				this.emit(this.__isLogged ? 'login' : 'logout', {
 					client,
 					isInitialEvent,
+					isReauth,
 					isLoggedInAsDevice: this.isLoggedInAs(this.__parsedJwt, 'device'),
 					isLoggedInAsObserver: this.isLoggedInAs(this.__parsedJwt, 'observer'),
 					isLoggedInAsInstanceAdmin: this.isLoggedInAs(this.__parsedJwt, 'instanceAdmin'),
 					isLoggedInAsAdmin: this.isLoggedInAs(this.__parsedJwt, 'admin'),
-					domain: this.getDomain(this.__parsedJwt),
-					isReauth
+					domain: this.getDomain(this.__parsedJwt)
 				});
 				return client;
 			})

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

@@ -0,0 +1,245 @@
+
+import {device} from 'aws-iot-device-sdk';
+import emitter from './wt-emitter';
+import {decodeJanusDisplay} from "./wt-utils";
+
+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;
+        this.credentialsExpirationCheckIntervalId = null;
+        this.currentCredentialsExpirationStamp = null
+        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) {
+        if(this.device) {
+            this.device.updateWebSocketCredentials(accessKeyId, secretAccessKey, sessionToken);
+            this.startCredentialsExpirationCheck(expiration);
+        }
+    }
+    
+    connect(apiMqttUrl, apiMqttClientId, region, accessKeyId, secretAccessKey, sessionToken, expiration, forceDisconnect = false) {
+        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: 15,
+                    maximumReconnectTimeMs: 8000,
+                    enableMetrics: false,
+                    debug: this.debugFlag,
+                    autoResubscribe: true
+                });
+                
+                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));
+                
+            })
+        })
+        
+    }
+    
+    disconnect(force = false) {
+        
+        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);
+        });
+    }
+    
+    isConnected() {
+        return this.connectionActive;
+    }
+    
+    subscribe(topic) {
+        return this.device && this.device.subscribe(topic);
+    }
+    
+    unsubscribe(topic) {
+        return this.device && this.device.unsubscribe(topic);
+    }
+    
+    send(topic, message) {
+        let msg = typeof message === 'object' ? JSON.stringify(message) : message;
+        return this.device && this.device.publish(topic, msg);
+    }
+    
+    __reconnectCb() {
+        this.emit('reconnect');
+    }
+    __connectCb() {
+        this.connectionActive = true;
+        this.emit('connect');
+    }
+    __failureCb(err) {
+        this.emit('error', err);
+    }
+    __closeCb(responseObject) {
+        this.connectionActive = false;
+        this.emit('close');
+    }
+    __offlineCb(responseObject) {
+        this.emit('offline');
+    }
+    
+    __messageCb(t, message, packet) {
+        const topic = t.split('/');
+        let payload = JSON.parse(this.decoder.decode(message));
+
+        if(payload.display) {
+            const decodedDisplay = decodeJanusDisplay(payload.display);
+            if(decodedDisplay.userId) {
+                payload = {...payload, 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(
+                    event === 'message' ||
+                    event === 'template_updated' ||
+                    event === 'record_start' ||
+                    event === 'record_stop' ||
+                    event === 'record_configured' ||
+                    event === 'record_livestream_available' ||
+                    event === 'record_livestream_kick' ||
+                    event === 'user_update_displayname' ||
+                    event === 'user_update_avatar' ||
+                    event === 'user_update_customattributes' ||
+                    event === 'user_update_privateattributes' ||
+                    event === 'channel_changed' ||
+                    event === "instance_homepage_changed" ||
+                    event === "instance_settings_changed" ||
+                    event === "externalmix_changed" ||
+                    event === "video_uploaded" ||
+                    event === "change_user_devices" ||
+                    event === "queue" ||
+                    event === "title_changed"
+                ) {
+                    this.emit('message', {event, ...payload, roomId})
+                }
+                else if(event === 'joined' || event === 'leaving') {
+                    this.emit('message', {event, ...payload, isObserver:!!payload.isObserver, roomId});
+                }
+                else if(
+                    event === 'left' || //user removed room a.k.a. left the room
+                    event === 'kicked' ||
+                    event === 'banned' ||
+                    event === 'unbanned' ||
+                    event === 'approved' ||
+                    event === 'muted' ||
+                    event === 'unmuted' ||
+                    event === 'messageRemoved' ||
+                    event === 'messageReported' ||
+                    event === 'chatClear' ||
+                    event === 'handRaised' || event === 'handLowered' || event === 'handsCleared'
+                ) {
+                    this.emit('message', {event, ...payload});
+                }
+                else if(event === 'volume_set') {
+                    this.emit('message', {event, ...payload});
+                }
+            }
+            else if(topic[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});
+                }
+            }
+            else if(topic[1] === 'externalmix') {
+                const event = payload.event;
+                this.emit('message', {event, ...payload});
+            }
+        } else if(topic[0] === 'wtr') {
+            const recorderId = topic[1];
+            const sessionId = topic[2];
+            if(topic[3] === 'control') {
+                this.emit('message', {event: 'recorder_control', ...payload, recorderId, sessionId});
+            } // recorder control
+            else if(topic[3] === 'monitor') {
+                this.emit('message', {event: 'recorder_monitor', ...payload, recorderId, sessionId});
+            } // recorder monitor
+        }
+    }
+}
+
+
+export default Iot;

package/src/modules/wt-room.js

@@ -2027,7 +2027,7 @@ class RoomSession {
 								tid: generateUUID(),
 								id: handle.handleId,
 								userId: decodeJanusDisplay(handle.userId)?.userId,
-								role: decodeJanusDisplay(handle.userId)?.role,
+								role: decodeJanusDisplay(this.display)?.role,
 								track,
 								stream: config.stream,
 								adding: true,
@@ -2041,7 +2041,7 @@ class RoomSession {
 									tid:generateUUID(),
 									id: handle.handleId,
 									userId: decodeJanusDisplay(handle.userId)?.userId,
-									role: decodeJanusDisplay(handle.userId)?.role,
+									role: decodeJanusDisplay(this.display)?.role,
 									track: ev.target,
 									stream: config.stream,
 									adding: false,
@@ -2059,7 +2059,7 @@ class RoomSession {
 						tid: generateUUID(),
 						id: handle.handleId,
 						userId: decodeJanusDisplay(handle.userId)?.userId,
-						role: decodeJanusDisplay(handle.userId)?.role,
+						role: decodeJanusDisplay(this.display)?.role,
 						stream: null,
 						adding: false,
 						constructId: this.constructId,