feat(rules): run a rule when the car reaches or leaves a place

A LOCATION trigger samples the rule's "near a place" conditions every 5 s
while the ignition is in RUN and runs the rule once on a confirmed
false -> true edge, with a silent baseline like the P trigger. Only the rule
whose place was reached runs. GPS subscription cadence 60 s -> 5 s.

Runs while moving: vehicle writes still take the standstill gate, and a
position rule must name a place and may not ask a question or open the
profile picker (refused at save and import).

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

Author: malys

AGENTS.md

@@ -57,7 +57,11 @@ switch-off trigger reads the other end of that same stream — no second listene
 Gear callbacks are not portable across the supported firmwares, so the P trigger samples
 `EVHardware.isVehicleInPark()` every 500 ms only while ignition is RUN and fires only on a
 confirmed non-P → P transition. Its first readable sample is a silent baseline, so service
-recreation while already parked never fabricates an event. Physical buttons are conditions
+recreation while already parked never fabricates an event. The position trigger shares that sampling lifecycle (every 5 s, RUN only):
+`LocationTriggerDetector` fires per "near a place" condition on a confirmed false → true edge,
+with the same silent baseline, and `RuleCycle` runs only the rule whose place it was. It runs
+while moving, so `Rule.positionTriggerIsSound` refuses screen-taking actions (question,
+profile picker) at save and import. Physical buttons are conditions
 (never a `RuleTrigger`): a rule containing one is
 addressed by that event and excluded from vehicle-trigger cycles. EVHardware owns the OEM keycode
 catalogue and short/long-press state machine; the app only receives the broadcast and feeds

CHANGELOG.md

@@ -6,6 +6,21 @@ All notable changes to this project are documented here. Format follows
 
 ## [Unreleased]
 
+### Added
+
+- **Position trigger.** A rule can now run when the car reaches a place, instead of only at
+  start, P or switch-off. While the ignition is on, its "near a place" conditions are checked
+  every 5 s; the rule runs once when one turns true (arriving — or leaving, for "not near"),
+  never again while the car stays there, and a drive that starts inside the zone does not
+  count as an arrival. Vehicle writes still take the standstill gate, so on the move they are
+  refused and shown as such. Such a rule must contain a place condition and may not ask a
+  question or open the profile picker, since it runs while driving.
+
+### Changed
+
+- The GPS subscription updates every 5 s instead of every 60 s, so an arrival is noticed
+  within a few dozen metres.
+
 ## [2.12.0] - 2026-09-23
 
 ### Added

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

@@ -20,8 +20,12 @@ enum class MatchMode { ALL, ANY }
  * At [IGNITION_OFF] the car is powering down. Settings that persist (charge limit, door
  * locks, windows) land; anything the vehicle drops with the ignition may not, and the
  * history reports what each action returned rather than assuming.
+ *
+ * [LOCATION] is sampled while the ignition is in RUN: the rule runs once when one of its
+ * "near a place" conditions turns true (arriving, or leaving when the condition says "not
+ * near"), never repeatedly while the car stays where it is. See [positionTriggerIsSound].
  */
-enum class RuleTrigger { IGNITION_ON, GEAR_PARK, IGNITION_OFF }
+enum class RuleTrigger { IGNITION_ON, GEAR_PARK, IGNITION_OFF, LOCATION }
 
 /**
  * One configured condition.
@@ -239,8 +243,24 @@ data class Rule(
      */
     val buttonAddressingIsSound: Boolean get() = !hasPhysicalButtonCondition ||
         (otherwise.isEmpty() && branches.all { branch -> branch.conditions.any { it.type.eventDriven } })
+
+    /**
+     * Whether a position-triggered rule can fire, and fire safely.
+     *
+     * The event *is* a "near a place" condition turning true, so a rule without one would
+     * never run. And it runs mostly while the car moves: an action that puts a question or a
+     * picker in front of the driver is refused, per the suite rule against driver-facing
+     * overlays while moving. Refused at save and import, like [buttonAddressingIsSound].
+     */
+    val positionTriggerIsSound: Boolean get() = firesOn != RuleTrigger.LOCATION ||
+        hasPhysicalButtonCondition ||
+        (branches.any { b -> b.conditions.any { it.type == ConditionType.LOCATION_WITHIN } } &&
+            (branches.flatMap { it.actions } + otherwise).none { it.type in SCREEN_ACTIONS })
 }
 
+/** Actions that wait for the driver's hands on the screen. */
+private val SCREEN_ACTIONS = setOf(ActionType.ASK_CONFIRM, ActionType.SHOW_PROFILE_PICKER)
+
 /** Whether a list of actions changes anything, or is only waiting. */
 private fun List<Action>.doesSomething(): Boolean = any { it.type != ActionType.DELAY }
 

app/src/main/java/com/evsuite/tasker/service/TaskerVehicleService.kt

@@ -21,6 +21,7 @@ import com.evsuite.tasker.util.BtDevices
 import com.evsuite.tasker.util.BtMessaging
 import com.evsuite.tasker.util.CarLocation
 import com.evsuite.tasker.util.DriveClock
+import com.evsuite.tasker.util.LocationTriggerDetector
 import com.evsuite.tasker.util.Notifier
 import com.evsuite.tasker.util.ParkTriggerDetector
 import com.evsuite.tasker.vehicle.BtOnboard
@@ -56,6 +57,12 @@ class TaskerVehicleService : Service() {
         private const val ONBOARD_SAMPLE_MS = 15_000L
         /** Gear has no portable push callback on every supported generation. Poll only in RUN. */
         private const val PARK_SAMPLE_MS = 500L
+        /**
+         * How often position rules are checked while in RUN. At 50 km/h the car covers ~70 m
+         * between two looks — inside any radius worth writing — and each look is one cached
+         * fix and one read of the rule store, no vehicle binder call.
+         */
+        private const val LOCATION_SAMPLE_MS = 5_000L
         private const val HARDKEY_ACTION = "com.saic.keyevent.hardkey.report"
         private const val SYSTEMUI_HARDKEY_ACTION = "com.android.systemui.ACTION_HARD_KEY_EVENT"
         const val HARDKEY_PERMISSION = "com.evsuite.tasker.permission.RECEIVE_HARDKEY"
@@ -95,6 +102,7 @@ class TaskerVehicleService : Service() {
     private var lastTrigger: RuleTrigger? = null
 
     private val parkTrigger = ParkTriggerDetector()
+    private val locationTrigger = LocationTriggerDetector()
 
     /** Stops an in-flight park sample from scheduling itself again after ignition-off. */
     @Volatile
@@ -127,6 +135,21 @@ class TaskerVehicleService : Service() {
         }
     }
 
+    /** Shares the park sampler's lifecycle and thread: RUN only, detector reset at each edge. */
+    private val locationSampler = object : Runnable {
+        override fun run() {
+            if (!vehicleRunning) return
+            val rules = RuleStore(this@TaskerVehicleService).getAll().filter {
+                it.enabled && !it.hasPhysicalButtonCondition && it.firesOn == RuleTrigger.LOCATION
+            }
+            val fix = CarLocation.lastKnown(applicationContext)
+            for (id in locationTrigger.sample(rules, fix)) {
+                runRulesFor(RuleTrigger.LOCATION, "Position condition turned true", id)
+            }
+            if (vehicleRunning) onboardHandler.postDelayed(this, LOCATION_SAMPLE_MS)
+        }
+    }
+
     override fun onBind(intent: Intent?): IBinder? = null
 
     override fun onCreate() {
@@ -213,6 +236,7 @@ class TaskerVehicleService : Service() {
         vehicleRunning = false
         onboardHandler.removeCallbacks(onboardSampler)
         onboardHandler.removeCallbacks(parkSampler)
+        onboardHandler.removeCallbacks(locationSampler)
         onboardThread.quitSafely()
     }
 
@@ -229,24 +253,33 @@ class TaskerVehicleService : Service() {
         if (vehicleRunning) return
         vehicleRunning = true
         onboardHandler.removeCallbacks(parkSampler)
+        onboardHandler.removeCallbacks(locationSampler)
         onboardHandler.post {
             parkTrigger.reset()
-            if (vehicleRunning) parkSampler.run()
+            locationTrigger.reset()
+            if (vehicleRunning) {
+                parkSampler.run()
+                locationSampler.run()
+            }
         }
     }
 
     private fun stopParkSampling() {
         if (!vehicleRunning) return
         vehicleRunning = false
         onboardHandler.removeCallbacks(parkSampler)
+        onboardHandler.removeCallbacks(locationSampler)
         // Keep detector mutation on its sampling thread.
-        onboardHandler.post { parkTrigger.reset() }
+        onboardHandler.post {
+            parkTrigger.reset()
+            locationTrigger.reset()
+        }
     }
 
-    private fun runRulesFor(trigger: RuleTrigger, event: String) {
+    private fun runRulesFor(trigger: RuleTrigger, event: String, ruleId: String? = null) {
         if (AppState.isAutomationEnabled(this)) {
-            AppLogger.i(TAG, "$event → evaluating ${trigger.name} rules")
-            thread(name = "mg4-tasker-cycle") { RuleCycle.run(this, trigger.name) }
+            AppLogger.i(TAG, "$event → evaluating ${trigger.name} rules${ruleId?.let { " ($it)" }.orEmpty()}")
+            thread(name = "mg4-tasker-cycle") { RuleCycle.run(this, trigger.name, ruleId = ruleId) }
         } else {
             AppLogger.i(TAG, "$event but automation disabled — ignored")
         }

app/src/main/java/com/evsuite/tasker/store/RuleTransfer.kt

@@ -224,6 +224,7 @@ object RuleTransfer {
         // and a rule addressed by a button must name one in every case it can run.
         if (!rule.isComplete()) return Result.Invalid(Reason.MALFORMED)
         if (!rule.buttonAddressingIsSound) return Result.Invalid(Reason.MALFORMED)
+        if (!rule.positionTriggerIsSound) return Result.Invalid(Reason.MALFORMED)
 
         return Result.Ok(listOf(rule))
     }

app/src/main/java/com/evsuite/tasker/ui/HistoryFragment.kt

@@ -89,6 +89,7 @@ class HistoryFragment : Fragment() {
                     DeferredWrites.TRIGGER -> R.string.history_trigger_deferred
                     RuleTrigger.GEAR_PARK.name -> R.string.history_trigger_park
                     RuleTrigger.IGNITION_OFF.name -> R.string.history_trigger_ignition_off
+                    RuleTrigger.LOCATION.name -> R.string.history_trigger_location
                     RuleCycle.PHYSICAL_BUTTON -> R.string.history_trigger_button
                     else -> R.string.history_trigger_ignition
                 }

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

@@ -105,6 +105,7 @@ class RuleEditorActivity : AppCompatActivity() {
         binding.triggerGroup.check(when (existing?.firesOn) {
             RuleTrigger.GEAR_PARK -> R.id.triggerGearPark
             RuleTrigger.IGNITION_OFF -> R.id.triggerIgnitionOff
+            RuleTrigger.LOCATION -> R.id.triggerLocation
             else -> R.id.triggerIgnitionOn
         })
 
@@ -276,6 +277,7 @@ class RuleEditorActivity : AppCompatActivity() {
             trigger = when (binding.triggerGroup.checkedButtonId) {
                 R.id.triggerGearPark -> RuleTrigger.GEAR_PARK
                 R.id.triggerIgnitionOff -> RuleTrigger.IGNITION_OFF
+                R.id.triggerLocation -> RuleTrigger.LOCATION
                 else -> RuleTrigger.IGNITION_ON
             },
             conditions = first.conditions,
@@ -301,6 +303,10 @@ class RuleEditorActivity : AppCompatActivity() {
         if (!rule.buttonAddressingIsSound) {
             toastLong(getString(R.string.editor_button_cases)); return
         }
+        // Without a place the trigger never fires; with a question it would ask a moving driver.
+        if (!rule.positionTriggerIsSound) {
+            toastLong(getString(R.string.editor_location_trigger_rules)); return
+        }
         // Said now rather than through a wait cut short in the history after the drive.
         if (rule.totalDelayMs > com.evsuite.tasker.model.DELAY_BUDGET_MS) {
             toastLong(

app/src/main/java/com/evsuite/tasker/ui/RulesFragment.kt

@@ -174,6 +174,7 @@ class RulesFragment : Fragment() {
             else when (current.firesOn) {
                 com.evsuite.tasker.model.RuleTrigger.GEAR_PARK -> R.string.editor_trigger_park
                 com.evsuite.tasker.model.RuleTrigger.IGNITION_OFF -> R.string.editor_trigger_off
+                com.evsuite.tasker.model.RuleTrigger.LOCATION -> R.string.editor_trigger_location
                 else -> R.string.editor_trigger_on
             }
         )

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

@@ -29,11 +29,12 @@ object CarLocation {
     private const val MAX_AGE_MS = 30 * 60 * 1000L
 
     /**
-     * Cadence of the service's subscription. Far below [MAX_AGE_MS], so the cache is never
-     * the reason a condition is unanswerable, and far above a navigation app's, because
-     * nothing here needs to know which lane the car is in.
+     * Cadence of the service's subscription. Matches the position trigger's sampling: at
+     * 60 s the fix jumped ~800 m between updates at 50 km/h and an arrival was noticed a
+     * minute late or, through a small radius, not at all. Still well above a navigation
+     * app's, because nothing here needs to know which lane the car is in.
      */
-    private const val TRACK_INTERVAL_MS = 60_000L
+    private const val TRACK_INTERVAL_MS = 5_000L
 
     /** How long an inactive subscription may stay inactive before the watchdog re-arms it. */
     const val TRACK_RETRY_INTERVAL_MS = 60_000L

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

@@ -0,0 +1,46 @@
+package com.evsuite.tasker.util
+
+import com.evsuite.hardware.catalog.ConditionType
+import com.evsuite.tasker.engine.ConditionEvaluator
+import com.evsuite.tasker.model.ConditionOutcome
+import com.evsuite.tasker.model.Rule
+import com.evsuite.tasker.model.Snapshot
+
+/**
+ * Detects a "near a place" condition turning true, for the position trigger.
+ *
+ * Same contract as [ParkTriggerDetector], per condition: the first readable sample is a
+ * silent baseline (a drive that starts at home must not "arrive" there), an unreadable one
+ * changes nothing, and only a confirmed false → true transition fires. The key carries the
+ * condition's own point, radius and sense, so editing a place starts a fresh baseline
+ * instead of comparing against the old one.
+ */
+class LocationTriggerDetector {
+    private val lastMatch = HashMap<String, Boolean>()
+
+    /** @return the ids of [rules] one of whose position conditions has just turned true. */
+    fun sample(rules: List<Rule>, fix: CarLocation.Fix?): List<String> {
+        val snapshot = Snapshot(latitude = fix?.latitude, longitude = fix?.longitude)
+        val seen = HashSet<String>()
+        val fired = rules.filter { rule ->
+            rule.branches.flatMap { it.conditions }
+                .filter { it.type == ConditionType.LOCATION_WITHIN }
+                .mapIndexed { i, c ->
+                    val key = "${rule.id}#$i#${c.text}#${c.number}#${c.flag}"
+                    seen += key
+                    when (ConditionEvaluator.evaluate(c, snapshot)) {
+                        ConditionOutcome.UNAVAILABLE -> false
+                        ConditionOutcome.MATCH -> lastMatch.put(key, true) == false
+                        else -> { lastMatch[key] = false; false }
+                    }
+                }
+                .any { it }
+        }.map { it.id }
+        lastMatch.keys.retainAll(seen)
+        return fired
+    }
+
+    fun reset() {
+        lastMatch.clear()
+    }
+}