@poolse/react-native-calls 0.4.3 → 0.4.5

package/ios/Platform/CallCore.swift

@@ -171,6 +171,12 @@ final class CallCore {
     // LiveKit's audio stays off until CallKit activates the session —
     // configured now, at launch, before any activation can happen.
     mediaPort.prepareAudio()
+    // A no-op mute transaction (same state) makes CallKit retry a failed
+    // audio-session activation.
+    mediaPort.requestAudioActivation = { [weak self] in
+      guard let self = self, let callId = self.runtime.currentState().callId else { return }
+      self.callKit.requestMute(callId: callId, muted: self.mutedSelf)
+    }
   }
 
   // MARK: - native entry points

package/ios/Platform/CallKitController.swift

@@ -86,6 +86,25 @@ final class CallKitController: NSObject, CXProviderDelegate {
   /// or the runtime's SHOW_RING after the push path) is re-reported with
   /// the SAME UUID: CallKit rejects it as a duplicate and nothing changes,
   /// which still satisfies PushKit's "report a call for every push".
+  /// Put the shared session in the call's category BEFORE CallKit activates
+  /// it — at ring time, in the answer action, in the start action (Apple's
+  /// CallKit sample does the same). Setting the category does not activate
+  /// anything. Without it the session is still the default
+  /// SoloAmbientSound when CallKit activates it, and with the phone locked
+  /// and the app in the background iOS REFUSES that activation (seen in a
+  /// device log as an activate "early exit due to failure", -16980): no
+  /// didActivate, so no audio at all on a call answered with the app closed.
+  static func prepareSessionForCall(video: Bool) {
+    let s = AVAudioSession.sharedInstance()
+    let mode: AVAudioSession.Mode = video ? .videoChat : .voiceChat
+    guard s.category != .playAndRecord || s.mode != mode else { return }
+    do {
+      try s.setCategory(.playAndRecord, mode: mode, options: [.allowBluetooth, .allowBluetoothA2DP])
+    } catch {
+      NSLog("[PoolseCalls] pre-activation category failed: %@", "\(error)")
+    }
+  }
+
   func reportIncoming(ring: RingContext) {
     let hasVideo = ring.media == "video"
     let title = ring.conversationName ?? ring.callerName
@@ -95,6 +114,7 @@ final class CallKitController: NSObject, CXProviderDelegate {
     }
     let t = Tracked(uuid: UUID(), callId: ring.callId, outgoing: false, hasVideo: hasVideo, title: title)
     calls[t.uuid] = t
+    Self.prepareSessionForCall(video: hasVideo)
     provider.reportNewIncomingCall(with: t.uuid, update: update(title: title, handle: ring.conversationId, video: hasVideo)) { [weak self] error in
       guard let error = error else { return }
       NSLog("[PoolseCalls] CallKit refused incoming call %@: %@", ring.callId, error.localizedDescription)
@@ -224,9 +244,12 @@ final class CallKitController: NSObject, CXProviderDelegate {
   }
 
   func provider(_ provider: CXProvider, perform action: CXAnswerCallAction) {
+    pcTrace("CallKit answer action")
     guard let t = calls[action.callUUID], !t.ended else { action.fail(); return }
     let fromUs = t.answered
     t.answered = true
+    // Before fulfil: CallKit activates the session right after.
+    Self.prepareSessionForCall(video: t.hasVideo)
     if !fromUs {
       guard let actions = actions else { action.fail(); return }
       actions.callKitAnswer(callId: t.callId)
@@ -244,7 +267,8 @@ final class CallKitController: NSObject, CXProviderDelegate {
   }
 
   func provider(_ provider: CXProvider, perform action: CXStartCallAction) {
-    guard calls[action.callUUID] != nil else { action.fail(); return }
+    guard let t = calls[action.callUUID] else { action.fail(); return }
+    Self.prepareSessionForCall(video: t.hasVideo)
     provider.reportOutgoingCall(with: action.callUUID, startedConnectingAt: nil)
     action.fulfill()
   }
@@ -259,10 +283,12 @@ final class CallKitController: NSObject, CXProviderDelegate {
   }
 
   func provider(_ provider: CXProvider, didActivate audioSession: AVAudioSession) {
+    pcTrace("CallKit didActivate \(pcSessionDescription(audioSession))")
     actions?.callKitAudioActivated(audioSession)
   }
 
   func provider(_ provider: CXProvider, didDeactivate audioSession: AVAudioSession) {
+    pcTrace("CallKit didDeactivate")
     actions?.callKitAudioDeactivated(audioSession)
   }
 }

package/ios/Platform/LiveKitMediaPort.swift

@@ -1,4 +1,5 @@
 import AVFoundation
+import os
 import Foundation
 #if canImport(LiveKitClient)
 import LiveKitClient // CocoaPods module name
@@ -26,6 +27,26 @@ protocol MediaEvents: AnyObject {
   func onLocalCamera(on: Bool, facing: String?)
 }
 
+/// Step-by-step trace of the audio path, in the device log as
+/// "[PoolseCalls] trace …" — the order of activation, engine availability,
+/// connect and publish is what cold-answer audio failures hinge on.
+///
+/// os_log with a PUBLIC argument: NSLog's text is redacted to "<private>"
+/// on release builds, which made the first device trace unreadable.
+func pcTrace(_ message: @autoclosure () -> String) {
+  os_log("[PoolseCalls] trace %{public}@", log: pcLog, type: .default, message())
+}
+
+let pcLog = OSLog(subsystem: "dev.poolse.callcore", category: "calls")
+
+func pcSessionDescription(_ s: AVAudioSession = .sharedInstance()) -> String {
+  let outs = s.currentRoute.outputs.map { $0.portType.rawValue }.joined(separator: ",")
+  let ins = s.currentRoute.inputs.map { $0.portType.rawValue }.joined(separator: ",")
+  return "category=\(s.category.rawValue) mode=\(s.mode.rawValue) in=[\(ins)] out=[\(outs)] " +
+    "otherAudio=\(s.isOtherAudioPlaying) inputAvailable=\(s.isInputAvailable) " +
+    "record=\(s.recordPermission.rawValue)"
+}
+
 /// 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.
@@ -57,6 +78,9 @@ final class LiveKitMediaPort: NSObject, MediaPort {
   private var audioActive = false
   /// The room whose audio engine has been kicked (once per room).
   private var audioKicked: ObjectIdentifier?
+  /// Asks CallKit to (re)try activating the audio session — set by
+  /// CallCore. Used when a room is live but activation never arrived.
+  var requestAudioActivation: (() -> Void)?
 
   init(events: MediaEvents) {
     self.events = events
@@ -83,6 +107,7 @@ final class LiveKitMediaPort: NSObject, MediaPort {
   func prepareAudio() {
     guard !audioPrepared else { return }
     audioPrepared = true
+    pcTrace("prepareAudio (automatic config off, engine .none)")
     AudioManager.shared.audioSession.isAutomaticConfigurationEnabled = false
     do { try AudioManager.shared.setEngineAvailability(.none) } catch {
       NSLog("[PoolseCalls] setEngineAvailability(.none) failed: %@", "\(error)")
@@ -91,6 +116,7 @@ final class LiveKitMediaPort: NSObject, MediaPort {
 
   /// CallKit activated the session (or, without CallKit, we did).
   func audioActivated(_ session: AVAudioSession, media: String) {
+    pcTrace("audioActivated media=\(media) room=\(room != nil) connected=\(connectedRoom != nil) \(pcSessionDescription(session))")
     prepareAudio()
     audioActive = true
     if media != self.media && room == nil { self.media = media }
@@ -98,6 +124,29 @@ final class LiveKitMediaPort: NSObject, MediaPort {
     kickAudioIfReady()
   }
 
+  /// Connected with a live mic but CallKit never activated the session
+  /// (iOS refused the activation): nudge CallKit to retry — a transaction
+  /// on the call makes it attempt activation again (in the device log a
+  /// mute toggle did exactly that, and audio came up). Three tries, then
+  /// activate the session ourselves as a last resort.
+  private func ensureAudioActivated(_ r: Room, attempt: Int) {
+    guard room === r, !audioActive else { return }
+    let delays: [Double] = [1.2, 2.5, 4.0]
+    guard attempt <= delays.count else { return }
+    if attempt == delays.count {
+      pcTrace("audio never activated by CallKit; activating ourselves")
+      activateAudioWithoutCallKit(media: media)
+      return
+    }
+    DispatchQueue.main.asyncAfter(deadline: .now() + delays[attempt]) { [weak self] in
+      guard let self = self, self.room === r, !self.audioActive else { return }
+      pcTrace("audio not active \(attempt + 1)x after connect; nudging CallKit")
+      CallKitController.prepareSessionForCall(video: self.media == "video")
+      self.requestAudioActivation?()
+      self.ensureAudioActivated(r, attempt: attempt + 1)
+    }
+  }
+
   /// Once per call, the first moment the session is active AND the mic is
   /// published (in whichever order they happen): make LiveKit's audio
   /// engine rebuild around the live mic.
@@ -115,6 +164,7 @@ final class LiveKitMediaPort: NSObject, MediaPort {
           audioKicked != ObjectIdentifier(r), !mutedWanted else { return }
     guard r.localParticipant.isMicrophoneEnabled() else { return }
     audioKicked = ObjectIdentifier(r)
+    pcTrace("kick: cycling engine availability + mic")
     do {
       try AudioManager.shared.setEngineAvailability(.none)
       try AudioManager.shared.setEngineAvailability(.default)
@@ -134,6 +184,7 @@ final class LiveKitMediaPort: NSObject, MediaPort {
       } catch {
         NSLog("[PoolseCalls] mic cycle failed: %@", "\(error)")
       }
+      pcTrace("kick done enabled=\(r.localParticipant.isMicrophoneEnabled()) \(pcSessionDescription())")
       await MainActor.run { self?.reassertAudio() }
     }
   }
@@ -147,6 +198,7 @@ final class LiveKitMediaPort: NSObject, MediaPort {
   /// no-CallKit fallback) holds the session active.
   func reassertAudio(_ session: AVAudioSession = .sharedInstance()) {
     guard audioActive else { return }
+    pcTrace("reassertAudio before: \(pcSessionDescription(session))")
     let mode: AVAudioSession.Mode = media == "video" && speakerWanted != false ? .videoChat : .voiceChat
     if session.category != .playAndRecord || session.mode != mode {
       do {
@@ -163,6 +215,7 @@ final class LiveKitMediaPort: NSObject, MediaPort {
   }
 
   func audioDeactivated() {
+    pcTrace("audioDeactivated")
     audioActive = false
     guard audioPrepared else { return }
     do { try AudioManager.shared.setEngineAvailability(.none) } catch {
@@ -181,6 +234,7 @@ final class LiveKitMediaPort: NSObject, MediaPort {
   // MARK: - MediaPort
 
   func join(bundle: CallSessionBundle) {
+    pcTrace("join call=\(bundle.callId) media=\(bundle.media) audioActive=\(audioActive)")
     prepareAudio()
     if let joined = joinedCallId, joined != bundle.callId { resetWanted() }
     joinedCallId = bundle.callId
@@ -224,15 +278,19 @@ final class LiveKitMediaPort: NSObject, MediaPort {
         return
       }
       let muted = await MainActor.run { self.mutedWanted }
+      let activeNow = await MainActor.run { self.audioActive }
+      pcTrace("connected; publishing mic muted=\(muted) audioActive=\(activeNow)")
       do { try await r.localParticipant.setMicrophone(enabled: !muted) } catch {
         NSLog("[PoolseCalls] microphone publish failed: %@", "\(error)")
       }
       // Connected and publishing: make sure nothing changed the session
+      pcTrace("mic published enabled=\(r.localParticipant.isMicrophoneEnabled()) \(pcSessionDescription())")
       // while we connected (a cold answer boots JS in exactly this window),
       // then make sure the engine is actually carrying the mic.
       await MainActor.run {
         self.reassertAudio()
         self.kickAudioIfReady()
+        self.ensureAudioActivated(r, attempt: 0)
       }
       let camera = await MainActor.run { self.cameraWanted ?? wantsVideo }
       if camera { await self.enableCamera(r, true) }
@@ -375,18 +433,21 @@ final class LiveKitMediaPort: NSObject, MediaPort {
   /// An interruption (another app's audio, Siri) ended: the session may
   /// have been reconfigured; restore the call's.
   @objc private func interrupted(_ note: Notification) {
+    pcTrace("interruption \(note.userInfo ?? [:])")
     guard let raw = note.userInfo?[AVAudioSessionInterruptionTypeKey] as? UInt,
           AVAudioSession.InterruptionType(rawValue: raw) == .ended else { return }
     DispatchQueue.main.async { [weak self] in self?.reassertAudio() }
   }
 
   @objc private func mediaServicesReset(_ note: Notification) {
+    pcTrace("mediaServicesWereReset")
     DispatchQueue.main.async { [weak self] in self?.reassertAudio() }
   }
 
   @objc private func routeChanged(_ note: Notification) {
     let reason = (note.userInfo?[AVAudioSessionRouteChangeReasonKey] as? UInt)
       .flatMap(AVAudioSession.RouteChangeReason.init(rawValue:))
+    pcTrace("routeChange reason=\(reason.map { String($0.rawValue) } ?? "?") \(pcSessionDescription())")
     DispatchQueue.main.async { [weak self] in
       guard let self = self, self.audioActive else { return }
       // Something reconfigured the shared session mid-call: put it back.

package/ios/Platform/VoipPush.swift

@@ -1,6 +1,7 @@
 import CallKit
 import Foundation
 import PushKit
+import UIKit
 
 /// Native PushKit intake — the iOS twin of CallMessagingService. The
 /// registry is created at launch (PoolseCallsAppDelegateSubscriber →
@@ -59,6 +60,7 @@ final class VoipPush: NSObject, PKPushRegistryDelegate {
 
   func pushRegistry(_ registry: PKPushRegistry, didReceiveIncomingPushWith payload: PKPushPayload,
                     for type: PKPushType, completion: @escaping () -> Void) {
+    pcTrace("VoIP push received appState=\(UIApplication.shared.applicationState.rawValue)")
     if type == .voIP { handle(payload.dictionaryPayload) }
     completion()
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poolse/react-native-calls",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "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",