expo-beacon 0.8.0 → 0.8.1

package/README.md

@@ -729,11 +729,20 @@ disconnectSub.remove();
 - Connect/disconnect events flow through the same SQLite event log and remote API forwarder as beacon events.
 - When the config plugin is installed, the auto-generated `BeaconGeoPlugin` also calls `BackgroundGeolocation.start()` on connect and `.stop()` on disconnect — no extra wiring required.
 
+**Background detection**
+
+CarPlay observation is **persistent** — the enabled flag is stored in native preferences and the observer is automatically re-attached after app kill or device reboot. `startMonitoring()` also enables CarPlay observation by default; calling `startCarPlayMonitoring()` explicitly is only required if you want CarPlay events without beacon monitoring.
+
+- **Android:** the foreground service hosts the `CarConnection` observer. As long as the service runs (which it does whenever beacon monitoring or CarPlay monitoring is enabled, and is restarted on boot by `BootReceiver`), CarPlay events are captured even after the app process is killed. **Guaranteed background detection.**
+- **iOS:** the observer auto-restarts in the module's `OnCreate`, including background-launches triggered by beacon region monitoring. **iOS cannot wake a terminated app on CarPlay alone** — for guaranteed wake-from-suspension, also call `startMonitoring()` with at least one paired beacon (e.g. a beacon left in the vehicle). Region-wake events trigger a CarPlay state resync to reconcile any route changes that happened while the app was suspended.
+
 **Notes**
 
 - `startCarPlayMonitoring()` is idempotent. Calling it twice does not register a duplicate observer.
+- `stopCarPlayMonitoring()` clears the persisted flag, so the observer will not auto-restart on next launch.
 - The iOS detector does not require the CarPlay entitlement because it only reads the active audio route; you do not need to ship a CarPlay app.
 - On iOS, if the JS bundle is suspended in the background, the JS event delivery is deferred until the app resumes, but the native lifecycle delegate (used by the geolocation plugin) fires immediately on connect.
+- On Android, when CarPlay monitoring is enabled without beacon monitoring, the foreground service shows a generic "Connected device monitoring active" notification.
 
 ---
 

package/android/src/main/java/expo/modules/beacon/BeaconForegroundService.kt

@@ -84,6 +84,12 @@ class BeaconForegroundService : Service(), BeaconConsumer {
     // Seconds of silence after last valid sighting before a disappearance-based exit fires.
     @Volatile private var exitTimeoutMs: Long = (DEFAULT_EXIT_TIMEOUT_SECONDS * 1000.0).toLong()
 
+    // CarPlay / Android Auto observer hosted by the foreground service so that
+    // CarConnection events are captured for as long as the service runs —
+    // independent of the JS bridge / module lifecycle. Survives app suspension
+    // and (via BootReceiver) device reboot.
+    @Volatile private var carPlayMonitor: CarPlayMonitor? = null
+
     override fun onCreate() {
         super.onCreate()
         activeService = this
@@ -106,6 +112,14 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         // process and inherits the elevated priority. Calling enable/disable on the
         // shared singleton causes crashes when the ExpoBeaconModule has an active
         // scan bound to the same BeaconManager.
+
+        // Restore CarPlay observer if the user previously enabled CarPlay
+        // monitoring. Reading the flag here means cold-started services
+        // (e.g. via BootReceiver after reboot) automatically re-attach the
+        // observer with no JS interaction required.
+        if (isCarPlayEnabled(this)) {
+            startCarPlayObserverInternal()
+        }
     }
 
     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
@@ -134,11 +148,32 @@ class BeaconForegroundService : Service(), BeaconConsumer {
             stopSelf()
             return START_NOT_STICKY
         }
+        // Handle CarPlay enable/disable actions. These can arrive after the
+        // service is already running for beacon monitoring, OR be the reason
+        // the service was started in the first place (CarPlay-only mode).
+        when (intent?.action) {
+            ACTION_ENABLE_CARPLAY -> {
+                setCarPlayEnabled(this, true)
+                startCarPlayObserverInternal()
+            }
+            ACTION_DISABLE_CARPLAY -> {
+                setCarPlayEnabled(this, false)
+                stopCarPlayObserverInternal()
+                // If the service is only alive for CarPlay (no beacon monitoring),
+                // shut it down so we don't keep an unnecessary foreground notification.
+                if (!isMonitoringActive(this)) {
+                    stopSelf()
+                    return START_NOT_STICKY
+                }
+            }
+        }
         if (serviceConnected) {
             // Already bound from a prior onStartCommand — reload regions directly
             // so that re-starting monitoring from JS always takes effect.
             loadAndMonitorRegions()
-        } else {
+        } else if (isMonitoringActive(this)) {
+            // Only bind to AltBeacon when beacon monitoring is active.
+            // CarPlay-only mode keeps the service alive without scanning.
             beaconManager.bind(this)
         }
         return START_STICKY
@@ -765,6 +800,64 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         }
     }
 
+    // MARK: - CarPlay observer (service-hosted)
+
+    /**
+     * Lazily instantiate and start the CarPlay observer. Idempotent —
+     * `CarPlayMonitor.start` itself is safe to call multiple times.
+     * Must be called from any thread; the monitor hops to main internally.
+     */
+    private fun startCarPlayObserverInternal() {
+        val monitor = carPlayMonitor ?: try {
+            CarPlayMonitor(applicationContext).also { carPlayMonitor = it }
+        } catch (e: Throwable) {
+            Log.w(TAG, "Failed to create CarPlayMonitor", e)
+            return
+        }
+        try {
+            monitor.start { eventName, payload ->
+                emitCarPlayEvent(eventName, payload)
+            }
+        } catch (e: Throwable) {
+            Log.w(TAG, "Failed to start CarPlayMonitor", e)
+        }
+    }
+
+    private fun stopCarPlayObserverInternal() {
+        carPlayMonitor?.stop()
+        // Keep the instance — it's idempotent, and recreating costs nothing
+        // beyond the `CarConnection` LiveData wrapper. Setting null here is
+        // also safe but unnecessary.
+    }
+
+    /**
+     * Fan out a CarPlay event to all sinks: SQLite log, remote API forwarder,
+     * native plugin registry, and (best-effort) the live JS bridge. Runs from
+     * the main thread (CarPlayMonitor's emit hop).
+     */
+    private fun emitCarPlayEvent(eventName: String, payload: Map<String, Any?>) {
+        // SQLite log (only if event logging is enabled).
+        try {
+            if (BeaconEventLogger.isLoggingEnabled(this)) {
+                val identifier = payload["identifier"] as? String
+                getOrCreateEventLogger().logEvent(eventName, identifier, payload)
+            }
+        } catch (e: Throwable) {
+            Log.w(TAG, "CarPlay log write failed", e)
+        }
+        // Remote API forwarder (no-op if unconfigured).
+        try { apiForwarder?.forwardEvent(payload) } catch (_: Throwable) {}
+        // Native plugin registry (BeaconGeoPlugin etc.).
+        when (eventName) {
+            "onCarPlayConnected" -> BeaconPluginRegistry.dispatchCarPlayConnected(
+                payload["transport"] as? String ?: "unknown"
+            )
+            "onCarPlayDisconnected" -> BeaconPluginRegistry.dispatchCarPlayDisconnected()
+        }
+        // Best-effort delivery to the live JS bridge if a module instance is bound.
+        try { boundModule?.get()?.forwardCarPlayEventFromService(eventName, payload) } catch (_: Throwable) {}
+    }
+
     private fun createNotificationChannel() {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
             val config = readNotificationConfig()
@@ -814,13 +907,20 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         const val DISTANCE_JUMP_FACTOR = 5.0
 
         private const val PREF_IS_MONITORING = "expo.beacon.is_monitoring"
+        private const val PREF_CARPLAY_ENABLED = "expo.beacon.carplay_enabled"
         private const val EXTRA_RETRY_COUNT = "retryCount"
+        /** Intent action: enable CarPlay/Android Auto observation in the foreground service. */
+        const val ACTION_ENABLE_CARPLAY = "expo.modules.beacon.ENABLE_CARPLAY"
+        /** Intent action: disable CarPlay/Android Auto observation. Stops the service if no other reason to run. */
+        const val ACTION_DISABLE_CARPLAY = "expo.modules.beacon.DISABLE_CARPLAY"
         private const val MAX_STARTFOREGROUND_RETRIES = 3
         private const val RETRY_DELAY_MS = 10_000L
         private const val RETRY_SERVICE_REQUEST_CODE = 0x42454143 // "BEAC"
         /** Minimum milliseconds between consecutive loadAndMonitorRegions() calls. */
         private const val LOAD_REGIONS_DEBOUNCE_MS = 500L
         @Volatile private var activeService: BeaconForegroundService? = null
+        /** Weak reference to the live ExpoBeaconModule for best-effort JS bridge fan-out. */
+        @Volatile private var boundModule: java.lang.ref.WeakReference<ExpoBeaconModule>? = null
 
         fun start(context: Context) {
             context.getSharedPreferences(PREF_IS_MONITORING, Context.MODE_PRIVATE)
@@ -837,6 +937,12 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         fun stop(context: Context) {
             context.getSharedPreferences(PREF_IS_MONITORING, Context.MODE_PRIVATE)
                 .edit().putBoolean("active", false).apply()
+            // Keep the service alive if it's still needed for CarPlay observation;
+            // otherwise the user would silently lose CarPlay events when calling
+            // stopMonitoring() while CarPlay monitoring was independently enabled.
+            if (isCarPlayEnabled(context)) {
+                return
+            }
             context.stopService(Intent(context, BeaconForegroundService::class.java))
         }
 
@@ -845,6 +951,70 @@ class BeaconForegroundService : Service(), BeaconConsumer {
                 .getBoolean("active", false)
         }
 
+        // MARK: - CarPlay public API
+
+        /**
+         * Persist whether the user wants CarPlay observation. Cold service starts
+         * (e.g. via [BootReceiver]) read this flag in [onCreate] and re-attach
+         * the observer automatically.
+         */
+        internal fun setCarPlayEnabled(context: Context, enabled: Boolean) {
+            context.getSharedPreferences(PREF_CARPLAY_ENABLED, Context.MODE_PRIVATE)
+                .edit().putBoolean("enabled", enabled).apply()
+        }
+
+        fun isCarPlayEnabled(context: Context): Boolean {
+            return context.getSharedPreferences(PREF_CARPLAY_ENABLED, Context.MODE_PRIVATE)
+                .getBoolean("enabled", false)
+        }
+
+        /**
+         * Enable CarPlay observation. Starts the foreground service if it's not
+         * already running so the observer survives app suspension and process death.
+         * Idempotent and safe to call from any context.
+         */
+        fun enableCarPlay(context: Context) {
+            setCarPlayEnabled(context, true)
+            ensureNotificationChannel(context)
+            val intent = Intent(context, BeaconForegroundService::class.java)
+                .setAction(ACTION_ENABLE_CARPLAY)
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                context.startForegroundService(intent)
+            } else {
+                context.startService(intent)
+            }
+        }
+
+        /**
+         * Disable CarPlay observation. The foreground service stops itself
+         * if no other monitoring reason remains.
+         */
+        fun disableCarPlay(context: Context) {
+            setCarPlayEnabled(context, false)
+            val intent = Intent(context, BeaconForegroundService::class.java)
+                .setAction(ACTION_DISABLE_CARPLAY)
+            // Best-effort: if the service isn't running, sending the intent will
+            // start it just to stop it. Skip startForegroundService unless beacon
+            // monitoring is also active (otherwise the start might fail with
+            // ForegroundServiceStartNotAllowedException on some Android versions).
+            if (activeService != null || isMonitoringActive(context)) {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                    context.startForegroundService(intent)
+                } else {
+                    context.startService(intent)
+                }
+            }
+        }
+
+        /**
+         * Bind a live module instance for best-effort JS-bridge delivery of
+         * service-emitted events. The reference is weak; pass `null` from the
+         * module's OnDestroy to clear it.
+         */
+        fun bindModule(module: ExpoBeaconModule?) {
+            boundModule = module?.let { java.lang.ref.WeakReference(it) }
+        }
+
         fun getMonitoringRuntimeSnapshot(): Map<String, MonitoringRuntimeState> {
             return activeService?.snapshotMonitoringRuntimeState() ?: emptyMap()
         }
@@ -891,10 +1061,16 @@ class BeaconForegroundService : Service(), BeaconConsumer {
             val config = try { org.json.JSONObject(json ?: "") } catch (_: Exception) { org.json.JSONObject() }
             val fgConfig = config.optJSONObject("foregroundService")
 
-            val title = fgConfig?.optString("title")?.takeIf { it.isNotEmpty() }
-                ?: "Beacon Monitoring Active"
-            val text = fgConfig?.optString("text")?.takeIf { it.isNotEmpty() }
-                ?: "Monitoring for iBeacons in the background"
+            // If beacon monitoring is not active and the service is alive only
+            // for CarPlay observation, fall back to a generic notification so
+            // users don't see "Monitoring for iBeacons" when no beacons are being
+            // monitored.
+            val carPlayOnly = !isMonitoringActive(context) && isCarPlayEnabled(context)
+            val defaultTitle = if (carPlayOnly) "Connected device monitoring active" else "Beacon Monitoring Active"
+            val defaultText = if (carPlayOnly) "Monitoring connected vehicle (CarPlay/Android Auto)" else "Monitoring for iBeacons in the background"
+
+            val title = fgConfig?.optString("title")?.takeIf { it.isNotEmpty() } ?: defaultTitle
+            val text = fgConfig?.optString("text")?.takeIf { it.isNotEmpty() } ?: defaultText
             val iconName = fgConfig?.optString("icon")?.takeIf { it.isNotEmpty() }
             val iconResId = iconName?.let { name ->
                 try { context.resources.getIdentifier(name, "drawable", context.packageName).takeIf { it != 0 } }
@@ -921,6 +1097,13 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         if (activeService === this) {
             activeService = null
         }
+        // Stop CarPlay observer first so the LiveData observer doesn't leak
+        // past the service lifecycle. Safe even if it was never started.
+        try {
+            carPlayMonitor?.stop()
+        } catch (_: Throwable) {}
+        carPlayMonitor = null
+        val wasBound = serviceConnected
         serviceConnected = false
         timeoutHandler.removeCallbacksAndMessages(null)
         timeoutRunnables.clear()
@@ -944,7 +1127,11 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         monitoredRegions.forEach {
             try { beaconManager.stopMonitoringBeaconsInRegion(it) } catch (_: RemoteException) {}
         }
-        beaconManager.unbind(this)
+        // Only unbind if we successfully bound — CarPlay-only service
+        // instances skip beaconManager.bind() in onStartCommand.
+        if (wasBound) {
+            try { beaconManager.unbind(this) } catch (_: Throwable) {}
+        }
         super.onDestroy()
     }
 

package/android/src/main/java/expo/modules/beacon/BootReceiver.kt

@@ -29,11 +29,16 @@ class BootReceiver : BroadcastReceiver() {
                 logMemoryKillDiagnostics(context)
                 if (BeaconForegroundService.isMonitoringActive(context)) {
                     tryStartService(context)
+                } else if (BeaconForegroundService.isCarPlayEnabled(context)) {
+                    // CarPlay-only mode: re-attach the observer so it survives reboot.
+                    tryEnableCarPlay(context)
                 }
             }
             ACTION_RETRY_MONITORING -> {
                 if (BeaconForegroundService.isMonitoringActive(context)) {
                     tryStartService(context)
+                } else if (BeaconForegroundService.isCarPlayEnabled(context)) {
+                    tryEnableCarPlay(context)
                 }
             }
         }
@@ -54,6 +59,16 @@ class BootReceiver : BroadcastReceiver() {
         }
     }
 
+    private fun tryEnableCarPlay(context: Context) {
+        try {
+            BeaconForegroundService.enableCarPlay(context)
+            Log.d(TAG, "BootReceiver: CarPlay-only service started successfully")
+        } catch (e: Exception) {
+            Log.e(TAG, "BootReceiver: Failed to start CarPlay-only service — retrying in ${RETRY_DELAY_MS}ms", e)
+            scheduleRetry(context)
+        }
+    }
+
     private fun scheduleRetry(context: Context) {
         val alarmManager = context.getSystemService(AlarmManager::class.java) ?: return
         val retryIntent = Intent(context, BootReceiver::class.java).apply {

package/android/src/main/java/expo/modules/beacon/ExpoBeaconModule.kt

@@ -82,9 +82,6 @@ class ExpoBeaconModule : Module(), BeaconConsumer {
     private var eventLogger: BeaconEventLogger? = null
     @Volatile private var loggingEnabled = false
 
-    // CarPlay / Android Auto monitor (lazy because it requires reactContext)
-    private var carPlayMonitor: CarPlayMonitor? = null
-
     override fun definition() = ModuleDefinition {
         Name("ExpoBeacon")
 
@@ -379,6 +376,10 @@ class ExpoBeaconModule : Module(), BeaconConsumer {
                 sendEvent("onBeaconError", mapOf("identifier" to "", "code" to "SERVICE_START_FAILED", "message" to "Failed to start monitoring service: ${e.message}"))
                 return@AsyncFunction
             }
+            // Auto-enable CarPlay observation alongside beacon monitoring so
+            // the service captures CarPlay/Android Auto events for the same
+            // lifetime. Users can opt out at any time via stopCarPlayMonitoring().
+            try { BeaconForegroundService.enableCarPlay(ctx) } catch (_: Throwable) {}
             promise.resolve(null)
         }
 
@@ -462,6 +463,11 @@ class ExpoBeaconModule : Module(), BeaconConsumer {
             loggingEnabled = false
         }
 
+        Function("isEventLoggingEnabled") {
+            val ctx = appContext.reactContext ?: return@Function false
+            BeaconEventLogger.isLoggingEnabled(ctx)
+        }
+
         Function("getEventLogs") { options: Map<String, Any?>? ->
             val logger = getOrCreateEventLogger() ?: return@Function emptyList<Map<String, Any?>>()
             val limit = (options?.get("limit") as? Number)?.toInt() ?: 1000
@@ -574,10 +580,7 @@ class ExpoBeaconModule : Module(), BeaconConsumer {
                 return@AsyncFunction
             }
             try {
-                val monitor = carPlayMonitor ?: CarPlayMonitor(ctx).also { carPlayMonitor = it }
-                monitor.start { eventName, payload ->
-                    emitCarPlayEvent(eventName, payload)
-                }
+                BeaconForegroundService.enableCarPlay(ctx)
                 promise.resolve(null)
             } catch (e: Throwable) {
                 promise.reject("CARPLAY_START_FAILED", "Failed to start CarPlay monitoring: ${e.message}", e)
@@ -585,15 +588,35 @@ class ExpoBeaconModule : Module(), BeaconConsumer {
         }
 
         AsyncFunction("stopCarPlayMonitoring") { promise: Promise ->
-            carPlayMonitor?.stop()
-            promise.resolve(null)
+            val ctx = appContext.reactContext
+            if (ctx == null) {
+                promise.reject("NO_CONTEXT", "React context is not available", null)
+                return@AsyncFunction
+            }
+            try {
+                BeaconForegroundService.disableCarPlay(ctx)
+                promise.resolve(null)
+            } catch (e: Throwable) {
+                promise.reject("CARPLAY_STOP_FAILED", "Failed to stop CarPlay monitoring: ${e.message}", e)
+            }
+        }
+
+        Function("isCarPlayMonitoringEnabled") {
+            val ctx = appContext.reactContext ?: return@Function false
+            BeaconForegroundService.isCarPlayEnabled(ctx)
+        }
+
+        OnCreate {
+            // Register this module instance for best-effort JS-bridge fan-out
+            // of CarPlay events emitted by the foreground service. The service
+            // holds a weak reference; cleared in OnDestroy.
+            BeaconForegroundService.bindModule(this@ExpoBeaconModule)
         }
 
         OnDestroy {
             with(this@ExpoBeaconModule) {
+                BeaconForegroundService.bindModule(null)
                 unregisterEventReceiver()
-                carPlayMonitor?.stop()
-                carPlayMonitor = null
                 loggingEnabled = false
                 eventLogger?.close()
                 eventLogger = null
@@ -1038,22 +1061,12 @@ class ExpoBeaconModule : Module(), BeaconConsumer {
     }
 
     /**
-     * Emit a CarPlay/Android Auto event to JS, log it to SQLite, forward to the
-     * configured remote API, and dispatch to registered native plugins.
+     * Called by [BeaconForegroundService] (via weak reference) when it emits a
+     * CarPlay event from its own observer. Best-effort delivery to the JS bridge
+     * — the service has already handled SQLite logging, API forwarding, and
+     * native plugin dispatch, so this method only needs to relay to JS.
      */
-    private fun emitCarPlayEvent(eventName: String, payload: Map<String, Any?>) {
-        sendEvent(eventName, payload)
-        logBeaconEvent(eventName, payload)
-        appContext.reactContext?.let { ctx ->
-            try {
-                BeaconApiForwarder(ctx).forwardEvent(payload)
-            } catch (_: Throwable) { /* best-effort */ }
-        }
-        when (eventName) {
-            "onCarPlayConnected" -> BeaconPluginRegistry.dispatchCarPlayConnected(
-                payload["transport"] as? String ?: "unknown"
-            )
-            "onCarPlayDisconnected" -> BeaconPluginRegistry.dispatchCarPlayDisconnected()
-        }
+    fun forwardCarPlayEventFromService(eventName: String, payload: Map<String, Any?>) {
+        try { sendEvent(eventName, payload) } catch (_: Throwable) { /* JS bridge may be torn down */ }
     }
 }

package/build/ExpoBeaconModule.d.ts

@@ -93,6 +93,11 @@ declare class ExpoBeaconModule extends NativeModule<ExpoBeaconModuleEvents> {
     enableEventLogging(): void;
     /** Disable event logging. Previously logged events are retained. */
     disableEventLogging(): void;
+    /**
+     * Returns whether SQLite event logging is currently enabled.
+     * Reads the persisted flag, so this stays accurate across app cold-starts.
+     */
+    isEventLoggingEnabled(): boolean;
     /**
      * Retrieve logged beacon events from the SQLite database.
      * @param options Optional filters (limit, eventType, sinceTimestamp).
@@ -143,7 +148,22 @@ declare class ExpoBeaconModule extends NativeModule<ExpoBeaconModuleEvents> {
      * endpoint, and dispatched to native lifecycle plugins (used by the auto-
      * generated geolocation plugin to start/stop background-geolocation).
      *
-     * Safe to call multiple times — subsequent calls are no-ops.
+     * **Persistent.** The enabled state is stored in native preferences and
+     * survives app kill / device reboot. Call `stopCarPlayMonitoring()` to
+     * disable. `startMonitoring()` also enables CarPlay observation
+     * automatically — calling this method explicitly is only required if you
+     * want CarPlay events without beacon monitoring.
+     *
+     * **Background behavior:**
+     * - **Android**: the foreground service hosts the observer and continues to
+     *   receive `CarConnection` events even after the app process is killed and
+     *   restarted via `BootReceiver`. Guaranteed background detection.
+     * - **iOS**: the observer auto-restarts in `OnCreate` whenever the module
+     *   is recreated, including background-launches triggered by beacon region
+     *   monitoring. **iOS cannot wake a terminated app on CarPlay alone** — for
+     *   guaranteed wake-from-suspension, also call `startMonitoring()` with at
+     *   least one paired beacon. Region wake events trigger a CarPlay state
+     *   resync to reconcile any route changes that occurred during suspension.
      *
      * - iOS: observes `AVAudioSession.routeChangeNotification` for `.carAudio` ports.
      *   No CarPlay entitlement required.
@@ -152,8 +172,21 @@ declare class ExpoBeaconModule extends NativeModule<ExpoBeaconModuleEvents> {
      * - Web: no-op (resolves immediately).
      */
     startCarPlayMonitoring(): Promise<void>;
-    /** Stop CarPlay / Android Auto connection monitoring started by `startCarPlayMonitoring()`. */
+    /**
+     * Stop CarPlay / Android Auto connection monitoring and clear the persisted
+     * "enabled" flag so the observer is not auto-restarted on next launch / boot.
+     *
+     * On Android, if no beacon monitoring is active, the foreground service
+     * stops itself.
+     */
     stopCarPlayMonitoring(): Promise<void>;
+    /**
+     * Returns whether CarPlay / Android Auto observation is currently enabled.
+     * Reads the persisted flag, so the value survives app cold-starts and
+     * reflects the native source of truth (foreground service on Android,
+     * UserDefaults suite on iOS).
+     */
+    isCarPlayMonitoringEnabled(): boolean;
 }
 declare const _default: ExpoBeaconModule;
 export default _default;

package/build/ExpoBeaconModule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ExpoBeaconModule.d.ts","sourceRoot":"","sources":["../src/ExpoBeaconModule.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ExpoBeaconModule.d.ts","sourceRoot":"","sources":["../src/ExpoBeaconModule.ts"],"names":[],"mappings":"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"}

package/build/ExpoBeaconModule.js.map

@@ -1 +1 @@
-{"version":3,"file":"ExpoBeaconModule.js","sourceRoot":"","sources":["../src/ExpoBeaconModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,mBAAmB,EAAE,MAAM,MAAM,CAAC;AAsNzD,eAAe,mBAAmB,CAAmB,YAAY,CAAC,CAAC","sourcesContent":["import { NativeModule, requireNativeModule } from \"expo\";\r\n\r\nimport {\r\n  ExpoBeaconModuleEvents,\r\n  BeaconScanResult,\r\n  EddystoneScanResult,\r\n  PairedBeacon,\r\n  PairedEddystone,\r\n  NotificationConfig,\r\n  MonitoringOptions,\r\n  MonitoringConfig,\r\n  MonitoredDeviceState,\r\n  EventLogQueryOptions,\r\n  EventLogEntry,\r\n} from \"./ExpoBeacon.types\";\r\n\r\ndeclare class ExpoBeaconModule extends NativeModule<ExpoBeaconModuleEvents> {\r\n  /**\r\n   * Start a one-shot iBeacon scan. Resolves with discovered beacons after scanDuration ms.\r\n   *\r\n   * Pass one or more UUIDs to scan for specific beacons (uses CoreLocation on iOS).\r\n   * On iOS, at least one UUID is required — Apple strips iBeacon data from BLE\r\n   * advertisements, making wildcard discovery impossible. When you pass an empty\r\n   * array, the module automatically uses UUIDs from paired beacons.\r\n   * On Android, pass an empty array to discover all nearby iBeacons.\r\n   *\r\n   * @param uuids Proximity UUIDs to filter by. Empty/omitted = use paired UUIDs (iOS) or wildcard (Android).\r\n   * @param scanDuration Duration in ms (default 5000)\r\n   */\r\n  scanForBeaconsAsync(\r\n    uuids?: string[],\r\n    scanDuration?: number,\r\n  ): Promise<BeaconScanResult[]>;\r\n\r\n  /**\r\n   * Start a one-shot Eddystone beacon scan using BLE.\r\n   * Discovers Eddystone-UID and Eddystone-URL frames.\r\n   *\r\n   * @param scanDuration Duration in ms (default 5000)\r\n   */\r\n  scanForEddystonesAsync(\r\n    scanDuration?: number,\r\n  ): Promise<EddystoneScanResult[]>;\r\n\r\n  /**\r\n   * Register a beacon for persistent region monitoring.\r\n   */\r\n  pairBeacon(\r\n    identifier: string,\r\n    uuid: string,\r\n    major: number,\r\n    minor: number,\r\n    name?: string,\r\n    timeoutSeconds?: number,\r\n  ): void;\r\n\r\n  /**\r\n   * Remove a previously paired beacon.\r\n   */\r\n  unpairBeacon(identifier: string): void;\r\n\r\n  /**\r\n   * Return all currently paired beacons.\r\n   */\r\n  getPairedBeacons(): PairedBeacon[];\r\n\r\n  /**\r\n   * Register an Eddystone-UID beacon for persistent monitoring.\r\n   */\r\n  pairEddystone(\r\n    identifier: string,\r\n    namespace: string,\r\n    instance: string,\r\n    name?: string,\r\n    timeoutSeconds?: number,\r\n  ): void;\r\n\r\n  /**\r\n   * Remove a previously paired Eddystone beacon.\r\n   */\r\n  unpairEddystone(identifier: string): void;\r\n\r\n  /**\r\n   * Return all currently paired Eddystone beacons.\r\n   */\r\n  getPairedEddystones(): PairedEddystone[];\r\n\r\n  /**\r\n   * Set persistent notification configuration. Settings are saved and applied to all\r\n   * subsequent monitoring sessions until explicitly changed.\r\n   */\r\n  setNotificationConfig(config: NotificationConfig): void;\r\n\r\n  /**\r\n   * Start background region monitoring for all paired beacons.\r\n   * On Android starts a foreground service.\r\n   * On iOS starts CLLocationManager region monitoring.\r\n   *\r\n   * Accepts a plain number (backward-compatible maxDistance shorthand) or a\r\n   * MonitoringOptions object with maxDistance and/or notification overrides.\r\n   */\r\n  startMonitoring(options?: MonitoringOptions | number): Promise<void>;\r\n\r\n  /**\r\n   * Stop background region monitoring.\r\n   */\r\n  stopMonitoring(): Promise<void>;\r\n\r\n  /**\r\n   * Start a continuous BLE scan. Fires `onBeaconFound` events as beacons are detected.\r\n   * Call stopContinuousScan() to end the scan.\r\n   */\r\n  startContinuousScan(): void;\r\n\r\n  /** Stop the continuous scan started by startContinuousScan(). */\r\n  stopContinuousScan(): void;\r\n\r\n  /**\r\n   * Cancel any in-progress one-shot scan (iBeacon or Eddystone).\r\n   * The pending promise will be rejected with code \"SCAN_CANCELLED\".\r\n   */\r\n  cancelScan(): void;\r\n\r\n  /** Request Bluetooth + Location permissions. Returns true if granted. */\r\n  requestPermissionsAsync(): Promise<boolean>;\r\n\r\n  /**\r\n   * Check whether the app is exempt from Android battery optimizations.\r\n   * Always returns true on iOS and web (no equivalent concept).\r\n   */\r\n  isBatteryOptimizationExempt(): boolean;\r\n\r\n  /**\r\n   * Request exemption from Android battery optimizations.\r\n   * Opens the system dialog asking the user to whitelist this app.\r\n   * Returns true if the dialog was shown (or already exempt), false on failure.\r\n   * Always resolves true on iOS and web.\r\n   */\r\n  requestBatteryOptimizationExemption(): Promise<boolean>;\r\n\r\n  /** Enable SQLite event logging. All beacon events will be persisted to a local database. */\r\n  enableEventLogging(): void;\r\n\r\n  /** Disable event logging. Previously logged events are retained. */\r\n  disableEventLogging(): void;\r\n\r\n  /**\r\n   * Retrieve logged beacon events from the SQLite database.\r\n   * @param options Optional filters (limit, eventType, sinceTimestamp).\r\n   */\r\n  getEventLogs(options?: EventLogQueryOptions): EventLogEntry[];\r\n\r\n  /** Delete all logged events from the database. */\r\n  clearEventLogs(): void;\r\n\r\n  /** Delete the entire event log database. Also disables logging. */\r\n  destroyEventLogs(): void;\r\n\r\n  /**\r\n   * Configure a remote API endpoint for native event forwarding.\r\n   * Once set, beacon events are POSTed directly from native code,\r\n   * ensuring delivery even when the JS bridge is not active (app backgrounded).\r\n   *\r\n   * @param url The API endpoint URL to POST events to.\r\n   * @param apiKey Optional API key sent as X-CSFR-Token header.\r\n   * @param id Optional identifier appended to every forwarded event payload.\r\n   */\r\n  setApiEndpoint(url: string, apiKey?: string, id?: string): void;\r\n\r\n  /**\r\n   * Return the current monitoring configuration and active state.\r\n   * Option fields are undefined if not explicitly set.\r\n   */\r\n  getMonitoringConfig(): MonitoringConfig;\r\n\r\n  /**\r\n   * Return the current state snapshot for a paired monitored device.\r\n   * Returns null when no paired device matches the identifier.\r\n   */\r\n  getMonitoredDeviceState(identifier: string): MonitoredDeviceState | null;\r\n\r\n  /**\r\n   * Return the current state snapshot for all paired monitored devices.\r\n   */\r\n  getMonitoredDeviceStates(): MonitoredDeviceState[];\r\n\r\n  /**\r\n   * Return the current API forwarding configuration.\r\n   * Each field is `null` if not set.\r\n   */\r\n  getApiEndpoint(): { url: string | null; apiKey: string | null; id: string | null };\r\n\r\n  /**\r\n   * Start observing CarPlay (iOS) / Android Auto (Android) connection state.\r\n   *\r\n   * Emits `onCarPlayConnected` and `onCarPlayDisconnected` JS events. Events are\r\n   * also written to the SQLite event log and forwarded to the configured API\r\n   * endpoint, and dispatched to native lifecycle plugins (used by the auto-\r\n   * generated geolocation plugin to start/stop background-geolocation).\r\n   *\r\n   * Safe to call multiple times — subsequent calls are no-ops.\r\n   *\r\n   * - iOS: observes `AVAudioSession.routeChangeNotification` for `.carAudio` ports.\r\n   *   No CarPlay entitlement required.\r\n   * - Android: observes `androidx.car.app.connection.CarConnection` LiveData.\r\n   *   No Android Auto certification required.\r\n   * - Web: no-op (resolves immediately).\r\n   */\r\n  startCarPlayMonitoring(): Promise<void>;\r\n\r\n  /** Stop CarPlay / Android Auto connection monitoring started by `startCarPlayMonitoring()`. */\r\n  stopCarPlayMonitoring(): Promise<void>;\r\n}\r\n\r\nexport default requireNativeModule<ExpoBeaconModule>(\"ExpoBeacon\");\r\n"]}
+{"version":3,"file":"ExpoBeaconModule.js","sourceRoot":"","sources":["../src/ExpoBeaconModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,mBAAmB,EAAE,MAAM,MAAM,CAAC;AAyPzD,eAAe,mBAAmB,CAAmB,YAAY,CAAC,CAAC","sourcesContent":["import { NativeModule, requireNativeModule } from \"expo\";\r\n\r\nimport {\r\n  ExpoBeaconModuleEvents,\r\n  BeaconScanResult,\r\n  EddystoneScanResult,\r\n  PairedBeacon,\r\n  PairedEddystone,\r\n  NotificationConfig,\r\n  MonitoringOptions,\r\n  MonitoringConfig,\r\n  MonitoredDeviceState,\r\n  EventLogQueryOptions,\r\n  EventLogEntry,\r\n} from \"./ExpoBeacon.types\";\r\n\r\ndeclare class ExpoBeaconModule extends NativeModule<ExpoBeaconModuleEvents> {\r\n  /**\r\n   * Start a one-shot iBeacon scan. Resolves with discovered beacons after scanDuration ms.\r\n   *\r\n   * Pass one or more UUIDs to scan for specific beacons (uses CoreLocation on iOS).\r\n   * On iOS, at least one UUID is required — Apple strips iBeacon data from BLE\r\n   * advertisements, making wildcard discovery impossible. When you pass an empty\r\n   * array, the module automatically uses UUIDs from paired beacons.\r\n   * On Android, pass an empty array to discover all nearby iBeacons.\r\n   *\r\n   * @param uuids Proximity UUIDs to filter by. Empty/omitted = use paired UUIDs (iOS) or wildcard (Android).\r\n   * @param scanDuration Duration in ms (default 5000)\r\n   */\r\n  scanForBeaconsAsync(\r\n    uuids?: string[],\r\n    scanDuration?: number,\r\n  ): Promise<BeaconScanResult[]>;\r\n\r\n  /**\r\n   * Start a one-shot Eddystone beacon scan using BLE.\r\n   * Discovers Eddystone-UID and Eddystone-URL frames.\r\n   *\r\n   * @param scanDuration Duration in ms (default 5000)\r\n   */\r\n  scanForEddystonesAsync(\r\n    scanDuration?: number,\r\n  ): Promise<EddystoneScanResult[]>;\r\n\r\n  /**\r\n   * Register a beacon for persistent region monitoring.\r\n   */\r\n  pairBeacon(\r\n    identifier: string,\r\n    uuid: string,\r\n    major: number,\r\n    minor: number,\r\n    name?: string,\r\n    timeoutSeconds?: number,\r\n  ): void;\r\n\r\n  /**\r\n   * Remove a previously paired beacon.\r\n   */\r\n  unpairBeacon(identifier: string): void;\r\n\r\n  /**\r\n   * Return all currently paired beacons.\r\n   */\r\n  getPairedBeacons(): PairedBeacon[];\r\n\r\n  /**\r\n   * Register an Eddystone-UID beacon for persistent monitoring.\r\n   */\r\n  pairEddystone(\r\n    identifier: string,\r\n    namespace: string,\r\n    instance: string,\r\n    name?: string,\r\n    timeoutSeconds?: number,\r\n  ): void;\r\n\r\n  /**\r\n   * Remove a previously paired Eddystone beacon.\r\n   */\r\n  unpairEddystone(identifier: string): void;\r\n\r\n  /**\r\n   * Return all currently paired Eddystone beacons.\r\n   */\r\n  getPairedEddystones(): PairedEddystone[];\r\n\r\n  /**\r\n   * Set persistent notification configuration. Settings are saved and applied to all\r\n   * subsequent monitoring sessions until explicitly changed.\r\n   */\r\n  setNotificationConfig(config: NotificationConfig): void;\r\n\r\n  /**\r\n   * Start background region monitoring for all paired beacons.\r\n   * On Android starts a foreground service.\r\n   * On iOS starts CLLocationManager region monitoring.\r\n   *\r\n   * Accepts a plain number (backward-compatible maxDistance shorthand) or a\r\n   * MonitoringOptions object with maxDistance and/or notification overrides.\r\n   */\r\n  startMonitoring(options?: MonitoringOptions | number): Promise<void>;\r\n\r\n  /**\r\n   * Stop background region monitoring.\r\n   */\r\n  stopMonitoring(): Promise<void>;\r\n\r\n  /**\r\n   * Start a continuous BLE scan. Fires `onBeaconFound` events as beacons are detected.\r\n   * Call stopContinuousScan() to end the scan.\r\n   */\r\n  startContinuousScan(): void;\r\n\r\n  /** Stop the continuous scan started by startContinuousScan(). */\r\n  stopContinuousScan(): void;\r\n\r\n  /**\r\n   * Cancel any in-progress one-shot scan (iBeacon or Eddystone).\r\n   * The pending promise will be rejected with code \"SCAN_CANCELLED\".\r\n   */\r\n  cancelScan(): void;\r\n\r\n  /** Request Bluetooth + Location permissions. Returns true if granted. */\r\n  requestPermissionsAsync(): Promise<boolean>;\r\n\r\n  /**\r\n   * Check whether the app is exempt from Android battery optimizations.\r\n   * Always returns true on iOS and web (no equivalent concept).\r\n   */\r\n  isBatteryOptimizationExempt(): boolean;\r\n\r\n  /**\r\n   * Request exemption from Android battery optimizations.\r\n   * Opens the system dialog asking the user to whitelist this app.\r\n   * Returns true if the dialog was shown (or already exempt), false on failure.\r\n   * Always resolves true on iOS and web.\r\n   */\r\n  requestBatteryOptimizationExemption(): Promise<boolean>;\r\n\r\n  /** Enable SQLite event logging. All beacon events will be persisted to a local database. */\r\n  enableEventLogging(): void;\r\n\r\n  /** Disable event logging. Previously logged events are retained. */\r\n  disableEventLogging(): void;\r\n\r\n  /**\r\n   * Returns whether SQLite event logging is currently enabled.\r\n   * Reads the persisted flag, so this stays accurate across app cold-starts.\r\n   */\r\n  isEventLoggingEnabled(): boolean;\r\n\r\n  /**\r\n   * Retrieve logged beacon events from the SQLite database.\r\n   * @param options Optional filters (limit, eventType, sinceTimestamp).\r\n   */\r\n  getEventLogs(options?: EventLogQueryOptions): EventLogEntry[];\r\n\r\n  /** Delete all logged events from the database. */\r\n  clearEventLogs(): void;\r\n\r\n  /** Delete the entire event log database. Also disables logging. */\r\n  destroyEventLogs(): void;\r\n\r\n  /**\r\n   * Configure a remote API endpoint for native event forwarding.\r\n   * Once set, beacon events are POSTed directly from native code,\r\n   * ensuring delivery even when the JS bridge is not active (app backgrounded).\r\n   *\r\n   * @param url The API endpoint URL to POST events to.\r\n   * @param apiKey Optional API key sent as X-CSFR-Token header.\r\n   * @param id Optional identifier appended to every forwarded event payload.\r\n   */\r\n  setApiEndpoint(url: string, apiKey?: string, id?: string): void;\r\n\r\n  /**\r\n   * Return the current monitoring configuration and active state.\r\n   * Option fields are undefined if not explicitly set.\r\n   */\r\n  getMonitoringConfig(): MonitoringConfig;\r\n\r\n  /**\r\n   * Return the current state snapshot for a paired monitored device.\r\n   * Returns null when no paired device matches the identifier.\r\n   */\r\n  getMonitoredDeviceState(identifier: string): MonitoredDeviceState | null;\r\n\r\n  /**\r\n   * Return the current state snapshot for all paired monitored devices.\r\n   */\r\n  getMonitoredDeviceStates(): MonitoredDeviceState[];\r\n\r\n  /**\r\n   * Return the current API forwarding configuration.\r\n   * Each field is `null` if not set.\r\n   */\r\n  getApiEndpoint(): { url: string | null; apiKey: string | null; id: string | null };\r\n\r\n  /**\r\n   * Start observing CarPlay (iOS) / Android Auto (Android) connection state.\r\n   *\r\n   * Emits `onCarPlayConnected` and `onCarPlayDisconnected` JS events. Events are\r\n   * also written to the SQLite event log and forwarded to the configured API\r\n   * endpoint, and dispatched to native lifecycle plugins (used by the auto-\r\n   * generated geolocation plugin to start/stop background-geolocation).\r\n   *\r\n   * **Persistent.** The enabled state is stored in native preferences and\r\n   * survives app kill / device reboot. Call `stopCarPlayMonitoring()` to\r\n   * disable. `startMonitoring()` also enables CarPlay observation\r\n   * automatically — calling this method explicitly is only required if you\r\n   * want CarPlay events without beacon monitoring.\r\n   *\r\n   * **Background behavior:**\r\n   * - **Android**: the foreground service hosts the observer and continues to\r\n   *   receive `CarConnection` events even after the app process is killed and\r\n   *   restarted via `BootReceiver`. Guaranteed background detection.\r\n   * - **iOS**: the observer auto-restarts in `OnCreate` whenever the module\r\n   *   is recreated, including background-launches triggered by beacon region\r\n   *   monitoring. **iOS cannot wake a terminated app on CarPlay alone** — for\r\n   *   guaranteed wake-from-suspension, also call `startMonitoring()` with at\r\n   *   least one paired beacon. Region wake events trigger a CarPlay state\r\n   *   resync to reconcile any route changes that occurred during suspension.\r\n   *\r\n   * - iOS: observes `AVAudioSession.routeChangeNotification` for `.carAudio` ports.\r\n   *   No CarPlay entitlement required.\r\n   * - Android: observes `androidx.car.app.connection.CarConnection` LiveData.\r\n   *   No Android Auto certification required.\r\n   * - Web: no-op (resolves immediately).\r\n   */\r\n  startCarPlayMonitoring(): Promise<void>;\r\n\r\n  /**\r\n   * Stop CarPlay / Android Auto connection monitoring and clear the persisted\r\n   * \"enabled\" flag so the observer is not auto-restarted on next launch / boot.\r\n   *\r\n   * On Android, if no beacon monitoring is active, the foreground service\r\n   * stops itself.\r\n   */\r\n  stopCarPlayMonitoring(): Promise<void>;\r\n\r\n  /**\r\n   * Returns whether CarPlay / Android Auto observation is currently enabled.\r\n   * Reads the persisted flag, so the value survives app cold-starts and\r\n   * reflects the native source of truth (foreground service on Android,\r\n   * UserDefaults suite on iOS).\r\n   */\r\n  isCarPlayMonitoringEnabled(): boolean;\r\n}\r\n\r\nexport default requireNativeModule<ExpoBeaconModule>(\"ExpoBeacon\");\r\n"]}

package/build/ExpoBeaconModule.web.d.ts

@@ -17,6 +17,7 @@ declare const stub: {
     requestPermissionsAsync: () => Promise<boolean>;
     enableEventLogging: () => void;
     disableEventLogging: () => void;
+    isEventLoggingEnabled: () => boolean;
     getEventLogs: (_options?: EventLogQueryOptions) => EventLogEntry[];
     clearEventLogs: () => void;
     destroyEventLogs: () => void;
@@ -32,6 +33,7 @@ declare const stub: {
     requestBatteryOptimizationExemption: () => Promise<boolean>;
     startCarPlayMonitoring: () => Promise<void>;
     stopCarPlayMonitoring: () => Promise<void>;
+    isCarPlayMonitoringEnabled: () => boolean;
     addListener: (_eventName: keyof ExpoBeaconModuleEvents, _listener: any) => {
         remove: () => void;
     };

package/build/ExpoBeaconModule.web.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ExpoBeaconModule.web.d.ts","sourceRoot":"","sources":["../src/ExpoBeaconModule.web.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EACtB,gBAAgB,EAChB,mBAAmB,EACnB,YAAY,EACZ,eAAe,EACf,oBAAoB,EACpB,oBAAoB,EACpB,aAAa,EACd,MAAM,oBAAoB,CAAC;AAM5B,QAAA,MAAM,IAAI;kCAEE,MAAM,EAAE,kBACA,MAAM,KACrB,OAAO,CAAC,gBAAgB,EAAE,CAAC;6CAEZ,MAAM,KACrB,OAAO,CAAC,mBAAmB,EAAE,CAAC;8BAElB,MAAM,SACZ,MAAM,UACL,MAAM,UACN,MAAM,KACb,IAAI;gCACqB,MAAM,KAAG,IAAI;4BACnB,YAAY,EAAE;iCAErB,MAAM,cACP,MAAM,aACP,MAAM,KAChB,IAAI;mCACwB,MAAM,KAAG,IAAI;+BACnB,eAAe,EAAE;2BACrB,OAAO,CAAC,IAAI,CAAC;0BACd,OAAO,CAAC,IAAI,CAAC;+BACR,IAAI;8BACL,IAAI;sBACZ,IAAI;qCACa,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,IAAI;mCAClC,OAAO,CAAC,OAAO,CAAC;8BACrB,IAAI;+BACH,IAAI;8BACH,oBAAoB,KAAG,aAAa,EAAE;0BAC5C,IAAI;4BACF,IAAI;;2CAEa,MAAM,KAAG,oBAAoB,GAAG,IAAI;oCAC7C,oBAAoB,EAAE;0BAChC;QAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE;uCACnD,OAAO;+CACC,OAAO,CAAC,OAAO,CAAC;kCAC7B,OAAO,CAAC,IAAI,CAAC;iCACd,OAAO,CAAC,IAAI,CAAC;8BACd,MAAM,sBAAsB,aAAa,GAAG;;;qCAGrC,MAAM,sBAAsB;CAC9D,CAAC;AAEF,eAAe,IAAI,CAAC"}
+{"version":3,"file":"ExpoBeaconModule.web.d.ts","sourceRoot":"","sources":["../src/ExpoBeaconModule.web.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EACtB,gBAAgB,EAChB,mBAAmB,EACnB,YAAY,EACZ,eAAe,EACf,oBAAoB,EACpB,oBAAoB,EACpB,aAAa,EACd,MAAM,oBAAoB,CAAC;AAM5B,QAAA,MAAM,IAAI;kCAEE,MAAM,EAAE,kBACA,MAAM,KACrB,OAAO,CAAC,gBAAgB,EAAE,CAAC;6CAEZ,MAAM,KACrB,OAAO,CAAC,mBAAmB,EAAE,CAAC;8BAElB,MAAM,SACZ,MAAM,UACL,MAAM,UACN,MAAM,KACb,IAAI;gCACqB,MAAM,KAAG,IAAI;4BACnB,YAAY,EAAE;iCAErB,MAAM,cACP,MAAM,aACP,MAAM,KAChB,IAAI;mCACwB,MAAM,KAAG,IAAI;+BACnB,eAAe,EAAE;2BACrB,OAAO,CAAC,IAAI,CAAC;0BACd,OAAO,CAAC,IAAI,CAAC;+BACR,IAAI;8BACL,IAAI;sBACZ,IAAI;qCACa,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,IAAI;mCAClC,OAAO,CAAC,OAAO,CAAC;8BACrB,IAAI;+BACH,IAAI;iCACF,OAAO;8BACR,oBAAoB,KAAG,aAAa,EAAE;0BAC5C,IAAI;4BACF,IAAI;;2CAEa,MAAM,KAAG,oBAAoB,GAAG,IAAI;oCAC7C,oBAAoB,EAAE;0BAChC;QAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE;uCACnD,OAAO;+CACC,OAAO,CAAC,OAAO,CAAC;kCAC7B,OAAO,CAAC,IAAI,CAAC;iCACd,OAAO,CAAC,IAAI,CAAC;sCACR,OAAO;8BACb,MAAM,sBAAsB,aAAa,GAAG;;;qCAGrC,MAAM,sBAAsB;CAC9D,CAAC;AAEF,eAAe,IAAI,CAAC"}

package/build/ExpoBeaconModule.web.js

@@ -19,6 +19,7 @@ const stub = {
     requestPermissionsAsync: () => notSupported(),
     enableEventLogging: () => notSupported(),
     disableEventLogging: () => notSupported(),
+    isEventLoggingEnabled: () => false,
     getEventLogs: (_options) => notSupported(),
     clearEventLogs: () => notSupported(),
     destroyEventLogs: () => notSupported(),
@@ -30,6 +31,7 @@ const stub = {
     requestBatteryOptimizationExemption: () => Promise.resolve(true),
     startCarPlayMonitoring: () => Promise.resolve(),
     stopCarPlayMonitoring: () => Promise.resolve(),
+    isCarPlayMonitoringEnabled: () => false,
     addListener: (_eventName, _listener) => ({
         remove: () => { },
     }),

package/build/ExpoBeaconModule.web.js.map

@@ -1 +1 @@
-{"version":3,"file":"ExpoBeaconModule.web.js","sourceRoot":"","sources":["../src/ExpoBeaconModule.web.ts"],"names":[],"mappings":"AAWA,MAAM,YAAY,GAAG,GAAU,EAAE;IAC/B,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;AAC1D,CAAC,CAAC;AAEF,MAAM,IAAI,GAAG;IACX,mBAAmB,EAAE,CACnB,MAAgB,EAChB,aAAsB,EACO,EAAE,CAAC,YAAY,EAAE;IAChD,sBAAsB,EAAE,CACtB,aAAsB,EACU,EAAE,CAAC,YAAY,EAAE;IACnD,UAAU,EAAE,CACV,WAAmB,EACnB,KAAa,EACb,MAAc,EACd,MAAc,EACR,EAAE,CAAC,YAAY,EAAE;IACzB,YAAY,EAAE,CAAC,WAAmB,EAAQ,EAAE,CAAC,YAAY,EAAE;IAC3D,gBAAgB,EAAE,GAAmB,EAAE,CAAC,YAAY,EAAE;IACtD,aAAa,EAAE,CACb,WAAmB,EACnB,UAAkB,EAClB,SAAiB,EACX,EAAE,CAAC,YAAY,EAAE;IACzB,eAAe,EAAE,CAAC,WAAmB,EAAQ,EAAE,CAAC,YAAY,EAAE;IAC9D,mBAAmB,EAAE,GAAsB,EAAE,CAAC,YAAY,EAAE;IAC5D,eAAe,EAAE,GAAkB,EAAE,CAAC,YAAY,EAAE;IACpD,cAAc,EAAE,GAAkB,EAAE,CAAC,YAAY,EAAE;IACnD,mBAAmB,EAAE,GAAS,EAAE,CAAC,YAAY,EAAE;IAC/C,kBAAkB,EAAE,GAAS,EAAE,CAAC,YAAY,EAAE;IAC9C,UAAU,EAAE,GAAS,EAAE,CAAC,YAAY,EAAE;IACtC,qBAAqB,EAAE,CAAC,OAAgC,EAAQ,EAAE,CAAC,YAAY,EAAE;IACjF,uBAAuB,EAAE,GAAqB,EAAE,CAAC,YAAY,EAAE;IAC/D,kBAAkB,EAAE,GAAS,EAAE,CAAC,YAAY,EAAE;IAC9C,mBAAmB,EAAE,GAAS,EAAE,CAAC,YAAY,EAAE;IAC/C,YAAY,EAAE,CAAC,QAA+B,EAAmB,EAAE,CAAC,YAAY,EAAE;IAClF,cAAc,EAAE,GAAS,EAAE,CAAC,YAAY,EAAE;IAC1C,gBAAgB,EAAE,GAAS,EAAE,CAAC,YAAY,EAAE;IAC5C,mBAAmB,EAAE,GAAG,EAAE,CAAC,YAAY,EAAE;IACzC,uBAAuB,EAAE,CAAC,WAAmB,EAA+B,EAAE,CAAC,YAAY,EAAE;IAC7F,wBAAwB,EAAE,GAA2B,EAAE,CAAC,YAAY,EAAE;IACtE,cAAc,EAAE,GAAqE,EAAE,CAAC,YAAY,EAAE;IACtG,2BAA2B,EAAE,GAAY,EAAE,CAAC,IAAI;IAChD,mCAAmC,EAAE,GAAqB,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC;IAClF,sBAAsB,EAAE,GAAkB,EAAE,CAAC,OAAO,CAAC,OAAO,EAAE;IAC9D,qBAAqB,EAAE,GAAkB,EAAE,CAAC,OAAO,CAAC,OAAO,EAAE;IAC7D,WAAW,EAAE,CAAC,UAAwC,EAAE,SAAc,EAAE,EAAE,CAAC,CAAC;QAC1E,MAAM,EAAE,GAAG,EAAE,GAAE,CAAC;KACjB,CAAC;IACF,kBAAkB,EAAE,CAAC,UAAwC,EAAE,EAAE,GAAE,CAAC;CACrE,CAAC;AAEF,eAAe,IAAI,CAAC","sourcesContent":["import type {\r\n  ExpoBeaconModuleEvents,\r\n  BeaconScanResult,\r\n  EddystoneScanResult,\r\n  PairedBeacon,\r\n  PairedEddystone,\r\n  MonitoredDeviceState,\r\n  EventLogQueryOptions,\r\n  EventLogEntry,\r\n} from \"./ExpoBeacon.types\";\r\n\r\nconst notSupported = (): never => {\r\n  throw new Error(\"expo-beacon is not supported on web.\");\r\n};\r\n\r\nconst stub = {\r\n  scanForBeaconsAsync: (\r\n    _uuids: string[],\r\n    _scanDuration?: number,\r\n  ): Promise<BeaconScanResult[]> => notSupported(),\r\n  scanForEddystonesAsync: (\r\n    _scanDuration?: number,\r\n  ): Promise<EddystoneScanResult[]> => notSupported(),\r\n  pairBeacon: (\r\n    _identifier: string,\r\n    _uuid: string,\r\n    _major: number,\r\n    _minor: number,\r\n  ): void => notSupported(),\r\n  unpairBeacon: (_identifier: string): void => notSupported(),\r\n  getPairedBeacons: (): PairedBeacon[] => notSupported(),\r\n  pairEddystone: (\r\n    _identifier: string,\r\n    _namespace: string,\r\n    _instance: string,\r\n  ): void => notSupported(),\r\n  unpairEddystone: (_identifier: string): void => notSupported(),\r\n  getPairedEddystones: (): PairedEddystone[] => notSupported(),\r\n  startMonitoring: (): Promise<void> => notSupported(),\r\n  stopMonitoring: (): Promise<void> => notSupported(),\r\n  startContinuousScan: (): void => notSupported(),\r\n  stopContinuousScan: (): void => notSupported(),\r\n  cancelScan: (): void => notSupported(),\r\n  setNotificationConfig: (_config: Record<string, unknown>): void => notSupported(),\r\n  requestPermissionsAsync: (): Promise<boolean> => notSupported(),\r\n  enableEventLogging: (): void => notSupported(),\r\n  disableEventLogging: (): void => notSupported(),\r\n  getEventLogs: (_options?: EventLogQueryOptions): EventLogEntry[] => notSupported(),\r\n  clearEventLogs: (): void => notSupported(),\r\n  destroyEventLogs: (): void => notSupported(),\r\n  getMonitoringConfig: () => notSupported(),\r\n  getMonitoredDeviceState: (_identifier: string): MonitoredDeviceState | null => notSupported(),\r\n  getMonitoredDeviceStates: (): MonitoredDeviceState[] => notSupported(),\r\n  getApiEndpoint: (): { url: string | null; apiKey: string | null; id: string | null } => notSupported(),\r\n  isBatteryOptimizationExempt: (): boolean => true,\r\n  requestBatteryOptimizationExemption: (): Promise<boolean> => Promise.resolve(true),\r\n  startCarPlayMonitoring: (): Promise<void> => Promise.resolve(),\r\n  stopCarPlayMonitoring: (): Promise<void> => Promise.resolve(),\r\n  addListener: (_eventName: keyof ExpoBeaconModuleEvents, _listener: any) => ({\r\n    remove: () => {},\r\n  }),\r\n  removeAllListeners: (_eventName: keyof ExpoBeaconModuleEvents) => {},\r\n};\r\n\r\nexport default stub;\r\n"]}
+{"version":3,"file":"ExpoBeaconModule.web.js","sourceRoot":"","sources":["../src/ExpoBeaconModule.web.ts"],"names":[],"mappings":"AAWA,MAAM,YAAY,GAAG,GAAU,EAAE;IAC/B,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;AAC1D,CAAC,CAAC;AAEF,MAAM,IAAI,GAAG;IACX,mBAAmB,EAAE,CACnB,MAAgB,EAChB,aAAsB,EACO,EAAE,CAAC,YAAY,EAAE;IAChD,sBAAsB,EAAE,CACtB,aAAsB,EACU,EAAE,CAAC,YAAY,EAAE;IACnD,UAAU,EAAE,CACV,WAAmB,EACnB,KAAa,EACb,MAAc,EACd,MAAc,EACR,EAAE,CAAC,YAAY,EAAE;IACzB,YAAY,EAAE,CAAC,WAAmB,EAAQ,EAAE,CAAC,YAAY,EAAE;IAC3D,gBAAgB,EAAE,GAAmB,EAAE,CAAC,YAAY,EAAE;IACtD,aAAa,EAAE,CACb,WAAmB,EACnB,UAAkB,EAClB,SAAiB,EACX,EAAE,CAAC,YAAY,EAAE;IACzB,eAAe,EAAE,CAAC,WAAmB,EAAQ,EAAE,CAAC,YAAY,EAAE;IAC9D,mBAAmB,EAAE,GAAsB,EAAE,CAAC,YAAY,EAAE;IAC5D,eAAe,EAAE,GAAkB,EAAE,CAAC,YAAY,EAAE;IACpD,cAAc,EAAE,GAAkB,EAAE,CAAC,YAAY,EAAE;IACnD,mBAAmB,EAAE,GAAS,EAAE,CAAC,YAAY,EAAE;IAC/C,kBAAkB,EAAE,GAAS,EAAE,CAAC,YAAY,EAAE;IAC9C,UAAU,EAAE,GAAS,EAAE,CAAC,YAAY,EAAE;IACtC,qBAAqB,EAAE,CAAC,OAAgC,EAAQ,EAAE,CAAC,YAAY,EAAE;IACjF,uBAAuB,EAAE,GAAqB,EAAE,CAAC,YAAY,EAAE;IAC/D,kBAAkB,EAAE,GAAS,EAAE,CAAC,YAAY,EAAE;IAC9C,mBAAmB,EAAE,GAAS,EAAE,CAAC,YAAY,EAAE;IAC/C,qBAAqB,EAAE,GAAY,EAAE,CAAC,KAAK;IAC3C,YAAY,EAAE,CAAC,QAA+B,EAAmB,EAAE,CAAC,YAAY,EAAE;IAClF,cAAc,EAAE,GAAS,EAAE,CAAC,YAAY,EAAE;IAC1C,gBAAgB,EAAE,GAAS,EAAE,CAAC,YAAY,EAAE;IAC5C,mBAAmB,EAAE,GAAG,EAAE,CAAC,YAAY,EAAE;IACzC,uBAAuB,EAAE,CAAC,WAAmB,EAA+B,EAAE,CAAC,YAAY,EAAE;IAC7F,wBAAwB,EAAE,GAA2B,EAAE,CAAC,YAAY,EAAE;IACtE,cAAc,EAAE,GAAqE,EAAE,CAAC,YAAY,EAAE;IACtG,2BAA2B,EAAE,GAAY,EAAE,CAAC,IAAI;IAChD,mCAAmC,EAAE,GAAqB,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC;IAClF,sBAAsB,EAAE,GAAkB,EAAE,CAAC,OAAO,CAAC,OAAO,EAAE;IAC9D,qBAAqB,EAAE,GAAkB,EAAE,CAAC,OAAO,CAAC,OAAO,EAAE;IAC7D,0BAA0B,EAAE,GAAY,EAAE,CAAC,KAAK;IAChD,WAAW,EAAE,CAAC,UAAwC,EAAE,SAAc,EAAE,EAAE,CAAC,CAAC;QAC1E,MAAM,EAAE,GAAG,EAAE,GAAE,CAAC;KACjB,CAAC;IACF,kBAAkB,EAAE,CAAC,UAAwC,EAAE,EAAE,GAAE,CAAC;CACrE,CAAC;AAEF,eAAe,IAAI,CAAC","sourcesContent":["import type {\r\n  ExpoBeaconModuleEvents,\r\n  BeaconScanResult,\r\n  EddystoneScanResult,\r\n  PairedBeacon,\r\n  PairedEddystone,\r\n  MonitoredDeviceState,\r\n  EventLogQueryOptions,\r\n  EventLogEntry,\r\n} from \"./ExpoBeacon.types\";\r\n\r\nconst notSupported = (): never => {\r\n  throw new Error(\"expo-beacon is not supported on web.\");\r\n};\r\n\r\nconst stub = {\r\n  scanForBeaconsAsync: (\r\n    _uuids: string[],\r\n    _scanDuration?: number,\r\n  ): Promise<BeaconScanResult[]> => notSupported(),\r\n  scanForEddystonesAsync: (\r\n    _scanDuration?: number,\r\n  ): Promise<EddystoneScanResult[]> => notSupported(),\r\n  pairBeacon: (\r\n    _identifier: string,\r\n    _uuid: string,\r\n    _major: number,\r\n    _minor: number,\r\n  ): void => notSupported(),\r\n  unpairBeacon: (_identifier: string): void => notSupported(),\r\n  getPairedBeacons: (): PairedBeacon[] => notSupported(),\r\n  pairEddystone: (\r\n    _identifier: string,\r\n    _namespace: string,\r\n    _instance: string,\r\n  ): void => notSupported(),\r\n  unpairEddystone: (_identifier: string): void => notSupported(),\r\n  getPairedEddystones: (): PairedEddystone[] => notSupported(),\r\n  startMonitoring: (): Promise<void> => notSupported(),\r\n  stopMonitoring: (): Promise<void> => notSupported(),\r\n  startContinuousScan: (): void => notSupported(),\r\n  stopContinuousScan: (): void => notSupported(),\r\n  cancelScan: (): void => notSupported(),\r\n  setNotificationConfig: (_config: Record<string, unknown>): void => notSupported(),\r\n  requestPermissionsAsync: (): Promise<boolean> => notSupported(),\r\n  enableEventLogging: (): void => notSupported(),\r\n  disableEventLogging: (): void => notSupported(),\r\n  isEventLoggingEnabled: (): boolean => false,\r\n  getEventLogs: (_options?: EventLogQueryOptions): EventLogEntry[] => notSupported(),\r\n  clearEventLogs: (): void => notSupported(),\r\n  destroyEventLogs: (): void => notSupported(),\r\n  getMonitoringConfig: () => notSupported(),\r\n  getMonitoredDeviceState: (_identifier: string): MonitoredDeviceState | null => notSupported(),\r\n  getMonitoredDeviceStates: (): MonitoredDeviceState[] => notSupported(),\r\n  getApiEndpoint: (): { url: string | null; apiKey: string | null; id: string | null } => notSupported(),\r\n  isBatteryOptimizationExempt: (): boolean => true,\r\n  requestBatteryOptimizationExemption: (): Promise<boolean> => Promise.resolve(true),\r\n  startCarPlayMonitoring: (): Promise<void> => Promise.resolve(),\r\n  stopCarPlayMonitoring: (): Promise<void> => Promise.resolve(),\r\n  isCarPlayMonitoringEnabled: (): boolean => false,\r\n  addListener: (_eventName: keyof ExpoBeaconModuleEvents, _listener: any) => ({\r\n    remove: () => {},\r\n  }),\r\n  removeAllListeners: (_eventName: keyof ExpoBeaconModuleEvents) => {},\r\n};\r\n\r\nexport default stub;\r\n"]}

package/ios/CarPlayMonitor.swift

@@ -67,6 +67,27 @@ final class CarPlayMonitor {
         }
     }
 
+    /// Re-read the current audio route and emit a connect/disconnect event if
+    /// the state has changed since the last observed value. Cheap and idempotent;
+    /// safe to call from any background-wake hook (e.g. CLLocationManager region
+    /// callbacks) to reconcile CarPlay state changes that occurred while the app
+    /// was suspended and `AVAudioSession.routeChangeNotification` was not delivered.
+    func resyncIfNeeded() {
+        queue.async { [weak self] in
+            self?.handleRouteChange()
+        }
+    }
+
+    /// Whether `start(emit:)` has been called and `stop()` has not.
+    /// Use to decide whether to skip a redundant start during auto-start logic.
+    var isObserving: Bool {
+        // Synchronous read from main queue is safe — `observer` is only mutated on `queue`.
+        if Thread.isMainThread {
+            return observer != nil
+        }
+        return queue.sync { observer != nil }
+    }
+
     private func handleRouteChange() {
         let (connected, transport) = Self.currentCarPlayState()
         if connected == isConnected { return }

package/ios/ExpoBeaconModule.swift

@@ -14,6 +14,7 @@ private let EVENT_LOGGING_ENABLED_KEY = "expo.beacon.event_logging_enabled"
 private let MIN_RSSI_KEY = "expo.beacon.min_rssi"
 private let EVENT_LEVEL_KEY = "expo.beacon.event_level"
 private let EXIT_TIMEOUT_SECONDS_KEY = "expo.beacon.exit_timeout_seconds"
+private let CARPLAY_MONITORING_ENABLED_KEY = "expo.beacon.carplay_monitoring_enabled"
 
 /// Default minimum RSSI (dBm) below which beacon readings are discarded as unreliable.
 private let DEFAULT_MIN_RSSI: Int = -85
@@ -150,6 +151,14 @@ public class ExpoBeaconModule: Module {
 
         OnCreate {
             self.migrateUserDefaultsIfNeeded()
+            // If the user previously enabled CarPlay monitoring, restart it now —
+            // the module may have been recreated after the app was killed and
+            // background-launched (e.g. via a CLLocationManager region wake).
+            // Without this, CarPlay state changes that happened during suspension
+            // would be missed until JS calls startCarPlayMonitoring() again.
+            if self.defaults.bool(forKey: CARPLAY_MONITORING_ENABLED_KEY) {
+                self.startCarPlayMonitoringInternal()
+            }
         }
 
         Events("onBeaconEnter", "onBeaconExit", "onBeaconDistance", "onBeaconTimeout", "onBeaconFound", "onEddystoneFound", "onEddystoneEnter", "onEddystoneExit", "onEddystoneDistance", "onEddystoneTimeout", "onBeaconError", "onCarPlayConnected", "onCarPlayDisconnected")
@@ -432,6 +441,11 @@ public class ExpoBeaconModule: Module {
                 }
                 self.requestNotificationPermission()
                 self.startRegionMonitoring()
+                // Auto-enable CarPlay monitoring when beacon monitoring starts so
+                // CarPlay events are captured for the same lifetime as beacons.
+                // Users can opt out at any time via stopCarPlayMonitoring().
+                self.defaults.set(true, forKey: CARPLAY_MONITORING_ENABLED_KEY)
+                self.startCarPlayMonitoringInternal()
                 promise.resolve(nil)
             }
         }
@@ -458,17 +472,21 @@ public class ExpoBeaconModule: Module {
         // MARK: - CarPlay
 
         AsyncFunction("startCarPlayMonitoring") { (promise: Promise) in
-            CarPlayMonitor.shared.start { [weak self] eventName, payload in
-                self?.sendLoggedEvent(eventName, payload)
-            }
+            self.defaults.set(true, forKey: CARPLAY_MONITORING_ENABLED_KEY)
+            self.startCarPlayMonitoringInternal()
             promise.resolve(nil)
         }
 
         AsyncFunction("stopCarPlayMonitoring") { (promise: Promise) in
+            self.defaults.set(false, forKey: CARPLAY_MONITORING_ENABLED_KEY)
             CarPlayMonitor.shared.stop()
             promise.resolve(nil)
         }
 
+        Function("isCarPlayMonitoringEnabled") { () -> Bool in
+            return self.defaults.bool(forKey: CARPLAY_MONITORING_ENABLED_KEY)
+        }
+
         // MARK: - Continuous Scan
 
         Function("startContinuousScan") { () -> Void in
@@ -528,6 +546,10 @@ public class ExpoBeaconModule: Module {
             self.loggingEnabled = false
         }
 
+        Function("isEventLoggingEnabled") { () -> Bool in
+            return self.defaults.bool(forKey: EVENT_LOGGING_ENABLED_KEY)
+        }
+
         Function("getEventLogs") { (options: [String: Any]?) -> [[String: Any]] in
             let logger = self.getOrCreateEventLogger()
             let limit = (options?["limit"] as? Int) ?? 1000
@@ -613,7 +635,13 @@ public class ExpoBeaconModule: Module {
             self.eventLogger = nil
             self.stopRegionMonitoring()
             self.stopEddystoneMonitoring()
-            CarPlayMonitor.shared.stop()
+            // Only tear down CarPlay observation when the user has explicitly
+            // disabled it. Otherwise leave `CarPlayMonitor.shared` running so
+            // that route changes continue to be observed across module recreations
+            // (e.g. background-launch wake → module re-init → OnDestroy on suspend).
+            if !self.defaults.bool(forKey: CARPLAY_MONITORING_ENABLED_KEY) {
+                CarPlayMonitor.shared.stop()
+            }
             self.centralManager?.stopScan()
             self.centralManager = nil
             self.scanTimer?.cancel()
@@ -1080,6 +1108,16 @@ public class ExpoBeaconModule: Module {
         return distance
     }
 
+    /// Starts the shared `CarPlayMonitor` and routes its events through the
+    /// standard `sendLoggedEvent` pipeline (JS bridge + SQLite + API forwarder
+    /// + lifecycle plugin registry). Idempotent — safe to call multiple times
+    /// (see `CarPlayMonitor.start(emit:)` semantics).
+    private func startCarPlayMonitoringInternal() {
+        CarPlayMonitor.shared.start { [weak self] eventName, payload in
+            self?.sendLoggedEvent(eventName, payload)
+        }
+    }
+
     /// Sends an event to JS and logs it to SQLite if logging is enabled.
     private func sendLoggedEvent(_ eventName: String, _ params: [String: Any]) {
         if isEventLoggingEnabled() {
@@ -1739,12 +1777,22 @@ public class ExpoBeaconModule: Module {
     }
 
     fileprivate func handleDidEnterRegion(_ region: CLRegion) {
+        // CLLocationManager region events are one of the few iOS background-wake
+        // signals available to this app. Use this opportunity to reconcile
+        // CarPlay state in case it changed during suspension.
+        if defaults.bool(forKey: CARPLAY_MONITORING_ENABLED_KEY) {
+            CarPlayMonitor.shared.resyncIfNeeded()
+        }
         // Region callbacks are suppressed — all enter/exit logic goes through
         // ranging-based hysteresis in handleDidRange for consistent behaviour
         // with ENTER_HYSTERESIS_COUNT / EXIT_HYSTERESIS_COUNT, regardless of whether maxDistance is set.
     }
 
     fileprivate func handleDidExitRegion(_ region: CLRegion) {
+        // Reconcile CarPlay state on background wake — see handleDidEnterRegion.
+        if defaults.bool(forKey: CARPLAY_MONITORING_ENABLED_KEY) {
+            CarPlayMonitor.shared.resyncIfNeeded()
+        }
         guard let beaconRegion = region as? CLBeaconRegion else { return }
         let identifier = beaconRegion.identifier
 

package/package.json

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

package/src/ExpoBeaconModule.ts

@@ -144,6 +144,12 @@ declare class ExpoBeaconModule extends NativeModule<ExpoBeaconModuleEvents> {
   /** Disable event logging. Previously logged events are retained. */
   disableEventLogging(): void;
 
+  /**
+   * Returns whether SQLite event logging is currently enabled.
+   * Reads the persisted flag, so this stays accurate across app cold-starts.
+   */
+  isEventLoggingEnabled(): boolean;
+
   /**
    * Retrieve logged beacon events from the SQLite database.
    * @param options Optional filters (limit, eventType, sinceTimestamp).
@@ -198,7 +204,22 @@ declare class ExpoBeaconModule extends NativeModule<ExpoBeaconModuleEvents> {
    * endpoint, and dispatched to native lifecycle plugins (used by the auto-
    * generated geolocation plugin to start/stop background-geolocation).
    *
-   * Safe to call multiple times — subsequent calls are no-ops.
+   * **Persistent.** The enabled state is stored in native preferences and
+   * survives app kill / device reboot. Call `stopCarPlayMonitoring()` to
+   * disable. `startMonitoring()` also enables CarPlay observation
+   * automatically — calling this method explicitly is only required if you
+   * want CarPlay events without beacon monitoring.
+   *
+   * **Background behavior:**
+   * - **Android**: the foreground service hosts the observer and continues to
+   *   receive `CarConnection` events even after the app process is killed and
+   *   restarted via `BootReceiver`. Guaranteed background detection.
+   * - **iOS**: the observer auto-restarts in `OnCreate` whenever the module
+   *   is recreated, including background-launches triggered by beacon region
+   *   monitoring. **iOS cannot wake a terminated app on CarPlay alone** — for
+   *   guaranteed wake-from-suspension, also call `startMonitoring()` with at
+   *   least one paired beacon. Region wake events trigger a CarPlay state
+   *   resync to reconcile any route changes that occurred during suspension.
    *
    * - iOS: observes `AVAudioSession.routeChangeNotification` for `.carAudio` ports.
    *   No CarPlay entitlement required.
@@ -208,8 +229,22 @@ declare class ExpoBeaconModule extends NativeModule<ExpoBeaconModuleEvents> {
    */
   startCarPlayMonitoring(): Promise<void>;
 
-  /** Stop CarPlay / Android Auto connection monitoring started by `startCarPlayMonitoring()`. */
+  /**
+   * Stop CarPlay / Android Auto connection monitoring and clear the persisted
+   * "enabled" flag so the observer is not auto-restarted on next launch / boot.
+   *
+   * On Android, if no beacon monitoring is active, the foreground service
+   * stops itself.
+   */
   stopCarPlayMonitoring(): Promise<void>;
+
+  /**
+   * Returns whether CarPlay / Android Auto observation is currently enabled.
+   * Reads the persisted flag, so the value survives app cold-starts and
+   * reflects the native source of truth (foreground service on Android,
+   * UserDefaults suite on iOS).
+   */
+  isCarPlayMonitoringEnabled(): boolean;
 }
 
 export default requireNativeModule<ExpoBeaconModule>("ExpoBeacon");

package/src/ExpoBeaconModule.web.ts

@@ -45,6 +45,7 @@ const stub = {
   requestPermissionsAsync: (): Promise<boolean> => notSupported(),
   enableEventLogging: (): void => notSupported(),
   disableEventLogging: (): void => notSupported(),
+  isEventLoggingEnabled: (): boolean => false,
   getEventLogs: (_options?: EventLogQueryOptions): EventLogEntry[] => notSupported(),
   clearEventLogs: (): void => notSupported(),
   destroyEventLogs: (): void => notSupported(),
@@ -56,6 +57,7 @@ const stub = {
   requestBatteryOptimizationExemption: (): Promise<boolean> => Promise.resolve(true),
   startCarPlayMonitoring: (): Promise<void> => Promise.resolve(),
   stopCarPlayMonitoring: (): Promise<void> => Promise.resolve(),
+  isCarPlayMonitoringEnabled: (): boolean => false,
   addListener: (_eventName: keyof ExpoBeaconModuleEvents, _listener: any) => ({
     remove: () => {},
   }),