@reactoo/watchtogether-sdk-js 2.7.98 → 2.8.0-beta.2

package/src/modules/wt-room-sfu.js

@@ -201,6 +201,23 @@ class RoomSession {
 	#subscriberHandle = null;
 	#subscriberJoinPromise = null;
 
+	// Configuration for simulcast quality selection
+	#rtcStatsConfig = {
+		// Network thresholds
+		packetLossThreshold: 3.0,       // Percentage of packet loss to trigger downgrade
+		jitterBufferThreshold: 100,     // ms of jitter buffer delay to trigger downgrade
+		roundTripTimeThreshold: 250,    // ms of RTT to trigger downgrade
+		frameDropRateThreshold: 5,      // Percentage of frame drops to trigger downgrade
+		freezeLengthThreshold: 0.7, 		// 70% of freeze time for current monitored period
+		// Hysteresis to prevent rapid switching (ms)
+		switchCooldown: 15000, // Min time between switches
+		switchCooldownForFreeze: 3000,
+		historySize: 60000,           // Ms of history to keep
+		badBandwidthThresholdMultiplier: 0.8,  // 80% of required bitrate
+		// Stability thresholds
+		stableNetworkTime: 10000, 	   // Time in ms to consider network stable
+	};
+
 
 	constructor(constructId = null, type = 'reactooroom', options = {}) {
 
@@ -262,7 +279,7 @@ class RoomSession {
 
 		this.isSupposeToBeConnected = false;
 		this.isConnecting = false;
-		this.isEstablishingConnection = false; //TODO: get rid of this?
+		this.isEstablishingConnection = false;
 		this.isDisconnecting = false;
 		this.isConnected = false;
 		this.isPublished = false;
@@ -278,7 +295,6 @@ class RoomSession {
 		this._longPollTimeout = 60000;
 		this._maxev = 10;
 		this._keepAliveId = null;
-		this._participants = [];
 		this._restrictSubscribeToUserIds = []; // all if empty
 		this._talkIntercomChannels = ['participants'];
 		this._listenIntercomChannels = ['participants'];
@@ -295,6 +311,7 @@ class RoomSession {
 		if (this.options.debug) {
 			this.#enableDebug();
 		}
+
 	}
 
 	#httpAPICall = function(url, options) {
@@ -772,7 +789,7 @@ class RoomSession {
 		if (!handle) {
 			this.emit('error', {
 				type: 'warning',
-				id: 15,
+				id: 1,
 				message: 'id non-existent',
 				data: [handleId, 'updateTransceiverMap']
 			});
@@ -864,9 +881,9 @@ class RoomSession {
 			})
 			.catch(json => {
 				if (json && json["error"]) {
-					return Promise.reject({type: 'warning', id: 1, message: 'sendMessage failed', data: json["error"]})
+					return Promise.reject({type: 'warning', id: 2, message: 'sendMessage failed', data: json["error"]})
 				} else {
-					return Promise.reject({type: 'warning', id: 1, message: 'sendMessage failed', data: json});
+					return Promise.reject({type: 'warning', id: 3, message: 'sendMessage failed', data: json});
 				}
 			})
 	}
@@ -907,7 +924,7 @@ class RoomSession {
 				this._abortController.signal.removeEventListener('abort', abortResponse);
 				clearTimeout(messageTimeoutId);
 				this.ws.removeEventListener('message', parseResponse);
-				reject({type: 'warning', id: 17, message: 'connection cancelled'})
+				reject({type: 'warning', id: 4, message: 'connection cancelled'})
 			};
 
 			let parseResponse = (event) => {
@@ -921,7 +938,7 @@ class RoomSession {
 						if (json?.error?.code == 403) {
 							this.disconnect();
 						}
-						reject({type: 'error', id: 2, message: 'send failed', data: json, requestData});
+						reject({type: 'error', id: 5, message: 'send failed', data: json, requestData});
 					} else {
 						resolve(json);
 					}
@@ -939,12 +956,12 @@ class RoomSession {
 					messageTimeoutId = setTimeout(() => {
 						this.ws.removeEventListener('message', parseResponse);
 						this._abortController.signal.removeEventListener('abort', abortResponse);
-						reject({type: 'warning', id: 3, message: 'send timeout', data: requestData});
+						reject({type: 'warning', id: 6, message: 'send timeout', data: requestData});
 					}, this._sendMessageTimeout);
 					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});
+					reject({type: 'warning', id: 7, message: 'No connection to WebSockets', data: requestData});
 				}
 			}
 		})
@@ -1006,7 +1023,9 @@ class RoomSession {
 
 		this.#reconnect()
 			.catch(e => {
-				this.disconnect();
+				if(e.type !== 'warning') {
+					this.disconnect();
+				}
 				this.emit('error', e)
 			});
 	}
@@ -1024,14 +1043,14 @@ class RoomSession {
 				if (json["janus"] !== 'ack') {
 					this.emit('error', {
 						type: 'warning',
-						id: 5,
+						id: 8,
 						message: 'keepalive response suspicious',
 						data: json["janus"]
 					});
 				}
 			})
 			.catch((e) => {
-				this.emit('error', {type: 'warning', id: 6, message: 'keepalive dead', data: e});
+				this.emit('error', {type: 'warning', id: 9, message: 'keepalive dead', data: e});
 				this.#connectionClosed();
 			});
 
@@ -1077,10 +1096,15 @@ class RoomSession {
 			let candidate = json["candidate"];
 			let config = handle.webrtcStuff;
 			if (config.pc && config.remoteSdp) {
+
 				if (!candidate || candidate.completed === true) {
-					config.pc.addIceCandidate(null);
+					config.pc.addIceCandidate(null).catch((e) => {
+						this._log('Error adding null candidate', e);
+					});
 				} else {
-					config.pc.addIceCandidate(candidate);
+					config.pc.addIceCandidate(candidate).catch((e) => {
+						this._log('Error adding candidate', e);
+					});
 				}
 			} else {
 				if (!config.candidates) {
@@ -1131,7 +1155,8 @@ class RoomSession {
 				let leaving = msg["leaving"];
 				let kicked = msg["kicked"];
 				let substream = msg["substream"];
-				let temporal = msg["temporal"];
+				let temporal = msg["temporal"] ?? msg["temporal_layer"];
+				let spatial = msg["spatial_layer"];
 				let joining = msg["joining"];
 				let unpublished = msg["unpublished"];
 				let error = msg["error"];
@@ -1143,7 +1168,7 @@ class RoomSession {
 					this.isConnected = true;
 					
 					this._log('We have successfully joined Room',msg);
-
+					this.emit('joined', true, this.constructId);
 					// initial events
 
 					attendees.forEach((attendee) => {
@@ -1157,8 +1182,6 @@ class RoomSession {
 					});
 
 					// end of initial events
-
-					this.emit('joined', true, this.constructId);
 					this.#emitLocalFeedUpdate();
 					this.#updateAvailablePublishersTrackData(list);
 					this.#updateSubscriptions()
@@ -1243,7 +1266,7 @@ class RoomSession {
 					if (error) {
 						this.emit('error', {
 							type: 'error',
-							id: 7,
+							id: 10,
 							message: 'local participant error',
 							data: [sender, msg]
 						});
@@ -1285,8 +1308,9 @@ class RoomSession {
 			let event = msg["videoroom"];
 			let error = msg["error"];
 			let substream = msg["substream"];
+			let temporal = msg["temporal"] ?? msg["temporal_layer"];
+			let spatial = msg["spatial_layer"];
 			let mid = msg["mid"];
-			let temporal = msg["temporal"];
 
 			if(substream !== undefined && substream !== null) {
 				this._log('Substream: ', sender, mid, substream);
@@ -1316,7 +1340,7 @@ class RoomSession {
 			}
 
 			if (error) {
-				this.emit('error', {type: 'warning', id: 8, message: 'remote participant error', data: [sender, msg]});
+				this.emit('error', {type: 'warning', id: 11, message: 'remote participant error', data: [sender, msg]});
 			}
 
 			if (jsep) {
@@ -1349,7 +1373,7 @@ class RoomSession {
 
 			this.emit('error', {
 				type: 'warning',
-				id: 9,
+				id: 12,
 				message: 'data event warning',
 				data: [handleId, data]
 			});
@@ -1373,7 +1397,7 @@ class RoomSession {
 			try {
 				d = JSON.parse(data)
 			} catch (e) {
-				this.emit('error', {type: 'warning', id: 10, message: 'data message parse error', data: [handleId, e]});
+				this.emit('error', {type: 'warning', id: 13, message: 'data message parse error', data: [handleId, e]});
 				return;
 			}
 			this.emit('data', d);
@@ -1407,9 +1431,10 @@ class RoomSession {
 					streamMap: {}, // id to sources to mids?
 					availablePublishers: [],
 					subscribeMap: [], // subscribed to [id][mid]
-
-					// figure this out below
-					stats: {}
+					stats: {},
+					currentLayers : new Map(),
+					qualityHistory : new Map(),
+					lastSwitchTime : new Map(),
 				}
 			};
 		})
@@ -1511,8 +1536,10 @@ class RoomSession {
 			streamMap: {}, // id to sources to mids?
 			availablePublishers: [],
 			subscribeMap: [], // subscribed to [id][mid]
-			// figure this out below
-			stats: {}
+			stats: {},
+			currentLayers : new Map(),
+			qualityHistory : new Map(),
+			lastSwitchTime : new Map(),
 		}
 
 		if(this.#publisherHandle && handleId === this.#publisherHandle.handleId) {
@@ -1626,8 +1653,7 @@ class RoomSession {
 	async #webSocketConnection(reclaim = false)  {
 
 		if(this.isEstablishingConnection) {
-			this.emit('error',  {type: 'warning', id: 16, message: 'connection already in progress'});
-			return;
+			return Promise.reject({type: 'warning', id: 14, message: 'connection already in progress'});
 		}
 
 		this.isEstablishingConnection = true;
@@ -1652,7 +1678,7 @@ class RoomSession {
 				this.ws.removeEventListener('message', this.__handleWsEventsBoundFn);
 				this.ws.onopen = null;
 				this.ws.onerror = null;
-				reject({type: 'warning', id: 17, message: 'Connection cancelled'});
+				reject({type: 'warning', id: 15, message: 'Connection cancelled'});
 			};
 
 			this.ws = new WebSocket(this.server, 'janus-protocol');
@@ -1669,7 +1695,7 @@ class RoomSession {
 							resolve(this);
 						})
 						.catch(error => {
-							reject({type: error?.type === 'warning' ? 'warning' : 'error', id: 13, message: 'connection error', data: error})
+							reject({type: error?.type === 'warning' ? 'warning' : 'error', id: 16, message: 'connection error', data: error})
 						})
 						.finally(() => {
 							this.isEstablishingConnection = false;
@@ -1683,7 +1709,7 @@ class RoomSession {
 							resolve(json);
 						})
 						.catch(error => {
-							reject({type: 'error', id: 11, message: 'reconnection error', data: error})
+							reject({type: 'error', id: 17, message: 'reconnection error', data: error})
 						})
 						.finally(() => {
 							this.isEstablishingConnection = false;
@@ -1693,7 +1719,7 @@ class RoomSession {
 
 			this.ws.onerror = (e) => {
 				this._abortController.signal.removeEventListener('abort', abortConnect);
-				reject({type: 'error', id: 14, message: 'ws connection error', data: e});
+				reject({type: 'error', id: 18, message: 'ws connection error', data: e});
 			}
 
 			this._abortController.signal.addEventListener('abort', abortConnect);
@@ -1704,7 +1730,7 @@ class RoomSession {
 	async #httpConnection(reclaim = false) {
 
 		if(this.isEstablishingConnection) {
-			this.emit('error',  {type: 'warning', id: 16, message: 'connection already in progress'});
+			this.emit('error',  {type: 'warning', id: 19, message: 'connection already in progress'});
 			return;
 		}
 
@@ -1729,7 +1755,7 @@ class RoomSession {
 					return this;
 				})
 				.catch(error => {
-					return Promise.reject({type: error?.type === 'warning' ? 'warning' : 'error', id: 13, message: 'connection error', data: error})
+					return Promise.reject({type: error?.type === 'warning' ? 'warning' : 'error', id: 20, message: 'connection error', data: error})
 				})
 				.finally(() => {
 					this.isEstablishingConnection = false;
@@ -1744,7 +1770,7 @@ class RoomSession {
 					return this;
 				})
 				.catch(error => {
-					return Promise.reject({type: 'error', id: 11, message: 'reconnection error', data: error})
+					return Promise.reject({type: 'error', id: 21, message: 'reconnection error', data: error})
 				})
 				.finally(() => {
 					this.isEstablishingConnection = false;
@@ -1752,10 +1778,39 @@ class RoomSession {
 		}
 	}
 
+	async #waitForConnectEvent() {
+		return new Promise((resolve, reject) => {
+			let timeoutId = null;
+			if(this.isConnected) {
+				return resolve();
+			}
+			const cleanup = () => {
+				clearTimeout(timeoutId);
+				this.off('joined', _resolve);
+				this._abortController.signal.removeEventListener('abort', _rejectAbort);
+			}
+			let _resolve = () => {
+				cleanup();
+				resolve();
+			}
+			let _rejectAbort = () => {
+				cleanup();
+				reject({type: 'warning', id: 43, message: 'Connection cancelled'})
+			}
+			let _rejectTimeout = () => {
+				cleanup();
+				reject({type: 'warning', id: 44, message: 'Connection timeout'})
+			}
+			this.once('joined', _resolve);
+			timeoutId = setTimeout(_rejectTimeout, 10000)
+			this._abortController.signal.addEventListener('abort', _rejectAbort);
+		})
+	}
+
 	async #reconnect() {
 
 		if (this.isConnecting) {
-			return Promise.reject({type: 'warning', id: 16, message: 'connection already in progress'});
+			return Promise.reject({type: 'warning', id: 22, message: 'connection already in progress'});
 		}
 
 		this.isConnecting = true;
@@ -1798,7 +1853,7 @@ class RoomSession {
 		this.isSupposeToBeConnected = true;
 
 		if (this.isConnecting) {
-			this.emit('error',  {type: 'warning', id: 16, message: 'connection already in progress'});
+			this.emit('error',  {type: 'warning', id: 23, message: 'connection already in progress'});
 			return
 		}
 
@@ -1826,17 +1881,14 @@ class RoomSession {
 		this.simulcastSettings = structuredClone(simulcastSettings);
 		this.useWebsockets = this.protocol === 'ws' || this.protocol === 'wss';
 
-		// sort simulcast bitrates
-		if(this.simulcastSettings && typeof this.simulcastSettings === 'object' && Object.keys(this.simulcastSettings).length) {
-			Object.keys(this.simulcastSettings).forEach(k => {
-				this.simulcastSettings[k].bitrates = this.simulcastSettings[k].bitrates.sort((a, b) => {
-					if(a.maxBitrate === b.maxBitrate) {
-						return a.maxFramerate - b.maxFramerate;
-					}
-					return a.maxBitrate - b.maxBitrate;
-				});
-			});
-		}
+		// fixing wrong order
+		Object.keys(this.simulcastSettings).forEach(source => {
+			const wrongOrder = this.simulcastSettings[source].bitrates[0].rid === 'l';
+			if(wrongOrder) {
+				this.simulcastSettings[source].bitrates = this.simulcastSettings[source].bitrates.reverse();
+				this.simulcastSettings[source].defaultSubstream = 2 - this.simulcastSettings[source].defaultSubstream
+			}
+		})
 
 		this.isConnecting = true;
 		this.emit('joining', true);
@@ -1856,6 +1908,7 @@ class RoomSession {
 			this.#subscriberHandle = await this.#createHandle();
 
 			await this.#joinAsPublisher(this.roomId,  this.pin, this.userId, this.display);
+			await this.#waitForConnectEvent();
 
 		} catch (error) {
 			this.emit('error', error);
@@ -1965,7 +2018,7 @@ class RoomSession {
 		if (!handle) {
 			this.emit('error', {
 				type: 'error',
-				id: 15,
+				id: 24,
 				message: 'id non-existent',
 				data: [handleId, 'create rtc connection']
 			});
@@ -2151,9 +2204,8 @@ class RoomSession {
 						event.track.onended = (ev) => {
 							this._log('Remote track ended', ev);
 
-							// TODO: check this
-
 							const trackIndex = config?.tracks?.findIndex(t => t.id === ev.target.id);
+
 							if(trackIndex > -1) {
 								config.tracks.splice(trackIndex, 1);
 							}
@@ -2253,7 +2305,7 @@ class RoomSession {
 
 		let handle = this.#getHandle(handleId);
 		if (!handle) {
-			return Promise.reject({type: 'warning', id: 15, message: 'id non-existent', data: [handleId, 'rtc peer']});
+			return Promise.reject({type: 'warning', id: 25, message: 'id non-existent', data: [handleId, 'rtc peer']});
 		}
 
 		var config = handle.webrtcStuff;
@@ -2272,9 +2324,13 @@ class RoomSession {
 						for (var i = 0; i < config.candidates.length; i++) {
 							var candidate = config.candidates[i];
 							if (!candidate || candidate.completed === true) {
-								config.pc.addIceCandidate(null);
+								config.pc.addIceCandidate(null).catch((e) => {
+									this._log('Error adding null candidate', e);
+								});;
 							} else {
-								config.pc.addIceCandidate(candidate);
+								config.pc.addIceCandidate(candidate).catch((e) => {
+									this._log('Error adding candidate', e);
+								});
 							}
 						}
 						config.candidates = [];
@@ -2283,10 +2339,10 @@ class RoomSession {
 					return true;
 				})
 				.catch((e) => {
-					return Promise.reject({type: 'warning', id: 32, message: 'rtc peer', data: [handleId, e]});
+					return Promise.reject({type: 'warning', id: 26, message: 'rtc peer', data: [handleId, e]});
 				});
 		} else {
-			return Promise.reject({type: 'warning', id: 22, message: 'rtc peer', data: [handleId, 'invalid jsep']});
+			return Promise.reject({type: 'warning', id: 27, message: 'rtc peer', data: [handleId, 'invalid jsep']});
 		}
 	}
 
@@ -2305,6 +2361,9 @@ class RoomSession {
 
 		config.isIceRestarting = true;
 
+		// removing this so we can cache ice candidates again
+		config.remoteSdp = null;
+
 		if (this.#publisherHandle.handleId === handleId) {
 			this._log('Performing local ICE restart');
 			let hasAudio = !!(config.stream && config.stream.getAudioTracks().length > 0);
@@ -2325,7 +2384,7 @@ class RoomSession {
 				})
 				.catch((e) => {
 					config.isIceRestarting = false;
-					this.emit('error', {type: 'warning', id: 28, message: 'iceRestart failed', data: e});
+					this.emit('error', {type: 'error', id: 28, message: 'iceRestart failed', data: e});
 				});
 		} else {
 			this._log('Performing remote ICE restart', handleId);
@@ -2430,7 +2489,7 @@ class RoomSession {
 		if (!handle) {
 			return Promise.reject({
 				type: 'warning',
-				id: 15,
+				id: 29,
 				message: 'id non-existent',
 				data: [handleId, 'createAO', type]
 			});
@@ -2464,7 +2523,7 @@ class RoomSession {
 					.catch((e) => {
 						return Promise.reject({
 							type: 'warning',
-							id: 24,
+							id: 30,
 							message: 'setLocalDescription',
 							data: [handleId, e]
 						})
@@ -2491,7 +2550,7 @@ class RoomSession {
 
 				return _p.then(() => jsep)
 			}, (e) => {
-				return Promise.reject({type: 'warning', id: 25, message: methodName, data: [handleId, e]})
+				return Promise.reject({type: 'warning', id: 31, message: methodName, data: [handleId, e]})
 			});
 
 	}
@@ -2501,7 +2560,7 @@ class RoomSession {
 		if (!handle) {
 			return Promise.reject({
 				type: 'warning',
-				id: 15,
+				id: 32,
 				message: 'id non-existent',
 				data: [handleId, 'publish remote participant']
 			})
@@ -2512,7 +2571,6 @@ class RoomSession {
 		let config = handle.webrtcStuff;
 
 		if (jsep) {
-
 			return config.pc.setRemoteDescription(jsep)
 				.then(() => {
 					config.remoteSdp = jsep.sdp;
@@ -2522,10 +2580,14 @@ class RoomSession {
 							var candidate = config.candidates[i];
 							if (!candidate || candidate.completed === true) {
 								// end-of-candidates
-								config.pc.addIceCandidate(null);
+								config.pc.addIceCandidate(null).catch(e => {
+									this._log('Error adding null candidate', e);
+								});
 							} else {
 								// New candidate
-								config.pc.addIceCandidate(candidate);
+								config.pc.addIceCandidate(candidate).catch(e => {
+									this._log('Error adding candidate', e);
+								});
 							}
 						}
 						config.candidates = [];
@@ -2539,7 +2601,7 @@ class RoomSession {
 							if (!_jsep) {
 								this.emit('error', {
 									type: 'warning',
-									id: 19,
+									id: 33,
 									message: 'publish remote participant',
 									data: [handleId, 'no jsep']
 								});
@@ -2552,7 +2614,7 @@ class RoomSession {
 						})
 				}, (e) => Promise.reject({
 					type: 'warning',
-					id: 23,
+					id: 34,
 					message: 'setRemoteDescription',
 					data: [handleId, e]
 				}));
@@ -2564,7 +2626,7 @@ class RoomSession {
 	}
 	
 	#republishOnTrackEnded(source) {
-		let handle = this.#getHandle(this.#publisherHandle.handleId);
+		let handle = this.#publisherHandle;
 		if (!handle) {
 			return;
 		}
@@ -2592,10 +2654,10 @@ class RoomSession {
 	
 	async publishLocal(stream = null, source = 'camera0') {
 
-		if(!this.isConnected) {
+		if(!this.isConnected || this.isDisconnecting) {
 			return {
 				type: 'warning',
-				id: 18,
+				id: 35,
 				message: 'Either not connected or disconnecting',
 			}
 		}
@@ -2603,7 +2665,7 @@ class RoomSession {
 		if(stream?.getVideoTracks()?.length > 1) {
 			return {
 				type: 'warning',
-				id: 30,
+				id: 36,
 				message: 'multiple video tracks not supported',
 				data: null
 			}
@@ -2612,7 +2674,7 @@ class RoomSession {
 		if(stream?.getAudioTracks()?.length > 1) {
 			return {
 				type: 'warning',
-				id: 30,
+				id: 37,
 				message: 'multiple audio tracks not supported',
 				data: null
 			}
@@ -2622,7 +2684,7 @@ class RoomSession {
 		if (!handle) {
 			return {
 				type: 'error',
-				id: 31,
+				id: 38,
 				message: 'no local handle, connect before publishing',
 				data: null
 			}
@@ -2833,24 +2895,24 @@ class RoomSession {
 			if(this._isDataChannelOpen !== true) {
 				await new Promise((resolve, reject) => {
 					let dataChannelTimeoutId = null;
+					let _cleanup = () => {
+						clearTimeout(dataChannelTimeoutId);
+						this._abortController.signal.removeEventListener('abort', _rejectAbort);
+						this.off('dataChannel', _resolve, this);
+					}
 					let _resolve = (val) => {
 						if (val) {
-							clearTimeout(dataChannelTimeoutId);
-							this._abortController.signal.removeEventListener('abort', _rejectAbort);
-							this.off('dataChannel', _resolve, this);
+							_cleanup();
 							resolve(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});
+						_cleanup();
+						reject({type: 'error', id: 39, message: 'Data channel did not open', data: null});
 					}
 					let _rejectAbort = () => {
-						this._abortController.signal.removeEventListener('abort', _rejectAbort);
-						clearTimeout(dataChannelTimeoutId);
-						this.off('dataChannel', _resolve, this);
-						reject({type: 'warning', id: 17, message: 'Connection cancelled'})
+						_cleanup();
+						reject({type: 'warning', id: 40, message: 'Connection cancelled'})
 					}
 					dataChannelTimeoutId = setTimeout(_rejectTimeout, 10000);
 					this._abortController.signal.addEventListener('abort', _rejectAbort);
@@ -2880,11 +2942,11 @@ class RoomSession {
 	}
 
 	toggleAudio(value = null, source = 'camera0', mid) {
-		let handle = this.#getHandle(this.#publisherHandle.handleId);
+		let handle = this.#publisherHandle;
 		if (!handle) {
 			this.emit('error', {
 				type: 'warning',
-				id: 21,
+				id: 41,
 				message: 'no local id, connect first', data: null
 			});
 			return;
@@ -2917,11 +2979,11 @@ class RoomSession {
 	}
 
 	toggleVideo(value = null, source = 'camera0', mid) {
-		let handle = this.#getHandle(this.#publisherHandle.handleId);
+		let handle = this.#publisherHandle;
 		if (!handle) {
 			this.emit('error', {
 				type: 'warning',
-				id: 21,
+				id: 42,
 				message: 'no local id, connect first', data: null
 			});
 			return;
@@ -2969,10 +3031,38 @@ class RoomSession {
 
 	#setSelectedSubstream(sender, mid, substream) {
 
+		const handle = this.#getHandle(sender);
+
+		if(!handle) {
+			return;
+		}
+
+		handle.webrtcStuff.lastSwitchTime.set(mid, Date.now());
+
+		if(!handle.webrtcStuff.currentLayers.has(mid)) {
+			handle.webrtcStuff.currentLayers.set(mid, {mid, substream: substream, temporal: -1});
+		}
+		else {
+			handle.webrtcStuff.currentLayers.get(mid).substream = substream;
+		}
 	}
 
 	#setSelectedTemporal(sender, mid, temporal) {
 
+		const handle = this.#getHandle(sender);
+
+		if(!handle) {
+			return;
+		}
+
+		handle.webrtcStuff.lastSwitchTime.set(mid, Date.now());
+
+		if(!handle.webrtcStuff.currentLayers.has(mid)) {
+			handle.webrtcStuff.currentLayers.set(mid, {mid, substream: -1, temporal: temporal});
+		}
+		else {
+			handle.webrtcStuff.currentLayers.get(mid).temporal = temporal;
+		}
 	}
 
 	#shouldEmitFeedUpdate(parsedDisplay = {}) {
@@ -3084,8 +3174,9 @@ class RoomSession {
 		return await this.#updateSubscriptions();
 	}
 
-	async selectSubStream(id, substream = 2, source, mid) {
-		this._log('Select substream called for id:', id, 'Source or mid:', source ? source : mid, 'Substream:', substream);
+	async selectSubStream(id, substream = 2, temporal = 2, source, mid) {
+
+		this._log('Select substream called for id:', id, 'Source, mid:', source, mid, 'Substream:', substream, 'Temporal:', temporal);
 
 		let config = this.#subscriberHandle.webrtcStuff;
 		return new Promise((resolve, reject) => {
@@ -3150,7 +3241,7 @@ class RoomSession {
 							"request": "configure",
 							"streams": [
 								{
-									mid, substream: parseInt(substream)
+									mid, substream: parseInt(substream), temporal: parseInt(temporal)
 								}
 							]
 						}
@@ -3165,11 +3256,406 @@ class RoomSession {
 		});
 	}
 
-	#getStats(type = null) {
+	async #getStats(type = 'video') {
+
+		let handle = this.#subscriberHandle;
+		if(handle) {
+
+			const tracks =  handle?.webrtcStuff?.tracks.filter(track =>  track.kind === type);
+			const transceivers = handle?.webrtcStuff?.pc?.getTransceivers();
+			return await tracks.reduce(async (prevPromise, track) => {
+
+				const results = await prevPromise;
+				const mid = transceivers.find(t =>
+					t.receiver?.track?.id === track.id || t.sender?.track?.id === track.id
+				)?.mid;
+				const transceiverData = this.#getTransceiverDataByMid(mid);
+
+				const id = transceiverData?.feed_id ?? null;
+				const display = transceiverData?.feed_display ?? null;
+				const description = transceiverData.feed_description ?? null;
+
+				return handle.webrtcStuff.pc.getStats(track)
+					.then(stats => {
+
+						const parsedStats = {
+							inboundRtpStats: null,
+							remoteOutboundRtpStats: null,
+							candidatePairStats: null,
+							packetLoss: 0,
+							jitter: 0,
+							rtt: 0,
+							currentBandwidth: 0,
+							framesDecoded: 0,
+							framesDropped: 0,
+							framesReceived: 0,
+							frameRate: 0,
+							freezeCount: 0,
+							totalFreezesDuration: 0,
+						};
+
+						let selectedCandidatePairId = null;
+						
+						// First pass to identify the selected candidate pair ID from transport
+						stats.forEach(stat => {
+							if (stat.type === 'transport' && stat.selectedCandidatePairId) {
+								selectedCandidatePairId = stat.selectedCandidatePairId;
+							}
+						});
+
+						// Second pass to process all stats
+						stats.forEach(stat => {
+							// Inbound RTP stats processing
+							if (stat.type === 'inbound-rtp' && !stat.isRemote) {
+								parsedStats.inboundRtpStats = stat;
+								
+								// Consistent unit conversion - convert seconds to milliseconds for jitter
+								parsedStats.jitter = stat.jitter ? Math.round(stat.jitter * 1000) : 0;
+								
+								parsedStats.framesDecoded = stat.framesDecoded || 0;
+								parsedStats.framesDropped = stat.framesDropped || 0;
+								parsedStats.framesReceived = stat.framesReceived || 0;
+								parsedStats.frameRate = stat.framesPerSecond || 0;
+								parsedStats.freezeCount = stat.freezeCount || 0;
+								parsedStats.totalFreezesDuration = stat.totalFreezesDuration || 0;
+
+								// Robust packet loss calculation
+								if (stat.packetsLost !== undefined && stat.packetsReceived !== undefined) {
+									const totalPackets = stat.packetsLost + stat.packetsReceived;
+									if (totalPackets > 0) {
+										// Calculate as percentage and round to 2 decimal places for accuracy
+										parsedStats.packetLoss = Number(((stat.packetsLost / totalPackets) * 100).toFixed(2));
+									} else {
+										parsedStats.packetLoss = 0;
+									}
+								} else {
+									parsedStats.packetLoss = 0;
+								}
+							}
+
+							if (stat.type === 'remote-outbound-rtp') {
+								parsedStats.remoteOutboundRtpStats = stat;
+							}
+
+							// Find active candidate pair based on the selectedCandidatePairId
+							if (stat.type === 'candidate-pair' && 
+								(stat.selected || stat.id === selectedCandidatePairId)) {
+								parsedStats.candidatePairStats = stat;
+								
+								// RTT calculation from candidate pair
+								if (stat.currentRoundTripTime) {
+									parsedStats.rtt = Math.round(stat.currentRoundTripTime * 1000); // Convert to ms
+								} else if (stat.totalRoundTripTime && stat.responsesReceived > 0) {
+									parsedStats.rtt = Math.round((stat.totalRoundTripTime / stat.responsesReceived) * 1000);
+								}
+							}
+						});
+
+						// Additional fallback for bandwidth estimation from inboundRtp
+						if (parsedStats.currentBandwidth === 0 && parsedStats.inboundRtpStats) {
+							const stat = parsedStats.inboundRtpStats;
+							// Simple estimation based on received bytes over time
+							if (stat.bytesReceived && stat.timestamp && handle.webrtcStuff.stats && 
+								handle.webrtcStuff.stats[stat.id]) {
+								const prevStat = handle.webrtcStuff.stats[stat.id];
+								const timeDiff = stat.timestamp - prevStat.timestamp;
+								if (timeDiff > 0) {
+									const bitrateBps = 8000 * (stat.bytesReceived - prevStat.bytesReceived) / timeDiff;
+									parsedStats.currentBandwidth = Math.floor(bitrateBps / 1000);
+								}
+							}
+							// Store current stats for next calculation
+							if (!handle.webrtcStuff.stats) {
+								handle.webrtcStuff.stats = {};
+							}
+							handle.webrtcStuff.stats[stat.id] = { ...stat };
+						}
+
+						return [...results, {
+                            stats: Object.fromEntries(stats), // Convert MapLike object to regular object
+                            parsedStats,
+                            id,
+                            display,
+                            description,
+                            mid
+                        }];
+					});
+			}, Promise.resolve([]))
+		}
+        
+        return [];
+	}
+
+	#adjustVideoQualitySettings(stats) {
+
+		// Only proceed if we have stats to work with and simulcast is enabled
+		if (!stats?.length || !this.simulcast) {
+			return;
+		}
+
+		const handle = this.#subscriberHandle;
+		const webrtcStuff = handle?.webrtcStuff;
+
+		if(!handle) {
+			return
+		}
+
+		const now = Date.now();
+		
+		// Process each video stream's stats
+		for (const stat of stats) {
+			// Skip if no parsedStats or missing essential data
+			if (!stat.parsedStats || !stat.mid || !stat.id || !stat.description) {
+				continue;
+			}
+			
+			const mid = stat.mid;
+			const feedId = stat.id;
+			
+			// Parse description to get simulcast settings
+			let simulcastConfig = null;
+			try {
+				const description = typeof stat.description === 'string' ? 
+					JSON.parse(stat.description) : stat.description;
+				
+				if (description?.simulcastBitrates) {
+					simulcastConfig = {
+						bitrates: description.simulcastBitrates,
+						defaultSubstream: 0 // Default to highest quality initially
+					};
+				}
+			} catch (e) {
+				this._log('Error parsing simulcast config:', e);
+				continue;
+			}
+
+			// Skip if no simulcast config or we don't have layer tracking for this mid
+			if (!simulcastConfig || !webrtcStuff?.currentLayers?.has(mid)) {
+				continue;
+			}
+			
+			const currentLayer = webrtcStuff?.currentLayers?.get(mid);
+			const currentSubstream = currentLayer.substream;
+			const currentTemporal = currentLayer.temporal === -1 ? 2 : currentLayer.temporal;
+			
+			// Initialize quality history for this mid if needed
+			if (!webrtcStuff.qualityHistory.has(mid)) {
+				webrtcStuff.qualityHistory.set(mid, []);
+				webrtcStuff.lastSwitchTime.set(mid, 0);
+			}
+			
+			// Extract network stats
+			const { 
+				packetLoss, 
+				jitter, 
+				rtt, 
+				currentBandwidth,
+				framesDropped,
+				framesReceived,
+				freezeCount,
+				totalFreezesDuration
+			} = stat.parsedStats;
+			
+			// Calculated stats (like frame drop rate)
+			const frameDropRate = framesReceived ? (framesDropped / framesReceived * 100) : 0;
+
+			// Add current quality measurement to history
+			const qualityMeasure = {
+				timestamp: now,
+				packetLoss,
+				jitter,
+				rtt,
+				currentBandwidth,
+				frameDropRate,
+				freezeCount,
+				totalFreezesDuration
+			};
+
+			// Determine whether we need to switch qualities
+			let targetSubstream = currentSubstream;
+
+			const history = webrtcStuff.qualityHistory.get(mid);
+			history.push(qualityMeasure);
+			
+			// Keep only recent history
+			const recentHistory = history.filter(item => now - item.timestamp < this.#rtcStatsConfig.historySize);
+			webrtcStuff.qualityHistory.set(mid, recentHistory);
+
+			let totalFreezesDurationTillLast = null;
+
+			// if we can calculate the freeze duration for last measured segment
+
+			if(recentHistory.length - 2 > -1) {
 
+				totalFreezesDurationTillLast = totalFreezesDuration - (recentHistory?.[recentHistory.length - 2]?.totalFreezesDuration ?? 0);
+				if(totalFreezesDurationTillLast * 1000 >= this.#rtcStatsConfig.freezeLengthThreshold * this._statsInterval) {
+					this._log(`Freezes detected for ${mid} - totalFreezesDuration: ${totalFreezesDuration}, totalFreezesDurationTillLast: ${totalFreezesDurationTillLast}`);
+					if (currentSubstream > 0) {
+						targetSubstream = currentSubstream - 1;
+					}
+
+					// Apply the layer change if needed
+					// Don't change layers if we haven't waited enough since last switch
+
+					if (targetSubstream !== currentSubstream && now - webrtcStuff.lastSwitchTime.get(mid) >= this.#rtcStatsConfig.switchCooldownForFreeze) {
+						webrtcStuff.lastSwitchTime.set(mid, now);
+						this.selectSubStream(feedId, targetSubstream, currentTemporal, null, mid)
+							.then(() => {
+								this._log(`Successfully switched substream for ${mid} to ${targetSubstream}`);
+							})
+							.catch(err => {
+								this._log(`Failed to switch substream for ${mid}:`, err);
+							});
+					}
+					continue;
+				}
+			}
+
+			// Don't change layers if we haven't waited enough since last switch
+			if (now - webrtcStuff.lastSwitchTime.get(mid) < this.#rtcStatsConfig.switchCooldown) {
+				continue;
+			}
+			
+			// Get median values from recent history to avoid making decisions on outliers
+			const medianPacketLoss = median(recentHistory.map(item => item.packetLoss));
+			const medianJitter = median(recentHistory.map(item => item.jitter));
+			const medianRtt = median(recentHistory.map(item => item.rtt));
+			const medianBandwidth = median(recentHistory.map(item => item.currentBandwidth));
+			const medianFrameDropRate = median(recentHistory.map(item => item.frameDropRate));
+
+			// Check for network issues that would require downgrading
+			const hasHighPacketLoss = medianPacketLoss > this.#rtcStatsConfig.packetLossThreshold;
+			const hasHighJitter = medianJitter > this.#rtcStatsConfig.jitterBufferThreshold;
+			const hasHighRtt = medianRtt > this.#rtcStatsConfig.roundTripTimeThreshold;
+			// Check if we have high frame drop rate
+			const hasHighFrameDropRate = medianFrameDropRate > this.#rtcStatsConfig.frameDropRateThreshold; // 5% frame drop threshold
+
+			// Determine required bandwidth based on simulcast config
+			let currentLayerBitrate = 0;
+			let nextHigherLayerBitrate = 0;
+
+			// Bitrates are ordered from high to low (h, m, l)
+			if (simulcastConfig?.bitrates?.length > currentSubstream) {
+				currentLayerBitrate = simulcastConfig.bitrates[2 - currentSubstream].maxBitrate / 1000; // Convert to kbps
+
+				if (currentSubstream < simulcastConfig?.bitrates?.length - 1) {
+					nextHigherLayerBitrate = simulcastConfig.bitrates[(2 - currentSubstream) - 1].maxBitrate / 1000;
+				}
+			}
+
+			// !!! WE CAN'T USE THIS AS IT REPORTS medianBandwidth of 1500 for 2000 stream and the stream works just fine
+			// Check if we have enough bandwidth for current layer
+			const hasLowBandwidthForCurrentLayer = medianBandwidth < (currentLayerBitrate * this.#rtcStatsConfig.badBandwidthThresholdMultiplier);
+
+			// Log stats for debugging
+			this._log(`Stream ${mid} stats:`, {
+				packetLoss: medianPacketLoss,
+				jitter: medianJitter,
+				rtt: medianRtt,
+				bandwidth: medianBandwidth,
+				frameDropRate: medianFrameDropRate,
+				currentLayerBitrate,
+				currentSubstream,
+				totalFreezesDurationTillLast
+			});
+			
+			// Network issues detected - downgrade if possible
+			if (hasHighPacketLoss || hasHighJitter || hasHighRtt || hasHighFrameDropRate) {
+				// Can't downgrade if already at lowest quality
+				if (currentSubstream > 0) {
+					targetSubstream = currentSubstream - 1;
+					this._log(`Downgrading stream quality for ${mid} due to network issues:`, {
+						packetLoss: medianPacketLoss,
+						jitter: medianJitter,
+						rtt: medianRtt,
+						bandwidth: medianBandwidth,
+						frameDropRate: medianFrameDropRate,
+						from: currentSubstream,
+						to: targetSubstream
+					});
+				}
+			} 
+			// Check if we can upgrade - network is good
+			else {
+
+				const stableHistory = recentHistory.filter(item => now - item.timestamp < this.#rtcStatsConfig.stableNetworkTime)
+				const hasStableNetwork = stableHistory.every(item => item.packetLoss < this.#rtcStatsConfig.packetLossThreshold &&
+						item.jitter < this.#rtcStatsConfig.jitterBufferThreshold &&
+						item.rtt < this.#rtcStatsConfig.roundTripTimeThreshold &&
+						item.frameDropRate < this.#rtcStatsConfig.frameDropRateThreshold
+					);
+
+				if (hasStableNetwork) {
+					if(currentSubstream < 2) {
+						targetSubstream = currentSubstream + 1;
+						this._log(`Upgrading stream quality for ${mid} due to good network conditions:`, {
+							packetLoss: medianPacketLoss,
+							jitter: medianJitter,
+							rtt: medianRtt,
+							bandwidth: medianBandwidth,
+							from: currentSubstream,
+							to: targetSubstream
+						});
+					}
+				}
+			}
+
+			// Apply the layer change if needed
+			if (targetSubstream !== currentSubstream) {
+				webrtcStuff.lastSwitchTime.set(mid, now);
+				this.selectSubStream(feedId, targetSubstream, currentTemporal, null, mid)
+					.then(() => {
+						this._log(`Successfully switched substream for ${mid} to ${targetSubstream}`);
+					})
+					.catch(err => {
+						this._log(`Failed to switch substream for ${mid}:`, err);
+					});
+			}
+		}
 	}
 
-	#adjustQualitySettings(stats) {}
+	#emitRtcStats(stats) {
+		if (stats?.length > 0) {
+			const s = stats.map(stat => {
+				const {
+					currentBandwidth,
+					frameRate,
+					framesDecoded,
+					framesDropped,
+					framesReceived,
+					freezeCount,
+					jitter,
+					packetLoss,
+					rtt,
+					totalFreezesDuration
+				} = stat.parsedStats;
+
+				let description = {};
+				try {
+					description = JSON.parse(stat.description);
+				} catch {}
+				return {
+					id: stat.id,
+					mid: stat.mid,
+					userId: decodeJanusDisplay(stat.display)?.userId,
+					source: description.source,
+					stats: {
+						currentBandwidth,
+						frameRate,
+						framesDecoded,
+						framesDropped,
+						framesReceived,
+						freezeCount,
+						jitter,
+						packetLoss,
+						rtt,
+						totalFreezesDuration
+					}
+				}
+			});
+			this.emit('rtcStats', s);
+		}
+	}
 
 	#disableStatsWatch() {
 		if (this._statsIntervalId) {
@@ -3177,13 +3663,21 @@ class RoomSession {
 			this._statsIntervalId = null;
 		}
 	}
+
 	#enableStatsWatch() {
 
 		this.#disableStatsWatch();
 
 		const loop = () => {
 			this.#getStats('video')
-				.then(this.#adjustQualitySettings)
+				.then(stats => {
+					if (stats && stats.length > 0) {
+						this.#emitRtcStats(stats)
+						if(this.options.enableVideoQualityAdjustment) {
+							this.#adjustVideoQualitySettings(stats);
+						}
+					}
+				})
 		};
 
 		this._statsIntervalId = setInterval(loop, this._statsInterval);
@@ -3191,4 +3685,8 @@ class RoomSession {
 
 }
 
+
 export default Room;
+
+
+