Method stdio_key_handler

terminal/src/lib.rs:193–227

Async task to wait for key events on a non-raw terminal and translate them into events for the console or the machine.

(on_key_tx: Sender<Key>)

    /// Async task to wait for key events on a non-raw terminal and translate them into events for
    /// the console or the machine.
    async fn stdio_key_handler(on_key_tx: Sender<Key>) {
        // TODO(jmmv): We should probably install a signal handler here to capture SIGINT and
        // funnel it to the Machine via signals_rx, as we do in the raw_key_handler.  This would
        // help ensure both consoles behave in the same way, but there is strictly no need for this
        // because, when we do not configure the terminal in raw mode, we aren't capturing CTRL+C
        // and the default system handler will work.

        let mut buffer = VecDeque::default();

        let mut done = false;
        while !done {
            if on_key_tx.is_closed() {
                break;
            }

            let key = match read_key_from_stdin(&mut buffer) {
                Ok(key) => key,
                Err(_) => {
                    // There is not much we can do if we get an error from stdin.
                    Key::Unknown
                }
            };

            done = key == Key::EofOrDelete;

            // This should never fail but can if the receiver outruns the console because we don't
            // await for the handler to terminate (which we cannot do safely because `Drop` is not
            // async).
            if on_key_tx.send(key).await.is_err() {
                break;
            }
        }

        on_key_tx.close();
    }

    /// Flushes the console, which has already been written to via `lock`, if syncing is enabled.
    fn maybe_flush(&self, mut lock: StdoutLock<'_>) -> io::Result<()> {