@livedigital/client 2.18.2 → 2.19.1

package/dist/types/common.d.ts

@@ -212,3 +212,9 @@ export declare type TransportConnectionTimeoutPayload = {
     direction: 'receive' | 'send';
     timeout: number;
 };
+export declare enum DeviceErrors {
+    NotFoundError = "NotFoundError",
+    NoDevices = "NoDevices",
+    DeviceIsBusy = "DeviceIsBusy",
+    NotAllowedError = "NotAllowedError"
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@livedigital/client",
   "author": "vlprojects",
   "license": "MIT",
-  "version": "2.18.2",
+  "version": "2.19.1",
   "private": false,
   "bugs": {
     "url": "https://github.com/vlprojects/livedigital-sdk/issues"

package/src/engine/index.ts

@@ -208,6 +208,11 @@ class Engine {
   }
 
   public setPeer(peerData: PeerResponse): Peer {
+    const existingPeer = this.peersRepository.get(peerData.id);
+    if (existingPeer) {
+      return existingPeer;
+    }
+
     const peer = new Peer({
       ...peerData,
       engine: this,

package/src/engine/system/index.ts

@@ -1,7 +1,7 @@
 import { CreateSystemParams } from '../../types/engine';
 import { CLIENT_EVENTS } from '../../constants/events';
 import EnhancedEventEmitter from '../../EnhancedEventEmitter';
-import { AvailableMediaDevices } from '../../types/common';
+import { AvailableMediaDevices, DeviceErrors } from '../../types/common';
 import Logger from '../Logger';
 
 class System {
@@ -15,8 +15,6 @@ class System {
 
   public availableAudioDevices: MediaDeviceInfo[] = [];
 
-  private isMediaDevicesAccessGranted = false;
-
   public clientEventEmitter: EnhancedEventEmitter;
 
   private readonly logger: Logger;
@@ -28,6 +26,9 @@ class System {
       namespace: 'System',
       logLevel,
     });
+
+    this.deviceChangeHandler = this.deviceChangeHandler.bind(this);
+
     this.listenDevices();
   }
 
@@ -47,23 +48,28 @@ class System {
     this.availableAudioDevices = availableAudioDevices;
   }
 
-  async requestMediaDevicesAccess(): Promise<void> {
+  async requestMediaDevicesAccess(constraints: MediaStreamConstraints = { video: true, audio: true }): Promise<void> {
     try {
-      const stream = await navigator.mediaDevices.getUserMedia({
-        video: true,
-        audio: true,
-      });
+      const stream = await navigator.mediaDevices.getUserMedia(constraints);
       stream.getTracks().forEach((track) => track.stop());
-      this.isMediaDevicesAccessGranted = true;
     } catch (error) {
-      this.logger.error('getUserMedia()', { error });
+      this.logger.error('getUserMedia()', { error, constraints });
+
+      if (error.name === 'NotAllowedError') {
+        throw new Error(DeviceErrors.NotAllowedError);
+      }
+
       if (error.name === 'NotReadableError') {
-        throw new Error('DeviceIsBusy');
+        throw new Error(DeviceErrors.DeviceIsBusy);
+      }
+
+      if (error.name === 'NotFoundError') {
+        throw new Error(DeviceErrors.NotFoundError);
       }
     }
   }
 
-  async refreshAvailableMediaDevicesList(): Promise<void> {
+  async refreshAvailableMediaDevicesList(): Promise<MediaDeviceInfo[]> {
     const devices = await navigator.mediaDevices.enumerateDevices();
     const videoDevices = [] as MediaDeviceInfo[];
     const audioDevices = [] as MediaDeviceInfo[];
@@ -72,10 +78,6 @@ class System {
         return;
       }
 
-      if (device.deviceId === 'default') {
-        return;
-      }
-
       if (device.kind === 'videoinput') {
         videoDevices.push(device);
       }
@@ -89,6 +91,8 @@ class System {
     this.setAvailableAudioDevices(audioDevices);
 
     this.logger.debug('Devices list updated');
+
+    return devices;
   }
 
   async detectDevices(): Promise<void> {
@@ -96,31 +100,52 @@ class System {
       return;
     }
 
-    if (!this.isMediaDevicesAccessGranted) {
+    try {
       await this.requestMediaDevicesAccess();
+    } catch (errorVideoAndAudio) {
+      if (errorVideoAndAudio.message !== DeviceErrors.NotFoundError) {
+        throw errorVideoAndAudio;
+      }
+
+      try {
+        await this.requestMediaDevicesAccess({ audio: true });
+      } catch (errorAudioOnly) {
+        if (errorAudioOnly.message !== DeviceErrors.NotFoundError) {
+          throw errorAudioOnly;
+        }
+
+        await this.requestMediaDevicesAccess({ video: true });
+      }
     }
 
-    navigator.mediaDevices.addEventListener('devicechange', () => {
-      this.refreshAvailableMediaDevicesList();
-    });
+    this.isDevicesDetected = true;
+
+    // at this moment or access to device granted or no devices exists
+
+    const rawDevices = await this.refreshAvailableMediaDevicesList();
+    const hasAudioInputDevices = rawDevices.some((x) => x.kind === 'audioinput');
+    const hasVideoInputDevices = rawDevices.some((x) => x.kind === 'videoinput');
+
+    if (!hasAudioInputDevices && !hasVideoInputDevices) {
+      throw new Error(DeviceErrors.NoDevices);
+    }
+  }
+
+  async deviceChangeHandler(): Promise<void> {
+    if (!this.isDevicesDetected) {
+      return;
+    }
 
     await this.refreshAvailableMediaDevicesList();
 
-    this.isDevicesDetected = true;
+    this.clientEventEmitter.safeEmit(CLIENT_EVENTS.devicesListUpdated, {
+      audio: this.availableAudioDevices,
+      video: this.availableVideoDevices,
+    } as AvailableMediaDevices);
   }
 
   listenDevices(): void {
-    navigator.mediaDevices.ondevicechange = async () => {
-      if (!this.isDevicesDetected) {
-        return;
-      }
-
-      await this.refreshAvailableMediaDevicesList();
-      this.clientEventEmitter.safeEmit(CLIENT_EVENTS.devicesListUpdated, {
-        audio: this.availableAudioDevices,
-        video: this.availableVideoDevices,
-      } as AvailableMediaDevices);
-    };
+    navigator.mediaDevices.addEventListener('devicechange', this.deviceChangeHandler);
   }
 }
 

package/src/types/common.ts

@@ -245,3 +245,10 @@ export type TransportConnectionTimeoutPayload = {
   direction: 'receive' | 'send',
   timeout: number,
 };
+
+export enum DeviceErrors {
+  NotFoundError = 'NotFoundError',
+  NoDevices = 'NoDevices',
+  DeviceIsBusy = 'DeviceIsBusy',
+  NotAllowedError = 'NotAllowedError',
+}