@stream-io/video-client 1.57.0 → 1.59.0

package/src/StreamVideoClient.ts

@@ -39,7 +39,6 @@ import {
   getInstanceKey,
 } from './helpers/clientUtils';
 import { logToConsole, ScopedLogger, videoLoggerSystem } from './logger';
-import { isReactNative } from './helpers/platforms';
 import { withoutConcurrency } from './helpers/concurrency';
 import { enableTimerWorker } from './timers';
 import { ClientEventReporter } from './reporting';
@@ -211,6 +210,7 @@ export class StreamVideoClient {
               await call.reject('busy');
             } else {
               await call.updateFromRingingEvent(e as CallRingEvent);
+              await call.get();
             }
           } else {
             call.state.updateFromCallResponse(e.call);
@@ -248,6 +248,17 @@ export class StreamVideoClient {
     }
   };
 
+  /**
+   * Queries the API for calls matching the given filters.
+   * @param data the query data.
+   */
+  private doQueryCalls = (data: QueryCallsRequest) => {
+    return this.streamClient.post<QueryCallsResponse, QueryCallsRequest>(
+      '/calls',
+      data,
+    );
+  };
+
   /**
    * Rewatches the given calls with retry logic.
    * @param callsToReWatch array of call IDs to rewatch
@@ -261,11 +272,22 @@ export class StreamVideoClient {
           `Rewatching calls ${callsToReWatch.join(', ')} attempt ${attempt + 1}`,
         );
 
-        await this.queryCalls({
+        const response = await this.doQueryCalls({
           watch: true,
           filter_conditions: { cid: { $in: callsToReWatch } },
         });
 
+        for (const c of response.calls) {
+          const call = this.writeableStateStore.findCall(
+            c.call.type,
+            c.call.id,
+          );
+
+          if (call) {
+            call.updateFromCallStateResponse(c);
+          }
+        }
+
         return;
       } catch (err) {
         if (err instanceof ErrorFromResponse && err.unrecoverable) {
@@ -452,12 +474,14 @@ export class StreamVideoClient {
    * Will query the API for calls matching the given filters.
    *
    * @param data the query data.
+   * @param opts additional options, for tweaking the API behavior.
    */
-  queryCalls = async (data: QueryCallsRequest = {}) => {
-    const response = await this.streamClient.post<
-      QueryCallsResponse,
-      QueryCallsRequest
-    >('/calls', data);
+  queryCalls = async (
+    data: QueryCallsRequest = {},
+    opts: { withDisabledDevices?: boolean } = {},
+  ) => {
+    const { withDisabledDevices = true } = opts;
+    const response = await this.doQueryCalls(data);
     const calls = [];
     for (const c of response.calls) {
       const call = new Call({
@@ -471,7 +495,10 @@ export class StreamVideoClient {
         clientStore: this.writeableStateStore,
       });
       call.state.updateFromCallResponse(c.call);
-      await call.applyDeviceConfig(c.call.settings, false, isReactNative());
+      await call.applyDeviceConfig(c.call.settings, {
+        publish: false,
+        withDisabledDevices,
+      });
       if (data.watch) {
         await call.setup();
         this.writeableStateStore.registerCall(call);

package/src/__tests__/Call.lifecycle.test.ts

@@ -4,27 +4,38 @@
 
 import '../rtc/__tests__/mocks/webrtc.mocks';
 
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { Call } from '../Call';
 import { StreamClient } from '../coordinator/connection/client';
 import { ClientEventReporter } from '../reporting';
 import { generateUUIDv4 } from '../coordinator/connection/utils';
 import { StreamVideoWriteableStateStore } from '../store';
+import { promiseWithResolvers } from '../helpers/promise';
 
 describe('Call lifecycle wiring', () => {
   let call: Call;
 
   beforeEach(() => {
+    vi.spyOn(globalThis, 'fetch').mockResolvedValue({
+      headers: { get: () => 'AMS1-P2' },
+    } as Response);
     const streamClient = new StreamClient('abc');
     call = new Call({
       type: 'test',
       id: generateUUIDv4(),
       streamClient,
-      clientEventReporter: new ClientEventReporter({ streamClient }),
+      clientEventReporter: new ClientEventReporter({
+        streamClient,
+        enabled: false,
+      }),
       clientStore: new StreamVideoWriteableStateStore(),
     });
   });
 
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
   // Regression guard for the Call-owned helper teardown chain. Each of
   // these helpers holds a resource (timer, listener, AudioContext) that
   // leaks across calls if teardown is dropped during a refactor.
@@ -67,4 +78,24 @@ describe('Call lifecycle wiring', () => {
     expect(trackSubOrder).toBeLessThan(audioBindingsOrder);
     expect(audioBindingsOrder).toBeLessThan(dynascaleOrder);
   });
+
+  it('call.join() shares an in-flight join flow', async () => {
+    const joinTask = promiseWithResolvers<void>();
+    vi.spyOn(call, 'setup').mockResolvedValue(undefined);
+    const doJoin = vi
+      .spyOn(call as unknown as { doJoin: Call['join'] }, 'doJoin')
+      .mockReturnValue(joinTask.promise);
+
+    const firstJoin = call.join();
+    const secondJoin = call.join();
+
+    await Promise.resolve();
+    expect(doJoin).toHaveBeenCalledTimes(1);
+
+    joinTask.resolve();
+    await expect(Promise.all([firstJoin, secondJoin])).resolves.toEqual([
+      undefined,
+      undefined,
+    ]);
+  });
 });

package/src/__tests__/Call.publishing.test.ts

@@ -2,7 +2,7 @@ import '../rtc/__tests__/mocks/webrtc.mocks';
 
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { Call } from '../Call';
-import { Publisher } from '../rtc';
+import { Publisher, Subscriber } from '../rtc';
 import { StreamClient } from '../coordinator/connection/client';
 import { ClientEventReporter } from '../reporting';
 import { generateUUIDv4 } from '../coordinator/connection/utils';
@@ -183,6 +183,47 @@ describe('Publishing and Unpublishing tracks', () => {
       expect(participant!.audioStream).toEqual(mediaStream);
     });
 
+    it('keeps a stream the SFU already echoed back instead of the capture one', async () => {
+      // `allowOwnTracksLoopback`: the echo can land on the participant before
+      // publishing gets to write the capture stream to the same field.
+      const echoedStream = new MediaStream();
+      call.subscriber = {
+        isSelfSubscribedStream: (stream: MediaStream | undefined) =>
+          stream === echoedStream,
+      } as unknown as Subscriber;
+      call.state.updateParticipant(sessionId, { audioStream: echoedStream });
+
+      const track = new MediaStreamTrack();
+      const captureStream = new MediaStream();
+      vi.spyOn(captureStream, 'getAudioTracks').mockReturnValue([track]);
+
+      await call.publish(captureStream, TrackType.AUDIO);
+
+      const participant = call.state.findParticipantBySessionId(sessionId);
+      expect(participant!.publishedTracks).toEqual([TrackType.AUDIO]);
+      expect(participant!.audioStream).toBe(echoedStream);
+    });
+
+    it('keeps an echoed stream when the track is unpublished', async () => {
+      // a device switch unpublishes and republishes; the echoed track goes
+      // briefly silent but is never replaced, so the reference has to survive
+      const echoedStream = new MediaStream();
+      call.subscriber = {
+        isSelfSubscribedStream: (stream: MediaStream | undefined) =>
+          stream === echoedStream,
+      } as unknown as Subscriber;
+      call.state.updateParticipant(sessionId, {
+        audioStream: echoedStream,
+        publishedTracks: [TrackType.AUDIO],
+      });
+
+      await call.stopPublish(TrackType.AUDIO);
+
+      const participant = call.state.findParticipantBySessionId(sessionId);
+      expect(participant!.publishedTracks).toEqual([]);
+      expect(participant!.audioStream).toBe(echoedStream);
+    });
+
     it('publish screen share stream', async () => {
       const track = new MediaStreamTrack();
       const mediaStream = new MediaStream();

package/src/__tests__/Call.test.ts

@@ -17,6 +17,7 @@ import { Dispatcher } from '../rtc';
 import { Call } from '../Call';
 import { StreamVideoParticipant } from '../types';
 import { TrackType } from '../gen/video/sfu/models/models';
+import type { E2EEManager } from '../rtc/e2ee/E2EEManager';
 
 const apiKey = process.env.STREAM_API_KEY!;
 const secret = process.env.STREAM_SECRET!;
@@ -300,6 +301,20 @@ describe('muting logic', () => {
   });
 });
 
+describe('setE2EEManager', () => {
+  it('throws when called after the peer connections exist', () => {
+    const call = client.call('default', generateUUIDv4());
+    const e2ee = fromPartial<E2EEManager>({});
+    // Before join there are no peer connections, so it is accepted.
+    expect(() => call.setE2EEManager(e2ee)).not.toThrow();
+    // Once a subscriber/publisher exists (i.e. after join) the PCs were already
+    // built without the manager; setting it now would leave the live session
+    // half-encrypted, so it must be rejected (finding 12).
+    call['subscriber'] = fromPartial({});
+    expect(() => call.setE2EEManager(e2ee)).toThrow(/before join/);
+  });
+});
+
 describe('client event reporting', () => {
   afterEach(() => {
     vi.restoreAllMocks();

package/src/__tests__/StreamVideoClient.api.test.ts

@@ -9,6 +9,8 @@ import {
 } from 'vitest';
 import { StreamVideoClient } from '../StreamVideoClient';
 import { Call } from '../Call';
+import { CameraManager } from '../devices/CameraManager';
+import { MicrophoneManager } from '../devices/MicrophoneManager';
 import { CallCreatedPayload } from './data';
 import { generateUUIDv4 } from '../coordinator/connection/utils';
 import type { StreamClient } from '../coordinator/connection/client';
@@ -73,6 +75,37 @@ describe('StreamVideoClient - coordinator API', () => {
     expect(call.cid).toBe(CallCreatedPayload.call.cid);
   });
 
+  it('query calls keeps devices disabled by default', async () => {
+    const response: QueryCallsResponse = {
+      duration: '1ms',
+      calls: [
+        {
+          call: CallCreatedPayload.call,
+          members: CallCreatedPayload.members,
+          own_capabilities: [],
+        },
+      ],
+    };
+    post.mockResolvedValue(response);
+    const applyCamera = vi
+      .spyOn(CameraManager.prototype, 'apply')
+      .mockResolvedValue();
+    const applyMicrophone = vi
+      .spyOn(MicrophoneManager.prototype, 'apply')
+      .mockResolvedValue();
+
+    await client.queryCalls();
+    await client.queryCalls({}, {});
+    await client.queryCalls({}, { withDisabledDevices: false });
+
+    expect(
+      applyCamera.mock.calls.map(([, , forceDisabled]) => forceDisabled),
+    ).toEqual([true, true, false]);
+    expect(
+      applyMicrophone.mock.calls.map(([, , forceDisabled]) => forceDisabled),
+    ).toEqual([true, true, false]);
+  });
+
   it('query calls - ongoing', async () => {
     post.mockResolvedValue({ duration: '1ms', calls: [] });
 

package/src/__tests__/StreamVideoClient.rewatch.test.ts

@@ -0,0 +1,213 @@
+import '../rtc/__tests__/mocks/webrtc.mocks';
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { StreamVideoClient } from '../StreamVideoClient';
+import { Call } from '../Call';
+import { CallRingPayload } from './data';
+import { settled, withoutConcurrency } from '../helpers/concurrency';
+import { getCallInitConcurrencyTag } from '../helpers/clientUtils';
+import { CallingState } from '../store';
+import type { StreamVideoEvent } from '../coordinator/connection/types';
+import type {
+  CallResponse,
+  ConnectedEvent,
+  GetCallResponse,
+  QueryCallsResponse,
+} from '../gen/coordinator';
+
+const apiKey = 'mock-api-key';
+// the receiver of the CallRingPayload fixture
+const userId = 'marcelo';
+
+const queryCallsResponse = (call: CallResponse): QueryCallsResponse => ({
+  duration: '1ms',
+  calls: [{ call, members: CallRingPayload.members, own_capabilities: [] }],
+});
+
+const countListeners = (client: StreamVideoClient) =>
+  Object.values(client.streamClient.listeners).reduce(
+    (count, listeners) => count + (listeners?.length ?? 0),
+    0,
+  );
+
+describe('StreamVideoClient re-watching calls on reconnect', () => {
+  let client: StreamVideoClient;
+
+  beforeEach(async () => {
+    client = new StreamVideoClient(apiKey, {
+      // tests run in node, so we have to fake being in browser env
+      browser: true,
+    });
+    client.streamClient.connectUser = vi.fn().mockResolvedValue({
+      me: { id: userId },
+    } as ConnectedEvent);
+    await client.connectUser({ id: userId }, 'mock-token');
+  });
+
+  afterEach(() => {
+    for (const call of client.state.calls) {
+      call['cancelAutoDrop']();
+    }
+    vi.restoreAllMocks();
+  });
+
+  const setupRingingCall = async () => {
+    vi.spyOn(client.streamClient, 'get').mockResolvedValue({
+      duration: '1ms',
+      call: CallRingPayload.call,
+      members: CallRingPayload.members,
+      own_capabilities: [],
+    } as GetCallResponse);
+
+    client.streamClient.dispatchEvent(CallRingPayload as StreamVideoEvent);
+    await settled(getCallInitConcurrencyTag(CallRingPayload.call_cid));
+
+    const [call] = client.state.calls;
+    expect(call).toBeDefined();
+    expect(call.watching).toBe(true);
+    expect(call.state.callingState).toBe(CallingState.RINGING);
+    return call;
+  };
+
+  const reconnect = () => {
+    client.streamClient.dispatchEvent({
+      type: 'connection.changed',
+      online: true,
+    });
+  };
+
+  it('reuses the registered instance and refreshes its state', async () => {
+    const call = await setupRingingCall();
+    const listenerCountBeforeReconnect = countListeners(client);
+
+    const post = vi
+      .spyOn(client.streamClient, 'post')
+      .mockResolvedValue(
+        queryCallsResponse({ ...CallRingPayload.call, recording: true }),
+      );
+
+    reconnect();
+
+    await vi.waitFor(() => expect(post).toHaveBeenCalled());
+    expect(post).toHaveBeenCalledWith('/calls', {
+      watch: true,
+      filter_conditions: { cid: { $in: [call.cid] } },
+    });
+
+    // the refreshed state must reach the instance the integrator holds
+    await vi.waitFor(() => expect(call.state.recording).toBe(true));
+    expect(client.state.calls).toHaveLength(1);
+    expect(client.state.calls[0]).toBe(call);
+    expect(call.watching).toBe(true);
+
+    // re-watching must not leak event handlers (one orphaned Call
+    // used to register its handlers on every reconnect)
+    expect(countListeners(client)).toBe(listenerCountBeforeReconnect);
+  });
+
+  it('drops a ringing call accepted elsewhere while the socket was down', async () => {
+    const call = await setupRingingCall();
+    const leave = vi.spyOn(call, 'leave').mockResolvedValue(undefined);
+
+    const session = CallRingPayload.call.session!;
+    vi.spyOn(client.streamClient, 'post').mockResolvedValue(
+      queryCallsResponse({
+        ...CallRingPayload.call,
+        session: {
+          ...session,
+          accepted_by: { [userId]: '2025-08-14T14:49:00Z' },
+        },
+      }),
+    );
+
+    reconnect();
+
+    // accepted on another device -> this device should stop ringing
+    await vi.waitFor(() => expect(leave).toHaveBeenCalled());
+  });
+
+  it('queryCalls returns an independent instance for registered calls', async () => {
+    // e.g. being on a call while watching a dashboard of calls:
+    // leaving the joined instance must not silence the dashboard instance
+    const joinedCall = await setupRingingCall();
+    vi.spyOn(client.streamClient, 'post').mockResolvedValue(
+      queryCallsResponse(CallRingPayload.call),
+    );
+
+    const result = await client.queryCalls({ watch: true });
+    const [dashboardCall] = result.calls;
+    expect(dashboardCall).not.toBe(joinedCall);
+    expect(client.state.calls[0]).toBe(joinedCall);
+
+    await joinedCall.leave({ reject: false });
+
+    client.streamClient.dispatchEvent({
+      type: 'call.updated',
+      call_cid: joinedCall.cid,
+      created_at: '2025-08-14T14:50:00Z',
+      call: { ...CallRingPayload.call, recording: true },
+    } as StreamVideoEvent);
+
+    await vi.waitFor(() => expect(dashboardCall.state.recording).toBe(true));
+  });
+
+  it('creates and registers a new instance for unknown cids', async () => {
+    vi.spyOn(client.streamClient, 'post').mockResolvedValue(
+      queryCallsResponse(CallRingPayload.call),
+    );
+
+    const result = await client.queryCalls({ watch: true });
+
+    expect(result.calls).toHaveLength(1);
+    const [call] = result.calls;
+    expect(call).toBeInstanceOf(Call);
+    expect(call.watching).toBe(true);
+    expect(client.state.calls[0]).toBe(call);
+  });
+
+  it('does not resurrect a call that leaves during a re-watch', async () => {
+    const listenersBeforeRing = countListeners(client);
+    const call = await setupRingingCall();
+    const post = vi
+      .spyOn(client.streamClient, 'post')
+      .mockResolvedValue(queryCallsResponse(CallRingPayload.call));
+
+    // hold the call's join/leave queue so leave() is still in flight
+    // while the re-watch response is being processed
+    let releaseGate!: () => void;
+    const gate = new Promise<void>((resolve) => (releaseGate = resolve));
+    withoutConcurrency(call['joinLeaveConcurrencyTag'], () => gate);
+    const leavePromise = call.leave({ reject: false });
+
+    reconnect();
+    await vi.waitFor(() => expect(post).toHaveBeenCalled());
+    await Promise.resolve();
+
+    releaseGate();
+    await leavePromise;
+
+    // the left call must stay dead: not re-registered, not re-initialized,
+    // and all of its event handlers released
+    expect(client.state.calls).toHaveLength(0);
+    expect(call.state.callingState).toBe(CallingState.LEFT);
+    expect(countListeners(client)).toBe(listenersBeforeRing);
+  });
+
+  it('creates a fresh instance when the previous one has left', async () => {
+    const call = await setupRingingCall();
+    const post = vi
+      .spyOn(client.streamClient, 'post')
+      .mockResolvedValue(queryCallsResponse(CallRingPayload.call));
+
+    // leaving unregisters the call from the client store
+    await call.leave({ reject: false });
+    expect(client.state.calls).toHaveLength(0);
+
+    const result = await client.queryCalls({ watch: true });
+    expect(post).toHaveBeenCalled();
+    expect(result.calls).toHaveLength(1);
+    expect(result.calls[0]).not.toBe(call);
+    expect(client.state.calls[0]).toBe(result.calls[0]);
+    expect(result.calls[0].watching).toBe(true);
+  });
+});

package/src/__tests__/StreamVideoClient.ringing.test.ts

@@ -45,12 +45,21 @@ describe('StreamVideoClient Ringing', () => {
     ]);
   };
 
+  const leaveAllCalls = async () => {
+    await Promise.all(
+      [oliverClient, sachaClient, marceloClient].flatMap((client) =>
+        client.state.calls.map((call) => call.leave().catch(() => {})),
+      ),
+    );
+  };
+
   beforeEach(async () => {
     [oliverClient, sachaClient, marceloClient] =
       await createClients(testUserIds);
   });
 
   afterEach(async () => {
+    await leaveAllCalls();
     await disconnectClients();
   });
 
@@ -275,6 +284,7 @@ describe('StreamVideoClient Ringing', () => {
     };
 
     it('should reject the call when the caller is busy', async () => {
+      await disconnectClients();
       [oliverClient, sachaClient, marceloClient] = await createClients(
         testUserIds,
         {
@@ -301,11 +311,10 @@ describe('StreamVideoClient Ringing', () => {
         marceloCall.cid,
       );
       expect(oliverClient.state.calls.length).toBe(1);
-
-      await disconnectClients();
     });
 
     it('should reject the call when the callee is busy', async () => {
+      await disconnectClients();
       [oliverClient, sachaClient, marceloClient] = await createClients(
         testUserIds,
         {
@@ -332,8 +341,6 @@ describe('StreamVideoClient Ringing', () => {
         marceloCall.cid,
       );
       expect(sachaClient.state.calls.length).toBe(1);
-
-      await disconnectClients();
     });
 
     it('should allow multiple simultaneous calls to the same caller when rejectCallWhenBusy is false', async () => {

package/src/__tests__/StreamVideoClient.test.ts

@@ -277,7 +277,7 @@ describe('StreamVideoClient.connectUser retries', () => {
 });
 
 describe('StreamVideoClient.watchCalls retries', () => {
-  it('should retry queryCalls up to 3 times after reconnecting', async () => {
+  it('should retry the re-watch request up to 3 times after reconnecting', async () => {
     vi.useFakeTimers();
     const client = new StreamVideoClient(apiKey, {
       browser: true,
@@ -290,8 +290,8 @@ describe('StreamVideoClient.watchCalls retries', () => {
     const call = client.call('default', generateUUIDv4());
     await call.getOrCreate();
 
-    const queryCallsSpy = vi
-      .spyOn(client, 'queryCalls')
+    const doQueryCalls = vi
+      .spyOn(client as any, 'doQueryCalls')
       .mockRejectedValueOnce(new Error('fail 1'))
       .mockRejectedValueOnce(new Error('fail 2'))
       .mockResolvedValue({
@@ -306,7 +306,7 @@ describe('StreamVideoClient.watchCalls retries', () => {
 
     await vi.runAllTimersAsync();
 
-    expect(queryCallsSpy).toHaveBeenCalledTimes(3);
+    expect(doQueryCalls).toHaveBeenCalledTimes(3);
 
     await client.disconnectUser();
 
@@ -327,8 +327,8 @@ describe('StreamVideoClient.watchCalls retries', () => {
     const call = client.call('default', generateUUIDv4());
     await call.getOrCreate();
 
-    const queryCallsSpy = vi
-      .spyOn(client, 'queryCalls')
+    const doQueryCalls = vi
+      .spyOn(client as any, 'doQueryCalls')
       .mockRejectedValueOnce(new Error('fail 1'))
       .mockRejectedValueOnce(new Error('fail 2'))
       .mockRejectedValueOnce(new Error('fail 3'))
@@ -344,7 +344,7 @@ describe('StreamVideoClient.watchCalls retries', () => {
 
     await vi.runAllTimersAsync();
 
-    expect(queryCallsSpy).toHaveBeenCalledTimes(3);
+    expect(doQueryCalls).toHaveBeenCalledTimes(3);
 
     await client.disconnectUser();
     vi.useRealTimers();
@@ -363,10 +363,12 @@ describe('StreamVideoClient.watchCalls retries', () => {
     const call = client.call('default', generateUUIDv4());
     await call.getOrCreate();
 
-    const queryCallsSpy = vi.spyOn(client, 'queryCalls').mockResolvedValue({
-      calls: [],
-      duration: '0ms',
-    });
+    const doQueryCalls = vi
+      .spyOn(client as any, 'doQueryCalls')
+      .mockResolvedValue({
+        calls: [],
+        duration: '0ms',
+      });
 
     client.streamClient.dispatchEvent({
       type: 'connection.changed',
@@ -375,7 +377,7 @@ describe('StreamVideoClient.watchCalls retries', () => {
 
     await vi.runAllTimersAsync();
 
-    expect(queryCallsSpy).toHaveBeenCalledTimes(1);
+    expect(doQueryCalls).toHaveBeenCalledTimes(1);
 
     await client.disconnectUser();
     vi.useRealTimers();

package/src/coordinator/connection/connection.ts

@@ -9,10 +9,11 @@ import {
 } from './utils';
 import type { StreamVideoEvent, UR, WSConnectionError } from './types';
 import type { LogLevel } from '@stream-io/logger';
-import type {
+import {
   ConnectedEvent,
   ConnectionErrorEvent,
   WSAuthMessage,
+  WSAuthMessageProductsEnum,
 } from '../../gen/coordinator';
 import { makeSafePromise, type SafePromise } from '../../helpers/promise';
 import { getTimers } from '../../timers';
@@ -529,15 +530,17 @@ export class StableWSConnection {
       return;
     }
 
-    const authMessage = JSON.stringify({
+    const wsAuthMessage: WSAuthMessage = {
       token,
+      products: [WSAuthMessageProductsEnum.VIDEO],
       user_details: {
         id: user.id,
         name: user.name,
         image: user.image,
         custom: user.custom,
       },
-    } as WSAuthMessage);
+    };
+    const authMessage = JSON.stringify(wsAuthMessage);
 
     this._log(`onopen() - Sending auth message ${authMessage}`, {}, 'trace');
 

package/src/devices/AudioDeviceManager.ts

@@ -2,6 +2,7 @@ import { DeviceManager } from './DeviceManager';
 import { AudioDeviceManagerState } from './AudioDeviceManagerState';
 import { AudioBitrateProfile } from '../gen/video/sfu/models/models';
 import { TrackPublishOptions } from '../rtc';
+import { isReactNative } from '../helpers/platforms';
 
 /**
  * Base class for High Fidelity enabled Device Managers.
@@ -17,6 +18,11 @@ export abstract class AudioDeviceManager<
     if (!this.call.state.settings?.audio.hifi_audio_enabled) {
       throw new Error('High Fidelity audio is not enabled for this call');
     }
+    if (isReactNative() && this.call.hasMediaEngine) {
+      throw new Error(
+        'setAudioBitrateProfile must be called before joining the call.',
+      );
+    }
     this.doSetAudioBitrateProfile(profile);
     this.state.setAudioBitrateProfile(profile);
     if (this.enabled) {