expo-app-blocker 0.1.60 → 0.1.62

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

@@ -21,13 +21,24 @@ class AppBlockerService : Service() {
   private val handler = Handler(Looper.getMainLooper())
   private var lastForegroundPackage: String? = null
   private lateinit var overlayManager: OverlayManager
-  private val unlockController = TemporaryUnlockController(handler)
+  private val unlockController by lazy { TemporaryUnlockController(this, handler) }
+  private var wasUnlocked = false
 
   private val pollRunnable = object : Runnable {
     override fun run() {
-      if (!unlockController.isUnlocked) {
+      if (unlockController.isUnlocked) {
+        wasUnlocked = true
+      } else {
         val foregroundPackage = getCurrentForegroundPackage()
-        if (foregroundPackage != null && foregroundPackage != lastForegroundPackage) {
+        val unlockJustExpired = wasUnlocked
+        wasUnlocked = false
+
+        if (unlockJustExpired && foregroundPackage != null && isBlocked(foregroundPackage)) {
+          // Earned time ran out while the user was still inside a blocked app.
+          Log.d(TAG, "Unlock expired in foreground app: $foregroundPackage")
+          lastForegroundPackage = foregroundPackage
+          block(foregroundPackage, BlockReason.EXPIRED)
+        } else if (foregroundPackage != null && foregroundPackage != lastForegroundPackage) {
           Log.d(TAG, "Foreground changed: $foregroundPackage")
           lastForegroundPackage = foregroundPackage
           handleForegroundChange(foregroundPackage)
@@ -48,18 +59,24 @@ class AppBlockerService : Service() {
     handler.post(pollRunnable)
   }
 
+  private fun isBlocked(packageName: String): Boolean =
+    packageName in AppBlockerPrefs.getBlockedPackages(this)
+
   private fun handleForegroundChange(foregroundPackage: String) {
-    val blocked = AppBlockerPrefs.getBlockedPackages(this)
-    if (foregroundPackage in blocked) {
+    if (isBlocked(foregroundPackage)) {
       Log.d(TAG, "Blocked app in foreground: $foregroundPackage")
-      overlayManager.show(foregroundPackage)
-      showBlockedNotification(foregroundPackage)
+      block(foregroundPackage, BlockReason.OPENED)
     } else {
       overlayManager.hide()
     }
   }
 
-  private fun showBlockedNotification(packageName: String) {
+  private fun block(packageName: String, reason: BlockReason) {
+    overlayManager.show(packageName, reason)
+    showBlockedNotification(packageName, reason)
+  }
+
+  private fun showBlockedNotification(packageName: String, reason: BlockReason) {
     val appName = try {
       val pm = this.packageManager
       val appInfo = pm.getApplicationInfo(packageName, 0)
@@ -74,7 +91,10 @@ class AppBlockerService : Service() {
     val scheme = getAppScheme()
     val deepLinkIntent = Intent(
       Intent.ACTION_VIEW,
-      Uri.parse("${scheme}://blocked?app=${Uri.encode(appName)}&package=${Uri.encode(packageName)}")
+      Uri.parse(
+        "${scheme}://blocked?app=${Uri.encode(appName)}" +
+          "&package=${Uri.encode(packageName)}&reason=${reason.slug}"
+      )
     ).apply {
       addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
     }

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

@@ -0,0 +1,14 @@
+package expo.modules.appblocker
+
+/**
+ * Why a blocked app is being intercepted right now. Carried into the deep link
+ * so the JS side can branch (e.g. a softer "time's up" interstitial when an
+ * earned-time window expires while the user is still inside the app).
+ */
+enum class BlockReason(val slug: String) {
+  /** A blocked app was freshly brought to the foreground. */
+  OPENED("opened"),
+
+  /** A temporary unlock expired while a blocked app was already in the foreground. */
+  EXPIRED("expired"),
+}

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

@@ -123,6 +123,10 @@ class ExpoAppBlockerModule : Module() {
       Log.d(TAG, "relockAndroid")
     }
 
+    Function("getRemainingUnlockTimeAndroid") {
+      TemporaryUnlockController.remainingSeconds(context)
+    }
+
     AsyncFunction("getInstalledApps") {
       val pm = context.packageManager
       val intent = Intent(Intent.ACTION_MAIN).apply {

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

@@ -24,11 +24,11 @@ class OverlayManager(private val context: Context) {
 
   private var overlayView: View? = null
 
-  fun show(blockedPackageName: String? = null) {
+  fun show(blockedPackageName: String? = null, reason: BlockReason = BlockReason.OPENED) {
     if (overlayView != null) {
       Log.d(TAG, "Overlay already visible")
       if (blockedPackageName != null) {
-        navigateToApp(blockedPackageName)
+        navigateToApp(blockedPackageName, reason)
       } else {
         bringAppToFront()
       }
@@ -47,7 +47,7 @@ class OverlayManager(private val context: Context) {
     }
 
     if (blockedPackageName != null) {
-      navigateToApp(blockedPackageName)
+      navigateToApp(blockedPackageName, reason)
     } else {
       bringAppToFront()
     }
@@ -72,14 +72,17 @@ class OverlayManager(private val context: Context) {
     packageName
   }
 
-  private fun navigateToApp(blockedPackageName: String) {
+  private fun navigateToApp(blockedPackageName: String, reason: BlockReason) {
     val appName = resolveAppName(blockedPackageName)
 
     // Use the app's own scheme for deep linking
     val scheme = getAppScheme()
     val deepLinkIntent = Intent(
       Intent.ACTION_VIEW,
-      Uri.parse("${scheme}://blocked?app=${Uri.encode(appName)}&package=${Uri.encode(blockedPackageName)}")
+      Uri.parse(
+        "${scheme}://blocked?app=${Uri.encode(appName)}" +
+          "&package=${Uri.encode(blockedPackageName)}&reason=${reason.slug}"
+      )
     ).apply {
       addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
     }

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

@@ -1,37 +1,64 @@
 package expo.modules.appblocker
 
+import android.content.Context
 import android.os.Handler
 
 /**
- * Owns the "temporary unlock" state for Android blocking.
+ * Single source of truth for the Android "temporary unlock" state.
  *
  * While unlocked, the monitor should not block — see [isUnlocked]. An unlock
- * auto-expires after the requested duration; [relock] ends it early. All timer
- * bookkeeping is hidden here so the service only asks a single yes/no question.
+ * auto-expires after the requested duration; [relock] ends it early. The expiry
+ * timestamp is persisted (see [Store]) so the JS module can read the remaining
+ * time without holding a reference to the running service, mirroring the iOS
+ * shared-defaults approach.
  *
- * Not thread-safe beyond the [isUnlocked] read: drive [unlock] / [relock] from
- * the same (main) thread the [Handler] is bound to.
+ * Drive [unlock] / [relock] from the same (main) thread the [Handler] is bound to.
  */
-class TemporaryUnlockController(private val handler: Handler) {
-  @Volatile private var unlocked = false
-
-  private val expireRunnable = Runnable { unlocked = false }
+class TemporaryUnlockController(
+  private val context: Context,
+  private val handler: Handler,
+) {
+  private val expireRunnable = Runnable { Store.clear(context) }
 
   /** True while a temporary unlock is in effect (blocking should be suppressed). */
   val isUnlocked: Boolean
-    get() = unlocked
+    get() = Store.remainingSeconds(context) > 0
 
   /** Suppress blocking for [durationMinutes], replacing any pending expiry. No-op if <= 0. */
   fun unlock(durationMinutes: Int) {
     if (durationMinutes <= 0) return
+    val durationMs = durationMinutes * 60_000L
     handler.removeCallbacks(expireRunnable)
-    unlocked = true
-    handler.postDelayed(expireRunnable, durationMinutes * 60_000L)
+    Store.setExpiry(context, System.currentTimeMillis() + durationMs)
+    handler.postDelayed(expireRunnable, durationMs)
   }
 
   /** End any active unlock immediately, restoring blocking. */
   fun relock() {
     handler.removeCallbacks(expireRunnable)
-    unlocked = false
+    Store.clear(context)
+  }
+
+  /**
+   * Stateless persistence for the unlock expiry. Readable from anywhere with a
+   * [Context] — the running service is not required.
+   */
+  companion object Store {
+    private const val KEY_EXPIRES_AT = "temporary_unlock_expires_at"
+
+    private fun setExpiry(context: Context, expiresAtMs: Long) {
+      AppBlockerPrefs.get(context).edit().putLong(KEY_EXPIRES_AT, expiresAtMs).apply()
+    }
+
+    private fun clear(context: Context) {
+      AppBlockerPrefs.get(context).edit().remove(KEY_EXPIRES_AT).apply()
+    }
+
+    /** Seconds remaining on the active unlock, or 0 if none / already expired. */
+    fun remainingSeconds(context: Context): Int {
+      val expiresAtMs = AppBlockerPrefs.get(context).getLong(KEY_EXPIRES_AT, 0L)
+      val remainingMs = expiresAtMs - System.currentTimeMillis()
+      return if (remainingMs > 0) (remainingMs / 1000).toInt() else 0
+    }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-app-blocker",
-  "version": "0.1.60",
+  "version": "0.1.62",
   "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

@@ -181,8 +181,9 @@ export function isTemporarilyUnlocked(): boolean {
   return NativeModule.isTemporarilyUnlocked();
 }
 
+/** Seconds remaining on the active temporary unlock, or 0 if none. */
 export function getRemainingUnlockTime(): number {
-  if (Platform.OS !== "ios") return 0;
+  if (Platform.OS === "android") return NativeModule.getRemainingUnlockTimeAndroid();
   return NativeModule.getRemainingUnlockTime();
 }