@100mslive/react-native-room-kit 0.0.1

package/src/index.ts

@@ -0,0 +1 @@
+export * from './HMSPrebuilt';

package/src/peerTrackNodeUtils.tsx

@@ -0,0 +1,114 @@
+import {
+  HMSPeer,
+  HMSTrack,
+  HMSTrackSource,
+  HMSTrackType,
+} from '@100mslive/react-native-hms';
+
+import type { PeerTrackNode } from './utils/types';
+
+export const degradeOrRestorePeerTrackNodes = (
+  peerTrackNodes: PeerTrackNode[],
+  peer: HMSPeer,
+  track: HMSTrack,
+  isDegraded: boolean
+): PeerTrackNode[] => {
+  const uniqueId =
+    peer.peerID +
+    (track.type === HMSTrackType.VIDEO
+      ? track?.source || HMSTrackSource.REGULAR
+      : HMSTrackSource.REGULAR);
+
+  return peerTrackNodes.map((peerTrackNode) => {
+    if (peerTrackNode.id !== uniqueId) {
+      return peerTrackNode;
+    }
+    return {
+      ...peerTrackNode,
+      isDegraded,
+    };
+  });
+};
+
+export const removePeerTrackNodes = (
+  peerTrackNodes: PeerTrackNode[],
+  peerToRemove: HMSPeer
+): PeerTrackNode[] => {
+  return peerTrackNodes.filter(
+    (peerTrackNode) => peerTrackNode.peer.peerID !== peerToRemove.peerID
+  );
+};
+
+export const removePeerTrackNodesWithTrack = (
+  peerTrackNodes: PeerTrackNode[],
+  peer: HMSPeer,
+  track: HMSTrack
+): PeerTrackNode[] => {
+  const uniqueId =
+    peer.peerID +
+    (track.source === undefined ? HMSTrackSource.REGULAR : track.source);
+  return peerTrackNodes.filter(
+    (peerTrackNode) => peerTrackNode.id !== uniqueId
+  );
+};
+
+export const replacePeerTrackNodes = (
+  peerTrackNodes: PeerTrackNode[],
+  peerToReplace: HMSPeer
+): PeerTrackNode[] => {
+  return peerTrackNodes.map((peerTrackNode) => {
+    if (peerTrackNode.peer.peerID !== peerToReplace.peerID) {
+      return peerTrackNode;
+    }
+    return {
+      ...peerTrackNode,
+      peer: peerToReplace,
+    };
+  });
+};
+
+export const replacePeerTrackNodesWithTrack = (
+  peerTrackNodes: PeerTrackNode[],
+  peer: HMSPeer,
+  track: HMSTrack
+): PeerTrackNode[] => {
+  const uniqueId = peer.peerID + (track.source ?? HMSTrackSource.REGULAR);
+  return peerTrackNodes.map((peerTrackNode) => {
+    if (peerTrackNode.id !== uniqueId) {
+      return peerTrackNode;
+    }
+    return {
+      ...peerTrackNode,
+      peer,
+      track,
+    };
+  });
+};
+
+export const peerTrackNodeExistForPeer = (
+  peerTrackNodes: PeerTrackNode[],
+  peer: HMSPeer
+): boolean => {
+  return (
+    peerTrackNodes.findIndex(
+      (peerTrackNode) => peerTrackNode.peer.peerID === peer.peerID
+    ) >= 0
+  );
+};
+
+export const peerTrackNodeExistForPeerAndTrack = (
+  peerTrackNodes: PeerTrackNode[],
+  peer: HMSPeer,
+  track: HMSTrack
+): boolean => {
+  const uniqueId =
+    peer.peerID +
+    (track.type === HMSTrackType.VIDEO
+      ? track?.source || HMSTrackSource.REGULAR
+      : HMSTrackSource.REGULAR);
+  return (
+    peerTrackNodes.findIndex(
+      (peerTrackNode) => peerTrackNode.id === uniqueId
+    ) >= 0
+  );
+};

package/src/redux/actionTypes.ts

@@ -0,0 +1,85 @@
+const createRequests = (base: String) => {
+  const statusObject = {
+    REQUEST: `${base}_REQUEST`,
+    SUCCESS: `${base}_SUCCESS`,
+    FAILED: `${base}_FAILED`,
+  };
+  return statusObject;
+};
+
+const ADD_MESSAGE = createRequests('ADD_MESSAGE');
+
+const ADD_PINNED_MESSAGE = createRequests('ADD_PINNED_MESSAGE');
+
+const CLEAR_MESSAGE_DATA = createRequests('CLEAR_MESSAGE_DATA');
+
+const SET_PEER_STATE = 'SET_PEER_STATE';
+
+const CLEAR_PEER_DATA = createRequests('CLEAR_PEER_DATA');
+
+const SAVE_USER_DATA = createRequests('SAVE_USER_DATA');
+
+const SET_HMS_INSTANCE = 'SET_HMS_INSTANCE';
+
+const CLEAR_HMS_INSTANCE = 'CLEAR_HMS_INSTANCE';
+
+const CHANGE_PIP_MODE_STATUS = 'CHANGE_PIP_MODE_STATUS';
+
+const RESET_JOIN_CONFIG = 'RESET_JOIN_CONFIG';
+
+const CHANGE_MIRROR_CAMERA = 'CHANGE_MIRROR_CAMERA';
+
+const CHANGE_SHOW_STATS = 'CHANGE_SHOW_STATS'; // RTC Stats
+
+const CHANGE_SHOW_HLS_STATS = 'CHANGE_SHOW_HLS_STATS'; // HLS Stats
+
+const CHANGE_ENABLE_HLS_PLAYER_CONTROLS = 'CHANGE_ENABLE_HLS_PLAYER_CONTROLS'; // HLS Stats
+
+const CHANGE_SHOW_CUSTOM_HLS_PLAYER_CONTROLS =
+  'CHANGE_SHOW_CUSTOM_HLS_PLAYER_CONTROLS';
+
+const CHANGE_AUTO_SIMULCAST = 'CHANGE_AUTO_SIMULCAST';
+
+const SET_RTC_STATS = 'SET_RTC_STATS';
+
+const CHANGE_HLS_ASPECT_RATIO = 'CHANGE_HLS_ASPECT_RATIO';
+
+const SET_MODAL_TYPE = 'SET_MODAL_TYPE';
+
+const SET_PEER_TO_UPDATE = 'SET_PEER_TO_UPDATE';
+
+export default {
+  ADD_PINNED_MESSAGE,
+  ADD_MESSAGE,
+  CLEAR_MESSAGE_DATA,
+  CLEAR_PEER_DATA,
+  SET_PEER_STATE,
+  SAVE_USER_DATA,
+  SET_HMS_INSTANCE,
+  CLEAR_HMS_INSTANCE,
+  CHANGE_PIP_MODE_STATUS,
+  RESET_JOIN_CONFIG,
+  CHANGE_MIRROR_CAMERA,
+  CHANGE_SHOW_STATS,
+  CHANGE_AUTO_SIMULCAST,
+  CHANGE_SHOW_HLS_STATS,
+  CHANGE_ENABLE_HLS_PLAYER_CONTROLS,
+  CHANGE_SHOW_CUSTOM_HLS_PLAYER_CONTROLS,
+  CHANGE_HLS_ASPECT_RATIO,
+  SET_RTC_STATS,
+  SET_MODAL_TYPE,
+  SET_PEER_TO_UPDATE,
+};
+
+export enum HmsStateActionTypes {
+  CLEAR_STATES = 'CLEAR_STATES',
+  SET_PREBUILT_DATA = 'SET_PREBUILT_DATA',
+  SET_ROOM_STATE = 'SET_ROOM_STATE',
+  SET_LOCAL_PEER_STATE = 'SET_LOCAL_PEER_STATE',
+  SET_ROLES_STATE = 'SET_ROLES_STATE',
+  SET_IS_LOCAL_AUDIO_MUTED_STATE = 'SET_IS_LOCAL_AUDIO_MUTED_STATE',
+  SET_IS_LOCAL_VIDEO_MUTED_STATE = 'SET_IS_LOCAL_VIDEO_MUTED_STATE',
+  SET_IS_LOCAL_SCREEN_SHARED_STATE = 'SET_IS_LOCAL_SCREEN_SHARED_STATE',
+  SET_ROOM_LOCALLY_MUTED = 'SET_ROOM_LOCALLY_MUTED',
+  SET_USER_NAME = 'SET_USER_NAME',
+}

package/src/redux/actions/index.ts

@@ -0,0 +1,196 @@
+import { HMSRoom, HMSLocalPeer } from '@100mslive/react-native-hms';
+import type {
+  HMSLocalAudioStats,
+  HMSLocalVideoStats,
+  HMSMessage,
+  HMSPeer,
+  HMSRemoteAudioStats,
+  HMSRemoteVideoStats,
+  HMSRole,
+  HMSSDK,
+  HMSSessionStore,
+} from '@100mslive/react-native-hms';
+import type {
+  IOSBuildConfig,
+  ModalTypes,
+  PeerTrackNode,
+  PipModes,
+} from '../../utils/types';
+import actionTypes, { HmsStateActionTypes } from '../actionTypes';
+
+export const setPrebuiltData = (data: {
+  roomCode: string;
+  options?: {
+    userName?: string;
+    userId?: string;
+    debugMode?: boolean;
+    endPoints?: {
+      init: string;
+      token: string;
+    };
+    ios?: IOSBuildConfig;
+  };
+}) => ({
+  type: HmsStateActionTypes.SET_PREBUILT_DATA,
+  payload: data,
+});
+
+export const clearStore = () => ({
+  type: HmsStateActionTypes.CLEAR_STATES,
+});
+
+export const setRoomLocallyMuted = (roomLocallyMuted: boolean) => ({
+  type: HmsStateActionTypes.SET_ROOM_LOCALLY_MUTED,
+  roomLocallyMuted,
+});
+
+export const setIsLocalVideoMutedState = (
+  isLocalVideoMuted: boolean | undefined
+) => ({
+  type: HmsStateActionTypes.SET_IS_LOCAL_VIDEO_MUTED_STATE,
+  isLocalVideoMuted,
+});
+
+export const setIsLocalAudioMutedState = (
+  isLocalAudioMuted: boolean | undefined
+) => ({
+  type: HmsStateActionTypes.SET_IS_LOCAL_AUDIO_MUTED_STATE,
+  isLocalAudioMuted,
+});
+
+export const setIsLocalScreenSharedState = (
+  isLocalScreenShared: boolean | undefined
+) => ({
+  type: HmsStateActionTypes.SET_IS_LOCAL_SCREEN_SHARED_STATE,
+  isLocalScreenShared,
+});
+
+export const setHMSRoleState = (roles: HMSRole[]) => ({
+  type: HmsStateActionTypes.SET_ROLES_STATE,
+  roles,
+});
+
+export const setHMSRoomState = (room: HMSRoom | null) => ({
+  type: HmsStateActionTypes.SET_ROOM_STATE,
+  room,
+});
+
+export const setHMSLocalPeerState = (localPeer: HMSLocalPeer | null) => ({
+  type: HmsStateActionTypes.SET_LOCAL_PEER_STATE,
+  localPeer,
+});
+
+export const setHMSInstance = (hmsInstance: HMSSDK) => ({
+  type: actionTypes.SET_HMS_INSTANCE,
+  payload: { hmsInstance },
+});
+
+export const addMessage = (data: HMSMessage) => ({
+  type: actionTypes.ADD_MESSAGE.REQUEST,
+  payload: data,
+});
+
+export const addPinnedMessage = (data: string | null | undefined) => ({
+  type: actionTypes.ADD_PINNED_MESSAGE.REQUEST,
+  payload: data,
+});
+
+export const clearMessageData = () => ({
+  type: actionTypes.CLEAR_MESSAGE_DATA.REQUEST,
+});
+
+export const setPeerState = (data: { peerState: PeerTrackNode[] }) => ({
+  type: actionTypes.SET_PEER_STATE,
+  payload: data,
+});
+
+export const changePipModeStatus = (pipModeStatus: PipModes) => ({
+  type: actionTypes.CHANGE_PIP_MODE_STATUS,
+  payload: { pipModeStatus },
+});
+
+export const clearPeerData = () => ({
+  type: actionTypes.CLEAR_PEER_DATA.REQUEST,
+});
+
+export const saveUserData = (data: {
+  userName?: String;
+  roomID?: String;
+  roomCode?: String;
+  hmsInstance?: HMSSDK;
+  hmsSessionStore?: HMSSessionStore;
+  spotlightTrackId?: string | null;
+  isHLSFlow?: boolean;
+  roles?: HMSRole[];
+}) => ({
+  type: actionTypes.SAVE_USER_DATA.REQUEST,
+  payload: data,
+});
+
+export const clearHmsReference = () => ({
+  type: actionTypes.CLEAR_HMS_INSTANCE,
+});
+
+export const resetJoinConfig = () => ({ type: actionTypes.RESET_JOIN_CONFIG });
+
+export const changeMirrorCamera = (value: boolean) => ({
+  type: actionTypes.CHANGE_MIRROR_CAMERA,
+  payload: { mirrorCamera: value },
+});
+
+export const changeShowStats = (value: boolean) => ({
+  type: actionTypes.CHANGE_SHOW_STATS,
+  payload: { showStats: value },
+});
+
+export const changeShowHLSStats = (value: boolean) => ({
+  type: actionTypes.CHANGE_SHOW_HLS_STATS,
+  payload: { showHLSStats: value },
+});
+
+export const changeShowCustomHLSPlayerControls = (value: boolean) => ({
+  type: actionTypes.CHANGE_SHOW_CUSTOM_HLS_PLAYER_CONTROLS,
+  payload: { showCustomHLSPlayerControls: value },
+});
+
+export const changeEnableHLSPlayerControls = (value: boolean) => ({
+  type: actionTypes.CHANGE_ENABLE_HLS_PLAYER_CONTROLS,
+  payload: { enableHLSPlayerControls: value },
+});
+
+export const changeAutoSimulcast = (value: boolean) => ({
+  type: actionTypes.CHANGE_AUTO_SIMULCAST,
+  payload: { autoSimulcast: value },
+});
+
+export const setRTCStats = (
+  trackId: string,
+  stats:
+    | HMSLocalAudioStats
+    | HMSLocalVideoStats[]
+    | HMSRemoteAudioStats
+    | HMSRemoteVideoStats
+) => ({
+  type: actionTypes.SET_RTC_STATS,
+  payload: { trackId, stats },
+});
+
+export const changeHLSAspectRatio = (value: { value: number; id: string }) => ({
+  type: actionTypes.CHANGE_HLS_ASPECT_RATIO,
+  payload: { hlsAspectRatio: value },
+});
+
+export const changeUsername = (userName: string) => ({
+  type: HmsStateActionTypes.SET_USER_NAME,
+  payload: { userName },
+});
+
+export const setModalType = (modalType: ModalTypes) => ({
+  type: actionTypes.SET_MODAL_TYPE,
+  payload: { modalType },
+});
+
+export const setPeerToUpdate = (peerToUpdate: HMSPeer) => ({
+  type: actionTypes.SET_PEER_TO_UPDATE,
+  payload: { peerToUpdate },
+});

package/src/redux/index.ts

@@ -0,0 +1,8 @@
+import { createStore } from 'redux';
+
+import rootReducer from './reducers/index';
+
+export const store = createStore(rootReducer);
+
+export type RootState = ReturnType<typeof store.getState>;
+export type AppDispatch = typeof store.dispatch;

package/src/redux/reducers/appState.ts

@@ -0,0 +1,143 @@
+import ActionTypes, { HmsStateActionTypes } from '../actionTypes';
+import type { PeerTrackNode } from '../../utils/types';
+import { SUPPORTED_ASPECT_RATIOS, ModalTypes } from '../../utils/types';
+import { PipModes } from '../../utils/types';
+import {
+  HMSLocalAudioStats,
+  HMSLocalVideoStats,
+  HMSPeer,
+  HMSRemoteAudioStats,
+  HMSRemoteVideoStats,
+} from '@100mslive/react-native-hms';
+
+type ActionType = {
+  payload: { [key: string]: any };
+  type: String;
+};
+
+type IntialStateType = {
+  peerState: PeerTrackNode[];
+  pipModeStatus: PipModes;
+  rtcStats: Record<
+    string,
+    | undefined
+    | HMSLocalAudioStats
+    | HMSLocalVideoStats[]
+    | HMSRemoteAudioStats
+    | HMSRemoteVideoStats
+  >;
+  hlsAspectRatio: { value: number; id: string };
+  joinConfig: {
+    mirrorCamera: boolean;
+    autoSimulcast: boolean;
+    showStats: boolean;
+    showHLSStats: boolean;
+    enableHLSPlayerControls: boolean;
+    showCustomHLSPlayerControls: boolean;
+  };
+  modalType: ModalTypes;
+  peerToUpdate: HMSPeer | null;
+};
+
+const INITIAL_STATE: IntialStateType = {
+  peerState: [],
+  pipModeStatus: PipModes.INACTIVE,
+  rtcStats: {},
+  hlsAspectRatio: SUPPORTED_ASPECT_RATIOS[0]!, // This is static array, and should always have 0th item
+  joinConfig: {
+    mirrorCamera: true,
+    autoSimulcast: true,
+    showStats: false,
+    showHLSStats: false,
+    enableHLSPlayerControls: true,
+    showCustomHLSPlayerControls: false,
+  },
+  modalType: ModalTypes.DEFAULT,
+  peerToUpdate: null,
+};
+
+const appReducer = (
+  state = INITIAL_STATE,
+  action: ActionType
+): IntialStateType => {
+  switch (action.type) {
+    case ActionTypes.CHANGE_PIP_MODE_STATUS:
+      return { ...state, pipModeStatus: action.payload.pipModeStatus };
+    case ActionTypes.SET_PEER_STATE:
+      return { ...state, ...action.payload };
+    case ActionTypes.CLEAR_PEER_DATA.REQUEST:
+      return { ...state, peerState: [] };
+    case ActionTypes.CHANGE_HLS_ASPECT_RATIO:
+      return { ...state, hlsAspectRatio: action.payload.hlsAspectRatio };
+    case ActionTypes.SET_MODAL_TYPE:
+      return { ...state, modalType: action.payload.modalType };
+    case ActionTypes.SET_PEER_TO_UPDATE:
+      return { ...state, peerToUpdate: action.payload.peerToUpdate };
+    case ActionTypes.RESET_JOIN_CONFIG:
+      return { ...state, joinConfig: INITIAL_STATE.joinConfig };
+    case ActionTypes.CHANGE_MIRROR_CAMERA:
+      return {
+        ...state,
+        joinConfig: {
+          ...state.joinConfig,
+          mirrorCamera: action.payload.mirrorCamera ?? true,
+        },
+      };
+    case ActionTypes.CHANGE_SHOW_STATS:
+      return {
+        ...state,
+        joinConfig: {
+          ...state.joinConfig,
+          showStats: action.payload.showStats ?? false,
+        },
+      };
+    case ActionTypes.CHANGE_SHOW_HLS_STATS:
+      return {
+        ...state,
+        joinConfig: {
+          ...state.joinConfig,
+          showHLSStats: action.payload.showHLSStats ?? false,
+        },
+      };
+    case ActionTypes.CHANGE_ENABLE_HLS_PLAYER_CONTROLS:
+      return {
+        ...state,
+        joinConfig: {
+          ...state.joinConfig,
+          enableHLSPlayerControls:
+            action.payload.enableHLSPlayerControls ?? true,
+        },
+      };
+    case ActionTypes.CHANGE_SHOW_CUSTOM_HLS_PLAYER_CONTROLS:
+      return {
+        ...state,
+        joinConfig: {
+          ...state.joinConfig,
+          showCustomHLSPlayerControls:
+            action.payload.showCustomHLSPlayerControls ?? false,
+        },
+      };
+    case ActionTypes.CHANGE_AUTO_SIMULCAST:
+      return {
+        ...state,
+        joinConfig: {
+          ...state.joinConfig,
+          autoSimulcast: action.payload.autoSimulcast ?? true,
+        },
+      };
+    case ActionTypes.SET_RTC_STATS:
+      return {
+        ...state,
+        rtcStats: {
+          ...state.rtcStats,
+          [action.payload.trackId]: action.payload.stats,
+        },
+      };
+    case HmsStateActionTypes.CLEAR_STATES:
+      return INITIAL_STATE;
+    default:
+      return state;
+  }
+};
+
+export default appReducer;

package/src/redux/reducers/chatWindow.ts

@@ -0,0 +1,35 @@
+import { HmsStateActionTypes } from '../actionTypes';
+
+const INITIAL_STATE = {
+  showChatView: false,
+  typedMessage: '',
+  sendTo: { name: 'everyone' },
+  sendToType: 'everyone', // 'everyone' | 'role' | 'direct'
+};
+
+const chatWindowReducer = (state = INITIAL_STATE, action: any): any => {
+  switch (action.type) {
+    case 'SET_SENDTO':
+      return {
+        ...state,
+        sendTo: action.sendTo,
+        sendToType: action.sendToType,
+      };
+    case 'SET_TYPED_MESSAGE':
+      return {
+        ...state,
+        typedMessage: action.typedMessage,
+      };
+    case 'SET_SHOW_CHAT_VIEW':
+      return {
+        ...state,
+        showChatView: action.showChatView,
+      };
+    case HmsStateActionTypes.CLEAR_STATES:
+      return INITIAL_STATE;
+    default:
+      return state;
+  }
+};
+
+export default chatWindowReducer;

package/src/redux/reducers/hmsStates.ts

@@ -0,0 +1,126 @@
+import type {
+  HMSLocalPeer,
+  HMSRole,
+  HMSRoom,
+} from '@100mslive/react-native-hms';
+import { HmsStateActionTypes } from '../actionTypes';
+
+type ActionType =
+  | SetRoomAction
+  | SetLocalPeerAction
+  | SetRolesAction
+  | SetIsLocalAudioMutedAction
+  | SetIsLocalVideoMutedAction
+  | SetIsLocalScreenSharedAction
+  | SetRoomLocallyMutedAction
+  | ResetAction;
+
+type SetRoomAction = {
+  type: HmsStateActionTypes.SET_ROOM_STATE;
+  room: HMSRoom | null;
+};
+
+type SetLocalPeerAction = {
+  type: HmsStateActionTypes.SET_LOCAL_PEER_STATE;
+  localPeer: HMSLocalPeer | null;
+};
+
+type SetRolesAction = {
+  type: HmsStateActionTypes.SET_ROLES_STATE;
+  roles: HMSRole[];
+};
+
+type SetIsLocalAudioMutedAction = {
+  type: HmsStateActionTypes.SET_IS_LOCAL_AUDIO_MUTED_STATE;
+  isLocalAudioMuted: boolean | undefined;
+};
+
+type SetIsLocalVideoMutedAction = {
+  type: HmsStateActionTypes.SET_IS_LOCAL_VIDEO_MUTED_STATE;
+  isLocalVideoMuted: boolean | undefined;
+};
+
+type SetIsLocalScreenSharedAction = {
+  type: HmsStateActionTypes.SET_IS_LOCAL_SCREEN_SHARED_STATE;
+  isLocalScreenShared: boolean | undefined;
+};
+
+type ResetAction = {
+  type: HmsStateActionTypes.CLEAR_STATES;
+};
+
+type SetRoomLocallyMutedAction = {
+  type: HmsStateActionTypes.SET_ROOM_LOCALLY_MUTED;
+  roomLocallyMuted: boolean;
+};
+
+type IntialStateType = {
+  isLocalAudioMuted: boolean | undefined;
+  isLocalVideoMuted: boolean | undefined;
+  isLocalScreenShared: boolean | undefined;
+  roomLocallyMuted: boolean;
+  room: HMSRoom | null;
+  localPeer: HMSLocalPeer | null;
+  roles: HMSRole[];
+};
+
+const INITIAL_STATE: IntialStateType = {
+  isLocalAudioMuted: undefined,
+  isLocalVideoMuted: undefined,
+  isLocalScreenShared: undefined,
+  roomLocallyMuted: false,
+  room: null,
+  localPeer: null,
+  roles: [],
+};
+
+const hmsStatesReducer = (
+  state = INITIAL_STATE,
+  action: ActionType
+): IntialStateType => {
+  switch (action.type) {
+    case HmsStateActionTypes.SET_ROOM_STATE:
+      return {
+        ...state,
+        room: action.room,
+      };
+    case HmsStateActionTypes.SET_LOCAL_PEER_STATE:
+      return {
+        ...state,
+        localPeer: action.localPeer,
+        isLocalAudioMuted: action.localPeer?.audioTrack?.isMute(),
+        isLocalVideoMuted: action.localPeer?.videoTrack?.isMute(),
+      };
+    case HmsStateActionTypes.SET_ROLES_STATE:
+      return {
+        ...state,
+        roles: action.roles,
+      };
+    case HmsStateActionTypes.SET_IS_LOCAL_AUDIO_MUTED_STATE:
+      return {
+        ...state,
+        isLocalAudioMuted: action.isLocalAudioMuted,
+      };
+    case HmsStateActionTypes.SET_IS_LOCAL_VIDEO_MUTED_STATE:
+      return {
+        ...state,
+        isLocalVideoMuted: action.isLocalVideoMuted,
+      };
+    case HmsStateActionTypes.SET_IS_LOCAL_SCREEN_SHARED_STATE:
+      return {
+        ...state,
+        isLocalScreenShared: action.isLocalScreenShared,
+      };
+    case HmsStateActionTypes.SET_ROOM_LOCALLY_MUTED:
+      return {
+        ...state,
+        roomLocallyMuted: action.roomLocallyMuted,
+      };
+    case HmsStateActionTypes.CLEAR_STATES:
+      return INITIAL_STATE;
+    default:
+      return state;
+  }
+};
+
+export default hmsStatesReducer;