expo-beacon 0.10.1 → 0.10.2

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

@@ -12,9 +12,9 @@ import android.os.Looper
 import android.os.RemoteException
 import android.os.SystemClock
 import android.util.Log
-import java.util.concurrent.atomic.AtomicInteger
 import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
+import java.util.concurrent.atomic.AtomicInteger
 import org.altbeacon.beacon.*
 import org.json.JSONArray
 
@@ -22,26 +22,22 @@ private const val CHANNEL_ID = "expo_beacon_channel"
 private const val CARPLAY_CHANNEL_ID = "expo_beacon_carplay_channel"
 internal const val FOREGROUND_NOTIF_ID = 1001
 /**
- * Base ID for per-beacon enter/exit notifications; incremented per unique region.
- * With FOREGROUND_NOTIF_ID at 1001, this allows up to 999 unique regions
- * before ID collision. Sufficient for real-world beacon deployments.
+ * Base ID for per-beacon enter/exit notifications; incremented per unique region. With
+ * FOREGROUND_NOTIF_ID at 1001, this allows up to 999 unique regions before ID collision. Sufficient
+ * for real-world beacon deployments.
  */
 private const val ENTER_EXIT_NOTIF_BASE_ID = 2000
 /**
- * Fixed notification IDs for CarPlay connect / disconnect events. Each event
- * type uses a single ID so repeated events of the same type replace the prior
- * notification rather than stacking, while connect and disconnect remain
- * independently visible.
+ * Fixed notification IDs for CarPlay connect / disconnect events. Each event type uses a single ID
+ * so repeated events of the same type replace the prior notification rather than stacking, while
+ * connect and disconnect remain independently visible.
  */
 private const val CARPLAY_CONNECTED_NOTIF_ID = 3000
 private const val CARPLAY_DISCONNECTED_NOTIF_ID = 3001
 
 class BeaconForegroundService : Service(), BeaconConsumer {
 
-    data class MonitoringRuntimeState(
-        val isEntered: Boolean,
-        val distance: Double?
-    )
+    data class MonitoringRuntimeState(val isEntered: Boolean, val distance: Double?)
 
     private lateinit var beaconManager: BeaconManager
     private val monitoredRegions = mutableListOf<Region>()
@@ -109,14 +105,19 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         ensureNotificationChannel(this)
         ensureCarPlayNotificationChannel(this)
         apiForwarder = BeaconApiForwarder(this)
-        beaconManager = BeaconManager.getInstanceForApplication(this).also { manager ->
-            BeaconParsers.ensureRegistered(manager)
-            try { manager.setEnableScheduledScanJobs(false) } catch (e: IllegalStateException) { Log.w(TAG, "setEnableScheduledScanJobs failed", e) }
-            manager.setBackgroundBetweenScanPeriod(MONITORING_BETWEEN_SCAN_PERIOD_MS)
-            manager.setBackgroundScanPeriod(MONITORING_SCAN_PERIOD_MS)
-            manager.setForegroundScanPeriod(MONITORING_SCAN_PERIOD_MS)
-            manager.setForegroundBetweenScanPeriod(MONITORING_BETWEEN_SCAN_PERIOD_MS)
-        }
+        beaconManager =
+                BeaconManager.getInstanceForApplication(this).also { manager ->
+                    BeaconParsers.ensureRegistered(manager)
+                    try {
+                        manager.setEnableScheduledScanJobs(false)
+                    } catch (e: IllegalStateException) {
+                        Log.w(TAG, "setEnableScheduledScanJobs failed", e)
+                    }
+                    manager.setBackgroundBetweenScanPeriod(MONITORING_BETWEEN_SCAN_PERIOD_MS)
+                    manager.setBackgroundScanPeriod(MONITORING_SCAN_PERIOD_MS)
+                    manager.setForegroundScanPeriod(MONITORING_SCAN_PERIOD_MS)
+                    manager.setForegroundBetweenScanPeriod(MONITORING_BETWEEN_SCAN_PERIOD_MS)
+                }
         // Increase AltBeacon's region exit period so didExitRegion doesn't fire
         // prematurely during brief BLE scan gaps.
         BeaconManager.setRegionExitPeriod(REGION_EXIT_PERIOD_MS)
@@ -145,9 +146,9 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         try {
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
                 startForeground(
-                    FOREGROUND_NOTIF_ID,
-                    buildForegroundNotification(),
-                    ServiceInfo.FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE
+                        FOREGROUND_NOTIF_ID,
+                        buildForegroundNotification(),
+                        ServiceInfo.FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE
                 )
             } else {
                 startForeground(FOREGROUND_NOTIF_ID, buildForegroundNotification())
@@ -158,14 +159,19 @@ class BeaconForegroundService : Service(), BeaconConsumer {
             // if the service start window was missed (e.g. BT not yet initialized at boot).
             val retryCount = intent?.getIntExtra(EXTRA_RETRY_COUNT, 0) ?: 0
             Log.e(TAG, "startForeground failed (retry=$retryCount) — stopping service", e)
-            sendErrorBroadcast(null, "SERVICE_START_FAILED", "startForeground failed (retry=$retryCount): ${e.message}")
+            sendErrorBroadcast(
+                    null,
+                    "SERVICE_START_FAILED",
+                    "startForeground failed (retry=$retryCount): ${e.message}"
+            )
             // Schedule a retry so monitoring can recover without user interaction, capped to
             // avoid infinite crash loops. Retry if EITHER beacon monitoring OR CarPlay
             // observation is supposed to be active — without the CarPlay branch the
             // service silently dies when the very first startCarPlayMonitoring() call
             // races with a transient BT permission / FGS-restriction failure.
             if (retryCount < MAX_STARTFOREGROUND_RETRIES &&
-                (isMonitoringActive(this) || isCarPlayEnabled(this))) {
+                            (isMonitoringActive(this) || isCarPlayEnabled(this))
+            ) {
                 scheduleServiceRetry(retryCount + 1)
             }
             stopSelf()
@@ -211,36 +217,40 @@ class BeaconForegroundService : Service(), BeaconConsumer {
     }
 
     /**
-     * Schedules a one-shot alarm to restart this service via startForegroundService().
-     * Used when startForeground() fails transiently (e.g. BT not yet ready at boot).
+     * Schedules a one-shot alarm to restart this service via startForegroundService(). Used when
+     * startForeground() fails transiently (e.g. BT not yet ready at boot).
      */
     private fun scheduleServiceRetry(retryCount: Int) {
         val alarmManager = getSystemService(AlarmManager::class.java) ?: return
-        val retryIntent = Intent(this, BeaconForegroundService::class.java)
-            .putExtra(EXTRA_RETRY_COUNT, retryCount)
-        val pendingIntent = PendingIntent.getService(
-            this,
-            RETRY_SERVICE_REQUEST_CODE,
-            retryIntent,
-            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
-        )
+        val retryIntent =
+                Intent(this, BeaconForegroundService::class.java)
+                        .putExtra(EXTRA_RETRY_COUNT, retryCount)
+        val pendingIntent =
+                PendingIntent.getService(
+                        this,
+                        RETRY_SERVICE_REQUEST_CODE,
+                        retryIntent,
+                        PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+                )
         alarmManager.setExactAndAllowWhileIdle(
-            AlarmManager.ELAPSED_REALTIME_WAKEUP,
-            SystemClock.elapsedRealtime() + RETRY_DELAY_MS,
-            pendingIntent
+                AlarmManager.ELAPSED_REALTIME_WAKEUP,
+                SystemClock.elapsedRealtime() + RETRY_DELAY_MS,
+                pendingIntent
         )
         Log.w(TAG, "startForeground retry $retryCount scheduled in ${RETRY_DELAY_MS}ms")
     }
 
     /**
-     * Called by the system on Android 14+ (API 34) if a foreground service with a time-limited
-     * type exceeds its allowed duration. connectedDevice has no documented time limit as of
-     * Android 17, but this override ensures we handle a future limit gracefully rather than
-     * receiving an ANR.
+     * Called by the system on Android 14+ (API 34) if a foreground service with a time-limited type
+     * exceeds its allowed duration. connectedDevice has no documented time limit as of Android 17,
+     * but this override ensures we handle a future limit gracefully rather than receiving an ANR.
      */
     @Suppress("NewApi")
     override fun onTimeout(startId: Int, fgsType: Int) {
-        Log.w(TAG, "BeaconForegroundService.onTimeout(startId=$startId, fgsType=$fgsType) — scheduling restart")
+        Log.w(
+                TAG,
+                "BeaconForegroundService.onTimeout(startId=$startId, fgsType=$fgsType) — scheduling restart"
+        )
         if (isMonitoringActive(this)) {
             scheduleServiceRetry(0)
         }
@@ -251,7 +261,9 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         if (!isMonitoringActive(this)) {
             // stopMonitoring() raced the AltBeacon bind — drop the connection
             // instead of arming regions that were just disabled.
-            try { beaconManager.unbind(this) } catch (_: Throwable) {}
+            try {
+                beaconManager.unbind(this)
+            } catch (_: Throwable) {}
             return
         }
         serviceConnected = true
@@ -262,8 +274,8 @@ class BeaconForegroundService : Service(), BeaconConsumer {
     }
 
     /**
-     * (Re-)read monitoring options from prefs. Called on every region load so a
-     * second startMonitoring on a live bound service picks up new options.
+     * (Re-)read monitoring options from prefs. Called on every region load so a second
+     * startMonitoring on a live bound service picks up new options.
      */
     private fun applyMonitoringOptions() {
         val optPrefs = getSharedPreferences(MONITORING_OPTIONS_PREFS, Context.MODE_PRIVATE)
@@ -271,7 +283,9 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         exitDistance = optPrefs.getString(MONITORING_OPT_EXIT_DISTANCE, null)?.toDoubleOrNull()
         minRssiThreshold = optPrefs.getInt(MONITORING_OPT_MIN_RSSI, DEFAULT_MIN_RSSI)
         eventLevel = optPrefs.getString(MONITORING_OPT_LEVEL, "all") ?: "all"
-        exitTimeoutMs = ((optPrefs.getString(MONITORING_OPT_EXIT_TIMEOUT_SECONDS, null)?.toDoubleOrNull() ?: DEFAULT_EXIT_TIMEOUT_SECONDS) * 1000.0).toLong()
+        exitTimeoutMs =
+                ((optPrefs.getString(MONITORING_OPT_EXIT_TIMEOUT_SECONDS, null)?.toDoubleOrNull()
+                                ?: DEFAULT_EXIT_TIMEOUT_SECONDS) * 1000.0).toLong()
     }
 
     private fun loadAndMonitorRegions() {
@@ -282,12 +296,18 @@ class BeaconForegroundService : Service(), BeaconConsumer {
             // Trailing-edge re-run so a debounced call is deferred, not dropped.
             if (!pendingLoadRegions) {
                 pendingLoadRegions = true
-                timeoutHandler.postDelayed({
-                    pendingLoadRegions = false
-                    loadAndMonitorRegions()
-                }, LOAD_REGIONS_DEBOUNCE_MS - elapsed)
+                timeoutHandler.postDelayed(
+                        {
+                            pendingLoadRegions = false
+                            loadAndMonitorRegions()
+                        },
+                        LOAD_REGIONS_DEBOUNCE_MS - elapsed
+                )
             }
-            Log.d(TAG, "loadAndMonitorRegions: debounced (${elapsed}ms after last load) — re-running on trailing edge")
+            Log.d(
+                    TAG,
+                    "loadAndMonitorRegions: debounced (${elapsed}ms after last load) — re-running on trailing edge"
+            )
             return
         }
         lastLoadRegionsMs = now
@@ -295,12 +315,23 @@ class BeaconForegroundService : Service(), BeaconConsumer {
 
         val prefs: SharedPreferences = getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
         val json = prefs.getString(PREFS_KEY, "[]") ?: "[]"
-        val beacons = try { JSONArray(json) } catch (_: Exception) { JSONArray() }
+        val beacons =
+                try {
+                    JSONArray(json)
+                } catch (_: Exception) {
+                    JSONArray()
+                }
 
         // Load paired Eddystones
-        val eddystonePrefs: SharedPreferences = getSharedPreferences(EDDYSTONE_PREFS_NAME, Context.MODE_PRIVATE)
+        val eddystonePrefs: SharedPreferences =
+                getSharedPreferences(EDDYSTONE_PREFS_NAME, Context.MODE_PRIVATE)
         val eddystoneJson = eddystonePrefs.getString(EDDYSTONE_PREFS_KEY, "[]") ?: "[]"
-        val eddystones = try { JSONArray(eddystoneJson) } catch (_: Exception) { JSONArray() }
+        val eddystones =
+                try {
+                    JSONArray(eddystoneJson)
+                } catch (_: Exception) {
+                    JSONArray()
+                }
 
         // Build timeout lookup from paired beacon data
         beaconTimeouts.clear()
@@ -323,15 +354,18 @@ class BeaconForegroundService : Service(), BeaconConsumer {
 
         // Stop previous regions and distance-log ranging
         distanceLogRegions.forEach {
-            try { beaconManager.stopRangingBeaconsInRegion(it) } catch (_: RemoteException) {}
+            try {
+                beaconManager.stopRangingBeaconsInRegion(it)
+            } catch (_: RemoteException) {}
         }
         distanceLogRegions.clear()
         monitoredRegions.forEach {
-            try { beaconManager.stopMonitoringBeaconsInRegion(it) } catch (_: RemoteException) {}
+            try {
+                beaconManager.stopMonitoringBeaconsInRegion(it)
+            } catch (_: RemoteException) {}
         }
         monitoredRegions.clear()
         monitoredRegionIds.clear()
-        lastSeenAtMs.clear()
         timeoutHandler.removeCallbacksAndMessages(null)
         timeoutRunnables.clear()
         inactivityRunnables.clear()
@@ -351,24 +385,37 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         // iBeacon regions
         for (i in 0 until beacons.length()) {
             val b = beacons.getJSONObject(i)
-            val region = Region(
-                b.getString("identifier"),
-                Identifier.parse(b.getString("uuid")),
-                Identifier.fromInt(b.getInt("major")),
-                Identifier.fromInt(b.getInt("minor"))
-            )
+            val region =
+                    Region(
+                            b.getString("identifier"),
+                            Identifier.parse(b.getString("uuid")),
+                            Identifier.fromInt(b.getInt("major")),
+                            Identifier.fromInt(b.getInt("minor"))
+                    )
             monitoredRegions.add(region)
             monitoredRegionIds.add(region.uniqueId)
             try {
                 beaconManager.startMonitoringBeaconsInRegion(region)
             } catch (e: RemoteException) {
                 Log.e(TAG, "Failed to start monitoring iBeacon region ${region.uniqueId}", e)
-                sendErrorBroadcast(region.uniqueId, "MONITORING_FAILED", "Failed to start monitoring iBeacon region ${region.uniqueId}")
+                sendErrorBroadcast(
+                        region.uniqueId,
+                        "MONITORING_FAILED",
+                        "Failed to start monitoring iBeacon region ${region.uniqueId}"
+                )
             } catch (e: SecurityException) {
                 // Android 17+ may throw SecurityException if BLUETOOTH_SCAN/CONNECT were
                 // not held at the exact moment monitoring starts.
-                Log.e(TAG, "Security exception starting monitoring for ${region.uniqueId} — check BT permissions", e)
-                sendErrorBroadcast(region.uniqueId, "SECURITY_EXCEPTION", "Security exception starting monitoring for ${region.uniqueId} — check BT permissions")
+                Log.e(
+                        TAG,
+                        "Security exception starting monitoring for ${region.uniqueId} — check BT permissions",
+                        e
+                )
+                sendErrorBroadcast(
+                        region.uniqueId,
+                        "SECURITY_EXCEPTION",
+                        "Security exception starting monitoring for ${region.uniqueId} — check BT permissions"
+                )
             }
             // Start ranging this region for distance logging
             if (distanceLogRegions.add(region)) {
@@ -377,11 +424,23 @@ class BeaconForegroundService : Service(), BeaconConsumer {
                 } catch (e: RemoteException) {
                     distanceLogRegions.remove(region)
                     Log.e(TAG, "Failed to start ranging iBeacon region ${region.uniqueId}", e)
-                    sendErrorBroadcast(region.uniqueId, "RANGING_FAILED", "Failed to start ranging iBeacon region ${region.uniqueId}")
+                    sendErrorBroadcast(
+                            region.uniqueId,
+                            "RANGING_FAILED",
+                            "Failed to start ranging iBeacon region ${region.uniqueId}"
+                    )
                 } catch (e: SecurityException) {
                     distanceLogRegions.remove(region)
-                    Log.e(TAG, "Security exception starting ranging for ${region.uniqueId} — check BT permissions", e)
-                    sendErrorBroadcast(region.uniqueId, "SECURITY_EXCEPTION", "Security exception starting ranging for ${region.uniqueId} — check BT permissions")
+                    Log.e(
+                            TAG,
+                            "Security exception starting ranging for ${region.uniqueId} — check BT permissions",
+                            e
+                    )
+                    sendErrorBroadcast(
+                            region.uniqueId,
+                            "SECURITY_EXCEPTION",
+                            "Security exception starting ranging for ${region.uniqueId} — check BT permissions"
+                    )
                 }
             }
         }
@@ -392,22 +451,35 @@ class BeaconForegroundService : Service(), BeaconConsumer {
             val identifier = e.getString("identifier")
             val namespace = e.getString("namespace")
             val instance = e.getString("instance")
-            val region = Region(
-                identifier,
-                Identifier.parse("0x$namespace"),
-                Identifier.parse("0x$instance"),
-                null
-            )
+            val region =
+                    Region(
+                            identifier,
+                            Identifier.parse("0x$namespace"),
+                            Identifier.parse("0x$instance"),
+                            null
+                    )
             monitoredRegions.add(region)
             monitoredRegionIds.add(region.uniqueId)
             try {
                 beaconManager.startMonitoringBeaconsInRegion(region)
             } catch (ex: RemoteException) {
                 Log.e(TAG, "Failed to start monitoring Eddystone region $identifier", ex)
-                sendErrorBroadcast(identifier, "MONITORING_FAILED", "Failed to start monitoring Eddystone region $identifier")
+                sendErrorBroadcast(
+                        identifier,
+                        "MONITORING_FAILED",
+                        "Failed to start monitoring Eddystone region $identifier"
+                )
             } catch (ex: SecurityException) {
-                Log.e(TAG, "Security exception starting monitoring for Eddystone $identifier — check BT permissions", ex)
-                sendErrorBroadcast(identifier, "SECURITY_EXCEPTION", "Security exception starting monitoring for Eddystone $identifier — check BT permissions")
+                Log.e(
+                        TAG,
+                        "Security exception starting monitoring for Eddystone $identifier — check BT permissions",
+                        ex
+                )
+                sendErrorBroadcast(
+                        identifier,
+                        "SECURITY_EXCEPTION",
+                        "Security exception starting monitoring for Eddystone $identifier — check BT permissions"
+                )
             }
             if (distanceLogRegions.add(region)) {
                 try {
@@ -415,15 +487,29 @@ class BeaconForegroundService : Service(), BeaconConsumer {
                 } catch (ex: RemoteException) {
                     distanceLogRegions.remove(region)
                     Log.e(TAG, "Failed to start ranging Eddystone region $identifier", ex)
-                    sendErrorBroadcast(identifier, "RANGING_FAILED", "Failed to start ranging Eddystone region $identifier")
+                    sendErrorBroadcast(
+                            identifier,
+                            "RANGING_FAILED",
+                            "Failed to start ranging Eddystone region $identifier"
+                    )
                 } catch (ex: SecurityException) {
                     distanceLogRegions.remove(region)
-                    Log.e(TAG, "Security exception starting ranging for Eddystone $identifier — check BT permissions", ex)
-                    sendErrorBroadcast(identifier, "SECURITY_EXCEPTION", "Security exception starting ranging for Eddystone $identifier — check BT permissions")
+                    Log.e(
+                            TAG,
+                            "Security exception starting ranging for Eddystone $identifier — check BT permissions",
+                            ex
+                    )
+                    sendErrorBroadcast(
+                            identifier,
+                            "SECURITY_EXCEPTION",
+                            "Security exception starting ranging for Eddystone $identifier — check BT permissions"
+                    )
                 }
             }
         }
 
+        lastSeenAtMs.keys.retainAll(monitoredRegionIds)
+
         // If no regions to monitor, stop the service to avoid idling
         if (monitoredRegions.isEmpty()) {
             enteredRegions.clear()
@@ -439,7 +525,10 @@ class BeaconForegroundService : Service(), BeaconConsumer {
     private val distanceLoggingRangeNotifier = RangeNotifier { beacons, region ->
         if (eventLevel != "all") return@RangeNotifier
         if (!monitoredRegionIds.contains(region.uniqueId)) return@RangeNotifier
-        val closest = beacons.filter { it.distance >= 0 && it.rssi >= minRssiThreshold }.minByOrNull { it.distance }
+        val closest =
+                beacons.filter { it.distance >= 0 && it.rssi >= minRssiThreshold }.minByOrNull {
+                    it.distance
+                }
         if (closest != null) {
             lastSeenAtMs[region.uniqueId] = SystemClock.elapsedRealtime()
             // Valid BLE reading — reset inactivity timer.
@@ -448,42 +537,48 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         }
     }
 
-    private val monitorNotifier = object : MonitorNotifier {
-        override fun didEnterRegion(region: Region) {
-            // Enter is synthesized from ranging so distance and enter/exit stay in sync.
-        }
+    private val monitorNotifier =
+            object : MonitorNotifier {
+                override fun didEnterRegion(region: Region) {
+                    // Enter is synthesized from ranging so distance and enter/exit stay in sync.
+                }
 
-        override fun didExitRegion(region: Region) {
-            if (!monitoredRegionIds.contains(region.uniqueId)) return
-            if (wasSeenRecently(region.uniqueId)) {
-                Log.d(TAG, "Ignoring stale didExitRegion for ${region.uniqueId}; beacon was seen by ranging recently")
-                return
-            }
+                override fun didExitRegion(region: Region) {
+                    if (!monitoredRegionIds.contains(region.uniqueId)) return
+                    if (wasSeenRecently(region.uniqueId)) {
+                        Log.d(
+                                TAG,
+                                "Ignoring stale didExitRegion for ${region.uniqueId}; beacon was seen by ranging recently"
+                        )
+                        return
+                    }
 
-            lastSeenAtMs.remove(region.uniqueId)
+                    lastSeenAtMs.remove(region.uniqueId)
 
-            // Ranging-based hysteresis handles exit in the normal case. If the OS
-            // fires didExitRegion after ranging has already stopped, emit exit as a
-            // safety net only if the region was previously in the entered state.
-            val wasEntered = enteredRegions.remove(region.uniqueId)
-            synchronized(distanceLock) {
-                enterCounters.remove(region.uniqueId)
-                exitCounters.remove(region.uniqueId)
-                missCounters.remove(region.uniqueId)
-            }
-            if (wasEntered) {
-                sendBeaconBroadcast(region, "exit", -1.0)
-                showEnterExitNotification(region, "exit")
-                // OS-level exit safety net — cancel inactivity timer and start the timeout clock.
-                cancelInactivity(region.uniqueId)
-                scheduleTimeoutIfConfigured(region)
-            }
-        }
+                    // Ranging-based hysteresis handles exit in the normal case. If the OS
+                    // fires didExitRegion after ranging has already stopped, emit exit as a
+                    // safety net only if the region was previously in the entered state.
+                    val wasEntered = enteredRegions.remove(region.uniqueId)
+                    synchronized(distanceLock) {
+                        enterCounters.remove(region.uniqueId)
+                        exitCounters.remove(region.uniqueId)
+                        missCounters.remove(region.uniqueId)
+                    }
+                    if (wasEntered) {
+                        synchronized(distanceLock) { smoothedDistances.remove(region.uniqueId) }
+                        sendBeaconBroadcast(region, "exit", -1.0)
+                        showEnterExitNotification(region, "exit")
+                        // OS-level exit safety net — cancel inactivity timer and start the timeout
+                        // clock.
+                        cancelInactivity(region.uniqueId)
+                        scheduleTimeoutIfConfigured(region)
+                    }
+                }
 
-        override fun didDetermineStateForRegion(state: Int, region: Region) {
-            // Intentionally empty — enter/exit handled by didEnterRegion/didExitRegion.
-        }
-    }
+                override fun didDetermineStateForRegion(state: Int, region: Region) {
+                    // Intentionally empty — enter/exit handled by didEnterRegion/didExitRegion.
+                }
+            }
 
     // Single source of truth for distance-based enter/exit with hysteresis.
     // Processes only actual monitoring regions and handles exit via miss counting
@@ -494,9 +589,10 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         val maxDist = maxDistance
         if (!monitoredRegionIds.contains(region.uniqueId)) return@RangeNotifier
 
-        val beacon = beacons
-            .filter { it.distance >= 0 && it.rssi >= minRssiThreshold }
-            .minByOrNull { it.distance }
+        val beacon =
+                beacons.filter { it.distance >= 0 && it.rssi >= minRssiThreshold }.minByOrNull {
+                    it.distance
+                }
 
         // Pending transition to emit after the lock is released: (eventType, distance, rssi).
         var pendingEvent: Triple<String, Double, Int>? = null
@@ -518,6 +614,7 @@ class BeaconForegroundService : Service(), BeaconConsumer {
                     }
                     HysteresisAction.EXIT -> {
                         enteredRegions.remove(region.uniqueId)
+                        smoothedDistances.remove(region.uniqueId)
                         pendingEvent = Triple("exit", beacon.distance, beacon.rssi)
                     }
                     HysteresisAction.NONE -> {}
@@ -528,7 +625,8 @@ class BeaconForegroundService : Service(), BeaconConsumer {
                 // On Android 17+ (API 37) the BLE scan callbacks are more intermittent: valid
                 // readings are interspersed with occasional null cycles even when the beacon is
                 // nearby. Resetting direction counters on every null would prevent the hysteresis
-                // from ever accumulating to ENTER_HYSTERESIS_COUNT, breaking enter/exit entirely while
+                // from ever accumulating to ENTER_HYSTERESIS_COUNT, breaking enter/exit entirely
+                // while
                 // still allowing distance events (which fire on each individual valid reading).
                 // Direction counters are reset by evaluateDistanceHysteresis when a valid reading
                 // contradicts the current direction (e.g., in-range reading resets exitCounters).
@@ -536,12 +634,15 @@ class BeaconForegroundService : Service(), BeaconConsumer {
                 missCounters[region.uniqueId] = count
 
                 val lastSeen = lastSeenAtMs[region.uniqueId]
-                val silentMs = if (lastSeen != null) SystemClock.elapsedRealtime() - lastSeen else Long.MAX_VALUE
+                val silentMs =
+                        if (lastSeen != null) SystemClock.elapsedRealtime() - lastSeen
+                        else Long.MAX_VALUE
                 if (enteredRegions.contains(region.uniqueId) && silentMs >= exitTimeoutMs) {
                     enteredRegions.remove(region.uniqueId)
                     missCounters[region.uniqueId] = 0
                     enterCounters[region.uniqueId] = 0
                     exitCounters[region.uniqueId] = 0
+                    smoothedDistances.remove(region.uniqueId)
                     pendingEvent = Triple("exit", -1.0, 0)
                 }
             }
@@ -563,14 +664,18 @@ class BeaconForegroundService : Service(), BeaconConsumer {
 
     // MARK: - Distance-based enter/exit hysteresis
 
-    private enum class HysteresisAction { NONE, ENTER, EXIT }
+    private enum class HysteresisAction {
+        NONE,
+        ENTER,
+        EXIT
+    }
 
     /**
-     * Apply exponential moving average (EMA) smoothing to a raw distance reading.
-     * If the reading is a large jump (> DISTANCE_JUMP_FACTOR), resets the EMA to the new
-     * value instead of rejecting it — this ensures the hysteresis pipeline keeps receiving
-     * data and can fire exit events when the user moves away from a beacon, rather than
-     * freezing because the EMA is stuck at the old close-range value.
+     * Apply exponential moving average (EMA) smoothing to a raw distance reading. If the reading is
+     * a large jump (> DISTANCE_JUMP_FACTOR), resets the EMA to the new value instead of rejecting
+     * it — this ensures the hysteresis pipeline keeps receiving data and can fire exit events when
+     * the user moves away from a beacon, rather than freezing because the EMA is stuck at the old
+     * close-range value.
      */
     private fun smoothDistance(regionId: String, rawDistance: Double): Double {
         val prev = smoothedDistances[regionId]
@@ -595,19 +700,20 @@ class BeaconForegroundService : Service(), BeaconConsumer {
      * Default: maxDistance + min(maxDistance × 0.5, 2.5).
      */
     private fun effectiveExitDistance(maxDist: Double): Double {
-        exitDistance?.let { return it }
+        exitDistance?.let {
+            return it
+        }
         return maxDist + minOf(maxDist * 0.5, 2.5)
     }
 
     /**
-     * Evaluate distance-based enter/exit with hysteresis counters.
-     * Must be called within synchronized(distanceLock).
-     * Mirrors [ExpoBeaconModule.swift evaluateDistanceHysteresis].
+     * Evaluate distance-based enter/exit with hysteresis counters. Must be called within
+     * synchronized(distanceLock). Mirrors [ExpoBeaconModule.swift evaluateDistanceHysteresis].
      */
     private fun evaluateDistanceHysteresis(
-        regionId: String,
-        distance: Double,
-        maxDist: Double?
+            regionId: String,
+            distance: Double,
+            maxDist: Double?
     ): HysteresisAction {
         if (maxDist == null) {
             exitCounters[regionId] = 0
@@ -694,7 +800,12 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         inactivityRunnables.remove(regionId)?.let { timeoutHandler.removeCallbacks(it) }
     }
 
-    private fun sendBeaconBroadcast(region: Region, eventType: String, distance: Double, rssi: Int = 0) {
+    private fun sendBeaconBroadcast(
+            region: Region,
+            eventType: String,
+            distance: Double,
+            rssi: Int = 0
+    ) {
         // Determine if this is an Eddystone region based on identifier format
         // Eddystone regions have id1 as a hex namespace (not a UUID)
         val id1Str = region.id1?.toString() ?: ""
@@ -704,20 +815,21 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         // Single payload shared by the SQLite log, the API forwarder, and the
         // JS broadcast. "event" is part of the public payload for enter/exit
         // only — distance and timeout omit it (matches the TS types and iOS).
-        val params = buildMap<String, Any?> {
-            put("identifier", region.uniqueId)
-            if (isEddystone) {
-                put("namespace", id1Str.removePrefix("0x"))
-                put("instance", region.id2?.toString()?.removePrefix("0x") ?: "")
-            } else {
-                put("uuid", id1Str.uppercase())
-                put("major", region.id2?.toInt() ?: 0)
-                put("minor", region.id3?.toInt() ?: 0)
-            }
-            if (eventType == "enter" || eventType == "exit") put("event", eventType)
-            put("distance", distance)
-            put("rssi", rssi)
-        }
+        val params =
+                buildMap<String, Any?> {
+                    put("identifier", region.uniqueId)
+                    if (isEddystone) {
+                        put("namespace", id1Str.removePrefix("0x"))
+                        put("instance", region.id2?.toString()?.removePrefix("0x") ?: "")
+                    } else {
+                        put("uuid", id1Str.uppercase())
+                        put("major", region.id2?.toInt() ?: 0)
+                        put("minor", region.id3?.toInt() ?: 0)
+                    }
+                    if (eventType == "enter" || eventType == "exit") put("event", eventType)
+                    put("distance", distance)
+                    put("rssi", rssi)
+                }
         logBeaconEvent(eventName, params)
 
         // Forward all produced events to remote API
@@ -732,9 +844,39 @@ class BeaconForegroundService : Service(), BeaconConsumer {
             val namespace = if (isEddystone) id1Str.removePrefix("0x") else ""
             val instance = if (isEddystone) region.id2?.toString()?.removePrefix("0x") ?: "" else ""
             when (eventType) {
-                "enter" -> BeaconPluginRegistry.dispatchEnter(isEddystone, identifier, uuid, major, minor, namespace, instance, distance)
-                "exit" -> BeaconPluginRegistry.dispatchExit(isEddystone, identifier, uuid, major, minor, namespace, instance, distance)
-                "timeout" -> BeaconPluginRegistry.dispatchTimeout(isEddystone, identifier, uuid, major, minor, namespace, instance, distance)
+                "enter" ->
+                        BeaconPluginRegistry.dispatchEnter(
+                                isEddystone,
+                                identifier,
+                                uuid,
+                                major,
+                                minor,
+                                namespace,
+                                instance,
+                                distance
+                        )
+                "exit" ->
+                        BeaconPluginRegistry.dispatchExit(
+                                isEddystone,
+                                identifier,
+                                uuid,
+                                major,
+                                minor,
+                                namespace,
+                                instance,
+                                distance
+                        )
+                "timeout" ->
+                        BeaconPluginRegistry.dispatchTimeout(
+                                isEddystone,
+                                identifier,
+                                uuid,
+                                major,
+                                minor,
+                                namespace,
+                                instance,
+                                distance
+                        )
             }
         }
 
@@ -743,11 +885,12 @@ class BeaconForegroundService : Service(), BeaconConsumer {
     }
 
     private fun sendErrorBroadcast(identifier: String?, code: String, message: String) {
-        val params = buildMap<String, Any?> {
-            put("identifier", identifier ?: "")
-            put("code", code)
-            put("message", message)
-        }
+        val params =
+                buildMap<String, Any?> {
+                    put("identifier", identifier ?: "")
+                    put("code", code)
+                    put("message", message)
+                }
         logBeaconEvent("onBeaconError", params)
         sendEventBroadcast("onBeaconError", params)
     }
@@ -763,11 +906,12 @@ class BeaconForegroundService : Service(), BeaconConsumer {
                 is Boolean -> bundle.putBoolean(key, value)
             }
         }
-        val intent = Intent(ACTION_BEACON_EVENT).apply {
-            putExtra(EXTRA_EVENT_NAME, eventName)
-            putExtra(EXTRA_EVENT_PARAMS, bundle)
-            setPackage(packageName)
-        }
+        val intent =
+                Intent(ACTION_BEACON_EVENT).apply {
+                    putExtra(EXTRA_EVENT_NAME, eventName)
+                    putExtra(EXTRA_EVENT_PARAMS, bundle)
+                    setPackage(packageName)
+                }
         sendBroadcast(intent)
     }
 
@@ -808,44 +952,53 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         // Respect the enabled flag (defaults to true)
         if (eventsConfig != null && !eventsConfig.optBoolean("enabled", true)) return
 
-        val defaultTitle = when (eventType) {
-            "enter" -> "Beacon Entered"
-            "timeout" -> "Beacon Timeout"
-            else -> "Beacon Exited"
-        }
-        val title = when (eventType) {
-            "enter" -> eventsConfig?.optString("enterTitle")?.takeIf { it.isNotEmpty() } ?: defaultTitle
-            "timeout" -> eventsConfig?.optString("timeoutTitle")?.takeIf { it.isNotEmpty() } ?: defaultTitle
-            else -> eventsConfig?.optString("exitTitle")?.takeIf { it.isNotEmpty() } ?: defaultTitle
-        }
+        val defaultTitle =
+                when (eventType) {
+                    "enter" -> "Beacon Entered"
+                    "timeout" -> "Beacon Timeout"
+                    else -> "Beacon Exited"
+                }
+        val title =
+                when (eventType) {
+                    "enter" -> eventsConfig?.optString("enterTitle")?.takeIf { it.isNotEmpty() }
+                                    ?: defaultTitle
+                    "timeout" -> eventsConfig?.optString("timeoutTitle")?.takeIf { it.isNotEmpty() }
+                                    ?: defaultTitle
+                    else -> eventsConfig?.optString("exitTitle")?.takeIf { it.isNotEmpty() }
+                                    ?: defaultTitle
+                }
 
-        val bodyTemplate = eventsConfig?.optString("body")?.takeIf { it.isNotEmpty() }
-            ?: "{identifier} region {event}ed"
-        val message = bodyTemplate
-            .replace("{identifier}", region.uniqueId)
-            .replace("{event}", eventType)
+        val bodyTemplate =
+                eventsConfig?.optString("body")?.takeIf { it.isNotEmpty() }
+                        ?: "{identifier} region {event}ed"
+        val message =
+                bodyTemplate.replace("{identifier}", region.uniqueId).replace("{event}", eventType)
 
-        val notifId = notifIdMap.computeIfAbsent(region.uniqueId) {
-            ENTER_EXIT_NOTIF_BASE_ID + notifIdCounter.getAndIncrement()
-        }
+        val notifId =
+                notifIdMap.computeIfAbsent(region.uniqueId) {
+                    ENTER_EXIT_NOTIF_BASE_ID + notifIdCounter.getAndIncrement()
+                }
         postEventNotification(CHANNEL_ID, eventsConfig, title, message, notifId)
     }
 
-    /** Build and post a user-facing event notification; silently skipped without POST_NOTIFICATIONS. */
+    /**
+     * Build and post a user-facing event notification; silently skipped without POST_NOTIFICATIONS.
+     */
     private fun postEventNotification(
-        channelId: String,
-        eventsConfig: org.json.JSONObject?,
-        title: String,
-        message: String,
-        notifId: Int
+            channelId: String,
+            eventsConfig: org.json.JSONObject?,
+            title: String,
+            message: String,
+            notifId: Int
     ) {
-        val notification = NotificationCompat.Builder(this, channelId)
-            .setSmallIcon(resolveIconRes(this, eventsConfig))
-            .setContentTitle(title)
-            .setContentText(message)
-            .setPriority(NotificationCompat.PRIORITY_DEFAULT)
-            .setAutoCancel(true)
-            .build()
+        val notification =
+                NotificationCompat.Builder(this, channelId)
+                        .setSmallIcon(resolveIconRes(this, eventsConfig))
+                        .setContentTitle(title)
+                        .setContentText(message)
+                        .setPriority(NotificationCompat.PRIORITY_DEFAULT)
+                        .setAutoCancel(true)
+                        .build()
 
         try {
             NotificationManagerCompat.from(this).notify(notifId, notification)
@@ -857,21 +1010,21 @@ 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.
+     * 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
-        }
+        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)
-            }
+            monitor.start { eventName, payload -> emitCarPlayEvent(eventName, payload) }
         } catch (e: Throwable) {
             Log.w(TAG, "Failed to start CarPlayMonitor", e)
         }
@@ -885,26 +1038,34 @@ class BeaconForegroundService : Service(), BeaconConsumer {
     }
 
     /**
-     * Re-emit CarPlay state to a freshly-bound module. Invoked from [bindModule]
-     * whenever a new [ExpoBeaconModule] attaches while the foreground service is
-     * already running (typical after the app process is killed and relaunched).
+     * Re-emit CarPlay state to a freshly-bound module. Invoked from [bindModule] whenever a new
+     * [ExpoBeaconModule] attaches while the foreground service is already running (typical after
+     * the app process is killed and relaunched).
      *
      * Three outcomes:
-     *  1. Observer running + car connected → re-emit `onCarPlayConnected` (JS-only;
+     * 1. Observer running + car connected → re-emit `onCarPlayConnected` (JS-only;
+     * ```
      *     SQLite / API / registry already ran when the event originally fired).
-     *  2. Observer running + car disconnected + JS last knew "connected" →
+     * ```
+     * 2. Observer running + car disconnected + JS last knew "connected" →
+     * ```
      *     emit synthetic `onCarPlayDisconnected` with `reason = "reconciled"`.
-     *  3. Observer not yet running (fresh service start) → LiveData delivers
+     * ```
+     * 3. Observer not yet running (fresh service start) → LiveData delivers
+     * ```
      *     the initial value naturally; no action needed.
+     * ```
      */
     private fun reEmitCarPlayStateIfNeeded(module: ExpoBeaconModule) {
         val monitor = carPlayMonitor ?: return
-        if (!monitor.isObserving()) return  // Fresh service start; LiveData handles first delivery.
+        if (!monitor.isObserving()) return // Fresh service start; LiveData handles first delivery.
 
         val connPayload = monitor.buildConnectedPayload()
         if (connPayload != null) {
             // Car is still connected — give the new module the current state.
-            try { module.forwardCarPlayEventFromService("onCarPlayConnected", connPayload) } catch (_: Throwable) {}
+            try {
+                module.forwardCarPlayEventFromService("onCarPlayConnected", connPayload)
+            } catch (_: Throwable) {}
             return
         }
 
@@ -912,12 +1073,15 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         // reconciled disconnect (mirrors iOS `reconcileOnProcessStart()`).
         if (readJsConnected()) {
             val now = System.currentTimeMillis()
-            val payload = mapOf<String, Any?>(
-                "timestamp" to now,
-                "timestampIso" to buildIsoTimestamp(now),
-                "reason" to "reconciled",
-            )
-            try { module.forwardCarPlayEventFromService("onCarPlayDisconnected", payload) } catch (_: Throwable) {}
+            val payload =
+                    mapOf<String, Any?>(
+                            "timestamp" to now,
+                            "timestampIso" to buildIsoTimestamp(now),
+                            "reason" to "reconciled",
+                    )
+            try {
+                module.forwardCarPlayEventFromService("onCarPlayDisconnected", payload)
+            } catch (_: Throwable) {}
             writeJsConnected(false)
         }
     }
@@ -925,13 +1089,19 @@ class BeaconForegroundService : Service(), BeaconConsumer {
     // MARK: - JS delivery state helpers
 
     private fun readJsConnected(): Boolean =
-        try { getSharedPreferences(CARPLAY_JS_STATE_PREFS, Context.MODE_PRIVATE).getBoolean(CARPLAY_JS_STATE_KEY, false) }
-        catch (_: Throwable) { false }
+            try {
+                getSharedPreferences(CARPLAY_JS_STATE_PREFS, Context.MODE_PRIVATE)
+                        .getBoolean(CARPLAY_JS_STATE_KEY, false)
+            } catch (_: Throwable) {
+                false
+            }
 
     private fun writeJsConnected(connected: Boolean) {
         try {
             getSharedPreferences(CARPLAY_JS_STATE_PREFS, Context.MODE_PRIVATE)
-                .edit().putBoolean(CARPLAY_JS_STATE_KEY, connected).apply()
+                    .edit()
+                    .putBoolean(CARPLAY_JS_STATE_KEY, connected)
+                    .apply()
         } catch (_: Throwable) {}
     }
 
@@ -942,9 +1112,9 @@ class BeaconForegroundService : Service(), BeaconConsumer {
     }
 
     /**
-     * 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).
+     * 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).
@@ -957,12 +1127,15 @@ class BeaconForegroundService : Service(), BeaconConsumer {
             Log.w(TAG, "CarPlay log write failed", e)
         }
         // Remote API forwarder (no-op if unconfigured).
-        try { apiForwarder?.forwardEvent(payload, eventName) } catch (_: Throwable) {}
+        try {
+            apiForwarder?.forwardEvent(payload, eventName)
+        } catch (_: Throwable) {}
         // Native plugin registry (BeaconGeoPlugin etc.).
         when (eventName) {
-            "onCarPlayConnected" -> BeaconPluginRegistry.dispatchCarPlayConnected(
-                payload["transport"] as? String ?: "unknown"
-            )
+            "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.
@@ -975,10 +1148,11 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         // Local notification for connect/disconnect (config-gated).
         try {
             when (eventName) {
-                "onCarPlayConnected" -> showCarPlayNotification(
-                    "connected",
-                    payload["transport"] as? String,
-                )
+                "onCarPlayConnected" ->
+                        showCarPlayNotification(
+                                "connected",
+                                payload["transport"] as? String,
+                        )
                 "onCarPlayDisconnected" -> showCarPlayNotification("disconnected", null)
             }
         } catch (e: Throwable) {
@@ -993,20 +1167,26 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         // Respect the enabled flag (defaults to true)
         if (eventsConfig != null && !eventsConfig.optBoolean("enabled", true)) return
 
-        val defaultTitle = if (eventType == "connected") "CarPlay Connected" else "CarPlay Disconnected"
-        val title = when (eventType) {
-            "connected" -> eventsConfig?.optString("connectedTitle")?.takeIf { it.isNotEmpty() } ?: defaultTitle
-            else -> eventsConfig?.optString("disconnectedTitle")?.takeIf { it.isNotEmpty() } ?: defaultTitle
-        }
+        val defaultTitle =
+                if (eventType == "connected") "CarPlay Connected" else "CarPlay Disconnected"
+        val title =
+                when (eventType) {
+                    "connected" ->
+                            eventsConfig?.optString("connectedTitle")?.takeIf { it.isNotEmpty() }
+                                    ?: defaultTitle
+                    else -> eventsConfig?.optString("disconnectedTitle")?.takeIf { it.isNotEmpty() }
+                                    ?: defaultTitle
+                }
 
-        val bodyTemplate = eventsConfig?.optString("body")?.takeIf { it.isNotEmpty() }
-            ?: "CarPlay session {event}"
-        val message = bodyTemplate
-            .replace("{event}", eventType)
-            .replace("{transport}", transport ?: "")
+        val bodyTemplate =
+                eventsConfig?.optString("body")?.takeIf { it.isNotEmpty() }
+                        ?: "CarPlay session {event}"
+        val message =
+                bodyTemplate.replace("{event}", eventType).replace("{transport}", transport ?: "")
 
-        val notifId = if (eventType == "connected") CARPLAY_CONNECTED_NOTIF_ID
-                      else CARPLAY_DISCONNECTED_NOTIF_ID
+        val notifId =
+                if (eventType == "connected") CARPLAY_CONNECTED_NOTIF_ID
+                else CARPLAY_DISCONNECTED_NOTIF_ID
         postEventNotification(CARPLAY_CHANNEL_ID, eventsConfig, title, message, notifId)
     }
 
@@ -1019,8 +1199,8 @@ class BeaconForegroundService : Service(), BeaconConsumer {
             val regionIds = monitoredRegionIds.toList()
             return regionIds.associateWith { regionId ->
                 MonitoringRuntimeState(
-                    isEntered = enteredRegions.contains(regionId),
-                    distance = smoothedDistances[regionId]
+                        isEntered = enteredRegions.contains(regionId),
+                        distance = smoothedDistances[regionId]
                 )
             }
         }
@@ -1035,9 +1215,15 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         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. */
+        /**
+         * 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"
-        /** Intent action: stop beacon ranging/monitoring while keeping the service alive for CarPlay. */
+        /**
+         * Intent action: stop beacon ranging/monitoring while keeping the service alive for
+         * CarPlay.
+         */
         const val ACTION_DISABLE_MONITORING = "expo.modules.beacon.DISABLE_MONITORING"
         private const val MAX_STARTFOREGROUND_RETRIES = 3
         private const val RETRY_DELAY_MS = 10_000L
@@ -1050,7 +1236,9 @@ class BeaconForegroundService : Service(), BeaconConsumer {
 
         fun start(context: Context) {
             context.getSharedPreferences(MONITORING_ACTIVE_PREFS, Context.MODE_PRIVATE)
-                .edit().putBoolean(MONITORING_ACTIVE_KEY, true).apply()
+                    .edit()
+                    .putBoolean(MONITORING_ACTIVE_KEY, true)
+                    .apply()
             ensureNotificationChannel(context)
             ensureCarPlayNotificationChannel(context)
             val intent = Intent(context, BeaconForegroundService::class.java)
@@ -1063,7 +1251,9 @@ class BeaconForegroundService : Service(), BeaconConsumer {
 
         fun stop(context: Context) {
             context.getSharedPreferences(MONITORING_ACTIVE_PREFS, Context.MODE_PRIVATE)
-                .edit().putBoolean(MONITORING_ACTIVE_KEY, false).apply()
+                    .edit()
+                    .putBoolean(MONITORING_ACTIVE_KEY, 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.
@@ -1073,8 +1263,9 @@ class BeaconForegroundService : Service(), BeaconConsumer {
             // future cold start in CarPlay-only mode.
             if (isCarPlayEnabled(context)) {
                 if (activeService != null) {
-                    val intent = Intent(context, BeaconForegroundService::class.java)
-                        .setAction(ACTION_DISABLE_MONITORING)
+                    val intent =
+                            Intent(context, BeaconForegroundService::class.java)
+                                    .setAction(ACTION_DISABLE_MONITORING)
                     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                         context.startForegroundService(intent)
                     } else {
@@ -1088,30 +1279,31 @@ class BeaconForegroundService : Service(), BeaconConsumer {
 
         fun isMonitoringActive(context: Context): Boolean {
             return context.getSharedPreferences(MONITORING_ACTIVE_PREFS, Context.MODE_PRIVATE)
-                .getBoolean(MONITORING_ACTIVE_KEY, false)
+                    .getBoolean(MONITORING_ACTIVE_KEY, 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.
+         * 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(CARPLAY_ENABLED_PREFS, Context.MODE_PRIVATE)
-                .edit().putBoolean(CARPLAY_ENABLED_KEY, enabled).apply()
+                    .edit()
+                    .putBoolean(CARPLAY_ENABLED_KEY, enabled)
+                    .apply()
         }
 
         fun isCarPlayEnabled(context: Context): Boolean {
             return context.getSharedPreferences(CARPLAY_ENABLED_PREFS, Context.MODE_PRIVATE)
-                .getBoolean(CARPLAY_ENABLED_KEY, false)
+                    .getBoolean(CARPLAY_ENABLED_KEY, 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.
+         * 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)
@@ -1123,8 +1315,9 @@ class BeaconForegroundService : Service(), BeaconConsumer {
             // is killed while CarPlay observation is enabled.
             CarPlayWatchdogWorker.schedule(context)
             BootReceiver.scheduleCarPlayWatchdogAlarm(context)
-            val intent = Intent(context, BeaconForegroundService::class.java)
-                .setAction(ACTION_ENABLE_CARPLAY)
+            val intent =
+                    Intent(context, BeaconForegroundService::class.java)
+                            .setAction(ACTION_ENABLE_CARPLAY)
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                 context.startForegroundService(intent)
             } else {
@@ -1133,8 +1326,8 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         }
 
         /**
-         * Disable CarPlay observation. The foreground service stops itself
-         * if no other monitoring reason remains.
+         * Disable CarPlay observation. The foreground service stops itself if no other monitoring
+         * reason remains.
          */
         fun disableCarPlay(context: Context) {
             setCarPlayEnabled(context, false)
@@ -1149,10 +1342,13 @@ class BeaconForegroundService : Service(), BeaconConsumer {
             // Clear the JS delivery state so a future re-enable starts from a clean slate.
             try {
                 context.getSharedPreferences(CARPLAY_JS_STATE_PREFS, Context.MODE_PRIVATE)
-                    .edit().clear().apply()
+                        .edit()
+                        .clear()
+                        .apply()
             } catch (_: Throwable) {}
-            val intent = Intent(context, BeaconForegroundService::class.java)
-                .setAction(ACTION_DISABLE_CARPLAY)
+            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
@@ -1167,9 +1363,8 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         }
 
         /**
-         * 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.
+         * 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) }
@@ -1184,9 +1379,9 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         }
 
         /**
-         * Returns a snapshot of the current CarPlay / Android Auto connection state.
-         * Reads from the live [CarPlayMonitor] if the foreground service is running,
-         * otherwise falls back to the persisted last-known state.
+         * Returns a snapshot of the current CarPlay / Android Auto connection state. Reads from the
+         * live [CarPlayMonitor] if the foreground service is running, otherwise falls back to the
+         * persisted last-known state.
          */
         fun getCarPlayStatus(context: Context): Map<String, Any?> {
             val monitor = activeService?.carPlayMonitor
@@ -1198,132 +1393,166 @@ class BeaconForegroundService : Service(), BeaconConsumer {
                 return mapOf("connected" to false)
             }
             // Fallback: persisted last-known state (valid even when service is stopped).
-            val connected = try {
-                context.getSharedPreferences(CarPlayMonitor.CARPLAY_MONITOR_PREFS, Context.MODE_PRIVATE)
-                    .getBoolean(CarPlayMonitor.KEY_LAST_CONNECTED, false)
-            } catch (_: Throwable) { false }
+            val connected =
+                    try {
+                        context.getSharedPreferences(
+                                        CarPlayMonitor.CARPLAY_MONITOR_PREFS,
+                                        Context.MODE_PRIVATE
+                                )
+                                .getBoolean(CarPlayMonitor.KEY_LAST_CONNECTED, false)
+                    } catch (_: Throwable) {
+                        false
+                    }
             return mapOf("connected" to connected)
         }
 
         /**
-         * Returns a diagnostic snapshot of the CarPlay / Android Auto detection
-         * pipeline. Probes for the host-app AA registration meta-data and the
-         * resolvability of the CarConnection content provider so callers can
-         * tell from JS whether the underlying detection requirements are met.
+         * Returns a diagnostic snapshot of the CarPlay / Android Auto detection pipeline. Probes
+         * for the host-app AA registration meta-data and the resolvability of the CarConnection
+         * content provider so callers can tell from JS whether the underlying detection
+         * requirements are met.
          */
         fun getCarPlayDiagnostics(context: Context): Map<String, Any?> {
             val pm = context.packageManager
             // 1) Is the host app declared as an Android-Auto-aware app?
-            val metadataPresent = try {
-                val ai = pm.getApplicationInfo(
-                    context.packageName,
-                    android.content.pm.PackageManager.GET_META_DATA,
-                )
-                ai.metaData?.containsKey("com.google.android.gms.car.application") == true
-            } catch (_: Throwable) { false }
+            val metadataPresent =
+                    try {
+                        val ai =
+                                pm.getApplicationInfo(
+                                        context.packageName,
+                                        android.content.pm.PackageManager.GET_META_DATA,
+                                )
+                        ai.metaData?.containsKey("com.google.android.gms.car.application") == true
+                    } catch (_: Throwable) {
+                        false
+                    }
 
             // 2) Can the system resolve any provider for the CAR_PROVIDER action?
             //    This combines (a) <queries> visibility on API 30+, and (b) a
             //    Gearhead / AAOS install that actually advertises the provider.
-            val providerQueryable = try {
-                val intent = Intent("androidx.car.app.connection.action.CAR_PROVIDER")
-                val resolved = pm.queryIntentContentProviders(intent, 0)
-                resolved.isNotEmpty()
-            } catch (_: Throwable) { false }
+            val providerQueryable =
+                    try {
+                        val intent = Intent("androidx.car.app.connection.action.CAR_PROVIDER")
+                        val resolved = pm.queryIntentContentProviders(intent, 0)
+                        resolved.isNotEmpty()
+                    } catch (_: Throwable) {
+                        false
+                    }
 
             val monitor = activeService?.carPlayMonitor
-            val lastRaw: Int? = if (monitor != null && monitor.hasObservedValue) monitor.lastObservedType else null
+            val lastRaw: Int? =
+                    if (monitor != null && monitor.hasObservedValue) monitor.lastObservedType
+                    else null
             val observerActive = monitor?.isObserving() == true
             val serviceAlive = activeService != null
 
             return mapOf(
-                "isCarAppMetadataPresent" to metadataPresent,
-                "isCarProviderQueryable" to providerQueryable,
-                "lastRawConnectionType" to lastRaw,
-                "observerActive" to observerActive,
-                "serviceAlive" to serviceAlive,
+                    "isCarAppMetadataPresent" to metadataPresent,
+                    "isCarProviderQueryable" to providerQueryable,
+                    "lastRawConnectionType" to lastRaw,
+                    "observerActive" to observerActive,
+                    "serviceAlive" to serviceAlive,
             )
         }
 
         /** Read the persisted notification config JSON; empty object when unset or malformed. */
         internal fun readNotificationConfig(context: Context): org.json.JSONObject {
-            val json = context.getSharedPreferences(NOTIFICATION_CONFIG_PREFS, Context.MODE_PRIVATE)
-                .getString(NOTIFICATION_CONFIG_KEY, null) ?: return org.json.JSONObject()
-            return try { org.json.JSONObject(json) } catch (_: Exception) { org.json.JSONObject() }
+            val json =
+                    context.getSharedPreferences(NOTIFICATION_CONFIG_PREFS, Context.MODE_PRIVATE)
+                            .getString(NOTIFICATION_CONFIG_KEY, null)
+                            ?: return org.json.JSONObject()
+            return try {
+                org.json.JSONObject(json)
+            } catch (_: Exception) {
+                org.json.JSONObject()
+            }
         }
 
-        /** Resolve the configured small-icon drawable from [config], falling back to a stock icon. */
+        /**
+         * Resolve the configured small-icon drawable from [config], falling back to a stock icon.
+         */
         private fun resolveIconRes(context: Context, config: org.json.JSONObject?): Int {
             val iconName = config?.optString("icon")?.takeIf { it.isNotEmpty() }
             return iconName?.let { name ->
-                try { context.resources.getIdentifier(name, "drawable", context.packageName).takeIf { it != 0 } }
-                catch (_: Exception) { null }
-            } ?: android.R.drawable.ic_dialog_info
+                try {
+                    context.resources.getIdentifier(name, "drawable", context.packageName).takeIf {
+                        it != 0
+                    }
+                } catch (_: Exception) {
+                    null
+                }
+            }
+                    ?: android.R.drawable.ic_dialog_info
         }
 
         private fun ensureChannel(
-            context: Context,
-            channelId: String,
-            configKey: String,
-            defaultName: String,
-            defaultDescription: String,
-            fallbackImportance: Int
+                context: Context,
+                channelId: String,
+                configKey: String,
+                defaultName: String,
+                defaultDescription: String,
+                fallbackImportance: Int
         ) {
             if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
             val channelConfig = readNotificationConfig(context).optJSONObject(configKey)
 
-            val channelName = channelConfig?.optString("name")?.takeIf { it.isNotEmpty() }
-                ?: defaultName
-            val channelDesc = channelConfig?.optString("description")?.takeIf { it.isNotEmpty() }
-                ?: defaultDescription
-            val importance = when (channelConfig?.optString("importance")) {
-                "high" -> NotificationManager.IMPORTANCE_HIGH
-                "default" -> NotificationManager.IMPORTANCE_DEFAULT
-                "low" -> NotificationManager.IMPORTANCE_LOW
-                else -> fallbackImportance
-            }
+            val channelName =
+                    channelConfig?.optString("name")?.takeIf { it.isNotEmpty() } ?: defaultName
+            val channelDesc =
+                    channelConfig?.optString("description")?.takeIf { it.isNotEmpty() }
+                            ?: defaultDescription
+            val importance =
+                    when (channelConfig?.optString("importance")) {
+                        "high" -> NotificationManager.IMPORTANCE_HIGH
+                        "default" -> NotificationManager.IMPORTANCE_DEFAULT
+                        "low" -> NotificationManager.IMPORTANCE_LOW
+                        else -> fallbackImportance
+                    }
 
             val notifMgr = context.getSystemService(NotificationManager::class.java)
             // Only create channel if it doesn't exist yet — preserves user notification preferences
             if (notifMgr?.getNotificationChannel(channelId) == null) {
-                val channel = NotificationChannel(channelId, channelName, importance).apply {
-                    description = channelDesc
-                }
+                val channel =
+                        NotificationChannel(channelId, channelName, importance).apply {
+                            description = channelDesc
+                        }
                 notifMgr?.createNotificationChannel(channel)
             }
         }
 
         /**
-         * Ensure the notification channel exists. Must be called before building
-         * a notification from a non-service context (e.g. ExpoBeaconModule).
+         * Ensure the notification channel exists. Must be called before building a notification
+         * from a non-service context (e.g. ExpoBeaconModule).
          */
-        fun ensureNotificationChannel(context: Context) = ensureChannel(
-            context,
-            CHANNEL_ID,
-            "channel",
-            "Beacon Monitoring",
-            "Used for background iBeacon region monitoring",
-            NotificationManager.IMPORTANCE_LOW
-        )
+        fun ensureNotificationChannel(context: Context) =
+                ensureChannel(
+                        context,
+                        CHANNEL_ID,
+                        "channel",
+                        "Beacon Monitoring",
+                        "Used for background iBeacon region monitoring",
+                        NotificationManager.IMPORTANCE_LOW
+                )
 
         /**
-         * Ensure the CarPlay notification channel exists. Mirrors
-         * [ensureNotificationChannel] for the dedicated CarPlay channel so that
-         * users can mute CarPlay notifications independently in system settings.
+         * Ensure the CarPlay notification channel exists. Mirrors [ensureNotificationChannel] for
+         * the dedicated CarPlay channel so that users can mute CarPlay notifications independently
+         * in system settings.
          */
-        fun ensureCarPlayNotificationChannel(context: Context) = ensureChannel(
-            context,
-            CARPLAY_CHANNEL_ID,
-            "carPlayChannel",
-            "CarPlay / Android Auto",
-            "CarPlay and Android Auto connect/disconnect notifications",
-            NotificationManager.IMPORTANCE_DEFAULT
-        )
+        fun ensureCarPlayNotificationChannel(context: Context) =
+                ensureChannel(
+                        context,
+                        CARPLAY_CHANNEL_ID,
+                        "carPlayChannel",
+                        "CarPlay / Android Auto",
+                        "CarPlay and Android Auto connect/disconnect notifications",
+                        NotificationManager.IMPORTANCE_DEFAULT
+                )
 
         /**
-         * Build the persistent foreground-service notification from any Context.
-         * Static so cold-start paths that run before a service instance exists
-         * (e.g. [BootReceiver]) read the same persisted config.
+         * Build the persistent foreground-service notification from any Context. Static so
+         * cold-start paths that run before a service instance exists (e.g. [BootReceiver]) read the
+         * same persisted config.
          */
         fun buildForegroundNotification(context: Context): Notification {
             val fgConfig = readNotificationConfig(context).optJSONObject("foregroundService")
@@ -1333,29 +1562,32 @@ class BeaconForegroundService : Service(), BeaconConsumer {
             // 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 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
 
             return NotificationCompat.Builder(context, CHANNEL_ID)
-                .setSmallIcon(resolveIconRes(context, fgConfig))
-                .setContentTitle(title)
-                .setContentText(text)
-                .setPriority(NotificationCompat.PRIORITY_LOW)
-                .setOngoing(true)
-                .build()
+                    .setSmallIcon(resolveIconRes(context, fgConfig))
+                    .setContentTitle(title)
+                    .setContentText(text)
+                    .setPriority(NotificationCompat.PRIORITY_LOW)
+                    .setOngoing(true)
+                    .build()
         }
     }
 
     private fun readNotificationConfig(): org.json.JSONObject = readNotificationConfig(this)
 
     /**
-     * Stop all beacon ranging/monitoring, cancel beacon timers, and unbind from
-     * AltBeacon, while leaving the service (and any CarPlay observer) running.
-     * Safe to call when monitoring was never armed. Used both by
-     * [ACTION_DISABLE_MONITORING] (CarPlay-only mode) and [onDestroy].
+     * Stop all beacon ranging/monitoring, cancel beacon timers, and unbind from AltBeacon, while
+     * leaving the service (and any CarPlay observer) running. Safe to call when monitoring was
+     * never armed. Used both by [ACTION_DISABLE_MONITORING] (CarPlay-only mode) and [onDestroy].
      */
     private fun disableMonitoringInternal() {
         pendingLoadRegions = false
@@ -1365,11 +1597,15 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         beaconTimeouts.clear()
         lastSeenAtMs.clear()
         distanceLogRegions.forEach {
-            try { beaconManager.stopRangingBeaconsInRegion(it) } catch (_: RemoteException) {}
+            try {
+                beaconManager.stopRangingBeaconsInRegion(it)
+            } catch (_: RemoteException) {}
         }
         distanceLogRegions.clear()
         monitoredRegions.forEach {
-            try { beaconManager.stopMonitoringBeaconsInRegion(it) } catch (_: RemoteException) {}
+            try {
+                beaconManager.stopMonitoringBeaconsInRegion(it)
+            } catch (_: RemoteException) {}
         }
         monitoredRegions.clear()
         monitoredRegionIds.clear()
@@ -1387,7 +1623,9 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         // instances skip beaconManager.bind() in onStartCommand.
         if (serviceConnected) {
             serviceConnected = false
-            try { beaconManager.unbind(this) } catch (_: Throwable) {}
+            try {
+                beaconManager.unbind(this)
+            } catch (_: Throwable) {}
         }
     }
 
@@ -1412,17 +1650,15 @@ class BeaconForegroundService : Service(), BeaconConsumer {
     override fun onBind(intent: Intent?): IBinder? = null
 
     /**
-     * Defensive override: when the user swipes the host app away from
-     * Recents, Android delivers `onTaskRemoved` to bound services. Our
-     * service is started via `startForegroundService` with `START_STICKY`
-     * and is intended to keep running independently of the app's task —
-     * specifically so that CarPlay / Android Auto observation and beacon
-     * monitoring continue across swipe-away. We intentionally do NOT call
-     * `stopSelf()` here; the system will redeliver `onStartCommand` on
+     * Defensive override: when the user swipes the host app away from Recents, Android delivers
+     * `onTaskRemoved` to bound services. Our service is started via `startForegroundService` with
+     * `START_STICKY` and is intended to keep running independently of the app's task — specifically
+     * so that CarPlay / Android Auto observation and beacon monitoring continue across swipe-away.
+     * We intentionally do NOT call `stopSelf()` here; the system will redeliver `onStartCommand` on
      * its own if the process is later reclaimed.
      *
-    * We also arm a near-term keepalive alarm so devices that tear down the
-    * process on task removal recover before the slower periodic watchdogs run.
+     * We also arm a near-term keepalive alarm so devices that tear down the process on task removal
+     * recover before the slower periodic watchdogs run.
      */
     override fun onTaskRemoved(rootIntent: Intent?) {
         val keepAlive = isMonitoringActive(this) || isCarPlayEnabled(this)
@@ -1439,10 +1675,10 @@ class BeaconForegroundService : Service(), BeaconConsumer {
             }
         }
         Log.d(
-            TAG,
-            "onTaskRemoved received (monitoring=${isMonitoringActive(this)}, " +
-                "carPlay=${isCarPlayEnabled(this)}, keepAlive=$keepAlive). " +
-                "Service will remain in foreground."
+                TAG,
+                "onTaskRemoved received (monitoring=${isMonitoringActive(this)}, " +
+                        "carPlay=${isCarPlayEnabled(this)}, keepAlive=$keepAlive). " +
+                        "Service will remain in foreground."
         )
         super.onTaskRemoved(rootIntent)
     }
@@ -1451,5 +1687,7 @@ class BeaconForegroundService : Service(), BeaconConsumer {
 const val ACTION_BEACON_EVENT = "expo.modules.beacon.BEACON_EVENT"
 /** Intent extra holding the resolved JS event name (e.g. "onBeaconEnter"). */
 internal const val EXTRA_EVENT_NAME = "eventName"
-/** Intent extra holding the event payload as a Bundle, unpacked verbatim by [BeaconEventReceiver]. */
+/**
+ * Intent extra holding the event payload as a Bundle, unpacked verbatim by [BeaconEventReceiver].
+ */
 internal const val EXTRA_EVENT_PARAMS = "params"