Uses new peer connection statuses to check and show different user msgs. (#1441)

* Uses new peer connection statuses to check and show different user msgs.

Checks for interrupted state of peer connection and shows appropriate messages. In case of inactive or restoring state a message is show to user that video was stopped on purpose. Removes some unused parameters from the event handlers about peer connection status change.

* Removes isParticipantConnectionActive.

conference.js

         return room ? room.getParticipantById(id) : null;
     },
     /**
-     * Checks whether the user identified by given id is currently connected.
+     * Get participant connection status for the participant.
      *
      * @param {string} id participant's identifier(MUC nickname)
      *
-     * @returns {boolean|null} true if participant's connection is ok or false
-     * if the user is having connectivity issues.
+     * @returns {ParticipantConnectionStatus|null} the status of the participant
+     * or null if no such participant is found or participant is the local user.
      */
-    isParticipantConnectionActive (id) {
+    getParticipantConnectionStatus (id) {
         let participant = this.getParticipantById(id);
-        return participant ? participant.isConnectionActive() : null;
+        return participant
+            ? participant.getConnectionStatus() : null;
     },
     /**
      * Gets the display name foe the <tt>JitsiParticipant</tt> identified by
 
         room.on(
             ConferenceEvents.PARTICIPANT_CONN_STATUS_CHANGED,
-            (id, isActive) => {
-                APP.UI.participantConnectionStatusChanged(id, isActive);
+            id => {
+                APP.UI.participantConnectionStatusChanged(id);
         });
         room.on(ConferenceEvents.DOMINANT_SPEAKER_CHANGED, (id) => {
             if (this.isLocalId(id)) {

modules/UI/UI.js

  * Will handle notification about participant's connectivity status change.
  *
  * @param {string} id the id of remote participant(MUC jid)
- * @param {boolean} isActive true if the connection is ok or false if the user
- * is having connectivity issues.
  */
-UI.participantConnectionStatusChanged = function (id, isActive) {
-    VideoLayout.onParticipantConnectionStatusChanged(id, isActive);
+UI.participantConnectionStatusChanged = function (id) {
+    VideoLayout.onParticipantConnectionStatusChanged(id);
 };
 
 /**

modules/UI/videolayout/LargeVideoManager.js

-/* global $, APP */
+/* global $, APP, JitsiMeetJS */
 const logger = require("jitsi-meet-logger").getLogger(__filename);
 
 import Avatar from "../avatar/Avatar";
 
 import AudioLevels from "../audio_levels/AudioLevels";
 
+const ParticipantConnectionStatus
+    = JitsiMeetJS.constants.participantConnectionStatus;
+
 /**
  * Manager for all Large containers.
  */
             // (camera or desktop) is a completely different thing than
             // the video container type (Etherpad, SharedVideo, VideoContainer).
             // ----------------------------------------------------------------
-            // If we the continer is VIDEO_CONTAINER_TYPE, we need to check
+            // If the container is VIDEO_CONTAINER_TYPE, we need to check
             // its stream whether exist and is muted to set isVideoMuted
             // in rest of the cases it is false
             let showAvatar
             // displayed in case we have no video image cached. That is if
             // there was a user switch(image is lost on stream detach) or if
             // the video was not rendered, before the connection has failed.
-            const isHavingConnectivityIssues
-                = APP.conference.isParticipantConnectionActive(id) === false;
+            const isConnectionActive = this._isConnectionActive(id);
 
             if (videoType === VIDEO_CONTAINER_TYPE
-                    && isHavingConnectivityIssues
+                    && !isConnectionActive
                     && (isUserSwitch || !container.wasVideoRendered)) {
                 showAvatar = true;
             }
             // Make sure no notification about remote failure is shown as
             // its UI conflicts with the one for local connection interrupted.
             const isConnected = APP.conference.isConnectionInterrupted()
-                                || !isHavingConnectivityIssues;
+                                || isConnectionActive;
+
+            // when isHavingConnectivityIssues, state can be inactive,
+            // interrupted or restoring. We show different message for
+            // interrupted and the rest.
+            const isConnectionInterrupted =
+                APP.conference.getParticipantConnectionStatus(id)
+                    === ParticipantConnectionStatus.INTERRUPTED;
 
             this.updateParticipantConnStatusIndication(
                     id,
                     isConnected,
-                    (isHavingConnectivityIssues)
+                    (isConnectionInterrupted)
                         ? "connection.USER_CONNECTION_INTERRUPTED"
                         : "connection.LOW_BANDWIDTH");
 
         });
     }
 
+    /**
+     * Checks whether a participant's peer connection status is active.
+     * There is no JitsiParticipant for local id we skip checking local
+     * participant and report it as having no connectivity issues.
+     *
+     * @param {string} id the id of participant(MUC nickname)
+     * @returns {boolean} <tt>true</tt> when participant connection status is
+     * {@link ParticipantConnectionStatus.ACTIVE} and <tt>false</tt> otherwise.
+     * @private
+     */
+    _isConnectionActive(id) {
+        return APP.conference.isLocalId(id)
+                || APP.conference.getParticipantConnectionStatus(this.id)
+                    === ParticipantConnectionStatus.ACTIVE;
+    }
+
     /**
      * Shows/hides notification about participant's connectivity issues to be
      * shown on the large video area.
      */
     showRemoteConnectionMessage (show) {
         if (typeof show !== 'boolean') {
-            show = !APP.conference.isParticipantConnectionActive(this.id);
+            show = !this._isConnectionActive(this.id);
         }
 
         if (show) {

modules/UI/videolayout/RemoteVideo.js

-/* global $, APP, interfaceConfig */
+/* global $, APP, interfaceConfig, JitsiMeetJS */
 const logger = require("jitsi-meet-logger").getLogger(__filename);
 
 import ConnectionIndicator from './ConnectionIndicator';
     cancel: 0,
     muted: 1
 };
+const ParticipantConnectionStatus
+    = JitsiMeetJS.constants.participantConnectionStatus;
 
 /**
  * Creates new instance of the <tt>RemoteVideo</tt>.
 RemoteVideo.prototype.setMutedView = function(isMuted) {
     SmallVideo.prototype.setMutedView.call(this, isMuted);
     // Update 'mutedWhileDisconnected' flag
-    this._figureOutMutedWhileDisconnected(this.isConnectionActive() === false);
+    this._figureOutMutedWhileDisconnected(this.isConnectionInterrupted());
 };
 
 /**
  * <tt>false</tt> otherwise.
  */
 RemoteVideo.prototype.isConnectionActive = function() {
-    return this.user.isConnectionActive();
+    return this.user.getConnectionStatus()
+        === ParticipantConnectionStatus.ACTIVE;
 };
 
 /**

modules/UI/videolayout/VideoLayout.js

      * Shows/hides warning about remote user's connectivity issues.
      *
      * @param {string} id the ID of the remote participant(MUC nickname)
-     * @param {boolean} isActive true if the connection is ok or false when
-     * the user is having connectivity issues.
      */
     // eslint-disable-next-line no-unused-vars
-    onParticipantConnectionStatusChanged (id, isActive) {
+    onParticipantConnectionStatusChanged (id) {
         // Show/hide warning on the large video
         if (this.isCurrentlyOnLarge(id)) {
-            if (largeVideo) {
+            // when pinning and we have lastN enabled, we have rapid connection
+            // status changed between inactive, restoring and active and
+            // if there was a large video update scheduled already it will
+            // reflect the current status and no need to schedule new one
+            // otherwise we end up scheduling updates for endpoints which are
+            // were on large while checking, but a change was already scheduled
+            if (largeVideo && !largeVideo.updateInProcess) {
                 // We have to trigger full large video update to transition from
                 // avatar to video on connectivity restored.
                 this.updateLargeVideo(id, true /* force update */);