@ethora/chat-component-rn 26.5.10 → 26.5.12

package/src/context/xmppProvider.tsx

@@ -598,17 +598,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 +621,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(() => {});

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

@@ -64,6 +64,102 @@ const MIME_TO_EXT: Record<string, string> = {
 
 const VALID_EXT_RE = /\.[a-z0-9]{1,8}$/i;
 
+// Audio file extensions we recognise across the SDK. Used for the
+// "looks like audio even when the mimetype is application/octet-stream"
+// heuristic in MediaMessage / FilePreviewModal. Voice-message senders
+// (web app, push voice memos) sometimes ship audio as octet-stream with
+// no audio mime — sniffing the extension lets us still play it.
+// `.bin` is intentionally NOT here: it's our own fallback extension for
+// truly unknown payloads (see getExtensionForMime), not a real format.
+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-…".
+const AUDIO_NAME_HINT_RE =
+  /(?:^|[_\-./])(voice|voicemail|audio|audio-message|audiomessage|recording|voice-?note)(?:[_\-./]|$)/i;
+
+/**
+ * Returns true when the (mime, fileName, url) triple looks like an
+ * audio payload — either by mime, by recognised extension on the
+ * filename or URL path, or by a voice-message naming hint. The hint
+ * branch is what catches voicemails sent as `application/octet-stream`
+ * with a generic `.bin` filename (customer-reported #9 voicemail).
+ */
+export function isLikelyAudio(
+  mime: string | undefined | null,
+  fileName?: 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(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
+  // segment is an opaque id with no hint by itself.
+  const urlPath = (() => {
+    if (!url) {return '';}
+    try {
+      const noQuery = url.split('?')[0]!.split('#')[0]!;
+      return decodeURIComponent(noQuery).toLowerCase();
+    } catch {
+      return '';
+    }
+  })();
+  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)
+  ) {
+    return true;
+  }
+  return false;
+}
+
 /**
  * Returns the conventional extension (including the leading dot) for a
  * MIME type, or `.bin` as a last-resort fallback so callers never end up
@@ -92,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/useLogout.tsx

@@ -134,18 +134,41 @@ const logoutService = {
   },
 };
 
-export const useLogout = () => {
-  const dispatch = useDispatch();
+/**
+ * Hook that returns an awaitable logout function.
+ *
+ * ```tsx
+ * const logout = useLogout();
+ * await logout();
+ * navigation.replace('SignIn'); // disk is provably clean here
+ * ```
+ *
+ * The returned function resolves AFTER all teardown work has landed:
+ * XMPP disconnect, redux reset, persisted slices wiped, stray
+ * AsyncStorage keys removed, REST cache cleared. It never rejects —
+ * any internal failure is logged via console.warn so a fire-and-forget
+ * `logout()` call (no `await`) still won't crash the host.
+ *
+ * Why awaitable: the persistence middleware debounces writes by 200ms,
+ * and the chat-slice `logout` reducer removes ETHORA_USER fire-and-
+ * forget. If the host navigated / re-mounted `<Chat>` immediately
+ * after a non-awaited call, the next bootstrap could occasionally
+ * read stale persisted state ("old chats reappear"). Awaiting the
+ * returned promise eliminates that race entirely.
+ */
+export const useLogout = (): (() => Promise<void>) => {
+  // dispatch is kept for backward-compat with consumers who treat the
+  // hook's presence as a redux-context requirement; not used directly
+  // here because the work happens through the module-level service.
+  useDispatch();
 
-  const handleLogout = useCallback(() => {
-    // The hook fires-and-forgets — consumers that need to await the
-    // teardown should call `logoutService.performLogout()` directly.
-    logoutService.performLogout().catch((err) => {
-      console.warn('useLogout: performLogout rejected', err);
-    });
+  return useCallback(async () => {
+    try {
+      await logoutService.performLogout();
+    } catch (err) {
+      console.warn('useLogout: performLogout failed', err);
+    }
   }, []);
-
-  return handleLogout;
 };
 
 export { logoutService };

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/api-requests/rooms.api.ts

@@ -21,21 +21,45 @@ interface ApiRoomMember {
  *   1. explicit `room.jid` from the server (if present)
  *   2. `<name>@conference.<xmppHost>` where xmppHost comes from the
  *      provider's `xmppSettings.host` saved to `chatSettingStore.config`
- *   3. fallback: `<name>@conference.xmpp.chat.ethora.com`
+ *   3. derive host from `config.baseUrl` (api.<host> → xmpp.<host>)
+ *      as a last-resort heuristic for misconfigured deployments
+ *   4. otherwise: skip the room with a warn log (NEVER fall back to a
+ *      hardcoded vendor host — previously `xmpp.chat.ethora.com`, which
+ *      manifested as a phantom "ethora" room stub on third-party servers,
+ *      customer-reported #23)
  */
 function dispatchRoomsFromRestItems(items: ApiRoom[]): void {
   if (!items?.length) return;
   const config = store.getState().chatSettingStore?.config as any;
-  const host: string =
+  // Best: explicit xmpp settings.
+  let host: string | undefined =
     config?.xmppSettings?.host ||
-    config?.xmppSettings?.conference?.replace(/^conference\./, '') ||
-    'xmpp.chat.ethora.com';
-  const conference =
-    config?.xmppSettings?.conference || `conference.${host}`;
+    config?.xmppSettings?.conference?.replace(/^conference\./, '');
+  // Heuristic fallback: derive xmpp host from the REST baseUrl.
+  // `https://api.foo.com/v1` → `xmpp.foo.com`. Better than a hardcoded
+  // vendor host and right in 99% of single-domain deployments.
+  if (!host && typeof config?.baseUrl === 'string') {
+    const m = /^https?:\/\/(?:api\.)?([^/]+)/i.exec(config.baseUrl);
+    if (m && m[1]) {host = `xmpp.${m[1].replace(/^api\./, '')}`;}
+  }
+  const conference = config?.xmppSettings?.conference
+    || (host ? `conference.${host}` : undefined);
 
   for (const item of items) {
     if (!item) continue;
-    const jid = item.jid || `${item.name}@${conference}`;
+    let jid = item.jid;
+    if (!jid) {
+      if (!conference) {
+        // No server-supplied JID and no way to synthesize one safely —
+        // skip rather than create a phantom room on a wrong host.
+        // Consumers who hit this should set config.xmppSettings.host.
+        console.warn(
+          `[ethora-rn] rooms.api: skipping room "${item.name}" — no item.jid and no xmppSettings.host / baseUrl to derive host from`
+        );
+        continue;
+      }
+      jid = `${item.name}@${conference}`;
+    }
     if (!jid.includes('@')) continue;
     const room: IRoom = {
       id: item._id || jid,

package/src/roomStore/roomsSlice.ts

@@ -429,7 +429,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

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
@@ -338,6 +348,22 @@ export interface IConfig {
     disableMembers?: boolean;
     hideMembers?: boolean;
     disableChatHeaderMenu?: boolean;
+    /**
+     * Disables uploading / removing the chat icon from the chat-info
+     * modal. The avatar stays rendered (initials / current icon) but
+     * the press-to-pick / remove affordances are gone — so the room
+     * icon becomes read-only regardless of the user's role.
+     */
+    disableIconEdit?: boolean;
+    /**
+     * Disables the tap on a member row in the chat-info member list —
+     * the popup that would show user-profile + per-member actions
+     * (message / copy-id) never opens. `disableMemberProfileActions`
+     * only hid the action BLOCK inside that popup; the popup itself
+     * still opened on tap. Set this when no per-member interaction is
+     * appropriate (e.g. patient-facing apps). Customer-reported #16.
+     */
+    disableMemberTap?: boolean;
   };
   qrUrl?: string;
 
@@ -501,6 +527,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`