P2P ver2 (#413)

* ref(RTC): store remote tracks in peer TPC

In order to implement P2P <-> JVB connection switching we need to
be able to associate remote tracks with the TraceablePeerConnections.

* feat(ChatRoom): multiple presence handlers

Add support for more than 1 presence handler per tag name.

* feat(JitsiLocalTrack): update stored MSID

* ref(stats): add peer connection arg to BYTE_SENT_STATS

Required to store local SSRCs in TraceablePeerConnection.

* ref: change local SSRCs strategy

* fix: generate recvonly SSRC if 0 video tracks

Video SSRC has to be generated for the recvonly stream if there are no
video tracks in the PeerConnection.

* feat: add "attach" and "detach" methods

* feat(jitsi tracks): improve logging

Adds toString methods and improve log messages around local and remote
tracks.

* ref(modify SSRCs): optimisations + fixes

- adds _doRenegotiate to JingleSessionPC that wraps some of
  the duplicated logic
- fixes problems with attach/detach
- renames methods to reflect what that they really do (operate on
  JitsiTrack rather than streams)

* ref(JingleSessionPC): remove duplication

Extracts common code for the 'modificationQueue' execution

* ref(VideoMuteSdpHack): rename, add docs, fix minor

Renames, adds docs and moves 'modified' flag and media direction
modification.

* ref(TPC): add 'isSimulcastOn'

* ref(MungeLocalSdp): move to RTC module

* ref: move "ufrag" events to the RTC module

* ref(JitsiConference): use promises for mute

* feat(XMPPEvents): add CONNECTION_ESTABLISHED

* feat: add peer to peer

* fix(P2P): deal with everyone's a moderator + fixes

* feat(P2P): implement "backToP2PDelay"

* fix(TPC): crash on FF accessing LD/RD

Firefox return null/undefined for localDescription/remoteDescription
objects if they have not been set yet, while Chrome does return empty
object instead. This commit makes the behaviour consistent by making
sure that at least empty object is returned for all browsers.

* fix(TPC): replace isFirefox with feature

* fix(JSPC): fix renegotiate crash on FF

FF does not allow to call 'createAnswer' in 'have-local-offer' state

* fix(JSPC): fix addIceCandidate crash on FF

* doc(JitsiConference): fix outdated comment

To be squashed with "ref(ChatRoom): remove unnecessary JingleSessionPC dependency"

* style(JitsiConference): rename arg to "jingleSession"

* feat(stats): add 'p2p' to 'transport'

The new p2p field will inform whether the transport comes from the peer
to peer type of connection or not.

* doc(TPC): describe local maps

* fix(P2P): multiplex between JVB and P2P ICE status

Will make sure that when in P2P mode the conference will be updated
with the ICE state coming from P2P and when in the JVB mode will get
the JVB one.

* doc(TPC): fixes docs and adds FIXME

* ref: use 'doesVideoMuteByStreamRemove'

* feat(P2P): stop P2P when ICE enters FAILED

The conference will switch back to the JVB connection when P2P
connection breaks (ICE enters failed state).

* feat(P2P): "connectivity-error" for ICE failed

Will use "connectivity-error" reason element name when ending P2P
session due to ICE failure.

* feat(xmpp): make P2P Stun servers configurable

STUN servers used in the P2P connection can be configured through
"p2pStunServers" option.

* ref(JitsiConference): use 'getActivePeerConnection'

* fix(P2P): re-create 'dtmfManager'

* ref(P2P): deal with ICE "completed" state

* ref(RTC): rename "owner" to "ownerEndpointId"

* fix(MungeLocalSdp): fix directions

* ref(ParticipantConnectionStatus): use for..of and () =>

* remove double 'l'

* ref: fix ESLint errors

* fix(MungeLocalSdp): adopt to new SdpTransformerUtil

* ref(MungeLocalSdp): use for .. of

* ref(SdpTransformUtil): remove "forEachSSRCAttr"

* fix(SDPDiffer): fix invalid "arrayEquals" call

* doc(MungeLocalSdp): add fixme

* fix(P2PEnabledConference): JVB tracks not added

* ref(JitsiConference): doc + rename mute methods

* ref(JitsiConference): adjust log level

* fix(JitsiConference): remove invalid eslint comments

Some mistake during rebase merge

* doc(JitsiConference): add FIXME

* ref(JitsiConferenceEventManager): stick to "tpc"

* ref(JitsiLocalTrack): use Set for "peerConnections"

* ref(JitsiLocalTrack): simplify expression

* ref(MungeLocalSdp): style + doc fixes

* ref: rename MungeLocalSdp to LocalSdpMunger

* ref(ParticipantConn..Status): rename method

* ref(SignalingLayerImpl): use Map and =>

* fix(strophe.jingle.js): minor style fixes + rename

* doc(XMPPEvents): typo

* doc(P2PEnabledConference): typo and style

* ref(P2PEnabledConference): rename methods

* ref(P2PEnabledConference): do not use "window"

* fix(P2PEnabledConference): cleanup deferred task

* ref(TPC): make options the last arg

* ref(TPC): use Map

* ref(TPC): syntax and other fixes...

* doc(ChatRoom): remove comment

* ref: remove P2PEnabledConference

* fix: remove JSUtil.js

* ref(LocalSdpMunger): re-use 'RtxModifier'

Reuses RtxModifier for injecting local RTX SSRCs as part of
the LocalSdpMunger logic.

* doc(LocalSdpMunger): remove confusing FIXME

* fix(TPC): setLocalDescription for FF

* fix(LocalSdpMunger): crash on react-native

* fix(JingleSessionPC): no events when ended

The instance once terminated should not emit connection state events.

* fix(P2P): do not start P2P on react-native

* fix: log meaningful error

Prior to this change you would see something like:
JitsiConference <error>: null

* fix(JingleSessionPC): no IQs once ended

* fix(JingleSessionPC): Jingle error logging

* fix: arguments order

* fix: make audio SSRC consistent

Audio SSRC needs to stay consistent between detach and attach operations
in order to avoid source-remove/source-add.

* fix(P2P): disable P2P on FF

There are problems with going back from P2P to JVB in FireFox. Other
participants will not see FF video. Looks like something related to
detach/attach.

* fix(JitsiConference): attach local tracks

Local tracks should be attached back to the JVB connection only
if the P2P was established.

* ref(JitsiConference): PR review fixes

ref(JitsiConference): else if

ref(JitsiConference): use getter

doc(JitsiConference): add comment

style(JitsiConference): remove extra line

log(JitsiConference): misleading msg

ref(JitsiConference): rename method

* ref(RTC): del _iteratePeerConnections

* ref: move getUfrag to SDPUtil

* fix(LocalSdpMunger): docs and if check

* fix(TPC): docs and typo

* ref(JingleSessionPC): PR review fixes

ref(JingleSessionPC): rename 'candidates'

ref(JitsiConference): remove extra check

ref(JitsiConference): rename isP2PEstablished

ref(JitsiConference): rename field (typo)

* doc(JitsiConferenceEventManager): typo

* ref(JitsiLocalTrack): rename var

* ref(JitsiConference): PR review fixes

ref(JitsiConference): rename var

doc(JitsiConference): add comment

doc(JitsiConference): add comment

doc(JitsiConference): fix comment

ref(JitsiConference): rename listener

ref(JitsiConference): rename var

* doc(RTC): remove duplicated arg description

doc(RTC): fill docs

* doc(SignalingLayerImpl): remove fixed FIXME

* ref(strophe.jingle.js): remove comment and break line

* style(TPC): formatting

doc(TPC): add FIXME

ref(TPC): remove unused code

doc(TPC): add docs

* doc(JingleSessionPC): mark "send" methods private

style(JingleSessionPC): extra lines

JitsiConferenceEventManager.js

             conference.statistics.sendMuteEvent(track.isMuted(),
                 track.getType());
         });
+    conference.on(
+        JitsiConferenceEvents.CONNECTION_INTERRUPTED,
+        Statistics.sendEventToAll.bind(Statistics, 'connection.interrupted'));
+    conference.on(
+        JitsiConferenceEvents.CONNECTION_RESTORED,
+        Statistics.sendEventToAll.bind(Statistics, 'connection.restored'));
 }
 
 /**
     this.chatRoomForwarder = new EventEmitterForwarder(chatRoom,
         this.conference.eventEmitter);
 
-    chatRoom.addListener(XMPPEvents.ICE_RESTARTING, () => {
-        // All data channels have to be closed, before ICE restart
-        // otherwise Chrome will not trigger "opened" event for the channel
-        // established with the new bridge
-        conference.rtc.closeAllDataChannels();
+    chatRoom.addListener(XMPPEvents.ICE_RESTARTING, jingleSession => {
+        if (!jingleSession.isP2P) {
+            // All data channels have to be closed, before ICE restart
+            // otherwise Chrome will not trigger "opened" event for the channel
+            // established with the new bridge
+            conference.rtc.closeAllDataChannels();
+        }
+
+        // else: there are no DataChannels in P2P session (at least for now)
     });
 
     chatRoom.addListener(XMPPEvents.AUDIO_MUTED_BY_FOCUS,
     // send some analytics events
     chatRoom.addListener(XMPPEvents.MUC_JOINED,
         () => {
-            this.conference.connectionIsInterrupted = false;
+            this.conference.isJvbConnectionInterrupted = false;
 
             Object.keys(chatRoom.connectionTimes).forEach(key => {
                 const value = chatRoom.connectionTimes[key];
 
     chatRoom.addListener(XMPPEvents.JINGLE_FATAL_ERROR,
         (session, error) => {
-            conference.eventEmitter.emit(
-                JitsiConferenceEvents.CONFERENCE_FAILED,
-                JitsiConferenceErrors.JINGLE_FATAL_ERROR, error);
+            if (!session.isP2P) {
+                conference.eventEmitter.emit(
+                    JitsiConferenceEvents.CONFERENCE_FAILED,
+                    JitsiConferenceErrors.JINGLE_FATAL_ERROR, error);
+            }
         });
 
     chatRoom.addListener(XMPPEvents.CONNECTION_ICE_FAILED,
-        () => {
-            chatRoom.eventEmitter.emit(
-                XMPPEvents.CONFERENCE_SETUP_FAILED,
-                new Error('ICE fail'));
+        jingleSession => {
+            conference._onIceConnectionFailed(jingleSession);
         });
 
     this.chatRoomForwarder.forward(XMPPEvents.MUC_DESTROYED,
         = reason => Statistics.sendEventToAll(`conference.error.${reason}`);
 
     chatRoom.addListener(XMPPEvents.SESSION_ACCEPT_TIMEOUT,
-        eventLogHandler.bind(null, 'sessionAcceptTimeout'));
-
-    this.chatRoomForwarder.forward(XMPPEvents.CONNECTION_INTERRUPTED,
-        JitsiConferenceEvents.CONNECTION_INTERRUPTED);
-    chatRoom.addListener(XMPPEvents.CONNECTION_INTERRUPTED,
-        () => {
-            Statistics.sendEventToAll('connection.interrupted');
-            this.conference.connectionIsInterrupted = true;
+        jingleSession => {
+            eventLogHandler(
+                jingleSession.isP2P
+                    ? 'p2pSessionAcceptTimeout' : 'sessionAcceptTimeout');
         });
 
     this.chatRoomForwarder.forward(XMPPEvents.RECORDER_STATE_CHANGED,
     this.chatRoomForwarder.forward(XMPPEvents.PHONE_NUMBER_CHANGED,
         JitsiConferenceEvents.PHONE_NUMBER_CHANGED);
 
-    this.chatRoomForwarder.forward(XMPPEvents.CONNECTION_RESTORED,
-        JitsiConferenceEvents.CONNECTION_RESTORED);
-    chatRoom.addListener(XMPPEvents.CONNECTION_RESTORED,
-        () => {
-            Statistics.sendEventToAll('connection.restored');
-            this.conference.connectionIsInterrupted = false;
+    chatRoom.addListener(
+        XMPPEvents.CONFERENCE_SETUP_FAILED,
+        (jingleSession, error) => {
+            if (!jingleSession.isP2P) {
+                conference.eventEmitter.emit(
+                    JitsiConferenceEvents.CONFERENCE_FAILED,
+                    JitsiConferenceErrors.SETUP_FAILED,
+                    error);
+            }
         });
 
-    this.chatRoomForwarder.forward(XMPPEvents.CONFERENCE_SETUP_FAILED,
-        JitsiConferenceEvents.CONFERENCE_FAILED,
-        JitsiConferenceErrors.SETUP_FAILED);
-
     chatRoom.setParticipantPropertyListener((node, from) => {
         const participant = conference.getParticipantById(from);
 
         conference.onDisplayNameChanged.bind(conference));
 
     chatRoom.addListener(XMPPEvents.LOCAL_ROLE_CHANGED, role => {
-        conference.eventEmitter.emit(JitsiConferenceEvents.USER_ROLE_CHANGED,
-            conference.myUserId(), role);
+        conference.onLocalRoleChanged(role);
 
         // log all events for the recorder operated by the moderator
         if (conference.statistics && conference.isModerator()) {
                 JitsiConferenceEvents.USER_STATUS_CHANGED, id, status);
         });
 
-    conference.room.addListener(XMPPEvents.LOCAL_UFRAG_CHANGED,
-        ufrag => {
-            Statistics.sendLog(
-                JSON.stringify({ id: 'local_ufrag',
-                    value: ufrag }));
-        });
-    conference.room.addListener(XMPPEvents.REMOTE_UFRAG_CHANGED,
-        ufrag => {
-            Statistics.sendLog(
-                JSON.stringify({ id: 'remote_ufrag',
-                    value: ufrag }));
-        });
-
     chatRoom.addPresenceListener('startmuted', (data, from) => {
         let isModerator = false;
 
         }
     });
 
-    chatRoom.addPresenceListener('videomuted', (values, from) => {
-        conference.rtc.handleRemoteTrackMute(MediaType.VIDEO,
-            values.value === 'true', from);
-    });
-
-    chatRoom.addPresenceListener('audiomuted', (values, from) => {
-        conference.rtc.handleRemoteTrackMute(MediaType.AUDIO,
-            values.value === 'true', from);
-    });
-
-    chatRoom.addPresenceListener('videoType', (data, from) => {
-        conference.rtc.handleRemoteTrackVideoTypeChanged(data.value, from);
-    });
-
     chatRoom.addPresenceListener('devices', (data, from) => {
         let isAudioAvailable = false;
         let isVideoAvailable = false;
     if (conference.statistics) {
         // FIXME ICE related events should end up in RTCEvents eventually
         chatRoom.addListener(XMPPEvents.CONNECTION_ICE_FAILED,
-            pc => {
+            (session, pc) => {
                 conference.statistics.sendIceConnectionFailedEvent(pc);
             });
         chatRoom.addListener(XMPPEvents.ADD_ICE_CANDIDATE_FAILED,
             }
         });
 
+    rtc.addListener(RTCEvents.LOCAL_UFRAG_CHANGED,
+        (tpc, ufrag) => {
+            if (!tpc.isP2P) {
+                Statistics.sendLog(
+                    JSON.stringify({
+                        id: 'local_ufrag',
+                        value: ufrag
+                    }));
+            }
+        });
+    rtc.addListener(RTCEvents.REMOTE_UFRAG_CHANGED,
+        (tpc, ufrag) => {
+            if (!tpc.isP2P) {
+                Statistics.sendLog(
+                    JSON.stringify({
+                        id: 'remote_ufrag',
+                        value: ufrag
+                    }));
+            }
+        });
+
     if (conference.statistics) {
         rtc.addListener(RTCEvents.CREATE_ANSWER_FAILED,
             (e, pc) => {
     conference.xmpp.addListener(
         XMPPEvents.CALL_INCOMING,
         conference.onIncomingCall.bind(conference));
+    conference.xmpp.addListener(
+        XMPPEvents.CALL_ACCEPTED,
+        conference.onCallAccepted.bind(conference));
+    conference.xmpp.addListener(
+        XMPPEvents.TRANSPORT_INFO,
+        conference.onTransportInfo.bind(conference));
     conference.xmpp.addListener(
         XMPPEvents.CALL_ENDED,
         conference.onCallEnded.bind(conference));
     }
 
     conference.statistics.addAudioLevelListener((ssrc, level) => {
-        const resource = conference.rtc.getResourceBySSRC(ssrc);
-
-        if (!resource) {
-            return;
-        }
-
-        conference.rtc.setAudioLevel(resource, level);
+        conference.rtc.setAudioLevel(ssrc, level);
     });
 
     // Forward the "before stats disposed" event
             JitsiConferenceEvents.CONNECTION_STATS, stats);
     });
 
-    conference.statistics.addByteSentStatsListener(stats => {
+    conference.statistics.addByteSentStatsListener((tpc, stats) => {
         conference.getLocalTracks(MediaType.AUDIO).forEach(track => {
-            const ssrc = track.getSSRC();
+            const ssrc = tpc.getLocalSSRC(track);
 
             if (!ssrc || !stats.hasOwnProperty(ssrc)) {
                 return;
             }
 
-            track._setByteSent(stats[ssrc]);
+            track._setByteSent(tpc, stats[ssrc]);
         });
     });
 };

JitsiConferenceEvents.js

 export const PARTICIPANT_PROPERTY_CHANGED
     = 'conference.participant_property_changed';
 
+/**
+ * Indicates that the conference has switched between JVB and P2P connections.
+ * The first argument of this event is a <tt>boolean</tt> which when set to
+ * <tt>true</tt> means that the conference is running on the P2P connection.
+ */
+export const P2P_STATUS = 'conference.p2pStatus';
+
 /**
  * Indicates that phone number changed.
  */

JitsiConnection.js

-const JitsiConference = require('./JitsiConference');
-
+import JitsiConference from './JitsiConference';
 import * as JitsiConnectionEvents from './JitsiConnectionEvents';
+import Statistics from './modules/statistics/statistics';
 import XMPP from './modules/xmpp/xmpp';
-const Statistics = require('./modules/statistics/statistics');
 
 /**
  * Creates new connection object for the Jitsi Meet server side video
  * @returns {JitsiConference} returns the new conference object.
  */
 JitsiConnection.prototype.initJitsiConference = function(name, options) {
-    return new JitsiConference({ name,
+    return new JitsiConference({
+        name,
         config: options,
-        connection: this });
+        connection: this
+    });
 };
 
 /**

modules/RTC/JitsiLocalTrack.js

 /**
  * Represents a single media track(either audio or video).
  * One <tt>JitsiLocalTrack</tt> corresponds to one WebRTC MediaStreamTrack.
+ * @param {number} rtcId the ID assigned by the RTC module
  * @param stream WebRTC MediaStream, parent of the track
  * @param track underlying WebRTC MediaStreamTrack for new JitsiRemoteTrack
  * @param mediaType the MediaType of the JitsiRemoteTrack
  * @constructor
  */
 function JitsiLocalTrack(
+        rtcId,
         stream,
         track,
         mediaType,
         resolution,
         deviceId,
         facingMode) {
+
+    /**
+     * The ID assigned by the RTC module on instance creation.
+     * @type {number}
+     */
+    this.rtcId = rtcId;
     JitsiTrack.call(
         this,
         null /* RTC */,
             this.dontFireRemoveEvent = false;
         } /* inactiveHandler */,
         mediaType,
-        videoType,
-        null /* ssrc */);
+        videoType);
     this.dontFireRemoveEvent = false;
     this.resolution = resolution;
 
 
     this.deviceId = deviceId;
     this.startMuted = false;
-    this.initialMSID = this.getMSID();
+    this.storedMSID = this.getMSID();
     this.inMuteOrUnmuteProgress = false;
 
+    /**
+     * An array which stores the peer connection to which this local track is
+     * currently attached to. See {@link TraceablePeerConnection.attachTrack}.
+     * @type {Set<TraceablePeerConnection>}
+     */
+    this.peerConnections = new Set();
+
     /**
      * The facing mode of the camera from which this JitsiLocalTrack instance
      * was obtained.
 JitsiLocalTrack.prototype = Object.create(JitsiTrack.prototype);
 JitsiLocalTrack.prototype.constructor = JitsiLocalTrack;
 
+JitsiLocalTrack.prototype._addPeerConnection = function(tpc) {
+    if (this._isAttachedToPC(tpc)) {
+        logger.error(`${tpc} has been associated with ${this} already !`);
+    } else {
+        this.peerConnections.add(tpc);
+    }
+};
+
+JitsiLocalTrack.prototype._removePeerConnection = function(tpc) {
+    if (this._isAttachedToPC(tpc)) {
+        this.peerConnections.delete(tpc);
+    } else {
+        logger.error(`${tpc} is not associated with ${this}`);
+    }
+};
+
+/**
+ * Checks whether or not this instance is attached to given
+ * <tt>TraceablePeerConnection</tt>. See
+ * {@link TraceablePeerConnection.attachTrack} for more info.
+ * @param {TraceablePeerConnection.attachTrack} tpc
+ * @return {boolean} <tt>true</tt> if this tracks is currently attached to given
+ * peer connection or <tt>false</tt> otherwise.
+ */
+JitsiLocalTrack.prototype._isAttachedToPC = function(tpc) {
+    return this.peerConnections.has(tpc);
+};
+
 /**
  * Returns if associated MediaStreamTrack is in the 'ended' state
  * @returns {boolean}
     }
 };
 
+/**
+ * Sets the stream property of JitsiLocalTrack object and sets all stored
+ * handlers to it.
+ * @param {MediaStream} stream the new stream.
+ */
+JitsiLocalTrack.prototype._setStream = function(stream) {
+    JitsiTrack.prototype._setStream.call(this, stream);
+
+    // Store the MSID for video mute/unmute purposes
+    if (stream) {
+        this.storedMSID = this.getMSID();
+        logger.debug(`Setting new MSID: ${this.storedMSID} on ${this}`);
+    } else {
+        logger.debug(`Setting 'null' stream on ${this}`);
+    }
+};
+
 /**
  * Mutes the track. Will reject the Promise if there is mute/unmute operation
  * in progress.
     // Local track can be used out of conference, so we need to handle that
     // case and mark that track should start muted or not when added to
     // conference.
+    // Pawel: track's muted status should be taken into account when track is
+    // being added to the conference/JingleSessionPC/TraceablePeerConnection.
+    // There's no need to add such fields. It is logical that when muted track
+    // is being added to a conference it "starts muted"...
     if (!this.conference || !this.conference.room) {
         this.startMuted = mute;
     }
 
     this.dontFireRemoveEvent = false;
 
-    // FIXME FF does not support 'removeStream' method used to mute
+    // A function that will print info about muted status transition
+    const logMuteInfo = () => logger.info(`Mute ${this}: ${mute}`);
+
     if (this.isAudioTrack()
         || this.videoType === VideoType.DESKTOP
-        || RTCBrowserType.isFirefox()) {
+        || !RTCBrowserType.doesVideoMuteByStreamRemove()) {
+        logMuteInfo();
         if (this.track) {
             this.track.enabled = !mute;
         }
     } else if (mute) {
         this.dontFireRemoveEvent = true;
         promise = new Promise((resolve, reject) => {
+            logMuteInfo();
             this._removeStreamFromConferenceAsMute(() => {
                 // FIXME: Maybe here we should set the SRC for the containers
                 // to something
             });
         });
     } else {
+        logMuteInfo();
+
         // This path is only for camera.
         const streamOptions = {
             cameraDeviceId: this.getDeviceId(),
                     // unmute, but let's not crash here
                     if (self.videoType !== streamInfo.videoType) {
                         logger.warn(
-                            'Video type has changed after unmute!',
+                            `${this}: video type has changed after unmute!`,
                             self.videoType, streamInfo.videoType);
                         self.videoType = streamInfo.videoType;
                     }
         return Promise.resolve();
     }
 
+    // FIXME it would be good to not included conference as part of this process
+    // Only TraceablePeerConnections to which the track is attached should care
+    // about this action. The TPCs to which the track is not attached can sync
+    // up when track is re-attached.
+    // A problem with that is that the "modify sources" queue is part of
+    // the JingleSessionPC and it would be excluded from the process. One
+    // solution would be to extract class between TPC and JingleSessionPC which
+    // would contain the queue and would notify the signaling layer when local
+    // SSRCs are changed. This would help to separate XMPP from the RTC module.
     return new Promise((resolve, reject) => {
-        this.conference._addLocalStream(
-            this.stream,
-            resolve,
-            error => reject(new Error(error)),
-            {
-                mtype: this.type,
-                type: 'unmute',
-                ssrcs: this.ssrc && this.ssrc.ssrcs,
-                groups: this.ssrc && this.ssrc.groups,
-                msid: this.getMSID()
-            });
+        this.conference._addLocalTrackAsUnmute(this)
+            .then(resolve, error => reject(new Error(error)));
     });
 };
 
 
         return;
     }
-
-    this.conference.removeLocalStream(
-        this.stream,
+    this.conference._removeLocalTrackAsMute(this).then(
         successCallback,
-        error => errorCallback(new Error(error)),
-        {
-            mtype: this.type,
-            type: 'mute',
-            ssrcs: this.ssrc && this.ssrc.ssrcs,
-            groups: this.ssrc && this.ssrc.groups
-        });
+        error => errorCallback(new Error(error)));
 };
 
 /**
 
 };
 
-/**
- * Updates the SSRC associated with the MediaStream in JitsiLocalTrack object.
- * @ssrc the new ssrc
- */
-JitsiLocalTrack.prototype._setSSRC = function(ssrc) {
-    this.ssrc = ssrc;
-};
-
-
 /**
  * Sets the JitsiConference object associated with the track. This is temp
  * solution.
     }
 };
 
-/**
- * Gets the SSRC of this local track if it's available already or <tt>null</tt>
- * otherwise. That's because we don't know the SSRC until local description is
- * created.
- * In case of video and simulcast returns the the primarySSRC.
- * @returns {string} or {null}
- */
-JitsiLocalTrack.prototype.getSSRC = function() {
-    if (this.ssrc && this.ssrc.groups && this.ssrc.groups.length) {
-        return this.ssrc.groups[0].ssrcs[0];
-    } else if (this.ssrc && this.ssrc.ssrcs && this.ssrc.ssrcs.length) {
-        return this.ssrc.ssrcs[0];
-    }
-
-    return null;
-
-};
-
 /**
  * Returns <tt>true</tt>.
  * @returns {boolean} <tt>true</tt>
     return this._realDeviceId || this.deviceId;
 };
 
+/**
+ * Returns the participant id which owns the track.
+ * @returns {string} the id of the participants. It corresponds to the Colibri
+ * endpoint id/MUC nickname in case of Jitsi-meet.
+ */
+JitsiLocalTrack.prototype.getParticipantId = function() {
+    return this.conference && this.conference.myUserId();
+};
+
 /**
  * Sets the value of bytes sent statistic.
- * @param bytesSent {integer} the new value (FIXME: what is an integer in js?)
+ * @param {TraceablePeerConnection} tpc the source of the "bytes sent" stat
+ * @param {number} bytesSent the new value
  * NOTE: used only for audio tracks to detect audio issues.
  */
-JitsiLocalTrack.prototype._setByteSent = function(bytesSent) {
+JitsiLocalTrack.prototype._setByteSent = function(tpc, bytesSent) {
     this._bytesSent = bytesSent;
-
-    // FIXME it's a shame that PeerConnection and ICE status does not belong
-    // to the RTC module and it has to be accessed through
-    // the conference(and through the XMPP chat room ???) instead
-    const iceConnectionState
-        = this.conference ? this.conference.getConnectionState() : null;
+    const iceConnectionState = tpc.getConnectionState();
 
     if (this._testByteSent && iceConnectionState === 'connected') {
         setTimeout(() => {
             if (this._bytesSent <= 0) {
+                logger.warn(`${this} 'bytes sent' <= 0: ${this._bytesSent}`);
+
                 // we are not receiving anything from the microphone
                 this._fireNoDataFromSourceEvent();
             }
             && (!('muted' in track) || track.muted !== true));
 };
 
+/**
+ * Creates a text representation of this local track instance.
+ * @return {string}
+ */
+JitsiLocalTrack.prototype.toString = function() {
+    return `LocalTrack[${this.rtcId},${this.getType()}]`;
+};
+
 module.exports = JitsiLocalTrack;

modules/RTC/JitsiRemoteTrack.js

  * @param {VideoType} videoType the type of the video if applicable
  * @param {string} ssrc the SSRC number of the Media Stream
  * @param {boolean} muted the initial muted state
+ * @param {boolean} isP2P indicates whether or not this track belongs to a P2P
+ * session
  * @constructor
  */
 function JitsiRemoteTrack(
         mediaType,
         videoType,
         ssrc,
-        muted) {
+        muted,
+        isP2P) {
     JitsiTrack.call(
         this,
         conference,
             // Nothing to do if the track is inactive.
         },
         mediaType,
-        videoType,
-        ssrc);
+        videoType);
     this.rtc = rtc;
+    this.ssrc = ssrc;
     this.ownerEndpointId = ownerEndpointId;
     this.muted = muted;
+    this.isP2P = isP2P;
 
     // we want to mark whether the track has been ever muted
     // to detect ttfm events for startmuted conferences, as it can significantly
     }
 };
 
+/**
+ * Creates a text representation of this remote track instance.
+ * @return {string}
+ */
+JitsiRemoteTrack.prototype.toString = function() {
+    return `RemoteTrack[${this.ownerEndpointId}, ${this.getType()
+            }, p2p: ${this.isP2P}]`;
+};
+
 module.exports = JitsiRemoteTrack;

modules/RTC/JitsiTrack.js

  *        onended/oninactive events of the stream.
  * @param trackMediaType the media type of the JitsiTrack
  * @param videoType the VideoType for this track if any
- * @param ssrc the SSRC of this track if known
  */
 function JitsiTrack(
-        conference,
-        stream,
-        track,
-        streamInactiveHandler,
-        trackMediaType,
-        videoType,
-        ssrc) {
+    conference,
+    stream,
+    track,
+    streamInactiveHandler,
+    trackMediaType,
+    videoType) {
     /**
      * Array with the HTML elements that are displaying the streams.
      * @type {Array}
     this.containers = [];
     this.conference = conference;
     this.stream = stream;
-    this.ssrc = ssrc;
     this.eventEmitter = new EventEmitter();
     this.audioLevel = -1;
     this.type = trackMediaType;

modules/RTC/LocalSdpMunger.js

+/* global __filename */
+
+import { getLogger } from 'jitsi-meet-logger';
+import * as MediaType from '../../service/RTC/MediaType';
+import { SdpTransformWrap } from '../xmpp/SdpTransformUtil';
+
+const logger = getLogger(__filename);
+
+/**
+ * Fakes local SDP, so that it will reflect detached local tracks associated
+ * with the {@link TraceablePeerConnection} and make operations like
+ * attach/detach and video mute/unmute local operations. That means it prevents
+ * from SSRC updates being sent to Jicofo/remote peer, so that there is no
+ * sRD/sLD cycle on the remote side.
+ */
+export default class LocalSdpMunger {
+
+    /**
+     * Creates new <tt>LocalSdpMunger</tt> instance.
+     *
+     * @param {TraceablePeerConnection} tpc
+     */
+    constructor(tpc) {
+        this.tpc = tpc;
+    }
+
+    /**
+     * Makes sure that detached local audio tracks stored in the parent
+     * {@link TraceablePeerConnection} are described in the local SDP.
+     * It's done in order to prevent from sending 'source-remove'/'source-add'
+     * Jingle notifications when local audio track is detached from
+     * the {@link TraceablePeerConnection}.
+     * @param {SdpTransformWrap} transformer the transformer instance which will
+     * be used to process the SDP.
+     * @return {boolean} <tt>true</tt> if there were any modifications to
+     * the SDP wrapped by <tt>transformer</tt>.
+     * @private
+     */
+    _addDetachedLocalAudioTracksToSDP(transformer) {
+        const localAudio = this.tpc.getLocalTracks(MediaType.AUDIO);
+
+        if (!localAudio.length) {
+            return false;
+        }
+        const audioMLine = transformer.selectMedia('audio');
+
+        if (!audioMLine) {
+            logger.error(
+                'Unable to hack local audio track SDP - no "audio" media');
+
+            return false;
+        }
+
+        if (audioMLine.direction === 'inactive') {
+            logger.error(
+                'Not doing local audio transform for "inactive" direction');
+
+            return false;
+        }
+
+        let modified = false;
+
+        for (const audioTrack of localAudio) {
+            const isAttached = audioTrack._isAttachedToPC(this.tpc);
+            const shouldFake = !isAttached;
+
+            logger.debug(
+                `${audioTrack} isAttached: ${isAttached
+                    } => should fake audio SDP ?: ${shouldFake}`);
+
+            if (!shouldFake) {
+                // not using continue increases indentation
+                // eslint-disable-next-line no-continue
+                continue;
+            }
+
+            // Inject removed SSRCs
+            const audioSSRC = this.tpc.getLocalSSRC(audioTrack);
+            const audioMSID = audioTrack.storedMSID;
+
+            if (!audioSSRC) {
+                logger.error(
+                    `Can't fake SDP for ${audioTrack} - no SSRC stored`);
+
+                // Aborts the forEach on this particular track,
+                // but will continue with the other ones
+                // eslint-disable-next-line no-continue
+                continue;
+            } else if (!audioMSID) {
+                logger.error(
+                    `No MSID stored for local audio SSRC: ${audioSSRC}`);
+
+                // eslint-disable-next-line no-continue
+                continue;
+            }
+
+            if (audioMLine.getSSRCCount() > 0) {
+                logger.debug(
+                    'Doing nothing - audio SSRCs are still there');
+
+                // audio SSRCs are still there
+                // eslint-disable-next-line no-continue
+                continue;
+            }
+
+            modified = true;
+
+            // We need to fake sendrecv
+            audioMLine.direction = 'sendrecv';
+
+            logger.debug(`Injecting audio SSRC: ${audioSSRC}`);
+            audioMLine.addSSRCAttribute({
+                id: audioSSRC,
+                attribute: 'cname',
+                value: `injected-${audioSSRC}`
+            });
+            audioMLine.addSSRCAttribute({
+                id: audioSSRC,
+                attribute: 'msid',
+                value: audioMSID
+            });
+        }
+
+        return modified;
+    }
+
+    /**
+     * Makes sure that detached (or muted) local video tracks associated with
+     * the parent {@link TraceablePeerConnection} are described in the local
+     * SDP. It's done in order to prevent from sending
+     * 'source-remove'/'source-add' Jingle notifications when local video track
+     * is detached from the {@link TraceablePeerConnection} (or muted).
+     *
+     * NOTE 1 video track is assumed
+     *
+     * @param {SdpTransformWrap} transformer the transformer instance which will
+     * be used to process the SDP.
+     * @return {boolean} <tt>true</tt> if there were any modifications to
+     * the SDP wrapped by <tt>transformer</tt>.
+     * @private
+     */
+    _addDetachedLocalVideoTracksToSDP(transformer) {
+        // Go over each video tracks and check if the SDP has to be changed
+        const localVideos = this.tpc.getLocalTracks(MediaType.VIDEO);
+
+        if (!localVideos.length) {
+            return false;
+        } else if (localVideos.length !== 1) {
+            logger.error(
+                'There is more than 1 video track ! '
+                    + 'Strange things may happen !', localVideos);
+        }
+
+        const videoMLine = transformer.selectMedia('video');
+
+        if (!videoMLine) {
+            logger.error(
+                'Unable to hack local video track SDP - no "video" media');
+
+            return false;
+        }
+
+        if (videoMLine.direction === 'inactive') {
+            logger.error(
+                'Not doing local video transform for "inactive" direction.');
+
+            return false;
+        }
+
+        let modified = false;
+
+        for (const videoTrack of localVideos) {
+            const isMuted = videoTrack.isMuted();
+            const muteInProgress = videoTrack.inMuteOrUnmuteProgress;
+            const isAttached = videoTrack._isAttachedToPC(this.tpc);
+            const shouldFakeSdp = isMuted || muteInProgress || !isAttached;
+
+            logger.debug(
+                `${videoTrack
+                 } isMuted: ${isMuted
+                 }, is mute in progress: ${muteInProgress
+                 }, is attached ? : ${isAttached
+                 } => should fake sdp ? : ${shouldFakeSdp}`);
+
+            if (!shouldFakeSdp) {
+                // eslint-disable-next-line no-continue
+                continue;
+            }
+
+            // Inject removed SSRCs
+            const requiredSSRCs
+                = this.tpc.isSimulcastOn()
+                    ? this.tpc.simulcast.ssrcCache
+                    : [ this.tpc.sdpConsistency.cachedPrimarySsrc ];
+
+            if (!requiredSSRCs.length) {
+                logger.error(
+                    `No SSRCs stored for: ${videoTrack} in ${this.tpc}`);
+
+                // eslint-disable-next-line no-continue
+                continue;
+            }
+            if (!videoMLine.getSSRCCount()) {
+                logger.error(
+                    'No video SSRCs found '
+                        + '(should be at least the recv-only one');
+
+                // eslint-disable-next-line no-continue
+                continue;
+            }
+
+            modified = true;
+
+            // We need to fake sendrecv
+            videoMLine.direction = 'sendrecv';
+
+            // Check if the recvonly has MSID
+            const primarySSRC = requiredSSRCs[0];
+
+            // FIXME the cname could come from the stream, but may
+            // turn out to be too complex. It is fine to come up
+            // with any value, as long as we only care about
+            // the actual SSRC values when deciding whether or not
+            // an update should be sent
+            const primaryCname = `injected-${primarySSRC}`;
+
+            for (const ssrcNum of requiredSSRCs) {
+                // Remove old attributes
+                videoMLine.removeSSRC(ssrcNum);
+
+                // Inject
+                logger.debug(
+                    `Injecting video SSRC: ${ssrcNum} for ${videoTrack}`);
+                videoMLine.addSSRCAttribute({
+                    id: ssrcNum,
+                    attribute: 'cname',
+                    value: primaryCname
+                });
+                videoMLine.addSSRCAttribute({
+                    id: ssrcNum,
+                    attribute: 'msid',
+                    value: videoTrack.storedMSID
+                });
+            }
+            if (requiredSSRCs.length > 1) {
+                const group = {
+                    ssrcs: requiredSSRCs.join(' '),
+                    semantics: 'SIM'
+                };
+
+                if (!videoMLine.findGroup(group.semantics, group.ssrcs)) {
+                    // Inject the group
+                    logger.debug(
+                        `Injecting SIM group for ${videoTrack}`, group);
+                    videoMLine.addSSRCGroup(group);
+                }
+            }
+
+            // Insert RTX
+            // FIXME in P2P RTX is used by Chrome regardless of config option
+            // status. Because of that 'source-remove'/'source-add'
+            // notifications are still sent to remove/add RTX SSRC and FID group
+            if (!this.tpc.options.disableRtx) {
+                this.tpc.rtxModifier.modifyRtxSsrcs2(videoMLine);
+            }
+        }
+
+        return modified;
+    }
+
+    /**
+     * Maybe modifies local description to fake local tracks SDP when those are
+     * either muted or detached from the <tt>PeerConnection</tt>.
+     *
+     * @param {object} desc the WebRTC SDP object instance for the local
+     * description.
+     */
+    maybeMungeLocalSdp(desc) {
+        // Nothing to be done in early stage when localDescription
+        // is not available yet
+        if (!desc || !desc.sdp) {
+            return;
+        }
+
+        const transformer = new SdpTransformWrap(desc.sdp);
+        let modified = this._addDetachedLocalAudioTracksToSDP(transformer);
+
+        if (this._addDetachedLocalVideoTracksToSDP(transformer)) {
+            modified = true;
+        }
+        if (modified) {
+            // Write
+            desc.sdp = transformer.toRawSDP();
+
+            // logger.info("Post TRANSFORM: ", desc.sdp);
+        }
+    }
+}

modules/RTC/RTC.js

 import { getLogger } from 'jitsi-meet-logger';
 import GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
 import JitsiLocalTrack from './JitsiLocalTrack.js';
-import JitsiRemoteTrack from './JitsiRemoteTrack.js';
 import JitsiTrackError from '../../JitsiTrackError';
 import * as JitsiTrackErrors from '../../JitsiTrackErrors';
 import Listenable from '../util/Listenable';
 
 const logger = getLogger(__filename);
 
+let rtcTrackIdCounter = 0;
+
 /**
  *
  * @param tracksInfo
         } else if (trackInfo.videoType === VideoType.CAMERA) {
             deviceId = options.cameraDeviceId;
         }
+        rtcTrackIdCounter += 1;
         const localTrack
             = new JitsiLocalTrack(
+                rtcTrackIdCounter,
                 trackInfo.stream,
                 trackInfo.track,
                 trackInfo.mediaType,
 
         this.localTracks = [];
 
-        // FIXME: We should support multiple streams per jid.
-        this.remoteTracks = {};
         this.options = options;
 
         // A flag whether we had received that the data channel had opened
         return RTCUtils.getDeviceAvailability();
     }
 
+    /* eslint-disable max-params */
+
     /**
      * Creates new <tt>TraceablePeerConnection</tt>
      * @param {SignalingLayer} signaling the signaling layer that will
      * over SDP.
      * @param {Object} iceConfig an object describing the ICE config like
      * defined in the WebRTC specification.
+     * @param {boolean} isP2P indicates whether or not the new TPC will be used
+     * in a peer to peer type of session
      * @param {Object} options the config options
      * @param {boolean} options.disableSimulcast if set to 'true' will disable
      * the simulcast
      * preferred over other video codecs.
      * @return {TraceablePeerConnection}
      */
-    createPeerConnection(signaling, iceConfig, options) {
+    createPeerConnection(signaling, iceConfig, isP2P, options) {
         const newConnection
             = new TraceablePeerConnection(
                 this,
                 this.peerConnectionIdCounter,
-                signaling, iceConfig, RTC.getPCConstraints(), options);
+                signaling, iceConfig, RTC.getPCConstraints(), isP2P, options);
 
         this.peerConnections.set(newConnection.id, newConnection);
         this.peerConnectionIdCounter += 1;
         return newConnection;
     }
 
+    /* eslint-enable max-params */
+
     /**
      * Removed given peer connection from this RTC module instance.
      * @param {TraceablePeerConnection} traceablePeerConnection
      * @return {Array<JitsiRemoteTrack>}
      */
     getRemoteTracks(mediaType) {
-        const remoteTracks = [];
-        const remoteEndpoints = Object.keys(this.remoteTracks);
-
-        for (const endpoint of remoteEndpoints) {
-            const endpointMediaTypes = Object.keys(this.remoteTracks[endpoint]);
+        let remoteTracks = [];
 
-            for (const trackMediaType of endpointMediaTypes) {
-                // per media type filtering
-                if (!mediaType || mediaType === trackMediaType) {
-                    const mediaTrack
-                        = this.remoteTracks[endpoint][trackMediaType];
+        for (const tpc of this.peerConnections.values()) {
+            const pcRemoteTracks = tpc.getRemoteTracks(undefined, mediaType);
 
-                    if (mediaTrack) {
-                        remoteTracks.push(mediaTrack);
-                    }
-                }
+            if (pcRemoteTracks) {
+                remoteTracks = remoteTracks.concat(pcRemoteTracks);
             }
         }
 
         return remoteTracks;
     }
 
-    /**
-     * Gets JitsiRemoteTrack for the passed MediaType associated with given MUC
-     * nickname (resource part of the JID).
-     * @param type audio or video.
-     * @param resource the resource part of the MUC JID
-     * @returns {JitsiRemoteTrack|null}
-     */
-    getRemoteTrackByType(type, resource) {
-        if (this.remoteTracks[resource]) {
-            return this.remoteTracks[resource][type];
-        }
-
-        return null;
-
-    }
-
-    /**
-     * Gets JitsiRemoteTrack for AUDIO MediaType associated with given MUC
-     * nickname (resource part of the JID).
-     * @param resource the resource part of the MUC JID
-     * @returns {JitsiRemoteTrack|null}
-     */
-    getRemoteAudioTrack(resource) {
-        return this.getRemoteTrackByType(MediaType.AUDIO, resource);
-    }
-
-    /**
-     * Gets JitsiRemoteTrack for VIDEO MediaType associated with given MUC
-     * nickname (resource part of the JID).
-     * @param resource the resource part of the MUC JID
-     * @returns {JitsiRemoteTrack|null}
-     */
-    getRemoteVideoTrack(resource) {
-        return this.getRemoteTrackByType(MediaType.VIDEO, resource);
-    }
-
     /**
      * Set mute for all local audio streams attached to the conference.
      * @param value the mute value
         this.localTracks.splice(pos, 1);
     }
 
-    /* eslint-disable max-params */
-
-    /**
-     * Initializes a new JitsiRemoteTrack instance with the data provided by
-     * the signaling layer and SDP.
-     *
-     * @param {string} ownerEndpointId
-     * @param {MediaStream} stream
-     * @param {MediaStreamTrack} track
-     * @param {MediaType} mediaType
-     * @param {VideoType|undefined} videoType
-     * @param {string} ssrc
-     * @param {boolean} muted
-     */
-    _createRemoteTrack(
-            ownerEndpointId,
-            stream,
-            track,
-            mediaType,
-            videoType,
-            ssrc,
-            muted) {
-        const remoteTrack
-            = new JitsiRemoteTrack(
-                this,
-                this.conference,
-                ownerEndpointId,
-                stream,
-                track,
-                mediaType,
-                videoType,
-                ssrc,
-                muted);
-        const remoteTracks
-            = this.remoteTracks[ownerEndpointId]
-                || (this.remoteTracks[ownerEndpointId] = {});
-
-        if (remoteTracks[mediaType]) {
-            logger.error(
-                'Overwriting remote track!',
-                ownerEndpointId,
-                mediaType);
-        }
-        remoteTracks[mediaType] = remoteTrack;
-
-        this.eventEmitter.emit(RTCEvents.REMOTE_TRACK_ADDED, remoteTrack);
-    }
-
-    /* eslint-enable max-params */
-
     /**
      * Removes all JitsiRemoteTracks associated with given MUC nickname
      * (resource part of the JID). Returns array of removed tracks.
      * @returns {JitsiRemoteTrack[]}
      */
     removeRemoteTracks(owner) {
-        const removedTracks = [];
+        let removedTracks = [];
 
-        if (this.remoteTracks[owner]) {
-            const removedAudioTrack
-                = this.remoteTracks[owner][MediaType.AUDIO];
-            const removedVideoTrack
-                = this.remoteTracks[owner][MediaType.VIDEO];
+        for (const tpc of this.peerConnections.values()) {
+            const pcRemovedTracks = tpc.removeRemoteTracks(owner);
 
-            removedAudioTrack && removedTracks.push(removedAudioTrack);
-            removedVideoTrack && removedTracks.push(removedVideoTrack);
-
-            delete this.remoteTracks[owner];
+            removedTracks = removedTracks.concat(pcRemovedTracks);
         }
 
-        return removedTracks;
-    }
-
-    /**
-     * Finds remote track by it's stream and track ids.
-     * @param {string} streamId the media stream id as defined by the WebRTC
-     * @param {string} trackId the media track id as defined by the WebRTC
-     * @return {JitsiRemoteTrack|undefined}
-     * @private
-     */
-    _getRemoteTrackById(streamId, trackId) {
-        let result;
-
-        // .find will break the loop once the first match is found
-        Object.keys(this.remoteTracks).find(endpoint => {
-            const endpointTracks = this.remoteTracks[endpoint];
-
-            return endpointTracks && Object.keys(endpointTracks).find(
-                mediaType => {
-                    const mediaTrack = endpointTracks[mediaType];
-
-                    if (mediaTrack
-                        && mediaTrack.getStreamId() === streamId
-                        && mediaTrack.getTrackId() === trackId) {
-                        result = mediaTrack;
-
-                        return true;
-                    }
-
-                    return false;
-
-                });
-        });
-
-        return result;
-    }
-
-    /**
-     * Removes <tt>JitsiRemoteTrack</tt> identified by given stream and track
-     * ids.
-     *
-     * @param {string} streamId media stream id as defined by the WebRTC
-     * @param {string} trackId media track id as defined by the WebRTC
-     * @returns {JitsiRemoteTrack|undefined} the track which has been removed or
-     * <tt>undefined</tt> if no track matching given stream and track ids was
-     * found.
-     */
-    _removeRemoteTrack(streamId, trackId) {
-        const toBeRemoved = this._getRemoteTrackById(streamId, trackId);
-
-        if (toBeRemoved) {
-            toBeRemoved.dispose();
+        logger.debug(
+            `Removed remote tracks for ${owner}`
+                + ` count: ${removedTracks.length}`);
 
-            delete this.remoteTracks[
-                toBeRemoved.getParticipantId()][toBeRemoved.getType()];
-
-            this.eventEmitter.emit(
-                RTCEvents.REMOTE_TRACK_REMOVED, toBeRemoved);
-        }
-
-        return toBeRemoved;
+        return removedTracks;
     }
 
     /**
      * @param resource
      * @param audioLevel
      */
-    setAudioLevel(resource, audioLevel) {
-        if (!resource) {
+    setAudioLevel(ssrc, audioLevel) {
+        const track = this._getTrackBySSRC(ssrc);
+
+        if (!track) {
             return;
         }
-        const audioTrack = this.getRemoteAudioTrack(resource);
+        if (!track.isAudioTrack()) {
+            logger.warn(`Received audio level for non-audio track: ${ssrc}`);
 
-        if (audioTrack) {
-            audioTrack.setAudioLevel(audioLevel);
+            return;
         }
+
+        track.setAudioLevel(audioLevel);
     }
 
     /**
      * @param ssrc the ssrc to check.
      */
     getResourceBySSRC(ssrc) {
+        const track = this._getTrackBySSRC(ssrc);
 
-        // FIXME: Convert the SSRCs in whole project to use the same type.
-        // Now we are using number and string.
-        if (this.getLocalTracks().find(
+        return track ? track.getParticipantId() : null;
+    }
 
-            // eslint-disable-next-line eqeqeq
-                localTrack => localTrack.getSSRC() == ssrc)) {
-            return this.conference.myUserId();
-        }
+    /**
+     * Finds a track (either local or remote) which runs on the given SSRC.
+     * @param {string|number} ssrc
+     * @return {JitsiTrack|undefined}
+     *
+     * FIXME figure out where SSRC is stored as a string and convert to number
+     * @private
+     */
+    _getTrackBySSRC(ssrc) {
+        let track
+            = this.getLocalTracks().find(
+                localTrack =>
 
-        const track = this.getRemoteTrackBySSRC(ssrc);
+                    // It is important that SSRC is not compared with ===,
+                    // because the code calling this method is inconsistent
+                    // about string vs number types
+                    Array.from(this.peerConnections.values())
+                         .find(pc => pc.getLocalSSRC(localTrack) == ssrc) // eslint-disable-line eqeqeq, max-len
+                );
 
+        if (!track) {
+            track = this._getRemoteTrackBySSRC(ssrc);
+        }
 
-        return track ? track.getParticipantId() : null;
+        return track;
     }
 
     /**
      * @param ssrc the ssrc to check.
      * @return {JitsiRemoteTrack|undefined} return the first remote track that
      * matches given SSRC or <tt>undefined</tt> if no such track was found.
+     * @private
      */
-    getRemoteTrackBySSRC(ssrc) {
-
+    _getRemoteTrackBySSRC(ssrc) {
+        /* eslint-disable eqeqeq */
         // FIXME: Convert the SSRCs in whole project to use the same type.
         // Now we are using number and string.
-        // eslint-disable-next-line eqeqeq
-        return this.getRemoteTracks().find(t => ssrc == t.getSSRC());
-    }
-
-    /**
-     * Handles remote track mute / unmute events.
-     * @param type {string} "audio" or "video"
-     * @param isMuted {boolean} the new mute state
-     * @param from {string} user id
-     */
-    handleRemoteTrackMute(type, isMuted, from) {
-        const track = this.getRemoteTrackByType(type, from);
+        return this.getRemoteTracks().find(
+            remoteTrack => ssrc == remoteTrack.getSSRC());
 
-        if (track) {
-            track.setMute(isMuted);
-        }
-    }
-
-    /**
-     * Handles remote track video type events
-     * @param value {string} the new video type
-     * @param from {string} user id
-     */
-    handleRemoteTrackVideoTypeChanged(value, from) {
-        const videoTrack = this.getRemoteVideoTrack(from);
-
-        if (videoTrack) {
-            videoTrack._setVideoType(value);
-        }
+        /* eslint-enable eqeqeq */
     }
 
     /**

modules/RTC/RTCBrowserType.js

 
     RTC_BROWSER_REACT_NATIVE: 'rtc_browser.react-native',
 
+    /**
+     * Tells whether or not the <tt>MediaStream/tt> is removed from
+     * the <tt>PeerConnection</tt> and disposed on video mute (in order to turn
+     * off the camera device).
+     * @return {boolean} <tt>true</tt> if the current browser supports this
+     * strategy or <tt>false</tt> otherwise.
+     */
+    doesVideoMuteByStreamRemove() {
+        return !RTCBrowserType.isFirefox();
+    },
+
     /**
      * Gets current browser type.
      * @returns {string}
         return currentBrowser === RTCBrowserType.RTC_BROWSER_ELECTRON;
     },
 
+    /**
+     * Check whether or not the current browser support peer to peer connections
+     * @return {boolean} <tt>true</tt> if p2p is supported or <tt>false</tt>
+     * otherwise.
+     */
+    isP2PSupported() {
+        return !RTCBrowserType.isFirefox() && !RTCBrowserType.isReactNative();
+    },
+
     /**
      * Checks if current environment is React Native.
      * @returns {boolean}

modules/connectivity/ConnectionQuality.js

 
         conference.room.addListener(
             XMPPEvents.ICE_CONNECTION_STATE_CHANGED,
-            newState => {
-                if (newState === 'connected') {
+            (jingleSession, newState) => {
+                if (!jingleSession.isP2P && newState === 'connected') {
                     this._timeIceConnected = window.performance.now();
                 }
             });

modules/connectivity/ParticipantConnectionStatus.js

             RTCEvents.ENDPOINT_CONN_STATUS_CHANGED,
             this._onEndpointConnStatusChanged);
 
+        // Handles P2P status changes
+        this._onP2PStatus = this.refreshConnectionStatusForAll.bind(this);
+        this.conference.on(JitsiConferenceEvents.P2P_STATUS, this._onP2PStatus);
+
         // On some browsers MediaStreamTrack trigger "onmute"/"onunmute"
         // events for video type tracks when they stop receiving data which is
         // often a sign that remote user is having connectivity issues
                 this._onRemoteTrackRemoved);
         }
 
-        Object.keys(this.trackTimers).forEach(participantId => {
+        this.conference.off(
+            JitsiConferenceEvents.P2P_STATUS, this._onP2PStatus);
+
+        const participantIds = Object.keys(this.trackTimers);
+
+        for (const participantId of participantIds) {
             this.clearTimeout(participantId);
             this.clearRtcMutedTimestamp(participantId);
-        });
+        }
 
         // Clear RTC connection status cache
         this.connStatusFromJvb = {};
             && (Date.now() - rtcMutedTimestamp) >= this.rtcMuteTimeout;
     }
 
+    /**
+     * Goes over every participant and updates connectivity status.
+     * Should be called when a parameter which affects all of the participants
+     * is changed (P2P for example).
+     */
+    refreshConnectionStatusForAll() {
+        const participants = this.conference.getParticipants();
+
+        for (const participant of participants) {
+            this.figureOutConnectionStatus(participant.getId());
+        }
+    }
+
     /**
      * Figures out (and updates) the current connectivity status for
      * the participant identified by the given id.
         const isInLastN = this.rtc.isInLastN(id);
         let isConnActiveByJvb = this.connStatusFromJvb[id];
 
-        // If no status was received from the JVB it means that it's active
-        // (the bridge does not send notification unless there is a problem).
-        if (typeof isConnActiveByJvb !== 'boolean') {
+        if (this.conference.isP2PActive()) {
+            logger.debug('Assuming connection active by JVB - in P2P mode');
+            isConnActiveByJvb = true;
+        } else if (typeof isConnActiveByJvb !== 'boolean') {
+            // If no status was received from the JVB it means that it's active
+            // (the bridge does not send notification unless there is a problem)
             logger.debug('Assuming connection active by JVB - no notification');
             isConnActiveByJvb = true;
         }

modules/statistics/RTPStatsCollector.js

 
             if (!conferenceStatsTransport.some(
                     t =>
-                        t.ip === ip
-                        && t.type === type
-                        && t.localip === localip)) {
-                conferenceStatsTransport.push({ ip,
+                       t.ip === ip
+                       && t.type === type
+                       && t.localip === localip)) {
+                conferenceStatsTransport.push({
+                    ip,
                     type,
-                    localip });
+                    localip,
+                    p2p: this.peerconnection.isP2P
+                });
             }
             continue;
         }
             this.conferenceStats.transport.push({
                 ip: `${remote.ipAddress}:${remote.portNumber}`,
                 type: local.transport,
-                localip: `${local.ipAddress}:${local.portNumber}`
+                localip: `${local.ipAddress}:${local.portNumber}`,
+                p2p: this.peerconnection.isP2P
             });
         }
 
         this
     );
 
-    this.eventEmitter.emit(StatisticsEvents.BYTE_SENT_STATS, byteSentStats);
+    this.eventEmitter.emit(
+        StatisticsEvents.BYTE_SENT_STATS, this.peerconnection, byteSentStats);
 
     this.conferenceStats.bitrate
       = { 'upload': bitrateUpload,

modules/xmpp/ChatRoom.js

         // make sure we catch all errors coming from any handler
         // otherwise we can remove the presence handler from strophe
         try {
-            let tagHandler = this.presHandlers[node.tagName];
+            let tagHandlers = this.presHandlers[node.tagName];
 
             if (node.tagName.startsWith('jitsi_participant_')) {
-                tagHandler = this.participantPropertyListener;
+                tagHandlers = [ this.participantPropertyListener ];
             }
 
-            if (tagHandler) {
-                tagHandler(node, Strophe.getResourceFromJid(from), from);
+            if (tagHandlers) {
+                tagHandlers.forEach(handler => {
+                    handler(node, Strophe.getResourceFromJid(from), from);
+                });
             }
         } catch (e) {
             GlobalOnErrorHandler.callErrorHandler(e);
      * @param handler
      */
     addPresenceListener(name, handler) {
-        this.presHandlers[name] = handler;
+        if (typeof handler !== 'function') {
+            throw new Error('"handler" is not a function');
+        }
+        let tagHandlers = this.presHandlers[name];
+
+        if (!tagHandlers) {
+            this.presHandlers[name] = tagHandlers = [];
+        }
+        if (tagHandlers.indexOf(handler) === -1) {
+            tagHandlers.push(handler);
+        } else {
+            logger.warn(
+                `Trying to add the same handler more than once for: ${name}`);
+        }
     }
 
     /**
      *
      * @param name
+     * @param handler
      */
-    removePresenceListener(name) {
-        delete this.presHandlers[name];
+    removePresenceListener(name, handler) {
+        const tagHandlers = this.presHandlers[name];
+        const handlerIdx = tagHandlers ? tagHandlers.indexOf(handler) : -1;
+
+        // eslint-disable-next-line no-negated-condition
+        if (handlerIdx !== -1) {
+            tagHandlers.splice(handlerIdx, 1);
+        } else {
+            logger.warn(`Handler for: ${name} was not registered`);
+        }
     }
 
     /**
     /**
      *
      * @param mute
-     * @apram callback
+     * @param callback
      */
     setAudioMute(mute, callback) {
         return this.sendAudioInfoPresence(mute, callback);

modules/xmpp/RtxModifier.js

 
             return sdpStr;
         }
+
+        return this.modifyRtxSsrcs2(videoMLine)
+            ? sdpTransformer.toRawSDP() : sdpStr;
+    }
+
+    /**
+     * Does the same thing as {@link modifyRtxSsrcs}, but takes the
+     *  {@link MLineWrap} instance wrapping video media as an argument.
+     * @param {MLineWrap} videoMLine
+     * @return {boolean} <tt>true</tt> if the SDP wrapped by
+     *  {@link SdpTransformWrap} has been modified or <tt>false</tt> otherwise.
+     */
+    modifyRtxSsrcs2(videoMLine) {
         if (videoMLine.direction === 'inactive'
-                || videoMLine.direction === 'recvonly') {
+            || videoMLine.direction === 'recvonly') {
             logger.debug('RtxModifier doing nothing, video '
                 + 'm line is inactive or recvonly');
 
-            return sdpStr;
+            return false;
         }
         if (videoMLine.getSSRCCount() < 1) {
             logger.debug('RtxModifier doing nothing, no video ssrcs present');
 
-            return sdpStr;
+            return false;
         }
         logger.debug('Current ssrc mapping: ', this.correspondingRtxSsrcs);
         const primaryVideoSsrcs = videoMLine.getPrimaryVideoSSRCs();
                 correspondingRtxSsrc);
         }
 
-        return sdpTransformer.toRawSDP();
+        // FIXME we're not looking into much details whether the SDP has been
+        // modified or not once the precondition requirements are met.
+        return true;
     }
 
     /**

modules/xmpp/SDPDiffer.js

                 const mySsrcGroup = myMedia.ssrcGroups[i];
 
                 if (otherSsrcGroup.semantics === mySsrcGroup.semantics
-                    && arrayEquals(otherSsrcGroup.ssrcs,
-                                      [ mySsrcGroup.ssrcs ])) {
+                    && arrayEquals(otherSsrcGroup.ssrcs, mySsrcGroup.ssrcs)) {
 
                     matched = true;
                     break;

modules/xmpp/SDPUtil.js

         return sdp.media.find(m => m.type === type);
     },
 
+    /**
+     * Extracts the ICE username fragment from an SDP string.
+     * @param {string} sdp the SDP in raw text format
+     */
+    getUfrag(sdp) {
+        const ufragLines
+            = sdp.split('\n').filter(
+                    line => line.startsWith('a=ice-ufrag:'));
+
+        if (ufragLines.length > 0) {
+            return ufragLines[0].substr('a=ice-ufrag:'.length);
+        }
+    },
+
     /**
      * Sets the given codecName as the preferred codec by
      *  moving it to the beginning of the payload types

modules/xmpp/SdpConsistency.js

      * Constructor
      */
     constructor() {
-        this.clearSsrcCache();
+        this.clearVideoSsrcCache();
+
+        /**
+         * Cached audio SSRC.
+         * @type {number|null}
+         */
+        this.cachedAudioSSRC = null;
     }
 
     /**
-     * Clear the cached primary and primary rtx ssrcs so that
+     * Clear the cached video primary and primary rtx ssrcs so that
      *  they will not be used for the next call to
      *  makeVideoPrimarySsrcsConsistent
      */
-    clearSsrcCache() {
+    clearVideoSsrcCache() {
         this.cachedPrimarySsrc = null;
     }
 
 
         return sdpTransformer.toRawSDP();
     }
+
+    /**
+     * Makes sure that audio SSRC is preserved between "detach" and "attach"
+     *  operations. The code assumes there can be only 1 audio track added to
+     *  the peer connection at a time.
+     * @param {string} sdpStr the sdp string to (potentially)
+     *  change to make the audio ssrc consistent
+     * @returns {string} a (potentially) modified sdp string
+     *  with ssrcs consistent with this class' cache
+     */
+    makeAudioSSRCConsistent(sdpStr) {
+        const sdpTransformer = new SdpTransformWrap(sdpStr);
+        const audioMLine = sdpTransformer.selectMedia('audio');
+
+        if (!audioMLine) {
+            logger.error(`No 'audio' media found in the sdp: ${sdpStr}`);
+
+            return sdpStr;
+        }
+        if (audioMLine.direction === 'inactive') {
+            logger.info(
+                'Sdp-consistency doing nothing, audio mline is inactive');
+
+            return sdpStr;
+        }
+
+        const audioSSRCObj = audioMLine.findSSRCByMSID(null);
+
+        if (audioSSRCObj) {
+            if (this.cachedAudioSSRC) {
+                const oldSSRC = audioSSRCObj.id;
+
+                if (oldSSRC !== this.cachedAudioSSRC) {
+                    logger.info(
+                        `Replacing audio SSRC ${
+                            oldSSRC} with ${this.cachedAudioSSRC}`);
+                    audioMLine.replaceSSRC(oldSSRC, this.cachedAudioSSRC);
+                }
+            } else {
+                this.cachedAudioSSRC = audioSSRCObj.id;
+                logger.info(`Storing audio SSRC: ${this.cachedAudioSSRC}`);
+            }
+        } else {
+            logger.info('Doing nothing - no audio stream in the SDP');
+        }
+
+        return sdpTransformer.toRawSDP();
+    }
 }

modules/xmpp/SdpTransformUtil.js

     }
 
     /**
+     * Getter for the mLine's "ssrcs" array. If the array was undefined an empty
+     * one will be preassigned.
      *
+     * @return {Array<Object>} an array of 'sdp-transform' SSRC attributes
+     * objects.
      */
-    get _ssrcs() {
+    get ssrcs() {
         if (!this.mLine.ssrcs) {
             this.mLine.ssrcs = [];
         }
         return this.mLine.ssrcs;
     }
 
+    /**
+     * Setter for the mLine's "ssrcs" array.
+     *
+     * @param {Array<Object>} ssrcs an array of 'sdp-transform' SSRC attributes
+     * objects.
+     */
+    set ssrcs(ssrcs) {
+        this.mLine.ssrcs = ssrcs;
+    }
+
     /**
      * Returns the direction of the underlying media description.
      * @return {string} the media direction name as defined in the SDP.
      * <tt>undefined</tt> if no such attribute exists.
      */
     getSSRCAttrValue(ssrcNumber, attrName) {
-        const attribute = this._ssrcs.find(
+        const attribute = this.ssrcs.find(
             ssrcObj => ssrcObj.id === ssrcNumber
             && ssrcObj.attribute === attrName);
 
      * the 'sdp-transform' lib.
      */
     addSSRCAttribute(ssrcObj) {
-        this._ssrcs.push(ssrcObj);
+        this.ssrcs.push(ssrcObj);
     }
 
     /**
                 && parsePrimarySSRC(group) === primarySSRC);
     }
 
+    /**
+     * @param {string|null} msid the media stream id or <tt>null</tt> to match
+     * the first SSRC object with any 'msid' value.
+     * @return {Object|undefined} the SSRC object as defined by 'sdp-transform'
+     * lib.
+     */
+    findSSRCByMSID(msid) {
+        return this.ssrcs.find(
+            ssrcObj => ssrcObj.attribute === 'msid'
+                && (msid === null || ssrcObj.value === msid));
+    }
+
     /**
      * Gets the SSRC count for the underlying media description.
      * @return {number}
         const numSsrcs = _getSSRCCount(this.mLine);
 
         if (numSsrcs === 1) {
-            // Not using _ssrcs on purpose here
+            // Not using "ssrcs" getter on purpose here
             return this.mLine.ssrcs[0].id;
         }
 
      * @return {Array.<number>} an array with all SSRC as numbers.
      */
     getSSRCs() {
-        return this._ssrcs
+        return this.ssrcs
             .map(ssrcInfo => ssrcInfo.id)
             .filter((ssrc, index, array) => array.indexOf(ssrc) === index);
     }

modules/xmpp/SignalingLayerImpl.js

+/* global __filename */
+
+import { getLogger } from 'jitsi-meet-logger';
+import * as MediaType from '../../service/RTC/MediaType';
+import * as SignalingEvents from '../../service/RTC/SignalingEvents';
+import SignalingLayer from '../../service/RTC/SignalingLayer';
+
+const logger = getLogger(__filename);
+
+/**
+ * Default XMPP implementation of the {@link SignalingLayer} interface. Obtains
+ * the data from the MUC presence.
+ */
+export default class SignalingLayerImpl extends SignalingLayer {
+    /**
+     * Creates new instance.
+     */
+    constructor() {
+        super();
+
+        /**
+         * A map that stores SSRCs of remote streams. And is used only locally
+         * We store the mapping when jingle is received, and later is used
+         * onaddstream webrtc event where we have only the ssrc
+         * FIXME: This map got filled and never cleaned and can grow during long
+         * conference
+         * @type {Map<string, string>} maps SSRC number to jid
+         */
+        this.ssrcOwners = new Map();
+
+        /**
+         *
+         * @type {ChatRoom|null}
+         */
+        this.chatRoom = null;
+    }
+
+    /**
+     * Sets the <tt>ChatRoom</tt> instance used and binds presence listeners.
+     * @param {ChatRoom} room
+     */
+    setChatRoom(room) {
+        const oldChatRoom = this.chatRoom;
+
+        this.chatRoom = room;
+        if (oldChatRoom) {
+            oldChatRoom.removePresenceListener(
+                'audiomuted', this._audioMuteHandler);
+            oldChatRoom.removePresenceListener(
+                'videomuted', this._videoMuteHandler);
+            oldChatRoom.removePresenceListener(
+                'videoType', this._videoTypeHandler);
+        }
+        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);
+        }
+    }
+
+    /**
+     * @inheritDoc
+     */
+    getPeerMediaInfo(owner, mediaType) {
+        if (this.chatRoom) {
+            return this.chatRoom.getMediaPresenceInfo(owner, mediaType);
+        }
+        logger.error('Requested peer media info, before room was set');
+    }
+
+    /**
+     * @inheritDoc
+     */
+    getSSRCOwner(ssrc) {
+        return this.ssrcOwners.get(ssrc);
+    }
+
+    /**
+     * Set an SSRC owner.
+     * @param {string} ssrc an SSRC to be owned
+     * @param {string} endpointId owner's ID (MUC nickname)
+     */
+    setSSRCOwner(ssrc, endpointId) {
+        this.ssrcOwners.set(ssrc, endpointId);
+    }
+}

modules/xmpp/strophe.jingle.js

-/* global $, $iq, Strophe */
+/* global $, $iq, __filename, Strophe */
 
 import { getLogger } from 'jitsi-meet-logger';
 const logger = getLogger(__filename);
 
 import JingleSessionPC from './JingleSessionPC';
+import * as JingleSessionState from './JingleSessionState';
 import XMPPEvents from '../../service/xmpp/XMPPEvents';
 import GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
+import RandomUtil from '../util/RandomUtil';
 import Statistics from '../statistics/statistics';
 import ConnectionPlugin from './ConnectionPlugin';
 
  */
 class JingleConnectionPlugin extends ConnectionPlugin {
     /**
-     *
-     * @param xmpp
-     * @param eventEmitter
+     * Creates new <tt>JingleConnectionPlugin</tt>
+     * @param {XMPP} xmpp
+     * @param {EventEmitter} eventEmitter
+     * @param {Array<Object>} p2pStunServers an array which is part of the ice
+     * config passed to the <tt>PeerConnection</tt> with the structure defined
+     * by the WebRTC standard.
      */
-    constructor(xmpp, eventEmitter) {
+    constructor(xmpp, eventEmitter, p2pStunServers) {
         super();
         this.xmpp = xmpp;
         this.eventEmitter = eventEmitter;
         this.sessions = {};
-        this.iceConfig = { iceServers: [] };
+        this.jvbIceConfig = { iceServers: [ ] };
+        this.p2pIceConfig = { iceServers: [ ] };
+        if (Array.isArray(p2pStunServers)) {
+            logger.info('Configured STUN servers: ', p2pStunServers);
+            this.p2pIceConfig.iceServers = p2pStunServers;
+        }
         this.mediaConstraints = {
             mandatory: {
                 'OfferToReceiveAudio': true,
                 const videoMuted = startMuted.attr('video');
 
                 this.eventEmitter.emit(XMPPEvents.START_MUTED_FROM_FOCUS,
-                            audioMuted === 'true', videoMuted === 'true');
+                        audioMuted === 'true', videoMuted === 'true');
             }
+
+            // FIXME that should work most of the time, but we'd have to
+            // think how secure it is to assume that user with "focus"
+            // nickname is Jicofo.
+            const isP2P = Strophe.getResourceFromJid(fromJid) !== 'focus';
+
+            logger.info(
+                `Marking session from ${fromJid
+                } as ${isP2P ? '' : '*not*'} P2P`);
             sess = new JingleSessionPC(
                         $(iq).find('jingle').attr('sid'),
                         $(iq).attr('to'),
                         fromJid,
                         this.connection,
                         this.mediaConstraints,
-                        this.iceConfig, this.xmpp.options);
+                        isP2P ? this.p2pIceConfig : this.jvbIceConfig,
+                        isP2P /* P2P */,
+                        false /* initiator */,
+                        this.xmpp.options);
 
             this.sessions[sess.sid] = sess;
 
                     'xmpp.session-initiate', { value: now });
             break;
         }
+        case 'session-accept': {
+            this.eventEmitter.emit(
+                XMPPEvents.CALL_ACCEPTED, sess, $(iq).find('>jingle'));
+            break;
+        }
+        case 'transport-info': {
+            this.eventEmitter.emit(
+                XMPPEvents.TRANSPORT_INFO, sess, $(iq).find('>jingle'));
+            break;
+        }
         case 'session-terminate': {
             logger.log('terminating...', sess.sid);
             let reasonCondition = null;
                     = $(iq).find('>jingle>reason>:first')[0].tagName;
                 reasonText = $(iq).find('>jingle>reason>text').text();
             }
+            sess.state = JingleSessionState.ENDED;
             this.terminate(sess.sid, reasonCondition, reasonText);
             this.eventEmitter.emit(XMPPEvents.CALL_ENDED,
-                    sess, reasonCondition, reasonText);
+                sess, reasonCondition, reasonText);
             break;
         }
         case 'transport-replace':
         return true;
     }
 
+    /**
+     * Creates new <tt>JingleSessionPC</tt> meant to be used in a direct P2P
+     * connection, configured as 'initiator'.
+     * @param {string} me our JID
+     * @param {string} peer remote participant's JID
+     * @return {JingleSessionPC}
+     */
+    newP2PJingleSession(me, peer) {
+        const sess
+            = new JingleSessionPC(
+                    RandomUtil.randomHexString(12),
+                    me,
+                    peer,
+                    this.connection,
+                    this.mediaConstraints,
+                    this.p2pIceConfig,
+                    true /* P2P */,
+                    true /* initiator */,
+                    this.xmpp.options);
+
+        this.sessions[sess.sid] = sess;
+
+        return sess;
+    }
+
     /**
      *
      * @param sid
                     }
                     }
                 });
-                this.iceConfig.iceServers = iceservers;
+                this.jvbIceConfig.iceServers = iceservers;
             }, err => {
                 logger.warn('getting turn credentials failed', err);
                 logger.warn('is mod_turncredentials or similar installed?');
 
 /* eslint-enable newline-per-chained-call */
 
-module.exports = function(XMPP, eventEmitter) {
+module.exports = function(XMPP, eventEmitter, p2pStunServers) {
     Strophe.addConnectionPlugin(
         'jingle',
-        new JingleConnectionPlugin(XMPP, eventEmitter));
+        new JingleConnectionPlugin(XMPP, eventEmitter, p2pStunServers));
 };

modules/xmpp/xmpp.js

  */
 export default class XMPP extends Listenable {
     /**
-     *
-     * @param options
+     * FIXME describe all options
+     * @param {Object} options
+     * @param {Array<Object>} options.p2pStunServers see
+     * {@link JingleConnectionPlugin} for more details.
      * @param token
      */
     constructor(options, token) {
      */
     _initStrophePlugins() {
         initEmuc(this);
-        initJingle(this, this.eventEmitter);
+        initJingle(this, this.eventEmitter, this.options.p2pStunServers);
         initStropheUtil();
         initPing(this);
         initRayo();

service/RTC/RTCEvents.js

      */
     CREATE_OFFER_FAILED: 'rtc.create_offer_failed',
     RTC_READY: 'rtc.ready',
-
-    /**
-     * FIXME: rename to something closer to "local streams SDP changed"
-     * Indicates that the local sendrecv streams in local SDP are changed.
-     */
-    SENDRECV_STREAMS_CHANGED: 'rtc.sendrecv_streams_changed',
     DATA_CHANNEL_OPEN: 'rtc.data_channel_open',
     ENDPOINT_CONN_STATUS_CHANGED: 'rtc.endpoint_conn_status_changed',
     LASTN_CHANGED: 'rtc.lastn_changed',
 
     /**
      * Event fired when we remote track is added to the conference.
-     * The following structure is passed as an argument:
-     * {
-     *   stream: the WebRTC MediaStream instance
-     *   track: the WebRTC MediaStreamTrack
-     *   mediaType: the MediaType instance
-     *   owner: the MUC JID of the stream owner
-     *   muted: a boolean indicating initial 'muted' status of the track or
-      *         'null' if unknown
+     * 1st event argument is the added <tt>JitsiRemoteTrack</tt> instance.
      **/
     REMOTE_TRACK_ADDED: 'rtc.remote_track_added',
 
 
     /**
      * Indicates that the remote track has been removed from the conference.
-     * 1st event argument is the ID of the parent WebRTC stream to which
-     * the track being removed belongs to.
-     * 2nd event argument is the ID of the removed track.
+     * 1st event argument is the removed {@link JitsiRemoteTrack} instance.
      */
     REMOTE_TRACK_REMOVED: 'rtc.remote_track_removed',
 
      * Indicates that a message from another participant is received on
      * data channel.
      */
-    ENDPOINT_MESSAGE_RECEIVED:
-        'rtc.endpoint_message_received'
+    ENDPOINT_MESSAGE_RECEIVED: 'rtc.endpoint_message_received',
+
+    /**
+     * Designates an event indicating that the local ICE username fragment of
+     * the jingle session has changed.
+     * The first argument of the vent is <tt>TraceablePeerConnection</tt> which
+     * is the source of the event.
+     * The second argument is the actual "ufrag" string.
+     */
+    LOCAL_UFRAG_CHANGED: 'rtc.local_ufrag_changed',
+
+    /**
+     * Designates an event indicating that the local ICE username fragment of
+     * the jingle session has changed.
+     * The first argument of the vent is <tt>TraceablePeerConnection</tt> which
+     * is the source of the event.
+     * The second argument is the actual "ufrag" string.
+     */
+    REMOTE_UFRAG_CHANGED: 'rtc.remote_ufrag_changed'
 };
 
 module.exports = RTCEvents;

service/RTC/SignalingEvents.js

+/**
+ * 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
+ */
+export const 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
+ */
+export const PEER_VIDEO_TYPE_CHANGED = 'signaling.peerVideoType';

service/RTC/SignalingLayer.js

 
+import Listenable from '../../modules/util/Listenable';
+
 /**
  * An object that carries the info about specific media type advertised by
- * participant in the signalling channel.
+ * participant in the signaling channel.
  * @typedef {Object} PeerMediaInfo
  * @property {boolean} muted indicates if the media is currently muted
  * @property {VideoType|undefined} videoType the type of the video if applicable
  */
 
 /**
- * Interface used to expose the information carried over the signalling channel
+ * Interface used to expose the information carried over the signaling channel
  * which is not available to the RTC module in the media SDP.
  *
  * @interface SignalingLayer
  */
-export default class SignalingLayer {
+export default class SignalingLayer extends Listenable {
 
     /**
      * Obtains the endpoint ID for given SSRC.

service/xmpp/XMPPEvents.js

     AUTHENTICATION_REQUIRED: 'xmpp.authentication_required',
     BRIDGE_DOWN: 'xmpp.bridge_down',
 
+    /**
+     * Triggered when 'session-accept' is received from the responder.
+     */
+    CALL_ACCEPTED: 'xmpp.callaccepted.jingle',
+
     // Designates an event indicating that an offer (e.g. Jingle
     // session-initiate) was received.
     CALL_INCOMING: 'xmpp.callincoming.jingle',
     CHAT_ERROR_RECEIVED: 'xmpp.chat_error_received',
     CONFERENCE_SETUP_FAILED: 'xmpp.conference_setup_failed',
 
+    /**
+     * This event is triggered when the ICE connects for the first time.
+     */
+    CONNECTION_ESTABLISHED: 'xmpp.connection.connected',
+
     // Designates an event indicating that the connection to the XMPP server
     // failed.
     CONNECTION_FAILED: 'xmpp.connection.failed',
     // changed.
     SUBJECT_CHANGED: 'xmpp.subject_changed',
 
+    // FIXME: how does it belong to XMPP ? - it's detected by the PeerConnection
     // suspending detected
     SUSPEND_DETECTED: 'xmpp.suspend_detected',
 
-    // Designates an event indicating that the local ICE username fragment of
-    // the jingle session has changed.
-    LOCAL_UFRAG_CHANGED: 'xmpp.local_ufrag_changed',
-
-    // Designates an event indicating that the local ICE username fragment of
-    // the jingle session has changed.
-    REMOTE_UFRAG_CHANGED: 'xmpp.remote_ufrag_changed',
+    /**
+     * Event fired when 'transport-info' with new ICE candidates is received.
+     */
+    TRANSPORT_INFO: 'xmpp.transportinfo.jingle',
 
     // Designates an event indicating that the local ICE connection state has
     // changed.