expo-app-blocker 0.1.65 → 0.1.66

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

@@ -2,9 +2,15 @@ package expo.modules.appblocker
 
 import android.content.Context
 import android.content.SharedPreferences
+import org.json.JSONArray
+import org.json.JSONObject
 
 object AppBlockerPrefs {
   const val PREFS_NAME = "expo_app_blocker_prefs"
+  private const val KEY_PENDING_INTERCEPTS = "pending_intercepts"
+  private const val KEY_LAST_INTERCEPT_TS = "last_intercept_ts"
+  private const val INTERCEPT_DEBOUNCE_MS = 2_000L
+  private const val MAX_PENDING_INTERCEPTS = 200
   const val KEY_BLOCKED_PACKAGES = "blocked_packages"
   private const val KEY_OVERLAY_TITLE = "overlay_title"
   private const val KEY_OVERLAY_TEXT = "overlay_text"
@@ -149,6 +155,59 @@ object AppBlockerPrefs {
   fun getNotificationText(context: Context): String =
     get(context).getString(KEY_NOTIFICATION_TEXT, null) ?: "{appName} is blocked. Tap to manage."
 
+  /**
+   * Queue one OS-level block event for the app to drain into
+   * `blocker_intercepts`. Debounced globally so the poll loop can't emit
+   * duplicates for a single block, and capped to bound storage.
+   */
+  fun appendIntercept(context: Context, appName: String, interceptedAtMs: Long) {
+    val prefs = get(context)
+    val lastTs = prefs.getLong(KEY_LAST_INTERCEPT_TS, 0L)
+    if (lastTs > 0L && interceptedAtMs - lastTs < INTERCEPT_DEBOUNCE_MS) return
+
+    val arr = try {
+      JSONArray(prefs.getString(KEY_PENDING_INTERCEPTS, "[]"))
+    } catch (e: Exception) {
+      JSONArray()
+    }
+    arr.put(JSONObject().put("appName", appName).put("interceptedAt", interceptedAtMs))
+
+    val trimmed = if (arr.length() > MAX_PENDING_INTERCEPTS) {
+      JSONArray().also { t ->
+        for (i in (arr.length() - MAX_PENDING_INTERCEPTS) until arr.length()) t.put(arr.get(i))
+      }
+    } else {
+      arr
+    }
+
+    prefs.edit()
+      .putString(KEY_PENDING_INTERCEPTS, trimmed.toString())
+      .putLong(KEY_LAST_INTERCEPT_TS, interceptedAtMs)
+      .apply()
+  }
+
+  /** Return and clear the queued block events. */
+  fun drainIntercepts(context: Context): List<Map<String, Any>> {
+    val prefs = get(context)
+    val arr = try {
+      JSONArray(prefs.getString(KEY_PENDING_INTERCEPTS, "[]"))
+    } catch (e: Exception) {
+      JSONArray()
+    }
+    val out = ArrayList<Map<String, Any>>(arr.length())
+    for (i in 0 until arr.length()) {
+      val o = arr.getJSONObject(i)
+      out.add(
+        mapOf(
+          "appName" to o.optString("appName", ""),
+          "interceptedAt" to o.optDouble("interceptedAt"),
+        )
+      )
+    }
+    if (arr.length() > 0) prefs.edit().remove(KEY_PENDING_INTERCEPTS).apply()
+    return out
+  }
+
   private fun putNullableFloat(editor: SharedPreferences.Editor, key: String, value: Float?) {
     if (value != null) editor.putFloat(key, value) else editor.remove(key)
   }

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

@@ -97,10 +97,22 @@ class AppBlockerService : Service() {
   private fun enforceBlock(packageName: String, reason: BlockReason) {
     overlayManager.show(packageName, reason)
     showBlockedNotification(packageName, reason)
+    recordIntercept(packageName)
     blocking = true
     consumingSinceMs = 0L
   }
 
+  /** Queue this block event for the app to drain (debounced in prefs). */
+  private fun recordIntercept(packageName: String) {
+    val appName = try {
+      val pm = this.packageManager
+      pm.getApplicationLabel(pm.getApplicationInfo(packageName, 0)).toString()
+    } catch (e: Exception) {
+      packageName
+    }
+    AppBlockerPrefs.appendIntercept(this, appName, System.currentTimeMillis())
+  }
+
   private fun showBlockedNotification(packageName: String, reason: BlockReason) {
     val appName = try {
       val pm = this.packageManager

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

@@ -103,6 +103,10 @@ class ExpoAppBlockerModule : Module() {
       AppBlockerPrefs.getBlockedPackages(context).toList()
     }
 
+    Function("drainPendingIntercepts") {
+      AppBlockerPrefs.drainIntercepts(context)
+    }
+
     Function("startMonitoring") {
       AppBlockerService.start(context)
       Log.d(TAG, "startMonitoring called")

package/ios/ExpoAppBlockerModule.swift

@@ -38,6 +38,7 @@ public class ExpoAppBlockerModule: Module {
   // event count stays under this (Apple degrades with too many events).
   private let maxUsageSteps = 60
   private let pendingUnlockKey = "appBlocker.pendingUnlock.v1"
+  private let pendingInterceptsKey = "appBlocker.pendingIntercepts.v1"
   private let minimumTemporaryUnlockMinutes = 1
   private var didLoadPersistedConfig = false
 
@@ -200,6 +201,16 @@ public class ExpoAppBlockerModule: Module {
       return hasPending
     }
 
+    Function("drainPendingIntercepts") { () -> [[String: Any]] in
+      guard let defaults = self.sharedDefaults else { return [] }
+      let queue = defaults.array(forKey: self.pendingInterceptsKey) as? [[String: Any]] ?? []
+      if !queue.isEmpty {
+        defaults.removeObject(forKey: self.pendingInterceptsKey)
+        defaults.synchronize()
+      }
+      return queue
+    }
+
     Function("isAppBlocked") { (bundleIdentifier: String) -> Bool in
       self.ensureLoadedPersistedConfig()
       guard let config = self.currentBlockConfig else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-app-blocker",
-  "version": "0.1.65",
+  "version": "0.1.66",
   "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,28 @@ export function checkAndClearPendingUnlock(): boolean {
   return NativeModule.checkAndClearPendingUnlock();
 }
 
+/**
+ * One OS-level block event: the blocker intercepted a blocked app (iOS
+ * shield render / Android foreground block). `interceptedAt` is epoch
+ * milliseconds; `appName` is the localized app name when the platform
+ * can resolve it (null otherwise).
+ */
+export interface PendingIntercept {
+  appName: string | null;
+  interceptedAt: number;
+}
+
+/**
+ * Drain and clear the queue of block events recorded natively since the
+ * last call. Implemented on both platforms (iOS App Group queue / Android
+ * SharedPreferences queue). The app calls this on foreground and persists
+ * the results to power the "blocks" counter.
+ */
+export function drainPendingIntercepts(): PendingIntercept[] {
+  if (Platform.OS !== "ios" && Platform.OS !== "android") return [];
+  return NativeModule.drainPendingIntercepts() ?? [];
+}
+
 export function addPendingUnlockListener(
   handler: () => void
 ): { remove: () => void } | null {

package/targets/ShieldConfiguration/ShieldConfigurationExtension.swift

@@ -43,6 +43,30 @@ class ShieldConfigurationExtension: ShieldConfigurationDataSource {
     return Date() < expiration
   }
 
+  // Block-event queue, drained by the app into `blocker_intercepts` to power
+  // the "blocks" counter. The system re-renders the shield often (app
+  // switcher previews, re-foreground), so a short global debounce collapses
+  // those bursts into one logical block event.
+  private let pendingInterceptsKey = "appBlocker.pendingIntercepts.v1"
+  private let lastInterceptTsKey = "appBlocker.lastInterceptTs.v1"
+  private let interceptDebounceMs: Double = 2_000
+  private let maxPendingIntercepts = 200
+
+  private func recordIntercept(appName: String) {
+    guard let defaults = UserDefaults(suiteName: appGroupIdentifier) else { return }
+    let nowMs = Date().timeIntervalSince1970 * 1000.0
+    let lastMs = defaults.double(forKey: lastInterceptTsKey)
+    if lastMs > 0, (nowMs - lastMs) < interceptDebounceMs { return }
+
+    var queue = defaults.array(forKey: pendingInterceptsKey) as? [[String: Any]] ?? []
+    queue.append(["appName": appName, "interceptedAt": nowMs])
+    if queue.count > maxPendingIntercepts {
+      queue = Array(queue.suffix(maxPendingIntercepts))
+    }
+    defaults.set(queue, forKey: pendingInterceptsKey)
+    defaults.set(nowMs, forKey: lastInterceptTsKey)
+  }
+
   private func makeConfig(appName: String) -> ShieldConfiguration {
     if isTemporarilyUnlocked() {
       return ShieldConfiguration(
@@ -57,6 +81,10 @@ class ShieldConfigurationExtension: ShieldConfigurationDataSource {
       )
     }
 
+    // A blocked app is being shielded — this is a block event. Record it
+    // (debounced) for the app to drain.
+    recordIntercept(appName: appName)
+
     let count = getBlockedAppCount()
     // The plugin replaces this placeholder with a Swift string literal
     // containing `\(count)` interpolation, or `""` when the user opted out.