expo-beacon 0.6.2 → 0.6.4

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

@@ -10,6 +10,17 @@ internal const val EDDYSTONE_PREFS_NAME = "expo.beacon.paired_eddystones"
 internal const val EDDYSTONE_PREFS_KEY = "paired_eddystones"
 internal const val NOTIFICATION_CONFIG_PREFS = "expo.beacon.notification_config"
 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/BeaconEventLogger.kt

@@ -11,12 +11,30 @@ import org.json.JSONObject
  * Thread-safe — all writes go through a single SQLiteOpenHelper.
  */
 internal class BeaconEventLogger(context: Context) :
-    SQLiteOpenHelper(context, DB_NAME, null, DB_VERSION) {
+    SQLiteOpenHelper(context.applicationContext, DB_NAME, null, DB_VERSION) {
 
     companion object {
         private const val DB_NAME = "expo_beacon_events.db"
         private const val DB_VERSION = 1
         private const val TABLE = "events"
+
+        fun isLoggingEnabled(context: Context): Boolean {
+            return context.applicationContext
+                .getSharedPreferences(EVENT_LOGGING_PREFS, Context.MODE_PRIVATE)
+                .getBoolean(EVENT_LOGGING_ENABLED_KEY, false)
+        }
+
+        fun setLoggingEnabled(context: Context, enabled: Boolean) {
+            context.applicationContext
+                .getSharedPreferences(EVENT_LOGGING_PREFS, Context.MODE_PRIVATE)
+                .edit()
+                .putBoolean(EVENT_LOGGING_ENABLED_KEY, enabled)
+                .apply()
+        }
+
+        fun deleteLogDatabase(context: Context) {
+            context.applicationContext.deleteDatabase(DB_NAME)
+        }
     }
 
     override fun onCreate(db: SQLiteDatabase) {
@@ -90,9 +108,4 @@ internal class BeaconEventLogger(context: Context) :
     fun clearEvents() {
         writableDatabase.delete(TABLE, null, null)
     }
-
-    fun destroyDatabase(context: Context) {
-        close()
-        context.deleteDatabase(DB_NAME)
-    }
 }

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()
@@ -55,6 +57,7 @@ class BeaconForegroundService : Service(), BeaconConsumer {
     private val timeoutRunnables = java.util.concurrent.ConcurrentHashMap<String, Runnable>()
     // Per-beacon timeout seconds lookup (identifier → seconds), loaded from paired data
     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"
@@ -88,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)
         }
     }
 
@@ -155,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) {}
         }
@@ -170,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) {
@@ -199,6 +213,7 @@ class BeaconForegroundService : Service(), BeaconConsumer {
                 null
             )
             monitoredRegions.add(region)
+            monitoredRegionIds.add(region.uniqueId)
             try {
                 beaconManager.startMonitoringBeaconsInRegion(region)
             } catch (ex: RemoteException) {
@@ -223,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) {
@@ -276,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 }
@@ -289,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)
@@ -303,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")
                     }
@@ -348,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
@@ -377,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) {
@@ -404,6 +429,26 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         val id1Str = region.id1?.toString() ?: ""
         val isEddystone = id1Str.startsWith("0x")
 
+        val params = if (isEddystone) {
+            buildMap<String, Any?> {
+                put("identifier", region.uniqueId)
+                put("namespace", id1Str.removePrefix("0x"))
+                put("instance", region.id2?.toString()?.removePrefix("0x") ?: "")
+                put("event", eventType)
+                put("distance", distance)
+            }
+        } else {
+            buildMap<String, Any?> {
+                put("identifier", region.uniqueId)
+                put("uuid", id1Str)
+                put("major", region.id2?.toInt() ?: 0)
+                put("minor", region.id3?.toInt() ?: 0)
+                put("event", eventType)
+                put("distance", distance)
+            }
+        }
+        monitoringEventName(isEddystone, eventType)?.let { logBeaconEvent(it, params) }
+
         val intent = Intent(ACTION_BEACON_EVENT).apply {
             putExtra("identifier", region.uniqueId)
             putExtra("event", eventType)
@@ -424,6 +469,36 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         sendBroadcast(intent)
     }
 
+    private fun monitoringEventName(isEddystone: Boolean, eventType: String): String? {
+        return when (eventType) {
+            "enter" -> if (isEddystone) "onEddystoneEnter" else "onBeaconEnter"
+            "exit" -> if (isEddystone) "onEddystoneExit" else "onBeaconExit"
+            "distance" -> if (isEddystone) "onEddystoneDistance" else "onBeaconDistance"
+            "timeout" -> if (isEddystone) "onEddystoneTimeout" else "onBeaconTimeout"
+            else -> null
+        }
+    }
+
+    @Synchronized
+    private fun getOrCreateEventLogger(): BeaconEventLogger {
+        return eventLogger ?: BeaconEventLogger(applicationContext).also { eventLogger = it }
+    }
+
+    @Synchronized
+    private fun releaseEventLogger() {
+        eventLogger?.close()
+        eventLogger = null
+    }
+
+    private fun logBeaconEvent(eventType: String, params: Map<String, Any?>) {
+        if (!BeaconEventLogger.isLoggingEnabled(this)) {
+            releaseEventLogger()
+            return
+        }
+        val identifier = params["identifier"] as? String
+        getOrCreateEventLogger().logEvent(eventType, identifier, params)
+    }
+
     private fun showEnterExitNotification(region: Region, eventType: String) {
         val config = readNotificationConfig()
         val eventsConfig = config.optJSONObject("beaconEvents")
@@ -527,13 +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())
@@ -385,15 +401,17 @@ class ExpoBeaconModule : Module(), BeaconConsumer {
             if (eventLogger == null) {
                 eventLogger = BeaconEventLogger(ctx)
             }
+            BeaconEventLogger.setLoggingEnabled(ctx, true)
             loggingEnabled = true
         }
 
         Function("disableEventLogging") {
+            appContext.reactContext?.let { BeaconEventLogger.setLoggingEnabled(it, false) }
             loggingEnabled = false
         }
 
         Function("getEventLogs") { options: Map<String, Any?>? ->
-            val logger = eventLogger ?: return@Function emptyList<Map<String, Any?>>()
+            val logger = getOrCreateEventLogger() ?: return@Function emptyList<Map<String, Any?>>()
             val limit = (options?.get("limit") as? Number)?.toInt() ?: 1000
             val eventType = options?.get("eventType") as? String
             val sinceTimestamp = (options?.get("sinceTimestamp") as? Number)?.toLong()
@@ -401,14 +419,16 @@ class ExpoBeaconModule : Module(), BeaconConsumer {
         }
 
         Function("clearEventLogs") {
-            eventLogger?.clearEvents()
+            getOrCreateEventLogger()?.clearEvents()
         }
 
         Function("destroyEventLogs") {
             loggingEnabled = false
             val ctx = appContext.reactContext ?: return@Function null
-            eventLogger?.destroyDatabase(ctx)
+            BeaconEventLogger.setLoggingEnabled(ctx, false)
+            eventLogger?.close()
             eventLogger = null
+            BeaconEventLogger.deleteLogDatabase(ctx)
         }
 
         OnDestroy {
@@ -699,7 +719,6 @@ class ExpoBeaconModule : Module(), BeaconConsumer {
     private fun registerEventReceiver() {
         if (eventReceiver != null) return
         val receiver = BeaconEventReceiver { eventName, params ->
-            logBeaconEvent(eventName, params)
             sendEvent(eventName, params)
         }
         eventReceiver = receiver
@@ -740,10 +759,26 @@ class ExpoBeaconModule : Module(), BeaconConsumer {
         }
     }
 
+    private fun getOrCreateEventLogger(): BeaconEventLogger? {
+        val context = appContext.reactContext ?: return null
+        return eventLogger ?: BeaconEventLogger(context).also { eventLogger = it }
+    }
+
+    private fun isEventLoggingEnabled(): Boolean {
+        if (loggingEnabled) return true
+        val context = appContext.reactContext ?: return false
+        if (!BeaconEventLogger.isLoggingEnabled(context)) return false
+        loggingEnabled = true
+        if (eventLogger == null) {
+            eventLogger = BeaconEventLogger(context)
+        }
+        return true
+    }
+
     /** Log an event to SQLite if logging is enabled. */
     private fun logBeaconEvent(eventType: String, params: Map<String, Any?>) {
-        if (!loggingEnabled) return
+        if (!isEventLoggingEnabled()) return
         val identifier = params["identifier"] as? String
-        eventLogger?.logEvent(eventType, identifier, params)
+        getOrCreateEventLogger()?.logEvent(eventType, identifier, params)
     }
 }

package/ios/BeaconEventLogger.swift

@@ -4,17 +4,28 @@ import SQLite3
 /// SQLite-backed event logger for beacon events (iOS).
 /// All access is expected from the main thread (same as ExpoBeaconModule).
 final class BeaconEventLogger {
+    private static let databaseFileName = "expo_beacon_events.db"
+
+    private static var databaseURL: URL {
+        let dir = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask).first!
+        return dir.appendingPathComponent(databaseFileName)
+    }
+
     private var db: OpaquePointer?
     private let dbPath: String
 
     init() {
-        let dir = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask).first!
+        let dir = Self.databaseURL.deletingLastPathComponent()
         try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
-        dbPath = dir.appendingPathComponent("expo_beacon_events.db").path
+        dbPath = Self.databaseURL.path
         openDatabase()
         createTableIfNeeded()
     }
 
+    static func destroyPersistentStore() {
+        try? FileManager.default.removeItem(at: databaseURL)
+    }
+
     private func openDatabase() {
         guard sqlite3_open(dbPath, &db) == SQLITE_OK else {
             print("[ExpoBeacon] Failed to open event log database")
@@ -126,7 +137,7 @@ final class BeaconEventLogger {
             sqlite3_close(db)
             db = nil
         }
-        try? FileManager.default.removeItem(atPath: dbPath)
+        Self.destroyPersistentStore()
     }
 
     deinit {

package/ios/ExpoBeaconModule.swift

@@ -10,6 +10,7 @@ private let IS_MONITORING_KEY = "expo.beacon.is_monitoring"
 private let MAX_DISTANCE_KEY = "expo.beacon.max_distance"
 private let EXIT_DISTANCE_KEY = "expo.beacon.exit_distance"
 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).
@@ -312,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 {
@@ -402,15 +419,17 @@ public class ExpoBeaconModule: Module {
             if self.eventLogger == nil {
                 self.eventLogger = BeaconEventLogger()
             }
+            self.defaults.set(true, forKey: EVENT_LOGGING_ENABLED_KEY)
             self.loggingEnabled = true
         }
 
         Function("disableEventLogging") { () -> Void in
+            self.defaults.set(false, forKey: EVENT_LOGGING_ENABLED_KEY)
             self.loggingEnabled = false
         }
 
         Function("getEventLogs") { (options: [String: Any]?) -> [[String: Any]] in
-            guard let logger = self.eventLogger else { return [] }
+            let logger = self.getOrCreateEventLogger()
             let limit = (options?["limit"] as? Int) ?? 1000
             let eventType = options?["eventType"] as? String
             let sinceTimestamp: Int64? = (options?["sinceTimestamp"] as? NSNumber)?.int64Value
@@ -418,12 +437,17 @@ public class ExpoBeaconModule: Module {
         }
 
         Function("clearEventLogs") { () -> Void in
-            self.eventLogger?.clearEvents()
+            self.getOrCreateEventLogger().clearEvents()
         }
 
         Function("destroyEventLogs") { () -> Void in
+            self.defaults.set(false, forKey: EVENT_LOGGING_ENABLED_KEY)
             self.loggingEnabled = false
-            self.eventLogger?.destroy()
+            if let logger = self.eventLogger {
+                logger.destroy()
+            } else {
+                BeaconEventLogger.destroyPersistentStore()
+            }
             self.eventLogger = nil
         }
 
@@ -736,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()
@@ -855,13 +884,36 @@ public class ExpoBeaconModule: Module {
 
     /// Sends an event to JS and logs it to SQLite if logging is enabled.
     private func sendLoggedEvent(_ eventName: String, _ params: [String: Any]) {
-        if loggingEnabled {
+        if isEventLoggingEnabled() {
             let identifier = params["identifier"] as? String
-            eventLogger?.logEvent(eventType: eventName, identifier: identifier, data: params)
+            getOrCreateEventLogger().logEvent(eventType: eventName, identifier: identifier, data: params)
         }
         sendEvent(eventName, params)
     }
 
+    private func getOrCreateEventLogger() -> BeaconEventLogger {
+        if let logger = eventLogger {
+            return logger
+        }
+        let logger = BeaconEventLogger()
+        eventLogger = logger
+        return logger
+    }
+
+    private func isEventLoggingEnabled() -> Bool {
+        if loggingEnabled {
+            return true
+        }
+        guard defaults.bool(forKey: EVENT_LOGGING_ENABLED_KEY) else {
+            return false
+        }
+        loggingEnabled = true
+        if eventLogger == nil {
+            eventLogger = BeaconEventLogger()
+        }
+        return true
+    }
+
     private func loadPairedBeaconsRaw() -> [[String: Any]] {
         if let cached = cachedPairedBeacons { return cached }
         let value = self.defaults.array(forKey: PAIRED_BEACONS_KEY) as? [[String: Any]] ?? []
@@ -881,7 +933,8 @@ public class ExpoBeaconModule: Module {
         guard !defaults.bool(forKey: migrationKey) else { return }
         let keysToMigrate = [
             PAIRED_BEACONS_KEY, PAIRED_EDDYSTONES_KEY,
-            IS_MONITORING_KEY, MAX_DISTANCE_KEY, NOTIFICATION_CONFIG_KEY
+            IS_MONITORING_KEY, MAX_DISTANCE_KEY, NOTIFICATION_CONFIG_KEY,
+            EVENT_LOGGING_ENABLED_KEY
         ]
         for key in keysToMigrate {
             if let value = UserDefaults.standard.object(forKey: key) {

package/package.json

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