feat(JitsiConference): delay the ICE failed notification

Because it's possible to go back from ICE FAILED state to CONNECTED it's
better to give it some time until the XMPP connection recovers and only
if they ICE does not recover in time send the ICE failed notification
to Jicofo. It's done by sending a ping to the XMPP server and checking
the ICE after 2 seconds past the ping successful response.

JitsiConference.js

 import TalkMutedDetection from './modules/TalkMutedDetection';
 import browser from './modules/browser';
 import ConnectionQuality from './modules/connectivity/ConnectionQuality';
+import IceFailedNotification
+    from './modules/connectivity/IceFailedNotification';
 import ParticipantConnectionStatusHandler
     from './modules/connectivity/ParticipantConnectionStatus';
 import E2ePing from './modules/e2eping/e2eping';
         this.statistics.dispose();
     }
 
+    this._delayedIceFailed && this._delayedIceFailed.cancel();
+
     // Close both JVb and P2P JingleSessions
     if (this.jvbJingleSession) {
         this.jvbJingleSession.close();
         }
         this._stopP2PSession('connectivity-error', 'ICE FAILED');
     } else if (session && this.jvbJingleSession === session) {
-        // Let Jicofo know that the JVB's ICE connection has failed
-        session.sendIceFailedNotification();
+        if (this.xmpp.isPingSupported()) {
+            this._delayedIceFailed = new IceFailedNotification(this);
+            this._delayedIceFailed.start(session);
+        } else {
+            // Let Jicofo know that the JVB's ICE connection has failed
+            logger.info('PING not supported - sending ICE failed immediately');
+            session.sendIceFailedNotification();
+        }
     }
 };
 
         this.isP2PConnectionInterrupted = false;
     } else {
         this.isJvbConnectionInterrupted = false;
+        this._delayedIceFailed && this._delayedIceFailed.cancel();
     }
 
     if (session.isP2P === this.isP2PActive()) {

modules/connectivity/IceFailedNotification.js

+/* global __filename */
+import { getLogger } from 'jitsi-meet-logger';
+
+const logger = getLogger(__filename);
+
+/**
+ * A delayed ICE failed notification which is triggered only if the ICE
+ * connection does not recover soon after or before the XMPP connection is
+ * restored (if it was ever broken). If ICE fails while the XMPP connection is
+ * not broken then the notifications will be sent after 2 seconds delay. This
+ * extra delay is not intentional just a side effect of the code.
+ * NOTE that this delayed task can only be used if PING is supported by the XMPP
+ * server.
+ */
+export default class IceFailedNotification {
+    /**
+     * Creates new {@code DelayedIceFailed} task.
+     * @param {JitsiConference} conference
+     */
+    constructor(conference) {
+        this._conference = conference;
+    }
+
+    /**
+     * Starts the task.
+     * @param {JingleSessionPC} session - the JVB Jingle session.
+     */
+    start(session) {
+        // The 65 seconds are greater than the default Prosody's BOSH
+        // timeout of 60. This gives some time for the XMPP connection
+        // to recover.
+        this._conference.xmpp.ping(65000).then(
+            () => {
+                if (this._canceled) {
+                    return;
+                }
+
+                if (this._conference.isJvbConnectionInterrupted) {
+                    this._iceFailedTimeout = window.setTimeout(() => {
+                        logger.info(
+                            'Sending ICE failed'
+                            + ' - the connection has not recovered');
+                        this._iceFailedTimeout = undefined;
+                        session.sendIceFailedNotification();
+                    }, 2000);
+                } else {
+                    logger.info(
+                        'ICE connection restored - not sending ICE failed');
+                }
+            },
+            error => {
+                logger.error(
+                    'PING error/timeout - not sending ICE failed', error);
+            });
+    }
+
+    /**
+     * Cancels the task.
+     */
+    cancel() {
+        this._canceled = true;
+        if (this._iceFailedTimeout) {
+            window.clearTimeout(this._iceFailedTimeout);
+        }
+    }
+}