@poolse/react-native-calls 0.3.0 → 0.4.0

package/ios/Core/Ports.swift

@@ -0,0 +1,193 @@
+import Foundation
+
+// The seams between the pure machine and the platform. Direct port of
+// android/.../callcore/Ports.kt (plus the state value types from
+// CallMachine.kt). Everything is main-thread confined: adapters may call
+// back from any thread — the runtime hops onto DispatchQueue.main.
+
+// MARK: - HTTP (CONTRACT.md §4 — the three doors)
+
+public protocol HttpPort: AnyObject {
+  /// POST /calls/:id/answer with the ring grant.
+  func answer(callId: String, grant: String, cb: @escaping (HttpResult) -> Void)
+  /// POST /calls/:id/join with a session token.
+  func join(callId: String, sessionToken: String, cb: @escaping (HttpResult) -> Void)
+  /// POST /conversations/:id/calls with a session token.
+  func place(conversationId: String, media: String, sessionToken: String, cb: @escaping (HttpResult) -> Void)
+  /// POST /calls/:id/decline — grant or session; fire-and-forget with retry.
+  func decline(callId: String, auth: String, busy: Bool)
+  /// POST /calls/:id/hangup with the call-control token; fire-and-forget with retry.
+  func hangup(callId: String, controlToken: String)
+  /// POST /calls/:id/reconnect with the call-control token. Answers with the
+  /// FULL bundle; `current` lets an older server's `{livekit:{url,token}}`
+  /// refresh be applied onto it.
+  func reconnect(current: CallSessionBundle, cb: @escaping (HttpResult) -> Void)
+}
+
+public enum HttpResult: Equatable {
+  /// 2xx: the CallSessionBundle (or reconnect's token refresh).
+  case ok(CallSessionBundle)
+  /// 404/410 — the call is finished (or this device was superseded).
+  case gone
+  /// Timeout / transient network failure.
+  case timeout
+  /// 401/403 — grant spent, expired, or wrong device. Terminal.
+  case authFailed(code: String)
+  /// Terminal but not auth: 503, another 4xx, or an unparseable 2xx.
+  case failed(code: String)
+}
+
+public struct CallSessionBundle: Equatable {
+  public var callId: String
+  public var conversationId: String
+  public var conversationName: String?
+  public var media: String
+  public var created: Bool
+  public var livekitUrl: String
+  public var livekitToken: String
+  public var controlToken: String
+
+  public init(callId: String, conversationId: String, conversationName: String?, media: String,
+              created: Bool, livekitUrl: String, livekitToken: String, controlToken: String) {
+    self.callId = callId
+    self.conversationId = conversationId
+    self.conversationName = conversationName
+    self.media = media
+    self.created = created
+    self.livekitUrl = livekitUrl
+    self.livekitToken = livekitToken
+    self.controlToken = controlToken
+  }
+}
+
+// MARK: - Media
+
+/// LiveKit (or any SFU) — media only, no lifecycle opinions.
+public protocol MediaPort: AnyObject {
+  func join(bundle: CallSessionBundle)
+  func leave()
+  func setMuted(_ muted: Bool)
+  func setCamera(_ on: Bool)
+  func switchCamera()
+  /// Loudspeaker (`true`) or back to the private route (`false`).
+  func setSpeaker(_ on: Bool)
+}
+
+// MARK: - Ring surface
+
+/// The ring UX. iOS: CallKit report + tones.
+public protocol RingSurfacePort: AnyObject {
+  func show(ring: RingContext)
+  func dismiss(callId: String)
+  func ringtoneStart()
+  func ringtoneStop()
+  func ringbackStart()
+  func ringbackStop()
+}
+
+public struct RingContext: Equatable {
+  public var callId: String
+  public var conversationId: String
+  public var conversationName: String?
+  public var callerName: String?
+  public var media: String
+  public var grant: String
+  public var ringDeadlineEpochMs: Int64
+
+  public init(callId: String, conversationId: String, conversationName: String?, callerName: String?,
+              media: String, grant: String, ringDeadlineEpochMs: Int64) {
+    self.callId = callId
+    self.conversationId = conversationId
+    self.conversationName = conversationName
+    self.callerName = callerName
+    self.media = media
+    self.grant = grant
+    self.ringDeadlineEpochMs = ringDeadlineEpochMs
+  }
+}
+
+// MARK: - Session / snapshots / time
+
+/// Android: the phoneCall foreground service. iOS: the CallKit session / audio session.
+public protocol CallSessionPort: AnyObject {
+  func start(callId: String, media: String)
+  func stop()
+}
+
+/// Snapshots out — the bridge turns these into JS events (IDLE → null).
+public protocol SnapshotSink: AnyObject {
+  func emit(state: MachineState)
+}
+
+/// Closure-backed SnapshotSink convenience.
+public final class BlockSnapshotSink: SnapshotSink {
+  private let block: (MachineState) -> Void
+  public init(_ block: @escaping (MachineState) -> Void) { self.block = block }
+  public func emit(state: MachineState) { block(state) }
+}
+
+/// Time, injectable: real adapter uses DispatchQueue.main; tests a fake.
+public protocol TimerPort: AnyObject {
+  func nowMs() -> Int64
+  /// Scheduling an existing key replaces it.
+  func schedule(key: String, delayMs: Int64, fire: @escaping () -> Void)
+  func cancel(key: String)
+}
+
+// MARK: - Machine state value types (CallMachine.kt)
+
+public enum Phase: String, CaseIterable {
+  case idle = "IDLE"
+  case ringingIn = "RINGING_IN"
+  case ringingOut = "RINGING_OUT"
+  case connecting = "CONNECTING"
+  case active = "ACTIVE"
+  case reconnecting = "RECONNECTING"
+  case ended = "ENDED"
+}
+
+public enum Direction: String {
+  case incoming = "INCOMING"
+  case outgoing = "OUTGOING"
+  case joined = "JOINED"
+}
+
+public enum EndReason: String {
+  case left = "LEFT"
+  case finished = "FINISHED"
+  case declinedAll = "DECLINED_ALL"
+  case busyAll = "BUSY_ALL"
+  case noAnswer = "NO_ANSWER"
+  case cancelled = "CANCELLED"
+  case connectionLost = "CONNECTION_LOST"
+  case failed = "FAILED"
+
+  /// Wire form: lowercase snake (e.g. "declined_all").
+  public var wire: String { rawValue.lowercased() }
+}
+
+/// Everything the machine knows. Immutable value; transitions return a new one.
+public struct MachineState: Equatable {
+  public var phase: Phase
+  public var callId: String?
+  public var conversationId: String?
+  public var direction: Direction?
+  public var media: String
+  public var reason: EndReason?
+  /// HTTP attempts made for the current connecting request (retry budget = 2).
+  public var httpAttempts: Int
+
+  public init(phase: Phase = .idle, callId: String? = nil, conversationId: String? = nil,
+              direction: Direction? = nil, media: String = "audio", reason: EndReason? = nil,
+              httpAttempts: Int = 0) {
+    self.phase = phase
+    self.callId = callId
+    self.conversationId = conversationId
+    self.direction = direction
+    self.media = media
+    self.reason = reason
+    self.httpAttempts = httpAttempts
+  }
+
+  public static var IDLE: MachineState { MachineState() }
+}

package/ios/Core/SnapshotEncoding.swift

@@ -0,0 +1,75 @@
+import Foundation
+
+/// One remote participant as the JS `Snapshot.participants[]` entry.
+public struct SnapshotParticipant: Equatable {
+  /// The LiveKit identity.
+  public var userId: String
+  public var externalId: String
+  public var speaking: Bool
+  public var muted: Bool
+  /// True only with a published, subscribed, unmuted camera track.
+  public var cameraOn: Bool
+
+  public init(userId: String, externalId: String, speaking: Bool, muted: Bool, cameraOn: Bool) {
+    self.userId = userId
+    self.externalId = externalId
+    self.speaking = speaking
+    self.muted = muted
+    self.cameraOn = cameraOn
+  }
+
+  public var dictionary: [String: Any] {
+    ["userId": userId, "externalId": externalId, "speaking": speaking, "muted": muted, "cameraOn": cameraOn]
+  }
+}
+
+public extension Phase {
+  var wire: String {
+    switch self {
+    case .idle: return "idle"
+    case .ringingIn: return "ringing_in"
+    case .ringingOut: return "ringing_out"
+    case .connecting: return "connecting"
+    case .active: return "active"
+    case .reconnecting: return "reconnecting"
+    case .ended: return "ended"
+    }
+  }
+}
+
+public extension Direction {
+  var wire: String { rawValue.lowercased() }
+}
+
+public extension MachineState {
+  /// The one place a MachineState becomes the contract's `Snapshot`
+  /// (CONTRACT.md §8; mirrors SnapshotJson.kt and src/index.ts). Returns nil
+  /// for idle: the bridge sends `{ snapshot: null }`. The roster/route/self
+  /// fields are merged in by the bridge from the media adapter.
+  /// `conversationName` nil → NSNull; `reason`/`cameraFacing` omitted when nil.
+  func toSnapshot(conversationName: String? = nil,
+                  participants: [SnapshotParticipant] = [],
+                  audioRoute: String = "earpiece",
+                  mutedSelf: Bool = false,
+                  cameraOn: Bool = false,
+                  cameraFacing: String? = nil) -> [String: Any]? {
+    if phase == .idle { return nil }
+    var out: [String: Any] = [
+      "cv": 1,
+      "callId": callId.map { $0 as Any } ?? NSNull(),
+      "conversationId": conversationId.map { $0 as Any } ?? NSNull(),
+      "conversationName": conversationName.map { $0 as Any } ?? NSNull(),
+      "direction": (direction ?? .incoming).wire,
+      "media": media,
+      "phase": phase.wire,
+      "participants": participants.map { $0.dictionary },
+      "audioRoute": audioRoute,
+      "mutedSelf": mutedSelf,
+      "cameraOn": cameraOn,
+    ]
+    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 }
+    return out
+  }
+}

package/ios/Module/PoolseCallVideoView.swift

@@ -0,0 +1,62 @@
+import ExpoModulesCore
+import UIKit
+
+/// `<CallVideoView>` on iOS: a thin host for the core's LiveKitVideoSurface.
+/// All binding logic lives in the media adapter; this view forwards props
+/// and ties the surface's lifetime to the window.
+public final class PoolseCallVideoView: ExpoView {
+  private var surface: LiveKitVideoSurface?
+
+  var participantId: String?
+  var local = false
+  var mirror: Bool?
+  var fit = "cover"
+
+  public required init(appContext: AppContext? = nil) {
+    super.init(appContext: appContext)
+    backgroundColor = .clear
+    clipsToBounds = true
+  }
+
+  public override func didMoveToWindow() {
+    super.didMoveToWindow()
+    if window != nil { attachSurface() } else { detachSurface() }
+  }
+
+  public override func layoutSubviews() {
+    super.layoutSubviews()
+    surface?.frame = bounds
+  }
+
+  private func attachSurface() {
+    guard surface == nil else { return }
+    // No core yet (never configured): stay empty; a later prop update retries.
+    guard let core = CallCore.peek() else { return }
+    let s = core.createVideoSurface()
+    s.frame = bounds
+    s.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+    addSubview(s)
+    surface = s
+    apply()
+  }
+
+  func detachSurface() {
+    guard let s = surface else { return }
+    surface = nil
+    s.release()
+    s.removeFromSuperview()
+  }
+
+  func apply() {
+    guard let s = surface else {
+      if window != nil { attachSurface() }
+      return
+    }
+    s.configure(participantId: participantId, local: local, mirror: mirror, fit: fit == "contain" ? "contain" : "cover")
+  }
+
+  deinit {
+    // UIKit objects must be torn down on main; deinit of a view runs there.
+    surface?.release()
+  }
+}

package/ios/Module/PoolseCallsAppDelegateSubscriber.swift

@@ -0,0 +1,16 @@
+import ExpoModulesCore
+import UIKit
+
+/// Registers PushKit at launch, before React Native starts — the only
+/// point early enough for a VoIP push that cold-launches a killed app.
+/// Registered via expo-module.config.json "appDelegateSubscribers", so an
+/// Expo host (AppDelegate: ExpoAppDelegate) needs no AppDelegate edit.
+public class PoolseCallsAppDelegateSubscriber: ExpoAppDelegateSubscriber {
+  public func application(
+    _ application: UIApplication,
+    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil
+  ) -> Bool {
+    PoolseCallsSetup.registerVoipEarly()
+    return true
+  }
+}

package/ios/Module/PoolseCallsModule.swift

@@ -0,0 +1,111 @@
+import ExpoModulesCore
+
+/// The React Native face of the native call core on iOS — PoolseCallsModule.kt's
+/// twin, with the same names, arity and return shapes (src/index.ts is shared).
+/// Deliberately thin: commands go to CallCore, snapshots stream out.
+///
+/// Nothing here throws before `configure`: reads return idle, commands no-op.
+public class PoolseCallsModule: Module {
+  public func definition() -> ModuleDefinition {
+    Name("PoolseCalls")
+
+    Events("onCallState", "onVoipToken")
+
+    // Normally done at launch by PoolseCallsAppDelegateSubscriber; this is
+    // the backstop for a host whose AppDelegate does not forward to Expo.
+    OnCreate {
+      PoolseCallsSetup.registerVoipEarly()
+    }
+
+    OnStartObserving {
+      CallCore.listener = { [weak self] snapshot in
+        self?.sendEvent("onCallState", ["snapshot": snapshot ?? NSNull()])
+      }
+      VoipPush.tokenListener = { [weak self] token in
+        self?.sendEvent("onVoipToken", ["token": token, "environment": PoolseCallsModule.environment()])
+      }
+    }
+
+    OnStopObserving {
+      CallCore.listener = nil
+      VoipPush.tokenListener = nil
+    }
+
+    AsyncFunction("configure") { (apiBaseUrl: String, options: [String: Any]?) in
+      let env = (options?["apnsEnvironment"] as? String).flatMap { $0 == "production" || $0 == "sandbox" ? $0 : nil }
+      CallCore.configure(
+        apiBaseUrl: apiBaseUrl,
+        ringback: options?["ringback"] as? String,
+        apnsEnvironment: env
+      )
+      // Materialise the core now (and PushKit, if launch did not), so a
+      // call already in flight (cold answer) is visible to getCallState.
+      PoolseCallsSetup.registerVoipEarly()
+      _ = CallCore.getOrNull()
+    }.runOnQueue(.main)
+
+    Function("getCallState") { () -> [String: Any] in
+      ["snapshot": CallCore.peek()?.snapshot() ?? NSNull()]
+    }
+
+    AsyncFunction("place") { (conversationId: String, media: String, sessionToken: String) in
+      CallCore.getOrNull()?.place(conversationId: conversationId, media: media, sessionToken: sessionToken)
+    }.runOnQueue(.main)
+
+    AsyncFunction("join") { (callId: String, conversationId: String?, sessionToken: String) in
+      CallCore.getOrNull()?.join(callId: callId, conversationId: conversationId, sessionToken: sessionToken)
+    }.runOnQueue(.main)
+
+    Function("answer") { onCore { $0.answer() } }
+    Function("decline") { onCore { $0.decline() } }
+    Function("hangUp") { onCore { $0.hangUp() } }
+    Function("setMuted") { (muted: Bool) in onCore { $0.setMuted(muted) } }
+    Function("setCamera") { (on: Bool) in onCore { $0.setCamera(on) } }
+    Function("switchCamera") { onCore { $0.switchCamera() } }
+    Function("setSpeaker") { (on: Bool) in onCore { $0.setSpeaker(on) } }
+
+    // Socket forwarding (open app): idempotent with the push path.
+    Function("onRingEnded") { (callId: String, reason: String) in
+      onCore { $0.onRingEnded(callId: callId, reason: reason) }
+    }
+    Function("onCallFinished") { (callId: String, reason: String?) in
+      let r = (reason?.isEmpty ?? true) ? nil : reason
+      onCore { $0.onCallFinished(callId: callId, reason: r) }
+    }
+
+    // Android-only concepts: CallKit owns the lock-screen ring on iOS.
+    Function("canUseFullScreenIntent") { () -> Bool in true }
+    Function("openFullScreenIntentSettings") { () -> Void in }
+
+    Function("getVoipToken") { () -> [String: Any]? in
+      guard let token = VoipPush.shared.token else { return nil }
+      return ["token": token, "environment": PoolseCallsModule.environment()]
+    }
+
+    // <CallVideoView>: a participant's (or our own) camera.
+    View(PoolseCallVideoView.self) {
+      ViewName("PoolseCallVideo")
+      Prop("participantId") { (view: PoolseCallVideoView, id: String?) in view.participantId = id }
+      Prop("local") { (view: PoolseCallVideoView, local: Bool?) in view.local = local ?? false }
+      Prop("mirror") { (view: PoolseCallVideoView, mirror: Bool?) in view.mirror = mirror }
+      Prop("fit") { (view: PoolseCallVideoView, fit: String?) in view.fit = fit ?? "cover" }
+      OnViewDidUpdateProps { (view: PoolseCallVideoView) in view.apply() }
+    }
+  }
+
+  /// The configured APNs environment; unconfigured → the build's default.
+  static func environment() -> String {
+    if let env = CallCore.apnsEnvironment { return env }
+    #if DEBUG
+    return "sandbox"
+    #else
+    return "production"
+    #endif
+  }
+}
+
+/// Run on main against the core; a no-op when never configured.
+private func onCore(_ block: @escaping (CallCore) -> Void) {
+  let run = { if let core = CallCore.getOrNull() { block(core) } }
+  if Thread.isMainThread { run() } else { DispatchQueue.main.async(execute: run) }
+}