@livedigital/client 1.1.5 → 1.4.1

package/src/engine/system/index.ts

@@ -21,14 +21,11 @@ class System {
 
   public currentVideoDeviceId?: string;
 
-  public getUserMediaError?: string = undefined;
-
-  public deviceIsBusy?: boolean = false;
-
   private readonly logger: Logger;
 
   constructor() {
     this.logger = new Logger('System');
+    this.listenDevices();
   }
 
   setIsEnableVideoDevicesLock(value: boolean): void {
@@ -98,26 +95,35 @@ class System {
     };
   }
 
-  async startVideoStream(params?: VideoConstraintParams): Promise<MediaStream | undefined> {
+  async getVideoTrack(): Promise<MediaStreamTrack> {
+    const videoStream = this.videoStream || await this.startVideoStream();
+    const [track] = videoStream.getVideoTracks();
+    return track;
+  }
+
+  async getAudioTrack(): Promise<MediaStreamTrack> {
+    const videoStream = this.videoStream || await this.startAudioStream();
+    const [track] = videoStream.getAudioTracks();
+    return track;
+  }
+
+  async startVideoStream(params?: VideoConstraintParams): Promise<MediaStream> {
     if (!this.videoStream || !this.videoStream.active) {
       try {
         this.videoStream = await navigator.mediaDevices.getUserMedia({
           video: this.getVideoConstraints(params),
         });
+        this.logger.debug('startVideoStream()');
       } catch (error) {
-        this.logger.error('startVideoStream()');
+        this.logger.error('startVideoStream()', { error });
 
         if (error.name === 'NotReadableError') {
-          this.deviceIsBusy = true;
           this.videoStream = undefined;
-
-          return undefined;
+          throw new Error('DeviceIsBusy');
         }
 
-        if (error.name === 'NotAllowedError') {
-          this.getUserMediaError = error.name;
-
-          return undefined;
+        if (error.name === 'This action is not allowed') {
+          throw new Error('NotAllowedError');
         }
 
         throw new Error('Can`t start video stream');
@@ -127,26 +133,23 @@ class System {
     return this.videoStream;
   }
 
-  async startAudioStream(params?: AudioConstraintParams): Promise<MediaStream | undefined> {
+  async startAudioStream(params?: AudioConstraintParams): Promise<MediaStream> {
     if (!this.audioStream || !this.audioStream.active) {
       try {
         this.audioStream = await navigator.mediaDevices.getUserMedia({
           audio: this.getAudioConstraints(params),
         });
+        this.logger.debug('startAudioStream()');
       } catch (error) {
-        this.logger.error('startAudioStream()', error);
+        this.logger.error('startAudioStream()', { error });
 
         if (error.name === 'NotReadableError') {
-          this.deviceIsBusy = true;
           this.audioStream = undefined;
-
-          return undefined;
+          throw new Error('DeviceIsBusy');
         }
 
         if (error.name === 'NotAllowedError') {
-          this.getUserMediaError = error.name;
-
-          return undefined;
+          throw new Error('Device access denied');
         }
 
         throw new Error('Can`t start audio stream');
@@ -158,8 +161,6 @@ class System {
 
   async detectDevices(): Promise<void> {
     this.isDevicesLoaded = false;
-    this.deviceIsBusy = false;
-    this.getUserMediaError = undefined;
 
     try {
       const mediaDevices = await navigator.mediaDevices.enumerateDevices();
@@ -175,8 +176,9 @@ class System {
           audio: availableDevicesTypes.audio && this.getAudioConstraints(),
         });
       } catch (error) {
+        this.logger.error('getUserMedia()', { error });
         if (error.name === 'NotReadableError') {
-          this.deviceIsBusy = true;
+          throw new Error('DeviceIsBusy');
         }
       }
 
@@ -201,15 +203,25 @@ class System {
       this.setAvailableVideoDevices(videoDevices);
       this.setAvailableAudioDevices(audioDevices);
       this.isDevicesLoaded = true;
+      this.logger.debug('detectDevices()', { videoDevices, audioDevices });
     } catch (error) {
-      this.getUserMediaError = error.name || error;
-      this.logger.error('detectDevices()');
+      this.logger.error('detectDevices()', { error });
       throw new Error('Can`t detect devices');
     }
   }
 
+  listenDevices(): void {
+    navigator.mediaDevices.ondevicechange = () => {
+      if (this.isDevicesLoaded) {
+        this.logger.debug('Available devices list was changed');
+        this.detectDevices();
+      }
+    };
+  }
+
   stopVideoStream(): void {
     if (!this.videoStream) {
+      this.logger.warn('stopVideoStream()', { message: 'No available video stream' });
       return;
     }
 
@@ -218,10 +230,12 @@ class System {
     });
 
     this.videoStream = undefined;
+    this.logger.debug('stopVideoStream()');
   }
 
   stopAudioStream(): void {
     if (!this.audioStream) {
+      this.logger.warn('stopVideoStream()', { message: 'No available audio stream' });
       return;
     }
 
@@ -230,6 +244,7 @@ class System {
     });
 
     this.audioStream = undefined;
+    this.logger.debug('stopAudioStream()');
   }
 
   async restartVideoStream(): Promise<void> {

package/src/index.ts

@@ -43,7 +43,23 @@ class Client {
     return !!this.engine.media.audioProducer?.paused;
   }
 
-  async getDevices(): Promise<AvailableMediaDevices> {
+  get availableVideoDevices(): MediaDeviceInfo[] {
+    return this.engine.system.availableVideoDevices;
+  }
+
+  get availableAudioDevices(): MediaDeviceInfo[] {
+    return this.engine.system.availableAudioDevices;
+  }
+
+  get currentAudioDeviceId(): string | undefined {
+    return this.engine.system.currentAudioDeviceId;
+  }
+
+  get currentVideoDeviceId(): string | undefined {
+    return this.engine.system.currentVideoDeviceId;
+  }
+
+  async detectDevices(): Promise<AvailableMediaDevices> {
     await this.engine.system.detectDevices();
     return {
       video: this.engine.system.availableVideoDevices,
@@ -51,6 +67,22 @@ class Client {
     };
   }
 
+  async getVideoStream(): Promise<MediaStream> {
+    return this.engine.system.videoStream || this.engine.system.startVideoStream();
+  }
+
+  async getAudioStream(): Promise<MediaStream> {
+    return this.engine.system.audioStream || this.engine.system.startAudioStream();
+  }
+
+  async getVideoTrack(): Promise<MediaStreamTrack> {
+    return this.engine.system.getVideoTrack();
+  }
+
+  async getAudioTrack(): Promise<MediaStreamTrack> {
+    return this.engine.system.getAudioTrack();
+  }
+
   setVideoDevice(deviceId: string): void {
     this.engine.system.setCurrentVideoDevice(deviceId);
   }