Merge pull request #233 from jitsi/session-terminate

Handle session-terminate

JitsiConference.js

     };
     this.isMutedByFocus = false;
     this.reportedAudioSSRCs = {};
+    // Flag indicates if the 'onCallEnded' method was ever called on this
+    // instance. Used to log extra analytics event for debugging purpose.
+    // We need to know if the potential issue happened before or after
+    // the restart.
+    this.wasStopped = false;
 }
 
 /**
     // Accept incoming call
     this.room.setJingleSession(jingleSession);
     this.room.connectionTimes["session.initiate"] = now;
+    // Log "session.restart"
+    if (this.wasStopped) {
+        Statistics.sendEventToAll("session.restart");
+    }
     // add info whether call is cross-region
     var crossRegion = null;
     if (window.jitsiRegionInfo)
     // both camera and microphone.
     this.statistics.startCallStats(jingleSession, this.settings);
     this.statistics.startRemoteStats(jingleSession.peerconnection);
-}
+};
+
+/**
+ * Handles the call ended event.
+ * @param {JingleSessionPC} JingleSession the jingle session which has been
+ * terminated.
+ * @param {String} reasonCondition the Jingle reason condition.
+ * @param {String|null} reasonText human readable reason text which may provide
+ * more details about why the call has been terminated.
+ */
+JitsiConference.prototype.onCallEnded
+= function (JingleSession, reasonCondition, reasonText) {
+    logger.info("Call ended: " + reasonCondition + " - " + reasonText);
+    this.wasStopped = true;
+    // Send session.terminate event
+    Statistics.sendEventToAll("session.terminate");
+    // Stop the stats
+    if (this.statistics) {
+        this.statistics.stopRemoteStats();
+        this.statistics.stopCallStats();
+    }
+    // Current JingleSession is invalid so set it to null on the room
+    this.room.setJingleSession(null);
+    // Let the RTC service do any cleanups
+    this.rtc.onCallEnded();
+    // PeerConnection has been closed which means that SSRCs stored in
+    // JitsiLocalTrack will not match those assigned by the old PeerConnection
+    // and SSRC replacement logic will not work as expected.
+    // We want to re-register 'ssrcHandler' of our local tracks, so that they
+    // 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) {
+        // 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);
+    });
+};
+
 
 JitsiConference.prototype.updateDTMFSupport = function () {
     var somebodySupportsDTMF = false;

JitsiConferenceEventManager.js

     var conference = this.conference;
     conference.xmpp.addListener(
         XMPPEvents.CALL_INCOMING, conference.onIncomingCall.bind(conference));
+    conference.xmpp.addListener(
+        XMPPEvents.CALL_ENDED, conference.onCallEnded.bind(conference));
 
     conference.xmpp.addListener(XMPPEvents.START_MUTED_FROM_FOCUS,
         function (audioMuted, videoMuted) {

modules/RTC/RTC.js

             this.eventEmitter);
 };
 
+/**
+ * Should be called when current media session ends and after the PeerConnection
+ * has been closed using PeerConnection.close() method.
+ */
+RTC.prototype.onCallEnded = function() {
+    if (this.dataChannels) {
+        // DataChannels are not explicitly closed as the PeerConnection
+        // is closed on call ended which triggers data channel onclose events.
+        // The reference is cleared to disable any logic related to the data
+        // channels.
+        this.dataChannels = null;
+    }
+};
+
 /**
  * Elects the participant with the given id to be the pinned participant in
  * order to always receive video for this participant (even when last n is

modules/statistics/statistics.js

     if(this.callStatsIntegrationEnabled)
         loadCallStatsAPI();
     this.callStats = null;
+    // Flag indicates whether or not the CallStats have been started for this
+    // Statistics instance
+    this.callStatsStarted = false;
 
     /**
      * Send the stats already saved in rtpStats to be logged via the focus.
  * /modules/settings/Settings.js
  */
 Statistics.prototype.startCallStats = function (session, settings) {
-    if(this.callStatsIntegrationEnabled && !this.callstats) {
+    if(this.callStatsIntegrationEnabled && !this.callStatsStarted) {
+        // Here we overwrite the previous instance, but it must be bound to
+        // the new PeerConnection
+        // FIXME CallStats does not show the participant after
+        // stopCallStats/startCallStats, the issue is being investigated on both
+        // our and CallStats side, but given how rare this situation should
+        // be, we need to have this change merged. Without it "invalid pcHash"
+        // error is reported(lib calls are made for the old PeerConnection).
         this.callstats = new CallStats(session, settings, this.options);
         Statistics.callsStatsInstances.push(this.callstats);
+        this.callStatsStarted = true;
     }
 };
 
  * Removes the callstats.io instances.
  */
 Statistics.prototype.stopCallStats = function () {
-    if(this.callstats) {
+    if(this.callStatsStarted) {
         var index = Statistics.callsStatsInstances.indexOf(this.callstats);
         if(index > -1)
             Statistics.callsStatsInstances.splice(index, 1);
         // feedback even after the conference has been destroyed.
         // this.callstats = null;
         CallStats.dispose();
+        this.callStatsStarted = false;
     }
 };
 

modules/xmpp/strophe.jingle.js

                         reasonText = $(iq).find('>jingle>reason>text').text();
                     }
                     this.terminate(sess.sid, reasonCondition, reasonText);
+                    eventEmitter.emit(XMPPEvents.CALL_ENDED,
+                        sess, reasonCondition, reasonText);
                     break;
                 case 'transport-replace':
                     var now = window.performance.now();

service/xmpp/XMPPEvents.js

     // Designates an event indicating that an offer (e.g. Jingle
     // session-initiate) was received.
     CALL_INCOMING: "xmpp.callincoming.jingle",
+    // Triggered when Jicofo kills our media session, this can happen while
+    // we're still in the MUC, when it decides to terminate the media session.
+    // For example when the session is idle for too long, because we're the only
+    // person in the conference room.
+    CALL_ENDED: "xmpp.callended.jingle",
     CHAT_ERROR_RECEIVED: "xmpp.chat_error_received",
     CONFERENCE_SETUP_FAILED: "xmpp.conference_setup_failed",
     // Designates an event indicating that the connection to the XMPP server