Merge pull request #373 from jitsi/move_TPC

Move TraceablePeerConnection to RTC

.jshintignore

@@ -8,7 +8,6 @@ doc
 
 modules/xmpp/xmpp.js
 modules/xmpp/strophe.jingle.js
-modules/xmpp/TraceablePeerConnection.js
 modules/xmpp/SDPUtil.js
 modules/xmpp/SDP.js
 modules/xmpp/strophe.emuc.js
@@ -22,6 +21,7 @@ modules/RTC/adapter.screenshare.js
 modules/statistics/statistics.js
 modules/RTC/RTC.js
 modules/RTC/RTCUtils.js
+modules/RTC/TraceablePeerConnection.js
 modules/RTC/DataChannels.js
 modules/RTC/JitsiLocalTrack.js
 modules/RTC/JitsiRemoteTrack.js

JitsiConference.js

@@ -1,28 +1,30 @@
-/* global Strophe, Promise */
+/* global __filename, Strophe, Promise */
 
-var logger = require("jitsi-meet-logger").getLogger(__filename);
-import RTC from "./modules/RTC/RTC";
-import * as MediaType from "./service/RTC/MediaType";
-var XMPPEvents = require("./service/xmpp/XMPPEvents");
-var EventEmitter = require("events");
+import ComponentsVersions from "./modules/version/ComponentsVersions";
+import ConnectionQuality from "./modules/connectivity/ConnectionQuality";
+import { getLogger } from "jitsi-meet-logger";
+import GlobalOnErrorHandler from "./modules/util/GlobalOnErrorHandler";
+import EventEmitter from "events";
 import * as JitsiConferenceErrors from "./JitsiConferenceErrors";
+import JitsiConferenceEventManager from "./JitsiConferenceEventManager";
 import * as JitsiConferenceEvents from "./JitsiConferenceEvents";
+import JitsiDTMFManager from './modules/DTMF/JitsiDTMFManager';
 import JitsiParticipant from "./JitsiParticipant";
-var Statistics = require("./modules/statistics/statistics");
-var JitsiDTMFManager = require('./modules/DTMF/JitsiDTMFManager');
 import JitsiTrackError from "./JitsiTrackError";
 import * as JitsiTrackErrors from "./JitsiTrackErrors";
 import * as JitsiTrackEvents from "./JitsiTrackEvents";
-var ComponentsVersions = require("./modules/version/ComponentsVersions");
-var GlobalOnErrorHandler = require("./modules/util/GlobalOnErrorHandler");
-var JitsiConferenceEventManager = require("./JitsiConferenceEventManager");
-var VideoType = require('./service/RTC/VideoType');
-var RTCBrowserType = require("./modules/RTC/RTCBrowserType.js");
-var Transcriber = require("./modules/transcription/transcriber");
+import * as MediaType from "./service/RTC/MediaType";
 import ParticipantConnectionStatus
     from "./modules/connectivity/ParticipantConnectionStatus";
+import RTC from "./modules/RTC/RTC";
+import RTCBrowserType from "./modules/RTC/RTCBrowserType.js";
+import * as RTCEvents from "./service/RTC/RTCEvents";
+import Statistics from "./modules/statistics/statistics";
 import TalkMutedDetection from "./modules/TalkMutedDetection";
-import ConnectionQuality from "./modules/connectivity/ConnectionQuality";
+import Transcriber from "./modules/transcription/transcriber";
+import VideoType from './service/RTC/VideoType';
+
+const logger = getLogger(__filename);
 
 /**
  * Creates a JitsiConference object with the given name and properties.
@@ -170,7 +172,7 @@ JitsiConference.prototype.leave = function () {
         this.participantConnectionStatus = null;
     }
 
-    this.getLocalTracks().forEach(track => this.onTrackRemoved(track));
+    this.getLocalTracks().forEach(track => this.onLocalTrackRemoved(track));
 
     this.rtc.closeAllDataChannels();
     if (this.statistics)
@@ -262,17 +264,27 @@ JitsiConference.prototype.getExternalAuthUrl = function (urlForPopup) {
 JitsiConference.prototype.getLocalTracks = function (mediaType) {
     let tracks = [];
     if (this.rtc) {
-        tracks = this.rtc.localTracks.slice();
-    }
-    if (mediaType !== undefined) {
-        tracks = tracks.filter(
-            (track) => {
-                return track && track.getType && track.getType() === mediaType;
-            });
+        tracks = this.rtc.getLocalTracks(mediaType);
     }
     return tracks;
 };
 
+/**
+ * Obtains local audio track.
+ * @return {JitsiLocalTrack|null}
+ */
+JitsiConference.prototype.getLocalAudioTrack = function () {
+    return this.rtc ? this.rtc.getLocalAudioTrack() : null;
+};
+
+/**
+ * Obtains local video track.
+ * @return {JitsiLocalTrack|null}
+ */
+JitsiConference.prototype.getLocalVideoTrack = function () {
+    return this.rtc ? this.rtc.getLocalVideoTrack() : null;
+};
+
 /**
  * Attaches a handler for events(For example - "participant joined".) in the conference. All possible event are defined
  * in JitsiConferenceEvents.
@@ -394,17 +406,15 @@ JitsiConference.prototype.getTranscriber = function(){
     if (this.transcriber === undefined){
         this.transcriber = new Transcriber();
         //add all existing local audio tracks to the transcriber
-        this.rtc.localTracks.forEach(function (localTrack) {
-            if (localTrack.isAudioTrack()){
-                this.transcriber.addTrack(localTrack);
-            }
-        }.bind(this));
+        const localAudioTracks = this.getLocalTracks(MediaType.AUDIO);
+        for (const localAudio of localAudioTracks) {
+            this.transcriber.addTrack(localAudio);
+        }
         //and all remote audio tracks
-        this.rtc.remoteTracks.forEach(function (remoteTrack){
-            if (remoteTrack.isAudioTrack()){
-                this.transcriber.addTrack(remoteTrack);
-            }
-        }.bind(this));
+        const remoteAudioTracks = this.rtc.getRemoteTracks(MediaType.AUDIO);
+        for (const remoteTrack of remoteAudioTracks){
+            this.transcriber.addTrack(remoteTrack);
+        }
     }
     return this.transcriber;
 };
@@ -463,7 +473,7 @@ JitsiConference.prototype._fireMuteChangeEvent = function (track) {
  * Clear JitsiLocalTrack properties and listeners.
  * @param track the JitsiLocalTrack object.
  */
-JitsiConference.prototype.onTrackRemoved = function (track) {
+JitsiConference.prototype.onLocalTrackRemoved = function (track) {
     track._setSSRC(null);
     track._setConference(null);
     this.rtc.removeLocalTrack(track);
@@ -471,7 +481,7 @@ JitsiConference.prototype.onTrackRemoved = function (track) {
         track.muteHandler);
     track.removeEventListener(JitsiTrackEvents.TRACK_AUDIO_LEVEL_CHANGED,
         track.audioLevelHandler);
-    this.room.removeListener(XMPPEvents.SENDRECV_STREAMS_CHANGED,
+    this.rtc.removeListener(RTCEvents.SENDRECV_STREAMS_CHANGED,
         track.ssrcHandler);
 
     // send event for stopping screen sharing
@@ -519,18 +529,19 @@ JitsiConference.prototype.replaceTrack = function (oldTrack, newTrack) {
         newTrack.ssrcHandler = function (conference, ssrcMap) {
             if (ssrcMap[this.getMSID()]) {
                 this._setSSRC(ssrcMap[this.getMSID()]);
-                conference.room.removeListener(XMPPEvents.SENDRECV_STREAMS_CHANGED,
+                conference.rtc.removeListener(
+                    RTCEvents.SENDRECV_STREAMS_CHANGED,
                     this.ssrcHandler);
             }
         }.bind(newTrack, this);
-        this.room.addListener(XMPPEvents.SENDRECV_STREAMS_CHANGED,
+        this.rtc.addListener(RTCEvents.SENDRECV_STREAMS_CHANGED,
             newTrack.ssrcHandler);
     }
     // Now replace the stream at the lower levels
     return this._doReplaceTrack(oldTrack, newTrack)
         .then(() => {
             if (oldTrack) {
-                this.onTrackRemoved(oldTrack);
+                this.onLocalTrackRemoved(oldTrack);
             }
             if (newTrack) {
                 // Now handle the addition of the newTrack at the JitsiConference level
@@ -895,16 +906,17 @@ JitsiConference.prototype.onDisplayNameChanged = function (jid, displayName) {
 };
 
 /**
- * Notifies this JitsiConference that a JitsiRemoteTrack was added (into the
- * ChatRoom of this JitsiConference).
+ * Notifies this JitsiConference that a JitsiRemoteTrack was added into
+ * the conference.
  *
  * @param {JitsiRemoteTrack} track the JitsiRemoteTrack which was added to this
  * JitsiConference
  */
-JitsiConference.prototype.onTrackAdded = function (track) {
-    var id = track.getParticipantId();
-    var participant = this.getParticipantById(id);
+JitsiConference.prototype.onRemoteTrackAdded = function (track) {
+    const id = track.getParticipantId();
+    const participant = this.getParticipantById(id);
     if (!participant) {
+        logger.error(`No participant found for id: ${id}`);
         return;
     }
 
@@ -915,7 +927,7 @@ JitsiConference.prototype.onTrackAdded = function (track) {
         this.transcriber.addTrack(track);
     }
 
-    var emitter = this.eventEmitter;
+    const emitter = this.eventEmitter;
     track.addEventListener(
         JitsiTrackEvents.TRACK_MUTE_CHANGED,
         function () {
@@ -935,6 +947,47 @@ JitsiConference.prototype.onTrackAdded = function (track) {
     emitter.emit(JitsiConferenceEvents.TRACK_ADDED, track);
 };
 
+/**
+ * Notifies this JitsiConference that a JitsiRemoteTrack was removed from
+ * the conference.
+ *
+ * @param {JitsiRemoteTrack} removedTrack
+ */
+JitsiConference.prototype.onRemoteTrackRemoved = function (removedTrack) {
+    let consumed = false;
+
+    this.getParticipants().forEach(function(participant) {
+        const tracks = participant.getTracks();
+
+        for(let i = 0; i < tracks.length; i++) {
+            if (tracks[i] === removedTrack) {
+                // Since the tracks have been compared and are
+                // considered equal the result of splice can be ignored.
+                participant._tracks.splice(i, 1);
+
+                this.eventEmitter.emit(
+                    JitsiConferenceEvents.TRACK_REMOVED, removedTrack);
+
+                if (this.transcriber){
+                    this.transcriber.removeTrack(removedTrack);
+                }
+
+                consumed = true;
+
+                break;
+            }
+        }
+    }, this);
+
+    if (!consumed) {
+        logger.error(
+            "Failed to match remote track on remove"
+                + " with any of the participants",
+            removedTrack.getStreamId(),
+            removedTrack.getParticipantId());
+    }
+};
+
 /**
  * Handles incoming call event.
  */
@@ -978,14 +1031,14 @@ function (jingleSession, jingleOffer, now) {
             label: crossRegion
         });
     try {
-        jingleSession.initialize(false /* initiator */,this.room);
+        jingleSession.initialize(false /* initiator */, this.room, this.rtc);
     } catch (error) {
         GlobalOnErrorHandler.callErrorHandler(error);
     }
 
     this.rtc.initializeDataChannels(jingleSession.peerconnection);
     // Add local Tracks to the ChatRoom
-    this.rtc.localTracks.forEach(function(localTrack) {
+    this.getLocalTracks().forEach(function(localTrack) {
         var ssrcInfo = null;
         /**
          * We don't do this for Firefox because, on Firefox, we keep the
@@ -1081,13 +1134,13 @@ JitsiConference.prototype.onCallEnded
     // will learn what their SSRC from the new PeerConnection which will be
     // created on incoming call event.
     var self = this;
-    this.rtc.localTracks.forEach(function(localTrack) {
+    this.getLocalTracks().forEach(function(localTrack) {
         // Reset SSRC as it will no longer be valid
         localTrack._setSSRC(null);
         // Bind the handler to fetch new SSRC, it will un register itself once
         // it reads the values
-        self.room.addListener(
-            XMPPEvents.SENDRECV_STREAMS_CHANGED, localTrack.ssrcHandler);
+        self.rtc.addListener(
+            RTCEvents.SENDRECV_STREAMS_CHANGED, localTrack.ssrcHandler);
     });
 };
 
@@ -1134,21 +1187,25 @@ JitsiConference.prototype.myUserId = function () {
 };
 
 JitsiConference.prototype.sendTones = function (tones, duration, pause) {
+    // FIXME P2P 'dtmfManager' must be cleared, after switching jingleSessions
     if (!this.dtmfManager) {
-        var connection = this.xmpp.connection.jingle.activecall.peerconnection;
-        if (!connection) {
-            logger.warn("cannot sendTones: no conneciton");
+        if (!this.jingleSession) {
+            logger.warn("cannot sendTones: no jingle session");
             return;
         }
 
-        var tracks = this.getLocalTracks().filter(function (track) {
-            return track.isAudioTrack();
-        });
-        if (!tracks.length) {
+        const peerConnection = this.jingleSession.peerconnection;
+        if (!peerConnection) {
+            logger.warn("cannot sendTones: no peer connection");
+            return;
+        }
+
+        const localAudio = this.getLocalAudioTrack();
+        if (!localAudio) {
             logger.warn("cannot sendTones: no local audio stream");
             return;
         }
-        this.dtmfManager = new JitsiDTMFManager(tracks[0], connection);
+        this.dtmfManager = new JitsiDTMFManager(localAudio, peerConnection);
     }
 
     this.dtmfManager.sendTones(tones, duration, pause);

JitsiConferenceEventManager.js

@@ -43,41 +43,6 @@ JitsiConferenceEventManager.prototype.setupChatRoomListeners = function () {
         conference.rtc.closeAllDataChannels();
     });
 
-    chatRoom.addListener(XMPPEvents.REMOTE_TRACK_ADDED,
-        function (data) {
-            var track = conference.rtc.createRemoteTrack(data);
-            if (track) {
-                conference.onTrackAdded(track);
-            }
-        }
-    );
-    chatRoom.addListener(XMPPEvents.REMOTE_TRACK_REMOVED,
-        function (streamId, trackId) {
-            conference.getParticipants().forEach(function(participant) {
-                var tracks = participant.getTracks();
-                for(var i = 0; i < tracks.length; i++) {
-                    if(tracks[i]
-                        && tracks[i].getStreamId() == streamId
-                        && tracks[i].getTrackId() == trackId) {
-                        var track = participant._tracks.splice(i, 1)[0];
-
-                        conference.rtc.removeRemoteTrack(
-                            participant.getId(), track.getType());
-
-                        conference.eventEmitter.emit(
-                            JitsiConferenceEvents.TRACK_REMOVED, track);
-
-                        if(conference.transcriber){
-                            conference.transcriber.removeTrack(track);
-                        }
-
-                        return;
-                    }
-                }
-            });
-        }
-    );
-
     chatRoom.addListener(XMPPEvents.AUDIO_MUTED_BY_FOCUS,
         function (value) {
             // set isMutedByFocus when setAudioMute Promise ends
@@ -413,31 +378,11 @@ JitsiConferenceEventManager.prototype.setupChatRoomListeners = function () {
     });
 
     if(conference.statistics) {
+        // FIXME ICE related events should end up in RTCEvents eventually
         chatRoom.addListener(XMPPEvents.CONNECTION_ICE_FAILED,
             function (pc) {
                 conference.statistics.sendIceConnectionFailedEvent(pc);
             });
-
-        chatRoom.addListener(XMPPEvents.CREATE_OFFER_FAILED,
-            function (e, pc) {
-                conference.statistics.sendCreateOfferFailed(e, pc);
-            });
-
-        chatRoom.addListener(XMPPEvents.CREATE_ANSWER_FAILED,
-            function (e, pc) {
-                conference.statistics.sendCreateAnswerFailed(e, pc);
-            });
-
-        chatRoom.addListener(XMPPEvents.SET_LOCAL_DESCRIPTION_FAILED,
-            function (e, pc) {
-                conference.statistics.sendSetLocalDescFailed(e, pc);
-            });
-
-        chatRoom.addListener(XMPPEvents.SET_REMOTE_DESCRIPTION_FAILED,
-            function (e, pc) {
-                conference.statistics.sendSetRemoteDescFailed(e, pc);
-            });
-
         chatRoom.addListener(XMPPEvents.ADD_ICE_CANDIDATE_FAILED,
             function (e, pc) {
                 conference.statistics.sendAddIceCandidateFailed(e, pc);
@@ -449,12 +394,21 @@ JitsiConferenceEventManager.prototype.setupChatRoomListeners = function () {
  * Setups event listeners related to conference.rtc
  */
 JitsiConferenceEventManager.prototype.setupRTCListeners = function () {
-    var conference = this.conference;
+    const conference = this.conference;
+    const rtc = conference.rtc;
 
-    this.rtcForwarder = new EventEmitterForwarder(conference.rtc,
-        this.conference.eventEmitter);
+    this.rtcForwarder
+        = new EventEmitterForwarder(rtc, this.conference.eventEmitter);
 
-    conference.rtc.addListener(RTCEvents.DOMINANT_SPEAKER_CHANGED,
+    rtc.addListener(
+        RTCEvents.REMOTE_TRACK_ADDED,
+        conference.onRemoteTrackAdded.bind(conference));
+
+    rtc.addListener(
+        RTCEvents.REMOTE_TRACK_REMOVED,
+        conference.onRemoteTrackRemoved.bind(conference));
+
+    rtc.addListener(RTCEvents.DOMINANT_SPEAKER_CHANGED,
         function (id) {
             if(conference.lastDominantSpeaker !== id && conference.room) {
                 conference.lastDominantSpeaker = id;
@@ -467,7 +421,7 @@ JitsiConferenceEventManager.prototype.setupRTCListeners = function () {
             }
         });
 
-    conference.rtc.addListener(RTCEvents.DATA_CHANNEL_OPEN, function () {
+    rtc.addListener(RTCEvents.DATA_CHANNEL_OPEN, function () {
         var now = window.performance.now();
         logger.log("(TIME) data channel opened ", now);
         conference.room.connectionTimes["data.channel.opened"] = now;
@@ -481,12 +435,12 @@ JitsiConferenceEventManager.prototype.setupRTCListeners = function () {
     this.rtcForwarder.forward(RTCEvents.LASTN_ENDPOINT_CHANGED,
         JitsiConferenceEvents.LAST_N_ENDPOINTS_CHANGED);
 
-    conference.rtc.addListener(RTCEvents.AVAILABLE_DEVICES_CHANGED,
+    rtc.addListener(RTCEvents.AVAILABLE_DEVICES_CHANGED,
         function (devices) {
             conference.room.updateDeviceAvailability(devices);
         });
 
-    conference.rtc.addListener(RTCEvents.ENDPOINT_MESSAGE_RECEIVED,
+    rtc.addListener(RTCEvents.ENDPOINT_MESSAGE_RECEIVED,
         function (from, payload) {
             const participant = conference.getParticipantById(from);
             if (participant) {
@@ -499,6 +453,28 @@ JitsiConferenceEventManager.prototype.setupRTCListeners = function () {
                     "for not existing participant: " + from, payload);
             }
         });
+
+    if (conference.statistics) {
+        rtc.addListener(RTCEvents.CREATE_ANSWER_FAILED,
+            (e, pc) => {
+                conference.statistics.sendCreateAnswerFailed(e, pc);
+            });
+
+        rtc.addListener(RTCEvents.CREATE_OFFER_FAILED,
+            (e, pc) => {
+                conference.statistics.sendCreateOfferFailed(e, pc);
+            });
+
+        rtc.addListener(RTCEvents.SET_LOCAL_DESCRIPTION_FAILED,
+            (e, pc) => {
+                conference.statistics.sendSetLocalDescFailed(e, pc);
+            });
+
+        rtc.addListener(RTCEvents.SET_REMOTE_DESCRIPTION_FAILED,
+            (e, pc) => {
+                conference.statistics.sendSetRemoteDescFailed(e, pc);
+            });
+    }
 };
 
 /**
@@ -597,9 +573,9 @@ JitsiConferenceEventManager.prototype.setupStatisticsListeners = function () {
     });
 
     conference.statistics.addByteSentStatsListener(function (stats) {
-        conference.getLocalTracks().forEach(function (track) {
-            var ssrc = track.getSSRC();
-            if(!track.isAudioTrack() || !ssrc || !stats.hasOwnProperty(ssrc))
+        conference.getLocalTracks(MediaType.AUDIO).forEach(function (track) {
+            const ssrc = track.getSSRC();
+            if (!ssrc || !stats.hasOwnProperty(ssrc))
                 return;
 
             track._setByteSent(stats[ssrc]);

modules/RTC/JitsiRemoteTrack.js

@@ -1,4 +1,4 @@
-/* global Strophe */
+/* global */
 
 var JitsiTrack = require("./JitsiTrack");
 import * as JitsiTrackEvents from "../../JitsiTrackEvents";
@@ -12,22 +12,25 @@ var ttfmTrackerVideoAttached = false;
 
 /**
  * Represents a single media track (either audio or video).
- * @param rtc {RTC} the RTC service instance.
- * @param ownerJid the MUC JID of the track owner
- * @param stream WebRTC MediaStream, parent of the track
- * @param track underlying WebRTC MediaStreamTrack for new JitsiRemoteTrack
- * @param mediaType the MediaType of the JitsiRemoteTrack
- * @param videoType the VideoType of the JitsiRemoteTrack
- * @param ssrc the SSRC number of the Media Stream
- * @param muted initial muted state of the JitsiRemoteTrack
+ * @param {RTC} rtc the RTC service instance.
+ * @param {JitsiConference} conference the conference to which this track
+ *        belongs to
+ * @param {string} ownerEndpointId the endpoint ID of the track owner
+ * @param {MediaStream} stream WebRTC MediaStream, parent of the track
+ * @param {MediaStreamTrack} track underlying WebRTC MediaStreamTrack for
+ *        the new JitsiRemoteTrack
+ * @param {MediaType} mediaType the type of the media
+ * @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
  * @constructor
  */
-function JitsiRemoteTrack(rtc, conference, ownerJid, stream, track, mediaType, videoType,
-                          ssrc, muted) {
+function JitsiRemoteTrack(rtc, conference, ownerEndpointId, stream, track,
+                          mediaType, videoType, ssrc, muted) {
     JitsiTrack.call(
         this, conference, stream, track, function () {}, mediaType, videoType, ssrc);
     this.rtc = rtc;
-    this.peerjid = ownerJid;
+    this.ownerEndpointId = ownerEndpointId;
     this.muted = muted;
     // we want to mark whether the track has been ever muted
     // to detect ttfm events for startmuted conferences, as it can significantly
@@ -98,10 +101,11 @@ JitsiRemoteTrack.prototype.isMuted = function () {
 
 /**
  * Returns the participant id which owns the track.
- * @returns {string} the id of the participants.
+ * @returns {string} the id of the participants. It corresponds to the Colibri
+ * endpoint id/MUC nickname in case of Jitsi-meet.
  */
 JitsiRemoteTrack.prototype.getParticipantId = function() {
-    return Strophe.getResourceFromJid(this.peerjid);
+    return this.ownerEndpointId;
 };
 
 /**

modules/RTC/JitsiTrack.js

@@ -308,15 +308,6 @@ JitsiTrack.prototype.dispose = function () {
 JitsiTrack.prototype.isScreenSharing = function() {
 };
 
-/**
- * FIXME remove hack in SDP.js and this method
- * Returns id of the track.
- * @returns {string|null} id of the track or null if this is fake track.
- */
-JitsiTrack.prototype._getId = function () {
-    return this.getTrackId();
-};
-
 /**
  * Returns id of the track.
  * @returns {string|null} id of the track or null if this is fake track.

modules/RTC/RTC.js

@@ -1,4 +1,4 @@
-/* global Strophe */
+/* global */
 
 var logger = require("jitsi-meet-logger").getLogger(__filename);
 var RTCEvents = require("../../service/RTC/RTCEvents.js");
@@ -9,6 +9,7 @@ import * as JitsiTrackErrors from "../../JitsiTrackErrors";
 var DataChannels = require("./DataChannels");
 var JitsiRemoteTrack = require("./JitsiRemoteTrack.js");
 var MediaType = require("../../service/RTC/MediaType");
+var TraceablePeerConnection = require("./TraceablePeerConnection");
 var VideoType = require("../../service/RTC/VideoType");
 var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
 import Listenable from "../util/Listenable";
@@ -40,11 +41,20 @@ export default class RTC extends Listenable {
     constructor(conference, options = {}) {
         super();
         this.conference = conference;
+        /**
+         * A map of active <tt>TraceablePeerConnection</tt>.
+         * @type {Map.<number, TraceablePeerConnection>}
+         */
+        this.peerConnections = new Map();
+        /**
+         * The counter used to generated id numbers assigned to peer connections
+         * @type {number}
+         */
+        this.peerConnectionIdCounter = 1;
+
         this.localTracks = [];
         //FIXME: We should support multiple streams per jid.
         this.remoteTracks = {};
-        this.localAudio = null;
-        this.localVideo = null;
         this.options = options;
         // A flag whether we had received that the data channel had opened
         // we can get this flag out of sync if for some reason data channel got
@@ -57,12 +67,10 @@ export default class RTC extends Listenable {
         if (RTCUtils.isDeviceChangeAvailable('output')) {
             RTCUtils.addListener(RTCEvents.AUDIO_OUTPUT_DEVICE_CHANGED,
                 (deviceId) => {
-                    for (var key in this.remoteTracks) {
-                        if (this.remoteTracks.hasOwnProperty(key)
-                            && this.remoteTracks[key].audio) {
-                            this.remoteTracks[key].audio
-                                .setAudioOutput(deviceId);
-                        }
+                    const remoteAudioTracks
+                        = this.getRemoteTracks(MediaType.AUDIO);
+                    for (const track of remoteAudioTracks) {
+                        track.setAudioOutput(deviceId);
                     }
                 });
         }
@@ -197,6 +205,51 @@ export default class RTC extends Listenable {
         return RTCUtils.getDeviceAvailability();
     }
 
+    /**
+     * Creates new <tt>TraceablePeerConnection</tt>
+     * @param {SignalingLayer} signaling the signaling layer that will
+     * provide information about the media or participants which is not carried
+     * over SDP.
+     * @param {Object} iceConfig an object describing the ICE config like
+     * defined in the WebRTC specification.
+     * @param {Object} options the config options
+     * @param {boolean} options.disableSimulcast if set to 'true' will disable
+     * the simulcast
+     * @param {boolean} options.disableRtx if set to 'true' will disable the RTX
+     * @param {boolean} options.preferH264 if set to 'true' H264 will be
+     * preferred over other video codecs.
+     * @return {TraceablePeerConnection}
+     */
+    createPeerConnection (signaling, iceConfig, options) {
+        const newConnection
+            = new TraceablePeerConnection(
+                this,
+                this.peerConnectionIdCounter,
+                signaling, iceConfig, RTC.getPCConstraints(), options);
+
+        this.peerConnections.set(newConnection.id, newConnection);
+        this.peerConnectionIdCounter += 1;
+        return newConnection;
+    }
+
+    /**
+     * Removed given peer connection from this RTC module instance.
+     * @param {TraceablePeerConnection} traceablePeerConnection
+     * @return {boolean} <tt>true</tt> if the given peer connection was removed
+     * successfully or <tt>false</tt> if there was no peer connection mapped in
+     * this RTC instance.
+     */
+    _removePeerConnection (traceablePeerConnection) {
+        const id = traceablePeerConnection.id;
+        if (this.peerConnections.has(id)) {
+            // NOTE Remote tracks are not removed here.
+            this.peerConnections.delete(id);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
     addLocalTrack (track) {
         if (!track)
             throw new Error('track must not be null nor undefined');
@@ -204,20 +257,68 @@ export default class RTC extends Listenable {
         this.localTracks.push(track);
 
         track.conference = this.conference;
-
-        if (track.isAudioTrack()) {
-            this.localAudio = track;
-        } else {
-            this.localVideo = track;
-        }
     }
 
     /**
      * Get local video track.
-     * @returns {JitsiLocalTrack}
+     * @returns {JitsiLocalTrack|undefined}
      */
     getLocalVideoTrack () {
-        return this.localVideo;
+        const localVideo = this.getLocalTracks(MediaType.VIDEO);
+        return localVideo.length ? localVideo[0] : undefined;
+    }
+
+    /**
+     * Get local audio track.
+     * @returns {JitsiLocalTrack|undefined}
+     */
+    getLocalAudioTrack () {
+        const localAudio = this.getLocalTracks(MediaType.AUDIO);
+        return localAudio.length ? localAudio[0] : undefined;
+    }
+
+    /**
+     * Returns the local tracks of the given media type, or all local tracks if
+     * no specific type is given.
+     * @param {MediaType} [mediaType] optional media type filter
+     * (audio or video).
+     */
+    getLocalTracks (mediaType) {
+        let tracks = this.localTracks.slice();
+        if (mediaType !== undefined) {
+            tracks = tracks.filter(
+                (track) => { return track.getType() === mediaType; });
+        }
+        return tracks;
+    }
+
+    /**
+     * Obtains all remote tracks currently known to this RTC module instance.
+     * @param {MediaType} [mediaType] the remote tracks will be filtered
+     * by their media type if this argument is specified.
+     * @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]);
+
+            for (const trackMediaType of endpointMediaTypes) {
+                // per media type filtering
+                if (mediaType && mediaType !== trackMediaType) {
+                    continue;
+                }
+
+                const mediaTrack = this.remoteTracks[endpoint][trackMediaType];
+
+                if (mediaTrack) {
+                    remoteTracks.push(mediaTrack);
+                }
+            }
+        }
+        return remoteTracks;
     }
 
     /**
@@ -260,94 +361,135 @@ export default class RTC extends Listenable {
      * @returns {Promise}
      */
     setAudioMute (value) {
-        var mutePromises = [];
-        for(var i = 0; i < this.localTracks.length; i++) {
-            var track = this.localTracks[i];
-            if(track.getType() !== MediaType.AUDIO) {
-                continue;
-            }
+        const mutePromises = [];
+        this.getLocalTracks(MediaType.AUDIO).forEach(function(audioTrack){
             // this is a Promise
-            mutePromises.push(value ? track.mute() : track.unmute());
-        }
+            mutePromises.push(value ? audioTrack.mute() : audioTrack.unmute());
+        });
         // we return a Promise from all Promises so we can wait for their execution
         return Promise.all(mutePromises);
     }
 
     removeLocalTrack (track) {
-        var pos = this.localTracks.indexOf(track);
+        const pos = this.localTracks.indexOf(track);
         if (pos === -1) {
             return;
         }
 
         this.localTracks.splice(pos, 1);
-
-        if (track.isAudioTrack()) {
-            this.localAudio = null;
-        } else {
-            this.localVideo = null;
-        }
     }
 
     /**
-     * Initializes a new JitsiRemoteTrack instance with the data provided by (a)
-     * ChatRoom to XMPPEvents.REMOTE_TRACK_ADDED.
+     * Initializes a new JitsiRemoteTrack instance with the data provided by
+     * the signaling layer and SDP.
      *
-     * @param {Object} event the data provided by (a) ChatRoom to
-     * XMPPEvents.REMOTE_TRACK_ADDED to (a)
-     */
-    createRemoteTrack (event) {
-        var ownerJid = event.owner;
-        var remoteTrack = new JitsiRemoteTrack(
-            this, this.conference, ownerJid, event.stream, event.track,
-            event.mediaType, event.videoType, event.ssrc, event.muted);
-        var resource = Strophe.getResourceFromJid(ownerJid);
-        var remoteTracks
-            = this.remoteTracks[resource] || (this.remoteTracks[resource] = {});
-        var mediaType = remoteTrack.getType();
+     * @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.warn("Overwriting remote track!", resource, mediaType);
+            logger.error(
+                "Overwriting remote track!", ownerEndpointId, mediaType);
         }
         remoteTracks[mediaType] = remoteTrack;
-        return remoteTrack;
+
+        this.eventEmitter.emit(RTCEvents.REMOTE_TRACK_ADDED, remoteTrack);
     }
 
     /**
-     * Removes all JitsiRemoteTracks associated with given MUC nickname (resource
-     * part of the JID). Returns array of removed tracks.
+     * Removes all JitsiRemoteTracks associated with given MUC nickname
+     * (resource part of the JID). Returns array of removed tracks.
      *
-     * @param {string} resource - The resource part of the MUC JID.
+     * @param {string} owner - The resource part of the MUC JID.
      * @returns {JitsiRemoteTrack[]}
      */
-    removeRemoteTracks (resource) {
-        var removedTracks = [];
-        var removedAudioTrack = this.removeRemoteTrack(resource, MediaType.AUDIO);
-        var removedVideoTrack = this.removeRemoteTrack(resource, MediaType.VIDEO);
+    removeRemoteTracks (owner) {
+        const removedTracks = [];
 
-        removedAudioTrack && removedTracks.push(removedAudioTrack);
-        removedVideoTrack && removedTracks.push(removedVideoTrack);
+        if (this.remoteTracks[owner]) {
+            const removedAudioTrack
+                = this.remoteTracks[owner][MediaType.AUDIO];
+            const removedVideoTrack
+                = this.remoteTracks[owner][MediaType.VIDEO];
 
-        delete this.remoteTracks[resource];
+            removedAudioTrack && removedTracks.push(removedAudioTrack);
+            removedVideoTrack && removedTracks.push(removedVideoTrack);
 
+            delete this.remoteTracks[owner];
+        }
         return removedTracks;
     }
 
     /**
-     * Removes specified track type associated with given MUC nickname
-     * (resource part of the JID). Returns removed track if any.
+     * 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 = undefined;
+
+        // .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;
+                    } else {
+                        return false;
+                    }
+                });
+        });
+
+        return result;
+    }
+
+    /**
+     * Removes <tt>JitsiRemoteTrack</tt> identified by given stream and track
+     * ids.
      *
-     * @param {string} resource - The resource part of the MUC JID.
-     * @param {string} mediaType - Type of track to remove.
-     * @returns {JitsiRemoteTrack|undefined}
-     */
-    removeRemoteTrack (resource, mediaType) {
-        var remoteTracksForResource = this.remoteTracks[resource];
-
-        if (remoteTracksForResource && remoteTracksForResource[mediaType]) {
-            var track = remoteTracksForResource[mediaType];
-            track.dispose();
-            delete remoteTracksForResource[mediaType];
-            return track;
+     * @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();
+
+            delete this.remoteTracks[
+                toBeRemoved.getParticipantId()][toBeRemoved.getType()];
+
+            this.rtc.eventEmitter.emit(
+                RTCEvents.REMOTE_TRACK_REMOVED, toBeRemoved);
         }
+
+        return toBeRemoved;
     }
 
     static getPCConstraints () {
@@ -427,11 +569,26 @@ export default class RTC extends Listenable {
      * "streams/channels/tracks" for receiving remote stream/tracks, as opposed
      * to Plan B where there are only 3 channels: audio, video and data.
      *
-     * @param stream WebRTC MediaStream instance
+     * @param {MediaStream} stream the WebRTC MediaStream instance
      * @returns {boolean}
      */
     static isUserStream (stream) {
-        var streamId = RTCUtils.getStreamID(stream);
+        return RTC.isUserStreamById(RTCUtils.getStreamID(stream));
+    }
+
+    /**
+     * Returns <tt>true<tt/> if a WebRTC MediaStream identified by given stream
+     * ID is considered a valid "user" stream which means that it's not a
+     * "receive only" stream nor a "mixed" JVB stream.
+     *
+     * Clients that implement Unified Plan, such as Firefox use recvonly
+     * "streams/channels/tracks" for receiving remote stream/tracks, as opposed
+     * to Plan B where there are only 3 channels: audio, video and data.
+     *
+     * @param {string} streamId the id of WebRTC MediaStream
+     * @returns {boolean}
+     */
+    static isUserStreamById (streamId) {
         return (streamId && streamId !== "mixedmslabel"
             && streamId !== "default");
     }
@@ -488,32 +645,26 @@ export default class RTC extends Listenable {
      * @param ssrc the ssrc to check.
      */
     getResourceBySSRC (ssrc) {
-        if((this.localVideo && ssrc == this.localVideo.getSSRC())
-            || (this.localAudio && ssrc == this.localAudio.getSSRC())) {
+        if (this.getLocalTracks().find(
+                localTrack => { return localTrack.getSSRC() == ssrc; })) {
             return this.conference.myUserId();
         }
 
-        var track = this.getRemoteTrackBySSRC(ssrc);
-        return track? track.getParticipantId() : null;
+        const track = this.getRemoteTrackBySSRC(ssrc);
+        return track ? track.getParticipantId() : null;
     }
 
     /**
      * Searches in remoteTracks for the ssrc and returns the corresponding
      * 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.
      */
     getRemoteTrackBySSRC (ssrc) {
-        for (var resource in this.remoteTracks) {
-            var track = this.getRemoteAudioTrack(resource);
-            if(track && track.getSSRC() == ssrc) {
-                return track;
-            }
-            track = this.getRemoteVideoTrack(resource);
-            if(track && track.getSSRC() == ssrc) {
-                return track;
-            }
-        }
-        return null;
+        return this.getRemoteTracks().find(function (remoteTrack) {
+            return ssrc == remoteTrack.getSSRC();
+        });
     }
 
     /**

modules/xmpp/TraceablePeerConnection.js → modules/RTC/TraceablePeerConnection.js

@@ -1,20 +1,27 @@
-/* global mozRTCPeerConnection, webkitRTCPeerConnection */
+/* global __filename, mozRTCPeerConnection, webkitRTCPeerConnection,
+    RTCPeerConnection, RTCSessionDescription */
 
 import { getLogger } from "jitsi-meet-logger";
-const logger = getLogger(__filename);
-import SdpConsistency from "./SdpConsistency.js";
-import RtxModifier from "./RtxModifier.js";
-var RTCBrowserType = require("../RTC/RTCBrowserType.js");
-var XMPPEvents = require("../../service/xmpp/XMPPEvents");
-var transform = require('sdp-transform');
-var SDP = require("./SDP");
-var SDPUtil = require("./SDPUtil");
+import * as GlobalOnErrorHandler from "../util/GlobalOnErrorHandler";
+import RTC from "./RTC";
+import RTCBrowserType from "./RTCBrowserType.js";
+import RTCEvents from "../../service/RTC/RTCEvents";
+import RtxModifier from "../xmpp/RtxModifier.js";
+// FIXME SDP tools should end up in some kind of util module
+import SDP from "../xmpp/SDP";
+import SdpConsistency from "../xmpp/SdpConsistency.js";
+import SDPUtil from "../xmpp/SDPUtil";
+import transform from "sdp-transform";
 
-var SIMULCAST_LAYERS = 3;
+const logger = getLogger(__filename);
+const SIMULCAST_LAYERS = 3;
 
 /**
  * Creates new instance of 'TraceablePeerConnection'.
  *
+ * @param {RTC} rtc the instance of <tt>RTC</tt> service
+ * @param {number} id the peer connection id assigned by the parent RTC module.
+ * @param {SignalingLayer} signalingLayer the signaling layer instance
  * @param {object} ice_config WebRTC 'PeerConnection' ICE config
  * @param {object} constraints WebRTC 'PeerConnection' constraints
  * @param {object} options <tt>TracablePeerConnection</tt> config options.
@@ -23,14 +30,33 @@ var SIMULCAST_LAYERS = 3;
  * @param {boolean} options.disableRtx if set to 'true' will disable the RTX
  * @param {boolean} options.preferH264 if set to 'true' H264 will be preferred
  * over other video codecs.
- * @param {EventEmitter} eventEmitter the emitter which wil be used by the new
- * instance to emit events.
+ *
+ * FIXME: initially the purpose of TraceablePeerConnection was to be able to
+ * debug the peer connection. Since many other responsibilities have been added
+ * it would make sense to extract a separate class from it and come up with
+ * a more suitable name.
  *
  * @constructor
  */
-function TraceablePeerConnection(ice_config,
-                                 constraints, options, eventEmitter) {
+function TraceablePeerConnection(rtc, id, signalingLayer, ice_config,
+                                 constraints, options) {
     var self = this;
+    /**
+     * The parent instance of RTC service which created this
+     * <tt>TracablePeerConnection</tt>.
+     * @type {RTC}
+     */
+    this.rtc = rtc;
+    /**
+     * The peer connection identifier assigned by the RTC module.
+     * @type {number}
+     */
+    this.id = id;
+    /**
+     * The signaling layer which operates this peer connection.
+     * @type {SignalingLayer}
+     */
+    this.signalingLayer = signalingLayer;
     this.options = options;
     var RTCPeerConnectionType = null;
     if (RTCBrowserType.isFirefox()) {
@@ -44,15 +70,22 @@ function TraceablePeerConnection(ice_config,
     this.updateLog = [];
     this.stats = {};
     this.statsinterval = null;
-    this.maxstats = 0; // limit to 300 values, i.e. 5 minutes; set to 0 to disable
+    /**
+     * @type {number}
+     */
+    this.maxstats = 0;
     var Interop = require('sdp-interop').Interop;
     this.interop = new Interop();
     var Simulcast = require('sdp-simulcast');
     this.simulcast = new Simulcast({numOfLayers: SIMULCAST_LAYERS,
         explodeRemoteSimulcast: false});
     this.sdpConsistency = new SdpConsistency();
+    /**
+     * TracablePeerConnection uses RTC's eventEmitter
+     * @type {EventEmitter}
+     */
+    this.eventEmitter = rtc.eventEmitter;
     this.rtxModifier = new RtxModifier();
-    this.eventEmitter = eventEmitter;
 
     // override as desired
     this.trace = function (what, info) {
@@ -74,8 +107,12 @@ function TraceablePeerConnection(ice_config,
     this.onicecandidate = null;
     this.peerconnection.onicecandidate = function (event) {
         // FIXME: this causes stack overflow with Temasys Plugin
-        if (!RTCBrowserType.isTemasysPluginUsed())
-            self.trace('onicecandidate', JSON.stringify(event.candidate, null, ' '));
+        if (!RTCBrowserType.isTemasysPluginUsed()) {
+            self.trace(
+                'onicecandidate',
+                JSON.stringify(event.candidate, null, ' '));
+        }
+
         if (self.onicecandidate !== null) {
             self.onicecandidate(event);
         }
@@ -94,6 +131,12 @@ function TraceablePeerConnection(ice_config,
             self.onremovestream(event);
         }
     };
+    this.peerconnection.onaddstream = function (event) {
+        self._remoteStreamAdded(event.stream);
+    };
+    this.peerconnection.onremovestream = function (event) {
+        self._remoteStreamRemoved(event.stream);
+    };
     this.onsignalingstatechange = null;
     this.peerconnection.onsignalingstatechange = function (event) {
         self.trace('onsignalingstatechange', self.signalingState);
@@ -165,6 +208,196 @@ var dumpSDP = function(description) {
     return 'type: ' + description.type + '\r\n' + description.sdp;
 };
 
+/**
+ * Called when new remote MediaStream is added to the PeerConnection.
+ * @param {MediaStream} stream the WebRTC MediaStream for remote participant
+ */
+TraceablePeerConnection.prototype._remoteStreamAdded = function (stream) {
+    if (!RTC.isUserStream(stream)) {
+        logger.info(
+            "Ignored remote 'stream added' event for non-user stream", stream);
+        return;
+    }
+    // Bind 'addtrack'/'removetrack' event handlers
+    if (RTCBrowserType.isChrome() || RTCBrowserType.isNWJS()
+        || RTCBrowserType.isElectron()) {
+        stream.onaddtrack = (event) => {
+            this._remoteTrackAdded(event.target, event.track);
+        };
+        stream.onremovetrack = (event) => {
+            this._remoteTrackRemoved(event.target, event.track);
+        };
+    }
+    // Call remoteTrackAdded for each track in the stream
+    const streamAudioTracks = stream.getAudioTracks();
+    for (const audioTrack of streamAudioTracks) {
+        this._remoteTrackAdded(stream, audioTrack);
+    }
+    const streamVideoTracks = stream.getVideoTracks();
+    for (const videoTrack of streamVideoTracks) {
+        this._remoteTrackAdded(stream, videoTrack);
+    }
+};
+
+
+/**
+ * Called on "track added" and "stream added" PeerConnection events (because we
+ * handle streams on per track basis). Finds the owner and the SSRC for
+ * the track and passes that to ChatRoom for further processing.
+ * @param {MediaStream} stream the WebRTC MediaStream instance which is
+ * the parent of the track
+ * @param {MediaStreamTrack} track the WebRTC MediaStreamTrack added for remote
+ * participant
+ */
+TraceablePeerConnection.prototype._remoteTrackAdded = function (stream, track) {
+    const streamId = RTC.getStreamID(stream);
+    const mediaType = track.kind;
+
+    logger.info("Remote track added", streamId, mediaType);
+
+    // look up an associated JID for a stream id
+    if (!mediaType) {
+        GlobalOnErrorHandler.callErrorHandler(
+            new Error(
+                `MediaType undefined for remote track, stream id: ${streamId}`
+            ));
+        // Abort
+        return;
+    }
+
+    const remoteSDP = new SDP(this.remoteDescription.sdp);
+    const mediaLines = remoteSDP.media.filter(
+        function (mediaLines){
+            return mediaLines.startsWith("m=" + mediaType);
+        });
+    if (!mediaLines.length) {
+        GlobalOnErrorHandler.callErrorHandler(
+            new Error(
+                "No media lines for type " + mediaType
+                    + " found in remote SDP for remote track: " + streamId));
+        // Abort
+        return;
+    }
+
+    let ssrcLines = SDPUtil.find_lines(mediaLines[0], 'a=ssrc:');
+
+    ssrcLines = ssrcLines.filter(
+        function (line) {
+            const msid
+                = RTCBrowserType.isTemasysPluginUsed() ? 'mslabel' : 'msid';
+            return line.indexOf(msid + ':' + streamId) !== -1;
+        });
+    if (!ssrcLines.length) {
+        GlobalOnErrorHandler.callErrorHandler(
+            new Error(
+                "No SSRC lines for streamId " + streamId
+                    + " for remote track, media type: " + mediaType));
+        // Abort
+        return;
+    }
+
+    // FIXME the length of ssrcLines[0] not verified, but it will fail
+    // with global error handler anyway
+    let trackSsrc = ssrcLines[0].substring(7).split(' ')[0];
+    const ownerEndpointId = this.signalingLayer.getSSRCOwner(trackSsrc);
+
+    if (!ownerEndpointId) {
+        GlobalOnErrorHandler.callErrorHandler(
+            new Error(
+                "No SSRC owner known for: " + trackSsrc
+                    + " for remote track, msid: " + streamId
+                    + " media type: " + mediaType));
+        // Abort
+        return;
+    }
+
+    logger.log('associated ssrc', ownerEndpointId, trackSsrc);
+
+    const peerMediaInfo
+        = this.signalingLayer.getPeerMediaInfo(ownerEndpointId, mediaType);
+
+    if (!peerMediaInfo) {
+        GlobalOnErrorHandler.callErrorHandler(
+            new Error("No peer media info available for: " + ownerEndpointId));
+        // Abort
+        return;
+    }
+
+    const muted = peerMediaInfo.muted;
+    const videoType = peerMediaInfo.videoType; // can be undefined
+
+    this.rtc._createRemoteTrack(
+        ownerEndpointId, stream, track, mediaType, videoType, trackSsrc, muted);
+};
+
+/**
+ * Handles remote stream removal.
+ * @param stream the WebRTC MediaStream object which is being removed from the
+ * PeerConnection
+ */
+TraceablePeerConnection.prototype._remoteStreamRemoved = function (stream) {
+    if (!RTC.isUserStream(stream)) {
+        const id = RTC.getStreamID(stream);
+        logger.info(
+            `Ignored remote 'stream removed' event for non-user stream ${id}`);
+        return;
+    }
+    // Call remoteTrackRemoved for each track in the stream
+    const streamVideoTracks = stream.getVideoTracks();
+    for (const videoTrack of streamVideoTracks) {
+        this._remoteTrackRemoved(stream, videoTrack);
+    }
+    const streamAudioTracks = stream.getAudioTracks();
+    for (const audioTrack of streamAudioTracks) {
+        this._remoteTrackRemoved(stream, audioTrack);
+    }
+};
+
+/**
+ * Handles remote media track removal.
+ * @param {MediaStream} stream WebRTC MediaStream instance which is the parent
+ * of the track.
+ * @param {MediaStreamTrack} track the WebRTC MediaStreamTrack which has been
+ * removed from the PeerConnection.
+ */
+TraceablePeerConnection.prototype._remoteTrackRemoved
+= function (stream, track) {
+    const streamId = RTC.getStreamID(stream);
+    const trackId = track && track.id;
+
+    logger.info("Remote track removed", streamId, trackId);
+
+    if (!streamId) {
+        GlobalOnErrorHandler.callErrorHandler(
+            new Error("Remote track removal failed - no stream ID"));
+        // Abort
+        return;
+    }
+
+    if (!trackId) {
+        GlobalOnErrorHandler.callErrorHandler(
+            new Error("Remote track removal failed - no track ID"));
+        // Abort
+        return;
+    }
+
+    if (!this.rtc._removeRemoteTrack(streamId, trackId)) {
+        // NOTE this warning is always printed when user leaves the room,
+        // because we remove remote tracks manually on MUC member left event,
+        // before the SSRCs are removed by Jicofo. In most cases it is fine to
+        // ignore this warning, but still it's better to keep it printed for
+        // debugging purposes.
+        //
+        // We could change the behaviour to emit track removed only from here,
+        // but the order of the events will change and consuming apps could
+        // behave unexpectedly (the "user left" event would come before "track
+        // removed" events).
+        logger.warn(
+            `Removed track not found for msid: ${streamId},
+             track id: ${trackId}`);
+    }
+};
+
 /**
  * Returns map with keys msid and values ssrc.
  * @param desc the SDP that will be modified.
@@ -259,7 +492,7 @@ var normalizePlanB = function(desc) {
                 });
             }
 
-            if (typeof mLine.ssrcs !== 'undefined' && Array.isArray(mLine.ssrcs)) {
+            if (Array.isArray(mLine.ssrcs)) {
                 var i;
                 for (i = 0; i<mLine.ssrcs.length; i++){
                     if (typeof mLine.ssrcs[i] === 'object'
@@ -315,7 +548,8 @@ var getters = {
         // if we're running on FF, transform to Plan B first.
         if (RTCBrowserType.usesUnifiedPlan()) {
             desc = this.interop.toPlanB(desc);
-            this.trace('getRemoteDescription::postTransform (Plan B)', dumpSDP(desc));
+            this.trace(
+                'getRemoteDescription::postTransform (Plan B)', dumpSDP(desc));
         }
         return desc;
     }
@@ -392,7 +626,8 @@ TraceablePeerConnection.prototype.setLocalDescription
         },
         function (err) {
             self.trace('setLocalDescriptionOnFailure', err);
-            self.eventEmitter.emit(XMPPEvents.SET_LOCAL_DESCRIPTION_FAILED,
+            self.eventEmitter.emit(
+                RTCEvents.SET_LOCAL_DESCRIPTION_FAILED,
                 err, self.peerconnection);
             failureCallback(err);
         }
@@ -404,7 +639,9 @@ TraceablePeerConnection.prototype.setRemoteDescription
     this.trace('setRemoteDescription::preTransform', dumpSDP(description));
     // TODO the focus should squeze or explode the remote simulcast
     description = this.simulcast.mungeRemoteDescription(description);
-    this.trace('setRemoteDescription::postTransform (simulcast)', dumpSDP(description));
+    this.trace(
+        'setRemoteDescription::postTransform (simulcast)',
+        dumpSDP(description));
 
     if (this.options.preferH264) {
         const parsedSdp = transform.parse(description.sdp);
@@ -418,7 +655,9 @@ TraceablePeerConnection.prototype.setRemoteDescription
         description.sdp = this.rtxModifier.stripRtx(description.sdp);
         this.trace('setRemoteDescription::postTransform (stripRtx)', dumpSDP(description));
         description = this.interop.toUnifiedPlan(description);
-        this.trace('setRemoteDescription::postTransform (Plan A)', dumpSDP(description));
+        this.trace(
+            'setRemoteDescription::postTransform (Plan A)',
+            dumpSDP(description));
     }
 
     if (RTCBrowserType.usesPlanB()) {
@@ -433,7 +672,7 @@ TraceablePeerConnection.prototype.setRemoteDescription
         },
         function (err) {
             self.trace('setRemoteDescriptionOnFailure', err);
-            self.eventEmitter.emit(XMPPEvents.SET_REMOTE_DESCRIPTION_FAILED,
+            self.eventEmitter.emit(RTCEvents.SET_REMOTE_DESCRIPTION_FAILED,
                 err, self.peerconnection);
             failureCallback(err);
         }
@@ -459,6 +698,9 @@ TraceablePeerConnection.prototype.generateRecvonlySsrc = function() {
 
 TraceablePeerConnection.prototype.close = function () {
     this.trace('stop');
+    if (!this.rtc._removePeerConnection(this)) {
+        logger.error("RTC._removePeerConnection returned false");
+    }
     if (this.statsinterval !== null) {
         window.clearInterval(this.statsinterval);
         this.statsinterval = null;
@@ -578,7 +820,7 @@ TraceablePeerConnection.prototype.createAnswer
                 _fixAnswerRFC4145Setup(remoteDescription, localDescription);
                 answer.sdp = localDescription.raw;
 
-                this.eventEmitter.emit(XMPPEvents.SENDRECV_STREAMS_CHANGED,
+                this.eventEmitter.emit(RTCEvents.SENDRECV_STREAMS_CHANGED,
                     extractSSRCMap(answer));
 
                 successCallback(answer);
@@ -591,7 +833,7 @@ TraceablePeerConnection.prototype.createAnswer
         },
         (err) => {
             this.trace('createAnswerOnFailure', err);
-            this.eventEmitter.emit(XMPPEvents.CREATE_ANSWER_FAILED, err,
+            this.eventEmitter.emit(RTCEvents.CREATE_ANSWER_FAILED, err,
                 this.peerconnection);
             failureCallback(err);
         },

modules/connectivity/ConnectionQuality.js

@@ -5,7 +5,6 @@ import {getLogger} from "jitsi-meet-logger";
 import RTCBrowserType from "../RTC/RTCBrowserType";
 
 var XMPPEvents = require('../../service/xmpp/XMPPEvents');
-var MediaType = require('../../service/RTC/MediaType');
 var VideoType = require('../../service/RTC/VideoType');
 var Resolutions = require("../../service/RTC/Resolutions");
 
@@ -359,8 +358,7 @@ export default class ConnectionQuality {
         // about the resolution, and they look at their local rendered
         // resolution instead. Consider removing this.
         let localVideoTrack
-            = this._conference.getLocalTracks(MediaType.VIDEO)
-                .find(track => track.isVideoTrack());
+            = this._conference.getLocalVideoTrack();
         if (localVideoTrack && localVideoTrack.resolution) {
             data.resolution = localVideoTrack.resolution;
         }
@@ -390,9 +388,8 @@ export default class ConnectionQuality {
         let key;
         let updateLocalConnectionQuality
             = !this._conference.isConnectionInterrupted();
-        let localVideoTrack =
-                this._conference.getLocalTracks(MediaType.VIDEO)
-                    .find(track => track.isVideoTrack());
+        let localVideoTrack
+            = this._conference.getLocalVideoTrack();
         let videoType = localVideoTrack ? localVideoTrack.videoType : undefined;
         let isMuted = localVideoTrack ? localVideoTrack.isMuted() : true;
         let resolution = localVideoTrack ? localVideoTrack.resolution : null;

modules/xmpp/ChatRoom.js

@@ -746,34 +746,47 @@ export default class ChatRoom extends Listenable {
         this.sendPresence();
     }
 
-    remoteTrackAdded (data) {
+    /**
+     * Obtains the info about given media advertised in the MUC presence of
+     * the participant identified by the given endpoint JID.
+     * @param {string} endpointId the endpoint ID mapped to the participant
+     * which corresponds to MUC nickname.
+     * @param {MediaType} mediaType the type of the media for which presence
+     * info will be obtained.
+     * @return {PeerMediaInfo} presenceInfo an object with media presence
+     * info or <tt>null</tt> either if there is no presence available or if
+     * the media type given is invalid.
+     */
+    getMediaPresenceInfo (endpointId, mediaType) {
         // Will figure out current muted status by looking up owner's presence
-        var pres = this.lastPresences[data.owner];
-        if(pres) {
-            var mediaType = data.mediaType;
-            var mutedNode = null;
-            if (mediaType === MediaType.AUDIO) {
-                mutedNode = filterNodeFromPresenceJSON(pres, "audiomuted");
-            } else if (mediaType === MediaType.VIDEO) {
-                mutedNode = filterNodeFromPresenceJSON(pres, "videomuted");
-                var videoTypeNode = filterNodeFromPresenceJSON(pres, "videoType");
-                if(videoTypeNode
-                    && videoTypeNode.length > 0
-                    && videoTypeNode[0])
-                    data.videoType = videoTypeNode[0]["value"];
-            } else {
-                logger.warn("Unsupported media type: " + mediaType);
-                data.muted = null;
-            }
-
-            if (mutedNode) {
-                data.muted = mutedNode.length > 0 &&
-                             mutedNode[0] &&
-                             mutedNode[0]["value"] === "true";
+        const pres = this.lastPresences[this.roomjid + "/" + endpointId];
+        if (!pres) {
+            // No presence available
+            return null;
+        }
+        const data = {
+            muted: false, // unmuted by default
+            videoType: undefined // no video type by default
+        };
+        let mutedNode = null;
+
+        if (mediaType === MediaType.AUDIO) {
+            mutedNode = filterNodeFromPresenceJSON(pres, "audiomuted");
+        } else if (mediaType === MediaType.VIDEO) {
+            mutedNode = filterNodeFromPresenceJSON(pres, "videomuted");
+            let videoTypeNode = filterNodeFromPresenceJSON(pres, "videoType");
+
+            if(videoTypeNode.length > 0) {
+                data.videoType = videoTypeNode[0]["value"];
             }
+        } else {
+            logger.error("Unsupported media type: " + mediaType);
+            return null;
         }
 
-        this.eventEmitter.emit(XMPPEvents.REMOTE_TRACK_ADDED, data);
+        data.muted = mutedNode.length > 0 && mutedNode[0]["value"] === "true";
+
+        return data;
     }
 
     /**

modules/xmpp/JingleSession.js

@@ -56,14 +56,21 @@ function JingleSession(me, sid, peerjid, connection,
      * @type {JingleSessionState}
      */
     this.state = null;
+
+    /**
+     * The RTC service instance
+     * @type {RTC}
+     */
+    this.rtc = null;
 }
 
 /**
  * Prepares this object to initiate a session.
  * @param isInitiator whether we will be the Jingle initiator.
  * @param room <tt>ChatRoom<tt> for the conference associated with this session
+ * @param {RTC} rtc the RTC service instance
  */
-JingleSession.prototype.initialize = function(isInitiator, room) {
+JingleSession.prototype.initialize = function(isInitiator, room, rtc) {
     if (this.state !== null) {
         var errmsg
             = 'attempt to initiate on session ' + this.sid + 'in state '
@@ -72,6 +79,7 @@ JingleSession.prototype.initialize = function(isInitiator, room) {
         throw new Error(errmsg);
     }
     this.room = room;
+    this.rtc = rtc;
     this.state = JingleSessionState.PENDING;
     this.initiator = isInitiator ? this.me : this.peerjid;
     this.responder = !isInitiator ? this.me : this.peerjid;

modules/xmpp/JingleSessionPC.js

@@ -1,16 +1,14 @@
-/* global $, $iq */
+/* global $, $iq, Strophe */
 
 import {getLogger} from "jitsi-meet-logger";
 const logger = getLogger(__filename);
 var JingleSession = require("./JingleSession");
-var TraceablePeerConnection = require("./TraceablePeerConnection");
 var SDPDiffer = require("./SDPDiffer");
 var SDPUtil = require("./SDPUtil");
 var SDP = require("./SDP");
 var async = require("async");
 var XMPPEvents = require("../../service/xmpp/XMPPEvents");
 var RTCBrowserType = require("../RTC/RTCBrowserType");
-import RTC from "../RTC/RTC";
 var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
 var Statistics = require("../statistics/statistics");
 
@@ -42,6 +40,10 @@ var IQ_TIMEOUT = 10000;
  * candidates.
  * @param {boolean} options.failICE it's an option used in the tests. Set to
  * <tt>true</tt> to block any real candidates and make the ICE fail.
+ *
+ * @constructor
+ *
+ * @implements {SignalingLayer}
  */
 function JingleSessionPC(me, sid, peerjid, connection,
                          media_constraints, ice_config, options) {
@@ -94,7 +96,6 @@ function JingleSessionPC(me, sid, peerjid, connection,
 JingleSessionPC.prototype = Object.create(JingleSession.prototype);
 JingleSessionPC.prototype.constructor = JingleSessionPC;
 
-
 JingleSessionPC.prototype.doInitialize = function () {
     var self = this;
     this.lasticecandidate = false;
@@ -102,21 +103,16 @@ JingleSessionPC.prototype.doInitialize = function () {
     this.isreconnect = false;
     // Set to true if the connection was ever stable
     this.wasstable = false;
-
-    this.peerconnection = new TraceablePeerConnection(
+    // Create new peer connection instance
+    this.peerconnection = this.rtc.createPeerConnection(
+        this,
         this.connection.jingle.ice_config,
-        RTC.getPCConstraints(),
         /* Options */
         {
             disableSimulcast: this.room.options.disableSimulcast,
             disableRtx: this.room.options.disableRtx,
             preferH264: this.room.options.preferH264
-        },
-        // TPC is using room's eventEmitter, so that all XMPPEvents can be
-        // captured from ChatRoom. But at the same time it makes hard
-        // or impossible to deal with more than one TPC instance without
-        // further refactoring.
-        this.room.eventEmitter);
+        });
 
     this.peerconnection.onicecandidate = function (ev) {
         if (!ev) {
@@ -145,12 +141,6 @@ JingleSessionPC.prototype.doInitialize = function () {
         }
         self.sendIceCandidate(candidate);
     };
-    this.peerconnection.onaddstream = function (event) {
-        self.remoteStreamAdded(event.stream);
-    };
-    this.peerconnection.onremovestream = function (event) {
-        self.remoteStreamRemoved(event.stream);
-    };
     // Note there is a change in the spec about closed:
     // This value moved into the RTCPeerConnectionState enum in the May 13, 2016
     // draft of the specification, as it reflects the state of the
@@ -308,8 +298,11 @@ JingleSessionPC.prototype.readSsrcInfo = function (contents) {
             var ssrc = this.getAttribute('ssrc');
             $(this).find('>ssrc-info[xmlns="http://jitsi.org/jitmeet"]').each(
                 function () {
-                    var owner = this.getAttribute('owner');
-                    self.ssrcOwners[ssrc] = owner;
+                    const owner = this.getAttribute('owner');
+                    if (owner && owner.length) {
+                        self.ssrcOwners[ssrc]
+                            = Strophe.getResourceFromJid(owner);
+                    }
                 }
             );
         });
@@ -1278,149 +1271,17 @@ JingleSessionPC.onJingleFatalError = function (session, error)
 };
 
 /**
- * Called when new remote MediaStream is added to the PeerConnection.
- * @param stream the WebRTC MediaStream for remote participant
- */
-JingleSessionPC.prototype.remoteStreamAdded = function (stream) {
-    var self = this;
-    if (!RTC.isUserStream(stream)) {
-        logger.info(
-            "Ignored remote 'stream added' event for non-user stream", stream);
-        return;
-    }
-    // Bind 'addtrack'/'removetrack' event handlers
-    if (RTCBrowserType.isChrome() || RTCBrowserType.isNWJS()
-        || RTCBrowserType.isElectron()) {
-        stream.onaddtrack = function (event) {
-            self.remoteTrackAdded(event.target, event.track);
-        };
-        stream.onremovetrack = function (event) {
-            self.remoteTrackRemoved(event.target, event.track);
-        };
-    }
-    // Call remoteTrackAdded for each track in the stream
-    stream.getAudioTracks().forEach(function (track) {
-        self.remoteTrackAdded(stream, track);
-    });
-    stream.getVideoTracks().forEach(function (track) {
-        self.remoteTrackAdded(stream, track);
-    });
-};
-
-/**
- * Called on "track added" and "stream added" PeerConnection events(cause we
- * handle streams on per track basis). Does find the owner and the SSRC for
- * the track and passes that to ChatRoom for further processing.
- * @param stream WebRTC MediaStream instance which is the parent of the track
- * @param track the WebRTC MediaStreamTrack added for remote participant
- */
-JingleSessionPC.prototype.remoteTrackAdded = function (stream, track) {
-    logger.info("Remote track added", stream, track);
-    var streamId = RTC.getStreamID(stream);
-    var mediaType = track.kind;
-
-    // This is our event structure which will be passed by the ChatRoom as
-    // XMPPEvents.REMOTE_TRACK_ADDED data
-    var jitsiTrackAddedEvent = {
-        stream: stream,
-        track: track,
-        mediaType: track.kind, /* 'audio' or 'video' */
-        owner: undefined, /* to be determined below */
-        muted: null /* will be set in the ChatRoom */
-    };
-    try{
-        // look up an associated JID for a stream id
-        if (!mediaType) {
-            logger.error("MediaType undefined", track);
-            throw new Error("MediaType undefined for remote track");
-        }
-
-        var remoteSDP = new SDP(this.peerconnection.remoteDescription.sdp);
-        var medialines = remoteSDP.media.filter(function (mediaLines){
-            return mediaLines.startsWith("m=" + mediaType);
-        });
-        if (!medialines.length) {
-            logger.error("No media for type " + mediaType + " found in remote SDP");
-            throw new Error("No media for type " + mediaType +
-                " found in remote SDP for remote track");
-        }
-
-        var ssrclines = SDPUtil.find_lines(medialines[0], 'a=ssrc:');
-        ssrclines = ssrclines.filter(function (line) {
-            var msid = RTCBrowserType.isTemasysPluginUsed() ? 'mslabel' : 'msid';
-            return line.indexOf(msid + ':' + streamId) !== -1;
-        });
-
-        var thessrc;
-        if (ssrclines.length) {
-            thessrc = ssrclines[0].substring(7).split(' ')[0];
-            if (!this.ssrcOwners[thessrc]) {
-                logger.error("No SSRC owner known for: " + thessrc);
-                throw new Error("No SSRC owner known for: " + thessrc +
-                    " for remote track");
-            }
-            jitsiTrackAddedEvent.owner = this.ssrcOwners[thessrc];
-            logger.log('associated jid', this.ssrcOwners[thessrc], thessrc);
-        } else {
-            logger.error("No SSRC lines for ", streamId);
-            throw new Error("No SSRC lines for streamId " + streamId +
-                " for remote track");
-        }
-        jitsiTrackAddedEvent.ssrc = thessrc;
-
-        this.room.remoteTrackAdded(jitsiTrackAddedEvent);
-    } catch (error) {
-        GlobalOnErrorHandler.callErrorHandler(error);
-    }
-};
-
-/**
- * Handles remote stream removal.
- * @param stream the WebRTC MediaStream object which is being removed from the
- * PeerConnection
+ * @inheritDoc
  */
-JingleSessionPC.prototype.remoteStreamRemoved = function (stream) {
-    var self = this;
-    if (!RTC.isUserStream(stream)) {
-        logger.info(
-            "Ignored remote 'stream removed' event for non-user stream", stream);
-        return;
-    }
-    // Call remoteTrackRemoved for each track in the stream
-    stream.getVideoTracks().forEach(function(track){
-        self.remoteTrackRemoved(stream, track);
-    });
-    stream.getAudioTracks().forEach(function(track) {
-       self.remoteTrackRemoved(stream, track);
-    });
+JingleSessionPC.prototype.getPeerMediaInfo  = function (owner, mediaType) {
+    return this.room.getMediaPresenceInfo(owner, mediaType);
 };
 
 /**
- * Handles remote media track removal.
- * @param stream WebRTC MediaStream instance which is the parent of the track
- * @param track the WebRTC MediaStreamTrack which has been removed from
- * the PeerConnection.
+ * @inheritDoc
  */
-JingleSessionPC.prototype.remoteTrackRemoved = function (stream, track) {
-    logger.info("Remote track removed", stream, track);
-    var streamId = RTC.getStreamID(stream);
-    var trackId = track && track.id;
-    try{
-        if (!streamId) {
-            logger.error("No stream ID for", stream);
-            throw new Error("Remote track removal failed - No stream ID");
-        }
-
-        if (!trackId) {
-            logger.error("No track ID for", track);
-            throw new Error("Remote track removal failed - No track ID");
-        }
-
-        this.room.eventEmitter.emit(
-            XMPPEvents.REMOTE_TRACK_REMOVED, streamId, trackId);
-    } catch (error) {
-        GlobalOnErrorHandler.callErrorHandler(error);
-    }
+JingleSessionPC.prototype.getSSRCOwner = function(ssrc) {
+    return this.ssrcOwners[ssrc];
 };
 
 /**

modules/xmpp/SDP.js

@@ -251,12 +251,14 @@ SDP.prototype.toJingle = function (elem, thecreator) {
                     elem.c('parameter');
                     elem.attrs({name: "cname", value:Math.random().toString(36).substring(7)});
                     elem.up();
-                    var msid = null;
-                    if(mline.media == "audio") {
-                        // FIXME what is this ? global APP.RTC in SDP ?
-                        msid = APP.RTC.localAudio._getId();
-                    } else {
-                        msid = APP.RTC.localVideo._getId();
+                    // FIXME what case does this code handle ? remove ???
+                    let msid = null;
+                    // FIXME what is this ? global APP.RTC in SDP ?
+                    const localTrack = APP.RTC.getLocalTracks(mline.media);
+                    if (localTrack) {
+                        // FIXME before this changes the track id was accessed,
+                        // but msid stands for the stream id, makes no sense ?
+                        msid = localTrack.getTrackId();
                     }
                     if(msid != null) {
                         msid = SDPUtil.filter_special_chars(msid);

service/RTC/RTCEvents.js

@@ -1,5 +1,19 @@
 var RTCEvents = {
+    /**
+     * Indicates error while create answer call.
+     */
+    CREATE_ANSWER_FAILED: "rtc.create_answer_failed",
+    /**
+     * Indicates error while create offer call.
+     * FIXME not used (yet), but hook up with create offer failure once added
+     */
+    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",
@@ -7,12 +21,39 @@ var RTCEvents = {
     LASTN_ENDPOINT_CHANGED: "rtc.lastn_endpoint_changed",
     AVAILABLE_DEVICES_CHANGED: "rtc.available_devices_changed",
     TRACK_ATTACHED: "rtc.track_attached",
+    /**
+     * 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
+     **/
+    REMOTE_TRACK_ADDED: "rtc.remote_track_added",
     // FIXME get rid of this event in favour of NO_DATA_FROM_SOURCE event
     // (currently implemented for local tracks only)
     REMOTE_TRACK_MUTE: "rtc.remote_track_mute",
+    /**
+     * 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.
+     */
+    REMOTE_TRACK_REMOVED: "rtc.remote_track_removed",
     // FIXME get rid of this event in favour of NO_DATA_FROM_SOURCE event
     // (currently implemented for local tracks only)
     REMOTE_TRACK_UNMUTE: "rtc.remote_track_unmute",
+    /**
+     * Indicates error while set local description.
+     */
+    SET_LOCAL_DESCRIPTION_FAILED: "rtc.set_local_description_failed",
+    /**
+     * Indicates error while set remote description.
+     */
+    SET_REMOTE_DESCRIPTION_FAILED: "rtc.set_remote_description_failed",
     AUDIO_OUTPUT_DEVICE_CHANGED: "rtc.audio_output_device_changed",
     DEVICE_LIST_CHANGED: "rtc.device_list_changed",
     DEVICE_LIST_AVAILABLE: "rtc.device_list_available",

service/RTC/SignalingLayer.js

@@ -0,0 +1,40 @@
+
+/**
+ * An object that carries the info about specific media type advertised by
+ * participant in the signalling 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
+ * which is not available to the RTC module in the media SDP.
+ *
+ * @interface SignalingLayer
+ */
+export default class SignalingLayer {
+
+    /**
+     * Obtains the endpoint ID for given SSRC.
+     * @param {string} ssrc a string representation of the SSRC number.
+     * @return {string|null} the endpoint ID for given media SSRC.
+     */
+    getSSRCOwner (ssrc) { // eslint-disable-line no-unused-vars
+        throw new Error('not implemented');
+    }
+    /**
+     * Obtains the info about given media advertised in the MUC presence of
+     * the participant identified by the given MUC JID.
+     * @param {string} owner the MUC jid of the participant for whom
+     * {@link PeerMediaInfo} will be obtained.
+     * @param {MediaType} mediaType the type of the media for which presence
+     * info will be obtained.
+     * @return {PeerMediaInfo|null} presenceInfo an object with media presence
+     * info or <tt>null</tt> either if there is no presence available for given
+     * JID or if the media type given is invalid.
+     */
+    getPeerMediaInfo (owner, mediaType) { // eslint-disable-line no-unused-vars
+        throw new Error('not implemented');
+    }
+}

service/xmpp/XMPPEvents.js

@@ -30,16 +30,6 @@ var XMPPEvents = {
     // Designates an event indicating that the media (ICE) connection failed.
     // This should go to the RTC module.
     CONNECTION_ICE_FAILED: "xmpp.connection.ice.failed",
-    // TODO: only used in a hack, should probably be removed.
-    CREATE_ANSWER_ERROR: 'xmpp.create_answer_error',
-    /**
-     * Indicates error while create answer call.
-     */
-    CREATE_ANSWER_FAILED: "xmpp.create_answer_failed",
-    /**
-     * Indicates error while create offer call.
-     */
-    CREATE_OFFER_FAILED: "xmpp.create_offer_failed",
     // Designates an event indicating that the display name of a participant
     // has changed.
     DISPLAY_NAME_CHANGED: "xmpp.display_name_changed",
@@ -127,25 +117,6 @@ var XMPPEvents = {
     // Designates an event indicating that we received statistics from a
     // participant in the MUC.
     REMOTE_STATS: "xmpp.remote_stats",
-    /**
-     * 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
-     **/
-    REMOTE_TRACK_ADDED: "xmpp.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.
-     */
-    REMOTE_TRACK_REMOVED: "xmpp.remote_track_removed",
     RESERVATION_ERROR: "xmpp.room_reservation_error",
     ROOM_CONNECT_ERROR: 'xmpp.room_connect_error',
     ROOM_CONNECT_NOT_ALLOWED_ERROR: 'xmpp.room_connect_error.not_allowed',
@@ -156,10 +127,6 @@ var XMPPEvents = {
     ROOM_MAX_USERS_ERROR: "xmpp.room_max_users_error",
     // Designates an event indicating that we sent an XMPP message to the MUC.
     SENDING_CHAT_MESSAGE: "xmpp.sending_chat_message",
-    /**
-     * Indicates that the local sendrecv streams in local SDP are changed.
-     */
-    SENDRECV_STREAMS_CHANGED: "xmpp.sendrecv_streams_changed",
     /**
      * Event fired when we do not get our 'session-accept' acknowledged by
      * Jicofo. It most likely means that there is serious problem with our
@@ -171,19 +138,6 @@ var XMPPEvents = {
      * packets means that most likely it has never seen our IQ.
      */
     SESSION_ACCEPT_TIMEOUT: "xmpp.session_accept_timeout",
-    // TODO: only used in a hack, should probably be removed.
-    SET_LOCAL_DESCRIPTION_ERROR: 'xmpp.set_local_description_error',
-
-    /**
-     * Indicates error while set local description.
-     */
-    SET_LOCAL_DESCRIPTION_FAILED: "xmpp.set_local_description_failed",
-    // TODO: only used in a hack, should probably be removed.
-    SET_REMOTE_DESCRIPTION_ERROR: 'xmpp.set_remote_description_error',
-    /**
-     * Indicates error while set remote description.
-     */
-    SET_REMOTE_DESCRIPTION_FAILED: "xmpp.set_remote_description_failed",
     // Designates an event indicating that we should join the conference with
     // audio and/or video muted.
     START_MUTED_FROM_FOCUS: "xmpp.start_muted_from_focus",