@poolse/react-native-calls 0.4.2 → 0.4.4

package/ios/Platform/CallKitController.swift

@@ -224,6 +224,7 @@ 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
@@ -259,10 +260,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

@@ -26,6 +26,21 @@ 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.
+func pcTrace(_ message: @autoclosure () -> String) {
+  NSLog("[PoolseCalls] trace %@", message())
+}
+
+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.
@@ -55,6 +70,8 @@ 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?
 
   init(events: MediaEvents) {
     self.events = events
@@ -81,6 +98,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)")
@@ -89,10 +107,54 @@ 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 }
     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)")
+    }
+    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() }
+    }
   }
 
   /// Put the call's audio back the way the call needs it: play-and-record
@@ -104,6 +166,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 {
@@ -120,6 +183,7 @@ final class LiveKitMediaPort: NSObject, MediaPort {
   }
 
   func audioDeactivated() {
+    pcTrace("audioDeactivated")
     audioActive = false
     guard audioPrepared else { return }
     do { try AudioManager.shared.setEngineAvailability(.none) } catch {
@@ -138,6 +202,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
@@ -181,12 +246,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
-      // while we connected (a cold answer boots JS in exactly this window).
-      await MainActor.run { self.reassertAudio() }
+      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()
+      }
       let camera = await MainActor.run { self.cameraWanted ?? wantsVideo }
       if camera { await self.enableCamera(r, true) }
       await MainActor.run {
@@ -328,18 +400,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.2",
+  "version": "0.4.4",
   "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",