decouple the key listener from the main window

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,8 @@ 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;
+    private static AutoSquealConfig config;
 
     /** Whether the hook and its listener are registered, so retries don't add duplicates. */
     private static boolean hookRegistered = false;
@@ -21,6 +24,9 @@ public class Main {
     public static void main(String[] args) {
         LOGGER.info("Hello world!");
 
+        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"));
@@ -53,7 +59,8 @@ public class Main {
         LOGGER.info("Registering jnativehook library...");
         try {
             GlobalScreen.registerNativeHook();
-            GlobalScreen.addNativeKeyListener(new KeyPressListener());
+            GlobalScreen.addNativeKeyListener(
+                    new KeyPressListener(mainWindow::toggleRunning, mainWindow::notifyKeyboardActivity, config));
             hookRegistered = true;
             LOGGER.info("Successfully registered jnativehook library!");
             return true;
@@ -84,8 +91,4 @@ public class Main {
         }
     }
 
-    public static MainWindow getMainWindow() {
-        return mainWindow;
-    }
-
 }

src/main/java/wtf/beatrice/autosqueal/config/AutoSquealConfig.java

@@ -0,0 +1,113 @@
+package wtf.beatrice.autosqueal.config;
+
+/**
+ * The user-editable settings of the app.
+ *
+ * A single instance is shared between the components, which read the
+ * current values while running: a change is picked up by the next poll or
+ * movement without a restart. Values are clamped to sane ranges when set,
+ * so that no matter what ends up in the settings file, the automation
+ * always gets workable numbers.
+ */
+public class AutoSquealConfig {
+
+    public static final int AWAY_THRESHOLD_MIN_SECONDS = 5;
+    public static final int AWAY_THRESHOLD_MAX_SECONDS = 600;
+
+    public static final int MOVE_INTERVAL_MIN_SECONDS = 1;
+    public static final int MOVE_INTERVAL_MAX_SECONDS = 3600;
+
+    public static final int STEP_DELAY_MIN_MILLISECONDS = 1;
+    public static final int STEP_DELAY_MAX_MILLISECONDS = 50;
+
+    public static final int CLICK_EVERY_MIN_MOVES = 1;
+    public static final int CLICK_EVERY_MAX_MOVES = 100;
+
+    private volatile int awayThresholdSeconds = 30;
+    private volatile int moveIntervalSeconds = 10;
+    private volatile int stepDelayMilliseconds = 2;
+    private volatile boolean clickEnabled = true;
+    private volatile int clickEveryNMoves = 5;
+    private volatile ScreenArea movementScreen = ScreenArea.PRIMARY;
+    private volatile boolean startAutomatically = true;
+    private volatile boolean hotkeyEnabled = true;
+
+    /** Seconds without user activity after which the user is considered away. */
+    public int getAwayThresholdSeconds() {
+        return awayThresholdSeconds;
+    }
+
+    public void setAwayThresholdSeconds(int seconds) {
+        awayThresholdSeconds = clamp(seconds, AWAY_THRESHOLD_MIN_SECONDS, AWAY_THRESHOLD_MAX_SECONDS);
+    }
+
+    /** Seconds between two movements. */
+    public int getMoveIntervalSeconds() {
+        return moveIntervalSeconds;
+    }
+
+    public void setMoveIntervalSeconds(int seconds) {
+        moveIntervalSeconds = clamp(seconds, MOVE_INTERVAL_MIN_SECONDS, MOVE_INTERVAL_MAX_SECONDS);
+    }
+
+    /** Pause between two cursor steps, in milliseconds: the lower, the faster. */
+    public int getStepDelayMilliseconds() {
+        return stepDelayMilliseconds;
+    }
+
+    public void setStepDelayMilliseconds(int milliseconds) {
+        stepDelayMilliseconds = clamp(milliseconds, STEP_DELAY_MIN_MILLISECONDS, STEP_DELAY_MAX_MILLISECONDS);
+    }
+
+    /** Whether the corner double click is performed at all. */
+    public boolean isClickEnabled() {
+        return clickEnabled;
+    }
+
+    public void setClickEnabled(boolean enabled) {
+        clickEnabled = enabled;
+    }
+
+    /**
+     * One movement every N is a corner double click, so that the
+     * notification area gets exercised too.
+     */
+    public int getClickEveryNMoves() {
+        return clickEveryNMoves;
+    }
+
+    public void setClickEveryNMoves(int moves) {
+        clickEveryNMoves = clamp(moves, CLICK_EVERY_MIN_MOVES, CLICK_EVERY_MAX_MOVES);
+    }
+
+    /** Which screens the cursor may travel to. */
+    public ScreenArea getMovementScreen() {
+        return movementScreen;
+    }
+
+    public void setMovementScreen(ScreenArea screenArea) {
+        movementScreen = screenArea == null ? ScreenArea.PRIMARY : screenArea;
+    }
+
+    /** Whether the automation starts as soon as the window opens. */
+    public boolean isStartAutomatically() {
+        return startAutomatically;
+    }
+
+    public void setStartAutomatically(boolean automatically) {
+        startAutomatically = automatically;
+    }
+
+    /** Whether the global toggle hotkey is active. */
+    public boolean isHotkeyEnabled() {
+        return hotkeyEnabled;
+    }
+
+    public void setHotkeyEnabled(boolean enabled) {
+        hotkeyEnabled = enabled;
+    }
+
+    private static int clamp(int value, int min, int max) {
+        return Math.max(min, Math.min(max, value));
+    }
+}

src/main/java/wtf/beatrice/autosqueal/config/ConfigStore.java

@@ -0,0 +1,163 @@
+package wtf.beatrice.autosqueal.config;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import wtf.beatrice.autosqueal.util.SystemUtil;
+
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.AtomicMoveNotSupportedException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.util.Map;
+import java.util.Properties;
+import java.util.TreeMap;
+import java.util.function.Consumer;
+import java.util.function.IntConsumer;
+
+/**
+ * Loads and saves the settings, as a properties file in the user's config
+ * directory.
+ *
+ * The whole store is defensive: a missing file, garbage values or an
+ * unwritable directory degrade to the defaults instead of breaking the
+ * app, because the automation must be able to start no matter what.
+ * Writing goes through a temp file and an atomic move, so that a crash
+ * mid-save can never leave a truncated settings file behind.
+ */
+public class ConfigStore {
+
+    private static final Logger LOGGER = LogManager.getLogger(ConfigStore.class);
+
+    static final String KEY_AWAY_THRESHOLD_SECONDS = "away.threshold.seconds";
+    static final String KEY_MOVE_INTERVAL_SECONDS = "move.interval.seconds";
+    static final String KEY_STEP_DELAY_MILLISECONDS = "move.step.delay.milliseconds";
+    static final String KEY_CLICK_ENABLED = "click.enabled";
+    static final String KEY_CLICK_EVERY_N_MOVES = "click.every.n.moves";
+    static final String KEY_MOVEMENT_SCREEN = "move.screen";
+    static final String KEY_START_AUTOMATICALLY = "automation.start.automatically";
+    static final String KEY_HOTKEY_ENABLED = "hotkey.enabled";
+
+    private final Path file;
+
+    /** A store reading the standard settings file of the host platform. */
+    public ConfigStore() {
+        this(SystemUtil.getAppConfigDir().resolve("autosqueal.properties"));
+    }
+
+    /** A store reading the given file; used by the tests. */
+    public ConfigStore(Path file) {
+        this.file = file;
+    }
+
+    /** Reads the settings, falling back to the defaults for anything missing or broken. */
+    public AutoSquealConfig load() {
+        AutoSquealConfig config = new AutoSquealConfig();
+
+        if (!Files.isRegularFile(file)) {
+            LOGGER.info("No settings file yet, using the defaults");
+            return config;
+        }
+
+        Properties properties = new Properties();
+        try (InputStream input = Files.newInputStream(file)) {
+            properties.load(input);
+        } catch (IOException ex) {
+            LOGGER.warn("Could not read the settings file, using the defaults", ex);
+            return config;
+        }
+
+        readInt(properties, KEY_AWAY_THRESHOLD_SECONDS, config::setAwayThresholdSeconds);
+        readInt(properties, KEY_MOVE_INTERVAL_SECONDS, config::setMoveIntervalSeconds);
+        readInt(properties, KEY_STEP_DELAY_MILLISECONDS, config::setStepDelayMilliseconds);
+        readInt(properties, KEY_CLICK_EVERY_N_MOVES, config::setClickEveryNMoves);
+        readBoolean(properties, KEY_CLICK_ENABLED, config::setClickEnabled);
+        readBoolean(properties, KEY_START_AUTOMATICALLY, config::setStartAutomatically);
+        readBoolean(properties, KEY_HOTKEY_ENABLED, config::setHotkeyEnabled);
+        readEnum(properties, KEY_MOVEMENT_SCREEN, ScreenArea.class, config::setMovementScreen);
+
+        return config;
+    }
+
+    /** Writes the settings atomically, so that readers never see a half-written file. */
+    public void save(AutoSquealConfig config) {
+        Map<String, String> entries = new TreeMap<>();
+        entries.put(KEY_AWAY_THRESHOLD_SECONDS, String.valueOf(config.getAwayThresholdSeconds()));
+        entries.put(KEY_MOVE_INTERVAL_SECONDS, String.valueOf(config.getMoveIntervalSeconds()));
+        entries.put(KEY_STEP_DELAY_MILLISECONDS, String.valueOf(config.getStepDelayMilliseconds()));
+        entries.put(KEY_CLICK_ENABLED, String.valueOf(config.isClickEnabled()));
+        entries.put(KEY_CLICK_EVERY_N_MOVES, String.valueOf(config.getClickEveryNMoves()));
+        entries.put(KEY_MOVEMENT_SCREEN, String.valueOf(config.getMovementScreen()));
+        entries.put(KEY_START_AUTOMATICALLY, String.valueOf(config.isStartAutomatically()));
+        entries.put(KEY_HOTKEY_ENABLED, String.valueOf(config.isHotkeyEnabled()));
+
+        try {
+            Path directory = file.toAbsolutePath().getParent();
+            Files.createDirectories(directory);
+            Path tempFile = Files.createTempFile(directory, "autosqueal-", ".tmp");
+
+            try (BufferedWriter writer = Files.newBufferedWriter(tempFile)) {
+                writer.write("# autosqueal settings, rewritten by the app when the settings change");
+                writer.newLine();
+                for (Map.Entry<String, String> entry : entries.entrySet()) {
+                    writer.write(entry.getKey());
+                    writer.write("=");
+                    writer.write(entry.getValue());
+                    writer.newLine();
+                }
+            }
+
+            try {
+                Files.move(tempFile, file, StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING);
+            } catch (AtomicMoveNotSupportedException ex) {
+                Files.move(tempFile, file, StandardCopyOption.REPLACE_EXISTING);
+            }
+        } catch (IOException ex) {
+            LOGGER.error("Could not save the settings", ex);
+        }
+    }
+
+    private static void readInt(Properties properties, String key, IntConsumer setter) {
+        String value = properties.getProperty(key);
+        if (value == null) {
+            return;
+        }
+
+        try {
+            setter.accept(Integer.parseInt(value.trim()));
+        } catch (NumberFormatException ex) {
+            LOGGER.warn("Ignoring invalid value for {}: {}", key, value);
+        }
+    }
+
+    private static void readBoolean(Properties properties, String key, Consumer<Boolean> setter) {
+        String value = properties.getProperty(key);
+        if (value == null) {
+            return;
+        }
+
+        String normalized = value.trim();
+        if ("true".equalsIgnoreCase(normalized)) {
+            setter.accept(true);
+        } else if ("false".equalsIgnoreCase(normalized)) {
+            setter.accept(false);
+        } else {
+            LOGGER.warn("Ignoring invalid value for {}: {}", key, value);
+        }
+    }
+
+    private static <E extends Enum<E>> void readEnum(Properties properties, String key, Class<E> type, Consumer<E> setter) {
+        String value = properties.getProperty(key);
+        if (value == null) {
+            return;
+        }
+
+        try {
+            setter.accept(Enum.valueOf(type, value.trim()));
+        } catch (IllegalArgumentException ex) {
+            LOGGER.warn("Ignoring unknown value for {}: {}", key, value);
+        }
+    }
+}

src/main/java/wtf/beatrice/autosqueal/config/ScreenArea.java

@@ -0,0 +1,13 @@
+package wtf.beatrice.autosqueal.config;
+
+/**
+ * Which screens the automation is allowed to move the cursor to.
+ */
+public enum ScreenArea {
+
+    /** The main screen only, as the app has always used. */
+    PRIMARY,
+
+    /** Every connected screen, treated as one big virtual screen. */
+    ALL
+}

src/main/java/wtf/beatrice/autosqueal/controls/CursorMover.java

@@ -2,7 +2,7 @@ package wtf.beatrice.autosqueal.controls;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import wtf.beatrice.autosqueal.util.RunnerUtil;
+import wtf.beatrice.autosqueal.config.AutoSquealConfig;
 
 import java.awt.*;
 import java.security.SecureRandom;
@@ -10,10 +10,11 @@ import java.util.Random;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.RejectedExecutionException;
 import java.util.function.BooleanSupplier;
+import java.util.function.Supplier;
 
 /**
  * Periodically starts a new movement of the mouse cursor to a random position,
- * or to the top-right corner of the screen for a double click.
+ * or to the top-right corner of the main screen for a double click.
  *
  * The movements only happen when the user is away: while the user is actively
  * using the machine, they are skipped, so the app never fights for the mouse.
@@ -21,26 +22,50 @@ import java.util.function.BooleanSupplier;
  * the user is still away at every step, and gives the mouse back when they
  * are not.
  *
- * The movement itself is executed by a {@link SingleStepMovementTask}, which
- * runs on its own virtual thread until it reaches its destination.
+ * Everything that varies — how often to move, how fast, whether and how
+ * often to click, which screens to travel — comes from the settings, which
+ * are read live at every movement. The movement itself is executed by a
+ * {@link SingleStepMovementTask}, which runs on its own virtual thread
+ * until it reaches its destination.
  */
-public class CursorMover implements Runnable
-{
+public class CursorMover implements Runnable {
+
     private static final Logger LOGGER = LogManager.getLogger(CursorMover.class);
 
-    private static final int LOOPS_BEFORE_CLICK = 5;
+    /** Distance from the screen edge, so the corner click lands inside the screen. */
+    private static final int CORNER_OFFSET_PIXELS = 5;
 
-    private final Random random = new SecureRandom();
+    private final Random random;
     private final ExecutorService movementExecutor;
     private final RobotMouseTracker robotTracker;
     private final BooleanSupplier isUserAway;
+    private final AutoSquealConfig config;
+    private final Supplier<Rectangle> movementBounds;
+    private final Supplier<Rectangle> primaryScreenBounds;
+    private final Supplier<Point> currentPosition;
 
+    /** Movements started since the last corner click. */
     private int iteration = 0;
 
-    public CursorMover(ExecutorService movementExecutor, RobotMouseTracker robotTracker, BooleanSupplier isUserAway) {
+    public CursorMover(ExecutorService movementExecutor, RobotMouseTracker robotTracker,
+                       BooleanSupplier isUserAway, AutoSquealConfig config,
+                       Supplier<Rectangle> movementBounds, Supplier<Rectangle> primaryScreenBounds) {
+        this(movementExecutor, robotTracker, isUserAway, config, movementBounds, primaryScreenBounds,
+                new SecureRandom(), () -> MouseInfo.getPointerInfo().getLocation());
+    }
+
+    CursorMover(ExecutorService movementExecutor, RobotMouseTracker robotTracker,
+                BooleanSupplier isUserAway, AutoSquealConfig config,
+                Supplier<Rectangle> movementBounds, Supplier<Rectangle> primaryScreenBounds,
+                Random random, Supplier<Point> currentPosition) {
         this.movementExecutor = movementExecutor;
         this.robotTracker = robotTracker;
         this.isUserAway = isUserAway;
+        this.config = config;
+        this.movementBounds = movementBounds;
+        this.primaryScreenBounds = primaryScreenBounds;
+        this.random = random;
+        this.currentPosition = currentPosition;
     }
 
     @Override
@@ -51,34 +76,38 @@ public class CursorMover implements Runnable
             return;
         }
 
-        Point location = MouseInfo.getPointerInfo().getLocation();
+        Point location = currentPosition.get();
         LOGGER.info("Starting coordinates: {}, {}", location.x, location.y);
 
         int destX;
         int destY;
         boolean click;
 
-        if (iteration == LOOPS_BEFORE_CLICK) {
-            destX = RunnerUtil.SCREEN_WIDTH - 5;
-            destY = 5;
+        // one movement every N is a corner double click, so that the
+        // notification area gets exercised too. the corner is always the
+        // main screen's top-right one, whatever screens the cursor may
+        // otherwise travel to.
+        if (config.isClickEnabled() && iteration == config.getClickEveryNMoves() - 1) {
+            Rectangle primary = primaryScreenBounds.get();
+            destX = primary.x + primary.width - CORNER_OFFSET_PIXELS;
+            destY = primary.y + CORNER_OFFSET_PIXELS;
             click = true;
-
             iteration = 0;
         } else {
-            destX = random.nextInt(RunnerUtil.SCREEN_WIDTH);
-            destY = random.nextInt(RunnerUtil.SCREEN_HEIGHT);
+            Rectangle bounds = movementBounds.get();
+            destX = bounds.x + random.nextInt(Math.max(1, bounds.width));
+            destY = bounds.y + random.nextInt(Math.max(1, bounds.height));
             click = false;
-
             iteration++;
         }
 
         LOGGER.info("Destination coordinates: {}, {}", destX, destY);
 
         try {
-            SingleStepMovementTask movement = new SingleStepMovementTask(robotTracker, destX, destY, click, isUserAway);
+            SingleStepMovementTask movement = new SingleStepMovementTask(
+                    robotTracker, destX, destY, click, isUserAway,
+                    config.getStepDelayMilliseconds(), location);
             movementExecutor.execute(movement);
-        } catch (AWTException ex) {
-            LOGGER.error("Could not start movement task", ex);
         } catch (RejectedExecutionException ex) {
             LOGGER.debug("Movement not started: automation is shutting down");
         }

src/main/java/wtf/beatrice/autosqueal/controls/SingleStepMovementTask.java

@@ -25,33 +25,31 @@ public class SingleStepMovementTask implements Runnable {
 
     private static final Logger LOGGER = LogManager.getLogger(SingleStepMovementTask.class);
 
-    /** Delay between two consecutive cursor steps, in milliseconds. */
-    private static final long STEP_DELAY_MILLISECONDS = 2L;
-
     private final RobotMouseTracker robotTracker;
-    private final Robot robot;
     private final int destX;
     private final int destY;
     private final boolean click;
     private final BooleanSupplier userIsAway;
+    private final long stepDelayMilliseconds;
 
     private float currentX;
     private float currentY;
     private float stepX;
     private float stepY;
 
-    public SingleStepMovementTask(RobotMouseTracker robotTracker, int destinationX, int destinationY, boolean click,
-                                  BooleanSupplier userIsAway) throws AWTException {
+    public SingleStepMovementTask(RobotMouseTracker robotTracker, int destinationX, int destinationY,
+                                  boolean click, BooleanSupplier userIsAway, long stepDelayMilliseconds,
+                                  Point start) {
 
         this.robotTracker = robotTracker;
         this.destX = destinationX;
         this.destY = destinationY;
         this.click = click;
         this.userIsAway = userIsAway;
+        this.stepDelayMilliseconds = stepDelayMilliseconds;
 
-        Point location = MouseInfo.getPointerInfo().getLocation();
-        this.currentX = location.x;
-        this.currentY = location.y;
+        this.currentX = start.x;
+        this.currentY = start.y;
 
         int lengthX = Math.round(Math.abs(currentX - destX));
         int lengthY = Math.round(Math.abs(currentY - destY));
@@ -61,13 +59,22 @@ public class SingleStepMovementTask implements Runnable {
 
         LOGGER.info("Dest: [{}, {}], Curr: [{}, {}]", destX, destY, currentX, currentY);
         LOGGER.info("Step: [{}, {}]", stepX, stepY);
-
-        this.robot = new Robot();
     }
 
     @Override
     public void run() {
 
+        // the robot is created here, not in the constructor: building a
+        // movement must never touch the system on its own, or there would be
+        // no way to queue one for testing or display without moving a mouse
+        Robot robot;
+        try {
+            robot = new Robot();
+        } catch (AWTException ex) {
+            LOGGER.error("Could not create a robot, skipping this movement", ex);
+            return;
+        }
+
         // any position change from here on is the app's doing
         robotTracker.moveStarted();
 
@@ -91,10 +98,10 @@ public class SingleStepMovementTask implements Runnable {
 
                 robot.mouseMove(Math.round(currentX), Math.round(currentY));
 
-                Thread.sleep(STEP_DELAY_MILLISECONDS);
+                Thread.sleep(stepDelayMilliseconds);
             }
 
-            onDestinationReached();
+            onDestinationReached(robot);
         } catch (InterruptedException ex) {
             // the movement was interrupted: the automation was stopped, so
             // just end the movement here
@@ -111,13 +118,13 @@ public class SingleStepMovementTask implements Runnable {
         return Math.round(currentX) == destX && Math.round(currentY) == destY;
     }
 
-    private void onDestinationReached() throws InterruptedException {
+    private void onDestinationReached(Robot robot) throws InterruptedException {
         LOGGER.info("Reached destination [{}, {}], stopping mover", destX, destY);
 
         robotTracker.moveEnded(destX, destY);
 
         if (click) {
-            performClickSequence();
+            performClickSequence(robot);
         }
     }
 
@@ -125,7 +132,7 @@ public class SingleStepMovementTask implements Runnable {
      * Performs a double click with the same pacing the app has always used:
      * press at +500ms, release at +700ms, press at +1200ms, release at +1400ms.
      */
-    private void performClickSequence() throws InterruptedException {
+    private void performClickSequence(Robot robot) throws InterruptedException {
         Thread.sleep(500L);
         robot.mousePress(InputEvent.BUTTON1_DOWN_MASK);
         Thread.sleep(200L);
@@ -183,4 +190,18 @@ public class SingleStepMovementTask implements Runnable {
         }
         return current;
     }
+
+    // package-private: read by the tests, and soon by the live status view
+
+    int getDestX() {
+        return destX;
+    }
+
+    int getDestY() {
+        return destY;
+    }
+
+    boolean isClick() {
+        return click;
+    }
 }

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<Point> 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<Point> currentPosition) {
+    CursorMoveListener(RobotMouseTracker robotTracker, AutoSquealConfig config,
+                       Supplier<Point> 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;

src/main/java/wtf/beatrice/autosqueal/listener/KeyPressListener.java

@@ -4,16 +4,34 @@ import com.github.kwhat.jnativehook.keyboard.NativeKeyEvent;
 import com.github.kwhat.jnativehook.keyboard.NativeKeyListener;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import wtf.beatrice.autosqueal.Main;
+import wtf.beatrice.autosqueal.config.AutoSquealConfig;
 
 import java.util.ArrayList;
 import java.util.List;
 
-public class KeyPressListener implements NativeKeyListener
-{
+/**
+ * Listens for the global toggle hotkey, and reports every key press to the
+ * away detection: a user who is typing is present, hotkey or not.
+ *
+ * The listener is fully decoupled: it receives the actions to run instead
+ * of reaching into the main window, so it can be wired — and tested — on
+ * its own.
+ */
+public class KeyPressListener implements NativeKeyListener {
+
     private static final Logger LOGGER = LogManager.getLogger(KeyPressListener.class);
+
+    private final Runnable toggleAction;
+    private final Runnable keyboardActivityReporter;
+    private final AutoSquealConfig config;
     private final List<Integer> pressedKeys = new ArrayList<>();
 
+    public KeyPressListener(Runnable toggleAction, Runnable keyboardActivityReporter, AutoSquealConfig config) {
+        this.toggleAction = toggleAction;
+        this.keyboardActivityReporter = keyboardActivityReporter;
+        this.config = config;
+    }
+
     @Override
     public void nativeKeyPressed(NativeKeyEvent e) {
         // the OS fires repeated "press" events while a key is being held down; ignore them,
@@ -27,18 +45,22 @@ public class KeyPressListener implements NativeKeyListener
 
         // any key the user presses means they are present: let the away
         // detection know, so the app doesn't grab the mouse while they type
-        Main.getMainWindow().notifyKeyboardActivity();
+        keyboardActivityReporter.run();
+
+        if (!config.isHotkeyEnabled()) {
+            return;
+        }
 
         // toggle only when the second key of the combo is pressed down: not only does this
         // fire exactly once per combo, but it also avoids toggling when any other key is
         // pressed or released while ctrl+alt happen to be held down
         if ((e.getKeyCode() == NativeKeyEvent.VC_CONTROL && pressedKeys.contains(NativeKeyEvent.VC_ALT))
                 || (e.getKeyCode() == NativeKeyEvent.VC_ALT && pressedKeys.contains(NativeKeyEvent.VC_CONTROL))) {
-            LOGGER.warn("Received shutdown keystroke: [{}][{}]",
+            LOGGER.info("Received toggle hotkey: [{}][{}]",
                     NativeKeyEvent.getKeyText(NativeKeyEvent.VC_CONTROL),
                     NativeKeyEvent.getKeyText(NativeKeyEvent.VC_ALT));
 
-            Main.getMainWindow().toggleRunning();
+            toggleAction.run();
         }
     }
 

src/main/java/wtf/beatrice/autosqueal/ui/MainWindow.java

@@ -4,6 +4,8 @@ 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.config.ScreenArea;
 import wtf.beatrice.autosqueal.controls.CursorMover;
 import wtf.beatrice.autosqueal.controls.RobotMouseTracker;
 import wtf.beatrice.autosqueal.listener.CursorMoveListener;
@@ -21,6 +23,7 @@ import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
+import java.util.function.Supplier;
 
 public class MainWindow
 {
@@ -35,10 +38,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;
@@ -103,7 +118,9 @@ public class MainWindow
             addTrayIcon();
         }
 
-        startAutomation();
+        if (config.isStartAutomatically()) {
+            startAutomation();
+        }
         updateToggleLabel();
     }
 
@@ -308,10 +325,18 @@ public class MainWindow
         // the automation only moves the mouse when the user is away.
         periodicScheduler.scheduleWithFixedDelay(awayDetector, 0L, AWAY_POLL_INTERVAL_SECONDS, TimeUnit.SECONDS);
 
-        cursorMover = new CursorMover(movementExecutor, robotTracker, awayDetector::isUserAway);
+        // the movement bounds are read again at every movement, so a change
+        // of setting applies from the next movement without a restart. the
+        // corner click always aims at the main screen, whatever screens the
+        // cursor may otherwise travel to.
+        Supplier<Rectangle> movementBounds = () -> RunnerUtil.screenBounds(config.getMovementScreen());
+        Supplier<Rectangle> primaryScreenBounds = () -> RunnerUtil.screenBounds(ScreenArea.PRIMARY);
+
+        cursorMover = new CursorMover(movementExecutor, robotTracker, awayDetector::isUserAway,
+                config, movementBounds, primaryScreenBounds);
         periodicScheduler.scheduleWithFixedDelay(cursorMover,
                 AUTOMATION_START_DELAY_SECONDS,
-                RunnerUtil.SECONDS_BETWEEN_MOVES,
+                config.getMoveIntervalSeconds(),
                 TimeUnit.SECONDS);
     }
 

src/main/java/wtf/beatrice/autosqueal/util/RunnerUtil.java

@@ -1,5 +1,7 @@
 package wtf.beatrice.autosqueal.util;
 
+import wtf.beatrice.autosqueal.config.ScreenArea;
+
 import java.awt.*;
 
 public class RunnerUtil {
@@ -8,9 +10,35 @@ public class RunnerUtil {
         throw new AssertionError("The RunnerUtil class is not intended to be instantiated.");
     }
 
-    public static final int SECONDS_BETWEEN_MOVES = 10;
-
     public static final int SCREEN_HEIGHT = Toolkit.getDefaultToolkit().getScreenSize().height;
     public static final int SCREEN_WIDTH = Toolkit.getDefaultToolkit().getScreenSize().width;
 
+    /**
+     * The bounds of the screens the cursor may travel to, according to the
+     * given setting. Fetched on every call, so that a change of setting, or
+     * a screen plugged in while the app runs, is picked up by the next
+     * movement.
+     *
+     * The result is never empty: when no screen is found, the main screen
+     * is returned, because it always exists.
+     */
+    public static Rectangle screenBounds(ScreenArea area) {
+        Rectangle bounds = new Rectangle();
+
+        if (area == ScreenArea.ALL) {
+            for (GraphicsDevice device : GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices()) {
+                bounds.add(device.getDefaultConfiguration().getBounds());
+            }
+        }
+
+        if (bounds.isEmpty()) {
+            // the main screen was requested, or no other screen was found
+            bounds = GraphicsEnvironment.getLocalGraphicsEnvironment()
+                    .getDefaultScreenDevice().getDefaultConfiguration().getBounds();
+        }
+
+        // defensive copy: the callers treat the rectangle as theirs
+        return new Rectangle(bounds);
+    }
+
 }

src/main/java/wtf/beatrice/autosqueal/util/SystemUtil.java

@@ -1,5 +1,6 @@
 package wtf.beatrice.autosqueal.util;
 
+import java.nio.file.Path;
 import java.util.Locale;
 
 public class SystemUtil
@@ -9,6 +10,27 @@ public class SystemUtil
         return fromOsName(System.getProperty("os.name"));
     }
 
+    /**
+     * The per-user directory where the app keeps its settings, following
+     * the conventions of the host platform.
+     */
+    public static Path getAppConfigDir() {
+        String home = System.getProperty("user.home", ".");
+        String appData = System.getenv("APPDATA");
+        String xdgConfigHome = System.getenv("XDG_CONFIG_HOME");
+
+        return switch (getHostSystem()) {
+            case MAC_OS -> Path.of(home, "Library", "Application Support", "autosqueal");
+            case WINDOWS -> appData != null && !appData.isBlank()
+                    ? Path.of(appData, "autosqueal")
+                    : Path.of(home, ".autosqueal");
+            case LINUX -> xdgConfigHome != null && !xdgConfigHome.isBlank()
+                    ? Path.of(xdgConfigHome, "autosqueal")
+                    : Path.of(home, ".config", "autosqueal");
+            default -> Path.of(home, ".autosqueal");
+        };
+    }
+
     public static OperatingSystem fromOsName(String osName) {
         String normalizedOsName = osName.toLowerCase(Locale.ENGLISH);
         if (normalizedOsName.contains("win")) {

src/test/java/wtf/beatrice/autosqueal/config/ConfigStoreTest.java

@@ -0,0 +1,125 @@
+package wtf.beatrice.autosqueal.config;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class ConfigStoreTest
+{
+    @TempDir
+    Path tempDir;
+
+    private ConfigStore store;
+
+    @BeforeEach
+    void createStore() {
+        store = new ConfigStore(tempDir.resolve("autosqueal.properties"));
+    }
+
+    @Test
+    void missingFileYieldsTheDefaults() {
+        AutoSquealConfig config = store.load();
+
+        assertEquals(30, config.getAwayThresholdSeconds());
+        assertEquals(10, config.getMoveIntervalSeconds());
+        assertEquals(2, config.getStepDelayMilliseconds());
+        assertTrue(config.isClickEnabled());
+        assertEquals(5, config.getClickEveryNMoves());
+        assertEquals(ScreenArea.PRIMARY, config.getMovementScreen());
+        assertTrue(config.isStartAutomatically());
+        assertTrue(config.isHotkeyEnabled());
+    }
+
+    @Test
+    void savedSettingsLoadBack() {
+        AutoSquealConfig config = new AutoSquealConfig();
+        config.setAwayThresholdSeconds(45);
+        config.setMoveIntervalSeconds(20);
+        config.setStepDelayMilliseconds(4);
+        config.setClickEnabled(false);
+        config.setClickEveryNMoves(7);
+        config.setMovementScreen(ScreenArea.ALL);
+        config.setStartAutomatically(false);
+        config.setHotkeyEnabled(false);
+
+        store.save(config);
+        AutoSquealConfig loaded = store.load();
+
+        assertEquals(45, loaded.getAwayThresholdSeconds());
+        assertEquals(20, loaded.getMoveIntervalSeconds());
+        assertEquals(4, loaded.getStepDelayMilliseconds());
+        assertFalse(loaded.isClickEnabled());
+        assertEquals(7, loaded.getClickEveryNMoves());
+        assertEquals(ScreenArea.ALL, loaded.getMovementScreen());
+        assertFalse(loaded.isStartAutomatically());
+        assertFalse(loaded.isHotkeyEnabled());
+    }
+
+    @Test
+    void outOfRangeValuesAreClamped() throws IOException {
+        writeFile(ConfigStore.KEY_AWAY_THRESHOLD_SECONDS + "=0",
+                ConfigStore.KEY_MOVE_INTERVAL_SECONDS + "=99999999",
+                ConfigStore.KEY_STEP_DELAY_MILLISECONDS + "=-3",
+                ConfigStore.KEY_CLICK_EVERY_N_MOVES + "=1000");
+
+        AutoSquealConfig config = store.load();
+
+        assertEquals(5, config.getAwayThresholdSeconds());
+        assertEquals(3600, config.getMoveIntervalSeconds());
+        assertEquals(1, config.getStepDelayMilliseconds());
+        assertEquals(100, config.getClickEveryNMoves());
+    }
+
+    @Test
+    void invalidValuesKeepTheDefaults() throws IOException {
+        writeFile(ConfigStore.KEY_AWAY_THRESHOLD_SECONDS + "=soon",
+                ConfigStore.KEY_CLICK_ENABLED + "=banana",
+                ConfigStore.KEY_MOVEMENT_SCREEN + "=THE_MOON",
+                ConfigStore.KEY_MOVE_INTERVAL_SECONDS + "=15");
+
+        AutoSquealConfig config = store.load();
+
+        assertEquals(30, config.getAwayThresholdSeconds());
+        assertTrue(config.isClickEnabled());
+        assertEquals(ScreenArea.PRIMARY, config.getMovementScreen());
+        // the one valid value still loads
+        assertEquals(15, config.getMoveIntervalSeconds());
+    }
+
+    @Test
+    void settingsSettersClampToo() {
+        AutoSquealConfig config = new AutoSquealConfig();
+
+        config.setAwayThresholdSeconds(-10);
+        assertEquals(5, config.getAwayThresholdSeconds());
+
+        config.setAwayThresholdSeconds(10_000);
+        assertEquals(600, config.getAwayThresholdSeconds());
+
+        config.setMovementScreen(null);
+        assertEquals(ScreenArea.PRIMARY, config.getMovementScreen());
+    }
+
+    @Test
+    void savingNeverLeavesTempFilesBehind() throws IOException {
+        store.save(new AutoSquealConfig());
+
+        assertTrue(Files.isRegularFile(tempDir.resolve("autosqueal.properties")));
+        try (var files = Files.list(tempDir)) {
+            assertEquals(1, files.count());
+        }
+    }
+
+    private void writeFile(String... lines) throws IOException {
+        Files.write(tempDir.resolve("autosqueal.properties"), List.of(lines));
+    }
+}

src/test/java/wtf/beatrice/autosqueal/controls/CursorMoverTest.java

@@ -0,0 +1,187 @@
+package wtf.beatrice.autosqueal.controls;
+
+import org.junit.jupiter.api.Test;
+import wtf.beatrice.autosqueal.config.AutoSquealConfig;
+
+import java.awt.Point;
+import java.awt.Rectangle;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.AbstractExecutorService;
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class CursorMoverTest
+{
+    private static final Point CURSOR_AT = new Point(100, 100);
+
+    private final RobotMouseTracker robotTracker = new RobotMouseTracker();
+    private final AutoSquealConfig config = new AutoSquealConfig();
+    private final RecordingExecutor executor = new RecordingExecutor();
+
+    /** Bounds of a pretend multi-screen setup: the main screen is offset. */
+    private final Rectangle movementBounds = new Rectangle(100, 50, 800, 600);
+    private final Rectangle primaryBounds = new Rectangle(100, 50, 800, 600);
+
+    /** A mover that queues its movements on the recording executor. */
+    private CursorMover mover() {
+        return new CursorMover(executor, robotTracker, () -> true, config,
+                () -> movementBounds, () -> primaryBounds,
+                new Random(42), () -> CURSOR_AT);
+    }
+
+    private List<SingleStepMovementTask> movements() {
+        List<SingleStepMovementTask> movements = new ArrayList<>();
+        for (Runnable movement : executor.movements) {
+            movements.add((SingleStepMovementTask) movement);
+        }
+        return movements;
+    }
+
+    @Test
+    void movementsAreSkippedWhileTheUserIsPresent() {
+        // the automation only moves the mouse when the user is away
+        CursorMover presentMover = new CursorMover(executor, robotTracker, () -> false, config,
+                () -> movementBounds, () -> primaryBounds,
+                new Random(42), () -> CURSOR_AT);
+
+        for (int i = 0; i < 10; i++) {
+            presentMover.run();
+        }
+
+        assertTrue(executor.movements.isEmpty());
+    }
+
+    @Test
+    void randomMovementsStayWithinTheBounds() {
+        config.setClickEnabled(false);
+
+        CursorMover cursorMover = mover();
+        for (int i = 0; i < 50; i++) {
+            cursorMover.run();
+        }
+
+        List<SingleStepMovementTask> movements = movements();
+        assertEquals(50, movements.size());
+        for (SingleStepMovementTask movement : movements) {
+            assertFalse(movement.isClick());
+            assertTrue(movement.getDestX() >= 100, "destX below the bounds: " + movement.getDestX());
+            assertTrue(movement.getDestX() < 900, "destX above the bounds: " + movement.getDestX());
+            assertTrue(movement.getDestY() >= 50, "destY below the bounds: " + movement.getDestY());
+            assertTrue(movement.getDestY() < 650, "destY above the bounds: " + movement.getDestY());
+        }
+    }
+
+    @Test
+    void cornerClicksHappenEveryNthMovement() {
+        config.setClickEveryNMoves(3);
+
+        CursorMover cursorMover = mover();
+        for (int i = 0; i < 6; i++) {
+            cursorMover.run();
+        }
+
+        List<SingleStepMovementTask> movements = movements();
+        assertEquals(6, movements.size());
+
+        // one movement every 3: the 3rd and the 6th are corner clicks
+        assertFalse(movements.get(0).isClick());
+        assertFalse(movements.get(1).isClick());
+        assertTrue(movements.get(2).isClick());
+        assertFalse(movements.get(3).isClick());
+        assertFalse(movements.get(4).isClick());
+        assertTrue(movements.get(5).isClick());
+    }
+
+    @Test
+    void cornerClicksAimAtTheMainScreensTopRight() {
+        // the click must open the notifications, which live on the main
+        // screen's corner: wherever the movement bounds are, the click
+        // destination follows the main screen
+        config.setClickEveryNMoves(3);
+        Rectangle elsewhere = new Rectangle(5000, 5000, 200, 200);
+        CursorMover cursorMover = new CursorMover(executor, robotTracker, () -> true, config,
+                () -> elsewhere, () -> primaryBounds,
+                new Random(42), () -> CURSOR_AT);
+
+        cursorMover.run(); // iteration 0: a normal movement
+        cursorMover.run(); // iteration 1: a normal movement
+        cursorMover.run(); // iteration 2: the corner click
+
+        List<SingleStepMovementTask> movements = movements();
+        assertTrue(movements.get(2).isClick());
+        // the main screen's top-right corner, 5px inside
+        assertEquals(100 + 800 - 5, movements.get(2).getDestX());
+        assertEquals(50 + 5, movements.get(2).getDestY());
+    }
+
+    @Test
+    void clicksCanBeTurnedOff() {
+        config.setClickEnabled(false);
+
+        CursorMover cursorMover = mover();
+        for (int i = 0; i < 10; i++) {
+            cursorMover.run();
+        }
+
+        for (SingleStepMovementTask movement : movements()) {
+            assertFalse(movement.isClick());
+        }
+    }
+
+    @Test
+    void clickCadenceIsReadLive() {
+        config.setClickEveryNMoves(2);
+
+        CursorMover cursorMover = mover();
+        cursorMover.run(); // iteration 0
+        cursorMover.run(); // iteration 1: click, cadence 2
+        assertTrue(movements().get(1).isClick());
+
+        // the user loosens the cadence while the automation runs
+        config.setClickEveryNMoves(4);
+        cursorMover.run(); // iteration 0
+        cursorMover.run(); // iteration 1
+        cursorMover.run(); // iteration 2
+        cursorMover.run(); // iteration 3: click, cadence 4
+
+        List<SingleStepMovementTask> movements = movements();
+        assertEquals(6, movements.size());
+        assertFalse(movements.get(2).isClick());
+        assertFalse(movements.get(3).isClick());
+        assertFalse(movements.get(4).isClick());
+        assertTrue(movements.get(5).isClick());
+    }
+
+    /** An executor that records the tasks instead of running them. */
+    private static class RecordingExecutor extends AbstractExecutorService {
+
+        final List<Runnable> movements = new ArrayList<>();
+
+        public void execute(Runnable command) {
+            movements.add(command);
+        }
+
+        public void shutdown() { }
+
+        public List<Runnable> shutdownNow() {
+            return List.of();
+        }
+
+        public boolean isShutdown() {
+            return false;
+        }
+
+        public boolean isTerminated() {
+            return false;
+        }
+
+        public boolean awaitTermination(long timeout, TimeUnit unit) {
+            return false;
+        }
+    }
+}

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<Point> 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<Point> 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<Point> 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<Point> positions = new ArrayList<>();
-        positions.add(at(100, 100)); // baseline
-        for (int i = 1; i <= 40; i++) positions.add(at(100 + i, 100));
+        Queue<Point> 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<Point> 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<Point> 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<Point> 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<Point> 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<Point> 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<Point> 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());
     }
 }

src/test/java/wtf/beatrice/autosqueal/listener/KeyPressListenerTest.java

@@ -0,0 +1,86 @@
+package wtf.beatrice.autosqueal.listener;
+
+import com.github.kwhat.jnativehook.keyboard.NativeKeyEvent;
+import org.junit.jupiter.api.Test;
+import wtf.beatrice.autosqueal.config.AutoSquealConfig;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class KeyPressListenerTest
+{
+    private final List<String> events = new ArrayList<>();
+    private final AutoSquealConfig config = new AutoSquealConfig();
+    private final KeyPressListener listener = new KeyPressListener(
+            () -> events.add("toggle"), () -> events.add("activity"), config);
+
+    private static NativeKeyEvent press(int keyCode) {
+        return new NativeKeyEvent(NativeKeyEvent.NATIVE_KEY_PRESSED, 0, 0, keyCode, ' ');
+    }
+
+    private static NativeKeyEvent release(int keyCode) {
+        return new NativeKeyEvent(NativeKeyEvent.NATIVE_KEY_RELEASED, 0, 0, keyCode, ' ');
+    }
+
+    @Test
+    void theComboTogglesOnceOnItsSecondKey() {
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_CONTROL));
+
+        // ctrl alone is not the combo: it only reports presence
+        assertEquals(List.of("activity"), events);
+
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_ALT));
+
+        // the second key completes the combo: presence first, then the toggle
+        assertEquals(List.of("activity", "activity", "toggle"), events);
+    }
+
+    @Test
+    void theComboWorksInTheOtherOrderToo() {
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_ALT));
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_CONTROL));
+
+        assertEquals(List.of("activity", "activity", "toggle"), events);
+    }
+
+    @Test
+    void repeatedPressesAreIgnored() {
+        // the OS repeats press events while a key is held down: they must
+        // not toggle repeatedly
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_CONTROL));
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_ALT));
+
+        events.clear();
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_CONTROL));
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_ALT));
+
+        assertEquals(List.of(), events);
+    }
+
+    @Test
+    void theComboCanFireAgainAfterBothKeysAreReleased() {
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_CONTROL));
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_ALT));
+        listener.nativeKeyReleased(release(NativeKeyEvent.VC_CONTROL));
+        listener.nativeKeyReleased(release(NativeKeyEvent.VC_ALT));
+
+        events.clear();
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_CONTROL));
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_ALT));
+
+        assertEquals(List.of("activity", "activity", "toggle"), events);
+    }
+
+    @Test
+    void theHotkeyCanBeDisabledWithoutLosingPresenceReporting() {
+        config.setHotkeyEnabled(false);
+
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_CONTROL));
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_ALT));
+
+        // typing still counts as presence, but the combo does nothing
+        assertEquals(List.of("activity", "activity"), events);
+    }
+}