KeyboardEventPoller.cs

using System.Collections.Concurrent;
using System.Collections.ObjectModel;
 
namespace Gondwana.Input.Keyboard;

public sealed class KeyboardEventPoller
{
    public static KeyboardEventPoller? Instance { get; private set; }

    public static void Initialize(IKeyboardAdapter adapter)
    {
        Instance = new KeyboardEventPoller(adapter);
    }

    public event Action<KeyDownEventArgs>? KeyDown;
 
    // Hot path uses int key codes.
    private readonly Dictionary<int, KeyEventConfiguration> _keyConfigs = new();
    private readonly Dictionary<int, bool> _previousPressed = new();
 
    // Apply monitoring changes on the engine thread to avoid ToList() allocations.
    private readonly ConcurrentQueue<Action> _pendingOps = new();
 
    private KeyboardEventPoller() { }
 
    private KeyboardEventPoller(IKeyboardAdapter adapter)
    {
        Adapter = adapter;
    }

    public IKeyboardAdapter? Adapter { get; private set; }

    public bool PauseAllKeyEvents { get; set; }

    internal void PollForEvents(long tick)
    {
        if (PauseAllKeyEvents)
            return;
 
        var adapter = Adapter;
        if (adapter is null)
            return;
 
        // Apply any pending adds/removes on the engine thread.
        while (_pendingOps.TryDequeue(out var op))
            op();
 
        var mods = adapter.CurrentKeyboardModifiers;
 
        foreach (var kvp in _keyConfigs)
        {
            int keyCode = kvp.Key;
            var config = kvp.Value;
 
            bool currentlyPressed = adapter.IsDown(keyCode);
            bool previouslyPressed = _previousPressed.TryGetValue(keyCode, out var prev) && prev;
 
            // Transition: not pressed -> pressed
            if (currentlyPressed && !previouslyPressed)
            {
                _previousPressed[keyCode] = true;
                config._lastEventTick = tick;
 
                KeyDown?.Invoke(new KeyDownEventArgs(config, mods, KeyAction.Pressed));
                continue;
            }
 
            // Still pressed -> maybe repeated (throttled)
            if (currentlyPressed && previouslyPressed)
            {
                if (!config.IsPaused && config.ReadyForNextEvent(tick))
                {
                    config._lastEventTick = tick;
                    KeyDown?.Invoke(new KeyDownEventArgs(config, mods, KeyAction.Repeated));
                }
                continue;
            }
 
            // Transition: pressed -> not pressed
            if (!currentlyPressed && previouslyPressed)
            {
                _previousPressed[keyCode] = false;
                KeyDown?.Invoke(new KeyDownEventArgs(config, mods, KeyAction.Released));
            }
 
            // not pressed && not previously pressed => nothing
        }
    }

    public void StartMonitoringKey(int keyCode, string? displayName = null, double timeBetweenEvents = -1, bool isPaused = false)
    {
        _pendingOps.Enqueue(() =>
        {
            if (timeBetweenEvents < 0)
                timeBetweenEvents = Engine.Instance.Configuration.TimeBetweenKeyboardEvents;
 
            var name = string.IsNullOrWhiteSpace(displayName) ? keyCode.ToString() : displayName;
            var config = new KeyEventConfiguration(name, timeBetweenEvents, isPaused);
 
            _keyConfigs[keyCode] = config;
 
            var adapter = Adapter;
            _previousPressed[keyCode] = adapter?.IsDown(keyCode) ?? false;
        });
    }

    public void StopMonitoringKey(int keyCode)
    {
        _pendingOps.Enqueue(() =>
        {
            _keyConfigs.Remove(keyCode);
            _previousPressed.Remove(keyCode);
        });
    }

    public void StopMonitoringKey(string key)
    {
        if (int.TryParse(key, out int code))
            StopMonitoringKey(code);
    }

    public void StopMonitoringAllKeys()
    {
        _pendingOps.Enqueue(() =>
        {
            _keyConfigs.Clear();
            _previousPressed.Clear();
        });
    }

    public IReadOnlyDictionary<int, KeyEventConfiguration> AllKeyConfigs =>
        new ReadOnlyDictionary<int, KeyEventConfiguration>(_keyConfigs);
}