expo-beacon 0.8.8 → 0.8.9

package/android/build.gradle

@@ -23,4 +23,9 @@ dependencies {
   // androidx.car.app provides CarConnection LiveData for detecting Android Auto sessions.
   // No Android Auto certification or extra permissions required for read-only state.
   implementation 'androidx.car.app:app:1.4.0'
+  // WorkManager powers the CarPlay watchdog (periodic restart of the foreground
+  // service if it was killed by the OS / OEM cleaners while CarPlay observation
+  // is enabled). Minimum periodic interval is 15 min; an AlarmManager loop in
+  // BootReceiver covers the sub-15-min gap.
+  implementation 'androidx.work:work-runtime-ktx:2.9.1'
 }

package/android/src/main/AndroidManifest.xml

@@ -79,8 +79,18 @@
             android:exported="true">
             <intent-filter>
                 <action android:name="android.intent.action.BOOT_COMPLETED" />
+                <!-- Direct-boot phase boot (Android 7+). Harmless without
+                     directBootAware="true"; declaring early so the only
+                     follow-up needed for true direct-boot support is that
+                     single attribute. -->
+                <action android:name="android.intent.action.LOCKED_BOOT_COMPLETED" />
+                <!-- Restart observers after the host app is updated. -->
+                <action android:name="android.intent.action.MY_PACKAGE_REPLACED" />
                 <!-- Self-scheduled retry when BT isn't ready at boot -->
                 <action android:name="expo.modules.beacon.ACTION_RETRY_MONITORING" />
+                <!-- Self-scheduled CarPlay watchdog (11-min cadence; above
+                     setExactAndAllowWhileIdle per-app quota). -->
+                <action android:name="expo.modules.beacon.ACTION_CARPLAY_WATCHDOG" />
             </intent-filter>
         </receiver>
     </application>

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

@@ -131,6 +131,11 @@ class BeaconForegroundService : Service(), BeaconConsumer {
         // observer with no JS interaction required.
         if (isCarPlayEnabled(this)) {
             startCarPlayObserverInternal()
+            // Re-arm the WorkManager watchdog on every cold start. KEEP policy
+            // makes this a cheap no-op if a schedule already exists, but it
+            // recovers the schedule if WorkManager's DB was wiped by an OEM
+            // cleaner or by a `pm clear` from adb.
+            CarPlayWatchdogWorker.schedule(this)
         }
     }
 
@@ -1133,6 +1138,12 @@ class BeaconForegroundService : Service(), BeaconConsumer {
             setCarPlayEnabled(context, true)
             ensureNotificationChannel(context)
             ensureCarPlayNotificationChannel(context)
+            // Arm the WorkManager watchdog (15-min periodic safety net) and the
+            // AlarmManager loop (~11-min cadence, above the OS quota). Both
+            // call back into this same idempotent entry point if the service
+            // is killed while CarPlay observation is enabled.
+            CarPlayWatchdogWorker.schedule(context)
+            BootReceiver.scheduleCarPlayWatchdogAlarm(context)
             val intent = Intent(context, BeaconForegroundService::class.java)
                 .setAction(ACTION_ENABLE_CARPLAY)
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
@@ -1148,6 +1159,10 @@ class BeaconForegroundService : Service(), BeaconConsumer {
          */
         fun disableCarPlay(context: Context) {
             setCarPlayEnabled(context, false)
+            // Stop the safety-net watchdogs — without this they would keep
+            // restarting the service on every tick.
+            CarPlayWatchdogWorker.cancel(context)
+            BootReceiver.cancelCarPlayWatchdogAlarm(context)
             // Wipe the monitor's persisted last-known connection so a future
             // re-enable starts from a clean slate (no stale "was connected"
             // assumption that would arm the bootstrap-grace re-check).

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

@@ -11,8 +11,24 @@ import android.os.SystemClock
 import android.util.Log
 
 private const val ACTION_RETRY_MONITORING = "expo.modules.beacon.ACTION_RETRY_MONITORING"
+/**
+ * Periodic self-rescheduling watchdog action handled by [BootReceiver].
+ * Public on the manifest so the AlarmManager can route back to us after the
+ * process has been killed.
+ */
+internal const val ACTION_CARPLAY_WATCHDOG = "expo.modules.beacon.ACTION_CARPLAY_WATCHDOG"
 private const val RETRY_DELAY_MS = 10_000L
 private const val RETRY_REQUEST_CODE = 0x424F4F54 // "BOOT"
+private const val CARPLAY_WATCHDOG_REQUEST_CODE = 0x43504C57 // "CPLW"
+
+/**
+ * Cadence for the AlarmManager-based CarPlay watchdog. Set to **11 minutes**
+ * so we stay safely above Android's per-app rate limit on
+ * `setExactAndAllowWhileIdle()` (~10 minutes on API 23+, tightened again on
+ * API 31+). Going lower risks silent coalescing or dropping by the framework.
+ * This still beats WorkManager's 15-minute periodic floor.
+ */
+private const val CARPLAY_WATCHDOG_INTERVAL_MS = 11L * 60L * 1000L
 
 /**
  * Restarts beacon monitoring after device reboot if it was active before shutdown.
@@ -25,13 +41,19 @@ private const val RETRY_REQUEST_CODE = 0x424F4F54 // "BOOT"
 class BootReceiver : BroadcastReceiver() {
     override fun onReceive(context: Context, intent: Intent) {
         when (intent.action) {
-            Intent.ACTION_BOOT_COMPLETED -> {
+            Intent.ACTION_BOOT_COMPLETED,
+            Intent.ACTION_LOCKED_BOOT_COMPLETED,
+            Intent.ACTION_MY_PACKAGE_REPLACED -> {
                 logMemoryKillDiagnostics(context)
                 if (BeaconForegroundService.isMonitoringActive(context)) {
                     tryStartService(context)
-                } else if (BeaconForegroundService.isCarPlayEnabled(context)) {
-                    // CarPlay-only mode: re-attach the observer so it survives reboot.
+                }
+                if (BeaconForegroundService.isCarPlayEnabled(context)) {
+                    // CarPlay observation: re-attach the observer so it survives
+                    // reboot / app update / direct-boot, and arm the
+                    // self-rescheduling alarm loop.
                     tryEnableCarPlay(context)
+                    scheduleCarPlayWatchdogAlarm(context)
                 }
             }
             ACTION_RETRY_MONITORING -> {
@@ -41,6 +63,18 @@ class BootReceiver : BroadcastReceiver() {
                     tryEnableCarPlay(context)
                 }
             }
+            ACTION_CARPLAY_WATCHDOG -> {
+                if (!BeaconForegroundService.isCarPlayEnabled(context)) {
+                    // CarPlay was disabled since the alarm was set — let the
+                    // chain die. cancelCarPlayWatchdogAlarm() is also called
+                    // from disableCarPlay(), this is just defence-in-depth.
+                    Log.d(TAG, "BootReceiver: watchdog tick skipped (CarPlay disabled)")
+                    return
+                }
+                tryEnableCarPlay(context)
+                // Reschedule the next tick. setExactAndAllowWhileIdle is one-shot.
+                scheduleCarPlayWatchdogAlarm(context)
+            }
         }
     }
 
@@ -102,4 +136,69 @@ class BootReceiver : BroadcastReceiver() {
             }
         }
     }
+
+    companion object {
+        /**
+         * Arm (or re-arm) the AlarmManager-based CarPlay watchdog. One-shot
+         * alarm using `setExactAndAllowWhileIdle` — the receiver re-schedules
+         * itself on each fire as long as CarPlay observation remains enabled.
+         *
+         * Cadence is governed by [CARPLAY_WATCHDOG_INTERVAL_MS], deliberately
+         * above the per-app exact-alarm quota.
+         *
+         * Safe to call from any context; idempotent thanks to
+         * `FLAG_UPDATE_CURRENT` on the PendingIntent.
+         */
+        @JvmStatic
+        fun scheduleCarPlayWatchdogAlarm(context: Context) {
+            val alarmManager = context.getSystemService(AlarmManager::class.java) ?: return
+            val intent = Intent(context, BootReceiver::class.java).apply {
+                action = ACTION_CARPLAY_WATCHDOG
+                // Explicit package so the implicit-broadcast restriction on
+                // Android 8+ doesn't drop the delivery.
+                `package` = context.packageName
+            }
+            val pendingIntent = PendingIntent.getBroadcast(
+                context,
+                CARPLAY_WATCHDOG_REQUEST_CODE,
+                intent,
+                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+            )
+            try {
+                alarmManager.setExactAndAllowWhileIdle(
+                    AlarmManager.ELAPSED_REALTIME_WAKEUP,
+                    SystemClock.elapsedRealtime() + CARPLAY_WATCHDOG_INTERVAL_MS,
+                    pendingIntent,
+                )
+                Log.d(TAG, "BootReceiver: CarPlay watchdog alarm armed (${CARPLAY_WATCHDOG_INTERVAL_MS}ms)")
+            } catch (t: Throwable) {
+                // Defensive: setExactAndAllowWhileIdle can throw SecurityException on
+                // some configurations even though it doesn't strictly require
+                // SCHEDULE_EXACT_ALARM. Fall back is the WorkManager 15-min job.
+                Log.w(TAG, "BootReceiver: failed to arm CarPlay watchdog alarm", t)
+            }
+        }
+
+        /** Cancel the periodic CarPlay watchdog alarm. */
+        @JvmStatic
+        fun cancelCarPlayWatchdogAlarm(context: Context) {
+            val alarmManager = context.getSystemService(AlarmManager::class.java) ?: return
+            val intent = Intent(context, BootReceiver::class.java).apply {
+                action = ACTION_CARPLAY_WATCHDOG
+                `package` = context.packageName
+            }
+            val pendingIntent = PendingIntent.getBroadcast(
+                context,
+                CARPLAY_WATCHDOG_REQUEST_CODE,
+                intent,
+                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+            )
+            try {
+                alarmManager.cancel(pendingIntent)
+                Log.d(TAG, "BootReceiver: CarPlay watchdog alarm cancelled")
+            } catch (t: Throwable) {
+                Log.w(TAG, "BootReceiver: failed to cancel CarPlay watchdog alarm", t)
+            }
+        }
+    }
 }

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

@@ -0,0 +1,89 @@
+package expo.modules.beacon
+
+import android.content.Context
+import android.util.Log
+import androidx.work.ExistingPeriodicWorkPolicy
+import androidx.work.PeriodicWorkRequestBuilder
+import androidx.work.WorkManager
+import androidx.work.Worker
+import androidx.work.WorkerParameters
+import java.util.concurrent.TimeUnit
+
+/**
+ * Periodic safety-net that re-arms the [BeaconForegroundService] whenever
+ * CarPlay observation is enabled but the service has been killed (low memory,
+ * OEM cleaners, etc.).
+ *
+ * [BeaconForegroundService.enableCarPlay] is idempotent: if the service is
+ * alive this is a cheap no-op; if it is dead it cold-starts a fresh
+ * foreground instance and re-attaches [CarPlayMonitor].
+ *
+ * WorkManager guarantees a minimum 15-minute period. A second
+ * `AlarmManager` loop in [BootReceiver] covers the sub-15-min gap.
+ */
+internal class CarPlayWatchdogWorker(
+    appContext: Context,
+    params: WorkerParameters,
+) : Worker(appContext, params) {
+
+    override fun doWork(): Result {
+        val ctx = applicationContext
+        if (!BeaconForegroundService.isCarPlayEnabled(ctx)) {
+            // User turned CarPlay off — let the periodic work fade out via cancel().
+            Log.d(TAG, "Watchdog tick: CarPlay disabled, no action")
+            return Result.success()
+        }
+        try {
+            BeaconForegroundService.enableCarPlay(ctx)
+            Log.d(TAG, "Watchdog tick: ensured BeaconForegroundService is running for CarPlay")
+        } catch (t: Throwable) {
+            Log.w(TAG, "Watchdog tick: enableCarPlay failed", t)
+            // Returning retry would just defer to the next period; success keeps
+            // the periodic schedule running and avoids burning the retry budget.
+        }
+        return Result.success()
+    }
+
+    companion object {
+        private const val TAG = "CarPlayWatchdog"
+        private const val WORK_NAME = "expo-beacon-carplay-watchdog"
+
+        /**
+         * Schedule the periodic watchdog. Idempotent — [ExistingPeriodicWorkPolicy.KEEP]
+         * preserves the existing schedule across calls so we don't reset the
+         * next-run timer every time the user re-enables CarPlay.
+         */
+        @JvmStatic
+        fun schedule(context: Context) {
+            try {
+                val request = PeriodicWorkRequestBuilder<CarPlayWatchdogWorker>(
+                    15, TimeUnit.MINUTES,
+                ).addTag(WORK_NAME).build()
+                WorkManager.getInstance(context.applicationContext)
+                    .enqueueUniquePeriodicWork(
+                        WORK_NAME,
+                        ExistingPeriodicWorkPolicy.KEEP,
+                        request,
+                    )
+                Log.d(TAG, "Watchdog scheduled (15 min period)")
+            } catch (t: Throwable) {
+                // WorkManager.getInstance() can throw IllegalStateException if the
+                // host app has not initialised it. Fall back silently — the
+                // AlarmManager loop in BootReceiver still provides coverage.
+                Log.w(TAG, "Failed to schedule CarPlay watchdog", t)
+            }
+        }
+
+        /** Cancel the periodic watchdog. Safe to call when not scheduled. */
+        @JvmStatic
+        fun cancel(context: Context) {
+            try {
+                WorkManager.getInstance(context.applicationContext)
+                    .cancelUniqueWork(WORK_NAME)
+                Log.d(TAG, "Watchdog cancelled")
+            } catch (t: Throwable) {
+                Log.w(TAG, "Failed to cancel CarPlay watchdog", t)
+            }
+        }
+    }
+}

package/package.json

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