expo-beacon 0.6.3 → 0.6.4

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

@@ -13,6 +13,15 @@ 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"
 
+/** 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. */
+internal const val MONITORING_BETWEEN_SCAN_PERIOD_MS = 0L
+
+/** Ignore monitor-based exits if ranging saw the beacon within this window. */
+internal const val RECENT_RANGING_SIGHTING_GRACE_MS = 4000L
+
 /** Number of consecutive ranging misses before emitting a distance-based exit event. */
 internal const val EXIT_MISS_THRESHOLD = 3
 

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
@@ -34,8 +35,9 @@ class BeaconForegroundService : Service(), BeaconConsumer {
     // 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()
@@ -89,10 +91,10 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         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)
         }
     }
 
@@ -156,6 +158,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 +183,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 +213,7 @@ class BeaconForegroundService : Service(), BeaconConsumer {
                 null
             )
             monitoredRegions.add(region)
+            monitoredRegionIds.add(region.uniqueId)
             try {
                 beaconManager.startMonitoringBeaconsInRegion(region)
             } catch (ex: RemoteException) {
@@ -224,51 +238,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 +282,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 +295,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,7 +309,6 @@ class BeaconForegroundService : Service(), BeaconConsumer {
                     HysteresisAction.EXIT -> {
                         cancelTimeout(region.uniqueId)
                         enteredRegions.remove(region.uniqueId)
-                        rangingRegions.add(region)
                         sendBeaconBroadcast(region, "exit", beacon.distance)
                         showEnterExitNotification(region, "exit")
                     }
@@ -349,8 +353,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 +397,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) {
@@ -578,14 +602,12 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         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) {}
         }

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

@@ -294,6 +294,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())

package/ios/ExpoBeaconModule.swift

@@ -313,6 +313,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 {
@@ -744,40 +760,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()

package/package.json

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