Started work on Musixmatch fetcher

src/lyrics.rs

@@ -1,4 +1,4 @@
-use log::trace;
+use log::debug;
 use std::{cell::RefCell, collections::HashMap, sync::Arc};
 
 use crate::{
@@ -7,15 +7,14 @@ use crate::{
     queue::Queue,
 };
 
-#[derive(Clone)]
 pub struct LyricsManager {
     queue: Arc<Queue>,
-    fetcher: LyricsFetcher,
+    fetcher: Box<dyn LyricsFetcher>,
     cache: RefCell<HashMap<String, String>>,
 }
 
 impl LyricsManager {
-    pub fn new(queue: Arc<Queue>, fetcher: LyricsFetcher) -> Self {
+    pub fn new(queue: Arc<Queue>, fetcher: Box<dyn LyricsFetcher>) -> Self {
         LyricsManager {
             queue,
             fetcher,
@@ -43,8 +42,8 @@ impl LyricsManager {
             let cache = self.cache.borrow();
 
             if cache.contains_key(track_id) {
-                trace!("Retrieving cached lyrics for {}", track.title);
-                return cache.get(track_id).unwrap().to_owned();
+                debug!("Retrieving cached lyrics for {}", track.title);
+                return cache.get(track_id).unwrap().into();
             }
         }
 

src/lyrics_fetcher.rs

@@ -1,26 +1,58 @@
-use log::trace;
+use std::sync::Arc;
 
-use crate::model::track::Track;
+use log::debug;
 
-#[derive(Clone)]
-pub struct LyricsFetcher {}
+use crate::{config::Config, model::track::Track};
 
-impl LyricsFetcher {
-    pub fn new() -> LyricsFetcher {
-        Self {}
-    }
+pub trait LyricsFetcher {
+    fn fetch(&self, track: &Track) -> String;
+}
+
+pub struct MusixMatchLyricsFetcher {
+    api_key: String,
+}
+
+impl LyricsFetcher for MusixMatchLyricsFetcher {
+    fn fetch(&self, track: &Track) -> String {
+        let track_title = track.title.clone();
+        let track_authors = track.artists.join(", ");
+
+        debug!("Fetching lyrics for {} by {}", track_title, track_authors);
 
-    /// Fetches the lyrics of the given song using the specified lyrics source
-    pub fn fetch(&self, track: &Track) -> String {
-        // std::thread::sleep(std::time::Duration::from_secs(2));
-        trace!("Fetching lyrics for {track}");
+        let client = reqwest::blocking::Client::new();
 
-        format!("Sample Lyrics for {}\n", track.title)
+        let response = client
+            .get("https://api.musixmatch.com/ws/1.1/matcher.lyrics.get")
+            .query(&[
+                ("q_track", track_title.clone()),
+                ("q_artist", track_authors),
+                ("apikey", self.api_key.clone()),
+            ])
+            .send()
+            .unwrap();
+
+        if response.status() != 200 {
+            debug!("Error fetching lyrics for {}", track_title);
+            return format!("Error fetching lyrics for {}", track_title);
+        }
+
+        // Do this since we do not have a specific body type to parse into
+        let text = response.text().unwrap();
+        let json: serde_json::Value = serde_json::from_str(&text).unwrap();
+
+        debug!("Received {:?}", json);
+
+        if json["status_code"] != 200 {
+            debug!("Error fetching lyrics for {}", track_title);
+            return format!("Error fetching lyrics for {}", track_title);
+        }
+
+        json["message"]["body"]["lyrics"]["lyrics_body"].to_string()
     }
 }
 
-impl Default for LyricsFetcher {
-    fn default() -> Self {
-        LyricsFetcher::new() // TODO: check the prefered fetcher
-    }
+pub fn default_fetcher(cfg: Arc<Config>) -> Box<dyn LyricsFetcher> {
+    Box::new(MusixMatchLyricsFetcher {
+        api_key: cfg.values().backend.clone().unwrap(),
+    })
 }

src/ui/lyrics.rs

@@ -60,14 +60,15 @@ impl LyricsView {
         lyrics_view
     }
 
-    // needs to be made public in order to be updated from main's event loop
-    pub fn update_lyrics(&self) {
+    fn update_lyrics(&self) {
+        // TODO: this should be done in a separate thread and the UI should be updated when the lyrics are fetched (or an error occurs)
+
         let current_track = self.manager.get_current_track();
 
         if let Some(track) = current_track {
             let track_title_str = track.clone().title;
 
-            let track_authors_str = track.clone().artists.join(", ");
+            let track_authors_str = track.artists.join(", ");
 
             let track_album_str = match track.clone().album {
                 None => String::default(),