Merge remote-tracking branch 'upstream/master' into ds-error-handle

JitsiConference.js

 var Statistics = require("./modules/statistics/statistics");
 var JitsiDTMFManager = require('./modules/DTMF/JitsiDTMFManager');
 var JitsiTrackEvents = require("./JitsiTrackEvents");
+var JitsiTrackErrors = require("./JitsiTrackErrors");
 var Settings = require("./modules/settings/Settings");
 
 /**
  * and there is already another video track in the conference.
  */
 JitsiConference.prototype.addTrack = function (track) {
+    if(track.disposed)
+    {
+        throw new Error(JitsiTrackErrors.TRACK_IS_DISPOSED);
+    }
     if (track.isVideoTrack()) {
         if (this.rtc.getLocalVideoStream()) {
             throw new Error("cannot add second video track to the conference");
             }
 
             track.muteHandler = this._fireMuteChangeEvent.bind(this, track);
-            track.stopHandler = this.removeTrack.bind(this, track);
             track.audioLevelHandler = this._fireAudioLevelChangeEvent.bind(this);
             track.addEventListener(JitsiTrackEvents.TRACK_MUTE_CHANGED,
                                    track.muteHandler);
-            track.addEventListener(JitsiTrackEvents.TRACK_STOPPED,
-                                   track.stopHandler);
             track.addEventListener(JitsiTrackEvents.TRACK_AUDIO_LEVEL_CHANGED,
                                    track.audioLevelHandler);
             //FIXME: This dependacy is not necessary. This is quick fix.
  * @returns {Promise}
  */
 JitsiConference.prototype.removeTrack = function (track) {
+    if(track.disposed)
+    {
+        throw new Error(JitsiTrackErrors.TRACK_IS_DISPOSED);
+    }
     if(!this.room){
         if(this.rtc) {
             this.rtc.removeLocalStream(track);
             this.rtc.removeLocalStream(track);
             track.removeEventListener(JitsiTrackEvents.TRACK_MUTE_CHANGED,
                 track.muteHandler);
-            track.removeEventListener(JitsiTrackEvents.TRACK_STOPPED,
-                track.stopHandler);
             track.removeEventListener(JitsiTrackEvents.TRACK_AUDIO_LEVEL_CHANGED,
                 track.audioLevelHandler);
             this.room.removeListener(XMPPEvents.SENDRECV_STREAMS_CHANGED,
     participant._tracks.push(track);
 
     var emitter = this.eventEmitter;
-    track.addEventListener(
-        JitsiTrackEvents.TRACK_STOPPED,
-        function () {
-            // remove track from JitsiParticipant
-            var pos = participant._tracks.indexOf(track);
-            if (pos > -1) {
-                participant._tracks.splice(pos, 1);
-            }
-            emitter.emit(JitsiConferenceEvents.TRACK_REMOVED, track);
-        }
-    );
     track.addEventListener(
         JitsiTrackEvents.TRACK_MUTE_CHANGED,
         function () {
             }
         }
     );
+    conference.room.addListener(XMPPEvents.REMOTE_STREAM_REMOVED,
+        function (streamId) {
+            var participants = conference.getParticipants();
+            for(var j = 0; j < participants.length; j++) {
+                var participant = participants[j];
+                var tracks = participant.getTracks();
+                for(var i = 0; i < tracks.length; i++) {
+                    if(tracks[i] && tracks[i].stream &&
+                        RTC.getStreamID(tracks[i].stream) == streamId){
+                        var track = participant._tracks.splice(i, 1)[0];
+                        conference.eventEmitter.emit(
+                            JitsiConferenceEvents.TRACK_REMOVED, track);
+                        return;
+                    }
+                }
+            }
+        }
+    );
     conference.rtc.addListener(RTCEvents.FAKE_VIDEO_TRACK_CREATED,
         function (track) {
             conference.onTrackAdded(track);

JitsiMeetJS.js

                             Statistics.startLocalStats(mStream,
                                 track.setAudioLevel.bind(track));
                             track.addEventListener(
-                                JitsiTrackEvents.TRACK_STOPPED,
+                                JitsiTrackEvents.LOCAL_TRACK_STOPPED,
                                 function(){
                                     Statistics.stopLocalStats(mStream);
                                 });

JitsiTrackErrors.js

         "gum.chrome_extension_installation_error",
     CHROME_EXTENSION_USER_CANCELED:
         "gum.chrome_extension_user_canceled",
-    GENERAL: "gum.general"
+    GENERAL: "gum.general",
+    TRACK_IS_DISPOSED: "track.track_is_disposed"
 };

JitsiTrackEvents.js

     /**
      * The media track was removed to the conference.
      */
-    TRACK_STOPPED: "track.stopped",
+    LOCAL_TRACK_STOPPED: "track.stopped",
     /**
      * The video type("camera" or "desktop") of the track was changed.
      */

doc/API.md

         - CONNECTION_DISCONNECTED - indicates that we are disconnected.
         - WRONG_STATE - indicates that the user has performed action that can't be executed because the connection is in wrong state.
 
+    3. tracks
+        - LOCAL_TRACK_STOPPED - indicates that a local track was stopped. This
+        event can be fired when ```dispose()``` method is called or for other reasons.
+
 * ```JitsiMeetJS.errors``` - JS object that contains all errors used by the API. You can use that object to check the reported errors from the API
     We have two error types - connection and conference. You can access the events with the following code ```JitsiMeetJS.errors.<error_type>.<error_name>```.
     For example if you want to use the conference event that is fired when somebody leave conference you can use the following code - ```JitsiMeetJS.errors.conference.PASSWORD_REQUIRED```.
 
 6. detach(container) - removes the track from the container.
 
-7. stop() - stop sending the track to the other participants in the conference. Returns Promise.
+7. dispose() - disposes the track. If the track is added to a conference the track will be removed. Returns Promise.
 
    Note: This method is implemented only for the local tracks.
 

doc/example/example.js

             function () {
                 console.log("local track muted");
             });
-        localTracks[i].addEventListener(JitsiMeetJS.events.track.TRACK_STOPPED,
+        localTracks[i].addEventListener(JitsiMeetJS.events.track.LOCAL_TRACK_STOPPED,
             function () {
                 console.log("local track stoped");
             });
         function () {
             console.log("remote track muted");
         });
-    track.addEventListener(JitsiMeetJS.events.track.TRACK_STOPPED,
+    track.addEventListener(JitsiMeetJS.events.track.LOCAL_TRACK_STOPPED,
         function () {
             console.log("remote track stoped");
         });
 function switchVideo() {
     isVideo = !isVideo;
     if(localTracks[1]) {
-        localTracks[1].stop();
+        localTracks[1].dispose();
         localTracks.pop();
     }
     JitsiMeetJS.createLocalTracks({devices: isVideo? ["video"] : ["desktop"]}).
                 function () {
                     console.log("local track muted");
                 });
-            localTracks[1].addEventListener(JitsiMeetJS.events.track.TRACK_STOPPED,
+            localTracks[1].addEventListener(JitsiMeetJS.events.track.LOCAL_TRACK_STOPPED,
                 function () {
                     console.log("local track stoped");
                 });

modules/RTC/JitsiLocalTrack.js

     this.deviceId = deviceId;
     this.startMuted = false;
     this.ssrc = null;
+    this.disposed = false;
     //FIXME: This dependacy is not necessary.
     this.conference = null;
     JitsiTrack.call(this, null, stream,
         function () {
             if(!this.dontFireRemoveEvent)
                 this.eventEmitter.emit(
-                    JitsiTrackEvents.TRACK_STOPPED);
+                    JitsiTrackEvents.LOCAL_TRACK_STOPPED);
             this.dontFireRemoveEvent = false;
         }.bind(this));
     this.initialMSID = this.getMSID();
  * NOTE: Works for local tracks only.
  * @returns {Promise}
  */
-JitsiLocalTrack.prototype.stop = function () {
+JitsiLocalTrack.prototype.dispose = function () {
     var promise = Promise.resolve();
 
     if (this.conference){
         RTCUtils.stopMediaStream(this.stream);
         this.detach();
     }
+    this.disposed = true;
 
     return promise;
 };

modules/RTC/JitsiRemoteTrack.js

  */
 function JitsiRemoteTrack(RTC, data, sid, ssrc) {
     JitsiTrack.call(this, RTC, data.stream,
-        function () {
-            this.eventEmitter.emit(JitsiTrackEvents.TRACK_STOPPED);
-        }.bind(this), data.jitsiTrackType);
+        function () {}, data.jitsiTrackType);
     this.rtc = RTC;
     this.sid = sid;
     this.stream = data.stream;
     this.eventEmitter.emit(JitsiTrackEvents.TRACK_VIDEOTYPE_CHANGED, type);
 }
 
-delete JitsiRemoteTrack.prototype.stop;
+delete JitsiRemoteTrack.prototype.dispose;
 
 module.exports = JitsiRemoteTrack;

modules/RTC/JitsiTrack.js

 }
 
 /**
- * Stops sending the media track. And removes it from the HTML.
+ * Dispose sending the media track. And removes it from the HTML.
  * NOTE: Works for local tracks only.
  */
-JitsiTrack.prototype.stop = function () {
+JitsiTrack.prototype.dispose = function () {
 }
 
 /**

modules/xmpp/JingleSessionPC.js

     };
     this.peerconnection.onremovestream = function (event) {
         // Remove the stream from remoteStreams
-        // FIXME: remotestreamremoved.jingle not defined anywhere(unused)
-
-        $(document).trigger('remotestreamremoved.jingle', [event, self.sid]);
+        if (event.stream.id !== 'default') {
+            logger.log("REMOTE STREAM REMOVED: ", event.stream , event.stream.id);
+            self.remoteStreamRemoved(event);
+        } else {
+            // This is a recvonly 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.
+            logger.log("RECVONLY REMOTE STREAM IGNORED: " + event.stream + " - " + event.stream.id);
+        }
     };
     this.peerconnection.onsignalingstatechange = function (event) {
         if (!(self && self.peerconnection)) return;
     }
 }
 
+/**
+ * Handles remote stream removal.
+ * @param event The event object associated with the removal.
+ */
+JingleSessionPC.prototype.remoteStreamRemoved = function (event) {
+    var thessrc;
+    var streamId = RTC.getStreamID(event.stream);
+    if (!streamId) {
+        logger.error("No stream ID for", event.stream);
+    } else if (streamId && streamId.indexOf('mixedmslabel') === -1) {
+        this.room.eventEmitter.emit(XMPPEvents.REMOTE_STREAM_REMOVED, streamId);
+    }
+}
+
 /**
  * Returns the ice connection state for the peer connection.
  * @returns the ice connection state for the peer connection.

service/xmpp/XMPPEvents.js

     READY_TO_JOIN: 'xmpp.ready_to_join',
     FOCUS_LEFT: "xmpp.focus_left",
     REMOTE_STREAM_RECEIVED: "xmpp.remote_stream_received",
+    /**
+     * Indicates that remote stream has been removed from the conference.
+     */
+    REMOTE_STREAM_REMOVED: "xmpp.remote_stream_removed",
     /**
      * Indicates that recording state changed.
      */