@ethora/chat-component-rn 26.10.10 → 26.10.11

package/lib/module/calls/p2p/P2PCallController.js

@@ -0,0 +1,718 @@
+"use strict";
+
+import { IceRestartPolicy } from './icePolicy';
+import { P2PNegotiator } from './negotiator';
+
+// One peer to peer call, from getUserMedia to hang-up. Everything that talks
+// to the outside world is injected (RTCPeerConnection, getUserMedia, the
+// signal transport, ICE credential refresh), so the class is plain TypeScript
+// and runs under a fake connection in unit tests. The decisions live in the
+// small pure modules next to it (negotiator, icePolicy, signalStanza); this
+// class only wires them to a real connection and cleans up after itself.
+//
+// Media encryption: a WebRTC peer connection already encrypts media between
+// the two peers with DTLS-SRTP, so the LiveKit insertable-streams E2EE layer
+// (and its OMEMO key exchange) is deliberately NOT applied on this path.
+
+const DEFAULT_TIMINGS = {
+  connectTimeoutMs: 25_000,
+  // While nobody has answered, the offer and candidates are sent again: a
+  // callee that was still reconnecting (woken by push) missed the first copy,
+  // and the stanzas are not stored for later. Duplicates are no-ops there.
+  offerResendMs: [4_000, 10_000]
+};
+export const describeMediaError = error => {
+  const name = error?.name || '';
+  const text = String(error?.message || '').toLowerCase();
+  if (name === 'NotAllowedError' || name === 'SecurityError' || text.includes('permission') || text.includes('denied')) {
+    return 'Camera or microphone permission denied';
+  }
+  if (name === 'NotFoundError' || name === 'OverconstrainedError') {
+    return 'No camera or microphone found on this device';
+  }
+  if (name === 'NotReadableError' || name === 'AbortError') {
+    return 'Your camera or microphone is already in use by another app';
+  }
+  return 'Could not access your camera or microphone';
+};
+
+/**
+ * What to show when the PEER ended the call for a reason that is a failure
+ * rather than a normal hang up / decline. Null means "just close the call".
+ */
+export const remoteEndNotice = reason => {
+  switch (reason) {
+    case 'media-error':
+      return 'The other person could not access their camera or microphone';
+    case 'connect-timeout':
+    case 'connection-failed':
+    case 'negotiation-error':
+    case 'setup-error':
+      return 'The call could not be connected';
+    default:
+      return null;
+  }
+};
+const AUDIO_CONSTRAINTS = {
+  echoCancellation: true,
+  noiseSuppression: true,
+  autoGainControl: true
+};
+const VIDEO_CONSTRAINTS = {
+  width: {
+    ideal: 1280
+  },
+  height: {
+    ideal: 720
+  },
+  facingMode: 'user'
+};
+export class P2PCallController {
+  policy = new IceRestartPolicy();
+  listeners = new Set();
+  pc = null;
+  localStream = null;
+  audioTrack = null;
+  videoTrack = null;
+  videoSender = null;
+  ownedTracks = [];
+  remoteStream = null;
+  remoteCleanups = [];
+  queue = Promise.resolve();
+  timers = new Set();
+  graceTimer = null;
+  deadlineTimer = null;
+  connectTimer = null;
+  started = false;
+  disposed = false;
+  endSent = false;
+  connectedOnce = false;
+  negotiated = false;
+  cameraBusy = false;
+  lastConn = null;
+
+  // Outgoing candidates wait until the offer/answer they belong to is out, so
+  // the peer never sees a candidate before its description.
+  candidateGateOpen = false;
+  heldOutgoingCandidates = [];
+  sentCandidates = [];
+  lastOffer = null;
+  constructor(params, deps, events = {}, timings = {}) {
+    this.params = params;
+    this.deps = deps;
+    this.events = events;
+    this.timings = {
+      ...DEFAULT_TIMINGS,
+      ...timings
+    };
+    this.callId = params.callId;
+    this.role = params.role;
+    this.kind = params.kind;
+    this.negotiator = new P2PNegotiator({
+      callId: params.callId,
+      role: params.role,
+      peerLocal: params.peerLocal
+    });
+    this.snapshot = {
+      status: 'preparing',
+      localStream: null,
+      remoteStream: null,
+      micEnabled: params.startWithMicOn !== false,
+      camEnabled: params.kind === 'video' && params.startWithCameraOn !== false,
+      remoteVideoLive: false,
+      notice: null
+    };
+  }
+
+  // ---- observable state (useSyncExternalStore friendly) -------------------
+
+  subscribe = listener => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  getSnapshot = () => this.snapshot;
+  update(patch) {
+    this.snapshot = {
+      ...this.snapshot,
+      ...patch
+    };
+    for (const listener of Array.from(this.listeners)) listener();
+  }
+  log(message, detail) {
+    this.deps.log?.(`[p2p ${this.callId}] ${message}`, detail);
+  }
+
+  // ---- timers -------------------------------------------------------------
+
+  later(fn, ms) {
+    const id = setTimeout(() => {
+      this.timers.delete(id);
+      if (!this.disposed) fn();
+    }, ms);
+    this.timers.add(id);
+    return id;
+  }
+  cancel(id) {
+    if (id === null) return;
+    clearTimeout(id);
+    this.timers.delete(id);
+  }
+
+  // ---- lifecycle ----------------------------------------------------------
+
+  /**
+   * Caller: get media, build the connection, offer. Callee: get media, build
+   * the connection, then apply the offer that may already be waiting. Safe to
+   * call once; every failure ends the call with a message instead of throwing.
+   */
+  async start() {
+    if (this.started || this.disposed) return;
+    this.started = true;
+    this.update({
+      status: 'preparing'
+    });
+
+    // Credentials are fetched while the permission prompt is open.
+    const icePromise = this.params.iceServers.length > 0 ? Promise.resolve(this.params.iceServers) : this.deps.fetchIceServers().then(list => list || []).catch(() => []);
+    try {
+      await this.acquireMedia();
+    } catch (error) {
+      this.log('getUserMedia failed', error);
+      this.fail(describeMediaError(error), 'media-error');
+      return;
+    }
+    if (this.disposed) {
+      this.releaseMedia();
+      return;
+    }
+    const servers = await icePromise;
+    if (this.disposed) return;
+    try {
+      this.createConnection(servers);
+    } catch (error) {
+      this.log('peer connection setup failed', error);
+      this.fail('Could not start the call', 'setup-error');
+      return;
+    }
+    this.enqueue(async () => {
+      await this.runCommands(this.negotiator.markReady());
+      if (this.role === 'caller' && !this.disposed) {
+        await this.sendOffer(false);
+        this.update({
+          status: 'waiting'
+        });
+        this.scheduleOfferResends();
+      }
+    });
+  }
+
+  /** Feed a signal from the peer (already routed by callId). */
+  receive(signal) {
+    if (this.disposed) return;
+    const commands = this.negotiator.receive(signal);
+    // An end must act immediately: it can arrive while the permission prompt
+    // is still open, before the connection (and so the job queue) is running.
+    const end = commands.find(c => c.type === 'remote-end');
+    if (end && end.type === 'remote-end') {
+      this.handleRemoteEnd(end.reason);
+      return;
+    }
+    if (commands.length > 0) this.enqueue(() => this.runCommands(commands));
+  }
+
+  /** Local user hung up (or cancelled): tell the peer and release everything. */
+  hangup(reason = 'hangup') {
+    if (this.disposed) return;
+    this.sendEnd(reason);
+    this.dispose();
+  }
+
+  /**
+   * Release every resource: timers, listeners, media tracks, the connection.
+   * Idempotent, safe from any exit path. Tells the peer unless it is already
+   * known to be over.
+   */
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    if (this.started && !this.negotiator.isEnded) this.sendEnd('hangup');
+    for (const id of this.timers) clearTimeout(id);
+    this.timers.clear();
+    this.negotiator.stop();
+    for (const cleanup of this.remoteCleanups) {
+      try {
+        cleanup();
+      } catch {
+        /* listener already gone */
+      }
+    }
+    this.remoteCleanups = [];
+    const pc = this.pc;
+    this.pc = null;
+    if (pc) {
+      pc.onicecandidate = null;
+      pc.ontrack = null;
+      pc.onconnectionstatechange = null;
+      pc.oniceconnectionstatechange = null;
+      try {
+        pc.close();
+      } catch {
+        /* already closed */
+      }
+    }
+    this.releaseMedia();
+    this.snapshot = {
+      ...this.snapshot,
+      status: this.snapshot.status === 'failed' ? 'failed' : 'ended',
+      localStream: null,
+      remoteStream: null,
+      remoteVideoLive: false
+    };
+    for (const listener of Array.from(this.listeners)) listener();
+    this.listeners.clear();
+    this.events.onDisposed?.({
+      started: this.started
+    });
+  }
+  sendEnd(reason) {
+    if (this.endSent) return;
+    this.endSent = true;
+    try {
+      this.deps.sendSignal('end', {
+        reason
+      });
+    } catch (error) {
+      this.log('end signal failed', error);
+    }
+  }
+  fail(message, reason) {
+    if (this.disposed) return;
+    this.sendEnd(reason);
+    this.snapshot = {
+      ...this.snapshot,
+      status: 'failed',
+      notice: message
+    };
+    this.events.onFailed?.(message);
+    this.dispose();
+  }
+  handleRemoteEnd(reason) {
+    if (this.disposed) return;
+    // The peer already knows; do not echo an end back.
+    this.endSent = true;
+    this.snapshot = {
+      ...this.snapshot,
+      status: 'ended'
+    };
+    this.events.onRemoteEnd?.(reason);
+    this.dispose();
+  }
+
+  // ---- media --------------------------------------------------------------
+
+  async acquireMedia() {
+    const wantVideo = this.kind === 'video' && this.params.startWithCameraOn !== false;
+    const stream = await this.deps.getUserMedia({
+      audio: AUDIO_CONSTRAINTS,
+      video: wantVideo ? VIDEO_CONSTRAINTS : false
+    });
+    this.localStream = stream;
+    this.ownedTracks = stream.getTracks();
+    this.audioTrack = stream.getAudioTracks()[0] || null;
+    this.videoTrack = stream.getVideoTracks()[0] || null;
+    if (this.audioTrack && this.params.startWithMicOn === false) {
+      this.audioTrack.enabled = false;
+    }
+    this.update({
+      localStream: stream,
+      micEnabled: !!this.audioTrack && this.audioTrack.enabled,
+      camEnabled: !!this.videoTrack
+    });
+  }
+  releaseMedia() {
+    const tracks = new Set(this.ownedTracks);
+    this.localStream?.getTracks().forEach(t => tracks.add(t));
+    for (const track of tracks) {
+      try {
+        track.stop();
+      } catch {
+        /* already stopped */
+      }
+    }
+    this.ownedTracks = [];
+    this.audioTrack = null;
+    this.videoTrack = null;
+    this.videoSender = null;
+    this.localStream = null;
+  }
+  toggleMic() {
+    if (this.disposed || !this.audioTrack) return;
+    this.audioTrack.enabled = !this.audioTrack.enabled;
+    this.update({
+      micEnabled: this.audioTrack.enabled
+    });
+  }
+
+  /**
+   * Turning the camera off stops sending video and releases the device (the
+   * camera light goes out); turning it on opens the camera again and swaps it
+   * into the existing sender, so no renegotiation is needed.
+   */
+  async toggleCamera() {
+    if (this.disposed || this.kind !== 'video' || !this.videoSender || !this.localStream || this.cameraBusy) {
+      return;
+    }
+    this.cameraBusy = true;
+    try {
+      if (this.videoTrack) {
+        const track = this.videoTrack;
+        this.videoTrack = null;
+        try {
+          await this.videoSender.replaceTrack(null);
+        } catch (error) {
+          this.log('replaceTrack(null) failed', error);
+        }
+        try {
+          this.localStream.removeTrack(track);
+        } catch {
+          /* not in the stream */
+        }
+        track.stop();
+        this.ownedTracks = this.ownedTracks.filter(t => t !== track);
+        this.update({
+          camEnabled: false,
+          notice: null
+        });
+      } else {
+        const media = await this.deps.getUserMedia({
+          video: VIDEO_CONSTRAINTS
+        });
+        const track = media.getVideoTracks()[0];
+        if (!track) return;
+        if (this.disposed || !this.videoSender || !this.localStream) {
+          track.stop();
+          return;
+        }
+        await this.videoSender.replaceTrack(track);
+        this.localStream.addTrack(track);
+        this.videoTrack = track;
+        this.ownedTracks.push(track);
+        this.update({
+          camEnabled: true,
+          notice: null
+        });
+      }
+    } catch (error) {
+      this.log('camera toggle failed', error);
+      this.update({
+        notice: describeMediaError(error)
+      });
+    } finally {
+      this.cameraBusy = false;
+    }
+  }
+  dismissNotice() {
+    if (this.snapshot.notice) this.update({
+      notice: null
+    });
+  }
+
+  // ---- peer connection ----------------------------------------------------
+
+  createConnection(servers) {
+    const pc = this.deps.createPeerConnection({
+      iceServers: servers,
+      iceCandidatePoolSize: 2
+    });
+    this.pc = pc;
+    pc.onicecandidate = event => {
+      const c = event.candidate;
+      if (!c || !c.candidate) return;
+      const json = typeof c.toJSON === 'function' ? c.toJSON() : {
+        candidate: c.candidate,
+        sdpMid: c.sdpMid,
+        sdpMLineIndex: c.sdpMLineIndex
+      };
+      if (this.candidateGateOpen) this.emitCandidate(json);else this.heldOutgoingCandidates.push(json);
+    };
+    pc.ontrack = event => this.onRemoteTrack(event.track);
+    pc.onconnectionstatechange = () => this.onConnectionState();
+    pc.oniceconnectionstatechange = () => this.onConnectionState();
+    const stream = this.localStream;
+    if (stream) {
+      if (this.audioTrack) pc.addTrack(this.audioTrack, stream);
+      if (this.kind === 'video') {
+        if (this.videoTrack) {
+          this.videoSender = pc.addTrack(this.videoTrack, stream);
+        } else {
+          // Camera starts off: keep a video section so it can be turned on
+          // later without renegotiating.
+          this.videoSender = pc.addTransceiver('video', {
+            direction: 'sendrecv'
+          }).sender;
+        }
+      }
+    }
+  }
+  emitCandidate(candidate) {
+    this.sentCandidates.push(candidate);
+    this.deps.sendSignal('candidate', candidate);
+  }
+  openCandidateGate() {
+    this.candidateGateOpen = true;
+    const held = this.heldOutgoingCandidates;
+    this.heldOutgoingCandidates = [];
+    for (const candidate of held) this.emitCandidate(candidate);
+  }
+  onRemoteTrack(track) {
+    if (!this.remoteStream) this.remoteStream = this.deps.createMediaStream();
+    const stream = this.remoteStream;
+    if (!stream.getTracks().includes(track)) stream.addTrack(track);
+    const refresh = () => this.update({
+      remoteVideoLive: this.remoteVideoLive()
+    });
+    track.addEventListener('mute', refresh);
+    track.addEventListener('unmute', refresh);
+    track.addEventListener('ended', refresh);
+    this.remoteCleanups.push(() => {
+      track.removeEventListener('mute', refresh);
+      track.removeEventListener('unmute', refresh);
+      track.removeEventListener('ended', refresh);
+    });
+    this.update({
+      remoteStream: stream,
+      remoteVideoLive: this.remoteVideoLive()
+    });
+  }
+  remoteVideoLive() {
+    return (this.remoteStream?.getVideoTracks() || []).some(t => t.readyState === 'live' && !t.muted);
+  }
+
+  // ---- negotiation --------------------------------------------------------
+
+  enqueue(job) {
+    this.queue = this.queue.then(() => this.disposed ? undefined : job()).catch(error => {
+      this.log('negotiation step failed', error);
+      // A broken negotiation cannot recover on its own.
+      this.fail('Could not set up the call', 'negotiation-error');
+    });
+  }
+  async sendOffer(iceRestart) {
+    const pc = this.pc;
+    if (!pc || this.disposed) return;
+    this.candidateGateOpen = false;
+    const offer = await pc.createOffer(iceRestart ? {
+      iceRestart: true
+    } : undefined);
+    await pc.setLocalDescription(offer);
+    if (this.disposed) return;
+    const sdp = pc.localDescription?.sdp || offer.sdp || '';
+    this.negotiator.markLocalOffer();
+    this.lastOffer = {
+      type: 'offer',
+      sdp
+    };
+    this.sentCandidates = [];
+    this.deps.sendSignal('offer', this.lastOffer);
+    this.openCandidateGate();
+  }
+  scheduleOfferResends() {
+    for (const ms of this.timings.offerResendMs) {
+      this.later(() => {
+        if (!this.negotiator.awaitingAnswer || !this.lastOffer) return;
+        this.log('re-sending offer');
+        this.deps.sendSignal('offer', this.lastOffer);
+        for (const candidate of this.sentCandidates) {
+          this.deps.sendSignal('candidate', candidate);
+        }
+      }, ms);
+    }
+  }
+  async runCommands(commands) {
+    for (const command of commands) {
+      if (this.disposed || !this.pc) return;
+      switch (command.type) {
+        case 'apply-offer':
+          await this.applyOffer(command);
+          break;
+        case 'apply-answer':
+          await this.pc.setRemoteDescription({
+            type: 'answer',
+            sdp: command.sdp
+          });
+          await this.runCommands(this.negotiator.markRemoteApplied());
+          this.onNegotiated();
+          break;
+        case 'add-candidate':
+          try {
+            await this.pc.addIceCandidate(command.candidate);
+          } catch (error) {
+            // A candidate from a superseded ICE session; harmless.
+            this.log('addIceCandidate ignored', error);
+          }
+          break;
+        case 'remote-end':
+          // Handled synchronously in receive(); never queued.
+          break;
+      }
+    }
+  }
+  async applyOffer(command) {
+    const pc = this.pc;
+    if (!pc) return;
+    if (command.rollback && pc.signalingState === 'have-local-offer') {
+      await pc.setLocalDescription({
+        type: 'rollback'
+      });
+    }
+    await pc.setRemoteDescription({
+      type: 'offer',
+      sdp: command.sdp
+    });
+    await this.runCommands(this.negotiator.markRemoteApplied());
+    if (this.disposed || !this.pc) return;
+    this.candidateGateOpen = false;
+    const answer = await pc.createAnswer();
+    await pc.setLocalDescription(answer);
+    if (this.disposed) return;
+    this.deps.sendSignal('answer', {
+      type: 'answer',
+      sdp: pc.localDescription?.sdp || answer.sdp || ''
+    });
+    this.openCandidateGate();
+    if (command.initial) this.onNegotiated();
+  }
+  onNegotiated() {
+    if (this.negotiated || this.disposed) return;
+    this.negotiated = true;
+    if (!this.connectedOnce) {
+      this.update({
+        status: 'connecting'
+      });
+      this.connectTimer = this.later(() => {
+        if (!this.connectedOnce) {
+          this.fail('Could not connect the call', 'connect-timeout');
+        }
+      }, this.timings.connectTimeoutMs);
+    }
+    this.events.onNegotiated?.();
+  }
+
+  // ---- connection health --------------------------------------------------
+
+  connState() {
+    const pc = this.pc;
+    if (!pc) return 'closed';
+    const cs = pc.connectionState;
+    if (cs) return cs;
+    // Browsers without connectionState: map the ICE state.
+    switch (pc.iceConnectionState) {
+      case 'connected':
+      case 'completed':
+        return 'connected';
+      case 'disconnected':
+        return 'disconnected';
+      case 'failed':
+        return 'failed';
+      case 'closed':
+        return 'closed';
+      case 'checking':
+        return 'connecting';
+      default:
+        return 'new';
+    }
+  }
+  onConnectionState() {
+    if (this.disposed) return;
+    const state = this.connState();
+    if (state === this.lastConn) return;
+    this.lastConn = state;
+    this.log(`connection ${state}`);
+    if (state === 'connected') {
+      this.cancel(this.graceTimer);
+      this.cancel(this.deadlineTimer);
+      this.cancel(this.connectTimer);
+      this.graceTimer = this.deadlineTimer = this.connectTimer = null;
+      this.runIceAction(this.policy.onState(state));
+      this.update({
+        status: 'connected'
+      });
+      if (!this.connectedOnce) {
+        this.connectedOnce = true;
+        this.events.onConnected?.();
+      }
+      return;
+    }
+    if (state === 'connecting') {
+      if (this.connectedOnce) this.update({
+        status: 'reconnecting'
+      });
+      return;
+    }
+    if (state === 'disconnected' || state === 'failed') {
+      if (this.connectedOnce) this.update({
+        status: 'reconnecting'
+      });
+      this.runIceAction(this.policy.onState(state));
+    }
+  }
+  runIceAction(action) {
+    switch (action.type) {
+      case 'wait':
+        this.cancel(this.graceTimer);
+        this.graceTimer = this.later(() => {
+          this.graceTimer = null;
+          this.runIceAction(this.policy.onGraceElapsed());
+        }, action.ms);
+        break;
+      case 'restart':
+        this.cancel(this.graceTimer);
+        this.graceTimer = null;
+        this.cancel(this.deadlineTimer);
+        this.deadlineTimer = this.later(() => {
+          this.deadlineTimer = null;
+          const down = this.lastConn !== 'connected';
+          this.runIceAction(this.policy.onRestartDeadline(down));
+        }, action.deadlineMs);
+        this.enqueue(() => this.restartIce());
+        break;
+      case 'give-up':
+        this.fail('Connection lost', 'connection-failed');
+        break;
+      case 'recovered':
+      case 'none':
+        break;
+    }
+  }
+
+  /** ICE restart with fresh TURN credentials; the caller of this is the policy. */
+  async restartIce() {
+    const pc = this.pc;
+    if (!pc || this.disposed) return;
+    let fresh = null;
+    try {
+      fresh = await this.deps.fetchIceServers();
+    } catch {
+      fresh = null;
+    }
+    if (this.disposed || !this.pc) return;
+    if (fresh && fresh.length > 0) {
+      try {
+        pc.setConfiguration({
+          ...pc.getConfiguration(),
+          iceServers: fresh
+        });
+      } catch (error) {
+        this.log('setConfiguration failed', error);
+      }
+    }
+    // A negotiation is already in flight (e.g. the peer is restarting too);
+    // the restart deadline still guards the outcome.
+    if (pc.signalingState !== 'stable') return;
+    if (typeof pc.restartIce === 'function') pc.restartIce();
+    await this.sendOffer(true);
+  }
+}
+//# sourceMappingURL=P2PCallController.js.map