livekit-client 2.22.3 → 2.23.0

package/src/room/utils.ts

@@ -300,6 +300,33 @@ export function isSafariBased(): boolean {
   return b?.name === 'Safari' || b?.os === 'iOS';
 }
 
+/**
+ * iPadOS has sent the desktop Macintosh user agent by default since iPadOS 13, so `getBrowser()`
+ * reports `os: 'macOS'` there and every `os === 'iOS'` check misses it. macOS Safari implements no
+ * touch events at all (`TouchEvent` undefined, `maxTouchPoints` 0) regardless of any touchscreen
+ * attached, so touch capability separates the two. Measured on an iPad 6 / iPadOS 17
+ * (`maxTouchPoints` 5) against macOS Safari 26.4 (`maxTouchPoints` 0).
+ *
+ * Deliberately a separate helper rather than a fix in `browserParser`: iPadOS spoofs the Mac
+ * version too, so reporting `os: 'iOS'` there would leave `osVersion` at `10.15.7` and silently
+ * break {@link isSafari17Based} and {@link isSafariSvcApi}, which compare it.
+ */
+export function isIPadOS(): boolean {
+  if (!isWeb()) {
+    return false;
+  }
+  const b = getBrowser();
+  return b?.name === 'Safari' && b?.os === 'macOS' && navigator.maxTouchPoints > 1;
+}
+
+/**
+ * iPhone, iPad and iOS-hosted browsers — everything running the Apple camera capture pipeline,
+ * including iPads that present themselves as a Mac.
+ */
+export function isAppleMobile(): boolean {
+  return getBrowser()?.os === 'iOS' || isIPadOS();
+}
+
 export function isSafari17Based(): boolean {
   const b = getBrowser();
   return (
@@ -532,6 +559,17 @@ export function createDummyVideoStreamTrack(
 
 let emptyAudioStreamTrack: MediaStreamTrack | undefined;
 
+let emptyAudioStreamContext: AudioContext | undefined;
+
+/** tracks handed out by `getEmptyAudioStreamTrack` that haven't been released yet */
+const outstandingEmptyAudioStreamTracks = new Set<MediaStreamTrack>();
+
+/**
+ * Returns a silent audio track, cloned off a shared `AudioContext` created on first use. Hand the
+ * clone back to `releaseEmptyAudioStreamTrack` rather than stopping it, so the context can close.
+ * A clone that is only stopped stays counted as outstanding, which holds the shared context open
+ * for the lifetime of the page.
+ */
 export function getEmptyAudioStreamTrack() {
   if (!emptyAudioStreamTrack) {
     // implementation adapted from https://blog.mozilla.org/webrtc/warm-up-with-replacetrack/
@@ -545,31 +583,37 @@ export function getEmptyAudioStreamTrack() {
     oscillator.start();
     [emptyAudioStreamTrack] = dst.stream.getAudioTracks();
     if (!emptyAudioStreamTrack) {
+      // don't hold on to a context we can't get a track out of
+      ctx.close().catch(() => {});
       throw Error('Could not get empty media stream audio track');
     }
     emptyAudioStreamTrack.enabled = false;
+    emptyAudioStreamContext = ctx;
   }
-  return emptyAudioStreamTrack.clone();
+  const track = emptyAudioStreamTrack.clone();
+  outstandingEmptyAudioStreamTracks.add(track);
+  return track;
 }
 
-export function getStereoAudioStreamTrack() {
-  const ctx = new AudioContext();
-  const oscLeft = ctx.createOscillator();
-  const oscRight = ctx.createOscillator();
-  oscLeft.frequency.value = 440;
-  oscRight.frequency.value = 220;
-  const merger = ctx.createChannelMerger(2);
-  oscLeft.connect(merger, 0, 0); // left channel
-  oscRight.connect(merger, 0, 1); // right channel
-  const dst = ctx.createMediaStreamDestination();
-  merger.connect(dst);
-  oscLeft.start();
-  oscRight.start();
-  const [stereoTrack] = dst.stream.getAudioTracks();
-  if (!stereoTrack) {
-    throw Error('Could not get stereo media stream audio track');
+/**
+ * Stops a track obtained from `getEmptyAudioStreamTrack` and closes the shared `AudioContext`
+ * backing it once every track it handed out has been released. Does nothing for a track this
+ * module never handed out, or one that has been released already.
+ */
+export async function releaseEmptyAudioStreamTrack(track: MediaStreamTrack) {
+  if (!outstandingEmptyAudioStreamTracks.delete(track)) {
+    // the track wasn't obtained from `getEmptyAudioStreamTrack`, or has been released before
+    return;
+  }
+  track.stop();
+  if (outstandingEmptyAudioStreamTracks.size > 0) {
+    return;
   }
-  return stereoTrack;
+  const context = emptyAudioStreamContext;
+  emptyAudioStreamTrack?.stop();
+  emptyAudioStreamTrack = undefined;
+  emptyAudioStreamContext = undefined;
+  await context?.close();
 }
 
 /** An object that represents a serialized version of a `new Promise((resolve, reject) => {})`
@@ -681,11 +725,20 @@ export function createAudioAnalyser(
     return volume;
   };
 
+  let isCleanedUp = false;
+
   const cleanup = async () => {
-    await audioContext.close();
+    if (isCleanedUp) {
+      // closing an already closed context would reject, make repeated cleanups a no-op instead
+      return;
+    }
+    isCleanedUp = true;
+    mediaStreamSource.disconnect();
+    analyser.disconnect();
     if (opts.cloneTrack) {
       streamTrack.stop();
     }
+    await audioContext.close();
   };
 
   return { calculateVolume, analyser, cleanup };
@@ -724,6 +777,43 @@ export function unwrapConstraint(constraint: ConstrainDOMString | ConstrainULong
   throw Error('could not unwrap constraint');
 }
 
+/**
+ * The getUserMedia rejections that no softer constraint can recover from, because the user or the
+ * document refused capture outright. Retrying one of these would put a second prompt in front of
+ * someone who already said no. The last two names are legacy spellings still reported by older
+ * engines. Matched by `name` rather than with `instanceof`, because these are not reliably distinct
+ * constructors across environments. happy-dom, which the tests run under, aliases them to `Event`.
+ */
+export function isPermissionDeniedError(e: unknown): boolean {
+  return (
+    typeof e === 'object' &&
+    e !== null &&
+    'name' in e &&
+    (e.name === 'NotAllowedError' ||
+      e.name === 'SecurityError' ||
+      e.name === 'PermissionDeniedError' ||
+      e.name === 'PermissionDismissedError')
+  );
+}
+
+const deviceAcquisitionFailures = new WeakSet();
+
+/** Records that `e` is the rejection getUserMedia itself produced. */
+export function markDeviceAcquisitionFailure(e: unknown) {
+  if (typeof e === 'object' && e !== null) {
+    deviceAcquisitionFailures.add(e);
+  }
+}
+
+/**
+ * Whether a track restart failed at getUserMedia rather than in the work that adopts the new track.
+ * Recorded on the side rather than by wrapping, because callers of `restartTrack` match on the
+ * rejection's own name.
+ */
+export function isDeviceAcquisitionFailure(e: unknown): boolean {
+  return typeof e === 'object' && e !== null && deviceAcquisitionFailures.has(e);
+}
+
 export function toWebsocketUrl(url: string): string {
   if (url.startsWith('http')) {
     return url.replace(/^(http)/, 'ws');
@@ -961,6 +1051,49 @@ export function isCompressionStreamSupported() {
   return typeof CompressionStream !== 'undefined';
 }
 
+let deflateRawCompressionSupported: boolean | null = null;
+
+/**
+ * Whether this runtime can compress AND decompress the `deflate-raw` format, which is a stricter
+ * requirement than {@link isCompressionStreamSupported}: Chromium 80-102 included
+ * `CompressionStream` supporting only `gzip` / `deflate`, and `deflate-raw` was added in Chromium
+ * 103 (Firefox 113, Safari 16.4).
+ */
+export function isDeflateRawCompressionSupported(): boolean {
+  if (typeof deflateRawCompressionSupported !== 'boolean') {
+    deflateRawCompressionSupported = probeDeflateRawCompressionSupport();
+  }
+  return deflateRawCompressionSupported;
+}
+
+function probeDeflateRawCompressionSupport(): boolean {
+  if (typeof CompressionStream === 'undefined' || typeof DecompressionStream === 'undefined') {
+    return false;
+  }
+  try {
+    // There is no api to query format support, and constructing with an unsupported format throws
+    // synchronously, so constructing one of each is the probe. Both are checked because the
+    // deflate-raw capability advertised to peers is as much about decompressing what they send us
+    // as it is about compressing what we send them.
+    new CompressionStream('deflate-raw');
+    new DecompressionStream('deflate-raw');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Clears the memoized {@link isDeflateRawCompressionSupported} probe result. A runtime doesn't
+ * gain or lose compression formats while it is running, so this only exists for tests that swap
+ * the global `CompressionStream` / `DecompressionStream`.
+ *
+ * @internal
+ */
+export function resetDeflateRawCompressionSupportCache() {
+  deflateRawCompressionSupported = null;
+}
+
 export function isPublisherOfferWithJoinSupported() {
   // we have connectivity issue about publisher offer with join on firefox #1919
   return isCompressionStreamSupported() && !isFireFox();

package/src/test/compressionStreamStubs.ts

@@ -0,0 +1,53 @@
+import { resetDeflateRawCompressionSupportCache } from '../room/utils';
+
+/**
+ * Swaps the global `CompressionStream` / `DecompressionStream` away entirely, emulating a runtime
+ * that predates the compression streams api. Returns a function that restores them.
+ */
+export function stubMissingCompressionStreams(): () => void {
+  return stubCompressionStreams(undefined, undefined);
+}
+
+/**
+ * Swaps in global `CompressionStream` / `DecompressionStream` constructors that reject the
+ * `deflate-raw` format the way Chromium 80-102 does (the api exists, but only `gzip` / `deflate`
+ * are supported). Returns a function that restores the real ones.
+ */
+export function stubMissingDeflateRawSupport(): () => void {
+  return stubCompressionStreams(
+    legacyFormatsOnly('CompressionStream', CompressionStream),
+    legacyFormatsOnly('DecompressionStream', DecompressionStream),
+  );
+}
+
+type CompressionStreamCtor<T> = new (format: CompressionFormat) => T;
+
+function legacyFormatsOnly<T>(
+  name: string,
+  Real: CompressionStreamCtor<T>,
+): CompressionStreamCtor<T> {
+  return function LegacyCompressionStream(format: CompressionFormat) {
+    if (format === 'deflate-raw') {
+      throw new TypeError(
+        `Failed to construct '${name}': Unsupported compression format: 'deflate-raw'`,
+      );
+    }
+    return new Real(format);
+  } as unknown as CompressionStreamCtor<T>;
+}
+
+function stubCompressionStreams(compression: unknown, decompression: unknown): () => void {
+  const originalCompressionStream = globalThis.CompressionStream;
+  const originalDecompressionStream = globalThis.DecompressionStream;
+  (globalThis as any).CompressionStream = compression;
+  (globalThis as any).DecompressionStream = decompression;
+  // The support probe memoizes, which is only safe because a real runtime never changes formats
+  // mid-session; swapping the globals has to invalidate it.
+  resetDeflateRawCompressionSupportCache();
+
+  return () => {
+    (globalThis as any).CompressionStream = originalCompressionStream;
+    (globalThis as any).DecompressionStream = originalDecompressionStream;
+    resetDeflateRawCompressionSupportCache();
+  };
+}