@poolse/react-native-calls 0.4.1 → 0.4.3

package/ios/Platform/CallCore.swift

@@ -168,6 +168,9 @@ final class CallCore {
     eventsAdapter.core = self
     surfaceAdapter.core = self
     callKit.actions = self
+    // LiveKit's audio stays off until CallKit activates the session —
+    // configured now, at launch, before any activation can happen.
+    mediaPort.prepareAudio()
   }
 
   // MARK: - native entry points

package/ios/Platform/LiveKitMediaPort.swift

@@ -55,19 +55,32 @@ 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
     super.init()
     NotificationCenter.default.addObserver(self, selector: #selector(routeChanged),
                                            name: AVAudioSession.routeChangeNotification, object: nil)
+    NotificationCenter.default.addObserver(self, selector: #selector(interrupted),
+                                           name: AVAudioSession.interruptionNotification, object: nil)
+    NotificationCenter.default.addObserver(self, selector: #selector(mediaServicesReset),
+                                           name: AVAudioSession.mediaServicesWereResetNotification,
+                                           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() {
+  ///
+  /// Called at app LAUNCH (CallCore.init, from the app-delegate
+  /// subscriber), as LiveKit's CallKit integration requires — before any
+  /// audio session can be activated. Doing it inside didActivate meant a
+  /// call answered with the app closed created and reconfigured LiveKit's
+  /// audio manager mid-activation, and came up with no audio.
+  func prepareAudio() {
     guard !audioPrepared else { return }
     audioPrepared = true
     AudioManager.shared.audioSession.isAutomaticConfigurationEnabled = false
@@ -80,17 +93,72 @@ final class LiveKitMediaPort: NSObject, MediaPort {
   func audioActivated(_ session: AVAudioSession, media: String) {
     prepareAudio()
     audioActive = true
-    let video = media == "video"
+    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)
     do {
-      try session.setCategory(.playAndRecord, mode: video && speakerWanted != false ? .videoChat : .voiceChat,
-                              options: [.allowBluetooth, .allowBluetoothA2DP])
+      try AudioManager.shared.setEngineAvailability(.none)
+      try AudioManager.shared.setEngineAvailability(.default)
     } catch {
-      NSLog("[PoolseCalls] audio session category failed: %@", "\(error)")
+      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)")
+      }
+      await MainActor.run { self?.reassertAudio() }
+    }
+  }
+
+  /// Put the call's audio back the way the call needs it: play-and-record
+  /// in the voice/video chat mode, LiveKit's engine available, the chosen
+  /// route. Idempotent — only touches what differs — so it is safe to run
+  /// whenever anything may have changed the session behind the call's
+  /// back (another audio library reconfiguring it as JS boots mid-call,
+  /// an interruption, a media-services reset). Only while CallKit (or the
+  /// no-CallKit fallback) holds the session active.
+  func reassertAudio(_ session: AVAudioSession = .sharedInstance()) {
+    guard audioActive else { return }
+    let mode: AVAudioSession.Mode = media == "video" && speakerWanted != false ? .videoChat : .voiceChat
+    if session.category != .playAndRecord || session.mode != mode {
+      do {
+        try session.setCategory(.playAndRecord, mode: mode,
+                                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()
   }
 
@@ -159,6 +227,13 @@ final class LiveKitMediaPort: NSObject, MediaPort {
       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),
+      // 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 {
@@ -297,9 +372,28 @@ final class LiveKitMediaPort: NSObject, MediaPort {
     events?.onAudioRoute(currentRoute())
   }
 
+  /// An interruption (another app's audio, Siri) ended: the session may
+  /// have been reconfigured; restore the call's.
+  @objc private func interrupted(_ note: Notification) {
+    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) {
+    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:))
     DispatchQueue.main.async { [weak self] in
       guard let self = self, self.audioActive else { return }
+      // Something reconfigured the shared session mid-call: put it back.
+      if reason == .categoryChange {
+        self.reassertAudio()
+        return
+      }
       // A user's speaker choice survives route changes, except that a
       // newly connected headset/Bluetooth device always wins.
       let route = self.currentRoute()

package/package.json

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