fix(safari-ios) Fix audio being lost on safari ios after phone call

JitsiMeetJS.js

                 if (!RTC.options.disableAudioLevels) {
                     for (let i = 0; i < tracks.length; i++) {
                         const track = tracks[i];
-                        const mStream = track.getOriginalStream();
 
                         if (track.getType() === MediaType.AUDIO) {
-                            Statistics.startLocalStats(mStream,
+                            Statistics.startLocalStats(track,
                                 track.setAudioLevel.bind(track));
-                            track.addEventListener(
-                                JitsiTrackEvents.LOCAL_TRACK_STOPPED,
-                                () => {
-                                    Statistics.stopLocalStats(mStream);
-                                });
                         }
                     }
                 }

modules/detection/ActiveDeviceDetector.js

                     // We expect a single device to be available when obtained from obtainAudioAndVideoPermissions
                     // that's  why only take p.value[0].
                     const track = tracks[0];
-                    const originalStream = track.getOriginalStream();
 
-                    Statistics.startLocalStats(originalStream, track.setAudioLevel.bind(track));
-                    track.addEventListener(JitsiTrackEvents.LOCAL_TRACK_STOPPED, () => {
-                        Statistics.stopLocalStats(originalStream);
-                    });
+                    Statistics.startLocalStats(track, track.setAudioLevel.bind(track));
 
                     return track;
                 });

modules/statistics/LocalStatsCollector.js

  * Provides statistics for the local stream.
  */
 
+const logger = require('@jitsi/logger').getLogger(__filename);
+
 /**
  * Size of the webaudio analyzer buffer.
  * @type {number}
 
 window.AudioContext = window.AudioContext || window.webkitAudioContext;
 
+/**
+ * The audio context.
+ * @type {AudioContext}
+ */
 let context = null;
 
-if (window.AudioContext) {
-    context = new AudioContext();
-
-    // XXX Not all browsers define a suspend method on AudioContext. As the
-    // invocation is at the (ES6 module) global execution level, it breaks the
-    // loading of the lib-jitsi-meet library in such browsers and, consequently,
-    // the loading of the very Web app that uses the lib-jitsi-meet library. For
-    // example, Google Chrome 40 on Android does not define the method but we
-    // still want to be able to load the lib-jitsi-meet library there and
-    // display a page which notifies the user that the Web app is not supported
-    // there.
-    context.suspend && context.suspend();
-}
 
 /**
  * Converts time domain data array to audio level.
     this.intervalMilis = interval;
     this.audioLevel = 0;
     this.callback = callback;
+    this.source = null;
+    this.analyser = null;
 }
 
 /**
     if (!LocalStatsCollector.isLocalStatsSupported()) {
         return;
     }
+
     context.resume();
-    const analyser = context.createAnalyser();
+    this.analyser = context.createAnalyser();
 
-    analyser.smoothingTimeConstant = WEBAUDIO_ANALYZER_SMOOTING_TIME;
-    analyser.fftSize = WEBAUDIO_ANALYZER_FFT_SIZE;
+    this.analyser.smoothingTimeConstant = WEBAUDIO_ANALYZER_SMOOTING_TIME;
+    this.analyser.fftSize = WEBAUDIO_ANALYZER_FFT_SIZE;
 
-    const source = context.createMediaStreamSource(this.stream);
+    this.source = context.createMediaStreamSource(this.stream);
 
-    source.connect(analyser);
+    this.source.connect(this.analyser);
 
     this.intervalId = setInterval(
         () => {
-            const array = new Uint8Array(analyser.frequencyBinCount);
+            const array = new Uint8Array(this.analyser.frequencyBinCount);
 
-            analyser.getByteTimeDomainData(array);
+            this.analyser.getByteTimeDomainData(array);
             const audioLevel = timeDomainDataToAudioLevel(array);
 
             // Set the audio levels always as NoAudioSignalDetection now
         clearInterval(this.intervalId);
         this.intervalId = null;
     }
+
+    this.analyser?.disconnect();
+    this.analyser = null;
+    this.source?.disconnect();
+    this.source = null;
 };
 
 /**
  * @returns {boolean}
  */
 LocalStatsCollector.isLocalStatsSupported = function() {
-    return Boolean(context);
+    return Boolean(window.AudioContext);
+};
+
+/**
+ * Disconnects the audio context.
+ */
+LocalStatsCollector.disconnectAudioContext = async function() {
+    if (context) {
+        logger.info('Disconnecting audio context');
+        await context.close();
+        context = null;
+    }
 };
+
+/**
+ * Connects the audio context.
+ */
+LocalStatsCollector.connectAudioContext = function() {
+    if (!LocalStatsCollector.isLocalStatsSupported()) {
+        return;
+    }
+
+    logger.info('Connecting audio context');
+    context = new AudioContext();
+
+    context.suspend();
+};
+
+/**
+ * Initialize the audio context on startup.
+ */
+LocalStatsCollector.connectAudioContext();

modules/statistics/statistics.js

 
 import * as JitsiConferenceEvents from '../../JitsiConferenceEvents';
 import JitsiTrackError from '../../JitsiTrackError';
+import { JitsiTrackEvents } from '../../JitsiTrackEvents';
 import { FEEDBACK } from '../../service/statistics/AnalyticsEvents';
 import * as StatisticsEvents from '../../service/statistics/Events';
 import browser from '../browser';
 
 Statistics.localStats = [];
 
-Statistics.startLocalStats = function(stream, callback) {
+Statistics.startLocalStats = function(track, callback) {
+    if (browser.isIosBrowser()) {
+        // On iOS browsers audio is lost if the audio input device is in use by another app
+        // https://bugs.webkit.org/show_bug.cgi?id=233473
+        // The culprit was using the AudioContext, so now we close the AudioContext during
+        // the track being muted, and re-instantiate it afterwards.
+        track.addEventListener(
+        JitsiTrackEvents.NO_DATA_FROM_SOURCE,
+
+        /**
+         * Closes AudioContext on no audio data, and enables it on data received again.
+         *
+         * @param {boolean} value - Whether we receive audio data or not.
+         */
+        async value => {
+            if (value) {
+                for (const localStat of Statistics.localStats) {
+                    localStat.stop();
+                }
+
+                await LocalStats.disconnectAudioContext();
+            } else {
+                LocalStats.connectAudioContext();
+                for (const localStat of Statistics.localStats) {
+                    localStat.start();
+                }
+            }
+        });
+    }
+
     if (!Statistics.audioLevelsEnabled) {
         return;
     }
+
+    track.addEventListener(
+        JitsiTrackEvents.LOCAL_TRACK_STOPPED,
+        () => {
+            Statistics.stopLocalStats(track);
+        });
+
+    const stream = track.getOriginalStream();
     const localStats = new LocalStats(stream, Statistics.audioLevelsInterval,
         callback);
 
     }
 };
 
-Statistics.stopLocalStats = function(stream) {
+Statistics.stopLocalStats = function(track) {
     if (!Statistics.audioLevelsEnabled) {
         return;
     }
 
+    const stream = track.getOriginalStream();
+
     for (let i = 0; i < Statistics.localStats.length; i++) {
         if (Statistics.localStats[i].stream === stream) {
             const localStats = Statistics.localStats.splice(i, 1);

types/auto/modules/statistics/LocalStatsCollector.d.ts

     intervalMilis: any;
     audioLevel: number;
     callback: any;
+    source: MediaStreamAudioSourceNode;
+    analyser: AnalyserNode;
     /**
      * Starts the collecting the statistics.
      */
      * @returns {boolean}
      */
     function isLocalStatsSupported(): boolean;
+    /**
+     * Disconnects the audio context.
+     */
+    function disconnectAudioContext(): Promise<void>;
+    /**
+     * Connects the audio context.
+     */
+    function connectAudioContext(): void;
 }
 export default LocalStatsCollector;

types/auto/modules/statistics/statistics.d.ts

     export { analytics };
     export const instances: any;
     export const localStats: any[];
-    export function startLocalStats(stream: any, callback: any): void;
-    export function stopLocalStats(stream: any): void;
+    export function startLocalStats(track: any, callback: any): void;
+    export function stopLocalStats(track: any): void;
     /**
      * Obtains the list of *all* {@link CallStats} instances collected from every
      * valid {@link Statistics} instance.