api: implement GetTracklistTrack

readme: update usage instructions

update README.md

Author: tsirysndr

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "music-player"
-version = "0.1.1"
+version = "0.1.2"
 edition = "2021"
 repository = "https://github.com/tsirysndr/music-player"
 license = "MIT"
@@ -20,11 +20,11 @@ path = "src/main.rs"
 
 [dependencies.music-player-server]
 path = "server"
-version = "0.1.0"
+version = "0.1.2"
 
 [dependencies.music-player-playback]
 path = "playback"
-version = "0.1.1"
+version = "0.1.2"
 
 [dependencies.music-player-scanner]
 path = "scanner"
@@ -52,7 +52,7 @@ version = "0.1.0"
 
 [dependencies.music-player-tracklist]
 path = "tracklist"
-version = "0.1.0"
+version = "0.1.1"
 
 [dependencies.sea-orm-migration]
 version = "^0.9.0"

Cargo.toml

@@ -42,11 +42,17 @@ Note: Don't forget to add `~/.cargo/bin` to your `PATH` environment variable.
 ### macOS/Linux
 
 ```bash
-$ brew install tsirysndr/tap/musicplayer
+brew install tsirysndr/tap/musicplayer
 ```
 
 Or download the latest release for your platform [here](https://github.com/tsirysndr/music-player/releases).
 
+## Start the server
+
+```bash
+music-player
+```
+
 ## Usage
 
 ```

README.md

@@ -1,6 +1,6 @@
 [package]
 name = "music-player-playback"
-version = "0.1.1"
+version = "0.1.2"
 edition = "2021"
 repository = "https://github.com/tsirysndr/music-player"
 license = "MIT"
@@ -33,3 +33,4 @@ thiserror = "1.0.34"
 tokio = { version = "1.21.0", features = ["full"] }
 zerocopy = "0.6.1"
 owo-colors = "3.5.0"
+async-trait = "0.1.57"

playback/Cargo.toml

@@ -1,3 +1,4 @@
+use async_trait::async_trait;
 use futures_util::{future::FusedFuture, Future};
 use log::{error, trace};
 use music_player_entity::track::Model as Track;
@@ -15,7 +16,10 @@ use std::{
     thread,
 };
 use symphonia::core::{errors::Error, io::MediaSourceStream, probe::Hint};
-use tokio::sync::mpsc;
+use tokio::{
+    runtime::Runtime,
+    sync::mpsc::{self, UnboundedReceiver},
+};
 
 use crate::{
     audio_backend::Sink,
@@ -30,6 +34,7 @@ const PRELOAD_NEXT_TRACK_BEFORE_END: u64 = 30000;
 
 pub type PlayerResult = Result<(), Error>;
 
+#[async_trait]
 pub trait PlayerEngine: Send + Sync {
     fn load(&mut self, track_id: &str, _start_playing: bool, _position_ms: u32);
     fn load_tracklist(&mut self, tracks: Vec<Track>);
@@ -40,6 +45,11 @@ pub trait PlayerEngine: Send + Sync {
     fn seek(&self, position_ms: u32);
     fn next(&self);
     fn previous(&self);
+    fn clear(&self);
+    async fn get_tracks(&self) -> (Vec<Track>, Vec<Track>);
+    async fn wait_for_tracklist(
+        mut event: UnboundedReceiver<PlayerEvent>,
+    ) -> (Vec<Track>, Vec<Track>);
 }
 
 #[derive(Clone)]
@@ -115,6 +125,7 @@ impl Player {
     }
 }
 
+#[async_trait]
 impl PlayerEngine for Player {
     fn load(&mut self, track_id: &str, _start_playing: bool, _position_ms: u32) {
         self.command(PlayerCommand::Load {
@@ -153,6 +164,32 @@ impl PlayerEngine for Player {
     fn previous(&self) {
         self.command(PlayerCommand::Previous);
     }
+
+    fn clear(&self) {
+        self.command(PlayerCommand::Clear);
+    }
+
+    async fn get_tracks(&self) -> (Vec<Track>, Vec<Track>) {
+        let channel = self.get_player_event_channel();
+        let handle = thread::spawn(move || {
+            Runtime::new()
+                .unwrap()
+                .block_on(Self::wait_for_tracklist(channel))
+        });
+        self.command(PlayerCommand::GetTracks);
+        handle.join().unwrap()
+    }
+
+    async fn wait_for_tracklist(
+        mut channel: UnboundedReceiver<PlayerEvent>,
+    ) -> (Vec<Track>, Vec<Track>) {
+        while let Some(event) = channel.recv().await {
+            if matches!(event, PlayerEvent::TracklistUpdated { .. }) {
+                return event.get_tracks().unwrap();
+            }
+        }
+        (vec![], vec![])
+    }
 }
 
 #[derive(PartialEq, Eq, Debug, Clone, Copy)]
@@ -303,6 +340,8 @@ impl PlayerInternal {
             PlayerCommand::AddEventSender(sender) => self.event_senders.push(sender),
             PlayerCommand::Next => self.handle_next(),
             PlayerCommand::Previous => self.handle_previous(),
+            PlayerCommand::Clear => self.handle_clear(),
+            PlayerCommand::GetTracks => self.handle_get_tracks(),
         }
         Ok(())
     }
@@ -430,6 +469,15 @@ impl PlayerInternal {
             self.handle_command_load(&self.tracklist.current_track().unwrap().uri);
         }
     }
+
+    fn handle_clear(&mut self) {
+        self.tracklist.clear();
+    }
+
+    fn handle_get_tracks(&mut self) {
+        let tracks = self.tracklist.tracks();
+        self.send_event(PlayerEvent::TracklistUpdated { tracks });
+    }
 }
 
 struct PlayerLoadedTrackData {
@@ -565,6 +613,8 @@ enum PlayerCommand {
     Next,
     Previous,
     AddEventSender(mpsc::UnboundedSender<PlayerEvent>),
+    Clear,
+    GetTracks,
 }
 
 #[derive(Debug, Clone)]
@@ -579,6 +629,7 @@ pub enum PlayerEvent {
     EndOfTrack { is_last_track: bool },
     VolumeSet { volume: u16 },
     Error { track_id: String, error: String },
+    TracklistUpdated { tracks: (Vec<Track>, Vec<Track>) },
 }
 
 impl PlayerEvent {
@@ -589,6 +640,14 @@ impl PlayerEvent {
             _ => None,
         }
     }
+
+    pub fn get_tracks(&self) -> Option<(Vec<Track>, Vec<Track>)> {
+        use PlayerEvent::*;
+        match self {
+            TracklistUpdated { tracks, .. } => Some(tracks.clone()),
+            _ => None,
+        }
+    }
 }
 
 pub type PlayerEventChannel = mpsc::UnboundedReceiver<PlayerEvent>;

playback/src/player.rs

@@ -1,6 +1,6 @@
 [package]
 name = "music-player-server"
-version = "0.1.1"
+version = "0.1.2"
 edition = "2021"
 repository = "https://github.com/tsirysndr/music-player"
 license = "MIT"

server/Cargo.toml

@@ -36,7 +36,10 @@ message SetRepeatResponse {}
 
 message ShuffleResponse {}
 
-message GetTracklistTracksResponse {}
+message GetTracklistTracksResponse {
+  repeated metadata.v1alpha1.Track next_tracks = 1;
+  repeated metadata.v1alpha1.Track previous_tracks = 2;
+}
 
 message GetRandomRequest {}
 

server/proto/music/v1alpha1/tracklist.proto

@@ -1,19 +1,22 @@
 use std::sync::Arc;
 
-use music_player_entity::{track, tracklist};
+use music_player_entity::track;
 use music_player_playback::player::{Player, PlayerEngine};
 use music_player_storage::Database;
-use sea_orm::EntityTrait;
 use tokio::sync::Mutex;
 
-use crate::api::v1alpha1::{
-    tracklist_service_server::TracklistService, AddTrackRequest, AddTrackResponse,
-    ClearTracklistRequest, ClearTracklistResponse, FilterTracklistRequest, FilterTracklistResponse,
-    GetNextTrackRequest, GetNextTrackResponse, GetPreviousTrackRequest, GetPreviousTrackResponse,
-    GetRandomRequest, GetRandomResponse, GetRepeatRequest, GetRepeatResponse, GetSingleRequest,
-    GetSingleResponse, GetTracklistTracksRequest, GetTracklistTracksResponse, PlayNextRequest,
-    PlayNextResponse, RemoveTrackRequest, RemoveTrackResponse, SetRepeatRequest, SetRepeatResponse,
-    ShuffleRequest, ShuffleResponse,
+use crate::{
+    api::v1alpha1::{
+        tracklist_service_server::TracklistService, AddTrackRequest, AddTrackResponse,
+        ClearTracklistRequest, ClearTracklistResponse, FilterTracklistRequest,
+        FilterTracklistResponse, GetNextTrackRequest, GetNextTrackResponse,
+        GetPreviousTrackRequest, GetPreviousTrackResponse, GetRandomRequest, GetRandomResponse,
+        GetRepeatRequest, GetRepeatResponse, GetSingleRequest, GetSingleResponse,
+        GetTracklistTracksRequest, GetTracklistTracksResponse, PlayNextRequest, PlayNextResponse,
+        RemoveTrackRequest, RemoveTrackResponse, SetRepeatRequest, SetRepeatResponse,
+        ShuffleRequest, ShuffleResponse,
+    },
+    metadata::v1alpha1::{Album, Artist, Track},
 };
 
 pub struct Tracklist {
@@ -34,8 +37,16 @@ impl TracklistService for Tracklist {
         request: tonic::Request<AddTrackRequest>,
     ) -> Result<tonic::Response<AddTrackResponse>, tonic::Status> {
         let song = request.get_ref().track.as_ref().unwrap();
+        let artist = match song.artists.len() {
+            0 => "Unknown Artist".to_string(),
+            _ => song.artists[0].name.clone(),
+        };
         self.player.lock().await.load_tracklist(vec![track::Model {
+            id: song.id.clone(),
             uri: song.uri.clone(),
+            title: song.title.clone(),
+            album: song.album.clone().unwrap_or_default().title,
+            artist,
             ..Default::default()
         }]);
         let response = AddTrackResponse {};
@@ -46,6 +57,7 @@ impl TracklistService for Tracklist {
         &self,
         _request: tonic::Request<ClearTracklistRequest>,
     ) -> Result<tonic::Response<ClearTracklistResponse>, tonic::Status> {
+        self.player.lock().await.clear();
         let response = ClearTracklistResponse {};
         Ok(tonic::Response::new(response))
     }
@@ -126,12 +138,50 @@ impl TracklistService for Tracklist {
         &self,
         _request: tonic::Request<GetTracklistTracksRequest>,
     ) -> Result<tonic::Response<GetTracklistTracksResponse>, tonic::Status> {
-        tracklist::Entity::find()
-            .all(self.db.get_connection())
-            .await
-            .map_err(|e| tonic::Status::internal(e.to_string()))?;
-
-        let response = GetTracklistTracksResponse {};
+        let (previous_tracks, next_tracks) = self.player.lock().await.get_tracks().await;
+
+        let response = GetTracklistTracksResponse {
+            next_tracks: next_tracks
+                .into_iter()
+                .map(|track| Track {
+                    id: track.id,
+                    title: track.title,
+                    uri: track.uri,
+                    disc_number: format!("{}", track.track.unwrap_or(0)).parse().unwrap(),
+                    artists: vec![Artist {
+                        name: track.artist,
+                        ..Default::default()
+                    }],
+                    album: Some(Album {
+                        // id: track.album_id.unwrap(),
+                        title: track.album,
+                        year: format!("{}", track.year.unwrap_or(0)).parse().unwrap(),
+                        ..Default::default()
+                    }),
+                    ..Default::default()
+                })
+                .collect(),
+            previous_tracks: previous_tracks
+                .into_iter()
+                .map(|track| Track {
+                    id: track.id,
+                    title: track.title,
+                    uri: track.uri,
+                    disc_number: format!("{}", track.track.unwrap_or(0)).parse().unwrap(),
+                    artists: vec![Artist {
+                        name: track.artist,
+                        ..Default::default()
+                    }],
+                    album: Some(Album {
+                        // id: track.album_id.unwrap(),
+                        title: track.album,
+                        year: format!("{}", track.year.unwrap_or(0)).parse().unwrap(),
+                        ..Default::default()
+                    }),
+                    ..Default::default()
+                })
+                .collect(),
+        };
         Ok(tonic::Response::new(response))
     }
 

server/src/tracklist.rs

@@ -1,6 +1,6 @@
 [package]
 name = "music-player-tracklist"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 repository = "https://github.com/tsirysndr/music-player"
 license = "MIT"