Implement hot plugging support and connect/disconnect events for InputDevices

Currently this is only supported by XInput

- Reorder some methods

Author: steffen-wilke

src/main/java/de/gurkenlabs/input4j/AbstractInputDevicePlugin.java

@@ -1,14 +1,22 @@
 package de.gurkenlabs.input4j;
 
 import java.util.Collection;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Consumer;
 import java.util.logging.Logger;
 
 public abstract class AbstractInputDevicePlugin implements InputDevicePlugin {
   protected static final Logger log = Logger.getLogger(AbstractInputDevicePlugin.class.getPackage().getName());
+  private final Collection<Consumer<InputDevice>> deviceConnectedListeners = ConcurrentHashMap.newKeySet();
+  private final Collection<Consumer<InputDevice>> deviceDisconnectedListeners = ConcurrentHashMap.newKeySet();
+  private final Collection<Runnable> devicesChangedListeners = ConcurrentHashMap.newKeySet();
 
+  private final int hotPlugInterval;
+  private long lastDeviceUpdate;
   private Collection<InputDevice> devices;
 
   protected AbstractInputDevicePlugin() {
+    this.hotPlugInterval = InputDevices.configure().getHotPlugInterval();
   }
 
   /**
@@ -25,6 +33,20 @@ public Collection<InputDevice> getAll() {
     return this.devices;
   }
 
+  /**
+   * Closes the plugin and clears the collection of devices.
+   */
+  @Override
+  public void close() {
+    if (this.devices != null) {
+      this.devices.forEach(InputDevice::close);
+    }
+
+    deviceConnectedListeners.clear();
+    deviceDisconnectedListeners.clear();
+    devicesChangedListeners.clear();
+  }
+
   /**
    * Sets the devices that are managed by this plugin.
    * <p>
@@ -34,5 +56,76 @@ public Collection<InputDevice> getAll() {
    */
   protected void setDevices(Collection<InputDevice> devices) {
     this.devices = devices;
+    this.lastDeviceUpdate = System.currentTimeMillis();
+  }
+
+  /**
+   * Refreshes the list of input devices.
+   * <p>
+   * This method needs to be called explicitly to support hot-plugging devices.
+   * If a new device is connected or an existing device is disconnected, the list of input devices is updated accordingly.
+   * </p>
+   * <p>
+   * IMPORTANT: This is a costly operation and should be called periodically to ensure that the list of input devices is up-to-date.
+   * This method should not be called in the same interval as the polling of input devices.
+   * </p>
+   * <p>
+   * This also triggers the {@link #onDeviceConnected(Consumer)} and {@link #onDeviceDisconnected(Consumer)} events when necessary.
+   * </p>
+   */
+  protected void refreshDevices() {
+    if (this.lastDeviceUpdate == 0 || System.currentTimeMillis() - this.lastDeviceUpdate < this.hotPlugInterval) {
+      return;
+    }
+
+    this.lastDeviceUpdate = System.currentTimeMillis();
+    final var oldDeviceIds = this.getAll().stream().map(InputDevice::getID).toList();
+    var refreshedDevices = this.refreshInputDevices();
+    var refreshedDeviceIds = refreshedDevices.stream().map(InputDevice::getID).toList();
+
+    var devicesChanged = false;
+    // Check for disconnected devices
+    for (var currentDeviceId : oldDeviceIds) {
+      if (!refreshedDeviceIds.contains(currentDeviceId)) {
+        // Device was disconnected
+        var disconnectedDevice = this.devices.stream().filter(d -> d.getID().equals(currentDeviceId)).findFirst().orElse(null);
+        if (disconnectedDevice != null) {
+          this.deviceDisconnectedListeners.forEach(listener -> listener.accept(disconnectedDevice));
+          devicesChanged = true;
+        }
+      }
+    }
+
+    // Check for newly connected devices
+    for (var connectedDeviceId : refreshedDeviceIds) {
+      if (!oldDeviceIds.contains(connectedDeviceId)) {
+        // New device connected
+        InputDevice connectedDevice = refreshedDevices.stream().filter(d -> d.getID().equals(connectedDeviceId)).findFirst().orElse(null);
+        if (connectedDevice != null) {
+          this.deviceConnectedListeners.forEach(listener -> listener.accept(connectedDevice));
+          devicesChanged = true;
+        }
+      }
+    }
+
+    if (devicesChanged) {
+      this.devicesChangedListeners.forEach(Runnable::run);
+    }
+
+    this.setDevices(refreshedDevices);
+  }
+
+  protected abstract Collection<InputDevice> refreshInputDevices();
+
+  public void onDevicesChanged(Runnable listener) {
+    this.devicesChangedListeners.add(listener);
+  }
+
+  public void onDeviceConnected(Consumer<InputDevice> listener) {
+    this.deviceConnectedListeners.add(listener);
+  }
+
+  public void onDeviceDisconnected(Consumer<InputDevice> listener) {
+    this.deviceDisconnectedListeners.add(listener);
   }
 }

src/main/java/de/gurkenlabs/input4j/InputDevice.java

@@ -32,7 +32,7 @@
  */
 public final class InputDevice implements Closeable {
   private final String identifier;
-  private final String instanceName;
+  private final String name;
   private final String productName;
   private final List<InputComponent> components = new CopyOnWriteArrayList<>();
   private final Collection<InputDeviceListener> listeners = ConcurrentHashMap.newKeySet();
@@ -49,14 +49,14 @@ public final class InputDevice implements Closeable {
    * Creates a new instance of the InputDevice class.
    *
    * @param identifier     the identifier of the input device
-   * @param instanceName   the name of the instance of the input device
+   * @param name           the name of the instance of the input device
    * @param productName    the name of the product of the input device
    * @param pollCallback   the function to be called when polling for input data from the device
    * @param rumbleCallback the function to be called when setting rumble intensity
    */
-  public InputDevice(String identifier, String instanceName, String productName, Function<InputDevice, float[]> pollCallback, BiConsumer<InputDevice, float[]> rumbleCallback) {
+  public InputDevice(String identifier, String name, String productName, Function<InputDevice, float[]> pollCallback, BiConsumer<InputDevice, float[]> rumbleCallback) {
     this.identifier = identifier;
-    this.instanceName = instanceName;
+    this.name = name;
     this.productName = productName;
     this.pollCallback = pollCallback;
     this.rumbleCallback = rumbleCallback;
@@ -81,8 +81,8 @@ public String getID() {
    *
    * @return the instance name
    */
-  public String getInstanceName() {
-    return instanceName;
+  public String getName() {
+    return name;
   }
 
   /**
@@ -239,14 +239,6 @@ public void rumble(float... intensity) {
 
     this.rumbleCallback.accept(this, intensity);
   }
-
-  @Override
-  public void close() {
-    this.listeners.clear();
-    this.buttonPressedListeners.clear();
-    this.buttonReleasedListeners.clear();
-  }
-
   public void setAccuracy(int decimalPlaces) {
     if (decimalPlaces < 0) {
       throw new IllegalArgumentException("Decimal places must be a non-negative integer.");
@@ -255,6 +247,13 @@ public void setAccuracy(int decimalPlaces) {
     this.accuracyFactor = (float) Math.pow(10, Math.min(decimalPlaces, 7));
   }
 
+  @Override
+  public void close() {
+    this.listeners.clear();
+    this.buttonPressedListeners.clear();
+    this.buttonReleasedListeners.clear();
+  }
+
   /**
    * Checks if the input device has any input data.
    *
@@ -264,6 +263,11 @@ public boolean hasInputData() {
     return this.hasInputData;
   }
 
+  @Override
+  public String toString() {
+    return this.getName();
+  }
+
   public void onInputValueChanged(InputDeviceListener listener) {
     this.listeners.add(listener);
   }

src/main/java/de/gurkenlabs/input4j/InputDevicePlugin.java

@@ -3,6 +3,7 @@
 import java.awt.*;
 import java.io.Closeable;
 import java.util.Collection;
+import java.util.function.Consumer;
 
 /**
  * Represents a plugin that provides input devices.
@@ -38,4 +39,10 @@ public interface InputDevicePlugin extends Closeable {
    * @return A collection of {@link InputDevice} objects representing the available input devices of this system.
    */
   Collection<InputDevice> getAll();
+
+  void onDevicesChanged(Runnable listener);
+
+  void onDeviceConnected(Consumer<InputDevice> listener);
+
+  void onDeviceDisconnected(Consumer<InputDevice> listener);
 }

src/main/java/de/gurkenlabs/input4j/InputDevices.java

@@ -53,7 +53,8 @@ public static InputDevicePlugin init(Frame owner) throws IOException {
   /**
    * Initializes the input device provider with the specified library.
    * <p>
-   *   Note: Some controllers don't support background mode which is why it can be necessary to pass a frame owner to the {@link InputDevices#init(Frame, String)} method.
+   * Note: Some controllers don't support background mode which is why it can be necessary to pass a frame owner to the {@link InputDevices#init(Frame, String)} method.
+   *
    * @param library The library to be used.
    * @return The initialized input device provider.
    * @throws IOException if the input device provider cannot be initialized.
@@ -65,7 +66,8 @@ public static InputDevicePlugin init(InputLibrary library) throws IOException {
   /**
    * Initializes the input device provider with the specified input plugin class.
    * <p>
-   *   Note: Some controllers don't support background mode which is why it can be necessary to pass a frame owner to the {@link InputDevices#init(Frame, String)} method.
+   * Note: Some controllers don't support background mode which is why it can be necessary to pass a frame owner to the {@link InputDevices#init(Frame, String)} method.
+   *
    * @param inputPluginClass The input plugin class to be used.
    * @return The initialized input device provider.
    * @throws IOException if the input device provider cannot be initialized.
@@ -214,16 +216,21 @@ public static final class DefaultInputConfiguration {
     // default polling rate in hertz (times per second)
     private static final int DEFAULT_POLLING_RATE = 100;
 
+    private static final int DEFAULT_HOTPLUG_INTERVAL = 3000;
+
     private int pollingRate;
     private boolean pollingEnabled;
 
     private int accuracy;
 
+    private int hotplugInterval;
+
     private DefaultInputConfiguration() {
       this.pollingRate = DEFAULT_POLLING_RATE;
       this.pollingEnabled = false;
 
       this.accuracy = DEFAULT_ACCURACY;
+      this.hotplugInterval = DEFAULT_HOTPLUG_INTERVAL;
     }
 
     /**
@@ -285,5 +292,13 @@ public boolean isPollingEnabled() {
     public void enablePolling(boolean pollingEnabled) {
       this.pollingEnabled = pollingEnabled;
     }
+
+    public int getHotPlugInterval() {
+      return hotplugInterval;
+    }
+
+    public void setHotPlugInterval(int hotplugInterval) {
+      this.hotplugInterval = hotplugInterval;
+    }
   }
 }

src/main/java/de/gurkenlabs/input4j/examples/ExampleEventBasedInputHandling.java

@@ -9,6 +9,9 @@
 public class ExampleEventBasedInputHandling {
   public static void main(String[] args) throws IOException, InterruptedException {
     try (var devices = InputDevices.init()) {
+
+      devices.onDeviceConnected(inputDevice -> System.out.println("Device connected " + inputDevice));
+      devices.onDeviceDisconnected(inputDevice -> System.out.println("Device disconnected " + inputDevice));
       var device = devices.getAll().stream().findFirst().orElse(null);
       if (device == null) {
         System.out.println("No input devices found.");

src/main/java/de/gurkenlabs/input4j/examples/ExamplePollAllInputDevicesManually.java

@@ -27,7 +27,7 @@ public static void main(String[] args) throws IOException {
             continue;
           }
 
-          System.out.println(inputDevice.getInstanceName() + ":" + inputDevice.getComponents().stream().filter(x -> x.getData() != 0).toList());
+          System.out.println(inputDevice.getName() + ":" + inputDevice.getComponents().stream().filter(x -> x.getData() != 0).toList());
 
           // Rumble the device if the X button is pressed
           // handleRumble(inputDevice);
@@ -61,4 +61,4 @@ private static void handleRumble(InputDevice inputDevice) {
       }
     });
   }
-}
+}