@reactoo/watchtogether-sdk-js 2.5.32 → 2.5.35

package/src/modules/wt-room.js

@@ -143,10 +143,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 +158,9 @@ class RoomSession {
 		this._observerIds = [];
 		this._talkbackIds = [];
 		this._instuctorId = null;
-		this._hasJoined = false;
-		this._isStreaming = false;
-		this._isPublished = false;
 		this._isDataChannelOpen = false;
-		this._dataChannelTimeoutId = null;
-		this._messageTimeoutId = null;
+		this._abortController = null;
+
 		this.isAudioMuted = false;
 		this.isVideoMuted = false;
 		this.isVideoEnabled = false;
@@ -321,12 +320,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 +359,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 +378,8 @@ class RoomSession {
 	}
 
 	_connectionClosed() {
-		if (this.disconnectingPromise || this.connectingPromise) {
+
+		if (!this.isConnected || this.isConnecting || this.isDisconnecting) {
 			return;
 		}
 
@@ -484,7 +502,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 +611,7 @@ class RoomSession {
 					}
 					if (result["status"] === 'started') {
 						this.emit('streaming', true);
-						this._isStreaming = true;
+						this.isStreaming = true;
 					}
 				}
 
@@ -775,7 +793,7 @@ 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});
 				} else {
@@ -836,10 +854,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 +867,8 @@ class RoomSession {
 
 	_reconnect() {
 
-		if (this.connectingPromise) {
-			return this.connectingPromise;
+		if (this.isReclaiming) {
+			return Promise.resolve();
 		}
 
 		if (this.ws) {
@@ -860,25 +878,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 +918,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) {
 
-		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;
@@ -918,15 +951,29 @@ class RoomSession {
 		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 +988,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,46 +1030,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 => {
@@ -1032,38 +1097,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();
@@ -1072,15 +1138,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);
-				this.emit('disconnect', _isStreaming);
-				this.disconnectingPromise = null;
+				this.emit('disconnect', isStreaming);
 				return Promise.resolve('Disconnected');
 			});
-
-		return this.disconnectingPromise;
 	}
 
 	destroy() {
@@ -1710,6 +1774,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);
@@ -1874,23 +1946,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 => {
@@ -1954,10 +2043,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
 				})