livekit-client 0.18.4-RC7 → 0.18.5

package/src/room/DeviceManager.ts

@@ -0,0 +1,80 @@
+const defaultId = 'default';
+
+export default class DeviceManager {
+  private static instance?: DeviceManager;
+
+  static mediaDeviceKinds: MediaDeviceKind[] = ['audioinput', 'audiooutput', 'videoinput'];
+
+  static getInstance(): DeviceManager {
+    if (this.instance === undefined) {
+      this.instance = new DeviceManager();
+    }
+    return this.instance;
+  }
+
+  async getDevices(
+    kind?: MediaDeviceKind,
+    requestPermissions: boolean = true,
+  ): Promise<MediaDeviceInfo[]> {
+    let devices = await navigator.mediaDevices.enumerateDevices();
+
+    if (requestPermissions) {
+      const isDummyDeviceOrEmpty =
+        devices.length === 0 ||
+        devices.some((device) => {
+          const noLabel = device.label === '';
+          const isRelevant = kind ? device.kind === kind : true;
+          return noLabel && isRelevant;
+        });
+
+      if (isDummyDeviceOrEmpty) {
+        const permissionsToAcquire = {
+          video: kind !== 'audioinput' && kind !== 'audiooutput',
+          audio: kind !== 'videoinput',
+        };
+        await navigator.mediaDevices.getUserMedia(permissionsToAcquire);
+        devices = await navigator.mediaDevices.enumerateDevices();
+      }
+    }
+    if (kind) {
+      devices = devices.filter((device) => device.kind === kind);
+    }
+
+    // Chrome returns 'default' devices, we would filter them out, but put the default
+    // device at first
+    // we would only do this if there are more than 1 device though
+    if (devices.length > 1 && devices[0].deviceId === defaultId) {
+      // find another device with matching group id, and move that to 0
+      const defaultDevice = devices[0];
+      for (let i = 1; i < devices.length; i += 1) {
+        if (devices[i].groupId === defaultDevice.groupId) {
+          const temp = devices[0];
+          devices[0] = devices[i];
+          devices[i] = temp;
+          break;
+        }
+      }
+      return devices.filter((device) => device !== defaultDevice);
+    }
+
+    return devices;
+  }
+
+  async normalizeDeviceId(
+    kind: MediaDeviceKind,
+    deviceId?: string,
+    groupId?: string,
+  ): Promise<string | undefined> {
+    if (deviceId !== defaultId) {
+      return deviceId;
+    }
+
+    // resolve actual device id if it's 'default': Chrome returns it when no
+    // device has been chosen
+    const devices = await this.getDevices(kind);
+
+    const device = devices.find((d) => d.groupId === groupId && d.deviceId !== defaultId);
+
+    return device?.deviceId;
+  }
+}

package/src/room/PCTransport.ts

@@ -0,0 +1,88 @@
+import { debounce } from 'ts-debounce';
+import log from '../logger';
+
+/** @internal */
+export default class PCTransport {
+  pc: RTCPeerConnection;
+
+  pendingCandidates: RTCIceCandidateInit[] = [];
+
+  restartingIce: boolean = false;
+
+  renegotiate: boolean = false;
+
+  onOffer?: (offer: RTCSessionDescriptionInit) => void;
+
+  constructor(config?: RTCConfiguration) {
+    this.pc = new RTCPeerConnection(config);
+  }
+
+  get isICEConnected(): boolean {
+    return this.pc.iceConnectionState === 'connected' || this.pc.iceConnectionState === 'completed';
+  }
+
+  async addIceCandidate(candidate: RTCIceCandidateInit): Promise<void> {
+    if (this.pc.remoteDescription && !this.restartingIce) {
+      return this.pc.addIceCandidate(candidate);
+    }
+    this.pendingCandidates.push(candidate);
+  }
+
+  async setRemoteDescription(sd: RTCSessionDescriptionInit): Promise<void> {
+    await this.pc.setRemoteDescription(sd);
+
+    this.pendingCandidates.forEach((candidate) => {
+      this.pc.addIceCandidate(candidate);
+    });
+    this.pendingCandidates = [];
+    this.restartingIce = false;
+
+    if (this.renegotiate) {
+      this.renegotiate = false;
+      this.createAndSendOffer();
+    }
+  }
+
+  // debounced negotiate interface
+  negotiate = debounce(() => {
+    this.createAndSendOffer();
+  }, 100);
+
+  async createAndSendOffer(options?: RTCOfferOptions) {
+    if (this.onOffer === undefined) {
+      return;
+    }
+
+    if (options?.iceRestart) {
+      log.debug('restarting ICE');
+      this.restartingIce = true;
+    }
+
+    if (this.pc.signalingState === 'have-local-offer') {
+      // we're waiting for the peer to accept our offer, so we'll just wait
+      // the only exception to this is when ICE restart is needed
+      const currentSD = this.pc.remoteDescription;
+      if (options?.iceRestart && currentSD) {
+        // TODO: handle when ICE restart is needed but we don't have a remote description
+        // the best thing to do is to recreate the peerconnection
+        await this.pc.setRemoteDescription(currentSD);
+      } else {
+        this.renegotiate = true;
+        return;
+      }
+    } else if (this.pc.signalingState === 'closed') {
+      log.warn('could not createOffer with closed peer connection');
+      return;
+    }
+
+    // actually negotiate
+    log.debug('starting to negotiate');
+    const offer = await this.pc.createOffer(options);
+    await this.pc.setLocalDescription(offer);
+    this.onOffer(offer);
+  }
+
+  close() {
+    this.pc.close();
+  }
+}