ref(unified-plan): Fix unified plan p2p case.

Configure the encodings on FF after the track is added.

modules/RTC/TPCUtils.js

     /**
     * Adds {@link JitsiLocalTrack} to the WebRTC peerconnection for the first time.
     * @param {JitsiLocalTrack} track - track to be added to the peerconnection.
+    * @param {boolean} isInitiator - boolean that indicates if the endpoint is offerer
+    * in a p2p connection.
     * @returns {void}
     */
-    addTrack(localTrack, isInitiator = true) {
+    addTrack(localTrack, isInitiator) {
         const track = localTrack.getTrack();
 
         if (isInitiator) {
     * @returns {void}
     */
     setAudioTransferActive(active) {
-        this.setMediaTransferActive('audio', active);
+        this.setMediaTransferActive(MediaType.AUDIO, 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(`${active ? 'Enabling' : 'Suspending'} ${mediaType} media transfer on ${this.pc}`);
 
         transceivers.forEach((transceiver, idx) => {
             if (active) {
     * @returns {void}
     */
     setVideoTransferActive(active) {
-        this.setMediaTransferActive('video', active);
+        this.setMediaTransferActive(MediaType.VIDEO, active);
     }
 }

modules/RTC/TraceablePeerConnection.js

 /**
  * Add {@link JitsiLocalTrack} to this TPC.
  * @param {JitsiLocalTrack} track
+ * @param {boolean} isInitiator indicates if the endpoint is the offerer.
  * @returns {Promise<void>} - resolved when done.
  */
 TraceablePeerConnection.prototype.addTrack = function(track, isInitiator = false) {
     }
 
     this.localTracks.set(rtcId, track);
-    if (browser.usesUnifiedPlan() && isInitiator) {
-        this.tpcUtils.addTrack(track, isInitiator);
-
-        return Promise.resolve();
-    }
 
-    const webrtcStream = track.getOriginalStream();
-
-    if (webrtcStream) {
-        this._addStream(webrtcStream);
-
-    // It's not ok for a track to not have a WebRTC stream if:
-    } else if (!browser.doesVideoMuteByStreamRemove()
-                || track.isAudioTrack()
-                || (track.isVideoTrack() && !track.isMuted())) {
-        return Promise.reject(new Error(`${this} no WebRTC stream for: ${track}`));
-    }
+    // For p2p unified case, use addTransceiver API to add the tracks on the peerconnection.
+    if (browser.usesUnifiedPlan() && this.isP2P) {
+        this.tpcUtils.addTrack(track, isInitiator);
+    } else {
+        // In all other cases, i.e., plan-b and unified plan bridge case, use addStream API to
+        // add the track to the peerconnection.
+        // TODO - addTransceiver doesn't generate a MSID for the stream, which is needed for signaling
+        // the ssrc to Jicofo. Switch to using UUID as MSID when addTransceiver is used in Unified plan
+        // JVB connection case as well.
+        const webrtcStream = track.getOriginalStream();
+
+        if (webrtcStream) {
+            this._addStream(webrtcStream);
+
+        // It's not ok for a track to not have a WebRTC stream if:
+        } else if (!browser.doesVideoMuteByStreamRemove()
+                    || track.isAudioTrack()
+                    || (track.isVideoTrack() && !track.isMuted())) {
+            return Promise.reject(new Error(`${this} no WebRTC stream for: ${track}`));
+        }
 
-    // Muted video tracks do not have WebRTC stream
-    if (browser.usesPlanB() && browser.doesVideoMuteByStreamRemove()
-            && track.isVideoTrack() && track.isMuted()) {
-        const ssrcInfo = this.generateNewStreamSSRCInfo(track);
+        // Muted video tracks do not have WebRTC stream
+        if (browser.usesPlanB() && browser.doesVideoMuteByStreamRemove()
+                && track.isVideoTrack() && track.isMuted()) {
+            const ssrcInfo = this.generateNewStreamSSRCInfo(track);
 
-        this.sdpConsistency.setPrimarySsrc(ssrcInfo.ssrcs[0]);
-        const simGroup
-            = ssrcInfo.groups.find(groupInfo => groupInfo.semantics === 'SIM');
+            this.sdpConsistency.setPrimarySsrc(ssrcInfo.ssrcs[0]);
+            const simGroup
+                = ssrcInfo.groups.find(groupInfo => groupInfo.semantics === 'SIM');
 
-        if (simGroup) {
-            this.simulcast.setSsrcCache(simGroup.ssrcs);
-        }
-        const fidGroups
-            = ssrcInfo.groups.filter(
-                groupInfo => groupInfo.semantics === 'FID');
+            if (simGroup) {
+                this.simulcast.setSsrcCache(simGroup.ssrcs);
+            }
+            const fidGroups
+                = ssrcInfo.groups.filter(
+                    groupInfo => groupInfo.semantics === 'FID');
 
-        if (fidGroups) {
-            const rtxSsrcMapping = new Map();
+            if (fidGroups) {
+                const rtxSsrcMapping = new Map();
 
-            fidGroups.forEach(fidGroup => {
-                const primarySsrc = fidGroup.ssrcs[0];
-                const rtxSsrc = fidGroup.ssrcs[1];
+                fidGroups.forEach(fidGroup => {
+                    const primarySsrc = fidGroup.ssrcs[0];
+                    const rtxSsrc = fidGroup.ssrcs[1];
 
-                rtxSsrcMapping.set(primarySsrc, rtxSsrc);
-            });
-            this.rtxModifier.setSsrcCache(rtxSsrcMapping);
+                    rtxSsrcMapping.set(primarySsrc, rtxSsrc);
+                });
+                this.rtxModifier.setSsrcCache(rtxSsrcMapping);
+            }
         }
     }
 

modules/xmpp/JingleSessionPC.js

             const addTracks = [];
 
             for (const localTrack of localTracks) {
-                addTracks.push(this.peerconnection.addTrack(localTrack, true /* isInitiator */));
+                addTracks.push(this.peerconnection.addTrack(localTrack, this.isInitiator));
             }
 
             Promise.all(addTracks)
             const addTracks = [];
 
             for (const track of localTracks) {
-                addTracks.push(this.peerconnection.addTrack(track));
+                addTracks.push(this.peerconnection.addTrack(track, this.isInitiator));
             }
 
             const newRemoteSdp