TouchEventPoller.cs

using Gondwana.Input.Touch.Gestures;
 
namespace Gondwana.Input.Touch;

public sealed class TouchEventPoller : ITouchInput, IDisposable
{
    public static TouchEventPoller? Instance { get; private set; }

    public static void Initialize(ITouchAdapter adapter, TouchEventConfiguration? config = null)
    {
        ArgumentNullException.ThrowIfNull(adapter);
 
        config ??= new TouchEventConfiguration(
            secondsBetweenEvents: Engine.Instance.Configuration.TimeBetweenTouchEvents);
 
        Instance?.Dispose();
        Instance = new TouchEventPoller(adapter, config);
    }

    public static void Reset()
    {
        Instance?.Dispose();
        Instance = null;
    }
 
    private readonly Dictionary<int, TouchPoint> _activeTouches = new();
    private TouchPoint[] _activeTouchesSnapshot = Array.Empty<TouchPoint>();

    public IReadOnlyList<TouchPoint> ActiveTouches => _activeTouchesSnapshot;

    public ITouchAdapter? Adapter { get; private set; }

    public TouchEventConfiguration? Configuration { get; private set; }

    public event EventHandler<TouchEventArgs>? TouchBegan;

    public event EventHandler<TouchEventArgs>? TouchMoved;

    public event EventHandler<TouchEventArgs>? TouchEnded;

    public event Action<GestureEventArgs>? TouchEvent;

    public TapGestureRecognizer TapRecognizer { get; }

    public SwipeGestureRecognizer SwipeRecognizer { get; }

    public PinchGestureRecognizer PinchRecognizer { get; }
    private bool _isDisposed;
 
    private TouchEventPoller(ITouchAdapter adapter, TouchEventConfiguration config)
    {
        Adapter = adapter;
        Configuration = config;
 
        TapRecognizer = new TapGestureRecognizer(this);
        SwipeRecognizer = new SwipeGestureRecognizer(this);
        PinchRecognizer = new PinchGestureRecognizer(this);
        TapRecognizer.CompetingSwipeRecognizer = SwipeRecognizer;
 
        TapRecognizer.Tapped += (_, e) => TouchEvent?.Invoke(new GestureEventArgs(e));
        SwipeRecognizer.Swiped += (_, e) => TouchEvent?.Invoke(new GestureEventArgs(e));
        PinchRecognizer.PinchStarted += OnPinch;
        PinchRecognizer.PinchUpdated += OnPinch;
        PinchRecognizer.PinchEnded += OnPinch;
    }
 
    private void OnPinch(object? sender, PinchedEventArgs e)
        => TouchEvent?.Invoke(new GestureEventArgs(e));

    internal void PollForEvents(long tick)
    {
        if (_isDisposed || Adapter is null) return;
 
        var began = Adapter.ConsumeBeganTouches();
        var ended = Adapter.ConsumeEndedTouches();
 
        // A paused/stopped poller deliberately establishes a new logical contact boundary.
        // Drain transient queues, forget prior contacts, and begin fresh on resume.
        if (Configuration is null || Configuration.IsPaused)
        {
            ClearContactState();
            return;
        }
 
        // Lifecycle transitions are lossless and are never throttled.
        foreach (var beganPoint in began)
        {
            if (_activeTouches.ContainsKey(beganPoint.Id))
                continue;
 
            var normalized = new TouchPoint(
                beganPoint.Id,
                beganPoint.Position,
                TouchPhase.Began);
 
            _activeTouches[normalized.Id] = normalized;
            TouchBegan?.Invoke(this, new TouchEventArgs(normalized, tick));
        }
 
        foreach (var endedPoint in ended)
        {
            // A beginning and ending may both have occurred between engine polls. The queued
            // beginning above ensures consumers still receive a complete lifecycle.
            if (_activeTouches.Remove(endedPoint.Id))
                TouchEnded?.Invoke(this, new TouchEventArgs(endedPoint, tick));
        }
 
        var currentActive = Adapter.ActiveTouches;
 
        // Discover active contacts for adapters that use the default empty beginning queue.
        foreach (var point in currentActive)
        {
            if (!_activeTouches.ContainsKey(point.Id))
            {
                var normalized = new TouchPoint(point.Id, point.Position, TouchPhase.Began);
                _activeTouches[normalized.Id] = normalized;
                TouchBegan?.Invoke(this, new TouchEventArgs(normalized, tick));
            }
        }
 
        bool movementEmitted = false;
        if (Configuration.ReadyForNextEvent(tick))
        {
            foreach (var point in currentActive)
            {
                if (!_activeTouches.TryGetValue(point.Id, out var known) ||
                    known.Position == point.Position)
                    continue;
 
                var movedPoint = new TouchPoint(point.Id, point.Position, TouchPhase.Moved);
                _activeTouches[point.Id] = movedPoint;
                TouchMoved?.Invoke(this, new TouchEventArgs(movedPoint, tick));
                movementEmitted = true;
            }
        }
 
        _activeTouchesSnapshot = _activeTouches.Values.ToArray();
 
        if (movementEmitted)
            Configuration._lastEventTick = tick;
    }

    public void StartMonitoringTouch(double timeBetweenEvents = -1, bool isPaused = false)
    {
        if (timeBetweenEvents < 0)
            timeBetweenEvents = Engine.Instance.Configuration.TimeBetweenTouchEvents;
 
        Configuration = new TouchEventConfiguration(timeBetweenEvents, isPaused);
    }

    public void StopMonitoringTouch()
    {
        Configuration = null;
        ClearContactState();
    }
 
    private void ClearContactState()
    {
        _activeTouches.Clear();
        _activeTouchesSnapshot = Array.Empty<TouchPoint>();
        TapRecognizer.Reset();
        SwipeRecognizer.Reset();
        PinchRecognizer.Reset();
    }

    public void Dispose()
    {
        if (_isDisposed)
            return;
 
        _isDisposed = true;
 
        TapRecognizer.Dispose();
        SwipeRecognizer.Dispose();
        PinchRecognizer.PinchStarted -= OnPinch;
        PinchRecognizer.PinchUpdated -= OnPinch;
        PinchRecognizer.PinchEnded -= OnPinch;
        PinchRecognizer.Dispose();
 
        (Adapter as IDisposable)?.Dispose();
        Adapter = null;
        Configuration = null;
        _activeTouches.Clear();
        _activeTouchesSnapshot = Array.Empty<TouchPoint>();
 
        if (ReferenceEquals(Instance, this))
            Instance = null;
    }
}