@ethora/chat-component-rn 26.5.11 → 26.5.13

package/src/context/xmppProvider.tsx

@@ -37,13 +37,14 @@ import { ensureScopedChatCache } from '../helpers/ensureScopedChatCache';
 import { getRooms as prefetchRoomsViaRest } from '../networking/api-requests/rooms.api';
 import { allRoomPresences } from '../networking/xmpp/allRoomPresences.xmpp';
 import { store } from '../roomStore';
-import { logout, setStoreClient } from '../roomStore/chatSettingsSlice';
+import { logout, setStoreClient, setConfig } from '../roomStore/chatSettingsSlice';
 import {
   setLogoutState,
   setVisibleRoom,
   clearVisibleRoom,
   setLastViewedTimestamp,
   deleteRoomMessage,
+  msgSortableMs,
 } from '../roomStore/roomsSlice';
 import { runHistoryPreloadScheduler } from '../helpers/historyPreloadScheduler';
 import { asyncLocalStorage } from '../hooks/useLocalStorage';
@@ -343,6 +344,10 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
         devPushLog('rn', `initBeforeLoad: user resolved (${resolved.xmppUsername})`);
         applyResolvedUserToStore(resolved);
 
+        if (config) {
+          store.dispatch(setConfig(config));
+        }
+
         // Kick off REST /chats/my; allRoomPresences below needs the
         // room list to be in redux, otherwise it joins 0 MUCs and the
         // user receives zero realtime messages until they manually tap
@@ -598,17 +603,20 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
   // touch the chat store themselves. (Undefined = host unmounts on hide,
   // nothing to do.)
   // -----------------------------------------------------------
+  const chatWasVisibleRef = useRef(false);
   useEffect(() => {
     if (typeof isVisible !== 'boolean') {return;}
     const state = store.getState();
     const rooms = state.rooms?.rooms;
     const activeRoomJID = state.rooms?.activeRoomJID || null;
+    const wasVisible = chatWasVisibleRef.current;
+    chatWasVisibleRef.current = isVisible;
     if (isVisible) {
       if (activeRoomJID) {
         store.dispatch(setVisibleRoom({ roomJID: activeRoomJID }));
       }
     } else {
-      if (activeRoomJID) {
+      if (wasVisible && activeRoomJID) {
         store.dispatch(
           setLastViewedTimestamp({ chatJID: activeRoomJID, timestamp: Date.now() })
         );
@@ -618,8 +626,9 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
           deleteRoomMessage({ roomJID: activeRoomJID, messageId: 'delimiter-new' })
         );
       }
+
       store.dispatch(clearVisibleRoom());
-      if (client?.flushLastViewedToPrivateStoreStanza) {
+      if (wasVisible && client?.flushLastViewedToPrivateStoreStanza) {
         client
           .flushLastViewedToPrivateStoreStanza(rooms, { visibleRoomJID: activeRoomJID })
           .catch(() => {});
@@ -627,6 +636,55 @@ export const XmppProvider: React.FC<XmppProviderProps> = ({ children, config, is
     }
   }, [isVisible, client]);
 
+  useEffect(() => {
+    if (isVisible !== true) {return;}
+    let lastMessagesRef: any = null;
+    let lastStampedMs = 0;
+    let flushTimer: ReturnType<typeof setTimeout> | null = null;
+
+    const advance = () => {
+      const s = store.getState();
+      const jid = s.rooms?.activeRoomJID;
+      if (!jid) {return;}
+      const room = s.rooms?.rooms?.[jid];
+      if (!room) {return;}
+      if (room.messages === lastMessagesRef) {return;}
+      lastMessagesRef = room.messages;
+
+      let newest = 0;
+      const list = room.messages || [];
+      for (const m of list) {
+        if (!m || m.id === 'delimiter-new') {continue;}
+        const ms = msgSortableMs(m);
+        if (ms > newest) {newest = ms;}
+      }
+      if (newest <= lastStampedMs) {return;}
+      lastStampedMs = newest;
+
+      store.dispatch(
+        setLastViewedTimestamp({ chatJID: jid, timestamp: Date.now() })
+      );
+
+      if (flushTimer) {clearTimeout(flushTimer);}
+      if (client?.flushLastViewedToPrivateStoreStanza) {
+        flushTimer = setTimeout(() => {
+          client
+            .flushLastViewedToPrivateStoreStanza(store.getState().rooms?.rooms, {
+              visibleRoomJID: jid,
+            })
+            .catch(() => {});
+        }, 2000);
+      }
+    };
+
+    advance();
+    const unsub = store.subscribe(advance);
+    return () => {
+      unsub();
+      if (flushTimer) {clearTimeout(flushTimer);}
+    };
+  }, [isVisible, client]);
+
   // -----------------------------------------------------------
   // NetInfo → proactive reconnect on network restore. Without this the
   // only reconnect trigger is xmpp.js noticing the socket is dead, which

package/src/helpers/keyboardLayout.ts

@@ -2,8 +2,11 @@ type KeyboardLayoutArgs = {
   platform: string;
   configuredOffset?: number;
   bottomInset?: number;
+  keyboardVisible?: boolean;
 };
 
+export const ANDROID_INPUT_DOCK_GAP = 12;
+
 export const getKeyboardVerticalOffset = ({
   platform,
   configuredOffset = 0,
@@ -14,5 +17,6 @@ export const getKeyboardVerticalOffset = ({
 export const getInputDockPaddingBottom = ({
   platform,
   bottomInset = 0,
+  keyboardVisible = false,
 }: Omit<KeyboardLayoutArgs, 'configuredOffset'>): number =>
-  platform === 'ios' ? bottomInset : 0;
+  platform === 'ios' ? bottomInset : ANDROID_INPUT_DOCK_GAP;

package/src/helpers/mimeToExtension.ts

@@ -75,10 +75,21 @@ const AUDIO_EXTENSIONS = [
   '.mp3', '.m4a', '.wav', '.aac', '.ogg', '.flac',
   '.weba', '.webm', '.opus', '.amr', '.3gp', '.3gpp',
 ] as const;
+const IOS_AUDIO_PLAYBACK_EXTENSIONS = [
+  '.mp3', '.m4a', '.mp4', '.wav', '.aac', '.caf',
+  '.aif', '.aiff', '.amr', '.3gp', '.3gpp',
+] as const;
+const IOS_AUDIO_UNSUPPORTED_EXTENSIONS = [
+  '.webm', '.weba', '.opus', '.ogg',
+] as const;
 const AUDIO_EXT_RE = new RegExp(
   `(${AUDIO_EXTENSIONS.map((e) => e.replace('.', '\\.')).join('|')})$`,
   'i'
 );
+const IOS_AUDIO_PLAYBACK_EXT_RE = new RegExp(
+  `(${IOS_AUDIO_PLAYBACK_EXTENSIONS.map((e) => e.replace('.', '\\.')).join('|')})$`,
+  'i'
+);
 // Filename / URL substrings that strongly indicate a voice / audio
 // payload even without an explicit audio extension — e.g. a web-app
 // voicemail uploaded as application/octet-stream named "voicemail-…".
@@ -95,16 +106,36 @@ const AUDIO_NAME_HINT_RE =
 export function isLikelyAudio(
   mime: string | undefined | null,
   fileName?: string | null,
-  url?: string | null
+  url?: string | null,
+  opts?: {
+    duration?: number | string | null;
+    waveForm?: string | null;
+    originalName?: string | null;
+  }
 ): boolean {
   const m = (mime || '').toLowerCase();
   if (m.startsWith('audio/')) {return true;}
+  const durationNum =
+    typeof opts?.duration === 'string'
+      ? Number(opts.duration)
+      : opts?.duration ?? 0;
+  if (Number.isFinite(durationNum) && durationNum > 0) {return true;}
+  if (typeof opts?.waveForm === 'string' && opts.waveForm.trim().length > 0) {
+    return true;
+  }
   // For octet-stream (and any other non-audio mime) fall through to the
   // filename / URL heuristics. We don't restrict to octet-stream — some
   // backends send no mime at all, or send text/plain by accident.
   const name = (fileName || '').toLowerCase();
+  const originalName = (opts?.originalName || '').toLowerCase();
   const urlLast = filenameFromUrl(url).toLowerCase();
-  if (AUDIO_EXT_RE.test(name) || AUDIO_EXT_RE.test(urlLast)) {return true;}
+  if (
+    AUDIO_EXT_RE.test(name) ||
+    AUDIO_EXT_RE.test(originalName) ||
+    AUDIO_EXT_RE.test(urlLast)
+  ) {
+    return true;
+  }
   // Last resort: voice-message naming hint anywhere in the filename, the
   // URL's last segment, OR the URL's full path. Voicemails are commonly
   // hosted under `/voice/abc-123` or `/voicemail/abc-123` where the last
@@ -120,6 +151,7 @@ export function isLikelyAudio(
   })();
   if (
     AUDIO_NAME_HINT_RE.test(name) ||
+    AUDIO_NAME_HINT_RE.test(originalName) ||
     AUDIO_NAME_HINT_RE.test(urlLast) ||
     AUDIO_NAME_HINT_RE.test(urlPath)
   ) {
@@ -156,6 +188,88 @@ export function filenameFromUrl(url: string | undefined | null): string {
   }
 }
 
+const getLowerExtension = (value: string | undefined | null) => {
+  if (!value) {return '';}
+  const match = value.toLowerCase().match(VALID_EXT_RE);
+  return match ? match[0] : '';
+};
+
+/**
+ * AVFoundation on iOS is stricter than browsers: a remote URL served as
+ * `application/octet-stream` with an opaque `.bin` name may fail before
+ * probing the actual audio payload. When the payload already looks like
+ * audio, cache it locally with an iOS-playable extension before playback.
+ */
+export function shouldCacheAudioForIosPlayback(opts: {
+  src?: string | null;
+  mime?: string | null;
+  fileName?: string | null;
+  originalName?: string | null;
+  duration?: number | string | null;
+  waveForm?: string | null;
+}): boolean {
+  const src = opts.src || '';
+  if (!/^https?:\/\//i.test(src)) {return false;}
+
+  const mime = (opts.mime || '').toLowerCase().split(';')[0]!.trim();
+  const urlName = filenameFromUrl(src);
+  const candidates = [urlName, opts.fileName || '', opts.originalName || ''];
+  const hasIosPlayableName = candidates.some((value) =>
+    IOS_AUDIO_PLAYBACK_EXT_RE.test(value)
+  );
+  if (hasIosPlayableName && mime.startsWith('audio/')) {return false;}
+
+  return isLikelyAudio(mime, opts.fileName, src, {
+    duration: opts.duration,
+    waveForm: opts.waveForm,
+    originalName: opts.originalName,
+  });
+}
+
+export function getIosAudioPlaybackCacheExtension(opts: {
+  mime?: string | null;
+  fileName?: string | null;
+  originalName?: string | null;
+  url?: string | null;
+}): string {
+  const candidates = [
+    opts.fileName,
+    opts.originalName,
+    filenameFromUrl(opts.url),
+    getExtensionForMime(opts.mime),
+  ];
+  for (const candidate of candidates) {
+    const ext = getLowerExtension(candidate);
+    if (ext && IOS_AUDIO_PLAYBACK_EXT_RE.test(ext)) {
+      return ext === '.mp4' ? '.m4a' : ext;
+    }
+  }
+  return '.m4a';
+}
+
+export function isUnsupportedAudioForIosPlayback(opts: {
+  mime?: string | null;
+  fileName?: string | null;
+  originalName?: string | null;
+  url?: string | null;
+}): boolean {
+  const mime = (opts.mime || '').toLowerCase().split(';')[0]!.trim();
+  if (mime === 'audio/webm' || mime === 'audio/ogg') {
+    return true;
+  }
+  const candidates = [
+    opts.fileName,
+    opts.originalName,
+    filenameFromUrl(opts.url),
+  ];
+  return candidates.some((candidate) => {
+    const ext = getLowerExtension(candidate);
+    return IOS_AUDIO_UNSUPPORTED_EXTENSIONS.includes(
+      ext as (typeof IOS_AUDIO_UNSUPPORTED_EXTENSIONS)[number]
+    );
+  });
+}
+
 /**
  * Ensures `fileName` ends with a valid extension. Strategy:
  *   1. If the input already has an extension, return it unchanged.

package/src/hooks/useEventHandlers.tsx

@@ -57,7 +57,7 @@ export const useEventHandlers = (config?: IConfig): EventHandlersHook => {
         if (config?.eventHandlers?.onMessageFailed) {
           config.eventHandlers.onMessageFailed(event);
         }
-        console.error('Message failed details:', {
+        console.warn('Message failed details:', {
           message: event.message,
           roomJID: event.roomJID,
           messageType: event.messageType,

package/src/hooks/useSendMessage.tsx

@@ -313,6 +313,11 @@ export const useSendMessage = (_configOverride?: IConfig) => {
         `${user?.firstName || ''} ${user?.lastName || ''}`.trim() || selfId;
       const fileSizeStr = data?.size != null ? String(data.size) : '';
 
+      const normalizedFileUri =
+        typeof data?.uri === 'string'
+          ? data.uri.replace(/^assets-library:\/\//, 'file://')
+          : '';
+
       if (!config?.disableSentLogic && !existingId) {
         dispatch(
           addRoomMessage({
@@ -335,8 +340,8 @@ export const useSendMessage = (_configOverride?: IConfig) => {
               isSystemMessage: 'false',
               isMediafile: 'true',
               fileName: data?.name,
-              location: '',
-              locationPreview: '',
+              location: normalizedFileUri,
+              locationPreview: normalizedFileUri,
               mimetype: type,
               originalName: data?.name,
               size: fileSizeStr,
@@ -408,10 +413,7 @@ export const useSendMessage = (_configOverride?: IConfig) => {
       // legacy library items — those can't be read as files. Coerce
       // to a file:// scheme when possible so the body is a real blob.
       const fileBlob = {
-        uri:
-          typeof data?.uri === 'string'
-            ? data.uri.replace(/^assets-library:\/\//, 'file://')
-            : data?.uri,
+        uri: normalizedFileUri || data?.uri,
         type:
           data?.type ||
           data?.mimeType ||
@@ -492,6 +494,10 @@ export const useSendMessage = (_configOverride?: IConfig) => {
               store.getState()?.chatSettingStore?.client,
             ].find((c: any) => c && c.status === 'online');
           if (effectiveMediaClient) {
+            effectiveMediaClient.setActiveRoomJid?.(activeRoomJID);
+            await Promise.resolve(
+              effectiveMediaClient.prioritizeRoomPresence?.(activeRoomJID)
+            ).catch(() => false);
             effectiveMediaClient.sendMediaMessageStanza(
               activeRoomJID,
               messagePayload,

package/src/networking/xmppClient.ts

@@ -23,6 +23,8 @@ import { getRooms } from './xmpp/getRooms.xmpp';
 import { handleStanza } from './xmpp/handleStanzas.xmpp';
 import { pushLog as devPushLog } from '../utils/devLogger';
 import { normalizeRoomJid } from '../helpers/normalizeRoomJid';
+import { store } from '../roomStore';
+import { applyPrivateStoreMarkers } from '../roomStore/roomsSlice';
 import {
   clearOutboundSends,
   enqueueOutboundSend,
@@ -870,7 +872,28 @@ export class XmppClient {
   getChatsPrivateStoreRequestStanza = async () => {
     if (this.disableLastRead) {return null;}
     try {
-      return await getChatsPrivateStoreRequest(this.client);
+      const markers = await getChatsPrivateStoreRequest(this.client);
+      // Hydrate the fetched server-side read markers into redux. Without
+      // this the markers were fetched on every init/reconnect and then
+      // silently dropped, so any room the user hadn't locally opened+left
+      // this session kept `lastViewedTimestamp: 0` and the unread
+      // middleware's `> 0` gate skipped it forever — `useUnread()` stayed
+      // at 0 with no badge. Done here on the single READ method so every
+      // caller (provider init, reconnect, ChatWrapper, push handlers, …)
+      // hydrates automatically and a future caller can't reintroduce the
+      // drop. The write helpers call the lower-level
+      // `getChatsPrivateStoreRequest` directly and intentionally skip this.
+      if (markers && typeof markers === 'object') {
+        const normalized: Record<string, number> = {};
+        for (const jid of Object.keys(markers as Record<string, unknown>)) {
+          const n = Number((markers as Record<string, unknown>)[jid]);
+          if (jid && Number.isFinite(n) && n > 0) {normalized[jid] = n;}
+        }
+        if (Object.keys(normalized).length > 0) {
+          store.dispatch(applyPrivateStoreMarkers(normalized));
+        }
+      }
+      return markers;
     } catch (error) {
       console.log(error);
       return null;

package/src/roomStore/Middleware/unreadMidlleware.tsx

@@ -64,6 +64,10 @@ const TRIGGER_ACTIONS = new Set([
   'roomMessages/setRoomMessages',
   'roomMessages/editRoomMessage',
   'roomMessages/setLastViewedTimestamp',
+  // Hydrating server-side read markers can move several rooms' baselines
+  // at once; recompute so the badges reflect the freshly-applied markers
+  // (with own-message filtering this middleware adds on top).
+  'roomMessages/applyPrivateStoreMarkers',
   'roomMessages/setCurrentRoom',
   'roomMessages/setVisibleRoom',
   'roomMessages/clearVisibleRoom',
@@ -130,14 +134,13 @@ export const unreadMiddleware: Middleware =
         }
         if (!(room.lastViewedTimestamp > 0)) {return;}
 
-        // Fingerprint = "what would affect the answer". If neither the
-        // message count nor the lastViewedTimestamp changed since last
-        // time we computed, the answer is stable; skip the walk. (The
-        // previous version tracked only message count, so changing
-        // lastViewedTimestamp without a new message dropped the
-        // recompute silently — the unread badge could go stale.)
-        const currentMessagesLength = room.messages?.length || 0;
-        const fingerprint = `${currentMessagesLength}|${room.lastViewedTimestamp || 0}`;
+        const msgs = room.messages;
+        const currentMessagesLength = msgs?.length || 0;
+        const firstId = currentMessagesLength ? String(msgs![0]?.id ?? '') : '';
+        const lastId = currentMessagesLength
+          ? String(msgs![currentMessagesLength - 1]?.id ?? '')
+          : '';
+        const fingerprint = `${currentMessagesLength}|${room.lastViewedTimestamp || 0}|${firstId}|${lastId}`;
         if (triggerCache[jid] === fingerprint) {return;}
         triggerCache[jid] = fingerprint;
 

package/src/roomStore/roomsSlice.ts

@@ -98,6 +98,12 @@ export interface RoomMessagesState {
   loadingText?: string;
   usersSet?: Record<string, any>;
   pendingNotificationJid?: string | null;
+  // Server-side read markers fetched from the XMPP private store
+  // (`{ roomJID: lastViewedMs }`). Kept here so a room that loads AFTER
+  // the markers were fetched still inherits its baseline via `addRoom`
+  // — see `applyPrivateStoreMarkers`. Re-fetched every init/reconnect,
+  // so it is intentionally NOT persisted.
+  privateStoreMarkers: Record<string, number>;
 }
 
 const initialState: RoomMessagesState = {
@@ -112,6 +118,7 @@ const initialState: RoomMessagesState = {
     text: '',
   },
   pendingNotificationJid: null,
+  privateStoreMarkers: {},
 };
 
 const isValidRoomJid = (jid: unknown): jid is string => {
@@ -160,11 +167,19 @@ const reducers = {
       // the previous session, so cold-start showed no unread badge for
       // messages received while the app was closed (bug #19/#20). A real
       // (non-zero) explicit value still wins; otherwise keep the existing
-      // value; otherwise anchor to the newest message in the payload.
+      // value; otherwise fall back to the server-side read marker fetched
+      // from the private store (so a room the user has NEVER opened this
+      // session still gets a real baseline — without it the unread
+      // middleware's `lastViewedTimestamp > 0` gate skipped the room
+      // forever and the badge never lit up); otherwise anchor to the
+      // newest message in the payload.
+      const serverMarker = state.privateStoreMarkers?.[roomData.jid] || 0;
       if (roomData.lastViewedTimestamp != null && roomData.lastViewedTimestamp !== 0) {
         lastViewed = roomData.lastViewedTimestamp;
-      } else if (existing?.lastViewedTimestamp != null) {
+      } else if (existing?.lastViewedTimestamp != null && existing.lastViewedTimestamp > 0) {
         lastViewed = existing.lastViewedTimestamp;
+      } else if (serverMarker > 0) {
+        lastViewed = serverMarker;
       } else {
         const msgs = roomData.messages || [];
         let newest = 0;
@@ -346,6 +361,7 @@ const reducers = {
     deleteAllRooms(state: WritableDraft<RoomMessagesState>) {
       state.rooms = {};
       state.visibleRoomJID = null;
+      state.privateStoreMarkers = {};
     },
     setComposing(
       state: WritableDraft<RoomMessagesState>,
@@ -392,6 +408,45 @@ const reducers = {
         }
       }
     },
+    /**
+     * Apply server-side read markers fetched from the XMPP private store
+     * (`{ roomJID: lastViewedMs }`) to redux. This is the hydration that
+     * was missing: `getChatsPrivateStoreRequest` fetched the markers on
+     * every init/reconnect and every caller then DISCARDED the result, so
+     * rooms kept `lastViewedTimestamp: 0` and the unread middleware's
+     * `> 0` gate skipped them forever — `useUnread()` stayed at 0 for any
+     * room the user hadn't locally opened+left this session. Centralised
+     * here (and consulted by `addRoom`) so BOTH already-loaded rooms and
+     * rooms that load later pick up the baseline.
+     *
+     * Monotonic: a marker only ever moves a baseline FORWARD, so a stale
+     * server value can't resurrect already-read messages and a more-recent
+     * local read (tab blur stamping Date.now()) always wins.
+     */
+    applyPrivateStoreMarkers: (
+      state: WritableDraft<RoomMessagesState>,
+      action: PayloadAction<Record<string, number>>
+    ) => {
+      const markers = action.payload;
+      if (!markers || typeof markers !== 'object') {return;}
+      if (!state.privateStoreMarkers) {state.privateStoreMarkers = {};}
+      for (const jid of Object.keys(markers)) {
+        const ts = Number(markers[jid]);
+        if (!jid || !Number.isFinite(ts) || ts <= 0) {continue;}
+        // Remember the marker so rooms that load LATER (via addRoom)
+        // inherit it even though they don't exist in the store yet.
+        if (ts > (state.privateStoreMarkers[jid] || 0)) {
+          state.privateStoreMarkers[jid] = ts;
+        }
+        // Upgrade an already-loaded room's baseline + recompute its badge.
+        // Only ever forward, so a later local read isn't clobbered.
+        const room = state.rooms[jid];
+        if (room && ts > (room.lastViewedTimestamp || 0)) {
+          room.lastViewedTimestamp = ts;
+          room.unreadMessages = countNewerMessages(room.messages, ts);
+        }
+      }
+    },
     setRoomRole: (
       state: WritableDraft<RoomMessagesState>,
       action: PayloadAction<{ chatJID: string; role: string }>
@@ -429,7 +484,14 @@ const reducers = {
       }
     },
     clearVisibleRoom: (state: WritableDraft<RoomMessagesState>) => {
+      const jid = state.visibleRoomJID;
       state.visibleRoomJID = null;
+   
+      if (jid && state.rooms[jid]) {
+        const room = state.rooms[jid];
+        const t = room.lastViewedTimestamp || 0;
+        room.unreadMessages = t > 0 ? countNewerMessages(room.messages, t) : 0;
+      }
     },
     /**
      * Stash a JID that a push notification asked us to open before
@@ -476,6 +538,7 @@ const reducers = {
       state.activeRoomJID = null;
       state.visibleRoomJID = null;
       state.isLoading = false;
+      state.privateStoreMarkers = {};
     },
     setActiveMessage: (
       state: WritableDraft<RoomMessagesState>,
@@ -667,6 +730,7 @@ export const {
   setComposing,
   setIsLoading,
   setLastViewedTimestamp,
+  applyPrivateStoreMarkers,
   setRoomNoMessages,
   setCurrentRoom,
   setVisibleRoom,

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

@@ -6,4 +6,7 @@ export interface ModalFile {
   fileName: string;
   fileURL: string;
   mimetype: string;
+  originalName?: string;
+  duration?: number | string;
+  waveForm?: string;
 }

package/src/types/types.ts

@@ -248,6 +248,16 @@ export interface IConfig {
   // ----- header / nav -----
   disableHeader?: boolean;
   disableMedia?: boolean;
+  /**
+   * Enable in-chat voice-message recording. **Opt-in — off by default.**
+   * When `true`, an idle input (no text, no attachments) shows a
+   * microphone in the send-button slot; tap → start recording → stop &
+   * send. iOS apps need `NSMicrophoneUsageDescription` in Info.plist
+   * (add via `expo-av`'s plugin block in `app.json`). Receiving voice
+   * messages from other clients (incl. legacy web `.bin` voicemails) is
+   * independent of this flag — incoming audio plays regardless.
+   */
+  enableAudio?: boolean;
   chatHeaderBurgerMenu?: boolean;
   // Hide the burger icon entirely (the icon that opens the chatHeader-
   // BurgerMenu dropdown). `chatHeaderBurgerMenu` controls dropdown
@@ -362,6 +372,25 @@ export interface IConfig {
   chatRoomStyles?: ViewStyle;
 
   keyboardVerticalOffset?: number;
+  // Opt OUT of the built-in keyboard handling. By default <Chat> mounts
+  // its own react-native-keyboard-controller KeyboardProvider +
+  // KeyboardAvoidingView (behavior="padding"). If the HOST app already
+  // wraps <Chat> in its own KeyboardProvider / KeyboardAvoidingView, the
+  // built-in one becomes a SECOND avoider over the same tree — two of them
+  // animating padding on keyboard open is the Android flicker in bug #6.
+  // Set this so the component renders a plain View instead and drops its
+  // KeyboardProvider, leaving the host to own keyboard handling outright.
+  disableKeyboardAvoidingView?: boolean;
+  // Built-in keyboard strategy: instead of the default KeyboardAvoidingView
+  // (which adds bottom padding to the WHOLE chat tree — the message list
+  // reflows on keyboard open, the Android "messages jump/flash" in bug #6),
+  // wrap ONLY the input dock in a react-native-keyboard-controller
+  // KeyboardStickyView so just the input tracks the keyboard and the list
+  // is never resized. Best for edge-to-edge Android hosts (where the OS
+  // doesn't also resize the window). Ignored when
+  // `disableKeyboardAvoidingView` is set. Needs on-device tuning of any
+  // `keyboardVerticalOffset`.
+  keyboardStickyInput?: boolean;
 
   // ----- interactions / messages -----
   disableInteractions?: boolean;
@@ -517,6 +546,9 @@ export interface ModalFile {
   fileName: string;
   fileURL: string;
   mimetype: string;
+  originalName?: string;
+  duration?: number | string;
+  waveForm?: string;
 }
 
 // Re-export so middleware/hooks that historically import from `types`