@100mslive/react-native-hms 0.8.3 → 0.9.1

package/lib/typescript/classes/HMSRTCStats.d.ts

@@ -0,0 +1,18 @@
+export declare class HMSRTCStats {
+    bitrateReceived?: number;
+    bitrateSent?: number;
+    bytesReceived?: number;
+    bytesSent?: number;
+    packetsLost?: number;
+    packetsReceived?: number;
+    roundTripTime?: number;
+    constructor(params: {
+        bitrateReceived?: number;
+        bitrateSent?: number;
+        bytesReceived?: number;
+        bytesSent?: number;
+        packetsLost?: number;
+        packetsReceived?: number;
+        roundTripTime?: number;
+    });
+}

package/lib/typescript/classes/HMSRTCStatsReport.d.ts

@@ -0,0 +1,11 @@
+import type { HMSRTCStats } from './HMSRTCStats';
+export declare class HMSRTCStatsReport {
+    video?: HMSRTCStats;
+    audio?: HMSRTCStats;
+    combined?: HMSRTCStats;
+    constructor(params: {
+        video?: HMSRTCStats;
+        audio?: HMSRTCStats;
+        combined?: HMSRTCStats;
+    });
+}

package/lib/typescript/classes/HMSRemoteAudioStats.d.ts

@@ -0,0 +1,14 @@
+export declare class HMSRemoteAudioStats {
+    bitrate?: number;
+    packetsReceived?: number;
+    packetsLost?: number;
+    bytesReceived?: number;
+    jitter?: number;
+    constructor(params: {
+        bitrate?: number;
+        packetsReceived?: number;
+        packetsLost?: number;
+        bytesReceived?: number;
+        jitter?: number;
+    });
+}

package/lib/typescript/classes/HMSRemoteVideoStats.d.ts

@@ -0,0 +1,19 @@
+import type { HMSVideoResolution } from './HMSVideoResolution';
+export declare class HMSRemoteVideoStats {
+    bitrate?: number;
+    packetsReceived?: number;
+    packetsLost?: number;
+    bytesReceived?: number;
+    jitter?: number;
+    resolution?: HMSVideoResolution;
+    frameRate?: number;
+    constructor(params: {
+        bitrate?: number;
+        packetsReceived?: number;
+        packetsLost?: number;
+        bytesReceived?: number;
+        jitter?: number;
+        resolution?: HMSVideoResolution;
+        frameRate?: number;
+    });
+}

package/lib/typescript/classes/HMSRoom.d.ts

@@ -2,6 +2,7 @@ import type { HMSPeer } from './HMSPeer';
 import type { HMSRtmpStreamingState } from './HMSRtmpStreamingState';
 import type { HMSServerRecordingState } from './HMSServerRecordingState';
 import type { HMSBrowserRecordingState } from './HMSBrowserRecordingState';
+import type { HMSHLSStreamingState } from './HMSHLSStreamingState';
 export declare class HMSRoom {
     id: string;
     name: string;
@@ -10,6 +11,8 @@ export declare class HMSRoom {
     browserRecordingState: HMSBrowserRecordingState;
     rtmpHMSRtmpStreamingState: HMSRtmpStreamingState;
     serverRecordingState: HMSServerRecordingState;
+    hlsStreamingState: HMSHLSStreamingState;
+    peerCount: number;
     constructor(params: {
         id: string;
         name: string;
@@ -18,5 +21,7 @@ export declare class HMSRoom {
         browserRecordingState: HMSBrowserRecordingState;
         rtmpHMSRtmpStreamingState: HMSRtmpStreamingState;
         serverRecordingState: HMSServerRecordingState;
+        hlsStreamingState: HMSHLSStreamingState;
+        peerCount: number;
     });
 }

package/lib/typescript/classes/HMSRoomUpdate.d.ts

@@ -1,4 +1,11 @@
 export declare enum HMSRoomUpdate {
     ROOM_MUTED = "ROOM_MUTED",
-    ROOM_UNMUTED = "ROOM_UNMUTED"
+    ROOM_UNMUTED = "ROOM_UNMUTED",
+    ROOM_TYPE_CHANGED = "ROOM_TYPE_CHANGED",
+    META_DATA_CHANGED = "META_DATA_CHANGED",
+    SERVER_RECORDING_STATE_UPDATED = "SERVER_RECORDING_STATE_UPDATED",
+    RTMP_STREAMING_STATE_UPDATED = "RTMP_STREAMING_STATE_UPDATED",
+    BROWSER_RECORDING_STATE_UPDATED = "BROWSER_RECORDING_STATE_UPDATED",
+    HLS_STREAMING_STATE_UPDATED = "HLS_STREAMING_STATE_UPDATED",
+    ROOM_ID_UPDATED = "ROOM_ID_UPDATED"
 }

package/lib/typescript/classes/HMSRtmpStreamingState.d.ts

@@ -2,8 +2,12 @@ import type { HMSException } from './HMSException';
 export declare class HMSRtmpStreamingState {
     running: string;
     error: HMSException;
+    startedAt: Date;
+    stoppedAt: Date;
     constructor(params: {
         running: string;
         error: HMSException;
+        startedAt: Date;
+        stoppedAt: Date;
     });
 }

package/lib/typescript/classes/HMSSDK.d.ts

@@ -13,6 +13,7 @@ import type { HMSPeer } from './HMSPeer';
 import { HMSVideoViewMode } from './HMSVideoViewMode';
 import type { HMSTrackSettings } from './HMSTrackSettings';
 import type { HMSRTMPConfig } from './HMSRTMPConfig';
+import type { HMSHLSConfig } from './HMSHLSConfig';
 interface HmsComponentProps {
     trackId: string;
     sink: boolean;
@@ -28,6 +29,7 @@ export declare class HMSSDK {
     knownRoles?: HMSRole[];
     id: string;
     private muteStatus;
+    appStateSubscription?: any;
     onPreviewDelegate?: any;
     onJoinDelegate?: any;
     onRoomDelegate?: any;
@@ -41,6 +43,11 @@ export declare class HMSSDK {
     onRoleChangeRequestDelegate?: any;
     onChangeTrackStateRequestDelegate?: any;
     onRemovedFromRoomDelegate?: any;
+    onRtcStatsDelegate?: any;
+    onLocalAudioStatsDelegate?: any;
+    onLocalVideoStatsDelegate?: any;
+    onRemoteAudioStatsDelegate?: any;
+    onRemoteVideoStatsDelegate?: any;
     constructor(id: string);
     /**
      * - Returns an instance of [HMSSDK]{@link HMSSDK}
@@ -51,7 +58,7 @@ export declare class HMSSDK {
      * @memberof HMSSDK
      */
     static build(params?: {
-        trackSettings?: HMSTrackSettings;
+        trackSettings: HMSTrackSettings;
     }): Promise<HMSSDK>;
     static getLogger(): HMSLogger | undefined;
     setLogger: (hmsLogger: HMSLogger) => void;
@@ -68,6 +75,7 @@ export declare class HMSSDK {
      */
     join: (config: HMSConfig) => Promise<void>;
     preview: (config: HMSConfig) => void;
+    previewForRole: (role: HMSRole) => Promise<any>;
     HmsView: ({ sink, trackId, style, mirror, scaleType, }: HmsComponentProps) => JSX.Element;
     /**
      * Calls leave function of native sdk and session of current user is invalidated
@@ -75,21 +83,32 @@ export declare class HMSSDK {
      * @memberof HMSSDK
      */
     leave: () => Promise<any>;
-    sendBroadcastMessage: (message: string, type?: string | undefined) => Promise<any>;
-    sendGroupMessage: (message: string, roles: HMSRole[], type?: string | undefined) => Promise<any>;
-    sendDirectMessage: (message: string, peerId: string, type?: string | undefined) => Promise<any>;
+    sendBroadcastMessage: (message: string, type?: string) => Promise<any>;
+    sendGroupMessage: (message: string, roles: HMSRole[], type?: string) => Promise<any>;
+    sendDirectMessage: (message: string, peer: HMSPeer, type?: string) => Promise<any>;
     changeMetadata: (metadata: string) => void;
     startRTMPOrRecording: (data: HMSRTMPConfig) => Promise<any>;
     stopRtmpAndRecording: () => Promise<any>;
+    startHLSStreaming: (data: HMSHLSConfig) => Promise<any>;
+    stopHLSStreaming: () => Promise<any>;
     changeRole: (peer: HMSPeer, role: HMSRole, force?: boolean) => Promise<any>;
     changeTrackState: (track: HMSTrack, mute: boolean) => Promise<any>;
-    changeTrackStateRoles: (type: HMSTrackType, mute: boolean, source: string, roles: Array<HMSRole>) => Promise<any>;
-    removePeer: (peerId: string, reason: string) => Promise<any>;
-    endRoom: (lock: boolean, reason: string) => Promise<any>;
-    acceptRoleChange: () => void;
-    muteAllPeersAudio: (mute: boolean) => void;
+    changeTrackStateForRoles: (mute: boolean, type?: HMSTrackType | undefined, source?: string | undefined, roles?: HMSRole[] | undefined) => Promise<any>;
+    removePeer: (peer: HMSPeer, reason: string) => Promise<any>;
+    endRoom: (reason: string, lock?: boolean) => Promise<any>;
+    changeName: (name: string) => Promise<any>;
+    acceptRoleChange: () => Promise<any>;
+    setPlaybackForAllAudio: (mute: boolean) => void;
+    remoteMuteAllAudio: () => void;
     getRoom: () => Promise<HMSRoom>;
     setVolume: (track: HMSTrack, volume: number) => void;
+    resetVolume: () => void;
+    addAppStateListener: () => void;
+    startScreenshare: () => void;
+    isScreenShared: () => Promise<any>;
+    stopScreenshare: () => Promise<any>;
+    enableRTCStats: () => void;
+    disableRTCStats: () => void;
     /**
      * - This is a prototype event listener that takes action and listens for updates related to that particular action
      * - This method will be @deprecated in future and event listener will be passed in join method
@@ -127,5 +146,10 @@ export declare class HMSSDK {
     onRemovedFromRoomListener: (data: any) => void;
     reconnectingListener: (data: any) => void;
     reconnectedListener: (data: any) => void;
+    RTCStatsListener: (data: any) => void;
+    onLocalAudioStatsListener: (data: any) => void;
+    onLocalVideoStatsListener: (data: any) => void;
+    onRemoteAudioStatsListener: (data: any) => void;
+    onRemoteVideoStatsListener: (data: any) => void;
 }
 export {};

package/lib/typescript/classes/HMSServerRecordingState.d.ts

@@ -2,8 +2,10 @@ import type { HMSException } from './HMSException';
 export declare class HMSServerRecordingState {
     running: string;
     error: HMSException;
+    startedAt: Date;
     constructor(params: {
         running: string;
         error: HMSException;
+        startedAt: Date;
     });
 }

package/lib/typescript/classes/HMSUpdateListenerActions.d.ts

@@ -11,5 +11,10 @@ export declare enum HMSUpdateListenerActions {
     RECONNECTED = "RECONNECTED",
     ON_ROLE_CHANGE_REQUEST = "ON_ROLE_CHANGE_REQUEST",
     ON_CHANGE_TRACK_STATE_REQUEST = "ON_CHANGE_TRACK_STATE_REQUEST",
-    ON_REMOVED_FROM_ROOM = "ON_REMOVED_FROM_ROOM"
+    ON_REMOVED_FROM_ROOM = "ON_REMOVED_FROM_ROOM",
+    ON_RTC_STATS = "ON_RTC_STATS",
+    ON_LOCAL_AUDIO_STATS = "ON_LOCAL_AUDIO_STATS",
+    ON_LOCAL_VIDEO_STATS = "ON_LOCAL_VIDEO_STATS",
+    ON_REMOTE_AUDIO_STATS = "ON_REMOTE_AUDIO_STATS",
+    ON_REMOTE_VIDEO_STATS = "ON_REMOTE_VIDEO_STATS"
 }

package/lib/typescript/index.d.ts

@@ -46,6 +46,16 @@ export * from './classes/HMSRtmpStreamingState';
 export * from './classes/HMSServerRecordingState';
 export * from './classes/HMSBrowserRecordingState';
 export * from './classes/HMSRTMPConfig';
+export * from './classes/HMSHLSConfig';
+export * from './classes/HMSHLSMeetingURLVariant';
+export * from './classes/HMSHLSVariant';
+export * from './classes/HMSHLSStreamingState';
 export * from './classes/HMSVideoResolution';
+export * from './classes/HMSLocalAudioStats';
+export * from './classes/HMSLocalVideoStats';
+export * from './classes/HMSRTCStats';
+export * from './classes/HMSRTCStatsReport';
+export * from './classes/HMSRemoteAudioStats';
+export * from './classes/HMSRemoteVideoStats';
 import { HMSSDK as HmsManager } from './classes/HMSSDK';
 export default HmsManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@100mslive/react-native-hms",
-  "version": "0.8.3",
+  "version": "0.9.1",
   "description": "The React Native package for 100ms SDK",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",

package/react-native-hms.podspec

@@ -16,5 +16,5 @@ Pod::Spec.new do |s|
   s.source_files = "ios/**/*.{h,m,mm,swift}"
 
   s.dependency "React-Core"
-  s.dependency "HMSSDK"
+  s.dependency "HMSSDK", "0.2.7"
 end

package/src/classes/HMSBrowserRecordingState.ts

@@ -3,9 +3,18 @@ import type { HMSException } from './HMSException';
 export class HMSBrowserRecordingState {
   running: string;
   error: HMSException;
+  startedAt: Date;
+  stoppedAt: Date;
 
-  constructor(params: { running: string; error: HMSException }) {
+  constructor(params: {
+    running: string;
+    error: HMSException;
+    startedAt: Date;
+    stoppedAt: Date;
+  }) {
     this.running = params.running;
     this.error = params.error;
+    this.startedAt = params.startedAt;
+    this.stoppedAt = params.stoppedAt;
   }
 }

package/src/classes/HMSChangeTrackStateRequest.ts

@@ -3,9 +3,15 @@ import type { HMSPeer } from './HMSPeer';
 export class HMSChangeTrackStateRequest {
   requestedBy: HMSPeer;
   trackType: string;
+  mute: boolean;
 
-  constructor(params: { requestedBy: HMSPeer; trackType: string }) {
+  constructor(params: {
+    requestedBy: HMSPeer;
+    trackType: string;
+    mute: boolean;
+  }) {
     this.requestedBy = params.requestedBy;
     this.trackType = params.trackType;
+    this.mute = params.mute;
   }
 }

package/src/classes/HMSEncoder.ts

@@ -15,6 +15,13 @@ import { HMSRole } from './HMSRole';
 import { HMSRoleChangeRequest } from './HMSRoleChangeRequest';
 import { HMSChangeTrackStateRequest } from './HMSChangeTrackStateRequest';
 import { HMSVideoResolution } from './HMSVideoResolution';
+import { HMSRTCStats } from './HMSRTCStats';
+import { HMSRTCStatsReport } from './HMSRTCStatsReport';
+import { HMSRemoteAudioTrack } from './HMSRemoteAudioTrack';
+import { HMSRemoteVideoTrack } from './HMSRemoteVideoTrack';
+import { HMSSpeaker } from './HMSSpeaker';
+import { HMSSpeakerUpdate } from './HMSSpeakerUpdate';
+import { HMSBrowserRecordingState, HMSHLSStreamingState, HMSHLSVariant, HMSRtmpStreamingState, HMSServerRecordingState } from '..';
 
 export class HMSEncoder {
   static encodeHmsRoom(room: HMSRoom, id: string) {
@@ -22,10 +29,12 @@ export class HMSEncoder {
       id: room?.id,
       metaData: room?.metaData,
       name: room?.name,
+      peerCount: room?.peerCount,
       peers: HMSEncoder.encodeHmsPeers(room?.peers, id),
-      browserRecordingState: room?.browserRecordingState,
-      rtmpHMSRtmpStreamingState: room?.rtmpHMSRtmpStreamingState,
-      serverRecordingState: room?.serverRecordingState,
+      browserRecordingState: HMSEncoder.encodeBrowserRecordingState(room?.browserRecordingState),
+      rtmpHMSRtmpStreamingState: HMSEncoder.encodeRTMPStreamingState(room?.rtmpHMSRtmpStreamingState),
+      serverRecordingState: HMSEncoder.encodeServerRecordingState(room?.serverRecordingState),
+      hlsStreamingState: HMSEncoder.encodeHLSStreamingState(room?.hlsStreamingState),
     };
 
     return new HMSRoom(encodedObj);
@@ -182,6 +191,34 @@ export class HMSEncoder {
     return new HMSVideoResolution(encodedObj);
   }
 
+  static encodeHmsLocalAudioTrack(track: any, id: string) {
+    const encodedObj = {
+      id: id,
+      trackId: track?.trackId,
+      source: track?.source,
+      trackDescription: track?.trackDescription,
+      isMute: track?.isMute,
+      settings: HMSEncoder.encodeHmsAudioTrackSettings(track?.settings),
+      type: track?.type,
+    };
+
+    return new HMSLocalAudioTrack(encodedObj);
+  }
+
+  static encodeHmsLocalVideoTrack(track: any, id: string) {
+    const encodedObj = {
+      id: id,
+      trackId: track?.trackId,
+      source: track?.source,
+      trackDescription: track?.trackDescription,
+      isMute: track?.isMute,
+      settings: HMSEncoder.encodeHmsVideoTrackSettings(track?.settings),
+      type: track?.type,
+    };
+
+    return new HMSLocalVideoTrack(encodedObj);
+  }
+
   static encodeHmsRemotePeers(peers: any, id: string) {
     const hmsPeers: any[] = [];
 
@@ -231,6 +268,33 @@ export class HMSEncoder {
     return new HMSRemotePeer(encodedObj);
   }
 
+  static encodeHmsRemoteAudioTrack(track: any, id: string) {
+    const encodedObj = {
+      id: id,
+      trackId: track?.trackId,
+      source: track?.source,
+      trackDescription: track?.trackDescription,
+      isMute: track?.isMute,
+      playbackAllowed: track?.playbackAllowed,
+    };
+
+    return new HMSRemoteAudioTrack(encodedObj);
+  }
+
+  static encodeHmsRemoteVideoTrack(track: any, id: string) {
+    const encodedObj = {
+      id: id,
+      trackId: track?.trackId,
+      source: track?.source,
+      trackDescription: track?.trackDescription,
+      layer: track?.layer,
+      isMute: track?.isMute,
+      playbackAllowed: track?.playbackAllowed,
+    };
+
+    return new HMSRemoteVideoTrack(encodedObj);
+  }
+
   static encodeHmsPreviewTracks(previewTracks: any) {
     const encodedObj = {
       audioTrack: previewTracks.audioTrack
@@ -276,8 +340,104 @@ export class HMSEncoder {
     const encodedChangeTrackStateRequest = {
       requestedBy: HMSEncoder.encodeHmsPeer(data.requestedBy, id),
       trackType: data.trackType,
+      mute: data.mute,
     };
 
     return new HMSChangeTrackStateRequest(encodedChangeTrackStateRequest);
   }
+
+  static encodeRTCStats(data: any) {
+    let video = this.encodeRTCStatsUnit(data?.video);
+    let audio = this.encodeRTCStatsUnit(data?.audio);
+    let combined = this.encodeRTCStatsUnit(data?.combined);
+
+    return new HMSRTCStatsReport({ video, audio, combined });
+  }
+
+  static encodeRTCStatsUnit(data: any) {
+    return new HMSRTCStats({
+      bitrateReceived: data?.bitrateReceived,
+      bitrateSent: data?.bitrateSent,
+      bytesReceived: data?.bytesReceived,
+      bytesSent: data?.bytesSent,
+      packetsLost: data?.packetsLost,
+      packetsReceived: data?.packetsReceived,
+      roundTripTime: data?.roundTripTime,
+    });
+  }
+
+  static encodeHmsSpeakerUpdate(data: any, id: string) {
+    return new HMSSpeakerUpdate({
+      event: data?.event,
+      count: data?.count,
+      peers: HMSEncoder.encodeHmsSpeakers(data?.peers, id),
+    });
+  }
+
+  static encodeHmsSpeakers(data: any, id: string) {
+    let encodedSpeakers: Array<HMSSpeaker> = [];
+
+    data?.map((item: any) => {
+      encodedSpeakers.push(HMSEncoder.encodeHmsSpeaker(item, id));
+    });
+
+    return encodedSpeakers;
+  }
+
+  static encodeHmsSpeaker(data: any, id: string) {
+    return new HMSSpeaker({
+      level: data?.level,
+      peer: HMSEncoder.encodeHmsPeer(data?.peer, id),
+      track: HMSEncoder.encodeHmsTrack(data?.track, id),
+    });
+  }
+
+  static encodeBrowserRecordingState(data: any) {
+    return new HMSBrowserRecordingState({
+      running: data?.running,
+      startedAt: new Date(parseInt(data?.startedAt)),
+      stoppedAt: new Date(parseInt(data?.stoppedAt)),
+      error: data?.error,
+    })
+  }
+
+  static encodeServerRecordingState(data: any) {
+    return new HMSServerRecordingState({
+      running: data?.running,
+      error: data?.error,
+      startedAt: new Date(parseInt(data?.startedAt))
+    })
+  }
+
+  static encodeRTMPStreamingState(data: any) {
+    return new HMSRtmpStreamingState({
+      running: data?.running,
+      startedAt: new Date(parseInt(data?.startedAt)),
+      stoppedAt: new Date(parseInt(data?.stoppedAt)),
+      error: data?.error
+    })
+  }
+
+  static encodeHLSStreamingState(data: any) {
+    return new HMSHLSStreamingState({
+      running: data?.running,
+      variants: this.encodeHLSVariants(data?.variants)
+    })
+  }
+
+  static encodeHLSVariants(data: any) {
+    let variants: HMSHLSVariant[] = []
+
+    data?.map((item: any) => {
+      let variant = new HMSHLSVariant({
+        hlsStreamUrl: item.hlsStreamUrl,
+        meetingUrl: item.meetingUrl,
+        metadata: item?.metadata,
+        startedAt: new Date(parseInt(item?.startedAt)) 
+      })
+      variants.push(variant);
+    })
+
+    return variants;
+  }
 }

package/src/classes/HMSHLSConfig.ts

@@ -0,0 +1,9 @@
+import type { HMSHLSMeetingURLVariant } from './HMSHLSMeetingURLVariant';
+
+export class HMSHLSConfig {
+  meetingURLVariants?: Array<HMSHLSMeetingURLVariant>;
+
+  constructor(params: { meetingURLVariants?: Array<HMSHLSMeetingURLVariant> }) {
+    this.meetingURLVariants = params.meetingURLVariants;
+  }
+}

package/src/classes/HMSHLSMeetingURLVariant.ts

@@ -0,0 +1,9 @@
+export class HMSHLSMeetingURLVariant {
+  meetingUrl: string;
+  metadata: string;
+
+  constructor(params: { meetingUrl: string; metadata: string }) {
+    this.meetingUrl = params.meetingUrl;
+    this.metadata = params.metadata;
+  }
+}

package/src/classes/HMSHLSStreamingState.ts

@@ -0,0 +1,11 @@
+import type { HMSHLSVariant } from './HMSHLSVariant';
+
+export class HMSHLSStreamingState {
+  running: boolean;
+  variants: Array<HMSHLSVariant>;
+
+  constructor(params: { running: boolean; variants: Array<HMSHLSVariant> }) {
+    this.running = params.running;
+    this.variants = params.variants;
+  }
+}

package/src/classes/HMSHLSVariant.ts

@@ -0,0 +1,18 @@
+export class HMSHLSVariant {
+  hlsStreamUrl?: string;
+  meetingUrl?: string;
+  metadata?: string;
+  startedAt?: Date;
+
+  constructor(params: {
+    hlsStreamUrl?: string;
+    meetingUrl?: string;
+    metadata?: string;
+    startedAt?: Date;
+  }) {
+    this.hlsStreamUrl = params.hlsStreamUrl;
+    this.meetingUrl = params.meetingUrl;
+    this.metadata = params.metadata;
+    this.startedAt = params.startedAt;
+  }
+}

package/src/classes/HMSLocalAudioStats.ts

@@ -0,0 +1,15 @@
+export class HMSLocalAudioStats {
+  bitrate?: number;
+  bytesSent?: number;
+  roundTripTime?: number;
+
+  constructor(params: {
+    bitrate?: number;
+    bytesSent?: number;
+    roundTripTime?: number;
+  }) {
+    this.bitrate = params.bitrate;
+    this.bytesSent = params.bytesSent;
+    this.roundTripTime = params.roundTripTime;
+  }
+}

package/src/classes/HMSLocalVideoStats.ts

@@ -0,0 +1,23 @@
+import type { HMSVideoResolution } from './HMSVideoResolution';
+
+export class HMSLocalVideoStats {
+  bitrate?: number;
+  bytesSent?: number;
+  roundTripTime?: number;
+  frameRate?: number;
+  resolution?: HMSVideoResolution;
+
+  constructor(params: {
+    bitrate?: number;
+    bytesSent?: number;
+    roundTripTime?: number;
+    frameRate?: number;
+    resolution?: HMSVideoResolution;
+  }) {
+    this.bitrate = params.bitrate;
+    this.bytesSent = params.bytesSent;
+    this.roundTripTime = params.roundTripTime;
+    this.frameRate = params.frameRate;
+    this.resolution = params.resolution;
+  }
+}

package/src/classes/HMSLogger.ts

@@ -10,6 +10,7 @@ export class HMSLogger {
     data: any;
     id: string;
   }[] = [];
+  private onLog?: Function;
 
   constructor(params?: { verbose: boolean; warning: boolean; error: boolean }) {
     if (params) {
@@ -22,6 +23,9 @@ export class HMSLogger {
   verbose(message: string, data: any) {
     if (this._verbose) {
       console.log(message, data);
+      if (this.onLog) {
+        this?.onLog({ message, data });
+      }
     }
     this.logs.push({ type: 'verbose', message, data, id: data?.id });
   }
@@ -29,6 +33,9 @@ export class HMSLogger {
   warn(message: string, data: any) {
     if (this._warning) {
       console.warn(message, data);
+      if (this.onLog) {
+        this?.onLog({ message, data });
+      }
     }
     this.logs.push({ type: 'warn', message, data, id: data?.id });
   }
@@ -36,6 +43,9 @@ export class HMSLogger {
   error(message: string, data: any) {
     if (this._error) {
       console.error(message, data);
+      if (this.onLog) {
+        this?.onLog({ message, data });
+      }
     }
     this.logs.push({ type: 'error', message, data, id: data?.id });
   }
@@ -44,6 +54,10 @@ export class HMSLogger {
     return this.logs;
   }
 
+  setLogListener(callback: Function) {
+    this.onLog = callback;
+  }
+
   updateLogLevel(level: HMSLogLevel, value: boolean) {
     switch (level) {
       case HMSLogLevel.VERBOSE: {

package/src/classes/HMSPeerUpdate.ts

@@ -10,4 +10,6 @@ export enum HMSPeerUpdate {
   STARTED_SPEAKING = 'STARTED_SPEAKING',
   STOPPED_SPEAKING = 'STOPPED_SPEAKING',
   ROLE_CHANGED = 'ROLE_CHANGED',
+  NAME_CHANGED = 'NAME_CHANGED',
+  DEFAULT_UPDATE = 'DEFAULT_UPDATE'
 }