expo-beacon 0.8.4 → 0.8.5

package/ios/CarPlayMonitor.swift

@@ -36,13 +36,14 @@ final class CarPlayMonitor {
     /// Optional persistence target for last-known connection state. Injected via
     /// `start(emit:defaults:)`. When set, every connect/disconnect emission is
     /// mirrored to `CARPLAY_LAST_CONNECTED_KEY` so a freshly relaunched process
-    /// can detect a missed disconnect via `reconcileOnProcessStart(emit:)`.
+    /// can detect a missed disconnect via `reconcileOnProcessStart()`.
     private var defaults: UserDefaults?
     /// When `true`, an authoritative source (CarPlay scene delegate, granted via the
     /// `com.apple.developer.carplay-driving-task` entitlement) is providing
     /// connect/disconnect events. The audio-session observer becomes a passive
     /// secondary signal only — it will not emit events, to avoid duplicate
-    /// connect/disconnect notifications.
+    /// connect/disconnect notifications. Reset to `false` on entitled disconnect
+    /// so the audio-session fallback can take over for any subsequent events.
     private var isEntitledMode: Bool = false
 
     private init() {}
@@ -55,7 +56,7 @@ final class CarPlayMonitor {
     /// - Parameter defaults: Optional `UserDefaults` suite used to persist the
     ///   last-known connection state for cross-process reconciliation. When the
     ///   module is recreated in a new process (e.g. after a background-wake)
-    ///   the persisted value is used by `reconcileOnProcessStart(emit:)` to
+    ///   the persisted value is used by `reconcileOnProcessStart()` to
     ///   synthesize a missed disconnect. Pass `nil` to disable persistence.
     func start(emit: @escaping Emit, defaults: UserDefaults? = nil) {
         queue.async { [weak self] in
@@ -128,7 +129,14 @@ final class CarPlayMonitor {
             self.isEntitledMode = true
             os_log("CarPlay scene connected (entitled source)", log: self.log, type: .info)
             if !self.isConnected {
-                self.isConnected = trueclears the entitled-mode flag so the
+                self.isConnected = true
+                self.emitConnected(transport: transport)
+            }
+        }
+    }
+
+    /// Called by `BeaconCarPlaySceneDelegate.templateApplicationScene(_:didDisconnect:)`.
+    /// Emits `onCarPlayDisconnected` and clears the entitled-mode flag so the
     /// audio-session fallback path becomes authoritative again until the next
     /// entitled connect. Without this reset, a single missed scene-delegate
     /// disconnect (force-quit, OS reclaim, abrupt cable yank between connect
@@ -139,13 +147,6 @@ final class CarPlayMonitor {
             guard let self = self else { return }
             os_log("CarPlay scene disconnected (entitled source)", log: self.log, type: .info)
             self.isEntitledMode = false
-    /// Emits `onCarPlayDisconnected` and keeps the entitled-mode flag set so
-    /// subsequent audio-session events remain suppressed (the scene delegate is
-    /// the source of truth for the lifetime of the process).
-    func notifyEntitledDisconnect() {
-        queue.async { [weak self] in
-            guard let self = self else { return }
-            os_log("CarPlay scene disconnected (entitled source)", log: self.log, type: .info)
             if self.isConnected {
                 self.isConnected = false
                 self.emitDisconnected()
@@ -173,6 +174,17 @@ final class CarPlayMonitor {
     /// is always trusted.
     private func handleRouteChange(notification: Notification?) {
         if let userInfo = notification?.userInfo,
+           let reasonRaw = userInfo[AVAudioSessionRouteChangeReasonKey] as? UInt,
+           let reason = AVAudioSession.RouteChangeReason(rawValue: reasonRaw) {
+            switch reason {
+            case .newDeviceAvailable, .oldDeviceUnavailable:
+                break // real device change — proceed
+            default:
+                // Category/override/configuration changes etc. don't represent
+                // a CarPlay connect/disconnect. Skip to avoid spurious events.
+                return
+            }
+        }
         let (connected, transport) = Self.currentCarPlayState()
         // When an entitled CarPlay scene source is active it is authoritative.
         // The audio-session signal is kept as a redundant secondary check but
@@ -203,24 +215,15 @@ final class CarPlayMonitor {
     /// route is no longer CarPlay. Use case: the previous process was killed or
     /// suspended-then-OS-reclaimed while CarPlay was connected, and the disconnect
     /// fired off-process. JS listeners attached to the freshly recreated module
-    /// persistConnectionState(true)
-        emit?("onCarPlayConnected", payload)
-    }
-
-    /// Emit a disconnect event. When `reason` is non-nil it is included in the
-    /// payload so consumers can distinguish real-time disconnects from
-    /// post-hoc reconciled ones (currently `"reconciled"` from
-    /// `reconcileOnProcessStart`). Additive, non-breaking.
-    private func emitDisconnected(reason: String? = nil) {
-        let now = Date()
-        var payload: [String: Any] = [
-            "timestamp": now.timeIntervalSince1970 * 1000.0,
-            "timestampIso": Self.isoFormatter.string(from: now),
-        ]
-        if let reason = reason {
-            payload["reason"] = reason
-        }
-        persistConnectionState(false)   let persistedConnected = defaults.bool(forKey: CARPLAY_LAST_CONNECTED_KEY)
+    /// would otherwise never learn the session ended.
+    ///
+    /// Must be called AFTER `start(emit:defaults:)` so the emit callback is
+    /// installed and persistence target is known. Idempotent.
+    func reconcileOnProcessStart() {
+        queue.async { [weak self] in
+            guard let self = self else { return }
+            guard let defaults = self.defaults else { return }
+            let persistedConnected = defaults.bool(forKey: CARPLAY_LAST_CONNECTED_KEY)
             let (currentConnected, _) = Self.currentCarPlayState()
             if persistedConnected && !currentConnected {
                 os_log("CarPlay reconcile: persisted=connected, current=disconnected — emitting synthetic disconnect", log: self.log, type: .info)
@@ -233,18 +236,7 @@ final class CarPlayMonitor {
     /// Write the current connection state to the injected `UserDefaults` suite
     /// (when available). No-op when persistence wasn't configured.
     private func persistConnectionState(_ connected: Bool) {
-        defaults?.set(connected, forKey: CARPLAY_LAST_CONNECTED_KEY)/ must NOT emit events — the scene delegate already did, or will.
-        if isEntitledMode {
-            return
-        }
-        let (connected, transport) = Self.currentCarPlayState()
-        if connected == isConnected { return }
-        isConnected = connected
-        if connected {
-            emitConnected(transport: transport)
-        } else {
-            emitDisconnected()
-        }
+        defaults?.set(connected, forKey: CARPLAY_LAST_CONNECTED_KEY)
     }
 
     private func emitConnected(transport: String) {
@@ -254,15 +246,24 @@ final class CarPlayMonitor {
             "timestamp": now.timeIntervalSince1970 * 1000.0,
             "timestampIso": Self.isoFormatter.string(from: now),
         ]
+        persistConnectionState(true)
         emit?("onCarPlayConnected", payload)
     }
 
-    private func emitDisconnected() {
+    /// Emit a disconnect event. When `reason` is non-nil it is included in the
+    /// payload so consumers can distinguish real-time disconnects from
+    /// post-hoc reconciled ones (currently `"reconciled"` from
+    /// `reconcileOnProcessStart`). Additive, non-breaking.
+    private func emitDisconnected(reason: String? = nil) {
         let now = Date()
-        let payload: [String: Any] = [
+        var payload: [String: Any] = [
             "timestamp": now.timeIntervalSince1970 * 1000.0,
             "timestampIso": Self.isoFormatter.string(from: now),
         ]
+        if let reason = reason {
+            payload["reason"] = reason
+        }
+        persistConnectionState(false)
         emit?("onCarPlayDisconnected", payload)
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-beacon",
-  "version": "0.8.4",
+  "version": "0.8.5",
   "description": "Expo module for scanning, pairing, and monitoring iBeacons on Android and iOS",
   "main": "build/index.js",
   "types": "build/index.d.ts",