Shortcut commands, fixed playlist loading, improved settings menu

Author: 2latemc

package-lock.json

@@ -1,7 +1,7 @@
 {
   "name": "just-another-music-client",
   "private": true,
-  "version": "1.2.7",
+  "version": "1.2.71",
   "type": "module",
   "scripts": {
     "dev": "vite",

package.json

@@ -1,6 +1,6 @@
 [package]
 name = "just-another-music-client"
-version = "1.2.7"
+version = "1.2.71"
 description = "A desktop music client"
 authors = ["you"]
 edition = "2021"
@@ -35,6 +35,9 @@ tauri-plugin-process = "2"
 
 [target.'cfg(target_os = "macos")'.dependencies]
 aes-gcm = "0.10"
+block2 = "0.6.2"
+objc2 = "0.6.4"
+objc2-foundation = { version = "0.3.2", features = ["NSDictionary", "NSObject", "NSString", "NSValue"] }
 rand = "0.8"
 
 [target.'cfg(target_os = "windows")'.dependencies]

src-tauri/Cargo.lock

@@ -57,6 +57,7 @@
       "fetch_audio_bytes",
       "fetch_youtube_music_audio",
       "proxy_http_request",
+      "update_macos_media_session",
       "update_windows_media_session",
       "save_youtube_credentials",
       "load_youtube_credentials",

src-tauri/Cargo.toml

@@ -38,6 +38,8 @@ use rand::{rngs::OsRng, RngCore};
 
 #[cfg(target_os = "windows")]
 mod windows_media;
+#[cfg(target_os = "macos")]
+mod macos_media;
 
 mod discord_rpc;
 
@@ -1884,6 +1886,8 @@ pub fn run() {
 
     #[cfg(target_os = "windows")]
     let builder = builder.manage(windows_media::WindowsMediaSession::new());
+    #[cfg(target_os = "macos")]
+    let builder = builder.manage(macos_media::MacosMediaSession::new());
 
     builder
         .setup(|app| {
@@ -1957,6 +1961,8 @@ pub fn run() {
             cache_clear,
             discord_rpc_update,
             discord_rpc_clear,
+            #[cfg(target_os = "macos")]
+            macos_media::update_macos_media_session,
             #[cfg(target_os = "windows")]
             windows_media::update_windows_media_session
         ])

src-tauri/capabilities/default.json

@@ -0,0 +1,191 @@
+use block2::RcBlock;
+use objc2::rc::Retained;
+use objc2::runtime::{AnyClass, AnyObject};
+use objc2::{class, msg_send};
+use objc2_foundation::{NSMutableDictionary, NSNumber, NSString};
+use serde::Deserialize;
+use std::sync::Mutex;
+use tauri::{AppHandle, Emitter};
+
+const MEDIA_CONTROL_EVENT: &str = "macos-media-control";
+const COMMAND_SUCCESS: isize = 0;
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MediaSessionUpdate {
+    title: Option<String>,
+    artist: Option<String>,
+    artwork_url: Option<String>,
+    status: String,
+    duration_sec: Option<f64>,
+    position_sec: Option<f64>,
+}
+
+pub struct MacosMediaSession(Mutex<bool>);
+
+unsafe impl Send for MacosMediaSession {}
+unsafe impl Sync for MacosMediaSession {}
+
+#[link(name = "MediaPlayer", kind = "framework")]
+extern "C" {
+    static MPMediaItemPropertyTitle: *const NSString;
+    static MPMediaItemPropertyArtist: *const NSString;
+    static MPMediaItemPropertyPlaybackDuration: *const NSString;
+    static MPNowPlayingInfoPropertyElapsedPlaybackTime: *const NSString;
+    static MPNowPlayingInfoPropertyPlaybackRate: *const NSString;
+}
+
+impl MacosMediaSession {
+    pub fn new() -> Self {
+        Self(Mutex::new(false))
+    }
+
+    fn ensure_handlers(&self, app: &AppHandle) -> Result<(), String> {
+        let mut initialized = self.0.lock().map_err(|error| error.to_string())?;
+        if *initialized {
+            return Ok(());
+        }
+
+        install_remote_command_handler(app, "playCommand", "play")?;
+        install_remote_command_handler(app, "pauseCommand", "pause")?;
+        install_remote_command_handler(app, "nextTrackCommand", "next")?;
+        install_remote_command_handler(app, "previousTrackCommand", "previous")?;
+        *initialized = true;
+        Ok(())
+    }
+
+    fn update(&self, app: &AppHandle, update: MediaSessionUpdate) -> Result<(), String> {
+        self.ensure_handlers(app)?;
+        set_now_playing_info(update);
+        Ok(())
+    }
+}
+
+fn command_center() -> *mut AnyObject {
+    let class: &AnyClass = class!(MPRemoteCommandCenter);
+    unsafe { msg_send![class, sharedCommandCenter] }
+}
+
+fn now_playing_info_center() -> *mut AnyObject {
+    let class: &AnyClass = class!(MPNowPlayingInfoCenter);
+    unsafe { msg_send![class, defaultCenter] }
+}
+
+fn install_remote_command_handler(
+    app: &AppHandle,
+    command_selector: &str,
+    action: &'static str,
+) -> Result<(), String> {
+    let center = command_center();
+    if center.is_null() {
+        return Err("macOS remote command center unavailable".to_string());
+    }
+
+    let command: *mut AnyObject = unsafe {
+        match command_selector {
+            "playCommand" => msg_send![center, playCommand],
+            "pauseCommand" => msg_send![center, pauseCommand],
+            "nextTrackCommand" => msg_send![center, nextTrackCommand],
+            "previousTrackCommand" => msg_send![center, previousTrackCommand],
+            _ => return Err(format!("unsupported macOS media command: {command_selector}")),
+        }
+    };
+
+    if command.is_null() {
+        return Err(format!("macOS media command unavailable: {command_selector}"));
+    }
+
+    let app = app.clone();
+    let block = RcBlock::new(move |_event: *mut AnyObject| {
+        let _ = app.emit(MEDIA_CONTROL_EVENT, action);
+        COMMAND_SUCCESS
+    });
+
+    unsafe {
+        let _: () = msg_send![command, setEnabled: true];
+        let _: *mut AnyObject = msg_send![command, addTargetWithHandler: &*block];
+    }
+
+    std::mem::forget(block);
+    Ok(())
+}
+
+fn set_now_playing_info(update: MediaSessionUpdate) {
+    let center = now_playing_info_center();
+    if center.is_null() {
+        return;
+    }
+
+    let Some(title) = update.title else {
+        let nil_info: *mut AnyObject = std::ptr::null_mut();
+        unsafe {
+            let _: () = msg_send![center, setNowPlayingInfo: nil_info];
+        }
+        return;
+    };
+
+    let info = NSMutableDictionary::<NSString, AnyObject>::dictionaryWithCapacity(6);
+    insert_string(&info, unsafe { &*MPMediaItemPropertyTitle }, &title);
+
+    if let Some(artist) = update.artist {
+        insert_string(&info, unsafe { &*MPMediaItemPropertyArtist }, &artist);
+    }
+
+    if let Some(duration) = update.duration_sec.filter(|duration| duration.is_finite()) {
+        insert_number(
+            &info,
+            unsafe { &*MPMediaItemPropertyPlaybackDuration },
+            duration.max(0.0),
+        );
+    }
+
+    if let Some(position) = update.position_sec.filter(|position| position.is_finite()) {
+        insert_number(
+            &info,
+            unsafe { &*MPNowPlayingInfoPropertyElapsedPlaybackTime },
+            position.max(0.0),
+        );
+    }
+
+    let playback_rate = if update.status == "playing" { 1.0 } else { 0.0 };
+    insert_number(
+        &info,
+        unsafe { &*MPNowPlayingInfoPropertyPlaybackRate },
+        playback_rate,
+    );
+
+    let _ = update.artwork_url;
+
+    unsafe {
+        let _: () = msg_send![center, setNowPlayingInfo: &*info];
+    }
+}
+
+fn insert_string(
+    info: &NSMutableDictionary<NSString, AnyObject>,
+    key: &NSString,
+    value: &str,
+) {
+    let value = NSString::from_str(value);
+    let value: Retained<AnyObject> = value.into();
+    info.insert(key, &value);
+}
+
+fn insert_number(
+    info: &NSMutableDictionary<NSString, AnyObject>,
+    key: &NSString,
+    value: f64,
+) {
+    let value = NSNumber::new_f64(value);
+    let value: Retained<AnyObject> = value.into();
+    info.insert(key, &value);
+}
+
+#[tauri::command]
+pub fn update_macos_media_session(
+    app: AppHandle,
+    state: tauri::State<'_, MacosMediaSession>,
+    update: MediaSessionUpdate,
+) -> Result<(), String> {
+    state.update(&app, update)
+}

src-tauri/src/lib.rs

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Just Another Music Client",
-  "version": "1.2.7",
+  "version": "1.2.71",
   "identifier": "com.justanothermusicclient.desktop",
   "build": {
     "beforeDevCommand": "npm run dev",

src-tauri/src/macos_media.rs

@@ -6,6 +6,7 @@ import type {
   Lyrics,
   Playlist,
   SearchResults,
+  TrackPage,
   Track,
 } from "./types";
 
@@ -31,6 +32,11 @@ export abstract class DataSource {
   getArtist?(artistId: string, onUpdate?: (artist: ArtistPage) => void): Promise<ArtistPage>;
   setArtistSubscribed?(artistId: string, subscribed: boolean): Promise<void>;
   getPlaylistTracks?(playlist: Playlist, onUpdate?: (tracks: Track[]) => void): Promise<Track[]>;
+  getPlaylistTrackPage?(
+    playlist: Playlist,
+    pageKey?: string,
+    onUpdate?: (page: TrackPage) => void,
+  ): Promise<TrackPage>;
   setPlaylistSaved?(playlist: Playlist, saved: boolean): Promise<void>;
   addTrackToPlaylist?(
     track: Track,

src-tauri/tauri.conf.json

@@ -74,6 +74,12 @@ export interface SearchResults {
   playlists: Playlist[];
 }
 
+export interface TrackPage {
+  tracks: Track[];
+  nextPageKey?: string;
+  hasMore: boolean;
+}
+
 export interface AuthPrompt {
   verificationUrl: string;
   userCode: string;