@reactoo/watchtogether-sdk-js 2.6.13 → 2.6.20

package/src/modules/wt-room.js

@@ -206,9 +206,7 @@ class RoomSession {
 		this._roomType = 'watchparty';
 		this._isDataChannelOpen = false;
 		this._abortController = null;
-
-		this.isAudioMuted = false;
-		this.isVideoMuted = false;
+		this.isMuted = [];
 		this.isVideoEnabled = false;
 		this.isAudioEnabed = false;
 
@@ -221,7 +219,6 @@ class RoomSession {
 		if (this.options.debug) {
 			this._enableDebug();
 		}
-
 	}
 
 	_participantShouldSubscribe(userId) {
@@ -242,6 +239,7 @@ class RoomSession {
 				message: 'id non-existent',
 				data: [handleId, 'getParticipantEventName']
 			});
+			return;
 		}
 
 		const participantRole = decodeJanusDisplay(handle.userId)?.role;
@@ -278,6 +276,7 @@ class RoomSession {
 				message: 'id non-existent',
 				data: [handleId, 'getParticipantEventName']
 			});
+			return;
 		}
 
 		const participantRole = decodeJanusDisplay(handle.userId)?.role;
@@ -501,10 +500,10 @@ class RoomSession {
 
 		if (sender === this.handleId) {
 			if (type === "event") {
+
 				var plugindata = json["plugindata"] || {};
 				var msg = plugindata["data"] || {};
 				var jsep = json["jsep"];
-
 				let result = msg["result"] || null;
 				let event = msg["videoroom"] || null;
 				let list = msg["publishers"] || {};
@@ -539,9 +538,9 @@ class RoomSession {
 											"request": "join",
 											"room": this.roomId,
 											"ptype": "subscriber",
-											streams: streams.map(stream => ({feed: stream.id, mid: stream.mid})),
-											//"feed": id,
 											"private_id": this.privateId,
+											streams: streams.filter(s => !s.disabled).map(stream => ({feed: stream.id, mid: stream.mid})),
+											//"feed": id,
 											...(this.webrtcVersion > 1000 ? {id: this.userId} : {}),
 											pin: this.pin
 										}
@@ -560,6 +559,7 @@ class RoomSession {
 					}
 
 					for (let f in list) {
+
 						let userId = list[f]["display"];
 						let streams = list[f]["streams"] || [];
 						let id = list[f]["id"];
@@ -569,24 +569,42 @@ class RoomSession {
 						}
 						this._log('Remote userId: ', userId);
 						if (this._participantShouldSubscribe(userId)) {
-							this._log('Creating user: ', userId);
-							this._createParticipant(userId, id)
-								.then(handle => {
-									return this.sendMessage(handle.handleId, {
+
+							let handle = this._getHandle(null, id);
+							if(handle) {
+								let subscribe = streams.filter(stream => !stream.disabled && handle.webrtcStuff.tracksMap.filter(t => t.active).findIndex(t => t.mid === stream.mid) === -1).map(s => ({feed: s.id, mid: s.mid}));
+								let unsubscribe = streams.filter(stream => stream.disabled).map(s => ({feed: s.id, mid: s.mid}));
+								this._log('Already subscribed to user: ', userId, 'Update streams', subscribe, unsubscribe);
+								if(subscribe.length || unsubscribe.length) {
+									this.sendMessage(handle.handleId, {
 										body: {
-											"request": "join",
-											"room": this.roomId,
-											"ptype": "subscriber",
-											streams: streams.map(stream => ({feed: stream.id, mid: stream.mid})),
-											"private_id": this.privateId,
-											...(this.webrtcVersion > 1000 ? {id: this.userId} : {}),
-											pin: this.pin
+											"request": "update",
+											...(subscribe.length ? {subscribe}: {}),
+											...(unsubscribe.length ? {unsubscribe}: {})
 										}
 									})
-								})
-								.catch(err => {
-									this.emit('error', err);
-								})
+								}
+							}
+							else {
+								this._log('Creating user: ', userId, streams);
+								this._createParticipant(userId, id)
+									.then(handle => {
+										return this.sendMessage(handle.handleId, {
+											body: {
+												"request": "join",
+												"room": this.roomId,
+												"ptype": "subscriber",
+												"private_id": this.privateId,
+												streams: streams.filter(s => !s.disabled).map(stream => ({feed: stream.id, mid: stream.mid})),
+												...(this.webrtcVersion > 1000 ? {id: this.userId} : {}),
+												pin: this.pin
+											}
+										})
+									})
+									.catch(err => {
+										this.emit('error', err);
+									})
+							}
 						}
 					}
 
@@ -598,7 +616,7 @@ class RoomSession {
 							this.disconnect().catch(() => {});
 						}
 					} else if (leaving) {
-						//TODO: shouldnt we detach?
+						//TODO: in 1 PeerConnection case we only unsubscribe from streams
 						this._log('leaving', leaving);
 						this._removeParticipant(null, leaving, true);
 					}
@@ -607,6 +625,7 @@ class RoomSession {
 						this._log('unpublished', this.handleId, 'this is us');
 						this._removeParticipant(this.handleId, null, false); // we do just hangup
 					} else if (unpublished) {
+						//TODO: in 1 PeerConnection case we only unsubscribe from streams
 						this._log('unpublished', unpublished);
 						this._removeParticipant(null, unpublished, true); // we do hangup and detach
 					}
@@ -684,18 +703,25 @@ class RoomSession {
 			let error = msg["error"];
 			let substream = msg["substream"];
 
+			if (event === "updated") {
+				this._log('Remote has updated tracks', msg);
+				this._updateParticipantsTrackData(handle.handleId, msg["streams"] || []);
+			}
+
 			if (event === "attached") {
 				this._log('Remote have successfully joined Room', msg);
+				this._updateParticipantsTrackData(handle.handleId, msg["streams"] || []);
 				this.emit(this._getAddParticipantEventName(handle.handleId), {
 					tid: generateUUID(),
 					id: handle.handleId,
 					userId: decodeJanusDisplay(handle.userId)?.userId,
 					role: decodeJanusDisplay(handle.userId)?.role,
 					stream: null,
+					streamMap: handle.webrtcStuff?.streamMap,
+					source: null,
 					track: null,
 					adding: false,
 					constructId: this.constructId,
-					metaData: this.options.metaData,
 					hasAudioTrack: false,
 					hasVideoTrack: false
 				});
@@ -783,6 +809,7 @@ class RoomSession {
 				"handle_id": handleId
 			}, true) : Promise.resolve()))
 			.finally(() => {
+
 				try {
 					if (handle.webrtcStuff.stream) {
 						if(!this.isRestarting) {
@@ -795,7 +822,11 @@ class RoomSession {
 				} catch (e) {
 					// Do nothing
 				}
+
+				handle.webrtcStuff.clearTrackRemovedListener?.();
+				handle.webrtcStuff.stream.onremovetrack = null;
 				handle.webrtcStuff.stream = null;
+
 				if (handle.webrtcStuff.dataChannel) {
 					Object.keys(handle.webrtcStuff.dataChannel).forEach(label => {
 						handle.webrtcStuff.dataChannel[label].onmessage = null;
@@ -818,6 +849,8 @@ class RoomSession {
 				}
 				handle.webrtcStuff = {
 					stream: null,
+					streamMap: {},
+					tracksMap: [],
 					mySdp: null,
 					mediaConstraints: null,
 					pc: null,
@@ -826,15 +859,24 @@ class RoomSession {
 					dtmfSender: null,
 					trickle: true,
 					iceDone: false,
+					clearTrackRemovedListener: null,
 				};
 
 				if (handleId === this.handleId) {
 					this._isDataChannelOpen = false;
 					this.isPublished = false;
 					this.emit('published', {status: false, hasStream: false});
-					this.emit('removeLocalParticipant', {id: handleId, userId: decodeJanusDisplay(handle.userId)?.userId, role: decodeJanusDisplay(handle.userId)?.role});
+					this.emit('removeLocalParticipant', {
+						id: handleId,
+						userId: decodeJanusDisplay(handle.userId)?.userId,
+						role: decodeJanusDisplay(handle.userId)?.role}
+					);
 				} else {
-					this.emit(this._getRemoveParticipantEventName(handleId), {id: handleId, userId: decodeJanusDisplay(handle.userId)?.userId, role: decodeJanusDisplay(handle.userId)?.role});
+					this.emit(this._getRemoveParticipantEventName(handleId), {
+						id: handleId,
+						userId: decodeJanusDisplay(handle.userId)?.userId,
+						role: decodeJanusDisplay(handle.userId)?.role}
+					);
 				}
 
 				if (removeHandle) {
@@ -858,6 +900,8 @@ class RoomSession {
 				rfid, userId,
 				webrtcStuff: {
 					stream: null,
+					streamMap: {},
+					tracksMap: [],
 					mySdp: null,
 					mediaConstraints: null,
 					pc: null,
@@ -874,6 +918,54 @@ class RoomSession {
 		})
 	}
 
+	_updateParticipantsTrackData(handleId, streams) {
+		this._log('Updating participants track data', handleId, streams);
+		let handle = this._getHandle(handleId);
+		if (!handle) {
+			this.emit('error', {
+				type: 'warning',
+				id: 15,
+				message: 'id non-existent',
+				data: [handleId, 'updateParticipantsTrackData']
+			});
+			return;
+		}
+		let config = handle.webrtcStuff;
+		config.tracksMap = structuredClone(streams);
+	}
+
+	_updateRemoteParticipantStreamMap(handleId) {
+		this._log('Updating participants stream map', handleId);
+		let handle = this._getHandle(handleId);
+		if (!handle) {
+			this.emit('error', {
+				type: 'warning',
+				id: 15,
+				message: 'id non-existent',
+				data: [handleId, 'updateRemoteParticipantStreamMap']
+			});
+			return;
+		}
+		let config = handle.webrtcStuff;
+		config.streamMap = {};
+		config.tracksMap.forEach(tItem => {
+			if(tItem.type === 'data') {
+				return;
+			}
+			if(tItem.active === false) {
+				return;
+			}
+			if(!config.streamMap[tItem.feed_description]) {
+				config.streamMap[tItem.feed_description] = [];
+			}
+			let trackId = config.pc.getTransceivers().find(t => t.mid === tItem.mid).receiver.track.id;
+			if(trackId) {
+				config.streamMap[tItem.feed_description].push(trackId);
+			}
+		})
+	}
+
+
 	_joinRoom(roomId, pin, userId, display) {
 		return this.sendMessage(this.handleId, {
 			body: {
@@ -1239,11 +1331,12 @@ class RoomSession {
 		let handle = this._getHandle(handleId);
 		if (!handle) {
 			this.emit('error', {
-				type: 'warning',
+				type: 'error',
 				id: 15,
 				message: 'id non-existent',
 				data: [handleId, 'create rtc connection']
 			});
+			return;
 		}
 
 		let config = handle.webrtcStuff;
@@ -1266,8 +1359,15 @@ class RoomSession {
 			this._log('new RTCPeerConnection', pc_config, pc_constraints);
 
 			config.pc = new RTCPeerConnection(pc_config, pc_constraints);
+
+			config.pc.onnegotiationneeded = () => {
+				this._log('onnegotiationneeded');
+			};
+
 			config.pc.onconnectionstatechange = () => {
+				//TODO: check if this isnt fired prematurely when we switch internet connection
 				if (config.pc.connectionState === 'failed') {
+					this._log('connectionState failed');
 					this._iceRestart(handleId);
 				}
 				this.emit('connectionState', [handleId, handleId === this.handleId, config.pc.connectionState]);
@@ -1279,10 +1379,11 @@ class RoomSession {
 						userId: decodeJanusDisplay(handle.userId)?.userId,
 						role: decodeJanusDisplay(handle.userId)?.role,
 						stream: config.stream,
+						streamMap: config.streamMap,
 						track: null,
+						source: null,
 						optional: true,
 						constructId: this.constructId,
-						metaData: this.options.metaData,
 						adding: false,
 						hasAudioTrack: !!(config.stream && config.stream.getAudioTracks().length),
 						hasVideoTrack: !!(config.stream && config.stream.getVideoTracks().length)
@@ -1301,10 +1402,11 @@ class RoomSession {
 						userId: decodeJanusDisplay(handle.userId)?.userId,
 						role: decodeJanusDisplay(handle.userId)?.role,
 						stream: config.stream,
+						streamMap: config.streamMap,
 						track: null,
+						source: null,
 						optional: true,
 						constructId: this.constructId,
-						metaData: this.options.metaData,
 						adding: false,
 						hasAudioTrack: !!(config.stream && config.stream.getAudioTracks().length),
 						hasVideoTrack: !!(config.stream && config.stream.getVideoTracks().length)
@@ -1340,14 +1442,44 @@ class RoomSession {
 					if(!event.streams)
 						return;
 
-					//config.stream = event.streams[0];
-
 					if (!config.stream) {
 						config.stream = new MediaStream();
 					}
+
+					if(!event.streams?.[0]?.onremovetrack) {
+						event.streams[0].onremovetrack = (ev) => {
+							this._log('Remote track removed', ev);
+							let transceiver = config.pc?.getTransceivers()?.find(
+								t => t.receiver.track === ev.track);
+
+							let mid = transceiver?.mid || ev.track.id;
+							let source = Object.keys(config.streamMap).find(key => config.streamMap[key].includes(ev.track.id));
+							config.stream?.removeTrack(ev.track);
+							this._updateRemoteParticipantStreamMap(handle.handleId);
+							this.emit(this._getAddParticipantEventName(handle.handleId), {
+								tid: generateUUID(),
+								id: handle.handleId,
+								mid,
+								constructId: this.constructId,
+								userId: decodeJanusDisplay(handle.userId)?.userId,
+								role: decodeJanusDisplay(handle.userId)?.role,
+								stream: config.stream,
+								streamMap: config.streamMap,
+								source,
+								track: ev.track,
+								adding: false,
+								removing: true,
+								hasAudioTrack: !!(config.stream && config.stream.getAudioTracks().length),
+								hasVideoTrack: !!(config.stream && config.stream.getVideoTracks().length)
+							});
+						};
+					}
+
 					if (event.track) {
 						let mid = event.transceiver ? event.transceiver.mid : event.track.id;
-						config.stream.addTrack(event.track);
+						let source = Object.keys(config.streamMap).find(key => config.streamMap[key].includes(event.track.id));
+						config.stream?.addTrack(event.track);
+						this._updateRemoteParticipantStreamMap(handle.handleId);
 						this.emit(this._getAddParticipantEventName(handle.handleId), {
 							tid: generateUUID(),
 							mid,
@@ -1355,9 +1487,10 @@ class RoomSession {
 							userId: decodeJanusDisplay(handle.userId)?.userId,
 							role: decodeJanusDisplay(handle.userId)?.role,
 							stream: config.stream,
+							streamMap: config.streamMap,
+							source,
 							track: event.track,
 							constructId: this.constructId,
-							metaData: this.options.metaData,
 							adding: true,
 							hasAudioTrack: !!(config.stream && config.stream.getAudioTracks().length),
 							hasVideoTrack: !!(config.stream && config.stream.getVideoTracks().length)
@@ -1367,45 +1500,49 @@ class RoomSession {
 							return;
 
 						event.track.onended = (ev) => {
+							this._log('Remote track ended');
 
 							let transceiver = config.pc?.getTransceivers()?.find(
 								t => t.receiver.track === ev.target);
 
 							let mid = transceiver?.mid || ev.target.id;
-
-							if (config.stream) {
-								config.stream && config.stream.removeTrack(ev.target);
-								this.emit(this._getAddParticipantEventName(handle.handleId), {
-									tid: generateUUID(),
-									id: handle.handleId,
-									mid,
-									userId: decodeJanusDisplay(handle.userId)?.userId,
-									role: decodeJanusDisplay(handle.userId)?.role,
-									stream: config.stream,
-									track: ev.target,
-									constructId: this.constructId,
-									metaData: this.options.metaData,
-									adding: false,
-									removing: true,
-									hasAudioTrack: !!(config.stream && config.stream.getAudioTracks().length),
-									hasVideoTrack: !!(config.stream && config.stream.getVideoTracks().length)
-								});
-							}
+							let source = Object.keys(config.streamMap).find(key => config.streamMap[key].includes(ev.target.id));
+							config.stream?.removeTrack(ev.target);
+							this._updateRemoteParticipantStreamMap(handle.handleId);
+							this.emit(this._getAddParticipantEventName(handle.handleId), {
+								tid: generateUUID(),
+								id: handle.handleId,
+								mid,
+								constructId: this.constructId,
+								userId: decodeJanusDisplay(handle.userId)?.userId,
+								role: decodeJanusDisplay(handle.userId)?.role,
+								stream: config.stream,
+								streamMap: config.streamMap,
+								source,
+								track: ev.target,
+								adding: false,
+								removing: true,
+								hasAudioTrack: !!(config.stream && config.stream.getAudioTracks().length),
+								hasVideoTrack: !!(config.stream && config.stream.getVideoTracks().length)
+							});
 						};
 
 						event.track.onmute = (ev) => {
-							this._log('remoteTrackMuted', 'onmute');
+							this._log('Remote track muted');
 
 							let transceiver = config.pc.getTransceivers().find(
 								t => t.receiver.track === ev.target);
 							let mid = transceiver.mid || ev.target.id;
-
+							let source = Object.keys(config.streamMap).find(key => config.streamMap[key].includes(ev.target.id));
 							this.emit('remoteTrackMuted', {
 								id: handle.handleId,
 								mid,
+								constructId: this.constructId,
 								userId: decodeJanusDisplay(handle.userId)?.userId,
 								role: decodeJanusDisplay(handle.userId)?.role,
 								stream: config.stream,
+								streamMap: config.streamMap,
+								source,
 								kind: ev.target.kind,
 								track: ev.target,
 								muted: true
@@ -1413,26 +1550,27 @@ class RoomSession {
 						};
 
 						event.track.onunmute = (ev) => {
-							this._log('remoteTrackMuted', 'onunmute');
+							this._log('Remote track unmuted');
 
 							let transceiver = config.pc.getTransceivers().find(
 								t => t.receiver.track === ev.target);
 							let mid = transceiver.mid || ev.target.id;
-
+							let source = Object.keys(config.streamMap).find(key => config.streamMap[key].includes(ev.target.id));
 							this.emit('remoteTrackMuted', {
 								id: handle.handleId,
 								mid,
+								constructId: this.constructId,
 								userId: decodeJanusDisplay(handle.userId)?.userId,
 								role: decodeJanusDisplay(handle.userId)?.role,
 								stream: config.stream,
+								streamMap: config.streamMap,
+								source,
 								kind: ev.target.kind,
 								track: ev.target,
 								muted: false
 							});
 						};
-
 					}
-
 				};
 			}
 		}
@@ -1450,7 +1588,6 @@ class RoomSession {
 				let state = config.dataChannel[label] ? config.dataChannel[label].readyState : "null";
 				this._handleDataEvents(handleId, 'state', {state, label} );
 			};
-			//TODO: check this
 			var onDataChannelError = (error) => {
 				this._handleDataEvents(handleId, 'error', {label: error?.channel?.label, error});
 			};
@@ -1536,7 +1673,6 @@ class RoomSession {
 			config.isIceRestarting = true;
 			let hasAudio = !!(config.stream && config.stream.getAudioTracks().length > 0);
 			let hasVideo = !!(config.stream && config.stream.getVideoTracks().length > 0);
-			this._setupTransceivers(handleId,[hasAudio, false, hasVideo, false]);
 			this._createAO('offer', handleId, true )
 				.then((jsep) => {
 					if (!jsep) {
@@ -1569,118 +1705,91 @@ class RoomSession {
 
 	}
 
-	_setupTransceivers(handleId, [audioSend, audioRecv, videoSend, videoRecv]) {
+	_setupTransceivers(handleId, [audioSend, audioRecv, videoSend, videoRecv, audioTransceiver = null, videoTransceiver = null]) {
+
+		//TODO: this should be refactored to use handle's trackMap so we dont have to pass any parameters
 
 		let handle = this._getHandle(handleId);
 		if (!handle) {
 			return null;
 		}
-
 		let config = handle.webrtcStuff;
-		let audioTransceiver = null, videoTransceiver = null;
-		let transceivers = config.pc.getTransceivers();
-		if (transceivers && transceivers.length > 0) {
-			for (var i in transceivers) {
-				var t = transceivers[i];
-				if ((t.sender && t.sender.track && t.sender.track.kind === "audio") ||
-					(t.receiver && t.receiver.track && t.receiver.track.kind === "audio")) {
-					if (!audioTransceiver)
-						audioTransceiver = t;
-					continue;
-				}
-				if ((t.sender && t.sender.track && t.sender.track.kind === "video") ||
-					(t.receiver && t.receiver.track && t.receiver.track.kind === "video")) {
-					if (!videoTransceiver)
-						videoTransceiver = t;
-					continue;
-				}
-			}
-		}
 
-		// Handle audio (and related changes, if any)
-		if (!audioSend && !audioRecv) {
-			// Audio disabled: have we removed it?
-			if (audioTransceiver) {
-				if (audioTransceiver.setDirection) {
-					audioTransceiver.setDirection("inactive");
-				} else {
-					audioTransceiver.direction = "inactive";
-				}
-			}
-		} else {
-			// Take care of audio m-line
-			if (audioSend && audioRecv) {
-				if (audioTransceiver) {
-					if (audioTransceiver.setDirection) {
-						audioTransceiver.setDirection("sendrecv");
+		const setTransceiver = (transceiver, send, recv) => {
+			if (!send && !recv) {
+				// disabled: have we removed it?
+				if (transceiver) {
+					if (transceiver.setDirection) {
+						transceiver.setDirection("inactive");
 					} else {
-						audioTransceiver.direction = "sendrecv";
+						transceiver.direction = "inactive";
 					}
 				}
-			} else if (audioSend && !audioRecv) {
-				if (audioTransceiver) {
-					if (audioTransceiver.setDirection) {
-						audioTransceiver.setDirection("sendonly");
-					} else {
-						audioTransceiver.direction = "sendonly";
+			} else {
+				if (send && recv) {
+					if (transceiver) {
+						if (transceiver.setDirection) {
+							transceiver.setDirection("sendrecv");
+						} else {
+							transceiver.direction = "sendrecv";
+						}
 					}
-				}
-			} else if (!audioSend && audioRecv) {
-				if (audioTransceiver) {
-					if (audioTransceiver.setDirection) {
-						audioTransceiver.setDirection("recvonly");
+				} else if (send && !recv) {
+					if (transceiver) {
+						if (transceiver.setDirection) {
+							transceiver.setDirection("sendonly");
+						} else {
+							transceiver.direction = "sendonly";
+						}
+					}
+				} else if (!send && recv) {
+					if (transceiver) {
+						if (transceiver.setDirection) {
+							transceiver.setDirection("recvonly");
+						} else {
+							transceiver.direction = "recvonly";
+						}
 					} else {
-						audioTransceiver.direction = "recvonly";
+						// In theory, this is the only case where we might not have a transceiver yet
+						config.pc.addTransceiver("audio", {direction: "recvonly"});
 					}
-				} else {
-					// In theory, this is the only case where we might not have a transceiver yet
-					config.pc.addTransceiver("audio", {direction: "recvonly"});
 				}
 			}
 		}
-		// Handle video (and related changes, if any)
-		if (!videoSend && !videoRecv) {
-			if (videoTransceiver) {
-				if (videoTransceiver.setDirection) {
-					videoTransceiver.setDirection("inactive");
-				} else {
-					videoTransceiver.direction = "inactive";
-				}
+
+		// if we're passing any transceivers, we work only on them, doesn't matter if one of them is null
+		if(audioTransceiver || videoTransceiver) {
+			if(audioTransceiver) {
+				setTransceiver(audioTransceiver, audioSend, audioRecv);
 			}
-		} else {
-			// Take care of video m-line
-			if (videoSend && videoRecv) {
-				if (videoTransceiver) {
-					if (videoTransceiver.setDirection) {
-						videoTransceiver.setDirection("sendrecv");
-					} else {
-						videoTransceiver.direction = "sendrecv";
-					}
-				}
-			} else if (videoSend && !videoRecv) {
-				if (videoTransceiver) {
-					if (videoTransceiver.setDirection) {
-						videoTransceiver.setDirection("sendonly");
-					} else {
-						videoTransceiver.direction = "sendonly";
+			if(videoTransceiver) {
+				setTransceiver(videoTransceiver, videoSend, videoRecv);
+			}
+		}
+		// else we work on all transceivers
+		else {
+			let transceivers = config.pc.getTransceivers();
+			if (transceivers && transceivers.length > 0) {
+				for (let i in transceivers) {
+					let t = transceivers[i];
+					if (
+						(t.sender && t.sender.track && t.sender.track.kind === "audio") ||
+						(t.receiver && t.receiver.track && t.receiver.track.kind === "audio")
+					) {
+						setTransceiver(t, audioSend, audioRecv);
 					}
-				}
-			} else if (!videoSend && videoRecv) {
-				if (videoTransceiver) {
-					if (videoTransceiver.setDirection) {
-						videoTransceiver.setDirection("recvonly");
-					} else {
-						videoTransceiver.direction = "recvonly";
+					if (
+						(t.sender && t.sender.track && t.sender.track.kind === "video") ||
+						(t.receiver && t.receiver.track && t.receiver.track.kind === "video")
+					) {
+						setTransceiver(t, videoSend, videoRecv);
 					}
-				} else {
-					// In theory, this is the only case where we might not have a transceiver yet
-					config.pc.addTransceiver("video", {direction: "recvonly"});
 				}
 			}
 		}
 	}
 
-	_createAO(type = 'offer', handleId, iceRestart = false) {
+	_createAO(type = 'offer', handleId, iceRestart = false, ) {
 
 		let handle = this._getHandle(handleId);
 		if (!handle) {
@@ -1707,7 +1816,7 @@ class RoomSession {
 		}
 
 		return config.pc[methodName](mediaConstraints)
-			.then(function (response) {
+			.then( (response) => {
 				config.mySdp = response.sdp;
 				let _p = config.pc.setLocalDescription(response)
 					.catch((e) => {
@@ -1805,8 +1914,35 @@ class RoomSession {
 	}
 
 	//Public methods
+	_republishOnTrackEnded(source) {
+		let handle = this._getHandle(this.handleId);
+		if (!handle) {
+			return;
+		}
+		let config = handle.webrtcStuff;
+		if (!config.stream) {
+			return;
+		}
+		let sourceTrackIds = (config.streamMap[source] || []);
+		let remainingTracks = [];
+		for(let i = 0; i < sourceTrackIds.length; i++) {
+			let foundTrack = config.stream.getTracks().find(t => t.id === sourceTrackIds[i]);
+			if(foundTrack) {
+				remainingTracks.push(foundTrack);
+			}
+		}
+		if (remainingTracks.length) {
+			let stream = new MediaStream();
+			remainingTracks.forEach(track => stream.addTrack(track));
+			return this.publishLocal(stream, source);
+		}
+		else {
+			return this.publishLocal(null, source);
+		}
+	};
+
 
-	publishLocal(stream = null) {
+	publishLocal(stream = null, source = 'camera0') {
 
 		if(this.isDisconnecting || !this.isConnected) {
 			return Promise.reject({
@@ -1816,7 +1952,23 @@ class RoomSession {
 			})
 		}
 
-		this.emit('publishing', true);
+		if(stream?.getVideoTracks()?.length > 1) {
+			return Promise.reject({
+				type: 'warning',
+				id: 30,
+				message: 'multiple video tracks not supported',
+				data: null
+			})
+		}
+
+		if(stream?.getAudioTracks()?.length > 1) {
+			return Promise.reject({
+				type: 'warning',
+				id: 30,
+				message: 'multiple audio tracks not supported',
+				data: null
+			})
+		}
 
 		let handle = this._getHandle(this.handleId);
 		if (!handle) {
@@ -1828,26 +1980,105 @@ class RoomSession {
 			})
 		}
 
+		this.emit('publishing', true);
+
 		this._webrtc(this.handleId);
 
 		let config = handle.webrtcStuff;
+
+		if (!config.stream) {
+			config.stream = new MediaStream();
+		}
+
+		let needsNegotiation = false;
+		let transceivers = config.pc.getTransceivers();
+		let existingTracks = [...(config.streamMap[source] || [])];
+		config.streamMap[source] = stream?.getTracks()?.map(track => track.id) || [];
+
+		// remove old audio track related to this source
+		let oldAudioStream = config?.stream?.getAudioTracks()?.find(track => existingTracks.includes(track.id));
+		if (oldAudioStream) {
+			try {
+				oldAudioStream.stop();
+
+			} catch (e) {
+				this._log(e);
+			}
+			config.stream.removeTrack(oldAudioStream);
+			config.stream.dispatchEvent(new Event("trackremoved", {detail: oldAudioStream}))
+		}
+
+		// remove old video track related to this source
+		let oldVideoStream = config?.stream?.getVideoTracks()?.find(track => existingTracks.includes(track.id));
+		if (oldVideoStream) {
+			try {
+				oldVideoStream.stop();
+			} catch (e) {
+				this._log(e);
+			}
+			config.stream.removeTrack(oldVideoStream);
+			config.stream.dispatchEvent(new Event("trackremoved", {detail: oldVideoStream}))
+		}
+
 		let audioTrackReplacePromise = Promise.resolve();
 		let videoTrackReplacePromise = Promise.resolve();
 
-		if (!config.stream) {
-			config.stream = stream;
-			stream?.getTracks()?.forEach( (track) => {
+		let audioTransceiver = null;
+		let videoTransceiver = null;
+		let replaceAudio = stream?.getAudioTracks()?.length;
+		let replaceVideo = stream?.getVideoTracks()?.length;
+
+		for(const transceiver of transceivers) {
+			if(['sendonly', 'sendrecv'].includes(transceiver.currentDirection) && transceiver.sender?.track?.kind === 'audio' && existingTracks.includes(transceiver.sender?.track?.id)) {
+				audioTransceiver = transceiver;
+			}
+			else if(['sendonly', 'sendrecv'].includes(transceiver.currentDirection) && transceiver.sender?.track?.kind === 'video' && existingTracks.includes(transceiver.sender?.track?.id)) {
+				videoTransceiver = transceiver;
+			}
+
+			// Reusing existing transceivers
+			// TODO: if we start using different codecs for different sources, we need to check for that here
+
+			else if(transceiver.currentDirection === 'inactive' && transceiver.sender?.getParameters()?.codecs?.find(c => c.mimeType.indexOf('audio') > -1) && replaceAudio && !audioTransceiver) {
+				audioTransceiver = transceiver;
+				needsNegotiation = true;
+			}
+			else if(transceiver.currentDirection === 'inactive' && transceiver.sender?.getParameters()?.codecs?.find(c => c.mimeType.indexOf('video') > -1) && replaceVideo && !videoTransceiver) {
+				videoTransceiver = transceiver;
+				needsNegotiation = true;
+			}
+		}
+
+		if (replaceAudio) {
+			config.stream.addTrack(stream.getAudioTracks()[0]);
+			if (audioTransceiver && audioTransceiver.sender) {
+				audioTrackReplacePromise = audioTransceiver.sender.replaceTrack(stream.getAudioTracks()[0]);
+			} else {
+				config.pc.addTrack(stream.getAudioTracks()[0], config.stream);
+				needsNegotiation = true;
+			}
+		}
+		else {
+			if (audioTransceiver && audioTransceiver.sender) {
+				audioTrackReplacePromise = audioTransceiver.sender.replaceTrack(null);
+				needsNegotiation = true;
+			}
+		}
 
-				if(track.kind === 'audio' || !this.simulcast) {
-					config.pc.addTrack(track, stream);
+		if (replaceVideo) {
+			config.stream.addTrack(stream.getVideoTracks()[0]);
+			if (videoTransceiver && videoTransceiver.sender) {
+				videoTrackReplacePromise = videoTransceiver.sender.replaceTrack(stream.getVideoTracks()[0]);
+			} else {
+				if(!this.simulcast) {
+					config.pc.addTrack(stream.getVideoTracks()[0], config.stream);
 				}
 				else {
-					// adding simulcast streams
 					let bitRates = this.simulcastBitrates;
 					if(adapter.browserDetails.browser !== 'firefox') {
 						// standard
 
-						config.pc.addTransceiver(track, {
+						config.pc.addTransceiver(stream.getVideoTracks()[0], {
 							direction: 'sendonly',
 							streams: [config.stream],
 							sendEncodings: [
@@ -1859,14 +2090,14 @@ class RoomSession {
 					}
 					else {
 						// firefox
-						let transceiver = config.pc.addTransceiver(track, {
+						let transceiver = config.pc.addTransceiver(stream.getVideoTracks()[0], {
 							direction: 'sendonly',
 							streams: [config.stream]
 						});
 						let sender = transceiver ? transceiver.sender : null;
 						if(sender) {
 							let parameters = sender.getParameters() || {};
-							parameters.encodings = track.sendEncodings || [
+							parameters.encodings = stream.getVideoTracks()[0].sendEncodings || [
 								{ rid: 'h', active: true, maxBitrate: bitRates.high },
 								{ rid: 'm', active: true, maxBitrate: bitRates.medium, scaleResolutionDownBy: 2 },
 								{ rid: 'l', active: true, maxBitrate: bitRates.low, scaleResolutionDownBy: 4 }
@@ -1875,109 +2106,72 @@ class RoomSession {
 						}
 					}
 				}
-			});
-
-		} else {
-
-			let transceivers = config.pc.getTransceivers();
-			let audioTransceiver = null;
-			let videoTransceiver = null;
-			if (transceivers && transceivers.length > 0) {
-				for (let i in transceivers) {
-					let t = transceivers[i];
-					if ((t.sender && t.sender.track && t.sender.track.kind === "audio") ||
-						(t.receiver && t.receiver.track && t.receiver.track.kind === "audio")) {
-						audioTransceiver = t;
-						break;
-					}
-				}
-				for (let i in transceivers) {
-					let t = transceivers[i];
-					if ((t.sender && t.sender.track && t.sender.track.kind === "video") ||
-						(t.receiver && t.receiver.track && t.receiver.track.kind === "video")) {
-						videoTransceiver = t;
-						break;
-					}
-				}
+				needsNegotiation = true;
 			}
-
-			/* UPDATE Audio */
-			// stopping existing tracks
-
-			let oldAudioStream = config?.stream?.getAudioTracks()?.[0];
-			if (oldAudioStream) {
-				config.stream.removeTrack(oldAudioStream);
-				try {
-					oldAudioStream.stop();
-				} catch (e) {
-					this._log(e);
-				}
-			}
-
-			let replaceAudio = stream?.getAudioTracks()?.length;
-			if (replaceAudio) {
-				config.stream.addTrack(stream.getAudioTracks()[0]);
-				if (audioTransceiver && audioTransceiver.sender) {
-					audioTrackReplacePromise = audioTransceiver.sender.replaceTrack(stream.getAudioTracks()[0]);
-				} else {
-					config.pc.addTrack(stream.getAudioTracks()[0], stream);
-				}
-			}
-			else {
-				if (audioTransceiver && audioTransceiver.sender) {
-					audioTrackReplacePromise = audioTransceiver.sender.replaceTrack(null);
-				}
+		}
+		else {
+			if (videoTransceiver && videoTransceiver.sender) {
+				videoTrackReplacePromise = videoTransceiver.sender.replaceTrack(null);
+				needsNegotiation = true;
 			}
+		}
 
-			/* UPDATE Video */
 
-			// stopping existing tracks
+		this.isAudioEnabed = !!(config.stream && config.stream.getAudioTracks().length > 0);
+		this.isVideoEnabled = !!(config.stream && config.stream.getVideoTracks().length > 0);
 
-			let oldVideoStream = config?.stream?.getVideoTracks()?.[0];
-			if (oldVideoStream) {
-				config.stream.removeTrack(oldVideoStream);
-				try {
-					oldVideoStream.stop();
-				} catch (e) {
-					this._log(e);
-				}
-			}
+		// we possibly created new transceivers, so we need to get them again
 
-			let replaceVideo = stream?.getVideoTracks()?.length;
-			if (replaceVideo) {
-				config.stream.addTrack(stream.getVideoTracks()[0]);
-				if (videoTransceiver && videoTransceiver.sender) {
-					videoTrackReplacePromise = videoTransceiver.sender.replaceTrack(stream.getVideoTracks()[0]);
-				} else {
-					config.pc.addTrack(stream.getVideoTracks()[0], stream);
-				}
-			}
-			else {
-				if (videoTransceiver && videoTransceiver.sender) {
-					videoTrackReplacePromise = videoTransceiver.sender.replaceTrack(null);
-				}
-			}
+		transceivers = config.pc.getTransceivers();
+		existingTracks = [...(config.streamMap[source] || [])];
+		if(!audioTransceiver) {
+			audioTransceiver = transceivers.find(transceiver => transceiver.sender.track && transceiver.sender.track.kind === 'audio' && existingTracks.includes(transceiver.sender.track.id))
+		}
+		if(!videoTransceiver) {
+			videoTransceiver = transceivers.find(transceiver => transceiver.sender.track && transceiver.sender.track.kind === 'video' && existingTracks.includes(transceiver.sender.track.id))
 		}
 
 		let hasAudio = !!(stream && stream.getAudioTracks().length > 0);
 		let hasVideo = !!(stream && stream.getVideoTracks().length > 0);
-		let isAudioMuted = !stream || stream.getAudioTracks().length === 0 || !stream.getAudioTracks()[0].enabled;
-		let isVideoMuted = !stream || stream.getVideoTracks().length === 0 || !stream.getVideoTracks()[0].enabled;
-
-		this.isAudioEnabed = hasAudio;
-		this.isVideoEnabled = hasVideo;
-		this.isAudioMuted = isAudioMuted;
-		this.isVideoMuted = isVideoMuted;
+		this._setupTransceivers(this.handleId, [hasAudio, false, hasVideo, false, audioTransceiver, videoTransceiver]);
 
-		this._setupTransceivers(this.handleId, [hasAudio, false, hasVideo, false]);
 
 		const emitEvents = () => {
 			this.isPublished = true;
-			if(config.stream) {
-				let tracks = config.stream.getTracks();
+
+			if(!config.stream.onremovetrack) {
+				config.stream.onremovetrack = (ev) => {};
+
+				let trackremoved = (ev) => {
+					this.emit('addLocalParticipant', {
+						tid: generateUUID(),
+						id: handle.handleId,
+						constructId: this.constructId,
+						userId: decodeJanusDisplay(handle.userId)?.userId,
+						role: decodeJanusDisplay(this.display)?.role,
+						track: ev.detail,
+						stream: config.stream,
+						streamMap: config.streamMap,
+						source,
+						adding: false,
+						removing: true,
+						hasAudioTrack: hasAudio,
+						hasVideoTrack: hasVideo,
+					});
+				}
+
+				config.stream.addEventListener('trackremoved', trackremoved);
+				config.clearTrackRemovedListener = () => {
+					config.stream.removeEventListener('trackremoved', trackremoved);
+				}
+			}
+
+			let tracks = config.stream.getTracks();
+			if(tracks.length) {
 				tracks.forEach(track => {
 					// used as a flag to not emit tracks that been already emitted
 					if(!track.onended) {
+
 						this.emit('addLocalParticipant', {
 							tid: generateUUID(),
 							id: handle.handleId,
@@ -1985,31 +2179,24 @@ class RoomSession {
 							role: decodeJanusDisplay(this.display)?.role,
 							track,
 							stream: config.stream,
+							streamMap: config.streamMap,
+							source,
 							adding: true,
 							constructId: this.constructId,
-							metaData: this.options.metaData,
 							hasAudioTrack: hasAudio,
 							hasVideoTrack: hasVideo
 						});
+
 						track.onended = (ev) => {
-							this.emit('addLocalParticipant', {
-								tid:generateUUID(),
-								id: handle.handleId,
-								userId: decodeJanusDisplay(handle.userId)?.userId,
-								role: decodeJanusDisplay(this.display)?.role,
-								track: ev.target,
-								stream: config.stream,
-								adding: false,
-								removing: true,
-								constructId: this.constructId,
-								metaData: this.options.metaData,
-								hasAudioTrack: hasAudio,
-								hasVideoTrack: hasVideo
-							});
+							config.stream.removeTrack(track);
+							config.stream.dispatchEvent(new Event("trackremoved", {detail: track}))
+							this._republishOnTrackEnded(source);
 						}
 					}
 				})
 			}
+
+			//TODO: legacy event, remove in future
 			else {
 				this.emit('addLocalParticipant', {
 					tid: generateUUID(),
@@ -2017,24 +2204,34 @@ class RoomSession {
 					userId: decodeJanusDisplay(handle.userId)?.userId,
 					role: decodeJanusDisplay(this.display)?.role,
 					stream: null,
+					streamMap: config.streamMap,
+					source,
 					adding: false,
 					constructId: this.constructId,
-					metaData: this.options.metaData,
 					hasAudioTrack: hasAudio,
 					hasVideoTrack: hasVideo
 				});
 			}
-			this.emit('published', {status: true, hasStream: !!config.stream});
+
+			this.isMuted = [];
+			for(const source of Object.keys(config.streamMap)) {
+				const audioTrack = config.stream?.getAudioTracks()?.find(track => config.streamMap[source].includes(track.id));
+				const videoTrack = config.stream?.getVideoTracks()?.find(track => config.streamMap[source].includes(track.id));
+				this.isMuted.push({type: 'audio', value: !audioTrack || !audioTrack.enabled, source, mid: transceivers.find(transceiver => transceiver.sender?.track?.kind === 'audio' && transceiver.sender?.track?.id === audioTrack?.id)?.mid});
+				this.isMuted.push({type: 'video', value: !videoTrack || !videoTrack.enabled, source, mid: transceivers.find(transceiver => transceiver.sender?.track?.kind === 'video' && transceiver.sender?.track?.id === videoTrack?.id)?.mid});
+				this.emit('localHasVideo', !!videoTrack, source);
+				this.emit('localHasAudio', !!audioTrack, source);
+			}
+			for(const val of this.isMuted) {
+				this.emit('localMuted', {...val});
+			}
+			this.emit('published', {status: true, hasStream: tracks.length > 0});
 			this.emit('publishing', false);
-			this.emit('localHasVideo', hasVideo);
-			this.emit('localHasAudio', hasAudio);
-			this.emit('localMuted', {type: 'video', value: isVideoMuted});
-			this.emit('localMuted', {type: 'audio', value: isAudioMuted});
 			return this;
 		};
 
 		// this should be enough
-		if(this.isPublished) {
+		if(!needsNegotiation) {
 			return Promise
 				.all([audioTrackReplacePromise, videoTrackReplacePromise])
 				.then(() => emitEvents())
@@ -2051,47 +2248,29 @@ class RoomSession {
 				if (jsep.sdp && jsep.sdp.indexOf("\r\na=ice-ufrag") === -1) {
 					jsep.sdp = jsep.sdp.replace("\na=ice-ufrag", "\r\na=ice-ufrag");
 				}
-				return this.sendMessage(this.handleId, {
-					body: {"request": "configure", "audio": hasAudio, "video": hasVideo, "data": true, ...(this.recordingFilename ? {filename: this.recordingFilename} : {})},
-					jsep
-				});
-			})
-			.then((r) => {
-				if (this._isDataChannelOpen) {
-					return Promise.resolve(r)
-				} else {
-					return new Promise((resolve, reject) => {
-
-						let dataChannelTimeoutId = null;
-
-						let _resolve = (val) => {
-							if (val) {
-								clearTimeout(dataChannelTimeoutId);
-								this._abortController.signal.removeEventListener('abort', _rejectAbort);
-								this.off('dataChannel', _resolve, this);
-								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});
-						}
 
-						let _rejectAbort = () => {
-							this._abortController.signal.removeEventListener('abort', _rejectAbort);
-							clearTimeout(dataChannelTimeoutId);
-							this.off('dataChannel', _resolve, this);
-							reject({type: 'warning', id: 17, message: 'Connection cancelled'})
+				let descriptions = [];
+				Object.keys(config.streamMap).forEach(source => {
+					config.streamMap[source].forEach(trackId => {
+						let t = transceivers.find(transceiver => transceiver.sender.track && transceiver.sender.track.id === trackId)
+						if(t) {
+							descriptions.push({mid: t.mid, description: source});
 						}
+					})
+				});
 
-						dataChannelTimeoutId = setTimeout(_rejectTimeout, 5000);
-						this._abortController.signal.addEventListener('abort', _rejectAbort);
-
-						this.on('dataChannel', _resolve, this);
-					});
-				}
+				return this.sendMessage(this.handleId, {
+					body: {
+						"request": "configure",
+						"audio": this.isAudioEnabed,
+						"video": this.isVideoEnabled,
+						"data": true,
+						...(this.recordingFilename ? {filename: this.recordingFilename} : {}),
+						descriptions: descriptions
+					},
+					jsep
+				});
 			})
 			.then(() => emitEvents())
 			.catch(e => {
@@ -2111,53 +2290,71 @@ class RoomSession {
 			: Promise.resolve()
 	}
 
-	toggleAudio(value = null, mid) {
+	toggleAudio(value = null, source = 'camera0', mid) {
 		let handle = this._getHandle(this.handleId);
 		if (!handle) {
 			return Promise.reject({type: 'error', id: 21, message: 'no local id, connect first', data: null})
 		}
 		let config = handle.webrtcStuff;
-
-		let transceiver = config.pc.getTransceivers()
-			.find(t => t.sender && t.sender.track && t.receiver.track.kind === "audio" && (mid ? t.mid === mid : true));
-
+		let transceivers = config.pc.getTransceivers().filter(t => t.currentDirection !== 'inactive');
+		let transceiver = null;
+		if(source) {
+			transceiver = transceivers
+				.find(t => t.sender && t.sender.track && t.receiver.track.kind === "audio" && (config.streamMap[source] || []).includes(t.sender.track.id));
+		}
+		else {
+			transceiver = transceivers
+				.find(t => t.sender && t.sender.track && t.receiver.track.kind === "audio" && (mid ? t.mid === mid : true));
+		}
 		if (transceiver) {
 			transceiver.sender.track.enabled = value !== null ? !!value : !transceiver.sender.track.enabled;
 		}
 
-		this.isAudioMuted = !transceiver || !transceiver.sender.track.enabled;
-
-		// if (config.stream && config.stream.getAudioTracks().length) {
-		// 	config.stream.getAudioTracks()[0].enabled = value !== null ? !!value : !config.stream.getAudioTracks()[0].enabled;
-		// }
-		// this.isAudioMuted = config.stream.getAudioTracks().length === 0 || !config.stream.getAudioTracks()[0].enabled;
-		//
-
-		this.emit('localMuted', {type: 'audio', value: this.isAudioMuted, mid});
-
+		this.isMuted = [];
+		for(const source of Object.keys(config.streamMap)) {
+			const audioTrack = config.stream?.getAudioTracks()?.find(track => config.streamMap[source].includes(track.id));
+			const audioTransceiver = transceivers.find(transceiver => transceiver.sender.track && transceiver.sender.track.kind === 'audio' && transceiver.sender.track.id === audioTrack?.id);
+			const videoTrack = config.stream?.getVideoTracks()?.find(track => config.streamMap[source].includes(track.id));
+			const videoTransceiver = transceivers.find(transceiver => transceiver.sender.track && transceiver.sender.track.kind === 'video' && transceiver.sender.track.id === videoTrack?.id);
+			this.isMuted.push({type: 'audio', value: !audioTrack || !audioTransceiver || !audioTransceiver?.sender?.track?.enabled , source, mid: audioTransceiver?.mid});
+			this.isMuted.push({type: 'video', value: !videoTrack || !videoTransceiver || !videoTransceiver?.sender?.track?.enabled, source, mid: videoTransceiver?.mid});
+		}
+		for(let val of this.isMuted) {
+			this.emit('localMuted', {...val});
+		}
 	}
 
-	toggleVideo(value = null, mid) {
+	toggleVideo(value = null, source = 'camera0', mid) {
 		let handle = this._getHandle(this.handleId);
 		if (!handle) {
 			return Promise.reject({type: 'error', id: 21, message: 'no local id, connect first', data: null})
 		}
 		let config = handle.webrtcStuff;
-
-		let transceiver = config.pc.getTransceivers()
-			.find(t => t.sender && t.sender.track && t.receiver.track.kind === "video" && (mid ? t.mid === mid : true));
+		let transceivers = config.pc.getTransceivers().filter(t => t.currentDirection !== 'inactive');
+		let transceiver = null;
+		if(source) {
+			transceiver = transceivers
+				.find(t => t.sender && t.sender.track && t.receiver.track.kind === "video" && (config.streamMap[source] || []).includes(t.sender.track.id));
+		}
+		else {
+			transceiver = transceivers
+				.find(t => t.sender && t.sender.track && t.receiver.track.kind === "video" && (mid ? t.mid === mid : true));
+		}
 		if (transceiver) {
 			transceiver.sender.track.enabled = value !== null ? !!value : !transceiver.sender.track.enabled;
 		}
-
-		this.isVideoMuted = !transceiver || !transceiver.sender.track.enabled;
-
-		// if (config.stream && config.stream.getVideoTracks().length) {
-		// 	config.stream.getVideoTracks()[0].enabled = value !== null ? !!value : !config.stream.getVideoTracks()[0].enabled;
-		// }
-		// this.isVideoMuted = config.stream.getVideoTracks().length === 0 || !config.stream.getVideoTracks()[0].enabled;
-
-		this.emit('localMuted', {type: 'video', value: this.isVideoMuted, mid});
+		this.isMuted = [];
+		for(const source of Object.keys(config.streamMap)) {
+			const audioTrack = config.stream?.getAudioTracks()?.find(track => config.streamMap[source].includes(track.id));
+			const audioTransceiver = transceivers.find(transceiver => transceiver.sender.track && transceiver.sender.track.kind === 'audio' && transceiver.sender.track.id === audioTrack?.id);
+			const videoTrack = config.stream?.getVideoTracks()?.find(track => config.streamMap[source].includes(track.id));
+			const videoTransceiver = transceivers.find(transceiver => transceiver.sender.track && transceiver.sender.track.kind === 'video' && transceiver.sender.track.id === videoTrack?.id);
+			this.isMuted.push({type: 'audio', value: !audioTrack || !audioTransceiver || !audioTransceiver?.sender?.track?.enabled , source, mid: audioTransceiver?.mid});
+			this.isMuted.push({type: 'video', value: !videoTrack || !videoTransceiver || !videoTransceiver?.sender?.track?.enabled, source, mid: videoTransceiver?.mid});
+		}
+		for(let val of this.isMuted) {
+			this.emit('localMuted', {...val});
+		}
 	}
 
 	selectSubStream(handleId, substream = 2) {