RingController: accessibility, gesture, and action updates

Made-with: Cursor

Author: YoshifumiKawai

src/RingController/RingAccessibilityService.cs

@@ -44,6 +44,12 @@ public class RingAccessibilityService : AccessibilityService, ISensorEventListen
     /// <summary> ThresholdCrossing: last time we executed after a successful <see cref="RingGestureInterpreter.Interpret"/> (rate limit via <see cref="RingModeProfile.AccumulationTimeoutMs"/>). </summary>
     long lastThresholdTriggerAtMs;
 
+    /// <summary> Last sample where ring reported motion or off-center integral (see <see cref="TryResetInterpreterAfterRingIdle"/>). </summary>
+    long lastMeaningfulRingActivityMs;
+
+    const long MeaningfulRingIdleResetMs = 400;
+    const int MeaningfulRingSumAbsQuiet = 24;
+
     const string SensorStringTypeOpticalTracking = "xiaomi.sensor.optical_tracking";
 
     public override void OnCreate()
@@ -102,6 +108,7 @@ public override void OnDestroy()
     /// <summary> Sets foreground package for per-app config and whether a camera app is on top. </summary>
     void UpdateForegroundPackage(string packageName)
     {
+        var priorResolved = foregroundResolvedPackage;
         var resolvedPackageName = packageName;
 
         // Home / system UI can be the event package while another app is actually focused — prefer root window.
@@ -137,6 +144,14 @@ void UpdateForegroundPackage(string packageName)
         }
 
         foregroundResolvedPackage = resolvedPackageName;
+        if (!string.IsNullOrEmpty(priorResolved) &&
+            !string.Equals(priorResolved, foregroundResolvedPackage, StringComparison.Ordinal))
+        {
+            interpreter.ResetProcessingStateAfterIdle();
+            lastSumDeltaXForAccum = null;
+            accumBaselineSum = null;
+            lastMeaningfulRingActivityMs = 0;
+        }
     }
 
     RingConfig ResolveEffectiveRingConfig(RingConfig? loadedRoot = null)
@@ -182,6 +197,28 @@ static int AccumulateEffectiveAbsMag(int sum, int delta, int baseline, int minAb
         return Math.Max(integralAbs, ThresholdAlignedBlendedAbs(sum, delta, minAbsToTrigger));
     }
 
+    /// <summary>
+    /// Optical tracking can stream events continuously; inter-sample time never shows "idle". After quiet motion/integral,
+    /// reset interpreter + accum baselines so stale driver state cannot block triggers.
+    /// </summary>
+    void TryResetInterpreterAfterRingIdle(long nowMs, int sumDeltaX, int deltaX)
+    {
+        var meaningful = deltaX != 0 || Math.Abs(sumDeltaX) > MeaningfulRingSumAbsQuiet;
+        if (meaningful)
+        {
+            lastMeaningfulRingActivityMs = nowMs;
+            return;
+        }
+
+        if (lastMeaningfulRingActivityMs <= 0) return;
+        if (nowMs - lastMeaningfulRingActivityMs <= MeaningfulRingIdleResetMs) return;
+
+        interpreter.ResetProcessingStateAfterIdle();
+        lastSumDeltaXForAccum = null;
+        accumBaselineSum = null;
+        lastMeaningfulRingActivityMs = 0;
+    }
+
     public void OnSensorChanged(SensorEvent? e)
     {
         if (e?.Values == null || e.Values.Count < 8) return;
@@ -192,14 +229,14 @@ public void OnSensorChanged(SensorEvent? e)
         if (isCameraForeground) return;
 
         var sensorData = ringSensor.CreateRingSensorData(e);
+        var now = SystemClock.UptimeMillis();
+        TryResetInterpreterAfterRingIdle(now, sensorData.sum_delta_x, sensorData.delta_x);
+
         var config = ResolveEffectiveRingConfig(root);
         var modeProfile = config.GetProfile(config.ExecutionMode);
 
-        // Every sensor event: zero all timeout / interval bases so nothing carries over from prior samples.
-        lastThresholdTriggerAtMs = 0;
-        lastAccumExecuteAtMs = 0;
-        lastSensorEventMsForAccum = 0;
-        interpreter.ResetTimeoutClocksForSensorEvent();
+        // Timing state (threshold / accum idle / gesture gap & cooldown) must persist across sensor callbacks.
+        // Resetting clocks every sample broke MaxGapMs, idle baseline snap, and cooldowns after pauses (e.g. app scroll).
 
         if (config.ExecutionMode != RingExecutionMode.ThresholdAccumulatedRepeat)
         {
@@ -212,7 +249,6 @@ public void OnSensorChanged(SensorEvent? e)
 
         if (config.ExecutionMode == RingExecutionMode.Gesture)
         {
-            var now = SystemClock.UptimeMillis();
             var sum = sensorData.sum_delta_x;
             var gestureAction = interpreter.InterpretGesture(
                 sumDeltaX: sum,
@@ -238,7 +274,6 @@ public void OnSensorChanged(SensorEvent? e)
         }
         else if (config.ExecutionMode == RingExecutionMode.ThresholdAccumulatedRepeat)
         {
-            var now = SystemClock.UptimeMillis();
             long resetAfter = modeProfile.AccumulationTimeoutMs > 0 ? modeProfile.AccumulationTimeoutMs : 100;
             long minIntervalMs = resetAfter;
 

src/RingController/RingActionExecutor.cs

@@ -412,7 +412,7 @@ void DispatchCenterVerticalSwipe(bool swipeUp)
         var cy = h * 0.5f;
         cy = Math.Clamp(cy, h * 0.15f, h * 0.85f);
 
-        var half = Math.Min(h * 0.38f, 560f) * 0.5f;
+        var half = Math.Min(h * 0.38f, 560f) * 0.25f;
         float y1, y2;
         if (swipeUp)
         {

src/RingController/RingGestureInterpreter.cs

@@ -12,20 +12,10 @@ sealed record GestureEvent(long TimeMs, RingDirection Direction, int AbsDeltaX);
     readonly List<GestureEvent> buffer = new();
     readonly List<GestureSequenceState> gestureSequenceStates = new();
     int? lastGestureSumForDriver;
-    /// <summary>
-    /// Time of the last sensor callback. After <see cref="ResetTimeoutClocksForSensorEvent"/> resets to 0,
-    /// updated in <see cref="InterpretGesture"/>'s <c>finally</c> (elapsed time restarts per event).
-    /// </summary>
+    /// <summary> Time of the last <see cref="InterpretGesture"/> sample; used for <c>MaxGapMs</c> between callbacks. </summary>
     long lastGestureSensorMs;
     long lastActionAtMs;
 
-    /// <summary> Resets internal timeout/cooldown clocks to 0 on each sensor event (call from the service every time). </summary>
-    internal void ResetTimeoutClocksForSensorEvent()
-    {
-        lastGestureSensorMs = 0;
-        lastActionAtMs = 0;
-    }
-
     struct GestureSequenceState
     {
         /// <summary> Accumulation for the current step in the active direction only (left: positive delta_x; right: absolute of negative delta_x). </summary>
@@ -59,6 +49,16 @@ static int GestureLeftIncrement(int deltaX, int dSum) =>
     static int GestureRightIncrement(int deltaX, int dSum) =>
         DirectionalGestureIncrement(Math.Max(0, -deltaX), Math.Max(0, -dSum));
 
+    /// <summary> Clears driver/gesture/bookkeeping state after user idle or app switch (high-rate sensor never "gaps" in time). </summary>
+    public void ResetProcessingStateAfterIdle()
+    {
+        lastGestureSumForDriver = null;
+        lastGestureSensorMs = 0;
+        lastActionAtMs = 0;
+        buffer.Clear();
+        gestureSequenceStates.Clear();
+    }
+
     /// <summary>
     /// Gesture mode: accumulates per-frame <c>delta_x</c> and sum deltas per direction (<see cref="DirectionalGestureIncrement"/> dampens release overshoot).
     /// </summary>