expo-app-blocker 0.1.71 → 0.1.73

package/ios/ExpoAppBlockerModule.swift

@@ -540,21 +540,42 @@ public class ExpoAppBlockerModule: Module {
     let activityName = DeviceActivityName(unlockActivityName)
     let calendar = Calendar.current
     let now = Date()
-    let startComponents = calendar.dateComponents([.hour, .minute, .second], from: now)
-    let endComponents = calendar.dateComponents([.hour, .minute, .second], from: expirationDate)
-    let nowDay = calendar.startOfDay(for: now)
-    let expirationDay = calendar.startOfDay(for: expirationDate)
 
+    // Apple rejects DeviceActivitySchedule intervals shorter than 15 minutes, so
+    // a short earned grant can't simply end the interval at its real expiration.
+    // Pad the interval to the 15-min minimum and use `warningTime` so
+    // `intervalWillEndWarning` fires at the REAL expiration — letting the monitor
+    // re-block while the user is still inside the blocked app (sub-15-min grants).
+    // Grants ≥ 15 min end the interval exactly at expiration (no warning needed).
+    let minIntervalSec: TimeInterval = 15 * 60
+    let durationSec = max(0, expirationDate.timeIntervalSince(now))
+
+    let intervalEndDate: Date
+    var warningSec = 0
+    if durationSec >= minIntervalSec {
+      intervalEndDate = expirationDate
+    } else {
+      intervalEndDate = now.addingTimeInterval(minIntervalSec)
+      warningSec = Int(intervalEndDate.timeIntervalSince(expirationDate).rounded())
+    }
+
+    let startComponents = calendar.dateComponents([.hour, .minute, .second], from: now)
     let schedule: DeviceActivitySchedule
-    if nowDay == expirationDay {
+
+    if calendar.isDate(now, inSameDayAs: intervalEndDate) {
+      let endComponents = calendar.dateComponents([.hour, .minute, .second], from: intervalEndDate)
+      let warning: DateComponents? =
+        warningSec > 0 ? DateComponents(minute: warningSec / 60, second: warningSec % 60) : nil
       schedule = DeviceActivitySchedule(
         intervalStart: startComponents,
         intervalEnd: endComponents,
-        repeats: false
+        repeats: false,
+        warningTime: warning
       )
     } else {
-      // Expiration crosses midnight — cap the interval at end-of-day; the host
-      // relock handles the remainder on next foreground.
+      // Padded interval crosses midnight — cap at end-of-day (no warning); the
+      // host-side relock (getRemainingUnlockTime poll / foreground check) covers
+      // the remainder on next return to the app.
       schedule = DeviceActivitySchedule(
         intervalStart: startComponents,
         intervalEnd: DateComponents(hour: 23, minute: 59, second: 59),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-app-blocker",
-  "version": "0.1.71",
+  "version": "0.1.73",
   "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/targets/DeviceActivityMonitor/DeviceActivityMonitor.swift

@@ -24,24 +24,38 @@ class DeviceActivityMonitorExtension: DeviceActivityMonitor {
     sharedDefaults = UserDefaults(suiteName: appGroupIdentifier)
   }
 
+  // Fires at `intervalEnd − warningTime`, which the host aligns to the grant's
+  // real expiration. This is the ONLY callback that fires for sub-15-min grants
+  // (Apple's schedule interval minimum is 15 min), so it's the primary
+  // re-block-while-inside path. `intervalDidEnd` covers the ≥15-min case + safety.
+  override func intervalWillEndWarning(for activity: DeviceActivityName) {
+    super.intervalWillEndWarning(for: activity)
+    relockIfExpired()
+  }
+
   override func intervalDidEnd(for activity: DeviceActivityName) {
     super.intervalDidEnd(for: activity)
-    // The schedule's interval ends at the grant's wall-clock expiration → re-block.
-    // Guard against the spurious intervalDidEnd that stopMonitoring() fires during a
-    // re-grant: if the stored expiration is still in the future this is a re-arm, not
-    // an expiry, so leave the freshly-granted unlock intact.
+    relockIfExpired()
+  }
+
+  override func intervalDidStart(for activity: DeviceActivityName) {
+    super.intervalDidStart(for: activity)
+  }
+
+  /// Re-apply the shield once the grant's wall-clock expiration has arrived.
+  /// Guards against the spurious callback that `stopMonitoring()` fires during a
+  /// re-grant: if the stored expiration is still comfortably in the future
+  /// (> 60s), this is a re-arm — not an expiry — so the fresh grant is kept.
+  /// The 60s tolerance also absorbs callback/clock skew at the real boundary.
+  private func relockIfExpired() {
     if let expiration = sharedDefaults?.object(forKey: temporaryUnlockKey) as? Date,
-       Date() < expiration {
+       expiration.timeIntervalSinceNow > 60 {
       return
     }
     sharedDefaults?.removeObject(forKey: temporaryUnlockKey)
     reapplyBlockConfiguration()
   }
 
-  override func intervalDidStart(for activity: DeviceActivityName) {
-    super.intervalDidStart(for: activity)
-  }
-
   private func reapplyBlockConfiguration() {
     let userDefaults = sharedDefaults ?? UserDefaults.standard