@poolse/react-native-calls 0.2.0 → 0.4.0

package/ios/Platform/LiveKitMediaPort.swift

@@ -0,0 +1,445 @@
+import AVFoundation
+import Foundation
+#if canImport(LiveKitClient)
+import LiveKitClient // CocoaPods module name
+#else
+import LiveKit // SwiftPM module name
+#endif
+import UIKit
+
+/// Media-level signals the SFU adapter reports back to the core
+/// (CallCore.kt's MediaEvents). Delivered on the main thread.
+protocol MediaEvents: AnyObject {
+  func onConnected()
+  func onFailed()
+  /// Unexpected disconnect — the SFU gave up; the core asks the server and rejoins.
+  func onLost()
+  /// The SFU is resuming the session itself; only reflected in the UI.
+  func onReconnecting()
+  func onRecovered()
+  func onRemoteJoined()
+  /// The REMOTE roster (the local participant excluded).
+  func onParticipants(_ participants: [SnapshotParticipant])
+  /// `earpiece` | `speaker` | `bluetooth` | `headset`.
+  func onAudioRoute(_ route: String)
+  /// The local camera track is (not) published + enabled; facing `front` | `back`.
+  func onLocalCamera(on: Bool, facing: String?)
+}
+
+/// The shipped MediaPort over LiveKit's Swift SDK — LiveKitMediaPort.kt
+/// for iOS. Joins with the server-minted token, publishes the mic (and
+/// the camera for video), tracks the roster and reports room transitions.
+///
+/// Audio is CallKit's: LiveKit's automatic AVAudioSession handling is off
+/// and its engine is only available between CallKit's didActivate and
+/// didDeactivate (LiveKit's documented CallKit integration).
+///
+/// Threading: every method is called on main; LiveKit's delegate
+/// callbacks hop to main; async work re-checks that the room it captured
+/// is still the current one.
+final class LiveKitMediaPort: NSObject, MediaPort {
+  private weak var events: MediaEvents?
+
+  private(set) var room: Room?
+  private var observer: RoomObserver?
+  private var media = "audio"
+  private var connectedRoom: ObjectIdentifier?
+
+  /// Speaker forced by the user; nil = the media-type default.
+  private var speakerWanted: Bool?
+  /// The user's choices for the CURRENT call; survive a rejoin.
+  private var mutedWanted = false
+  private var cameraWanted: Bool?
+  private var joinedCallId: String?
+
+  private let surfaces = NSHashTable<LiveKitVideoSurface>.weakObjects()
+  private var audioPrepared = false
+  private var audioActive = false
+
+  init(events: MediaEvents) {
+    self.events = events
+    super.init()
+    NotificationCenter.default.addObserver(self, selector: #selector(routeChanged),
+                                           name: AVAudioSession.routeChangeNotification, object: nil)
+  }
+
+  // MARK: - audio session (CallKit-driven)
+
+  /// Before any room exists: LiveKit must not configure the session nor
+  /// start its engine outside CallKit's activation window.
+  private func prepareAudio() {
+    guard !audioPrepared else { return }
+    audioPrepared = true
+    AudioManager.shared.audioSession.isAutomaticConfigurationEnabled = false
+    do { try AudioManager.shared.setEngineAvailability(.none) } catch {
+      NSLog("[PoolseCalls] setEngineAvailability(.none) failed: %@", "\(error)")
+    }
+  }
+
+  /// CallKit activated the session (or, without CallKit, we did).
+  func audioActivated(_ session: AVAudioSession, media: String) {
+    prepareAudio()
+    audioActive = true
+    let video = media == "video"
+    do {
+      try session.setCategory(.playAndRecord, mode: video && speakerWanted != false ? .videoChat : .voiceChat,
+                              options: [.allowBluetooth, .allowBluetoothA2DP])
+    } catch {
+      NSLog("[PoolseCalls] audio session category failed: %@", "\(error)")
+    }
+    do { try AudioManager.shared.setEngineAvailability(.default) } catch {
+      NSLog("[PoolseCalls] setEngineAvailability(.default) failed: %@", "\(error)")
+    }
+    if media != self.media && room == nil { self.media = media }
+    applyRoute()
+  }
+
+  func audioDeactivated() {
+    audioActive = false
+    guard audioPrepared else { return }
+    do { try AudioManager.shared.setEngineAvailability(.none) } catch {
+      NSLog("[PoolseCalls] setEngineAvailability(.none) failed: %@", "\(error)")
+    }
+  }
+
+  /// No CallKit call holds the session (CallKit refused the outgoing
+  /// transaction): activate it ourselves so the call still has audio.
+  func activateAudioWithoutCallKit(media: String) {
+    let s = AVAudioSession.sharedInstance()
+    do { try s.setActive(true) } catch { NSLog("[PoolseCalls] session activate failed: %@", "\(error)") }
+    audioActivated(s, media: media)
+  }
+
+  // MARK: - MediaPort
+
+  func join(bundle: CallSessionBundle) {
+    prepareAudio()
+    if let joined = joinedCallId, joined != bundle.callId { resetWanted() }
+    joinedCallId = bundle.callId
+    detach()
+    media = bundle.media
+    let wantsVideo = bundle.media == "video"
+
+    // A 1:1/small call: never let the SFU pause a subscribed camera for
+    // "not visible" — a view that mounts late would stay black.
+    let r = Room(roomOptions: RoomOptions(adaptiveStream: false, dynacast: false))
+    let obs = RoomObserver(port: self, room: r)
+    r.add(delegate: obs)
+    room = r
+    observer = obs
+    refreshVideo()
+
+    let url = bundle.livekitUrl
+    let token = bundle.livekitToken
+    Task { [weak self] in
+      do {
+        try await r.connect(url: url, token: token, connectOptions: ConnectOptions(autoSubscribe: true))
+      } catch {
+        NSLog("[PoolseCalls] LiveKit connect failed: %@", "\(error)")
+        await MainActor.run {
+          guard let self = self, self.room === r else { return }
+          self.room = nil
+          self.observer = nil
+          self.refreshVideo()
+          self.events?.onFailed()
+        }
+        await r.disconnect()
+        return
+      }
+      let proceed: Bool = await MainActor.run {
+        guard let self = self, self.room === r else { return false }
+        self.markConnected(r)
+        return true
+      }
+      guard proceed, let self = self else {
+        if !proceed { await r.disconnect() }
+        return
+      }
+      let muted = await MainActor.run { self.mutedWanted }
+      do { try await r.localParticipant.setMicrophone(enabled: !muted) } catch {
+        NSLog("[PoolseCalls] microphone publish failed: %@", "\(error)")
+      }
+      let camera = await MainActor.run { self.cameraWanted ?? wantsVideo }
+      if camera { await self.enableCamera(r, true) }
+      await MainActor.run {
+        self.reportLocalCamera(r)
+        self.refreshVideo()
+      }
+    }
+  }
+
+  /// Connected (once per room): the core moves on; anyone already in is "joined".
+  private func markConnected(_ r: Room) {
+    guard room === r, connectedRoom != ObjectIdentifier(r) else { return }
+    connectedRoom = ObjectIdentifier(r)
+    if speakerWanted != nil { applyRoute() }
+    events?.onConnected()
+    if !r.remoteParticipants.isEmpty { events?.onRemoteJoined() }
+    emit(r)
+    refreshVideo()
+  }
+
+  private func cameraGranted() -> Bool {
+    AVCaptureDevice.authorizationStatus(for: .video) == .authorized
+  }
+
+  /// Without the camera grant a video call joins audio-only; a later
+  /// setCamera(true) after the user grants it publishes then.
+  private func enableCamera(_ r: Room, _ on: Bool) async {
+    if on && !cameraGranted() {
+      NSLog("[PoolseCalls] camera not authorized: staying audio-only")
+      return
+    }
+    do {
+      try await r.localParticipant.setCamera(enabled: on, captureOptions: on ? CameraCaptureOptions(position: .front) : nil)
+    } catch {
+      NSLog("[PoolseCalls] camera %@ failed: %@", on ? "publish" : "unpublish", "\(error)")
+    }
+  }
+
+  func leave() {
+    detach()
+    resetWanted()
+    joinedCallId = nil
+  }
+
+  private func resetWanted() {
+    mutedWanted = false
+    cameraWanted = nil
+    speakerWanted = nil
+  }
+
+  private func detach() {
+    guard let r = room else { return }
+    if let obs = observer { r.remove(delegate: obs) }
+    room = nil
+    observer = nil
+    connectedRoom = nil
+    refreshVideo()
+    Task { await r.disconnect() }
+    events?.onLocalCamera(on: false, facing: nil)
+  }
+
+  func setMuted(_ muted: Bool) {
+    mutedWanted = muted
+    guard let r = room, connectedRoom == ObjectIdentifier(r) else { return }
+    Task { _ = try? await r.localParticipant.setMicrophone(enabled: !muted) }
+  }
+
+  func setCamera(_ on: Bool) {
+    cameraWanted = on
+    guard let r = room, connectedRoom == ObjectIdentifier(r) else { return }
+    Task { [weak self] in
+      await self?.enableCamera(r, on)
+      await MainActor.run {
+        guard let self = self, self.room === r else { return }
+        self.reportLocalCamera(r)
+        self.refreshVideo()
+      }
+    }
+  }
+
+  func switchCamera() {
+    guard let r = room, let track = localCameraTrack(r), let capturer = track.capturer as? CameraCapturer else { return }
+    Task { [weak self] in
+      do { _ = try await capturer.switchCameraPosition() } catch {
+        NSLog("[PoolseCalls] switchCamera failed: %@", "\(error)")
+      }
+      await MainActor.run {
+        guard let self = self, self.room === r else { return }
+        self.reportLocalCamera(r)
+        self.refreshVideo()
+      }
+    }
+  }
+
+  func setSpeaker(_ on: Bool) {
+    speakerWanted = on
+    applyRoute()
+  }
+
+  // MARK: - audio routing
+
+  /// A voice call is held to the ear (earpiece, or a headset/Bluetooth
+  /// route first); video defaults to the loudspeaker.
+  private func applyRoute() {
+    guard audioActive else { return }
+    let s = AVAudioSession.sharedInstance()
+    let want = speakerWanted ?? (media == "video")
+    do {
+      if want {
+        try s.overrideOutputAudioPort(.speaker)
+      } else {
+        // .videoChat forces the speaker; the private route needs .voiceChat.
+        if s.mode == .videoChat { try s.setMode(.voiceChat) }
+        try s.overrideOutputAudioPort(.none)
+      }
+    } catch {
+      NSLog("[PoolseCalls] audio route failed: %@", "\(error)")
+    }
+    reportRoute()
+  }
+
+  private func currentRoute() -> String {
+    let outputs = AVAudioSession.sharedInstance().currentRoute.outputs
+    guard let port = outputs.first?.portType else { return media == "video" ? "speaker" : "earpiece" }
+    switch port {
+    case .builtInSpeaker: return "speaker"
+    case .builtInReceiver: return "earpiece"
+    case .bluetoothHFP, .bluetoothA2DP, .bluetoothLE, .carAudio, .airPlay: return "bluetooth"
+    case .headphones, .usbAudio, .lineOut, .HDMI: return "headset"
+    default: return "headset"
+    }
+  }
+
+  private func reportRoute() {
+    guard joinedCallId != nil || audioActive else { return }
+    events?.onAudioRoute(currentRoute())
+  }
+
+  @objc private func routeChanged(_ note: Notification) {
+    DispatchQueue.main.async { [weak self] in
+      guard let self = self, self.audioActive else { return }
+      // A user's speaker choice survives route changes, except that a
+      // newly connected headset/Bluetooth device always wins.
+      let route = self.currentRoute()
+      if let wanted = self.speakerWanted, route == "speaker" || route == "earpiece", (route == "speaker") != wanted {
+        self.applyRoute()
+        return
+      }
+      self.reportRoute()
+    }
+  }
+
+  // MARK: - video
+
+  func createVideoSurface() -> LiveKitVideoSurface {
+    let s = LiveKitVideoSurface(port: self)
+    surfaces.add(s)
+    return s
+  }
+
+  func unregister(_ s: LiveKitVideoSurface) { surfaces.remove(s) }
+
+  private func refreshVideo() {
+    for s in surfaces.allObjects { s.rebind() }
+  }
+
+  private func localCameraTrack(_ r: Room) -> LocalVideoTrack? {
+    guard let pub = r.localParticipant.trackPublications.values.first(where: { $0.source == .camera }), !pub.isMuted else { return nil }
+    return pub.track as? LocalVideoTrack
+  }
+
+  /// The local camera, or a remote's — only once published, SUBSCRIBED and unmuted.
+  func cameraTrack(participantId: String?, local: Bool) -> VideoTrack? {
+    guard let r = room else { return nil }
+    if local { return localCameraTrack(r) }
+    guard let id = participantId,
+          let p = r.remoteParticipants.values.first(where: { $0.identity?.stringValue == id }) else { return nil }
+    return remoteCamera(p)
+  }
+
+  private func remoteCamera(_ p: RemoteParticipant) -> VideoTrack? {
+    guard let pub = p.trackPublications.values.first(where: { $0.source == .camera }) as? RemoteTrackPublication,
+          pub.isSubscribed, !pub.isMuted else { return nil }
+    return pub.track as? VideoTrack
+  }
+
+  /// `front` | `back` of the published local camera, or nil when none.
+  func cameraFacing() -> String? {
+    guard let r = room, let track = localCameraTrack(r) else { return nil }
+    return (track.capturer as? CameraCapturer)?.position == .back ? "back" : "front"
+  }
+
+  private func reportLocalCamera(_ r: Room) {
+    guard room === r else { return }
+    let on = localCameraTrack(r) != nil
+    events?.onLocalCamera(on: on, facing: on ? cameraFacing() : nil)
+  }
+
+  // MARK: - room events (main thread, via RoomObserver)
+
+  fileprivate func roomEvent(_ r: Room, _ kind: RoomObserver.Kind) {
+    guard room === r else { return }
+    switch kind {
+    case .connected:
+      markConnected(r)
+    case .reconnecting:
+      events?.onReconnecting()
+    case .reconnected:
+      events?.onRecovered()
+    case .disconnected:
+      events?.onLost()
+    case .participantJoined:
+      events?.onRemoteJoined()
+      emit(r)
+      refreshVideo()
+    case .tracksChanged:
+      emit(r)
+      reportLocalCamera(r)
+      refreshVideo()
+    case .rosterChanged:
+      emit(r)
+    }
+  }
+
+  /// The REMOTE roster — the local participant is never included.
+  private func emit(_ r: Room) {
+    let roster = r.remoteParticipants.values.map { p -> SnapshotParticipant in
+      let identity = p.identity?.stringValue ?? ""
+      return SnapshotParticipant(
+        userId: identity,
+        externalId: externalId(p) ?? identity,
+        speaking: p.isSpeaking,
+        muted: !p.isMicrophoneEnabled(),
+        cameraOn: remoteCamera(p) != nil
+      )
+    }
+    events?.onParticipants(roster)
+  }
+
+  /// The host's own user id, if the server put it in attributes/metadata.
+  private func externalId(_ p: Participant) -> String? {
+    if let v = p.attributes["external_id"], !v.isEmpty { return v }
+    guard let m = p.metadata, let d = m.data(using: .utf8),
+          let obj = (try? JSONSerialization.jsonObject(with: d)) as? [String: Any],
+          let v = obj["external_id"] as? String, !v.isEmpty else { return nil }
+    return v
+  }
+}
+
+/// LiveKit's delegate → main-thread room events for the port.
+final class RoomObserver: NSObject, RoomDelegate, @unchecked Sendable {
+  enum Kind { case connected, reconnecting, reconnected, disconnected, participantJoined, tracksChanged, rosterChanged }
+
+  private weak var port: LiveKitMediaPort?
+  private weak var room: Room?
+
+  init(port: LiveKitMediaPort, room: Room) {
+    self.port = port
+    self.room = room
+  }
+
+  private func send(_ r: Room, _ kind: Kind) {
+    DispatchQueue.main.async { [weak self] in self?.port?.roomEvent(r, kind) }
+  }
+
+  func roomDidConnect(_ room: Room) { send(room, .connected) }
+  func room(_ room: Room, didStartReconnectWithMode reconnectMode: ReconnectMode) { send(room, .reconnecting) }
+  func room(_ room: Room, didCompleteReconnectWithMode reconnectMode: ReconnectMode) { send(room, .reconnected) }
+  // Our own leave() removes this delegate before disconnecting, so any
+  // disconnect seen here is the SFU giving up (or the server removing us).
+  func room(_ room: Room, didDisconnectWithError error: LiveKitError?) { send(room, .disconnected) }
+  func room(_ room: Room, participantDidConnect participant: RemoteParticipant) { send(room, .participantJoined) }
+  func room(_ room: Room, participantDidDisconnect participant: RemoteParticipant) { send(room, .tracksChanged) }
+  func room(_ room: Room, participant: RemoteParticipant, didSubscribeTrack publication: RemoteTrackPublication) { send(room, .tracksChanged) }
+  func room(_ room: Room, participant: RemoteParticipant, didUnsubscribeTrack publication: RemoteTrackPublication) { send(room, .tracksChanged) }
+  func room(_ room: Room, participant: RemoteParticipant, didPublishTrack publication: RemoteTrackPublication) { send(room, .tracksChanged) }
+  func room(_ room: Room, participant: RemoteParticipant, didUnpublishTrack publication: RemoteTrackPublication) { send(room, .tracksChanged) }
+  func room(_ room: Room, participant: LocalParticipant, didPublishTrack publication: LocalTrackPublication) { send(room, .tracksChanged) }
+  func room(_ room: Room, participant: LocalParticipant, didUnpublishTrack publication: LocalTrackPublication) { send(room, .tracksChanged) }
+  func room(_ room: Room, participant: Participant, trackPublication: TrackPublication, didUpdateIsMuted isMuted: Bool) { send(room, .tracksChanged) }
+  func room(_ room: Room, didUpdateSpeakingParticipants participants: [Participant]) { send(room, .rosterChanged) }
+  func room(_ room: Room, participant: Participant, didUpdateMetadata metadata: String?) { send(room, .rosterChanged) }
+  func room(_ room: Room, participant: Participant, didUpdateAttributes attributes: [String: String]) { send(room, .rosterChanged) }
+}

package/ios/Platform/LiveKitVideoSurface.swift

@@ -0,0 +1,67 @@
+#if canImport(LiveKitClient)
+import LiveKitClient // CocoaPods module name
+#else
+import LiveKit // SwiftPM module name
+#endif
+import UIKit
+
+/// One on-screen video slot over LiveKit's VideoView — LiveKitVideoSurface.kt
+/// for iOS. The port rebinds every live surface whenever a camera may have
+/// appeared, vanished, muted, or the room was replaced (rejoin).
+///
+/// Main thread only, like the port that owns it.
+final class LiveKitVideoSurface: UIView {
+  private weak var port: LiveKitMediaPort?
+  private let videoView = VideoView()
+  private var released = false
+
+  private var participantId: String?
+  private var local = false
+  private var mirror: Bool?
+  private var fit = "cover"
+
+  init(port: LiveKitMediaPort) {
+    self.port = port
+    super.init(frame: .zero)
+    backgroundColor = .clear
+    clipsToBounds = true
+    videoView.frame = bounds
+    videoView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+    videoView.isHidden = true
+    addSubview(videoView)
+  }
+
+  required init?(coder: NSCoder) { fatalError("init(coder:) is not supported") }
+
+  /// [participantId] is the remote's userId (SFU identity); [local] shows
+  /// the self view. [mirror] nil = mirrored for the local front camera only.
+  func configure(participantId: String?, local: Bool, mirror: Bool?, fit: String) {
+    self.participantId = participantId
+    self.local = local
+    self.mirror = mirror
+    self.fit = fit
+    rebind()
+  }
+
+  func rebind() {
+    guard !released else { return }
+    let next = port?.cameraTrack(participantId: participantId, local: local)
+    if (videoView.track as AnyObject?) !== (next as AnyObject?) {
+      videoView.track = next
+    }
+    // No camera: hide so a last frozen frame never shows; the UI draws
+    // the avatar from the snapshot's cameraOn underneath.
+    videoView.isHidden = next == nil
+    let mirrored = mirror ?? (local && port?.cameraFacing() != "back")
+    videoView.mirrorMode = mirrored ? .mirror : .off
+    videoView.layoutMode = fit == "contain" ? .fit : .fill
+  }
+
+  /// Detach from any track. Idempotent.
+  func release() {
+    guard !released else { return }
+    released = true
+    videoView.track = nil
+    port?.unregister(self)
+  }
+}

package/ios/Platform/Ringback.swift

@@ -0,0 +1,61 @@
+import AVFoundation
+import Foundation
+
+/// Outgoing ringback. The incoming ringtone is CallKit's own; the caller's
+/// "ring ring" is a host-bundled tone (configure options.ringback, looked
+/// up in the main bundle as mp3/caf/wav), else silence. Played inside the
+/// CallKit-activated session, so it follows the call route (earpiece).
+final class Ringback {
+  private var player: AVAudioPlayer?
+  private var wanted = false
+  var resourceName: () -> String?
+
+  init(resourceName: @escaping () -> String?) {
+    self.resourceName = resourceName
+  }
+
+  func start() {
+    wanted = true
+    play()
+  }
+
+  func stop() {
+    wanted = false
+    player?.stop()
+    player = nil
+  }
+
+  /// The session just became active: a ringback asked for earlier starts now.
+  func sessionActivated() {
+    if wanted && player?.isPlaying != true { play() }
+  }
+
+  private func play() {
+    guard let url = Ringback.url(for: resourceName()) else { return }
+    do {
+      if player == nil {
+        let p = try AVAudioPlayer(contentsOf: url)
+        p.numberOfLoops = -1
+        p.volume = 0.6
+        p.prepareToPlay()
+        player = p
+      }
+      player?.play()
+    } catch {
+      NSLog("[PoolseCalls] ringback failed: %@", "\(error)")
+    }
+  }
+
+  static func url(for name: String?) -> URL? {
+    guard let name = name, !name.isEmpty else { return nil }
+    let ns = name as NSString
+    if !ns.pathExtension.isEmpty,
+       let u = Bundle.main.url(forResource: ns.deletingPathExtension, withExtension: ns.pathExtension) {
+      return u
+    }
+    for ext in ["mp3", "caf", "wav", "m4a"] {
+      if let u = Bundle.main.url(forResource: name, withExtension: ext) { return u }
+    }
+    return nil
+  }
+}