@stream-io/video-client 0.4.10 → 0.5.1

package/dist/index.es.js

@@ -5832,6 +5832,15 @@ const createSignalClient = (options) => {
     return new SignalServerClient(transport);
 };
 
+/**
+ * Checks whether we are using React Native
+ */
+const isReactNative = () => {
+    if (typeof navigator === 'undefined')
+        return false;
+    return navigator.product?.toLowerCase() === 'reactnative';
+};
+
 // log levels, sorted by verbosity
 const logLevels = Object.freeze({
     trace: 0,
@@ -5849,6 +5858,11 @@ const logToConsole = (logLevel, message, ...args) => {
             logMethod = console.error;
             break;
         case 'warn':
+            if (isReactNative()) {
+                message = `WARN: ${message}`;
+                logMethod = console.info;
+                break;
+            }
             logMethod = console.warn;
             break;
         case 'info':
@@ -6035,15 +6049,6 @@ function getIceCandidate(candidate) {
     }
 }
 
-/**
- * Checks whether we are using React Native
- */
-const isReactNative = () => {
-    if (typeof navigator === 'undefined')
-        return false;
-    return navigator.product?.toLowerCase() === 'reactnative';
-};
-
 let sdkInfo;
 let osInfo;
 let deviceInfo;
@@ -9316,7 +9321,7 @@ const createStatsReporter = ({ subscriber, publisher, state, pollingIntervalInMs
 const transform = (report, opts) => {
     const { trackKind, kind } = opts;
     const direction = kind === 'subscriber' ? 'inbound-rtp' : 'outbound-rtp';
-    const stats = flatten(report);
+    const stats = flatten$1(report);
     const streams = stats
         .filter((stat) => stat.type === direction &&
         stat.kind === trackKind)
@@ -9411,7 +9416,7 @@ const aggregate = (stats) => {
  *
  * @param report the report to flatten.
  */
-const flatten = (report) => {
+const flatten$1 = (report) => {
     const stats = [];
     report.forEach((s) => {
         stats.push(s);
@@ -10753,7 +10758,7 @@ class MicrophoneManagerState extends InputMediaDeviceManagerState {
 }
 
 const DETECTION_FREQUENCY_IN_MS = 500;
-const AUDIO_LEVEL_THRESHOLD = 150;
+const AUDIO_LEVEL_THRESHOLD$1 = 150;
 const FFT_SIZE = 128;
 /**
  * Creates a new sound detector.
@@ -10764,7 +10769,7 @@ const FFT_SIZE = 128;
  * @returns a clean-up function which once invoked stops the sound detector.
  */
 const createSoundDetector = (audioStream, onSoundDetectedStateChanged, options = {}) => {
-    const { detectionFrequencyInMs = DETECTION_FREQUENCY_IN_MS, audioLevelThreshold = AUDIO_LEVEL_THRESHOLD, fftSize = FFT_SIZE, destroyStreamOnStop = true, } = options;
+    const { detectionFrequencyInMs = DETECTION_FREQUENCY_IN_MS, audioLevelThreshold = AUDIO_LEVEL_THRESHOLD$1, fftSize = FFT_SIZE, destroyStreamOnStop = true, } = options;
     const audioContext = new AudioContext();
     const analyser = audioContext.createAnalyser();
     analyser.fftSize = fftSize;
@@ -10803,6 +10808,99 @@ const createSoundDetector = (audioStream, onSoundDetectedStateChanged, options =
     };
 };
 
+/**
+ * Flatten the stats report into an array of stats objects.
+ *
+ * @param report the report to flatten.
+ */
+const flatten = (report) => {
+    const stats = [];
+    report.forEach((s) => {
+        stats.push(s);
+    });
+    return stats;
+};
+const AUDIO_LEVEL_THRESHOLD = 0.2;
+class RNSpeechDetector {
+    constructor() {
+        this.pc1 = new RTCPeerConnection({});
+        this.pc2 = new RTCPeerConnection({});
+    }
+    /**
+     * Starts the speech detection.
+     */
+    async start() {
+        try {
+            const audioStream = await navigator.mediaDevices.getUserMedia({
+                audio: true,
+            });
+            this.pc1.addEventListener('icecandidate', async (e) => {
+                await this.pc2.addIceCandidate(e.candidate);
+            });
+            this.pc2.addEventListener('icecandidate', async (e) => {
+                await this.pc1.addIceCandidate(e.candidate);
+            });
+            audioStream
+                .getTracks()
+                .forEach((track) => this.pc1.addTrack(track, audioStream));
+            const offer = await this.pc1.createOffer({});
+            await this.pc2.setRemoteDescription(offer);
+            await this.pc1.setLocalDescription(offer);
+            const answer = await this.pc2.createAnswer();
+            await this.pc1.setRemoteDescription(answer);
+            await this.pc2.setLocalDescription(answer);
+            const audioTracks = audioStream.getAudioTracks();
+            // We need to mute the audio track for this temporary stream, or else you will hear yourself twice while in the call.
+            audioTracks.forEach((track) => (track.enabled = false));
+        }
+        catch (error) {
+            console.error('Error connecting and negotiating between PeerConnections:', error);
+        }
+    }
+    /**
+     * Stops the speech detection and releases all allocated resources.
+     */
+    stop() {
+        this.pc1.close();
+        this.pc2.close();
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+        }
+    }
+    /**
+     * Public method that detects the audio levels and returns the status.
+     */
+    onSpeakingDetectedStateChange(onSoundDetectedStateChanged) {
+        this.intervalId = setInterval(async () => {
+            const stats = (await this.pc1.getStats());
+            const report = flatten(stats);
+            // Audio levels are present inside stats of type `media-source` and of kind `audio`
+            const audioMediaSourceStats = report.find((stat) => stat.type === 'media-source' &&
+                stat.kind === 'audio');
+            if (audioMediaSourceStats) {
+                const { audioLevel } = audioMediaSourceStats;
+                if (audioLevel) {
+                    if (audioLevel >= AUDIO_LEVEL_THRESHOLD) {
+                        onSoundDetectedStateChanged({
+                            isSoundDetected: true,
+                            audioLevel,
+                        });
+                    }
+                    else {
+                        onSoundDetectedStateChanged({
+                            isSoundDetected: false,
+                            audioLevel: 0,
+                        });
+                    }
+                }
+            }
+        }, 1000);
+        return () => {
+            clearInterval(this.intervalId);
+        };
+    }
+}
+
 class MicrophoneManager extends InputMediaDeviceManager {
     constructor(call) {
         super(call, new MicrophoneManagerState(), TrackType.AUDIO);
@@ -10844,20 +10942,31 @@ class MicrophoneManager extends InputMediaDeviceManager {
         return this.call.stopPublish(TrackType.AUDIO, stopTracks);
     }
     async startSpeakingWhileMutedDetection(deviceId) {
+        await this.stopSpeakingWhileMutedDetection();
         if (isReactNative()) {
-            return;
+            this.rnSpeechDetector = new RNSpeechDetector();
+            await this.rnSpeechDetector.start();
+            const unsubscribe = this.rnSpeechDetector?.onSpeakingDetectedStateChange((event) => {
+                this.state.setSpeakingWhileMuted(event.isSoundDetected);
+            });
+            this.soundDetectorCleanup = () => {
+                unsubscribe();
+                this.rnSpeechDetector?.stop();
+                this.rnSpeechDetector = undefined;
+            };
+        }
+        else {
+            // Need to start a new stream that's not connected to publisher
+            const stream = await this.getStream({
+                deviceId,
+            });
+            this.soundDetectorCleanup = createSoundDetector(stream, (event) => {
+                this.state.setSpeakingWhileMuted(event.isSoundDetected);
+            });
         }
-        await this.stopSpeakingWhileMutedDetection();
-        // Need to start a new stream that's not connected to publisher
-        const stream = await this.getStream({
-            deviceId,
-        });
-        this.soundDetectorCleanup = createSoundDetector(stream, (event) => {
-            this.state.setSpeakingWhileMuted(event.isSoundDetected);
-        });
     }
     async stopSpeakingWhileMutedDetection() {
-        if (isReactNative() || !this.soundDetectorCleanup) {
+        if (!this.soundDetectorCleanup) {
             return;
         }
         this.state.setSpeakingWhileMuted(false);
@@ -14036,7 +14145,7 @@ class StreamClient {
             });
         };
         this.getUserAgent = () => {
-            const version = "0.4.10" ;
+            const version = "0.5.1" ;
             return (this.userAgent ||
                 `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${version}`);
         };