@livedigital/client 1.14.1 → 2.0.0

package/dist/types/common.d.ts

@@ -21,6 +21,7 @@ export declare type ProducerData = {
     peerId: string;
     label: TrackLabel;
 };
+export declare type Role = 'audience' | 'host';
 export declare type PeerResponse = {
     id: string;
     channelIds: string[];
@@ -28,6 +29,7 @@ export declare type PeerResponse = {
     producers: ProducerData[];
     uid?: string;
     appData: Record<string, unknown>;
+    role: Role;
 };
 export declare type AvailableMediaDevices = {
     video: MediaDeviceInfo[];
@@ -39,6 +41,7 @@ export declare type JoinChannelParams = {
     sdkSecret: string;
     uid?: string;
     appData?: Record<string, unknown>;
+    role: Role;
 };
 export declare type ChannelEvent = {
     eventName: string;
@@ -125,9 +128,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.14.1",
+  "version": "2.0.0",
   "private": false,
   "bugs": {
     "url": "https://github.com/vlprojects/livedigital-sdk/issues"

package/src/engine/Peer.ts

@@ -12,6 +12,7 @@ import {
   PayloadOfPublishedMedia,
   PayloadOfUnpublishedMedia,
   ChangePreferredLayersPayload,
+  Role,
 } from '../types/common';
 import Consumer from './media/Consumer';
 import VideoConsumer from './media/VideoConsumer';
@@ -33,6 +34,7 @@ interface PeerConstructor {
   loginDate: Date;
   uid?: string;
   appData?: Record<string, unknown>,
+  role: Role,
 }
 
 export enum ScoreThreshold {
@@ -54,6 +56,8 @@ class Peer {
 
   public appData: Record<string, unknown>;
 
+  public role: Role;
+
   private producers: Map<string, PeerProducer> = new Map();
 
   private consumers: Map<string, Consumer | VideoConsumer> = new Map();
@@ -77,6 +81,7 @@ class Peer {
     engine,
     appData,
     uid,
+    role,
   }: PeerConstructor) {
     this.id = id;
     this.channelIds = channelIds;
@@ -84,6 +89,7 @@ class Peer {
     this.loginDate = loginDate;
     this.appData = appData || {};
     this.uid = uid;
+    this.role = role;
     this.engine = engine;
     this.logger = new Logger('Peer');
     producers.forEach(this.handleNewProducer.bind(this));

package/src/engine/index.ts

@@ -2,11 +2,11 @@ import { RtpCapabilities } from 'mediasoup-client/lib/RtpParameters';
 import {
   CreateCameraVideoTrackOptions,
   CreateMicrophoneAudioTrackOptions,
-  CreateScreenAudioTrackOptions,
-  CreateScreenVideoTrackOptions,
+  CreateScreenMediaOptions,
   EndTrackPayload,
   JoinChannelParams,
   PeerResponse,
+  Role,
   SocketResponse,
   StartTrackPayload,
   Track,
@@ -126,6 +126,14 @@ class Engine {
     return Array.from(this.peersRepository.values());
   }
 
+  public get hostPeers(): Peer[] {
+    return this.peers.filter((peer) => peer.role === 'host');
+  }
+
+  public get audiencePeers(): Peer[] {
+    return this.peers.filter((peer) => peer.role === 'audience');
+  }
+
   public get mySocketId(): string | undefined {
     return this.network.socket.id;
   }
@@ -146,6 +154,15 @@ class Engine {
     }
   }
 
+  public async loadPeers(role?: Role): Promise<void> {
+    const { peers } = await this.network.socket
+      .request(CHANNEL_EVENTS.channelGetPeers, { role }) as { peers: PeerResponse[] };
+
+    peers
+      .filter((peer) => !this.peersRepository.has(peer.id))
+      .forEach((peer) => this.setPeer(peer));
+  }
+
   public setPeer(peerData: PeerResponse): Peer {
     const peer = new Peer({
       ...peerData,
@@ -197,7 +214,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 +232,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,54 +252,47 @@ 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,
-      });
-
-      track.mediaStreamTrack.addEventListener('ended', () => {
-        this.unpublish(track);
+      const tracks = await this.media.createDisplayMediaTracks({
+        audio: options?.audio,
+        video: videoTrackParams.videoTrackOptions,
       });
 
-      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}`);
     }
   }
 
   public async publish(tracks: Track | Track[]): Promise<void> {
+    if (!this.cahPublish) {
+      this.logger.error('publish()', { message: 'Not enough access to publish' });
+      throw new Error('Not enough access to publish');
+    }
+
     const tracksToPublish = Array.isArray(tracks) ? tracks : [tracks];
     const actions = tracksToPublish.map(async (track) => {
       const encodings = 'getEncodings' in track
@@ -409,9 +419,6 @@ class Engine {
     try {
       await this.network.socket.request(CHANNEL_EVENTS.channelJoin, params);
       await this.initialize();
-      const { peers } = await this.network.socket
-        .request(CHANNEL_EVENTS.channelGetPeers) as { peers: PeerResponse[] };
-      peers.forEach((peer: PeerResponse) => this.setPeer(peer));
       this.channelEventsHandler.subscribeToEvents();
       this.mediaSoupEventsHandler.subscribeToEvents();
       this.app = params.appId;
@@ -423,6 +430,10 @@ class Engine {
       throw error;
     }
   }
+
+  get cahPublish(): boolean {
+    return this.peers.find((item) => item.isMe)?.role === 'host';
+  }
 }
 
 export default Engine;

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,9 +2,9 @@ import {
   AvailableMediaDevices,
   CreateCameraVideoTrackOptions,
   CreateMicrophoneAudioTrackOptions,
-  CreateScreenAudioTrackOptions,
-  CreateScreenVideoTrackOptions,
+  CreateScreenMediaOptions,
   JoinChannelParams,
+  Role,
   Track,
 } from './types/common';
 import EnhancedEventEmitter from './EnhancedEventEmitter';
@@ -96,17 +96,17 @@ 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 {
     return this.engine.deleteTrack(track);
   }
+
+  loadPeers(role?: Role): Promise<void> {
+    return this.engine.loadPeers(role);
+  }
 }
 
 export default Client;

package/src/types/common.ts

@@ -30,6 +30,8 @@ export type ProducerData = {
   label: TrackLabel,
 };
 
+export type Role = 'audience' | 'host';
+
 export type PeerResponse = {
   id: string,
   channelIds: string[],
@@ -37,6 +39,7 @@ export type PeerResponse = {
   producers: ProducerData[],
   uid?: string,
   appData: Record<string, unknown>,
+  role: Role,
 };
 
 export type AvailableMediaDevices = {
@@ -50,6 +53,7 @@ export type JoinChannelParams = {
   sdkSecret: string,
   uid?: string,
   appData?: Record<string, unknown>,
+  role: Role,
 };
 
 export type ChannelEvent = {
@@ -152,10 +156,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 {