livekit-client 1.1.7 → 1.2.0

package/src/proto/livekit_models.ts

@@ -213,6 +213,68 @@ export function clientConfigSettingToJSON(object: ClientConfigSetting): string {
   }
 }
 
+export enum DisconnectReason {
+  UNKNOWN_REASON = 0,
+  CLIENT_INITIATED = 1,
+  DUPLICATE_IDENTITY = 2,
+  SERVER_SHUTDOWN = 3,
+  PARTICIPANT_REMOVED = 4,
+  ROOM_DELETED = 5,
+  STATE_MISMATCH = 6,
+  UNRECOGNIZED = -1,
+}
+
+export function disconnectReasonFromJSON(object: any): DisconnectReason {
+  switch (object) {
+    case 0:
+    case 'UNKNOWN_REASON':
+      return DisconnectReason.UNKNOWN_REASON;
+    case 1:
+    case 'CLIENT_INITIATED':
+      return DisconnectReason.CLIENT_INITIATED;
+    case 2:
+    case 'DUPLICATE_IDENTITY':
+      return DisconnectReason.DUPLICATE_IDENTITY;
+    case 3:
+    case 'SERVER_SHUTDOWN':
+      return DisconnectReason.SERVER_SHUTDOWN;
+    case 4:
+    case 'PARTICIPANT_REMOVED':
+      return DisconnectReason.PARTICIPANT_REMOVED;
+    case 5:
+    case 'ROOM_DELETED':
+      return DisconnectReason.ROOM_DELETED;
+    case 6:
+    case 'STATE_MISMATCH':
+      return DisconnectReason.STATE_MISMATCH;
+    case -1:
+    case 'UNRECOGNIZED':
+    default:
+      return DisconnectReason.UNRECOGNIZED;
+  }
+}
+
+export function disconnectReasonToJSON(object: DisconnectReason): string {
+  switch (object) {
+    case DisconnectReason.UNKNOWN_REASON:
+      return 'UNKNOWN_REASON';
+    case DisconnectReason.CLIENT_INITIATED:
+      return 'CLIENT_INITIATED';
+    case DisconnectReason.DUPLICATE_IDENTITY:
+      return 'DUPLICATE_IDENTITY';
+    case DisconnectReason.SERVER_SHUTDOWN:
+      return 'SERVER_SHUTDOWN';
+    case DisconnectReason.PARTICIPANT_REMOVED:
+      return 'PARTICIPANT_REMOVED';
+    case DisconnectReason.ROOM_DELETED:
+      return 'ROOM_DELETED';
+    case DisconnectReason.STATE_MISMATCH:
+      return 'STATE_MISMATCH';
+    default:
+      return 'UNKNOWN';
+  }
+}
+
 export interface Room {
   sid: string;
   name: string;
@@ -315,6 +377,7 @@ export interface SimulcastCodecInfo {
   mimeType: string;
   mid: string;
   cid: string;
+  layers: VideoLayer[];
 }
 
 export interface TrackInfo {
@@ -499,12 +562,17 @@ export interface ClientConfiguration {
   video?: VideoConfiguration;
   screen?: VideoConfiguration;
   resumeConnection: ClientConfigSetting;
+  disabledCodecs?: DisabledCodecs;
 }
 
 export interface VideoConfiguration {
   hardwareEncoder: ClientConfigSetting;
 }
 
+export interface DisabledCodecs {
+  codecs: Codec[];
+}
+
 export interface RTPStats {
   startTime?: Date;
   endTime?: Date;
@@ -531,7 +599,9 @@ export interface RTPStats {
   jitterMax: number;
   gapHistogram: { [key: number]: number };
   nacks: number;
+  nackAcks: number;
   nackMisses: number;
+  nackRepeated: number;
   plis: number;
   lastPli?: Date;
   firs: number;
@@ -1015,7 +1085,7 @@ export const ParticipantInfo = {
 };
 
 function createBaseSimulcastCodecInfo(): SimulcastCodecInfo {
-  return { mimeType: '', mid: '', cid: '' };
+  return { mimeType: '', mid: '', cid: '', layers: [] };
 }
 
 export const SimulcastCodecInfo = {
@@ -1029,6 +1099,9 @@ export const SimulcastCodecInfo = {
     if (message.cid !== '') {
       writer.uint32(26).string(message.cid);
     }
+    for (const v of message.layers) {
+      VideoLayer.encode(v!, writer.uint32(34).fork()).ldelim();
+    }
     return writer;
   },
 
@@ -1048,6 +1121,9 @@ export const SimulcastCodecInfo = {
         case 3:
           message.cid = reader.string();
           break;
+        case 4:
+          message.layers.push(VideoLayer.decode(reader, reader.uint32()));
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -1061,6 +1137,9 @@ export const SimulcastCodecInfo = {
       mimeType: isSet(object.mimeType) ? String(object.mimeType) : '',
       mid: isSet(object.mid) ? String(object.mid) : '',
       cid: isSet(object.cid) ? String(object.cid) : '',
+      layers: Array.isArray(object?.layers)
+        ? object.layers.map((e: any) => VideoLayer.fromJSON(e))
+        : [],
     };
   },
 
@@ -1069,6 +1148,11 @@ export const SimulcastCodecInfo = {
     message.mimeType !== undefined && (obj.mimeType = message.mimeType);
     message.mid !== undefined && (obj.mid = message.mid);
     message.cid !== undefined && (obj.cid = message.cid);
+    if (message.layers) {
+      obj.layers = message.layers.map((e) => (e ? VideoLayer.toJSON(e) : undefined));
+    } else {
+      obj.layers = [];
+    }
     return obj;
   },
 
@@ -1077,6 +1161,7 @@ export const SimulcastCodecInfo = {
     message.mimeType = object.mimeType ?? '';
     message.mid = object.mid ?? '';
     message.cid = object.cid ?? '';
+    message.layers = object.layers?.map((e) => VideoLayer.fromPartial(e)) || [];
     return message;
   },
 };
@@ -1820,7 +1905,7 @@ export const ClientInfo = {
 };
 
 function createBaseClientConfiguration(): ClientConfiguration {
-  return { video: undefined, screen: undefined, resumeConnection: 0 };
+  return { video: undefined, screen: undefined, resumeConnection: 0, disabledCodecs: undefined };
 }
 
 export const ClientConfiguration = {
@@ -1834,6 +1919,9 @@ export const ClientConfiguration = {
     if (message.resumeConnection !== 0) {
       writer.uint32(24).int32(message.resumeConnection);
     }
+    if (message.disabledCodecs !== undefined) {
+      DisabledCodecs.encode(message.disabledCodecs, writer.uint32(34).fork()).ldelim();
+    }
     return writer;
   },
 
@@ -1853,6 +1941,9 @@ export const ClientConfiguration = {
         case 3:
           message.resumeConnection = reader.int32() as any;
           break;
+        case 4:
+          message.disabledCodecs = DisabledCodecs.decode(reader, reader.uint32());
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -1868,6 +1959,9 @@ export const ClientConfiguration = {
       resumeConnection: isSet(object.resumeConnection)
         ? clientConfigSettingFromJSON(object.resumeConnection)
         : 0,
+      disabledCodecs: isSet(object.disabledCodecs)
+        ? DisabledCodecs.fromJSON(object.disabledCodecs)
+        : undefined,
     };
   },
 
@@ -1879,6 +1973,10 @@ export const ClientConfiguration = {
       (obj.screen = message.screen ? VideoConfiguration.toJSON(message.screen) : undefined);
     message.resumeConnection !== undefined &&
       (obj.resumeConnection = clientConfigSettingToJSON(message.resumeConnection));
+    message.disabledCodecs !== undefined &&
+      (obj.disabledCodecs = message.disabledCodecs
+        ? DisabledCodecs.toJSON(message.disabledCodecs)
+        : undefined);
     return obj;
   },
 
@@ -1895,6 +1993,10 @@ export const ClientConfiguration = {
         ? VideoConfiguration.fromPartial(object.screen)
         : undefined;
     message.resumeConnection = object.resumeConnection ?? 0;
+    message.disabledCodecs =
+      object.disabledCodecs !== undefined && object.disabledCodecs !== null
+        ? DisabledCodecs.fromPartial(object.disabledCodecs)
+        : undefined;
     return message;
   },
 };
@@ -1951,6 +2053,59 @@ export const VideoConfiguration = {
   },
 };
 
+function createBaseDisabledCodecs(): DisabledCodecs {
+  return { codecs: [] };
+}
+
+export const DisabledCodecs = {
+  encode(message: DisabledCodecs, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.codecs) {
+      Codec.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): DisabledCodecs {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDisabledCodecs();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.codecs.push(Codec.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): DisabledCodecs {
+    return {
+      codecs: Array.isArray(object?.codecs) ? object.codecs.map((e: any) => Codec.fromJSON(e)) : [],
+    };
+  },
+
+  toJSON(message: DisabledCodecs): unknown {
+    const obj: any = {};
+    if (message.codecs) {
+      obj.codecs = message.codecs.map((e) => (e ? Codec.toJSON(e) : undefined));
+    } else {
+      obj.codecs = [];
+    }
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<DisabledCodecs>, I>>(object: I): DisabledCodecs {
+    const message = createBaseDisabledCodecs();
+    message.codecs = object.codecs?.map((e) => Codec.fromPartial(e)) || [];
+    return message;
+  },
+};
+
 function createBaseRTPStats(): RTPStats {
   return {
     startTime: undefined,
@@ -1978,7 +2133,9 @@ function createBaseRTPStats(): RTPStats {
     jitterMax: 0,
     gapHistogram: {},
     nacks: 0,
+    nackAcks: 0,
     nackMisses: 0,
+    nackRepeated: 0,
     plis: 0,
     lastPli: undefined,
     firs: 0,
@@ -2072,9 +2229,15 @@ export const RTPStats = {
     if (message.nacks !== 0) {
       writer.uint32(200).uint32(message.nacks);
     }
+    if (message.nackAcks !== 0) {
+      writer.uint32(296).uint32(message.nackAcks);
+    }
     if (message.nackMisses !== 0) {
       writer.uint32(208).uint32(message.nackMisses);
     }
+    if (message.nackRepeated !== 0) {
+      writer.uint32(304).uint32(message.nackRepeated);
+    }
     if (message.plis !== 0) {
       writer.uint32(216).uint32(message.plis);
     }
@@ -2193,9 +2356,15 @@ export const RTPStats = {
         case 25:
           message.nacks = reader.uint32();
           break;
+        case 37:
+          message.nackAcks = reader.uint32();
+          break;
         case 26:
           message.nackMisses = reader.uint32();
           break;
+        case 38:
+          message.nackRepeated = reader.uint32();
+          break;
         case 27:
           message.plis = reader.uint32();
           break;
@@ -2273,7 +2442,9 @@ export const RTPStats = {
           )
         : {},
       nacks: isSet(object.nacks) ? Number(object.nacks) : 0,
+      nackAcks: isSet(object.nackAcks) ? Number(object.nackAcks) : 0,
       nackMisses: isSet(object.nackMisses) ? Number(object.nackMisses) : 0,
+      nackRepeated: isSet(object.nackRepeated) ? Number(object.nackRepeated) : 0,
       plis: isSet(object.plis) ? Number(object.plis) : 0,
       lastPli: isSet(object.lastPli) ? fromJsonTimestamp(object.lastPli) : undefined,
       firs: isSet(object.firs) ? Number(object.firs) : 0,
@@ -2327,7 +2498,9 @@ export const RTPStats = {
       });
     }
     message.nacks !== undefined && (obj.nacks = Math.round(message.nacks));
+    message.nackAcks !== undefined && (obj.nackAcks = Math.round(message.nackAcks));
     message.nackMisses !== undefined && (obj.nackMisses = Math.round(message.nackMisses));
+    message.nackRepeated !== undefined && (obj.nackRepeated = Math.round(message.nackRepeated));
     message.plis !== undefined && (obj.plis = Math.round(message.plis));
     message.lastPli !== undefined && (obj.lastPli = message.lastPli.toISOString());
     message.firs !== undefined && (obj.firs = Math.round(message.firs));
@@ -2376,7 +2549,9 @@ export const RTPStats = {
       return acc;
     }, {});
     message.nacks = object.nacks ?? 0;
+    message.nackAcks = object.nackAcks ?? 0;
     message.nackMisses = object.nackMisses ?? 0;
+    message.nackRepeated = object.nackRepeated ?? 0;
     message.plis = object.plis ?? 0;
     message.lastPli = object.lastPli ?? undefined;
     message.firs = object.firs ?? 0;
@@ -2480,9 +2655,9 @@ const btoa: (bin: string) => string =
   globalThis.btoa || ((bin) => globalThis.Buffer.from(bin, 'binary').toString('base64'));
 function base64FromBytes(arr: Uint8Array): string {
   const bin: string[] = [];
-  arr.forEach((byte) => {
+  for (const byte of arr) {
     bin.push(String.fromCharCode(byte));
-  });
+  }
   return btoa(bin.join(''));
 }
 

package/src/proto/livekit_rtc.ts

@@ -9,6 +9,7 @@ import {
   ClientConfiguration,
   TrackInfo,
   VideoQuality,
+  DisconnectReason,
   ConnectionQuality,
   VideoLayer,
   ParticipantTracks,
@@ -19,6 +20,8 @@ import {
   trackSourceToJSON,
   videoQualityFromJSON,
   videoQualityToJSON,
+  disconnectReasonFromJSON,
+  disconnectReasonToJSON,
   connectionQualityFromJSON,
   connectionQualityToJSON,
 } from './livekit_models';
@@ -283,6 +286,7 @@ export interface LeaveRequest {
    * indicates clients should attempt full-reconnect sequence
    */
   canReconnect: boolean;
+  reason: DisconnectReason;
 }
 
 /** message to indicate published video track dimensions are changing */
@@ -1836,7 +1840,7 @@ export const UpdateTrackSettings = {
 };
 
 function createBaseLeaveRequest(): LeaveRequest {
-  return { canReconnect: false };
+  return { canReconnect: false, reason: 0 };
 }
 
 export const LeaveRequest = {
@@ -1844,6 +1848,9 @@ export const LeaveRequest = {
     if (message.canReconnect === true) {
       writer.uint32(8).bool(message.canReconnect);
     }
+    if (message.reason !== 0) {
+      writer.uint32(16).int32(message.reason);
+    }
     return writer;
   },
 
@@ -1857,6 +1864,9 @@ export const LeaveRequest = {
         case 1:
           message.canReconnect = reader.bool();
           break;
+        case 2:
+          message.reason = reader.int32() as any;
+          break;
         default:
           reader.skipType(tag & 7);
           break;
@@ -1868,18 +1878,21 @@ export const LeaveRequest = {
   fromJSON(object: any): LeaveRequest {
     return {
       canReconnect: isSet(object.canReconnect) ? Boolean(object.canReconnect) : false,
+      reason: isSet(object.reason) ? disconnectReasonFromJSON(object.reason) : 0,
     };
   },
 
   toJSON(message: LeaveRequest): unknown {
     const obj: any = {};
     message.canReconnect !== undefined && (obj.canReconnect = message.canReconnect);
+    message.reason !== undefined && (obj.reason = disconnectReasonToJSON(message.reason));
     return obj;
   },
 
   fromPartial<I extends Exact<DeepPartial<LeaveRequest>, I>>(object: I): LeaveRequest {
     const message = createBaseLeaveRequest();
     message.canReconnect = object.canReconnect ?? false;
+    message.reason = object.reason ?? 0;
     return message;
   },
 };

package/src/room/RTCEngine.ts

@@ -7,6 +7,7 @@ import {
   ClientConfiguration,
   DataPacket,
   DataPacket_Kind,
+  DisconnectReason,
   SpeakerInfo,
   TrackInfo,
   UserPacket,
@@ -276,23 +277,8 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         this.emit(EngineEvent.MediaTrackAdded, track, ev.stream);
       };
     }
-    // data channels
-    this.lossyDC = this.publisher.pc.createDataChannel(lossyDataChannel, {
-      // will drop older packets that arrive
-      ordered: true,
-      maxRetransmits: 0,
-    });
-    this.reliableDC = this.publisher.pc.createDataChannel(reliableDataChannel, {
-      ordered: true,
-    });
 
-    // also handle messages over the pub channel, for backwards compatibility
-    this.lossyDC.onmessage = this.handleDataMessage;
-    this.reliableDC.onmessage = this.handleDataMessage;
-
-    // handle datachannel errors
-    this.lossyDC.onerror = this.handleDataError;
-    this.reliableDC.onerror = this.handleDataError;
+    this.createDataChannels();
 
     // configure signaling client
     this.client.onAnswer = async (sd) => {
@@ -360,12 +346,47 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         this.fullReconnectOnNext = true;
         this.primaryPC = undefined;
       } else {
-        this.emit(EngineEvent.Disconnected);
+        this.emit(EngineEvent.Disconnected, leave?.reason);
         this.close();
       }
+      log.trace('leave request', { leave });
     };
   }
 
+  private createDataChannels() {
+    if (!this.publisher) {
+      return;
+    }
+
+    // clear old data channel callbacks if recreate
+    if (this.lossyDC) {
+      this.lossyDC.onmessage = null;
+      this.lossyDC.onerror = null;
+    }
+    if (this.reliableDC) {
+      this.reliableDC.onmessage = null;
+      this.reliableDC.onerror = null;
+    }
+
+    // create data channels
+    this.lossyDC = this.publisher.pc.createDataChannel(lossyDataChannel, {
+      // will drop older packets that arrive
+      ordered: true,
+      maxRetransmits: 0,
+    });
+    this.reliableDC = this.publisher.pc.createDataChannel(reliableDataChannel, {
+      ordered: true,
+    });
+
+    // also handle messages over the pub channel, for backwards compatibility
+    this.lossyDC.onmessage = this.handleDataMessage;
+    this.reliableDC.onmessage = this.handleDataMessage;
+
+    // handle datachannel errors
+    this.lossyDC.onerror = this.handleDataError;
+    this.reliableDC.onerror = this.handleDataError;
+  }
+
   private handleDataChannel = async ({ channel }: RTCDataChannelEvent) => {
     if (!channel) {
       return;
@@ -561,6 +582,12 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     await this.waitForPCConnected();
     this.client.setReconnected();
 
+    // recreate publish datachannel if it's id is null
+    // (for safari https://bugs.webkit.org/show_bug.cgi?id=184688)
+    if (this.reliableDC?.readyState === 'open' && this.reliableDC.id === null) {
+      this.createDataChannels();
+    }
+
     // resume success
     this.emit(EngineEvent.Resumed);
   }
@@ -715,7 +742,7 @@ class SignalReconnectError extends Error {}
 
 export type EngineEventCallbacks = {
   connected: () => void;
-  disconnected: () => void;
+  disconnected: (reason?: DisconnectReason) => void;
   resuming: () => void;
   resumed: () => void;
   restarting: () => void;

package/src/room/Room.ts

@@ -5,6 +5,7 @@ import log from '../logger';
 import { RoomConnectOptions, RoomOptions } from '../options';
 import {
   DataPacket_Kind,
+  DisconnectReason,
   ParticipantInfo,
   ParticipantInfo_State,
   ParticipantPermission,
@@ -150,8 +151,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
           this.onTrackAdded(mediaTrack, stream, receiver);
         },
       )
-      .on(EngineEvent.Disconnected, () => {
-        this.handleDisconnect();
+      .on(EngineEvent.Disconnected, (reason?: DisconnectReason) => {
+        this.handleDisconnect(this.options.stopLocalTrackOnUnpublish, reason);
       })
       .on(EngineEvent.ActiveSpeakersUpdate, this.handleActiveSpeakersUpdate)
       .on(EngineEvent.DataPacketReceived, this.handleDataPacket)
@@ -288,7 +289,17 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
       // populate remote participants, these should not trigger new events
       joinResponse.otherParticipants.forEach((info) => {
-        this.getOrCreateParticipant(info.sid, info);
+        if (
+          info.sid !== this.localParticipant.sid &&
+          info.identity !== this.localParticipant.identity
+        ) {
+          this.getOrCreateParticipant(info.sid, info);
+        } else {
+          log.warn('received info to create local participant as remote participant', {
+            info,
+            localParticipant: this.localParticipant,
+          });
+        }
       });
 
       this.name = joinResponse.room!.name;
@@ -347,7 +358,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   /**
    * disconnects the room, emits [[RoomEvent.Disconnected]]
    */
-  disconnect = (stopTracks = true) => {
+  disconnect = async (stopTracks = true) => {
+    log.info('disconnect from room', { identity: this.localParticipant.identity });
     if (this.state === ConnectionState.Connecting) {
       // try aborting pending connection attempt
       log.warn('abort connection attempt');
@@ -356,14 +368,14 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     }
     // send leave
     if (this.engine?.client.isConnected) {
-      this.engine.client.sendLeave();
+      await this.engine.client.sendLeave();
     }
     // close engine (also closes client)
     if (this.engine) {
       this.engine.close();
     }
 
-    this.handleDisconnect(stopTracks);
+    this.handleDisconnect(stopTracks, DisconnectReason.CLIENT_INITIATED);
     /* @ts-ignore */
     this.engine = undefined;
   };
@@ -541,21 +553,27 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     // at that time, ICE connectivity has not been established so the track is not
     // technically subscribed.
     // We'll defer these events until when the room is connected or eventually disconnected.
-    if (this.state === ConnectionState.Connecting || this.state === ConnectionState.Reconnecting) {
-      setTimeout(() => {
+    if (this.connectFuture) {
+      this.connectFuture.promise.then(() => {
         this.onTrackAdded(mediaTrack, stream, receiver);
-      }, 50);
+      });
       return;
     }
     if (this.state === ConnectionState.Disconnected) {
       log.warn('skipping incoming track after Room disconnected');
+      return;
     }
     const parts = unpackStreamId(stream.id);
     const participantId = parts[0];
     let trackId = parts[1];
     if (!trackId || trackId === '') trackId = mediaTrack.id;
 
+    if (participantId === this.localParticipant.sid) {
+      log.warn('tried to create RemoteParticipant for local participant');
+      return;
+    }
     const participant = this.getOrCreateParticipant(participantId);
+
     let adaptiveStreamSettings: AdaptiveStreamSettings | undefined;
     if (this.options.adaptiveStream) {
       if (typeof this.options.adaptiveStream === 'object') {
@@ -629,7 +647,10 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     );
   };
 
-  private handleDisconnect(shouldStopTracks = true) {
+  private handleDisconnect(shouldStopTracks = true, reason?: DisconnectReason) {
+    if (this.state === ConnectionState.Disconnected) {
+      return;
+    }
     this.participants.forEach((p) => {
       p.tracks.forEach((pub) => {
         p.unpublishTrack(pub.trackSid);
@@ -645,6 +666,9 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         pub.track?.stop();
       }
     });
+    this.localParticipant.tracks.clear();
+    this.localParticipant.videoTracks.clear();
+    this.localParticipant.audioTracks.clear();
 
     this.participants.clear();
     this.activeSpeakers = [];
@@ -657,7 +681,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       navigator.mediaDevices?.removeEventListener('devicechange', this.handleDeviceChange);
     }
     this.setAndEmitConnectionState(ConnectionState.Disconnected);
-    this.emit(RoomEvent.Disconnected);
+    this.emit(RoomEvent.Disconnected, reason);
   }
 
   private handleParticipantUpdates = (participantInfos: ParticipantInfo[]) => {
@@ -806,18 +830,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       return;
     }
 
-    pub._allowed = update.allowed;
-    participant.emit(
-      ParticipantEvent.TrackSubscriptionPermissionChanged,
-      pub,
-      pub.subscriptionStatus,
-    );
-    this.emitWhenConnected(
-      RoomEvent.TrackSubscriptionPermissionChanged,
-      pub,
-      pub.subscriptionStatus,
-      participant,
-    );
+    pub.setAllowed(update.allowed);
   };
 
   private handleDataPacket = (userPacket: UserPacket, kind: DataPacket_Kind) => {
@@ -954,7 +967,15 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
             participant,
           );
         },
-      );
+      )
+      .on(ParticipantEvent.TrackSubscriptionPermissionChanged, (pub, status) => {
+        this.emitWhenConnected(
+          RoomEvent.TrackSubscriptionPermissionChanged,
+          pub,
+          status,
+          participant,
+        );
+      });
 
     // update info at the end after callbacks have been set up
     if (info) {
@@ -1075,7 +1096,7 @@ export default Room;
 export type RoomEventCallbacks = {
   reconnecting: () => void;
   reconnected: () => void;
-  disconnected: () => void;
+  disconnected: (reason?: DisconnectReason) => void;
   /** @deprecated stateChanged has been renamed to connectionStateChanged */
   stateChanged: (state: ConnectionState) => void;
   connectionStateChanged: (state: ConnectionState) => void;