expo-app-blocker 0.1.76 → 0.1.77

package/android/src/main/java/expo/modules/appblocker/ExpoAppBlockerModule.kt

@@ -131,6 +131,43 @@ class ExpoAppBlockerModule : Module() {
       TemporaryUnlockController.remainingSeconds(context)
     }
 
+    // Last-resort recovery for an unrecoverable native state (observed:
+    // expo-sqlite's Android connection degrading after enough reuse in a
+    // long-lived process — a fresh `openDatabaseAsync` + first pragma NPEs
+    // even after a full DB rebuild). Apps that keep this module's
+    // AppBlockerService running as a foreground service can end up with an
+    // unusually long-lived process (the OS won't kill it just because the
+    // Activity was "closed"), which surfaces exactly this kind of
+    // native-module degradation far more than a normal app would. Only a
+    // genuine process kill clears it: queue the relaunch intent (optionally
+    // straight back into `deepLink`, e.g. the blocker intercept URL the
+    // caller was trying to reach) — `startActivity` only needs to queue the
+    // intent with ActivityManagerService, which survives our process dying
+    // right after — then kill this process outright. No AlarmManager/
+    // PendingIntent needed (and SCHEDULE_EXACT_ALARM would require a
+    // permission apps otherwise don't need just for this).
+    Function("restartApp") { deepLink: String? ->
+      val intent = if (!deepLink.isNullOrEmpty()) {
+        Intent(Intent.ACTION_VIEW, Uri.parse(deepLink))
+      } else {
+        context.packageManager.getLaunchIntentForPackage(context.packageName)
+      }
+      if (intent == null) {
+        Log.e(TAG, "restartApp: no launch intent resolvable, cannot self-heal")
+        return@Function
+      }
+      intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)
+
+      context.startActivity(intent)
+
+      Log.w(
+        TAG,
+        "restartApp: relaunch queued, killing process ${Process.myPid()} to recover " +
+          "from an unrecoverable native state"
+      )
+      Process.killProcess(Process.myPid())
+    }
+
     AsyncFunction("getInstalledApps") {
       val pm = context.packageManager
       val intent = Intent(Intent.ACTION_MAIN).apply {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-app-blocker",
-  "version": "0.1.76",
+  "version": "0.1.77",
   "description": "Expo module for cross-platform app blocking. Android: UsageStatsManager + Overlay. iOS: Screen Time API (FamilyControls + ManagedSettings + DeviceActivity).",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/index.ts

@@ -222,6 +222,35 @@ export function checkAndClearPendingUnlock(): boolean {
   return NativeModule.checkAndClearPendingUnlock();
 }
 
+/**
+ * Android-only, last-resort recovery: forces a genuine process kill and
+ * relaunch. Some native-layer failures (observed: an expo-sqlite connection
+ * that NPEs on every operation, even a fresh `openDatabaseAsync` against a
+ * freshly-rebuilt database file) can only be cleared by a real process
+ * restart — closing/reopening the JS-side handle doesn't reach far enough.
+ * Apps that run this module's `AppBlockerService` as a foreground service
+ * can end up with an unusually long-lived Android process (the OS won't
+ * kill it just because the Activity was "closed"), which surfaces this kind
+ * of native-module degradation far more than it would in a normal app.
+ *
+ * Queues a relaunch (optionally straight back into `deepLink`, e.g. the
+ * blocker intercept URL the caller was trying to reach), then calls
+ * `Process.killProcess`. If that succeeds the process is gone before the
+ * call would otherwise return. The native call itself can still reject
+ * (e.g. a missing Android permission) — this is already the last-resort
+ * path, so that failure is swallowed rather than left as an unhandled
+ * rejection.
+ *
+ * No-op on iOS: that platform's process model doesn't exhibit this failure
+ * mode, and there is no equivalent restart primitive.
+ */
+export function restartAppForRecovery(deepLink?: string): void {
+  if (Platform.OS !== "android") return;
+  NativeModule.restartApp(deepLink ?? null).catch((err: unknown) => {
+    console.warn("[expo-app-blocker] restartAppForRecovery failed", err);
+  });
+}
+
 /**
  * One OS-level block event: the blocker intercepted a blocked app (iOS
  * shield render / Android foreground block). `interceptedAt` is epoch