fix(multi-stream) Handle source-name based presence updates.

Handle presence updates for multiple sources per remote endpoint.

modules/RTC/TraceablePeerConnection.js

 
     // SignalingLayer listeners
     this._peerVideoTypeChanged = this._peerVideoTypeChanged.bind(this);
-    this.signalingLayer.on(
-        SignalingEvents.PEER_VIDEO_TYPE_CHANGED,
-        this._peerVideoTypeChanged);
+    this.signalingLayer.on(SignalingEvents.PEER_VIDEO_TYPE_CHANGED, this._peerVideoTypeChanged);
 
     this._peerMutedChanged = this._peerMutedChanged.bind(this);
-    this.signalingLayer.on(
-        SignalingEvents.PEER_MUTED_CHANGED,
-        this._peerMutedChanged);
+    this.signalingLayer.on(SignalingEvents.PEER_MUTED_CHANGED, this._peerMutedChanged);
     this.options = options;
 
+    // Setup SignalingLayer listeners for source-name based events.
+    this.signalingLayer.on(SignalingEvents.SOURCE_MUTED_CHANGED,
+        (sourceName, isMuted) => this._sourceMutedChanged(sourceName, isMuted));
+    this.signalingLayer.on(SignalingEvents.SOURCE_VIDEO_TYPE_CHANGED,
+        (sourceName, videoType) => this._sourceVideoTypeChanged(sourceName, videoType));
+
     // Make sure constraints is properly formatted in order to provide information about whether or not this
     // connection is P2P to rtcstats.
     const safeConstraints = constraints || {};
  * @param {VideoType} videoType the new value
  * @private
  */
-TraceablePeerConnection.prototype._peerVideoTypeChanged = function(
-        endpointId,
-        videoType) {
+TraceablePeerConnection.prototype._peerVideoTypeChanged = function(endpointId, videoType) {
     // Check if endpointId has a value to avoid action on random track
     if (!endpointId) {
         logger.error(`${this} No endpointID on peerVideoTypeChanged`);
  * @param {boolean} isMuted the new mute state
  * @private
  */
-TraceablePeerConnection.prototype._peerMutedChanged = function(
-        endpointId,
-        mediaType,
-        isMuted) {
+TraceablePeerConnection.prototype._peerMutedChanged = function(endpointId, mediaType, isMuted) {
     // Check if endpointId is a value to avoid doing action on all remote tracks
     if (!endpointId) {
         logger.error(`${this} On peerMuteChanged - no endpoint ID`);
     }
 };
 
+/**
+ * Handles remote source mute and unmute changed events.
+ *
+ * @param {string} sourceName - The name of the remote source.
+ * @param {boolean} isMuted - The new mute state.
+ */
+TraceablePeerConnection.prototype._sourceMutedChanged = function(sourceName, isMuted) {
+    const track = this.getRemoteTracks().find(t => t.getSourceName() === sourceName);
+
+    if (!track) {
+        return;
+    }
+
+    track.setMute(isMuted);
+};
+
+/**
+ * Handles remote source videoType changed events.
+ *
+ * @param {string} sourceName - The name of the remote source.
+ * @param {boolean} isMuted - The new value.
+ */
+TraceablePeerConnection.prototype._sourceVideoTypeChanged = function(sourceName, videoType) {
+    const track = this.getRemoteTracks().find(t => t.getSourceName() === sourceName);
+
+    if (!track) {
+        return;
+    }
+
+    track._setVideoType(videoType);
+};
+
 /**
  * Obtains audio levels of the remote audio tracks by getting the source information on the RTCRtpReceivers.
  * The information relevant to the ssrc is updated each time a RTP packet constaining the ssrc is received.

modules/xmpp/SignalingLayerImpl.js

 
                 if (oldSourceState.muted !== newMutedState) {
                     oldSourceState.muted = newMutedState;
-                    if (emitEventsFromHere && mediaType === MediaType.AUDIO) {
-                        emitAudioMutedEvent(endpointId, newMutedState);
-                    } else {
-                        emitVideoMutedEvent(endpointId, newMutedState);
+                    if (emitEventsFromHere && !this._localSourceState[sourceName]) {
+                        this.eventEmitter.emit(SignalingEvents.SOURCE_MUTED_CHANGED, sourceName, newMutedState);
                     }
                 }
 
                 if (oldSourceState.videoType !== newVideoType) {
                     oldSourceState.videoType = newVideoType;
 
-                    // videoType is not allowed to change on a given JitsiLocalTrack when multi stream support is
-                    // enabled.
-                    emitEventsFromHere
-                        && !FeatureFlags.isMultiStreamSupportEnabled()
-                        && emitVideoTypeEvent(endpointId, newVideoType);
+                    // Since having a mix of eps that do/don't support multi-stream in the same call is supported, emit
+                    // SOURCE_VIDEO_TYPE_CHANGED event when the remote source changes videoType.
+                    if (emitEventsFromHere && !this._localSourceState[sourceName]) {
+                        this.eventEmitter.emit(SignalingEvents.SOURCE_VIDEO_TYPE_CHANGED, sourceName, newVideoType);
+                    }
                 }
             }
 

modules/xmpp/SignalingLayerImpl.spec.js

                 // Just once event though the legacy presence is there as well
                 expect(emitterSpy).toHaveBeenCalledTimes(1);
                 expect(emitterSpy).toHaveBeenCalledWith(
-                    SignalingEvents.PEER_MUTED_CHANGED,
-                    'endpoint1',
-                    'audio',
+                    SignalingEvents.SOURCE_MUTED_CHANGED,
+                    '12345678-a0',
                     true
                 );
             });

service/RTC/SignalingEvents.spec.ts

     const {
         PEER_MUTED_CHANGED,
         PEER_VIDEO_TYPE_CHANGED,
+        SOURCE_MUTED_CHANGED,
+        SOURCE_VIDEO_TYPE_CHANGED,
         SignalingEvents,
         ...others
     } = exported;
     it( "known members", () => {
         expect( PEER_MUTED_CHANGED ).toBe( 'signaling.peerMuted' );
         expect( PEER_VIDEO_TYPE_CHANGED ).toBe( 'signaling.peerVideoType' );
+        expect( SOURCE_MUTED_CHANGED ).toBe( 'signaling.sourceMuted');
+        expect( SOURCE_VIDEO_TYPE_CHANGED ).toBe( 'signaling.sourceVideoType');
 
         expect( SignalingEvents ).toBeDefined();
 

service/RTC/SignalingEvents.ts

 export enum SignalingEvents {
     /**
      * Event triggered when participant's muted status changes.
+     *
      * @param {string} endpointId the track owner's identifier (MUC nickname)
      * @param {MediaType} mediaType "audio" or "video"
      * @param {boolean} isMuted the new muted state
 
     /**
      * Event triggered when participant's video type changes.
+     *
      * @param {string} endpointId the video owner's ID (MUC nickname)
      * @param {VideoType} videoType the new value
      */
-    PEER_VIDEO_TYPE_CHANGED = 'signaling.peerVideoType'
+    PEER_VIDEO_TYPE_CHANGED = 'signaling.peerVideoType',
+
+    /**
+     * Event triggered when source's muted status changes.
+     *
+     * @param {string} sourceName - The name of the source.
+     * @param {boolean} isMuted - The new muted state.
+     */
+    SOURCE_MUTED_CHANGED = 'signaling.sourceMuted',
+
+    /**
+     * Event triggered when source's video type changes.
+     *
+     * @param {string} source - The name of the source.
+     * @param {VideoType} videoType - The new value.
+     */
+    SOURCE_VIDEO_TYPE_CHANGED = 'signaling.sourceVideoType'
 }
 
 // exported for backward compatibility
 export const PEER_MUTED_CHANGED = SignalingEvents.PEER_MUTED_CHANGED;
 export const PEER_VIDEO_TYPE_CHANGED = SignalingEvents.PEER_VIDEO_TYPE_CHANGED;
+export const SOURCE_MUTED_CHANGED = SignalingEvents.SOURCE_MUTED_CHANGED;
+export const SOURCE_VIDEO_TYPE_CHANGED = SignalingEvents.SOURCE_VIDEO_TYPE_CHANGED;

types/auto/modules/RTC/TraceablePeerConnection.d.ts

      * <tt>false</tt> if it's turned off.
      */
     isSimulcastOn(): boolean;
+    /**
+     * Handles remote source mute and unmute changed events.
+     *
+     * @param {string} sourceName - The name of the remote source.
+     * @param {boolean} isMuted - The new mute state.
+     */
+    _sourceMutedChanged(sourceName: string, isMuted: boolean): void;
+    /**
+     * Handles remote source videoType changed events.
+     *
+     * @param {string} sourceName - The name of the remote source.
+     * @param {boolean} isMuted - The new value.
+     */
+    _sourceVideoTypeChanged(sourceName: string, videoType: any): void;
     /**
      * Obtains audio levels of the remote audio tracks by getting the source information on the RTCRtpReceivers.
      * The information relevant to the ssrc is updated each time a RTP packet constaining the ssrc is received.

types/auto/service/RTC/SignalingEvents.d.ts

 export declare enum SignalingEvents {
     /**
      * Event triggered when participant's muted status changes.
+     *
      * @param {string} endpointId the track owner's identifier (MUC nickname)
      * @param {MediaType} mediaType "audio" or "video"
      * @param {boolean} isMuted the new muted state
     PEER_MUTED_CHANGED = "signaling.peerMuted",
     /**
      * Event triggered when participant's video type changes.
+     *
      * @param {string} endpointId the video owner's ID (MUC nickname)
      * @param {VideoType} videoType the new value
      */
-    PEER_VIDEO_TYPE_CHANGED = "signaling.peerVideoType"
+    PEER_VIDEO_TYPE_CHANGED = "signaling.peerVideoType",
+    /**
+     * Event triggered when source's muted status changes.
+     *
+     * @param {string} sourceName - The name of the source.
+     * @param {boolean} isMuted - The new muted state.
+     */
+    SOURCE_MUTED_CHANGED = "signaling.sourceMuted",
+    /**
+     * Event triggered when source's video type changes.
+     *
+     * @param {string} source - The name of the source.
+     * @param {VideoType} videoType - The new value.
+     */
+    SOURCE_VIDEO_TYPE_CHANGED = "signaling.sourceVideoType"
 }
 export declare const PEER_MUTED_CHANGED = SignalingEvents.PEER_MUTED_CHANGED;
 export declare const PEER_VIDEO_TYPE_CHANGED = SignalingEvents.PEER_VIDEO_TYPE_CHANGED;
+export declare const SOURCE_MUTED_CHANGED = SignalingEvents.SOURCE_MUTED_CHANGED;
+export declare const SOURCE_VIDEO_TYPE_CHANGED = SignalingEvents.SOURCE_VIDEO_TYPE_CHANGED;