src/mpris/player.rs

@@ -1,13 +1,123 @@
-use crate::ui::Window;
+use crate::{model::Song, ui::Window};
 use adw::prelude::*;
 use gtk::glib::SendWeakRef;
 use std::collections::HashMap;
 use tracing::{event, Level};
 use zbus::object_server::{InterfaceRef, SignalEmitter};
-use zbus::zvariant::{ObjectPath, OwnedValue, Value};
+use zbus::zvariant::{ObjectPath, OwnedObjectPath, OwnedValue, Value};
 
 pub const MICROSECONDS: f64 = 1e6; // in a second
 
+#[derive(Default)]
+pub struct MetadataMap {
+    // mpris
+    track_id: Option<OwnedObjectPath>,
+    length: Option<i64>,
+    art_url: Option<String>,
+    // xesam
+    album: Option<String>,
+    //album_artist: Option<Vec<String>>,
+    artist: Option<Vec<String>>,
+    //as_text: Option<String>,
+    //audio_bpm: Option<i32>,
+    //auto_rating: Option<f32>,
+    //comment: Option<Vec<String>>,
+    //composer: Option<Vec<String>>,
+    content_created: Option<chrono::NaiveDateTime>,
+    //disc_number: Option<i32>,
+    //first_used: Option<chrono::DateTime>,
+    genre: Option<Vec<String>>,
+    //last_used: Option<chrono::DateTime>,
+    //lyricist: Option<Vec<String>>,
+    title: Option<String>,
+    track_number: Option<i32>,
+    //url: Option<String>,
+    //use_count: Option<String>,
+    user_rating: Option<f32>,
+}
+
+impl MetadataMap {
+    pub fn from_playbin_song(song: Option<&Song>) -> Self {
+        song.map(|song| MetadataMap {
+            // use a unique growing counter to identify tracks
+            track_id: Some({
+                format!("/eu/callcc/audrey/Track/{}", song.counter())
+                    .try_into()
+                    .unwrap()
+            }),
+            length: Some(song.duration() * MICROSECONDS as i64),
+            art_url: Some(
+                url::Url::from_file_path(audrey::globals::art_path())
+                    .unwrap()
+                    .to_string(),
+            ),
+            album: Some(song.album()),
+            artist: Some(vec![song.artist()]),
+            //content_created: song.year().map(|year| chrono::NaiveDate::from_yo_opt(year, 1).unwrap()), // FIXME: replace this unwrap with Some(Err) -> None
+            //genre: Some(song.genre.iter().collect()),
+            title: Some(song.title()),
+            //track_number: song.track().map(|u| u as i32),
+            //user_rating: Some(if song.starred().is_none() { 0.0 } else { 1.0 }),
+            ..Default::default()
+        })
+        .unwrap_or_default()
+    }
+
+    fn as_hash_map(&self) -> HashMap<&'static str, OwnedValue> {
+        let mut map = HashMap::new();
+
+        if let Some(track_id) = &self.track_id {
+            map.insert(
+                "mpris:trackid",
+                Value::new(track_id.as_ref()).try_into().unwrap(),
+            );
+        }
+        if let Some(art_url) = &self.art_url {
+            map.insert(
+                "mpris:artUrl",
+                Value::new(art_url.to_string()).try_into().unwrap(),
+            );
+        }
+        if let Some(length) = &self.length {
+            map.insert("mpris:length", Value::new(length).try_into().unwrap());
+        }
+        if let Some(album) = &self.album {
+            map.insert("xesam:album", Value::new(album).try_into().unwrap());
+        }
+        if let Some(artist) = &self.artist {
+            map.insert("xesam:artist", Value::new(artist).try_into().unwrap());
+        }
+        if let Some(content_created) = &self.content_created {
+            map.insert(
+                "xesam:contentCreated",
+                Value::new(content_created.format("%+").to_string())
+                    .try_into()
+                    .unwrap(),
+            );
+        }
+        if let Some(genre) = &self.genre {
+            map.insert("xesam:genre", Value::new(genre).try_into().unwrap());
+        }
+        if let Some(track_number) = self.track_number {
+            map.insert(
+                "xesam:trackNumber",
+                Value::new(track_number).try_into().unwrap(),
+            );
+        }
+        if let Some(title) = &self.title {
+            map.insert("xesam:title", Value::new(title).try_into().unwrap());
+        }
+        if let Some(user_rating) = self.user_rating {
+            map.insert(
+                "xesam:userRating",
+                Value::new(user_rating).try_into().unwrap(),
+            );
+        }
+
+        map
+    }
+}
+
 pub struct Player {
     window: SendWeakRef<Window>,
 }
@@ -154,40 +264,8 @@ impl Player {
 
     #[zbus(property)]
     fn metadata(&self) -> HashMap<&'static str, OwnedValue> {
-        let mut map = HashMap::new();
+        // TODO: no need to MetadataMap wrapper anymore
-
+        MetadataMap::from_playbin_song(self.window().song().as_ref()).as_hash_map()
-        if let Some(song) = self.window().song() {
-            map.insert(
-                "mpris:trackid",
-                Value::new(format!("/eu/callcc/audrey/Track/{}", song.counter()))
-                    .try_into()
-                    .unwrap(),
-            );
-            map.insert(
-                "mpris:length",
-                Value::new((self.window().duration() * MICROSECONDS) as i64)
-                    .try_into()
-                    .unwrap(),
-            );
-            map.insert(
-                "mpris:artUrl",
-                Value::new(
-                    url::Url::from_file_path(audrey::globals::art_path())
-                        .unwrap()
-                        .to_string(),
-                )
-                .try_into()
-                .unwrap(),
-            );
-            map.insert("xesam:album", Value::new(song.album()).try_into().unwrap());
-            map.insert(
-                "xesam:artist",
-                Value::new(vec![song.artist()]).try_into().unwrap(),
-            );
-            map.insert("xesam:title", Value::new(song.title()).try_into().unwrap());
-        }
-
-        map
     }
 
     #[zbus(property)]