livekit-client 1.11.3 → 1.12.0

package/src/room/track/utils.ts

@@ -1,6 +1,5 @@
 import { sleep } from '../utils';
-import log from './../../logger';
-import LocalTrack from './LocalTrack';
+import { Track } from './Track';
 import type { AudioCaptureOptions, CreateLocalTracksOptions, VideoCaptureOptions } from './options';
 import type { AudioTrack } from './types';
 
@@ -115,102 +114,28 @@ export function getNewAudioContext(): AudioContext | void {
   }
 }
 
-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
+ * @internal
  */
-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;
-    }
+export function kindToSource(kind: MediaDeviceKind) {
+  if (kind === 'audioinput') {
+    return Track.Source.Microphone;
+  } else if (kind === 'videoinput') {
+    return Track.Source.Camera;
+  } else {
+    return Track.Source.Unknown;
   }
-
-  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
+ * @internal
  */
-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 === '') {
+export function sourceToKind(source: Track.Source): MediaDeviceKind | undefined {
+  if (source === Track.Source.Microphone) {
+    return 'audioinput';
+  } else if (source === Track.Source.Camera) {
+    return 'videoinput';
+  } else {
     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/utils.ts

@@ -4,6 +4,7 @@ import type { DetectableBrowser } from '../utils/browserParser';
 import { protocolVersion, version } from '../version';
 import type LocalAudioTrack from './track/LocalAudioTrack';
 import type RemoteAudioTrack from './track/RemoteAudioTrack';
+import { VideoCodec, videoCodecs } from './track/options';
 import { getNewAudioContext } from './track/utils';
 import type { LiveKitReactNativeInfo } from './types';
 
@@ -456,6 +457,10 @@ export class Mutex {
   }
 }
 
+export function isVideoCodec(maybeCodec: string): maybeCodec is VideoCodec {
+  return videoCodecs.includes(maybeCodec as VideoCodec);
+}
+
 export function unwrapConstraint(constraint: ConstrainDOMString): string {
   if (typeof constraint === 'string') {
     return constraint;

package/src/room/worker.d.ts

@@ -0,0 +1,4 @@
+declare module 'web-worker:*' {
+  const WorkerFactory: new () => Worker;
+  export default WorkerFactory;
+}

package/src/test/MockMediaStreamTrack.ts

@@ -1,4 +1,5 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
+// @ts-ignore
 export default class MockMediaStreamTrack implements MediaStreamTrack {
   contentHint: string = '';