@ethora/chat-component-rn 26.7.6 → 26.7.7

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/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/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/types.ts

@@ -151,6 +151,7 @@ export interface xmppSettingsInterface {
   disableLastRead?: boolean;
   xmppPingOnSendEnabled?: boolean;
   historyQoS?: HistoryQoSConfig;
+  keepAliveInBackground?: boolean;
 }
 
 export interface InAppNotificationConfig {