From f89af040b92ad52f688ed173d9f9e9fbb6efe7f2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Beatrice=20Dellac=C3=A0?= Date: Thu, 1 Oct 2026 23:32:08 +0200 Subject: [PATCH] track user presence by time instead of poll count --- .../java/wtf/beatrice/autosqueal/Main.java | 7 +- .../listener/CursorMoveListener.java | 55 +++-- .../beatrice/autosqueal/ui/MainWindow.java | 17 +- .../listener/CursorMoveListenerTest.java | 223 ++++++++++++------ 4 files changed, 198 insertions(+), 104 deletions(-) diff --git a/src/main/java/wtf/beatrice/autosqueal/Main.java b/src/main/java/wtf/beatrice/autosqueal/Main.java index cc79d2d..ffe1cf7 100644 --- a/src/main/java/wtf/beatrice/autosqueal/Main.java +++ b/src/main/java/wtf/beatrice/autosqueal/Main.java @@ -4,6 +4,8 @@ import com.github.kwhat.jnativehook.GlobalScreen; import com.github.kwhat.jnativehook.NativeHookException; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; +import wtf.beatrice.autosqueal.config.AutoSquealConfig; +import wtf.beatrice.autosqueal.config.ConfigStore; import wtf.beatrice.autosqueal.listener.KeyPressListener; import wtf.beatrice.autosqueal.ui.MainWindow; @@ -13,7 +15,7 @@ import javax.swing.UnsupportedLookAndFeelException; public class Main { private static final Logger LOGGER = LogManager.getLogger(Main.class); - private static final MainWindow mainWindow = new MainWindow(); + private static MainWindow mainWindow; /** Whether the hook and its listener are registered, so retries don't add duplicates. */ private static boolean hookRegistered = false; @@ -21,6 +23,9 @@ public class Main { public static void main(String[] args) { LOGGER.info("Hello world!"); + AutoSquealConfig config = new ConfigStore().load(); + mainWindow = new MainWindow(config); + // ⌘Q on macOS, the IDE stop button and signals all bypass // windowClosing: make cleanup run on every exit path instead Runtime.getRuntime().addShutdownHook(new Thread(mainWindow::cleanup, "autosqueal-shutdown")); diff --git a/src/main/java/wtf/beatrice/autosqueal/listener/CursorMoveListener.java b/src/main/java/wtf/beatrice/autosqueal/listener/CursorMoveListener.java index 49dfed5..39c4ee9 100644 --- a/src/main/java/wtf/beatrice/autosqueal/listener/CursorMoveListener.java +++ b/src/main/java/wtf/beatrice/autosqueal/listener/CursorMoveListener.java @@ -2,41 +2,50 @@ package wtf.beatrice.autosqueal.listener; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; +import wtf.beatrice.autosqueal.config.AutoSquealConfig; import wtf.beatrice.autosqueal.controls.RobotMouseTracker; import java.awt.*; +import java.util.function.LongSupplier; import java.util.function.Supplier; /** - * Watches the cursor position and tracks whether the user is away: if the cursor - * stays still for long enough — ignoring the movements the app performs on its - * own — the user is considered away. Keyboard activity counts as presence, - * too: a user who is typing is using the machine, even if the mouse never moves. + * Watches the cursor position and tracks whether the user is away: if the + * user has not touched mouse or keyboard for long enough — ignoring the + * movements the app performs on its own — the user is considered away. + * Keyboard activity counts as presence, too: a user who is typing is using + * the machine, even if the mouse never moves. + * + * The away state is time-based: how long the user has been idle is compared + * against the threshold at every poll, so a threshold changed on the fly + * applies from the very next poll. */ public class CursorMoveListener implements Runnable { private static final Logger LOGGER = LogManager.getLogger(CursorMoveListener.class); - /** Number of consecutive still polls after which the user is considered away. */ - private static final int LOOPS_BEFORE_AWAY = 30; - private final RobotMouseTracker robotTracker; private final Supplier currentPosition; + private final AutoSquealConfig config; + private final LongSupplier clock; private int lastSeenX; private int lastSeenY; private boolean firstPoll = true; - private int loops = 0; + private long lastUserActivityTime; private volatile boolean userAway = false; private volatile boolean keyboardActivity = false; - public CursorMoveListener(RobotMouseTracker robotTracker) { - this(robotTracker, () -> MouseInfo.getPointerInfo().getLocation()); + public CursorMoveListener(RobotMouseTracker robotTracker, AutoSquealConfig config) { + this(robotTracker, config, () -> MouseInfo.getPointerInfo().getLocation(), System::currentTimeMillis); } - CursorMoveListener(RobotMouseTracker robotTracker, Supplier currentPosition) { + CursorMoveListener(RobotMouseTracker robotTracker, AutoSquealConfig config, + Supplier currentPosition, LongSupplier clock) { this.robotTracker = robotTracker; + this.config = config; this.currentPosition = currentPosition; + this.clock = clock; } /** @@ -56,13 +65,15 @@ public class CursorMoveListener implements Runnable { this.keyboardActivity = false; Point location = currentPosition.get(); + long now = clock.getAsLong(); if (firstPoll) { - // seed the comparison baseline, so that the first poll is not - // mistaken for a movement + // seed the comparison baseline and the activity clock, so that + // the first poll is neither a movement nor a full idle period firstPoll = false; lastSeenX = location.x; lastSeenY = location.y; + lastUserActivityTime = now; return; } @@ -70,18 +81,16 @@ public class CursorMoveListener implements Runnable { boolean userMoved = keyboardActivity || (positionChanged && !isAppMovement(location)); if (userMoved) { - if (userAway) { - LOGGER.info("User is no longer away!"); - } - loops = 0; - } else if (loops < LOOPS_BEFORE_AWAY) { - loops++; - if (loops == LOOPS_BEFORE_AWAY) { - LOGGER.info("User is away!"); - } + lastUserActivityTime = now; } - userAway = loops >= LOOPS_BEFORE_AWAY; + boolean away = now - lastUserActivityTime >= config.getAwayThresholdSeconds() * 1000L; + if (away && !userAway) { + LOGGER.info("User is away!"); + } else if (!away && userAway) { + LOGGER.info("User is no longer away!"); + } + userAway = away; lastSeenX = location.x; lastSeenY = location.y; diff --git a/src/main/java/wtf/beatrice/autosqueal/ui/MainWindow.java b/src/main/java/wtf/beatrice/autosqueal/ui/MainWindow.java index 1724fae..96fa3de 100644 --- a/src/main/java/wtf/beatrice/autosqueal/ui/MainWindow.java +++ b/src/main/java/wtf/beatrice/autosqueal/ui/MainWindow.java @@ -4,6 +4,7 @@ import com.github.kwhat.jnativehook.keyboard.NativeKeyEvent; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import wtf.beatrice.autosqueal.Main; +import wtf.beatrice.autosqueal.config.AutoSquealConfig; import wtf.beatrice.autosqueal.controls.CursorMover; import wtf.beatrice.autosqueal.controls.RobotMouseTracker; import wtf.beatrice.autosqueal.listener.CursorMoveListener; @@ -35,10 +36,22 @@ public class MainWindow private final JFrame frame = new JFrame(); private JButton toggleButton; + private final AutoSquealConfig config; + // the away detection tracks the user, not the automation: it lives from // the window's creation and is polled only while the automation runs - private final RobotMouseTracker robotTracker = new RobotMouseTracker(); - private final CursorMoveListener awayDetector = new CursorMoveListener(robotTracker); + private final RobotMouseTracker robotTracker; + private final CursorMoveListener awayDetector; + + /** + * Creates the window around the given settings: the components read + * them live, so a change applies without a restart. + */ + public MainWindow(AutoSquealConfig config) { + this.config = config; + this.robotTracker = new RobotMouseTracker(); + this.awayDetector = new CursorMoveListener(robotTracker, config); + } private ScheduledExecutorService periodicScheduler; private ExecutorService movementExecutor; diff --git a/src/test/java/wtf/beatrice/autosqueal/listener/CursorMoveListenerTest.java b/src/test/java/wtf/beatrice/autosqueal/listener/CursorMoveListenerTest.java index 3533e8d..52b94fa 100644 --- a/src/test/java/wtf/beatrice/autosqueal/listener/CursorMoveListenerTest.java +++ b/src/test/java/wtf/beatrice/autosqueal/listener/CursorMoveListenerTest.java @@ -1,12 +1,11 @@ package wtf.beatrice.autosqueal.listener; import org.junit.jupiter.api.Test; +import wtf.beatrice.autosqueal.config.AutoSquealConfig; import wtf.beatrice.autosqueal.controls.RobotMouseTracker; import java.awt.*; import java.util.ArrayDeque; -import java.util.ArrayList; -import java.util.List; import java.util.Queue; import static org.junit.jupiter.api.Assertions.assertFalse; @@ -14,73 +13,93 @@ import static org.junit.jupiter.api.Assertions.assertTrue; class CursorMoveListenerTest { - private static final int LOOPS_BEFORE_AWAY = 30; + private static final int AWAY_THRESHOLD_SECONDS = 30; private final RobotMouseTracker robotTracker = new RobotMouseTracker(); + /** The fake clock the listener polls with, in milliseconds. */ + private long now = 1_000_000L; + /** Builds a listener that reads scripted cursor positions, one per poll. */ private CursorMoveListener scriptedListener(Point... positions) { Queue positionQueue = new ArrayDeque<>(java.util.List.of(positions)); - return new CursorMoveListener(robotTracker, positionQueue::remove); + return new CursorMoveListener(robotTracker, new AutoSquealConfig(), + positionQueue::remove, () -> now); } private static Point at(int x, int y) { return new Point(x, y); } + /** Polls, pretending that the given seconds have passed since the previous poll. */ + private void poll(CursorMoveListener listener, int secondsSincePreviousPoll) { + now += secondsSincePreviousPoll * 1000L; + listener.run(); + } + @Test void userIsAwayAfterThirtyStillSeconds() { - Point[] still = new Point[LOOPS_BEFORE_AWAY + 2]; + Point[] still = new Point[AWAY_THRESHOLD_SECONDS + 3]; for (int i = 0; i < still.length; i++) { still[i] = at(100, 100); } CursorMoveListener listener = scriptedListener(still); // the first poll seeds the baseline and does not count - for (int i = 0; i < LOOPS_BEFORE_AWAY; i++) { - listener.run(); + poll(listener, 1); + + // 29 still seconds: the user is still considered present + for (int i = 0; i < AWAY_THRESHOLD_SECONDS - 1; i++) { + poll(listener, 1); assertFalse(listener.isUserAway()); } - listener.run(); + // the 30th still second: the user is away + poll(listener, 1); assertTrue(listener.isUserAway()); } @Test - void firstPollDoesNotCountAsMovement() { - // the very first position read must seed the baseline: starting anywhere - // else would have counted as a user movement and reset the away timer + void firstPollDoesNotCountAsMovementOrIdleTime() { + // the very first position read must seed the baseline and the + // activity clock: starting anywhere else would have counted the + // first poll as a movement, or as a full idle period CursorMoveListener listener = scriptedListener(at(500, 300), at(500, 300)); - listener.run(); - listener.run(); + poll(listener, 5); + poll(listener, 10); assertFalse(listener.isUserAway()); - // still at (500, 300), so the baseline was seeded correctly + // still at (500, 300), and only 10 idle seconds: the seeding poll + // consumed the first 5 seconds } @Test void userMovementResetsTheAwayTimer() { - List positions = new ArrayList<>(); - positions.add(at(100, 100)); // baseline - for (int i = 0; i < 5; i++) positions.add(at(100, 100)); // 5 still polls - positions.add(at(140, 100)); // the user moves the mouse - for (int i = 0; i < LOOPS_BEFORE_AWAY; i++) positions.add(at(140, 100)); // then it stays put + Queue positions = new ArrayDeque<>(); + positions.add(at(100, 100)); // baseline + for (int i = 0; i < 3; i++) positions.add(at(100, 100)); // 3 still seconds + positions.add(at(140, 100)); // the user moves the mouse + for (int i = 0; i < AWAY_THRESHOLD_SECONDS; i++) positions.add(at(140, 100)); // then it stays put + CursorMoveListener listener = new CursorMoveListener(robotTracker, new AutoSquealConfig(), + positions::remove, () -> now); - CursorMoveListener listener = scriptedListener(positions.toArray(Point[]::new)); - - listener.run(); // seed the baseline - for (int i = 0; i < 5; i++) listener.run(); // loops = 5 + poll(listener, 1); // seed the baseline + for (int i = 0; i < 3; i++) { + poll(listener, 1); + } assertFalse(listener.isUserAway()); - listener.run(); // the user moved: the away timer resets + poll(listener, 1); // the user moved: the away timer resets assertFalse(listener.isUserAway()); - // ...and it still takes 30 more still polls to be away again - for (int i = 0; i < LOOPS_BEFORE_AWAY - 1; i++) listener.run(); // loops = 29 - assertFalse(listener.isUserAway()); + // ...and it still takes 30 more still seconds to be away again + for (int i = 0; i < AWAY_THRESHOLD_SECONDS - 1; i++) { + poll(listener, 1); + assertFalse(listener.isUserAway()); + } - listener.run(); // loops = 30 + poll(listener, 1); assertTrue(listener.isUserAway()); } @@ -92,19 +111,21 @@ class CursorMoveListenerTest // always think the user was present // every poll finds the cursor where the app last left it - List positions = new ArrayList<>(); - positions.add(at(100, 100)); // baseline - for (int i = 1; i <= 40; i++) positions.add(at(100 + i, 100)); + Queue appPositions = new ArrayDeque<>(); + appPositions.add(at(100, 100)); + for (int i = 1; i <= 40; i++) { + appPositions.add(at(100 + i, 100)); + } + CursorMoveListener listener = new CursorMoveListener(robotTracker, new AutoSquealConfig(), + appPositions::remove, () -> now); - CursorMoveListener listener = scriptedListener(positions.toArray(Point[]::new)); - - listener.run(); // seed the baseline + poll(listener, 1); // seed the baseline for (int i = 1; i <= 40; i++) { // the app just finished a movement, leaving the cursor exactly // where this poll will find it robotTracker.moveEnded(100 + i, 100); - listener.run(); + poll(listener, 1); } // every position change was the app's own doing: the user is away @@ -115,16 +136,17 @@ class CursorMoveListenerTest void ongoingAppMovementsDoNotKeepTheUserPresent() { // same as above, but the polls happen while the app is mid-movement, // with the cursor transiently at intermediate positions - Point[] positions = new Point[41]; - positions[0] = at(100, 100); - for (int i = 1; i < positions.length; i++) { - positions[i] = at(100 + (i / 2), 100); + Queue positions = new ArrayDeque<>(); + positions.add(at(100, 100)); + for (int i = 1; i <= 40; i++) { + positions.add(at(100 + (i / 2), 100)); } - CursorMoveListener listener = scriptedListener(positions); + CursorMoveListener listener = new CursorMoveListener(robotTracker, new AutoSquealConfig(), + positions::remove, () -> now); robotTracker.moveStarted(); - for (int i = 1; i < positions.length; i++) { - listener.run(); + for (int i = 0; i <= 40; i++) { + poll(listener, 1); } assertTrue(listener.isUserAway()); @@ -132,48 +154,55 @@ class CursorMoveListenerTest @Test void keyboardActivityResetsTheAwayTimer() { - List positions = new ArrayList<>(); - positions.add(at(100, 100)); // baseline - for (int i = 0; i < 29; i++) positions.add(at(100, 100)); // 29 still polls - positions.add(at(100, 100)); // the user presses a key - for (int i = 0; i < LOOPS_BEFORE_AWAY; i++) positions.add(at(100, 100)); // then the mouse stays put + Queue positions = new ArrayDeque<>(); + positions.add(at(100, 100)); // baseline + for (int i = 0; i < 60; i++) { + positions.add(at(100, 100)); // the mouse never moves + } + CursorMoveListener listener = new CursorMoveListener(robotTracker, new AutoSquealConfig(), + positions::remove, () -> now); - CursorMoveListener listener = scriptedListener(positions.toArray(Point[]::new)); - - listener.run(); // seed the baseline - for (int i = 0; i < 29; i++) listener.run(); // loops = 29 + poll(listener, 1); // seed the baseline + for (int i = 0; i < AWAY_THRESHOLD_SECONDS - 1; i++) { + poll(listener, 1); + } assertFalse(listener.isUserAway()); // the user is typing without moving the mouse: the timer resets listener.reportKeyboardActivity(); - listener.run(); + poll(listener, 1); assertFalse(listener.isUserAway()); - // ...and it still takes 30 still polls to be away again - for (int i = 0; i < LOOPS_BEFORE_AWAY - 1; i++) listener.run(); // loops = 29 - assertFalse(listener.isUserAway()); + // ...and it still takes 30 still seconds to be away again + for (int i = 0; i < AWAY_THRESHOLD_SECONDS - 1; i++) { + poll(listener, 1); + assertFalse(listener.isUserAway()); + } - listener.run(); // loops = 30 + poll(listener, 1); assertTrue(listener.isUserAway()); } @Test void keyboardActivityBringsTheUserBackWhileAway() { - Point[] positions = new Point[LOOPS_BEFORE_AWAY + 3]; - for (int i = 0; i < positions.length; i++) { - positions[i] = at(100, 100); + Queue positions = new ArrayDeque<>(); + positions.add(at(100, 100)); + for (int i = 0; i < AWAY_THRESHOLD_SECONDS + 3; i++) { + positions.add(at(100, 100)); } - CursorMoveListener listener = scriptedListener(positions); + CursorMoveListener listener = new CursorMoveListener(robotTracker, new AutoSquealConfig(), + positions::remove, () -> now); - for (int i = 0; i <= LOOPS_BEFORE_AWAY; i++) { // baseline + 30 still polls - listener.run(); + poll(listener, 1); // seed the baseline + for (int i = 0; i < AWAY_THRESHOLD_SECONDS; i++) { + poll(listener, 1); } assertTrue(listener.isUserAway()); // the user comes back at the keyboard: the away state must end, // even though the mouse never moved listener.reportKeyboardActivity(); - listener.run(); + poll(listener, 1); assertFalse(listener.isUserAway()); } @@ -181,34 +210,72 @@ class CursorMoveListenerTest void userComingBackIsDetectedWhileTheAppIsWiggling() { // the app keeps wiggling while the user is away; when the user comes // back and moves the mouse, the away state must end - - // polls: baseline, 30 still polls, two app wiggles, then the user's move - Point[] positions = new Point[LOOPS_BEFORE_AWAY + 4]; - for (int i = 0; i <= LOOPS_BEFORE_AWAY; i++) { - positions[i] = at(100, 100); + Queue positions = new ArrayDeque<>(); + positions.add(at(100, 100)); + for (int i = 0; i < AWAY_THRESHOLD_SECONDS; i++) { + positions.add(at(100, 100)); } - positions[LOOPS_BEFORE_AWAY + 1] = at(150, 100); - positions[LOOPS_BEFORE_AWAY + 2] = at(200, 100); - positions[LOOPS_BEFORE_AWAY + 3] = at(333, 100); - CursorMoveListener listener = scriptedListener(positions); + positions.add(at(150, 100)); // app wiggle + positions.add(at(200, 100)); // app wiggle + positions.add(at(333, 100)); // the user's move + CursorMoveListener listener = new CursorMoveListener(robotTracker, new AutoSquealConfig(), + positions::remove, () -> now); - // baseline + 30 still polls: the user goes away - for (int i = 0; i <= LOOPS_BEFORE_AWAY; i++) { - listener.run(); + poll(listener, 1); // seed the baseline + for (int i = 0; i < AWAY_THRESHOLD_SECONDS; i++) { + poll(listener, 1); } assertTrue(listener.isUserAway()); // the app wiggles: each movement is discounted, the user stays "away" robotTracker.moveEnded(150, 100); - listener.run(); + poll(listener, 1); assertTrue(listener.isUserAway()); robotTracker.moveEnded(200, 100); - listener.run(); + poll(listener, 1); assertTrue(listener.isUserAway()); // the user comes back and grabs the mouse - listener.run(); + poll(listener, 1); + assertFalse(listener.isUserAway()); + } + + @Test + void thresholdChangesApplyFromTheNextPoll() { + // the threshold is read live: a change applies without a restart + AutoSquealConfig config = new AutoSquealConfig(); + config.setAwayThresholdSeconds(10); + Queue positions = new ArrayDeque<>(); + for (int i = 0; i < 20; i++) { + positions.add(at(100, 100)); + } + CursorMoveListener listener = new CursorMoveListener(robotTracker, config, + positions::remove, () -> now); + + poll(listener, 1); // seed the baseline + + // 9 still seconds: not away with a 10 seconds threshold + for (int i = 0; i < 9; i++) { + poll(listener, 1); + assertFalse(listener.isUserAway()); + } + + // 10th second: away + poll(listener, 1); + assertTrue(listener.isUserAway()); + + // the user tightens the threshold to 5: the next poll re-evaluates + // and the user is still away (already idle for more than 5 seconds) + config.setAwayThresholdSeconds(5); + poll(listener, 1); + assertTrue(listener.isUserAway()); + + // the user loosens the threshold to 600: the same idle time is no + // longer enough, so the user is present again — and back to away + // only after 600 seconds of stillness + config.setAwayThresholdSeconds(600); + poll(listener, 1); assertFalse(listener.isUserAway()); } } \ No newline at end of file