@stream-io/video-client 1.58.0 → 2.0.0-beta.0

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

@@ -17,7 +17,14 @@ const secret = process.env.STREAM_SECRET!;
 
 describe('StreamVideoClient Ringing', () => {
   const serverClient = new StreamClient(apiKey, secret);
-  const testUserIds = ['oliver', 'sacha', 'marcelo'];
+
+  // user ids are generated per test: CI runs share a single Stream app, so
+  // fixed ids let a concurrently running job ring these users and satisfy the
+  // assertions in this file with an unrelated call.
+  let oliverId: string;
+  let sachaId: string;
+  let marceloId: string;
+  let testUserIds: string[];
 
   let oliverClient: StreamVideoClient;
   let sachaClient: StreamVideoClient;
@@ -45,12 +52,26 @@ describe('StreamVideoClient Ringing', () => {
     ]);
   };
 
+  const leaveAllCalls = async () => {
+    await Promise.all(
+      [oliverClient, sachaClient, marceloClient].flatMap((client) =>
+        client.state.calls.map((call) => call.leave().catch(() => {})),
+      ),
+    );
+  };
+
   beforeEach(async () => {
+    const suffix = crypto.randomUUID();
+    oliverId = `oliver-${suffix}`;
+    sachaId = `sacha-${suffix}`;
+    marceloId = `marcelo-${suffix}`;
+    testUserIds = [oliverId, sachaId, marceloId];
     [oliverClient, sachaClient, marceloClient] =
       await createClients(testUserIds);
   });
 
   afterEach(async () => {
+    await leaveAllCalls();
     await disconnectClients();
   });
 
@@ -66,11 +87,11 @@ describe('StreamVideoClient Ringing', () => {
       await call.create({
         ring: true,
         data: {
-          created_by_id: 'oliver',
+          created_by_id: oliverId,
           members: [
-            { user_id: 'oliver' },
-            { user_id: 'sacha' },
-            { user_id: 'marcelo' },
+            { user_id: oliverId },
+            { user_id: sachaId },
+            { user_id: marceloId },
           ],
         },
       });
@@ -103,9 +124,9 @@ describe('StreamVideoClient Ringing', () => {
         ring: true,
         data: {
           members: [
-            { user_id: 'oliver' },
-            { user_id: 'sacha' },
-            { user_id: 'marcelo' },
+            { user_id: oliverId },
+            { user_id: sachaId },
+            { user_id: marceloId },
           ],
         },
       });
@@ -135,9 +156,9 @@ describe('StreamVideoClient Ringing', () => {
         ring: false, // don't ring all members by default
         data: {
           members: [
-            { user_id: 'oliver' },
-            { user_id: 'sacha' },
-            { user_id: 'marcelo' },
+            { user_id: oliverId },
+            { user_id: sachaId },
+            { user_id: marceloId },
           ],
         },
       });
@@ -153,7 +174,7 @@ describe('StreamVideoClient Ringing', () => {
       // oliver is calling sacha. only sacha should get a ring event
       const sachaIndividualRing = expectEvent(sachaClient, 'call.ring');
       const marceloIndividualRing = expectEvent(marceloClient, 'call.ring');
-      await oliverCall.ring({ members_ids: ['sacha'] });
+      await oliverCall.ring({ members_ids: [sachaId] });
       await expect(sachaIndividualRing).resolves.toHaveProperty(
         'call.cid',
         oliverCall.cid,
@@ -166,7 +187,7 @@ describe('StreamVideoClient Ringing', () => {
       // sacha is calling marcelo. only marcelo should get a ring event
       const oliverIndividualRing = expectEvent(oliverClient, 'call.ring');
       const marceloIndividualRing2 = expectEvent(marceloClient, 'call.ring');
-      await sachaCall.ring({ members_ids: ['marcelo'] });
+      await sachaCall.ring({ members_ids: [marceloId] });
       await expect(marceloIndividualRing2).resolves.toHaveProperty(
         'call.cid',
         sachaCall.cid,
@@ -232,8 +253,8 @@ describe('StreamVideoClient Ringing', () => {
       const serverCall = serverClient.video.call('default', callId);
       await serverCall.create({
         data: {
-          created_by_id: 'oliver',
-          members: [{ user_id: 'oliver' }, { user_id: 'sacha' }],
+          created_by_id: oliverId,
+          members: [{ user_id: oliverId }, { user_id: sachaId }],
         },
       });
 
@@ -257,7 +278,7 @@ describe('StreamVideoClient Ringing', () => {
       await oliverCall.create({
         ring: true,
         data: {
-          members: [{ user_id: 'oliver' }, { user_id: 'sacha' }],
+          members: [{ user_id: oliverId }, { user_id: sachaId }],
         },
       });
 
@@ -275,6 +296,7 @@ describe('StreamVideoClient Ringing', () => {
     };
 
     it('should reject the call when the caller is busy', async () => {
+      await disconnectClients();
       [oliverClient, sachaClient, marceloClient] = await createClients(
         testUserIds,
         {
@@ -292,7 +314,7 @@ describe('StreamVideoClient Ringing', () => {
       await marceloCall.create({
         ring: true,
         data: {
-          members: [{ user_id: 'marcelo' }, { user_id: 'oliver' }],
+          members: [{ user_id: marceloId }, { user_id: oliverId }],
         },
       });
 
@@ -301,11 +323,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,
         {
@@ -323,7 +344,7 @@ describe('StreamVideoClient Ringing', () => {
       await marceloCall.create({
         ring: true,
         data: {
-          members: [{ user_id: 'marcelo' }, { user_id: 'sacha' }],
+          members: [{ user_id: marceloId }, { user_id: sachaId }],
         },
       });
 
@@ -332,8 +353,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 () => {
@@ -347,7 +366,7 @@ describe('StreamVideoClient Ringing', () => {
       await marceloCall.create({
         ring: true,
         data: {
-          members: [{ user_id: 'marcelo' }, { user_id: 'oliver' }],
+          members: [{ user_id: marceloId }, { user_id: oliverId }],
         },
       });
 
@@ -368,7 +387,7 @@ describe('StreamVideoClient Ringing', () => {
       await marceloCall.create({
         ring: true,
         data: {
-          members: [{ user_id: 'marcelo' }, { user_id: 'sacha' }],
+          members: [{ user_id: marceloId }, { user_id: sachaId }],
         },
       });
 

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/__tests__/eventListenerIsolation.test.ts

@@ -0,0 +1,115 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { StreamClient } from '../client';
+import { StableWSConnection } from '../connection';
+import { videoLoggerSystem } from '../../../logger';
+import type { StreamVideoEvent } from '../types';
+
+const event: StreamVideoEvent = { type: 'network.changed', online: true };
+
+describe('event listener isolation', () => {
+  let client: StreamClient;
+  let sink: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    sink = vi.fn();
+    videoLoggerSystem.configureLoggers({
+      coordinator: { sink, level: 'error' },
+    });
+    client = new StreamClient('key');
+  });
+
+  afterEach(() => {
+    videoLoggerSystem.restoreDefaults();
+    vi.restoreAllMocks();
+  });
+
+  const errorLogs = () =>
+    sink.mock.calls.filter(([level]) => level === 'error');
+
+  it('keeps dispatching after a listener throws', () => {
+    const failure = new Error('listener blew up');
+    const first = vi.fn(() => {
+      throw failure;
+    });
+    const second = vi.fn();
+
+    client.on('network.changed', first);
+    client.on('network.changed', second);
+
+    expect(() => client.dispatchEvent(event)).not.toThrow();
+    expect(first).toHaveBeenCalledTimes(1);
+    expect(second).toHaveBeenCalledTimes(1);
+  });
+
+  it('reports a synchronous throw through the logger', () => {
+    const failure = new Error('listener blew up');
+    client.on('network.changed', () => {
+      throw failure;
+    });
+
+    client.dispatchEvent(event);
+
+    expect(errorLogs()).toEqual([
+      [
+        'error',
+        '[coordinator]: Unhandled error in event listener',
+        failure,
+        event,
+      ],
+    ]);
+  });
+
+  it('reports a rejection from an async listener', async () => {
+    const failure = new Error('async listener blew up');
+    client.on('network.changed', async () => {
+      throw failure;
+    });
+    const next = vi.fn();
+    client.on('network.changed', next);
+
+    client.dispatchEvent(event);
+    expect(next).toHaveBeenCalledTimes(1);
+    expect(errorLogs()).toHaveLength(0);
+
+    await vi.waitFor(() => expect(errorLogs()).toHaveLength(1));
+    expect(errorLogs()[0]).toEqual([
+      'error',
+      '[coordinator]: Unhandled error in event listener',
+      failure,
+      event,
+    ]);
+  });
+
+  it('isolates a faulty `all` listener from type specific listeners', () => {
+    const all = vi.fn(() => {
+      throw new Error('all listener blew up');
+    });
+    const typed = vi.fn();
+
+    client.on('all', all);
+    client.on('network.changed', typed);
+
+    client.dispatchEvent(event);
+
+    expect(all).toHaveBeenCalledTimes(1);
+    expect(typed).toHaveBeenCalledTimes(1);
+    expect(errorLogs()).toHaveLength(1);
+  });
+
+  it('schedules the connection check even when a listener throws', () => {
+    const connection = new StableWSConnection(client);
+    const scheduleConnectionCheck = vi
+      .spyOn(connection, 'scheduleConnectionCheck')
+      .mockImplementation(() => {});
+
+    client.on('all', () => {
+      throw new Error('listener blew up');
+    });
+
+    connection.onmessage(connection.wsID, {
+      data: JSON.stringify({ type: 'custom' }),
+    } as MessageEvent);
+
+    expect(scheduleConnectionCheck).toHaveBeenCalledTimes(1);
+  });
+});

package/src/coordinator/connection/client.ts

@@ -10,6 +10,7 @@ import { TokenManager } from './token_manager';
 import {
   addConnectionEventListeners,
   generateUUIDv4,
+  invokeEventListener,
   isErrorResponse,
   KnownCodes,
   removeConnectionEventListeners,
@@ -589,12 +590,12 @@ export class StreamClient {
 
     // call generic listeners
     for (const listener of this.listeners.all || []) {
-      listener(event);
+      invokeEventListener(listener, event, this.logger);
     }
 
     // call type specific listeners
     for (const listener of this.listeners[event.type] || []) {
-      listener(event);
+      invokeEventListener(listener, event, this.logger);
     }
   };
 

package/src/coordinator/connection/utils.ts

@@ -1,6 +1,7 @@
 import type { AxiosResponse } from 'axios';
 import type { APIErrorResponse } from './types';
 import type { ConnectionErrorEvent } from '../../gen/coordinator';
+import type { ScopedLogger } from '../../logger';
 
 export const sleep = (m: number) => new Promise((r) => setTimeout(r, m));
 
@@ -118,3 +119,30 @@ export function isCloseEvent(
 ): res is CloseEvent {
   return (res as CloseEvent).code !== undefined;
 }
+
+/**
+ * Invokes a single event listener in isolation, so that a faulty listener
+ * cannot abort the dispatch loop nor the bookkeeping that follows it.
+ *
+ * @param listener the listener to invoke.
+ * @param event the event to pass to the listener.
+ * @param logger the logger to report listener failures with.
+ */
+export const invokeEventListener = <T>(
+  listener: (event: T) => unknown,
+  event: T,
+  logger: ScopedLogger,
+) => {
+  try {
+    const result = listener(event);
+    if (result && typeof (result as PromiseLike<unknown>).then === 'function') {
+      Promise.resolve(result).catch((error) => report(logger, error, event));
+    }
+  } catch (error) {
+    report(logger, error, event);
+  }
+};
+
+const report = (logger: ScopedLogger, error: unknown, event: unknown) => {
+  logger.error('Unhandled error in event listener', error, event);
+};

package/src/devices/CameraManager.ts

@@ -167,8 +167,13 @@ export class CameraManager extends DeviceManager<CameraManagerState> {
    *
    * @param settings the video settings to apply.
    * @param publish whether to publish the stream after applying the settings.
+   * @param forceDisabled whether to keep the camera disabled, regardless of server-side or local preferences.
    */
-  async apply(settings: VideoSettingsResponse, publish: boolean) {
+  async apply(
+    settings: VideoSettingsResponse,
+    publish: boolean,
+    forceDisabled: boolean = false,
+  ): Promise<void> {
     // Wait for any in progress camera operation
     await this.statusChangeSettled();
     await this.selectTargetResolution(settings.target_resolution);
@@ -186,8 +191,10 @@ export class CameraManager extends DeviceManager<CameraManagerState> {
       this.devicePersistence.enabled &&
       permissionState === 'granted'
     ) {
-      persistedPreferencesApplied =
-        await this.applyPersistedPreferences(enabledInCallType);
+      persistedPreferencesApplied = await this.applyPersistedPreferences(
+        enabledInCallType,
+        forceDisabled,
+      );
     }
 
     // apply a direction and enable the camera only if in "pristine" state,
@@ -199,7 +206,12 @@ export class CameraManager extends DeviceManager<CameraManagerState> {
         await this.selectDirection(direction, { enableCamera: false });
       }
 
-      if (canPublish && settings.camera_default_on && enabledInCallType) {
+      if (
+        !forceDisabled &&
+        canPublish &&
+        settings.camera_default_on &&
+        enabledInCallType
+      ) {
         await this.enable();
       }
     }