play: SinkCommand: SetVolume

Allow user to set volume.

src/app.rs

···
     pub genre: String,
     pub description: String,
     pub br: String,
+    /// [`Volume`].
+    pub volume: Volume,
 }
 
 /// Volume of the player.
···
         if self.is_muted {
             0.0
         } else {
-            1.0
+            self.volume
         }
     }
 
···
         },
         frame,
     );
+    render_line(
+        "Volume ",
+        &if state.volume.is_muted() {
+            format!("{} muted", state.volume.volume())
+        } else {
+            format!("{}", state.volume.volume())
+        },
+        Rect {
+            x: size.x,
+            y: match state.now_playing.is_empty() {
+                true => size.y + 5,
+                false => size.y + 6,
+            },
+            width: size.width,
+            height: 1,
+        },
+        frame,
+    )
 }
 
 fn render_line(label: &str, value: &str, area: Rect, frame: &mut Frame) {
···
                 let event = event::read().unwrap();
 
                 if self
-                    .process_events(event.clone(), &mut sink_cmd_tx)
+                    .process_events(event.clone(), new_state.clone(), &mut sink_cmd_tx)
                     .unwrap()
                 {
                     return;
···
     fn process_events(
         &mut self,
         event: Event,
+        state: Arc<Mutex<State>>,
         sink_cmd_tx: &mut UnboundedSender<SinkCommand>,
     ) -> Result<bool, io::Error> {
         let mut quit = false;
+
+        let lower_volume = || {
+            let mut state = state.lock().unwrap();
+            state.volume.change_volume(-0.01);
+            sink_cmd_tx
+                .send(SinkCommand::SetVolume(state.volume.volume()))
+                .expect("receiver never dropped");
+        };
+
+        let raise_volume = || {
+            let mut state = state.lock().unwrap();
+            state.volume.change_volume(0.01);
+            sink_cmd_tx
+                .send(SinkCommand::SetVolume(state.volume.volume()))
+                .expect("receiver never dropped");
+        };
+
+        let mute_volume = || {
+            let mut state = state.lock().unwrap();
+            state.volume.toggle_mute();
+            sink_cmd_tx
+                .send(SinkCommand::SetVolume(state.volume.volume()))
+                .expect("receiver never dropped");
+        };
+
         if let Event::Key(key) = event {
             if let KeyModifiers::CONTROL = key.modifiers {
                 match key.code {
···
                 _ => 1.0,
             };
             match key.code {
-                KeyCode::Up => update_value_f(&mut self.graph.scale, 0.01, magnitude, 0.0..10.0), // inverted to act as zoom
-                KeyCode::Down => update_value_f(&mut self.graph.scale, -0.01, magnitude, 0.0..10.0), // inverted to act as zoom
+                KeyCode::Up => {
+                    // inverted to act as zoom
+                    update_value_f(&mut self.graph.scale, 0.01, magnitude, 0.0..10.0);
+                    raise_volume();
+                }
+                KeyCode::Down => {
+                    // inverted to act as zoom
+                    update_value_f(&mut self.graph.scale, -0.01, magnitude, 0.0..10.0);
+                    lower_volume();
+                }
                 KeyCode::Right => update_value_i(
                     &mut self.graph.samples,
                     true,
···
                 KeyCode::Char('s') => self.graph.scatter = !self.graph.scatter,
                 KeyCode::Char('h') => self.graph.show_ui = !self.graph.show_ui,
                 KeyCode::Char('r') => self.graph.references = !self.graph.references,
+                KeyCode::Char('m') => mute_volume(),
                 KeyCode::Esc => {
                     self.graph.samples = self.graph.width;
                     self.graph.scale = 1.;
···
                     MediaKeyCode::Stop => {
                         quit = true;
                     }
-                    MediaKeyCode::LowerVolume
-                    | MediaKeyCode::RaiseVolume
-                    | MediaKeyCode::MuteVolume
-                    | MediaKeyCode::TrackNext
+                    MediaKeyCode::LowerVolume => lower_volume(),
+                    MediaKeyCode::RaiseVolume => raise_volume(),
+                    MediaKeyCode::MuteVolume => mute_volume(),
+                    MediaKeyCode::TrackNext
                     | MediaKeyCode::TrackPrevious
                     | MediaKeyCode::Reverse
                     | MediaKeyCode::FastForward

src/play.rs

···
 use hyper::header::HeaderValue;
 
 use crate::{
-    app::{App, State},
+    app::{App, State, Volume},
     cfg::{SourceOptions, UiOptions},
     decoder::Mp3Decoder,
     provider::{radiobrowser::Radiobrowser, tunein::Tunein, Provider},
···
                     .to_str()
                     .unwrap()
                     .to_string(),
+                volume: Volume::default(),
             })
             .unwrap();
         let location = response.headers().get("location");
···
                     SinkCommand::Pause => {
                         sink.pause();
                     }
+                    SinkCommand::SetVolume(volume) => {
+                        sink.set_volume(volume);
+                    }
                 }
             }
             std::thread::sleep(Duration::from_millis(10));
···
     Play,
     /// Pause.
     Pause,
+    /// Set the volume.
+    SetVolume(f32),
 }