@reactoo/watchtogether-sdk-js 2.5.31 → 2.5.37

package/src/modules/wt-room.js

@@ -2,7 +2,7 @@
 
 import adapter from 'webrtc-adapter';
 import emitter from './wt-emitter';
-import {generateUUID} from "./wt-utils";
+import {decodeJanusDisplay, generateUUID} from "./wt-utils";
 
 class Room {
 
@@ -96,24 +96,39 @@ class RoomSession {
 
 	static subscriptionRules = {
 		participant: {
-			watchTogether: ['participant', 'talkback'],
-			videoWall: ['instructor', 'observer', 'talkback']
+			"watchparty": ['participant', 'talkback'],
+			"commentary": ['participant', 'talkback'],
+			"videowall": ['instructor', 'observer', 'talkback'],
+			"videowall-queue": ['instructor', 'observer', 'talkback'],
+			"videowall-queue-video": ['instructor', 'observer', 'talkback']
 		},
 		monitor: {
-			watchTogether: ['participant'],
-			videoWall: ['instructor', 'participant'],
+			"watchparty": ['participant'],
+			"commentary": ['participant'],
+			"videowall": ['instructor', 'participant'],
+			"videowall-queue": ['instructor', 'participant'],
+			"videowall-queue-video": ['instructor', 'participant'],
 		},
 		talkback: {
-			watchTogether: ['participant'],
-			videoWall: ['instructor', 'participant'],
+			"watchparty": ['participant'],
+			"commentary": ['participant'],
+			"videowall": ['instructor', 'participant'],
+			"videowall-queue": ['instructor', 'participant'],
+			"videowall-queue-video": ['instructor', 'participant'],
 		},
 		observer: {
-			watchTogether: ['participant'],
-			videoWall: ['participant'],
+			"watchparty": ['participant'],
+			"commentary": ['participant'],
+			"videowall": ['participant'],
+			"videowall-queue": ['participant'],
+			"videowall-queue-video": ['participant'],
 		},
 		instructor: {
-			watchTogether: [],
-			videoWall: [],
+			"watchparty": [],
+			"commentary": [],
+			"videowall": [],
+			"videowall-queue": [],
+			"videowall-queue-video": [],
 		},
 	};
 
@@ -130,8 +145,6 @@ class RoomSession {
 		this.userId = null;
 		this.sessiontype = type;
 		this.initialBitrate = 0;
-		//TODO: remove this
-		this.isMonitor = false; // currently used just for classroom context so monitor user only subscribes to participants and not trainer (for other monitor this flag is not necessary)
 		this.recordingFilename = null;
 		this.pluginName = RoomSession.sessionTypes[type];
 		this.options = options;
@@ -143,10 +156,12 @@ class RoomSession {
 		this.ws = null;
 		this.isRestarting = false;
 
-		//TODO: do it better
-		// double click prevention
-		this.connectingPromise = null;
-		this.disconnectingPromise = null;
+		this.isConnecting = false;
+		this.isDisconnecting = false;
+		this.isConnected = false;
+		this.isPublished = false;
+		this.isReclaiming = false;
+		this.isStreaming = false;
 
 		this._ipv6Support = false;
 		this._retries = 0;
@@ -156,12 +171,10 @@ class RoomSession {
 		this._observerIds = [];
 		this._talkbackIds = [];
 		this._instuctorId = null;
-		this._hasJoined = false;
-		this._isStreaming = false;
-		this._isPublished = false;
+		this._roomType = 'watchparty';
 		this._isDataChannelOpen = false;
-		this._dataChannelTimeoutId = null;
-		this._messageTimeoutId = null;
+		this._abortController = null;
+
 		this.isAudioMuted = false;
 		this.isVideoMuted = false;
 		this.isVideoEnabled = false;
@@ -210,29 +223,29 @@ class RoomSession {
 	}
 
 	_participantShouldSubscribe(userId) {
+		const myUserId = decodeJanusDisplay(this.userId)?.userId;
+		const remoteUserId = decodeJanusDisplay(userId)?.userId;
+
 		let allowedObservers = this._observerIds || [];
 		let allowedTalkback = this._talkbackIds || [];
 		let allowedInstructor = this._instuctorId || null;
 		let localUserRole = 'participant';
-		if(this.isMonitor) {
-			localUserRole = 'monitor';
-		} else if(allowedObservers.indexOf(this.userId) > -1) {
+		if(allowedObservers.indexOf(myUserId) > -1) {
 			localUserRole = 'observer';
-		} else if(allowedTalkback.indexOf(this.userId) > -1) {
+		} else if(allowedTalkback.indexOf(myUserId) > -1) {
 			localUserRole = 'talkback';
-		} else if(this.userId === allowedInstructor) {
+		} else if(myUserId === allowedInstructor) {
 			localUserRole = 'instructor';
 		}
 		let remoteUserRole = 'participant';
-		if(allowedObservers.indexOf(userId) > -1) {
+		if(allowedObservers.indexOf(remoteUserId) > -1) {
 			remoteUserRole = 'observer';
-		} else if(allowedTalkback.indexOf(userId) > -1) {
+		} else if(allowedTalkback.indexOf(remoteUserId) > -1) {
 			remoteUserRole = 'talkback';
-		} else if(userId === allowedInstructor) {
+		} else if(remoteUserId === allowedInstructor) {
 			remoteUserRole = 'instructor';
 		}
-		let mode = allowedInstructor !== null ? 'videoWall' : 'watchTogether';
-		return this.subscriptionRules[localUserRole][mode].indexOf(remoteUserRole) > -1;
+		return this.subscriptionRules[localUserRole][this._roomType].indexOf(remoteUserRole) > -1;
 	}
 
 	_getAddParticipantEventName(handleId) {
@@ -247,17 +260,19 @@ class RoomSession {
 			});
 		}
 
+		const decodedUserId = decodeJanusDisplay(handle.userId)?.userId;
+
 		let allowedTalkback = this._talkbackIds || [];
 		let allowedObservers = this._observerIds || [];
 		let allowedInstructor = this._instuctorId || null;
 		let eventName = 'addRemoteParticipant';
-		if(handle.userId === allowedInstructor) {
+		if(decodedUserId === allowedInstructor) {
 			eventName = 'addRemoteInstructor';
 		}
-		if (allowedTalkback.indexOf(handle.userId) > -1) {
+		if (allowedTalkback.indexOf(decodedUserId) > -1) {
 			eventName = 'addRemoteTalkback';
 		}
-		if (allowedObservers.indexOf(handle.userId) > -1) {
+		if (allowedObservers.indexOf(decodedUserId) > -1) {
 			eventName = 'addRemoteObserver';
 		}
 		return eventName
@@ -275,17 +290,19 @@ class RoomSession {
 			});
 		}
 
+		const decodedUserId = decodeJanusDisplay(handle.userId)?.userId;
+
 		let allowedTalkback = this._talkbackIds || [];
 		let allowedObservers = this._observerIds || [];
 		let allowedInstructor = this._instuctorId || null;
 		let eventName = 'removeRemoteParticipant';
-		if(handle.userId === allowedInstructor) {
+		if(decodedUserId === allowedInstructor) {
 			eventName = 'removeRemoteInstructor';
 		}
-		if (allowedTalkback.indexOf(handle.userId) > -1) {
+		if (allowedTalkback.indexOf(decodedUserId) > -1) {
 			eventName = 'removeRemoteTalkback';
 		}
-		if (allowedObservers.indexOf(handle.userId) > -1) {
+		if (allowedObservers.indexOf(decodedUserId) > -1) {
 			eventName = 'removeRemoteObserver';
 		}
 		return eventName
@@ -321,12 +338,25 @@ class RoomSession {
 			transaction,
 			token: this.token, ...((this.sessionId && {'session_id': this.sessionId}) || {})
 		};
+
+		this._log(requestData);
+
 		return new Promise((resolve, reject) => {
+			let messageTimeoutId = null;
+
+			let abortResponse = () => {
+				this._abortController.signal.removeEventListener('abort', abortResponse);
+				clearTimeout(messageTimeoutId);
+				this.ws.removeEventListener('message', parseResponse);
+				reject({type: 'warning', id: 17, message: 'connection cancelled'})
+			};
+
 			let parseResponse = (event) => {
 				let json = JSON.parse(event.data);
 				let r_transaction = json['transaction'];
 				if (r_transaction === transaction && (!dontResolveOnAck || json['janus'] !== 'ack')) {
-					clearTimeout(this._messageTimeoutId);
+					clearTimeout(messageTimeoutId);
+					this._abortController.signal.removeEventListener('abort', abortResponse);
 					this.ws.removeEventListener('message', parseResponse);
 					if (json['janus'] === 'error') {
 						if (json?.error?.code == 403) {
@@ -347,11 +377,16 @@ class RoomSession {
 
 			} else {
 				if (this.ws && this.ws.readyState === 1) {
+
 					this.ws.addEventListener('message', parseResponse);
-					this._messageTimeoutId = setTimeout(() => {
+
+					messageTimeoutId = setTimeout(() => {
 						this.ws.removeEventListener('message', parseResponse);
+						this._abortController.signal.removeEventListener('abort', abortResponse);
 						reject({type: 'error', id: 3, message: 'send timeout', data: requestData});
 					}, 10000);
+
+					this._abortController.signal.addEventListener('abort', abortResponse);
 					this.ws.send(JSON.stringify(requestData));
 				} else {
 					reject({type: 'warning', id: 29, message: 'No connection to WebSockets', data: requestData});
@@ -361,7 +396,8 @@ class RoomSession {
 	}
 
 	_connectionClosed() {
-		if (this.disconnectingPromise || this.connectingPromise) {
+
+		if (!this.isConnected || this.isConnecting || this.isDisconnecting) {
 			return;
 		}
 
@@ -484,7 +520,7 @@ class RoomSession {
 				if (event === "joined") {
 					this.id = msg["id"];
 					this.privateId = msg["private_id"];
-					this._hasJoined = true;
+					this.isConnected = true;
 					this.emit('joined', true);
 					this._log('We have successfully joined Room');
 					for (let f in list) {
@@ -593,7 +629,7 @@ class RoomSession {
 					}
 					if (result["status"] === 'started') {
 						this.emit('streaming', true);
-						this._isStreaming = true;
+						this.isStreaming = true;
 					}
 				}
 
@@ -640,7 +676,7 @@ class RoomSession {
 				this.emit(this._getAddParticipantEventName(handle.handleId), {
 					tid: generateUUID(),
 					id: handle.handleId,
-					userId: handle.userId,
+					userId: decodeJanusDisplay(handle.userId)?.userId,
 					stream: null,
 					track: null,
 					adding: false,
@@ -775,11 +811,11 @@ class RoomSession {
 
 				if (handleId === this.handleId) {
 					this._isDataChannelOpen = false;
-					this._isPublished = false;
+					this.isPublished = false;
 					this.emit('published', {status: false, hasStream: false});
-					this.emit('removeLocalParticipant', {id: handleId, userId: handle.userId});
+					this.emit('removeLocalParticipant', {id: handleId, userId: decodeJanusDisplay(handle.userId)?.userId});
 				} else {
-					this.emit(this._getRemoveParticipantEventName(handleId), {id: handleId, userId: handle.userId});
+					this.emit(this._getRemoveParticipantEventName(handleId), {id: handleId, userId: decodeJanusDisplay(handle.userId)?.userId});
 				}
 
 				if (removeHandle) {
@@ -836,10 +872,10 @@ class RoomSession {
 	}
 
 	_leaveRoom(dontWait = false) {
-		return this._hasJoined
+		return this.isConnected
 			? this.sendMessage(this.handleId, {body: {"request": "leave"}}, dontWait)
 				.finally(() => {
-					this._hasJoined = false;
+					this.isConnected = false;
 					this.emit('joined', false);
 				})
 			: Promise.resolve();
@@ -849,8 +885,8 @@ class RoomSession {
 
 	_reconnect() {
 
-		if (this.connectingPromise) {
-			return this.connectingPromise;
+		if (this.isReclaiming) {
+			return Promise.resolve();
 		}
 
 		if (this.ws) {
@@ -860,25 +896,39 @@ class RoomSession {
 			}
 		}
 		this._stopKeepAlive();
-		this.connectingPromise = new Promise((resolve, reject) => {
-			this.emit('joining', true);
+		this.isReclaiming = true;
+		this.emit('joining', true);
+		return new Promise((resolve, reject) => {
+
+			let abortReconnect = () => {
+				this._abortController.signal.removeEventListener('abort', abortReconnect);
+				this.ws.removeEventListener('close', this.__connectionClosedBoundFn);
+				this.ws.removeEventListener('message', this.__handleWsEventsBoundFn);
+				this.ws.onopen = null;
+				this.ws.onerror = null;
+				this.isReclaiming = false;
+				this.emit('joining', false);
+				reject({type: 'warning', id: 17, message: 'Connection cancelled', data: e});
+			};
+
 			this.ws = new WebSocket(this.server, 'janus-protocol');
 			this.__connectionClosedBoundFn = this._connectionClosed.bind(this);
 			this.__handleWsEventsBoundFn = this._handleWsEvents.bind(this);
 			this.ws.addEventListener('close', this.__connectionClosedBoundFn);
 			this.ws.addEventListener('message', this.__handleWsEventsBoundFn);
 			this.ws.onopen = () => {
+				this._abortController.signal.removeEventListener('abort', abortReconnect);
 				this._send({"janus": "claim"})
 					.then(json => {
 						this.sessionId = json["session_id"] ? json["session_id"] : json.data["id"];
 						this._startKeepAlive();
-						this.connectingPromise = null;
+						this.isReclaiming = false;
 						this.emit('joining', false);
 						this._retries = 0;
 						resolve(json);
 					})
 					.catch(error => {
-						this.connectingPromise = null;
+						this.isReclaiming = false;
 						this.emit('joining', false);
 						reject({type: 'error', id: 11, message: 'reconnection error', data: error})
 					});
@@ -886,26 +936,27 @@ class RoomSession {
 
 			// this is called before 'close' event callback so it doesn't break reconnect loop
 			this.ws.onerror = (e) => {
-				this.connectingPromise = null;
+				this._abortController.signal.removeEventListener('abort', abortReconnect);
+				this.isReclaiming = false;
 				this.emit('joining', false);
 				reject({type: 'warning', id: 12, message: 'ws reconnection error', data: e});
 			}
+
+			this._abortController.signal.addEventListener('abort', abortReconnect);
 		});
-		return this.connectingPromise;
 	}
 
-	connect(roomId, pin, server, iceServers, token, display, userId, webrtcVersion = 0, initialBitrate = 0, isMonitor, recordingFilename) {
+	connect(roomId, pin, server, iceServers, token, display, userId, webrtcVersion = 0, initialBitrate = 0, recordingFilename) {
 
-		if (this.connectingPromise) {
-			return this.connectingPromise;
+		if (this.isConnecting) {
+			return Promise.reject({type: 'warning', id: 16, message: 'connection already in progress'});
 		}
 
-		this.emit('joined', false);
 		if (this.ws) {
 			this._wipeListeners();
 		}
 		this._stopKeepAlive();
-		this.disconnectingPromise = null;
+		this._abortController = new AbortController();
 		this.sessionId = null;
 		this.server = server;
 		this.iceServers = iceServers;
@@ -916,17 +967,30 @@ class RoomSession {
 		this.userId = userId;
 		this.webrtcVersion = webrtcVersion;
 		this.initialBitrate = initialBitrate;
-		this.isMonitor = isMonitor;
 		this.recordingFilename = recordingFilename;
-		this.disconnectingPromise = null;
-		this.connectingPromise = new Promise((resolve, reject) => {
-			this.emit('joining', true);
+		this.isConnecting = true;
+		this.emit('joining', true);
+		return new Promise((resolve, reject) => {
+
 			this.ws = new WebSocket(this.server, 'janus-protocol');
 			this.__connectionClosedBoundFn = this._connectionClosed.bind(this);
 			this.__handleWsEventsBoundFn = this._handleWsEvents.bind(this);
+
+			let abortConnect = () => {
+				this._abortController.signal.removeEventListener('abort', abortConnect);
+				this.ws.removeEventListener('close', this.__connectionClosedBoundFn);
+				this.ws.removeEventListener('message', this.__handleWsEventsBoundFn);
+				this.ws.onopen = null;
+				this.ws.onerror = null;
+				this.isConnecting = false;
+				this.emit('joining', false);
+				reject({type: 'warning', id: 17, message: 'Connection cancelled'});
+			};
+
 			this.ws.addEventListener('close', this.__connectionClosedBoundFn);
 			this.ws.addEventListener('message', this.__handleWsEventsBoundFn);
 			this.ws.onopen = () => {
+				this._abortController.signal.removeEventListener('abort', abortConnect);
 				this._retries = 0;
 				this._send({"janus": "create"})
 					.then(json => {
@@ -941,36 +1005,41 @@ class RoomSession {
 					})
 					.then(() => this._joinRoom(roomId, pin, userId, display))
 					.then(() => {
-						this.connectingPromise = null;
+						this.isConnecting = false;
 						this.emit('joining', false);
 						resolve(this);
 					})
 					.catch(error => {
-						this.connectingPromise = null;
+						this.isConnecting = false;
 						this.emit('joining', false);
-						reject({type: 'error', id: 13, message: 'connection error', data: error})
+						reject({type: error?.type === 'warning' ? 'warning' : 'error', id: 13, message: 'connection error', data: error})
 					});
 			};
+
 			this.ws.onerror = (e) => {
-				this.connectingPromise = null;
+				this._abortController.signal.removeEventListener('abort', abortConnect);
+				this.isConnecting = false;
 				this.emit('joining', false);
 				reject({type: 'error', id: 14, message: 'ws connection error', data: e});
 			}
+
+			this._abortController.signal.addEventListener('abort', abortConnect);
+
 		});
-		return this.connectingPromise;
 	}
 
 	disconnect() {
-		if (this.disconnectingPromise) {
-			return this.disconnectingPromise;
+		
+		if (this.isDisconnecting) {
+			return Promise.resolve();
 		}
 
-		let _hasJoined = this._hasJoined;
-
-		clearTimeout(this._messageTimeoutId);
-		clearTimeout(this._dataChannelTimeoutId);
+		this._abortController?.abort?.();
 		this._stopKeepAlive();
-		this.disconnectingPromise = Promise.all(this._participants.map(p => this._removeParticipant(p.handleId)))
+
+		let isConnected = this.isConnected;
+		this.isDisconnecting = true;
+		return Promise.all(this._participants.map(p => this._removeParticipant(p.handleId)))
 			.finally(() => {
 				this._wipeListeners();
 				if (this.ws && this.ws.readyState === 1) {
@@ -978,44 +1047,59 @@ class RoomSession {
 					this.ws.close();
 				}
 				this.sessionId = null;
-				//TODO: Just in case something crashed along the way
-				this._isPublished = false;
-				this._hasJoined = false;
+				this.isPublished = false;
+				this.isConnected = false;
+				this.isDisconnecting = false;
+				this.emit('publishing', false);
 				this.emit('published', {status: false, hasStream: false});
+				this.emit('joining', false);
 				this.emit('joined', false);
-				this.emit('disconnect', _hasJoined);
+				this.emit('disconnect', isConnected);
 				return Promise.resolve('Disconnected');
 			})
-		return this.disconnectingPromise;
 	}
 
 	startStream(streamId, server, iceServers, token, userId) {
 
-		if (this.connectingPromise) {
-			return this.connectingPromise
+		if (this.isConnecting) {
+			return Promise.reject({type: 'warning', id: 16, message: 'connection error', data: 'Connection is in progress'});
 		}
 
-		this.emit('streaming', false);
 		if (this.ws) {
 			this._wipeListeners();
 		}
+
 		this._stopKeepAlive();
-		this.disconnectingPromise = null;
-		this.sessionId = null;
+		this._abortController = new AbortController();
 		this.server = server;
 		this.iceServers = iceServers;
 		this.token = token;
 		this.streamId = streamId;
 		this.userId = userId;
+		this.sessionId = null;
+		this.isConnecting = true;
+		this.emit('streamStarting', true);
+		return new Promise((resolve, reject) => {
 
-		this.connectingPromise = new Promise((resolve, reject) => {
-			this.emit('streamStarting', true);
 			this.ws = new WebSocket(this.server, 'janus-protocol');
 			this.__connectionClosedBoundFn = this._connectionClosed.bind(this);
 			this.__handleWsEventsBoundFn = this._handleWsEvents.bind(this);
+
+			let abortConnect = () => {
+				this._abortController.signal.removeEventListener('abort', abortConnect);
+				this.ws.removeEventListener('close', this.__connectionClosedBoundFn);
+				this.ws.removeEventListener('message', this.__handleWsEventsBoundFn);
+				this.ws.onopen = null;
+				this.ws.onerror = null;
+				this.isConnecting = false;
+				this.emit('streamStarting', false);
+				reject({type: 'warning', id: 17, message: 'Connection cancelled'});
+			};
+
 			this.ws.addEventListener('close', this.__connectionClosedBoundFn);
 			this.ws.addEventListener('message', this.__handleWsEventsBoundFn);
 			this.ws.onopen = () => {
+				this._abortController.signal.removeEventListener('abort', abortConnect);
 				this._retries = 0;
 				this._send({"janus": "create"})
 					.then(json => {
@@ -1030,38 +1114,39 @@ class RoomSession {
 					})
 					.then(() => this._watchStream(streamId))
 					.then(() => {
-						this.connectingPromise = null;
+						this.isConnecting = false;
 						this.emit('streamStarting', false);
 						resolve(this);
 					})
 					.catch(error => {
-						this.connectingPromise = null;
+						this.isConnecting = false;
 						this.emit('streamStarting', false);
 						reject({type: 'error', id: 13, message: 'connection error', data: error})
 					});
 			};
 			this.ws.onerror = (e) => {
-				this.connectingPromise = null;
+				this._abortController.signal.removeEventListener('abort', abortConnect);
+				this.isConnecting = false;
 				this.emit('streamStarting', false);
 				reject({type: 'error', id: 14, message: 'ws connection error', data: e});
 			}
+
+			this._abortController.signal.addEventListener('abort', abortConnect);
 		});
-		return this.connectingPromise;
 	}
 
 	stopStream() {
-		if (this.disconnectingPromise) {
-			return this.disconnectingPromise;
-		}
 
-		let _isStreaming = this._isStreaming;
+		if (this.isDisconnecting) {
+			return Promise.resolve();
+		}
 
+		this._abortController?.abort?.();
 		this._stopKeepAlive();
-		this.disconnectingPromise = this.sendMessage(this.handleId, {
-			body: {
-				"request": "stop"
-			}
-		}, false, true)
+
+		let isStreaming = this.isStreaming;
+		this.isDisconnecting = true;
+		return this.sendMessage(this.handleId, {body: {"request": "stop"}}, false, true)
 			.then(() => this._removeParticipant(this.handleId))
 			.finally(() => {
 				this._wipeListeners();
@@ -1070,15 +1155,13 @@ class RoomSession {
 					this.ws.close();
 				}
 				this.sessionId = null;
-				this._isStreaming = false;
+				this.isDisconnecting = false;
+				this.isStreaming = false;
+				this.emit('streamStarting', false);
 				this.emit('streaming', false);
-				// last event
-				this.emit('disconnect', _isStreaming);
-				this.disconnectingPromise = null;
+				this.emit('disconnect', isStreaming);
 				return Promise.resolve('Disconnected');
 			});
-
-		return this.disconnectingPromise;
 	}
 
 	destroy() {
@@ -1169,7 +1252,7 @@ class RoomSession {
 					this.emit(this._getAddParticipantEventName(handle.handleId), {
 						tid: generateUUID(),
 						id: handle.handleId,
-						userId: handle.userId,
+						userId: decodeJanusDisplay(handle.userId)?.userId,
 						stream: config.stream,
 						track: null,
 						optional: true,
@@ -1190,7 +1273,7 @@ class RoomSession {
 					this.emit(this._getAddParticipantEventName(handle.handleId), {
 						tid: generateUUID(),
 						id: handle.handleId,
-						userId: handle.userId,
+						userId: decodeJanusDisplay(handle.userId)?.userId,
 						stream: config.stream,
 						track: null,
 						optional: true,
@@ -1243,7 +1326,7 @@ class RoomSession {
 							tid: generateUUID(),
 							mid,
 							id: handle.handleId,
-							userId: handle.userId,
+							userId: decodeJanusDisplay(handle.userId)?.userId,
 							stream: config.stream,
 							track: event.track,
 							constructId: this.constructId,
@@ -1271,7 +1354,7 @@ class RoomSession {
 									tid: generateUUID(),
 									id: handle.handleId,
 									mid,
-									userId: handle.userId,
+									userId: decodeJanusDisplay(handle.userId)?.userId,
 									stream: config.stream,
 									track: ev.target,
 									constructId: this.constructId,
@@ -1297,7 +1380,7 @@ class RoomSession {
 							this.emit('remoteTrackMuted', {
 								id: handle.handleId,
 								mid,
-								userId: handle.userId,
+								userId: decodeJanusDisplay(handle.userId)?.userId,
 								stream: config.stream,
 								kind: ev.target.kind,
 								track: ev.target,
@@ -1318,7 +1401,7 @@ class RoomSession {
 							this.emit('remoteTrackMuted', {
 								id: handle.handleId,
 								mid,
-								userId: handle.userId,
+								userId: decodeJanusDisplay(handle.userId)?.userId,
 								stream: config.stream,
 								kind: ev.target.kind,
 								track: ev.target,
@@ -1708,6 +1791,14 @@ class RoomSession {
 
 	publishLocal(stream, {keepAudio = false, keepVideo = false} = {}) {
 
+		if(this.isDisconnecting || !this.isConnected) {
+			return Promise.reject({
+				type: 'warning',
+				id: 18,
+				message: 'Either not connected or disconnecting',
+			})
+		}
+
 		this.emit('publishing', true);
 
 		let handle = this._getHandle(this.handleId);
@@ -1872,23 +1963,40 @@ class RoomSession {
 					return Promise.resolve(r)
 				} else {
 					return new Promise((resolve, reject) => {
-						let __ = (val) => {
+
+						let dataChannelTimeoutId = null;
+
+						let _resolve = (val) => {
 							if (val) {
-								clearTimeout(this._dataChannelTimeoutId);
-								this.off('dataChannel', __, this);
+								clearTimeout(dataChannelTimeoutId);
+								this._abortController.signal.removeEventListener('abort', _rejectAbort);
+								this.off('dataChannel', _resolve, this);
 								resolve(this);
 							}
 						};
-						this._dataChannelTimeoutId = setTimeout(() => {
-							this.off('dataChannel', __, this);
+
+						let _rejectTimeout = () => {
+							this.off('dataChannel', _resolve, this);
+							this._abortController.signal.removeEventListener('abort', _rejectAbort);
 							reject({type: 'error', id: 27, message: 'Data channel did not open', data: null});
-						}, 5000);
-						this.on('dataChannel', __, this);
+						}
+
+						let _rejectAbort = () => {
+							this._abortController.signal.removeEventListener('abort', _rejectAbort);
+							clearTimeout(dataChannelTimeoutId);
+							this.off('dataChannel', _resolve, this);
+							reject({type: 'warning', id: 17, message: 'Connection cancelled'})
+						}
+
+						dataChannelTimeoutId = setTimeout(_rejectTimeout, 5000);
+						this._abortController.signal.addEventListener('abort', _rejectAbort);
+
+						this.on('dataChannel', _resolve, this);
 					});
 				}
 			})
 			.then(r => {
-				this._isPublished = true;
+				this.isPublished = true;
 				if(config.stream) {
 					let tracks = config.stream.getTracks();
 					tracks.forEach(track => {
@@ -1897,7 +2005,7 @@ class RoomSession {
 							this.emit('addLocalParticipant', {
 								tid: generateUUID(),
 								id: handle.handleId,
-								userId: handle.userId,
+								userId: decodeJanusDisplay(handle.userId)?.userId,
 								track,
 								stream: config.stream,
 								adding: true,
@@ -1910,7 +2018,7 @@ class RoomSession {
 								this.emit('addLocalParticipant', {
 									tid:generateUUID(),
 									id: handle.handleId,
-									userId: handle.userId,
+									userId: decodeJanusDisplay(handle.userId)?.userId,
 									track: ev.target,
 									stream: config.stream,
 									adding: false,
@@ -1927,7 +2035,7 @@ class RoomSession {
 					this.emit('addLocalParticipant', {
 						tid: generateUUID(),
 						id: handle.handleId,
-						userId: handle.userId,
+						userId: decodeJanusDisplay(handle.userId)?.userId,
 						stream: null,
 						adding: false,
 						constructId: this.constructId,
@@ -1952,10 +2060,10 @@ class RoomSession {
 	}
 
 	unpublishLocal(dontWait = false) {
-		return this._isPublished
+		return this.isPublished
 			? this.sendMessage(this.handleId, {body: {"request": "unpublish"}}, dontWait)
 				.finally(r => {
-					this._isPublished = false;
+					this.isPublished = false;
 					this.emit('published', {status: false, hasStream: false});
 					return r
 				})
@@ -2026,6 +2134,11 @@ class RoomSession {
 		return this._talkbackIds;
 	}
 
+	setRoomType(type = 'watchparty') {
+		this._roomType = type;
+		return this._roomType;
+	}
+
 }
 
 export default Room;