@stream-io/video-client 0.3.15 → 0.3.17

package/dist/src/Call.d.ts

@@ -1,4 +1,4 @@
-import { SfuEventKinds, SfuEventListener } from './rtc';
+import { Publisher, SfuEventKinds, SfuEventListener, Subscriber } from './rtc';
 import { TrackType } from './gen/video/sfu/models/models';
 import { CallState } from './store';
 import { AcceptCallResponse, BlockUserResponse, EndCallResponse, GetCallResponse, GetOrCreateCallRequest, GetOrCreateCallResponse, GoLiveRequest, GoLiveResponse, ListRecordingsResponse, MuteUsersResponse, PinRequest, PinResponse, QueryMembersRequest, QueryMembersResponse, RejectCallResponse, RequestPermissionRequest, RequestPermissionResponse, SendEventResponse, SendReactionRequest, SendReactionResponse, StartBroadcastingResponse, StartRecordingResponse, StopBroadcastingResponse, StopLiveResponse, StopRecordingResponse, UnblockUserResponse, UnpinRequest, UnpinResponse, UpdateCallMembersRequest, UpdateCallMembersResponse, UpdateCallRequest, UpdateCallResponse, UpdateUserPermissionsRequest, UpdateUserPermissionsResponse } from './gen/coordinator';
@@ -7,9 +7,7 @@ import { DynascaleManager } from './helpers/DynascaleManager';
 import { PermissionsContext } from './permissions';
 import { StreamClient } from './coordinator/connection/client';
 import { CallEventHandler, CallEventTypes, EventTypes, Logger } from './coordinator/connection/types';
-import { CameraManager } from './devices/CameraManager';
-import { MicrophoneManager } from './devices/MicrophoneManager';
-import { SpeakerManager } from './devices/SpeakerManager';
+import { CameraManager, MicrophoneManager, SpeakerManager } from './devices';
 /**
  * An object representation of a `Call`.
  */
@@ -40,14 +38,19 @@ export declare class Call {
      */
     readonly camera: CameraManager;
     /**
-     * Device manager for the microhpone
+     * Device manager for the microphone.
      */
     readonly microphone: MicrophoneManager;
+    /**
+     * Device manager for the speaker.
+     */
+    readonly speaker: SpeakerManager;
     /**
      * The DynascaleManager instance.
      */
     readonly dynascaleManager: DynascaleManager;
-    readonly speaker: SpeakerManager;
+    subscriber?: Subscriber;
+    publisher?: Publisher;
     /**
      * Flag telling whether this call is a "ringing" call.
      */
@@ -62,8 +65,6 @@ export declare class Call {
      * @private
      */
     private readonly dispatcher;
-    private subscriber?;
-    private publisher?;
     private trackSubscriptionsSubject;
     private statsReporter?;
     private dropTimeout;

package/dist/src/coordinator/connection/types.d.ts

@@ -98,10 +98,6 @@ export type StreamClientOptions = Partial<AxiosRequestConfig> & {
     secret?: string;
     warmUp?: boolean;
     wsConnection?: StableWSConnection;
-    /**
-     * The preferred video codec to use.
-     */
-    preferredVideoCodec?: string;
 };
 export type TokenProvider = () => Promise<string>;
 export type TokenOrProvider = null | string | TokenProvider | undefined;

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

@@ -59,10 +59,10 @@ export declare abstract class InputMediaDeviceManager<T extends InputMediaDevice
     protected abstract publishStream(stream: MediaStream): Promise<void>;
     protected abstract stopPublishStream(stopTracks: boolean): Promise<void>;
     protected abstract getTrack(): undefined | MediaStreamTrack;
-    private muteStream;
+    protected muteStream(stopTracks?: boolean): Promise<void>;
     private muteTrack;
     private unmuteTrack;
     private stopTrack;
     private muteLocalStream;
-    private unmuteStream;
+    protected unmuteStream(): Promise<void>;
 }

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

@@ -50,12 +50,12 @@ export declare abstract class InputMediaDeviceManagerState {
     setStatus(status: InputDeviceStatus): void;
     /**
      * @internal
-     * @param stream
+     * @param stream the stream to set.
      */
     setMediaStream(stream: MediaStream | undefined): void;
     /**
      * @internal
-     * @param stream
+     * @param deviceId the device id to set.
      */
     setDevice(deviceId: string | undefined): void;
     /**

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

@@ -3,10 +3,13 @@ import { Call } from '../Call';
 import { InputMediaDeviceManager } from './InputMediaDeviceManager';
 import { MicrophoneManagerState } from './MicrophoneManagerState';
 export declare class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManagerState> {
+    private soundDetectorCleanup?;
     constructor(call: Call);
     protected getDevices(): Observable<MediaDeviceInfo[]>;
     protected getStream(constraints: MediaTrackConstraints): Promise<MediaStream>;
     protected publishStream(stream: MediaStream): Promise<void>;
     protected stopPublishStream(stopTracks: boolean): Promise<void>;
     protected getTrack(): MediaStreamTrack | undefined;
+    private startSpeakingWhileMutedDetection;
+    private stopSpeakingWhileMutedDetection;
 }

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

@@ -1,5 +1,23 @@
+import { Observable } from 'rxjs';
 import { InputMediaDeviceManagerState } from './InputMediaDeviceManagerState';
 export declare class MicrophoneManagerState extends InputMediaDeviceManagerState {
+    private speakingWhileMutedSubject;
+    /**
+     * An Observable that emits `true` if the user's microphone is muted but they'are speaking.
+     *
+     * This feature is not available in the React Native SDK.
+     */
+    speakingWhileMuted$: Observable<boolean>;
     constructor();
+    /**
+     * `true` if the user's microphone is muted but they'are speaking.
+     *
+     * This feature is not available in the React Native SDK.
+     */
+    get speakingWhileMuted(): boolean;
+    /**
+     * @internal
+     */
+    setSpeakingWhileMuted(isSpeaking: boolean): void;
     protected getDeviceIdFromStream(stream: MediaStream): string | undefined;
 }

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

@@ -1,7 +1,6 @@
 import { SpeakerState } from './SpeakerState';
 export declare class SpeakerManager {
     readonly state: SpeakerState;
-    constructor();
     /**
      * Lists the available audio output devices
      *

package/dist/src/devices/__tests__/mocks.d.ts

@@ -1,10 +1,8 @@
-import { CallingState } from '../../store';
+import { CallState } from '../../store';
 export declare const mockVideoDevices: MediaDeviceInfo[];
 export declare const mockAudioDevices: MediaDeviceInfo[];
 export declare const mockCall: () => {
-    state: {
-        callingState: CallingState;
-    };
+    state: CallState;
     publishVideoStream: import("@vitest/spy").Mock<any, any>;
     publishAudioStream: import("@vitest/spy").Mock<any, any>;
     stopPublish: import("@vitest/spy").Mock<any, any>;

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

@@ -5,3 +5,5 @@ export * from './CameraManager';
 export * from './CameraManagerState';
 export * from './MicrophoneManager';
 export * from './MicrophoneManagerState';
+export * from './SpeakerManager';
+export * from './SpeakerState';

package/dist/src/events/__tests__/mutes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/events/index.d.ts

@@ -1,5 +1,6 @@
 export * from './call';
 export * from './call-permissions';
 export * from './internal';
+export * from './mutes';
 export * from './participant';
 export * from './speaker';

package/dist/src/events/mutes.d.ts

@@ -0,0 +1,7 @@
+import { Call } from '../Call';
+/**
+ * An event handler that handles soft mutes.
+ *
+ * @param call the call.
+ */
+export declare const handleRemoteSoftMute: (call: Call) => () => void;

package/dist/src/rtc/Publisher.d.ts

@@ -3,14 +3,13 @@ import { TrackInfo, TrackType } from '../gen/video/sfu/models/models';
 import { CallState } from '../store';
 import { PublishOptions } from '../types';
 import { Dispatcher } from './Dispatcher';
-export type PublisherOpts = {
+export type PublisherConstructorOpts = {
     sfuClient: StreamSfuClient;
     state: CallState;
     dispatcher: Dispatcher;
     connectionConfig?: RTCConfiguration;
     isDtxEnabled: boolean;
     isRedEnabled: boolean;
-    preferredVideoCodec?: string;
     iceRestartDelay?: number;
 };
 /**
@@ -31,17 +30,8 @@ export declare class Publisher {
     private transceiverInitOrder;
     private readonly trackKindMapping;
     private readonly trackLayersCache;
-    /**
-     * A map keeping track of track types that were published to the SFU.
-     * This map shouldn't be cleared when unpublishing a track, as it is used
-     * to determine whether a track was published before.
-     *
-     * @private
-     */
-    private readonly trackTypePublishHistory;
     private readonly isDtxEnabled;
     private readonly isRedEnabled;
-    private readonly preferredVideoCodec?;
     private readonly unsubscribeOnIceRestart;
     private readonly iceRestartDelay;
     private isIceRestarting;
@@ -58,10 +48,9 @@ export declare class Publisher {
      * @param dispatcher the dispatcher to use.
      * @param isDtxEnabled whether DTX is enabled.
      * @param isRedEnabled whether RED is enabled.
-     * @param preferredVideoCodec the preferred video codec.
      * @param iceRestartDelay the delay in milliseconds to wait before restarting ICE once connection goes to `disconnected` state.
      */
-    constructor({ connectionConfig, sfuClient, dispatcher, state, isDtxEnabled, isRedEnabled, preferredVideoCodec, iceRestartDelay, }: PublisherOpts);
+    constructor({ connectionConfig, sfuClient, dispatcher, state, isDtxEnabled, isRedEnabled, iceRestartDelay, }: PublisherConstructorOpts);
     private createPeerConnection;
     /**
      * Closes the publisher PeerConnection and cleans up the resources.
@@ -93,14 +82,6 @@ export declare class Publisher {
      * @param trackType the track type to check.
      */
     isPublishing: (trackType: TrackType) => boolean;
-    /**
-     * Returns true if the given track type was ever published to the SFU.
-     * Contrary to `isPublishing`, this method returns true if a certain
-     * track type was published before, even if it is currently unpublished.
-     *
-     * @param trackType the track type to check.
-     */
-    hasEverPublished: (trackType: TrackType) => boolean;
     /**
      * Returns true if the given track type is currently live
      *

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "0.3.15";
+export declare const version = "0.3.17";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "0.3.15",
+  "version": "0.3.17",
   "packageManager": "yarn@3.2.4",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",
@@ -52,15 +52,15 @@
     "@types/sdp-transform": "^2.4.6",
     "@types/ua-parser-js": "^0.7.36",
     "@types/ws": "^8.5.4",
-    "@vitest/coverage-v8": "^0.34.2",
+    "@vitest/coverage-v8": "^0.34.4",
     "dotenv": "^16.3.1",
-    "happy-dom": "^10.11.0",
+    "happy-dom": "^11.0.2",
     "prettier": "^2.8.4",
     "rimraf": "^3.0.2",
     "rollup": "^3.28.1",
     "typescript": "^4.9.5",
     "vite": "^4.4.9",
-    "vitest": "^0.34.3",
-    "vitest-mock-extended": "^1.2.0"
+    "vitest": "^0.34.4",
+    "vitest-mock-extended": "^1.2.1"
   }
 }

package/src/Call.ts

@@ -116,10 +116,12 @@ import {
 } from './coordinator/connection/types';
 import { getClientDetails, getSdkInfo } from './client-details';
 import { getLogger } from './logger';
-import { CameraManager } from './devices/CameraManager';
-import { MicrophoneManager } from './devices/MicrophoneManager';
-import { CameraDirection } from './devices/CameraManagerState';
-import { SpeakerManager } from './devices/SpeakerManager';
+import {
+  CameraDirection,
+  CameraManager,
+  MicrophoneManager,
+  SpeakerManager,
+} from './devices';
 
 /**
  * An object representation of a `Call`.
@@ -157,19 +159,22 @@ export class Call {
   readonly camera: CameraManager;
 
   /**
-   * Device manager for the microhpone
+   * Device manager for the microphone.
    */
   readonly microphone: MicrophoneManager;
 
+  /**
+   * Device manager for the speaker.
+   */
+  readonly speaker: SpeakerManager;
+
   /**
    * The DynascaleManager instance.
    */
   readonly dynascaleManager = new DynascaleManager(this);
 
-  /*
-   * Device manager for the speaker
-   */
-  readonly speaker: SpeakerManager;
+  subscriber?: Subscriber;
+  publisher?: Publisher;
 
   /**
    * Flag telling whether this call is a "ringing" call.
@@ -188,8 +193,6 @@ export class Call {
    */
   private readonly dispatcher = new Dispatcher();
 
-  private subscriber?: Subscriber;
-  private publisher?: Publisher;
   private trackSubscriptionsSubject = new BehaviorSubject<{
     type: DebounceType;
     data: TrackSubscriptionDetails[];
@@ -277,41 +280,6 @@ export class Call {
 
     this.camera = new CameraManager(this);
     this.microphone = new MicrophoneManager(this);
-
-    // FIXME OL: disable soft-mutes as they are not working properly
-    // this.state.localParticipant$.subscribe(async (p) => {
-    //   if (!this.publisher) return;
-    //   // Mute via device manager
-    //   // If integrator doesn't use device manager, we mute using stopPublish
-    //   if (
-    //     this.publisher.hasEverPublished(TrackType.VIDEO) &&
-    //     this.publisher.isPublishing(TrackType.VIDEO) &&
-    //     !p?.publishedTracks.includes(TrackType.VIDEO)
-    //   ) {
-    //     this.logger(
-    //       'info',
-    //       `Local participant's video track is muted remotely`,
-    //     );
-    //     await this.camera.disable();
-    //     if (this.publisher.isPublishing(TrackType.VIDEO)) {
-    //       await this.stopPublish(TrackType.VIDEO);
-    //     }
-    //   }
-    //   if (
-    //     this.publisher.hasEverPublished(TrackType.AUDIO) &&
-    //     this.publisher.isPublishing(TrackType.AUDIO) &&
-    //     !p?.publishedTracks.includes(TrackType.AUDIO)
-    //   ) {
-    //     this.logger(
-    //       'info',
-    //       `Local participant's audio track is muted remotely`,
-    //     );
-    //     await this.microphone.disable();
-    //     if (this.publisher.isPublishing(TrackType.AUDIO)) {
-    //       await this.stopPublish(TrackType.AUDIO);
-    //     }
-    //   }
-    // });
     this.speaker = new SpeakerManager();
   }
 
@@ -396,7 +364,7 @@ export class Call {
     this.leaveCallHooks.add(
       // handles the case when the user is blocked by the call owner.
       createSubscription(this.state.blockedUserIds$, async (blockedUserIds) => {
-        if (!blockedUserIds) return;
+        if (!blockedUserIds || blockedUserIds.length === 0) return;
         const currentUserId = this.currentUserId;
         if (currentUserId && blockedUserIds.includes(currentUserId)) {
           this.logger('info', 'Leaving call because of being blocked');
@@ -932,7 +900,6 @@ export class Call {
         connectionConfig,
         isDtxEnabled,
         isRedEnabled,
-        preferredVideoCodec: this.streamClient.options.preferredVideoCodec,
       });
     }
 
@@ -1902,10 +1869,10 @@ export class Call {
       this.microphone.state.mediaStream &&
       !this.publisher?.isPublishing(TrackType.AUDIO)
     ) {
-      this.publishAudioStream(this.microphone.state.mediaStream);
+      await this.publishAudioStream(this.microphone.state.mediaStream);
     }
 
-    // Start mic if backend config speicifies, and there is no local setting
+    // Start mic if backend config specifies, and there is no local setting
     if (
       this.microphone.state.status === undefined &&
       this.state.settings?.audio.mic_default_on

package/src/coordinator/connection/types.ts

@@ -127,10 +127,6 @@ export type StreamClientOptions = Partial<AxiosRequestConfig> & {
   // Set the instance of StableWSConnection on chat client. Its purely for testing purpose and should
   // not be used in production apps.
   wsConnection?: StableWSConnection;
-  /**
-   * The preferred video codec to use.
-   */
-  preferredVideoCodec?: string;
 };
 
 export type TokenProvider = () => Promise<string>;

package/src/devices/CameraManager.ts

@@ -34,7 +34,7 @@ export class CameraManager extends InputMediaDeviceManager<CameraManagerState> {
    */
   async flip() {
     const newDirection = this.state.direction === 'front' ? 'back' : 'front';
-    this.selectDirection(newDirection);
+    await this.selectDirection(newDirection);
   }
 
   /**

package/src/devices/InputMediaDeviceManager.ts

@@ -87,7 +87,7 @@ export abstract class InputMediaDeviceManager<
       this.state.prevStatus === 'enabled' &&
       this.state.status === 'disabled'
     ) {
-      this.enable();
+      await this.enable();
     }
   }
 
@@ -141,7 +141,7 @@ export abstract class InputMediaDeviceManager<
 
   protected abstract getTrack(): undefined | MediaStreamTrack;
 
-  private async muteStream(stopTracks: boolean = true) {
+  protected async muteStream(stopTracks: boolean = true) {
     if (!this.state.mediaStream) {
       return;
     }
@@ -154,7 +154,7 @@ export abstract class InputMediaDeviceManager<
       // @ts-expect-error release() is present in react-native-webrtc and must be called to dispose the stream
       if (typeof this.state.mediaStream.release === 'function') {
         // @ts-expect-error
-        this.state.mediaStream.release();
+        stream.release();
       }
       this.state.setMediaStream(undefined);
     }
@@ -191,7 +191,7 @@ export abstract class InputMediaDeviceManager<
     stopTracks ? this.stopTrack() : this.muteTrack();
   }
 
-  private async unmuteStream() {
+  protected async unmuteStream() {
     this.logger('debug', 'Starting stream');
     let stream: MediaStream;
     if (this.state.mediaStream && this.getTrack()?.readyState === 'live') {
@@ -207,6 +207,8 @@ export abstract class InputMediaDeviceManager<
     if (this.call.state.callingState === CallingState.JOINED) {
       await this.publishStream(stream);
     }
-    this.state.setMediaStream(stream);
+    if (this.state.mediaStream !== stream) {
+      this.state.setMediaStream(stream);
+    }
   }
 }

package/src/devices/InputMediaDeviceManagerState.ts

@@ -1,4 +1,4 @@
-import { BehaviorSubject, Observable, distinctUntilChanged } from 'rxjs';
+import { BehaviorSubject, distinctUntilChanged, Observable } from 'rxjs';
 import { RxUtils } from '../store';
 
 export type InputDeviceStatus = 'enabled' | 'disabled' | undefined;
@@ -85,7 +85,7 @@ export abstract class InputMediaDeviceManagerState {
 
   /**
    * @internal
-   * @param stream
+   * @param stream the stream to set.
    */
   setMediaStream(stream: MediaStream | undefined) {
     this.setCurrentValue(this.mediaStreamSubject, stream);
@@ -96,7 +96,7 @@ export abstract class InputMediaDeviceManagerState {
 
   /**
    * @internal
-   * @param stream
+   * @param deviceId the device id to set.
    */
   setDevice(deviceId: string | undefined) {
     this.setCurrentValue(this.selectedDeviceSubject, deviceId);

package/src/devices/MicrophoneManager.ts

@@ -1,13 +1,42 @@
-import { Observable } from 'rxjs';
+import { combineLatest, Observable } from 'rxjs';
 import { Call } from '../Call';
 import { InputMediaDeviceManager } from './InputMediaDeviceManager';
 import { MicrophoneManagerState } from './MicrophoneManagerState';
 import { getAudioDevices, getAudioStream } from './devices';
 import { TrackType } from '../gen/video/sfu/models/models';
+import { createSoundDetector } from '../helpers/sound-detector';
+import { isReactNative } from '../helpers/platforms';
+import { OwnCapability } from '../gen/coordinator';
+import { CallingState } from '../store';
 
 export class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManagerState> {
+  private soundDetectorCleanup?: Function;
+
   constructor(call: Call) {
     super(call, new MicrophoneManagerState(), TrackType.AUDIO);
+
+    combineLatest([
+      this.call.state.callingState$,
+      this.call.state.ownCapabilities$,
+      this.state.selectedDevice$,
+      this.state.status$,
+    ]).subscribe(async ([callingState, ownCapabilities, deviceId, status]) => {
+      if (callingState !== CallingState.JOINED) {
+        if (callingState === CallingState.LEFT) {
+          await this.stopSpeakingWhileMutedDetection();
+        }
+        return;
+      }
+      if (ownCapabilities.includes(OwnCapability.SEND_AUDIO)) {
+        if (status === 'disabled') {
+          await this.startSpeakingWhileMutedDetection(deviceId);
+        } else {
+          await this.stopSpeakingWhileMutedDetection();
+        }
+      } else {
+        await this.stopSpeakingWhileMutedDetection();
+      }
+    });
   }
 
   protected getDevices(): Observable<MediaDeviceInfo[]> {
@@ -28,4 +57,30 @@ export class MicrophoneManager extends InputMediaDeviceManager<MicrophoneManager
   protected getTrack() {
     return this.state.mediaStream?.getAudioTracks()[0];
   }
+
+  private async startSpeakingWhileMutedDetection(deviceId?: string) {
+    if (isReactNative()) {
+      return;
+    }
+    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);
+    });
+  }
+
+  private async stopSpeakingWhileMutedDetection() {
+    if (isReactNative() || !this.soundDetectorCleanup) {
+      return;
+    }
+    this.state.setSpeakingWhileMuted(false);
+    try {
+      await this.soundDetectorCleanup();
+    } finally {
+      this.soundDetectorCleanup = undefined;
+    }
+  }
 }

package/src/devices/MicrophoneManagerState.ts

@@ -1,8 +1,38 @@
+import { BehaviorSubject, Observable, distinctUntilChanged } from 'rxjs';
 import { InputMediaDeviceManagerState } from './InputMediaDeviceManagerState';
 
 export class MicrophoneManagerState extends InputMediaDeviceManagerState {
+  private speakingWhileMutedSubject = new BehaviorSubject<boolean>(false);
+
+  /**
+   * An Observable that emits `true` if the user's microphone is muted but they'are speaking.
+   *
+   * This feature is not available in the React Native SDK.
+   */
+  speakingWhileMuted$: Observable<boolean>;
+
   constructor() {
     super('disable-tracks');
+
+    this.speakingWhileMuted$ = this.speakingWhileMutedSubject
+      .asObservable()
+      .pipe(distinctUntilChanged());
+  }
+
+  /**
+   * `true` if the user's microphone is muted but they'are speaking.
+   *
+   * This feature is not available in the React Native SDK.
+   */
+  get speakingWhileMuted() {
+    return this.getCurrentValue(this.speakingWhileMuted$);
+  }
+
+  /**
+   * @internal
+   */
+  setSpeakingWhileMuted(isSpeaking: boolean) {
+    this.setCurrentValue(this.speakingWhileMutedSubject, isSpeaking);
   }
 
   protected getDeviceIdFromStream(stream: MediaStream): string | undefined {

package/src/devices/SpeakerManager.ts

@@ -5,8 +5,6 @@ import { getAudioOutputDevices } from './devices';
 export class SpeakerManager {
   public readonly state = new SpeakerState();
 
-  constructor() {}
-
   /**
    * Lists the available audio output devices
    *

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

@@ -2,7 +2,7 @@ import { Call } from '../../Call';
 import { StreamClient } from '../../coordinator/connection/client';
 import { CallingState, StreamVideoWriteableStateStore } from '../../store';
 
-import { afterEach, beforeEach, describe, vi, it, expect, Mock } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, Mock, vi } from 'vitest';
 import { mockCall, mockVideoDevices, mockVideoStream } from './mocks';
 import { getVideoStream } from '../devices';
 import { TrackType } from '../../gen/video/sfu/models/models';
@@ -67,8 +67,7 @@ describe('CameraManager', () => {
   });
 
   it('publish stream', async () => {
-    // @ts-expect-error
-    manager['call'].state.callingState = CallingState.JOINED;
+    manager['call'].state.setCallingState(CallingState.JOINED);
 
     await manager.enable();
 
@@ -78,8 +77,7 @@ describe('CameraManager', () => {
   });
 
   it('stop publish stream', async () => {
-    // @ts-expect-error
-    manager['call'].state.callingState = CallingState.JOINED;
+    manager['call'].state.setCallingState(CallingState.JOINED);
     await manager.enable();
 
     await manager.disable();