gui: MediaKeys, simpler layout, performance fixes

psst-core/src/audio_player.rs

@@ -257,6 +257,7 @@ impl Player {
             PlayerCommand::Preload { item } => self.preload(item),
             PlayerCommand::Pause => self.pause(),
             PlayerCommand::Resume => self.resume(),
+            PlayerCommand::PauseOrResume => self.pause_or_resume(),
             PlayerCommand::Previous => self.previous(),
             PlayerCommand::Next => self.next(),
             PlayerCommand::Stop => self.stop(),
@@ -464,6 +465,16 @@ impl Player {
         }
     }
 
+    fn pause_or_resume(&mut self) {
+        match &self.state {
+            PlayerState::Playing { .. } => self.pause(),
+            PlayerState::Paused { .. } => self.resume(),
+            _ => {
+                // Do nothing.
+            }
+        }
+    }
+
     fn previous(&mut self) {
         if self.is_near_playback_start() {
             self.queue.skip_to_previous();
@@ -537,6 +548,7 @@ pub enum PlayerCommand {
     },
     Pause,
     Resume,
+    PauseOrResume,
     Previous,
     Next,
     Stop,

psst-gui/Cargo.toml

@@ -21,4 +21,5 @@ platform-dirs = "0.3"
 rand = "0.8"
 serde = { version = "1.0", features = ["derive", "rc"] }
 serde_json = "1.0"
+souvlaki = { git = "https://github.com/jpochyla/souvlaki", branch = "macos" }
 ureq = { version = "2.1", features = ["json"] }

psst-gui/src/cmd.rs

@@ -37,7 +37,8 @@ pub const UPDATE_SEARCH_RESULTS: Selector<Result<SearchResults, Error>> =
 
 // Library
 
-pub const LOAD_LIBRARY: Selector = Selector::new("app.load-library");
+pub const LOAD_SAVED_TRACKS: Selector = Selector::new("app.load-saved-tracks");
+pub const LOAD_SAVED_ALBUMS: Selector = Selector::new("app.load-saved-albums");
 pub const LOAD_PLAYLISTS: Selector = Selector::new("app.load-playlists");
 pub const UPDATE_SAVED_ALBUMS: Selector<Result<Vector<Album>, Error>> =
     Selector::new("app.update-saved-albums");

psst-gui/src/controller/nav.rs

@@ -11,6 +11,12 @@ impl NavController {
     fn load_route_data(&self, ctx: &mut EventCtx, data: &mut State) {
         match &data.route {
             Nav::Home => {}
+            Nav::SavedTracks => {
+                ctx.submit_command(cmd::LOAD_SAVED_TRACKS);
+            }
+            Nav::SavedAlbums => {
+                ctx.submit_command(cmd::LOAD_SAVED_ALBUMS);
+            }
             Nav::SearchResults(query) => {
                 ctx.submit_command(cmd::LOAD_SEARCH_RESULTS.with(query.to_owned()));
             }
@@ -23,9 +29,6 @@ impl NavController {
             Nav::PlaylistDetail(link) => {
                 ctx.submit_command(cmd::LOAD_PLAYLIST_DETAIL.with(link.to_owned()));
             }
-            Nav::Library => {
-                ctx.submit_command(cmd::LOAD_LIBRARY);
-            }
         }
     }
 }

psst-gui/src/controller/playback.rs

@@ -18,15 +18,22 @@ use psst_core::{
     session::SessionHandle,
 };
 
+#[cfg(target_os = "macos")]
+use souvlaki::platform::macos::MediaControlsExtMacOs;
+use souvlaki::{MediaControlEvent, MediaControls, MediaMetadata, MediaPlayback};
+
 use crate::{
     cmd,
-    data::{Config, PlaybackOrigin, QueueBehavior, QueuedTrack, State, TrackId},
+    data::{
+        Config, Playback, PlaybackOrigin, PlaybackState, QueueBehavior, QueuedTrack, State, TrackId,
+    },
 };
 
 pub struct PlaybackController {
     sender: Option<Sender<PlayerEvent>>,
     thread: Option<JoinHandle<()>>,
     output_thread: Option<JoinHandle<()>>,
+    media_controls: Option<MediaControls>,
 }
 
 impl PlaybackController {
@@ -35,6 +42,7 @@ impl PlaybackController {
             sender: None,
             thread: None,
             output_thread: None,
+            media_controls: None,
         }
     }
 
@@ -67,9 +75,18 @@ impl PlaybackController {
             output.start_playback(source).expect("Playback failed");
         });
 
+        let mut media_controls = MediaControls::create().unwrap();
+        media_controls.attach({
+            let sender = sender.clone();
+            move |event| {
+                Self::handle_media_control_event(event, &sender);
+            }
+        });
+
         self.sender.replace(sender);
         self.thread.replace(thread);
         self.output_thread.replace(output_thread);
+        self.media_controls.replace(media_controls);
     }
 
     fn service_events(mut player: Player, event_sink: ExtEventSink, widget_id: WidgetId) {
@@ -123,6 +140,35 @@ impl PlaybackController {
         }
     }
 
+    fn handle_media_control_event(event: MediaControlEvent, sender: &Sender<PlayerEvent>) {
+        let cmd = match event {
+            MediaControlEvent::Play => PlayerEvent::Command(PlayerCommand::Resume),
+            MediaControlEvent::Pause => PlayerEvent::Command(PlayerCommand::Pause),
+            MediaControlEvent::Toggle => PlayerEvent::Command(PlayerCommand::PauseOrResume),
+            MediaControlEvent::Next => PlayerEvent::Command(PlayerCommand::Next),
+            MediaControlEvent::Previous => PlayerEvent::Command(PlayerCommand::Previous),
+        };
+        sender.send(cmd).unwrap();
+    }
+
+    fn update_media_controls(&mut self, playback: &Playback) {
+        if let Some(media_controls) = self.media_controls.as_mut() {
+            media_controls.set_playback(match playback.state {
+                PlaybackState::Loading | PlaybackState::Stopped => MediaPlayback::Stopped,
+                PlaybackState::Playing => MediaPlayback::Playing,
+                PlaybackState::Paused => MediaPlayback::Paused,
+            });
+            let title = playback.now_playing.as_ref().map(|c| c.item.name.clone());
+            let album = playback.now_playing.as_ref().map(|c| c.item.album_name());
+            let artist = playback.now_playing.as_ref().map(|c| c.item.artist_name());
+            media_controls.set_metadata(MediaMetadata {
+                title: title.as_deref(),
+                album: album.as_deref(),
+                artist: artist.as_deref(),
+            });
+        }
+    }
+
     fn send(&mut self, event: PlayerEvent) {
         self.sender.as_mut().unwrap().send(event).unwrap();
     }
@@ -198,6 +244,7 @@ where
 
                 if let Some(queued) = data.queued_track(item) {
                     data.loading_playback(queued.track, queued.origin);
+                    self.update_media_controls(&data.playback);
                 } else {
                     log::warn!("loaded item not found in playback queue");
                 }
@@ -209,6 +256,7 @@ where
 
                 if let Some(queued) = data.queued_track(item) {
                     data.start_playback(queued.track, queued.origin, progress.to_owned());
+                    self.update_media_controls(&data.playback);
                 } else {
                     log::warn!("played item not found in playback queue");
                 }
@@ -221,10 +269,12 @@ where
             }
             Event::Command(cmd) if cmd.is(cmd::PLAYBACK_PAUSING) => {
                 data.pause_playback();
+                self.update_media_controls(&data.playback);
                 ctx.set_handled();
             }
             Event::Command(cmd) if cmd.is(cmd::PLAYBACK_RESUMING) => {
                 data.resume_playback();
+                self.update_media_controls(&data.playback);
                 ctx.set_handled();
             }
             Event::Command(cmd) if cmd.is(cmd::PLAYBACK_BLOCKED) => {
@@ -233,11 +283,12 @@ where
             }
             Event::Command(cmd) if cmd.is(cmd::PLAYBACK_STOPPED) => {
                 data.stop_playback();
+                self.update_media_controls(&data.playback);
                 ctx.set_handled();
             }
             Event::Command(cmd) if cmd.is(cmd::UPDATE_AUDIO_ANALYSIS) => {
                 let (track_id, result) = cmd.get_unchecked(cmd::UPDATE_AUDIO_ANALYSIS);
-                data.playback.current.as_mut().map(|current| {
+                data.playback.now_playing.as_mut().map(|current| {
                     if current.analysis.is_deferred(track_id) {
                         current.analysis.resolve_or_reject(result.to_owned());
                     }
@@ -286,7 +337,7 @@ where
             }
             Event::Command(cmd) if cmd.is(cmd::PLAY_SEEK) => {
                 let fraction = cmd.get_unchecked(cmd::PLAY_SEEK);
-                data.playback.current.as_ref().map(|current| {
+                data.playback.now_playing.as_ref().map(|current| {
                     let position =
                         Duration::from_secs_f64(current.item.duration.as_secs_f64() * fraction);
                     self.seek(position);