expo-app-blocker 0.1.59 → 0.1.61

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

@@ -21,16 +21,11 @@ class AppBlockerService : Service() {
   private val handler = Handler(Looper.getMainLooper())
   private var lastForegroundPackage: String? = null
   private lateinit var overlayManager: OverlayManager
-  @Volatile private var paused = false
-
-  private val resumeRunnable = Runnable {
-    Log.d(TAG, "Temporary unlock expired, resuming blocking")
-    paused = false
-  }
+  private val unlockController by lazy { TemporaryUnlockController(this, handler) }
 
   private val pollRunnable = object : Runnable {
     override fun run() {
-      if (!paused) {
+      if (!unlockController.isUnlocked) {
         val foregroundPackage = getCurrentForegroundPackage()
         if (foregroundPackage != null && foregroundPackage != lastForegroundPackage) {
           Log.d(TAG, "Foreground changed: $foregroundPackage")
@@ -123,15 +118,19 @@ class AppBlockerService : Service() {
   }
 
   override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-    val action = intent?.action
-    if (action == ACTION_TEMPORARY_UNLOCK) {
-      val minutes = intent.getIntExtra(EXTRA_DURATION_MINUTES, 0)
-      if (minutes > 0) {
+    when (intent?.action) {
+      ACTION_TEMPORARY_UNLOCK -> {
+        val minutes = intent.getIntExtra(EXTRA_DURATION_MINUTES, 0)
         Log.d(TAG, "Temporary unlock for $minutes minutes")
-        handler.removeCallbacks(resumeRunnable)
-        paused = true
+        unlockController.unlock(minutes)
         overlayManager.hide()
-        handler.postDelayed(resumeRunnable, minutes * 60_000L)
+      }
+      ACTION_RELOCK -> {
+        Log.d(TAG, "Relock: ending temporary unlock")
+        unlockController.relock()
+        // Forget the last-seen app so a blocked app already in the foreground
+        // is re-detected and re-blocked on the next poll.
+        lastForegroundPackage = null
       }
     }
     return START_STICKY
@@ -200,15 +199,11 @@ class AppBlockerService : Service() {
     private const val POLL_INTERVAL_MS = 500L
     private const val LOOKBACK_WINDOW_MS = 10_000L
     private const val ACTION_TEMPORARY_UNLOCK = "expo.modules.appblocker.TEMPORARY_UNLOCK"
+    private const val ACTION_RELOCK = "expo.modules.appblocker.RELOCK"
     private const val EXTRA_DURATION_MINUTES = "duration_minutes"
 
     fun start(context: Context) {
-      val intent = Intent(context, AppBlockerService::class.java)
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-        context.startForegroundService(intent)
-      } else {
-        context.startService(intent)
-      }
+      startCommand(context, Intent(context, AppBlockerService::class.java))
     }
 
     fun stop(context: Context) {
@@ -221,6 +216,17 @@ class AppBlockerService : Service() {
         action = ACTION_TEMPORARY_UNLOCK
         putExtra(EXTRA_DURATION_MINUTES, durationMinutes)
       }
+      startCommand(context, intent)
+    }
+
+    fun relock(context: Context) {
+      val intent = Intent(context, AppBlockerService::class.java).apply {
+        action = ACTION_RELOCK
+      }
+      startCommand(context, intent)
+    }
+
+    private fun startCommand(context: Context, intent: Intent) {
       if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
         context.startForegroundService(intent)
       } else {

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

@@ -118,6 +118,15 @@ class ExpoAppBlockerModule : Module() {
       Log.d(TAG, "temporaryUnlockAndroid: $durationMinutes minutes")
     }
 
+    Function("relockAndroid") {
+      AppBlockerService.relock(context)
+      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/TemporaryUnlockController.kt

@@ -0,0 +1,64 @@
+package expo.modules.appblocker
+
+import android.content.Context
+import android.os.Handler
+
+/**
+ * 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. 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.
+ *
+ * Drive [unlock] / [relock] from the same (main) thread the [Handler] is bound to.
+ */
+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() = 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)
+    Store.setExpiry(context, System.currentTimeMillis() + durationMs)
+    handler.postDelayed(expireRunnable, durationMs)
+  }
+
+  /** End any active unlock immediately, restoring blocking. */
+  fun relock() {
+    handler.removeCallbacks(expireRunnable)
+    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.59",
+  "version": "0.1.61",
   "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,14 +181,16 @@ 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();
 }
 
 export async function relockApps(): Promise<RelockResult> {
-  if (Platform.OS !== "ios") {
-    throw new Error("Relock is only available on iOS");
+  if (Platform.OS === "android") {
+    NativeModule.relockAndroid();
+    return { locked: true };
   }
   return NativeModule.relockApps();
 }