@livedigital/client 2.25.0 → 2.26.0-stop-streams.1

package/dist/types/common.d.ts

@@ -304,6 +304,10 @@ export declare type UpdatePeerAppDataPayload = {
     peerId: string;
     appData: Record<string, unknown>;
 };
+export declare type CreateTracksPayload = {
+    stream: MediaStream;
+    constraints: MediaStreamConstraints;
+};
 export declare type TrackPublishParams = {
     keyFrameRequestDelay?: number;
 };

package/package.json

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

package/src/engine/index.ts

@@ -457,20 +457,7 @@ class Engine {
 
   private watchClientEvents(): void {
     this.clientEventEmitter.on(INTERNAL_CLIENT_EVENTS.trackProduced, (track: Track) => {
-      const myPeer = this.peersRepository.get(<string> this.mySocketId);
-      if (!myPeer) {
-        return;
-      }
-
-      const peerTrack = new PeerTrack({
-        mediaStreamTrack: track.mediaStreamTrack,
-        label: track.getLabel(),
-        engine: this,
-        isPaused: track.isPaused,
-        peerEventEmitter: myPeer.observer,
-      });
-
-      myPeer.tracks.set(peerTrack.label, peerTrack);
+      this.createSelfPeerTrack(track);
     });
 
     this.clientEventEmitter.on(INTERNAL_CLIENT_EVENTS.trackUnproduced, (track: Track) => {
@@ -481,14 +468,30 @@ class Engine {
 
     this.clientEventEmitter.on(INTERNAL_CLIENT_EVENTS.trackPaused, (track: Track) => {
       const peerTrack = this.myPeer?.tracks.get(track.getLabel());
-      peerTrack?.pause();
+      peerTrack?.close();
     });
 
     this.clientEventEmitter.on(INTERNAL_CLIENT_EVENTS.trackResumed, (track: Track) => {
-      const peerTrack = this.myPeer?.tracks.get(track.getLabel());
-      peerTrack?.resume();
+      this.createSelfPeerTrack(track);
     });
   }
+
+  private createSelfPeerTrack(track: Track): void {
+    const myPeer = this.peersRepository.get(<string> this.mySocketId);
+    if (!myPeer) {
+      return;
+    }
+
+    const peerTrack = new PeerTrack({
+      mediaStreamTrack: track.mediaStreamTrack,
+      label: track.getLabel(),
+      engine: this,
+      isPaused: track.isPaused,
+      peerEventEmitter: myPeer.observer,
+    });
+
+    myPeer.tracks.set(peerTrack.label, peerTrack);
+  }
 }
 
 export default Engine;

package/src/engine/media/index.ts

@@ -3,7 +3,11 @@ import { RtpCapabilities, RtpCodecCapability } from 'mediasoup-client/lib/RtpPar
 import VideoTrack from './tracks/VideoTrack';
 import AudioTrack from './tracks/AudioTrack';
 import {
-  CreateScreenVideoTrackOptions, CreateVideoTrackParams, LogLevel, Track,
+  CreateScreenVideoTrackOptions,
+  CreateTracksPayload,
+  CreateVideoTrackParams,
+  LogLevel,
+  Track,
 } from '../../types/common';
 import Logger from '../Logger';
 import { VIDEO_CONSTRAINS } from '../../constants/videoConstrains';
@@ -11,6 +15,7 @@ import { SCREEN_SHARING_SIMULCAST_ENCODINGS, WEBCAM_SIMULCAST_ENCODINGS } from '
 import { CreateMediaParams } from '../../types/engine';
 import Engine from '../index';
 import EnhancedEventEmitter from '../../EnhancedEventEmitter';
+import TrackMediaStreamManager from './tracks/TrackMediaStreamManager';
 
 class Media {
   public isDeviceLoaded = false;
@@ -62,7 +67,7 @@ class Media {
     return codecs.find((c) => c.mimeType.toLowerCase() === `${track.kind}/${track.getPreferredCodec()}`);
   }
 
-  private createTracks(stream: MediaStream): Track[] {
+  private createTracks({ constraints, stream }: CreateTracksPayload): Track[] {
     const mediaStreamTracks = stream.getTracks();
     return mediaStreamTracks.map((mediaStreamTrack) => {
       const params = {
@@ -70,6 +75,7 @@ class Media {
         logLevel: this.#logLevel,
         engine: this.#engine,
         clientEventEmitter: this.#clientEventEmitter,
+        mediaStreamManager: new TrackMediaStreamManager(constraints),
       };
 
       const track = mediaStreamTrack.kind === 'audio' ? new AudioTrack(params) : new VideoTrack(params);
@@ -87,12 +93,12 @@ class Media {
   async createUserMediaTracks(constraints: MediaStreamConstraints): Promise<Track[]> {
     const stream = await navigator.mediaDevices.getUserMedia(constraints);
     this.#logger.debug('createUserMediaTrack() stream created', { streamId: stream.id });
-    return this.createTracks(stream);
+    return this.createTracks({ stream, constraints });
   }
 
   async createDisplayMediaTracks(constraints: MediaStreamConstraints): Promise<Track[]> {
     const stream = await navigator.mediaDevices.getDisplayMedia(constraints);
-    return this.createTracks(stream);
+    return this.createTracks({ stream, constraints });
   }
 
   deleteTrack(track: Track) {

package/src/engine/media/tracks/BaseTrack.ts

@@ -5,27 +5,30 @@ import {
   EncoderConfig,
   LogLevel,
   SocketResponse,
-  TrackLabel, TrackOutboundStats,
+  TrackLabel,
+  TrackOutboundStats,
   TrackProduceParams,
 } from '../../../types/common';
 import Logger from '../../Logger';
 import Engine from '../../index';
 import PeerConsumer from '../../PeerConsumer';
 import { PRODUCER_CHECK_STATE_TIMEOUT } from '../../../constants/common';
-import Timeout = NodeJS.Timeout;
-import { MEDIASOUP_EVENTS, INTERNAL_CLIENT_EVENTS, CLIENT_EVENTS } from '../../../constants/events';
+import { CLIENT_EVENTS, INTERNAL_CLIENT_EVENTS, MEDIASOUP_EVENTS } from '../../../constants/events';
 import EnhancedEventEmitter from '../../../EnhancedEventEmitter';
 import filterStatsCodecs from '../../../helpers/filterStatsCodecs';
+import Timeout = NodeJS.Timeout;
+import TrackMediaStreamManager from './TrackMediaStreamManager';
 
 export type BaseTrackConstructorParams = {
   mediaStreamTrack: MediaStreamTrack,
   logLevel: LogLevel,
   engine: Engine,
   clientEventEmitter: EnhancedEventEmitter,
+  mediaStreamManager: TrackMediaStreamManager,
 };
 
 class BaseTrack {
-  readonly #mediaStreamTrack: MediaStreamTrack;
+  #mediaStreamTrack: MediaStreamTrack;
 
   protected encoderConfig: EncoderConfig = {};
 
@@ -47,13 +50,16 @@ class BaseTrack {
 
   #closed = false;
 
+  readonly #mediaStreamManager: TrackMediaStreamManager;
+
   constructor(params: BaseTrackConstructorParams) {
     const {
-      mediaStreamTrack, logLevel, engine, clientEventEmitter,
+      mediaStreamTrack, logLevel, engine, clientEventEmitter, mediaStreamManager,
     } = params;
     this.#mediaStreamTrack = mediaStreamTrack;
     this.#engine = engine;
     this.#clientEventEmitter = clientEventEmitter;
+    this.#mediaStreamManager = mediaStreamManager;
     this.logger = new Logger({
       namespace: 'Track',
       logLevel,
@@ -96,6 +102,7 @@ class BaseTrack {
 
   setLabel(label: TrackLabel): void {
     this.label = label;
+    this.#mediaStreamManager.setLabel(label);
   }
 
   setEncoderConfig(encoderConfig: EncoderConfig): void {
@@ -366,6 +373,7 @@ class BaseTrack {
       await this.cancelProducerCheckState();
       await this.pauseRemoteProducer(this.producer.id);
       this.producer.pause();
+      this.#mediaStreamTrack.stop();
       this.clientEventEmitter.emit(INTERNAL_CLIENT_EVENTS.trackPaused, this);
       this.logger.debug('pause()', { track: this });
     } catch (error) {
@@ -381,6 +389,9 @@ class BaseTrack {
     }
 
     try {
+      const track = await this.#mediaStreamManager.getMediaStreamTrack();
+      this.#mediaStreamTrack = track;
+      await this.producer.replaceTrack({ track });
       await this.resumeRemoteProducer(this.producer.id);
       this.producer.resume();
       this.clientEventEmitter.emit(INTERNAL_CLIENT_EVENTS.trackResumed, this);

package/src/engine/media/tracks/TrackMediaStreamManager.ts

@@ -0,0 +1,41 @@
+import { TrackLabel } from '../../../types/common';
+
+class TrackMediaStreamManager {
+  #label = TrackLabel.Unknown;
+
+  readonly #constraints: MediaStreamConstraints;
+
+  constructor(constraints: MediaStreamConstraints) {
+    this.#constraints = constraints;
+  }
+
+  setLabel(label: TrackLabel): void {
+    this.#label = label;
+  }
+
+  async getMediaStreamTrack(): Promise<MediaStreamTrack> {
+    if (this.isDisplayMedia) {
+      return this.getDisplayMediaTrack();
+    }
+
+    return this.getUserMediaTrack();
+  }
+
+  private get isDisplayMedia(): boolean {
+    return [TrackLabel.ScreenVideo, TrackLabel.ScreenAudio].includes(this.#label);
+  }
+
+  private async getUserMediaTrack(): Promise<MediaStreamTrack> {
+    const stream = await navigator.mediaDevices.getUserMedia(this.#constraints);
+    const [track] = stream.getTracks();
+    return track;
+  }
+
+  private async getDisplayMediaTrack(): Promise<MediaStreamTrack> {
+    const stream = await navigator.mediaDevices.getDisplayMedia(this.#constraints);
+    const [track] = stream.getTracks();
+    return track;
+  }
+}
+
+export default TrackMediaStreamManager;

package/src/types/common.ts

@@ -350,6 +350,11 @@ export type UpdatePeerAppDataPayload = {
   appData: Record<string, unknown>,
 };
 
+export type CreateTracksPayload = {
+  stream: MediaStream,
+  constraints: MediaStreamConstraints,
+};
+
 export type TrackPublishParams = {
   keyFrameRequestDelay?: number;
 };