expo-beacon 0.6.10 → 0.6.12

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

@@ -459,8 +459,10 @@ class BeaconForegroundService : Service(), BeaconConsumer {
 
     private fun scheduleTimeoutIfConfigured(region: Region) {
         val seconds = beaconTimeouts[region.uniqueId] ?: return
-        // Cancel any existing timer (shouldn't happen, but be safe)
-        cancelTimeout(region.uniqueId)
+        // If a timer is already running, don't reset it. Miss-based exits clear
+        // enteredRegions without cancelling the timer, so a subsequent re-entry
+        // must not restart the clock — doing so would defer the timeout indefinitely.
+        if (timeoutRunnables.containsKey(region.uniqueId)) return
         val runnable = Runnable {
             timeoutRunnables.remove(region.uniqueId)
             // Fire unconditionally. A miss-based exit may have cleared enteredRegions before

package/ios/ExpoBeaconModule.swift

@@ -850,6 +850,7 @@ public class ExpoBeaconModule: Module {
                     postBeaconNotification(identifier: identifier, eventType: "enter")
                     scheduleEddystoneTimeout(identifier: identifier, namespace: ns, instance: inst)
                 case .exit:
+                    smoothedDistances.removeValue(forKey: identifier)
                     cancelEddystoneTimeout(identifier: identifier)
                     sendLoggedEvent("onEddystoneExit", [
                         "identifier": identifier,
@@ -1078,7 +1079,8 @@ public class ExpoBeaconModule: Module {
                 eddystoneEnterCounters[identifier] = 0
                 eddystoneExitCounters[identifier] = 0
                 eddystoneLatestSeen.removeValue(forKey: identifier)
-                cancelEddystoneTimeout(identifier: identifier)
+                smoothedDistances.removeValue(forKey: identifier)
+                // Do NOT cancel the timeout here — same reason as iBeacon miss-based exit.
 
                 let ns = paired["namespace"] as? String ?? ""
                 let inst = paired["instance"] as? String ?? ""
@@ -1098,9 +1100,10 @@ public class ExpoBeaconModule: Module {
     // MARK: - Timeout timer helpers
 
     private func scheduleBeaconTimeout(identifier: String, beacon: CLBeacon) {
-        // Cancel any existing timer for this identifier (shouldn't happen, but be safe)
-        beaconTimeoutTimers[identifier]?.cancel()
-        beaconTimeoutTimers.removeValue(forKey: identifier)
+        // If a timer is already running, don't reset it. Miss-based exits clear
+        // enteredRegions without cancelling the timer, so a subsequent re-entry
+        // must not restart the clock — doing so would defer the timeout indefinitely.
+        guard beaconTimeoutTimers[identifier] == nil else { return }
 
         let paired = loadPairedBeaconsRaw().first { ($0["identifier"] as? String) == identifier }
         guard let seconds = paired?["timeoutSeconds"] as? Int, seconds > 0 else { return }
@@ -1108,8 +1111,10 @@ public class ExpoBeaconModule: Module {
         let work = DispatchWorkItem { [weak self] in
             guard let self = self else { return }
             self.beaconTimeoutTimers.removeValue(forKey: identifier)
-            // Only fire if the beacon is still in range
-            guard self.enteredRegions.contains(identifier) else { return }
+            // Fire unconditionally. A miss-based exit may have cleared enteredRegions before
+            // the timer elapsed (ranging gaps can cause false exits), but the beacon may still
+            // be physically present. Distance-based exits call cancelBeaconTimeout() so this
+            // work item is cancelled before it runs on genuine out-of-range departures.
             self.sendLoggedEvent("onBeaconTimeout", self.makeBeaconEventParams(identifier: identifier, beacon: beacon))
         }
         beaconTimeoutTimers[identifier] = work
@@ -1121,8 +1126,8 @@ public class ExpoBeaconModule: Module {
     }
 
     private func scheduleEddystoneTimeout(identifier: String, namespace: String, instance: String) {
-        eddystoneTimeoutTimers[identifier]?.cancel()
-        eddystoneTimeoutTimers.removeValue(forKey: identifier)
+        // If a timer is already running, don't reset it — same reason as iBeacon timeout.
+        guard eddystoneTimeoutTimers[identifier] == nil else { return }
 
         let paired = loadPairedEddystonesRaw().first { ($0["identifier"] as? String) == identifier }
         guard let seconds = paired?["timeoutSeconds"] as? Int, seconds > 0 else { return }
@@ -1130,7 +1135,7 @@ public class ExpoBeaconModule: Module {
         let work = DispatchWorkItem { [weak self] in
             guard let self = self else { return }
             self.eddystoneTimeoutTimers.removeValue(forKey: identifier)
-            guard self.eddystoneEnteredRegions.contains(identifier) else { return }
+            // Fire unconditionally — same reason as iBeacon timeout.
             self.sendLoggedEvent("onEddystoneTimeout", [
                 "identifier": identifier,
                 "namespace": namespace,
@@ -1195,16 +1200,21 @@ public class ExpoBeaconModule: Module {
     // MARK: - Distance smoothing + enter/exit hysteresis
 
     /// Apply exponential moving average (EMA) smoothing to a raw distance reading.
-    /// Returns nil if the reading is a jump outlier (raw differs from smoothed by > DISTANCE_JUMP_FACTOR).
+    /// If the reading is a large jump (> DISTANCE_JUMP_FACTOR), resets the EMA to the new
+    /// value instead of rejecting it — this ensures distance events keep flowing when the
+    /// user moves away from a beacon, rather than freezing because the EMA is stuck at the
+    /// old close-range value and every new far-range reading is rejected.
     private func smoothDistance(identifier: String, rawDistance: Double) -> Double? {
         guard let prev = smoothedDistances[identifier] else {
             smoothedDistances[identifier] = rawDistance
             return rawDistance
         }
-        // Jump guard: if the raw value is wildly different, treat as outlier
+        // Jump guard: if the raw value is wildly different, reset EMA to the new reading
+        // so the hysteresis pipeline keeps receiving data and can fire the exit event.
         let ratio = prev > 0.001 ? rawDistance / prev : rawDistance
         if ratio > Self.DISTANCE_JUMP_FACTOR || (ratio > 0 && ratio < 1.0 / Self.DISTANCE_JUMP_FACTOR) {
-            return nil
+            smoothedDistances[identifier] = rawDistance
+            return rawDistance
         }
         let smoothed = Self.DISTANCE_EMA_ALPHA * rawDistance + (1 - Self.DISTANCE_EMA_ALPHA) * prev
         smoothedDistances[identifier] = smoothed
@@ -1354,6 +1364,7 @@ public class ExpoBeaconModule: Module {
                     postBeaconNotification(identifier: identifier, eventType: "enter")
                     scheduleBeaconTimeout(identifier: identifier, beacon: beacon)
                 case .exit:
+                    smoothedDistances.removeValue(forKey: identifier)
                     cancelBeaconTimeout(identifier: identifier)
                     sendLoggedEvent("onBeaconExit", makeBeaconEventParams(identifier: identifier, beacon: beacon, event: "exit"))
                     postBeaconNotification(identifier: identifier, eventType: "exit")
@@ -1377,7 +1388,12 @@ public class ExpoBeaconModule: Module {
                     missCounters[identifier] = 0
                     enterCounters[identifier] = 0
                     exitCounters[identifier] = 0
-                    cancelBeaconTimeout(identifier: identifier)
+                    smoothedDistances.removeValue(forKey: identifier)
+                    // Do NOT cancel the timeout here. A miss-based exit is triggered by
+                    // ranging gaps (e.g. accuracy == -1), not a confirmed physical departure.
+                    // Cancelling here prevents the timeout from firing when it is longer than
+                    // the miss window. Distance-based exits call cancelBeaconTimeout() so the
+                    // timer is still cancelled on genuine out-of-range events.
 
                     // Look up region info for the exit event payload
                     let region = monitoredRegions.first { $0.identifier == identifier }
@@ -1423,6 +1439,7 @@ public class ExpoBeaconModule: Module {
         enterCounters.removeValue(forKey: identifier)
         exitCounters.removeValue(forKey: identifier)
         missCounters.removeValue(forKey: identifier)
+        smoothedDistances.removeValue(forKey: identifier)
         if wasEntered {
             cancelBeaconTimeout(identifier: identifier)
             sendLoggedEvent("onBeaconExit", makeBeaconEventParams(identifier: identifier, region: beaconRegion, event: "exit"))

package/package.json

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