@ethora/chat-component-rn 26.7.6 → 26.7.8

package/src/components/MainComponents/ChatWrapper.tsx

@@ -30,6 +30,7 @@ import Modal from '../Modals/Modal/Modal';
 import ThreadWrapper from '../Thread/ThreadWrapper';
 import {ModalWrapper} from '../Modals/ModalWrapper/ModalWrapper';
 import {useChatSettingState} from '../../hooks/useChatSettingState';
+import { usePendingNotification } from '../../hooks/usePendingNotification';
 import {DeviceEventEmitter, Pressable, Text, View} from 'react-native';
 import {pushLog as devPushLog} from '../../utils/devLogger';
 import {normalizeRoomJid} from '../../helpers/normalizeRoomJid';
@@ -61,6 +62,8 @@ const ChatWrapper: FC<ChatWrapperProps> = ({
     client: storedClient,
   } = useChatSettingState();
 
+  usePendingNotification();
+
   const [isInited, setInited] = useState(false);
   const [showModal, setShowModal] = useState(false);
   const [errorMsg, setErrorMsg] = useState<string | null>(null);

package/src/components/Modals/ChatProfileModal/ChatProfileModal.tsx

@@ -26,6 +26,8 @@ import { deleteRoom, updateRoom } from '../../../roomStore/roomsSlice';
 import Loader from '../../styled/Loader';
 import {
   AddNewIcon,
+  BellIcon,
+  BellOffIcon,
   DeleteIcon,
   EditIcon,
   LeaveIcon,
@@ -36,7 +38,7 @@ import { useChatSettingState } from '../../../hooks/useChatSettingState';
 import { chatTextStyle } from '../../../helpers/typography';
 import { getElementFont } from '../../../helpers/getElementFont';
 import { getIconColor } from '../../../helpers/getIconColor';
-import { deleteRoomMember } from '../../../networking/api-requests/rooms.api';
+import { deleteRoomMember, setRoomMuted } from '../../../networking/api-requests/rooms.api';
 import { RoomMember } from '../../../types/models/room.model';
 import { setActiveModal, setSelectedUser } from '../../../roomStore/chatSettingsSlice';
 import { MODAL_TYPES } from '../../../helpers/constants/MODAL_TYPES';
@@ -355,8 +357,40 @@ const ChatProfileModal: React.FC<ChatProfileModalProps> = ({
     return () => sub.remove();
   }, [isSearchOpen]); // eslint-disable-line react-hooks/exhaustive-deps
 
+  const muteInFlightRef = useRef(false);
+  const toggleMuted = async () => {
+    if (!activeRoom?.jid || !activeRoom?.name || muteInFlightRef.current) {return;}
+    const next = !activeRoom.muted;
+    muteInFlightRef.current = true;
+    dispatch(updateRoom({ jid: activeRoom.jid, updates: { muted: next } }));
+    try {
+      const confirmed = await setRoomMuted(activeRoom.name, next);
+      if (confirmed !== next) {
+        dispatch(updateRoom({ jid: activeRoom.jid, updates: { muted: confirmed } }));
+      }
+    } catch (error) {
+      dispatch(updateRoom({ jid: activeRoom.jid, updates: { muted: !next } }));
+      console.warn('[ethora-rn] mute toggle failed', error);
+      showToast({
+        id: Date.now().toString(),
+        title: 'Error',
+        message: t('toast.muteFailed'),
+        type: 'error',
+      });
+    } finally {
+      muteInFlightRef.current = false;
+    }
+  };
+
   const heroActions: HeroAction[] = useMemo(
     () => [
+      {
+        key: 'mute',
+        label: activeRoom?.muted ? t('action.muted') : t('action.unmuted'),
+        icon: (color: string) =>
+          activeRoom?.muted ? <BellOffIcon color={color} /> : <BellIcon color={color} />,
+        onPress: toggleMuted,
+      },
       {
         key: 'search',
         label: t('action.search'),
@@ -376,7 +410,7 @@ const ChatProfileModal: React.FC<ChatProfileModalProps> = ({
         onPress: () => setIsReportOpen(true),
       },
     ],
-    [t, activeRoom?.jid] // eslint-disable-line react-hooks/exhaustive-deps
+    [t, activeRoom?.jid, activeRoom?.muted] // eslint-disable-line react-hooks/exhaustive-deps
   );
 
   // "…" menu. Edit is the chat picture — the only chat detail this SDK can

package/src/context/xmppProvider.tsx

@@ -594,9 +594,14 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
     // be re-marked visible on return. Lives in the effect closure (one per
     // client) — persists across the listener's many invocations.
     let visibleBeforeBackground: string | null = null;
+    const suspendInBackground = !config?.xmppSettings?.keepAliveInBackground;
     const sub = AppState.addEventListener('change', (next) => {
       const c = client;
       if (next === 'active') {
+        if (c?.isSuspended) {
+          devPushLog('rn', 'AppState active: resuming suspended XMPP client');
+          c.resume();
+        }
         // Returned to foreground. If the socket died while backgrounded
         // (iOS suspends the WebSocket; long background kills it), the
         // status may still read 'online' until xmpp.js notices the dead
@@ -624,6 +629,9 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
       }
       // Going to background/inactive (sleep / app switcher / tray):
       if (!c) {return;}
+      if (next === 'background' && suspendInBackground) {
+        c.suspend().catch(() => undefined);
+      }
       const state = store.getState();
       const rooms = state.rooms?.rooms;
       const visibleRoomJID = state.rooms?.visibleRoomJID || null;
@@ -655,7 +663,7 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
       );
     });
     return () => sub.remove();
-  }, [client]);
+  }, [client, config?.xmppSettings?.keepAliveInBackground]);
 
   // -----------------------------------------------------------
   // Consumer visibility signal (`isVisible` prop). For hosts that keep

package/src/helpers/pushPayload.ts

@@ -0,0 +1,62 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { store } from '../roomStore';
+import {
+  clearPendingNotificationJid,
+  setCurrentRoom,
+  setPendingNotificationJid,
+} from '../roomStore/roomsSlice';
+import { handleCallPush } from './incomingCallFromPush';
+import { normalizeRoomJid } from './normalizeRoomJid';
+
+export type PushPayloadOutcome = 'call' | 'room' | 'pending' | 'unknown';
+
+export const PENDING_NOTIFICATION_JID_KEY = 'ethora_pending_notification_jid';
+export const PENDING_NOTIFICATION_TTL_MS = 5 * 60 * 1000;
+
+export const readPendingJid = async (): Promise<string | null> => {
+  try {
+    const raw = await AsyncStorage.getItem(PENDING_NOTIFICATION_JID_KEY);
+    if (!raw) {return null;}
+    if (raw.startsWith('{')) {
+      const { jid, at } = JSON.parse(raw) as { jid?: string; at?: number };
+      if (!jid || !at || Date.now() - at > PENDING_NOTIFICATION_TTL_MS) {
+        await AsyncStorage.removeItem(PENDING_NOTIFICATION_JID_KEY);
+        return null;
+      }
+      return jid;
+    }
+    return raw;
+  } catch {
+    return null;
+  }
+};
+
+export const openRoomFromPush = (jid: string): 'room' | 'pending' => {
+  const state = store.getState();
+  const conference = state.chatSettingStore?.config?.xmppSettings?.conference;
+  const full = normalizeRoomJid(jid, conference);
+
+  AsyncStorage.setItem(
+    PENDING_NOTIFICATION_JID_KEY,
+    JSON.stringify({ jid: full, at: Date.now() })
+  ).catch(() => undefined);
+  if (state.rooms?.rooms?.[full]) {
+    store.dispatch(clearPendingNotificationJid());
+    store.dispatch(setCurrentRoom({ roomJID: full }));
+    return 'room';
+  }
+  store.dispatch(setPendingNotificationJid(full));
+  return 'pending';
+};
+
+export const handlePushPayload = (
+  data: Record<string, unknown> | null | undefined
+): PushPayloadOutcome => {
+  if (!data) {return 'unknown';}
+  if (handleCallPush(data as Record<string, any>)) {return 'call';}
+  const jid = data.jid ?? data.chatJid ?? data.roomJid ?? data.roomJID;
+  if (typeof jid === 'string' && jid) {
+    return openRoomFromPush(jid);
+  }
+  return 'unknown';
+};

package/src/hooks/usePendingNotification.ts

@@ -4,7 +4,7 @@ import AsyncStorage from '@react-native-async-storage/async-storage';
 import { RootState } from '../roomStore';
 import { setCurrentRoom, clearPendingNotificationJid } from '../roomStore/roomsSlice';
 
-const PENDING_NOTIFICATION_JID_KEY = 'ethora_pending_notification_jid';
+import { PENDING_NOTIFICATION_JID_KEY, readPendingJid } from '../helpers/pushPayload';
 
 export function usePendingNotification() {
   const dispatch = useDispatch();
@@ -21,21 +21,15 @@ export function usePendingNotification() {
       let jidToOpen = pendingNotificationJid;
 
       if (!jidToOpen) {
-        try {
-          const storedJid = await AsyncStorage.getItem(PENDING_NOTIFICATION_JID_KEY);
-          if (storedJid) {
-            jidToOpen = storedJid;
-            await AsyncStorage.removeItem(PENDING_NOTIFICATION_JID_KEY);
-          }
-        } catch (error) {
-          console.error('Error reading from AsyncStorage:', error);
-        }
+        jidToOpen = await readPendingJid();
       }
 
       if (jidToOpen) {
         const room = rooms[jidToOpen];
         if (room) {
-          return;
+          dispatch(clearPendingNotificationJid());
+          AsyncStorage.removeItem(PENDING_NOTIFICATION_JID_KEY).catch(() => undefined);
+          dispatch(setCurrentRoom({ roomJID: jidToOpen }));
         }
       }
     };

package/src/i18n/strings.ts

@@ -81,6 +81,9 @@ const en: UiStringTable = {
   'action.save': 'Save',
   'action.delete': 'Delete',
   'action.leave': 'Leave',
+  'action.muted': 'Muted',
+  'action.unmuted': 'Unmuted',
+  'toast.muteFailed': 'Could not update notifications for this chat',
   'action.create': 'Create',
   'action.submit': 'Submit',
   'action.translate': 'Translate',
@@ -309,6 +312,9 @@ const fr: UiStringTable = {
   'action.save': 'Enregistrer',
   'action.delete': 'Supprimer',
   'action.leave': 'Quitter',
+  'action.muted': 'En sourdine',
+  'action.unmuted': 'Activé',
+  'toast.muteFailed': 'Impossible de modifier les notifications de ce chat',
   'action.create': 'Créer',
   'action.submit': 'Soumettre',
   'action.translate': 'Traduire',
@@ -537,6 +543,9 @@ const es: UiStringTable = {
   'action.save': 'Guardar',
   'action.delete': 'Eliminar',
   'action.leave': 'Salir',
+  'action.muted': 'Silenciado',
+  'action.unmuted': 'Activado',
+  'toast.muteFailed': 'No se pudieron cambiar las notificaciones de este chat',
   'action.create': 'Crear',
   'action.submit': 'Enviar',
   'action.translate': 'Traducir',
@@ -765,6 +774,9 @@ const pt: UiStringTable = {
   'action.save': 'Guardar',
   'action.delete': 'Eliminar',
   'action.leave': 'Sair',
+  'action.muted': 'Muted',
+  'action.unmuted': 'Unmuted',
+  'toast.muteFailed': 'Could not update notifications for this chat',
   'action.create': 'Criar',
   'action.submit': 'Enviar',
   'action.translate': 'Traduzir',
@@ -993,6 +1005,9 @@ const ht: UiStringTable = {
   'action.save': 'Anrejistre',
   'action.delete': 'Efase',
   'action.leave': 'Kite',
+  'action.muted': 'Muted',
+  'action.unmuted': 'Unmuted',
+  'toast.muteFailed': 'Could not update notifications for this chat',
   'action.create': 'Kreye',
   'action.submit': 'Soumèt',
   'action.translate': 'Tradui',
@@ -1221,6 +1236,9 @@ const zh: UiStringTable = {
   'action.save': '保存',
   'action.delete': '删除',
   'action.leave': '退出',
+  'action.muted': 'Muted',
+  'action.unmuted': 'Unmuted',
+  'toast.muteFailed': 'Could not update notifications for this chat',
   'action.create': '创建',
   'action.submit': '提交',
   'action.translate': '翻译',

package/src/main.ts

@@ -31,6 +31,9 @@ export { XmppProvider } from './context/xmppProvider';
 
 // Hooks that consumers usually need (badge counts, logout, push, etc.).
 export { useUnread } from './hooks/useUnreadMessagesCounter';
+
+export { handlePushPayload, openRoomFromPush } from './helpers/pushPayload';
+export type { PushPayloadOutcome } from './helpers/pushPayload';
 export { useChatRoomFocus } from './hooks/useChatRoomFocus';
 export { logoutService, useLogout } from './hooks/useLogout';
 export { useQRCodeChat, handleQRChatId } from './hooks/useQRCodeChatHandler';

package/src/networking/api-requests/rooms.api.ts

@@ -130,6 +130,7 @@ function dispatchRoomsFromRestItems(items: ApiRoom[]): void {
       icon: item.picture || item.icon,
       createdAt: item.createdAt,
       updatedAt: item.updatedAt,
+      muted: item.muted === true,
       description: (item as any).description,
       type: (item as any).type,
       // ChatProfileModal renders this list under the description/type
@@ -254,6 +255,14 @@ export async function postPrivateRoom(
   }
 }
 
+export async function setRoomMuted(chatName: string, muted: boolean): Promise<boolean> {
+  const token = store.getState().chatSettingStore.user.token || '';
+  const url = `/v1/chats/my/${encodeURIComponent(chatName)}/mute`;
+  const config = { headers: { Authorization: token } };
+  const response = muted ? await http.put(url, {}, config) : await http.delete(url, config);
+  return response.data?.result?.muted ?? muted;
+}
+
 export async function postReportRoom(data: PostReportRoom) {
   const { chatName, category, text } = data;
   const token = store.getState().chatSettingStore.user.token || '';

package/src/networking/xmpp/subscribeToRoomMessages.xmpp.ts

@@ -2,12 +2,14 @@ import { Client, xml } from '@xmpp/client';
 import { Element } from '@xmpp/xml';
 import { createTimeoutPromise } from './createTimeoutPromise.xmpp';
 
+let subscribeIdCounter = 0;
+
 export async function subscribeToRoomMessages(
   client: Client,
   roomJID: string,
   userNick?: string
 ): Promise<boolean> {
-  const id = `newSubscription:${Date.now().toString()}`;
+  const id = `newSubscription:${Date.now().toString(36)}-${(++subscribeIdCounter).toString(36)}`;
   let stanzaHandler: (stanza: Element) => void;
 
   const unsubscribe = () => {
@@ -33,6 +35,15 @@ export async function subscribeToRoomMessages(
         if (stanza.attrs.type === 'result') {
           finish(resolve, true);
         } else if (stanza.attrs.type === 'error') {
+          const errorEl = typeof stanza.getChild === 'function' ? stanza.getChild('error') : null;
+          const condition = errorEl?.children?.find(
+            (c: any) => c?.name && c.name !== 'text'
+          ) as Element | undefined;
+          console.warn(
+            '[PushService] MucSub subscribe error for',
+            roomJID,
+            condition?.name ?? 'unknown'
+          );
           finish(resolve, false);
         }
       }

package/src/networking/xmppClient.ts

@@ -342,6 +342,7 @@ export class XmppClient {
   }
 
   initializeClient() {
+    this.clientAlreadyStopped = false;
     try {
       const devServer = this.devServer || DEFAULT_DEV_SERVER;
       const url = `wss://${devServer}/ws`;
@@ -752,7 +753,10 @@ export class XmppClient {
       // `this.client` still points at the old client — i.e. before
       // initializeClient() reassigns it.
       const old = this.client;
-      if (old) {
+      if (old && this.clientAlreadyStopped) {
+        this.detachEventListeners();
+        this.clientAlreadyStopped = false;
+      } else if (old) {
         this.detachEventListeners();
         // NEVER await a bare stop(): on a half-dead socket (the exact case
         // we're reconnecting for) @xmpp/client's stop() can hang forever
@@ -767,6 +771,9 @@ export class XmppClient {
         await withTimeout(old.stop(), STOP_TIMEOUT_MS);
       }
       this.initializeClient();
+      if (this.suspendedForBackground) {
+        await this.stopClientQuietly();
+      }
     } finally {
       this.reconnecting = false;
     }
@@ -804,6 +811,56 @@ export class XmppClient {
     return this.credentialsRefreshInFlight;
   }
 
+  private suspendedForBackground = false;
+  private clientAlreadyStopped = false;
+
+  private async stopClientQuietly(): Promise<void> {
+    const c: any = this.client;
+    if (c) {
+      const sock = c.socket;
+      if (sock && typeof sock.end === 'function') {
+        try {
+          sock.end();
+        } catch {}
+        try {
+          if (c.status !== 'offline') c._status?.('offline');
+        } catch {}
+      } else {
+        await withTimeout(
+          Promise.resolve(c.stop()).catch(() => undefined),
+          STOP_TIMEOUT_MS
+        );
+      }
+      this.clientAlreadyStopped = true;
+    }
+    this.status = 'offline';
+    this.presencesReady = false;
+  }
+
+  async suspend(): Promise<void> {
+    if (this.suspendedForBackground) {return;}
+    this.suspendedForBackground = true;
+    this.suppressReconnect = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    await this.stopClientQuietly();
+    console.log('XMPP suspended (background).');
+  }
+
+  /** Back in the foreground: allow reconnects again and reconnect at once. */
+  resume(): void {
+    if (!this.suspendedForBackground) {return;}
+    this.suspendedForBackground = false;
+    this.suppressReconnect = false;
+    this.forceReconnect();
+  }
+
+  get isSuspended(): boolean {
+    return this.suspendedForBackground;
+  }
+
   async disconnect(options?: { suppressReconnect?: boolean }): Promise<void> {
     if (options?.suppressReconnect) {this.suppressReconnect = true;}
     return this.close();

package/src/services/pushSubscriptionService.ts

@@ -81,7 +81,9 @@ export class PushSubscriptionService {
         this.subscribedRooms.add(roomJID);
         await this.saveSubscribedRoomsToStorage();
       }
-      console.log('Successfully Subscribed to room', roomJID);
+      if (!result) {
+        console.warn('[PushService] MucSub subscribe refused for', roomJID);
+      }
       return result;
     } catch (error) {
       console.error(`[PushService] Failed to subscribe to room ${roomJID}:`, error);
@@ -92,30 +94,33 @@ export class PushSubscriptionService {
   async subscribeToRooms(
     client: Client,
     roomJIDs: string[],
-    userNick?: string
+    userNick?: string,
+    concurrency = 8
   ): Promise<void> {
     let successful = 0;
     let failed = 0;
 
-    console.log('test roomJIDs', roomJIDs);
+    await this.loadSubscribedRoomsFromStorage();
+    const pending = roomJIDs.filter((jid) => !this.subscribedRooms.has(jid));
+    if (!pending.length) {
+      return;
+    }
 
-    for (const roomJID of roomJIDs) {
-      try {
-        const result = await this.subscribeToRoom(client, roomJID, userNick);
-        console.log('test roomJID-1', result);
-        if (result) {
+    for (let i = 0; i < pending.length; i += concurrency) {
+      const batch = pending.slice(i, i + concurrency);
+      const results = await Promise.allSettled(
+        batch.map((roomJID) => this.subscribeToRoom(client, roomJID, userNick))
+      );
+      for (const r of results) {
+        if (r.status === 'fulfilled' && r.value) {
           successful++;
         } else {
           failed++;
         }
-        await new Promise(resolve => setTimeout(resolve, 100));
-      } catch (error) {
-        failed++;
-        console.error(`Failed to subscribe to room ${roomJID}:`, error);
       }
     }
 
-    console.log(`Subscribed to ${successful} rooms, ${failed} failed`);
+    console.log(`[PushService] MucSub: ${successful} rooms subscribed, ${failed} failed`);
   }
 
   async reset(): Promise<void> {

package/src/types/models/room.model.ts

@@ -79,6 +79,7 @@ export interface ApiRoom {
   jid?: string;
   participants?: number;
   icon?: string;
+  muted?: boolean;
 }
 
 export interface PostRoom {

package/src/types/types.ts

@@ -34,6 +34,7 @@ export interface IRoom {
   lastViewedTimestamp?: number;
   unreadMessages?: number;
   noMessages?: boolean;
+  muted?: boolean;
   role?: string;
   createdAt?: string | number | Date;
   updatedAt?: string | number | Date;
@@ -151,6 +152,7 @@ export interface xmppSettingsInterface {
   disableLastRead?: boolean;
   xmppPingOnSendEnabled?: boolean;
   historyQoS?: HistoryQoSConfig;
+  keepAliveInBackground?: boolean;
 }
 
 export interface InAppNotificationConfig {