capacitor-mobilecron 0.2.22 → 0.2.23

package/android/src/main/java/io/mobilecron/MobileCronPlugin.kt

@@ -3,6 +3,8 @@ package io.mobilecron
 import android.content.Context
 import android.content.Intent
 import android.content.IntentFilter
+import android.os.Handler
+import android.os.Looper
 import androidx.work.Constraints
 import androidx.work.ExistingPeriodicWorkPolicy
 import androidx.work.ExistingWorkPolicy
@@ -29,27 +31,55 @@ class MobileCronPlugin : Plugin() {
     private var mode = "balanced"
     private var chargingReceiver: ChargingReceiver? = null
 
+    // Foreground watchdog — evaluates due jobs while the app is active
+    private val handler = Handler(Looper.getMainLooper())
+    private var watchdogRunning = false
+    private val watchdogRunnable = object : Runnable {
+        override fun run() {
+            if (!watchdogRunning) return
+            evaluateDueJobsForeground()
+            handler.postDelayed(this, tickMs())
+        }
+    }
+
     companion object {
         private const val STORAGE_FILE = "CapacitorStorage"
         private const val STORAGE_KEY = "mobilecron:state"
+        private const val TICK_ECO = 60_000L
+        private const val TICK_BALANCED = 30_000L
+        private const val TICK_AGGRESSIVE = 15_000L
+    }
+
+    private fun tickMs(): Long = when (mode) {
+        "eco" -> TICK_ECO
+        "aggressive" -> TICK_AGGRESSIVE
+        else -> TICK_BALANCED
     }
 
     override fun load() {
         super.load()
         CronBridge.plugin = this
         loadState()
+        computeMissingNextDueAt()
         registerChargingReceiver()
         scheduleWorkManager()
+        startWatchdog()
     }
 
     override fun handleOnResume() {
         super.handleOnResume()
-        // Fire any pendingNativeEvents written by NativeJobEvaluator while the app was backgrounded/killed.
         firePendingNativeEvents()
+        startWatchdog()
+    }
+
+    override fun handleOnPause() {
+        super.handleOnPause()
+        stopWatchdog()
     }
 
     override fun handleOnDestroy() {
         super.handleOnDestroy()
+        stopWatchdog()
         if (CronBridge.plugin === this) {
             CronBridge.plugin = null
         }
@@ -59,6 +89,115 @@ class MobileCronPlugin : Plugin() {
         chargingReceiver = null
     }
 
+    // ── Foreground watchdog ───────────────────────────────────────────────────
+
+    private fun startWatchdog() {
+        if (watchdogRunning) return
+        watchdogRunning = true
+        handler.postDelayed(watchdogRunnable, tickMs())
+    }
+
+    private fun stopWatchdog() {
+        watchdogRunning = false
+        handler.removeCallbacks(watchdogRunnable)
+    }
+
+    private fun restartWatchdog() {
+        stopWatchdog()
+        startWatchdog()
+    }
+
+    /**
+     * Evaluate due jobs while the app is in the foreground.
+     * Directly emits jobDue events via notifyListeners (no SharedPreferences round-trip).
+     * Mirrors the logic in NativeJobEvaluator but operates on the in-memory jobs map.
+     */
+    private fun evaluateDueJobsForeground() {
+        val now = System.currentTimeMillis()
+        var mutated = false
+
+        for ((id, job) in jobs) {
+            if (!job.optBoolean("enabled", false)) continue
+
+            // Compute nextDueAt if missing
+            val schedule = try { job.getJSONObject("schedule") } catch (_: Exception) { continue }
+            var nextDueAt = readLong(job.opt("nextDueAt"))
+            if (nextDueAt == null) {
+                nextDueAt = NativeJobEvaluator.computeNextDueAt(schedule, now)
+                if (nextDueAt != null) {
+                    job.put("nextDueAt", nextDueAt)
+                    mutated = true
+                }
+            }
+
+            if (nextDueAt == null || nextDueAt > now) continue
+
+            // Check skip reasons
+            if (paused) continue
+
+            val activeHours = try { job.getJSONObject("activeHours") } catch (_: Exception) { null }
+            if (activeHours != null && !NativeJobEvaluator.isWithinActiveHours(activeHours, now)) {
+                job.put("consecutiveSkips", job.optInt("consecutiveSkips", 0) + 1)
+                job.put("updatedAt", now)
+                if (schedule.optString("kind") == "every") {
+                    val next = NativeJobEvaluator.computeNextDueAt(schedule, now)
+                    if (next != null) job.put("nextDueAt", next) else job.remove("nextDueAt")
+                }
+                mutated = true
+                continue
+            }
+
+            // Fire the job
+            job.put("lastFiredAt", now)
+            job.put("updatedAt", now)
+            job.put("consecutiveSkips", 0)
+
+            if (schedule.optString("kind") == "at") {
+                job.put("enabled", false)
+                job.remove("nextDueAt")
+            } else {
+                val next = NativeJobEvaluator.computeNextDueAt(schedule, now)
+                if (next != null) job.put("nextDueAt", next) else job.remove("nextDueAt")
+            }
+
+            mutated = true
+
+            // Emit jobDue directly to JS listeners
+            val payload = JSObject()
+            payload.put("id", id)
+            payload.put("name", job.optString("name"))
+            payload.put("firedAt", now)
+            payload.put("source", "watchdog")
+            if (job.has("data")) {
+                try { payload.put("data", job.getJSONObject("data")) } catch (_: Exception) {}
+            }
+            notifyListeners("jobDue", payload)
+        }
+
+        if (mutated) {
+            saveState()
+        }
+    }
+
+    /**
+     * Compute nextDueAt for all jobs that are missing it (e.g. after loadState from storage).
+     */
+    private fun computeMissingNextDueAt() {
+        val now = System.currentTimeMillis()
+        var mutated = false
+        for ((_, job) in jobs) {
+            if (!job.optBoolean("enabled", false)) continue
+            if (readLong(job.opt("nextDueAt")) != null) continue
+            val schedule = try { job.getJSONObject("schedule") } catch (_: Exception) { continue }
+            val computed = NativeJobEvaluator.computeNextDueAt(schedule, now)
+            if (computed != null) {
+                job.put("nextDueAt", computed)
+                mutated = true
+            }
+        }
+        if (mutated) saveState()
+    }
+
     // ── Persistence ─────────────────────────────────────────────────────────
 
     private fun loadState() {
@@ -200,17 +339,29 @@ class MobileCronPlugin : Plugin() {
         }
 
         val id = UUID.randomUUID().toString()
+        val now = System.currentTimeMillis()
+        val schedule = call.getObject("schedule") ?: JSObject()
+
         val record = JSObject()
         record.put("id", id)
         record.put("name", name)
         record.put("enabled", true)
-        record.put("schedule", call.getObject("schedule") ?: JSObject())
+        record.put("schedule", schedule)
         record.put("activeHours", call.getObject("activeHours"))
         record.put("requiresNetwork", call.getBoolean("requiresNetwork", false))
         record.put("requiresCharging", call.getBoolean("requiresCharging", false))
         record.put("priority", call.getString("priority", "normal"))
         call.getObject("data")?.let { record.put("data", it) }
         record.put("consecutiveSkips", 0)
+        record.put("createdAt", now)
+        record.put("updatedAt", now)
+
+        // Compute nextDueAt at registration time
+        val nextDueAt = NativeJobEvaluator.computeNextDueAt(schedule, now)
+        if (nextDueAt != null) {
+            record.put("nextDueAt", nextDueAt)
+        }
+
         jobs[id] = record
         saveState()
 
@@ -247,12 +398,18 @@ class MobileCronPlugin : Plugin() {
         }
 
         call.getString("name")?.let { existing.put("name", it) }
-        call.getObject("schedule")?.let { existing.put("schedule", it) }
+        call.getObject("schedule")?.let {
+            existing.put("schedule", it)
+            // Recompute nextDueAt when schedule changes
+            val next = NativeJobEvaluator.computeNextDueAt(it, System.currentTimeMillis())
+            if (next != null) existing.put("nextDueAt", next) else existing.remove("nextDueAt")
+        }
         if (call.data.has("activeHours")) existing.put("activeHours", call.getObject("activeHours"))
         if (call.data.has("requiresNetwork")) existing.put("requiresNetwork", call.getBoolean("requiresNetwork", false))
         if (call.data.has("requiresCharging")) existing.put("requiresCharging", call.getBoolean("requiresCharging", false))
         call.getString("priority")?.let { existing.put("priority", it) }
         if (call.data.has("data")) existing.put("data", call.getObject("data"))
+        existing.put("updatedAt", System.currentTimeMillis())
 
         jobs[id] = existing
         saveState()
@@ -318,6 +475,7 @@ class MobileCronPlugin : Plugin() {
         mode = next!!
         scheduleWorkManager()
         saveState()
+        restartWatchdog()
         call.resolve()
         notifyListeners("statusChanged", buildStatus())
     }
@@ -339,4 +497,13 @@ class MobileCronPlugin : Plugin() {
         })
         return status
     }
+
+    private fun readLong(value: Any?): Long? {
+        return when (value) {
+            null -> null
+            is Number -> value.toLong()
+            is String -> value.toLongOrNull()
+            else -> null
+        }
+    }
 }

package/ios/Plugin/MobileCronPlugin.swift

@@ -28,11 +28,23 @@ public class MobileCronPlugin: CAPPlugin, CAPBridgedPlugin {
     var currentMode: String { mode }
     private var bgManager: BGTaskManager?
 
+    // Foreground watchdog — evaluates due jobs while the app is active
+    private var watchdogTimer: Timer?
+
+    private var tickInterval: TimeInterval {
+        switch mode {
+        case "eco": return 60.0
+        case "aggressive": return 15.0
+        default: return 30.0
+        }
+    }
+
     // ── Lifecycle ─────────────────────────────────────────────────────────────
 
     public override func load() {
         super.load()
         loadState()
+        computeMissingNextDueAt()
         firePendingNativeEvents()
         let manager = BGTaskManager(plugin: self)
         manager.registerBGTasks()
@@ -45,10 +57,22 @@ public class MobileCronPlugin: CAPPlugin, CAPBridgedPlugin {
             name: UIApplication.didBecomeActiveNotification,
             object: nil
         )
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(appWillResignActive),
+            name: UIApplication.willResignActiveNotification,
+            object: nil
+        )
+        startWatchdog()
     }
 
     @objc private func appDidBecomeActive() {
         firePendingNativeEvents()
+        startWatchdog()
+    }
+
+    @objc private func appWillResignActive() {
+        stopWatchdog()
     }
 
     func handleBackgroundWake(source: String) {
@@ -57,6 +81,121 @@ public class MobileCronPlugin: CAPPlugin, CAPBridgedPlugin {
         notifyListeners("nativeWake", data: ["source": source, "paused": paused])
     }
 
+    // ── Foreground watchdog ───────────────────────────────────────────────────
+
+    private func startWatchdog() {
+        guard watchdogTimer == nil else { return }
+        watchdogTimer = Timer.scheduledTimer(withTimeInterval: tickInterval, repeats: true) { [weak self] _ in
+            self?.evaluateDueJobsForeground()
+        }
+    }
+
+    private func stopWatchdog() {
+        watchdogTimer?.invalidate()
+        watchdogTimer = nil
+    }
+
+    private func restartWatchdog() {
+        stopWatchdog()
+        startWatchdog()
+    }
+
+    /// Evaluate due jobs while the app is in the foreground.
+    /// Directly emits jobDue events via notifyListeners (no file round-trip).
+    private func evaluateDueJobsForeground() {
+        let now = Int64(Date().timeIntervalSince1970 * 1000)
+        var mutated = false
+
+        for (id, var job) in jobs {
+            guard (job["enabled"] as? Bool) == true else { continue }
+            guard let schedule = job["schedule"] as? [String: Any] else { continue }
+
+            // Compute nextDueAt if missing
+            var nextDueAt = readLong(job["nextDueAt"])
+            if nextDueAt == nil {
+                if let computed = NativeJobEvaluator.computeNextDueAt(schedule: schedule, nowMs: now) {
+                    nextDueAt = computed
+                    job["nextDueAt"] = computed
+                    jobs[id] = job
+                    mutated = true
+                }
+            }
+
+            guard let due = nextDueAt, due <= now else { continue }
+
+            // Check skip reasons
+            if paused { continue }
+
+            if let activeHours = job["activeHours"] as? [String: Any],
+               !NativeJobEvaluator.isWithinActiveHours(activeHours: activeHours, nowMs: now) {
+                job["consecutiveSkips"] = ((job["consecutiveSkips"] as? Int) ?? 0) + 1
+                job["updatedAt"] = now
+                if (schedule["kind"] as? String) == "every" {
+                    if let next = NativeJobEvaluator.computeNextDueAt(schedule: schedule, nowMs: now) {
+                        job["nextDueAt"] = next
+                    } else {
+                        job.removeValue(forKey: "nextDueAt")
+                    }
+                }
+                jobs[id] = job
+                mutated = true
+                continue
+            }
+
+            // Fire the job
+            job["lastFiredAt"] = now
+            job["updatedAt"] = now
+            job["consecutiveSkips"] = 0
+
+            if (schedule["kind"] as? String) == "at" {
+                job["enabled"] = false
+                job.removeValue(forKey: "nextDueAt")
+            } else {
+                if let next = NativeJobEvaluator.computeNextDueAt(schedule: schedule, nowMs: now) {
+                    job["nextDueAt"] = next
+                } else {
+                    job.removeValue(forKey: "nextDueAt")
+                }
+            }
+
+            jobs[id] = job
+            mutated = true
+
+            // Emit jobDue directly to JS listeners
+            var payload: [String: Any] = [
+                "id": id,
+                "name": (job["name"] as? String) ?? "",
+                "firedAt": now,
+                "source": "watchdog"
+            ]
+            if let data = job["data"] {
+                payload["data"] = data
+            }
+            notifyListeners("jobDue", data: payload)
+        }
+
+        if mutated {
+            saveState()
+        }
+    }
+
+    /// Compute nextDueAt for all jobs that are missing it (e.g. after loadState from storage).
+    private func computeMissingNextDueAt() {
+        let now = Int64(Date().timeIntervalSince1970 * 1000)
+        var mutated = false
+        for (id, var job) in jobs {
+            guard (job["enabled"] as? Bool) == true else { continue }
+            guard readLong(job["nextDueAt"]) == nil else { continue }
+            guard let schedule = job["schedule"] as? [String: Any] else { continue }
+            if let computed = NativeJobEvaluator.computeNextDueAt(schedule: schedule, nowMs: now) {
+                job["nextDueAt"] = computed
+                jobs[id] = job
+                mutated = true
+            }
+        }
+        if mutated { saveState() }
+    }
+
     // ── Persistence ───────────────────────────────────────────────────────────
     // Uses NativeJobEvaluator.readStateRaw() / writeStateRaw() for file-backed
     // atomic writes that survive simctl terminate (SIGKILL) reliably.
@@ -144,19 +283,29 @@ public class MobileCronPlugin: CAPPlugin, CAPBridgedPlugin {
         }
 
         let id = UUID().uuidString
+        let now = Int64(Date().timeIntervalSince1970 * 1000)
+        let schedule = call.getObject("schedule") ?? [:]
+
         var record: [String: Any] = [
             "id": id,
             "name": name,
             "enabled": true,
-            "consecutiveSkips": 0
+            "consecutiveSkips": 0,
+            "createdAt": now,
+            "updatedAt": now
         ]
-        if let schedule = call.getObject("schedule") { record["schedule"] = schedule }
+        record["schedule"] = schedule
         if let activeHours = call.getObject("activeHours") { record["activeHours"] = activeHours }
         if call.options.keys.contains("requiresNetwork") { record["requiresNetwork"] = call.getBool("requiresNetwork") ?? false }
         if call.options.keys.contains("requiresCharging") { record["requiresCharging"] = call.getBool("requiresCharging") ?? false }
         if let priority = call.getString("priority") { record["priority"] = priority }
         if let data = call.getObject("data") { record["data"] = data }
 
+        // Compute nextDueAt at registration time
+        if let nextDueAt = NativeJobEvaluator.computeNextDueAt(schedule: schedule, nowMs: now) {
+            record["nextDueAt"] = nextDueAt
+        }
+
         jobs[id] = record
         saveState()
         notifyListeners("statusChanged", data: buildStatus())
@@ -185,12 +334,22 @@ public class MobileCronPlugin: CAPPlugin, CAPBridgedPlugin {
         }
 
         if let name = call.getString("name") { existing["name"] = name }
-        if let schedule = call.getObject("schedule") { existing["schedule"] = schedule }
+        if let schedule = call.getObject("schedule") {
+            existing["schedule"] = schedule
+            // Recompute nextDueAt when schedule changes
+            let now = Int64(Date().timeIntervalSince1970 * 1000)
+            if let next = NativeJobEvaluator.computeNextDueAt(schedule: schedule, nowMs: now) {
+                existing["nextDueAt"] = next
+            } else {
+                existing.removeValue(forKey: "nextDueAt")
+            }
+        }
         if call.options.keys.contains("activeHours") { existing["activeHours"] = call.getObject("activeHours") }
         if call.options.keys.contains("requiresNetwork") { existing["requiresNetwork"] = call.getBool("requiresNetwork") ?? false }
         if call.options.keys.contains("requiresCharging") { existing["requiresCharging"] = call.getBool("requiresCharging") ?? false }
         if let priority = call.getString("priority") { existing["priority"] = priority }
         if call.options.keys.contains("data") { existing["data"] = call.getObject("data") }
+        existing["updatedAt"] = Int64(Date().timeIntervalSince1970 * 1000)
 
         jobs[id] = existing
         saveState()
@@ -250,6 +409,7 @@ public class MobileCronPlugin: CAPPlugin, CAPBridgedPlugin {
             bgManager.scheduleProcessing(requiresExternalPower: mode != "aggressive")
         }
         saveState()
+        restartWatchdog()
         notifyListeners("statusChanged", data: buildStatus())
         call.resolve()
     }
@@ -331,4 +491,12 @@ public class MobileCronPlugin: CAPPlugin, CAPBridgedPlugin {
             ]
         ]
     }
+
+    private func readLong(_ value: Any?) -> Int64? {
+        switch value {
+        case let n as NSNumber: return n.int64Value
+        case let s as String: return Int64(s)
+        default: return nil
+        }
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capacitor-mobilecron",
-  "version": "0.2.22",
+  "version": "0.2.23",
   "description": "Capacitor scheduling primitive that emits job due events across web, Android, and iOS",
   "main": "dist/esm/index.js",
   "module": "dist/esm/index.js",