feat: use source names in presence

...to advertise track's muted state and the video type.

For now, if the source name signaling flag is enabled, both legacy and
new <SourceInfo> element will be used at the same time. This is to be
able to interoperate with legacy clients and start testing the new
format at the same time. Whenever possible <SourceInfo> will be used
as main source of truth with the fallback to legacy <audiomuted/>,
<videomuted/> and <videotype/> elements.

JitsiConference.js

@@ -31,6 +31,7 @@ import VADTalkMutedDetection from './modules/detection/VADTalkMutedDetection';
 import { E2EEncryption } from './modules/e2ee/E2EEncryption';
 import E2ePing from './modules/e2eping/e2eping';
 import Jvb121EventGenerator from './modules/event/Jvb121EventGenerator';
+import FeatureFlags from './modules/flags/FeatureFlags';
 import { ReceiveVideoController } from './modules/qualitycontrol/ReceiveVideoController';
 import { SendVideoController } from './modules/qualitycontrol/SendVideoController';
 import RecordingManager from './modules/recording/RecordingManager';
@@ -54,6 +55,7 @@ import {
 import BridgeVideoType from './service/RTC/BridgeVideoType';
 import CodecMimeType from './service/RTC/CodecMimeType';
 import * as MediaType from './service/RTC/MediaType';
+import { getSourceNameForJitsiTrack } from './service/RTC/SignalingLayer';
 import VideoType from './service/RTC/VideoType';
 import {
     ACTION_JINGLE_RESTART,
@@ -1274,21 +1276,12 @@ JitsiConference.prototype._setupNewTrack = function(newTrack) {
         }
     }
     if (newTrack.isVideoTrack()) {
-        const videoTypeTagName = 'videoType';
-
-        // if video type is camera and there is no videoType in presence, we skip adding it, as this is the default one
-        if (newTrack.videoType !== VideoType.CAMERA || this.room.getFromPresence(videoTypeTagName)) {
-            this.sendCommand(videoTypeTagName, { value: newTrack.videoType });
-        }
+        this._sendNewVideoType(newTrack);
     }
     this.rtc.addLocalTrack(newTrack);
 
     // ensure that we're sharing proper "is muted" state
-    if (newTrack.isAudioTrack()) {
-        this.room.setAudioMute(newTrack.isMuted());
-    } else {
-        this.room.setVideoMute(newTrack.isMuted());
-    }
+    this._setTrackMuteStatus(newTrack, newTrack.isMuted());
 
     newTrack.muteHandler = this._fireMuteChangeEvent.bind(this, newTrack);
     newTrack.audioLevelHandler = this._fireAudioLevelChangeEvent.bind(this);
@@ -1304,6 +1297,44 @@ JitsiConference.prototype._setupNewTrack = function(newTrack) {
     this.eventEmitter.emit(JitsiConferenceEvents.TRACK_ADDED, newTrack);
 };
 
+JitsiConference.prototype._sendNewVideoType = function(track) {
+    if (FeatureFlags.isSourceNameSignalingEnabled()) {
+        // FIXME once legacy signaling using 'sendCommand' is removed, signalingLayer.setTrackVideoType must be adjusted
+        // to send the presence (not just modify it).
+        this._signalingLayer.setTrackVideoType(
+            getSourceNameForJitsiTrack(
+                this.myUserId(),
+                track.getType(),
+                0
+            ),
+            track.videoType);
+    }
+
+    const videoTypeTagName = 'videoType';
+
+    // if video type is camera and there is no videoType in presence, we skip adding it, as this is the default one
+    if (track.videoType !== VideoType.CAMERA || this.room.getFromPresence(videoTypeTagName)) {
+        this.sendCommand(videoTypeTagName, { value: track.videoType });
+    }
+};
+
+JitsiConference.prototype._setTrackMuteStatus = function(localTrack, isMuted) {
+    if (FeatureFlags.isSourceNameSignalingEnabled()) {
+        // TODO When legacy signaling part is removed, remember to adjust signalingLayer.setTrackMuteStatus, so that
+        // it triggers sending the presence (it only updates it for now, because the legacy code below sends).
+        this._signalingLayer.setTrackMuteStatus(
+            getSourceNameForJitsiTrack(this.myUserId(), localTrack.getType(), 0),
+            isMuted
+        );
+    }
+
+    if (localTrack.isAudioTrack()) {
+        this.room && this.room.setAudioMute(isMuted);
+    } else {
+        this.room && this.room.setVideoMute(isMuted);
+    }
+};
+
 /**
  * Method called by the {@link JitsiLocalTrack} (a video one) in order to add
  * back the underlying WebRTC MediaStream to the PeerConnection (which has

modules/RTC/JitsiLocalTrack.js

@@ -624,11 +624,8 @@ export default class JitsiLocalTrack extends JitsiTrack {
      * @returns {void}
      */
     _sendMuteStatus(mute) {
-        if (this.conference && this.conference.room) {
-            this.conference.room[
-                this.isAudioTrack()
-                    ? 'setAudioMute'
-                    : 'setVideoMute'](mute);
+        if (this.conference) {
+            this.conference._setTrackMuteStatus(this, mute);
         }
     }
 

modules/sdp/LocalSdpMunger.js

@@ -4,6 +4,7 @@ import { getLogger } from 'jitsi-meet-logger';
 
 import MediaDirection from '../../service/RTC/MediaDirection';
 import * as MediaType from '../../service/RTC/MediaType';
+import { getSourceNameForJitsiTrack } from '../../service/RTC/SignalingLayer';
 import VideoType from '../../service/RTC/VideoType';
 import FeatureFlags from '../flags/FeatureFlags';
 
@@ -352,13 +353,11 @@ export default class LocalSdpMunger {
             const nameExists = mediaSection.ssrcs.find(ssrc => ssrc.id === source && ssrc.attribute === 'name');
 
             if (!nameExists) {
-                const firstLetterOfMediaType = mediaType.substring(0, 1);
-
                 // Inject source names as a=ssrc:3124985624 name:endpointA-v0
                 mediaSection.ssrcs.push({
                     id: source,
                     attribute: 'name',
-                    value: `${this.localEndpointId}-${firstLetterOfMediaType}0`
+                    value: getSourceNameForJitsiTrack(this.localEndpointId, mediaType, 0)
                 });
             }
         }

modules/xmpp/ChatRoom.js

@@ -67,7 +67,7 @@ export const parser = {
  * @param pres the presence JSON
  * @param nodeName the name of the node (videomuted, audiomuted, etc)
  */
-function filterNodeFromPresenceJSON(pres, nodeName) {
+export function filterNodeFromPresenceJSON(pres, nodeName) {
     const res = [];
 
     for (let i = 0; i < pres.length; i++) {
@@ -1657,6 +1657,15 @@ export default class ChatRoom extends Listenable {
         return data;
     }
 
+    /**
+     * Returns the last presence advertised by a MUC member.
+     * @param {string} mucNick
+     * @returns {*}
+     */
+    getLastPresence(mucNick) {
+        return this.lastPresences[`${this.roomjid}/${mucNick}`];
+    }
+
     /**
      * Returns true if the SIP calls are supported and false otherwise
      */

modules/xmpp/JingleSessionPC.spec.js

@@ -55,6 +55,7 @@ describe('JingleSessionPC', () => {
         jingleSession.initialize(
             /* ChatRoom */ new MockChatRoom(),
             /* RTC */ rtc,
+            /* Signaling layer */ { },
             /* options */ { });
 
         // eslint-disable-next-line no-empty-function

modules/xmpp/SignalingLayerImpl.js

@@ -1,13 +1,21 @@
 /* global __filename */
 
 import { getLogger } from 'jitsi-meet-logger';
+import { Strophe } from 'strophe.js';
 
 import * as MediaType from '../../service/RTC/MediaType';
 import * as SignalingEvents from '../../service/RTC/SignalingEvents';
-import SignalingLayer from '../../service/RTC/SignalingLayer';
+import SignalingLayer, { getMediaTypeFromSourceName } from '../../service/RTC/SignalingLayer';
+import VideoType from '../../service/RTC/VideoType';
+import XMPPEvents from '../../service/xmpp/XMPPEvents';
+import FeatureFlags from '../flags/FeatureFlags';
+
+import { filterNodeFromPresenceJSON } from './ChatRoom';
 
 const logger = getLogger(__filename);
 
+export const SOURCE_INFO_PRESENCE_ELEMENT = 'SourceInfo';
+
 /**
  * Default XMPP implementation of the {@link SignalingLayer} interface. Obtains
  * the data from the MUC presence.
@@ -34,6 +42,45 @@ export default class SignalingLayerImpl extends SignalingLayer {
          * @type {ChatRoom|null}
          */
         this.chatRoom = null;
+
+        /**
+         * @type {Map<SourceName, SourceInfo>}
+         * @private
+         */
+        this._localSourceState = { };
+
+        /**
+         * @type {Map<EndpointId, Map<SourceName, SourceInfo>>}
+         * @private
+         */
+        this._remoteSourceState = { };
+    }
+
+    /**
+     * Adds <SourceInfo> element to the local presence.
+     *
+     * @returns {void}
+     * @private
+     */
+    _addLocalSourceInfoToPresence() {
+        if (this.chatRoom) {
+            this.chatRoom.addOrReplaceInPresence(
+                SOURCE_INFO_PRESENCE_ELEMENT,
+                { value: JSON.stringify(this._localSourceState) });
+        }
+    }
+
+    /**
+     * Check is given endpoint has advertised <SourceInfo/> in it's presence which means that the source name signaling
+     * is used by this endpoint.
+     *
+     * @param {EndpointId} endpointId
+     * @returns {boolean}
+     */
+    _doesEndpointSendNewSourceInfo(endpointId) {
+        const presence = this.chatRoom?.getLastPresence(endpointId);
+
+        return Boolean(presence && presence.find(node => node.tagName === SOURCE_INFO_PRESENCE_ELEMENT));
     }
 
     /**
@@ -51,40 +98,231 @@ export default class SignalingLayerImpl extends SignalingLayer {
                 'videomuted', this._videoMuteHandler);
             oldChatRoom.removePresenceListener(
                 'videoType', this._videoTypeHandler);
+            if (FeatureFlags.isSourceNameSignalingEnabled()) {
+                this._sourceInfoHandler
+                    && oldChatRoom.removePresenceListener(
+                        SOURCE_INFO_PRESENCE_ELEMENT, this._sourceInfoHandler);
+                this._memberLeftHandler
+                    && oldChatRoom.removeEventListener(
+                        XMPPEvents.MUC_MEMBER_LEFT, this._memberLeftHandler);
+            }
         }
         if (room) {
-            // SignalingEvents
-            this._audioMuteHandler = (node, from) => {
-                this.eventEmitter.emit(
-                    SignalingEvents.PEER_MUTED_CHANGED,
-                    from, MediaType.AUDIO, node.value === 'true');
-            };
-            room.addPresenceListener('audiomuted', this._audioMuteHandler);
-
-            this._videoMuteHandler = (node, from) => {
-                this.eventEmitter.emit(
-                    SignalingEvents.PEER_MUTED_CHANGED,
-                    from, MediaType.VIDEO, node.value === 'true');
-            };
-            room.addPresenceListener('videomuted', this._videoMuteHandler);
-
-            this._videoTypeHandler = (node, from) => {
-                this.eventEmitter.emit(
-                    SignalingEvents.PEER_VIDEO_TYPE_CHANGED,
-                    from, node.value);
-            };
-            room.addPresenceListener('videoType', this._videoTypeHandler);
+            if (FeatureFlags.isSourceNameSignalingEnabled()) {
+                this._bindChatRoomEventHandlers(room);
+                this._addLocalSourceInfoToPresence();
+            } else {
+                // TODO the logic below has been duplicated in _bindChatRoomEventHandlers, clean this up once
+                //  the new impl has been tested well enough
+                // SignalingEvents
+                this._audioMuteHandler = (node, from) => {
+                    this.eventEmitter.emit(
+                        SignalingEvents.PEER_MUTED_CHANGED,
+                        from, MediaType.AUDIO, node.value === 'true');
+                };
+                room.addPresenceListener('audiomuted', this._audioMuteHandler);
+
+                this._videoMuteHandler = (node, from) => {
+                    this.eventEmitter.emit(
+                        SignalingEvents.PEER_MUTED_CHANGED,
+                        from, MediaType.VIDEO, node.value === 'true');
+                };
+                room.addPresenceListener('videomuted', this._videoMuteHandler);
+
+                this._videoTypeHandler = (node, from) => {
+                    this.eventEmitter.emit(
+                        SignalingEvents.PEER_VIDEO_TYPE_CHANGED,
+                        from, node.value);
+                };
+                room.addPresenceListener('videoType', this._videoTypeHandler);
+            }
+        }
+    }
+
+    /**
+     * Binds event listeners to the chat room instance.
+     * @param {ChatRoom} room
+     * @private
+     * @returns {void}
+     */
+    _bindChatRoomEventHandlers(room) {
+        const emitAudioMutedEvent = (endpointId, muted) => {
+            this.eventEmitter.emit(
+                SignalingEvents.PEER_MUTED_CHANGED,
+                endpointId,
+                MediaType.AUDIO,
+                muted);
+        };
+        const emitVideoMutedEvent = (endpointId, muted) => {
+            this.eventEmitter.emit(
+                SignalingEvents.PEER_MUTED_CHANGED,
+                endpointId,
+                MediaType.VIDEO,
+                muted);
+        };
+
+        // SignalingEvents
+        this._audioMuteHandler = (node, from) => {
+            if (!this._doesEndpointSendNewSourceInfo(from)) {
+                emitAudioMutedEvent(from, node.value === 'true');
+            }
+        };
+        room.addPresenceListener('audiomuted', this._audioMuteHandler);
+
+        this._videoMuteHandler = (node, from) => {
+            if (!this._doesEndpointSendNewSourceInfo(from)) {
+                emitVideoMutedEvent(from, node.value === 'true');
+            }
+        };
+        room.addPresenceListener('videomuted', this._videoMuteHandler);
+
+        const emitVideoTypeEvent = (endpointId, videoType) => {
+            this.eventEmitter.emit(
+                SignalingEvents.PEER_VIDEO_TYPE_CHANGED,
+                endpointId, videoType);
+        };
+
+        this._videoTypeHandler = (node, from) => {
+            if (!this._doesEndpointSendNewSourceInfo(from)) {
+                emitVideoTypeEvent(from, node.value);
+            }
+        };
+        room.addPresenceListener('videoType', this._videoTypeHandler);
+
+        this._sourceInfoHandler = (node, mucNick) => {
+            const endpointId = mucNick;
+            const { value } = node;
+            const sourceInfoJSON = JSON.parse(value);
+            const emitEventsFromHere = this._doesEndpointSendNewSourceInfo(endpointId);
+            const endpointSourceState
+                = this._remoteSourceState[endpointId] || (this._remoteSourceState[endpointId] = {});
+
+            for (const sourceName of Object.keys(sourceInfoJSON)) {
+                const mediaType = getMediaTypeFromSourceName(sourceName);
+                const newMutedState = Boolean(sourceInfoJSON[sourceName].muted);
+                const oldSourceState = endpointSourceState[sourceName]
+                    || (endpointSourceState[sourceName] = { sourceName });
+
+                if (oldSourceState.muted !== newMutedState) {
+                    oldSourceState.muted = newMutedState;
+                    if (emitEventsFromHere && mediaType === MediaType.AUDIO) {
+                        emitAudioMutedEvent(endpointId, newMutedState);
+                    } else {
+                        emitVideoMutedEvent(endpointId, newMutedState);
+                    }
+                }
+
+                const newVideoType = sourceInfoJSON[sourceName].videoType;
+
+                if (oldSourceState.videoType !== newVideoType) {
+                    oldSourceState.videoType = newVideoType;
+                    emitEventsFromHere && emitVideoTypeEvent(endpointId, newVideoType);
+                }
+            }
+
+            // Cleanup removed source names
+            const newSourceNames = Object.keys(sourceInfoJSON);
+
+            for (const sourceName of Object.keys(endpointSourceState)) {
+                if (newSourceNames.indexOf(sourceName) === -1) {
+                    delete endpointSourceState[sourceName];
+                }
+            }
+        };
+        room.addPresenceListener('SourceInfo', this._sourceInfoHandler);
+
+        // Cleanup when participant leaves
+        this._memberLeftHandler = jid => {
+            const endpointId = Strophe.getResourceFromJid(jid);
+
+            delete this._remoteSourceState[endpointId];
+        };
+
+        room.addEventListener(XMPPEvents.MUC_MEMBER_LEFT, this._memberLeftHandler);
+    }
+
+    /**
+     * Finds the first source of given media type for the given endpoint.
+     * @param endpointId
+     * @param mediaType
+     * @returns {SourceInfo|null}
+     * @private
+     */
+    _findEndpointSourceInfoForMediaType(endpointId, mediaType) {
+        const remoteSourceState = this._remoteSourceState[endpointId];
+
+        if (!remoteSourceState) {
+            return null;
         }
+
+        for (const sourceInfo of Object.values(remoteSourceState)) {
+            const _mediaType = getMediaTypeFromSourceName(sourceInfo.sourceName);
+
+            if (_mediaType === mediaType) {
+                return sourceInfo;
+            }
+        }
+
+        return null;
     }
 
     /**
      * @inheritDoc
      */
     getPeerMediaInfo(owner, mediaType) {
-        if (this.chatRoom) {
-            return this.chatRoom.getMediaPresenceInfo(owner, mediaType);
+        const legacyGetPeerMediaInfo = () => {
+            if (this.chatRoom) {
+                return this.chatRoom.getMediaPresenceInfo(owner, mediaType);
+            }
+            logger.error('Requested peer media info, before room was set');
+        };
+
+        if (FeatureFlags.isSourceNameSignalingEnabled()) {
+            const lastPresence = this.chatRoom.getLastPresence(owner);
+
+            if (!lastPresence) {
+                throw new Error(`getPeerMediaInfo - no presence stored for: ${owner}`);
+            }
+
+            if (!this._doesEndpointSendNewSourceInfo(owner)) {
+                return legacyGetPeerMediaInfo();
+            }
+
+            /**
+             * @type {PeerMediaInfo}
+             */
+            const mediaInfo = {};
+            const endpointMediaSource = this._findEndpointSourceInfoForMediaType(owner, mediaType);
+
+            // The defaults are provided only, because getPeerMediaInfo is a legacy method. This will be eventually
+            // changed into a getSourceInfo method which returns undefined if there's no source. Also there will be
+            // no mediaType argument there.
+            if (mediaType === MediaType.AUDIO) {
+                mediaInfo.muted = endpointMediaSource ? endpointMediaSource.muted : true;
+            } else if (mediaType === MediaType.VIDEO) {
+                mediaInfo.muted = endpointMediaSource ? endpointMediaSource.muted : true;
+                mediaInfo.videoType = endpointMediaSource ? endpointMediaSource.videoType : undefined;
+
+                const codecTypeNode = filterNodeFromPresenceJSON(lastPresence, 'jitsi_participant_codecType');
+
+                if (codecTypeNode.length > 0) {
+                    mediaInfo.codecType = codecTypeNode[0].value;
+                }
+            } else {
+                throw new Error(`Unsupported media type: ${mediaType}`);
+            }
+
+            return mediaInfo;
         }
-        logger.error('Requested peer media info, before room was set');
+
+        return legacyGetPeerMediaInfo();
+    }
+
+    /**
+     * @inheritDoc
+     */
+    getPeerSourceInfo(owner, sourceName) {
+        return this._remoteSourceState[owner] ? this._remoteSourceState[owner][sourceName] : undefined;
     }
 
     /**
@@ -112,4 +350,47 @@ export default class SignalingLayerImpl extends SignalingLayer {
         }
         this.ssrcOwners.set(ssrc, endpointId);
     }
+
+    /**
+     * Adjusts muted status of given track.
+     *
+     * @param {SourceName} sourceName - the name of the track's source.
+     * @param {boolean} muted - the new muted status.
+     * @returns {boolean}
+     */
+    setTrackMuteStatus(sourceName, muted) {
+        if (!this._localSourceState[sourceName]) {
+            this._localSourceState[sourceName] = {};
+        }
+
+        this._localSourceState[sourceName].muted = muted;
+
+        if (this.chatRoom) {
+            // FIXME This only adjusts the presence, but doesn't actually send it. Here we temporarily rely on
+            // the legacy signaling part to send the presence. Remember to add "send presence" here when the legacy
+            // signaling is removed.
+            this._addLocalSourceInfoToPresence();
+        }
+    }
+
+    /**
+     * Sets track's video type.
+     * @param {SourceName} sourceName - the track's source name.
+     * @param {VideoType} videoType - the new video type.
+     */
+    setTrackVideoType(sourceName, videoType) {
+        if (!this._localSourceState[sourceName]) {
+            this._localSourceState[sourceName] = {};
+        }
+
+        if (this._localSourceState[sourceName].videoType !== videoType) {
+            // Include only if not a camera (default)
+            this._localSourceState[sourceName].videoType = videoType === VideoType.CAMERA ? undefined : videoType;
+
+            // NOTE this doesn't send the actual presence, because is called from the same place where the legacy video
+            // type is emitted which does the actual sending. A send presence statement needs to be added when
+            // the legacy part is removed.
+            this._addLocalSourceInfoToPresence();
+        }
+    }
 }

modules/xmpp/SignalingLayerImpl.spec.js

@@ -0,0 +1,416 @@
+import * as MediaType from '../../service/RTC/MediaType';
+import * as SignalingEvents from '../../service/RTC/SignalingEvents';
+import { getSourceNameForJitsiTrack } from '../../service/RTC/SignalingLayer';
+import VideoType from '../../service/RTC/VideoType';
+import XMPPEvents from '../../service/xmpp/XMPPEvents';
+import FeatureFlags from '../flags/FeatureFlags';
+import Listenable from '../util/Listenable';
+
+import SignalingLayerImpl, { SOURCE_INFO_PRESENCE_ELEMENT } from './SignalingLayerImpl';
+
+const INITIAL_SOURCE_INFO = { value: JSON.stringify({}) };
+
+// eslint-disable-next-line require-jsdoc
+function createMockChatRoom() {
+    const chatRoom = {
+        ...new Listenable(),
+        ...jasmine.createSpyObj('', [
+            'addOrReplaceInPresence',
+            'setAudioMute',
+            'setVideoMute'
+        ])
+    };
+
+    const listeners = {};
+
+    // Stores presence listeners
+    chatRoom.addPresenceListener = (tagName, l) => {
+        listeners[tagName] || (listeners[tagName] = []);
+        listeners[tagName].push(l);
+    };
+
+    // Notify presence listeners
+    chatRoom.emitPresenceListener = (node, mucNick) => {
+        const nodeListeners = listeners[node.tagName];
+
+        if (nodeListeners) {
+            for (const l of nodeListeners) {
+                l(node, mucNick);
+            }
+        }
+    };
+
+    // Fakes 'SourceInfo' in the presence by adjusting getLastPresence return value and emitting a presence event.
+    chatRoom.mockSourceInfoPresence = (endpointId, sourceInfo) => {
+        chatRoom.getLastPresence = () => [ {
+            tagName: SOURCE_INFO_PRESENCE_ELEMENT,
+            value: JSON.stringify(sourceInfo)
+        } ];
+        chatRoom.emitPresenceListener({
+            tagName: SOURCE_INFO_PRESENCE_ELEMENT,
+            value: JSON.stringify(sourceInfo)
+        }, endpointId);
+    };
+
+    chatRoom.emitParticipantLeft = endpointId => {
+        // Only the resource part (MUC nick) is relevant
+        chatRoom.eventEmitter.emit(XMPPEvents.MUC_MEMBER_LEFT, `room@server.com/${endpointId}`);
+    };
+
+    return chatRoom;
+}
+
+describe('SignalingLayerImpl', () => {
+    describe('setTrackMuteStatus advertises the track muted status in the chat room', () => {
+        describe('with source name signaling enabled', () => {
+            const endpointId = 'abcdef12';
+            let signalingLayer;
+            let chatRoom;
+
+            beforeEach(() => {
+                FeatureFlags.init({ sourceNameSignaling: true });
+                signalingLayer = new SignalingLayerImpl();
+                chatRoom = createMockChatRoom();
+                signalingLayer.setChatRoom(chatRoom);
+
+                // No tracks yet
+                expect(chatRoom.addOrReplaceInPresence)
+                    .toHaveBeenCalledWith(
+                        SOURCE_INFO_PRESENCE_ELEMENT,
+                        INITIAL_SOURCE_INFO);
+            });
+            it('for audio track', () => {
+                const audioSourceName = getSourceNameForJitsiTrack(endpointId, MediaType.AUDIO, 0);
+
+                // Audio track: muted
+                signalingLayer.setTrackMuteStatus(audioSourceName, true);
+                expect(chatRoom.addOrReplaceInPresence)
+                    .toHaveBeenCalledWith(
+                        SOURCE_INFO_PRESENCE_ELEMENT,
+                        { value: `{"${audioSourceName}":{"muted":true}}` });
+
+                // Audio track: unmuted
+                signalingLayer.setTrackMuteStatus(audioSourceName, false);
+                expect(chatRoom.addOrReplaceInPresence)
+                    .toHaveBeenCalledWith(
+                        SOURCE_INFO_PRESENCE_ELEMENT,
+                        { value: `{"${audioSourceName}":{"muted":false}}` });
+            });
+            it('for video track', () => {
+                const videoSourceName = getSourceNameForJitsiTrack(endpointId, MediaType.VIDEO, 0);
+
+                // Video track: muted
+                signalingLayer.setTrackMuteStatus(videoSourceName, true);
+                expect(chatRoom.addOrReplaceInPresence)
+                    .toHaveBeenCalledWith(
+                        SOURCE_INFO_PRESENCE_ELEMENT,
+                        { value: `{"${videoSourceName}":{"muted":true}}` });
+
+                // Video track: unmuted
+                signalingLayer.setTrackMuteStatus(videoSourceName, false);
+                expect(chatRoom.addOrReplaceInPresence)
+                    .toHaveBeenCalledWith(
+                        SOURCE_INFO_PRESENCE_ELEMENT,
+                        { value: `{"${videoSourceName}":{"muted":false}}` });
+            });
+        });
+    });
+    describe('setTrackVideoType', () => {
+        const endpointId = 'abcdef12';
+        let signalingLayer;
+        let chatRoom = createMockChatRoom();
+
+        beforeEach(() => {
+            FeatureFlags.init({ sourceNameSignaling: true });
+            signalingLayer = new SignalingLayerImpl();
+            chatRoom = createMockChatRoom();
+            signalingLayer.setChatRoom(chatRoom);
+
+            // Initial value is set in signalingLayer.setChatRoom
+            expect(chatRoom.addOrReplaceInPresence)
+                .toHaveBeenCalledWith(
+                    SOURCE_INFO_PRESENCE_ELEMENT,
+                    INITIAL_SOURCE_INFO);
+        });
+        it('sends video type in chat room presence', () => {
+            const videoSourceName = getSourceNameForJitsiTrack(endpointId, MediaType.VIDEO, 0);
+
+            signalingLayer.setTrackVideoType(videoSourceName, VideoType.CAMERA);
+            expect(chatRoom.addOrReplaceInPresence)
+                .toHaveBeenCalledWith(
+                    SOURCE_INFO_PRESENCE_ELEMENT,
+                    { value: '{"abcdef12-v0":{}}' });
+
+            signalingLayer.setTrackVideoType(videoSourceName, VideoType.DESKTOP);
+            expect(chatRoom.addOrReplaceInPresence)
+                .toHaveBeenCalledWith(
+                    SOURCE_INFO_PRESENCE_ELEMENT,
+                    { value: '{"abcdef12-v0":{"videoType":"desktop"}}' });
+
+            signalingLayer.setTrackVideoType(videoSourceName, VideoType.CAMERA);
+            expect(chatRoom.addOrReplaceInPresence)
+                .toHaveBeenCalledWith(
+                    SOURCE_INFO_PRESENCE_ELEMENT,
+                    { value: '{"abcdef12-v0":{}}' });
+        });
+    });
+    describe('should emit muted/video type events based on presence', () => {
+        describe('with:  sourceNameSignaling: true', () => {
+            let signalingLayer;
+            let chatRoom = createMockChatRoom();
+
+            beforeEach(() => {
+                FeatureFlags.init({ sourceNameSignaling: true });
+                signalingLayer = new SignalingLayerImpl();
+                chatRoom = createMockChatRoom();
+                signalingLayer.setChatRoom(chatRoom);
+            });
+            it('from a legacy user (no SourceInfo)', () => {
+                const emitterSpy = spyOn(signalingLayer.eventEmitter, 'emit');
+
+                chatRoom.getLastPresence = () => [];
+                chatRoom.emitPresenceListener({
+                    tagName: 'audiomuted',
+                    value: 'true'
+                }, 'endpoint1');
+
+                expect(emitterSpy).toHaveBeenCalledWith(
+                    SignalingEvents.PEER_MUTED_CHANGED,
+                    'endpoint1',
+                    'audio',
+                    true
+                );
+            });
+            it('from a user with SourceInfo', () => {
+                const emitterSpy = spyOn(signalingLayer.eventEmitter, 'emit');
+                const sourceInfo = {
+                    '12345678-a0': {
+                        muted: true
+                    }
+                };
+
+                chatRoom.mockSourceInfoPresence('endpoint1', sourceInfo);
+
+                // <audiomuted/> still included for backwards compat and ChatRoom will emit the presence event
+                chatRoom.emitPresenceListener({
+                    tagName: 'audiomuted',
+                    value: 'true'
+                }, 'endpoint1');
+
+                // Just once event though the legacy presence is there as well
+                expect(emitterSpy).toHaveBeenCalledTimes(1);
+                expect(emitterSpy).toHaveBeenCalledWith(
+                    SignalingEvents.PEER_MUTED_CHANGED,
+                    'endpoint1',
+                    'audio',
+                    true
+                );
+            });
+        });
+        describe('with:  sourceNameSignaling: false', () => {
+            let signalingLayer;
+            let chatRoom;
+
+            beforeEach(() => {
+                FeatureFlags.init({ sourceNameSignaling: false });
+                signalingLayer = new SignalingLayerImpl();
+                chatRoom = createMockChatRoom();
+                signalingLayer.setChatRoom(chatRoom);
+            });
+            it('does not react to SourceInfo', () => {
+                const emitterSpy = spyOn(signalingLayer.eventEmitter, 'emit');
+                const sourceInfo = {
+                    '12345678-a0': {
+                        muted: true
+                    }
+                };
+
+                chatRoom.mockSourceInfoPresence('endpoint1', sourceInfo);
+
+                expect(emitterSpy).not.toHaveBeenCalled();
+            });
+        });
+    });
+    describe('getPeerMediaInfo', () => {
+        describe('with:  sourceNameSignaling: true', () => {
+            let signalingLayer;
+            let chatRoom;
+
+            beforeEach(() => {
+                FeatureFlags.init({ sourceNameSignaling: true });
+                signalingLayer = new SignalingLayerImpl();
+                chatRoom = createMockChatRoom();
+                signalingLayer.setChatRoom(chatRoom);
+            });
+            it('will provide default value if only empty source info was sent so far', () => {
+                const endpointId = '12345678';
+
+                chatRoom.mockSourceInfoPresence(endpointId, { });
+
+                const audioPeerMediaInfo = signalingLayer.getPeerMediaInfo(endpointId, MediaType.AUDIO);
+
+                expect(audioPeerMediaInfo).toEqual({ muted: true });
+
+                const videoPeerMediaInfo = signalingLayer.getPeerMediaInfo(endpointId, MediaType.VIDEO);
+
+                expect(videoPeerMediaInfo).toEqual({
+                    muted: true,
+                    videoType: undefined
+                });
+            });
+            describe('will read from SourceInfo if available', () => {
+                it('for audio', () => {
+                    const endpointId = '12345678';
+                    const sourceInfo = {
+                        '12345678-a0': {
+                            muted: true
+                        }
+                    };
+
+                    chatRoom.mockSourceInfoPresence(endpointId, sourceInfo);
+
+                    const peerMediaInfo = signalingLayer.getPeerMediaInfo(endpointId, MediaType.AUDIO);
+
+                    expect(peerMediaInfo).toEqual({ muted: true });
+                });
+                it('for video', () => {
+                    const endointId = '12345678';
+                    const sourceInfo = {
+                        '12345678-v0': {
+                            muted: true,
+                            videoType: 'desktop'
+                        }
+                    };
+
+                    chatRoom.mockSourceInfoPresence(endointId, sourceInfo);
+
+                    const peerMediaInfo = signalingLayer.getPeerMediaInfo(endointId, MediaType.VIDEO);
+
+                    expect(peerMediaInfo).toEqual({
+                        muted: true,
+                        videoType: 'desktop'
+                    });
+                });
+            });
+            describe('if there\'s no SourceInfo then will read from the legacy element', () => {
+                const endointId = '12345678';
+
+                it('for audio', () => {
+                    // There's no 'SourceInfo' in the presence
+                    chatRoom.getLastPresence = () => [ { } ];
+
+                    // This test is very implementation specific and relies on the fact that the backwards compat logic
+                    // is supposed to call into 'chatRoom.getMediaPresenceInfo' and return whatever it returns.
+                    // To be removed once legacy signaling is deprecated.
+                    chatRoom.getMediaPresenceInfo = () => {
+                        return {
+                            muted: true
+                        };
+                    };
+
+                    const peerMediaInfo = signalingLayer.getPeerMediaInfo(endointId, MediaType.AUDIO);
+
+                    expect(peerMediaInfo).toEqual({ muted: true });
+                });
+                it('for video', () => {
+                    // There's no 'SourceInfo' in the presence
+                    chatRoom.getLastPresence = () => [ { } ];
+
+                    // This test is very implementation specific and relies on the fact that the backwards compat logic
+                    // is supposed to call into 'chatRoom.getMediaPresenceInfo' and return whatever it returns.
+                    // To be removed once legacy signaling is deprecated.
+                    chatRoom.getMediaPresenceInfo = () => {
+                        return {
+                            muted: true,
+                            videoType: 'desktop'
+                        };
+                    };
+
+                    const peerMediaInfo = signalingLayer.getPeerMediaInfo(endointId, MediaType.VIDEO);
+
+                    expect(peerMediaInfo).toEqual({
+                        muted: true,
+                        videoType: 'desktop'
+                    });
+                });
+            });
+        });
+        describe('with:  sourceNameSignaling: false', () => {
+            beforeEach(() => {
+                FeatureFlags.init({ sourceNameSignaling: false });
+            });
+            it('should not read from SourceInfo element', () => {
+                const signalingLayer = new SignalingLayerImpl();
+                const chatRoom = createMockChatRoom();
+
+                signalingLayer.setChatRoom(chatRoom);
+
+                const endointId = '12345678';
+                const sourceInfo = {
+                    '12345678-v0': {
+                        muted: true,
+                        videoType: 'desktop'
+                    }
+                };
+
+                chatRoom.mockSourceInfoPresence(endointId, sourceInfo);
+
+                // This is the value the legacy flow will use (the values are different that the SourceInfo one).
+                const legacyMediaInfoValue = {
+                    muted: false,
+                    videoType: 'camera'
+                };
+
+                chatRoom.getMediaPresenceInfo = () => legacyMediaInfoValue;
+
+                const peerMediaInfo = signalingLayer.getPeerMediaInfo(endointId, MediaType.VIDEO);
+
+                expect(peerMediaInfo).toEqual(legacyMediaInfoValue);
+            });
+        });
+    });
+    describe('will remove source info(cleanup corner cases)', () => {
+        let signalingLayer;
+        let chatRoom;
+        const endpointId = '12345678';
+
+        beforeEach(() => {
+            FeatureFlags.init({ sourceNameSignaling: true });
+
+            signalingLayer = new SignalingLayerImpl();
+            chatRoom = createMockChatRoom();
+
+            signalingLayer.setChatRoom(chatRoom);
+        });
+        it('when participant leaves', () => {
+            const sourceInfo = {
+                '12345678-v0': {
+                    muted: false,
+                    videoType: 'desktop'
+                }
+            };
+
+            chatRoom.mockSourceInfoPresence(endpointId, sourceInfo);
+
+            expect(signalingLayer.getPeerSourceInfo(endpointId, '12345678-v0')).toBeDefined();
+
+            chatRoom.emitParticipantLeft(endpointId);
+
+            expect(signalingLayer.getPeerSourceInfo(endpointId, '12345678-v0')).toBeUndefined();
+        });
+        it('when it\'s no longer in the presence', () => {
+            chatRoom.mockSourceInfoPresence(endpointId, {
+                '12345678-v0': { muted: false }
+            });
+
+            expect(signalingLayer.getPeerSourceInfo(endpointId, '12345678-v0')).toBeDefined();
+
+            chatRoom.mockSourceInfoPresence(endpointId, {
+                '12345678-v1': { muted: false }
+            });
+
+            expect(signalingLayer.getPeerSourceInfo(endpointId, '12345678-v0')).toBeUndefined();
+            expect(signalingLayer.getPeerSourceInfo(endpointId, '12345678-v1')).toBeDefined();
+        });
+    });
+});

service/RTC/SignalingLayer.js

@@ -1,5 +1,59 @@
 
 import Listenable from '../../modules/util/Listenable';
+import * as MediaType from '../../service/RTC/MediaType';
+
+/**
+ * @typedef {string} EndpointId
+ */
+/**
+ * @typedef {string} SourceName
+ */
+/**
+ * @typedef {Object} SourceInfo
+ *
+ * @property {SourceName} sourceName - Name of the media source.
+ * @property {boolean} [muted=false] - Tells if the source is muted (paused?).
+ * @property {string} [videoType] - Type of the video for video type.
+ */
+
+/**
+ * Generates a source name.
+ *
+ * @param {EndpointId} endpointId - Jitsi Endpoint Id.
+ * @param {MediaType} mediaType - the media type string.
+ * @param {number} trackIdx - Track index (or sender idx? - to be figured out) starting from 0.
+ * @returns {SourceName} eg. endpointA-v0
+ */
+export function getSourceNameForJitsiTrack(endpointId, mediaType, trackIdx) {
+    const firstLetterOfMediaType = mediaType.substring(0, 1);
+
+    return `${endpointId}-${firstLetterOfMediaType}${trackIdx}`;
+}
+
+/**
+ * Extracts MediaType from give source name (must be in the correct format as generated by
+ * {@link getSourceNameForJitsiTrack}).
+ *
+ * @param {SourceName} sourceName - the source name.
+ * @returns {MediaType}
+ */
+export function getMediaTypeFromSourceName(sourceName) {
+    const firstLetterOfMediaTypeIdx = sourceName.indexOf('-') + 1;
+
+    if (firstLetterOfMediaTypeIdx <= 0) {
+        throw new Error(`Invalid source name: ${sourceName}`);
+    }
+
+    const firstLetterOfMediaType = sourceName.substr(firstLetterOfMediaTypeIdx, 1);
+
+    for (const type of Object.values(MediaType)) {
+        if (type.substr(0, 1) === firstLetterOfMediaType) {
+            return type;
+        }
+    }
+
+    throw new Error(`Invalid source name: ${sourceName}`);
+}
 
 /**
  * An object that carries the info about specific media type advertised by
@@ -36,8 +90,20 @@ export default class SignalingLayer extends Listenable {
      * @return {PeerMediaInfo|null} presenceInfo an object with media presence
      * info or <tt>null</tt> either if there is no presence available for given
      * JID or if the media type given is invalid.
+     *
+     * @deprecated This method is to be replaced with getPeerSourceInfo.
      */
     getPeerMediaInfo(owner, mediaType) { // eslint-disable-line no-unused-vars
         throw new Error('not implemented');
     }
+
+    /**
+     * Obtains the info about a source for given name and endpoint ID.
+     * @param {EndpointId} owner - The owner's endpoint ID.
+     * @param {SourceName} sourceName - The name of the source for which the info is to be obtained.
+     * @returns {SourceInfo | undefined}
+     */
+    getPeerSourceInfo(owner, sourceName) { // eslint-disable-line no-unused-vars
+        throw new Error('not implemented');
+    }
 }