fix(CompositeDevice): Ensure proper handling of chord events in a way steam can understand them.

[pastaq]

• Add default configuration for steam that covers 99% of handhelds.

[ShadowApex]

The main issue I see with the current implementation is that the sleep calls that happen when performing these chords will halt the processing of all events for the CompositeDevice while its sleeping.

To avoid this, I propose we actually spawn a tokio task that will sleep for the desired amount of time, then send a Command using the sender side of the CompositeDevice channel to tell the device it should process the event after the sleep has finished. Since the sleep is happening in its own task, it will not block the CompositeDevice from processing other events.

e.g.

pub enum Command {
    ...
    WriteEvent(NativeEvent),
...

...
tokio::spawn(async move {
    tokio::time::sleep(Duration::from_millis(80)).await;
    if let Err(e) = tx.send(Command::WriteEvent(event)) {
        log::error!("Failed to send chord event command: {:?}", e);
    }
});
...

Then in the run loop, we can process the command sent through the channel after the delay:

match cmd {
    ...
    Command::WriteEvent(event) => {
        if let Err(e) = self.write_event(event).await {
            log::error!("Failed to write event: {:?}", e);
        }
    }
...

[ShadowApex]

Instead of using thread::sleep, we should be using tokio::time::sleep instead whenever we need to sleep in an async function. Using thread::sleep is something we should only use for synchronous code to prevent holding up the async runtime.

[pastaq]

I tried this, the tokio sleeps don't affect the thread we need to sleep so everything breaks.

[pastaq]

The main issue I see with the current implementation is that the sleep calls that happen when performing these chords will halt the processing of all events for the CompositeDevice while its sleeping.

To avoid this, I propose we actually spawn a tokio task that will sleep for the desired amount of time, then send a Command using the sender side of the CompositeDevice channel to tell the device it should process the event after the sleep has finished. Since the sleep is happening in its own task, it will not block the CompositeDevice from processing other events.

e.g.

pub enum Command {
    ...
    WriteEvent(NativeEvent),
...

...
tokio::spawn(async move {
    tokio::time::sleep(Duration::from_millis(80)).await;
    if let Err(e) = tx.send(Command::WriteEvent(event)) {
        log::error!("Failed to send chord event command: {:?}", e);
    }
});
...

Then in the run loop, we can process the command sent through the channel after the delay:

match cmd {
    ...
    Command::WriteEvent(event) => {
        if let Err(e) = self.write_event(event).await {
            log::error!("Failed to write event: {:?}", e);
        }
    }
...

We can't do this if we want to support devices that use on-release instead of momentary action for their buttons. Take for example the ROG Ally, arguably the second most popular handheld after the Steam Deck. The CC and AC buttons do not emit events when pressed, rather they release events only on release. Approximately 1ms after the "down" events fire the "up" events fire. If we use a tokio to delay before the event is transmitted then the "up" event will arrive 79ms before the "down" event. We could also add an 80 ms delay before any "up" chords but that still only provides 1ms for steam to recognize the chord and use the events, leading to multiple event pass-throughs.

[ShadowApex]

Ship it!

[github-actions]

🎉 This PR is included in version 0.10.2 🎉

The release is available on GitHub release

Your semantic-release bot 📦🚀