@stream-io/video-client 1.44.4 → 1.44.6-beta.0

package/src/helpers/__tests__/AudioBindingsWatchdog.test.ts

@@ -0,0 +1,325 @@
+/**
+ * @vitest-environment happy-dom
+ */
+
+import '../../rtc/__tests__/mocks/webrtc.mocks';
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { AudioBindingsWatchdog } from '../AudioBindingsWatchdog';
+import { Call } from '../../Call';
+import { StreamClient } from '../../coordinator/connection/client';
+import { CallingState, StreamVideoWriteableStateStore } from '../../store';
+import { noopComparator } from '../../sorting';
+import { fromPartial } from '@total-typescript/shoehorn';
+
+describe('AudioBindingsWatchdog', () => {
+  let watchdog: AudioBindingsWatchdog;
+  let call: Call;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    call = new Call({
+      id: 'id',
+      type: 'default',
+      streamClient: new StreamClient('api-key', {
+        devicePersistence: { enabled: false },
+      }),
+      clientStore: new StreamVideoWriteableStateStore(),
+    });
+    call.setSortParticipantsBy(noopComparator());
+    watchdog = new AudioBindingsWatchdog(call.state, call.tracer);
+  });
+
+  afterEach(() => {
+    watchdog.dispose();
+    call.leave();
+    vi.useRealTimers();
+  });
+
+  const addRemoteParticipant = (
+    sessionId: string,
+    userId: string,
+    streams?: {
+      audioStream?: MediaStream;
+      screenShareAudioStream?: MediaStream;
+    },
+  ) => {
+    call.state.updateOrAddParticipant(
+      sessionId,
+      fromPartial({
+        userId,
+        sessionId,
+        publishedTracks: [],
+        ...streams,
+      }),
+    );
+  };
+
+  it('should warn about dangling audio streams when active', () => {
+    // @ts-expect-error private property
+    const warnSpy = vi.spyOn(watchdog.logger, 'warn');
+
+    addRemoteParticipant('session-1', 'user-1', {
+      audioStream: new MediaStream(),
+    });
+
+    call.state.setCallingState(CallingState.JOINED);
+    vi.advanceTimersByTime(3000);
+
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Dangling audio bindings detected'),
+    );
+    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('user-1'));
+  });
+
+  it('should not warn when all audio elements are bound', () => {
+    // @ts-expect-error private property
+    const warnSpy = vi.spyOn(watchdog.logger, 'warn');
+
+    addRemoteParticipant('session-1', 'user-1', {
+      audioStream: new MediaStream(),
+    });
+    watchdog.register(
+      document.createElement('audio'),
+      'session-1',
+      'audioTrack',
+    );
+
+    call.state.setCallingState(CallingState.JOINED);
+    vi.advanceTimersByTime(3000);
+
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  it('should skip local participant', () => {
+    // @ts-expect-error private property
+    const warnSpy = vi.spyOn(watchdog.logger, 'warn');
+
+    // @ts-expect-error incomplete data
+    call.state.updateOrAddParticipant('local-session', {
+      userId: 'local-user',
+      sessionId: 'local-session',
+      isLocalParticipant: true,
+      publishedTracks: [],
+      audioStream: new MediaStream(),
+    });
+
+    call.state.setCallingState(CallingState.JOINED);
+    vi.advanceTimersByTime(3000);
+
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  it('should start on JOINED and stop on non-JOINED state', () => {
+    // @ts-expect-error private property
+    const warnSpy = vi.spyOn(watchdog.logger, 'warn');
+
+    addRemoteParticipant('session-1', 'user-1', {
+      audioStream: new MediaStream(),
+    });
+
+    call.state.setCallingState(CallingState.JOINED);
+    vi.advanceTimersByTime(3000);
+    expect(warnSpy).toHaveBeenCalled();
+
+    warnSpy.mockClear();
+
+    call.state.setCallingState(CallingState.IDLE);
+    vi.advanceTimersByTime(6000);
+
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  it('should be disableable via setEnabled', () => {
+    // @ts-expect-error private property
+    const warnSpy = vi.spyOn(watchdog.logger, 'warn');
+
+    addRemoteParticipant('session-1', 'user-1', {
+      audioStream: new MediaStream(),
+    });
+
+    watchdog.setEnabled(false);
+
+    call.state.setCallingState(CallingState.JOINED);
+    vi.advanceTimersByTime(6000);
+
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  it('should re-enable after disabling', () => {
+    // @ts-expect-error private property
+    const warnSpy = vi.spyOn(watchdog.logger, 'warn');
+
+    addRemoteParticipant('session-1', 'user-1', {
+      audioStream: new MediaStream(),
+    });
+
+    watchdog.setEnabled(false);
+    watchdog.setEnabled(true);
+
+    vi.advanceTimersByTime(3000);
+
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Dangling audio bindings detected'),
+    );
+  });
+
+  it('should warn when binding a different element to the same key', () => {
+    // @ts-expect-error private property
+    const warnSpy = vi.spyOn(watchdog.logger, 'warn');
+
+    const audioElement1 = document.createElement('audio');
+    const audioElement2 = document.createElement('audio');
+
+    watchdog.register(audioElement1, 'session-1', 'audioTrack');
+    watchdog.register(audioElement2, 'session-1', 'audioTrack');
+
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Audio element already bound'),
+    );
+  });
+
+  it('should not warn when re-binding the same element', () => {
+    // @ts-expect-error private property
+    const warnSpy = vi.spyOn(watchdog.logger, 'warn');
+
+    const audioElement = document.createElement('audio');
+
+    watchdog.register(audioElement, 'session-1', 'audioTrack');
+    watchdog.register(audioElement, 'session-1', 'audioTrack');
+
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  it('unregisterBinding should remove the binding', () => {
+    // @ts-expect-error private property
+    const warnSpy = vi.spyOn(watchdog.logger, 'warn');
+
+    addRemoteParticipant('session-1', 'user-1', {
+      audioStream: new MediaStream(),
+    });
+    watchdog.register(
+      document.createElement('audio'),
+      'session-1',
+      'audioTrack',
+    );
+
+    call.state.setCallingState(CallingState.JOINED);
+    vi.advanceTimersByTime(3000);
+    expect(warnSpy).not.toHaveBeenCalled();
+
+    watchdog.unregister('session-1', 'audioTrack');
+    vi.advanceTimersByTime(3000);
+
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Dangling audio bindings detected'),
+    );
+  });
+
+  it('should warn about dangling screenShareAudioStream', () => {
+    // @ts-expect-error private property
+    const warnSpy = vi.spyOn(watchdog.logger, 'warn');
+
+    addRemoteParticipant('session-1', 'user-1', {
+      screenShareAudioStream: new MediaStream(),
+    });
+
+    call.state.setCallingState(CallingState.JOINED);
+    vi.advanceTimersByTime(3000);
+
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Dangling audio bindings detected'),
+    );
+    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('user-1'));
+  });
+
+  it('should not warn when screenShareAudio element is bound', () => {
+    // @ts-expect-error private property
+    const warnSpy = vi.spyOn(watchdog.logger, 'warn');
+
+    addRemoteParticipant('session-1', 'user-1', {
+      screenShareAudioStream: new MediaStream(),
+    });
+    watchdog.register(
+      document.createElement('audio'),
+      'session-1',
+      'screenShareAudioTrack',
+    );
+
+    call.state.setCallingState(CallingState.JOINED);
+    vi.advanceTimersByTime(3000);
+
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  it('should warn only about the unbound track type', () => {
+    // @ts-expect-error private property
+    const warnSpy = vi.spyOn(watchdog.logger, 'warn');
+
+    addRemoteParticipant('session-1', 'user-1', {
+      audioStream: new MediaStream(),
+      screenShareAudioStream: new MediaStream(),
+    });
+
+    // bind only the regular audio track
+    watchdog.register(
+      document.createElement('audio'),
+      'session-1',
+      'audioTrack',
+    );
+
+    call.state.setCallingState(CallingState.JOINED);
+    vi.advanceTimersByTime(3000);
+
+    // should still warn because screenShareAudio is unbound
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Dangling audio bindings detected'),
+    );
+  });
+
+  it('should not warn when both audio and screenShareAudio are bound', () => {
+    // @ts-expect-error private property
+    const warnSpy = vi.spyOn(watchdog.logger, 'warn');
+
+    addRemoteParticipant('session-1', 'user-1', {
+      audioStream: new MediaStream(),
+      screenShareAudioStream: new MediaStream(),
+    });
+
+    watchdog.register(
+      document.createElement('audio'),
+      'session-1',
+      'audioTrack',
+    );
+    watchdog.register(
+      document.createElement('audio'),
+      'session-1',
+      'screenShareAudioTrack',
+    );
+
+    call.state.setCallingState(CallingState.JOINED);
+    vi.advanceTimersByTime(3000);
+
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  it('dispose should stop the watchdog', () => {
+    // @ts-expect-error private property
+    const warnSpy = vi.spyOn(watchdog.logger, 'warn');
+
+    addRemoteParticipant('session-1', 'user-1', {
+      audioStream: new MediaStream(),
+    });
+
+    call.state.setCallingState(CallingState.JOINED);
+    vi.advanceTimersByTime(3000);
+    expect(warnSpy).toHaveBeenCalled();
+
+    warnSpy.mockClear();
+
+    watchdog.dispose();
+    vi.advanceTimersByTime(6000);
+
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+});

package/src/helpers/__tests__/DynascaleManager.test.ts

@@ -618,6 +618,70 @@ describe('DynascaleManager', () => {
       });
     });
 
+    it('audio: should register and unregister watchdog binding', () => {
+      const watchdog = dynascaleManager.audioBindingsWatchdog!;
+      const registerSpy = vi.spyOn(watchdog, 'register');
+      const unregisterSpy = vi.spyOn(watchdog, 'unregister');
+
+      // @ts-expect-error incomplete data
+      call.state.updateOrAddParticipant('session-id', {
+        userId: 'user-id',
+        sessionId: 'session-id',
+        publishedTracks: [],
+      });
+
+      const cleanup = dynascaleManager.bindAudioElement(
+        document.createElement('audio'),
+        'session-id',
+        'audioTrack',
+      );
+
+      expect(registerSpy).toHaveBeenCalledWith(
+        expect.any(HTMLAudioElement),
+        'session-id',
+        'audioTrack',
+      );
+
+      cleanup?.();
+
+      expect(unregisterSpy).toHaveBeenCalledWith('session-id', 'audioTrack');
+    });
+
+    it('audio: should warn when binding an already-bound session', () => {
+      const watchdog = dynascaleManager.audioBindingsWatchdog!;
+      // @ts-expect-error private property
+      const warnSpy = vi.spyOn(watchdog.logger, 'warn');
+
+      // @ts-expect-error incomplete data
+      call.state.updateOrAddParticipant('session-id', {
+        userId: 'user-id',
+        sessionId: 'session-id',
+        publishedTracks: [],
+      });
+
+      const audioElement1 = document.createElement('audio');
+      const audioElement2 = document.createElement('audio');
+
+      const cleanup1 = dynascaleManager.bindAudioElement(
+        audioElement1,
+        'session-id',
+        'audioTrack',
+      );
+
+      const cleanup2 = dynascaleManager.bindAudioElement(
+        audioElement2,
+        'session-id',
+        'audioTrack',
+      );
+
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Audio element already bound'),
+      );
+
+      cleanup1?.();
+      cleanup2?.();
+    });
+
     it('video: should unsubscribe when element dimensions are zero', () => {
       // @ts-expect-error incomplete data
       call.state.updateOrAddParticipant('session-id', {

package/src/store/stateStore.ts

@@ -42,7 +42,7 @@ export class StreamVideoWriteableStateStore {
    * The currently connected user.
    */
   get connectedUser(): OwnUserResponse | undefined {
-    return RxUtils.getCurrentValue(this.connectedUserSubject);
+    return this.connectedUserSubject.getValue();
   }
 
   /**

package/src/types.ts

@@ -23,6 +23,7 @@ import type {
 import type { Comparator } from './sorting';
 import type { StreamVideoWriteableStateStore } from './store';
 import { AxiosError } from 'axios';
+import type { Call } from './Call';
 
 export type StreamReaction = Pick<
   ReactionResponse,
@@ -392,26 +393,68 @@ export type StartCallRecordingFnType = {
   ): Promise<StartRecordingResponse>;
 };
 
+type StreamRNVideoSDKCallManagerRingingParams = {
+  isRingingTypeCall: boolean;
+};
+
+type StreamRNVideoSDKCallManagerSetupParams =
+  StreamRNVideoSDKCallManagerRingingParams & {
+    defaultDevice: AudioSettingsRequestDefaultDeviceEnum;
+  };
+
+type StreamRNVideoSDKEndCallReason =
+  /** Call ended by the local user (e.g., hanging up). */
+  | 'local'
+  /** Call ended by the remote party, or outgoing call was not answered. */
+  | 'remote'
+  /** Call was rejected/declined by the user. */
+  | 'rejected'
+  /** Remote party was busy. */
+  | 'busy'
+  /** Call was answered on another device. */
+  | 'answeredElsewhere'
+  /** No response to an incoming call. */
+  | 'missed'
+  /** Call failed due to an error (e.g., network issue). */
+  | 'error'
+  /** Call was canceled before the remote party could answer. */
+  | 'canceled'
+  /** Call restricted (e.g., airplane mode, dialing restrictions). */
+  | 'restricted'
+  /** Unknown or unspecified disconnect reason. */
+  | 'unknown';
+
+type StreamRNVideoSDKCallingX = {
+  joinCall: (call: Call, activeCalls: Call[]) => Promise<void>;
+  endCall: (
+    call: Call,
+    reason?: StreamRNVideoSDKEndCallReason,
+  ) => Promise<void>;
+  registerOutgoingCall: (call: Call) => Promise<void>;
+};
+
 export type StreamRNVideoSDKGlobals = {
+  callingX: StreamRNVideoSDKCallingX;
   callManager: {
     /**
      * Sets up the in call manager.
      */
     setup({
       defaultDevice,
-    }: {
-      defaultDevice: AudioSettingsRequestDefaultDeviceEnum;
-    }): void;
+      isRingingTypeCall,
+    }: StreamRNVideoSDKCallManagerSetupParams): void;
 
     /**
      * Starts the in call manager.
      */
-    start(): void;
+    start({
+      isRingingTypeCall,
+    }: StreamRNVideoSDKCallManagerRingingParams): void;
 
     /**
      * Stops the in call manager.
      */
-    stop(): void;
+    stop({ isRingingTypeCall }: StreamRNVideoSDKCallManagerRingingParams): void;
   };
   permissions: {
     /**