@stream-io/video-client 1.53.0 → 1.53.1

package/dist/src/devices/MicrophoneManager.d.ts

@@ -71,5 +71,11 @@ export declare class MicrophoneManager extends AudioDeviceManager<MicrophoneMana
     private startSpeakingWhileMutedDetection;
     private stopSpeakingWhileMutedDetection;
     private teardownSpeakingWhileMutedDetection;
+    /**
+     * iOS-only: keep the mic-input chain prepared while muted
+     * so the `AVAudioEngine` stays full-duplex and remote audio renders on a
+     * muted join.
+     */
+    private setMutedRecordingPrepared;
     private hasPermission;
 }

package/dist/src/types.d.ts

@@ -387,6 +387,17 @@ export type StreamRNVideoSDKGlobals = {
          * Stops the in call manager.
          */
         stop({ isRingingTypeCall }: StreamRNVideoSDKCallManagerRingingParams): void;
+        /**
+         * iOS-only. Keeps the audio engine's microphone-input (voice-processing)
+         * chain prepared while the mic is muted, so the `AVAudioEngine` stays full-duplex
+         * meaning: mic going out and speaker coming in, simultaneously
+         *
+         * Without this, joining muted builds an output-only engine under the
+         * `PlayAndRecord`/`VoiceChat` (VPIO) session, which makes the remote audio
+         * not audible when joining muted. As echo cancellation expects the mic to be
+         * prepared.
+         */
+        setMutedRecordingPrepared?(enabled: boolean): void;
     };
     permissions: {
         /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "1.53.0",
+  "version": "1.53.1",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",
   "browser": "dist/index.browser.es.js",

package/src/devices/MicrophoneManager.ts

@@ -76,6 +76,7 @@ export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState
         ]) => {
           try {
             if (callingState === CallingState.LEFT) {
+              this.setMutedRecordingPrepared(false);
               await this.stopSpeakingWhileMutedDetection();
             }
             if (callingState !== CallingState.JOINED) return;
@@ -84,11 +85,14 @@ export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState
             if (ownCapabilities.includes(OwnCapability.SEND_AUDIO)) {
               const hasPermission = await this.hasPermission(permissionState);
               if (hasPermission && status !== 'enabled') {
+                this.setMutedRecordingPrepared(true);
                 await this.startSpeakingWhileMutedDetection(deviceId);
               } else {
+                this.setMutedRecordingPrepared(false);
                 await this.stopSpeakingWhileMutedDetection();
               }
             } else {
+              this.setMutedRecordingPrepared(false);
               await this.stopSpeakingWhileMutedDetection();
             }
           } catch (err) {
@@ -467,6 +471,18 @@ export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState
     });
   }
 
+  /**
+   * iOS-only: keep the mic-input chain prepared while muted
+   * so the `AVAudioEngine` stays full-duplex and remote audio renders on a
+   * muted join.
+   */
+  private setMutedRecordingPrepared(enabled: boolean): void {
+    if (!isReactNative()) return;
+    globalThis.streamRNVideoSDK?.callManager.setMutedRecordingPrepared?.(
+      enabled,
+    );
+  }
+
   private async hasPermission(
     permissionState: BrowserPermissionState,
   ): Promise<boolean> {

package/src/devices/__tests__/MicrophoneManagerRN.test.ts

@@ -2,7 +2,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { MicrophoneManager } from '../MicrophoneManager';
 import { Call } from '../../Call';
 import { StreamClient } from '../../coordinator/connection/client';
-import { StreamVideoWriteableStateStore } from '../../store';
+import { CallingState, StreamVideoWriteableStateStore } from '../../store';
 import {
   mockAudioDevices,
   mockAudioStream,
@@ -54,11 +54,13 @@ describe('MicrophoneManager React Native', () => {
   let manager: MicrophoneManager;
   let checkPermissionMock: ReturnType<typeof vi.fn>;
   let subscribeMock: ReturnType<typeof vi.fn>;
+  let setMutedRecordingPreparedMock: ReturnType<typeof vi.fn>;
 
   beforeEach(() => {
     speechActivityCallback = null;
     unsubscribeMocks = [];
     checkPermissionMock = vi.fn(async () => true);
+    setMutedRecordingPreparedMock = vi.fn();
     subscribeMock = vi.fn((cb) => {
       speechActivityCallback = cb;
       const unsub = vi.fn();
@@ -71,6 +73,7 @@ describe('MicrophoneManager React Native', () => {
         setup: vi.fn(),
         start: vi.fn(),
         stop: vi.fn(),
+        setMutedRecordingPrepared: setMutedRecordingPreparedMock,
       },
       permissions: {
         check: checkPermissionMock,
@@ -210,6 +213,76 @@ describe('MicrophoneManager React Native', () => {
     expect(fn).toHaveBeenCalled();
   });
 
+  it('should prepare muted recording when mic is disabled and user can send audio', async () => {
+    await manager.enable();
+    await manager.disable();
+
+    await vi.waitUntil(
+      () =>
+        setMutedRecordingPreparedMock.mock.calls.some(([arg]) => arg === true),
+      { timeout: 100 },
+    );
+    expect(setMutedRecordingPreparedMock).toHaveBeenCalledWith(true);
+  });
+
+  it('should release prepared muted recording when mic is enabled', async () => {
+    await manager.disable();
+    setMutedRecordingPreparedMock.mockClear();
+    await manager.enable();
+
+    await vi.waitUntil(
+      () =>
+        setMutedRecordingPreparedMock.mock.calls.some(([arg]) => arg === false),
+      { timeout: 100 },
+    );
+    expect(setMutedRecordingPreparedMock).toHaveBeenCalledWith(false);
+  });
+
+  it('should not prepare muted recording when user cannot send audio', async () => {
+    await manager.disable();
+    manager['call'].state.setOwnCapabilities([]);
+    setMutedRecordingPreparedMock.mockClear();
+    // toggle status to re-run the reactive subscription with no send-audio cap
+    await manager.enable();
+    await manager.disable();
+
+    await vi.waitUntil(
+      () => setMutedRecordingPreparedMock.mock.calls.length > 0,
+      { timeout: 100 },
+    );
+    expect(setMutedRecordingPreparedMock).not.toHaveBeenCalledWith(true);
+  });
+
+  it('should not prepare muted recording if native microphone permission is denied', async () => {
+    checkPermissionMock.mockResolvedValue(false);
+    await manager.enable();
+    await manager.disable();
+
+    await vi.waitUntil(() => checkPermissionMock.mock.calls.length > 0, {
+      timeout: 100,
+    });
+    expect(setMutedRecordingPreparedMock).not.toHaveBeenCalledWith(true);
+  });
+
+  it('should release prepared muted recording when the call is left', async () => {
+    await manager.disable();
+    await vi.waitUntil(
+      () =>
+        setMutedRecordingPreparedMock.mock.calls.some(([arg]) => arg === true),
+      { timeout: 100 },
+    );
+    setMutedRecordingPreparedMock.mockClear();
+
+    manager['call'].state.setCallingState(CallingState.LEFT);
+
+    await vi.waitUntil(
+      () =>
+        setMutedRecordingPreparedMock.mock.calls.some(([arg]) => arg === false),
+      { timeout: 100 },
+    );
+    expect(setMutedRecordingPreparedMock).toHaveBeenCalledWith(false);
+  });
+
   afterEach(() => {
     globalThis.streamRNVideoSDK = undefined;
     vi.clearAllMocks();

package/src/reporting/ClientEventReporter.ts

@@ -390,8 +390,13 @@ export class ClientEventReporter {
     const joinAttemptId = this.joinAttemptIds.get(cid);
     if (!joinAttemptId) return;
     const coordinatorConnectId = this.coordinatorConnectId;
+    const ctx = this.callContexts.get(cid);
+
     this.send({
       user_id: this.streamClient.userID,
+      type: ctx?.callType,
+      id: ctx?.callId,
+      call_cid: cid,
       stage: 'JoinInitiated',
       join_attempt_id: joinAttemptId,
       ...(coordinatorConnectId && {

package/src/types.ts

@@ -480,6 +480,18 @@ export type StreamRNVideoSDKGlobals = {
      * Stops the in call manager.
      */
     stop({ isRingingTypeCall }: StreamRNVideoSDKCallManagerRingingParams): void;
+
+    /**
+     * iOS-only. Keeps the audio engine's microphone-input (voice-processing)
+     * chain prepared while the mic is muted, so the `AVAudioEngine` stays full-duplex
+     * meaning: mic going out and speaker coming in, simultaneously
+     *
+     * Without this, joining muted builds an output-only engine under the
+     * `PlayAndRecord`/`VoiceChat` (VPIO) session, which makes the remote audio
+     * not audible when joining muted. As echo cancellation expects the mic to be
+     * prepared.
+     */
+    setMutedRecordingPrepared?(enabled: boolean): void;
   };
   permissions: {
     /**