fix: Now playing for listenbrainz

scrobbling/examples/scrobble_random.rs

@@ -13,7 +13,7 @@ async fn main() -> Result<()> {
         .about("Test scrobbling to Last.fm, Libre.fm or ListenBrainz")
         .arg(
             Arg::new("service")
-                .help("The service to use (lastfm or librefm)")
+                .help("The service to use (lastfm, librefm, or listenbrainz)")
                 .required(true)
                 .index(1),
         )
@@ -39,6 +39,12 @@ async fn main() -> Result<()> {
                 .help("API Secret for Last.fm (ignored for Libre.fm)")
                 .long("api_secret"),
         )
+        .arg(
+            Arg::new("action")
+                .help("Action to perform (nowplaying or scrobble)")
+                .required(true)
+                .index(4),
+        )
         .get_matches();
 
     let binding = "".to_string();
@@ -47,6 +53,7 @@ async fn main() -> Result<()> {
     let api_secret = matches.get_one::<String>("api_secret").unwrap_or(&binding);
     let username = matches.get_one::<String>("username").unwrap();
     let password = matches.get_one::<String>("password").unwrap();
+    let action = matches.get_one::<String>("action").unwrap();
 
     let track = ScrobblingTrack {
         artist: "Random Artist".to_string(),
@@ -61,17 +68,29 @@ async fn main() -> Result<()> {
         "lastfm" => {
             let mut client = LastFmClient::new(api_key.to_string(), api_secret.to_string())?;
             client.authenticate(username, password).await?;
-            client.scrobble(&track).await?
+            if action == "nowplaying" {
+                client.update_now_playing(&track).await?
+            } else {
+                client.scrobble(&track).await?
+            }
         }
         "librefm" => {
             let mut client = LibreFmClient::new()?;
             client.authenticate(username, password).await?;
-            client.scrobble(&track).await?
+            if action == "nowplaying" {
+                client.update_now_playing(&track).await?
+            } else {
+                client.scrobble(&track).await?
+            }
         }
         "listenbrainz" => {
             let mut client = ListenBrainzClient::new()?;
             client.authenticate(username, password).await?;
-            client.scrobble(&track).await?
+            if action == "nowplaying" {
+                client.update_now_playing(&track).await?
+            } else {
+                client.scrobble(&track).await?
+            }
         }
         _ => {
             eprintln!("Unsupported service: {}", service);

scrobbling/src/listen_brainz.rs

@@ -9,6 +9,38 @@ use std::{
 
 use crate::{ScrobblingClient, ScrobblingTrack};
 
+impl From<&ScrobblingTrack> for Value {
+    fn from(track: &ScrobblingTrack) -> Self {
+        let mut track_metadata: Map<String, Value> = Map::new();
+        track_metadata.insert(
+            "artist_name".to_string(),
+            Value::String(track.artist.clone()),
+        );
+        track_metadata.insert("track_name".to_string(), Value::String(track.track.clone()));
+
+        if let Some(album) = &track.album {
+            track_metadata.insert("release_name".to_string(), Value::String(album.clone()));
+        }
+
+        let mut additional_info = Map::new();
+        if let Some(duration) = track.duration {
+            additional_info.insert("duration".to_string(), Value::Number(duration.into()));
+        }
+
+        additional_info.insert(
+            "media_player".to_string(),
+            Value::String("rune".to_string()),
+        );
+
+        track_metadata.insert(
+            "additional_info".to_string(),
+            Value::Object(additional_info),
+        );
+
+        Value::Object(track_metadata)
+    }
+}
+
 #[derive(Clone)]
 pub struct ListenBrainzClient {
     client: Client,
@@ -85,37 +117,23 @@ impl ScrobblingClient for ListenBrainzClient {
     }
 
     async fn update_now_playing(&self, track: &ScrobblingTrack) -> Result<Response> {
+        let track_metadata: Value = track.into();
+
+        let mut payload = Map::new();
+        payload.insert("track_metadata".to_string(), track_metadata);
+
         let mut body = HashMap::new();
         body.insert(
             "listen_type",
             serde_json::Value::String("playing_now".to_string()),
         );
-        body.insert("payload", serde_json::json!([track]));
+        body.insert("payload", Value::Array(vec![Value::Object(payload)]));
 
         self.post_request("1/submit-listens", &body).await
     }
 
     async fn scrobble(&self, track: &ScrobblingTrack) -> Result<Response> {
-        let mut track_metadata = Map::new();
-        track_metadata.insert(
-            "artist_name".to_string(),
-            Value::String(track.artist.clone()),
-        );
-        track_metadata.insert("track_name".to_string(), Value::String(track.track.clone()));
-
-        if let Some(album) = &track.album {
-            track_metadata.insert("release_name".to_string(), Value::String(album.clone()));
-        }
-
-        let mut additional_info = Map::new();
-        if let Some(duration) = track.duration {
-            additional_info.insert("duration".to_string(), Value::Number(duration.into()));
-        }
-
-        additional_info.insert(
-            "media_player".to_string(),
-            Value::String("rune".to_string()),
-        );
+        let track_metadata: Value = track.into();
 
         let mut payload = Map::new();
         let timestamp = track.timestamp.unwrap_or_else(|| {
@@ -125,7 +143,7 @@ impl ScrobblingClient for ListenBrainzClient {
                 .as_secs()
         });
         payload.insert("listened_at".to_string(), Value::Number(timestamp.into()));
-        payload.insert("track_metadata".to_string(), Value::Object(track_metadata));
+        payload.insert("track_metadata".to_string(), track_metadata);
 
         let mut body = HashMap::new();
         body.insert("listen_type", Value::String("single".to_string()));