@poolse/react-native-calls 0.9.0 → 0.10.0

package/ios/Core/Ports.swift

@@ -94,6 +94,20 @@ public protocol RingSurfacePort: AnyObject {
   func ringtoneStop()
   func ringbackStart()
   func ringbackStop()
+  /// A call waiting beside the current one: its own quiet surface (iOS:
+  /// CallKit's call-waiting UI; Android: a heads-up with a waiting tone).
+  func showWaiting(ring: RingContext)
+  /// The waiting call is over (declined, cancelled, timed out).
+  func dismissWaiting(callId: String)
+  /// The waiting call becomes THE ring (SHOW_RING follows): drop its
+  /// waiting surface without resolving it.
+  func promoteWaiting(callId: String)
+}
+
+public extension RingSurfacePort {
+  func showWaiting(ring: RingContext) {}
+  func dismissWaiting(callId: String) {}
+  func promoteWaiting(callId: String) {}
 }
 
 public struct RingContext: Equatable {
@@ -177,6 +191,20 @@ public enum EndReason: String {
   public var wire: String { rawValue.lowercased() }
 }
 
+/// A second call ringing while this device is on one (CONTRACT.md §7,
+/// call waiting): shown beside the current call, never instead of it.
+public struct WaitingCall: Equatable {
+  public var callId: String
+  public var conversationId: String?
+  public var media: String
+
+  public init(callId: String, conversationId: String?, media: String) {
+    self.callId = callId
+    self.conversationId = conversationId
+    self.media = media
+  }
+}
+
 /// Everything the machine knows. Immutable value; transitions return a new one.
 public struct MachineState: Equatable {
   public var phase: Phase
@@ -187,10 +215,12 @@ public struct MachineState: Equatable {
   public var reason: EndReason?
   /// HTTP attempts made for the current connecting request (retry budget = 2).
   public var httpAttempts: Int
+  /// A second call ringing beside this one, if any.
+  public var waiting: WaitingCall?
 
   public init(phase: Phase = .idle, callId: String? = nil, conversationId: String? = nil,
               direction: Direction? = nil, media: String = "audio", reason: EndReason? = nil,
-              httpAttempts: Int = 0) {
+              httpAttempts: Int = 0, waiting: WaitingCall? = nil) {
     self.phase = phase
     self.callId = callId
     self.conversationId = conversationId
@@ -198,6 +228,7 @@ public struct MachineState: Equatable {
     self.media = media
     self.reason = reason
     self.httpAttempts = httpAttempts
+    self.waiting = waiting
   }
 
   public static var IDLE: MachineState { MachineState() }

package/ios/Core/SnapshotEncoding.swift

@@ -73,7 +73,8 @@ public extension MachineState {
                   audioOutputId: String? = nil,
                   mutedSelf: Bool = false,
                   cameraOn: Bool = false,
-                  cameraFacing: String? = nil) -> [String: Any]? {
+                  cameraFacing: String? = nil,
+                  waiting: RingContext? = nil) -> [String: Any]? {
     if phase == .idle { return nil }
     var out: [String: Any] = [
       "cv": 1,
@@ -91,6 +92,18 @@ public extension MachineState {
       "mutedSelf": mutedSelf,
       "cameraOn": cameraOn,
     ]
+    // The call waiting beside this one: null when none.
+    if let w = self.waiting {
+      out["waiting"] = [
+        "callId": w.callId,
+        "conversationId": (waiting?.conversationId ?? w.conversationId).map { $0 as Any } ?? NSNull(),
+        "conversationName": waiting?.conversationName.map { $0 as Any } ?? NSNull(),
+        "callerName": waiting?.callerName.map { $0 as Any } ?? NSNull(),
+        "media": w.media,
+      ] as [String: Any]
+    } else {
+      out["waiting"] = NSNull()
+    }
     if let reason = reason { out["reason"] = reason.wire }
     // Optional in the contract: present only while a camera is published.
     if let cameraFacing = cameraFacing { out["cameraFacing"] = cameraFacing }

package/ios/Module/PoolseCallsModule.swift

@@ -66,6 +66,8 @@ public class PoolseCallsModule: Module {
     Function("answer") { onCore { $0.answer() } }
     Function("decline") { onCore { $0.decline() } }
     Function("hangUp") { onCore { $0.hangUp() } }
+    Function("answerWaiting") { (callId: String?) in onCore { $0.answerWaiting(callId: callId) } }
+    Function("declineWaiting") { (callId: String?) in onCore { $0.declineWaiting(callId: callId) } }
     Function("setMuted") { (muted: Bool) in onCore { $0.setMuted(muted) } }
     Function("setCamera") { (on: Bool) in onCore { $0.setCamera(on) } }
     Function("switchCamera") { onCore { $0.switchCamera() } }

package/ios/Platform/CallCore.swift

@@ -233,6 +233,24 @@ final class CallCore {
     }
   }
 
+  /// Call waiting: end this call, answer the waiting one. CallKit follows
+  /// from the resulting state (reconcileCallKit ends the old call, then
+  /// answers the new one).
+  func answerWaiting(callId: String? = nil) {
+    onMain { [self] in
+      localEnd = true
+      runtime.answerWaiting(callId: callId)
+    }
+  }
+
+  /// Call waiting: turn the waiting call away (its caller hears busy).
+  func declineWaiting(callId: String? = nil) {
+    onMain { [self] in runtime.declineWaiting(callId: callId) }
+  }
+
+  /// True while `callId` is the call waiting beside the current one. Main thread.
+  func isWaiting(_ callId: String) -> Bool { runtime.currentState().waiting?.callId == callId }
+
   func place(conversationId: String, media: String, sessionToken: String) {
     onMain { [self] in
       localEnd = false
@@ -300,6 +318,9 @@ final class CallCore {
         if let old = extrasCallId, let new = state.callId { callKit.rename(from: old, to: new) }
         extrasCallId = state.callId
       } else {
+        // A different call (a waiting one promoted): nothing of the last
+        // carries over — not even "the user ended it here".
+        if extrasCallId != nil { localEnd = false }
         resetExtras(state.callId, state.media)
       }
     }
@@ -320,7 +341,8 @@ final class CallCore {
       audioOutputId: audioOutputId,
       mutedSelf: mutedSelf,
       cameraOn: cameraOn,
-      cameraFacing: cameraFacing
+      cameraFacing: cameraFacing,
+      waiting: runtime.waitingRing
     )
     snapshotLock.lock(); lastSnapshot = snap; snapshotLock.unlock()
     reconcileCallKit(state)
@@ -345,25 +367,27 @@ final class CallCore {
   /// CallKit follows the FINAL state of each dispatch.
   private func reconcileCallKit(_ state: MachineState) {
     let terminal = state.phase == .idle || state.phase == .ended
-    for t in callKit.liveCalls {
-      let isCurrent = !terminal && t.callId == state.callId
-      if isCurrent {
-        switch state.phase {
-        case .connecting, .active, .reconnecting, .ringingOut:
-          // Answered from the app's own UI: tell CallKit (audio follows).
-          if !t.outgoing && !t.answered && state.direction == .incoming { callKit.requestAnswer(callId: t.callId) }
-          if t.outgoing && state.phase == .active { callKit.reportConnected(callId: t.callId) }
-          callKit.updateTitle(callId: t.callId, title: conversationName, video: state.media == "video")
-        default:
-          break
-        }
-        continue
-      }
+    // The call waiting beside this one stays on CallKit's call-waiting UI.
+    let live = callKit.liveCalls.filter { terminal || $0.callId != state.waiting?.callId }
+    // Ends first: answering the next call (end-and-answer) while CallKit
+    // still holds the last one would ask it for two calls at once.
+    for t in live where terminal || t.callId != state.callId {
       // Not the call the machine is in (ended, busy-declined, superseded).
       // Terminal: whatever CallKit still shows is the call that just ended.
       let reason = endReason(for: t, state: state, current: terminal || t.callId == state.callId)
       callKit.end(t, reason: reason)
     }
+    for t in live where !terminal && t.callId == state.callId {
+      switch state.phase {
+      case .connecting, .active, .reconnecting, .ringingOut:
+        // Answered from the app's own UI: tell CallKit (audio follows).
+        if !t.outgoing && !t.answered && state.direction == .incoming { callKit.requestAnswer(callId: t.callId) }
+        if t.outgoing && state.phase == .active { callKit.reportConnected(callId: t.callId) }
+        callKit.updateTitle(callId: t.callId, title: conversationName, video: state.media == "video")
+      default:
+        break
+      }
+    }
     if terminal {
       localEnd = false
       if let id = state.callId { ringEndReasons.removeValue(forKey: id) }
@@ -419,6 +443,13 @@ final class CallCore {
     callKit.reportIncoming(ring: ring)
   }
 
+  /// CallKit shows a second incoming call over a live one as call
+  /// waiting (End & Accept / Decline). Usually already reported by the
+  /// push path; idempotent.
+  fileprivate func showWaiting(_ ring: RingContext) {
+    callKit.reportIncoming(ring: ring)
+  }
+
   fileprivate var ringbackPlayer: Ringback { ringback }
 
   // MediaEvents → runtime
@@ -451,12 +482,24 @@ final class CallCore {
 extension CallCore: CallKitActions {
   func callKitAnswer(callId: String) {
     let s = runtime.currentState()
+    // End & Accept may answer the waiting call before ending the current
+    // one: answering it ends the current call itself.
+    if s.waiting?.callId == callId {
+      localEnd = true
+      runtime.answerWaiting(callId: callId)
+      return
+    }
     guard s.callId == callId, s.phase == .ringingIn else { return }
     runtime.answer()
   }
 
   func callKitEnd(callId: String) {
     let s = runtime.currentState()
+    // Decline on CallKit's call-waiting UI.
+    if s.waiting?.callId == callId {
+      runtime.declineWaiting(callId: callId)
+      return
+    }
     guard s.callId == callId || (s.callId?.hasPrefix("pending:") == true) else { return }
     localEnd = true
     if s.phase == .ringingIn { runtime.decline() } else { runtime.hangUp() }
@@ -494,6 +537,11 @@ private final class SurfaceAdapter: RingSurfacePort, CallSessionPort {
 
   func show(ring: RingContext) { core?.showRing(ring) }
   func dismiss(callId: String) {}
+  func showWaiting(ring: RingContext) { core?.showWaiting(ring) }
+  // Dismissal is reconciled from the final state; promotion keeps the
+  // CallKit call, which SHOW_RING then finds already reported.
+  func dismissWaiting(callId: String) {}
+  func promoteWaiting(callId: String) {}
   func ringtoneStart() {}
   func ringtoneStop() {}
   func ringbackStart() { core?.ringbackPlayer.start() }

package/ios/Platform/CallKitController.swift

@@ -124,7 +124,13 @@ final class CallKitController: NSObject, CXProviderDelegate {
       DispatchQueue.main.async {
         t.ended = true
         self?.calls.removeValue(forKey: t.uuid)
-        CallCore.peek()?.onRingEnded(callId: ring.callId, reason: "cancelled")
+        // A refused call-waiting report: the caller would ring on into
+        // a void — turn it away as busy instead.
+        if let core = CallCore.peek(), core.isWaiting(ring.callId) {
+          core.declineWaiting(callId: ring.callId)
+        } else {
+          CallCore.peek()?.onRingEnded(callId: ring.callId, reason: "cancelled")
+        }
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poolse/react-native-calls",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Native call core for poolse — Kotlin/Swift calling engine with a thin React Native bridge. Ring, answer and carry audio with the app killed and the phone locked.",
   "license": "MIT",
   "type": "module",

package/src/index.ts

@@ -61,12 +61,29 @@ export interface Snapshot {
   mutedSelf: boolean;
   /** True only while the local camera track is actually published and enabled. */
   cameraOn: boolean;
+  /**
+   * A second call ringing while this one is in progress (call waiting).
+   * Offer `answerWaiting` ("End & answer" — this call ends) and
+   * `declineWaiting` (its caller hears busy). If this call ends first,
+   * the waiting one simply becomes the ringing call. null when none;
+   * absent before 0.10.0.
+   */
+  waiting?: WaitingCall | null;
   /** Facing of the published local camera; absent when the camera is off. */
   cameraFacing?: 'front' | 'back';
 }
 
 export type AudioOutputKind = 'earpiece' | 'speaker' | 'bluetooth' | 'headset';
 
+/** The call waiting beside the current one. */
+export interface WaitingCall {
+  callId: string;
+  conversationId: string | null;
+  conversationName: string | null;
+  callerName: string | null;
+  media: 'audio' | 'video';
+}
+
 /** One place call audio can play. */
 export interface AudioOutput {
   /** Opaque; stable while the device stays connected. */
@@ -128,6 +145,8 @@ interface PoolseCallsNative {
   answer(): void;
   decline(): void;
   hangUp(): void;
+  answerWaiting?(callId: string | null): void;
+  declineWaiting?(callId: string | null): void;
   setMuted(muted: boolean): void;
   setCamera(on: boolean): void;
   switchCamera(): void;
@@ -239,6 +258,16 @@ export async function startRoom(
 export const answer = (): void => native?.answer();
 export const decline = (): void => native?.decline();
 export const hangUp = (): void => native?.hangUp();
+
+/**
+ * Call waiting: end the current call and answer `snapshot.waiting`.
+ * Pass its `callId`: a tap on a card for a call that is no longer the
+ * one waiting is then ignored instead of answering a different call.
+ */
+export const answerWaiting = (callId?: string): void => native?.answerWaiting?.(callId ?? null);
+
+/** Call waiting: turn `snapshot.waiting` away — its caller hears busy. */
+export const declineWaiting = (callId?: string): void => native?.declineWaiting?.(callId ?? null);
 export const setMuted = (muted: boolean): void => native?.setMuted(muted);
 export const setCamera = (on: boolean): void => native?.setCamera(on);
 export const switchCamera = (): void => native?.switchCamera();