@ethora/chat-component-rn 26.10.10 → 26.10.11

package/src/networking/api-requests/callState.api.ts

@@ -0,0 +1,83 @@
+import { store } from '../../roomStore';
+import http from '../apiClient';
+import { ethoraLogger } from '../../helpers/ethoraLogger';
+import { IceServerConfig, normalizeIceServers } from '../../calls/callMode';
+
+// REST side of P2P calls. A P2P call never touches LiveKit, so there is no
+// LiveKit webhook to tell the server what happened: the clients report it.
+// Every report is fire and forget (the UI never waits on it and a failure is
+// only logged), and none of them may be sent for LiveKit calls (the server
+// answers 409 CALL_NOT_P2P).
+
+const authHeaders = () => ({
+  headers: { Authorization: store.getState().chatSettingStore.user?.token || '' },
+});
+
+type CallStateReport = 'ringing' | 'decline' | 'connected' | 'end';
+
+const postCallState = (report: CallStateReport, callId: string | null) => {
+  const id = String(callId || '').trim();
+  if (!id) return;
+  try {
+    void Promise.resolve(
+      http.post(
+        `/v1/chats/call/state/${report}/${encodeURIComponent(id)}`,
+        undefined,
+        authHeaders()
+      )
+    ).catch((err) =>
+      ethoraLogger.log(`[call] state/${report} report failed`, err)
+    );
+  } catch (err) {
+    ethoraLogger.log(`[call] state/${report} report failed`, err);
+  }
+};
+
+/** Callee: the incoming UI is on screen. */
+export const reportCallRinging = (callId: string | null) =>
+  postCallState('ringing', callId);
+
+/** Callee: the user rejected the call. The server relays it to the caller. */
+export const reportCallDeclined = (callId: string | null) =>
+  postCallState('decline', callId);
+
+/** Media is flowing (ICE connected). Starts the server-side call timer. */
+export const reportCallConnected = (callId: string | null) =>
+  postCallState('connected', callId);
+
+/**
+ * A ringing or connected call ended for any reason. Idempotent on the server
+ * (a second report returns `ended:false`), so both peers may send it.
+ */
+export const reportCallEnded = (callId: string | null) =>
+  postCallState('end', callId);
+
+export interface IceServersResponse {
+  enabled: boolean;
+  iceServers: IceServerConfig[];
+  ttlSeconds: number | null;
+}
+
+/**
+ * GET /v1/calls/ice-servers: fresh STUN/TURN credentials. Used by a callee
+ * whose call-token carried no `ice` list, and to refresh the (ephemeral)
+ * credentials before an ICE restart. Returns null on any failure so callers
+ * can carry on with the servers they already have.
+ */
+export async function fetchIceServers(): Promise<IceServersResponse | null> {
+  try {
+    const response = await http.get('/v1/calls/ice-servers', authHeaders());
+    const data = (response?.data || {}) as Record<string, any>;
+    const iceServers = normalizeIceServers(data.iceServers);
+    const ttl = Number(data.ttlSeconds);
+    return {
+      // Older servers omit `enabled`; a non-empty list means usable.
+      enabled: typeof data.enabled === 'boolean' ? data.enabled : iceServers.length > 0,
+      iceServers,
+      ttlSeconds: Number.isFinite(ttl) && ttl > 0 ? ttl : null,
+    };
+  } catch (err) {
+    ethoraLogger.log('[call] ice-servers fetch failed', err);
+    return null;
+  }
+}

package/src/networking/api-requests/push.api.ts

@@ -81,6 +81,11 @@ export interface PushSubscriptionPayload {
   pushKey?: string;
   pushKeyAlg?: typeof PUSH_KEY_ALG;
   pushKeyId?: string;
+  /**
+   * BCP-47 tag the service writes this device's pushes in. A full tag is
+   * fine: the service reduces fr-CA / es-US to fr / es itself.
+   */
+  language?: string;
 }
 
 export interface RegisterPushSubscriptionArgs {
@@ -91,13 +96,16 @@ export interface RegisterPushSubscriptionArgs {
   /** Base64 public key for encrypted pushes (`ensurePushKeyPair().publicKey`). */
   pushKey?: string;
   pushKeyId?: string;
+  /** Language of this device's pushes (`config.translates.readerLocale` / `i18n.locale`). */
+  language?: string;
 }
 
 export const buildPushSubscriptionPayload = (
   token: string,
   tokenType: PushTokenType,
   pushKey?: string,
-  pushKeyId?: string
+  pushKeyId?: string,
+  language?: string
 ): PushSubscriptionPayload => ({
   registrationToken: token,
   deviceType: resolvePushDeviceType(),
@@ -105,6 +113,7 @@ export const buildPushSubscriptionPayload = (
   ...(pushKey
     ? { pushKey, pushKeyAlg: PUSH_KEY_ALG, ...(pushKeyId ? { pushKeyId } : {}) }
     : {}),
+  ...(language ? { language } : {}),
 });
 
 export async function registerPushSubscription({
@@ -114,13 +123,29 @@ export async function registerPushSubscription({
   authToken,
   pushKey,
   pushKeyId,
+  language,
 }: RegisterPushSubscriptionArgs): Promise<void> {
   const path = `/v1/push/subscription/${encodeURIComponent(appId)}`;
   const headers = { Authorization: authToken };
-  const payload = buildPushSubscriptionPayload(token, tokenType, pushKey, pushKeyId);
+  const payload = buildPushSubscriptionPayload(token, tokenType, pushKey, pushKeyId, language);
+  // A backend that predates `language` still delivers, in its default
+  // language: worth more than no push at all, so that field alone is retried
+  // without.
+  const post = async (body: PushSubscriptionPayload): Promise<void> => {
+    try {
+      await http.post(path, body, { headers });
+    } catch (error: any) {
+      if (!(body.language && isUnknownFieldError(error))) {
+        throw error;
+      }
+      const withoutLanguage = { ...body };
+      delete withoutLanguage.language;
+      await http.post(path, withoutLanguage, { headers });
+    }
+  };
 
   try {
-    await http.post(path, payload, { headers });
+    await post(payload);
     return;
   } catch (error: any) {
     // A backend that predates `tokenType` still delivers to apns / fcm

package/src/networking/api-requests/rooms.api.ts

@@ -4,6 +4,10 @@ import { store } from '../../roomStore';
 import { addRoom, mergeUsersSet, updateRoom } from '../../roomStore/roomsSlice';
 import { IRoom } from '../../types/types';
 import http from '../apiClient';
+import {
+  CallCreateResult,
+  parseCallCreateResponse,
+} from '../../calls/callMode';
 import {
   mapApiLastMessage,
   readApiUnreadCount,
@@ -450,7 +454,7 @@ export async function postReportRoom(data: PostReportRoom) {
     );
     return response.data.result;
   } catch (error) {
-    throw new Error('Error updating profile');
+    throw new Error('Error reporting chat');
   }
 }
 
@@ -545,6 +549,10 @@ export async function deleteRoom(name: string) {
 // call-token stanza for the callee. When the server doesn't recognize the
 // field both sides still fall through to a video call (the default), which
 // matches the prior single-mode behavior.
+// We never send a transport: the server decides (`p2p` for private chats when
+// it has P2P enabled, `livekit` otherwise and always for group chats) and
+// tells us in the response. An old server answers with no `mode`, which
+// parses as `livekit`.
 // No timeout is set on the shared `http` client (matches web — neither SDK
 // configures one anywhere), so a stalled connection leaves this request
 // hanging indefinitely with nothing surfaced to the caller. Observed live
@@ -561,12 +569,12 @@ const CALL_CREATE_TIMEOUT_MS = 15000;
 export async function createChatCall(
   chatName: string,
   options?: { kind?: 'audio' | 'video' }
-): Promise<void> {
+): Promise<CallCreateResult> {
   const token = store.getState().chatSettingStore.user.token || '';
   const kind = options?.kind || 'video';
 
   try {
-    await http.post(
+    const response = await http.post(
       `/v1/chats/call/create/${chatName}`,
       { kind },
       {
@@ -576,6 +584,7 @@ export async function createChatCall(
         timeout: CALL_CREATE_TIMEOUT_MS,
       }
     );
+    return parseCallCreateResponse(response?.data, kind);
   } catch (error: any) {
     // Distinguish a timeout from a real server rejection — the caller
     // (CallButtons) surfaces this string directly on the ring/error

package/src/networking/api-requests/scheduledCalls.api.ts

@@ -0,0 +1,232 @@
+import http from '../apiClient';
+import { store } from '../../roomStore';
+
+/**
+ * Scheduled calls (booking). Wrappers for `/v1/chats/calls/scheduled`.
+ *
+ * The backend decides every link: the join link, the .ics download and the
+ * Google / Outlook templates come back in `links`, and the client only opens
+ * them. No calendar URL is ever built here.
+ */
+
+export type ScheduledCallKind = 'video' | 'audio';
+export type ScheduledCallRecordStatus = 'scheduled' | 'cancelled';
+
+export interface ScheduledCall {
+  id?: string;
+  chatName: string;
+  chatType?: 'private' | 'group' | 'public' | string;
+  createdBy?: string;
+  title: string;
+  description?: string;
+  /** ISO 8601, UTC. */
+  startAt: string;
+  durationMinutes: number;
+  timezone?: string;
+  kind: ScheduledCallKind;
+  slug: string;
+  status: ScheduledCallRecordStatus;
+  sequence?: number;
+}
+
+export interface ScheduledCallLinks {
+  join: string;
+  ics?: string;
+  google?: string;
+  outlook?: string;
+  office365?: string;
+}
+
+export interface ScheduledCallChat {
+  name?: string;
+  title?: string;
+  type?: string;
+  jid?: string;
+}
+
+export interface ScheduledCallDetail {
+  scheduledCall: ScheduledCall;
+  links: ScheduledCallLinks;
+  /** Only the single-call GET carries it. */
+  chat?: ScheduledCallChat;
+}
+
+export interface CreateScheduledCallInput {
+  /** The bare room name (JID localpart), as the call endpoints take it. */
+  chatName: string;
+  title?: string;
+  description?: string;
+  /** ISO 8601. */
+  startAt: string;
+  durationMinutes?: number;
+  timezone?: string;
+  kind?: ScheduledCallKind;
+}
+
+export interface UpdateScheduledCallInput {
+  title?: string;
+  description?: string;
+  startAt?: string;
+  durationMinutes?: number;
+  kind?: ScheduledCallKind;
+}
+
+export type ScheduledCallErrorCode =
+  | 'not-found'
+  | 'not-a-member'
+  | 'forbidden'
+  | 'invalid'
+  | 'conflict'
+  | 'network'
+  | 'unknown';
+
+export class ScheduledCallApiError extends Error {
+  code: ScheduledCallErrorCode;
+  status?: number;
+  /** The server's own `code` (e.g. `START_IN_PAST`, `CALL_CANCELLED`), when it sent one. */
+  serverCode?: string;
+  constructor(
+    code: ScheduledCallErrorCode,
+    status?: number,
+    message?: string,
+    serverCode?: string
+  ) {
+    super(message || code);
+    this.name = 'ScheduledCallApiError';
+    this.code = code;
+    this.status = status;
+    this.serverCode = serverCode;
+  }
+}
+
+export const isScheduledCallApiError = (
+  error: unknown
+): error is ScheduledCallApiError =>
+  error instanceof ScheduledCallApiError ||
+  (!!error && (error as any).name === 'ScheduledCallApiError');
+
+const REQUEST_TIMEOUT_MS = 15000;
+const BASE = '/v1/chats/calls/scheduled';
+
+const authHeaders = () => ({
+  Authorization: store.getState().chatSettingStore.user?.token || '',
+});
+
+const toApiError = (error: any): ScheduledCallApiError => {
+  const status: number | undefined = error?.response?.status;
+  const body = error?.response?.data;
+  const reason = String(body?.error || body?.message || '');
+  const serverCode = body?.code ? String(body.code) : undefined;
+  if (!error?.response) {
+    return new ScheduledCallApiError('network', undefined, error?.message);
+  }
+  if (status === 404) {return new ScheduledCallApiError('not-found', status, reason, serverCode);}
+  if (status === 403) {
+    return new ScheduledCallApiError(
+      reason === 'not-a-member' ? 'not-a-member' : 'forbidden',
+      status,
+      reason,
+      serverCode
+    );
+  }
+  if (status === 400 || status === 422) {
+    return new ScheduledCallApiError('invalid', status, reason, serverCode);
+  }
+  // PATCH on a cancelled call.
+  if (status === 409) {
+    return new ScheduledCallApiError('conflict', status, reason, serverCode);
+  }
+  return new ScheduledCallApiError(
+    'unknown',
+    status,
+    reason || error?.message,
+    serverCode
+  );
+};
+
+const pick = (data: any): ScheduledCallDetail => {
+  const scheduledCall = data?.scheduledCall;
+  if (!scheduledCall || typeof scheduledCall !== 'object') {
+    throw new ScheduledCallApiError('unknown', undefined, 'bad response');
+  }
+  return {
+    scheduledCall,
+    links: data?.links || { join: '' },
+    ...(data?.chat ? { chat: data.chat } : {}),
+  };
+};
+
+const run = async <T>(call: () => Promise<T>): Promise<T> => {
+  try {
+    return await call();
+  } catch (error) {
+    if (isScheduledCallApiError(error)) {throw error;}
+    throw toApiError(error);
+  }
+};
+
+/** POST /v1/chats/calls/scheduled */
+export const createScheduledCall = (
+  input: CreateScheduledCallInput
+): Promise<ScheduledCallDetail> =>
+  run(async () => {
+    const response = await http.post(BASE, input, {
+      headers: authHeaders(),
+      timeout: REQUEST_TIMEOUT_MS,
+    });
+    return pick(response?.data);
+  });
+
+/** GET /v1/chats/calls/scheduled?chatName=&from=&to= (upcoming first). */
+export const listScheduledCalls = (params: {
+  chatName?: string;
+  from?: string;
+  to?: string;
+}): Promise<ScheduledCallDetail[]> =>
+  run(async () => {
+    const response = await http.get(BASE, {
+      params,
+      headers: authHeaders(),
+      timeout: REQUEST_TIMEOUT_MS,
+    });
+    const items = response?.data?.items;
+    return Array.isArray(items) ? items.map(pick) : [];
+  });
+
+/** GET /v1/chats/calls/scheduled/:slug. 404 unknown, 403 not a member. */
+export const getScheduledCall = (slug: string): Promise<ScheduledCallDetail> =>
+  run(async () => {
+    const response = await http.get(`${BASE}/${encodeURIComponent(slug)}`, {
+      headers: authHeaders(),
+      timeout: REQUEST_TIMEOUT_MS,
+    });
+    return pick(response?.data);
+  });
+
+/** PATCH /v1/chats/calls/scheduled/:slug (creator or room owner). */
+export const updateScheduledCall = (
+  slug: string,
+  patch: UpdateScheduledCallInput
+): Promise<ScheduledCallDetail> =>
+  run(async () => {
+    const response = await http.patch(
+      `${BASE}/${encodeURIComponent(slug)}`,
+      patch,
+      { headers: authHeaders(), timeout: REQUEST_TIMEOUT_MS }
+    );
+    return pick(response?.data);
+  });
+
+/** DELETE /v1/chats/calls/scheduled/:slug (creator or room owner). */
+export const cancelScheduledCall = (slug: string): Promise<ScheduledCall> =>
+  run(async () => {
+    const response = await http.delete(
+      `${BASE}/${encodeURIComponent(slug)}`,
+      { headers: authHeaders(), timeout: REQUEST_TIMEOUT_MS }
+    );
+    const scheduledCall = response?.data?.scheduledCall;
+    if (!scheduledCall) {
+      throw new ScheduledCallApiError('unknown', undefined, 'bad response');
+    }
+    return scheduledCall as ScheduledCall;
+  });