@ethora/chat-component-rn 26.7.5 → 26.7.7

package/src/networking/xmppClient.ts

@@ -211,13 +211,6 @@ export class XmppClient {
       this.devServer = xmppSettings?.devServer;
     }
     this.disableLastRead = this.xmppSettings?.disableLastRead === true;
-    // `xmppPingOnSendEnabled` was declared in the public settings type but
-    // never read. It now controls the SEND-path liveness probe only; the
-    // periodic watchdog and the NetInfo check always run, so turning this
-    // off cannot leave a zombie socket undetected — it only removes the
-    // extra probe a send would otherwise trigger. Defaults to on
-    // (previous behaviour), just throttled and confirmation-gated now.
-    this.pingOnSendEnabled = this.xmppSettings?.xmppPingOnSendEnabled !== false;
 
     const qos = this.xmppSettings?.historyQoS;
     if (qos) {
@@ -349,6 +342,7 @@ export class XmppClient {
   }
 
   initializeClient() {
+    this.clientAlreadyStopped = false;
     try {
       const devServer = this.devServer || DEFAULT_DEV_SERVER;
       const url = `wss://${devServer}/ws`;
@@ -501,10 +495,6 @@ export class XmppClient {
       this.status = 'online';
       this.presencesReady = true;
       this.reconnectAttempts = 0;
-      // Fresh stream: forget any probe failures from the dead one, and
-      // don't let the throttle suppress the first probe on it.
-      this.failedProbeStreak = 0;
-      this.lastStreamProbeAt = 0;
       try {
         devPushLog(
           'xmpp',
@@ -666,54 +656,8 @@ export class XmppClient {
   }
 
   private streamAliveProbe: Promise<boolean> | null = null;
-  /** Wall-clock of the last probe, for throttling. */
-  private lastStreamProbeAt = 0;
-  /** Consecutive failed probes; a reconnect needs confirmation, not one miss. */
-  private failedProbeStreak = 0;
-
-  // --- liveness-probe tuning -------------------------------------------
-  // The probe exists to catch a ZOMBIE socket: the WebSocket still reads
-  // `online` but nothing traverses it (iOS suspending a backgrounded
-  // socket, the JS debugger pausing the runtime). Without it the client
-  // sits "online" forever and every send silently vanishes.
-  //
-  // The original settings were far too trigger-happy: a 4s budget for a
-  // ping round-trip, fired after EVERY send, with a single timeout
-  // immediately calling `forceReconnect()` — a full teardown, rebuild,
-  // MUC re-join and private-store refetch. On a slow or congested mobile
-  // link a perfectly healthy but quiet stream would miss that 4s window
-  // and get torn down mid-conversation, repeatedly. (That reconnect is
-  // also what used to replay the outbound queue and duplicate a message
-  // that had already been delivered — customer-reported #31.)
-  //
-  // Tuned to: a realistic timeout, a throttle so bursts of sends can't
-  // each start a probe, and a required second failure before we tear a
-  // connection down. Zombie sockets fail every probe, so they are still
-  // caught — just after confirmation rather than on one unlucky RTT.
-  /** Per-probe budget. 4s was under a slow-network ping RTT. */
-  private streamProbeTimeoutMs = 10_000;
-  /** Minimum gap between probes, so a burst of sends probes at most once. */
-  private minStreamProbeIntervalMs = 15_000;
-  /** Delay before the confirmation probe that a teardown requires. */
-  private streamProbeConfirmDelayMs = 2_000;
-  /** Failures needed before `forceReconnect()`. */
-  private streamProbeFailuresForReconnect = 2;
-  /** Host opt-out for the send-path probe (`xmppPingOnSendEnabled`). */
-  private pingOnSendEnabled = true;
 
-  /**
-   * Send-path liveness check. Throttled and skippable by config — unlike
-   * the watchdog, this fires from user activity and must not turn a chatty
-   * room into a probe storm.
-   */
-  ensureStreamAliveAfterSend(): void {
-    if (!this.pingOnSendEnabled) {return;}
-    this.ensureStreamAlive({ reason: 'send' }).catch(() => {});
-  }
-
-  verifyStreamAlive(
-    timeoutMs: number = this.streamProbeTimeoutMs
-  ): Promise<boolean> {
+  verifyStreamAlive(timeoutMs: number = 4000): Promise<boolean> {
     if (this.status !== 'online' || !this.client) {
       return Promise.resolve(false);
     }
@@ -745,70 +689,16 @@ export class XmppClient {
     return this.streamAliveProbe;
   }
 
-  /**
-   * Check that the stream is really carrying traffic, and tear it down only
-   * if that is confirmed false.
-   *
-   * `force` skips the throttle — used by the periodic watchdog and the
-   * NetInfo "we're reachable again" signal, which are already rare and
-   * genuinely want to know right now. Send-path callers leave it off so a
-   * burst of messages triggers at most one probe.
-   */
-  async ensureStreamAlive(opts?: {
-    force?: boolean;
-    reason?: string;
-  }): Promise<void> {
+  async ensureStreamAlive(timeoutMs: number = 4000): Promise<void> {
     if (this.suppressReconnect || this.status !== 'online') {return;}
-
-    const now = Date.now();
-    if (
-      !opts?.force &&
-      now - this.lastStreamProbeAt < this.minStreamProbeIntervalMs
-    ) {
-      // Probed recently — a healthy answer is still fresh, and a dead
-      // socket will be caught by the next watchdog tick anyway.
-      return;
-    }
-    this.lastStreamProbeAt = now;
-
-    const alive = await this.verifyStreamAlive();
-
-    // Re-check state: a reconnect may have started while we waited.
-    if (this.status !== 'online' || this.suppressReconnect) {return;}
-
-    if (alive) {
-      this.failedProbeStreak = 0;
-      return;
-    }
-
-    this.failedProbeStreak += 1;
-    if (this.failedProbeStreak < this.streamProbeFailuresForReconnect) {
-      // One missed probe is not proof of a dead socket — a congested link
-      // or a busy server can blow the budget on a stream that is fine.
-      // Confirm with a second probe shortly, instead of tearing down a
-      // working connection on a single unlucky round trip.
+    const alive = await this.verifyStreamAlive(timeoutMs);
+    // Re-check state: a reconnect may have started meanwhile.
+    if (!alive && this.status === 'online' && !this.suppressReconnect) {
       try {
-        devPushLog(
-          'xmpp',
-          `stream probe missed (${this.failedProbeStreak}/${this.streamProbeFailuresForReconnect}) — confirming before reconnect`
-        );
+        devPushLog('xmpp', 'stream is zombie (ping unanswered) → forceReconnect');
       } catch {}
-      setTimeout(() => {
-        this.ensureStreamAlive({ force: true, reason: 'probe-confirm' }).catch(
-          () => {}
-        );
-      }, this.streamProbeConfirmDelayMs);
-      return;
+      this.forceReconnect();
     }
-
-    this.failedProbeStreak = 0;
-    try {
-      devPushLog(
-        'xmpp',
-        'stream is zombie (probe unanswered twice) → forceReconnect'
-      );
-    } catch {}
-    this.forceReconnect();
   }
 
   async reconnect() {
@@ -863,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
@@ -878,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;
     }
@@ -915,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/roomStore/chatSettingsSlice.ts

@@ -33,7 +33,9 @@ export interface ChatState {
 
 export const unpackAndTransform = (input?: User): User => {
   return {
-    description: '',
+    // Was hardcoded to '' — every setUser dropped the user's own bio, so
+    // the profile's About section could never show one.
+    description: input?.description || '',
     token: input?.token || '',
     profileImage: input?.profileImage || '',
     _id: input?._id || '',

package/src/roomStore/roomsSlice.ts

@@ -317,6 +317,8 @@ const reducers = {
         : [];
       state.rooms[roomData.jid] = {
         ...roomData,
+        icon: roomData.icon !== undefined ? roomData.icon : existing?.icon,
+        roomBg: roomData.roomBg !== undefined ? roomData.roomBg : existing?.roomBg,
         messages:
           existingMessages.length > 0 ? existingMessages : incomingMessages,
         lastViewedTimestamp: lastViewed,
@@ -543,25 +545,6 @@ const reducers = {
     ) => {
       state.isUnreadSyncing = action.payload;
     },
-    /**
-     * Records how far the user has actually read in a room: the timestamp
-     * of the newest message they had reached when they scrolled away from
-     * the bottom, or `null` while they are at the bottom.
-     *
-     * Written only by MessageList as the user scrolls. Deliberately does
-     * NOT touch `unreadMessages` or `lastViewedTimestamp` — it only tells
-     * the various "mark this room read" paths what value to stamp instead
-     * of `Date.now()`. Customer-reported #33.
-     */
-    setReadBoundary: (
-      state: WritableDraft<RoomMessagesState>,
-      action: PayloadAction<{ chatJID: string; boundaryTs: number | null }>
-    ) => {
-      const { chatJID, boundaryTs } = action.payload;
-      if (state.rooms[chatJID]) {
-        state.rooms[chatJID].readBoundaryTs = boundaryTs;
-      }
-    },
     setLastViewedTimestamp: (
       state: WritableDraft<RoomMessagesState>,
       action: PayloadAction<{ chatJID: string; timestamp: number }>
@@ -918,7 +901,6 @@ export const {
   setIsLoading,
   setUnreadSyncing,
   setLastViewedTimestamp,
-  setReadBoundary,
   applyPrivateStoreMarkers,
   setRoomNoMessages,
   setCurrentRoom,

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

@@ -50,21 +50,6 @@ export interface IRoom {
   composingList?: string[];
   lastViewedTimestamp?: number;
   unreadMessages?: number;
-  /**
-   * Timestamp of the newest message the user had actually reached when
-   * they scrolled away from the bottom of this room, or null/undefined
-   * while they are at the bottom (everything on screen is read).
-   *
-   * Lives in the store rather than in ChatRoom's local state because
-   * several code paths outside the component mark a room read — the
-   * AppState background handler, the `isVisible` consumer signal, the
-   * visible-room auto-advance, `useChatRoomFocus` — and all of them must
-   * stamp what the user actually saw instead of `Date.now()`. Stamping
-   * "now" while they are scrolled up silently destroys unread messages,
-   * and because those paths also flush to the server-side private store
-   * the loss survives an app restart. Customer-reported #33.
-   */
-  readBoundaryTs?: number | null;
   noMessages?: boolean;
   role?: string;
 

package/src/types/types.ts

@@ -33,21 +33,6 @@ export interface IRoom {
   composingList?: string[];
   lastViewedTimestamp?: number;
   unreadMessages?: number;
-  /**
-   * Timestamp of the newest message the user had actually reached when
-   * they scrolled away from the bottom of this room; null/undefined while
-   * they are at the bottom (everything on screen is read).
-   *
-   * Written only by MessageList as the user scrolls. Every path that marks
-   * a room read must prefer this over `Date.now()` — the AppState
-   * background handler, the `isVisible` consumer signal, the visible-room
-   * auto-advance, `useChatRoomFocus` and logout all flush to the
-   * server-side private store, so stamping "now" while the user is
-   * scrolled up destroys unread messages permanently (survives an app
-   * restart, because the bad marker comes back from the server).
-   * Customer-reported #33.
-   */
-  readBoundaryTs?: number | null;
   noMessages?: boolean;
   role?: string;
   createdAt?: string | number | Date;
@@ -166,6 +151,7 @@ export interface xmppSettingsInterface {
   disableLastRead?: boolean;
   xmppPingOnSendEnabled?: boolean;
   historyQoS?: HistoryQoSConfig;
+  keepAliveInBackground?: boolean;
 }
 
 export interface InAppNotificationConfig {
@@ -325,13 +311,16 @@ export interface TypographyConfig {
   };
   /** Attach (photo/document picker) bottom sheet. */
   attachSheet?: {
-    /** "Attach" header label. Default 13 / "600". */
+    /** "Photos & Videos" section header. Default 17 / "700". */
     title?: ChatTextStyle;
-    /** Row labels (Camera / Gallery / Document). Default 16 / "500". */
+    /** "View Library" link next to the section header. Default 15 / "500". */
+    viewLibrary?: ChatTextStyle;
+    /** Row labels ("Upload a File"). Default 16 / "500". */
     rowLabel?: ChatTextStyle;
-    /** Grey hint under each row. Default 12. */
+    /** @deprecated Rows no longer render a hint line. */
     rowHint?: ChatTextStyle;
-    /** Cancel button. Default 16 / "600". */
+    /** @deprecated The sheet has no Cancel button — it closes by tapping
+     * the backdrop, dragging it down, or the hardware back gesture. */
     cancelButton?: ChatTextStyle;
   };
 
@@ -409,6 +398,16 @@ export interface IConfig {
      * value takes effect.
      */
     height?: number;
+    /**
+     * Extend the header cards (room list + chat) under the status bar:
+     * each pads its top by the safe-area inset and paints it white, so
+     * the card and the status-bar band are one surface. Use this instead
+     * of wrapping `<Chat>` in a top-edge SafeAreaView: a host-side white
+     * band above the card shows a hairline seam where the card's
+     * shadow/elevation starts. Off by default (hosts that already pad the
+     * top keep their layout).
+     */
+    safeAreaTop?: boolean;
   };
   disableHeader?: boolean;
   disableMedia?: boolean;
@@ -437,7 +436,7 @@ export interface IConfig {
   hideMemberSendMessageAction?: boolean; // hides only "Message"
   hideMemberCopyIdAction?: boolean;      // hides only "Copy User Id"
   chatHeaderAdditional?: { enabled: boolean; element: any };
-  headerMenu?: () => void;
+  headerMenu?: (() => void) | boolean;
   headerChatMenu?: () => void;
   chatHeaderSettings?: {
     hide?: boolean;
@@ -469,6 +468,20 @@ export interface IConfig {
     loginFunction: () => Promise<User | null>;
   };
   defaultLogin?: boolean;
+  logout?: {
+    enabled: boolean;
+    label?: string;
+    confirm?:
+      | boolean
+      | {
+          title?: string;
+          message?: string;
+          confirmText?: string;
+          cancelText?: string;
+        };
+    onBeforeLogout?: () => Promise<boolean | void> | boolean | void;
+    onAfterLogout?: () => Promise<void> | void;
+  };
   refreshTokens?: {
     enabled: boolean;
     /**