agora-appbuilder-core 4.0.13 → 4.0.14

package/template/src/components/chat-messages/useChatMessages.tsx

@@ -19,10 +19,9 @@ import {
   ContentInterface,
   DispatchContext,
 } from '../../../agora-rn-uikit';
-import {
-  ChatType as ChatType,
-  useChatUIControls,
-} from '../chat-ui/useChatUIControls';
+import events, {PersistanceLevel} from '../../rtm-events-api';
+import {EventNames} from '../../rtm-events';
+import {ChatType, useChatUIControls} from '../chat-ui/useChatUIControls';
 import {useChatNotification} from '../chat-notification/useChatNotification';
 import Toast from '../../../react-native-toast-message';
 import {timeNow} from '../../rtm/utils';
@@ -32,8 +31,6 @@ import {trimText} from '../../utils/common';
 import {useStringRef} from '../../utils/useString';
 import {
   publicChatToastHeading,
-  publicChatFileToastHeading,
-  publicChatImgToastHeading,
   multiplePublicChatToastHeading,
   multiplePrivateChatToastHeading,
   privateChatToastHeading,
@@ -41,112 +38,24 @@ import {
   multiplePublicAndPrivateChatToastSubHeading,
   multiplePublicChatToastSubHeading,
 } from '../../language/default-labels/videoCallScreenLabels';
+import {LogSource, logger} from '../../logger/AppBuilderLogger';
+
+enum ChatMessageActionEnum {
+  Create = 'Create_Chat_Message',
+  Update = 'Update_Chat_Message',
+  Delete = 'Delete_Chat_Message',
+}
 
 interface ChatMessagesProviderProps {
   children: React.ReactNode;
   callActive: boolean;
 }
-export enum ChatMessageType {
-  /**
-   * Text message.
-   */
-  TXT = 'txt',
-  /**
-   * Image message.
-   */
-  IMAGE = 'img',
-  /**
-   * Video message.
-   */
-  VIDEO = 'video',
-  /**
-   * Location message.
-   */
-  LOCATION = 'loc',
-  /**
-   * Voice message.
-   */
-  VOICE = 'voice',
-  /**
-   * File message.
-   */
-  FILE = 'file',
-  /**
-   * Command message.
-   */
-  CMD = 'cmd',
-  /**
-   * Custom message.
-   */
-  CUSTOM = 'custom',
-  /**
-   * Combined message.
-   */
-  COMBINE = 'combine',
-}
-
 export interface messageInterface {
   createdTimestamp: number;
   updatedTimestamp?: number;
   msg: string;
   msgId: string;
   isDeleted: boolean;
-  type: ChatMessageType;
-  thumb?: string;
-  url?: string;
-  fileName?: string;
-  ext?: string;
-}
-
-export enum SDKChatType {
-  SINGLE_CHAT = 'singleChat',
-  GROUP_CHAT = 'groupChat',
-}
-
-export interface ChatOption {
-  chatType: SDKChatType;
-  type: ChatMessageType;
-  from: string;
-  to: string;
-  msg?: string;
-  file?: object;
-  ext?: {
-    file_length: number;
-    file_ext: string;
-    file_name: string;
-    file_url: string;
-    from_platform?: string;
-  };
-  url?: string;
-}
-
-interface ChatMessage {
-  msgId?: string;
-  localMsgId?: string;
-  conversationId?: string;
-  from?: string;
-  to?: string;
-  localTime?: number;
-  serverTime?: number;
-  hasDeliverAck?: boolean;
-  hasReadAck?: boolean;
-  needGroupAck?: boolean;
-  groupAckCount?: number;
-  hasRead?: boolean;
-  chatType?: number;
-  direction?: string;
-  status?: number;
-  attributes?: any;
-  body: any;
-  isChatThread?: boolean;
-  isOnline?: boolean;
-  deliverOnlineOnly?: boolean;
-  receiverList?: string[];
-}
-export interface MessageStatusCallback {
-  onProgress?(localMsgId: string, progress: number): void;
-  onError(localMsgId: string, error: any): void;
-  onSuccess(message: ChatMessage): void;
 }
 export interface messageStoreInterface extends messageInterface {
   uid: UidType;
@@ -155,35 +64,19 @@ export interface messageStoreInterface extends messageInterface {
 interface ChatMessagesInterface {
   messageStore: messageStoreInterface[];
   privateMessageStore: {[key: string]: messageStoreInterface[]};
-  addMessageToPrivateStore: (
-    uid: UidType,
-    body: messageInterface,
-    local: boolean,
-  ) => void;
-  addMessageToStore: (uid: UidType, body: messageInterface) => void;
-  showMessageNotification: (
-    msg: string,
-    uid: string,
-    isPrivateMessage?: boolean,
-    msgType?: ChatMessageType,
-  ) => void;
+  sendChatMessage: (msg: string, toUid?: UidType) => void;
+  editChatMessage: (msgId: string, msg: string, toUid?: UidType) => void;
+  deleteChatMessage: (msgId: string, toUid?: UidType) => void;
   openPrivateChat: (toUid: UidType) => void;
-  removeMessageFromStore: (msgId: string, isMsgRecalled: boolean) => void;
-  removeMessageFromPrivateStore: (
-    msgId: string,
-    isMsgRecalled: boolean,
-  ) => void;
 }
 
 const ChatMessagesContext = React.createContext<ChatMessagesInterface>({
   messageStore: [],
   privateMessageStore: {},
-  addMessageToStore: () => {},
-  addMessageToPrivateStore: () => {},
-  showMessageNotification: () => {},
+  sendChatMessage: () => {},
+  editChatMessage: () => {},
+  deleteChatMessage: () => {},
   openPrivateChat: () => {},
-  removeMessageFromStore: () => {},
-  removeMessageFromPrivateStore: () => {},
 });
 
 const ChatMessagesProvider = (props: ChatMessagesProviderProps) => {
@@ -202,9 +95,7 @@ const ChatMessagesProvider = (props: ChatMessagesProviderProps) => {
     useChatUIControls();
   const {setUnreadGroupMessageCount, setUnreadIndividualMessageCount} =
     useChatNotification();
-  // to store group msgs
   const [messageStore, setMessageStore] = useState<messageStoreInterface[]>([]);
-  // to store private msgs
   const [privateMessageStore, setPrivateMessageStore] = useState<{
     [key: string]: messageStoreInterface[];
   }>({});
@@ -217,7 +108,8 @@ const ChatMessagesProvider = (props: ChatMessagesProviderProps) => {
   const groupActiveRef = useRef<boolean>(false);
   const individualActiveRef = useRef<string | number>();
 
-  //i18 labels:
+  //public single
+  const fromText = useStringRef(publicChatToastHeading);
 
   //public multple
   const multiplePublicChatToastHeadingTT = useStringRef(
@@ -249,32 +141,6 @@ const ChatMessagesProvider = (props: ChatMessagesProviderProps) => {
     from: string;
   }>(multiplePublicAndPrivateChatToastSubHeading);
 
-  //public single
-  const txtToastHeading = useStringRef(publicChatToastHeading);
-  const imgToastHeading = useStringRef(publicChatImgToastHeading);
-  const fileToastHeading = useStringRef(publicChatFileToastHeading);
-
-  //commented for v1 release
-  //const fromText = useString('messageSenderNotificationLabel');
-  const fromText = (name: string, msgType: ChatMessageType) => {
-    let text = '';
-    switch (msgType) {
-      case ChatMessageType.TXT:
-        text = txtToastHeading?.current(name);
-        break;
-      case ChatMessageType.IMAGE:
-        text = imgToastHeading?.current(name);
-        break;
-      case ChatMessageType.FILE:
-        text = fileToastHeading?.current(name);
-        break;
-      default:
-        text = txtToastHeading?.current(name);
-        break;
-    }
-    return text;
-  };
-
   useEffect(() => {
     callActiveRef.current.callActive = callActive;
   }, [callActive]);
@@ -296,14 +162,24 @@ const ChatMessagesProvider = (props: ChatMessagesProviderProps) => {
   }, [privateChatUser]);
 
   const allEqual = arr => arr.every(val => val === arr[0]);
-  const openPrivateChat = (uidAsNumber: number) => {
+  const openPrivateChat = uidAsNumber => {
+    //move this logic into ChatContainer
+    // setUnreadPrivateMessageCount(
+    //   unreadPrivateMessageCount -
+    //     (unreadIndividualMessageCount[uidAsNumber] || 0),
+    // );
+    // setUnreadIndividualMessageCount((prevState) => {
+    //   return {
+    //     ...prevState,
+    //     [uidAsNumber]: 0,
+    //   };
+    // });
+
     setPrivateChatUser(uidAsNumber);
     setChatType(ChatType.Private);
     setSidePanel(SidePanelType.Chat);
   };
 
-  //TODO: check why need
-
   const updateRenderListState = (
     uid: number,
     data: Partial<ContentInterface>,
@@ -311,6 +187,379 @@ const ChatMessagesProvider = (props: ChatMessagesProviderProps) => {
     dispatch({type: 'UpdateRenderList', value: [uid, data]});
   };
 
+  React.useEffect(() => {
+    const showMessageNotification = (
+      msg: string,
+      uid: string,
+      isPrivateMessage: boolean = false,
+      forceStop: boolean = false,
+    ) => {
+      //don't show group message notification if group chat is open
+      if (!isPrivateMessage && groupActiveRef.current) {
+        return;
+      }
+      const uidAsNumber = parseInt(uid);
+      //don't show private message notification if private chat is open
+      if (isPrivateMessage && uidAsNumber === individualActiveRef.current) {
+        return;
+      }
+      if (forceStop) {
+        return;
+      }
+      clearTimeout(timeoutRef.current);
+      isToastVisibleRef.current = true;
+      timeoutRef.current = setTimeout(() => {
+        isToastVisibleRef.current = false;
+        previousNotificationRef.current = [];
+      }, 3000);
+
+      previousNotificationRef.current.push({
+        isPrivateMessage: isPrivateMessage,
+        fromUid: isPrivateMessage ? uidAsNumber : 0,
+        from:
+          !isPrivateMessage &&
+          //@ts-ignore
+          defaultContentRef.current.defaultContent[uidAsNumber]?.name
+            ? trimText(
+                //@ts-ignore
+                defaultContentRef.current.defaultContent[uidAsNumber]?.name,
+              )
+            : '',
+      });
+
+      const privateMessages = previousNotificationRef.current.filter(
+        i => i.isPrivateMessage,
+      );
+      const publicMessages = previousNotificationRef.current.filter(
+        i => !i.isPrivateMessage,
+      );
+
+      //if 1 or more public and private messages
+      if (publicMessages && publicMessages.length > 1) {
+        const fromNamesArray = publicMessages
+          .filter(i => i.from !== undefined && i.from !== null && i.from !== '')
+          .map(i => i.from);
+        //removing the duplicate names
+        const fromNamesArrayUnique = [...new Set(fromNamesArray)];
+        //public chat with two name will seperated by "and"
+        //public chat with two or more name will have "and more" at the end
+        const fromNamesArrayUpdated =
+          fromNamesArrayUnique.length > 2
+            ? fromNamesArrayUnique
+                .slice(0, 2)
+                .map((i, index) => (index === 0 ? i + ', ' : i))
+                .concat(privateMessages?.length ? ', more' : ' and more')
+            : fromNamesArrayUnique.length == 2
+            ? fromNamesArrayUnique.map((i, index) =>
+                index === 0 ? i + ' and ' : i,
+              )
+            : fromNamesArrayUnique;
+        //converting the names array to string
+        const fromNames = fromNamesArrayUpdated.join('');
+        Toast.show({
+          //@ts-ignore
+          update: isToastVisibleRef.current ? true : false,
+          primaryBtn: null,
+          secondaryBtn: null,
+          type: 'info',
+          leadingIconName: 'chat-nav',
+          text1:
+            privateMessages && privateMessages.length
+              ? multiplePublicAndPrivateChatToastHeadingTT?.current()
+              : multiplePublicChatToastHeadingTT?.current(),
+          text2:
+            privateMessages && privateMessages.length
+              ? //@ts-ignore
+                multiplePublicAndPrivateChatToastSubHeadingTT?.current({
+                  publicChatCount: publicMessages.length,
+                  privateChatCount: privateMessages.length,
+                  from: fromNames,
+                })
+              : //@ts-ignore
+                multiplePublicChatToastSubHeadingTT?.current({
+                  count: publicMessages.length,
+                  from: fromNames,
+                }),
+          visibilityTime: 3000,
+          onPress: () => {
+            if (isPrivateMessage) {
+              openPrivateChat(uidAsNumber);
+            } else {
+              //move this logic into ChatContainer
+              // setUnreadGroupMessageCount(0);
+              setPrivateChatUser(0);
+              setChatType(ChatType.Group);
+              setSidePanel(SidePanelType.Chat);
+            }
+          },
+        });
+      }
+      //if one or more private message and no public messages
+      else if (privateMessages && privateMessages.length > 1) {
+        Toast.show({
+          //@ts-ignore
+          update: isToastVisibleRef.current ? true : false,
+          primaryBtn: null,
+          secondaryBtn: null,
+          type: 'info',
+          leadingIconName: 'chat-nav',
+          text1:
+            //@ts-ignore
+            multiplePrivateChatToastHeadingTT?.current({
+              count: privateMessages.length,
+            }),
+          text2: ``,
+          visibilityTime: 3000,
+          onPress: () => {
+            const openPrivateChatDetails = allEqual(
+              privateMessages.map(i => i.fromUid),
+            );
+            //if all private message comes from the single user then open details private chat
+            if (openPrivateChatDetails) {
+              openPrivateChat(privateMessages[0].fromUid);
+            }
+            //if private message comes from different user then open private tab not the private chatting window
+            else {
+              //open private tab (not the detail of private chat user)
+              setPrivateChatUser(0);
+              setChatType(ChatType.Group);
+              setSidePanel(SidePanelType.Chat);
+            }
+          },
+        });
+      }
+      //either 1 public or 1 private message
+      else {
+        Toast.show({
+          //@ts-ignore
+          update: isToastVisibleRef.current ? true : false,
+          primaryBtn: null,
+          secondaryBtn: null,
+          type: 'info',
+          leadingIconName: 'chat-nav',
+          text1: isPrivateMessage
+            ? privateMessageLabel?.current()
+            : //@ts-ignore
+            defaultContentRef.current.defaultContent[uidAsNumber]?.name
+            ? fromText?.current(
+                trimText(
+                  //@ts-ignore
+                  defaultContentRef.current.defaultContent[uidAsNumber]?.name,
+                ),
+              )
+            : '',
+          text2: isPrivateMessage
+            ? ''
+            : msg.length > 30
+            ? msg.slice(0, 30) + '...'
+            : msg,
+          visibilityTime: 3000,
+          onPress: () => {
+            if (isPrivateMessage) {
+              openPrivateChat(uidAsNumber);
+            } else {
+              //move this logic into ChatContainer
+              // setUnreadGroupMessageCount(0);
+              setPrivateChatUser(0);
+              setChatType(ChatType.Group);
+              setSidePanel(SidePanelType.Chat);
+            }
+          },
+        });
+      }
+    };
+    const unsubPublicChatMessage = events.on(
+      EventNames.PUBLIC_CHAT_MESSAGE,
+      data => {
+        const forceStop =
+          $config.ENABLE_WAITING_ROOM &&
+          !isHostRef.current.isHost &&
+          !callActiveRef.current.callActive;
+        //if call is not active don't store the message in the state
+        if (forceStop) {
+          return;
+        }
+        const payload = JSON.parse(data.payload);
+        const messageAction = payload.action;
+        const messageData = payload.value;
+        switch (messageAction) {
+          case ChatMessageActionEnum.Create:
+            showMessageNotification(
+              messageData.msg,
+              `${data.sender}`,
+              false,
+              forceStop,
+            );
+            addMessageToStore(data.sender, {
+              msg: messageData.msg,
+              createdTimestamp: messageData.createdTimestamp,
+              isDeleted: messageData.isDeleted,
+              msgId: messageData.msgId,
+            });
+            /**
+             * if chat group window is not active.
+             * then we will increment the unread count
+             */
+            if (!groupActiveRef.current) {
+              setUnreadGroupMessageCount(prevState => {
+                return prevState + 1;
+              });
+            }
+            break;
+          case ChatMessageActionEnum.Update:
+            setMessageStore(prevState => {
+              const newState = prevState.map(item => {
+                if (
+                  item.msgId === messageData.msgId &&
+                  item.uid === data.sender
+                ) {
+                  return {
+                    ...item,
+                    msg: messageData.msg,
+                    updatedTimestamp: messageData.updatedTimestamp,
+                  };
+                } else {
+                  return item;
+                }
+              });
+              return newState;
+            });
+            break;
+          case ChatMessageActionEnum.Delete:
+            setMessageStore(prevState => {
+              const newState = prevState.map(item => {
+                if (
+                  item.msgId === messageData.msgId &&
+                  item.uid === data.sender
+                ) {
+                  return {
+                    ...item,
+                    isDeleted: true,
+                    updatedTimestamp: messageData.updatedTimestamp,
+                  };
+                } else {
+                  return item;
+                }
+              });
+              return newState;
+            });
+            break;
+          default:
+            break;
+        }
+      },
+    );
+
+    const unsubPrivateChatMessage = events.on(
+      EventNames.PRIVATE_CHAT_MESSAGE,
+      data => {
+        const payload = JSON.parse(data.payload);
+        const messageAction = payload.action;
+        const messageData = payload.value;
+        switch (messageAction) {
+          case ChatMessageActionEnum.Create:
+            //To order chat participant based on recent message
+            try {
+              updateRenderListState(data.sender, {
+                lastMessageTimeStamp: new Date().getTime(),
+              });
+            } catch (error) {
+              logger.error(
+                LogSource.Internals,
+                'CHAT',
+                'ERROR : couldnt update the last message timestamp',
+                error,
+              );
+            }
+            showMessageNotification(messageData.msg, `${data.sender}`, true);
+            addMessageToPrivateStore(
+              data.sender,
+              {
+                msg: messageData.msg,
+                createdTimestamp: messageData.createdTimestamp,
+                msgId: messageData.msgId,
+                isDeleted: messageData.isDeleted,
+              },
+              false,
+            );
+            /**
+             * if user's private window is active.
+             * then we will not increment the unread count
+             */
+
+            if (!(individualActiveRef.current === data.sender)) {
+              setUnreadIndividualMessageCount(prevState => {
+                const prevCount =
+                  prevState && prevState[data.sender]
+                    ? prevState[data.sender]
+                    : 0;
+                return {
+                  ...prevState,
+                  [data.sender]: prevCount + 1,
+                };
+              });
+            }
+            break;
+          case ChatMessageActionEnum.Update:
+            setPrivateMessageStore(prevState => {
+              const privateChatOfUid = prevState[data.sender];
+              const updatedData = privateChatOfUid.map(item => {
+                if (
+                  item.msgId === messageData.msgId &&
+                  item.uid === data.sender
+                ) {
+                  return {
+                    ...item,
+                    msg: messageData.msg,
+                    updatedTimestamp: messageData.updatedTimestamp,
+                  };
+                } else {
+                  return item;
+                }
+              });
+              const newState = {
+                ...prevState,
+                [data.sender]: updatedData,
+              };
+              return newState;
+            });
+            break;
+          case ChatMessageActionEnum.Delete:
+            setPrivateMessageStore(prevState => {
+              const privateChatOfUid = prevState[data.sender];
+              const updatedData = privateChatOfUid.map(item => {
+                if (
+                  item.msgId === messageData.msgId &&
+                  item.uid === data.sender
+                ) {
+                  return {
+                    ...item,
+                    isDeleted: true,
+                    updatedTimestamp: messageData.updatedTimestamp,
+                  };
+                } else {
+                  return item;
+                }
+              });
+              const newState = {
+                ...prevState,
+                [data.sender]: updatedData,
+              };
+              return newState;
+            });
+            break;
+          default:
+            break;
+        }
+      },
+    );
+
+    return () => {
+      unsubPublicChatMessage();
+      unsubPrivateChatMessage();
+    };
+  }, []);
+
   const addMessageToStore = (uid: UidType, body: messageInterface) => {
     setMessageStore((m: messageStoreInterface[]) => {
       return [
@@ -321,11 +570,6 @@ const ChatMessagesProvider = (props: ChatMessagesProviderProps) => {
           msg: body.msg,
           msgId: body.msgId,
           isDeleted: body.isDeleted,
-          type: body.type,
-          thumb: body?.thumb,
-          url: body?.url,
-          ext: body?.ext,
-          fileName: body?.fileName,
         },
       ];
     });
@@ -347,11 +591,6 @@ const ChatMessagesProvider = (props: ChatMessagesProviderProps) => {
               msg: body.msg,
               msgId: body.msgId,
               isDeleted: body.isDeleted,
-              type: body.type,
-              thumb: body?.thumb,
-              url: body?.url,
-              ext: body?.ext,
-              fileName: body?.fileName,
             },
           ])
         : (newState = {
@@ -363,11 +602,6 @@ const ChatMessagesProvider = (props: ChatMessagesProviderProps) => {
                 msg: body.msg,
                 msgId: body.msgId,
                 isDeleted: body.isDeleted,
-                type: body.type,
-                thumb: body.thumb,
-                url: body.url,
-                ext: body?.ext,
-                fileName: body?.fileName,
               },
             ],
           });
@@ -375,257 +609,221 @@ const ChatMessagesProvider = (props: ChatMessagesProviderProps) => {
     });
   };
 
-  const removeMessageFromStore = (msgID, isMsgRecalled) => {
-    console.warn('msg delete native', msgID);
-    setMessageStore(prev => {
-      if (isMsgRecalled) {
-        const recalledMsgIndex = prev.findIndex(msg => msg.msgId === msgID);
-        if (recalledMsgIndex !== -1) {
-          const updatedMessages = [...prev];
-          updatedMessages[recalledMsgIndex].isDeleted = true;
-          return updatedMessages;
-        } else {
-          return prev;
-        }
-      } else {
-        return prev.filter(msg => msg.msgId !== msgID);
-      }
-    });
+  const sendChatMessage = (msg: string, toUid?: UidType) => {
+    if (typeof msg == 'string' && msg.trim() === '') return;
+    logger.log(
+      LogSource.Internals,
+      'CHAT',
+      `sending ${toUid ? 'private' : 'public'} chat message -> ${msg} ${
+        toUid ? toUid : ''
+      }`,
+    );
+    if (toUid) {
+      const messageData = {
+        msg,
+        createdTimestamp: timeNow(),
+        msgId: getUniqueID(),
+        isDeleted: false,
+      };
+      events.send(
+        EventNames.PRIVATE_CHAT_MESSAGE,
+        JSON.stringify({
+          value: messageData,
+          action: ChatMessageActionEnum.Create,
+        }),
+        PersistanceLevel.None,
+        toUid,
+      );
+      addMessageToPrivateStore(toUid, messageData, true);
+    } else {
+      const messageData = {
+        msg,
+        msgId: getUniqueID(),
+        isDeleted: false,
+        createdTimestamp: timeNow(),
+      };
+      events.send(
+        EventNames.PUBLIC_CHAT_MESSAGE,
+        JSON.stringify({
+          value: messageData,
+          action: ChatMessageActionEnum.Create,
+        }),
+        PersistanceLevel.None,
+      );
+      addMessageToStore(localUid, messageData);
+    }
   };
 
-  // const removeMessageFromPrivateStore = (msgID, isMsgRecalled) => {
-  //   setPrivateMessageStore(prev => {
-  //     const state = {...prev};
-  //     const filteredData = prev[localUid].filter(msg => msg.msgId !== msgID);
-  //     const newState = {...state, [localUid]: filteredData};
-  //     return {...newState};
-  //   });
-  // };
-
-  const removeMessageFromPrivateStore = (msgID, isMsgRecalled) => {
-    setPrivateMessageStore(state => {
-      const newState = {...state};
-
-      if (isMsgRecalled) {
-        Object.keys(newState).forEach(uid => {
-          const messages = newState[uid];
-          if (messages) {
-            const recalledMsg = messages.find(msg => msg.msgId === msgID);
-            if (recalledMsg) {
-              recalledMsg.isDeleted = true;
+  const editChatMessage = (msgId: string, msg: string, toUid?: UidType) => {
+    if (typeof msg == 'string' && msg.trim() === '') return;
+    logger.log(
+      LogSource.Internals,
+      'CHAT',
+      `editing ${toUid ? 'private' : 'public'} chat message..`,
+      {
+        msgId,
+        msg,
+      },
+    );
+    if (toUid) {
+      const checkData = privateMessageStore[toUid].filter(
+        item => item.msgId === msgId && item.uid === localUid,
+      );
+      if (checkData && checkData.length) {
+        const editMsgData = {msg, updatedTimestamp: timeNow()};
+        events.send(
+          EventNames.PRIVATE_CHAT_MESSAGE,
+          JSON.stringify({
+            value: {msgId, ...editMsgData},
+            action: ChatMessageActionEnum.Update,
+          }),
+          PersistanceLevel.None,
+          toUid,
+        );
+        setPrivateMessageStore(prevState => {
+          const privateChatOfUid = prevState[toUid];
+          const updatedData = privateChatOfUid.map(item => {
+            if (item.msgId === msgId) {
+              return {...item, ...editMsgData};
+            } else {
+              return item;
             }
-          }
+          });
+          const newState = {...prevState, [toUid]: updatedData};
+          return newState;
         });
       } else {
-        Object.keys(newState).forEach(uid => {
-          const messages = newState[uid];
-          if (messages) {
-            newState[uid] = messages.filter(msg => msg.msgId !== msgID);
-          }
+        logger.debug(
+          LogSource.Internals,
+          'CHAT',
+          "You don't have permission to edit",
+          {
+            msgId,
+            msg,
+          },
+        );
+      }
+    } else {
+      //check if user has permission to edit
+      const checkData = messageStore.filter(
+        item => item.msgId === msgId && item.uid === localUid,
+      );
+      if (checkData && checkData.length) {
+        const editMsgData = {msg, updatedTimestamp: timeNow()};
+        events.send(
+          EventNames.PUBLIC_CHAT_MESSAGE,
+          JSON.stringify({
+            value: {msgId, ...editMsgData},
+            action: ChatMessageActionEnum.Update,
+          }),
+          PersistanceLevel.None,
+        );
+        setMessageStore(prevState => {
+          const newState = prevState.map(item => {
+            if (item.msgId === msgId) {
+              return {...item, ...editMsgData};
+            } else {
+              return item;
+            }
+          });
+          return newState;
         });
+      } else {
+        logger.debug(
+          LogSource.Internals,
+          'CHAT',
+          "You don't have permission to edit",
+          {
+            msgId,
+            msg,
+          },
+        );
       }
-
-      return {...newState};
-    });
+    }
   };
 
-  const showMessageNotification = (
-    msg: string,
-    uid: string,
-    isPrivateMessage: boolean = false,
-    msgType: ChatMessageType,
-    forceStop: boolean = false,
-  ) => {
-    if (isPrivateMessage) {
-      // update notification count
-      if (!(individualActiveRef.current === Number(uid))) {
-        setUnreadIndividualMessageCount(prevState => {
-          const prevCount = prevState && prevState[uid] ? prevState[uid] : 0;
-          return {
-            ...prevState,
-            [uid]: prevCount + 1,
-          };
+  const deleteChatMessage = (msgId: string, toUid?: UidType) => {
+    logger.log(
+      LogSource.Internals,
+      'CHAT',
+      `deleting ${toUid ? 'private' : 'public'} chat message..`,
+      {
+        msgId,
+      },
+    );
+    if (toUid) {
+      const checkData = privateMessageStore[toUid].filter(
+        item => item.msgId === msgId && item.uid === localUid,
+      );
+      if (checkData && checkData.length) {
+        const deleteMsgData = {updatedTimestamp: timeNow()};
+        events.send(
+          EventNames.PRIVATE_CHAT_MESSAGE,
+          JSON.stringify({
+            value: {msgId, ...deleteMsgData},
+            action: ChatMessageActionEnum.Delete,
+          }),
+          PersistanceLevel.None,
+          toUid,
+        );
+        setPrivateMessageStore(prevState => {
+          const privateChatOfUid = prevState[toUid];
+          const updatedData = privateChatOfUid.map(item => {
+            if (item.msgId === msgId) {
+              return {...item, isDeleted: true, ...deleteMsgData};
+            } else {
+              return item;
+            }
+          });
+          const newState = {...prevState, [toUid]: updatedData};
+          return newState;
         });
+      } else {
+        logger.debug(
+          LogSource.Internals,
+          'CHAT',
+          "You don't have permission to delete",
+          {
+            msgId,
+          },
+        );
       }
     } else {
-      if (!groupActiveRef.current) {
-        setUnreadGroupMessageCount(prevState => {
-          return prevState + 1;
+      //check if user has permission to delete
+      const checkData = messageStore.filter(
+        item => item.msgId === msgId && item.uid === localUid,
+      );
+      if (checkData && checkData.length) {
+        const deleteMsgData = {updatedTimestamp: timeNow()};
+        events.send(
+          EventNames.PUBLIC_CHAT_MESSAGE,
+          JSON.stringify({
+            value: {msgId, ...deleteMsgData},
+            action: ChatMessageActionEnum.Delete,
+          }),
+          PersistanceLevel.None,
+        );
+        setMessageStore(prevState => {
+          const newState = prevState.map(item => {
+            if (item.msgId === msgId) {
+              return {...item, isDeleted: true, ...deleteMsgData};
+            } else {
+              return item;
+            }
+          });
+          return newState;
         });
+      } else {
+        logger.debug(
+          LogSource.Internals,
+          'CHAT',
+          "You don't have permission to delete",
+          {
+            msgId,
+          },
+        );
       }
     }
-
-    //don't show group message notification if group chat is open
-    if (!isPrivateMessage && groupActiveRef.current) {
-      return;
-    }
-    const uidAsNumber = parseInt(uid);
-    //don't show private message notification if private chat is open
-    if (isPrivateMessage && uidAsNumber === individualActiveRef.current) {
-      return;
-    }
-    if (forceStop) {
-      return;
-    }
-    clearTimeout(timeoutRef.current);
-    isToastVisibleRef.current = true;
-    timeoutRef.current = setTimeout(() => {
-      isToastVisibleRef.current = false;
-      previousNotificationRef.current = [];
-    }, 3000);
-
-    previousNotificationRef.current.push({
-      isPrivateMessage: isPrivateMessage,
-      fromUid: isPrivateMessage ? uidAsNumber : 0,
-      from:
-        !isPrivateMessage &&
-        //@ts-ignore
-        defaultContentRef.current.defaultContent[uidAsNumber]?.name
-          ? trimText(
-              //@ts-ignore
-              defaultContentRef.current.defaultContent[uidAsNumber]?.name,
-            )
-          : '',
-    });
-
-    const privateMessages = previousNotificationRef.current.filter(
-      i => i.isPrivateMessage,
-    );
-    const publicMessages = previousNotificationRef.current.filter(
-      i => !i.isPrivateMessage,
-    );
-
-    //if 1 or more public and private messages
-    if (publicMessages && publicMessages.length > 1) {
-      const fromNamesArray = publicMessages
-        .filter(i => i.from !== undefined && i.from !== null && i.from !== '')
-        .map(i => i.from);
-      //removing the duplicate names
-      const fromNamesArrayUnique = [...new Set(fromNamesArray)];
-      //public chat with two name will seperated by "and"
-      //public chat with two or more name will have "and more" at the end
-      const fromNamesArrayUpdated =
-        fromNamesArrayUnique.length > 2
-          ? fromNamesArrayUnique
-              .slice(0, 2)
-              .map((i, index) => (index === 0 ? i + ', ' : i))
-              .concat(privateMessages?.length ? ', more' : ' and more')
-          : fromNamesArrayUnique.length == 2
-          ? fromNamesArrayUnique.map((i, index) =>
-              index === 0 ? i + ' and ' : i,
-            )
-          : fromNamesArrayUnique;
-      //converting the names array to string
-      const fromNames = fromNamesArrayUpdated.join('');
-      Toast.show({
-        //@ts-ignore
-        update: isToastVisibleRef.current ? true : false,
-        primaryBtn: null,
-        secondaryBtn: null,
-        type: 'info',
-        leadingIconName: 'chat-nav',
-        text1:
-          privateMessages && privateMessages.length
-            ? multiplePublicAndPrivateChatToastHeadingTT?.current()
-            : multiplePublicChatToastHeadingTT?.current(),
-        text2:
-          privateMessages && privateMessages.length
-            ? //@ts-ignore
-              multiplePublicAndPrivateChatToastSubHeadingTT?.current({
-                publicChatCount: publicMessages.length,
-                privateChatCount: privateMessages.length,
-                from: fromNames,
-              })
-            : //@ts-ignore
-              multiplePublicChatToastSubHeadingTT?.current({
-                count: publicMessages.length,
-                from: fromNames,
-              }),
-        visibilityTime: 3000,
-        onPress: () => {
-          if (isPrivateMessage) {
-            openPrivateChat(uidAsNumber);
-          } else {
-            //move this logic into ChatContainer
-            // setUnreadGroupMessageCount(0);
-            setPrivateChatUser(0);
-            setChatType(ChatType.Group);
-            setSidePanel(SidePanelType.Chat);
-          }
-        },
-      });
-    }
-    //if one or more private message and no public messages
-    else if (privateMessages && privateMessages.length > 1) {
-      Toast.show({
-        //@ts-ignore
-        update: isToastVisibleRef.current ? true : false,
-        primaryBtn: null,
-        secondaryBtn: null,
-        type: 'info',
-        leadingIconName: 'chat-nav',
-        //@ts-ignore
-        text1: multiplePrivateChatToastHeadingTT?.current({
-          count: privateMessages.length,
-        }),
-        text2: ``,
-        visibilityTime: 3000,
-        onPress: () => {
-          const openPrivateChatDetails = allEqual(
-            privateMessages.map(i => i.fromUid),
-          );
-          //if all private message comes from the single user then open details private chat
-          if (openPrivateChatDetails) {
-            openPrivateChat(privateMessages[0].fromUid);
-          }
-          //if private message comes from different user then open private tab not the private chatting window
-          else {
-            //open private tab (not the detail of private chat user)
-            setPrivateChatUser(0);
-            setChatType(ChatType.Group);
-            setSidePanel(SidePanelType.Chat);
-          }
-        },
-      });
-    }
-    //either 1 public or 1 private message
-    else {
-      Toast.show({
-        //@ts-ignore
-        update: isToastVisibleRef.current ? true : false,
-        primaryBtn: null,
-        secondaryBtn: null,
-        type: 'info',
-        leadingIconName: 'chat-nav',
-        text1: isPrivateMessage
-          ? privateMessageLabel?.current()
-          : //@ts-ignore
-          defaultContentRef.current.defaultContent[uidAsNumber]?.name
-          ? fromText(
-              trimText(
-                //@ts-ignore
-                defaultContentRef.current.defaultContent[uidAsNumber]?.name,
-              ),
-              msgType,
-            )
-          : '',
-        text2: isPrivateMessage
-          ? ''
-          : msg.length > 30
-          ? msg.slice(0, 30) + '...'
-          : msg,
-        visibilityTime: 3000,
-        onPress: () => {
-          if (isPrivateMessage) {
-            openPrivateChat(uidAsNumber);
-          } else {
-            setPrivateChatUser(0);
-            setChatType(ChatType.Group);
-            setSidePanel(SidePanelType.Chat);
-          }
-        },
-      });
-    }
   };
 
   return (
@@ -633,11 +831,9 @@ const ChatMessagesProvider = (props: ChatMessagesProviderProps) => {
       value={{
         messageStore,
         privateMessageStore,
-        addMessageToStore,
-        addMessageToPrivateStore,
-        removeMessageFromStore,
-        removeMessageFromPrivateStore,
-        showMessageNotification,
+        sendChatMessage,
+        editChatMessage,
+        deleteChatMessage,
         openPrivateChat,
       }}>
       {props.children}