expo-beacon 0.6.2 → 0.6.3

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

@@ -10,6 +10,8 @@ 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"
 
 /** 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

@@ -55,6 +55,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"
@@ -404,6 +405,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 +445,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,6 +578,7 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         timeoutHandler.removeCallbacksAndMessages(null)
         timeoutRunnables.clear()
         beaconTimeouts.clear()
+        releaseEventLogger()
         beaconManager.removeMonitorNotifier(monitorNotifier)
         beaconManager.removeRangeNotifier(rangeNotifier)
         beaconManager.removeRangeNotifier(distanceLoggingRangeNotifier)

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

@@ -385,15 +385,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 +403,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 +703,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 +743,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).
@@ -402,15 +403,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 +421,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
         }
 
@@ -855,13 +863,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 +912,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.3",
   "description": "Expo module for scanning, pairing, and monitoring iBeacons on Android and iOS",
   "main": "build/index.js",
   "types": "build/index.d.ts",