expo-callkit-telecom 0.1.0

package/ios/Managers/CaptureSessionManager.swift

@@ -0,0 +1,54 @@
+import AVFoundation
+import livekit_react_native_webrtc
+
+private func permissionStatusString(_ status: AVAuthorizationStatus) -> String {
+  switch status {
+  case .authorized:
+    return "granted"
+  case .denied:
+    return "denied"
+  case .notDetermined:
+    return "undetermined"
+  case .restricted:
+    return "restricted"
+  @unknown default:
+    return "unknown"
+  }
+}
+
+/// Manages video capture session state.
+final class CaptureSessionManager {
+  static let shared = CaptureSessionManager()
+
+  private init() {
+    configureMultitaskingCameraAccess()
+  }
+
+  /// Configures WebRTC to enable multitasking camera access.
+  /// On iOS 18+ with voip background mode, this allows the camera to continue
+  /// capturing when the app enters PiP or slides over another app.
+  private func configureMultitaskingCameraAccess() {
+    let options = WebRTCModuleOptions.sharedInstance()
+    options.enableMultitaskingCameraAccess = true
+    Log.call.debug("Enabled multitasking camera access for WebRTC")
+  }
+
+  /// Returns the current capture session state.
+  func getCaptureSessionState() -> [String: Any] {
+    let cameraPermission = permissionStatusString(
+      AVCaptureDevice.authorizationStatus(for: .video)
+    )
+
+    var state: [String: Any] = [
+      "cameraPermission": cameraPermission,
+    ]
+
+    // Check multitasking camera access support (iOS 16+)
+    if #available(iOS 16.0, *) {
+      let session = AVCaptureSession()
+      state["isMultitaskingCameraAccessSupported"] = session.isMultitaskingCameraAccessSupported
+    }
+
+    return state
+  }
+}

package/ios/Managers/DialtonePlayer.swift

@@ -0,0 +1,126 @@
+import AVFoundation
+import os
+
+/// Plays the dialtone sound during outgoing call connection.
+///
+/// Reads the dialtone filename from Info.plist (ExpoCallKitTelecomDefaultDialtone) and plays
+/// it in a loop until stopped.
+final class DialtonePlayer {
+  static let shared = DialtonePlayer()
+
+  private var player: AVAudioPlayer?
+  private let dialtoneFilename: String?
+  private var fadeTimer: Timer?
+
+  /// Delay before starting playback to let audio session settle (in seconds)
+  private let startDelay: TimeInterval = 0.05
+  /// Duration of volume fade-in (in seconds)
+  private let fadeInDuration: TimeInterval = 0.1
+
+  private init() {
+    dialtoneFilename =
+      Bundle.main.object(
+        forInfoDictionaryKey: "ExpoCallKitTelecomDefaultDialtone"
+      ) as? String
+  }
+
+  /// Whether a dialtone is configured in Info.plist.
+  var hasDialtone: Bool {
+    dialtoneFilename != nil
+  }
+
+  /// Starts playing the dialtone sound in a loop.
+  ///
+  /// Does nothing if no dialtone is configured or if already playing.
+  func play() {
+    guard let filename = dialtoneFilename else {
+      Log.call.debug("No dialtone configured, skipping playback")
+      return
+    }
+
+    guard player == nil else {
+      Log.call.debug("Dialtone already playing")
+      return
+    }
+
+    guard
+      let url = Bundle.main.url(forResource: filename, withExtension: nil)
+        ?? Bundle.main.url(
+          forResource: (filename as NSString).deletingPathExtension,
+          withExtension: (filename as NSString).pathExtension
+        )
+    else {
+      Log.call.error("Dialtone sound file not found: \(filename)")
+      return
+    }
+
+    // Ensure audio session is active before playing
+    guard AudioManager.shared.isActive else {
+      Log.call.debug("Audio session not active, skipping dialtone")
+      return
+    }
+
+    do {
+      player = try AVAudioPlayer(contentsOf: url)
+      player?.numberOfLoops = -1  // Loop indefinitely
+      player?.volume = 0  // Start silent for fade-in
+
+      // Brief delay to let audio session settle, then play with fade-in
+      DispatchQueue.main.asyncAfter(deadline: .now() + startDelay) { [weak self] in
+        guard let self = self, let player = self.player else { return }
+
+        player.play()
+        self.fadeIn()
+        Log.call.debug("Started playing dialtone: \(filename)")
+      }
+    } catch {
+      Log.call.error("Failed to play dialtone: \(error.localizedDescription)")
+      player = nil
+    }
+  }
+
+  /// Fades in the volume from 0 to 1 over fadeInDuration.
+  private func fadeIn() {
+    fadeTimer?.invalidate()
+
+    let steps = 10
+    let stepDuration = fadeInDuration / Double(steps)
+    let volumeStep: Float = 1.0 / Float(steps)
+    var currentStep = 0
+
+    fadeTimer = Timer.scheduledTimer(withTimeInterval: stepDuration, repeats: true) {
+      [weak self] timer in
+      guard let self = self, let player = self.player else {
+        timer.invalidate()
+        return
+      }
+
+      currentStep += 1
+      player.volume = volumeStep * Float(currentStep)
+
+      if currentStep >= steps {
+        timer.invalidate()
+        self.fadeTimer = nil
+      }
+    }
+  }
+
+  /// Stops playing the dialtone sound.
+  func stop() {
+    fadeTimer?.invalidate()
+    fadeTimer = nil
+
+    guard player != nil else {
+      return
+    }
+
+    player?.stop()
+    player = nil
+    Log.call.debug("Stopped playing dialtone")
+  }
+
+  /// Whether the dialtone is currently playing.
+  var isPlaying: Bool {
+    player?.isPlaying ?? false
+  }
+}

package/ios/Managers/FulfillRequestManager.swift

@@ -0,0 +1,154 @@
+import Foundation
+import os
+
+/// Manages pending fulfill requests with automatic timeout handling.
+///
+/// When a CallKit action requires asynchronous fulfillment (e.g., waiting for JS
+/// to connect media), this manager tracks the pending request with a unique ID
+/// and handles timeouts gracefully.
+///
+/// Usage:
+/// 1. Create a request with `createRequest(callId:timeout:)`
+/// 2. Send the request ID to JS via an event
+/// 3. When JS calls back, use `fulfill(requestId:)` to complete or no-op if timed out
+/// 4. Await the result task to get the outcome
+actor FulfillRequestManager {
+  /// Shared instance for global access.
+  static let shared = FulfillRequestManager()
+
+  /// Result of a fulfill request.
+  enum Result {
+    /// The request was successfully fulfilled, includes the associated call ID.
+    case fulfilled(callId: UUID)
+    /// The request was explicitly cancelled (e.g., JS-side failure before fulfilling).
+    case cancelled
+    /// The request timed out before being fulfilled.
+    case timedOut
+  }
+
+  /// A pending request awaiting fulfillment.
+  private struct PendingRequest {
+    let id: UUID
+    let callId: UUID
+    let createdAt: Date
+    let continuation: CheckedContinuation<Result, Never>
+    let timeoutTask: Task<Void, Never>
+  }
+
+  /// Active pending requests keyed by request ID.
+  private var pendingRequests: [UUID: PendingRequest] = [:]
+
+  private init() {}
+
+  /// Creates a new pending request with the specified call ID and timeout.
+  ///
+  /// - Parameters:
+  ///   - callId: The UUID of the call associated with this request.
+  ///   - timeout: Duration before the request automatically times out.
+  /// - Returns: A tuple containing the request ID and a task that resolves
+  ///   when the request is fulfilled or times out.
+  func createRequest(callId: UUID, timeout: Duration) -> (
+    requestId: UUID, result: Task<Result, Never>
+  ) {
+    let requestId = UUID()
+
+    let resultTask = Task<Result, Never> { [weak self] in
+      await withCheckedContinuation { continuation in
+        guard let self = self else {
+          continuation.resume(returning: .timedOut)
+          return
+        }
+
+        let timeoutTask = Task { [weak self] in
+          try? await Task.sleep(for: timeout)
+
+          guard !Task.isCancelled, let self = self else { return }
+
+          // Timeout expired - remove and resume with timedOut
+          if let request = await self.removeRequest(for: requestId) {
+            Log.call.debug("Fulfill request timed out - requestId: \(requestId)")
+            request.continuation.resume(returning: .timedOut)
+          }
+        }
+
+        let request = PendingRequest(
+          id: requestId,
+          callId: callId,
+          createdAt: Date(),
+          continuation: continuation,
+          timeoutTask: timeoutTask
+        )
+
+        Task { [weak self] in
+          await self?.addRequest(request)
+        }
+
+        Log.call.debug(
+          "Created fulfill request - requestId: \(requestId), callId: \(callId), timeout: \(timeout)"
+        )
+      }
+    }
+
+    return (requestId, resultTask)
+  }
+
+  /// Attempts to fulfill a pending request.
+  ///
+  /// If the request exists, it will be fulfilled and removed. If the request
+  /// has already timed out or was never created, this is a no-op.
+  ///
+  /// - Parameter requestId: The unique ID of the request to fulfill.
+  /// - Returns: The associated call ID if fulfilled, nil if not found.
+  func fulfill(requestId: UUID) -> UUID? {
+    guard let request = pendingRequests.removeValue(forKey: requestId) else {
+      Log.call.debug("Fulfill request not found (likely timed out) - requestId: \(requestId)")
+      return nil
+    }
+
+    // Cancel the timeout task since we're fulfilling
+    request.timeoutTask.cancel()
+
+    Log.call.debug("Fulfill request succeeded - requestId: \(requestId), callId: \(request.callId)")
+    request.continuation.resume(returning: .fulfilled(callId: request.callId))
+    return request.callId
+  }
+
+  /// Cancels a pending request without fulfilling it.
+  ///
+  /// Use this when the request should be aborted (e.g., call ended before connection).
+  ///
+  /// - Parameter requestId: The unique ID of the request to cancel.
+  func cancel(requestId: UUID) {
+    guard let request = pendingRequests.removeValue(forKey: requestId) else {
+      return
+    }
+
+    request.timeoutTask.cancel()
+    Log.call.debug("Fulfill request cancelled - requestId: \(requestId)")
+    request.continuation.resume(returning: .cancelled)
+  }
+
+  /// Cancels all pending requests.
+  ///
+  /// Use this when cleaning up (e.g., provider reset).
+  func cancelAll() {
+    let requests = pendingRequests
+    pendingRequests.removeAll()
+
+    for (id, request) in requests {
+      request.timeoutTask.cancel()
+      Log.call.debug("Fulfill request cancelled (cancelAll) - requestId: \(id)")
+      request.continuation.resume(returning: .cancelled)
+    }
+  }
+
+  // MARK: - Private Helpers
+
+  private func addRequest(_ request: PendingRequest) {
+    pendingRequests[request.id] = request
+  }
+
+  private func removeRequest(for requestId: UUID) -> PendingRequest? {
+    pendingRequests.removeValue(forKey: requestId)
+  }
+}

package/ios/Managers/VoIPPushManager+PKPushRegistryDelegate.swift

@@ -0,0 +1,123 @@
+import Foundation
+import PushKit
+
+extension VoIPPushManager: PKPushRegistryDelegate {
+  /// Called when push credentials are updated.
+  ///
+  /// Converts the token data to a hex string and stores it for JS access.
+  nonisolated func pushRegistry(
+    _ registry: PKPushRegistry,
+    didUpdate pushCredentials: PKPushCredentials,
+    for type: PKPushType
+  ) {
+    guard type == .voIP else { return }
+
+    let tokenData = pushCredentials.token
+    let tokenString = tokenData.map { String(format: "%02x", $0) }.joined()
+
+    Task { @MainActor in
+      updateToken(tokenString)
+    }
+  }
+
+  /// Called when push credentials are invalidated.
+  ///
+  /// Clears the stored token and notifies JS.
+  nonisolated func pushRegistry(
+    _ registry: PKPushRegistry,
+    didInvalidatePushTokenFor type: PKPushType
+  ) {
+    guard type == .voIP else { return }
+
+    Log.voipPush.debug("VoIP push token invalidated")
+
+    Task { @MainActor in
+      updateToken(nil)
+    }
+  }
+
+  /// Called when a VoIP push notification is received.
+  ///
+  /// This method MUST report a call to CallKit before returning, per Apple's requirements.
+  /// The payload is expected to wrap an `IncomingCallEvent` under the top-level
+  /// key `"incoming_call"`, matching `IncomingCallEventParser`.
+  ///
+  /// - Parameters:
+  ///   - registry: The push registry.
+  ///   - payload: The push payload containing the incoming call event.
+  ///   - type: The push type (should be .voIP).
+  ///   - completion: Completion handler that must be called after processing.
+  nonisolated func pushRegistry(
+    _ registry: PKPushRegistry,
+    didReceiveIncomingPushWith payload: PKPushPayload,
+    for type: PKPushType,
+    completion: @escaping () -> Void
+  ) {
+    guard type == .voIP else {
+      completion()
+      return
+    }
+
+    let dictionaryPayload = payload.dictionaryPayload
+
+    Log.voipPush.debug("Received VoIP push - payload keys: \(dictionaryPayload.keys)")
+
+    guard let event = IncomingCallEventParser.parse(from: dictionaryPayload) else {
+      Log.voipPush.error("Failed to parse VoIP push payload as IncomingCallEvent")
+      // We must still report a call to CallKit even on parse failure, or the
+      // app will be terminated.
+      reportFailedIncomingCall(completion: completion)
+      return
+    }
+
+    Log.voipPush.debug(
+      "Parsed incoming call event - serverCallId: \(event.serverCallId)"
+    )
+
+    // Report the incoming call to CallKit using callback-based API
+    // (async/await may not work reliably when app is launched from terminated state)
+    CallManager.shared.reportIncomingCall(event: event) { error in
+      if let error = error {
+        Log.voipPush.error("Failed to report incoming call: \(error.localizedDescription)")
+      } else {
+        Log.voipPush.debug("Successfully reported incoming call from VoIP push")
+      }
+      completion()
+    }
+  }
+
+  /// Reports a failed incoming call to CallKit when we can't parse the push payload.
+  ///
+  /// Per Apple's requirements, we must report a call to CallKit when receiving a VoIP push.
+  /// If we can't parse the payload, we report a call and immediately end it.
+  private nonisolated func reportFailedIncomingCall(completion: @escaping () -> Void) {
+    let fallbackEvent = IncomingCallEvent(
+      eventId: UUID().uuidString.lowercased(),
+      serverCallId: UUID().uuidString.lowercased(),
+      caller: IncomingCallEvent.Caller(
+        id: UUID().uuidString,
+        displayName: "Invalid Call",
+        avatarUrl: nil,
+        phoneNumber: nil,
+        email: nil
+      ),
+      hasVideo: false,
+      startedAt: Date(),
+      metadata: nil
+    )
+
+    // Use callback-based API for reliability when app is launched from terminated state
+    CallManager.shared.reportIncomingCall(event: fallbackEvent) { error in
+      if let error = error {
+        Log.voipPush.error("Failed to report fallback incoming call: \(error.localizedDescription)")
+      }
+      // Immediately end the call since it's invalid
+      Task {
+        if let session = await CallManager.shared.store.firstSession {
+          await CallManager.shared.reportCallEnded(for: session.id, reason: .failed)
+        }
+      }
+      completion()
+    }
+  }
+}

package/ios/Managers/VoIPPushManager.swift

@@ -0,0 +1,58 @@
+import Foundation
+import PushKit
+
+/// Manages VoIP push notification registration and token handling.
+///
+/// This singleton handles:
+/// - Registering for VoIP push notifications via PushKit
+/// - Storing and exposing the current push token
+/// - Emitting events when the token updates or is invalidated
+///
+/// VoIP pushes are used to receive incoming call notifications and must report
+/// a call to CallKit immediately upon receipt.
+final class VoIPPushManager: NSObject {
+  static let shared = VoIPPushManager()
+
+  /// The PushKit registry for VoIP notifications.
+  private var pushRegistry: PKPushRegistry?
+
+  /// The current VoIP push token, if available.
+  private(set) var token: String?
+
+  private override init() {
+    super.init()
+  }
+
+  /// Registers for VoIP push notifications.
+  ///
+  /// This creates a PKPushRegistry and requests VoIP push credentials.
+  /// The token will be available via the `token` property once received,
+  /// and a `VoIPPushTokenUpdatedEvent` will be emitted.
+  func register() {
+    guard pushRegistry == nil else {
+      Log.voipPush.debug("VoIP push already registered")
+      return
+    }
+
+    Log.voipPush.debug("Registering for VoIP push notifications")
+
+    let registry = PKPushRegistry(queue: .main)
+    registry.delegate = self
+    registry.desiredPushTypes = [.voIP]
+    pushRegistry = registry
+  }
+
+  /// Updates the stored token and emits an event to JS.
+  ///
+  /// - Parameter newToken: The new token string, or nil if invalidated.
+  @MainActor
+  func updateToken(_ newToken: String?) {
+    let oldToken = token
+    token = newToken
+
+    if oldToken != newToken {
+      Log.voipPush.debug("VoIP token updated - hasToken: \(newToken != nil)")
+      CallEventEmitter.shared.send(VoIPPushTokenUpdatedEvent(token: newToken))
+    }
+  }
+}