@ethora/chat-component-rn 26.10.10 → 26.10.11

package/src/calls/p2p/icePolicy.ts

@@ -0,0 +1,99 @@
+// ICE restart policy for a p2p call, kept apart from the RTCPeerConnection so
+// it can be reasoned about and tested on its own. The controller feeds it the
+// connection state and runs the timers; the policy only decides.
+//
+//  - `disconnected` is often transient (a Wi-Fi blip heals by itself), so the
+//    first reaction is to wait a grace period and restart only if it has not
+//    recovered;
+//  - `failed` is terminal for that ICE session, so restart straight away;
+//  - one restart per outage, and a small cap per call so a flapping network
+//    ends in a clean failure instead of an endless loop;
+//  - a restart that does not bring the connection back within a deadline
+//    gives up.
+
+export type P2PConnState =
+  | 'new'
+  | 'connecting'
+  | 'connected'
+  | 'disconnected'
+  | 'failed'
+  | 'closed';
+
+export type IceAction =
+  | { type: 'none' }
+  | { type: 'wait'; ms: number } // re-check with onGraceElapsed() after ms
+  | { type: 'restart'; deadlineMs: number } // restart; onRestartDeadline() after deadlineMs
+  | { type: 'recovered' }
+  | { type: 'give-up'; reason: string };
+
+export interface IcePolicyOptions {
+  graceMs?: number;
+  restartDeadlineMs?: number;
+  maxRestartsPerCall?: number;
+}
+
+export class IceRestartPolicy {
+  private readonly graceMs: number;
+  private readonly restartDeadlineMs: number;
+  private readonly maxRestarts: number;
+  private restarts = 0;
+  private attemptedThisOutage = false;
+  private inOutage = false;
+
+  constructor(options: IcePolicyOptions = {}) {
+    this.graceMs = options.graceMs ?? 3_000;
+    this.restartDeadlineMs = options.restartDeadlineMs ?? 15_000;
+    this.maxRestarts = options.maxRestartsPerCall ?? 3;
+  }
+
+  get restartCount(): number {
+    return this.restarts;
+  }
+
+  private tryRestart(): IceAction {
+    if (this.attemptedThisOutage) {
+      return { type: 'give-up', reason: 'restart-did-not-recover' };
+    }
+    if (this.restarts >= this.maxRestarts) {
+      return { type: 'give-up', reason: 'too-many-restarts' };
+    }
+    this.attemptedThisOutage = true;
+    this.restarts += 1;
+    return { type: 'restart', deadlineMs: this.restartDeadlineMs };
+  }
+
+  onState(state: P2PConnState): IceAction {
+    switch (state) {
+      case 'connected': {
+        const wasOutage = this.inOutage;
+        this.inOutage = false;
+        this.attemptedThisOutage = false;
+        return wasOutage ? { type: 'recovered' } : { type: 'none' };
+      }
+      case 'disconnected': {
+        this.inOutage = true;
+        if (this.attemptedThisOutage) return { type: 'none' };
+        return { type: 'wait', ms: this.graceMs };
+      }
+      case 'failed': {
+        this.inOutage = true;
+        return this.tryRestart();
+      }
+      default:
+        return { type: 'none' };
+    }
+  }
+
+  /** The grace period after `disconnected` ran out without recovery. */
+  onGraceElapsed(): IceAction {
+    if (!this.inOutage) return { type: 'none' };
+    return this.tryRestart();
+  }
+
+  /** The restart deadline ran out; `stillDown` is the state at that moment. */
+  onRestartDeadline(stillDown: boolean): IceAction {
+    return stillDown
+      ? { type: 'give-up', reason: 'restart-timeout' }
+      : { type: 'none' };
+  }
+}

package/src/calls/p2p/negotiator.ts

@@ -0,0 +1,186 @@
+import type { P2PSignal } from './signalStanza';
+
+// The pure half of the p2p signalling state machine: given the stream of
+// signals from the peer and a few "we are ready" notifications, it says WHAT
+// to do next (apply an offer, apply an answer, add a candidate, stop) without
+// touching an RTCPeerConnection. The controller executes the commands.
+//
+// Rules it enforces:
+//  - one negotiation per callId; signals for another callId or from anyone but
+//    the expected peer are ignored;
+//  - the callee may receive the offer before it has accepted (and before it
+//    has local media): the first offer wins, later initial offers are ignored,
+//    and it is held until markReady();
+//  - candidates that arrive before the remote description is applied are held
+//    and flushed right after it;
+//  - duplicates (same SDP delivered twice, e.g. the caller re-sending its
+//    offer) are no-ops;
+//  - after the first exchange, a new offer is a renegotiation (ICE restart).
+//    If both sides restart at once (glare) the caller is "impolite" and keeps
+//    its own offer; the callee is "polite" and yields to the caller's.
+
+export type P2PRole = 'caller' | 'callee';
+
+export type NegotiatorCommand =
+  | { type: 'apply-offer'; sdp: string; initial: boolean; rollback: boolean }
+  | { type: 'apply-answer'; sdp: string }
+  | { type: 'add-candidate'; candidate: RTCIceCandidateInit }
+  | { type: 'remote-end'; reason: string };
+
+const MAX_HELD_CANDIDATES = 64;
+
+export class P2PNegotiator {
+  readonly callId: string;
+  readonly role: P2PRole;
+  private readonly peerLocal: string;
+
+  private ready = false;
+  private ended = false;
+  private remoteDescriptionSet = false;
+  private initialOfferTaken = false;
+  private heldOffer: string | null = null;
+  private localOfferPending = false;
+  private lastOfferSdp: string | null = null;
+  private lastAnswerSdp: string | null = null;
+  private heldCandidates: RTCIceCandidateInit[] = [];
+  // The caller re-sends its offer and candidates while unanswered, so the same
+  // candidate can arrive more than once; each is applied (or held) only once.
+  private seenCandidates = new Set<string>();
+
+  constructor(params: { callId: string; role: P2PRole; peerLocal: string }) {
+    this.callId = params.callId;
+    this.role = params.role;
+    this.peerLocal = String(params.peerLocal || '')
+      .split('@')[0]
+      .toLowerCase();
+  }
+
+  get isEnded(): boolean {
+    return this.ended;
+  }
+
+  /** True while we have sent an offer and not yet received its answer. */
+  get awaitingAnswer(): boolean {
+    return this.localOfferPending;
+  }
+
+  private accepts(signal: P2PSignal): boolean {
+    if (this.ended) return false;
+    if (signal.callId !== this.callId) return false;
+    if (this.peerLocal && signal.fromLocal !== this.peerLocal) return false;
+    return true;
+  }
+
+  receive(signal: P2PSignal): NegotiatorCommand[] {
+    if (!this.accepts(signal)) return [];
+
+    switch (signal.signal) {
+      case 'end': {
+        this.ended = true;
+        this.heldOffer = null;
+        this.heldCandidates = [];
+        const reason = (signal.payload as { reason?: string }).reason;
+        return [{ type: 'remote-end', reason: reason || 'ended' }];
+      }
+
+      case 'offer': {
+        const sdp = (signal.payload as { sdp: string }).sdp;
+        if (sdp === this.lastOfferSdp) return [];
+        if (!this.initialOfferTaken) {
+          // Only the callee ever receives the first offer.
+          if (this.role !== 'callee') return [];
+          this.initialOfferTaken = true;
+          this.lastOfferSdp = sdp;
+          if (!this.ready) {
+            this.heldOffer = sdp;
+            return [];
+          }
+          return [{ type: 'apply-offer', sdp, initial: true, rollback: false }];
+        }
+        // Renegotiation. Before the initial exchange finished, or before we
+        // are ready, there is nothing sensible to apply it to.
+        if (!this.ready || !this.remoteDescriptionSet) return [];
+        if (this.localOfferPending) {
+          if (this.role === 'caller') return []; // impolite: keep ours
+          this.localOfferPending = false; // polite: roll ours back
+          this.lastOfferSdp = sdp;
+          return [{ type: 'apply-offer', sdp, initial: false, rollback: true }];
+        }
+        this.lastOfferSdp = sdp;
+        return [{ type: 'apply-offer', sdp, initial: false, rollback: false }];
+      }
+
+      case 'answer': {
+        if (!this.localOfferPending) return [];
+        const sdp = (signal.payload as { sdp: string }).sdp;
+        if (sdp === this.lastAnswerSdp) return [];
+        this.lastAnswerSdp = sdp;
+        this.localOfferPending = false;
+        return [{ type: 'apply-answer', sdp }];
+      }
+
+      case 'candidate': {
+        const c = signal.payload as RTCIceCandidateInit;
+        // An empty candidate string is the end-of-candidates marker; nothing
+        // needs to be added for it.
+        if (!c.candidate) return [];
+        const key = `${c.candidate}|${c.sdpMid ?? ''}|${c.sdpMLineIndex ?? ''}`;
+        if (this.seenCandidates.has(key)) return [];
+        this.seenCandidates.add(key);
+        if (this.remoteDescriptionSet) {
+          return [{ type: 'add-candidate', candidate: c }];
+        }
+        if (this.heldCandidates.length < MAX_HELD_CANDIDATES) {
+          this.heldCandidates.push(c);
+        }
+        return [];
+      }
+    }
+    return [];
+  }
+
+  /**
+   * Local media and the peer connection exist. For the callee this releases
+   * the offer that arrived while it was still on the ring screen.
+   */
+  markReady(): NegotiatorCommand[] {
+    if (this.ended) return [];
+    this.ready = true;
+    if (this.heldOffer !== null) {
+      const sdp = this.heldOffer;
+      this.heldOffer = null;
+      return [{ type: 'apply-offer', sdp, initial: true, rollback: false }];
+    }
+    return [];
+  }
+
+  /** We created and set a local offer; its answer is now expected. */
+  markLocalOffer(): void {
+    this.localOfferPending = true;
+    this.lastAnswerSdp = null;
+    // The caller's own first offer IS its initial exchange, so any offer it
+    // receives afterwards is a renegotiation, not a second "first offer".
+    if (this.role === 'caller') this.initialOfferTaken = true;
+  }
+
+  /**
+   * A remote description (offer or answer) was applied to the connection.
+   * Returns the candidates that were waiting for it.
+   */
+  markRemoteApplied(): NegotiatorCommand[] {
+    this.remoteDescriptionSet = true;
+    const held = this.heldCandidates;
+    this.heldCandidates = [];
+    return held.map((candidate) => ({
+      type: 'add-candidate' as const,
+      candidate,
+    }));
+  }
+
+  /** Local teardown: later signals are ignored. */
+  stop(): void {
+    this.ended = true;
+    this.heldOffer = null;
+    this.heldCandidates = [];
+  }
+}

package/src/calls/p2p/p2pRuntime.ts

@@ -0,0 +1,164 @@
+import { Element } from 'ltx';
+import { store } from '../../roomStore';
+import { getGlobalXmppClient } from '../../utils/clientRegistry';
+import { ethoraLogger } from '../../helpers/ethoraLogger';
+import { fetchIceServers } from '../../networking/api-requests/callState.api';
+import { P2PSignalInbox } from './signalInbox';
+import {
+  buildP2PSignalStanza,
+  isP2PSignalFresh,
+  parseP2PSignalStanza,
+  P2PSignalName,
+  P2PSignalPayload,
+} from './signalStanza';
+import { loadWebRTC } from './webrtcRuntime';
+import type { P2PCallController, P2PCallDeps } from './P2PCallController';
+
+// The glue between the XMPP stanza stream, the redux call state and the
+// per-call controller. Native WebRTC / XMPP specifics live here so the
+// controller and the pure modules stay free of them.
+
+/** Signals that arrive for a call nobody is handling yet wait here. */
+export const p2pInbox = new P2PSignalInbox();
+
+/**
+ * Entry point for an incoming `<data type="call-p2p">` message (called from
+ * the stanza router). Stale, replayed, malformed or self-sent signals are
+ * dropped; the rest go to the inbox, which delivers or briefly holds them.
+ */
+export const handleP2PSignalStanza = (inner: Element): void => {
+  const signal = parseP2PSignalStanza(inner);
+  if (!signal || !signal.fromLocal) return;
+  if (!isP2PSignalFresh(signal)) return;
+
+  const self = String(store.getState().chatSettingStore.user?.xmppUsername || '')
+    .split('@')[0]
+    .toLowerCase();
+  if (signal.fromLocal === self) return;
+
+  p2pInbox.receive(signal);
+};
+
+/** Sends one signal straight to the peer's bare JID over the live XMPP client. */
+export const sendP2PSignal = (params: {
+  peerXmppUsername: string;
+  callId: string;
+  signal: P2PSignalName;
+  payload: P2PSignalPayload;
+}): boolean => {
+  const xmppClient = getGlobalXmppClient();
+  const host = (xmppClient as any)?.host || '';
+  const peer = String(params.peerXmppUsername || '').trim();
+  if (!xmppClient || !host || !peer) return false;
+  try {
+    const stanza = buildP2PSignalStanza({
+      to: peer.includes('@') ? peer : `${peer}@${host}`,
+      callId: params.callId,
+      signal: params.signal,
+      payload: params.payload,
+    });
+    (xmppClient as any).client?.send?.(stanza);
+    return true;
+  } catch (error) {
+    ethoraLogger.log('[p2p] failed to send signal', error);
+    return false;
+  }
+};
+
+/**
+ * The real native dependencies for one call's controller: the WebRTC classes
+ * of `@livekit/react-native-webrtc`, loaded lazily (see webrtcRuntime). Each
+ * call fails with a clear error when the package is missing, which the
+ * controller turns into a user-facing "could not start the call".
+ */
+export const createNativeP2PDeps = (params: {
+  callId: string;
+  peerXmppUsername: string;
+}): P2PCallDeps => {
+  const rtc = () => {
+    const runtime = loadWebRTC();
+    if (!runtime) throw new Error('WebRTC is not available');
+    return runtime;
+  };
+  return {
+    createPeerConnection: (config) =>
+      new (rtc().RTCPeerConnection)(config) as unknown as RTCPeerConnection,
+    getUserMedia: (constraints) =>
+      rtc().mediaDevices.getUserMedia(constraints) as Promise<MediaStream>,
+    createMediaStream: () => new (rtc().MediaStream)() as unknown as MediaStream,
+    fetchIceServers: async () => {
+      const response = await fetchIceServers();
+      return response && response.iceServers.length > 0
+        ? response.iceServers
+        : null;
+    },
+    sendSignal: (signal, payload) => {
+      sendP2PSignal({
+        peerXmppUsername: params.peerXmppUsername,
+        callId: params.callId,
+        signal,
+        payload,
+      });
+    },
+    log: (message, detail) => ethoraLogger.log(message, detail),
+  };
+};
+
+// ---- the one active controller --------------------------------------------
+
+let active: { key: string; controller: P2PCallController } | null = null;
+let pendingDispose: ReturnType<typeof setTimeout> | null = null;
+const activeListeners = new Set<() => void>();
+
+const notifyActive = () => {
+  for (const listener of Array.from(activeListeners)) listener();
+};
+
+export const getActiveP2PController = (): P2PCallController | null =>
+  active?.controller ?? null;
+
+export const subscribeActiveP2P = (listener: () => void): (() => void) => {
+  activeListeners.add(listener);
+  return () => {
+    activeListeners.delete(listener);
+  };
+};
+
+/**
+ * Returns the controller for `key`, creating it on first use. Effects that
+ * unmount and immediately remount (React StrictMode, a parent re-keying) get
+ * the SAME controller back instead of tearing the call down and starting a
+ * second negotiation: release() only disposes after a tick, and acquire()
+ * within that tick cancels it.
+ */
+export const acquireP2PController = (
+  key: string,
+  create: () => P2PCallController
+): P2PCallController => {
+  if (pendingDispose) {
+    clearTimeout(pendingDispose);
+    pendingDispose = null;
+  }
+  if (active && active.key === key) return active.controller;
+  if (active) {
+    active.controller.dispose();
+    active = null;
+  }
+  active = { key, controller: create() };
+  notifyActive();
+  return active.controller;
+};
+
+export const releaseP2PController = (key: string): void => {
+  if (!active || active.key !== key) return;
+  const released = active;
+  if (pendingDispose) clearTimeout(pendingDispose);
+  pendingDispose = setTimeout(() => {
+    pendingDispose = null;
+    if (active === released) {
+      active = null;
+      notifyActive();
+    }
+    released.controller.dispose();
+  }, 0);
+};

package/src/calls/p2p/signalInbox.ts

@@ -0,0 +1,117 @@
+import type { P2PSignal } from './signalStanza';
+
+// Routes incoming p2p signals to the call that owns them.
+//
+// Signals can arrive before anyone is listening: the caller's offer and first
+// candidates are on the wire while the callee is still on the ring screen (the
+// controller only exists after Accept), and may even overtake the relayed
+// call-token that tells the callee the call exists. So signals for a callId
+// with no listener are held briefly and replayed in order when a controller
+// attaches. The hold is small and bounded on purpose: a signal for a call that
+// never materialises is just dropped when its time is up, so unknown callIds
+// stay inert (they never raise UI and never grow memory without limit).
+
+export interface SignalInboxOptions {
+  /** How long signals for a call with no listener are kept. */
+  ttlMs?: number;
+  /** Most distinct unclaimed callIds held at once (oldest dropped first). */
+  maxPendingCalls?: number;
+  /** Most signals kept per unclaimed call. */
+  maxPerCall?: number;
+  now?: () => number;
+}
+
+export type SignalDelivery = 'delivered' | 'buffered' | 'dropped';
+
+type Handler = (signal: P2PSignal) => void;
+
+const CLOSED_MEMORY = 16;
+
+export class P2PSignalInbox {
+  private readonly ttlMs: number;
+  private readonly maxPendingCalls: number;
+  private readonly maxPerCall: number;
+  private readonly now: () => number;
+  private readonly pending = new Map<
+    string,
+    { firstAt: number; signals: P2PSignal[] }
+  >();
+  private readonly handlers = new Map<string, Handler>();
+  // Calls that already ended: late stragglers for them are dropped instead of
+  // being buffered for a controller that will never come.
+  private readonly closed: string[] = [];
+
+  constructor(options: SignalInboxOptions = {}) {
+    this.ttlMs = options.ttlMs ?? 20_000;
+    this.maxPendingCalls = options.maxPendingCalls ?? 8;
+    this.maxPerCall = options.maxPerCall ?? 96;
+    this.now = options.now ?? Date.now;
+  }
+
+  private sweep(): void {
+    const cutoff = this.now() - this.ttlMs;
+    for (const [callId, entry] of this.pending) {
+      if (entry.firstAt < cutoff) this.pending.delete(callId);
+    }
+  }
+
+  receive(signal: P2PSignal): SignalDelivery {
+    const handler = this.handlers.get(signal.callId);
+    if (handler) {
+      handler(signal);
+      return 'delivered';
+    }
+    if (this.closed.includes(signal.callId)) return 'dropped';
+
+    this.sweep();
+    let entry = this.pending.get(signal.callId);
+    if (!entry) {
+      if (this.pending.size >= this.maxPendingCalls) {
+        const oldest = this.pending.keys().next().value;
+        if (oldest !== undefined) this.pending.delete(oldest);
+      }
+      entry = { firstAt: this.now(), signals: [] };
+      this.pending.set(signal.callId, entry);
+    }
+    if (entry.signals.length >= this.maxPerCall) return 'dropped';
+    entry.signals.push(signal);
+    return 'buffered';
+  }
+
+  /**
+   * Starts delivering a call's signals to `handler`, replaying anything held
+   * for it first (in arrival order). Returns a detach function that also
+   * marks the call closed.
+   */
+  attach(callId: string, handler: Handler): () => void {
+    const idx = this.closed.indexOf(callId);
+    if (idx >= 0) this.closed.splice(idx, 1);
+
+    this.sweep();
+    const held = this.pending.get(callId);
+    this.pending.delete(callId);
+    this.handlers.set(callId, handler);
+    if (held) {
+      for (const signal of held.signals) handler(signal);
+    }
+    return () => {
+      if (this.handlers.get(callId) === handler) this.handlers.delete(callId);
+      this.close(callId);
+    };
+  }
+
+  /** The call is over: forget held signals and drop future stragglers. */
+  close(callId: string): void {
+    this.pending.delete(callId);
+    if (!this.closed.includes(callId)) {
+      this.closed.push(callId);
+      if (this.closed.length > CLOSED_MEMORY) this.closed.shift();
+    }
+  }
+
+  clear(): void {
+    this.pending.clear();
+    this.handlers.clear();
+    this.closed.length = 0;
+  }
+}