livekit-client 1.11.1 → 1.11.3

package/src/room/PCTransport.ts

@@ -8,11 +8,20 @@ import { ddExtensionURI, isChromiumBased, isSVCCodec } from './utils';
 
 /** @internal */
 interface TrackBitrateInfo {
-  sid: string;
+  cid?: string;
+  transceiver?: RTCRtpTransceiver;
   codec: string;
   maxbr: number;
 }
 
+/* The svc codec (av1/vp9) would use a very low bitrate at the begining and
+increase slowly by the bandwidth estimator until it reach the target bitrate. The
+process commonly cost more than 10 seconds cause subscriber will get blur video at 
+the first few seconds. So we use a 70% of target bitrate here as the start bitrate to
+eliminate this issue.
+*/
+const startBitrateForSVC = 0.7;
+
 export const PCEvents = {
   NegotiationStarted: 'negotiationStarted',
   NegotiationComplete: 'negotiationComplete',
@@ -56,12 +65,65 @@ export default class PCTransport extends EventEmitter {
   }
 
   async setRemoteDescription(sd: RTCSessionDescriptionInit): Promise<void> {
+    let mungedSDP: string | undefined = undefined;
     if (sd.type === 'offer') {
       let { stereoMids, nackMids } = extractStereoAndNackAudioFromOffer(sd);
       this.remoteStereoMids = stereoMids;
       this.remoteNackMids = nackMids;
+    } else if (sd.type === 'answer') {
+      const sdpParsed = parse(sd.sdp ?? '');
+      sdpParsed.media.forEach((media) => {
+        if (media.type === 'audio') {
+          // mung sdp for opus bitrate settings
+          this.trackBitrates.some((trackbr): boolean => {
+            if (!trackbr.transceiver || media.mid != trackbr.transceiver.mid) {
+              return false;
+            }
+
+            let codecPayload = 0;
+            media.rtp.some((rtp): boolean => {
+              if (rtp.codec.toUpperCase() === trackbr.codec.toUpperCase()) {
+                codecPayload = rtp.payload;
+                return true;
+              }
+              return false;
+            });
+
+            if (codecPayload === 0) {
+              return true;
+            }
+
+            let fmtpFound = false;
+            for (const fmtp of media.fmtp) {
+              if (fmtp.payload === codecPayload) {
+                fmtp.config = fmtp.config
+                  .split(';')
+                  .filter((attr) => !attr.includes('maxaveragebitrate'))
+                  .join(';');
+                if (trackbr.maxbr > 0) {
+                  fmtp.config += `;maxaveragebitrate=${trackbr.maxbr * 1000}`;
+                }
+                fmtpFound = true;
+                break;
+              }
+            }
+
+            if (!fmtpFound) {
+              if (trackbr.maxbr > 0) {
+                media.fmtp.push({
+                  payload: codecPayload,
+                  config: `maxaveragebitrate=${trackbr.maxbr * 1000}`,
+                });
+              }
+            }
+
+            return true;
+          });
+        }
+      });
+      mungedSDP = write(sdpParsed);
     }
-    await this.pc.setRemoteDescription(sd);
+    await this.setMungedSDP(sd, mungedSDP, true);
 
     this.pendingCandidates.forEach((candidate) => {
       this.pc.addIceCandidate(candidate);
@@ -130,7 +192,7 @@ export default class PCTransport extends EventEmitter {
         ensureVideoDDExtensionForSVC(media);
         // mung sdp for codec bitrate setting that can't apply by sendEncoding
         this.trackBitrates.some((trackbr): boolean => {
-          if (!media.msid || !media.msid.includes(trackbr.sid)) {
+          if (!media.msid || !trackbr.cid || !media.msid.includes(trackbr.cid)) {
             return false;
           }
 
@@ -143,39 +205,39 @@ export default class PCTransport extends EventEmitter {
             return false;
           });
 
-          // add x-google-max-bitrate to fmtp line if not exist
-          if (codecPayload > 0) {
-            if (
-              !media.fmtp.some((fmtp): boolean => {
-                if (fmtp.payload === codecPayload) {
-                  if (!fmtp.config.includes('x-google-start-bitrate')) {
-                    fmtp.config += `;x-google-start-bitrate=${trackbr.maxbr * 0.7}`;
-                  }
-                  if (!fmtp.config.includes('x-google-max-bitrate')) {
-                    fmtp.config += `;x-google-max-bitrate=${trackbr.maxbr}`;
-                  }
-                  return true;
-                }
-                return false;
-              })
-            ) {
-              media.fmtp.push({
-                payload: codecPayload,
-                config: `x-google-start-bitrate=${trackbr.maxbr * 0.7};x-google-max-bitrate=${
-                  trackbr.maxbr
-                }`,
-              });
+          if (codecPayload === 0) {
+            return true;
+          }
+
+          let fmtpFound = false;
+          for (const fmtp of media.fmtp) {
+            if (fmtp.payload === codecPayload) {
+              if (!fmtp.config.includes('x-google-start-bitrate')) {
+                fmtp.config += `;x-google-start-bitrate=${trackbr.maxbr * startBitrateForSVC}`;
+              }
+              if (!fmtp.config.includes('x-google-max-bitrate')) {
+                fmtp.config += `;x-google-max-bitrate=${trackbr.maxbr}`;
+              }
+              fmtpFound = true;
+              break;
             }
           }
 
+          if (!fmtpFound) {
+            media.fmtp.push({
+              payload: codecPayload,
+              config: `x-google-start-bitrate=${
+                trackbr.maxbr * startBitrateForSVC
+              };x-google-max-bitrate=${trackbr.maxbr}`,
+            });
+          }
+
           return true;
         });
       }
     });
 
-    this.trackBitrates = [];
-
-    await this.setMungedLocalDescription(offer, write(sdpParsed));
+    await this.setMungedSDP(offer, write(sdpParsed));
     this.onOffer(offer);
   }
 
@@ -187,16 +249,12 @@ export default class PCTransport extends EventEmitter {
         ensureAudioNackAndStereo(media, this.remoteStereoMids, this.remoteNackMids);
       }
     });
-    await this.setMungedLocalDescription(answer, write(sdpParsed));
+    await this.setMungedSDP(answer, write(sdpParsed));
     return answer;
   }
 
-  setTrackCodecBitrate(sid: string, codec: string, maxbr: number) {
-    this.trackBitrates.push({
-      sid,
-      codec,
-      maxbr,
-    });
+  setTrackCodecBitrate(info: TrackBitrateInfo) {
+    this.trackBitrates.push(info);
   }
 
   close() {
@@ -205,22 +263,32 @@ export default class PCTransport extends EventEmitter {
     this.pc.close();
   }
 
-  private async setMungedLocalDescription(sd: RTCSessionDescriptionInit, munged: string) {
-    const originalSdp = sd.sdp;
-    sd.sdp = munged;
-    try {
-      log.debug('setting munged local description');
-      await this.pc.setLocalDescription(sd);
-      return;
-    } catch (e) {
-      log.warn(`not able to set ${sd.type}, falling back to unmodified sdp`, {
-        error: e,
-      });
-      sd.sdp = originalSdp;
+  private async setMungedSDP(sd: RTCSessionDescriptionInit, munged?: string, remote?: boolean) {
+    if (munged) {
+      const originalSdp = sd.sdp;
+      sd.sdp = munged;
+      try {
+        log.debug(`setting munged ${remote ? 'remote' : 'local'} description`);
+        if (remote) {
+          await this.pc.setRemoteDescription(sd);
+        } else {
+          await this.pc.setLocalDescription(sd);
+        }
+        return;
+      } catch (e) {
+        log.warn(`not able to set ${sd.type}, falling back to unmodified sdp`, {
+          error: e,
+        });
+        sd.sdp = originalSdp;
+      }
     }
 
     try {
-      await this.pc.setLocalDescription(sd);
+      if (remote) {
+        await this.pc.setRemoteDescription(sd);
+      } else {
+        await this.pc.setLocalDescription(sd);
+      }
     } catch (e) {
       // this error cannot always be caught.
       // If the local description has a setCodecPreferences error, this error will be uncaught

package/src/room/Room.test.ts

@@ -0,0 +1,29 @@
+import Room from './Room';
+import { RoomEvent } from './events';
+
+describe('Active device switch', () => {
+  it('updates devices correctly', async () => {
+    const room = new Room();
+    await room.switchActiveDevice('audioinput', 'test');
+    expect(room.getActiveDevice('audioinput')).toBe('test');
+  });
+  it('updates devices with exact constraint', async () => {
+    const room = new Room();
+    await room.switchActiveDevice('audioinput', 'test', true);
+    expect(room.getActiveDevice('audioinput')).toBe('test');
+  });
+  it('emits changed event', async () => {
+    const room = new Room();
+    let kind: MediaDeviceKind | undefined;
+    let deviceId: string | undefined;
+    const deviceChangeHandler = (_kind: MediaDeviceKind, _deviceId: string) => {
+      kind = _kind;
+      deviceId = _deviceId;
+    };
+    room.on(RoomEvent.ActiveDeviceChanged, deviceChangeHandler);
+    await room.switchActiveDevice('audioinput', 'test', true);
+
+    expect(deviceId).toBe('test');
+    expect(kind).toBe('audioinput');
+  });
+});

package/src/room/Room.ts

@@ -68,6 +68,7 @@ import {
   isWeb,
   supportsSetSinkId,
   unpackStreamId,
+  unwrapConstraint,
 } from './utils';
 
 export enum ConnectionState {
@@ -134,6 +135,8 @@ class Room extends EventEmitter<RoomEventCallbacks> {
 
   private connectionReconcileInterval?: ReturnType<typeof setInterval>;
 
+  private activeDeviceMap: Map<MediaDeviceKind, string>;
+
   /**
    * Creates a new Room, the primary construct for a LiveKit session.
    * @param options
@@ -161,6 +164,22 @@ class Room extends EventEmitter<RoomEventCallbacks> {
     this.maybeCreateEngine();
 
     this.disconnectLock = new Mutex();
+    this.activeDeviceMap = new Map();
+    if (this.options.videoCaptureDefaults.deviceId) {
+      this.activeDeviceMap.set(
+        'videoinput',
+        unwrapConstraint(this.options.videoCaptureDefaults.deviceId),
+      );
+    }
+    if (this.options.audioCaptureDefaults.deviceId) {
+      this.activeDeviceMap.set(
+        'audioinput',
+        unwrapConstraint(this.options.audioCaptureDefaults.deviceId),
+      );
+    }
+    if (this.options.audioOutput?.deviceId) {
+      this.switchActiveDevice('audiooutput', unwrapConstraint(this.options.audioOutput.deviceId));
+    }
 
     this.localParticipant = new LocalParticipant('', '', this.engine, this.options);
   }
@@ -717,15 +736,17 @@ class Room extends EventEmitter<RoomEventCallbacks> {
 
   /**
    * Returns the active audio output device used in this room.
-   *
-   * Note: to get the active `audioinput` or `videoinput` use [[LocalTrack.getDeviceId()]]
-   *
    * @return the previously successfully set audio output device ID or an empty string if the default device is used.
+   * @deprecated use `getActiveDevice('audiooutput')` instead
    */
   getActiveAudioOutputDevice(): string {
     return this.options.audioOutput?.deviceId ?? '';
   }
 
+  getActiveDevice(kind: MediaDeviceKind): string | undefined {
+    return this.activeDeviceMap.get(kind);
+  }
+
   /**
    * Switches all active devices used in this room to the given device.
    *
@@ -737,15 +758,20 @@ class Room extends EventEmitter<RoomEventCallbacks> {
    * @param deviceId
    */
   async switchActiveDevice(kind: MediaDeviceKind, deviceId: string, exact: boolean = false) {
+    let deviceHasChanged = false;
+    let success = true;
     const deviceConstraint = exact ? { exact: deviceId } : deviceId;
     if (kind === 'audioinput') {
       const prevDeviceId = this.options.audioCaptureDefaults!.deviceId;
       this.options.audioCaptureDefaults!.deviceId = deviceConstraint;
+      deviceHasChanged = prevDeviceId !== deviceConstraint;
       const tracks = Array.from(this.localParticipant.audioTracks.values()).filter(
         (track) => track.source === Track.Source.Microphone,
       );
       try {
-        await Promise.all(tracks.map((t) => t.audioTrack?.setDeviceId(deviceConstraint)));
+        success = (
+          await Promise.all(tracks.map((t) => t.audioTrack?.setDeviceId(deviceConstraint)))
+        ).every((val) => val === true);
       } catch (e) {
         this.options.audioCaptureDefaults!.deviceId = prevDeviceId;
         throw e;
@@ -753,32 +779,50 @@ class Room extends EventEmitter<RoomEventCallbacks> {
     } else if (kind === 'videoinput') {
       const prevDeviceId = this.options.videoCaptureDefaults!.deviceId;
       this.options.videoCaptureDefaults!.deviceId = deviceConstraint;
+      deviceHasChanged = prevDeviceId !== deviceConstraint;
       const tracks = Array.from(this.localParticipant.videoTracks.values()).filter(
         (track) => track.source === Track.Source.Camera,
       );
       try {
-        await Promise.all(tracks.map((t) => t.videoTrack?.setDeviceId(deviceConstraint)));
+        success = (
+          await Promise.all(tracks.map((t) => t.videoTrack?.setDeviceId(deviceConstraint)))
+        ).every((val) => val === true);
       } catch (e) {
         this.options.videoCaptureDefaults!.deviceId = prevDeviceId;
         throw e;
       }
     } else if (kind === 'audiooutput') {
-      // TODO add support for webaudio mix once the API becomes available https://github.com/WebAudio/web-audio-api/pull/2498
-      if (!supportsSetSinkId()) {
+      if (
+        (!supportsSetSinkId() && !this.options.expWebAudioMix) ||
+        (this.audioContext && !('setSinkId' in this.audioContext))
+      ) {
         throw new Error('cannot switch audio output, setSinkId not supported');
       }
       this.options.audioOutput ??= {};
       const prevDeviceId = this.options.audioOutput.deviceId;
       this.options.audioOutput.deviceId = deviceId;
+      deviceHasChanged = prevDeviceId !== deviceConstraint;
+
       try {
-        await Promise.all(
-          Array.from(this.participants.values()).map((p) => p.setAudioOutput({ deviceId })),
-        );
+        if (this.options.expWebAudioMix) {
+          // @ts-expect-error setSinkId is not yet in the typescript type of AudioContext
+          this.audioContext?.setSinkId(deviceId);
+        } else {
+          await Promise.all(
+            Array.from(this.participants.values()).map((p) => p.setAudioOutput({ deviceId })),
+          );
+        }
       } catch (e) {
         this.options.audioOutput.deviceId = prevDeviceId;
         throw e;
       }
     }
+    if (deviceHasChanged && success) {
+      this.activeDeviceMap.set(kind, deviceId);
+      this.emit(RoomEvent.ActiveDeviceChanged, kind, deviceId);
+    }
+
+    return success;
   }
 
   private setupLocalParticipantEvents() {
@@ -1717,4 +1761,5 @@ export type RoomEventCallbacks = {
   signalConnected: () => void;
   recordingStatusChanged: (recording: boolean) => void;
   dcBufferStatusChanged: (isLow: boolean, kind: DataPacket_Kind) => void;
+  activeDeviceChanged: (kind: MediaDeviceKind, deviceId: string) => void;
 };

package/src/room/events.ts

@@ -278,6 +278,12 @@ export enum RoomEvent {
    * args: (isLow: boolean, kind: [[DataPacket_Kind]])
    */
   DCBufferStatusChanged = 'dcBufferStatusChanged',
+
+  /**
+   * Triggered by a call to room.switchActiveDevice
+   * args: (kind: MediaDeviceKind, deviceId: string)
+   */
+  ActiveDeviceChanged = 'activeDeviceChanged',
 }
 
 export enum ParticipantEvent {

package/src/room/participant/LocalParticipant.ts

@@ -494,12 +494,12 @@ export default class LocalParticipant extends Participant {
       return existingPublication;
     }
 
-    const isStereo =
-      options?.forceStereo ||
+    const isStereoInput =
       ('channelCount' in track.mediaStreamTrack.getSettings() &&
         // @ts-ignore `channelCount` on getSettings() is currently only available for Safari, but is generally the best way to determine a stereo track https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackSettings/channelCount
         track.mediaStreamTrack.getSettings().channelCount === 2) ||
       track.mediaStreamTrack.getConstraints().channelCount === 2;
+    const isStereo = options?.forceStereo ?? isStereoInput;
 
     // disable dtx for stereo track if not enabled explicitly
     if (isStereo) {
@@ -730,12 +730,36 @@ export default class LocalParticipant extends Participant {
     // store RTPSender
     track.sender = await this.engine.createSender(track, opts, encodings);
 
-    if (track.codec && isSVCCodec(track.codec) && encodings && encodings[0]?.maxBitrate) {
-      this.engine.publisher.setTrackCodecBitrate(
-        req.cid,
-        track.codec,
-        encodings[0].maxBitrate / 1000,
-      );
+    if (encodings) {
+      if (isFireFox() && track.kind === Track.Kind.Audio) {
+        /* Refer to RFC https://datatracker.ietf.org/doc/html/rfc7587#section-6.1, 
+           livekit-server uses maxaveragebitrate=510000in the answer sdp to permit client to
+           publish high quality audio track. But firefox always uses this value as the actual 
+           bitrates, causing the audio bitrates to rise to 510Kbps in any stereo case unexpectedly.
+           So the client need to modify maxaverragebitrates in answer sdp to user provided value to 
+           fix the issue.
+         */
+        let trackTransceiver: RTCRtpTransceiver | undefined = undefined;
+        for (const transceiver of this.engine.publisher.pc.getTransceivers()) {
+          if (transceiver.sender === track.sender) {
+            trackTransceiver = transceiver;
+            break;
+          }
+        }
+        if (trackTransceiver) {
+          this.engine.publisher.setTrackCodecBitrate({
+            transceiver: trackTransceiver,
+            codec: 'opus',
+            maxbr: encodings[0]?.maxBitrate ? encodings[0].maxBitrate / 1000 : 0,
+          });
+        }
+      } else if (track.codec && isSVCCodec(track.codec) && encodings[0]?.maxBitrate) {
+        this.engine.publisher.setTrackCodecBitrate({
+          cid: req.cid,
+          codec: track.codec,
+          maxbr: encodings[0].maxBitrate / 1000,
+        });
+      }
     }
 
     this.engine.negotiate();

package/src/room/participant/publishUtils.ts

@@ -10,7 +10,7 @@ import type {
   VideoCodec,
   VideoEncoding,
 } from '../track/options';
-import { getReactNativeOs, isReactNative, isSVCCodec } from '../utils';
+import { getReactNativeOs, isFireFox, isReactNative, isSVCCodec } from '../utils';
 
 /** @internal */
 export function mediaTrackToLocalTrack(
@@ -118,6 +118,7 @@ export function computeVideoEncodings(
     height,
     videoEncoding.maxBitrate,
     videoEncoding.maxFramerate,
+    videoEncoding.priority,
   );
 
   if (scalabilityMode && isSVCCodec(videoCodec)) {
@@ -311,7 +312,8 @@ function encodingsFromPresets(
     if (preset.encoding.maxFramerate) {
       encoding.maxFramerate = preset.encoding.maxFramerate;
     }
-    if (preset.encoding.priority) {
+    const canSetPriority = isFireFox() || idx === 0;
+    if (preset.encoding.priority && canSetPriority) {
       encoding.priority = preset.encoding.priority;
       encoding.networkPriority = preset.encoding.priority;
     }

package/src/room/track/LocalAudioTrack.ts

@@ -2,7 +2,7 @@ import log from '../../logger';
 import { TrackEvent } from '../events';
 import { computeBitrate, monitorFrequency } from '../stats';
 import type { AudioSenderStats } from '../stats';
-import { isWeb } from '../utils';
+import { isWeb, unwrapConstraint } from '../utils';
 import LocalTrack from './LocalTrack';
 import { Track } from './Track';
 import type { AudioCaptureOptions } from './options';
@@ -29,14 +29,15 @@ export default class LocalAudioTrack extends LocalTrack {
     this.checkForSilence();
   }
 
-  async setDeviceId(deviceId: ConstrainDOMString) {
+  async setDeviceId(deviceId: ConstrainDOMString): Promise<boolean> {
     if (this.constraints.deviceId === deviceId) {
-      return;
+      return true;
     }
     this.constraints.deviceId = deviceId;
     if (!this.isMuted) {
       await this.restartTrack();
     }
+    return unwrapConstraint(deviceId) === this.mediaStreamTrack.getSettings().deviceId;
   }
 
   async mute(): Promise<LocalAudioTrack> {

package/src/room/track/LocalTrack.ts

@@ -182,7 +182,7 @@ export default abstract class LocalTrack extends Track {
     }
 
     log.debug('replace MediaStreamTrack');
-    this.setMediaStreamTrack(track);
+    await this.setMediaStreamTrack(track);
     // this must be synced *after* setting mediaStreamTrack above, since it relies
     // on the previous state in order to cleanup
     this.providedByUser = userProvidedTrack;
@@ -227,7 +227,7 @@ export default abstract class LocalTrack extends Track {
     newTrack.addEventListener('ended', this.handleEnded);
     log.debug('re-acquired MediaStreamTrack');
 
-    this.setMediaStreamTrack(newTrack);
+    await this.setMediaStreamTrack(newTrack);
     this.constraints = constraints;
     if (this.processor) {
       const processor = this.processor;

package/src/room/track/LocalVideoTrack.ts

@@ -5,7 +5,7 @@ import type { SubscribedCodec, SubscribedQuality } from '../../proto/livekit_rtc
 import { ScalabilityMode } from '../participant/publishUtils';
 import { computeBitrate, monitorFrequency } from '../stats';
 import type { VideoSenderStats } from '../stats';
-import { Mutex, isFireFox, isMobile, isWeb } from '../utils';
+import { Mutex, isFireFox, isMobile, isWeb, unwrapConstraint } from '../utils';
 import LocalTrack from './LocalTrack';
 import { Track } from './Track';
 import type { VideoCaptureOptions, VideoCodec } from './options';
@@ -182,9 +182,12 @@ export default class LocalVideoTrack extends LocalTrack {
     this.setPublishingLayers(qualities);
   }
 
-  async setDeviceId(deviceId: ConstrainDOMString) {
-    if (this.constraints.deviceId === deviceId) {
-      return;
+  async setDeviceId(deviceId: ConstrainDOMString): Promise<boolean> {
+    if (
+      this.constraints.deviceId === deviceId &&
+      this._mediaStreamTrack.getSettings().deviceId === unwrapConstraint(deviceId)
+    ) {
+      return true;
     }
     this.constraints.deviceId = deviceId;
     // when video is muted, underlying media stream track is stopped and
@@ -192,6 +195,7 @@ export default class LocalVideoTrack extends LocalTrack {
     if (!this.isMuted) {
       await this.restartTrack();
     }
+    return unwrapConstraint(deviceId) === this._mediaStreamTrack.getSettings().deviceId;
   }
 
   async restartTrack(options?: VideoCaptureOptions) {

package/src/room/track/RemoteVideoTrack.ts

@@ -23,8 +23,6 @@ export default class RemoteVideoTrack extends RemoteTrack {
 
   private lastDimensions?: Track.Dimensions;
 
-  private isObserved: boolean = false;
-
   constructor(
     mediaTrack: MediaStreamTrack,
     sid: string,
@@ -39,12 +37,10 @@ export default class RemoteVideoTrack extends RemoteTrack {
     return this.adaptiveStreamSettings !== undefined;
   }
 
+  /**
+   * Note: When using adaptiveStream, you need to use remoteVideoTrack.attach() to add the track to a HTMLVideoElement, otherwise your video tracks might never start
+   */
   get mediaStreamTrack() {
-    if (this.isAdaptiveStream && !this.isObserved) {
-      log.warn(
-        'When using adaptiveStream, you need to use remoteVideoTrack.attach() to add the track to a HTMLVideoElement, otherwise your video tracks might never start',
-      );
-    }
     return this._mediaStreamTrack;
   }
 
@@ -106,7 +102,6 @@ export default class RemoteVideoTrack extends RemoteTrack {
       // the tab comes into focus for the first time.
       this.debouncedHandleResize();
       this.updateVisibility();
-      this.isObserved = true;
     } else {
       log.warn('visibility resize observer not triggered');
     }

package/src/room/track/options.ts

@@ -45,7 +45,7 @@ export interface TrackPublishDefaults {
   red?: boolean;
 
   /**
-   * stereo audio track. defaults determined by capture channel count.
+   * publish track in stereo mode (or set to false to disable). defaults determined by capture channel count.
    */
   forceStereo?: boolean;
 

package/src/room/track/utils.test.ts

@@ -1,5 +1,5 @@
 import { AudioCaptureOptions, VideoCaptureOptions, VideoPresets } from './options';
-import { constraintsForOptions, mergeDefaultOptions } from './utils';
+import { constraintsForOptions, facingModeFromDeviceLabel, mergeDefaultOptions } from './utils';
 
 describe('mergeDefaultOptions', () => {
   const audioDefaults: AudioCaptureOptions = {
@@ -108,3 +108,32 @@ describe('constraintsForOptions', () => {
     expect(videoOpts.aspectRatio).toEqual(VideoPresets.h720.resolution.aspectRatio);
   });
 });
+
+describe('Test facingMode detection', () => {
+  test('OBS virtual camera should be detected.', () => {
+    const result = facingModeFromDeviceLabel('OBS Virtual Camera');
+    expect(result?.facingMode).toEqual('environment');
+    expect(result?.confidence).toEqual('medium');
+  });
+
+  test.each([
+    ['Peter’s iPhone Camera', { facingMode: 'environment', confidence: 'medium' }],
+    ['iPhone de Théo Camera', { facingMode: 'environment', confidence: 'medium' }],
+  ])(
+    'Device labels that contain "iphone" should return facingMode "environment".',
+    (label, expected) => {
+      const result = facingModeFromDeviceLabel(label);
+      expect(result?.facingMode).toEqual(expected.facingMode);
+      expect(result?.confidence).toEqual(expected.confidence);
+    },
+  );
+
+  test.each([
+    ['Peter’s iPad Camera', { facingMode: 'environment', confidence: 'medium' }],
+    ['iPad de Théo Camera', { facingMode: 'environment', confidence: 'medium' }],
+  ])('Device label that contain "ipad" should detect.', (label, expected) => {
+    const result = facingModeFromDeviceLabel(label);
+    expect(result?.facingMode).toEqual(expected.facingMode);
+    expect(result?.confidence).toEqual(expected.confidence);
+  });
+});