fix(TPC): Switch media direction correctly on all m-lines associated with local tracks during p2p->jvb switch.

Fixes cases where SS stream is not being sent when p2p->jvb switch happens.

modules/RTC/MockClasses.js

         return Promise.resolve(/* answer */{});
     }
 
+    /**
+     * {@link TraceablePeerConnection.processLocalSdpForTransceiverInfo}.
+     *
+     * @returns {void}
+     */
+    processLocalSdpForTransceiverInfo() {
+    }
+
     /**
      * {@link TraceablePeerConnection.setLocalDescription}.
      *

modules/RTC/TPCUtils.js

                 const trackIndex = Number(sourceName.split('-')[1].substring(1));
 
                 if (trackIndex) {
-                    transceiver = this.pc.peerconnection.getTransceivers()
-                        .filter(t => t.receiver.track.kind === mediaType
-                            && t.direction !== MediaDirection.RECVONLY)[trackIndex];
+                    transceiver = this.pc.isP2P
+                        ? this.pc.peerconnection.getTransceivers()
+                            .filter(t => t.receiver.track.kind === mediaType)[trackIndex]
+                        : this.pc.peerconnection.getTransceivers()
+                            .filter(t => t.receiver.track.kind === mediaType
+                                && t.direction !== MediaDirection.RECVONLY)[trackIndex];
                 }
             }
         }
     setMediaTransferActive(mediaType, active) {
         const transceivers = this.pc.peerconnection.getTransceivers()
             .filter(t => t.receiver && t.receiver.track && t.receiver.track.kind === mediaType);
-        const localTracks = this.pc.getLocalTracks(mediaType);
 
         logger.info(`${this.pc} ${active ? 'Enabling' : 'Suspending'} ${mediaType} media transfer.`);
-        transceivers.forEach((transceiver, idx) => {
+        transceivers.forEach(transceiver => {
             if (active) {
-                // The first transceiver is for the local track and only this one can be set to 'sendrecv'.
-                // When multi-stream is enabled, there can be multiple transceivers with outbound streams.
-                if (idx < localTracks.length) {
+                const localTrackMids = Array.from(this.pc._localTrackTransceiverMids);
+
+                if (localTrackMids.find(mids => mids[1] === transceiver.mid)) {
                     transceiver.direction = MediaDirection.SENDRECV;
                 } else {
                     transceiver.direction = MediaDirection.RECVONLY;

modules/RTC/TraceablePeerConnection.js

      */
     this._senderMaxHeights = new Map();
 
+    /**
+     * Holds the RTCRtpTransceiver mids that the local tracks are attached to, mapped per their
+     * {@link JitsiLocalTrack.rtcId}.
+     * @type {Map<string, string>}
+     */
+    this._localTrackTransceiverMids = new Map();
+
     // override as desired
     this.trace = (what, info) => {
         logger.debug(what, info);
     }
 };
 
+/**
+ * Processes the local description SDP and caches the mids of the mlines associated with the given tracks.
+ *
+ * @param {Array<JitsiLocalTrack>} localTracks - local tracks that are added to the peerconnection.
+ * @returns {void}
+ */
+TraceablePeerConnection.prototype.processLocalSdpForTransceiverInfo = function(localTracks) {
+    const localSdp = this.peerconnection.localDescription?.sdp;
+
+    if (!localSdp) {
+        return;
+    }
+
+    for (const localTrack of localTracks) {
+        const mediaType = localTrack.getType();
+        const parsedSdp = transform.parse(localSdp);
+        const mLine = parsedSdp.media.find(mline => mline.type === mediaType);
+
+        if (!this._localTrackTransceiverMids.has(localTrack.rtcId)) {
+            this._localTrackTransceiverMids.set(localTrack.rtcId, mLine.mid.toString());
+        }
+    }
+};
+
 /**
  * Replaces <tt>oldTrack</tt> with <tt>newTrack</tt> from the peer connection.
  * Either <tt>oldTrack</tt> or <tt>newTrack</tt> can be null; replacing a valid
 
         return promise
             .then(transceiver => {
+                if (oldTrack) {
+                    this.localTracks.delete(oldTrack.rtcId);
+                    this._localTrackTransceiverMids.delete(oldTrack.rtcId);
+                }
+
                 if (newTrack) {
                     if (newTrack.isAudioTrack()) {
                         this._hasHadAudioTrack = true;
                     } else {
                         this._hasHadVideoTrack = true;
                     }
+                    this._localTrackTransceiverMids.set(newTrack.rtcId, transceiver?.mid?.toString());
+                    this.localTracks.set(newTrack.rtcId, newTrack);
                 }
 
-                oldTrack && this.localTracks.delete(oldTrack.rtcId);
-                newTrack && this.localTracks.set(newTrack.rtcId, newTrack);
-
                 // Update the local SSRC cache for the case when one track gets replaced with another and no
                 // renegotiation is triggered as a result of this.
                 if (oldTrack && newTrack) {

modules/xmpp/JingleSessionPC.js

                 .then(() => this.peerconnection.createOffer(this.mediaConstraints))
                 .then(offerSdp => this.peerconnection.setLocalDescription(offerSdp))
                 .then(() => {
+                    this.peerconnection.processLocalSdpForTransceiverInfo(localTracks);
+
                     // NOTE that the offer is obtained from the localDescription getter as it needs to go though
                     // the transformation chain.
                     this.sendSessionInitiate(this.peerconnection.localDescription.sdp);
             Promise.all(addTracks)
                 .then(() => this._responderRenegotiate(remoteDescription))
                 .then(() => {
+                    this.peerconnection.processLocalSdpForTransceiverInfo(localTracks);
                     if (this.state === JingleSessionState.PENDING) {
                         this.state = JingleSessionState.ACTIVE;
 

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

      * @returns {Promise<Object>}
      */
     createAnswer(): Promise<any>;
+    /**
+     * {@link TraceablePeerConnection.processLocalSdpForTransceiverInfo}.
+     *
+     * @returns {void}
+     */
+    processLocalSdpForTransceiverInfo(): void;
     /**
      * {@link TraceablePeerConnection.setLocalDescription}.
      *

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

      * @type {Map<string, number>}
      */
     _senderMaxHeights: Map<string, number>;
+    /**
+     * Holds the RTCRtpTransceiver mids that the local tracks are attached to, mapped per their
+     * {@link JitsiLocalTrack.rtcId}.
+     * @type {Map<string, string>}
+     */
+    _localTrackTransceiverMids: Map<string, string>;
     trace: (what: any, info: any) => void;
     onicecandidate: any;
     onTrack: (evt: any) => void;
      * was found.
      */
     findSenderForTrack(track: any): RTCRtpSender | undefined;
+    /**
+     * Processes the local description SDP and caches the mids of the mlines associated with the given tracks.
+     *
+     * @param {Array<JitsiLocalTrack>} localTracks - local tracks that are added to the peerconnection.
+     * @returns {void}
+     */
+    processLocalSdpForTransceiverInfo(localTracks: Array<any>): void;
     /**
      * Replaces <tt>oldTrack</tt> with <tt>newTrack</tt> from the peer connection.
      * Either <tt>oldTrack</tt> or <tt>newTrack</tt> can be null; replacing a valid