@stream-io/video-client 1.44.5 → 1.45.0

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

@@ -3,6 +3,7 @@ import { ConnectedEvent, UserRequest, VideoEvent } from '../../gen/coordinator';
 import { AllSfuEvents } from '../../rtc';
 import type { ConfigureLoggersOptions, LogLevel } from '@stream-io/logger';
 import type { DevicePersistenceOptions } from '../../devices/devicePersistence';
+import { InputDeviceStatus } from '../../devices';
 export type UR = Record<string, unknown>;
 export type User = (Omit<UserRequest, 'role'> & {
     type?: 'authenticated';
@@ -79,7 +80,27 @@ export type MicCaptureReportEvent = {
      */
     label?: string;
 };
-export type StreamVideoEvent = (VideoEvent | NetworkChangedEvent | ConnectionChangedEvent | TransportChangedEvent | ConnectionRecoveredEvent | MicCaptureReportEvent) & {
+export type DeviceDisconnectedEvent = {
+    type: 'device.disconnected';
+    call_cid: string;
+    /**
+     * The device status at the time it was disconnected.
+     */
+    status: InputDeviceStatus;
+    /**
+     * The disconnected device ID.
+     */
+    deviceId: string;
+    /**
+     * The human-readable label of the disconnected device.
+     */
+    label?: string;
+    /**
+     * The disconnected device kind.
+     */
+    kind: MediaDeviceKind;
+};
+export type StreamVideoEvent = (VideoEvent | NetworkChangedEvent | ConnectionChangedEvent | TransportChangedEvent | ConnectionRecoveredEvent | MicCaptureReportEvent | DeviceDisconnectedEvent) & {
     received_at?: string | Date;
 };
 export type StreamCallEvent = Extract<StreamVideoEvent, {

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

@@ -104,6 +104,7 @@ export declare abstract class DeviceManager<S extends DeviceManagerState<C>, C =
     private get mediaDeviceKind();
     private handleDisconnectedOrReplacedDevices;
     protected findDevice(devices: MediaDeviceInfo[], deviceId: string): MediaDeviceInfo | undefined;
+    private dispatchDeviceDisconnectedEvent;
     private persistPreference;
     protected applyPersistedPreferences(enabledInCallType: boolean): Promise<boolean>;
     private applyMutedState;

package/package.json

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

package/src/coordinator/connection/types.ts

@@ -3,6 +3,7 @@ import { ConnectedEvent, UserRequest, VideoEvent } from '../../gen/coordinator';
 import { AllSfuEvents } from '../../rtc';
 import type { ConfigureLoggersOptions, LogLevel } from '@stream-io/logger';
 import type { DevicePersistenceOptions } from '../../devices/devicePersistence';
+import { InputDeviceStatus } from '../../devices';
 
 export type UR = Record<string, unknown>;
 
@@ -126,6 +127,27 @@ export type MicCaptureReportEvent = {
   label?: string;
 };
 
+export type DeviceDisconnectedEvent = {
+  type: 'device.disconnected';
+  call_cid: string;
+  /**
+   * The device status at the time it was disconnected.
+   */
+  status: InputDeviceStatus;
+  /**
+   * The disconnected device ID.
+   */
+  deviceId: string;
+  /**
+   * The human-readable label of the disconnected device.
+   */
+  label?: string;
+  /**
+   * The disconnected device kind.
+   */
+  kind: MediaDeviceKind;
+};
+
 export type StreamVideoEvent = (
   | VideoEvent
   | NetworkChangedEvent
@@ -133,6 +155,7 @@ export type StreamVideoEvent = (
   | TransportChangedEvent
   | ConnectionRecoveredEvent
   | MicCaptureReportEvent
+  | DeviceDisconnectedEvent
 ) & { received_at?: string | Date };
 
 // TODO: we should use WSCallEvent here but that needs fixing

package/src/devices/DeviceManager.ts

@@ -1,5 +1,6 @@
 import { combineLatest, firstValueFrom, Observable, pairwise } from 'rxjs';
 import { Call } from '../Call';
+import type { DeviceDisconnectedEvent } from '../coordinator/connection/types';
 import { TrackPublishOptions } from '../rtc';
 import { CallingState } from '../store';
 import { createSubscription, getCurrentValue } from '../store/rxUtils';
@@ -13,6 +14,7 @@ import { ScopedLogger, videoLoggerSystem } from '../logger';
 import { TrackType } from '../gen/video/sfu/models/models';
 import { deviceIds$ } from './devices';
 import {
+  hasPending,
   settled,
   withCancellation,
   withoutConcurrency,
@@ -543,6 +545,7 @@ export abstract class DeviceManager<
             }
 
             if (isDeviceDisconnected) {
+              this.dispatchDeviceDisconnectedEvent(prevDevice!);
               await this.disable();
               await this.select(undefined);
             }
@@ -553,7 +556,7 @@ export abstract class DeviceManager<
               ) {
                 await this.enable();
                 this.isTrackStoppedDueToTrackEnd = false;
-              } else {
+              } else if (!hasPending(this.statusChangeConcurrencyTag)) {
                 await this.applySettingsToStream();
               }
             }
@@ -573,6 +576,22 @@ export abstract class DeviceManager<
     return devices.find((d) => d.deviceId === deviceId && d.kind === kind);
   }
 
+  private dispatchDeviceDisconnectedEvent(device: MediaDeviceInfo) {
+    const event: DeviceDisconnectedEvent = {
+      type: 'device.disconnected',
+      call_cid: this.call.cid,
+      status: this.isTrackStoppedDueToTrackEnd
+        ? this.state.prevStatus
+        : this.state.status,
+      deviceId: device.deviceId,
+      label: device.label,
+      kind: device.kind,
+    };
+
+    this.call.tracer.trace('device.disconnected', event);
+    this.call.streamClient.dispatchEvent(event);
+  }
+
   private persistPreference(
     selectedDevice: string | undefined,
     status: InputDeviceStatus,

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

@@ -380,6 +380,14 @@ describe('Device Manager', () => {
 
     expect(manager.state.selectedDevice).toBe(undefined);
     expect(manager.state.status).toBe('disabled');
+    expect(manager['call'].streamClient.dispatchEvent).toHaveBeenCalledWith({
+      type: 'device.disconnected',
+      call_cid: manager['call'].cid,
+      status: 'enabled',
+      deviceId: device.deviceId,
+      label: device.label,
+      kind: device.kind,
+    });
 
     vi.useRealTimers();
   });

package/src/devices/__tests__/mocks.ts

@@ -95,9 +95,13 @@ export const mockCall = (): Partial<Call> => {
     }),
   );
   return {
+    cid: 'default:test-call',
     state: callState,
     publish: vi.fn(),
     stopPublish: vi.fn(),
+    streamClient: fromPartial({
+      dispatchEvent: vi.fn(),
+    }),
     notifyNoiseCancellationStarting: vi.fn().mockResolvedValue(undefined),
     notifyNoiseCancellationStopped: vi.fn().mockResolvedValue(undefined),
     tracer: new Tracer('tests'),

package/src/helpers/AudioBindingsWatchdog.ts

@@ -3,6 +3,7 @@ import { CallingState, CallState } from '../store';
 import { createSubscription } from '../store/rxUtils';
 import { videoLoggerSystem } from '../logger';
 import { Tracer } from '../stats';
+import { TrackType } from '../gen/video/sfu/models/models';
 
 const toBindingKey = (
   sessionId: string,
@@ -91,12 +92,23 @@ export class AudioBindingsWatchdog {
       const danglingUserIds: string[] = [];
       for (const p of this.state.participants) {
         if (p.isLocalParticipant) continue;
-        const { audioStream, screenShareAudioStream, sessionId, userId } = p;
-        if (audioStream && !this.bindings.has(toBindingKey(sessionId))) {
+        const {
+          audioStream,
+          screenShareAudioStream,
+          sessionId,
+          userId,
+          publishedTracks,
+        } = p;
+        if (
+          audioStream &&
+          publishedTracks.includes(TrackType.AUDIO) &&
+          !this.bindings.has(toBindingKey(sessionId))
+        ) {
           danglingUserIds.push(userId);
         }
         if (
           screenShareAudioStream &&
+          publishedTracks.includes(TrackType.SCREEN_SHARE_AUDIO) &&
           !this.bindings.has(toBindingKey(sessionId, 'screenShareAudioTrack'))
         ) {
           danglingUserIds.push(userId);

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

@@ -11,6 +11,7 @@ import { StreamClient } from '../../coordinator/connection/client';
 import { CallingState, StreamVideoWriteableStateStore } from '../../store';
 import { noopComparator } from '../../sorting';
 import { fromPartial } from '@total-typescript/shoehorn';
+import { TrackType } from '../../gen/video/sfu/models/models';
 
 describe('AudioBindingsWatchdog', () => {
   let watchdog: AudioBindingsWatchdog;
@@ -44,12 +45,17 @@ describe('AudioBindingsWatchdog', () => {
       screenShareAudioStream?: MediaStream;
     },
   ) => {
+    const publishedTracks = [];
+    if (streams?.audioStream) publishedTracks.push(TrackType.AUDIO);
+    if (streams?.screenShareAudioStream) {
+      publishedTracks.push(TrackType.SCREEN_SHARE_AUDIO);
+    }
     call.state.updateOrAddParticipant(
       sessionId,
       fromPartial({
         userId,
         sessionId,
-        publishedTracks: [],
+        publishedTracks,
         ...streams,
       }),
     );
@@ -233,6 +239,26 @@ describe('AudioBindingsWatchdog', () => {
     expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('user-1'));
   });
 
+  it('should not warn when audioStream exists but audio is not published', () => {
+    // @ts-expect-error private property
+    const warnSpy = vi.spyOn(watchdog.logger, 'warn');
+
+    call.state.updateOrAddParticipant(
+      'session-1',
+      fromPartial({
+        userId: 'user-1',
+        sessionId: 'session-1',
+        publishedTracks: [],
+        audioStream: new MediaStream(),
+      }),
+    );
+
+    call.state.setCallingState(CallingState.JOINED);
+    vi.advanceTimersByTime(3000);
+
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
   it('should not warn when screenShareAudio element is bound', () => {
     // @ts-expect-error private property
     const warnSpy = vi.spyOn(watchdog.logger, 'warn');