expo-beacon 0.6.3 → 0.6.6

package/android/src/main/AndroidManifest.xml

@@ -22,6 +22,9 @@
     <!-- Receive boot broadcast to restart monitoring after device reboot -->
     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
 
+    <!-- Battery optimization exemption for reliable background BLE scanning -->
+    <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS" />
+
     <uses-feature android:name="android.hardware.bluetooth_le" android:required="true" />
 
     <application>
@@ -30,9 +33,10 @@
             android:name="org.altbeacon.beacon.service.BeaconService"
             android:enabled="true"
             android:exported="false"
+            android:foregroundServiceType="connectedDevice"
             android:isolatedProcess="false"
             android:label="iBeacon Service"
-            tools:replace="android:label" />
+            tools:replace="android:label,android:foregroundServiceType" />
 
         <service
             android:name="org.altbeacon.beacon.BeaconIntentProcessor"

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

@@ -1,8 +1,10 @@
 package expo.modules.beacon
 
 // Shared constants used across ExpoBeaconModule and BeaconForegroundService.
-// IMPORTANT: Timing constants (EXIT_MISS_THRESHOLD, HYSTERESIS_COUNT) must stay
-// in sync with ExpoBeaconModule.swift (iOS).
+// NOTE: EXIT_MISS_THRESHOLD and scan timing deviate from iOS intentionally —
+// Android requires a non-zero between-scan gap to prevent OS-level BLE
+// throttling, and a higher miss threshold to tolerate brief scan pauses.
+// HYSTERESIS_COUNT should stay in sync with ExpoBeaconModule.swift (iOS).
 
 internal const val PREFS_NAME = "expo.beacon.paired"
 internal const val PREFS_KEY = "paired_beacons"
@@ -13,12 +15,38 @@ internal const val MONITORING_OPTIONS_PREFS = "expo.beacon.monitoring_options"
 internal const val EVENT_LOGGING_PREFS = "expo.beacon.event_logging"
 internal const val EVENT_LOGGING_ENABLED_KEY = "enabled"
 
-/** Number of consecutive ranging misses before emitting a distance-based exit event. */
-internal const val EXIT_MISS_THRESHOLD = 3
+/** Foreground-service scan window for background monitoring responsiveness. */
+internal const val MONITORING_SCAN_PERIOD_MS = 1100L
+
+/**
+ * Gap between scan windows while the foreground service is active.
+ * A non-zero gap prevents Android from throttling continuous BLE scans
+ * after a few minutes — the BLE stack needs brief idle periods to avoid
+ * OS-level scan suppression on many devices (Samsung, Pixel, etc.).
+ */
+internal const val MONITORING_BETWEEN_SCAN_PERIOD_MS = 1000L
+
+/** Ignore monitor-based exits if ranging saw the beacon within this window. */
+internal const val RECENT_RANGING_SIGHTING_GRACE_MS = 25000L
+
+/**
+ * Number of consecutive ranging misses before emitting a distance-based exit event.
+ * With a ~2.1 s scan cycle (1100 ms scan + 1000 ms gap), 10 misses ≈ 21 s of
+ * silence before declaring exit — tolerant of brief BLE gaps while still
+ * responsive to actual departures.
+ */
+internal const val EXIT_MISS_THRESHOLD = 10
 
 /** Number of consecutive readings required to confirm a distance-based enter or exit transition. */
 internal const val HYSTERESIS_COUNT = 3
 
+/**
+ * AltBeacon region exit period — how long after the last sighting before
+ * MonitorNotifier.didExitRegion fires. Set generously to avoid premature
+ * monitor-level exits that bypass ranging hysteresis.
+ */
+internal const val REGION_EXIT_PERIOD_MS = 60000L
+
 /** Shared log tag for the expo-beacon module. */
 internal const val TAG = "ExpoBeacon"
 

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

@@ -10,6 +10,7 @@ import android.os.Handler
 import android.os.IBinder
 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
@@ -18,7 +19,7 @@ import org.altbeacon.beacon.*
 import org.json.JSONArray
 
 private const val CHANNEL_ID = "expo_beacon_channel"
-private const val FOREGROUND_NOTIF_ID = 1001
+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
@@ -31,11 +32,15 @@ class BeaconForegroundService : Service(), BeaconConsumer {
     private lateinit var beaconManager: BeaconManager
     private val monitoredRegions = mutableListOf<Region>()
 
+    /** Tracks whether onBeaconServiceConnect has fired for the current bind. */
+    @Volatile private var serviceConnected = false
+
     // Distance filtering
     @Volatile private var maxDistance: Double? = null
     @Volatile private var exitDistance: Double? = null
-    private val rangingRegions = java.util.concurrent.CopyOnWriteArraySet<Region>()
+    private val monitoredRegionIds = java.util.concurrent.CopyOnWriteArraySet<String>()
     private val enteredRegions = java.util.concurrent.CopyOnWriteArraySet<String>()
+    private val lastSeenAtMs = java.util.concurrent.ConcurrentHashMap<String, Long>()
 
     // Hysteresis counters (synchronized on distanceLock)
     private val distanceLock = Any()
@@ -57,42 +62,31 @@ class BeaconForegroundService : Service(), BeaconConsumer {
     private val beaconTimeouts = java.util.concurrent.ConcurrentHashMap<String, Int>()
     private var eventLogger: BeaconEventLogger? = null
 
-    companion object {
-        private const val PREF_IS_MONITORING = "expo.beacon.is_monitoring"
-
-        fun start(context: Context) {
-            context.getSharedPreferences(PREF_IS_MONITORING, Context.MODE_PRIVATE)
-                .edit().putBoolean("active", true).apply()
-            val intent = Intent(context, BeaconForegroundService::class.java)
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-                context.startForegroundService(intent)
-            } else {
-                context.startService(intent)
-            }
-        }
-
-        fun stop(context: Context) {
-            context.getSharedPreferences(PREF_IS_MONITORING, Context.MODE_PRIVATE)
-                .edit().putBoolean("active", false).apply()
-            context.stopService(Intent(context, BeaconForegroundService::class.java))
-        }
-
-        fun isMonitoringActive(context: Context): Boolean {
-            return context.getSharedPreferences(PREF_IS_MONITORING, Context.MODE_PRIVATE)
-                .getBoolean("active", false)
-        }
-    }
-
     override fun onCreate() {
         super.onCreate()
         createNotificationChannel()
         beaconManager = BeaconManager.getInstanceForApplication(this).also { manager ->
             BeaconParsers.ensureRegistered(manager)
             try { manager.setEnableScheduledScanJobs(false) } catch (e: IllegalStateException) { Log.w(TAG, "setEnableScheduledScanJobs failed", e) }
-            manager.setBackgroundBetweenScanPeriod(5000L)  // 5s between scans
-            manager.setBackgroundScanPeriod(1100L)         // 1.1s scan window
-            manager.setForegroundScanPeriod(1000L)         // 1s scan window for distance logging
-            manager.setForegroundBetweenScanPeriod(0L)     // no pause between scans
+            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)
+        // Let AltBeacon's internal BeaconService run as a foreground service so
+        // Samsung/OEM battery enforcement doesn't kill BLE scanning after ~4 min.
+        // Reset first to clear any stale state from a previous session.
+        try { beaconManager.disableForegroundServiceScanning() } catch (_: Exception) {}
+        try {
+            beaconManager.enableForegroundServiceScanning(
+                buildForegroundNotification(), FOREGROUND_NOTIF_ID
+            )
+        } catch (e: IllegalStateException) {
+            // Already bound by another consumer (e.g. a scan in progress) — non-fatal.
+            Log.w(TAG, "enableForegroundServiceScanning skipped (already bound)", e)
         }
     }
 
@@ -106,11 +100,18 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         } else {
             startForeground(FOREGROUND_NOTIF_ID, buildForegroundNotification())
         }
-        beaconManager.bind(this)
+        if (serviceConnected) {
+            // Already bound from a prior onStartCommand — reload regions directly
+            // so that re-starting monitoring from JS always takes effect.
+            loadAndMonitorRegions()
+        } else {
+            beaconManager.bind(this)
+        }
         return START_STICKY
     }
 
     override fun onBeaconServiceConnect() {
+        serviceConnected = true
         // Read max distance and exit distance from options prefs
         val optPrefs = getSharedPreferences(MONITORING_OPTIONS_PREFS, Context.MODE_PRIVATE)
         maxDistance = optPrefs.getString("max_distance", null)?.toDoubleOrNull()
@@ -156,6 +157,16 @@ class BeaconForegroundService : Service(), BeaconConsumer {
             try { beaconManager.stopRangingBeaconsInRegion(it) } catch (_: RemoteException) {}
         }
         distanceLogRegions.clear()
+        monitoredRegionIds.clear()
+        enteredRegions.clear()
+        lastSeenAtMs.clear()
+        timeoutHandler.removeCallbacksAndMessages(null)
+        timeoutRunnables.clear()
+        synchronized(distanceLock) {
+            enterCounters.clear()
+            exitCounters.clear()
+            missCounters.clear()
+        }
         monitoredRegions.forEach {
             try { beaconManager.stopMonitoringBeaconsInRegion(it) } catch (_: RemoteException) {}
         }
@@ -171,6 +182,7 @@ class BeaconForegroundService : Service(), BeaconConsumer {
                 Identifier.fromInt(b.getInt("minor"))
             )
             monitoredRegions.add(region)
+            monitoredRegionIds.add(region.uniqueId)
             try {
                 beaconManager.startMonitoringBeaconsInRegion(region)
             } catch (e: RemoteException) {
@@ -200,6 +212,7 @@ class BeaconForegroundService : Service(), BeaconConsumer {
                 null
             )
             monitoredRegions.add(region)
+            monitoredRegionIds.add(region.uniqueId)
             try {
                 beaconManager.startMonitoringBeaconsInRegion(region)
             } catch (ex: RemoteException) {
@@ -224,51 +237,42 @@ class BeaconForegroundService : Service(), BeaconConsumer {
 
     // Distance logging only — emits distance broadcasts. Enter/exit logic lives in rangeNotifier.
     private val distanceLoggingRangeNotifier = RangeNotifier { beacons, region ->
+        if (!monitoredRegionIds.contains(region.uniqueId)) return@RangeNotifier
         val closest = beacons.filter { it.distance >= 0 }.minByOrNull { it.distance }
         if (closest != null) {
+            lastSeenAtMs[region.uniqueId] = SystemClock.elapsedRealtime()
             sendBeaconBroadcast(region, "distance", closest.distance)
         }
     }
 
     private val monitorNotifier = object : MonitorNotifier {
         override fun didEnterRegion(region: Region) {
-            val maxDist = maxDistance
-            if (maxDist != null) {
-                // Mark region for distance confirmation — ranging is already active via distance logging
-                rangingRegions.add(region)
-            } else {
-                enteredRegions.add(region.uniqueId)
-                sendBeaconBroadcast(region, "enter", -1.0)
-                showEnterExitNotification(region, "enter")
-                scheduleTimeoutIfConfigured(region)
-            }
+            // Enter is synthesized from ranging so distance and enter/exit stay in sync.
         }
 
         override fun didExitRegion(region: Region) {
-            rangingRegions.remove(region)
-
-            if (maxDistance != null) {
-                // Distance ranging normally handles exit. But if the beacon was
-                // in "entered" state when OS fires didExitRegion, we must emit
-                // the exit event — ranging will no longer receive readings.
-                val wasEntered = enteredRegions.remove(region.uniqueId)
-                synchronized(distanceLock) {
-                    enterCounters.remove(region.uniqueId)
-                    exitCounters.remove(region.uniqueId)
-                    missCounters.remove(region.uniqueId)
-                }
-                if (wasEntered) {
-                    cancelTimeout(region.uniqueId)
-                    sendBeaconBroadcast(region, "exit", -1.0)
-                    showEnterExitNotification(region, "exit")
-                }
+            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
             }
 
-            cancelTimeout(region.uniqueId)
-            enteredRegions.remove(region.uniqueId)
-            sendBeaconBroadcast(region, "exit", -1.0)
-            showEnterExitNotification(region, "exit")
+            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) {
+                cancelTimeout(region.uniqueId)
+                sendBeaconBroadcast(region, "exit", -1.0)
+                showEnterExitNotification(region, "exit")
+            }
         }
 
         override fun didDetermineStateForRegion(state: Int, region: Region) {
@@ -277,11 +281,11 @@ class BeaconForegroundService : Service(), BeaconConsumer {
     }
 
     // Single source of truth for distance-based enter/exit with hysteresis.
-    // Processes regions added to rangingRegions by monitorNotifier.didEnterRegion,
-    // and also handles exit via miss counting when beacons disappear.
+    // Processes only actual monitoring regions and handles exit via miss counting
+    // when beacons disappear.
     private val rangeNotifier = RangeNotifier { beacons, region ->
-        val maxDist = maxDistance ?: return@RangeNotifier
-        if (!rangingRegions.contains(region) && !enteredRegions.contains(region.uniqueId)) return@RangeNotifier
+        val maxDist = maxDistance
+        if (!monitoredRegionIds.contains(region.uniqueId)) return@RangeNotifier
 
         val beacon = beacons
             .filter { it.distance >= 0 }
@@ -290,13 +294,13 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         synchronized(distanceLock) {
             if (beacon != null) {
                 // Got a valid reading — reset miss counter
+                lastSeenAtMs[region.uniqueId] = SystemClock.elapsedRealtime()
                 missCounters[region.uniqueId] = 0
 
                 val action = evaluateDistanceHysteresis(region.uniqueId, beacon.distance, maxDist)
                 when (action) {
                     HysteresisAction.ENTER -> {
                         enteredRegions.add(region.uniqueId)
-                        rangingRegions.remove(region)
                         sendBeaconBroadcast(region, "enter", beacon.distance)
                         showEnterExitNotification(region, "enter")
                         scheduleTimeoutIfConfigured(region)
@@ -304,14 +308,16 @@ class BeaconForegroundService : Service(), BeaconConsumer {
                     HysteresisAction.EXIT -> {
                         cancelTimeout(region.uniqueId)
                         enteredRegions.remove(region.uniqueId)
-                        rangingRegions.add(region)
                         sendBeaconBroadcast(region, "exit", beacon.distance)
                         showEnterExitNotification(region, "exit")
                     }
                     HysteresisAction.NONE -> {}
                 }
             } else {
-                // No valid beacon reading — track consecutive misses for exit detection
+                // No valid beacon reading — break distance hysteresis streaks and
+                // track consecutive misses for disappearance-based exit detection.
+                enterCounters[region.uniqueId] = 0
+                exitCounters[region.uniqueId] = 0
                 val count = (missCounters[region.uniqueId] ?: 0) + 1
                 missCounters[region.uniqueId] = count
 
@@ -349,8 +355,23 @@ class BeaconForegroundService : Service(), BeaconConsumer {
     private fun evaluateDistanceHysteresis(
         regionId: String,
         distance: Double,
-        maxDist: Double
+        maxDist: Double?
     ): HysteresisAction {
+        if (maxDist == null) {
+            exitCounters[regionId] = 0
+            if (enteredRegions.contains(regionId)) {
+                enterCounters[regionId] = 0
+                return HysteresisAction.NONE
+            }
+            val count = (enterCounters[regionId] ?: 0) + 1
+            enterCounters[regionId] = count
+            if (count >= HYSTERESIS_COUNT) {
+                enterCounters[regionId] = 0
+                return HysteresisAction.ENTER
+            }
+            return HysteresisAction.NONE
+        }
+
         val exitDist = effectiveExitDistance(maxDist)
         if (distance <= maxDist) {
             // Inside enter threshold
@@ -378,6 +399,11 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         return HysteresisAction.NONE
     }
 
+    private fun wasSeenRecently(regionId: String): Boolean {
+        val lastSeen = lastSeenAtMs[regionId] ?: return false
+        return SystemClock.elapsedRealtime() - lastSeen <= RECENT_RANGING_SIGHTING_GRACE_MS
+    }
+
     // MARK: - Timeout timer helpers
 
     private fun scheduleTimeoutIfConfigured(region: Region) {
@@ -546,26 +572,94 @@ class BeaconForegroundService : Service(), BeaconConsumer {
     }
 
     private fun buildForegroundNotification(): Notification {
-        val config = readNotificationConfig()
-        val fgConfig = config.optJSONObject("foregroundService")
+        return Companion.buildForegroundNotification(this)
+    }
 
-        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"
-        val iconName = fgConfig?.optString("icon")?.takeIf { it.isNotEmpty() }
-        val iconResId = iconName?.let { name ->
-            try { resources.getIdentifier(name, "drawable", packageName).takeIf { it != 0 } }
-            catch (_: Exception) { null }
-        } ?: android.R.drawable.ic_dialog_info
+    companion object {
+        private const val PREF_IS_MONITORING = "expo.beacon.is_monitoring"
 
-        return NotificationCompat.Builder(this, CHANNEL_ID)
-            .setSmallIcon(iconResId)
-            .setContentTitle(title)
-            .setContentText(text)
-            .setPriority(NotificationCompat.PRIORITY_LOW)
-            .setOngoing(true)
-            .build()
+        fun start(context: Context) {
+            context.getSharedPreferences(PREF_IS_MONITORING, Context.MODE_PRIVATE)
+                .edit().putBoolean("active", true).apply()
+            val intent = Intent(context, BeaconForegroundService::class.java)
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                context.startForegroundService(intent)
+            } else {
+                context.startService(intent)
+            }
+        }
+
+        fun stop(context: Context) {
+            context.getSharedPreferences(PREF_IS_MONITORING, Context.MODE_PRIVATE)
+                .edit().putBoolean("active", false).apply()
+            context.stopService(Intent(context, BeaconForegroundService::class.java))
+        }
+
+        fun isMonitoringActive(context: Context): Boolean {
+            return context.getSharedPreferences(PREF_IS_MONITORING, Context.MODE_PRIVATE)
+                .getBoolean("active", false)
+        }
+
+        /**
+         * Ensure the notification channel exists. Must be called before building
+         * a notification from a non-service context (e.g. ExpoBeaconModule).
+         */
+        fun ensureNotificationChannel(context: Context) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                val json = context.getSharedPreferences(NOTIFICATION_CONFIG_PREFS, Context.MODE_PRIVATE)
+                    .getString("config", null)
+                val config = try { org.json.JSONObject(json ?: "") } catch (_: Exception) { org.json.JSONObject() }
+                val channelConfig = config.optJSONObject("channel")
+
+                val channelName = channelConfig?.optString("name")?.takeIf { it.isNotEmpty() }
+                    ?: "Beacon Monitoring"
+                val channelDesc = channelConfig?.optString("description")?.takeIf { it.isNotEmpty() }
+                    ?: "Used for background iBeacon region monitoring"
+                val importance = when (channelConfig?.optString("importance")) {
+                    "high" -> NotificationManager.IMPORTANCE_HIGH
+                    "default" -> NotificationManager.IMPORTANCE_DEFAULT
+                    else -> NotificationManager.IMPORTANCE_LOW
+                }
+
+                val notifMgr = context.getSystemService(NotificationManager::class.java)
+                if (notifMgr?.getNotificationChannel(CHANNEL_ID) == null) {
+                    val channel = NotificationChannel(CHANNEL_ID, channelName, importance).apply {
+                        description = channelDesc
+                    }
+                    notifMgr?.createNotificationChannel(channel)
+                }
+            }
+        }
+
+        /**
+         * Build the foreground notification from any Context (service or module).
+         * Shared so that ExpoBeaconModule can pass the same notification to
+         * enableForegroundServiceScanning() before the service starts.
+         */
+        fun buildForegroundNotification(context: Context): Notification {
+            val json = context.getSharedPreferences(NOTIFICATION_CONFIG_PREFS, Context.MODE_PRIVATE)
+                .getString("config", null)
+            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"
+            val iconName = fgConfig?.optString("icon")?.takeIf { it.isNotEmpty() }
+            val iconResId = iconName?.let { name ->
+                try { context.resources.getIdentifier(name, "drawable", context.packageName).takeIf { it != 0 } }
+                catch (_: Exception) { null }
+            } ?: android.R.drawable.ic_dialog_info
+
+            return NotificationCompat.Builder(context, CHANNEL_ID)
+                .setSmallIcon(iconResId)
+                .setContentTitle(title)
+                .setContentText(text)
+                .setPriority(NotificationCompat.PRIORITY_LOW)
+                .setOngoing(true)
+                .build()
+        }
     }
 
     private fun readNotificationConfig(): org.json.JSONObject {
@@ -575,17 +669,16 @@ class BeaconForegroundService : Service(), BeaconConsumer {
     }
 
     override fun onDestroy() {
+        serviceConnected = false
         timeoutHandler.removeCallbacksAndMessages(null)
         timeoutRunnables.clear()
         beaconTimeouts.clear()
+        lastSeenAtMs.clear()
+        monitoredRegionIds.clear()
         releaseEventLogger()
         beaconManager.removeMonitorNotifier(monitorNotifier)
         beaconManager.removeRangeNotifier(rangeNotifier)
         beaconManager.removeRangeNotifier(distanceLoggingRangeNotifier)
-        rangingRegions.forEach {
-            try { beaconManager.stopRangingBeaconsInRegion(it) } catch (_: RemoteException) {}
-        }
-        rangingRegions.clear()
         distanceLogRegions.forEach {
             try { beaconManager.stopRangingBeaconsInRegion(it) } catch (_: RemoteException) {}
         }
@@ -598,6 +691,7 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         monitoredRegions.forEach {
             try { beaconManager.stopMonitoringBeaconsInRegion(it) } catch (_: RemoteException) {}
         }
+        try { beaconManager.disableForegroundServiceScanning() } catch (_: Exception) {}
         beaconManager.unbind(this)
         super.onDestroy()
     }

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

@@ -7,7 +7,9 @@ import android.content.IntentFilter
 import android.content.ServiceConnection
 import android.content.SharedPreferences
 import android.content.pm.PackageManager
+import android.net.Uri
 import android.os.Build
+import android.os.PowerManager
 import android.os.RemoteException
 import androidx.core.content.ContextCompat
 import expo.modules.interfaces.permissions.PermissionsStatus
@@ -294,6 +296,22 @@ class ExpoBeaconModule : Module(), BeaconConsumer {
                     }
                 }
             }
+            if (maxDistance != null && (!maxDistance.isFinite() || maxDistance <= 0.0)) {
+                promise.reject("INVALID_MAX_DISTANCE", "maxDistance must be a finite number greater than 0", null)
+                return@AsyncFunction
+            }
+            if (exitDistance != null && (!exitDistance.isFinite() || exitDistance <= 0.0)) {
+                promise.reject("INVALID_EXIT_DISTANCE", "exitDistance must be a finite number greater than 0", null)
+                return@AsyncFunction
+            }
+            if (exitDistance != null && maxDistance == null) {
+                promise.reject("INVALID_EXIT_DISTANCE", "exitDistance requires maxDistance to be set", null)
+                return@AsyncFunction
+            }
+            if (maxDistance != null && exitDistance != null && exitDistance < maxDistance) {
+                promise.reject("INVALID_EXIT_DISTANCE", "exitDistance must be greater than or equal to maxDistance", null)
+                return@AsyncFunction
+            }
             ctx.getSharedPreferences(MONITORING_OPTIONS_PREFS, Context.MODE_PRIVATE)
                 .edit().apply {
                     if (maxDistance != null) putString("max_distance", maxDistance.toString())
@@ -310,6 +328,21 @@ class ExpoBeaconModule : Module(), BeaconConsumer {
                 return@AsyncFunction
             }
 
+            // Enable AltBeacon foreground service scanning so the internal BeaconService
+            // runs as a foreground service, preventing Samsung/OEM BLE throttling.
+            // Reset first to clear stale state from a previous session / hot-reload.
+            if (!isBoundForScan) {
+                try {
+                    BeaconForegroundService.ensureNotificationChannel(ctx)
+                    try { beaconManager.disableForegroundServiceScanning() } catch (_: Exception) {}
+                    beaconManager.enableForegroundServiceScanning(
+                        BeaconForegroundService.buildForegroundNotification(ctx), FOREGROUND_NOTIF_ID
+                    )
+                } catch (_: IllegalStateException) {
+                    // Already bound — service onCreate() will enable it instead.
+                }
+            }
+
             registerEventReceiver()
             BeaconForegroundService.start(ctx)
             promise.resolve(null)
@@ -327,6 +360,7 @@ class ExpoBeaconModule : Module(), BeaconConsumer {
                 return@AsyncFunction
             }
             BeaconForegroundService.stop(ctx)
+            try { beaconManager.disableForegroundServiceScanning() } catch (_: Exception) {}
             unregisterEventReceiver()
             promise.resolve(null)
         }
@@ -415,6 +449,43 @@ class ExpoBeaconModule : Module(), BeaconConsumer {
             BeaconEventLogger.deleteLogDatabase(ctx)
         }
 
+        // MARK: - Battery Optimization
+
+        Function("isBatteryOptimizationExempt") {
+            val ctx = appContext.reactContext ?: return@Function false
+            val pm = ctx.getSystemService(Context.POWER_SERVICE) as? PowerManager
+                ?: return@Function false
+            pm.isIgnoringBatteryOptimizations(ctx.packageName)
+        }
+
+        AsyncFunction("requestBatteryOptimizationExemption") { promise: Promise ->
+            val ctx = appContext.reactContext ?: run {
+                promise.reject("NO_CONTEXT", "React context is not available", null)
+                return@AsyncFunction
+            }
+            val pm = ctx.getSystemService(Context.POWER_SERVICE) as? PowerManager
+            if (pm == null) {
+                promise.resolve(false)
+                return@AsyncFunction
+            }
+            if (pm.isIgnoringBatteryOptimizations(ctx.packageName)) {
+                promise.resolve(true)
+                return@AsyncFunction
+            }
+            try {
+                val intent = Intent(android.provider.Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS).apply {
+                    data = Uri.parse("package:${ctx.packageName}")
+                    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                }
+                ctx.startActivity(intent)
+                // The system dialog is fire-and-forget; we cannot observe the result
+                // from a non-Activity context. Resolve true to indicate the dialog was shown.
+                promise.resolve(true)
+            } catch (e: Exception) {
+                promise.reject("BATTERY_OPT_ERROR", "Failed to open battery optimization settings: ${e.message}", e)
+            }
+        }
+
         OnDestroy {
             with(this@ExpoBeaconModule) {
                 unregisterEventReceiver()

package/build/ExpoBeaconModule.d.ts

@@ -77,6 +77,18 @@ declare class ExpoBeaconModule extends NativeModule<ExpoBeaconModuleEvents> {
     cancelScan(): void;
     /** Request Bluetooth + Location permissions. Returns true if granted. */
     requestPermissionsAsync(): Promise<boolean>;
+    /**
+     * Check whether the app is exempt from Android battery optimizations.
+     * Always returns true on iOS and web (no equivalent concept).
+     */
+    isBatteryOptimizationExempt(): boolean;
+    /**
+     * Request exemption from Android battery optimizations.
+     * Opens the system dialog asking the user to whitelist this app.
+     * Returns true if the dialog was shown (or already exempt), false on failure.
+     * Always resolves true on iOS and web.
+     */
+    requestBatteryOptimizationExemption(): Promise<boolean>;
     /** Enable SQLite event logging. All beacon events will be persisted to a local database. */
     enableEventLogging(): void;
     /** Disable event logging. Previously logged events are retained. */

package/build/ExpoBeaconModule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ExpoBeaconModule.d.ts","sourceRoot":"","sources":["../src/ExpoBeaconModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAuB,MAAM,MAAM,CAAC;AAEzD,OAAO,EACL,sBAAsB,EACtB,gBAAgB,EAChB,mBAAmB,EACnB,YAAY,EACZ,eAAe,EACf,kBAAkB,EAClB,iBAAiB,EACjB,oBAAoB,EACpB,aAAa,EACd,MAAM,oBAAoB,CAAC;AAE5B,OAAO,OAAO,gBAAiB,SAAQ,YAAY,CAAC,sBAAsB,CAAC;IACzE;;;;;;;;;;;OAWG;IACH,mBAAmB,CACjB,KAAK,CAAC,EAAE,MAAM,EAAE,EAChB,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAE9B;;;;;OAKG;IACH,sBAAsB,CACpB,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,mBAAmB,EAAE,CAAC;IAEjC;;OAEG;IACH,UAAU,CACR,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE,MAAM,EACb,cAAc,CAAC,EAAE,MAAM,GACtB,IAAI;IAEP;;OAEG;IACH,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAEtC;;OAEG;IACH,gBAAgB,IAAI,YAAY,EAAE;IAElC;;OAEG;IACH,aAAa,CACX,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,MAAM,EACb,cAAc,CAAC,EAAE,MAAM,GACtB,IAAI;IAEP;;OAEG;IACH,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAEzC;;OAEG;IACH,mBAAmB,IAAI,eAAe,EAAE;IAExC;;;OAGG;IACH,qBAAqB,CAAC,MAAM,EAAE,kBAAkB,GAAG,IAAI;IAEvD;;;;;;;OAOG;IACH,eAAe,CAAC,OAAO,CAAC,EAAE,iBAAiB,GAAG,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAEpE;;OAEG;IACH,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IAE/B;;;OAGG;IACH,mBAAmB,IAAI,IAAI;IAE3B,iEAAiE;IACjE,kBAAkB,IAAI,IAAI;IAE1B;;;OAGG;IACH,UAAU,IAAI,IAAI;IAElB,yEAAyE;IACzE,uBAAuB,IAAI,OAAO,CAAC,OAAO,CAAC;IAE3C,4FAA4F;IAC5F,kBAAkB,IAAI,IAAI;IAE1B,oEAAoE;IACpE,mBAAmB,IAAI,IAAI;IAE3B;;;OAGG;IACH,YAAY,CAAC,OAAO,CAAC,EAAE,oBAAoB,GAAG,aAAa,EAAE;IAE7D,kDAAkD;IAClD,cAAc,IAAI,IAAI;IAEtB,mEAAmE;IACnE,gBAAgB,IAAI,IAAI;CACzB;;AAED,wBAAmE"}
+{"version":3,"file":"ExpoBeaconModule.d.ts","sourceRoot":"","sources":["../src/ExpoBeaconModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAuB,MAAM,MAAM,CAAC;AAEzD,OAAO,EACL,sBAAsB,EACtB,gBAAgB,EAChB,mBAAmB,EACnB,YAAY,EACZ,eAAe,EACf,kBAAkB,EAClB,iBAAiB,EACjB,oBAAoB,EACpB,aAAa,EACd,MAAM,oBAAoB,CAAC;AAE5B,OAAO,OAAO,gBAAiB,SAAQ,YAAY,CAAC,sBAAsB,CAAC;IACzE;;;;;;;;;;;OAWG;IACH,mBAAmB,CACjB,KAAK,CAAC,EAAE,MAAM,EAAE,EAChB,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAE9B;;;;;OAKG;IACH,sBAAsB,CACpB,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,mBAAmB,EAAE,CAAC;IAEjC;;OAEG;IACH,UAAU,CACR,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE,MAAM,EACb,cAAc,CAAC,EAAE,MAAM,GACtB,IAAI;IAEP;;OAEG;IACH,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAEtC;;OAEG;IACH,gBAAgB,IAAI,YAAY,EAAE;IAElC;;OAEG;IACH,aAAa,CACX,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,MAAM,EACb,cAAc,CAAC,EAAE,MAAM,GACtB,IAAI;IAEP;;OAEG;IACH,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAEzC;;OAEG;IACH,mBAAmB,IAAI,eAAe,EAAE;IAExC;;;OAGG;IACH,qBAAqB,CAAC,MAAM,EAAE,kBAAkB,GAAG,IAAI;IAEvD;;;;;;;OAOG;IACH,eAAe,CAAC,OAAO,CAAC,EAAE,iBAAiB,GAAG,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAEpE;;OAEG;IACH,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IAE/B;;;OAGG;IACH,mBAAmB,IAAI,IAAI;IAE3B,iEAAiE;IACjE,kBAAkB,IAAI,IAAI;IAE1B;;;OAGG;IACH,UAAU,IAAI,IAAI;IAElB,yEAAyE;IACzE,uBAAuB,IAAI,OAAO,CAAC,OAAO,CAAC;IAE3C;;;OAGG;IACH,2BAA2B,IAAI,OAAO;IAEtC;;;;;OAKG;IACH,mCAAmC,IAAI,OAAO,CAAC,OAAO,CAAC;IAEvD,4FAA4F;IAC5F,kBAAkB,IAAI,IAAI;IAE1B,oEAAoE;IACpE,mBAAmB,IAAI,IAAI;IAE3B;;;OAGG;IACH,YAAY,CAAC,OAAO,CAAC,EAAE,oBAAoB,GAAG,aAAa,EAAE;IAE7D,kDAAkD;IAClD,cAAc,IAAI,IAAI;IAEtB,mEAAmE;IACnE,gBAAgB,IAAI,IAAI;CACzB;;AAED,wBAAmE"}

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;AA+IzD,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  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  /** 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\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;AA6JzD,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  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\nexport default requireNativeModule<ExpoBeaconModule>(\"ExpoBeacon\");\r\n"]}

package/build/ExpoBeaconModule.web.d.ts

@@ -20,6 +20,8 @@ declare const stub: {
     getEventLogs: (_options?: EventLogQueryOptions) => EventLogEntry[];
     clearEventLogs: () => void;
     destroyEventLogs: () => void;
+    isBatteryOptimizationExempt: () => boolean;
+    requestBatteryOptimizationExemption: () => Promise<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,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;8BACA,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,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;uCACO,OAAO;+CACC,OAAO,CAAC,OAAO,CAAC;8BAC/B,MAAM,sBAAsB,aAAa,GAAG;;;qCAGrC,MAAM,sBAAsB;CAC9D,CAAC;AAEF,eAAe,IAAI,CAAC"}

package/build/ExpoBeaconModule.web.js

@@ -22,6 +22,8 @@ const stub = {
     getEventLogs: (_options) => notSupported(),
     clearEventLogs: () => notSupported(),
     destroyEventLogs: () => notSupported(),
+    isBatteryOptimizationExempt: () => true,
+    requestBatteryOptimizationExemption: () => Promise.resolve(true),
     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":"AAUA,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,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  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  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":"AAUA,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,2BAA2B,EAAE,GAAY,EAAE,CAAC,IAAI;IAChD,mCAAmC,EAAE,GAAqB,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC;IAClF,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  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  isBatteryOptimizationExempt: (): boolean => true,\r\n  requestBatteryOptimizationExemption: (): Promise<boolean> => Promise.resolve(true),\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/ExpoBeaconModule.swift

@@ -13,8 +13,10 @@ private let NOTIFICATION_CONFIG_KEY = "expo.beacon.notification_config"
 private let EVENT_LOGGING_ENABLED_KEY = "expo.beacon.event_logging_enabled"
 
 /// Number of consecutive ranging misses before emitting a distance-based exit event.
-/// IMPORTANT: Keep in sync with BeaconConstants.kt (Android).
-private let EXIT_MISS_THRESHOLD = 3
+/// With ~1 s CoreLocation ranging cycles, 10 misses ≈ 10 s of silence before
+/// declaring exit — tolerant of brief ranging gaps while still responsive.
+/// NOTE: Android uses the same value but with a different scan cycle (~2.1 s).
+private let EXIT_MISS_THRESHOLD = 10
 /// Number of consecutive readings required to confirm a distance-based enter or exit transition.
 /// IMPORTANT: Keep in sync with BeaconConstants.kt (Android).
 private let HYSTERESIS_COUNT = 3
@@ -22,7 +24,8 @@ private let HYSTERESIS_COUNT = 3
 /// Eddystone monitoring timer interval in seconds.
 private let EDDYSTONE_MONITORING_TICK_INTERVAL: TimeInterval = 2.0
 /// Maximum age (in seconds) before a beacon is considered "not recently seen".
-private let EDDYSTONE_RECENTLY_SEEN_THRESHOLD: TimeInterval = 3.0
+/// Set higher than a few tick intervals to tolerate brief BLE advertisement gaps.
+private let EDDYSTONE_RECENTLY_SEEN_THRESHOLD: TimeInterval = 8.0
 /// Minimum interval between consecutive distance event emissions per identifier.
 private let DISTANCE_EVENT_THROTTLE_INTERVAL: TimeInterval = 1.0
 
@@ -313,6 +316,22 @@ public class ExpoBeaconModule: Module {
                     self.defaults.set(json, forKey: NOTIFICATION_CONFIG_KEY)
                 }
             }
+            if let dist = maxDistance, (!dist.isFinite || dist <= 0) {
+                promise.reject("INVALID_MAX_DISTANCE", "maxDistance must be a finite number greater than 0")
+                return
+            }
+            if let exitDist = exitDistance, (!exitDist.isFinite || exitDist <= 0) {
+                promise.reject("INVALID_EXIT_DISTANCE", "exitDistance must be a finite number greater than 0")
+                return
+            }
+            if exitDistance != nil && maxDistance == nil {
+                promise.reject("INVALID_EXIT_DISTANCE", "exitDistance requires maxDistance to be set")
+                return
+            }
+            if let dist = maxDistance, let exitDist = exitDistance, exitDist < dist {
+                promise.reject("INVALID_EXIT_DISTANCE", "exitDistance must be greater than or equal to maxDistance")
+                return
+            }
             if let dist = maxDistance {
                 self.defaults.set(dist, forKey: MAX_DISTANCE_KEY)
             } else {
@@ -435,6 +454,16 @@ public class ExpoBeaconModule: Module {
             self.eventLogger = nil
         }
 
+        // MARK: - Battery Optimization (Android-only; no-op on iOS)
+
+        Function("isBatteryOptimizationExempt") { () -> Bool in
+            return true
+        }
+
+        AsyncFunction("requestBatteryOptimizationExemption") { (promise: Promise) in
+            promise.resolve(true)
+        }
+
         // MARK: - Lifecycle
 
         OnDestroy {
@@ -744,40 +773,45 @@ public class ExpoBeaconModule: Module {
             // reliably regardless of advertisement rate.
             let maxDist = self.defaults.object(forKey: MAX_DISTANCE_KEY) as? Double
             let exitDist = self.defaults.object(forKey: EXIT_DISTANCE_KEY) as? Double
-            let action = evaluateDistanceHysteresis(
-                identifier: identifier,
-                distance: distance,
-                maxDistance: maxDist,
-                exitDistance: exitDist,
-                entered: &eddystoneEnteredRegions,
-                enterCtrs: &eddystoneEnterCounters,
-                exitCtrs: &eddystoneExitCounters
-            )
-            switch action {
-            case .enter:
-                sendLoggedEvent("onEddystoneEnter", [
-                    "identifier": identifier,
-                    "namespace": ns,
-                    "instance": inst,
-                    "event": "enter",
-                    "distance": distance
-                ])
-                postBeaconNotification(identifier: identifier, eventType: "enter")
-                scheduleEddystoneTimeout(identifier: identifier, namespace: ns, instance: inst)
-            case .exit:
-                cancelEddystoneTimeout(identifier: identifier)
-                sendLoggedEvent("onEddystoneExit", [
-                    "identifier": identifier,
-                    "namespace": ns,
-                    "instance": inst,
-                    "event": "exit",
-                    "distance": distance
-                ])
-                postBeaconNotification(identifier: identifier, eventType: "exit")
-            case .none:
-                break
+            let hasValidDistance = distance.isFinite && distance >= 0
+            if hasValidDistance || maxDist == nil {
+                let action = evaluateDistanceHysteresis(
+                    identifier: identifier,
+                    distance: distance,
+                    maxDistance: maxDist,
+                    exitDistance: exitDist,
+                    entered: &eddystoneEnteredRegions,
+                    enterCtrs: &eddystoneEnterCounters,
+                    exitCtrs: &eddystoneExitCounters
+                )
+                switch action {
+                case .enter:
+                    sendLoggedEvent("onEddystoneEnter", [
+                        "identifier": identifier,
+                        "namespace": ns,
+                        "instance": inst,
+                        "event": "enter",
+                        "distance": distance
+                    ])
+                    postBeaconNotification(identifier: identifier, eventType: "enter")
+                    scheduleEddystoneTimeout(identifier: identifier, namespace: ns, instance: inst)
+                case .exit:
+                    cancelEddystoneTimeout(identifier: identifier)
+                    sendLoggedEvent("onEddystoneExit", [
+                        "identifier": identifier,
+                        "namespace": ns,
+                        "instance": inst,
+                        "event": "exit",
+                        "distance": distance
+                    ])
+                    postBeaconNotification(identifier: identifier, eventType: "exit")
+                case .none:
+                    break
+                }
             }
 
+            guard hasValidDistance else { break }
+
             // Throttle distance events — enter/exit above is evaluated on every
             // callback, but distance events are rate-limited to avoid flooding JS.
             let now = Date()
@@ -967,7 +1001,10 @@ public class ExpoBeaconModule: Module {
                 continue
             }
 
-            // Not seen recently — increment miss counter
+            // Not seen recently — break distance hysteresis streaks and, if the
+            // beacon was already entered, increment miss counter toward exit.
+            eddystoneEnterCounters[identifier] = 0
+            eddystoneExitCounters[identifier] = 0
             guard eddystoneEnteredRegions.contains(identifier) else { continue }
 
             let count = (eddystoneMissCounters[identifier] ?? 0) + 1
@@ -1242,6 +1279,8 @@ public class ExpoBeaconModule: Module {
                 // duplicate events when both monitoring and continuous scan are active.
             } else {
                 // No valid beacon reading — beacon may have disappeared
+                enterCounters[identifier] = 0
+                exitCounters[identifier] = 0
                 let count = (missCounters[identifier] ?? 0) + 1
                 missCounters[identifier] = count
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-beacon",
-  "version": "0.6.3",
+  "version": "0.6.6",
   "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

@@ -122,6 +122,20 @@ declare class ExpoBeaconModule extends NativeModule<ExpoBeaconModuleEvents> {
   /** Request Bluetooth + Location permissions. Returns true if granted. */
   requestPermissionsAsync(): Promise<boolean>;
 
+  /**
+   * Check whether the app is exempt from Android battery optimizations.
+   * Always returns true on iOS and web (no equivalent concept).
+   */
+  isBatteryOptimizationExempt(): boolean;
+
+  /**
+   * Request exemption from Android battery optimizations.
+   * Opens the system dialog asking the user to whitelist this app.
+   * Returns true if the dialog was shown (or already exempt), false on failure.
+   * Always resolves true on iOS and web.
+   */
+  requestBatteryOptimizationExemption(): Promise<boolean>;
+
   /** Enable SQLite event logging. All beacon events will be persisted to a local database. */
   enableEventLogging(): void;
 

package/src/ExpoBeaconModule.web.ts

@@ -47,6 +47,8 @@ const stub = {
   getEventLogs: (_options?: EventLogQueryOptions): EventLogEntry[] => notSupported(),
   clearEventLogs: (): void => notSupported(),
   destroyEventLogs: (): void => notSupported(),
+  isBatteryOptimizationExempt: (): boolean => true,
+  requestBatteryOptimizationExemption: (): Promise<boolean> => Promise.resolve(true),
   addListener: (_eventName: keyof ExpoBeaconModuleEvents, _listener: any) => ({
     remove: () => {},
   }),