@poolse/react-native-calls 0.4.4 → 0.4.6

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)
@@ -228,6 +248,8 @@ final class CallKitController: NSObject, CXProviderDelegate {
     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)
@@ -245,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()
   }

package/ios/Platform/LiveKitMediaPort.swift

@@ -1,4 +1,5 @@
 import AVFoundation
+import os
 import Foundation
 #if canImport(LiveKitClient)
 import LiveKitClient // CocoaPods module name
@@ -29,10 +30,15 @@ protocol MediaEvents: AnyObject {
 /// 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) {
-  NSLog("[PoolseCalls] trace %@", message())
+  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: ",")
@@ -70,8 +76,9 @@ final class LiveKitMediaPort: NSObject, MediaPort {
   private let surfaces = NSHashTable<LiveKitVideoSurface>.weakObjects()
   private var audioPrepared = false
   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
@@ -112,48 +119,28 @@ final class LiveKitMediaPort: NSObject, MediaPort {
     audioActive = true
     if media != self.media && room == nil { self.media = media }
     reassertAudio(session)
-    kickAudioIfReady()
   }
 
-  /// 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.
-  ///
-  /// On a call answered with the app closed, the process is brand new and
-  /// LiveKit's engine never started for a mic published right after
-  /// CallKit made audio available — no capture, no playback, though the
-  /// session was correct (video, which needs no audio engine, worked). A
-  /// user-side mute → unmute cured it, because toggling the mic makes the
-  /// engine re-evaluate and start. This does the same, automatically: an
-  /// availability cycle first, then a mic off/on. A deliberate mute is
-  /// left alone. The remote hears at most a sub-second blip at connect.
-  private func kickAudioIfReady() {
-    guard audioActive, let r = room, connectedRoom == ObjectIdentifier(r),
-          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)
-    } catch {
-      NSLog("[PoolseCalls] engine availability cycle failed: %@", "\(error)")
+  /// 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
     }
-    Task { [weak self] in
-      try? await Task.sleep(nanoseconds: 250_000_000)
-      let still = await MainActor.run { () -> Bool in
-        guard let self = self else { return false }
-        return self.room === r && self.audioActive && !self.mutedWanted
-      }
-      guard still else { return }
-      do {
-        try await r.localParticipant.setMicrophone(enabled: false)
-        try await r.localParticipant.setMicrophone(enabled: true)
-      } catch {
-        NSLog("[PoolseCalls] mic cycle failed: %@", "\(error)")
-      }
-      pcTrace("kick done enabled=\(r.localParticipant.isMicrophoneEnabled()) \(pcSessionDescription())")
-      await MainActor.run { self?.reassertAudio() }
+    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)
     }
   }
 
@@ -257,7 +244,7 @@ final class LiveKitMediaPort: NSObject, MediaPort {
       // 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) }

package/package.json

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