expo-beacon 0.7.1 → 0.7.3

package/android/src/main/AndroidManifest.xml

@@ -48,13 +48,17 @@
             android:foregroundServiceType="connectedDevice"
             android:exported="false" />
 
-        <!-- Restart monitoring after boot -->
+        <!-- Restart monitoring after boot.
+             android:exported="true" is required for the system to deliver BOOT_COMPLETED.
+             No android:permission — the incorrect RECEIVE_BOOT_COMPLETED attribute was
+             restricting incoming broadcasts instead of restricting who can receive them. -->
         <receiver
             android:name="expo.modules.beacon.BootReceiver"
-            android:exported="true"
-            android:permission="android.permission.RECEIVE_BOOT_COMPLETED">
+            android:exported="true">
             <intent-filter>
                 <action android:name="android.intent.action.BOOT_COMPLETED" />
+                <!-- Self-scheduled retry when BT isn't ready at boot -->
+                <action android:name="expo.modules.beacon.ACTION_RETRY_MONITORING" />
             </intent-filter>
         </receiver>
     </application>

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

@@ -0,0 +1,17 @@
+package expo.modules.beacon
+
+/**
+ * Implement this interface in your app to react to beacon enter/exit events at the native level.
+ *
+ * Register your implementation via [BeaconPluginRegistry.register] from MainApplication.onCreate().
+ * Unregister via [BeaconPluginRegistry.unregister] if the plugin has a scoped lifetime.
+ */
+interface BeaconEventPlugin {
+    // iBeacon
+    fun onBeaconEnter(identifier: String, uuid: String, major: Int, minor: Int, distance: Double)
+    fun onBeaconExit(identifier: String, uuid: String, major: Int, minor: Int, distance: Double)
+
+    // Eddystone
+    fun onEddystoneEnter(identifier: String, namespace: String, instance: String, distance: Double)
+    fun onEddystoneExit(identifier: String, namespace: String, instance: String, distance: Double)
+}

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

@@ -112,10 +112,17 @@ class BeaconForegroundService : Service(), BeaconConsumer {
                 startForeground(FOREGROUND_NOTIF_ID, buildForegroundNotification())
             }
         } catch (e: Exception) {
-            // SecurityException on Android 14+ if BT permissions missing,
-            // or other platform-specific issues. Stop gracefully instead of crashing.
-            Log.e(TAG, "startForeground failed — stopping service", e)
-            sendErrorBroadcast(null, "SERVICE_START_FAILED", "startForeground failed — stopping service: ${e.message}")
+            // SecurityException on Android 14+ if BT runtime permissions weren't yet granted,
+            // or ForegroundServiceStartNotAllowedException on Android 12+ / Android 17 beta
+            // if the service start window was missed (e.g. BT not yet initialized at boot).
+            val retryCount = intent?.getIntExtra(EXTRA_RETRY_COUNT, 0) ?: 0
+            Log.e(TAG, "startForeground failed (retry=$retryCount) — stopping service", e)
+            sendErrorBroadcast(null, "SERVICE_START_FAILED", "startForeground failed (retry=$retryCount): ${e.message}")
+            // Schedule a retry so monitoring can recover without user interaction, capped to
+            // avoid infinite crash loops. Only retry if monitoring should still be active.
+            if (retryCount < MAX_STARTFOREGROUND_RETRIES && isMonitoringActive(this)) {
+                scheduleServiceRetry(retryCount + 1)
+            }
             stopSelf()
             return START_NOT_STICKY
         }
@@ -129,6 +136,43 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         return START_STICKY
     }
 
+    /**
+     * Schedules a one-shot alarm to restart this service via startForegroundService().
+     * Used when startForeground() fails transiently (e.g. BT not yet ready at boot).
+     */
+    private fun scheduleServiceRetry(retryCount: Int) {
+        val alarmManager = getSystemService(AlarmManager::class.java) ?: return
+        val retryIntent = Intent(this, BeaconForegroundService::class.java)
+            .putExtra(EXTRA_RETRY_COUNT, retryCount)
+        val pendingIntent = PendingIntent.getService(
+            this,
+            RETRY_SERVICE_REQUEST_CODE,
+            retryIntent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+        alarmManager.setExactAndAllowWhileIdle(
+            AlarmManager.ELAPSED_REALTIME_WAKEUP,
+            SystemClock.elapsedRealtime() + RETRY_DELAY_MS,
+            pendingIntent
+        )
+        Log.w(TAG, "startForeground retry $retryCount scheduled in ${RETRY_DELAY_MS}ms")
+    }
+
+    /**
+     * Called by the system on Android 14+ (API 34) if a foreground service with a time-limited
+     * type exceeds its allowed duration. connectedDevice has no documented time limit as of
+     * Android 17, but this override ensures we handle a future limit gracefully rather than
+     * receiving an ANR.
+     */
+    @Suppress("NewApi")
+    override fun onTimeout(startId: Int, fgsType: Int) {
+        Log.w(TAG, "BeaconForegroundService.onTimeout(startId=$startId, fgsType=$fgsType) — scheduling restart")
+        if (isMonitoringActive(this)) {
+            scheduleServiceRetry(0)
+        }
+        stopSelf()
+    }
+
     override fun onBeaconServiceConnect() {
         serviceConnected = true
         // Read max distance, exit distance, and min RSSI from options prefs
@@ -570,6 +614,21 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         // Forward all produced events to remote API
         apiForwarder?.forwardEvent(params)
 
+        // Dispatch enter/exit to registered plugins (e.g. to start/stop BGLocation)
+        if (eventType == "enter" || eventType == "exit") {
+            val identifier = region.uniqueId
+            val uuid = if (!isEddystone) id1Str else ""
+            val major = if (!isEddystone) region.id2?.toInt() ?: 0 else 0
+            val minor = if (!isEddystone) region.id3?.toInt() ?: 0 else 0
+            val namespace = if (isEddystone) id1Str.removePrefix("0x") else ""
+            val instance = if (isEddystone) region.id2?.toString()?.removePrefix("0x") ?: "" else ""
+            if (eventType == "enter") {
+                BeaconPluginRegistry.dispatchEnter(isEddystone, identifier, uuid, major, minor, namespace, instance, distance)
+            } else {
+                BeaconPluginRegistry.dispatchExit(isEddystone, identifier, uuid, major, minor, namespace, instance, distance)
+            }
+        }
+
         val intent = Intent(ACTION_BEACON_EVENT).apply {
             putExtra("identifier", region.uniqueId)
             putExtra("event", eventType)
@@ -736,6 +795,10 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         const val DISTANCE_JUMP_FACTOR = 5.0
 
         private const val PREF_IS_MONITORING = "expo.beacon.is_monitoring"
+        private const val EXTRA_RETRY_COUNT = "retryCount"
+        private const val MAX_STARTFOREGROUND_RETRIES = 3
+        private const val RETRY_DELAY_MS = 10_000L
+        private const val RETRY_SERVICE_REQUEST_CODE = 0x42454143 // "BEAC"
         @Volatile private var activeService: BeaconForegroundService? = null
 
         fun start(context: Context) {

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

@@ -0,0 +1,61 @@
+package expo.modules.beacon
+
+import java.util.concurrent.CopyOnWriteArrayList
+
+/**
+ * Thread-safe singleton registry for [BeaconEventPlugin] implementations.
+ *
+ * Register your plugin once from MainApplication.onCreate():
+ *   BeaconPluginRegistry.register(MyBeaconPlugin(this))
+ *
+ * If no plugins are registered, all dispatch calls are no-ops.
+ */
+object BeaconPluginRegistry {
+    private val plugins = CopyOnWriteArrayList<BeaconEventPlugin>()
+
+    fun register(plugin: BeaconEventPlugin) {
+        plugins.add(plugin)
+    }
+
+    fun unregister(plugin: BeaconEventPlugin) {
+        plugins.remove(plugin)
+    }
+
+    internal fun dispatchEnter(
+        isEddystone: Boolean,
+        identifier: String,
+        uuid: String,
+        major: Int,
+        minor: Int,
+        namespace: String,
+        instance: String,
+        distance: Double,
+    ) {
+        plugins.forEach { plugin ->
+            if (isEddystone) {
+                plugin.onEddystoneEnter(identifier, namespace, instance, distance)
+            } else {
+                plugin.onBeaconEnter(identifier, uuid, major, minor, distance)
+            }
+        }
+    }
+
+    internal fun dispatchExit(
+        isEddystone: Boolean,
+        identifier: String,
+        uuid: String,
+        major: Int,
+        minor: Int,
+        namespace: String,
+        instance: String,
+        distance: Double,
+    ) {
+        plugins.forEach { plugin ->
+            if (isEddystone) {
+                plugin.onEddystoneExit(identifier, namespace, instance, distance)
+            } else {
+                plugin.onBeaconExit(identifier, uuid, major, minor, distance)
+            }
+        }
+    }
+}

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

@@ -1,17 +1,89 @@
 package expo.modules.beacon
 
+import android.app.ActivityManager
+import android.app.AlarmManager
+import android.app.PendingIntent
 import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
+import android.os.Build
+import android.os.SystemClock
+import android.util.Log
+
+private const val ACTION_RETRY_MONITORING = "expo.modules.beacon.ACTION_RETRY_MONITORING"
+private const val RETRY_DELAY_MS = 10_000L
+private const val RETRY_REQUEST_CODE = 0x424F4F54 // "BOOT"
 
 /**
  * Restarts beacon monitoring after device reboot if it was active before shutdown.
+ *
+ * Also handles ACTION_RETRY_MONITORING — a self-scheduled alarm used to retry the
+ * service start if Bluetooth is not yet fully initialized when BOOT_COMPLETED fires
+ * (observed on Android 17 beta where startForegroundService() throws SecurityException
+ * or ForegroundServiceStartNotAllowedException shortly after boot).
  */
 class BootReceiver : BroadcastReceiver() {
     override fun onReceive(context: Context, intent: Intent) {
-        if (intent.action == Intent.ACTION_BOOT_COMPLETED) {
-            if (BeaconForegroundService.isMonitoringActive(context)) {
-                BeaconForegroundService.start(context)
+        when (intent.action) {
+            Intent.ACTION_BOOT_COMPLETED -> {
+                logMemoryKillDiagnostics(context)
+                if (BeaconForegroundService.isMonitoringActive(context)) {
+                    tryStartService(context)
+                }
+            }
+            ACTION_RETRY_MONITORING -> {
+                if (BeaconForegroundService.isMonitoringActive(context)) {
+                    tryStartService(context)
+                }
+            }
+        }
+    }
+
+    private fun tryStartService(context: Context) {
+        try {
+            BeaconForegroundService.start(context)
+            Log.d(TAG, "BootReceiver: BeaconForegroundService started successfully")
+        } catch (e: SecurityException) {
+            // ForegroundServiceStartNotAllowedException extends SecurityException.
+            // Can occur on Android 17 beta if Bluetooth is not yet fully initialized at boot.
+            Log.e(TAG, "BootReceiver: Failed to start service (SecurityException) — retrying in ${RETRY_DELAY_MS}ms", e)
+            scheduleRetry(context)
+        } catch (e: Exception) {
+            Log.e(TAG, "BootReceiver: Failed to start service — retrying in ${RETRY_DELAY_MS}ms", e)
+            scheduleRetry(context)
+        }
+    }
+
+    private fun scheduleRetry(context: Context) {
+        val alarmManager = context.getSystemService(AlarmManager::class.java) ?: return
+        val retryIntent = Intent(context, BootReceiver::class.java).apply {
+            action = ACTION_RETRY_MONITORING
+        }
+        val pendingIntent = PendingIntent.getBroadcast(
+            context,
+            RETRY_REQUEST_CODE,
+            retryIntent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+        alarmManager.setExactAndAllowWhileIdle(
+            AlarmManager.ELAPSED_REALTIME_WAKEUP,
+            SystemClock.elapsedRealtime() + RETRY_DELAY_MS,
+            pendingIntent
+        )
+    }
+
+    /**
+     * Logs if the previous process was killed by Android 17's app memory limits
+     * (ApplicationExitInfo.description contains "MemoryLimiter") so the cause is
+     * visible in Logcat when the service restarts after being killed.
+     */
+    private fun logMemoryKillDiagnostics(context: Context) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            val am = context.getSystemService(ActivityManager::class.java)
+            am?.getHistoricalProcessExitReasons(null, 0, 5)?.forEach { info ->
+                if (info.description?.contains("MemoryLimiter") == true) {
+                    Log.w(TAG, "BootReceiver: previous process killed by Android 17 memory limits: ${info.description}")
+                }
             }
         }
     }

package/ios/BeaconLifecycleDelegate.swift

@@ -0,0 +1,54 @@
+/// Implement this protocol in your app to react to beacon enter/exit events at the native level.
+///
+/// Register your implementation once, before the Expo module is created:
+///   BeaconLifecycleRegistry.register(MyPlugin())
+///
+/// The registry holds a strong reference — register early (e.g. AppDelegate.didFinishLaunching
+/// before super, or in a +load / initialize method).
+public protocol BeaconLifecycleDelegate: AnyObject {
+    // MARK: iBeacon
+    func beaconDidEnter(identifier: String, uuid: String, major: Int, minor: Int, distance: Double)
+    func beaconDidExit(identifier: String, uuid: String, major: Int, minor: Int, distance: Double)
+
+    // MARK: Eddystone
+    func eddystoneDidEnter(identifier: String, namespace: String, instance: String, distance: Double)
+    func eddystoneDidExit(identifier: String, namespace: String, instance: String, distance: Double)
+}
+
+/// Thread-safe registry for [BeaconLifecycleDelegate] plugins.
+/// Mirrors the Android BeaconPluginRegistry pattern so both platforms use the same app-side wiring.
+public final class BeaconLifecycleRegistry {
+    public static let shared = BeaconLifecycleRegistry()
+    private init() {}
+
+    private let lock = NSLock()
+    private var plugins: [any BeaconLifecycleDelegate] = []
+
+    public static func register(_ plugin: any BeaconLifecycleDelegate) {
+        shared.lock.lock(); defer { shared.lock.unlock() }
+        shared.plugins.append(plugin)
+    }
+
+    public static func unregister(_ plugin: any BeaconLifecycleDelegate) {
+        shared.lock.lock(); defer { shared.lock.unlock() }
+        shared.plugins.removeAll { $0 === plugin }
+    }
+
+    internal func dispatchEnter(identifier: String, uuid: String, major: Int, minor: Int, distance: Double) {
+        snapshot().forEach { $0.beaconDidEnter(identifier: identifier, uuid: uuid, major: major, minor: minor, distance: distance) }
+    }
+    internal func dispatchExit(identifier: String, uuid: String, major: Int, minor: Int, distance: Double) {
+        snapshot().forEach { $0.beaconDidExit(identifier: identifier, uuid: uuid, major: major, minor: minor, distance: distance) }
+    }
+    internal func dispatchEddystoneEnter(identifier: String, namespace: String, instance: String, distance: Double) {
+        snapshot().forEach { $0.eddystoneDidEnter(identifier: identifier, namespace: namespace, instance: instance, distance: distance) }
+    }
+    internal func dispatchEddystoneExit(identifier: String, namespace: String, instance: String, distance: Double) {
+        snapshot().forEach { $0.eddystoneDidExit(identifier: identifier, namespace: namespace, instance: instance, distance: distance) }
+    }
+
+    private func snapshot() -> [any BeaconLifecycleDelegate] {
+        lock.lock(); defer { lock.unlock() }
+        return plugins
+    }
+}

package/ios/ExpoBeaconModule.swift

@@ -123,6 +123,8 @@ public class ExpoBeaconModule: Module {
     private var eventLogger: BeaconEventLogger?
     private var loggingEnabled = false
 
+
+
     // Native API forwarder (fire-and-forget HTTP)
     private lazy var apiForwarder = BeaconApiForwarder(defaults: defaults)
 
@@ -1038,9 +1040,51 @@ public class ExpoBeaconModule: Module {
         }
         // Forward all produced events to remote API
         apiForwarder.forwardEvent(params)
+        // Dispatch enter/exit to registered plugins (e.g. to start/stop BGLocation)
+        dispatchToLifecycleRegistry(eventName: eventName, params: params)
         sendEvent(eventName, params)
     }
 
+    private func dispatchToLifecycleRegistry(eventName: String, params: [String: Any]) {
+        let r = BeaconLifecycleRegistry.shared
+        let identifier = params["identifier"] as? String ?? ""
+        let distance = params["distance"] as? Double ?? -1.0
+        switch eventName {
+        case "onBeaconEnter":
+            r.dispatchEnter(
+                identifier: identifier,
+                uuid: params["uuid"] as? String ?? "",
+                major: params["major"] as? Int ?? 0,
+                minor: params["minor"] as? Int ?? 0,
+                distance: distance
+            )
+        case "onBeaconExit":
+            r.dispatchExit(
+                identifier: identifier,
+                uuid: params["uuid"] as? String ?? "",
+                major: params["major"] as? Int ?? 0,
+                minor: params["minor"] as? Int ?? 0,
+                distance: distance
+            )
+        case "onEddystoneEnter":
+            r.dispatchEddystoneEnter(
+                identifier: identifier,
+                namespace: params["namespace"] as? String ?? "",
+                instance: params["instance"] as? String ?? "",
+                distance: distance
+            )
+        case "onEddystoneExit":
+            r.dispatchEddystoneExit(
+                identifier: identifier,
+                namespace: params["namespace"] as? String ?? "",
+                instance: params["instance"] as? String ?? "",
+                distance: distance
+            )
+        default:
+            break
+        }
+    }
+
     private func getOrCreateEventLogger() -> BeaconEventLogger {
         if let logger = eventLogger {
             return logger

package/package.json

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