@livedigital/client 2.45.0-test-speaker.1 → 3.0.0

package/dist/types/common.d.ts

@@ -5,11 +5,9 @@ import { RtpCapabilities } from 'mediasoup-client/src/RtpParameters';
 import { ProducerCodecOptions } from 'mediasoup-client/lib/Producer';
 import { ConnectionState } from 'mediasoup-client/src/Transport';
 import { DtlsRole } from 'mediasoup-client/lib/Transport';
-import AudioTrack from '../engine/media/tracks/AudioTrack';
-import VideoTrack from '../engine/media/tracks/VideoTrack';
 import NodeJSTimeout = NodeJS.Timeout;
 export declare type Timeout = NodeJSTimeout | number;
-export declare type SocketResponse = {
+export declare type SocketResponse<T = Record<string, any>> = T & {
     success?: boolean;
     error?: string;
     errorCode?: string;
@@ -63,10 +61,8 @@ export declare type AvailableMediaDevices = {
 };
 export declare type JoinChannelParams = {
     channelId: string;
-    appId: string;
-    sdkSecret: string;
+    token: string;
     role: Role;
-    uid?: string;
     appData?: Record<string, unknown>;
 };
 export declare type ChannelEvent = {
@@ -143,7 +139,6 @@ export declare type CreateScreenMediaOptions = BaseVideoTrackOptions & BaseAudio
     videoEncoderConfig?: VideoEncoderConfig;
     audioEncoderConfig?: AudioEncoderConfig;
 };
-export declare type Track = VideoTrack | AudioTrack;
 export declare enum TrackLabel {
     Camera = "camera",
     Microphone = "microphone",
@@ -312,9 +307,6 @@ export declare type CreateTracksPayload = {
     mediaStreamTracks: MediaStreamTrack[];
     constraints: MediaStreamConstraints;
 };
-export declare type TrackPublishParams = {
-    keyFrameRequestDelay?: number;
-};
 export declare type ChangeProducerStatePayload = {
     peerId: string;
     producerId: string;
@@ -323,10 +315,6 @@ export declare type ForceCloseProducerPayload = {
     peerId: string;
     label: TrackLabel;
 };
-export interface TrackWithEncodings {
-    getCodecOptions(): ProducerCodecOptions;
-    getEncodings(): RtpEncodingParameters[];
-}
 export declare type ActivityConfirmationRequiredPayload = {
     channelId: string;
     time: number;

package/dist/types/engine.d.ts

@@ -7,8 +7,9 @@ import Engine from '../engine';
 import ChannelEventHandler from '../engine/handlers/ChannelEventHandler';
 import MediaSoupEventHandler from '../engine/handlers/MediaSoupEventHandler';
 import { LoadBalancerApiClientParams } from '../engine/network/LoadBalancerClient';
-import { Logger, LogLevel, LogMessageHandler } from './common';
+import { Logger, LogLevel, LogMessageHandler, Role } from './common';
 import ChannelAudioObserverEventHandler from '../engine/handlers/ChannelAudioObserverEventHandler';
+import { MediaTracksFactory } from './media';
 export declare type IssuesHandler = (issues: IssueDetectorResult) => void;
 export declare type NetworkScoresUpdatedHandler = (networks: NetworkScores) => void;
 export interface CreateIssueDetectorParams {
@@ -21,6 +22,7 @@ export interface CreateMediaParams {
     logLevel: LogLevel;
     engine: Engine;
     clientEventEmitter: EnhancedEventEmitter;
+    mediaTracksFactory: MediaTracksFactory;
     onLogMessage?: LogMessageHandler;
 }
 export interface CreateMediaStreamTrackManagerParams {
@@ -49,6 +51,11 @@ export interface CreateAudioObserverEventHandlerParams {
     engine: Engine;
     onLogMessage?: LogMessageHandler;
 }
+export interface ConnectParams {
+    channelId: string;
+    role: Role;
+    token: string;
+}
 export interface EngineDependenciesFactory {
     createSystem: (params: CreateSystemParams) => System;
     createMedia: (params: CreateMediaParams) => Media;

package/dist/types/media.d.ts

@@ -0,0 +1,73 @@
+import { Producer, ProducerCodecOptions } from 'mediasoup-client/lib/Producer';
+import { RtpEncodingParameters } from 'mediasoup-client/lib/types';
+import { MediaKind } from 'mediasoup-client/lib/RtpParameters';
+import Engine from '../engine';
+import { BaseTrackInfo, EncoderConfig, LogLevel, TrackLabel, TrackOutboundStats, TrackProduceParams } from './common';
+import EnhancedEventEmitter from '../EnhancedEventEmitter';
+import MediaStreamTrackManager from '../engine/media/tracks/MediaStreamTrackManager';
+export interface BaseTrackParams {
+    mediaStreamTrack: MediaStreamTrack;
+    logLevel: LogLevel;
+    engine: Engine;
+    clientEventEmitter: EnhancedEventEmitter;
+    constraints: MediaStreamConstraints;
+    mediaStreamTrackManager: MediaStreamTrackManager;
+}
+export interface BaseTrack {
+    mediaStreamTrack: MediaStreamTrack;
+    id: string;
+    kind: MediaKind;
+    isPublished: boolean;
+    isPaused: boolean;
+    clientEventEmitter: EnhancedEventEmitter;
+    producerId?: string;
+    getLabel(): TrackLabel;
+    setLabel(label: TrackLabel): void;
+    setEncoderConfig(encoderConfig: EncoderConfig): void;
+    getEncoderConfig(): EncoderConfig;
+    setProducer(producer: Producer): void;
+    setStopTrackOnPause(value: boolean): void;
+    getProducer(): Producer | undefined;
+    stopMediaStreamTrack(): void;
+    closeProducer(stopTrack?: boolean): Promise<void>;
+    setPriority(priority: RTCPriorityType): Promise<void>;
+    produce({ encodings, codecOptions, preferredCodec, transformParams, keyFrameRequestDelay, }: TrackProduceParams): Promise<void>;
+    publish(): Promise<void>;
+    unpublish(): Promise<void>;
+    pause(): Promise<void>;
+    resume(): Promise<void>;
+    getInfo(): Promise<BaseTrackInfo>;
+    getStats(): Promise<TrackOutboundStats | undefined>;
+    replaceTrack(track: MediaStreamTrack): Promise<void>;
+}
+export interface TrackWithEncodings extends BaseTrack {
+    getCodecOptions(): ProducerCodecOptions;
+    getEncodings(): RtpEncodingParameters[];
+    getPreferredCodec(): string;
+}
+export interface TrackWithEffects extends BaseTrack {
+    isEffectsProcessing: boolean;
+}
+export interface AudioTrack extends BaseTrack, TrackWithEncodings, TrackWithEffects {
+    enableNoiseSuppression(): Promise<void>;
+    disableNoiseSuppression(): Promise<void>;
+}
+export declare type VideoTrackPublishParams = {
+    keyFrameRequestDelay?: number;
+};
+export interface VideoTrack extends BaseTrack, TrackWithEncodings, TrackWithEffects {
+    publish(params?: VideoTrackPublishParams): Promise<void>;
+    setTransformParams(transformParams: {}): void;
+    setMaxSpatialLayer(spatialLayer: number): Promise<void>;
+    getMaxSpatialLayer(): number | undefined;
+    enableBlur(): Promise<void>;
+    disableBlur(): Promise<void>;
+}
+export declare type Track = AudioTrack | VideoTrack;
+export interface AudioTrackParams extends BaseTrackParams {
+    noiseSuppressor?: WebAssembly.WebAssemblyInstantiatedSource;
+}
+export interface MediaTracksFactory {
+    createAudioTrack: (params: AudioTrackParams) => BaseTrack;
+    createVideoTrack: (params: BaseTrackParams) => BaseTrack;
+}

package/dist/types/network.d.ts

@@ -1,3 +1,4 @@
+import { SocketIOEvents } from '../constants/events';
 import { Role } from './common';
 export declare type GetNodeRequest = {
     channelId: string;
@@ -6,3 +7,22 @@ export declare type GetNodeRequest = {
 export declare type GetNodeResponse = {
     webSocketUrl: string;
 };
+export declare type JoinChannelRequest = {
+    appData?: Record<string, unknown>;
+};
+export declare type JoinChannelSuccessResponse = {
+    channelId: string;
+    appId: string;
+    role: string;
+};
+export declare type SocketConnectionError = {
+    message: string;
+    data?: {
+        errorCode: string;
+    };
+};
+export declare type SocketObserverEvent = {
+    state: SocketIOEvents;
+    code?: string;
+    error?: SocketConnectionError;
+};

package/package.json

@@ -2,7 +2,7 @@
   "name": "@livedigital/client",
   "author": "vlprojects",
   "license": "MIT",
-  "version": "2.45.0-test-speaker.1",
+  "version": "3.0.0",
   "private": false,
   "bugs": {
     "url": "https://github.com/vlprojects/livedigital-sdk/issues"
@@ -68,6 +68,7 @@
     "@types/chai-subset": "^1.3.3",
     "@types/emscripten": "^1.39.6",
     "@types/faker": "^5.5.9",
+    "@types/jsonwebtoken": "^9.0.2",
     "@types/mocha": "^10.0.1",
     "@types/node": "^14.18.36",
     "@types/qs": "^6.9.5",
@@ -88,6 +89,7 @@
     "eslint-plugin-react": "^7.26.1",
     "event-target-shim": "^6.0.2",
     "faker": "^5.5.3",
+    "jsonwebtoken": "^9.0.1",
     "mocha": "^10.2.0",
     "nyc": "^15.1.0",
     "rollup": "^2.57.0",

package/src/constants/common.ts

@@ -16,3 +16,5 @@ export const CONSUMER_CHECK_STATE_TIMEOUT = 4500;
 export const PRODUCER_CHECK_STATE_TIMEOUT = 3000;
 
 export const PEER_APP_DATA_MAX_SIZE_BYTES = 1024;
+
+export const SOCKET_ERROR_CODE_UNAUTHORIZED = 'unauthorized';

package/src/engine/handlers/ChannelAudioObserverEventHandler.ts

@@ -8,17 +8,12 @@ import {
   ChannelAudioObserverEvents,
   DominantSpeakerEvent, PeersVolumesEvent,
 } from '../../types/channelAudioObserver';
-import Peer from '../Peer';
 
 class ChannelAudioObserverEventHandler {
   private readonly engine: Engine;
 
   private readonly logger: Logger;
 
-  private lastDominantSpeaker?: Peer;
-
-  private isSilence = true;
-
   constructor(params: { engine: Engine, onLogMessage?: LogMessageHandler }) {
     const { engine, onLogMessage } = params;
     this.engine = engine;
@@ -61,12 +56,9 @@ class ChannelAudioObserverEventHandler {
     const { peerId } = payload.data;
     const peer = this.engine.getPeerById(peerId);
     this.engine.setActiveSpeakerPeer(peer);
-    this.lastDominantSpeaker = peer;
   }
 
   private handlePeerVolumes(payload: PeersVolumesEvent): void {
-    this.checkLastDominantSpeakerContinueSpeak(payload);
-    this.isSilence = false;
     payload.volumes.forEach((item) => {
       const { peerId, trackLabel, value } = item;
       const track = this.engine.getPeerById(peerId)?.tracks.get(trackLabel);
@@ -79,7 +71,6 @@ class ChannelAudioObserverEventHandler {
   }
 
   private handleSilence(): void {
-    this.isSilence = true;
     const tracks = this.engine.peers.flatMap((peer) => Array.from(peer.tracks.values()));
     tracks.forEach((track) => track.setVolume(0));
     this.engine.setActiveSpeakerPeer(undefined);
@@ -130,20 +121,6 @@ class ChannelAudioObserverEventHandler {
     }
   }
 
-  private checkLastDominantSpeakerContinueSpeak(payload: PeersVolumesEvent) {
-    if (!this.isSilence || !this.lastDominantSpeaker) {
-      return;
-    }
-
-    const lastDominantSpeakerVolume = payload.volumes.find((item) => item.peerId === this.lastDominantSpeaker?.id);
-    if (!lastDominantSpeakerVolume) {
-      return;
-    }
-
-    const lastDominantSpeakerPeer = this.engine.getPeerById(lastDominantSpeakerVolume.peerId);
-    this.engine.setActiveSpeakerPeer(lastDominantSpeakerPeer);
-  }
-
   static throwInvalidPayload(): void {
     throw new InvalidPayloadError('Invalid channel audio observer event handler payload');
   }

package/src/engine/handlers/MediaSoupEventHandler.ts

@@ -14,7 +14,7 @@ import {
   CLIENT_EVENTS, INTERNAL_CLIENT_EVENTS, MEDIASOUP_EVENTS, PEER_EVENTS,
 } from '../../constants/events';
 import Logger from '../Logger';
-import VideoTrack from '../media/tracks/VideoTrack';
+import VideoTrack from '../media/tracks/DefaultVideoTrack';
 
 class MediaSoupEventHandler {
   private readonly engine: Engine;

package/src/engine/index.ts

@@ -10,7 +10,6 @@ import {
   PeerResponse,
   Role,
   SocketResponse,
-  Track,
   TrackLabel,
   LogMessageHandler,
   LogLevel,
@@ -27,23 +26,32 @@ import Logger from './Logger';
 import {
   CHANNEL_EVENTS, CLIENT_EVENTS, INTERNAL_CLIENT_EVENTS, SocketIOEvents,
 } from '../constants/events';
-import { GetNodeRequest } from '../types/network';
-import VideoTrack from './media/tracks/VideoTrack';
+import {
+  GetNodeRequest, JoinChannelRequest, JoinChannelSuccessResponse, SocketConnectionError, SocketObserverEvent,
+} from '../types/network';
+import VideoTrack from './media/tracks/DefaultVideoTrack';
 import PeerTrack from './media/tracks/PeerTrack';
 import { retryAsync } from '../helpers/retry';
-import { EngineDependenciesFactory, IssuesHandler, NetworkScoresUpdatedHandler } from '../types/engine';
-import { LogLevels } from '../constants/common';
+import {
+  ConnectParams, EngineDependenciesFactory, IssuesHandler, NetworkScoresUpdatedHandler,
+} from '../types/engine';
+import { LogLevels, SOCKET_ERROR_CODE_UNAUTHORIZED } from '../constants/common';
 import { LoadBalancerApiClientParams } from './network/LoadBalancerClient';
 import validateAppData from '../helpers/appDataValidator';
-import AudioTrack from './media/tracks/AudioTrack';
 import NeedJoinFirstError from '../errors/NeedJoinFirstError';
 import ChannelAudioObserverEventHandler from './handlers/ChannelAudioObserverEventHandler';
+import {
+  MediaTracksFactory, AudioTrack, Track, BaseTrack,
+} from '../types/media';
 
 type EngineParams = {
-  clientEventEmitter: EnhancedEventEmitter,
+  clientEventEmitter: EnhancedEventEmitter;
   network: {
     loadbalancer: LoadBalancerApiClientParams;
-  },
+  };
+  media: {
+    mediaTracksFactory: MediaTracksFactory;
+  };
   dependenciesFactory: EngineDependenciesFactory;
   logLevel?: LogLevel;
   onLogMessage?: LogMessageHandler;
@@ -93,6 +101,7 @@ class Engine {
     const {
       clientEventEmitter,
       network,
+      media,
       dependenciesFactory,
       logLevel,
     } = params;
@@ -106,6 +115,7 @@ class Engine {
       logLevel: this.logLevel,
       engine: this,
       clientEventEmitter,
+      mediaTracksFactory: media.mediaTracksFactory,
       onLogMessage: params.onLogMessage,
     });
     this.network = dependenciesFactory.createNetwork({
@@ -201,9 +211,16 @@ class Engine {
   }
 
   private watchSocketState(): void {
-    this.network.socket.observer.on('state', (evt: { state: SocketIOEvents, code?: string }) => {
-      const { state, code } = evt;
-      this.clientEventEmitter.emit(state, { code });
+    this.network.socket.observer.on('state', (evt: SocketObserverEvent) => {
+      const { state, code, error } = evt;
+      this.clientEventEmitter.emit(state, { code, error });
+
+      const isUnauthorizedError = error?.data?.errorCode === SOCKET_ERROR_CODE_UNAUTHORIZED;
+      if (state === SocketIOEvents.Error && this.isJoined && isUnauthorizedError) {
+        // reconnection failed due to expired token
+        this.clientEventEmitter.emit(CLIENT_EVENTS.channelRejoinRequired);
+        return;
+      }
 
       if (state === SocketIOEvents.Reconnected) {
         this.clientEventEmitter.emit(CLIENT_EVENTS.channelRejoinRequired);
@@ -252,7 +269,7 @@ class Engine {
       this.logger.debug('join()', { params });
       this.isChannelJoining = true;
       await this.connectToSocketServerWithRetry(params);
-      await this.performJoin(params);
+      await this.performJoin({ appData: params.appData });
     } catch (error) {
       this.logger.error('join()', { error });
       throw error;
@@ -310,7 +327,7 @@ class Engine {
     }
   }
 
-  async createCameraVideoTrack(options?: CreateCameraVideoTrackOptions): Promise<Track> {
+  async createCameraVideoTrack(options?: CreateCameraVideoTrackOptions): Promise<VideoTrack> {
     const trackParams = Media.getCameraVideoTrackParams(options);
     try {
       const [track] = await this.media.createUserMediaTracks({
@@ -334,14 +351,14 @@ class Engine {
 
       this.media.setTrack(track);
       this.logger.debug('createCameraVideoTrack()', { trackParams, track });
-      return track;
+      return track as VideoTrack;
     } catch (error) {
       this.logger.error('createCameraVideoTrack()', { error, trackParams });
       throw new Error(`Can not create camera track: ${error.message}`);
     }
   }
 
-  async createMicrophoneAudioTrack(options?: CreateMicrophoneAudioTrackOptions): Promise<Track> {
+  async createMicrophoneAudioTrack(options?: CreateMicrophoneAudioTrackOptions): Promise<AudioTrack> {
     try {
       const [track] = await this.media.createUserMediaTracks({
         video: false,
@@ -354,9 +371,9 @@ class Engine {
         track.setEncoderConfig(options.encoderConfig);
       }
 
-      if (track instanceof AudioTrack && options?.noiseSuppression) {
+      if (track.kind === 'audio' && options?.noiseSuppression) {
         try {
-          await track.enableNoiseSuppression();
+          await (track as AudioTrack).enableNoiseSuppression();
         } catch (error) {
           this.logger.warn('Failed to start noise suppression, featured original track', { track: this });
         }
@@ -364,7 +381,7 @@ class Engine {
 
       this.media.setTrack(track);
       this.logger.debug('createMicrophoneAudioTrack()', { options, track });
-      return track;
+      return track as AudioTrack;
     } catch (error) {
       this.logger.error('createMicrophoneAudioTrack()', { error, options });
       throw new Error(`Can not create microphone track: ${error.message}`);
@@ -413,14 +430,14 @@ class Engine {
         });
       });
 
-      return tracks;
+      return tracks as Track[];
     } catch (error) {
       this.logger.error('createScreenMediaTrack()', { error, trackParams: videoTrackParams });
       throw new Error(`Can not create screen media tracks: ${error.message}`);
     }
   }
 
-  deleteTrack(tracks: Track): Promise<void> {
+  deleteTrack(tracks: BaseTrack): Promise<void> {
     return this.media.deleteTrack(tracks);
   }
 
@@ -445,7 +462,7 @@ class Engine {
     this.clientEventEmitter.safeEmit(CLIENT_EVENTS.activeSpeakerChanged, { peer });
   }
 
-  private async connectToSocketServerWithRetry(params: { channelId: string, role: Role }): Promise<void> {
+  private async connectToSocketServerWithRetry(params: ConnectParams): Promise<void> {
     const connectToSocketServerAction = async () => this.connectToSocketServer(params);
     return retryAsync(connectToSocketServerAction, {
       maxRetries: 15,
@@ -456,15 +473,17 @@ class Engine {
         namespace: 'RetrySocketConnect',
         logLevel: this.logLevel,
       }),
+      abortOnError: (error: SocketConnectionError) => error?.data?.errorCode === SOCKET_ERROR_CODE_UNAUTHORIZED,
     });
   }
 
-  private async connectToSocketServer(params: { channelId: string, role: Role }): Promise<void> {
+  private async connectToSocketServer(params: ConnectParams): Promise<void> {
     const { webSocketUrl } = await this.getAvailableNode({
       channelId: params.channelId,
       role: params.role,
     });
-    this.network.socket.connect(webSocketUrl);
+
+    this.network.socket.connect(webSocketUrl, params.token);
 
     try {
       await this.waitForSocketConnection();
@@ -493,7 +512,7 @@ class Engine {
 
   private waitForSocketConnection(): Promise<void> {
     return new Promise((resolve, reject) => {
-      const onSocketStateChange = async (data: { state: SocketIOEvents, error?: string }) => {
+      const onSocketStateChange = async (data: SocketObserverEvent) => {
         const { error, state } = data;
         const stopListening = () => this.network.socket.observer.removeListener('state', onSocketStateChange);
         const isStateNotExpected = [SocketIOEvents.Disconnected, SocketIOEvents.Reconnecting].includes(state);
@@ -520,16 +539,16 @@ class Engine {
     });
   }
 
-  private async performJoin(params: JoinChannelParams): Promise<void> {
+  private async performJoin(params: JoinChannelRequest): Promise<void> {
     try {
-      await this.sendJoinChannelRequestWithRetry(params);
-      this.app = params.appId;
-      this.channel = params.channelId;
+      const { appId, channelId } = await this.sendJoinChannelRequestWithRetry<JoinChannelSuccessResponse>(params);
+      this.app = appId;
+      this.channel = channelId;
       await this.initialize();
       this.channelEventsHandler.subscribeToEvents();
       this.mediaSoupEventsHandler.subscribeToEvents();
       this.isJoined = true;
-      this.logger.debug('Successfully joined channel', { channelId: params.channelId });
+      this.logger.debug('Successfully joined channel', { channelId });
       await this.createAudioObserver();
     } catch (error) {
       this.logger.error('performJoin()', { error });
@@ -537,8 +556,8 @@ class Engine {
     }
   }
 
-  private async sendJoinChannelRequestWithRetry(params: JoinChannelParams): Promise<SocketResponse> {
-    const joinChannelAction = async () => this.sendJoinChannelRequest(params);
+  private async sendJoinChannelRequestWithRetry<T>(params: JoinChannelRequest): Promise<SocketResponse<T>> {
+    const joinChannelAction = async () => this.sendJoinChannelRequest<T>(params);
     return retryAsync(joinChannelAction, {
       maxRetries: 3,
       minBackoffDelayMs: 300,
@@ -550,8 +569,8 @@ class Engine {
     });
   }
 
-  private async sendJoinChannelRequest(params: JoinChannelParams): Promise<SocketResponse> {
-    return this.network.socket.request(CHANNEL_EVENTS.channelJoin, params);
+  private async sendJoinChannelRequest<T>(params: JoinChannelRequest): Promise<SocketResponse<T>> {
+    return this.network.socket.request<T>(CHANNEL_EVENTS.channelJoin, params);
   }
 
   get cahPublish(): boolean {

package/src/engine/media/DefaultMediaTracksFactory.ts

@@ -0,0 +1,17 @@
+import {
+  AudioTrack, AudioTrackParams, BaseTrackParams, MediaTracksFactory, VideoTrack,
+} from '../../types/media';
+import DefaultVideoTrack from './tracks/DefaultVideoTrack';
+import DefaultAudioTrack from './tracks/DefaultAudioTrack';
+
+class DefaultMediaTracksFactory implements MediaTracksFactory {
+  createAudioTrack(params: AudioTrackParams): AudioTrack {
+    return new DefaultAudioTrack(params);
+  }
+
+  createVideoTrack(params: BaseTrackParams): VideoTrack {
+    return new DefaultVideoTrack(params);
+  }
+}
+
+export default DefaultMediaTracksFactory;

package/src/engine/media/index.ts

@@ -1,14 +1,11 @@
 import { Device } from 'mediasoup-client';
 import { RtpCapabilities, RtpCodecCapability } from 'mediasoup-client/lib/RtpParameters';
-import VideoTrack from './tracks/VideoTrack';
-import AudioTrack from './tracks/AudioTrack';
 import {
   CreateCameraVideoTrackOptions,
   CreateScreenMediaOptions,
   CreateTracksPayload,
   CreateVideoTrackParams,
   LogLevel,
-  Track,
   TrackLabel,
   TransformParams,
 } from '../../types/common';
@@ -21,13 +18,16 @@ import EnhancedEventEmitter from '../../EnhancedEventEmitter';
 import MediaStreamTrackManager from './tracks/MediaStreamTrackManager';
 import { detectHandlerName } from '../../helpers/media';
 import WasmModuleCompiler from './streamEffects/audio/noiseSuppression/WasmModuleCompiler';
+import {
+  AudioTrack, BaseTrack, MediaTracksFactory, TrackWithEncodings, VideoTrack,
+} from '../../types/media';
 
 class Media {
   public isDeviceLoaded = false;
 
   private device?: Device;
 
-  private tracks: Map<TrackLabel, Track> = new Map();
+  private tracks: Map<TrackLabel, BaseTrack> = new Map();
 
   readonly #logger: Logger;
 
@@ -39,6 +39,8 @@ class Media {
 
   readonly #mediaStreamTrackManager: MediaStreamTrackManager;
 
+  readonly #mediaTracksFactory: MediaTracksFactory;
+
   #noiseSuppressor?: WebAssembly.WebAssemblyInstantiatedSource;
 
   constructor(params: CreateMediaParams) {
@@ -50,6 +52,7 @@ class Media {
     });
     this.#engine = params.engine;
     this.#clientEventEmitter = params.clientEventEmitter;
+    this.#mediaTracksFactory = params.mediaTracksFactory;
     this.#mediaStreamTrackManager = new MediaStreamTrackManager({
       logLevel: params.logLevel,
       onLogMessage: params.onLogMessage,
@@ -68,7 +71,7 @@ class Media {
     return !!this.#noiseSuppressor;
   }
 
-  getTrack(label: TrackLabel): Track | undefined {
+  getTrack(label: TrackLabel): BaseTrack | undefined {
     return this.tracks.get(label);
   }
 
@@ -92,7 +95,7 @@ class Media {
     }
   }
 
-  getTrackCodec(track: Track): RtpCodecCapability | undefined {
+  getTrackCodec(track: TrackWithEncodings): RtpCodecCapability | undefined {
     const { rtpCapabilities, rtpCapabilities: { codecs } } = this.mediasoupDevice;
     if (!codecs) {
       this.#logger.error('getTrackCodec()', { track, rtpCapabilities });
@@ -102,7 +105,7 @@ class Media {
     return codecs.find((c) => c.mimeType.toLowerCase() === `${track.kind}/${track.getPreferredCodec()}`);
   }
 
-  private createTracks({ constraints, mediaStreamTracks }: CreateTracksPayload): Track[] {
+  private createTracks({ constraints, mediaStreamTracks }: CreateTracksPayload): BaseTrack[] {
     return mediaStreamTracks.map((mediaStreamTrack) => {
       const params = {
         mediaStreamTrack,
@@ -114,8 +117,8 @@ class Media {
       };
 
       const track = mediaStreamTrack.kind === 'audio'
-        ? new AudioTrack({ ...params, noiseSuppressor: this.#noiseSuppressor })
-        : new VideoTrack(params);
+        ? this.#mediaTracksFactory.createAudioTrack({ ...params, noiseSuppressor: this.#noiseSuppressor })
+        : this.#mediaTracksFactory.createVideoTrack(params);
 
       this.#logger.debug('createTrack() track created', {
         trackId: track.id,
@@ -126,24 +129,24 @@ class Media {
     });
   }
 
-  async createUserMediaTracks(constraints: MediaStreamConstraints): Promise<Track[]> {
+  async createUserMediaTracks(constraints: MediaStreamConstraints): Promise<BaseTrack[]> {
     const mediaStreamTracks = await this.#mediaStreamTrackManager.createUserMediaTracks(constraints);
     return this.createTracks({ constraints, mediaStreamTracks });
   }
 
-  async createDisplayMediaTracks(constraints: MediaStreamConstraints): Promise<Track[]> {
+  async createDisplayMediaTracks(constraints: MediaStreamConstraints): Promise<BaseTrack[]> {
     const mediaStreamTracks = await this.#mediaStreamTrackManager.createDisplayMediaTracks(constraints);
     return this.createTracks({ constraints, mediaStreamTracks });
   }
 
-  async deleteTrack(track: Track) {
+  async deleteTrack(track: BaseTrack) {
     await track.closeProducer();
     if ('disableNoiseSuppression' in track) {
-      await track.disableNoiseSuppression();
+      await (track as AudioTrack).disableNoiseSuppression();
     }
 
     if ('disableBlur' in track) {
-      await track.disableBlur();
+      await (track as VideoTrack).disableBlur();
     }
 
     track.stopMediaStreamTrack();
@@ -151,7 +154,7 @@ class Media {
     this.#logger.debug('deleteTrack() tack deleted', { trackId: track.id, kind: track.kind });
   }
 
-  getAllTracks(): Track[] {
+  getAllTracks(): BaseTrack[] {
     return Array.from(this.tracks.values());
   }
 
@@ -165,7 +168,7 @@ class Media {
     }
   }
 
-  setTrack(track: Track): void {
+  setTrack(track: BaseTrack): void {
     this.tracks.set(track.getLabel(), track);
   }