@ethora/chat-component-rn 26.10.7 → 26.10.9

package/src/networking/callTokenStanza.ts

@@ -310,6 +310,8 @@ const handleCallStateData = (
     !!currentCall.callId &&
     currentCall.callId === stanzaCallId;
 
+  if (stanzaCallId && currentCall.callId && !callIdMatches) {return;}
+
   const isTerminalState =
     state === 'ended' ||
     state === 'declined' ||
@@ -381,7 +383,7 @@ export const onCallTokenMessage = (stanza: Element): boolean => {
         .split('/')[0]
         .split('@')[0]
         .trim();
-      handleCallStateData(inner, fromRoom);
+      handleCallStateData(data, fromRoom);
 
       // Server call-logs (carry callerXmppUsername / durationMs) should
       // flow on to onRealtimeMessage / onMessageHistory where they become
@@ -394,6 +396,13 @@ export const onCallTokenMessage = (stanza: Element): boolean => {
       return true;
     }
 
+    if (dataType === 'call-state-declined') {
+      handleCallStateData({
+        attrs: { ...data.attrs, state: 'declined' },
+      } as unknown as Element);
+      return true;
+    }
+
     if (dataType === 'call-invite') {
       const inviteKind = String(data.attrs?.kind || '').toLowerCase();
       const normalized: 'audio' | 'video' =
@@ -528,6 +537,16 @@ export const onCallTokenMessage = (stanza: Element): boolean => {
         return true;
       }
 
+      if (
+        callState.direction === 'incoming' &&
+        callState.phase !== 'idle' &&
+        !!callId &&
+        callState.callId === callId
+      ) {
+        callTrace('drop call-token: call already known from push', { callId });
+        return true;
+      }
+
       store.dispatch(
         setIncomingCallToken({
           roomJid,

package/src/networking/xmpp/sendMessageReaction.xmpp.ts

@@ -1,18 +1,51 @@
 import { Client, xml } from '@xmpp/client';
+import { shouldEncrypt } from '../../e2ee/send';
+
+export interface ReactionStanzaData {
+  firstName?: string;
+  lastName?: string;
+  photoURL?: string;
+  push?: boolean;
+  messageAuthor?: string;
+  messageText?: string;
+  isMediafile?: string;
+  mimetype?: string;
+  fileName?: string;
+}
+
+export const REACTION_MESSAGE_TEXT_MAX = 120;
 
 export function sendMessageReaction(
   client: Client,
   messageId: string,
   roomJid: string,
   reactionsList: string[],
-  data: any,
-  reactionSymbol?: any,
+  data: ReactionStanzaData = {}
 ) {
   const id = `message-reaction:${Date.now().toString()}`;
 
-  const dataReaction = {
-    senderFirstName: data.firstName,
-    senderLastName: data.lastName,
+  const push = Boolean(data.push) && reactionsList.length > 0;
+  const messageText =
+    push && !shouldEncrypt(roomJid)
+      ? String(data.messageText ?? '').slice(0, REACTION_MESSAGE_TEXT_MAX)
+      : '';
+
+  const dataReaction: Record<string, string> = {
+    senderFirstName: data.firstName ?? '',
+    senderLastName: data.lastName ?? '',
+    senderJID: client.jid?.toString() ?? '',
+    roomJid,
+    ...(data.photoURL ? { photoURL: data.photoURL } : {}),
+    ...(push
+      ? {
+          push: 'true',
+          messageAuthor: data.messageAuthor ?? '',
+          messageText,
+          isMediafile: data.isMediafile ?? '',
+          mimetype: data.mimetype ?? '',
+          fileName: data.fileName ?? '',
+        }
+      : {}),
   };
 
   const message = xml(
@@ -31,7 +64,6 @@ export function sendMessageReaction(
         xmlns: 'urn:xmpp:reactions:0',
       },
       ...reactionsList.map((reaction) => xml('reaction', {}, reaction ?? ''))
-      // xml('reaction', {}, reactionSymbol ?? '👋'),
     ),
     xml('data', dataReaction),
     xml('store', { xmlns: 'urn:xmpp:hints' })

package/src/networking/xmppClient.ts

@@ -16,7 +16,7 @@ import {
   HistoryPageCursor,
 } from './xmpp/getHistory.xmpp';
 import { sendTextMessage } from './xmpp/sendTextMessage.xmpp';
-import { sendMessageReaction } from './xmpp/sendMessageReaction.xmpp';
+import { sendMessageReaction, type ReactionStanzaData } from './xmpp/sendMessageReaction.xmpp';
 import { sendReceivedReceipt } from './xmpp/sendReceivedReceipt.xmpp';
 import { sendDisplayedMarker } from './xmpp/sendDisplayedMarker.xmpp';
 import { sendTextMessageWithTranslateTag } from './xmpp/sendTextMessageWithTranslateTag.xmpp';
@@ -1646,7 +1646,7 @@ export class XmppClient {
     messageId: string,
     roomJid: string,
     reactionsList: string[],
-    data?: { firstName?: string; lastName?: string }
+    data?: ReactionStanzaData
   ) {
     sendMessageReaction(
       this.client,

package/src/push/sealedPush.ts

@@ -20,6 +20,8 @@ export interface SealedPushEnvelope {
   msgID: string;
   /** Recipient. */
   userJid: string;
+  /** 'reaction' for a push about an emoji put on the user's message; absent for a message. */
+  type?: string;
   /** Base64 of the sealed box; absent when the service could not seal. */
   enc?: string;
 }
@@ -35,8 +37,14 @@ export interface SealedPushContent {
   msgID: string;
   /** Sender avatar URL, '' when none. */
   image: string;
+  /** 'reaction' with the emoji in `reaction`; absent for a message. */
+  type?: string;
+  reaction?: string;
 }
 
+export const isReactionPush = (envelope: Pick<SealedPushEnvelope, 'type'>): boolean =>
+  envelope.type === 'reaction';
+
 export type SealedPushFailure =
   /** No key on this device (never generated, or the store is not readable). */
   | 'no-key'
@@ -68,6 +76,7 @@ export const sealedPushEnvelopeOf = (
     jid: str(data.jid),
     msgID: str(data.msgID),
     userJid: str(data.userJid),
+    ...(str(data.type) ? { type: str(data.type) } : {}),
     ...(enc ? { enc } : {}),
   };
 };
@@ -88,6 +97,8 @@ const parseContent = (plaintext: Uint8Array): SealedPushContent | null => {
       chatJid: str(parsed.chatJid),
       msgID: str(parsed.msgID),
       image: str(parsed.image),
+      ...(str(parsed.type) ? { type: str(parsed.type) } : {}),
+      ...(str(parsed.reaction) ? { reaction: str(parsed.reaction) } : {}),
     };
   } catch {
     return null;

package/src/push/sealedPushTask.ts

@@ -1,7 +1,13 @@
 import { AppState, Platform } from 'react-native';
 import { pushLog } from '../utils/devLogger';
+import { isCallPush } from '../helpers/callPush';
 import { loadPushSecretKey } from './pushKeyStore';
-import { openSealedPush, sealedPushEnvelopeOf, type OpenSealedPushResult } from './sealedPush';
+import {
+  isReactionPush,
+  openSealedPush,
+  sealedPushEnvelopeOf,
+  type OpenSealedPushResult,
+} from './sealedPush';
 
 // Android half of encrypted pushes. A sealed push is data-only, so the OS
 // shows nothing by itself: expo-notifications hands it to a background
@@ -18,12 +24,40 @@ export const SEALED_PUSH_TASK = 'ETHORA_SEALED_PUSH';
 export interface SealedPushTaskOptions {
   /** Android notification channel; the OS default channel when omitted. */
   channelId?: string;
+  /**
+   * Channel for a reaction to the user's message (a silent one, Telegram's
+   * way); `channelId` when omitted. Reactions carry no sound of their own
+   * either way.
+   */
+  reactionChannelId?: string;
   /** Shown when the box does not open (no key, another key, damaged). Default "New message". */
   placeholderTitle?: string;
   placeholderBody?: string;
+  /**
+   * An incoming-call push (data-only, high priority) while the app is not
+   * in the foreground; the host shows its own incoming-call notification
+   * (full-screen intent, Answer / Decline). Not called in the foreground,
+   * where the XMPP invite rings the in-app call screen.
+   */
+  onCallPush?: (data: Record<string, unknown>) => void | Promise<void>;
+  onMessageShown?: (shown: ShownMessagePush) => void | Promise<void>;
+}
+
+export interface ShownMessagePush {
+  identifier: string;
+  channelId?: string;
+  title: string;
+  body: string;
+  sender: string;
+  senderJid: string;
+  chat: string;
+  chatJid: string;
+  image: string;
+  reaction: boolean;
 }
 
 const PLACEHOLDER_TITLE = 'New message';
+const PLACEHOLDER_REACTION_TITLE = 'New reaction';
 
 let registered = false;
 
@@ -49,9 +83,9 @@ const loadNotifications = (): any => {
  * itself, `data.dataString` carries the same as a JSON string on some
  * versions, and a Firebase `RemoteMessage` keeps them under `data.data`.
  */
-export const sealedPushDataOf = (payload: unknown): Record<string, unknown> | null => {
+const pushDataCandidates = (payload: unknown): unknown[] => {
   const root = payload && typeof payload === 'object' ? (payload as Record<string, unknown>) : null;
-  if (!root) {return null;}
+  if (!root) {return [];}
   const candidates: unknown[] = [root.data, root];
   const data = root.data && typeof root.data === 'object' ? (root.data as Record<string, unknown>) : null;
   if (data) {
@@ -64,30 +98,39 @@ export const sealedPushDataOf = (payload: unknown): Record<string, unknown> | nu
     }
     candidates.push(data.data);
   }
-  for (const candidate of candidates) {
-    if (sealedPushEnvelopeOf(candidate as Record<string, unknown>)) {
-      return candidate as Record<string, unknown>;
-    }
-  }
-  return null;
+  return candidates.filter((c) => c && typeof c === 'object');
 };
 
+export const sealedPushDataOf = (payload: unknown): Record<string, unknown> | null =>
+  (pushDataCandidates(payload).find((candidate) =>
+    sealedPushEnvelopeOf(candidate as Record<string, unknown>)
+  ) as Record<string, unknown> | undefined) ?? null;
+
+/** The call fields of an incoming-call push in the task payload, if it is one. */
+export const callPushDataOf = (payload: unknown): Record<string, unknown> | null =>
+  (pushDataCandidates(payload).find((candidate) =>
+    isCallPush(candidate as Record<string, unknown>)
+  ) as Record<string, unknown> | undefined) ?? null;
+
 const notificationContent = (result: OpenSealedPushResult, options: SealedPushTaskOptions) => {
   const { envelope } = result;
   // What the tap handler (`handlePushPayload` through the host's response
   // listener) needs: the same ids a plain push carries on `data`.
+  const reaction = isReactionPush(envelope);
   const data = {
     jid: envelope.jid,
     msgID: envelope.msgID,
     userJid: envelope.userJid,
     sealed: true,
+    ...(reaction ? { type: 'reaction' } : {}),
   };
+  const sound = reaction ? false : 'default';
   if (!result.ok) {
     return {
-      title: options.placeholderTitle || PLACEHOLDER_TITLE,
+      title: options.placeholderTitle || (reaction ? PLACEHOLDER_REACTION_TITLE : PLACEHOLDER_TITLE),
       ...(options.placeholderBody ? { body: options.placeholderBody } : {}),
       data,
-      sound: 'default',
+      sound,
     };
   }
   const { content } = result;
@@ -95,14 +138,16 @@ const notificationContent = (result: OpenSealedPushResult, options: SealedPushTa
     title: content.title || content.sender || content.chat || PLACEHOLDER_TITLE,
     body: content.body,
     data: { ...data, chatJid: content.chatJid, senderJid: content.senderJid },
-    sound: 'default',
+    sound,
   };
 };
 
 /**
  * Open a sealed push and show it. One notification per chat: the room JID
  * is the identifier, so a newer message replaces the older one the way the
- * service's collapse key does for plain pushes.
+ * service's collapse key does for plain pushes. A reaction has its own
+ * identifier per chat (and its own channel), so it never replaces the
+ * chat's new-message notification.
  */
 export async function presentSealedPush(
   data: Record<string, unknown>,
@@ -122,11 +167,34 @@ export async function presentSealedPush(
     console.warn(`[push] sealed push kid=${envelope.kid} not opened (${result.reason}), showing the placeholder`);
     pushLog('warn', `push: sealed push not opened (${result.reason}), showing the placeholder`);
   }
+  const reaction = isReactionPush(envelope);
+  const base = envelope.jid || envelope.msgID || '';
+  const identifier = base ? (reaction ? `${base}#reaction` : base) : undefined;
+  const channelId = (reaction && options.reactionChannelId) || options.channelId;
+  const content = notificationContent(result, options);
   await notifications.scheduleNotificationAsync({
-    identifier: envelope.jid || envelope.msgID || undefined,
-    content: notificationContent(result, options),
-    trigger: options.channelId ? { channelId: options.channelId } : null,
+    identifier,
+    content,
+    trigger: channelId ? { channelId } : null,
   });
+  if (result.ok && result.content.image && identifier && options.onMessageShown) {
+    try {
+      await options.onMessageShown({
+        identifier,
+        channelId,
+        title: content.title,
+        body: content.body ?? '',
+        sender: result.content.sender,
+        senderJid: result.content.senderJid,
+        chat: result.content.chat,
+        chatJid: result.content.chatJid,
+        image: result.content.image,
+        reaction,
+      });
+    } catch (e) {
+      pushLog('warn', 'push: drawing the sender avatar failed', e);
+    }
+  }
   return result;
 }
 
@@ -150,6 +218,17 @@ export function registerSealedPushTask(options: SealedPushTaskOptions = {}): boo
   }
   taskManager.defineTask(SEALED_PUSH_TASK, async ({ data, error }: { data: unknown; error: unknown }) => {
     if (error) {return;}
+    const call = callPushDataOf(data);
+    if (call) {
+      if (AppState.currentState === 'active' || !options.onCallPush) {return;}
+      try {
+        console.log(`[push] incoming call push ${String(call.callId ?? '')}`);
+        await options.onCallPush(call);
+      } catch (e) {
+        pushLog('warn', 'push: showing an incoming call failed', e);
+      }
+      return;
+    }
     const map = sealedPushDataOf(data);
     if (!map) {return;}
     // In the foreground the room is live over XMPP; the host's

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

@@ -5,6 +5,7 @@
 // methods) rather than duplicating here.
 
 import { Client } from '@xmpp/client';
+import type { ReactionStanzaData } from '../../networking/xmpp/sendMessageReaction.xmpp';
 import XmppClient, {
   HistoryPage,
   HistoryPageCursor,
@@ -153,7 +154,7 @@ export interface XmppClientInterface {
     messageId: string,
     roomJid: string,
     reactionsList: string[],
-    data?: { firstName?: string; lastName?: string }
+    data?: ReactionStanzaData
   ): void;
   sendTextMessageWithTranslateTagStanza?(
     roomJID: string,

package/src/version.ts

@@ -1,3 +1,3 @@
 // Generated by scripts/sync-version.mjs on `npm version`.
 // Edit package.json's version instead of this file.
-export const ETHORA_CHAT_COMPONENT_VERSION = '26.10.7';
+export const ETHORA_CHAT_COMPONENT_VERSION = '26.10.9';