feat: a wait between two actions, and an order to put it in

The engine runs a rule's actions sequentially, so the wait belongs there rather than in
the executor: nothing is written, there is no verdict to obtain from the vehicle, and the
engine is the only place that can hold the line between two actions. It reuses the
injectable sleep, so tests do not actually wait.

Actions can now be reordered in the editor, which is what makes the wait usable — a pause
only means something if the user can say what it comes between. Conditions keep no arrows:
they are all evaluated whatever their order.

A rule made only of waits is incomplete. It holds the cycle for its duration and changes
nothing.

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

Author: malys

CHANGELOG.md

@@ -8,6 +8,10 @@ All notable changes to this project are documented here. Format follows
 
 ### Added
 
+- **Wait** action (1 to 60 seconds), and reordering of a rule's actions with the arrows
+  on each row. Actions run one after the other in the order shown, so a wait placed
+  between two of them lets the first write land before the second is asked for
+  (climate on, then fan level). A rule made only of waits is refused at save time.
 - Configuration tab. The speed threshold, the language and the rules file
   (export / import) moved there from the rules pane; the Rules tab is now the rule
   list and nothing else.

MG4Hardware

@@ -184,6 +184,14 @@ Gate refusals are now kept and re-attempted at the first standstill. Three limit
 Transient action failures are different: each failed action is retried independently up to
 three times with exponential backoff (250 ms, then 500 ms). Actions that already succeeded
 are never replayed.
+
+A rule's actions run **one after the other, in the order shown in the editor**, and each one
+is finished before the next starts. That order is part of the rule: the arrows on every
+action row move it up or down. Where one write must land before the next is asked for —
+switching the climate on, then setting the fan level — the **Wait** action (1 to 60 seconds)
+holds the sequence in between. It touches nothing in the car, and appears in the history at
+its place in the sequence. A rule made only of waits is refused at save time: it would hold
+the cycle and change nothing.
 - **15 minutes, and never across an ignition cycle.** A rule that fired for this drive
   belongs to this drive. At switch-off the queue is dropped, not applied: the car is stopped
   then, which is exactly what makes it the wrong moment to change the setting the next
@@ -215,7 +223,7 @@ temperature, A/C, AUTO, recirculation, fan level, front and rear defrosters), **
 (charge limit, allow charging, scheduled charging and its window, battery pre-heating),
 **audio** (volume, the fine controls, play the radio), **driver assistance**, and **system**
 (launch an app, show a message, speak through the head unit's text-to-speech engine,
-navigate to a destination, call a number). ADAS state — AEB, ELK, ACC/TJA, TSR, overspeed and
+navigate to a destination, call a number, wait). ADAS state — AEB, ELK, ACC/TJA, TSR, overspeed and
 so on — is fully covered as gated actions.
 
 **Near a place** compares the car's last known fix with a point stored in the rule and a

README.md

@@ -4,6 +4,7 @@ import com.mg4.tasker.bridge.BridgeContract
 import com.mg4.tasker.model.Action
 import com.mg4.tasker.model.ActionResult
 import com.mg4.tasker.model.ConditionOutcome
+import com.mg4.hardware.catalog.ActionType
 import com.mg4.hardware.catalog.ConditionType
 import com.mg4.tasker.model.EngineRun
 import com.mg4.tasker.model.MatchMode
@@ -75,10 +76,30 @@ class RuleEngine(
             }
         }
 
-        val results = rule.actions.map { executeWithBackoff(it) }
+        // Sequential on purpose: two writes to the same subsystem sent at once are answered
+        // from the state the car had before either landed, and the user's order is the order
+        // they meant — a [ActionType.DELAY] between two of them only means anything if what
+        // follows it really waits.
+        val results = rule.actions.map {
+            if (it.type == ActionType.DELAY) pause(it) else executeWithBackoff(it)
+        }
         return RuleRun(rule.id, rule.name, RuleOutcome.FIRED, results)
     }
 
+    /**
+     * The wait, run here rather than in the executor.
+     *
+     * Nothing is written, so there is no verdict to obtain from the vehicle; and the engine
+     * is what runs the actions one after the other, so it is also what can hold the line
+     * between two of them. Reusing the injectable [sleep] keeps tests from actually waiting.
+     */
+    private fun pause(action: Action): ActionResult {
+        val spec = ActionType.DELAY.spec
+        val seconds = action.number.coerceIn(spec.min, spec.max)
+        sleep(seconds * 1000L)
+        return ActionResult(ActionType.DELAY, true, BridgeContract.VERDICT_ALLOWED, "$seconds s")
+    }
+
     private fun executeWithBackoff(action: Action): ActionResult {
         var delay = initialDelayMs
         var attempt = 1

app/src/main/java/com/mg4/tasker/engine/RuleEngine.kt

@@ -91,8 +91,12 @@ data class Rule(
      * A rule with no condition would apply on every start without the user asking; a rule
      * with no action does nothing. Both are refused at save time rather than silently
      * ignored at run time.
+     *
+     * A rule made only of waits counts as having no action: it holds the cycle for its
+     * duration and changes nothing.
      */
-    fun isComplete(): Boolean = conditions.isNotEmpty() && actions.isNotEmpty()
+    fun isComplete(): Boolean =
+        conditions.isNotEmpty() && actions.any { it.type != ActionType.DELAY }
 
     /** [trigger], defaulting to vehicle start — what every rule written before this did. */
     val firesOn: RuleTrigger get() = trigger ?: RuleTrigger.IGNITION_ON

app/src/main/java/com/mg4/tasker/model/Rule.kt

@@ -313,23 +313,48 @@ class RuleEditorActivity : AppCompatActivity() {
                         }
                     }
                 },
-                onRemove = { actions.removeAt(index); renderActions() }
+                onRemove = { actions.removeAt(index); renderActions() },
+                // Actions run in the order shown, so the order is part of the rule: a wait
+                // is only useful where the user puts it.
+                reorderable = true,
+                canMoveUp = index > 0,
+                canMoveDown = index < actions.lastIndex,
+                onMoveUp = { move(index, index - 1) },
+                onMoveDown = { move(index, index + 1) }
             )
         }
     }
 
+    private fun move(from: Int, to: Int) {
+        actions.add(to, actions.removeAt(from))
+        renderActions()
+    }
+
     private fun addRow(
         container: android.view.ViewGroup,
         label: String,
         gated: Boolean,
         onEdit: () -> Unit,
-        onRemove: () -> Unit
+        onRemove: () -> Unit,
+        reorderable: Boolean = false,
+        canMoveUp: Boolean = false,
+        canMoveDown: Boolean = false,
+        onMoveUp: () -> Unit = {},
+        onMoveDown: () -> Unit = {}
     ) {
         val row = ItemEditorRowBinding.inflate(LayoutInflater.from(this), container, false)
         row.rowLabel.text = label
         row.rowGated.visibility = if (gated) View.VISIBLE else View.GONE
         row.rowClickArea.setOnClickListener { onEdit() }
         row.rowRemove.setOnClickListener { onRemove() }
+        // Kept in place and disabled at the ends rather than hidden: buttons that disappear
+        // move every other row's controls under the finger already reaching for them.
+        row.rowUp.visibility = if (reorderable) View.VISIBLE else View.GONE
+        row.rowDown.visibility = if (reorderable) View.VISIBLE else View.GONE
+        row.rowUp.isEnabled = canMoveUp
+        row.rowDown.isEnabled = canMoveDown
+        row.rowUp.setOnClickListener { onMoveUp() }
+        row.rowDown.setOnClickListener { onMoveDown() }
         container.addView(row.root)
     }
 

app/src/main/java/com/mg4/tasker/ui/RuleEditorActivity.kt

@@ -48,6 +48,40 @@
                 android:visibility="gone" />
         </LinearLayout>
 
+        <!-- Reordering: shown for actions, which run in the order listed, and hidden for
+             conditions, which are all evaluated regardless of order. -->
+        <com.google.android.material.button.MaterialButton
+            android:id="@+id/rowUp"
+            style="@style/Widget.Material3.Button.TextButton"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:minWidth="@dimen/touch_target"
+            android:minHeight="@dimen/touch_target"
+            android:insetLeft="0dp"
+            android:insetRight="0dp"
+            android:paddingStart="@dimen/spacing_sm"
+            android:paddingEnd="@dimen/spacing_sm"
+            android:textSize="@dimen/text_body"
+            android:text="@string/editor_move_up_glyph"
+            android:contentDescription="@string/editor_move_up"
+            android:visibility="gone" />
+
+        <com.google.android.material.button.MaterialButton
+            android:id="@+id/rowDown"
+            style="@style/Widget.Material3.Button.TextButton"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:minWidth="@dimen/touch_target"
+            android:minHeight="@dimen/touch_target"
+            android:insetLeft="0dp"
+            android:insetRight="0dp"
+            android:paddingStart="@dimen/spacing_sm"
+            android:paddingEnd="@dimen/spacing_sm"
+            android:textSize="@dimen/text_body"
+            android:text="@string/editor_move_down_glyph"
+            android:contentDescription="@string/editor_move_down"
+            android:visibility="gone" />
+
         <com.google.android.material.button.MaterialButton
             android:id="@+id/rowRemove"
             style="@style/Widget.Material3.Button.TextButton"

app/src/main/res/layout/item_editor_row.xml

@@ -239,4 +239,6 @@
     <string name="value_editor_instruction">Wählen Sie den Wert für diese Regel.</string>
     <string name="editor_trigger_on">Fahrzeugstart</string>
     <string name="editor_trigger_off">Fahrzeug aus</string>
+    <string name="editor_move_up">Nach oben</string>
+    <string name="editor_move_down">Nach unten</string>
 </resources>

app/src/main/res/values-de/strings.xml

@@ -239,4 +239,6 @@
     <string name="value_editor_instruction">Elija el valor que se usará en esta regla.</string>
     <string name="editor_trigger_on">Al arrancar</string>
     <string name="editor_trigger_off">Al apagar</string>
+    <string name="editor_move_up">Subir</string>
+    <string name="editor_move_down">Bajar</string>
 </resources>

app/src/main/res/values-es/strings.xml

@@ -256,4 +256,6 @@
     <string name="value_editor_instruction">Choisissez la valeur à utiliser dans cette règle.</string>
     <string name="editor_trigger_on">Au démarrage</string>
     <string name="editor_trigger_off">À l’extinction</string>
+    <string name="editor_move_up">Monter</string>
+    <string name="editor_move_down">Descendre</string>
 </resources>