@100mslive/react-native-hms 0.8.0 → 0.8.4

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

@@ -0,0 +1,10 @@
+export declare class HMSRTMPConfig {
+    meetingURL: string;
+    rtmpURLs?: Array<string>;
+    record: boolean;
+    constructor(params: {
+        meetingURL: string;
+        rtmpURLs?: Array<string>;
+        record: boolean;
+    });
+}

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

@@ -16,6 +16,7 @@ export declare class HMSRemotePeer extends HMSPeer {
         isLocal?: boolean;
         customerUserID?: string;
         customerDescription?: string;
+        metadata?: string;
         audioTrack?: HMSAudioTrack;
         videoTrack?: HMSVideoTrack;
         role?: HMSRole;

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

@@ -1,13 +1,22 @@
 import type { HMSPeer } from './HMSPeer';
+import type { HMSRtmpStreamingState } from './HMSRtmpStreamingState';
+import type { HMSServerRecordingState } from './HMSServerRecordingState';
+import type { HMSBrowserRecordingState } from './HMSBrowserRecordingState';
 export declare class HMSRoom {
     id: string;
     name: string;
     metaData?: string;
     peers: HMSPeer[];
+    browserRecordingState: HMSBrowserRecordingState;
+    rtmpHMSRtmpStreamingState: HMSRtmpStreamingState;
+    serverRecordingState: HMSServerRecordingState;
     constructor(params: {
         id: string;
         name: string;
         metaData?: string;
         peers: HMSPeer[];
+        browserRecordingState: HMSBrowserRecordingState;
+        rtmpHMSRtmpStreamingState: HMSRtmpStreamingState;
+        serverRecordingState: HMSServerRecordingState;
     });
 }

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

@@ -0,0 +1,9 @@
+import type { HMSException } from './HMSException';
+export declare class HMSRtmpStreamingState {
+    running: string;
+    error: HMSException;
+    constructor(params: {
+        running: string;
+        error: HMSException;
+    });
+}

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

@@ -11,6 +11,8 @@ import type { HMSTrackType } from './HMSTrackType';
 import type { HMSLogger } from './HMSLogger';
 import type { HMSPeer } from './HMSPeer';
 import { HMSVideoViewMode } from './HMSVideoViewMode';
+import type { HMSTrackSettings } from './HMSTrackSettings';
+import type { HMSRTMPConfig } from './HMSRTMPConfig';
 interface HmsComponentProps {
     trackId: string;
     sink: boolean;
@@ -24,8 +26,8 @@ export declare class HMSSDK {
     localPeer?: HMSLocalPeer;
     remotePeers?: HMSRemotePeer[];
     knownRoles?: HMSRole[];
-    logger?: HMSLogger;
     id: string;
+    private muteStatus;
     onPreviewDelegate?: any;
     onJoinDelegate?: any;
     onRoomDelegate?: any;
@@ -48,7 +50,11 @@ export declare class HMSSDK {
      * @returns
      * @memberof HMSSDK
      */
-    static build(): Promise<HMSSDK>;
+    static build(params?: {
+        trackSettings?: HMSTrackSettings;
+    }): Promise<HMSSDK>;
+    static getLogger(): HMSLogger | undefined;
+    setLogger: (hmsLogger: HMSLogger) => void;
     destroy: () => void;
     attachPreviewListener: () => void;
     attachListeners: () => void;
@@ -68,18 +74,22 @@ export declare class HMSSDK {
      *
      * @memberof HMSSDK
      */
-    leave: () => Promise<void>;
-    sendBroadcastMessage: (message: string, type?: string | undefined) => void;
-    sendGroupMessage: (message: string, roles: HMSRole[], type?: string | undefined) => void;
-    sendDirectMessage: (message: string, peerId: string, type?: string | undefined) => void;
-    changeRole: (peer: HMSPeer, role: HMSRole, force?: boolean) => void;
-    changeTrackState: (track: HMSTrack, mute: boolean) => void;
-    changeTrackStateRoles: (type: HMSTrackType, mute: boolean, source: string, roles: Array<HMSRole>) => void;
-    removePeer: (peerId: string, reason: string) => void;
-    endRoom: (lock: boolean, reason: string) => void;
-    acceptRoleChange: () => void;
+    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>;
+    changeMetadata: (metadata: string) => void;
+    startRTMPOrRecording: (data: HMSRTMPConfig) => Promise<any>;
+    stopRtmpAndRecording: () => 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: () => Promise<any>;
     muteAllPeersAudio: (mute: boolean) => void;
     getRoom: () => Promise<HMSRoom>;
+    setVolume: (track: HMSTrack, volume: number) => 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
@@ -104,7 +114,6 @@ export declare class HMSSDK {
      * @memberof HMSSDK
      */
     removeAllListeners: () => void;
-    setLogger: (hmsLogger: HMSLogger) => void;
     onPreviewListener: (data: any) => void;
     onJoinListener: (data: any) => void;
     onRoomListener: (data: any) => void;

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

@@ -0,0 +1,9 @@
+import type { HMSException } from './HMSException';
+export declare class HMSServerRecordingState {
+    running: string;
+    error: HMSException;
+    constructor(params: {
+        running: string;
+        error: HMSException;
+    });
+}

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

@@ -6,7 +6,7 @@ export declare class HMSTrack {
     mute?: boolean;
     id: string;
     type?: HMSTrackType;
-    isMute: () => Promise<any>;
+    isMute: () => boolean | undefined;
     constructor(params: {
         trackId: string;
         source?: number | string;

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

@@ -3,8 +3,10 @@ import type { HMSVideoTrackSettings } from './HMSVideoTrackSettings';
 export declare class HMSTrackSettings {
     video?: HMSVideoTrackSettings;
     audio?: HMSAudioTrackSettings;
+    useHardwareEchoCancellation?: boolean;
     constructor(params?: {
         video?: HMSVideoTrackSettings;
         audio?: HMSAudioTrackSettings;
+        useHardwareEchoCancellation?: boolean;
     });
 }

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

@@ -1,6 +1,6 @@
 export declare enum HMSVideoCodec {
-    h264 = "h264",
-    vp8 = "vp8",
-    vp9 = "vp9",
-    h265 = "h265"
+    H264 = "H264",
+    VP8 = "VP8",
+    VP9 = "VP9",
+    H265 = "H265"
 }

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

@@ -0,0 +1,8 @@
+export declare class HMSVideoResolution {
+    height?: number;
+    width?: number;
+    constructor(params: {
+        height: number;
+        width: number;
+    });
+}

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

@@ -1,15 +1,15 @@
-import type { HMSAudioCodec } from './HMSAudioCodec';
+import type { HMSVideoCodec } from '..';
 export declare class HMSVideoSettings {
     bitrate?: number;
     frameRate: number;
     width: number;
     height: number;
-    codec: HMSAudioCodec;
+    codec: HMSVideoCodec;
     constructor(params: {
         bitrate?: number;
         frameRate: number;
         width: number;
         height: number;
-        codec: HMSAudioCodec;
+        codec: HMSVideoCodec;
     });
 }

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

@@ -1,18 +1,21 @@
+import type { HMSVideoCodec } from './HMSVideoCodec';
 import type { HMSSimulcastLayerSettings } from './HMSSimulcastLayerSettings';
+import type { HMSCameraFacing } from './HMSCameraFacing';
+import type { HMSVideoResolution } from './HMSVideoResolution';
 export declare class HMSVideoTrackSettings {
-    codec?: any;
-    resolution?: any;
-    maxBitrate?: number;
-    maxFrameRate?: number;
-    cameraFacing?: any;
+    codec: HMSVideoCodec;
+    resolution: HMSVideoResolution;
+    maxBitrate: number;
+    maxFrameRate: number;
+    cameraFacing: HMSCameraFacing;
     trackDescription?: string;
     simulcastSettings?: HMSSimulcastLayerSettings[];
     constructor(params: {
-        codec?: any;
-        resolution?: any;
-        maxBitrate?: number;
-        maxFrameRate?: number;
-        cameraFacing?: any;
+        codec: HMSVideoCodec;
+        resolution: HMSVideoResolution;
+        maxBitrate: number;
+        maxFrameRate: number;
+        cameraFacing: HMSCameraFacing;
         trackDescription?: string;
         simulcastSettings?: HMSSimulcastLayerSettings[];
     });

package/lib/typescript/index.d.ts

@@ -40,5 +40,12 @@ export * from './classes/HMSVideoViewMode';
 export * from './classes/HMSChangeTrackStateRequest';
 export * from './classes/HMSSpeaker';
 export * from './classes/HMSSpeakerUpdate';
+export * from './classes/HMSCameraFacing';
+export * from './classes/HMSException';
+export * from './classes/HMSRtmpStreamingState';
+export * from './classes/HMSServerRecordingState';
+export * from './classes/HMSBrowserRecordingState';
+export * from './classes/HMSRTMPConfig';
+export * from './classes/HMSVideoResolution';
 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.0",
+  "version": "0.8.4",
   "description": "The React Native package for 100ms SDK",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -95,6 +95,7 @@
     "prettier": "^2.0.5",
     "react-native-builder-bob": "^0.18.0",
     "release-it": "^14.2.2",
+    "typedoc": "^0.22.10",
     "typescript": "^4.1.3"
   },
   "peerDependencies": {

package/src/classes/HMSAudioTrackSettings.ts

@@ -1,8 +1,16 @@
+import type { HMSAudioCodec } from './HMSAudioCodec';
+
 export class HMSAudioTrackSettings {
   maxBitrate?: number;
   trackDescription?: string;
-  constructor(params: { maxBitrate: number; trackDescription?: string }) {
+  codec?: HMSAudioCodec;
+  constructor(params: {
+    maxBitrate: number;
+    trackDescription?: string;
+    codec: HMSAudioCodec;
+  }) {
     this.maxBitrate = params.maxBitrate;
     this.trackDescription = params.trackDescription;
+    this.codec = params.codec;
   }
 }

package/src/classes/HMSBrowserRecordingState.ts

@@ -0,0 +1,11 @@
+import type { HMSException } from './HMSException';
+
+export class HMSBrowserRecordingState {
+  running: string;
+  error: HMSException;
+
+  constructor(params: { running: string; error: HMSException }) {
+    this.running = params.running;
+    this.error = params.error;
+  }
+}

package/src/classes/HMSCameraFacing.ts

@@ -0,0 +1,4 @@
+export enum HMSCameraFacing {
+  FRONT = 'FRONT',
+  BACK = 'BACK',
+}

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/HMSConfig.ts

@@ -1,16 +1,18 @@
 export class HMSConfig {
-  // endpoint: string;
   username: string;
   authToken: string;
   endpoint?: string;
+  metadata?: string;
 
   constructor(params: {
     username: string;
     authToken: string;
     endpoint?: string;
+    metadata?: string;
   }) {
     this.username = params.username;
     this.authToken = params.authToken;
     this.endpoint = params.endpoint;
+    this.metadata = params.metadata;
   }
 }

package/src/classes/HMSEncoder.ts

@@ -14,14 +14,18 @@ import { HMSLocalAudioTrack } from './HMSLocalAudioTrack';
 import { HMSRole } from './HMSRole';
 import { HMSRoleChangeRequest } from './HMSRoleChangeRequest';
 import { HMSChangeTrackStateRequest } from './HMSChangeTrackStateRequest';
+import { HMSVideoResolution } from './HMSVideoResolution';
 
 export class HMSEncoder {
-  static encodeHmsRoom(room: any, id: string) {
+  static encodeHmsRoom(room: HMSRoom, id: string) {
     const encodedObj = {
       id: room?.id,
       metaData: room?.metaData,
       name: room?.name,
       peers: HMSEncoder.encodeHmsPeers(room?.peers, id),
+      browserRecordingState: room?.browserRecordingState,
+      rtmpHMSRtmpStreamingState: room?.rtmpHMSRtmpStreamingState,
+      serverRecordingState: room?.serverRecordingState,
     };
 
     return new HMSRoom(encodedObj);
@@ -44,6 +48,7 @@ export class HMSEncoder {
       role: HMSEncoder.encodeHmsRole(peer?.role),
       customerUserID: peer?.customerUserID,
       customerDescription: peer?.customerDescription,
+      metadata: peer?.metadata,
       audioTrack: HMSEncoder.encodeHmsAudioTrack(peer?.audioTrack, id),
       videoTrack: HMSEncoder.encodeHmsVideoTrack(peer?.videoTrack, id),
       auxiliaryTracks: HMSEncoder.encodeHmsAuxiliaryTracks(
@@ -110,6 +115,7 @@ export class HMSEncoder {
       isLocal: peer.isLocal,
       customerUserID: peer.customerUserID,
       customerDescription: peer.customerDescription,
+      metadata: peer.metadata,
       role: HMSEncoder.encodeHmsRole(peer?.role),
       audioTrack: HMSEncoder.encodeHmsAudioTrack(peer.audioTrack, id),
       videoTrack: HMSEncoder.encodeHmsVideoTrack(peer.videoTrack, id),
@@ -126,6 +132,7 @@ export class HMSEncoder {
         settings: HMSEncoder.encodeHmsAudioTrackSettings(
           peer?.localAudioTrackData?.settings
         ),
+        type: peer?.localAudioTrackData?.type,
       },
       localVideoTrackData: {
         id: id,
@@ -136,6 +143,7 @@ export class HMSEncoder {
         settings: HMSEncoder.encodeHmsVideoTrackSettings(
           peer?.localVideoTrackData?.settings
         ),
+        type: peer?.localVideoTrackData?.type,
       },
     };
 
@@ -146,6 +154,7 @@ export class HMSEncoder {
     const encodedObj = {
       maxBitrate: settings?.maxBitrate,
       trackDescription: settings?.trackDescription,
+      codec: settings?.codec,
     };
 
     return new HMSAudioTrackSettings(encodedObj);
@@ -154,7 +163,7 @@ export class HMSEncoder {
   static encodeHmsVideoTrackSettings(settings: any) {
     const encodedObj = {
       codec: settings?.codec,
-      resolution: settings?.resolution,
+      resolution: HMSEncoder.encodeHmsVideoResolution(settings?.resolution),
       maxBitrate: settings?.maxBitrate,
       maxFrameRate: settings?.maxFrameRate,
       cameraFacing: settings?.cameraFacing,
@@ -164,6 +173,15 @@ export class HMSEncoder {
     return new HMSVideoTrackSettings(encodedObj);
   }
 
+  static encodeHmsVideoResolution(resolution: any) {
+    const encodedObj = {
+      height: resolution?.height,
+      width: resolution?.width,
+    };
+
+    return new HMSVideoResolution(encodedObj);
+  }
+
   static encodeHmsRemotePeers(peers: any, id: string) {
     const hmsPeers: any[] = [];
 
@@ -183,6 +201,7 @@ export class HMSEncoder {
       isLocal: peer.isLocal,
       customerUserID: peer.customerUserID,
       customerDescription: peer.customerDescription,
+      metadata: peer.metadata,
       role: HMSEncoder.encodeHmsRole(peer?.role),
       audioTrack: HMSEncoder.encodeHmsAudioTrack(peer.audioTrack, id),
       videoTrack: HMSEncoder.encodeHmsVideoTrack(peer.videoTrack, id),
@@ -257,6 +276,7 @@ export class HMSEncoder {
     const encodedChangeTrackStateRequest = {
       requestedBy: HMSEncoder.encodeHmsPeer(data.requestedBy, id),
       trackType: data.trackType,
+      mute: data.mute,
     };
 
     return new HMSChangeTrackStateRequest(encodedChangeTrackStateRequest);

package/src/classes/HMSException.ts

@@ -0,0 +1,33 @@
+export class HMSException {
+  public error: {
+    code: number;
+    description: string;
+    localizedDescription: string;
+    message: string;
+    name: string;
+    action: string;
+  };
+  public event: string;
+
+  constructor(params: {
+    error: {
+      code: number;
+      description: string;
+      localizedDescription: string;
+      message: string;
+      name: string;
+      action: string;
+    };
+    event: string;
+  }) {
+    this.error = {
+      code: params.error.code,
+      description: params.error.description,
+      localizedDescription: params.error.localizedDescription,
+      message: params.error.message,
+      name: params.error.name,
+      action: params.error.action,
+    };
+    this.event = params.event;
+  }
+}

package/src/classes/HMSHelper.ts

@@ -5,8 +5,8 @@ export class HMSHelper {
     let names: string[] = [];
 
     roles?.map((item: HMSRole) => {
-      if (item.name) {
-        names.push(item.name);
+      if (item?.name) {
+        names.push(item?.name);
       }
     });
 

package/src/classes/HMSLocalAudioTrack.ts

@@ -1,5 +1,6 @@
-import { NativeModules } from 'react-native';
+import { NativeModules, Platform } from 'react-native';
 import { HMSAudioTrack } from './HMSAudioTrack';
+import { HMSSDK } from './HMSSDK';
 import type { HMSAudioTrackSettings } from './HMSAudioTrackSettings';
 import type { HMSTrackType } from './HMSTrackType';
 
@@ -21,9 +22,36 @@ export class HMSLocalAudioTrack extends HMSAudioTrack {
    * @memberof HMSLocalAudioTrack
    */
   setMute(isMute: boolean) {
+    const logger = HMSSDK.getLogger();
+    logger?.verbose('#Function setMute', {
+      trackId: this.trackId,
+      id: this.id,
+      source: this.source,
+      type: this.type,
+      isMute,
+    });
     HmsManager.setLocalMute({ isMute, id: this.id });
   }
 
+  getVolume = async () => {
+    const logger = HMSSDK.getLogger();
+    logger?.verbose('#Function getVolume', {
+      trackId: this.trackId,
+      id: this.id,
+      source: this.source,
+      type: this.type,
+    });
+    if (Platform.OS === 'ios') {
+      return 'This API not available for IOS';
+    }
+    const volume = await HmsManager.getVolume({
+      trackId: this.trackId,
+      id: this.id,
+    });
+
+    return volume;
+  };
+
   constructor(params: {
     id: string;
     trackId: string;

package/src/classes/HMSLocalPeer.ts

@@ -7,6 +7,7 @@ import type { HMSAudioTrackSettings } from './HMSAudioTrackSettings';
 import { HMSLocalAudioTrack } from './HMSLocalAudioTrack';
 import { HMSLocalVideoTrack } from './HMSLocalVideoTrack';
 import type { HMSRole } from './HMSRole';
+import type { HMSTrackType } from './HMSTrackType';
 
 export class HMSLocalPeer extends HMSPeer {
   private localAudio?: HMSLocalAudioTrack;
@@ -25,6 +26,7 @@ export class HMSLocalPeer extends HMSPeer {
     isLocal?: boolean;
     customerUserID?: string;
     customerDescription?: string;
+    metadata?: string;
     audioTrack?: HMSAudioTrack;
     videoTrack?: HMSVideoTrack;
     role?: HMSRole;
@@ -36,6 +38,7 @@ export class HMSLocalPeer extends HMSPeer {
       trackDescription?: string;
       isMute?: boolean;
       settings?: HMSAudioTrackSettings;
+      type: HMSTrackType;
     };
     localVideoTrackData?: {
       id: string;
@@ -44,6 +47,7 @@ export class HMSLocalPeer extends HMSPeer {
       trackDescription?: string;
       isMute?: boolean;
       settings?: HMSVideoTrackSettings;
+      type: HMSTrackType;
     };
   }) {
     super(params);

package/src/classes/HMSLocalVideoTrack.ts

@@ -1,5 +1,6 @@
 import { NativeModules } from 'react-native';
 import { HMSVideoTrack } from './HMSVideoTrack';
+import { HMSSDK } from './HMSSDK';
 import type { HMSVideoTrackSettings } from './HMSVideoTrackSettings';
 import type { HMSTrackType } from './HMSTrackType';
 
@@ -22,6 +23,13 @@ export class HMSLocalVideoTrack extends HMSVideoTrack {
    * @memberof HMSSDK
    */
   switchCamera = () => {
+    const logger = HMSSDK.getLogger();
+    logger?.verbose('#Function switchCamera', {
+      trackId: this.trackId,
+      source: this.source,
+      type: this.type,
+      id: this.id,
+    });
     HmsManager.switchCamera({ id: this.id });
   };
 
@@ -32,6 +40,13 @@ export class HMSLocalVideoTrack extends HMSVideoTrack {
    * @memberof HMSLocalVideoTrack
    */
   setMute(isMute: boolean) {
+    const logger = HMSSDK.getLogger();
+    logger?.verbose('#Function setMute', {
+      trackId: this.trackId,
+      source: this.source,
+      type: this.type,
+      id: this.id,
+    });
     HmsManager.setLocalVideoMute({ isMute, id: this.id });
   }
 

package/src/classes/HMSLogger.ts

@@ -4,6 +4,12 @@ export class HMSLogger {
   private _verbose: boolean = false;
   private _warning: boolean = false;
   private _error: boolean = false;
+  private logs: {
+    type: 'verbose' | 'warn' | 'error';
+    message: string;
+    data: any;
+    id: string;
+  }[] = [];
 
   constructor(params?: { verbose: boolean; warning: boolean; error: boolean }) {
     if (params) {
@@ -14,21 +20,28 @@ export class HMSLogger {
   }
 
   verbose(message: string, data: any) {
-    if (this._verbose === true) {
+    if (this._verbose) {
       console.log(message, data);
     }
+    this.logs.push({ type: 'verbose', message, data, id: data?.id });
   }
 
   warn(message: string, data: any) {
     if (this._warning) {
       console.warn(message, data);
     }
+    this.logs.push({ type: 'warn', message, data, id: data?.id });
   }
 
   error(message: string, data: any) {
     if (this._error) {
       console.error(message, data);
     }
+    this.logs.push({ type: 'error', message, data, id: data?.id });
+  }
+
+  getLogs() {
+    return this.logs;
   }
 
   updateLogLevel(level: HMSLogLevel, value: boolean) {

package/src/classes/HMSPeer.ts

@@ -9,6 +9,7 @@ export class HMSPeer {
   isLocal?: boolean;
   customerUserID?: string;
   customerDescription?: string;
+  metadata?: string;
   role?: HMSRole;
 
   audioTrack?: HMSAudioTrack;
@@ -22,6 +23,7 @@ export class HMSPeer {
     isLocal?: boolean;
     customerUserID?: string;
     customerDescription?: string;
+    metadata?: string;
     role?: HMSRole;
     audioTrack?: HMSAudioTrack;
     videoTrack?: HMSVideoTrack;
@@ -36,5 +38,6 @@ export class HMSPeer {
     this.videoTrack = params.videoTrack;
     this.auxiliaryTracks = params.auxiliaryTracks;
     this.role = params.role;
+    this.metadata = params.metadata;
   }
 }