play: sink thread receives & processes commands

This adds play, pause & playpause functionality. The media keys
haven't been tested but in theory should work.

src/app.rs

···
-use crossterm::event::{self, Event, KeyCode, KeyModifiers};
+use crossterm::event::{self, Event, KeyCode, KeyModifiers, MediaKeyCode};
 use ratatui::{
     prelude::*,
     widgets::{block::*, *},
···
     thread,
     time::{Duration, Instant},
 };
-use tokio::sync::mpsc::UnboundedReceiver;
+use tokio::sync::mpsc::{UnboundedReceiver, UnboundedSender};
 
 use crate::{
     extract::get_currently_playing,
     input::stream_to_matrix,
+    play::SinkCommand,
     tui,
     visualization::{
         oscilloscope::Oscilloscope, spectroscope::Spectroscope, vectorscope::Vectorscope,
···
         &mut self,
         terminal: &mut tui::Tui,
         mut cmd_rx: UnboundedReceiver<State>,
+        mut sink_cmd_tx: UnboundedSender<SinkCommand>,
         id: &str,
     ) {
         let new_state = cmd_rx.recv().await.unwrap();
···
                 // process all enqueued events
                 let event = event::read().unwrap();
 
-                if self.process_events(event.clone()).unwrap() {
+                if self
+                    .process_events(event.clone(), &mut sink_cmd_tx)
+                    .unwrap()
+                {
                     return;
                 }
                 self.current_display_mut().handle(event);
···
         }
     }
 
-    fn process_events(&mut self, event: Event) -> Result<bool, io::Error> {
+    fn process_events(
+        &mut self,
+        event: Event,
+        sink_cmd_tx: &mut UnboundedSender<SinkCommand>,
+    ) -> Result<bool, io::Error> {
         let mut quit = false;
         if let Event::Key(key) = event {
             if let KeyModifiers::CONTROL = key.modifiers {
···
                         }
                     }
                 }
+                KeyCode::Media(media_key_code) => match media_key_code {
+                    MediaKeyCode::Play => {
+                        sink_cmd_tx
+                            .send(SinkCommand::Play)
+                            .expect("receiver never dropped");
+                    }
+                    MediaKeyCode::Pause => {
+                        sink_cmd_tx
+                            .send(SinkCommand::Pause)
+                            .expect("receiver never dropped");
+                    }
+                    MediaKeyCode::PlayPause => {
+                        sink_cmd_tx
+                            .send(SinkCommand::PlayPause)
+                            .expect("receiver never dropped");
+                    }
+                    MediaKeyCode::Stop => {
+                        quit = true;
+                    }
+                    MediaKeyCode::LowerVolume
+                    | MediaKeyCode::RaiseVolume
+                    | MediaKeyCode::MuteVolume
+                    | MediaKeyCode::TrackNext
+                    | MediaKeyCode::TrackPrevious
+                    | MediaKeyCode::Reverse
+                    | MediaKeyCode::FastForward
+                    | MediaKeyCode::Rewind
+                    | MediaKeyCode::Record => todo!(),
+                },
                 _ => {}
             }
         };

src/play.rs

···
     let now_playing = station.playing.clone().unwrap_or_default();
 
     let (cmd_tx, cmd_rx) = tokio::sync::mpsc::unbounded_channel::<State>();
+    let (sink_cmd_tx, mut sink_cmd_rx) = tokio::sync::mpsc::unbounded_channel::<SinkCommand>();
     let (frame_tx, frame_rx) = std::sync::mpsc::channel::<minimp3::Frame>();
 
     let ui = UiOptions {
···
         sink.append(decoder);
 
         loop {
+            while let Ok(sink_cmd) = sink_cmd_rx.try_recv() {
+                match sink_cmd {
+                    SinkCommand::Play => {
+                        sink.play();
+                    }
+                    SinkCommand::Pause => {
+                        sink.pause();
+                    }
+                    SinkCommand::PlayPause => {
+                        if sink.is_paused() {
+                            sink.play();
+                        } else {
+                            sink.pause();
+                        }
+                    }
+                }
+            }
             std::thread::sleep(Duration::from_millis(10));
         }
     });
 
     let mut terminal = tui::init()?;
-    app.run(&mut terminal, cmd_rx, &id).await;
+    app.run(&mut terminal, cmd_rx, sink_cmd_tx, &id).await;
     tui::restore()?;
     Ok(())
 }
+
+/// Command for a sink.
+#[derive(Debug, Clone, PartialEq)]
+pub enum SinkCommand {
+    /// Play.
+    Play,
+    /// Pause.
+    Pause,
+    /// Toggle between play and pause.
+    PlayPause,
+}