@100mslive/react-native-hms 0.7.3 → 0.8.2

package/src/classes/{HMSSDK.ts → HMSSDK.tsx}

@@ -1,4 +1,5 @@
-import { NativeEventEmitter, NativeModules } from 'react-native';
+import React from 'react';
+import { NativeEventEmitter, NativeModules, ViewStyle } from 'react-native';
 import { HMSUpdateListenerActions } from './HMSUpdateListenerActions';
 import type { HMSConfig } from './HMSConfig';
 import type { HMSLocalPeer } from './HMSLocalPeer';
@@ -9,7 +10,22 @@ import { HMSEncoder } from './HMSEncoder';
 import { HMSMessage } from './HMSMessage';
 import { HMSHelper } from './HMSHelper';
 import type { HMSTrack } from './HMSTrack';
+import type { HMSTrackType } from './HMSTrackType';
 import type { HMSLogger } from './HMSLogger';
+import type { HMSPeer } from './HMSPeer';
+import { HmsView as HMSViewComponent } from './HmsView';
+import { HMSVideoViewMode } from './HMSVideoViewMode';
+import type { HMSTrackSettings } from './HMSTrackSettings';
+import type { HMSRTMPConfig } from './HMSRTMPConfig';
+
+interface HmsComponentProps {
+  trackId: string;
+  sink: boolean;
+  style: ViewStyle;
+  mirror?: boolean;
+  scaleType: HMSVideoViewMode;
+  id?: string | null;
+}
 
 const {
   /**
@@ -22,12 +38,15 @@ const HmsEventEmitter = new NativeEventEmitter(HmsManager);
 
 let HmsSdk: HMSSDK | undefined;
 
+let logger: HMSLogger | undefined;
+
 export class HMSSDK {
   room?: HMSRoom;
   localPeer?: HMSLocalPeer;
   remotePeers?: HMSRemotePeer[];
   knownRoles?: HMSRole[];
-  logger?: HMSLogger;
+  id: string;
+  private muteStatus: boolean | undefined;
 
   onPreviewDelegate?: any;
   onJoinDelegate?: any;
@@ -43,6 +62,10 @@ export class HMSSDK {
   onChangeTrackStateRequestDelegate?: any;
   onRemovedFromRoomDelegate?: any;
 
+  constructor(id: string) {
+    this.id = id;
+  }
+
   /**
    * - Returns an instance of [HMSSDK]{@link HMSSDK}
    * - This function must be called to get an instance of HMSSDK class and only then user can interact with its methods
@@ -51,15 +74,27 @@ export class HMSSDK {
    * @returns
    * @memberof HMSSDK
    */
-  static build() {
-    if (HmsSdk) {
-      return HmsSdk;
-    }
-    HmsManager.build();
-    HmsSdk = new HMSSDK();
+  static async build(params?: { trackSettings?: HMSTrackSettings }) {
+    let id = await HmsManager.build(params?.trackSettings || {});
+    HmsSdk = new HMSSDK(id);
+    HmsSdk.attachPreviewListener();
+    HmsSdk.attachListeners();
     return HmsSdk;
   }
 
+  static getLogger() {
+    return logger;
+  }
+
+  setLogger = (hmsLogger: HMSLogger) => {
+    logger = hmsLogger;
+    hmsLogger.verbose('#Function setLogger', { id: this.id });
+  };
+
+  destroy = () => {
+    this.removeListeners();
+  };
+
   attachPreviewListener = () => {
     HmsEventEmitter.addListener(
       HMSUpdateListenerActions.ON_PREVIEW,
@@ -129,6 +164,68 @@ export class HMSSDK {
     );
   };
 
+  removeListeners = () => {
+    HmsEventEmitter.removeListener(
+      HMSUpdateListenerActions.ON_JOIN,
+      this.onJoinListener
+    );
+
+    HmsEventEmitter.removeListener(
+      HMSUpdateListenerActions.ON_ROOM_UPDATE,
+      this.onRoomListener
+    );
+
+    HmsEventEmitter.removeListener(
+      HMSUpdateListenerActions.ON_PEER_UPDATE,
+      this.onPeerListener
+    );
+
+    HmsEventEmitter.removeListener(
+      HMSUpdateListenerActions.ON_TRACK_UPDATE,
+      this.onTrackListener
+    );
+
+    HmsEventEmitter.removeListener(
+      HMSUpdateListenerActions.ON_ERROR,
+      this.onErrorListener
+    );
+
+    HmsEventEmitter.removeListener(
+      HMSUpdateListenerActions.ON_MESSAGE,
+      this.onMessageListener
+    );
+
+    HmsEventEmitter.removeListener(
+      HMSUpdateListenerActions.ON_SPEAKER,
+      this.onSpeakerListener
+    );
+
+    HmsEventEmitter.removeListener(
+      HMSUpdateListenerActions.RECONNECTING,
+      this.reconnectingListener
+    );
+
+    HmsEventEmitter.removeListener(
+      HMSUpdateListenerActions.RECONNECTED,
+      this.reconnectedListener
+    );
+
+    HmsEventEmitter.removeListener(
+      HMSUpdateListenerActions.ON_ROLE_CHANGE_REQUEST,
+      this.onRoleChangeRequestListener
+    );
+
+    HmsEventEmitter.removeListener(
+      HMSUpdateListenerActions.ON_CHANGE_TRACK_STATE_REQUEST,
+      this.onChangeTrackStateRequestListener
+    );
+
+    HmsEventEmitter.removeListener(
+      HMSUpdateListenerActions.ON_REMOVED_FROM_ROOM,
+      this.onRemovedFromRoomListener
+    );
+  };
+
   /**
    * takes an instance of [HMSConfig]{@link HMSConfig} and joins the room
    * after joining the room user will start receiving the events and updates of the room
@@ -137,15 +234,32 @@ export class HMSSDK {
    * @memberof HMSSDK
    */
   join = async (config: HMSConfig) => {
-    this.logger?.verbose('JOIN', { config });
-    this.attachListeners();
-    await HmsManager.join(config);
+    logger?.verbose('#Function join', { config, id: this.id });
+    await HmsManager.join({ ...config, id: this.id });
   };
 
   preview = (config: HMSConfig) => {
-    this.logger?.verbose('PREVIEW', { config });
-    this.attachPreviewListener();
-    HmsManager.preview(config);
+    logger?.verbose('#Function preview', { config, id: this.id });
+    HmsManager.preview({ ...config, id: this.id });
+  };
+
+  HmsView = ({
+    sink,
+    trackId,
+    style,
+    mirror,
+    scaleType = HMSVideoViewMode.ASPECT_FIT,
+  }: HmsComponentProps) => {
+    return (
+      <HMSViewComponent
+        sink={sink}
+        trackId={trackId}
+        style={style}
+        mirror={mirror}
+        scaleType={scaleType}
+        id={this.id}
+      />
+    );
   };
 
   /**
@@ -153,84 +267,199 @@ export class HMSSDK {
    *
    * @memberof HMSSDK
    */
-  leave = () => {
-    this.logger?.verbose('LEAVE', {});
+  leave = async () => {
+    logger?.verbose('#Function leave', { id: this.id });
+    const data = {
+      id: this.id,
+    };
+
+    const op = await HmsManager.leave(data);
+    this.muteStatus = undefined;
     this.localPeer = undefined;
     this.remotePeers = undefined;
     this.room = undefined;
     this.knownRoles = undefined;
-    HmsManager.leave();
+    return op;
   };
 
-  sendBroadcastMessage = (message: string) => {
-    this.logger?.verbose('SEND_BROADCAST_MESSAGE', { message });
-    HmsManager.sendBroadcastMessage({ message });
+  sendBroadcastMessage = async (message: string, type?: string) => {
+    logger?.verbose('#Function sendBroadcastMessage', {
+      message,
+      type: type || null,
+      id: this.id,
+    });
+    return await HmsManager.sendBroadcastMessage({
+      message,
+      type: type || null,
+      id: this.id,
+    });
   };
 
-  sendGroupMessage = (message: string, roles: HMSRole[]) => {
-    this.logger?.verbose('SEND_GROUP_MESSAGE', { message, roles });
-    HmsManager.sendGroupMessage({
+  sendGroupMessage = async (
+    message: string,
+    roles: HMSRole[],
+    type?: string
+  ) => {
+    logger?.verbose('#Function sendGroupMessage', {
+      message,
+      roles,
+      id: this.id,
+      type: type || null,
+    });
+    return await HmsManager.sendGroupMessage({
       message,
       roles: HMSHelper.getRoleNames(roles),
+      id: this.id,
+      type: type || null,
     });
   };
 
-  sendDirectMessage = (message: string, peerId: string) => {
-    this.logger?.verbose('SEND_DIRECT_MESSAGE', { message, peerId });
-    HmsManager.sendDirectMessage({
+  sendDirectMessage = async (
+    message: string,
+    peerId: string,
+    type?: string
+  ) => {
+    logger?.verbose('#Function sendDirectMessage', {
       message,
       peerId,
+      id: this.id,
+      type: type || null,
     });
+    return await HmsManager.sendDirectMessage({
+      message,
+      peerId,
+      id: this.id,
+      type: type || null,
+    });
+  };
+
+  changeMetadata = (metadata: string) => {
+    logger?.verbose('#Function changeMetadata', { metadata, id: this.id });
+    HmsManager.changeMetadata({ metadata, id: this.id });
+  };
+
+  startRTMPOrRecording = async (data: HMSRTMPConfig) => {
+    logger?.verbose('#Function startRTMPOrRecording', {
+      ...data,
+      id: this.id,
+    });
+
+    const op = await HmsManager.startRTMPOrRecording({ ...data, id: this.id });
+    return op;
   };
 
-  changeRole = (peerId: string, role: string, force: boolean = false) => {
+  stopRtmpAndRecording = async () => {
+    logger?.verbose('#Function stopRtmpAndRecording', {});
+    const op = await HmsManager.stopRtmpAndRecording({ id: this.id });
+    return op;
+  };
+
+  changeRole = async (peer: HMSPeer, role: HMSRole, force: boolean = false) => {
     const data = {
-      peerId: peerId,
-      role: role,
+      peerId: peer?.peerID,
+      role: role?.name,
       force: force,
+      id: this.id,
     };
-    this.logger?.verbose('CHANGE_ROLE', data);
-    HmsManager.changeRole(data);
+    logger?.verbose('#Function changeRole', data);
+    return await HmsManager.changeRole(data);
   };
 
-  changeTrackState = (track: HMSTrack, mute: boolean) => {
-    this.logger?.verbose('CHANGE_TRACK_STATE', { track, mute });
+  changeTrackState = async (track: HMSTrack, mute: boolean) => {
+    logger?.verbose('#Function changeTrackState', {
+      track,
+      mute,
+      id: this.id,
+    });
     const data = {
       trackId: track.trackId,
       mute,
+      id: this.id,
+    };
+
+    return await HmsManager.changeTrackState(data);
+  };
+
+  changeTrackStateRoles = async (
+    type: HMSTrackType,
+    mute: boolean,
+    source: string,
+    roles: Array<HMSRole>
+  ) => {
+    logger?.verbose('#Function changeTrackStateRoles', {
+      source,
+      mute,
+      type,
+      roles,
+      id: this.id,
+    });
+    const data = {
+      source,
+      mute,
+      type,
+      roles: HMSHelper.getRoleNames(roles),
+      id: this.id,
     };
 
-    HmsManager.changeTrackState(data);
+    return await HmsManager.changeTrackStateRoles(data);
   };
 
-  removePeer = (peerId: string, reason: string) => {
-    this.logger?.verbose('REMOVE_PEER', { peerId, reason });
+  removePeer = async (peerId: string, reason: string) => {
+    logger?.verbose('#Function removePeer', { peerId, reason, id: this.id });
     const data = {
       peerId,
       reason,
+      id: this.id,
     };
 
-    HmsManager.removePeer(data);
+    return await HmsManager.removePeer(data);
   };
 
-  endRoom = (lock: boolean, reason: string) => {
-    this.logger?.verbose('END_ROOM', { lock, reason });
+  endRoom = async (lock: boolean, reason: string) => {
+    logger?.verbose('#Function endRoom', { lock, reason, id: this.id });
     const data = {
       lock,
       reason,
+      id: this.id,
     };
 
-    HmsManager.endRoom(data);
+    return await HmsManager.endRoom(data);
   };
 
   acceptRoleChange = () => {
-    this.logger?.verbose('ACCEPT_ROLE_CHANGE', {});
-    HmsManager.acceptRoleChange();
+    logger?.verbose('#Function acceptRoleChange', { id: this.id });
+    HmsManager.acceptRoleChange({ id: this.id });
   };
 
   muteAllPeersAudio = (mute: boolean) => {
-    this.logger?.verbose('ON_MUTE_ALL_PEERS', { mute });
-    HmsManager.muteAllPeersAudio(mute);
+    logger?.verbose('#Function muteAllPeersAudio', { mute, id: this.id });
+    this.muteStatus = mute;
+    HmsManager.muteAllPeersAudio({ mute, id: this.id });
+  };
+
+  getRoom = async () => {
+    logger?.verbose('#Function getRoom', {
+      roomID: this.room?.id,
+      id: this.id,
+    });
+    const hmsRoom = await HmsManager.getRoom({ id: this.id });
+
+    const encodedHmsRoom = HMSEncoder.encodeHmsRoom(hmsRoom, this.id);
+    return encodedHmsRoom;
+  };
+
+  setVolume = (track: HMSTrack, volume: number) => {
+    logger?.verbose('#Function setVolume', {
+      track,
+      volume,
+      id: this.id,
+    });
+    HmsManager.setVolume({
+      id: this.id,
+      trackId: track.trackId,
+      volume,
+    });
+    return;
   };
 
   /**
@@ -242,7 +471,10 @@ export class HMSSDK {
    * @memberof HMSSDK
    */
   addEventListener = (action: HMSUpdateListenerActions, callback: any) => {
-    this.logger?.verbose('ON_ATTACH_EVENT_LISTENER', { action });
+    logger?.verbose('#Function addEventListener', {
+      action,
+      id: this.id,
+    });
     switch (action) {
       case HMSUpdateListenerActions.ON_PREVIEW:
         this.onPreviewDelegate = callback;
@@ -296,7 +528,7 @@ export class HMSSDK {
    * @memberof HMSSDK
    */
   removeEventListener = (action: HMSUpdateListenerActions) => {
-    this.logger?.verbose('ON_REMOVE_LISTENER', { action });
+    logger?.verbose('#Function removeEventListener', { action, id: this.id });
     switch (action) {
       case HMSUpdateListenerActions.ON_PREVIEW:
         this.onPreviewDelegate = null;
@@ -361,19 +593,18 @@ export class HMSSDK {
     this.onChangeTrackStateRequestDelegate = null;
     this.onRemovedFromRoomDelegate = null;
 
-    this.logger?.verbose('REMOVE_ALL_LISTENER', {});
-  };
-
-  setLogger = (hmsLogger: HMSLogger) => {
-    this.logger = hmsLogger;
-    hmsLogger.verbose('UPDATE_LOGGER', { hmsLogger });
+    logger?.verbose('#Function REMOVE_ALL_LISTENER', { id: this.id });
   };
 
   onPreviewListener = (data: any) => {
-    this.logger?.verbose('ON_PREVIEW', data);
-    const room: HMSRoom = HMSEncoder.encodeHmsRoom(data.room);
+    if (data.id !== this.id) {
+      return;
+    }
+    logger?.verbose('#Listener ON_PREVIEW', data);
+    const room: HMSRoom = HMSEncoder.encodeHmsRoom(data.room, this.id);
     const localPeer: HMSLocalPeer = HMSEncoder.encodeHmsLocalPeer(
-      data.localPeer
+      data.localPeer,
+      this.id
     );
 
     const previewTracks = HMSEncoder.encodeHmsPreviewTracks(data.previewTracks);
@@ -381,7 +612,7 @@ export class HMSSDK {
     this.localPeer = localPeer;
     this.room = room;
     if (this.onPreviewDelegate) {
-      this.logger?.verbose('ON_PREVIEW_LISTENER_CALL', {
+      logger?.verbose('#Listener ON_PREVIEW_LISTENER_CALL', {
         ...data,
         room,
         localPeer,
@@ -392,14 +623,19 @@ export class HMSSDK {
   };
 
   onJoinListener = (data: any) => {
-    this.logger?.verbose('ON_JOIN', data);
+    if (data.id !== this.id) {
+      return;
+    }
+    logger?.verbose('#LISTENER ON_JOIN', data);
     // Preprocessing
-    const room: HMSRoom = HMSEncoder.encodeHmsRoom(data.room);
+    const room: HMSRoom = HMSEncoder.encodeHmsRoom(data.room, this.id);
     const localPeer: HMSLocalPeer = HMSEncoder.encodeHmsLocalPeer(
-      data.localPeer
+      data.localPeer,
+      this.id
     );
     const remotePeers: HMSRemotePeer[] = HMSEncoder.encodeHmsRemotePeers(
-      data.remotePeers
+      data.remotePeers,
+      this.id
     );
     const roles: HMSRole[] = HMSEncoder.encodeHmsRoles(data.roles);
     this.room = room;
@@ -407,7 +643,7 @@ export class HMSSDK {
     this.remotePeers = remotePeers;
     this.knownRoles = roles;
     if (this.onJoinDelegate) {
-      this.logger?.verbose('ON_JOIN_LISTENER_CALL', {
+      logger?.verbose('#Listener ON_JOIN_LISTENER_CALL', {
         ...data,
         room,
         localPeer,
@@ -418,19 +654,24 @@ export class HMSSDK {
   };
 
   onRoomListener = (data: any) => {
-    this.logger?.verbose('ON_ROOM', data);
-    const room: HMSRoom = HMSEncoder.encodeHmsRoom(data.room);
+    if (data.id !== this.id) {
+      return;
+    }
+    logger?.verbose('#Listener ON_ROOM', data);
+    const room: HMSRoom = HMSEncoder.encodeHmsRoom(data.room, this.id);
     const localPeer: HMSLocalPeer = HMSEncoder.encodeHmsLocalPeer(
-      data.localPeer
+      data.localPeer,
+      this.id
     );
     const remotePeers: HMSRemotePeer[] = HMSEncoder.encodeHmsRemotePeers(
-      data.remotePeers
+      data.remotePeers,
+      this.id
     );
     this.room = room;
     this.localPeer = localPeer;
     this.remotePeers = remotePeers;
     if (this.onRoomDelegate) {
-      this.logger?.verbose('ON_ROOM_LISTENER_CALL', {
+      logger?.verbose('#Listener ON_ROOM_LISTENER_CALL', {
         ...data,
         room,
         localPeer,
@@ -441,71 +682,113 @@ export class HMSSDK {
   };
 
   onPeerListener = (data: any) => {
-    this.logger?.verbose('ON_PEER', data);
+    if (data.id !== this.id) {
+      return;
+    }
+    logger?.verbose('#Listener ON_PEER', data);
+    const peer: HMSPeer = HMSEncoder.encodeHmsPeer(data.peer, this.id);
+    const room: HMSRoom = HMSEncoder.encodeHmsRoom(data.room, this.id);
     const localPeer: HMSLocalPeer = HMSEncoder.encodeHmsLocalPeer(
-      data.localPeer
+      data.localPeer,
+      this.id
     );
     const remotePeers: HMSRemotePeer[] = HMSEncoder.encodeHmsRemotePeers(
-      data.remotePeers
+      data.remotePeers,
+      this.id
     );
     // this.room = room;
     this.localPeer = localPeer;
     this.remotePeers = remotePeers;
+    this.room = room;
     if (this.onPeerDelegate) {
-      this.logger?.verbose('ON_PEER_LISTENER_CALL', data);
-      this.onPeerDelegate({ ...data, localPeer, remotePeers });
+      logger?.verbose('#Listener ON_PEER_LISTENER_CALL', data);
+      this.onPeerDelegate({ ...data, localPeer, remotePeers, room, peer });
     }
   };
 
   onTrackListener = (data: any) => {
-    this.logger?.verbose('ON_TRACK', data);
-    // const room: HMSRoom = HMSEncoder.encodeHmsRoom(data.room);
+    if (data.id !== this.id) {
+      return;
+    }
+    logger?.verbose('#Listener ON_TRACK', data);
+    const track: HMSTrack = HMSEncoder.encodeHmsTrack(data.track, this.id);
+    const peer: HMSPeer = HMSEncoder.encodeHmsPeer(data.peer, this.id);
+    const room: HMSRoom = HMSEncoder.encodeHmsRoom(data.room, this.id);
     const localPeer: HMSLocalPeer = HMSEncoder.encodeHmsLocalPeer(
-      data.localPeer
+      data.localPeer,
+      this.id
     );
     const remotePeers: HMSRemotePeer[] = HMSEncoder.encodeHmsRemotePeers(
-      data.remotePeers
+      data.remotePeers,
+      this.id
     );
-    // this.room = room;
+    if (this.muteStatus && data?.type === 'TRACK_ADDED') {
+      this.muteAllPeersAudio(this.muteStatus);
+    }
+    this.room = room;
     this.localPeer = localPeer;
     this.remotePeers = remotePeers;
     if (this.onTrackDelegate) {
-      this.logger?.verbose('ON_TRACK_LISTENER_CALL', data);
-      this.onTrackDelegate({ ...data, localPeer, remotePeers });
+      logger?.verbose('#Listener ON_TRACK_LISTENER_CALL', data);
+      this.onTrackDelegate({
+        ...data,
+        localPeer,
+        remotePeers,
+        room,
+        peer,
+        track,
+      });
     }
   };
 
   onMessageListener = (data: any) => {
-    this.logger?.verbose('ON_MESSAGE', data);
+    if (data.id !== this.id) {
+      return;
+    }
+    logger?.verbose('#Listener ON_MESSAGE', data);
     const message = new HMSMessage(data);
     if (this.onMessageDelegate) {
-      this.logger?.verbose('ON_MESSAGE_LISTENER_CALL', message);
+      logger?.verbose('#Listener ON_MESSAGE_LISTENER_CALL', message);
       this.onMessageDelegate(message);
     }
   };
 
   onSpeakerListener = (data: any) => {
-    this.logger?.verbose('ON_SPEAKER', data);
+    if (data.id !== this.id) {
+      return;
+    }
+    logger?.verbose('#Listener ON_SPEAKER', data);
     if (this.onSpeakerDelegate) {
+      logger?.verbose('#Listener ON_SPEAKER_LISTENER_CALL', data);
       this.onSpeakerDelegate(data);
     }
   };
 
   onErrorListener = (data: any) => {
-    this.logger?.warn('ON_ERROR', data);
+    if (data.id !== this.id) {
+      return;
+    }
+    logger?.warn('#Listener ON_ERROR', data);
+    logger?.verbose('#Listener ON_ERROR', data);
     if (this.onErrorDelegate) {
-      this.logger?.warn('ON_ERROR_LISTENER_CALL', data);
+      logger?.verbose('#Listener ON_ERROR_LISTENER_CALL', data);
+      logger?.warn('#Listener ON_ERROR_LISTENER_CALL', data);
       this.onErrorDelegate(data);
     }
   };
 
   onRoleChangeRequestListener = (data: any) => {
-    this.logger?.verbose('ON_ROLE_CHANGE_REQUEST', data);
+    if (data.id !== this.id) {
+      return;
+    }
+    logger?.verbose('#Listener ON_ROLE_CHANGE_REQUEST', data);
     if (this.onRoleChangeRequestDelegate) {
-      const encodedRoleChangeRequest =
-        HMSEncoder.encodeHmsRoleChangeRequest(data);
-      this.logger?.verbose(
-        'ON_ROLE_CHANGE_LISTENER_CALL',
+      const encodedRoleChangeRequest = HMSEncoder.encodeHmsRoleChangeRequest(
+        data,
+        this.id
+      );
+      logger?.verbose(
+        '#Listener ON_ROLE_CHANGE_LISTENER_CALL',
         encodedRoleChangeRequest
       );
       this.onRoleChangeRequestDelegate(encodedRoleChangeRequest);
@@ -513,12 +796,15 @@ export class HMSSDK {
   };
 
   onChangeTrackStateRequestListener = (data: any) => {
-    this.logger?.verbose('ON_CHANGE_TRACK_STATE_REQUEST', data);
+    if (data.id !== this.id) {
+      return;
+    }
+    logger?.verbose('#Listener ON_CHANGE_TRACK_STATE_REQUEST', data);
     if (this.onChangeTrackStateRequestDelegate) {
       const encodedRoleChangeRequest =
-        HMSEncoder.encodeHmsChangeTrackStateRequest(data);
-      this.logger?.verbose(
-        'ON_CHANGE_TRACK_STATE_REQUEST_LISTENER_CALL',
+        HMSEncoder.encodeHmsChangeTrackStateRequest(data, this.id);
+      logger?.verbose(
+        '#Listener ON_CHANGE_TRACK_STATE_REQUEST_LISTENER_CALL',
         encodedRoleChangeRequest
       );
       this.onChangeTrackStateRequestDelegate(encodedRoleChangeRequest);
@@ -526,30 +812,43 @@ export class HMSSDK {
   };
 
   onRemovedFromRoomListener = (data: any) => {
-    this.logger?.verbose('ON_REMOVED_FROM_ROOM', data);
+    if (data.id !== this.id) {
+      return;
+    }
+    logger?.verbose('#Listener ON_REMOVED_FROM_ROOM', data);
     if (this.onRemovedFromRoomDelegate) {
-      const requestedBy = HMSEncoder.encodeHmsPeer(data.requestedBy);
+      let requestedBy = null;
+      if (data.requestedBy) {
+        requestedBy = HMSEncoder.encodeHmsPeer(data.requestedBy, this.id);
+      }
       const reason = data.reason;
       const roomEnded = data.roomEnded;
 
-      this.logger?.verbose('ON_REMOVED_FROM_ROOM_LISTENER_CALL', {
+      logger?.verbose('#Listener ON_REMOVED_FROM_ROOM_LISTENER_CALL', {
         requestedBy,
         reason,
         roomEnded,
+        id: this.id,
       });
       this.onRemovedFromRoomDelegate({ requestedBy, reason, roomEnded });
     }
   };
 
   reconnectingListener = (data: any) => {
-    this.logger?.verbose('ON_RECONNECTING', data);
+    if (data.id !== this.id) {
+      return;
+    }
+    logger?.verbose('#Listener ON_RECONNECTING', data);
     if (this.onReconnectingDelegate) {
       this.onReconnectingDelegate(data);
     }
   };
 
   reconnectedListener = (data: any) => {
-    this.logger?.verbose('ON_RECONNECTED', data);
+    if (data.id !== this.id) {
+      return;
+    }
+    logger?.verbose('#Listener ON_RECONNECTED', data);
     if (this.onReconnectedDelegate) {
       this.onReconnectedDelegate(data);
     }