feat(cycle): rules that read the clock wait for it at boot

The head unit boots on 2019-01-01 and the ignition cycle runs before the
network or GPS corrects it. Rules with a time, weekday or date condition
were then not evaluable for that ignition. They are now held back and
run once the clock is set, polled every 2 s for up to five minutes; the
other rules of the cycle run at once as before. Dropped if the ignition
changes meanwhile, so a start-of-drive rule never fires after the drive;
run anyway at the deadline, so the history still records CLOCK_UNSET.
The wait is measured on elapsed time, since the wall clock is what jumps.
The manual test does not wait.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: malys

app/src/main/java/com/evsuite/tasker/debug/Diagnostics.kt

@@ -12,6 +12,7 @@ import com.evsuite.tasker.model.CompareOp
 import com.evsuite.tasker.model.Condition
 import com.evsuite.tasker.model.ConditionOutcome
 import com.evsuite.tasker.model.Snapshot
+import com.evsuite.tasker.util.WallClock
 
 /**
  * Turns the execution context into a per-catalogue-entry verdict.
@@ -272,17 +273,11 @@ object Diagnostics {
         type in BLUETOOTH_CONDITIONS -> Reason.BLUETOOTH_OFF
         type == ConditionType.LOCATION_WITHIN -> Reason.NO_LOCATION
         type == ConditionType.WEATHER_NOW -> Reason.WEATHER_UNANSWERED
-        !snapshot.clockSet && type in CLOCK_CONDITIONS -> Reason.CLOCK_UNSET
+        !snapshot.clockSet && type in WallClock.CONDITIONS -> Reason.CLOCK_UNSET
         !snapshot.bridgeAvailable -> Reason.LAYER_NOT_READY
         else -> Reason.NOT_READABLE
     }
 
-    private val CLOCK_CONDITIONS = setOf(
-        ConditionType.TIME_OF_DAY,
-        ConditionType.DAY_OF_WEEK,
-        ConditionType.DATE
-    )
-
     private val BLUETOOTH_CONDITIONS = setOf(
         ConditionType.BT_DEVICE_CONNECTED,
         ConditionType.ANY_BT_CONNECTED,

app/src/main/java/com/evsuite/tasker/util/WallClock.kt

@@ -1,5 +1,7 @@
 package com.evsuite.tasker.util
 
+import com.evsuite.hardware.catalog.ConditionType
+
 /**
  * Whether the head unit's clock tells the time yet.
  *
@@ -14,4 +16,7 @@ object WallClock {
     const val FLOOR_MS = 1_767_225_600_000L
 
     fun isSet(nowMs: Long = System.currentTimeMillis()): Boolean = nowMs >= FLOOR_MS
+
+    /** The conditions that read this clock, and so cannot be answered before it is set. */
+    val CONDITIONS = setOf(ConditionType.TIME_OF_DAY, ConditionType.DAY_OF_WEEK, ConditionType.DATE)
 }

app/src/main/java/com/evsuite/tasker/vehicle/RuleCycle.kt

@@ -7,8 +7,12 @@ import com.evsuite.tasker.engine.RuleEngine
 import com.evsuite.tasker.store.HistoryStore
 import com.evsuite.tasker.store.RuleStore
 import com.evsuite.tasker.model.EngineRun
+import com.evsuite.tasker.model.Rule
 import com.evsuite.tasker.util.BtDevices
 import com.evsuite.tasker.util.CarLocation
+import com.evsuite.tasker.util.WallClock
+import android.os.SystemClock
+import kotlin.concurrent.thread
 
 /**
  * Bluetooth devices currently connected to the vehicle.
@@ -115,19 +119,29 @@ object RuleCycle {
     const val MANUAL = "MANUAL"
     const val PHYSICAL_BUTTON = "PHYSICAL_BUTTON"
 
+    /**
+     * How long rules that read the clock wait for it after boot. The head unit corrects its
+     * RTC default from the network or GPS; past this, the rules run anyway and the history
+     * shows them not evaluable for `CLOCK_UNSET` rather than leaving no trace.
+     */
+    private const val CLOCK_WAIT_MS = 5 * 60_000L
+    private const val CLOCK_POLL_MS = 2_000L
+
     // A P cycle can still be closing glass when ignition-off arrives. Keep whole cycles,
     // not just individual writes, atomic against every other trigger.
     @Synchronized
     fun run(
         context: Context,
         trigger: String,
         eventReadings: Map<String, Any> = emptyMap(),
-        ruleId: String? = null
+        ruleId: String? = null,
+        /** The rules held back by [waitForClock], run once it is over. */
+        clockWaited: Set<String>? = null
     ) {
         val all = RuleStore(context).getAll()
         // Rules wired to a different event are not "skipped", they were never addressed: the
         // history would otherwise fill with a line per rule per ignition saying nothing.
-        val rules = when (trigger) {
+        var rules = when (trigger) {
             MANUAL -> all.filter { it.id == ruleId }
             PHYSICAL_BUTTON -> all.filter { it.hasPhysicalButtonCondition }
             // A position event belongs to the one rule whose place it is: its neighbours are
@@ -137,10 +151,20 @@ object RuleCycle {
                     (ruleId == null || it.id == ruleId)
             }
         }
+        if (clockWaited != null) rules = rules.filter { it.id in clockWaited }
         if (rules.isEmpty()) {
             AppLogger.i(TAG, "no rules for $trigger (${all.size} total) — skipped")
             return
         }
+        // A manual test answers now, clock or not: the user is looking at the result.
+        if (trigger != MANUAL && clockWaited == null && !WallClock.isSet()) {
+            val (needClock, now) = rules.partition(::readsClock)
+            if (needClock.isNotEmpty()) {
+                waitForClock(context.applicationContext, trigger, eventReadings, needClock.map { it.id }.toSet())
+            }
+            rules = now
+            if (rules.isEmpty()) return
+        }
 
         val startedAt = System.currentTimeMillis()
         val profileBridge = ProfileBridge(context).takeIf { it.connect() }
@@ -180,4 +204,40 @@ object RuleCycle {
             profileBridge?.disconnect()
         }
     }
+
+    /** Whether any case of [rule], "else if" ones included, asks the time, weekday or date. */
+    internal fun readsClock(rule: Rule): Boolean =
+        rule.branches.any { branch -> branch.conditions.any { it.type in WallClock.CONDITIONS } }
+
+    /**
+     * Runs [ruleIds] again once the head unit's clock is set.
+     *
+     * At boot the clock reads 2019-01-01 until the network or GPS corrects it, and the
+     * ignition cycle runs before that. Rules that read the time, the weekday or the date
+     * wait for it; the others ran already and are not held up. Abandoned if the ignition
+     * changes meanwhile: a start-of-drive rule must not fire after the drive is over. Waits
+     * on elapsed time, because the wall clock is precisely what jumps.
+     */
+    private fun waitForClock(
+        context: Context,
+        trigger: String,
+        eventReadings: Map<String, Any>,
+        ruleIds: Set<String>
+    ) {
+        val ignition = EVHardware.getCurrentIgnitionState()
+        AppLogger.i(TAG, "clock not set — ${ruleIds.size} $trigger rule(s) wait for it")
+        thread(name = "mg4-tasker-clock-wait") {
+            val start = SystemClock.elapsedRealtime()
+            while (!WallClock.isSet() && SystemClock.elapsedRealtime() - start < CLOCK_WAIT_MS) {
+                Thread.sleep(CLOCK_POLL_MS)
+            }
+            val waitedS = (SystemClock.elapsedRealtime() - start) / 1000
+            if (EVHardware.getCurrentIgnitionState() != ignition) {
+                AppLogger.i(TAG, "ignition changed during the ${waitedS} s clock wait — $trigger rules dropped")
+                return@thread
+            }
+            AppLogger.i(TAG, "clock ${if (WallClock.isSet()) "set" else "still not set"} after ${waitedS} s — running held $trigger rules")
+            run(context, trigger, eventReadings, clockWaited = ruleIds)
+        }
+    }
 }

app/src/test/java/com/evsuite/tasker/vehicle/RuleCycleClockTest.kt

@@ -0,0 +1,28 @@
+package com.evsuite.tasker.vehicle
+
+import com.evsuite.hardware.catalog.ConditionType
+import com.evsuite.tasker.model.Branch
+import com.evsuite.tasker.model.Condition
+import com.evsuite.tasker.model.Rule
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class RuleCycleClockTest {
+
+    @Test fun `a clock condition in any case holds the rule back`() {
+        val outside = Condition(ConditionType.OUTSIDE_TEMP, number = 10f)
+        assertFalse(RuleCycle.readsClock(Rule(name = "r", conditions = listOf(outside))))
+        assertTrue(RuleCycle.readsClock(Rule(name = "r", conditions = listOf(Condition(ConditionType.DAY_OF_WEEK)))))
+        // The "else if" is where it is easy to miss.
+        assertTrue(
+            RuleCycle.readsClock(
+                Rule(
+                    name = "r",
+                    conditions = listOf(outside),
+                    elseIf = listOf(Branch(conditions = listOf(Condition(ConditionType.TIME_OF_DAY))))
+                )
+            )
+        )
+    }
+}