@poolse/react-native-calls 0.4.0 → 0.4.2

package/ios/Module/PoolseCallsModule.swift

@@ -17,18 +17,25 @@ public class PoolseCallsModule: Module {
       PoolseCallsSetup.registerVoipEarly()
     }
 
+    // The listeners are process-level statics read on main: assign and
+    // clear them on main too (these closures run on the module's queue).
     OnStartObserving {
-      CallCore.listener = { [weak self] snapshot in
-        self?.sendEvent("onCallState", ["snapshot": snapshot ?? NSNull()])
-      }
-      VoipPush.tokenListener = { [weak self] token in
-        self?.sendEvent("onVoipToken", ["token": token, "environment": PoolseCallsModule.environment()])
+      DispatchQueue.main.async { [weak self] in
+        guard self != nil else { return }
+        CallCore.listener = { [weak self] snapshot in
+          self?.sendEvent("onCallState", ["snapshot": snapshot ?? NSNull()])
+        }
+        VoipPush.tokenListener = { [weak self] token in
+          self?.sendEvent("onVoipToken", ["token": token, "environment": PoolseCallsModule.environment()])
+        }
       }
     }
 
     OnStopObserving {
-      CallCore.listener = nil
-      VoipPush.tokenListener = nil
+      DispatchQueue.main.async {
+        CallCore.listener = nil
+        VoipPush.tokenListener = nil
+      }
     }
 
     AsyncFunction("configure") { (apiBaseUrl: String, options: [String: Any]?) in

package/ios/Platform/CallCore.swift

@@ -45,6 +45,7 @@ final class CallCore {
     defaults.set(trimmed, forKey: "apiBaseUrl")
     defaults.set(ringback, forKey: "ringback")
     defaults.set(apnsEnvironment, forKey: "apnsEnvironment")
+    writeConfigFile(apiBaseUrl: trimmed, ringback: ringback, apnsEnvironment: apnsEnvironment)
     configLock.lock()
     _config = CallCoreConfig(apiBaseUrl: trimmed, ringback: ringback, apnsEnvironment: apnsEnvironment)
     configLock.unlock()
@@ -52,18 +53,65 @@ final class CallCore {
 
   /// The APNs environment last configured (persisted), if any.
   static var apnsEnvironment: String? {
-    config?.apnsEnvironment ?? defaults.string(forKey: "apnsEnvironment")
+    config?.apnsEnvironment ?? defaults.string(forKey: "apnsEnvironment") ?? readConfigFile()?.apnsEnvironment
   }
 
   private static func restoreConfig() {
-    guard config == nil, let url = defaults.string(forKey: "apiBaseUrl") else { return }
+    guard config == nil else { return }
+    let restored: CallCoreConfig
+    if let url = defaults.string(forKey: "apiBaseUrl") {
+      restored = CallCoreConfig(apiBaseUrl: url,
+                                ringback: defaults.string(forKey: "ringback"),
+                                apnsEnvironment: defaults.string(forKey: "apnsEnvironment"))
+    } else if let fromFile = readConfigFile() {
+      // Locked since reboot: UserDefaults is unreadable before first
+      // unlock, the unprotected file is not.
+      restored = fromFile
+    } else {
+      return
+    }
     configLock.lock()
-    _config = CallCoreConfig(apiBaseUrl: url,
-                             ringback: defaults.string(forKey: "ringback"),
-                             apnsEnvironment: defaults.string(forKey: "apnsEnvironment"))
+    _config = restored
     configLock.unlock()
   }
 
+  // MARK: config file (readable before first unlock)
+
+  /// Application Support/dev.poolse.callcore/config.json, written with
+  /// FileProtectionType.none so a PushKit wake while the device has been
+  /// locked since reboot can still rebuild the core. Holds no secrets —
+  /// only the API origin, a sound name and the APNs environment.
+  private static var configFileURL: URL? {
+    guard let base = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask).first else { return nil }
+    return base.appendingPathComponent("dev.poolse.callcore", isDirectory: true).appendingPathComponent("config.json")
+  }
+
+  private static func writeConfigFile(apiBaseUrl: String, ringback: String?, apnsEnvironment: String?) {
+    guard let url = configFileURL else { return }
+    var obj: [String: Any] = ["apiBaseUrl": apiBaseUrl]
+    if let ringback = ringback { obj["ringback"] = ringback }
+    if let apnsEnvironment = apnsEnvironment { obj["apnsEnvironment"] = apnsEnvironment }
+    do {
+      let fm = FileManager.default
+      let dir = url.deletingLastPathComponent()
+      try fm.createDirectory(at: dir, withIntermediateDirectories: true,
+                             attributes: [.protectionKey: FileProtectionType.none])
+      let data = try JSONSerialization.data(withJSONObject: obj)
+      try data.write(to: url, options: [.atomic, .noFileProtection])
+      try? fm.setAttributes([.protectionKey: FileProtectionType.none], ofItemAtPath: url.path)
+    } catch {
+      NSLog("[PoolseCalls] config file write failed: %@", "\(error)")
+    }
+  }
+
+  private static func readConfigFile() -> CallCoreConfig? {
+    guard let url = configFileURL, let data = try? Data(contentsOf: url),
+          let obj = (try? JSONSerialization.jsonObject(with: data)) as? [String: Any],
+          let api = obj["apiBaseUrl"] as? String, !api.isEmpty else { return nil }
+    return CallCoreConfig(apiBaseUrl: api, ringback: obj["ringback"] as? String,
+                          apnsEnvironment: obj["apnsEnvironment"] as? String)
+  }
+
   /// The core, or nil if this install was never configured. Main thread.
   static func getOrNull() -> CallCore? {
     if let i = instance { return i }
@@ -120,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/CallKitController.swift

@@ -89,7 +89,7 @@ final class CallKitController: NSObject, CXProviderDelegate {
   func reportIncoming(ring: RingContext) {
     let hasVideo = ring.media == "video"
     let title = ring.conversationName ?? ring.callerName
-    if let existing = calls.values.first(where: { $0.callId == ring.callId }) {
+    if let existing = calls.values.first(where: { $0.callId == ring.callId && !$0.ended }) {
       provider.reportNewIncomingCall(with: existing.uuid, update: update(title: title, handle: ring.conversationId, video: hasVideo)) { _ in }
       return
     }
@@ -99,8 +99,13 @@ final class CallKitController: NSObject, CXProviderDelegate {
       guard let error = error else { return }
       NSLog("[PoolseCalls] CallKit refused incoming call %@: %@", ring.callId, error.localizedDescription)
       // Refused (DND, blocked, busy group): CallKit holds nothing for it.
-      t.ended = true
-      self?.calls.removeValue(forKey: t.uuid)
+      // End the ring in the core too — silently (no decline is sent), so
+      // the engine is not left RINGING_IN with no UI, counting as busy.
+      DispatchQueue.main.async {
+        t.ended = true
+        self?.calls.removeValue(forKey: t.uuid)
+        CallCore.peek()?.onRingEnded(callId: ring.callId, reason: "cancelled")
+      }
     }
   }
 

package/ios/Platform/LiveKitMediaPort.swift

@@ -61,13 +61,24 @@ final class LiveKitMediaPort: NSObject, MediaPort {
     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 +91,31 @@ final class LiveKitMediaPort: NSObject, MediaPort {
   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)")
+    if media != self.media && room == nil { self.media = media }
+    reassertAudio(session)
+  }
+
+  /// 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 +184,9 @@ 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).
+      await MainActor.run { self.reassertAudio() }
       let camera = await MainActor.run { self.cameraWanted ?? wantsVideo }
       if camera { await self.enableCamera(r, true) }
       await MainActor.run {
@@ -297,9 +325,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.0",
+  "version": "0.4.2",
   "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",