@livedigital/client 1.7.0 → 1.10.0

package/dist/constants/events.d.ts

@@ -10,6 +10,7 @@ export declare const CLIENT_EVENTS: {
     peerLeft: string;
     channelLeave: string;
     channelRejoinRequired: string;
+    devicesListUpdated: string;
 };
 export declare const PEER_EVENTS: {
     mediaPublished: string;

package/dist/engine/Peer.d.ts

@@ -1,8 +1,9 @@
-import { ProducerData } from '../types/common';
+import { ProducerData, ConnectionQuality, PayloadOfPublishedMedia } from '../types/common';
 import Consumer from './media/Consumer';
 import VideoConsumer from './media/VideoConsumer';
 import EnhancedEventEmitter from '../EnhancedEventEmitter';
 import Engine from './index';
+import PeerProducer from './PeerProducer';
 interface PeerConstructor {
     id: string;
     channelId: string;
@@ -28,54 +29,34 @@ declare class Peer {
     loginDate: Date;
     uid?: string;
     appData: Record<string, unknown>;
-    private videoProducer?;
-    private audioProducer?;
-    private videoConsumer?;
-    private audioConsumer?;
+    private producers;
+    private consumers;
     private readonly engine;
     private readonly _observer;
     private readonly logger;
     private incomingConnectionQuality;
     private outgoingConnectionQuality;
-    constructor({ id, channelId, appId, loginDate, producers, videoConsumer, audioConsumer, engine, appData, uid, }: PeerConstructor);
+    constructor({ id, channelId, appId, loginDate, producers, engine, appData, uid, }: PeerConstructor);
     get observer(): EnhancedEventEmitter;
-    get isPublishedVideo(): boolean;
-    get isPublishedAudio(): boolean;
-    get hasVideo(): boolean;
-    get hasAudio(): boolean;
-    get videoTrack(): MediaStreamTrack | undefined;
-    get audioTrack(): MediaStreamTrack | undefined;
-    get isVideoPaused(): boolean;
-    get isAudioPaused(): boolean;
-    get videoCodec(): string | undefined;
-    get audioCodec(): string | undefined;
     get isMe(): boolean;
-    subscribeVideo(): Promise<void>;
-    subscribeAudio(): Promise<void>;
-    unSubscribeVideo(): Promise<void>;
-    unSubscribeAudio(): Promise<void>;
-    setMinResolution(): Promise<void>;
-    setMediumResolution(): Promise<void>;
-    setMaxResolution(): Promise<void>;
-    pauseVideo(): Promise<void>;
-    pauseAudio(): Promise<void>;
-    resumeVideo(): Promise<void>;
-    resumeAudio(): Promise<void>;
-    setVideoStreamPriority(priority: number): Promise<void>;
-    setAudioStreamPriority(priority: number): Promise<void>;
+    get publishedMedia(): PayloadOfPublishedMedia[];
+    subscribe(producerId: string): Promise<void>;
+    setMinResolution(consumerId: string): Promise<void>;
+    setMediumResolution(consumerId: string): Promise<void>;
+    setMaxResolution(consumerId: string): Promise<void>;
+    pause(consumerId: string): Promise<void>;
+    resume(consumerId: string): Promise<void>;
+    setPriority(consumerId: string, priority: number): Promise<void>;
     private setConsumerPriority;
     private createConsumer;
-    private closeConsumer;
     private changeConsumerPreferredLayers;
-    private setVideoProducer;
-    private setAudioProducer;
-    private removeVideoProducer;
-    private removeAudioProducer;
     private pauseRemoteConsumer;
     private resumeRemoteConsumer;
     private handleNewProducer;
     private handlePeerEvents;
     private emitConnectionQuality;
-    private getConnectionQualityByScore;
+    static getConnectionQualityByScore(score: number): ConnectionQuality;
+    getAllConsumers(): Consumer[];
+    getAllProducers(): PeerProducer[];
 }
 export default Peer;

package/dist/engine/PeerProducer.d.ts

@@ -1,9 +1,10 @@
 import { MediaKind } from 'mediasoup-client/lib/RtpParameters';
-import { ProducerData } from '../types/common';
+import { ProducerData, TrackLabel } from '../types/common';
 declare class PeerProducer {
     readonly id: string;
     readonly kind: MediaKind;
     readonly peerId: string;
+    readonly label: TrackLabel;
     score: number;
     constructor(params: ProducerData);
 }

package/dist/engine/index.d.ts

@@ -1,9 +1,13 @@
-import { PeerResponse, JoinChannelParams, PublishAudioOptions, PublishVideoOptions } from '../types/common';
+import { PeerResponse, JoinChannelParams, CreateCameraVideoTrackOptions, CreateMicrophoneAudioTrackOptions, CreateScreenVideoTrackOptions, CreateScreenAudioTrackOptions, Track } from '../types/common';
 import EnhancedEventEmitter from '../EnhancedEventEmitter';
 import System from './system';
 import Peer from './Peer';
-import Network from './network';
+import Network, { NetworkParams } from './network';
 import Media from './media';
+declare type EngineParams = {
+    clientEventEmitter: EnhancedEventEmitter;
+    network: NetworkParams;
+};
 declare class Engine {
     system: System;
     network: Network;
@@ -15,7 +19,7 @@ declare class Engine {
     private initialized;
     private isJoined;
     private logger;
-    constructor(clientEventEmitter: EnhancedEventEmitter);
+    constructor(params: EngineParams);
     private initialize;
     release(): Promise<void>;
     private pauseRemoteProducer;
@@ -26,13 +30,13 @@ declare class Engine {
     join(params: JoinChannelParams): Promise<void>;
     setPeer(peerData: PeerResponse): void;
     removePeer(peerId: string): void;
-    publishVideo(track?: MediaStreamTrack, options?: PublishVideoOptions): Promise<void>;
-    publishAudio(track?: MediaStreamTrack, options?: PublishAudioOptions): Promise<void>;
-    unpublishVideo(): Promise<void>;
-    unpublishAudio(): Promise<void>;
-    pauseVideo(): Promise<void>;
-    resumeVideo(): Promise<void>;
-    pauseAudio(): Promise<void>;
-    resumeAudio(): Promise<void>;
+    pause(track: Track): Promise<void>;
+    resume(track: Track): Promise<void>;
+    createCameraVideoTrack(options?: CreateCameraVideoTrackOptions): Promise<Track | null>;
+    createMicrophoneAudioTrack(options?: CreateMicrophoneAudioTrackOptions): Promise<Track | null>;
+    createScreenVideoTrack(options?: CreateScreenVideoTrackOptions): Promise<Track | null>;
+    createScreenAudioTrack(options?: CreateScreenAudioTrackOptions): Promise<Track | null>;
+    publish(tracks: Track | Track[]): Promise<void>;
+    unpublish(tracks?: Track | Track[]): Promise<void>;
 }
 export default Engine;

package/dist/engine/media/Consumer.d.ts

@@ -2,6 +2,5 @@ import { Consumer as MediasoupConsumer } from 'mediasoup-client/lib/types';
 declare class Consumer extends MediasoupConsumer {
     score: number;
     producerScore: number;
-    constructor(consumer: MediasoupConsumer);
 }
 export default Consumer;

package/dist/engine/media/VideoConsumer.d.ts

@@ -1,17 +1,9 @@
-import Consumer from './Consumer';
 import { Consumer as MediasoupConsumer } from 'mediasoup-client/lib/types';
+import Consumer from './Consumer';
 declare class VideoConsumer extends Consumer {
     spatialLayers: number;
     temporalLayers: number;
-    private currentSpatialLayer;
-    private currentTemporalLayer;
-    currentPreferredLayers: {
-        spatialLayer?: number;
-        temporalLayer?: number;
-    };
     constructor(consumer: MediasoupConsumer);
     parseScalabilityMode(): void;
-    setCurrentSpatialLayer(currentSpatialLayer: number): void;
-    setCurrentTemporalLayer(currentTemporalLayer: number): void;
 }
 export default VideoConsumer;

package/dist/engine/media/index.d.ts

@@ -1,19 +1,17 @@
 import { Device } from 'mediasoup-client';
-import { Producer } from 'mediasoup-client/lib/Producer';
 import { RtpCapabilities, RtpCodecCapability } from 'mediasoup-client/lib/RtpParameters';
+import { Track } from '../../types/common';
 declare class Media {
     mediasoupDevice: Device;
-    audioProducer?: Producer;
-    videoProducer?: Producer;
-    isDevicesLoaded: boolean;
-    isVideoDisabled: boolean;
-    isAudioDisabled: boolean;
+    isDeviceLoaded: boolean;
+    private tracks;
     constructor();
     loadDevice(routerRtpCapabilities: RtpCapabilities): Promise<void>;
-    getCodec(): RtpCodecCapability | undefined;
-    setVideoProducer(producer: Producer): void;
-    setAudioProducer(producer: Producer): void;
-    closeVideoProducer(): void;
-    closeAudioProducer(): void;
+    getTrackCodec(track: Track): RtpCodecCapability | undefined;
+    private createTrack;
+    createUserMediaTrack(constraints: MediaStreamConstraints): Promise<Track>;
+    createDisplayMediaTrack(constraints: MediaStreamConstraints): Promise<Track>;
+    deleteTrack(track: Track): Promise<void>;
+    getAllTracks(): Track[];
 }
 export default Media;

package/dist/engine/media/tracks/AudioTrack.d.ts

@@ -0,0 +1,9 @@
+import { ProducerCodecOptions } from 'mediasoup-client/lib/Producer';
+import { AudioEncoderConfig } from 'types/common';
+import BaseTrack from './BaseTrack';
+import TrackWithCodecOptions from './TrackWithCodecOptions';
+declare class AudioTrack extends BaseTrack implements TrackWithCodecOptions {
+    getEncoderConfig(): AudioEncoderConfig;
+    getCodecOptions(): ProducerCodecOptions;
+}
+export default AudioTrack;

package/dist/engine/media/tracks/BaseTrack.d.ts

@@ -0,0 +1,23 @@
+import { Producer } from 'mediasoup-client/lib/Producer';
+import { MediaKind } from 'mediasoup-client/lib/RtpParameters';
+import { EncoderConfig, TrackLabel } from 'types/common';
+declare class BaseTrack {
+    #private;
+    protected encoderConfig: EncoderConfig;
+    private producer?;
+    private label;
+    constructor(mediaStreamTrack: MediaStreamTrack);
+    get mediaStreamTrack(): MediaStreamTrack;
+    get id(): string;
+    get kind(): MediaKind;
+    get producerId(): string | undefined;
+    get isPublished(): boolean;
+    getLabel(): TrackLabel;
+    setLabel(label: TrackLabel): void;
+    setEncoderConfig(encoderConfig: EncoderConfig): void;
+    getEncoderConfig(): EncoderConfig;
+    setProducer(producer: Producer): void;
+    getProducer(): Producer | undefined;
+    closeProducer(): void;
+}
+export default BaseTrack;

package/dist/engine/media/tracks/TrackWithCodecOptions.d.ts

@@ -0,0 +1,4 @@
+import { ProducerCodecOptions } from 'mediasoup-client/lib/Producer';
+export default interface TrackWithCodecOptions {
+    getCodecOptions(): ProducerCodecOptions;
+}

package/dist/engine/media/tracks/TrackWithEncodings.d.ts

@@ -0,0 +1,4 @@
+import { RtpEncodingParameters } from 'mediasoup-client/lib/RtpParameters';
+export default interface TrackWithEncodings {
+    getEncodings(): RtpEncodingParameters[];
+}

package/dist/engine/media/tracks/VideoTrack.d.ts

@@ -0,0 +1,13 @@
+import { ProducerCodecOptions } from 'mediasoup-client/lib/Producer';
+import { RtpEncodingParameters } from 'mediasoup-client/lib/RtpParameters';
+import { VideoCodec, VideoEncoderConfig } from 'types/common';
+import BaseTrack from './BaseTrack';
+import TrackWithCodecOptions from './TrackWithCodecOptions';
+import TrackWithEncodings from './TrackWithEncodings';
+declare class VideoTrack extends BaseTrack implements TrackWithCodecOptions, TrackWithEncodings {
+    getEncoderConfig(): VideoEncoderConfig;
+    getCodecOptions(): ProducerCodecOptions;
+    getPreferredCodec(): VideoCodec;
+    getEncodings(): RtpEncodingParameters[];
+}
+export default VideoTrack;

package/dist/engine/network/LoadBalancerClient.d.ts

@@ -1,7 +1,13 @@
 import { GetNodeResponse } from '../../types/common';
+export declare type LoadBalancerApiClientParams = {
+    baseURL?: string;
+    timeout?: number;
+    customNode?: GetNodeResponse;
+};
 declare class LoadBalancerApiClient {
     private readonly api;
-    constructor();
+    private customNode?;
+    constructor(params: LoadBalancerApiClientParams);
     getNode({ channelId }: {
         channelId: string;
     }): Promise<GetNodeResponse>;

package/dist/engine/network/index.d.ts

@@ -1,14 +1,17 @@
 import { IceParameters, Transport } from 'mediasoup-client/lib/Transport';
 import { Device } from 'mediasoup-client';
 import SocketIO from './Socket';
-import LoadBalancerApiClient from './LoadBalancerClient';
+import LoadBalancerApiClient, { LoadBalancerApiClientParams } from './LoadBalancerClient';
+export declare type NetworkParams = {
+    loadbalancer: LoadBalancerApiClientParams;
+};
 declare class Network {
     readonly socket: SocketIO;
     readonly loadBalancerClient: LoadBalancerApiClient;
     sendTransport?: Transport;
     receiveTransport?: Transport;
     private readonly logger;
-    constructor();
+    constructor(params: NetworkParams);
     closeRemoteProducer(producerId: string): Promise<void>;
     closeSendTransport(): Promise<void>;
     closeReceiveTransport(): Promise<void>;

package/dist/engine/system/index.d.ts

@@ -1,33 +1,24 @@
-import { AudioTrackConstraints, VideoTrackConstraints } from '../../types/common';
+import EnhancedEventEmitter from 'EnhancedEventEmitter';
+declare type SystemParams = {
+    clientEventEmitter: EnhancedEventEmitter;
+};
 declare class System {
     isEnableVideoDevicesLock: boolean;
     isEnableAudioDevicesLock: boolean;
-    isDevicesLoaded: boolean;
-    videoStream?: MediaStream;
-    audioStream?: MediaStream;
+    isDevicesDetected: boolean;
     availableVideoDevices: MediaDeviceInfo[];
     availableAudioDevices: MediaDeviceInfo[];
-    currentAudioDeviceId?: string;
-    currentVideoDeviceId?: string;
+    private isMediaDevicesAccessGranted;
+    clientEventEmitter: EnhancedEventEmitter;
     private readonly logger;
-    constructor();
+    constructor(params: SystemParams);
     setIsEnableVideoDevicesLock(value: boolean): void;
     setIsEnableAudioDevicesLock(value: boolean): void;
-    setCurrentVideoDevice(deviceId: string): void;
-    setCurrentAudioDevice(deviceId: string): void;
     setAvailableVideoDevices(availableVideoDevices: MediaDeviceInfo[]): void;
     setAvailableAudioDevices(availableAudioDevices: MediaDeviceInfo[]): void;
-    getVideoConstraints(videoTrackConstraints?: VideoTrackConstraints): MediaTrackConstraints;
-    getAudioConstraints(audioTrackConstraints?: AudioTrackConstraints): MediaTrackConstraints;
-    getVideoTrack(): Promise<MediaStreamTrack>;
-    getAudioTrack(): Promise<MediaStreamTrack>;
-    startVideoStream(videoTrackConstraints?: VideoTrackConstraints): Promise<MediaStream>;
-    startAudioStream(audioTrackConstraints?: AudioTrackConstraints): Promise<MediaStream>;
+    requestMediaDevicesAccess(): Promise<void>;
+    refreshAvailableMediaDevicesList(): Promise<void>;
     detectDevices(): Promise<void>;
     listenDevices(): void;
-    stopVideoStream(): void;
-    stopAudioStream(): void;
-    restartVideoStream(): Promise<void>;
-    restartAudioStream(): Promise<void>;
 }
 export default System;

package/dist/index.d.ts

@@ -1,37 +1,31 @@
-import { AvailableMediaDevices, JoinChannelParams, PublishAudioOptions, PublishVideoOptions } from './types/common';
+import { AvailableMediaDevices, CreateCameraVideoTrackOptions, CreateMicrophoneAudioTrackOptions, CreateScreenAudioTrackOptions, CreateScreenVideoTrackOptions, JoinChannelParams, Track } from './types/common';
 import EnhancedEventEmitter from './EnhancedEventEmitter';
 import Peer from './engine/Peer';
+import { LoadBalancerApiClientParams } from './engine/network/LoadBalancerClient';
+declare type ClientParams = {
+    network?: {
+        loadbalancer?: LoadBalancerApiClientParams;
+    };
+};
 declare class Client {
     private readonly engine;
     private readonly _observer;
-    constructor();
+    constructor(params: ClientParams);
     get observer(): EnhancedEventEmitter;
     get id(): string | undefined;
     get peers(): Peer[];
-    get isVideoEnabled(): boolean;
-    get isVideoPaused(): boolean;
-    get isAudioEnabled(): boolean;
-    get isAudioPaused(): boolean;
     get availableVideoDevices(): MediaDeviceInfo[];
     get availableAudioDevices(): MediaDeviceInfo[];
-    get currentAudioDeviceId(): string | undefined;
-    get currentVideoDeviceId(): string | undefined;
     detectDevices(): Promise<AvailableMediaDevices>;
-    getVideoStream(): Promise<MediaStream>;
-    getAudioStream(): Promise<MediaStream>;
-    getVideoTrack(): Promise<MediaStreamTrack>;
-    getAudioTrack(): Promise<MediaStreamTrack>;
-    setVideoDevice(deviceId: string): void;
-    setAudioDevice(deviceId: string): void;
     join(params: JoinChannelParams): Promise<void>;
     leave(): Promise<void>;
-    publishVideo(track?: MediaStreamTrack, options?: PublishVideoOptions): Promise<void>;
-    publishAudio(track?: MediaStreamTrack, options?: PublishAudioOptions): Promise<void>;
-    unpublishVideo(): Promise<void>;
-    unpublishAudio(): Promise<void>;
-    pauseVideo(): Promise<void>;
-    resumeVideo(): Promise<void>;
-    pauseAudio(): Promise<void>;
-    resumeAudio(): Promise<void>;
+    publish(tracks: Track | Track[]): Promise<void>;
+    unpublish(tracks?: Track | Track[]): Promise<void>;
+    pause(track: Track): Promise<void>;
+    resume(track: Track): Promise<void>;
+    createCameraVideoTrack(options?: CreateCameraVideoTrackOptions): Promise<Track | null>;
+    createMicrophoneAudioTrack(options?: CreateMicrophoneAudioTrackOptions): Promise<Track | null>;
+    createScreenVideoTrack(options?: CreateScreenVideoTrackOptions): Promise<Track | null>;
+    createScreenAudioTrack(options?: CreateScreenAudioTrackOptions): Promise<Track | null>;
 }
 export default Client;