feat: stream currently playing + volume + toggle pause + seek position

src/music/player.rs

@@ -1,28 +1,40 @@
 use std::{
     fs,
-    io::{BufReader, Cursor}, path::Path,
+    io::{BufReader, Cursor},
+    path::Path,
+    time::Duration,
 };
 
-use rodio::{Decoder, Sink, Source};
+use rodio::{Decoder, Sink};
+
+use crate::{database::tracks::Track, proto::player::PlayerStatus};
 
 pub struct AudioPlayer {
-    pub sink: Sink,
+    sink: Sink,
+    currently_playing: Option<Track>,
 }
 
 impl AudioPlayer {
     pub fn new(sink: Sink) -> Self {
+        sink.set_volume(0.5);
+
         Self {
-            sink
+            sink,
+            currently_playing: None,
         }
     }
 
-    pub fn play_song<P>(&mut self, path: P) -> Result<(), Box<dyn std::error::Error>> where P: AsRef<Path> {
+    pub fn play_track<P>(&mut self, track: Track, path: P) -> Result<(), Box<dyn std::error::Error>>
+    where
+        P: AsRef<Path>,
+    {
         self.sink.clear();
 
         let file = BufReader::new(Cursor::new(fs::read(path)?));
 
-        let source = Decoder::new(file)?.amplify(0.2);
+        let source = Decoder::new(file)?;
 
+        self.currently_playing = Some(track);
         self.sink.append(source);
 
         self.sink.play();
@@ -30,11 +42,74 @@ impl AudioPlayer {
         Ok(())
     }
 
-    pub fn resume(&mut self) {
+    pub fn resume(&self) {
         self.sink.play();
     }
 
-    pub fn pause(&mut self) {
+    pub fn pause(&self) {
         self.sink.pause();
     }
+
+    /// Toggles the player's pause state and returns the new value
+    pub fn toggle_pause(&self) -> bool {
+        if self.is_paused() {
+            self.resume();
+            false
+        } else {
+            self.pause();
+            true
+        }
+    }
+
+    pub fn volume(&self) -> f32 {
+        self.sink.volume()
+    }
+
+    pub fn set_volume(&self, value: f32) {
+        self.sink.set_volume(value);
+    }
+
+    pub fn position(&self) -> u128 {
+        self.sink.get_pos().as_millis()
+    }
+
+    pub fn set_position(&self, position: u64) {
+        let _ = self.sink.try_seek(Duration::from_millis(position));
+    }
+
+    pub fn is_paused(&self) -> bool {
+        self.sink.is_paused()
+    }
+
+    pub fn currently_playing(&self) -> Option<Track> {
+        self.currently_playing.clone()
+    }
+
+    pub fn get_snapshot(&self) -> StatusSnapshot {
+        StatusSnapshot {
+            volume: self.volume(),
+            position: self.position(),
+            is_paused: self.is_paused(),
+            currently_playing: self.currently_playing(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct StatusSnapshot {
+    pub volume: f32,
+    pub position: u128,
+    pub is_paused: bool,
+    pub currently_playing: Option<Track>,
+}
+
+impl Into<PlayerStatus> for StatusSnapshot {
+    fn into(self) -> PlayerStatus {
+        PlayerStatus {
+            volume: self.volume,
+            is_paused: self.is_paused,
+            progress: self.position as u64,
+            currently_playing: self.currently_playing.clone().map(|t| t.into()),
+        }
+    }
 }