livekit-client 0.18.5 → 1.0.1

package/src/api/SignalClient.ts

@@ -123,15 +123,25 @@ export class SignalClient {
     this.requestQueue = new Queue();
   }
 
-  async join(url: string, token: string, opts?: SignalOptions): Promise<JoinResponse> {
+  async join(
+    url: string,
+    token: string,
+    opts?: SignalOptions,
+    abortSignal?: AbortSignal,
+  ): Promise<JoinResponse> {
     // during a full reconnect, we'd want to start the sequence even if currently
     // connected
     this.isConnected = false;
-    const res = await this.connect(url, token, {
-      autoSubscribe: opts?.autoSubscribe,
-      publishOnly: opts?.publishOnly,
-      adaptiveStream: opts?.adaptiveStream,
-    });
+    const res = await this.connect(
+      url,
+      token,
+      {
+        autoSubscribe: opts?.autoSubscribe,
+        publishOnly: opts?.publishOnly,
+        adaptiveStream: opts?.adaptiveStream,
+      },
+      abortSignal,
+    );
     return res as JoinResponse;
   }
 
@@ -142,7 +152,12 @@ export class SignalClient {
     });
   }
 
-  connect(url: string, token: string, opts: ConnectOpts): Promise<JoinResponse | void> {
+  connect(
+    url: string,
+    token: string,
+    opts: ConnectOpts,
+    abortSignal?: AbortSignal,
+  ): Promise<JoinResponse | void> {
     if (url.startsWith('http')) {
       url = url.replace('http', 'ws');
     }
@@ -154,6 +169,15 @@ export class SignalClient {
     const params = createConnectionParams(token, clientInfo, opts);
 
     return new Promise<JoinResponse | void>((resolve, reject) => {
+      const abortHandler = () => {
+        ws.close();
+        this.close();
+        reject(new ConnectionError('room connection has been cancelled'));
+      };
+      if (abortSignal?.aborted) {
+        abortHandler();
+      }
+      abortSignal?.addEventListener('abort', abortHandler);
       log.debug(`connecting to ${url + params}`);
       this.ws = undefined;
       const ws = new WebSocket(url + params);
@@ -204,6 +228,7 @@ export class SignalClient {
           // handle join message only
           if (msg.join) {
             this.isConnected = true;
+            abortSignal?.removeEventListener('abort', abortHandler);
             resolve(msg.join);
           } else {
             reject(new ConnectionError('did not receive join response'));

package/src/index.ts

@@ -4,7 +4,7 @@ import LocalParticipant from './room/participant/LocalParticipant';
 import Participant, { ConnectionQuality } from './room/participant/Participant';
 import { ParticipantTrackPermission } from './room/participant/ParticipantTrackPermission';
 import RemoteParticipant from './room/participant/RemoteParticipant';
-import Room, { RoomState } from './room/Room';
+import Room, { ConnectionState, RoomState } from './room/Room';
 import LocalAudioTrack from './room/track/LocalAudioTrack';
 import LocalTrack from './room/track/LocalTrack';
 import LocalTrackPublication from './room/track/LocalTrackPublication';
@@ -12,10 +12,9 @@ import LocalVideoTrack from './room/track/LocalVideoTrack';
 import RemoteAudioTrack from './room/track/RemoteAudioTrack';
 import RemoteTrack from './room/track/RemoteTrack';
 import RemoteTrackPublication from './room/track/RemoteTrackPublication';
-import RemoteVideoTrack from './room/track/RemoteVideoTrack';
+import RemoteVideoTrack, { ElementInfo } from './room/track/RemoteVideoTrack';
 import { TrackPublication } from './room/track/TrackPublication';
 
-export * from './connect';
 export * from './options';
 export * from './room/errors';
 export * from './room/events';
@@ -29,6 +28,7 @@ export {
   setLogExtension,
   LogLevel,
   Room,
+  ConnectionState,
   RoomState,
   DataPacket_Kind,
   Participant,
@@ -46,4 +46,5 @@ export {
   TrackPublication,
   VideoQuality,
   ConnectionQuality,
+  ElementInfo,
 };

package/src/options.ts

@@ -1,7 +1,5 @@
-import { LogLevel } from './logger';
 import {
   AudioCaptureOptions,
-  CreateLocalTracksOptions,
   TrackPublishDefaults,
   VideoCaptureOptions,
 } from './room/track/options';
@@ -74,83 +72,3 @@ export interface RoomConnectOptions {
    */
   publishOnly?: string;
 }
-
-/**
- * @deprecated use new Room([[RoomOptions]]) and room.connect([[RoomConnectOptions]]) instead
- *
- * if video or audio tracks are created as part of [[connect]], it'll automatically
- * publish those tracks to the room.
- */
-export interface ConnectOptions extends CreateLocalTracksOptions {
-  /** autosubscribe to room tracks upon connect, defaults to true */
-  autoSubscribe?: boolean;
-
-  /**
-   * publish only mode
-   */
-  publishOnly?: string;
-
-  /**
-   * see [[RoomOptions.adaptiveStream]]
-   */
-  adaptiveStream?: AdaptiveStreamSettings | boolean;
-
-  /**
-   * alias for adaptiveStream
-   * @deprecated
-   */
-  autoManageVideo?: boolean;
-
-  /**
-   * see [[RoomOptions.dynacast]]
-   */
-  dynacast?: boolean;
-
-  /** configures LiveKit internal log level */
-  logLevel?: LogLevel;
-
-  /**
-   * set ICE servers. When deployed correctly, LiveKit automatically uses the built-in TURN servers
-   */
-  iceServers?: RTCIceServer[];
-
-  /**
-   * use to override any RTCConfiguration options.
-   */
-  rtcConfig?: RTCConfiguration;
-
-  /**
-   * capture and publish audio track on connect, defaults to false
-   *
-   * If this option is used, you will not be notified if user denies capture permission.
-   */
-  audio?: boolean;
-
-  /**
-   * capture and publish video track on connect, defaults to false
-   *
-   * If this option is used, you will not be notified if user denies capture permission.
-   */
-  video?: boolean;
-
-  /**
-   * default options to use when capturing user's audio
-   */
-  audioCaptureDefaults?: AudioCaptureOptions;
-
-  /**
-   * default options to use when capturing user's video
-   */
-  videoCaptureDefaults?: VideoCaptureOptions;
-
-  /**
-   * default options to use when publishing tracks
-   */
-  publishDefaults?: TrackPublishDefaults;
-
-  /**
-   * should local tracks be stopped when they are unpublished. defaults to true
-   * set this to false if you would prefer to clean up unpublished local tracks manually.
-   */
-  stopLocalTrackOnUnpublish?: boolean;
-}

package/src/room/DeviceManager.ts

@@ -32,8 +32,11 @@ export default class DeviceManager {
           video: kind !== 'audioinput' && kind !== 'audiooutput',
           audio: kind !== 'videoinput',
         };
-        await navigator.mediaDevices.getUserMedia(permissionsToAcquire);
+        const stream = await navigator.mediaDevices.getUserMedia(permissionsToAcquire);
         devices = await navigator.mediaDevices.enumerateDevices();
+        stream.getTracks().forEach((track) => {
+          track.stop();
+        });
       }
     }
     if (kind) {

package/src/room/RTCEngine.ts

@@ -48,6 +48,10 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
   rtcConfig: RTCConfiguration = {};
 
+  get isClosed() {
+    return this._isClosed;
+  }
+
   private lossyDC?: RTCDataChannel;
 
   // @ts-ignore noUnusedLocals
@@ -64,7 +68,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
   private pcState: PCState = PCState.New;
 
-  private isClosed: boolean = true;
+  private _isClosed: boolean = true;
 
   private pendingTrackResolvers: { [key: string]: (info: TrackInfo) => void } = {};
 
@@ -94,13 +98,18 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     this.client = new SignalClient();
   }
 
-  async join(url: string, token: string, opts?: SignalOptions): Promise<JoinResponse> {
+  async join(
+    url: string,
+    token: string,
+    opts?: SignalOptions,
+    abortSignal?: AbortSignal,
+  ): Promise<JoinResponse> {
     this.url = url;
     this.token = token;
     this.signalOpts = opts;
 
-    const joinResponse = await this.client.join(url, token, opts);
-    this.isClosed = false;
+    const joinResponse = await this.client.join(url, token, opts, abortSignal);
+    this._isClosed = false;
 
     this.subscriberPrimary = joinResponse.subscriberPrimary;
     if (!this.publisher) {
@@ -117,7 +126,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
   }
 
   close() {
-    this.isClosed = true;
+    this._isClosed = true;
 
     this.removeAllListeners();
     if (this.publisher && this.publisher.pc.signalingState !== 'closed') {
@@ -403,7 +412,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
   // continues to work, we can reconnect to websocket to continue the session
   // after a number of retries, we'll close and give up permanently
   private handleDisconnect = (connection: string) => {
-    if (this.isClosed) {
+    if (this._isClosed) {
       return;
     }
     log.debug(`${connection} disconnected`);
@@ -414,7 +423,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
     const delay = this.reconnectAttempts * this.reconnectAttempts * 300;
     setTimeout(async () => {
-      if (this.isClosed) {
+      if (this._isClosed) {
         return;
       }
       if (

package/src/room/Room.ts

@@ -35,12 +35,16 @@ import { AdaptiveStreamSettings, RemoteTrack } from './track/types';
 import { getNewAudioContext } from './track/utils';
 import { isWeb, unpackStreamId } from './utils';
 
-export enum RoomState {
+export enum ConnectionState {
   Disconnected = 'disconnected',
+  Connecting = 'connecting',
   Connected = 'connected',
   Reconnecting = 'reconnecting',
 }
 
+/** @deprecated RoomState has been renamed to [[ConnectionState]] */
+export const RoomState = ConnectionState;
+
 /**
  * In LiveKit, a room is the logical grouping for a list of participants.
  * Participants in a room can publish tracks, and subscribe to others' tracks.
@@ -50,7 +54,7 @@ export enum RoomState {
  * @noInheritDoc
  */
 class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>) {
-  state: RoomState = RoomState.Disconnected;
+  state: ConnectionState = ConnectionState.Disconnected;
 
   /** map of sid: [[RemoteParticipant]] */
   participants: Map<string, RemoteParticipant>;
@@ -87,6 +91,9 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
   private audioContext?: AudioContext;
 
+  /** used for aborting pending connections to a LiveKit server */
+  private abortController?: AbortController;
+
   /**
    * Creates a new Room, the primary construct for a LiveKit session.
    * @param options
@@ -150,18 +157,16 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       .on(EngineEvent.ActiveSpeakersUpdate, this.handleActiveSpeakersUpdate)
       .on(EngineEvent.DataPacketReceived, this.handleDataPacket)
       .on(EngineEvent.Resuming, () => {
-        this.state = RoomState.Reconnecting;
+        this.setAndEmitConnectionState(ConnectionState.Reconnecting);
         this.emit(RoomEvent.Reconnecting);
-        this.emit(RoomEvent.StateChanged, this.state);
       })
       .on(EngineEvent.Resumed, () => {
-        this.state = RoomState.Connected;
+        this.setAndEmitConnectionState(ConnectionState.Connected);
         this.emit(RoomEvent.Reconnected);
-        this.emit(RoomEvent.StateChanged, this.state);
         this.updateSubscriptions();
       })
       .on(EngineEvent.SignalResumed, () => {
-        if (this.state === RoomState.Reconnecting) {
+        if (this.state === ConnectionState.Reconnecting) {
           this.sendSyncState();
         }
       })
@@ -186,11 +191,17 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
   connect = async (url: string, token: string, opts?: RoomConnectOptions) => {
     // guard against calling connect
-    if (this.state !== RoomState.Disconnected) {
+    if (this.state !== ConnectionState.Disconnected) {
       log.warn(`already connected to room ${this.name}`);
       return;
     }
 
+    this.setAndEmitConnectionState(ConnectionState.Connecting);
+
+    if (!this.abortController || this.abortController.signal.aborted) {
+      this.abortController = new AbortController();
+    }
+
     // recreate engine if previously disconnected
     this.createEngine();
 
@@ -203,12 +214,17 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.connOptions = opts;
 
     try {
-      const joinResponse = await this.engine.join(url, token, {
-        autoSubscribe: opts?.autoSubscribe,
-        publishOnly: opts?.publishOnly,
-        adaptiveStream:
-          typeof this.options?.adaptiveStream === 'object' ? true : this.options?.adaptiveStream,
-      });
+      const joinResponse = await this.engine.join(
+        url,
+        token,
+        {
+          autoSubscribe: opts?.autoSubscribe,
+          publishOnly: opts?.publishOnly,
+          adaptiveStream:
+            typeof this.options?.adaptiveStream === 'object' ? true : this.options?.adaptiveStream,
+        },
+        this.abortController.signal,
+      );
       log.debug(
         `connected to Livekit Server version: ${joinResponse.serverVersion}, region: ${joinResponse.serverRegion}`,
       );
@@ -223,7 +239,6 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         this.options.dynacast = false;
       }
 
-      this.state = RoomState.Connected;
       const pi = joinResponse.participant!;
 
       this.localParticipant.sid = pi.sid;
@@ -232,9 +247,6 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       this.localParticipant.updateInfo(pi);
       // forward metadata changed for the local participant
       this.localParticipant
-        .on(ParticipantEvent.MetadataChanged, (metadata: string | undefined) => {
-          this.emit(RoomEvent.MetadataChanged, metadata, this.localParticipant);
-        })
         .on(ParticipantEvent.ParticipantMetadataChanged, (metadata: string | undefined) => {
           this.emit(RoomEvent.ParticipantMetadataChanged, metadata, this.localParticipant);
         })
@@ -275,9 +287,9 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       this.name = joinResponse.room!.name;
       this.sid = joinResponse.room!.sid;
       this.metadata = joinResponse.room!.metadata;
-      this.emit(RoomEvent.StateChanged, this.state);
     } catch (err) {
       this.engine.close();
+      this.setAndEmitConnectionState(ConnectionState.Disconnected);
       throw err;
     }
 
@@ -286,18 +298,30 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       const connectTimeout = setTimeout(() => {
         // timeout
         this.engine.close();
+        this.setAndEmitConnectionState(ConnectionState.Disconnected);
         reject(new ConnectionError('could not connect after timeout'));
       }, maxICEConnectTimeout);
+      const abortHandler = () => {
+        log.warn('closing engine');
+        clearTimeout(connectTimeout);
+        this.engine.close();
+        this.setAndEmitConnectionState(ConnectionState.Disconnected);
+        reject(new ConnectionError('room connection has been cancelled'));
+      };
+      if (this.abortController?.signal.aborted) {
+        abortHandler();
+      }
+      this.abortController?.signal.addEventListener('abort', abortHandler);
 
       this.engine.once(EngineEvent.Connected, () => {
         clearTimeout(connectTimeout);
-
+        this.abortController?.signal.removeEventListener('abort', abortHandler);
         // also hook unload event
         if (isWeb()) {
           window.addEventListener('beforeunload', this.onBeforeUnload);
           navigator.mediaDevices?.addEventListener('devicechange', this.handleDeviceChange);
         }
-
+        this.setAndEmitConnectionState(ConnectionState.Connected);
         resolve(this);
       });
     });
@@ -307,6 +331,12 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
    * disconnects the room, emits [[RoomEvent.Disconnected]]
    */
   disconnect = (stopTracks = true) => {
+    if (this.state === ConnectionState.Connecting) {
+      // try aborting pending connection attempt
+      log.warn('abort connection attempt');
+      this.abortController?.abort();
+      return;
+    }
     // send leave
     if (this.engine) {
       this.engine.client.sendLeave();
@@ -482,9 +512,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   }
 
   private handleRestarting = () => {
-    this.state = RoomState.Reconnecting;
+    this.setAndEmitConnectionState(ConnectionState.Reconnecting);
     this.emit(RoomEvent.Reconnecting);
-    this.emit(RoomEvent.StateChanged, this.state);
 
     // also unwind existing participants & existing subscriptions
     for (const p of this.participants.values()) {
@@ -494,9 +523,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
   private handleRestarted = async (joinResponse: JoinResponse) => {
     log.debug(`reconnected to server region ${joinResponse.serverRegion}`);
-    this.state = RoomState.Connected;
+    this.setAndEmitConnectionState(ConnectionState.Connected);
     this.emit(RoomEvent.Reconnected);
-    this.emit(RoomEvent.StateChanged, this.state);
 
     // rehydrate participants
     if (joinResponse.participant) {
@@ -524,9 +552,6 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   };
 
   private handleDisconnect(shouldStopTracks = true) {
-    if (this.state === RoomState.Disconnected) {
-      return;
-    }
     this.participants.forEach((p) => {
       p.tracks.forEach((pub) => {
         p.unpublishTrack(pub.trackSid);
@@ -535,7 +560,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
     this.localParticipant.tracks.forEach((pub) => {
       if (pub.track) {
-        this.localParticipant.unpublishTrack(pub.track);
+        this.localParticipant.unpublishTrack(pub.track, shouldStopTracks);
       }
       if (shouldStopTracks) {
         pub.track?.detach();
@@ -553,9 +578,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       window.removeEventListener('beforeunload', this.onBeforeUnload);
       navigator.mediaDevices?.removeEventListener('devicechange', this.handleDeviceChange);
     }
-    this.state = RoomState.Disconnected;
+    this.setAndEmitConnectionState(ConnectionState.Disconnected);
     this.emit(RoomEvent.Disconnected);
-    this.emit(RoomEvent.StateChanged, this.state);
   }
 
   private handleParticipantUpdates = (participantInfos: ParticipantInfo[]) => {
@@ -821,9 +845,6 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       .on(ParticipantEvent.TrackUnmuted, (pub: TrackPublication) => {
         this.emit(RoomEvent.TrackUnmuted, pub, participant);
       })
-      .on(ParticipantEvent.MetadataChanged, (metadata: string | undefined) => {
-        this.emit(RoomEvent.MetadataChanged, metadata, participant);
-      })
       .on(ParticipantEvent.ParticipantMetadataChanged, (metadata: string | undefined) => {
         this.emit(RoomEvent.ParticipantMetadataChanged, metadata, participant);
       })
@@ -892,6 +913,14 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     }
   }
 
+  private setAndEmitConnectionState(state: ConnectionState) {
+    if (state === this.state) {
+      return;
+    }
+    this.state = state;
+    this.emit(RoomEvent.ConnectionStateChanged, this.state);
+  }
+
   // /** @internal */
   emit<E extends keyof RoomEventCallbacks>(
     event: E,
@@ -908,7 +937,9 @@ export type RoomEventCallbacks = {
   reconnecting: () => void;
   reconnected: () => void;
   disconnected: () => void;
-  stateChanged: (state: RoomState) => void;
+  /** @deprecated stateChanged has been renamed to connectionStateChanged */
+  stateChanged: (state: ConnectionState) => void;
+  connectionStateChanged: (state: ConnectionState) => void;
   mediaDevicesChanged: () => void;
   participantConnected: (participant: RemoteParticipant) => void;
   participantDisconnected: (participant: RemoteParticipant) => void;
@@ -932,13 +963,6 @@ export type RoomEventCallbacks = {
     publication: LocalTrackPublication,
     participant: LocalParticipant,
   ) => void;
-  /**
-   * @deprecated use [[participantMetadataChanged]] instead
-   */
-  metadataChanged: (
-    metadata: string | undefined,
-    participant?: RemoteParticipant | LocalParticipant,
-  ) => void;
   participantMetadataChanged: (
     metadata: string | undefined,
     participant: RemoteParticipant | LocalParticipant,

package/src/room/events.ts

@@ -29,9 +29,14 @@ export enum RoomEvent {
   /**
    * Whenever the connection state of the room changes
    *
-   * args: ([[RoomState]])
+   * args: ([[ConnectionState]])
    */
-  StateChanged = 'stateChanged',
+  ConnectionStateChanged = 'connectionStateChanged',
+
+  /**
+   * @deprecated StateChanged has been renamed to ConnectionStateChanged
+   */
+  StateChanged = 'connectionStateChanged',
 
   /**
    * When input or output devices on the machine have changed.
@@ -139,12 +144,6 @@ export enum RoomEvent {
    */
   ActiveSpeakersChanged = 'activeSpeakersChanged',
 
-  /**
-   * @deprecated Use ParticipantMetadataChanged instead
-   * @internal
-   */
-  MetadataChanged = 'metadataChanged',
-
   /**
    * Participant metadata is a simple way for app-specific state to be pushed to
    * all users.
@@ -308,12 +307,6 @@ export enum ParticipantEvent {
    */
   LocalTrackUnpublished = 'localTrackUnpublished',
 
-  /**
-   * @deprecated Use ParticipantMetadataChanged instead
-   * @internal
-   */
-  MetadataChanged = 'metadataChanged',
-
   /**
    * Participant metadata is a simple way for app-specific state to be pushed to
    * all users.

package/src/room/participant/LocalParticipant.ts

@@ -436,6 +436,10 @@ export default class LocalParticipant extends Participant {
       ];
     }
 
+    if (!this.engine || this.engine.isClosed) {
+      throw new UnexpectedConnectionState('cannot publish track when not connected');
+    }
+
     const ti = await this.engine.addTrack(req);
     const publication = new LocalTrackPublication(track.kind, ti, track);
     track.sid = ti.sid;

package/src/room/participant/Participant.ts

@@ -188,7 +188,6 @@ export default class Participant extends (EventEmitter as new () => TypedEmitter
     this.metadata = md;
 
     if (changed) {
-      this.emit(ParticipantEvent.MetadataChanged, prevMetadata);
       this.emit(ParticipantEvent.ParticipantMetadataChanged, prevMetadata);
     }
   }
@@ -266,10 +265,6 @@ export type ParticipantEventCallbacks = {
   trackUnmuted: (publication: TrackPublication) => void;
   localTrackPublished: (publication: LocalTrackPublication) => void;
   localTrackUnpublished: (publication: LocalTrackPublication) => void;
-  /**
-   * @deprecated use [[participantMetadataChanged]] instead
-   */
-  metadataChanged: (prevMetadata: string | undefined, participant?: any) => void;
   participantMetadataChanged: (prevMetadata: string | undefined, participant?: any) => void;
   dataReceived: (payload: Uint8Array, kind: DataPacket_Kind) => void;
   isSpeakingChanged: (speaking: boolean) => void;

package/src/room/participant/RemoteParticipant.ts

@@ -19,6 +19,8 @@ export default class RemoteParticipant extends Participant {
 
   signalClient: SignalClient;
 
+  private volume?: number;
+
   /** @internal */
   static fromParticipantInfo(signalClient: SignalClient, pi: ParticipantInfo): RemoteParticipant {
     const rp = new RemoteParticipant(signalClient, pi.sid, pi.identity);
@@ -68,24 +70,26 @@ export default class RemoteParticipant extends Participant {
   }
 
   /**
-   * sets the volume on the participant's microphone track if it exists.
+   * sets the volume on the participant's microphone track
+   * if no track exists the volume will be applied when the microphone track is added
    */
   setVolume(volume: number) {
+    this.volume = volume;
     const audioPublication = this.getTrack(Track.Source.Microphone);
-    if (audioPublication) {
+    if (audioPublication && audioPublication.track) {
       (audioPublication.track as RemoteAudioTrack).setVolume(volume);
     }
   }
 
   /**
    * gets the volume on the participant's microphone track
-   * returns undefined if no microphone track exists
    */
   getVolume() {
     const audioPublication = this.getTrack(Track.Source.Microphone);
-    if (audioPublication) {
+    if (audioPublication && audioPublication.track) {
       return (audioPublication.track as RemoteAudioTrack).getVolume();
     }
+    return this.volume;
   }
 
   /** @internal */
@@ -153,7 +157,14 @@ export default class RemoteParticipant extends Participant {
     track.start();
 
     publication.setTrack(track);
-
+    // set participant volume on new microphone tracks
+    if (
+      this.volume !== undefined &&
+      track instanceof RemoteAudioTrack &&
+      track.source === Track.Source.Microphone
+    ) {
+      track.setVolume(this.volume);
+    }
     this.emit(ParticipantEvent.TrackSubscribed, track, publication);
 
     return publication;