livekit-client 1.11.3 → 1.12.0

package/src/room/participant/LocalParticipant.ts

@@ -1,6 +1,12 @@
 import log from '../../logger';
 import type { InternalRoomOptions } from '../../options';
-import { DataPacket, DataPacket_Kind, ParticipantInfo } from '../../proto/livekit_models';
+import {
+  DataPacket,
+  DataPacket_Kind,
+  Encryption_Type,
+  ParticipantInfo,
+  ParticipantPermission,
+} from '../../proto/livekit_models';
 import {
   AddTrackRequest,
   DataChannelInfo,
@@ -50,6 +56,9 @@ export default class LocalParticipant extends Participant {
   /** @internal */
   engine: RTCEngine;
 
+  /** @internal */
+  activeDeviceMap: Map<MediaDeviceKind, string>;
+
   private pendingPublishing = new Set<Track.Source>();
 
   private pendingPublishPromises = new Map<LocalTrack, Promise<LocalTrackPublication>>();
@@ -65,6 +74,8 @@ export default class LocalParticipant extends Participant {
   // keep a pointer to room options
   private roomOptions: InternalRoomOptions;
 
+  private encryptionType: Encryption_Type = Encryption_Type.NONE;
+
   private reconnectFuture?: Future<void>;
 
   /** @internal */
@@ -76,6 +87,7 @@ export default class LocalParticipant extends Participant {
     this.engine = engine;
     this.roomOptions = options;
     this.setupEngine(engine);
+    this.activeDeviceMap = new Map();
   }
 
   get lastCameraError(): Error | undefined {
@@ -210,6 +222,22 @@ export default class LocalParticipant extends Participant {
     return this.setTrackEnabled(Track.Source.ScreenShare, enabled, options, publishOptions);
   }
 
+  /** @internal */
+  setPermissions(permissions: ParticipantPermission): boolean {
+    const prevPermissions = this.permissions;
+    const changed = super.setPermissions(permissions);
+    if (changed && prevPermissions) {
+      this.emit(ParticipantEvent.ParticipantPermissionsChanged, prevPermissions);
+    }
+    return changed;
+  }
+
+  /** @internal */
+  async setE2EEEnabled(enabled: boolean) {
+    this.encryptionType = enabled ? Encryption_Type.GCM : Encryption_Type.NONE;
+    await this.republishAllTracks(undefined, false);
+  }
+
   /**
    * Enable or disable publishing for a track by source. This serves as a simple
    * way to manage the common tracks (camera, mic, or screen share).
@@ -464,14 +492,38 @@ export default class LocalParticipant extends Participant {
     if (track instanceof LocalTrack && this.pendingPublishPromises.has(track)) {
       await this.pendingPublishPromises.get(track);
     }
+    let defaultConstraints: MediaTrackConstraints | undefined;
+    if (track instanceof MediaStreamTrack) {
+      defaultConstraints = track.getConstraints();
+    } else {
+      // we want to access constraints directly as `track.mediaStreamTrack`
+      // might be pointing to a non-device track (e.g. processed track) already
+      defaultConstraints = track.constraints;
+      let deviceKind: MediaDeviceKind | undefined = undefined;
+      switch (track.source) {
+        case Track.Source.Microphone:
+          deviceKind = 'audioinput';
+          break;
+        case Track.Source.Camera:
+          deviceKind = 'videoinput';
+        default:
+          break;
+      }
+      if (deviceKind && this.activeDeviceMap.has(deviceKind)) {
+        defaultConstraints = {
+          ...defaultConstraints,
+          deviceId: this.activeDeviceMap.get(deviceKind),
+        };
+      }
+    }
     // convert raw media track into audio or video track
     if (track instanceof MediaStreamTrack) {
       switch (track.kind) {
         case 'audio':
-          track = new LocalAudioTrack(track, undefined, true);
+          track = new LocalAudioTrack(track, defaultConstraints, true);
           break;
         case 'video':
-          track = new LocalVideoTrack(track, undefined, true);
+          track = new LocalVideoTrack(track, defaultConstraints, true);
           break;
         default:
           throw new TrackInvalidError(`unsupported MediaStreamTrack kind ${track.kind}`);
@@ -524,6 +576,12 @@ export default class LocalParticipant extends Participant {
       ...options,
     };
 
+    // disable simulcast if e2ee is set on safari
+    if (isSafari() && this.roomOptions.e2ee) {
+      log.info(`End-to-end encryption is set up, simulcast publishing will be disabled on Safari`);
+      opts.simulcast = false;
+    }
+
     if (opts.source) {
       track.source = opts.source;
     }
@@ -596,8 +654,9 @@ export default class LocalParticipant extends Participant {
       muted: track.isMuted,
       source: Track.sourceToProto(track.source),
       disableDtx: !(opts.dtx ?? true),
+      encryption: this.encryptionType,
       stereo: isStereo,
-      disableRed: !(opts.red ?? true),
+      // disableRed: !(opts.red ?? true),
     });
 
     // compute encodings and layers for video
@@ -732,11 +791,11 @@ export default class LocalParticipant extends Participant {
 
     if (encodings) {
       if (isFireFox() && track.kind === Track.Kind.Audio) {
-        /* Refer to RFC https://datatracker.ietf.org/doc/html/rfc7587#section-6.1, 
+        /* 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 
+           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 
+           So the client need to modify maxaverragebitrates in answer sdp to user provided value to
            fix the issue.
          */
         let trackTransceiver: RTCRtpTransceiver | undefined = undefined;
@@ -762,7 +821,7 @@ export default class LocalParticipant extends Participant {
       }
     }
 
-    this.engine.negotiate();
+    await this.engine.negotiate();
 
     if (track instanceof LocalVideoTrack) {
       track.startMonitor(this.engine.client);
@@ -848,7 +907,7 @@ export default class LocalParticipant extends Participant {
     }
     await this.engine.createSimulcastSender(track, simulcastTrack, opts, encodings);
 
-    this.engine.negotiate();
+    await this.engine.negotiate();
     log.debug(`published ${videoCodec} for track ${track.sid}`, { encodings, trackInfo: ti });
   }
 
@@ -952,7 +1011,7 @@ export default class LocalParticipant extends Participant {
     ) as LocalTrackPublication[];
   }
 
-  async republishAllTracks(options?: TrackPublishOptions) {
+  async republishAllTracks(options?: TrackPublishOptions, restartTracks: boolean = true) {
     const localPubs: LocalTrackPublication[] = [];
     this.tracks.forEach((pub) => {
       if (pub.track) {
@@ -967,6 +1026,19 @@ export default class LocalParticipant extends Participant {
       localPubs.map(async (pub) => {
         const track = pub.track!;
         await this.unpublishTrack(track, false);
+        if (
+          restartTracks &&
+          !track.isMuted &&
+          (track instanceof LocalAudioTrack || track instanceof LocalVideoTrack) &&
+          !track.isUserProvided
+        ) {
+          // generally we need to restart the track before publishing, often a full reconnect
+          // is necessary because computer had gone to sleep.
+          log.debug('restarting existing track', {
+            track: pub.trackSid,
+          });
+          await track.restartTrack();
+        }
         await this.publishTrack(track, pub.options);
       }),
     );

package/src/room/participant/Participant.ts

@@ -68,6 +68,10 @@ export default class Participant extends EventEmitter<ParticipantEventCallbacks>
 
   private _connectionQuality: ConnectionQuality = ConnectionQuality.Unknown;
 
+  get isEncrypted() {
+    return this.tracks.size > 0 && Array.from(this.tracks.values()).every((tr) => tr.isEncrypted);
+  }
+
   /** @internal */
   constructor(sid: string, identity: string, name?: string, metadata?: string) {
     super();

package/src/room/track/LocalAudioTrack.ts

@@ -30,14 +30,16 @@ export default class LocalAudioTrack extends LocalTrack {
   }
 
   async setDeviceId(deviceId: ConstrainDOMString): Promise<boolean> {
-    if (this.constraints.deviceId === deviceId) {
+    if (this._constraints.deviceId === deviceId) {
       return true;
     }
-    this.constraints.deviceId = deviceId;
+    this._constraints.deviceId = deviceId;
     if (!this.isMuted) {
       await this.restartTrack();
     }
-    return unwrapConstraint(deviceId) === this.mediaStreamTrack.getSettings().deviceId;
+    return (
+      this.isMuted || unwrapConstraint(deviceId) === this.mediaStreamTrack.getSettings().deviceId
+    );
   }
 
   async mute(): Promise<LocalAudioTrack> {
@@ -59,9 +61,14 @@ export default class LocalAudioTrack extends LocalTrack {
   async unmute(): Promise<LocalAudioTrack> {
     const unlock = await this.muteLock.lock();
     try {
+      const deviceHasChanged =
+        this._constraints.deviceId &&
+        this._mediaStreamTrack.getSettings().deviceId !==
+          unwrapConstraint(this._constraints.deviceId);
+
       if (
         this.source === Track.Source.Microphone &&
-        (this.stopOnMute || this._mediaStreamTrack.readyState === 'ended') &&
+        (this.stopOnMute || this._mediaStreamTrack.readyState === 'ended' || deviceHasChanged) &&
         !this.isUserProvided
       ) {
         log.debug('reacquiring mic track');

package/src/room/track/LocalTrack.ts

@@ -17,7 +17,11 @@ export default abstract class LocalTrack extends Track {
   /** @internal */
   codec?: VideoCodec;
 
-  protected constraints: MediaTrackConstraints;
+  get constraints() {
+    return this._constraints;
+  }
+
+  protected _constraints: MediaTrackConstraints;
 
   protected reacquireTrack: boolean;
 
@@ -31,7 +35,7 @@ export default abstract class LocalTrack extends Track {
 
   protected processor?: TrackProcessor<typeof this.kind>;
 
-  protected isSettingUpProcessor: boolean = false;
+  protected processorLock: Mutex;
 
   /**
    *
@@ -51,11 +55,13 @@ export default abstract class LocalTrack extends Track {
     this.providedByUser = userProvidedTrack;
     this.muteLock = new Mutex();
     this.pauseUpstreamLock = new Mutex();
+    this.processorLock = new Mutex();
+    this.setMediaStreamTrack(mediaTrack, true);
+
     // added to satisfy TS compiler, constraints are synced with MediaStreamTrack
-    this.constraints = mediaTrack.getConstraints();
-    this.setMediaStreamTrack(mediaTrack);
+    this._constraints = mediaTrack.getConstraints();
     if (constraints) {
-      this.constraints = constraints;
+      this._constraints = constraints;
     }
   }
 
@@ -92,8 +98,8 @@ export default abstract class LocalTrack extends Track {
     return this.processor?.processedTrack ?? this._mediaStreamTrack;
   }
 
-  private async setMediaStreamTrack(newTrack: MediaStreamTrack) {
-    if (newTrack === this._mediaStreamTrack) {
+  private async setMediaStreamTrack(newTrack: MediaStreamTrack, force?: boolean) {
+    if (newTrack === this._mediaStreamTrack && !force) {
       return;
     }
     if (this._mediaStreamTrack) {
@@ -104,7 +110,7 @@ export default abstract class LocalTrack extends Track {
       this._mediaStreamTrack.removeEventListener('ended', this.handleEnded);
       this._mediaStreamTrack.removeEventListener('mute', this.pauseUpstream);
       this._mediaStreamTrack.removeEventListener('unmute', this.resumeUpstream);
-      if (!this.providedByUser) {
+      if (!this.providedByUser && this._mediaStreamTrack !== newTrack) {
         this._mediaStreamTrack.stop();
       }
     }
@@ -119,7 +125,7 @@ export default abstract class LocalTrack extends Track {
       // touch MediaStreamTrack.enabled
       newTrack.addEventListener('mute', this.pauseUpstream);
       newTrack.addEventListener('unmute', this.resumeUpstream);
-      this.constraints = newTrack.getConstraints();
+      this._constraints = newTrack.getConstraints();
     }
     if (this.sender) {
       await this.sender.replaceTrack(newTrack);
@@ -195,7 +201,7 @@ export default abstract class LocalTrack extends Track {
 
   protected async restart(constraints?: MediaTrackConstraints): Promise<LocalTrack> {
     if (!constraints) {
-      constraints = this.constraints;
+      constraints = this._constraints;
     }
     log.debug('restarting track with constraints', constraints);
 
@@ -228,7 +234,7 @@ export default abstract class LocalTrack extends Track {
     log.debug('re-acquired MediaStreamTrack');
 
     await this.setMediaStreamTrack(newTrack);
-    this.constraints = constraints;
+    this._constraints = constraints;
     if (this.processor) {
       const processor = this.processor;
       await this.setProcessor(processor);
@@ -357,42 +363,43 @@ export default abstract class LocalTrack extends Track {
     processor: TrackProcessor<typeof this.kind>,
     showProcessedStreamLocally = true,
   ) {
-    if (this.isSettingUpProcessor) {
-      log.warn('already trying to set up a processor');
-      return;
-    }
-    log.debug('setting up processor');
-    this.isSettingUpProcessor = true;
-    if (this.processor) {
-      await this.stopProcessor();
-    }
-    if (this.kind === 'unknown') {
-      throw TypeError('cannot set processor on track of unknown kind');
-    }
-    this.processorElement = this.processorElement ?? document.createElement(this.kind);
-    this.processorElement.muted = true;
-
-    attachToElement(this._mediaStreamTrack, this.processorElement);
-    this.processorElement.play().catch((e) => log.error(e));
-
-    const processorOptions = {
-      kind: this.kind,
-      track: this._mediaStreamTrack,
-      element: this.processorElement,
-    };
+    const unlock = await this.processorLock.lock();
+    try {
+      log.debug('setting up processor');
+      if (this.processor) {
+        await this.stopProcessor();
+      }
+      if (this.kind === 'unknown') {
+        throw TypeError('cannot set processor on track of unknown kind');
+      }
+      this.processorElement = this.processorElement ?? document.createElement(this.kind);
+      this.processorElement.muted = true;
+
+      attachToElement(this._mediaStreamTrack, this.processorElement);
+      this.processorElement
+        .play()
+        .catch((error) => log.error('failed to play processor element', { error }));
+
+      const processorOptions = {
+        kind: this.kind,
+        track: this._mediaStreamTrack,
+        element: this.processorElement,
+      };
 
-    await processor.init(processorOptions);
-    this.processor = processor;
-    if (this.processor.processedTrack) {
-      for (const el of this.attachedElements) {
-        if (el !== this.processorElement && showProcessedStreamLocally) {
-          detachTrack(this._mediaStreamTrack, el);
-          attachToElement(this.processor.processedTrack, el);
+      await processor.init(processorOptions);
+      this.processor = processor;
+      if (this.processor.processedTrack) {
+        for (const el of this.attachedElements) {
+          if (el !== this.processorElement && showProcessedStreamLocally) {
+            detachTrack(this._mediaStreamTrack, el);
+            attachToElement(this.processor.processedTrack, el);
+          }
         }
+        await this.sender?.replaceTrack(this.processor.processedTrack);
       }
-      await this.sender?.replaceTrack(this.processor.processedTrack);
+    } finally {
+      unlock();
     }
-    this.isSettingUpProcessor = false;
   }
 
   getProcessor() {

package/src/room/track/LocalVideoTrack.ts

@@ -184,18 +184,20 @@ export default class LocalVideoTrack extends LocalTrack {
 
   async setDeviceId(deviceId: ConstrainDOMString): Promise<boolean> {
     if (
-      this.constraints.deviceId === deviceId &&
+      this._constraints.deviceId === deviceId &&
       this._mediaStreamTrack.getSettings().deviceId === unwrapConstraint(deviceId)
     ) {
       return true;
     }
-    this.constraints.deviceId = deviceId;
+    this._constraints.deviceId = deviceId;
     // when video is muted, underlying media stream track is stopped and
     // will be restarted later
     if (!this.isMuted) {
       await this.restartTrack();
     }
-    return unwrapConstraint(deviceId) === this._mediaStreamTrack.getSettings().deviceId;
+    return (
+      this.isMuted || unwrapConstraint(deviceId) === this._mediaStreamTrack.getSettings().deviceId
+    );
   }
 
   async restartTrack(options?: VideoCaptureOptions) {

package/src/room/track/RemoteVideoTrack.ts

@@ -123,6 +123,7 @@ export default class RemoteVideoTrack extends RemoteTrack {
     }
     this.elementInfos = this.elementInfos.filter((info) => info !== elementInfo);
     this.updateVisibility();
+    this.debouncedHandleResize();
   }
 
   detach(): HTMLMediaElement[];
@@ -195,9 +196,8 @@ export default class RemoteVideoTrack extends RemoteTrack {
   private stopObservingElement(element: HTMLMediaElement) {
     const stopElementInfos = this.elementInfos.filter((info) => info.element === element);
     for (const info of stopElementInfos) {
-      info.stopObserving();
+      this.stopObservingElementInfo(info);
     }
-    this.elementInfos = this.elementInfos.filter((info) => info.element !== element);
   }
 
   protected async handleAppVisibilityChanged() {

package/src/room/track/TrackPublication.ts

@@ -1,5 +1,6 @@
 import EventEmitter from 'eventemitter3';
 import log from '../../logger';
+import { Encryption_Type } from '../../proto/livekit_models';
 import type { SubscriptionError, TrackInfo } from '../../proto/livekit_models';
 import type { UpdateSubscription, UpdateTrackSettings } from '../../proto/livekit_rtc';
 import { TrackEvent } from '../events';
@@ -35,6 +36,8 @@ export class TrackPublication extends EventEmitter<PublicationEventCallbacks> {
 
   protected metadataMuted: boolean = false;
 
+  protected encryption: Encryption_Type = Encryption_Type.NONE;
+
   constructor(kind: Track.Kind, id: string, name: string) {
     super();
     this.kind = kind;
@@ -71,6 +74,10 @@ export class TrackPublication extends EventEmitter<PublicationEventCallbacks> {
     return this.track !== undefined;
   }
 
+  get isEncrypted(): boolean {
+    return this.encryption !== Encryption_Type.NONE;
+  }
+
   /**
    * an [AudioTrack] if this publication holds an audio track
    */
@@ -110,8 +117,9 @@ export class TrackPublication extends EventEmitter<PublicationEventCallbacks> {
       };
       this.simulcasted = info.simulcast;
     }
+    this.encryption = info.encryption;
     this.trackInfo = info;
-    log.trace('update publication info', { info });
+    log.debug('update publication info', { info });
   }
 }
 

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

@@ -0,0 +1,30 @@
+import { facingModeFromDeviceLabel } from './facingMode';
+
+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);
+  });
+});

package/src/room/track/facingMode.ts

@@ -0,0 +1,103 @@
+import log from 'loglevel';
+import LocalTrack from './LocalTrack';
+import type { VideoCaptureOptions } from './options';
+
+type FacingMode = NonNullable<VideoCaptureOptions['facingMode']>;
+type FacingModeFromLocalTrackOptions = {
+  /**
+   * If no facing mode can be determined, this value will be used.
+   * @defaultValue 'user'
+   */
+  defaultFacingMode?: FacingMode;
+};
+type FacingModeFromLocalTrackReturnValue = {
+  /**
+   * The (probable) facingMode of the track.
+   * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/facingMode | MDN docs on facingMode}
+   */
+  facingMode: FacingMode;
+  /**
+   * The confidence that the returned facingMode is correct.
+   */
+  confidence: 'high' | 'medium' | 'low';
+};
+
+/**
+ * Try to analyze the local track to determine the facing mode of a track.
+ *
+ * @remarks
+ * There is no property supported by all browsers to detect whether a video track originated from a user- or environment-facing camera device.
+ * For this reason, we use the `facingMode` property when available, but will fall back on a string-based analysis of the device label to determine the facing mode.
+ * If both methods fail, the default facing mode will be used.
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints/facingMode | MDN docs on facingMode}
+ * @experimental
+ */
+export function facingModeFromLocalTrack(
+  localTrack: LocalTrack | MediaStreamTrack,
+  options: FacingModeFromLocalTrackOptions = {},
+): FacingModeFromLocalTrackReturnValue {
+  const track = localTrack instanceof LocalTrack ? localTrack.mediaStreamTrack : localTrack;
+  const trackSettings = track.getSettings();
+  let result: FacingModeFromLocalTrackReturnValue = {
+    facingMode: options.defaultFacingMode ?? 'user',
+    confidence: 'low',
+  };
+
+  // 1. Try to get facingMode from track settings.
+  if ('facingMode' in trackSettings) {
+    const rawFacingMode = trackSettings.facingMode;
+    log.debug('rawFacingMode', { rawFacingMode });
+    if (rawFacingMode && typeof rawFacingMode === 'string' && isFacingModeValue(rawFacingMode)) {
+      result = { facingMode: rawFacingMode, confidence: 'high' };
+    }
+  }
+
+  // 2. If we don't have a high confidence we try to get the facing mode from the device label.
+  if (['low', 'medium'].includes(result.confidence)) {
+    log.debug(`Try to get facing mode from device label: (${track.label})`);
+    const labelAnalysisResult = facingModeFromDeviceLabel(track.label);
+    if (labelAnalysisResult !== undefined) {
+      result = labelAnalysisResult;
+    }
+  }
+
+  return result;
+}
+
+const knownDeviceLabels = new Map<string, FacingModeFromLocalTrackReturnValue>([
+  ['obs virtual camera', { facingMode: 'environment', confidence: 'medium' }],
+]);
+const knownDeviceLabelSections = new Map<string, FacingModeFromLocalTrackReturnValue>([
+  ['iphone', { facingMode: 'environment', confidence: 'medium' }],
+  ['ipad', { facingMode: 'environment', confidence: 'medium' }],
+]);
+/**
+ * Attempt to analyze the device label to determine the facing mode.
+ *
+ * @experimental
+ */
+export function facingModeFromDeviceLabel(
+  deviceLabel: string,
+): FacingModeFromLocalTrackReturnValue | undefined {
+  const label = deviceLabel.trim().toLowerCase();
+  // Empty string is a valid device label but we can't infer anything from it.
+  if (label === '') {
+    return undefined;
+  }
+
+  // Can we match against widely known device labels.
+  if (knownDeviceLabels.has(label)) {
+    return knownDeviceLabels.get(label);
+  }
+
+  // Can we match against sections of the device label.
+  return Array.from(knownDeviceLabelSections.entries()).find(([section]) =>
+    label.includes(section),
+  )?.[1];
+}
+
+function isFacingModeValue(item: string): item is FacingMode {
+  const allowedValues: FacingMode[] = ['user', 'environment', 'left', 'right'];
+  return item === undefined || allowedValues.includes(item as FacingMode);
+}

package/src/room/track/options.ts

@@ -272,10 +272,11 @@ export interface AudioPreset {
   priority?: RTCPriorityType;
 }
 
-const codecs = ['vp8', 'h264', 'vp9', 'av1'] as const;
 const backupCodecs = ['vp8', 'h264'] as const;
 
-export type VideoCodec = (typeof codecs)[number];
+export const videoCodecs = ['vp8', 'h264', 'vp9', 'av1'] as const;
+
+export type VideoCodec = (typeof videoCodecs)[number];
 
 export type BackupVideoCodec = (typeof backupCodecs)[number];
 

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

@@ -1,5 +1,5 @@
 import { AudioCaptureOptions, VideoCaptureOptions, VideoPresets } from './options';
-import { constraintsForOptions, facingModeFromDeviceLabel, mergeDefaultOptions } from './utils';
+import { constraintsForOptions, mergeDefaultOptions } from './utils';
 
 describe('mergeDefaultOptions', () => {
   const audioDefaults: AudioCaptureOptions = {
@@ -108,32 +108,3 @@ 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);
-  });
-});