@livedigital/client 1.15.0 → 1.15.1

package/dist/types/common.d.ts

@@ -125,9 +125,13 @@ export declare type CreateScreenVideoTrackOptions = CreateVideoTrackOptions & {
 export declare type CreateMicrophoneAudioTrackOptions = CreateTrackOptions & {
     encoderConfig?: AudioEncoderConfig;
 };
-export declare type CreateScreenAudioTrackOptions = CreateVideoTrackOptions & {
+export declare type CreateScreenAudioTrackOptions = CreateMicrophoneAudioTrackOptions & {
     encoderConfig?: AudioEncoderConfig;
 };
+export declare type CreateScreenMediaOptions = {
+    video: CreateScreenVideoTrackOptions;
+    audio: CreateScreenAudioTrackOptions;
+};
 export declare type Track = VideoTrack | AudioTrack;
 export declare enum TrackLabel {
     Camera = "camera",

package/package.json

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

package/src/engine/index.ts

@@ -2,8 +2,7 @@ import { RtpCapabilities } from 'mediasoup-client/lib/RtpParameters';
 import {
   CreateCameraVideoTrackOptions,
   CreateMicrophoneAudioTrackOptions,
-  CreateScreenAudioTrackOptions,
-  CreateScreenVideoTrackOptions,
+  CreateScreenMediaOptions,
   EndTrackPayload,
   JoinChannelParams,
   PeerResponse,
@@ -197,7 +196,7 @@ class Engine {
   async createCameraVideoTrack(options?: CreateCameraVideoTrackOptions): Promise<Track> {
     const trackParams = Media.getCameraVideoTrackParams(options);
     try {
-      const track = await this.media.createUserMediaTrack({
+      const [track] = await this.media.createUserMediaTracks({
         audio: false,
         video: trackParams.videoTrackOptions,
       });
@@ -215,7 +214,7 @@ class Engine {
 
   async createMicrophoneAudioTrack(options?: CreateMicrophoneAudioTrackOptions): Promise<Track> {
     try {
-      const track = await this.media.createUserMediaTrack({
+      const [track] = await this.media.createUserMediaTracks({
         video: false,
         audio: {
           deviceId: options?.deviceId,
@@ -235,50 +234,38 @@ class Engine {
     }
   }
 
-  async createScreenVideoTrack(options?: CreateScreenVideoTrackOptions): Promise<Track> {
-    const trackParams = Media.getScreenVideoTrackParams(options);
+  async createScreenMediaTracks(options?: CreateScreenMediaOptions): Promise<Track[]> {
+    const videoTrackParams = Media.getScreenVideoTrackParams(options?.video);
     try {
-      const track = await this.media.createDisplayMediaTrack({
-        audio: false,
-        video: trackParams.videoTrackOptions,
+      const tracks = await this.media.createDisplayMediaTracks({
+        audio: options?.audio,
+        video: videoTrackParams.videoTrackOptions,
       });
 
-      track.mediaStreamTrack.addEventListener('ended', () => {
-        this.unpublish(track);
-      });
-
-      track.setLabel(TrackLabel.ScreenVideo);
-      track.setEncoderConfig(trackParams.encoderConfig);
+      tracks.forEach((track) => {
+        track.mediaStreamTrack.addEventListener('ended', () => {
+          this.unpublish(track);
+        });
 
-      this.logger.debug('createScreenVideoTrack()', { trackParams, track });
-      return track;
-    } catch (error) {
-      this.logger.error('createScreenVideoTrack()', { error, trackParams });
-      throw new Error(`Can not create screen video track: ${error.message}`);
-    }
-  }
+        if (track.kind === 'video') {
+          track.setLabel(TrackLabel.ScreenVideo);
+          track.setEncoderConfig(videoTrackParams.encoderConfig);
+          this.logger.debug('createScreenMediaTrack()', { trackParams: videoTrackParams, track });
+          return;
+        }
 
-  async createScreenAudioTrack(options?: CreateScreenAudioTrackOptions): Promise<Track> {
-    try {
-      const track = await this.media.createDisplayMediaTrack({
-        video: false,
-        audio: true,
-      });
+        track.setLabel(TrackLabel.ScreenAudio);
+        if (options?.audio) {
+          track.setEncoderConfig(options.audio);
+        }
 
-      track.mediaStreamTrack.addEventListener('ended', () => {
-        this.unpublish(track);
+        this.logger.debug('createScreenMediaTrack()', { trackParams: options?.audio, track });
       });
 
-      track.setLabel(TrackLabel.ScreenAudio);
-      if (options?.encoderConfig) {
-        track.setEncoderConfig(options.encoderConfig);
-      }
-
-      this.logger.debug('createScreenAudioTrack()', { options, track });
-      return track;
+      return tracks;
     } catch (error) {
-      this.logger.error('createScreenAudioTrack()', { error, options });
-      throw new Error(`Can not create screen audio track: ${error.message}`);
+      this.logger.error('createScreenMediaTrack()', { error, trackParams: videoTrackParams });
+      throw new Error(`Can not create screen media tracks: ${error.message}`);
     }
   }
 

package/src/engine/media/index.ts

@@ -46,28 +46,33 @@ class Media {
       .find((c) => c.mimeType.toLowerCase() === `video/${track.getPreferredCodec()}`);
   }
 
-  private createTrack(stream: MediaStream): Track {
-    const mediaStreamTrack = stream.getTracks()[0];
-
-    const track = mediaStreamTrack.kind === 'audio'
-      ? new AudioTrack(mediaStreamTrack)
-      : new VideoTrack(mediaStreamTrack);
-
-    this.tracks.set(track.id, track);
-    this.#logger.debug('createTrack() track created', { streamId: stream.id, trackId: track.id, kind: track.kind });
-
-    return track;
+  private createTracks(stream: MediaStream): Track[] {
+    const mediaStreamTracks = stream.getTracks();
+    return mediaStreamTracks.map((mediaStreamTrack) => {
+      const track = mediaStreamTrack.kind === 'audio'
+        ? new AudioTrack(mediaStreamTrack)
+        : new VideoTrack(mediaStreamTrack);
+
+      this.tracks.set(track.id, track);
+      this.#logger.debug('createTrack() track created', {
+        streamId: stream.id,
+        trackId: track.id,
+        kind: track.kind,
+      });
+
+      return track;
+    });
   }
 
-  async createUserMediaTrack(constraints: MediaStreamConstraints): Promise<Track> {
+  async createUserMediaTracks(constraints: MediaStreamConstraints): Promise<Track[]> {
     const stream = await navigator.mediaDevices.getUserMedia(constraints);
     this.#logger.debug('createUserMediaTrack() stream created', { streamId: stream.id });
-    return this.createTrack(stream);
+    return this.createTracks(stream);
   }
 
-  async createDisplayMediaTrack(constraints: MediaStreamConstraints): Promise<Track> {
+  async createDisplayMediaTracks(constraints: MediaStreamConstraints): Promise<Track[]> {
     const stream = await navigator.mediaDevices.getDisplayMedia(constraints);
-    return this.createTrack(stream);
+    return this.createTracks(stream);
   }
 
   deleteTrack(track: Track) {

package/src/index.ts

@@ -2,8 +2,7 @@ import {
   AvailableMediaDevices,
   CreateCameraVideoTrackOptions,
   CreateMicrophoneAudioTrackOptions,
-  CreateScreenAudioTrackOptions,
-  CreateScreenVideoTrackOptions,
+  CreateScreenMediaOptions,
   JoinChannelParams,
   Track,
 } from './types/common';
@@ -96,12 +95,8 @@ class Client {
     return this.engine.createMicrophoneAudioTrack(options);
   }
 
-  createScreenVideoTrack(options?: CreateScreenVideoTrackOptions): Promise<Track> {
-    return this.engine.createScreenVideoTrack(options);
-  }
-
-  createScreenAudioTrack(options?: CreateScreenAudioTrackOptions): Promise<Track> {
-    return this.engine.createScreenAudioTrack(options);
+  createScreenMediaTracks(options?: CreateScreenMediaOptions): Promise<Track[]> {
+    return this.engine.createScreenMediaTracks(options);
   }
 
   deleteTrack(track: Track): void {

package/src/types/common.ts

@@ -152,10 +152,15 @@ export type CreateMicrophoneAudioTrackOptions = CreateTrackOptions & {
   encoderConfig?: AudioEncoderConfig,
 };
 
-export type CreateScreenAudioTrackOptions = CreateVideoTrackOptions & {
+export type CreateScreenAudioTrackOptions = CreateMicrophoneAudioTrackOptions & {
   encoderConfig?: AudioEncoderConfig,
 };
 
+export type CreateScreenMediaOptions = {
+  video: CreateScreenVideoTrackOptions,
+  audio: CreateScreenAudioTrackOptions,
+};
+
 export type Track = VideoTrack | AudioTrack;
 
 export enum TrackLabel {