@100mslive/react-native-room-kit 0.2.0 → 1.0.1

package/src/hooks-util.ts

@@ -3,6 +3,7 @@ import {
   HMSConfig,
   HMSLocalPeer,
   HMSMessage,
+  HMSMessageRecipientType,
   HMSPIPListenerActions,
   HMSPeer,
   HMSPeerUpdate,
@@ -16,15 +17,21 @@ import {
   HMSTrackType,
   HMSTrackUpdate,
   HMSUpdateListenerActions,
+  HMSMessageRecipient,
   // useHMSPeerUpdates,
 } from '@100mslive/react-native-hms';
+import type { Chat as ChatConfig } from '@100mslive/types-prebuilt/elements/chat';
 import type {
+  HMSRole,
   HMSSessionStore,
   HMSSessionStoreValue,
   HMSSpeaker,
 } from '@100mslive/react-native-hms';
 import type {
   ColorPalette,
+  DefaultConferencingScreen,
+  HLSLiveStreamingScreen,
+  Layout,
   Theme,
   Typography,
 } from '@100mslive/types-prebuilt';
@@ -39,9 +46,14 @@ import {
 } from 'react';
 import type { DependencyList } from 'react';
 
-import { MaxTilesInOnePage, ModalTypes, PipModes } from './utils/types';
-import type { PeerTrackNode } from './utils/types';
-import { createPeerTrackNode, parseMetadata } from './utils/functions';
+import {
+  MaxTilesInOnePage,
+  ModalTypes,
+  PeerListRefreshInterval,
+  PipModes,
+} from './utils/types';
+import type { ChatBroadcastFilter, PeerTrackNode } from './utils/types';
+import { createPeerTrackNode } from './utils/functions';
 import {
   batch,
   shallowEqual,
@@ -52,12 +64,25 @@ import {
 import type { RootState } from './redux';
 import {
   addMessage,
+  addNotification,
+  addParticipant,
+  addParticipants,
   addPinnedMessage,
+  addScreenshareTile,
+  addUpdateParticipant,
   changeMeetingState,
   changePipModeStatus,
   changeStartingHLSStream,
   clearStore,
+  removeNotification,
+  removeParticipant,
+  removeParticipants,
+  removeScreenshareTile,
+  replaceParticipantsList,
   saveUserData,
+  setActiveChatBottomSheetTab,
+  setActiveSpeakers,
+  setFullScreenPeerTrackNode,
   setHMSLocalPeerState,
   setHMSRoleState,
   setHMSRoomState,
@@ -67,9 +92,13 @@ import {
   setLocalPeerTrackNode,
   setMiniViewPeerTrackNode,
   setModalType,
+  setReconnecting,
+  setRoleChangeRequest,
   setStartingOrStoppingRecording,
+  updateFullScreenPeerTrackNode,
   updateLocalPeerTrackNode,
   updateMiniViewPeerTrackNode,
+  updateScreenshareTile,
 } from './redux/actions';
 import {
   createPeerTrackNodeUniqueId,
@@ -82,12 +111,7 @@ import {
   replacePeerTrackNodesWithTrack,
 } from './peerTrackNodeUtils';
 import { MeetingState } from './types';
-import {
-  AppState,
-  InteractionManager,
-  LayoutAnimation,
-  Platform,
-} from 'react-native';
+import { InteractionManager, Keyboard, Platform } from 'react-native';
 import type { ImageStyle, StyleProp, ViewStyle, TextStyle } from 'react-native';
 import { NavigationContext } from '@react-navigation/native';
 import {
@@ -95,13 +119,17 @@ import {
   useIsPortraitOrientation,
 } from './utils/dimension';
 import {
-  useSafeAreaFrame,
-  useSafeAreaInsets,
-} from 'react-native-safe-area-context';
-import { selectIsHLSViewer, selectShouldGoLive } from './hooks-util-selectors';
+  selectChatLayoutConfig,
+  selectConferencingScreenConfig,
+  selectIsHLSViewer,
+  selectLayoutConfigForRole,
+  selectShouldGoLive,
+  selectVideoTileLayoutConfig,
+} from './hooks-util-selectors';
 import type { GridViewRefAttrs } from './components/GridView';
 import { getRoomLayout } from './modules/HMSManager';
 import { DEFAULT_THEME, DEFAULT_TYPOGRAPHY } from './utils/theme';
+import { NotificationTypes } from './utils';
 
 export const useHMSListeners = (
   setPeerTrackNodes: React.Dispatch<React.SetStateAction<PeerTrackNode[]>>
@@ -113,6 +141,8 @@ export const useHMSListeners = (
 
   useHMSPeersUpdate(hmsInstance, updateLocalPeer, setPeerTrackNodes);
 
+  useHMSPeerListUpdated(hmsInstance);
+
   useHMSTrackUpdate(hmsInstance, updateLocalPeer, setPeerTrackNodes);
 };
 
@@ -129,21 +159,6 @@ const useHMSRoomUpdate = (hmsInstance: HMSSDK) => {
 
       dispatch(setHMSRoomState(room));
 
-      /**
-       * Handle case when User is joining as HLSViewer,
-       * before ON_JOIN, if ON_ROOM comes then we can show Meeting screen to user, instead of Loader or Preview
-       */
-      if (room.localPeer.role?.name?.includes('hls-') ?? false) {
-        const meetingState = reduxStore.getState().app.meetingState;
-
-        batch(() => {
-          dispatch(setHMSLocalPeerState(room.localPeer));
-          if (meetingState !== MeetingState.IN_MEETING) {
-            dispatch(changeMeetingState(MeetingState.IN_MEETING));
-          }
-        });
-      }
-
       if (type === HMSRoomUpdate.BROWSER_RECORDING_STATE_UPDATED) {
         const startingOrStoppingRecording =
           reduxStore.getState().app.startingOrStoppingRecording;
@@ -151,37 +166,8 @@ const useHMSRoomUpdate = (hmsInstance: HMSSDK) => {
         if (startingOrStoppingRecording) {
           dispatch(setStartingOrStoppingRecording(false));
         }
-
-        let streaming = room?.browserRecordingState?.running;
-        const startAtDate = room?.browserRecordingState?.startedAt;
-
-        let startTime: null | string = null;
-
-        if (startAtDate) {
-          let hours = startAtDate.getHours().toString();
-          let minutes = startAtDate.getMinutes()?.toString();
-          startTime = hours + ':' + minutes;
-        }
-
-        Toast.showWithGravity(
-          `Browser Recording ${
-            streaming
-              ? `Started ${startTime ? 'At ' + startTime : ''}`
-              : 'Stopped'
-          }`,
-          Toast.LONG,
-          Toast.TOP
-        );
       } else if (type === HMSRoomUpdate.HLS_STREAMING_STATE_UPDATED) {
         dispatch(changeStartingHLSStream(false));
-
-        let streaming = room?.hlsStreamingState?.running;
-
-        Toast.showWithGravity(
-          `HLS Streaming ${streaming ? 'Started' : 'Stopped'}`,
-          Toast.LONG,
-          Toast.TOP
-        );
       } else if (type === HMSRoomUpdate.RTMP_STREAMING_STATE_UPDATED) {
         let streaming = room?.rtmpHMSRtmpStreamingState?.running;
         const startAtDate = room?.rtmpHMSRtmpStreamingState?.startedAt;
@@ -268,41 +254,108 @@ const useHMSPeersUpdate = (
 
       // Handle State for Meeting screen
       if (type === HMSPeerUpdate.PEER_JOINED) {
+        dispatch(addParticipant(peer));
         return;
       }
       if (type === HMSPeerUpdate.PEER_LEFT) {
+        dispatch(removeParticipant(peer));
+
+        // Handling regular tiles list
         setPeerTrackNodes((prevPeerTrackNodes) =>
           removePeerTrackNodes(prevPeerTrackNodes, peer)
         );
+
+        const reduxState = store.getState();
+
+        // Handling Screenshare tiles list
+        const screensharePeerTrackNodes =
+          reduxState.app.screensharePeerTrackNodes;
+        const nodeToRemove = screensharePeerTrackNodes.find(
+          (node) => node.peer.peerID === peer.peerID
+        );
+        if (nodeToRemove) {
+          dispatch(removeScreenshareTile(nodeToRemove.id));
+        }
+
+        // Handling Full screen view
+        const fullScreenPeerTrackNode = reduxState.app.fullScreenPeerTrackNode;
+        if (
+          fullScreenPeerTrackNode !== null &&
+          fullScreenPeerTrackNode.peer.peerID === peer.peerID
+        ) {
+          dispatch(setFullScreenPeerTrackNode(null));
+        }
         return;
       }
       if (peer.isLocal) {
-        setPeerTrackNodes((prevPeerTrackNodes) => {
-          if (peerTrackNodeExistForPeer(prevPeerTrackNodes, peer)) {
-            return replacePeerTrackNodes(prevPeerTrackNodes, peer);
-          }
-          return prevPeerTrackNodes;
-        });
-
         const reduxState = store.getState();
+        const fullScreenPeerTrackNode = reduxState.app.fullScreenPeerTrackNode;
         const miniviewPeerTrackNode = reduxState.app.miniviewPeerTrackNode;
         const localPeerTrackNode = reduxState.app.localPeerTrackNode;
 
+        // Currently Applied Layout config
+        const currentLayoutConfig = selectLayoutConfigForRole(
+          reduxState.hmsStates.layoutConfig,
+          peer.role || null
+        );
+
+        // Local Tile Inset layout is enabled
+        const enableLocalTileInset =
+          selectVideoTileLayoutConfig(currentLayoutConfig)?.grid
+            ?.enable_local_tile_inset;
+
+        // Local Tile Inset layout is disabled
+        const localTileInsetDisbaled = !enableLocalTileInset;
+
+        // Local Tile Inset layout is disabled
+        // then update local peer track node available in list of peer track nodes
+        if (localTileInsetDisbaled) {
+          setPeerTrackNodes((prevPeerTrackNodes) => {
+            if (peerTrackNodeExistForPeer(prevPeerTrackNodes, peer)) {
+              return replacePeerTrackNodes(prevPeerTrackNodes, peer);
+            }
+            return prevPeerTrackNodes;
+          });
+        }
+
         batch(() => {
           if (localPeerTrackNode) {
             dispatch(updateLocalPeerTrackNode({ peer }));
-          } else {
+          } else if (isPublishingAllowed(peer)) {
             dispatch(
               setLocalPeerTrackNode(createPeerTrackNode(peer, peer.videoTrack))
             );
           }
 
-          // only set `localPeerTrackNode` as miniview peer track node when we are already using it.
           if (
-            miniviewPeerTrackNode &&
-            miniviewPeerTrackNode.peer.peerID === peer.peerID
+            fullScreenPeerTrackNode &&
+            fullScreenPeerTrackNode.peer.peerID === peer.peerID
           ) {
-            dispatch(updateMiniViewPeerTrackNode({ peer }));
+            dispatch(updateFullScreenPeerTrackNode({ peer }));
+          }
+
+          // If Local Tile Inset layout is enabled, then update or set it
+          if (enableLocalTileInset) {
+            if (
+              miniviewPeerTrackNode !== null &&
+              miniviewPeerTrackNode.peer.peerID === peer.peerID
+            ) {
+              dispatch(updateMiniViewPeerTrackNode({ peer }));
+            } else if (
+              miniviewPeerTrackNode === null &&
+              peer.role?.publishSettings?.allowed &&
+              peer.role.publishSettings.allowed.length > 0
+            ) {
+              dispatch(
+                setMiniViewPeerTrackNode(
+                  createPeerTrackNode(peer, peer.videoTrack)
+                )
+              );
+            }
+          }
+          // If Local Tile Inset layout is disabled, then remove it if it exists
+          else if (miniviewPeerTrackNode) {
+            dispatch(setMiniViewPeerTrackNode(null));
           }
         });
 
@@ -312,6 +365,9 @@ const useHMSPeersUpdate = (
         return;
       }
       if (type === HMSPeerUpdate.ROLE_CHANGED) {
+        dispatch(addUpdateParticipant(peer));
+
+        // Handling regular tiles list
         if (
           peer.role?.publishSettings?.allowed === undefined ||
           (peer.role?.publishSettings?.allowed &&
@@ -324,19 +380,122 @@ const useHMSPeersUpdate = (
             return prevPeerTrackNodes;
           });
         }
+
+        const reduxState = store.getState();
+
+        // Handling screenshare tiles list
+        if (
+          peer.role?.publishSettings?.allowed === undefined ||
+          (peer.role?.publishSettings?.allowed &&
+            !peer.role?.publishSettings?.allowed.includes('screen'))
+        ) {
+          const screensharePeerTrackNodes =
+            reduxState.app.screensharePeerTrackNodes;
+          const nodeToRemove = screensharePeerTrackNodes.find(
+            (node) => node.peer.peerID === peer.peerID
+          );
+          if (nodeToRemove) {
+            dispatch(removeScreenshareTile(nodeToRemove.id));
+          }
+        }
+
+        // Handling full screen view
+        if (
+          peer.role?.publishSettings?.allowed === undefined ||
+          (peer.role?.publishSettings?.allowed &&
+            !peer.role?.publishSettings?.allowed.includes('video'))
+        ) {
+          const fullScreenPeerTrackNode =
+            reduxState.app.fullScreenPeerTrackNode;
+          if (
+            fullScreenPeerTrackNode !== null &&
+            fullScreenPeerTrackNode.peer.peerID === peer.peerID
+          ) {
+            dispatch(setFullScreenPeerTrackNode(null));
+          }
+        }
         return;
       }
       if (
         type === HMSPeerUpdate.METADATA_CHANGED ||
+        type === HMSPeerUpdate.HAND_RAISED_CHANGED ||
         type === HMSPeerUpdate.NAME_CHANGED ||
         type === HMSPeerUpdate.NETWORK_QUALITY_UPDATED
       ) {
+        dispatch(addUpdateParticipant(peer));
+
+        const reduxState = store.getState();
+
+        if (type === HMSPeerUpdate.HAND_RAISED_CHANGED) {
+          const handRaised = peer.isHandRaised;
+
+          if (handRaised) {
+            const { layoutConfig, localPeer } = reduxState.hmsStates;
+
+            const selectedLayoutConfig = selectLayoutConfigForRole(
+              layoutConfig,
+              localPeer?.role || null
+            );
+
+            // list of roles which should be brought on stage when they raise hand
+            const offStageRoles =
+              selectedLayoutConfig?.screens?.conferencing?.default?.elements
+                ?.on_stage_exp?.off_stage_roles;
+
+            // checking if the current peer role is included in the above list
+            const shouldBringOnStage =
+              offStageRoles && offStageRoles.includes(peer.role?.name!);
+
+            const canChangeRole =
+              reduxState.hmsStates.localPeer?.role?.permissions?.changeRole;
+
+            if (shouldBringOnStage && canChangeRole) {
+              dispatch(
+                addNotification({
+                  id: `${peer.peerID}-${NotificationTypes.HAND_RAISE}`,
+                  type: NotificationTypes.HAND_RAISE,
+                  peer,
+                })
+              );
+            }
+          } else {
+            const notifications = reduxState.app.notifications;
+            const notificationToRemove = notifications.find(
+              (notification) =>
+                notification.id ===
+                `${peer.peerID}-${NotificationTypes.HAND_RAISE}`
+            );
+            if (notificationToRemove) {
+              dispatch(removeNotification(notificationToRemove.id));
+            }
+          }
+        }
+
         setPeerTrackNodes((prevPeerTrackNodes) => {
           if (peerTrackNodeExistForPeer(prevPeerTrackNodes, peer)) {
             return replacePeerTrackNodes(prevPeerTrackNodes, peer);
           }
           return prevPeerTrackNodes;
         });
+
+        // Handling screenshare tile views
+        const screensharePeerTrackNodes =
+          reduxState.app.screensharePeerTrackNodes;
+        const nodeToUpdate = screensharePeerTrackNodes.find(
+          (node) => node.peer.peerID === peer.peerID
+        );
+        if (nodeToUpdate) {
+          dispatch(updateScreenshareTile({ id: nodeToUpdate.id, peer }));
+        }
+
+        // Handling fullscreen view
+        const fullScreenPeerTrackNode = reduxState.app.fullScreenPeerTrackNode;
+        if (
+          fullScreenPeerTrackNode !== null &&
+          fullScreenPeerTrackNode.peer.peerID === peer.peerID
+        ) {
+          dispatch(updateFullScreenPeerTrackNode({ peer }));
+        }
         return;
       }
     };
@@ -352,12 +511,52 @@ const useHMSPeersUpdate = (
   }, [hmsInstance]);
 };
 
+type PeerListUpdate = {
+  addedPeers: HMSPeer[];
+  removedPeers: HMSPeer[];
+};
+
+const useHMSPeerListUpdated = (hmsInstance: HMSSDK) => {
+  const dispatch = useDispatch();
+
+  useEffect(() => {
+    const peerListUpdateHandler = ({
+      addedPeers,
+      removedPeers,
+    }: PeerListUpdate) => {
+      batch(() => {
+        dispatch(addParticipants(addedPeers));
+        dispatch(removeParticipants(removedPeers));
+      });
+    };
+
+    hmsInstance.addEventListener(
+      HMSUpdateListenerActions.ON_PEER_LIST_UPDATED,
+      peerListUpdateHandler
+    );
+
+    return () => {
+      hmsInstance.removeEventListener(
+        HMSUpdateListenerActions.ON_PEER_LIST_UPDATED
+      );
+    };
+  }, [hmsInstance]);
+};
+
 type TrackUpdate = {
   peer: HMSPeer;
   track: HMSTrack;
   type: HMSTrackUpdate;
 };
 
+export const isPublishingAllowed = (peer: HMSPeer): boolean => {
+  return (
+    (peer.role?.publishSettings?.allowed &&
+      peer.role?.publishSettings?.allowed?.length > 0) ??
+    false
+  );
+};
+
 const useHMSTrackUpdate = (
   hmsInstance: HMSSDK,
   updateLocalPeer: () => void,
@@ -369,48 +568,66 @@ const useHMSTrackUpdate = (
   useEffect(() => {
     const trackUpdateHandler = ({ peer, track, type }: TrackUpdate) => {
       const reduxState = store.getState();
+      const fullScreenPeerTrackNode = reduxState.app.fullScreenPeerTrackNode;
       const miniviewPeerTrackNode = reduxState.app.miniviewPeerTrackNode;
       const localPeerTrackNode = reduxState.app.localPeerTrackNode;
 
+      const currentLayoutConfig = selectLayoutConfigForRole(
+        reduxState.hmsStates.layoutConfig,
+        reduxState.hmsStates.localPeer?.role ?? null
+      );
+
+      const localTileInsetEnabled =
+        selectVideoTileLayoutConfig(currentLayoutConfig)?.grid
+          ?.enable_local_tile_inset;
+
       if (type === HMSTrackUpdate.TRACK_ADDED) {
         const newPeerTrackNode = createPeerTrackNode(peer, track);
 
-        const willCreateMiniviewPeerTrackNode =
-          !miniviewPeerTrackNode &&
-          peer.isLocal &&
-          track.source === HMSTrackSource.REGULAR;
+        if (track.source === HMSTrackSource.SCREEN) {
+          if (!peer.isLocal && track.type === HMSTrackType.VIDEO) {
+            dispatch(addScreenshareTile(newPeerTrackNode));
+          }
+        } else {
+          setPeerTrackNodes((prevPeerTrackNodes) => {
+            if (
+              peerTrackNodeExistForPeerAndTrack(prevPeerTrackNodes, peer, track)
+            ) {
+              if (track.type === HMSTrackType.VIDEO) {
+                return replacePeerTrackNodesWithTrack(
+                  prevPeerTrackNodes,
+                  peer,
+                  track
+                );
+              }
+              return replacePeerTrackNodes(prevPeerTrackNodes, peer);
+            }
 
-        setPeerTrackNodes((prevPeerTrackNodes) => {
-          if (
-            peerTrackNodeExistForPeerAndTrack(prevPeerTrackNodes, peer, track)
-          ) {
-            if (track.type === HMSTrackType.VIDEO) {
-              return replacePeerTrackNodesWithTrack(
-                prevPeerTrackNodes,
-                peer,
-                track
-              );
+            if (peer.isLocal && !localTileInsetEnabled) {
+              return [newPeerTrackNode, ...prevPeerTrackNodes];
             }
-            return replacePeerTrackNodes(prevPeerTrackNodes, peer);
-          }
 
-          if (
-            miniviewPeerTrackNode
-              ? newPeerTrackNode.id !== miniviewPeerTrackNode.id
-              : !willCreateMiniviewPeerTrackNode
-          ) {
-            return [...prevPeerTrackNodes, newPeerTrackNode];
-          }
+            if (
+              !peer.isLocal &&
+              (miniviewPeerTrackNode
+                ? newPeerTrackNode.id !== miniviewPeerTrackNode.id
+                : true)
+            ) {
+              return [...prevPeerTrackNodes, newPeerTrackNode];
+            }
 
-          return prevPeerTrackNodes;
-        });
+            return prevPeerTrackNodes;
+          });
+        }
 
         // - TODO: update local localPeer state
         // - Pass this updated data to Meeting component -> DisplayView component
         if (peer.isLocal) {
           if (track.source === HMSTrackSource.REGULAR) {
             if (!localPeerTrackNode) {
-              dispatch(setLocalPeerTrackNode(newPeerTrackNode));
+              if (isPublishingAllowed(newPeerTrackNode.peer)) {
+                dispatch(setLocalPeerTrackNode(newPeerTrackNode));
+              }
             } else {
               dispatch(
                 updateLocalPeerTrackNode(
@@ -419,18 +636,28 @@ const useHMSTrackUpdate = (
               );
             }
 
-            // only setting `miniviewPeerTrackNode`, when:
-            // - there is no `miniviewPeerTrackNode`
-            // - if there is, then it is of regular track
-            if (!miniviewPeerTrackNode) {
-              dispatch(setMiniViewPeerTrackNode(newPeerTrackNode));
-            } else if (miniviewPeerTrackNode.id === newPeerTrackNode.id) {
-              dispatch(
-                updateMiniViewPeerTrackNode(
-                  track.type === HMSTrackType.VIDEO ? { peer, track } : { peer }
-                )
-              );
+            if (localTileInsetEnabled) {
+              // only setting `miniviewPeerTrackNode`, when:
+              // - there is no `miniviewPeerTrackNode`
+              // - if there is, then it is of regular track
+              if (!miniviewPeerTrackNode) {
+                dispatch(setMiniViewPeerTrackNode(newPeerTrackNode));
+              } else if (miniviewPeerTrackNode.id === newPeerTrackNode.id) {
+                dispatch(
+                  updateMiniViewPeerTrackNode(
+                    track.type === HMSTrackType.VIDEO
+                      ? { peer, track }
+                      : { peer }
+                  )
+                );
+              }
             }
+
+            // if (track.type === HMSTrackType.AUDIO) {
+            //   dispatch(setIsLocalAudioMutedState(track.isMute()));
+            // } else if (track.type === HMSTrackType.VIDEO) {
+            //   dispatch(setIsLocalVideoMutedState(track.isMute()));
+            // }
           }
           // else -> {
           //    should `localPeerTrackNode` be created/updated for non-regular track addition?
@@ -456,8 +683,19 @@ const useHMSTrackUpdate = (
         return;
       }
       if (type === HMSTrackUpdate.TRACK_REMOVED) {
-        if (
-          track.source !== HMSTrackSource.REGULAR ||
+        if (track.source === HMSTrackSource.SCREEN) {
+          if (!peer.isLocal && track.type === HMSTrackType.VIDEO) {
+            const screensharePeerTrackNodes =
+              reduxState.app.screensharePeerTrackNodes;
+            const nodeToRemove = screensharePeerTrackNodes.find(
+              (node) => node.track?.trackId === track.trackId
+            );
+            if (nodeToRemove) {
+              dispatch(removeScreenshareTile(nodeToRemove.id));
+            }
+          }
+        } else if (
+          track.source === HMSTrackSource.PLUGIN ||
           (peer.audioTrack?.trackId === undefined &&
             peer.videoTrack?.trackId === undefined)
         ) {
@@ -466,6 +704,14 @@ const useHMSTrackUpdate = (
           );
         }
 
+        if (
+          fullScreenPeerTrackNode &&
+          fullScreenPeerTrackNode.track &&
+          fullScreenPeerTrackNode.track.trackId === track.trackId
+        ) {
+          dispatch(setFullScreenPeerTrackNode(null));
+        }
+
         // - TODO: update local localPeer state
         // - Pass this updated data to Meeting component -> DisplayView component
         if (peer.isLocal) {
@@ -552,48 +798,67 @@ const useHMSTrackUpdate = (
 
         // - TODO: update local localPeer state
         // - Pass this updated data to Meeting component -> DisplayView component
-        if (peer.isLocal) {
-          const updatePayload =
-            track.type === HMSTrackType.VIDEO ? { peer, track } : { peer };
+        const updatePayload =
+          track.type === HMSTrackType.VIDEO ? { peer, track } : { peer };
 
+        if (peer.isLocal) {
           dispatch(updateLocalPeerTrackNode(updatePayload));
-
-          // Take care of miniviewPeerTrackNode
-          if (miniviewPeerTrackNode && miniviewPeerTrackNode.id === uniqueId) {
-            dispatch(updateMiniViewPeerTrackNode(updatePayload));
-          }
-
           updateLocalPeer();
-        } else {
-          if (miniviewPeerTrackNode && miniviewPeerTrackNode.id === uniqueId) {
-            const updatePayload =
-              track.type === HMSTrackType.VIDEO ? { peer, track } : { peer };
+        }
 
-            dispatch(updateMiniViewPeerTrackNode(updatePayload));
-          }
+        if (miniviewPeerTrackNode && miniviewPeerTrackNode.id === uniqueId) {
+          dispatch(updateMiniViewPeerTrackNode(updatePayload));
         }
+
+        if (
+          fullScreenPeerTrackNode &&
+          fullScreenPeerTrackNode.id === uniqueId
+        ) {
+          dispatch(updateFullScreenPeerTrackNode(updatePayload));
+        }
+
         return;
       }
       if (
         type === HMSTrackUpdate.TRACK_RESTORED ||
         type === HMSTrackUpdate.TRACK_DEGRADED
       ) {
-        setPeerTrackNodes((prevPeerTrackNodes) => {
-          if (
-            peerTrackNodeExistForPeerAndTrack(prevPeerTrackNodes, peer, track)
-          ) {
-            return degradeOrRestorePeerTrackNodes(
-              prevPeerTrackNodes,
-              peer,
-              track,
-              type === HMSTrackUpdate.TRACK_DEGRADED
+        // Checking if track source is screenshare
+        if (track.source === HMSTrackSource.SCREEN) {
+          // Handling screenshare tiles list
+          const screensharePeerTrackNodes =
+            reduxState.app.screensharePeerTrackNodes;
+          const nodeToUpdate = screensharePeerTrackNodes.find(
+            (node) => node.track?.trackId === track.trackId
+          );
+          if (nodeToUpdate) {
+            dispatch(
+              updateScreenshareTile({
+                id: nodeToUpdate.id,
+                isDegraded: type === HMSTrackUpdate.TRACK_DEGRADED,
+              })
             );
           }
-          return prevPeerTrackNodes;
-        });
+        } else {
+          // Handling regular tiles list
+          setPeerTrackNodes((prevPeerTrackNodes) => {
+            if (
+              peerTrackNodeExistForPeerAndTrack(prevPeerTrackNodes, peer, track)
+            ) {
+              return degradeOrRestorePeerTrackNodes(
+                prevPeerTrackNodes,
+                peer,
+                track,
+                type === HMSTrackUpdate.TRACK_DEGRADED
+              );
+            }
+            return prevPeerTrackNodes;
+          });
+        }
 
         const uniqueId = createPeerTrackNodeUniqueId(peer, track);
 
+        // Handling miniview
         if (miniviewPeerTrackNode && miniviewPeerTrackNode.id === uniqueId) {
           dispatch(
             updateMiniViewPeerTrackNode({
@@ -601,6 +866,18 @@ const useHMSTrackUpdate = (
             })
           );
         }
+
+        // Handling full screen view
+        if (
+          fullScreenPeerTrackNode &&
+          fullScreenPeerTrackNode.id === uniqueId
+        ) {
+          dispatch(
+            updateFullScreenPeerTrackNode({
+              isDegraded: type === HMSTrackUpdate.TRACK_DEGRADED,
+            })
+          );
+        }
         return;
       }
     };
@@ -651,9 +928,14 @@ export const useHMSInstance = () => {
 };
 
 export const useIsHLSViewer = () => {
-  return useSelector((state: RootState) =>
-    selectIsHLSViewer(state.hmsStates.localPeer)
-  );
+  return useSelector((state: RootState) => {
+    const { layoutConfig, localPeer } = state.hmsStates;
+    const selectedLayoutConfig = selectLayoutConfigForRole(
+      layoutConfig,
+      localPeer?.role || null
+    );
+    return selectIsHLSViewer(localPeer?.role, selectedLayoutConfig);
+  });
 };
 
 type TrackStateChangeRequest = {
@@ -702,26 +984,20 @@ export const useHMSChangeTrackStateRequest = (
   return trackStateChangeRequest;
 };
 
-type RoleChangeRequest = {
-  requestedBy?: string;
-  suggestedRole?: string;
-};
-
 export const useHMSRoleChangeRequest = (
   callback?: (request: HMSRoleChangeRequest) => void,
   deps?: React.DependencyList
 ) => {
+  const taskRef = useRef<any>(null);
+  const dispatch = useDispatch();
   const hmsInstance = useHMSInstance();
-  const [roleChangeRequest, setRoleChangeRequest] =
-    useState<RoleChangeRequest | null>(null);
 
   useEffect(() => {
-    const changeRoleRequestHandler = (request: HMSRoleChangeRequest) => {
-      setRoleChangeRequest({
-        requestedBy: request?.requestedBy?.name,
-        suggestedRole: request?.suggestedRole?.name,
+    const changeRoleRequestHandler = async (request: HMSRoleChangeRequest) => {
+      taskRef.current = InteractionManager.runAfterInteractions(() => {
+        dispatch(setRoleChangeRequest(request));
+        callback?.(request);
       });
-      callback?.(request);
     };
 
     hmsInstance.addEventListener(
@@ -730,13 +1006,12 @@ export const useHMSRoleChangeRequest = (
     );
 
     return () => {
+      taskRef.current?.cancel();
       hmsInstance.removeEventListener(
         HMSUpdateListenerActions.ON_ROLE_CHANGE_REQUEST
       );
     };
   }, [...(deps || []), hmsInstance]);
-
-  return roleChangeRequest;
 };
 
 type SessionStoreListeners = Array<{ remove: () => void }>;
@@ -762,7 +1037,7 @@ export const useHMSSessionStoreListeners = (
           dispatch(saveUserData({ spotlightTrackId: id }));
           // Scroll to start of the list
           gridViewRef.current
-            ?.getFlatlistRef()
+            ?.getRegularTilesFlatlistRef()
             .current?.scrollToOffset({ animated: true, offset: 0 });
         };
 
@@ -917,10 +1192,31 @@ export const useHMSSessionStore = () => {
 export const useHMSMessages = () => {
   const hmsInstance = useHMSInstance();
   const dispatch = useDispatch();
+  const canChangeRole = useSelector(
+    (state: RootState) =>
+      state.hmsStates.localPeer?.role?.permissions?.changeRole
+  );
+  const canShowChat = useHMSConferencingScreenConfig(
+    (conferencingScreenConfig) => !!conferencingScreenConfig?.elements?.chat
+  );
 
   useEffect(() => {
     const onMessageListener = (message: HMSMessage) => {
-      dispatch(addMessage(message));
+      if (message.type === NotificationTypes.ROLE_CHANGE_DECLINED) {
+        if (canChangeRole) {
+          dispatch(
+            addNotification({
+              id: `${message.sender?.peerID}-${NotificationTypes.ROLE_CHANGE_DECLINED}`,
+              type: NotificationTypes.ROLE_CHANGE_DECLINED,
+              peer: message.sender!,
+            })
+          );
+        }
+      } else if (message.type === 'EMOJI_REACTION') {
+        console.log('Ignoring Emoji Reaction Message: ', message);
+      } else if (canShowChat) {
+        dispatch(addMessage(message));
+      }
     };
 
     hmsInstance.addEventListener(
@@ -932,12 +1228,38 @@ export const useHMSMessages = () => {
       // TODO: Remove this listener when user leaves, removed or room is ended
       hmsInstance.removeEventListener(HMSUpdateListenerActions.ON_MESSAGE);
     };
+  }, [canChangeRole, canShowChat, hmsInstance]);
+};
+
+export const useHMSReconnection = () => {
+  const dispatch = useDispatch();
+  const hmsInstance = useHMSInstance();
+
+  useEffect(() => {
+    let mounted = true;
+
+    hmsInstance.addEventListener(HMSUpdateListenerActions.RECONNECTING, () => {
+      if (mounted) {
+        dispatch(setReconnecting(true));
+      }
+    });
+    hmsInstance.addEventListener(HMSUpdateListenerActions.RECONNECTED, () => {
+      if (mounted) {
+        dispatch(setReconnecting(false));
+      }
+    });
+
+    return () => {
+      mounted = false;
+      hmsInstance.removeEventListener(HMSUpdateListenerActions.RECONNECTING);
+      hmsInstance.removeEventListener(HMSUpdateListenerActions.RECONNECTED);
+    };
   }, [hmsInstance]);
 };
 
 export const useHMSPIPRoomLeave = () => {
   const hmsInstance = useHMSInstance();
-  const { destroy } = useLeaveMethods();
+  const { destroy } = useLeaveMethods(true);
 
   useEffect(() => {
     const pipRoomLeaveHandler = () => {
@@ -957,7 +1279,7 @@ export const useHMSPIPRoomLeave = () => {
 
 export const useHMSRemovedFromRoomUpdate = () => {
   const hmsInstance = useHMSInstance();
-  const { destroy } = useLeaveMethods();
+  const { destroy } = useLeaveMethods(true);
 
   useEffect(() => {
     const removedFromRoomHandler = () => {
@@ -985,20 +1307,27 @@ export const usePIPListener = () => {
   );
 
   useEffect(() => {
-    if (isPipModeActive) {
-      const appStateListener = () => {
-        LayoutAnimation.configureNext(LayoutAnimation.Presets.easeInEaseOut);
-        dispatch(changePipModeStatus(PipModes.INACTIVE));
-      };
+    const pipModeChangedHandler = (data: {
+      isInPictureInPictureMode: boolean;
+    }) => {
+      dispatch(
+        changePipModeStatus(
+          data.isInPictureInPictureMode ? PipModes.ACTIVE : PipModes.INACTIVE
+        )
+      );
+    };
 
-      AppState.addEventListener('focus', appStateListener);
+    hmsInstance.addEventListener(
+      HMSPIPListenerActions.ON_PIP_MODE_CHANGED,
+      pipModeChangedHandler
+    );
 
-      return () => {
-        AppState.removeEventListener('focus', appStateListener);
-        dispatch(changePipModeStatus(PipModes.INACTIVE));
-      };
-    }
-  }, [isPipModeActive]);
+    return () => {
+      hmsInstance.removeEventListener(
+        HMSPIPListenerActions.ON_PIP_MODE_CHANGED
+      );
+    };
+  }, []);
 
   // Check if PIP is supported or not
   useEffect(() => {
@@ -1036,6 +1365,7 @@ export const useHMSActiveSpeakerUpdates = (
   active?: boolean
 ) => {
   const hmsInstance = useHMSInstance();
+  const dispatch = useDispatch();
   const reduxStore = useStore<RootState>();
   const isPortraitOrientation = useIsPortraitOrientation();
 
@@ -1045,6 +1375,8 @@ export const useHMSActiveSpeakerUpdates = (
     }
 
     const handleActiveSpeaker = (data: HMSSpeaker[]) => {
+      dispatch(setActiveSpeakers(data));
+
       const activePage = reduxStore.getState().app.gridViewActivePage;
       if (activePage !== 0) {
         return;
@@ -1192,12 +1524,9 @@ export const useShowLandscapeLayout = () => {
   const localPeerRoleName = useSelector(
     (state: RootState) => state.hmsStates.localPeer?.role?.name
   );
+  const isHLSViewer = useIsHLSViewer();
 
-  return (
-    isLandscapeOrientation &&
-    !!localPeerRoleName &&
-    localPeerRoleName.includes('hls-')
-  );
+  return isLandscapeOrientation && !!localPeerRoleName && isHLSViewer;
 };
 
 let hmsConfig: HMSConfig | null = null;
@@ -1227,7 +1556,7 @@ export const useHMSConfig = () => {
       const roomLayout = await getRoomLayout(
         hmsInstance,
         token,
-        'https://api-nonprod.100ms.live'
+        storeState.user.endPoints?.layout
       );
       dispatch(setLayoutConfig(roomLayout));
     } catch (error) {
@@ -1239,7 +1568,6 @@ export const useHMSConfig = () => {
       username: storeState.user.userName,
       captureNetworkQualityInPreview: true,
       endpoint: storeState.user.endPoints?.init,
-      // metadata: JSON.stringify({isHandRaised: true}), // To join with hand raised
     });
 
     return hmsConfig;
@@ -1259,137 +1587,296 @@ export const useHMSConfig = () => {
   return { clearConfig, updateConfig, getConfig };
 };
 
-export const useSafeDimensions = () => {
-  const { height, width } = useSafeAreaFrame();
-  const safeAreaInsets = useSafeAreaInsets();
+export const useShowChatAndParticipants = () => {
+  const dispatch = useDispatch();
+  const { modalVisibleType, handleModalVisibleType: setModalVisible } =
+    useModalType();
 
-  return {
-    safeWidth: width - safeAreaInsets.left - safeAreaInsets.right,
-    safeHeight: height - safeAreaInsets.top - safeAreaInsets.bottom,
-  };
-};
+  const overlayChatLayout = useHMSChatLayoutConfig(
+    (chatConfig) => chatConfig?.is_overlay
+  );
+  const canShowChat = useHMSConferencingScreenConfig(
+    (conferencingScreenConfig) => !!conferencingScreenConfig?.elements?.chat
+  );
+  const canShowParticipants = useHMSConferencingScreenConfig(
+    (conferencingScreenConfig) =>
+      !!conferencingScreenConfig?.elements?.participant_list
+  );
 
-export const useShowChat = (): [
-  'none' | 'inset' | 'modal',
-  (show: boolean) => void,
-] => {
-  const dispatch = useDispatch();
-  const isHLSViewer = useIsHLSViewer();
-  const showChatView = useSelector(
+  // state for inset chat view
+  const overlayChatVisible = useSelector(
     (state: RootState) => state.chatWindow.showChatView
   );
-  const hlsAspectRatio = useSelector(
-    (state: RootState) => state.app.hlsAspectRatio
-  );
-  const chatVisible: 'none' | 'inset' | 'modal' = useMemo(() => {
-    if (!showChatView) return 'none';
 
-    if (isHLSViewer && ['16:9', '4:3'].includes(hlsAspectRatio.id))
-      return 'inset';
+  const modalVisible = modalVisibleType === ModalTypes.CHAT_AND_PARTICIPANTS;
 
-    // TODO: handle case when type modal is selected, but chat modal is not shown because aspect ration modal was just closed
-    return 'modal';
-  }, [showChatView, hlsAspectRatio.id, isHLSViewer]);
+  const show = useCallback(
+    (view: 'chat' | 'participants') => {
+      // Handle Showing Chat View/Modal
+      if (view === 'chat') {
+        if (!canShowChat) return;
 
-  const isChatVisibleInsetType = chatVisible === 'inset';
+        if (overlayChatLayout) {
+          dispatch({ type: 'SET_SHOW_CHAT_VIEW', showChatView: true });
+        } else {
+          batch(() => {
+            dispatch({ type: 'SET_SHOW_CHAT_VIEW', showChatView: false });
+            dispatch(setActiveChatBottomSheetTab('Chat'));
+          });
+          setModalVisible(ModalTypes.CHAT_AND_PARTICIPANTS);
+        }
+      }
+      // Handle Showing Participant
+      else if (canShowParticipants) {
+        dispatch(setActiveChatBottomSheetTab('Participants'));
+        setModalVisible(ModalTypes.CHAT_AND_PARTICIPANTS);
+      }
+    },
+    [overlayChatLayout, canShowChat, canShowParticipants, setModalVisible]
+  );
 
-  const showChat = useCallback(
-    (show: boolean) => {
-      if (isChatVisibleInsetType) {
-        LayoutAnimation.configureNext(LayoutAnimation.Presets.easeInEaseOut);
+  const hide = useCallback(
+    (view: 'chat_overlay' | 'modal') => {
+      if (view === 'chat_overlay') {
+        dispatch({ type: 'SET_SHOW_CHAT_VIEW', showChatView: false });
+      } else {
+        setModalVisible(ModalTypes.DEFAULT);
       }
-      dispatch({ type: 'SET_SHOW_CHAT_VIEW', showChatView: show });
     },
-    [isChatVisibleInsetType]
+    [overlayChatLayout, setModalVisible]
   );
 
-  return [chatVisible, showChat];
+  return {
+    overlayChatVisible,
+    modalVisible,
+    overlayChatLayout,
+    canShowChat,
+    canShowParticipants,
+    show,
+    hide,
+  };
 };
 
 export const usePortraitChatViewVisible = () => {
-  const [chatVisible] = useShowChat();
+  const { overlayChatVisible } = useShowChatAndParticipants();
   const pipModeNotActive = useSelector(
     (state: RootState) => state.app.pipModeStatus !== PipModes.ACTIVE
   );
   const isPortraitOrientation = useIsPortraitOrientation();
 
-  return pipModeNotActive && isPortraitOrientation && chatVisible === 'inset';
+  return pipModeNotActive && isPortraitOrientation && overlayChatVisible;
 };
 
 export const useLandscapeChatViewVisible = () => {
-  const [chatVisible] = useShowChat();
+  const { overlayChatVisible } = useShowChatAndParticipants();
   const pipModeNotActive = useSelector(
     (state: RootState) => state.app.pipModeStatus !== PipModes.ACTIVE
   );
   const isLandscapeOrientation = useIsLandscapeOrientation();
 
-  return pipModeNotActive && isLandscapeOrientation && chatVisible === 'inset';
+  return pipModeNotActive && isLandscapeOrientation && overlayChatVisible;
 };
 
-export const useFilteredParticipants = () => {
+export type ParticipantAccordianData = {
+  id: string;
+  label: string;
+  showViewAll: boolean;
+  data: (HMSPeer | HMSLocalPeer)[];
+};
+
+export const useOffStageParticipants = () => {
+  const dispatch = useDispatch();
   const hmsInstance = useHMSInstance();
-  const localPeer = useSelector(
-    (state: RootState) => state.hmsStates.localPeer
-  );
-  const [filter, setFilter] = useState('everyone');
-  const [participantsSearchInput, setParticipantsSearchInput] = useState('');
-  const [hmsPeers, setHmsPeers] = useState<(HMSLocalPeer | HMSRemotePeer)[]>(
-    localPeer ? [localPeer] : []
+  const offStageRoles = useHMSLayoutConfig(
+    (layoutConfig) =>
+      layoutConfig?.screens?.conferencing?.default?.elements?.on_stage_exp
+        ?.off_stage_roles || null
   );
 
-  const filteredPeerTrackNodes = useMemo(() => {
-    const newFilteredPeerTrackNodes = hmsPeers?.filter((peer) => {
-      if (
-        participantsSearchInput.length < 1 ||
-        peer.name.includes(participantsSearchInput) ||
-        peer.role?.name?.includes(participantsSearchInput)
-      ) {
-        return true;
-      }
-      return false;
-    });
+  const [participantsTotalCounts, setParticipantsTotalCounts] = useState<
+    Record<string, number>
+  >({});
 
-    if (filter === 'everyone') {
-      return newFilteredPeerTrackNodes;
-    }
+  useEffect(() => {
+    if (offStageRoles) {
+      let mounted = true;
 
-    if (filter === 'raised hand') {
-      return newFilteredPeerTrackNodes.filter((peer) => {
-        const parsedMetaData = parseMetadata(peer.metadata);
-        return parsedMetaData.isHandRaised === true;
-      });
+      const createIterator = async (forRole: string) => {
+        const iterator = hmsInstance.getPeerListIterator({
+          byRoleName: forRole,
+          limit: 10,
+        });
+        const participants = await iterator.next();
+        if (mounted) {
+          dispatch(replaceParticipantsList(participants, forRole));
+          setParticipantsTotalCounts((prev) => ({
+            ...prev,
+            [forRole]: iterator.totalCount,
+          }));
+        }
+      };
+
+      const createIteratorForRoles = () => {
+        offStageRoles.forEach((role) => {
+          createIterator(role);
+        });
+      };
+
+      createIteratorForRoles();
+
+      const intervalId = setInterval(() => {
+        createIteratorForRoles();
+      }, PeerListRefreshInterval);
+
+      return () => {
+        mounted = false;
+        clearInterval(intervalId);
+      };
     }
+  }, [offStageRoles]);
 
-    return newFilteredPeerTrackNodes.filter(
-      (peer) => peer.role?.name === filter
-    );
-  }, [participantsSearchInput, filter, hmsPeers]);
+  return participantsTotalCounts;
+};
 
-  useEffect(() => {
-    let ignore = false;
+export const useFilteredParticipants = (filterText: string) => {
+  const roles = useSelector((state: RootState) => state.hmsStates.roles);
+  const onStageRole = useHMSLayoutConfig(
+    (layoutConfig) =>
+      layoutConfig?.screens?.conferencing?.default?.elements?.on_stage_exp
+        ?.on_stage_role || null
+  );
+
+  const offStageParticipantsTotalCounts = useOffStageParticipants();
+
+  const formattedSearchText = filterText.trim().toLowerCase();
+
+  const groupedParticipants = useSelector(
+    (state: RootState) => state.hmsStates.groupedParticipants
+  );
+
+  const sortedRoles = useMemo(
+    () => {
+      return roles
+        .filter((role) => {
+          if (!role.name || role.name.startsWith('_')) {
+            return false;
+          }
+          return true;
+
+          // const list = groupedParticipants[role.name!];
+
+          // return list && list.length > 0;
+        })
+        .sort((a, b) => {
+          if (onStageRole) {
+            if (a.name === onStageRole && b.name === onStageRole) {
+              return 0;
+            }
+
+            if (a.name === onStageRole) {
+              return -1;
+            }
 
-    hmsInstance.getRemotePeers().then((peers) => {
-      if (localPeer) {
-        InteractionManager.runAfterInteractions(() => {
-          if (!ignore) {
-            setHmsPeers([localPeer, ...peers]);
+            if (b.name === onStageRole) {
+              return 1;
+            }
           }
+
+          const canAPublish: boolean =
+            (a.publishSettings?.allowed &&
+              a.publishSettings.allowed.length > 0) ??
+            false;
+          const canBPublish: boolean =
+            (b.publishSettings?.allowed &&
+              b.publishSettings.allowed.length > 0) ??
+            false;
+
+          if (canAPublish && canBPublish) {
+            return 0;
+          }
+
+          if (canAPublish) {
+            return -1;
+          }
+
+          return 1;
+        });
+    },
+    // [groupedParticipants, onStageRole, roles]
+    [onStageRole, roles]
+  );
+
+  const participantsAccordianData: ParticipantAccordianData[] = useMemo(() => {
+    const t = [];
+
+    const filteredHandRaisedPeers: (HMSPeer | HMSLocalPeer)[][] = [];
+
+    sortedRoles.forEach((role) => {
+      const list = groupedParticipants[role.name!];
+      const filteredList =
+        Array.isArray(list) && formattedSearchText.length > 0
+          ? list.filter((peer) =>
+              peer.name.toLowerCase().includes(formattedSearchText)
+            )
+          : list;
+
+      if (Array.isArray(filteredList) && filteredList.length > 0) {
+
+        filteredHandRaisedPeers.push(filteredList);
+        const offStageRoleTotalCount =
+          offStageParticipantsTotalCounts[role.name!];
+
+        const firstTen = filteredList.slice(0, 10);
+
+        t.push({
+          id: role.name!,
+          label: `${role.name!} (${
+            typeof offStageRoleTotalCount === 'number'
+              ? offStageRoleTotalCount
+              : filteredList.length
+          })`,
+          showViewAll:
+            typeof offStageRoleTotalCount === 'number' &&
+            formattedSearchText.length <= 0
+              ? offStageRoleTotalCount > 10
+              : filteredList.length > 10,
+          data: firstTen,
         });
       }
     });
 
-    return () => {
-      ignore = true;
-    };
-  }, [localPeer, hmsInstance]);
+    const handRaisedParticipants = filteredHandRaisedPeers
+      .flat()
+      .filter((participant) => participant.isHandRaised);
+
+    const firstTenHandRaisedParticipants = handRaisedParticipants.slice(0, 10);
+
+    if (handRaisedParticipants.length > 0) {
+      t.unshift({
+        id: 'hand-raised',
+        label: `Hand Raised (${handRaisedParticipants.length})`,
+        showViewAll: handRaisedParticipants.length > 10,
+        data: firstTenHandRaisedParticipants,
+      });
+    }
+
+    return t;
+  }, [
+    formattedSearchText,
+    groupedParticipants,
+    offStageParticipantsTotalCounts,
+    sortedRoles,
+  ]);
+
+  const [expandedGroup, setExpandedGroup] = useState<string | null>(
+    participantsAccordianData[0]?.id ?? null
+  );
 
   return {
-    allParticipants: hmsPeers,
-    filteredParticipants: filteredPeerTrackNodes,
-    selectedFilter: filter,
-    changeFilter: setFilter,
-    searchText: participantsSearchInput,
-    setSearchText: setParticipantsSearchInput,
+    data: participantsAccordianData,
+    formattedSearchText,
+    expandedGroup,
+    setExpandedGroup,
   };
 };
 
@@ -1399,15 +1886,15 @@ export const useShouldGoLive = () => {
   return shouldGoLive;
 };
 
-export const useLeaveMethods = () => {
+export const useLeaveMethods = (isUnmounted: boolean) => {
   const navigation = useContext(NavigationContext);
   const hmsInstance = useHMSInstance();
   const dispatch = useDispatch();
   const reduxStore = useStore<RootState>();
 
-  const destroy = useCallback(async () => {
+  const destroy = useCallback(() => {
     try {
-      const s = await hmsInstance.destroy();
+      const s = hmsInstance.destroy();
       console.log('Destroy Success: ', s);
       // TODOS:
       // - If show `Meeting_Ended` is true, show Meeting screen by setting state to MEETING_ENDED
@@ -1434,11 +1921,10 @@ export const useLeaveMethods = () => {
       if (typeof onLeave === 'function') {
         onLeave();
         dispatch(clearStore());
-      } else if (navigation && navigation.canGoBack()) {
+      } else if (navigation && navigation.canGoBack() && !isUnmounted) {
         navigation.goBack();
         dispatch(clearStore());
       } else {
-        // TODO: call onLeave Callback if provided
         // Otherwise default action is to show "Meeting Ended" screen
         dispatch(clearStore()); // TODO: We need different clearStore for MeetingEnded
         dispatch(changeMeetingState(MeetingState.MEETING_ENDED));
@@ -1454,16 +1940,24 @@ export const useLeaveMethods = () => {
     }
   }, [hmsInstance]);
 
-  const leave = useCallback(async () => {
-    try {
-      const d = await hmsInstance.leave();
-      console.log('Leave Success: ', d);
-      await destroy();
-    } catch (e) {
-      console.log(`Leave Room Error: ${e}`);
-      Toast.showWithGravity(`Leave Room Error: ${e}`, Toast.LONG, Toast.TOP);
-    }
-  }, [destroy, hmsInstance]);
+  const leave = useCallback(
+    async (shouldEndStream: boolean = false) => {
+      if (shouldEndStream) {
+        hmsInstance.stopHLSStreaming().catch((error) => {
+          console.log('Stop HLS Streaming Error: ', error);
+        });
+      }
+      try {
+        const d = await hmsInstance.leave();
+        console.log('Leave Success: ', d);
+        await destroy();
+      } catch (e) {
+        console.log(`Leave Room Error: ${e}`);
+        Toast.showWithGravity(`Leave Room Error: ${e}`, Toast.LONG, Toast.TOP);
+      }
+    },
+    [destroy, hmsInstance]
+  );
 
   const goToPreview = useCallback(async () => {
     try {
@@ -1492,21 +1986,32 @@ export const useLeaveMethods = () => {
   return { destroy, leave, endRoom, goToPreview };
 };
 
-export const useHMSLayoutConfig = () => {
-  return useSelector((state: RootState) => state.hmsStates.layoutConfig);
+// Returns layout config as it is returned from server
+export const useHMSLayoutConfig = <Selected = unknown>(
+  selector: (layoutConfig: Layout | null) => Selected,
+  equalityFn?: (left: Selected, right: Selected) => boolean
+): Selected => {
+  return useSelector((state: RootState) => {
+    return selector(
+      selectLayoutConfigForRole(
+        state.hmsStates.layoutConfig,
+        state.hmsStates.localPeer?.role || null
+      )
+    );
+  }, equalityFn);
 };
 
-export const useHMSRoomTheme = <S>(
-  selector?: (theme: Required<Theme>) => S
-): Required<Theme> | S => {
-  return useSelector((state: RootState) => {
-    const layoutConfig = state.hmsStates.layoutConfig;
+type ThemeWithPalette = Theme & { palette: ColorPalette };
 
-    const roomTheme = layoutConfig?.themes.find((theme) => theme.default);
+export const useHMSRoomTheme = <S>(
+  selector?: (theme: ThemeWithPalette) => S
+): ThemeWithPalette | S => {
+  return useHMSLayoutConfig((layoutConfig) => {
+    const roomTheme = layoutConfig?.themes?.find((theme) => theme.default);
 
-    const defaultTheme: Required<Theme> = roomTheme
+    const defaultTheme: ThemeWithPalette = roomTheme
       ? roomTheme.palette
-        ? (roomTheme as Required<Theme>)
+        ? (roomTheme as ThemeWithPalette)
         : { ...roomTheme, palette: DEFAULT_THEME.palette }
       : DEFAULT_THEME;
 
@@ -1522,10 +2027,8 @@ export const useHMSRoomColorPalette = (): ColorPalette => {
   return useHMSRoomTheme((theme) => theme.palette) as ColorPalette;
 };
 
-export const useHMSRoomTypography = (): Typography => {
-  return useSelector((state: RootState) => {
-    const layoutConfig = state.hmsStates.layoutConfig;
-
+export const useHMSRoomTypography = (): Required<Typography> => {
+  return useHMSLayoutConfig((layoutConfig) => {
     const typography = layoutConfig?.typography;
 
     if (!typography) {
@@ -1539,17 +2042,20 @@ export const useHMSRoomTypography = (): Typography => {
       };
     }
 
-    return typography;
+    // formatting font family name
+    typography.font_family = typography.font_family.replace(/ /g, '');
+
+    return typography as Required<Typography>;
   }, shallowEqual);
 };
 
 export const useHMSRoomStyleSheet = <
   T extends { [key: string]: StyleProp<ViewStyle | TextStyle | ImageStyle> },
 >(
-  updater: (theme: Required<Theme>, typography: Required<Typography>) => T,
+  updater: (theme: ThemeWithPalette, typography: Required<Typography>) => T,
   deps: DependencyList = []
 ): T => {
-  const theme = useHMSRoomTheme<Required<Theme>>();
+  const theme = useHMSRoomTheme<ThemeWithPalette>();
   const typography = useHMSRoomTypography();
 
   return useMemo(
@@ -1561,7 +2067,7 @@ export const useHMSRoomStyleSheet = <
 export const useHMSRoomStyle = <
   T extends StyleProp<ViewStyle | TextStyle | ImageStyle>,
 >(
-  updater: (theme: Required<Theme>, typography: Required<Typography>) => T,
+  updater: (theme: ThemeWithPalette, typography: Required<Typography>) => T,
   deps: DependencyList = []
 ): T => {
   return useHMSRoomStyleSheet(
@@ -1571,3 +2077,115 @@ export const useHMSRoomStyle = <
     deps
   ).default;
 };
+
+export const useSendMessage = () => {
+  const hmsInstance = useHMSInstance();
+  const dispatch = useDispatch();
+  const reduxStore = useStore<RootState>();
+
+  const message = useSelector(
+    (state: RootState) => state.chatWindow.typedMessage
+  );
+
+  const setMessage = useCallback((text: string) => {
+    dispatch({ type: 'SET_TYPED_MESSAGE', typedMessage: text });
+  }, []);
+
+  const sendMessage = useCallback(async () => {
+    const chatWindowState = reduxStore.getState().chatWindow;
+
+    const message = chatWindowState.typedMessage;
+    const sendingTo = chatWindowState.sendTo as
+      | HMSRole
+      | HMSRemotePeer
+      | typeof ChatBroadcastFilter;
+
+    if (message.length <= 0) return;
+
+    const hmsMessageRecipient = new HMSMessageRecipient({
+      recipientType:
+        'publishSettings' in sendingTo
+          ? HMSMessageRecipientType.ROLES
+          : 'peerID' in sendingTo
+          ? HMSMessageRecipientType.PEER
+          : HMSMessageRecipientType.BROADCAST,
+      recipientPeer: 'peerID' in sendingTo ? sendingTo : undefined,
+      recipientRoles: 'publishSettings' in sendingTo ? [sendingTo] : undefined,
+    });
+
+    // Saving reference of `message` state to local variable
+    // to use the typed message after clearing state
+    const messageText = message;
+
+    dispatch({ type: 'SET_TYPED_MESSAGE', typedMessage: '' });
+
+    const handleMessageID = ({
+      messageId,
+    }: {
+      messageId: string | undefined;
+    }) => {
+      const localPeer = reduxStore.getState().hmsStates.localPeer;
+
+      if (messageId) {
+        Keyboard.dismiss();
+        const localMessage = new HMSMessage({
+          messageId: messageId,
+          message: messageText,
+          type: 'chat',
+          time: new Date(),
+          sender: localPeer || undefined,
+          recipient: hmsMessageRecipient,
+        });
+        dispatch(addMessage(localMessage));
+      }
+    };
+
+    try {
+      let result: { messageId: string | undefined };
+      if ('publishSettings' in sendingTo) {
+        result = await hmsInstance.sendGroupMessage(messageText, [sendingTo]);
+      } else if ('peerID' in sendingTo) {
+        result = await hmsInstance.sendDirectMessage(messageText, sendingTo);
+      } else {
+        result = await hmsInstance.sendBroadcastMessage(messageText);
+      }
+      handleMessageID(result);
+
+      return Promise.resolve(result);
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  }, []);
+
+  return {
+    message,
+    setMessage,
+    sendMessage,
+  };
+};
+
+export const useHMSChatLayoutConfig = <Selected = unknown>(
+  selector: (chatConfig: ChatConfig | null) => Selected,
+  equalityFn?: (left: Selected, right: Selected) => boolean
+): Selected => {
+  return useHMSLayoutConfig((layoutConfig) => {
+    const chatConfig = selectChatLayoutConfig(layoutConfig);
+    return selector(chatConfig);
+  }, equalityFn);
+};
+
+export const useHMSConferencingScreenConfig = <Selected = unknown>(
+  selector: (
+    conferencingScreenConfig:
+      | DefaultConferencingScreen
+      | HLSLiveStreamingScreen
+      | null
+  ) => Selected,
+  equalityFn?: (left: Selected, right: Selected) => boolean
+): Selected => {
+  return useHMSLayoutConfig((layoutConfig) => {
+    const conferencingScreenConfig =
+      selectConferencingScreenConfig(layoutConfig);
+    return selector(conferencingScreenConfig);
+  }, equalityFn);
+};