expo-callkit-telecom 0.1.0

package/ios/Models/CallEvents.swift

@@ -0,0 +1,263 @@
+import AVFoundation
+import CallKit
+import Foundation
+
+/// Protocol for events that can be sent to JS.
+protocol CallEvent {
+  static var name: String { get }
+  var body: [String: Any] { get }
+}
+
+// MARK: - Constants
+
+private enum CallEventKeys {
+  static let id = "id"
+}
+
+// MARK: - Call Session Events
+
+struct CallSessionAddedEvent: CallEvent {
+  static let name = "onCallSessionAdded"
+
+  let session: CallSession
+
+  var body: [String: Any] {
+    ["session": session.toDictionary()]
+  }
+}
+
+struct CallSessionUpdatedEvent: CallEvent {
+  static let name = "onCallSessionUpdated"
+
+  let session: CallSession
+
+  var body: [String: Any] {
+    ["session": session.toDictionary()]
+  }
+}
+
+struct CallSessionRemovedEvent: CallEvent {
+  static let name = "onCallSessionRemoved"
+
+  let id: UUID
+
+  var body: [String: Any] {
+    [CallEventKeys.id: id.uuidString]
+  }
+}
+
+// MARK: - Audio Session Events
+
+struct AudioSessionCallInfo {
+  let id: UUID
+  let status: CallSession.Status
+
+  init(from session: CallSession) {
+    self.id = session.id
+    self.status = session.status
+  }
+
+  func toDictionary() -> [String: Any] {
+    [
+      "id": id.uuidString,
+      "status": status.rawValue,
+    ]
+  }
+}
+
+struct AudioSessionActivatedEvent: CallEvent {
+  static let name = "onAudioSessionActivated"
+
+  let calls: [AudioSessionCallInfo]
+
+  var body: [String: Any] {
+    ["calls": calls.map { $0.toDictionary() }]
+  }
+}
+
+struct AudioSessionDeactivatedEvent: CallEvent {
+  static let name = "onAudioSessionDeactivated"
+
+  let calls: [AudioSessionCallInfo]
+
+  var body: [String: Any] {
+    ["calls": calls.map { $0.toDictionary() }]
+  }
+}
+
+struct AudioRouteChangedEvent: CallEvent {
+  static let name = "onAudioRouteChanged"
+
+  let inputs: [[String: String]]
+  let outputs: [[String: String]]
+
+  var body: [String: Any] {
+    [
+      "currentRoute": [
+        "inputs": inputs,
+        "outputs": outputs,
+      ]
+    ]
+  }
+}
+
+// MARK: - Call Intent Events
+
+struct CallIntentReceivedEvent: CallEvent {
+  static let name = "onCallIntentReceived"
+
+  let handle: String
+  let handleType: String
+  let hasVideo: Bool
+
+  var body: [String: Any] {
+    [
+      "handle": handle,
+      "handleType": handleType,
+      "hasVideo": hasVideo,
+    ]
+  }
+}
+
+// MARK: - Call Action Events
+
+struct IncomingCallReportedEvent: CallEvent {
+  static let name = "onIncomingCallReported"
+
+  let id: UUID
+
+  var body: [String: Any] {
+    [CallEventKeys.id: id.uuidString]
+  }
+}
+
+struct OutgoingCallStartedEvent: CallEvent {
+  static let name = "onOutgoingCallStarted"
+
+  let id: UUID
+
+  var body: [String: Any] {
+    [CallEventKeys.id: id.uuidString]
+  }
+}
+
+struct CallAnsweredEvent: CallEvent {
+  static let name = "onCallAnswered"
+
+  let id: UUID
+  let requestId: UUID
+
+  var body: [String: Any] {
+    [
+      CallEventKeys.id: id.uuidString,
+      "requestId": requestId.uuidString,
+    ]
+  }
+}
+
+struct CallEndedEvent: CallEvent {
+  static let name = "onCallEnded"
+
+  let id: UUID
+
+  var body: [String: Any] {
+    [CallEventKeys.id: id.uuidString]
+  }
+}
+
+struct CallReportedEnded: CallEvent {
+  static let name = "onCallReportedEnded"
+
+  let id: UUID
+  let reason: CXCallEndedReason
+
+  var body: [String: Any] {
+    [
+      CallEventKeys.id: id.uuidString,
+      "reason": Self.reasonString(for: reason),
+    ]
+  }
+
+  private static func reasonString(for reason: CXCallEndedReason) -> String {
+    switch reason {
+    case .failed: return "failed"
+    case .remoteEnded: return "remoteEnded"
+    case .unanswered: return "unanswered"
+    case .answeredElsewhere: return "answeredElsewhere"
+    case .declinedElsewhere: return "declinedElsewhere"
+    @unknown default: return "unknown"
+    }
+  }
+}
+
+struct SetMutedActionEvent: CallEvent {
+  static let name = "onSetMutedAction"
+
+  let id: UUID
+  let isMuted: Bool
+
+  var body: [String: Any] {
+    [
+      CallEventKeys.id: id.uuidString,
+      "isMuted": isMuted,
+    ]
+  }
+}
+
+struct SetHeldActionEvent: CallEvent {
+  static let name = "onSetHeldAction"
+
+  let id: UUID
+  let isOnHold: Bool
+
+  var body: [String: Any] {
+    [
+      CallEventKeys.id: id.uuidString,
+      "isOnHold": isOnHold,
+    ]
+  }
+}
+
+struct DTMFEvent: CallEvent {
+  static let name = "onDTMF"
+
+  let id: UUID
+  let digits: String
+
+  var body: [String: Any] {
+    [
+      CallEventKeys.id: id.uuidString,
+      "digits": digits,
+    ]
+  }
+}
+
+struct VideoChangedEvent: CallEvent {
+  static let name = "onVideoChanged"
+
+  let id: UUID
+  let hasVideo: Bool
+
+  var body: [String: Any] {
+    [
+      CallEventKeys.id: id.uuidString,
+      "hasVideo": hasVideo,
+    ]
+  }
+}
+
+// MARK: - VoIP Push Events
+
+struct VoIPPushTokenUpdatedEvent: CallEvent {
+  static let name = "onVoIPPushTokenUpdated"
+
+  let token: String?
+
+  var body: [String: Any] {
+    var result: [String: Any] = ["type": "APNS_VOIP"]
+    if let token = token {
+      result["token"] = token
+    }
+    return result
+  }
+}

package/ios/Models/CallOptions.swift

@@ -0,0 +1,15 @@
+import ExpoModulesCore
+import Foundation
+
+struct CallOptions: Equatable {
+  var hasVideo: Bool
+}
+
+struct CallOptionsRecord: Record {
+  @Field
+  var hasVideo: Bool = false
+
+  func toModel() -> CallOptions {
+    CallOptions(hasVideo: hasVideo)
+  }
+}

package/ios/Models/CallParticipant.swift

@@ -0,0 +1,37 @@
+import ExpoModulesCore
+import Foundation
+
+struct CallParticipant: Equatable {
+  let id: String
+  let phoneNumber: String?
+  let email: String?
+  let displayName: String?
+  let avatarUrl: String?
+}
+
+struct CallParticipantRecord: Record {
+  @Field
+  var id: String
+
+  @Field
+  var phoneNumber: String?
+
+  @Field
+  var email: String?
+
+  @Field
+  var displayName: String?
+
+  @Field
+  var avatarUrl: String?
+
+  func toModel() -> CallParticipant {
+    CallParticipant(
+      id: id,
+      phoneNumber: phoneNumber,
+      email: email,
+      displayName: displayName,
+      avatarUrl: avatarUrl
+    )
+  }
+}

package/ios/Models/CallSession.swift

@@ -0,0 +1,80 @@
+import Foundation
+
+/// Represents an active CallKit session.
+struct CallSession: Equatable {
+  let id: UUID
+  var options: CallOptions
+  let origin: Origin
+  let remoteParticipants: [CallParticipant]
+  let incomingCallEvent: IncomingCallEvent?
+  var status: Status
+  var connectedAt: Date?
+  var isMuted: Bool
+  var isOnHold: Bool
+  var dtmfDigits: String?
+
+  enum Origin: String {
+    case incoming
+    case outgoingApp
+    case outgoingSystem
+  }
+
+  enum Status: String {
+    case requesting
+    case ringing
+    case connecting
+    case connected
+    case ended
+  }
+}
+
+// MARK: - Serialization
+
+extension CallSession {
+  func toDictionary() -> [String: Any] {
+    var dict: [String: Any] = [
+      "id": id.uuidString,
+      "origin": origin.rawValue,
+      "options": [
+        "hasVideo": options.hasVideo
+      ],
+      "remoteParticipants": remoteParticipants.map { participant in
+        var p: [String: Any] = [
+          "id": participant.id
+        ]
+        if let phoneNumber = participant.phoneNumber {
+          p["phoneNumber"] = phoneNumber
+        }
+        if let email = participant.email {
+          p["email"] = email
+        }
+        if let displayName = participant.displayName {
+          p["displayName"] = displayName
+        }
+        if let avatarUrl = participant.avatarUrl {
+          p["avatarUrl"] = avatarUrl
+        }
+        return p
+      },
+      "status": status.rawValue,
+      "isMuted": isMuted,
+      "isOnHold": isOnHold,
+    ]
+
+    if let dtmfDigits = dtmfDigits {
+      dict["dtmfDigits"] = dtmfDigits
+    }
+
+    if let connectedAt = connectedAt {
+      dict["connectedAt"] = ISO8601DateFormatter().string(
+        from: connectedAt
+      )
+    }
+
+    if let incomingCallEvent = incomingCallEvent {
+      dict["incomingCallEvent"] = incomingCallEvent.toDictionary()
+    }
+
+    return dict
+  }
+}

package/ios/Models/IncomingCallEvent.swift

@@ -0,0 +1,196 @@
+import ExpoModulesCore
+import Foundation
+
+/// A validated incoming call event, parsed from a push payload or supplied
+/// directly by JS via `reportIncomingCall`.
+///
+/// Mirrors the TS `IncomingCallEvent` declared in `src/Calls.types.ts`.
+struct IncomingCallEvent: Equatable {
+  let eventId: String
+  /// Server-assigned id for this call (distinct from the native UUID assigned
+  /// by CallKit). Use this to talk to your backend about the call.
+  let serverCallId: String
+  let caller: Caller
+  let hasVideo: Bool
+  let startedAt: Date?
+  /// App-defined extra fields forwarded verbatim from the push payload.
+  /// Opaque to the library; excluded from `==` since `[String: Any]` is not
+  /// `Equatable` and events with the same `eventId` are treated as equivalent.
+  let metadata: [String: Any]?
+
+  struct Caller: Equatable {
+    let id: String
+    let displayName: String?
+    let avatarUrl: String?
+    let phoneNumber: String?
+    let email: String?
+  }
+
+  static func == (lhs: IncomingCallEvent, rhs: IncomingCallEvent) -> Bool {
+    lhs.eventId == rhs.eventId
+      && lhs.serverCallId == rhs.serverCallId
+      && lhs.caller == rhs.caller
+      && lhs.hasVideo == rhs.hasVideo
+      && lhs.startedAt == rhs.startedAt
+  }
+
+  func toDictionary() -> [String: Any] {
+    var dict: [String: Any] = [
+      "eventId": eventId,
+      "serverCallId": serverCallId,
+      "hasVideo": hasVideo,
+      "caller": {
+        var c: [String: Any] = ["id": caller.id]
+        if let displayName = caller.displayName {
+          c["displayName"] = displayName
+        }
+        if let avatarUrl = caller.avatarUrl {
+          c["avatarUrl"] = avatarUrl
+        }
+        if let phoneNumber = caller.phoneNumber {
+          c["phoneNumber"] = phoneNumber
+        }
+        if let email = caller.email {
+          c["email"] = email
+        }
+        return c
+      }(),
+    ]
+    if let startedAt = startedAt {
+      dict["startedAt"] = ISO8601DateFormatter().string(from: startedAt)
+    }
+    if let metadata = metadata {
+      dict["metadata"] = metadata
+    }
+    return dict
+  }
+}
+
+// MARK: - Expo Records (JS → Native, via `reportIncomingCall`)
+
+struct IncomingCallCallerRecord: Record {
+  @Field
+  var id: String = ""
+
+  @Field
+  var displayName: String?
+
+  @Field
+  var avatarUrl: String?
+
+  @Field
+  var phoneNumber: String?
+
+  @Field
+  var email: String?
+}
+
+struct IncomingCallEventRecord: Record {
+  @Field
+  var eventId: String = ""
+
+  @Field
+  var serverCallId: String = ""
+
+  @Field
+  var caller: IncomingCallCallerRecord = IncomingCallCallerRecord()
+
+  @Field
+  var hasVideo: Bool = false
+
+  @Field
+  var startedAt: String?
+
+  @Field
+  var metadata: [String: Any]?
+
+  func toModel() throws -> IncomingCallEvent {
+    let startedAtDate: Date?
+    if let raw = startedAt, !raw.isEmpty {
+      startedAtDate = IncomingCallEventParser.parseRFC3339Date(raw) ?? Date()
+    } else {
+      startedAtDate = nil
+    }
+    return IncomingCallEvent(
+      eventId: eventId,
+      serverCallId: serverCallId,
+      caller: IncomingCallEvent.Caller(
+        id: caller.id,
+        displayName: caller.displayName,
+        avatarUrl: caller.avatarUrl,
+        phoneNumber: caller.phoneNumber,
+        email: caller.email
+      ),
+      hasVideo: hasVideo,
+      startedAt: startedAtDate,
+      metadata: metadata
+    )
+  }
+}
+
+// MARK: - Push-payload parsing (PushKit / FCM dictionary → model)
+
+/// Parses an `IncomingCallEvent` from a VoIP push payload.
+///
+/// The payload must wrap the event under the top-level key `"incoming_call"`.
+/// There is no fallback to a flat top-level shape. Inner keys are camelCase
+/// to match the TS contract and the example server's wire format.
+enum IncomingCallEventParser {
+  static func parse(from payload: [AnyHashable: Any]) -> IncomingCallEvent? {
+    guard let event = payload["incoming_call"] as? [AnyHashable: Any] else {
+      return nil
+    }
+
+    let eventId = event["eventId"] as? String ?? ""
+    let serverCallId = event["serverCallId"] as? String ?? ""
+    guard !eventId.isEmpty, !serverCallId.isEmpty else {
+      return nil
+    }
+
+    guard let callerDict = event["caller"] as? [AnyHashable: Any],
+      let callerId = callerDict["id"] as? String,
+      !callerId.isEmpty
+    else {
+      return nil
+    }
+    let caller = IncomingCallEvent.Caller(
+      id: callerId,
+      displayName: callerDict["displayName"] as? String,
+      avatarUrl: callerDict["avatarUrl"] as? String,
+      phoneNumber: callerDict["phoneNumber"] as? String,
+      email: callerDict["email"] as? String
+    )
+
+    let hasVideo = event["hasVideo"] as? Bool ?? false
+
+    let startedAt: Date?
+    if let raw = event["startedAt"] as? String {
+      startedAt = parseRFC3339Date(raw)
+    } else {
+      startedAt = nil
+    }
+
+    let metadata = event["metadata"] as? [String: Any]
+
+    return IncomingCallEvent(
+      eventId: eventId,
+      serverCallId: serverCallId,
+      caller: caller,
+      hasVideo: hasVideo,
+      startedAt: startedAt,
+      metadata: metadata
+    )
+  }
+
+  /// Parses an RFC 3339 timestamp. Handles optional fractional seconds.
+  static func parseRFC3339Date(_ string: String) -> Date? {
+    let withFraction = ISO8601DateFormatter()
+    withFraction.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+    if let date = withFraction.date(from: string) {
+      return date
+    }
+    let noFraction = ISO8601DateFormatter()
+    noFraction.formatOptions = [.withInternetDateTime]
+    return noFraction.date(from: string)
+  }
+}