livekit-client 2.9.1 → 2.9.2

package/src/connectionHelper/ConnectionCheck.ts

@@ -2,6 +2,8 @@ import { EventEmitter } from 'events';
 import type TypedEmitter from 'typed-emitter';
 import type { CheckInfo, CheckerOptions, InstantiableCheck } from './checks/Checker';
 import { CheckStatus, Checker } from './checks/Checker';
+import { CloudRegionCheck } from './checks/cloudRegion';
+import { ConnectionProtocolCheck, type ProtocolStats } from './checks/connectionProtocol';
 import { PublishAudioCheck } from './checks/publishAudio';
 import { PublishVideoCheck } from './checks/publishVideo';
 import { ReconnectCheck } from './checks/reconnect';
@@ -86,6 +88,19 @@ export class ConnectionCheck extends (EventEmitter as new () => TypedEmitter<Con
   async checkPublishVideo() {
     return this.createAndRunCheck(PublishVideoCheck);
   }
+
+  async checkConnectionProtocol() {
+    const info = await this.createAndRunCheck(ConnectionProtocolCheck);
+    if (info.data && 'protocol' in info.data) {
+      const stats = info.data as ProtocolStats;
+      this.options.protocol = stats.protocol;
+    }
+    return info;
+  }
+
+  async checkCloudRegion() {
+    return this.createAndRunCheck(CloudRegionCheck);
+  }
 }
 
 type ConnectionCheckCallbacks = {

package/src/connectionHelper/checks/Checker.ts

@@ -3,6 +3,9 @@ import type TypedEmitter from 'typed-emitter';
 import type { RoomConnectOptions, RoomOptions } from '../../options';
 import type RTCEngine from '../../room/RTCEngine';
 import Room, { ConnectionState } from '../../room/Room';
+import { RoomEvent } from '../../room/events';
+import type { SimulationScenario } from '../../room/types';
+import { sleep } from '../../room/utils';
 
 type LogMessage = {
   level: 'info' | 'warning' | 'error';
@@ -22,12 +25,14 @@ export type CheckInfo = {
   logs: Array<LogMessage>;
   status: CheckStatus;
   description: string;
+  data?: any;
 };
 
 export interface CheckerOptions {
   errorsAsWarnings?: boolean;
   roomOptions?: RoomOptions;
   connectOptions?: RoomConnectOptions;
+  protocol?: 'udp' | 'tcp';
 }
 
 export abstract class Checker extends (EventEmitter as new () => TypedEmitter<CheckerCallbacks>) {
@@ -43,10 +48,10 @@ export abstract class Checker extends (EventEmitter as new () => TypedEmitter<Ch
 
   logs: Array<LogMessage> = [];
 
-  errorsAsWarnings: boolean = false;
-
   name: string;
 
+  options: CheckerOptions = {};
+
   constructor(url: string, token: string, options: CheckerOptions = {}) {
     super();
     this.url = url;
@@ -54,9 +59,7 @@ export abstract class Checker extends (EventEmitter as new () => TypedEmitter<Ch
     this.name = this.constructor.name;
     this.room = new Room(options.roomOptions);
     this.connectOptions = options.connectOptions;
-    if (options.errorsAsWarnings) {
-      this.errorsAsWarnings = options.errorsAsWarnings;
-    }
+    this.options = options;
   }
 
   abstract get description(): string;
@@ -73,7 +76,7 @@ export abstract class Checker extends (EventEmitter as new () => TypedEmitter<Ch
       await this.perform();
     } catch (err) {
       if (err instanceof Error) {
-        if (this.errorsAsWarnings) {
+        if (this.options.errorsAsWarnings) {
           this.appendWarning(err.message);
         } else {
           this.appendError(err.message);
@@ -101,11 +104,14 @@ export abstract class Checker extends (EventEmitter as new () => TypedEmitter<Ch
     return !this.logs.some((l) => l.level === 'error');
   }
 
-  protected async connect(): Promise<Room> {
+  protected async connect(url?: string): Promise<Room> {
     if (this.room.state === ConnectionState.Connected) {
       return this.room;
     }
-    await this.room.connect(this.url, this.token, this.connectOptions);
+    if (!url) {
+      url = this.url;
+    }
+    await this.room.connect(url, this.token, this.connectOptions);
     return this.room;
   }
 
@@ -121,6 +127,33 @@ export abstract class Checker extends (EventEmitter as new () => TypedEmitter<Ch
     this.setStatus(CheckStatus.SKIPPED);
   }
 
+  protected async switchProtocol(protocol: 'udp' | 'tcp' | 'tls') {
+    let hasReconnecting = false;
+    let hasReconnected = false;
+    this.room.on(RoomEvent.Reconnecting, () => {
+      hasReconnecting = true;
+    });
+    this.room.once(RoomEvent.Reconnected, () => {
+      hasReconnected = true;
+    });
+    this.room.simulateScenario(`force-${protocol}` as SimulationScenario);
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    if (!hasReconnecting) {
+      // no need to wait for reconnection
+      return;
+    }
+
+    // wait for 10 seconds for reconnection
+    const timeout = Date.now() + 10000;
+    while (Date.now() < timeout) {
+      if (hasReconnected) {
+        return;
+      }
+      await sleep(100);
+    }
+    throw new Error(`Could not reconnect using ${protocol} protocol after 10 seconds`);
+  }
+
   protected appendMessage(message: string) {
     this.logs.push({ level: 'info', message });
     this.emit('update', this.getInfo());

package/src/connectionHelper/checks/cloudRegion.ts

@@ -0,0 +1,94 @@
+import { RegionUrlProvider } from '../../room/RegionUrlProvider';
+import { type CheckInfo, Checker } from './Checker';
+
+export interface RegionStats {
+  region: string;
+  rtt: number;
+  duration: number;
+}
+
+/**
+ * Checks for connections quality to closests Cloud regions and determining the best quality
+ */
+export class CloudRegionCheck extends Checker {
+  private bestStats?: RegionStats;
+
+  get description(): string {
+    return 'Cloud regions';
+  }
+
+  async perform(): Promise<void> {
+    const regionProvider = new RegionUrlProvider(this.url, this.token);
+    if (!regionProvider.isCloud()) {
+      this.skip();
+      return;
+    }
+
+    const regionStats: RegionStats[] = [];
+    const seenUrls: Set<string> = new Set();
+    for (let i = 0; i < 3; i++) {
+      const regionUrl = await regionProvider.getNextBestRegionUrl();
+      if (!regionUrl) {
+        break;
+      }
+      if (seenUrls.has(regionUrl)) {
+        continue;
+      }
+      seenUrls.add(regionUrl);
+      const stats = await this.checkCloudRegion(regionUrl);
+      this.appendMessage(`${stats.region} RTT: ${stats.rtt}ms, duration: ${stats.duration}ms`);
+      regionStats.push(stats);
+    }
+
+    regionStats.sort((a, b) => {
+      return (a.duration - b.duration) * 0.5 + (a.rtt - b.rtt) * 0.5;
+    });
+    const bestRegion = regionStats[0];
+    this.bestStats = bestRegion;
+    this.appendMessage(`best Cloud region: ${bestRegion.region}`);
+  }
+
+  getInfo(): CheckInfo {
+    const info = super.getInfo();
+    info.data = this.bestStats;
+    return info;
+  }
+
+  private async checkCloudRegion(url: string): Promise<RegionStats> {
+    await this.connect(url);
+    if (this.options.protocol === 'tcp') {
+      await this.switchProtocol('tcp');
+    }
+    const region = this.room.serverInfo?.region;
+    if (!region) {
+      throw new Error('Region not found');
+    }
+
+    const writer = await this.room.localParticipant.streamText({ topic: 'test' });
+    const chunkSize = 1000; // each chunk is about 1000 bytes
+    const totalSize = 1_000_000; // approximately 1MB of data
+    const numChunks = totalSize / chunkSize; // will yield 1000 chunks
+    const chunkData = 'A'.repeat(chunkSize); // create a string of 1000 'A' characters
+
+    const startTime = Date.now();
+    for (let i = 0; i < numChunks; i++) {
+      await writer.write(chunkData);
+    }
+    await writer.close();
+    const endTime = Date.now();
+    const stats = await this.room.engine.pcManager?.publisher.getStats();
+    const regionStats: RegionStats = {
+      region: region,
+      rtt: 10000,
+      duration: endTime - startTime,
+    };
+    stats?.forEach((stat) => {
+      if (stat.type === 'candidate-pair' && stat.nominated) {
+        regionStats.rtt = stat.currentRoundTripTime * 1000;
+      }
+    });
+
+    await this.disconnect();
+    return regionStats;
+  }
+}

package/src/connectionHelper/checks/connectionProtocol.ts

@@ -0,0 +1,149 @@
+import { type CheckInfo, Checker } from './Checker';
+
+export interface ProtocolStats {
+  protocol: 'udp' | 'tcp';
+  packetsLost: number;
+  packetsSent: number;
+  qualityLimitationDurations: Record<string, number>;
+  // total metrics measure sum of all measurements, along with a count
+  rttTotal: number;
+  jitterTotal: number;
+  bitrateTotal: number;
+  count: number;
+}
+
+const TEST_DURATION = 10000;
+
+export class ConnectionProtocolCheck extends Checker {
+  private bestStats?: ProtocolStats;
+
+  get description(): string {
+    return 'Connection via UDP vs TCP';
+  }
+
+  async perform(): Promise<void> {
+    const udpStats = await this.checkConnectionProtocol('udp');
+    const tcpStats = await this.checkConnectionProtocol('tcp');
+    this.bestStats = udpStats;
+    // udp should is the better protocol typically. however, we'd prefer TCP when either of these conditions are true:
+    // 1. the bandwidth limitation is worse on UDP by 500ms
+    // 2. the packet loss is higher on UDP by 1%
+    if (
+      udpStats.qualityLimitationDurations.bandwidth -
+        tcpStats.qualityLimitationDurations.bandwidth >
+        0.5 ||
+      (udpStats.packetsLost - tcpStats.packetsLost) / udpStats.packetsSent > 0.01
+    ) {
+      this.appendMessage('best connection quality via tcp');
+      this.bestStats = tcpStats;
+    } else {
+      this.appendMessage('best connection quality via udp');
+    }
+
+    const stats = this.bestStats;
+    this.appendMessage(
+      `upstream bitrate: ${(stats.bitrateTotal / stats.count / 1000 / 1000).toFixed(2)} mbps`,
+    );
+    this.appendMessage(`RTT: ${((stats.rttTotal / stats.count) * 1000).toFixed(2)} ms`);
+    this.appendMessage(`jitter: ${((stats.jitterTotal / stats.count) * 1000).toFixed(2)} ms`);
+
+    if (stats.packetsLost > 0) {
+      this.appendWarning(
+        `packets lost: ${((stats.packetsLost / stats.packetsSent) * 100).toFixed(2)}%`,
+      );
+    }
+    if (stats.qualityLimitationDurations.bandwidth > 1) {
+      this.appendWarning(
+        `bandwidth limited ${((stats.qualityLimitationDurations.bandwidth / (TEST_DURATION / 1000)) * 100).toFixed(2)}%`,
+      );
+    }
+    if (stats.qualityLimitationDurations.cpu > 0) {
+      this.appendWarning(
+        `cpu limited ${((stats.qualityLimitationDurations.cpu / (TEST_DURATION / 1000)) * 100).toFixed(2)}%`,
+      );
+    }
+  }
+
+  getInfo(): CheckInfo {
+    const info = super.getInfo();
+    info.data = this.bestStats;
+    return info;
+  }
+
+  private async checkConnectionProtocol(protocol: 'tcp' | 'udp'): Promise<ProtocolStats> {
+    await this.connect();
+    if (protocol === 'tcp') {
+      await this.switchProtocol('tcp');
+    } else {
+      await this.switchProtocol('udp');
+    }
+
+    // create a canvas with animated content
+    const canvas = document.createElement('canvas');
+    canvas.width = 1280;
+    canvas.height = 720;
+    const ctx = canvas.getContext('2d');
+    if (!ctx) {
+      throw new Error('Could not get canvas context');
+    }
+
+    let hue = 0;
+    const animate = () => {
+      hue = (hue + 1) % 360;
+      ctx.fillStyle = `hsl(${hue}, 100%, 50%)`;
+      ctx.fillRect(0, 0, canvas.width, canvas.height);
+      requestAnimationFrame(animate);
+    };
+    animate();
+
+    // create video track from canvas
+    const stream = canvas.captureStream(30); // 30fps
+    const videoTrack = stream.getVideoTracks()[0];
+
+    // publish to room
+    const pub = await this.room.localParticipant.publishTrack(videoTrack, {
+      simulcast: false,
+      degradationPreference: 'maintain-resolution',
+      videoEncoding: {
+        maxBitrate: 2000000,
+      },
+    });
+    const track = pub!.track!;
+
+    const protocolStats: ProtocolStats = {
+      protocol,
+      packetsLost: 0,
+      packetsSent: 0,
+      qualityLimitationDurations: {},
+      rttTotal: 0,
+      jitterTotal: 0,
+      bitrateTotal: 0,
+      count: 0,
+    };
+    // gather stats once a second
+    const interval = setInterval(async () => {
+      const stats = await track.getRTCStatsReport();
+      stats?.forEach((stat) => {
+        if (stat.type === 'outbound-rtp') {
+          protocolStats.packetsSent = stat.packetsSent;
+          protocolStats.qualityLimitationDurations = stat.qualityLimitationDurations;
+          protocolStats.bitrateTotal += stat.targetBitrate;
+          protocolStats.count++;
+        } else if (stat.type === 'remote-inbound-rtp') {
+          protocolStats.packetsLost = stat.packetsLost;
+          protocolStats.rttTotal += stat.roundTripTime;
+          protocolStats.jitterTotal += stat.jitter;
+        }
+      });
+    }, 1000);
+
+    // wait a bit to gather stats
+    await new Promise((resolve) => setTimeout(resolve, TEST_DURATION));
+    clearInterval(interval);
+
+    videoTrack.stop();
+    canvas.remove();
+    await this.disconnect();
+    return protocolStats;
+  }
+}

package/src/connectionHelper/checks/publishAudio.ts

@@ -1,4 +1,5 @@
 import { createLocalAudioTrack } from '../../room/track/create';
+import { detectSilence } from '../../room/track/utils';
 import { Checker } from './Checker';
 
 export class PublishAudioCheck extends Checker {
@@ -10,6 +11,13 @@ export class PublishAudioCheck extends Checker {
     const room = await this.connect();
 
     const track = await createLocalAudioTrack();
+
+    const trackIsSilent = await detectSilence(track, 1000);
+    if (trackIsSilent) {
+      throw new Error('unable to detect audio from microphone');
+    }
+    this.appendMessage('detected audio from microphone');
+
     room.localParticipant.publishTrack(track);
     // wait for a few seconds to publish
     await new Promise((resolve) => setTimeout(resolve, 3000));

package/src/connectionHelper/checks/publishVideo.ts

@@ -10,6 +10,10 @@ export class PublishVideoCheck extends Checker {
     const room = await this.connect();
 
     const track = await createLocalVideoTrack();
+
+    // check if we have video from camera
+    await this.checkForVideo(track.mediaStreamTrack);
+
     room.localParticipant.publishTrack(track);
     // wait for a few seconds to publish
     await new Promise((resolve) => setTimeout(resolve, 5000));
@@ -33,4 +37,52 @@ export class PublishVideoCheck extends Checker {
     }
     this.appendMessage(`published ${numPackets} video packets`);
   }
+
+  async checkForVideo(track: MediaStreamTrack) {
+    const stream = new MediaStream();
+    stream.addTrack(track.clone());
+
+    // Create video element to check frames
+    const video = document.createElement('video');
+    video.srcObject = stream;
+    video.muted = true;
+
+    await new Promise<void>((resolve) => {
+      video.onplay = () => {
+        setTimeout(() => {
+          const canvas = document.createElement('canvas');
+          const settings = track.getSettings();
+          const width = settings.width ?? video.videoWidth ?? 1280;
+          const height = settings.height ?? video.videoHeight ?? 720;
+          canvas.width = width;
+          canvas.height = height;
+          const ctx = canvas.getContext('2d')!;
+
+          // Draw video frame to canvas
+          ctx.drawImage(video, 0, 0);
+
+          // Get image data and check if all pixels are black
+          const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+          const data = imageData.data;
+          let isAllBlack = true;
+          for (let i = 0; i < data.length; i += 4) {
+            if (data[i] !== 0 || data[i + 1] !== 0 || data[i + 2] !== 0) {
+              isAllBlack = false;
+              break;
+            }
+          }
+
+          if (isAllBlack) {
+            this.appendError('camera appears to be producing only black frames');
+          } else {
+            this.appendMessage('received video frames');
+          }
+          resolve();
+        }, 1000);
+      };
+      video.play();
+    });
+
+    video.remove();
+  }
 }

package/src/index.ts

@@ -95,6 +95,7 @@ export {
   Room,
   SubscriptionError,
   TrackPublication,
+  TrackType,
   compareVersions,
   createAudioAnalyser,
   getBrowser,
@@ -127,5 +128,4 @@ export type {
   VideoSenderStats,
   ReconnectContext,
   ReconnectPolicy,
-  TrackType,
 };

package/src/room/StreamReader.ts

@@ -1,5 +1,5 @@
 import type { DataStream_Chunk } from '@livekit/protocol';
-import type { BaseStreamInfo, ByteStreamInfo, TextStreamChunk, TextStreamInfo } from './types';
+import type { BaseStreamInfo, ByteStreamInfo, TextStreamInfo } from './types';
 import { bigIntToNumber } from './utils';
 
 abstract class BaseStreamReader<T extends BaseStreamInfo> {
@@ -124,7 +124,7 @@ export class TextStreamReader extends BaseStreamReader<TextStreamInfo> {
     const decoder = new TextDecoder();
 
     return {
-      next: async (): Promise<IteratorResult<TextStreamChunk>> => {
+      next: async (): Promise<IteratorResult<string>> => {
         try {
           const { done, value } = await reader.read();
           if (done) {
@@ -134,14 +134,7 @@ export class TextStreamReader extends BaseStreamReader<TextStreamInfo> {
 
             return {
               done: false,
-              value: {
-                index: bigIntToNumber(value.chunkIndex),
-                current: decoder.decode(value.content),
-                collected: Array.from(this.receivedChunks.values())
-                  .sort((a, b) => bigIntToNumber(a.chunkIndex) - bigIntToNumber(b.chunkIndex))
-                  .map((chunk) => decoder.decode(chunk.content))
-                  .join(''),
-              },
+              value: decoder.decode(value.content),
             };
           }
         } catch (error) {
@@ -150,7 +143,7 @@ export class TextStreamReader extends BaseStreamReader<TextStreamInfo> {
         }
       },
 
-      async return(): Promise<IteratorResult<TextStreamChunk>> {
+      async return(): Promise<IteratorResult<string>> {
         reader.releaseLock();
         return { done: true, value: undefined };
       },
@@ -158,11 +151,11 @@ export class TextStreamReader extends BaseStreamReader<TextStreamInfo> {
   }
 
   async readAll(): Promise<string> {
-    let latestString: string = '';
-    for await (const { collected } of this) {
-      latestString = collected;
+    let finalString: string = '';
+    for await (const chunk of this) {
+      finalString += chunk;
     }
-    return latestString;
+    return finalString;
   }
 }
 

package/src/room/StreamWriter.ts

@@ -1,15 +1,15 @@
 import type { BaseStreamInfo, ByteStreamInfo, TextStreamInfo } from './types';
 
 class BaseStreamWriter<T, InfoType extends BaseStreamInfo> {
-  protected writableStream: WritableStream<[T, number?]>;
+  protected writableStream: WritableStream<T>;
 
-  protected defaultWriter: WritableStreamDefaultWriter<[T, number?]>;
+  protected defaultWriter: WritableStreamDefaultWriter<T>;
 
   protected onClose?: () => void;
 
   readonly info: InfoType;
 
-  constructor(writableStream: WritableStream<[T, number?]>, info: InfoType, onClose?: () => void) {
+  constructor(writableStream: WritableStream<T>, info: InfoType, onClose?: () => void) {
     this.writableStream = writableStream;
     this.defaultWriter = writableStream.getWriter();
     this.onClose = onClose;
@@ -17,7 +17,7 @@ class BaseStreamWriter<T, InfoType extends BaseStreamInfo> {
   }
 
   write(chunk: T): Promise<void> {
-    return this.defaultWriter.write([chunk]);
+    return this.defaultWriter.write(chunk);
   }
 
   async close() {

package/src/room/participant/LocalParticipant.ts

@@ -90,6 +90,7 @@ import {
   isWeb,
   numberToBigInt,
   sleep,
+  splitUtf8,
   supportsAV1,
   supportsVP9,
 } from '../utils';
@@ -1536,19 +1537,9 @@ export default class LocalParticipant extends Participant {
       attachedStreamIds: fileIds,
     });
 
-    const textChunkSize = Math.floor(STREAM_CHUNK_SIZE / 4); // utf8 is at most 4 bytes long, so play it safe and take a quarter of the byte size to slice the string
-    const totalTextChunks = Math.ceil(totalTextLength / textChunkSize);
-
-    for (let i = 0; i < totalTextChunks; i++) {
-      const chunkData = text.slice(
-        i * textChunkSize,
-        Math.min((i + 1) * textChunkSize, totalTextLength),
-      );
-      await this.engine.waitForBufferStatusLow(DataPacket_Kind.RELIABLE);
-      await writer.write(chunkData);
-
-      handleProgress(Math.ceil((i + 1) / totalTextChunks), 0);
-    }
+    await writer.write(text);
+    // set text part of progress to 1
+    handleProgress(1, 0);
 
     await writer.close();
 
@@ -1614,20 +1605,13 @@ export default class LocalParticipant extends Participant {
     let chunkId = 0;
     const localP = this;
 
-    const writableStream = new WritableStream<[string, number?]>({
+    const writableStream = new WritableStream<string>({
       // Implement the sink
-      write([textChunk]) {
-        const textInBytes = new TextEncoder().encode(textChunk);
-
-        if (textInBytes.byteLength > STREAM_CHUNK_SIZE) {
-          this.abort?.();
-          throw new Error('chunk size too large');
-        }
-
-        return new Promise(async (resolve) => {
+      async write(text) {
+        for (const textChunk in splitUtf8(text, STREAM_CHUNK_SIZE)) {
           await localP.engine.waitForBufferStatusLow(DataPacket_Kind.RELIABLE);
           const chunk = new DataStream_Chunk({
-            content: textInBytes,
+            content: new TextEncoder().encode(textChunk),
             streamId,
             chunkIndex: numberToBigInt(chunkId),
           });
@@ -1641,8 +1625,7 @@ export default class LocalParticipant extends Participant {
           await localP.engine.sendDataPacket(chunkPacket, DataPacket_Kind.RELIABLE);
 
           chunkId += 1;
-          resolve();
-        });
+        }
       },
       async close() {
         const trailer = new DataStream_Trailer({

package/src/room/participant/publishUtils.ts

@@ -256,6 +256,10 @@ export function computeTrackBackupEncodings(
   const width = settings.width ?? track.dimensions?.width;
   const height = settings.height ?? track.dimensions?.height;
 
+  // disable simulcast for screenshare backup codec since L1Tx is used by primary codec
+  if (track.source === Track.Source.ScreenShare && opts.simulcast) {
+    opts.simulcast = false;
+  }
   const encodings = computeVideoEncodings(
     track.source === Track.Source.ScreenShare,
     width,

package/src/room/track/LocalTrack.ts

@@ -232,6 +232,7 @@ export default abstract class LocalTrack<
     ) {
       return true;
     }
+
     this._constraints.deviceId = deviceId;
 
     // when track is muted, underlying media stream track is stopped and
@@ -313,6 +314,7 @@ export default abstract class LocalTrack<
       if (!constraints) {
         constraints = this._constraints;
       }
+      const { deviceId, ...otherConstraints } = this._constraints;
       this.log.debug('restarting track with constraints', { ...this.logContext, constraints });
 
       const streamConstraints: MediaStreamConstraints = {
@@ -321,9 +323,9 @@ export default abstract class LocalTrack<
       };
 
       if (this.kind === Track.Kind.Video) {
-        streamConstraints.video = constraints;
+        streamConstraints.video = deviceId ? { deviceId } : true;
       } else {
-        streamConstraints.audio = constraints;
+        streamConstraints.audio = deviceId ? { deviceId } : true;
       }
 
       // these steps are duplicated from setMediaStreamTrack because we must stop
@@ -340,6 +342,7 @@ export default abstract class LocalTrack<
       // create new track and attach
       const mediaStream = await navigator.mediaDevices.getUserMedia(streamConstraints);
       const newTrack = mediaStream.getTracks()[0];
+      await newTrack.applyConstraints(otherConstraints);
       newTrack.addEventListener('ended', this.handleEnded);
       this.log.debug('re-acquired MediaStreamTrack', this.logContext);