Dry up some of the code in app

Author: Ross

src/app.rs

@@ -0,0 +1,103 @@
+use std::io::Cursor;
+
+use image::DynamicImage;
+use ratatui_image::picker::Picker;
+use anyhow::Result;
+
+use crate::app::Track;
+
+use super::App;
+impl App {
+    pub fn sanitize_album_name(&self, name: &str) -> String {
+        name.replace(|c: char| !c.is_alphanumeric() && c != '-', "_")
+            .to_lowercase()
+            .chars()
+            .fold(String::new(), |mut acc, c| {
+                if c == '_' && acc.ends_with('_') {
+                    acc
+                } else {
+                    acc.push(c);
+                    acc
+                }
+            })
+    }
+    pub async fn load_cover_art_for_track(&mut self, track: &Track) {
+        self.cover_art_protocol = None;
+        let album = self.sanitize_album_name(&track.album);
+
+        let url = match &track.cover_art {
+            Some(url) if !url.is_empty() => url,
+            _ => return,
+        };
+        let mut cache_path = std::env::temp_dir();
+        cache_path.push("sonicrust");
+        cache_path.push(format!("cover_{}.jpg", album));
+        let img_result = if cache_path.exists() {
+            log::debug!("Using cached cover_art for {}", album);
+            image::open(&cache_path)
+                .map_err(|e| Box::new(e) as Box<dyn std::error::Error + Send + Sync>)
+        } else {
+            self.fetch_cover_art(url).await.inspect(|img| {
+                let _ = std::fs::create_dir_all(cache_path.parent().unwrap());
+                let _ = img.save(&cache_path);
+            })
+        };
+        match img_result {
+            Ok(img) => match Picker::from_query_stdio() {
+                Ok(picker) => {
+                    self.cover_art_protocol = Some(picker.new_resize_protocol(img));
+                }
+                Err(e) => log::debug!("Failed ot create image picker: {}", e),
+            },
+            Err(e) => eprintln!("failed to load cover art: {}", e),
+        }
+    }
+    pub async fn fetch_and_cache_image(&self, url: &str, track_album: &str) -> Result<String> {
+        log::debug!("Currently fetching cover are for album: {}", track_album,);
+        let mut path = std::env::temp_dir();
+        path.push("sonicrust");
+        std::fs::create_dir_all(&path).map_err(|e| anyhow::anyhow!(e))?;
+        path.push(format!("cover_{}.jpg", track_album));
+        if path.exists() {
+            log::debug!("Using cached cover art for {}", track_album,);
+            return Ok(path.to_string_lossy().to_string());
+        }
+        log::debug!("fetching cover art for {}", track_album);
+        let img = self
+            .fetch_cover_art(url)
+            .await
+            .map_err(|e| anyhow::anyhow!("Failed to fetch cover art: {}", e))?;
+        img.save(&path).map_err(|e| anyhow::anyhow!(e))?;
+
+        Ok(path.to_string_lossy().to_string())
+    }
+
+    async fn fetch_cover_art(
+        &self,
+        url: &str,
+    ) -> Result<DynamicImage, Box<dyn std::error::Error + Send + Sync>> {
+        let url = url.to_string();
+        tokio::task::spawn_blocking(move || {
+            let res = reqwest::blocking::get(&url)?;
+            if !res.status().is_success() {
+                return Err(format!("HTTP error: {}", res.status()).into());
+            }
+            let bytes = res.bytes()?;
+            if bytes.is_empty() {
+                return Err("Empty response when fetching cover art".into());
+            }
+            let format = image::guess_format(&bytes).unwrap_or(image::ImageFormat::Jpeg);
+            let img = image::load(Cursor::new(bytes), format)?;
+            Ok(img)
+        })
+        .await?
+    }
+    pub fn _clear_cover_art_cache() -> Result<()> {
+        let mut path = std::env::temp_dir();
+        path.push("sonicrust");
+        if path.exists() {
+            std::fs::remove_dir_all(&path)?;
+        }
+        Ok(())
+    }
+}

src/app/cover_art.rs

@@ -0,0 +1,73 @@
+use mpris_server::{PlaybackStatus, Property};
+use notify_rust::{Hint, Notification};
+use anyhow::Result;
+
+use crate::app::Track;
+
+use super::App;
+impl App {
+    pub async fn sync_mpris(&mut self) {
+        let status = if self.is_playing {
+            PlaybackStatus::Playing
+        } else if self.current_track.is_some() {
+            PlaybackStatus::Paused
+        } else {
+            PlaybackStatus::Stopped
+        };
+
+        let can_next = self.queue_tab.index < self.queue_tab.len().saturating_sub(1);
+        let can_prev = self.queue_tab.index > 0;
+        let current_pos = self.player.lock().await.get_position();
+
+        if let Ok(mut state) = self.shared_state.write() {
+            state.status = status;
+            state.metadata = self.metadata.clone();
+            state.can_go_next = can_next;
+            state.can_go_previous = can_prev;
+            state.position = current_pos;
+        }
+
+        let _ = self
+            .mpris
+            .properties_changed([
+                Property::PlaybackStatus(status),
+                Property::Metadata(self.metadata.clone()),
+                Property::CanGoNext(can_next),
+                Property::CanGoPrevious(can_prev),
+            ])
+            .await;
+    }
+
+    pub async fn notify_now_playing(&mut self, track: &Track) -> Result<()> {
+        let mut notif = Notification::new()
+            .appname("Sonicrust")
+            .summary("Now playing")
+            .body(format!("{} - {}", track.title, track.artist).as_str())
+            .finalize();
+        if let Some(url) = &track.cover_art
+            && !url.is_empty()
+        {
+            let album = self.sanitize_album_name(&track.album);
+
+            match self.fetch_and_cache_image(url, &album).await {
+                Ok(path) => {
+                    notif.hint(Hint::ImagePath(path));
+                }
+                Err(e) => {
+                    log::debug!("Could not load cover art for notification: {}", e);
+                }
+            }
+        }
+        let _ = notif.show();
+        Ok(())
+    }
+    pub async fn update_mpris_position(&mut self) -> Result<()> {
+        if self.is_playing {
+            let current_pos = self.player.lock().await.get_position();
+            if let Ok(mut state) = self.shared_state.write() {
+                state.position = current_pos;
+            }
+        }
+        Ok(())
+    }
+}

src/app/input.rs

@@ -0,0 +1,180 @@
+use crate::app::{ActiveSection, ActiveTab, InputMode};
+
+use super::App;
+macro_rules! navigate_list {
+    ($state:expr, $forward:expr) => {
+        let len = $state.data.len();
+        if len > 0 {
+            let i = if $forward {
+                $state.state.selected().map_or(0, |s| (s + 1) % len)
+            } else {
+                $state
+                    .state
+                    .selected()
+                    .map_or(len - 1, |s| if s == 0 { len - 1 } else { s - 1 })
+            };
+            $state.index = i;
+            $state.state.select(Some(i));
+        } else {
+            $state.state.select(None)
+        }
+    };
+}
+
+impl App {
+    pub fn select_tab(&mut self, tab: ActiveTab) {
+        match self.active_tab {
+            // ActiveTab::Queue => self.queue_state.select(None),
+            ActiveTab::Songs => self.tracks_tab.clear(),
+            ActiveTab::Playlist => self.playlist_tab.clear(),
+            ActiveTab::Artists => self.artist_tab.clear(),
+            ActiveTab::Albums => self.album_tab.clear(),
+            ActiveTab::Favorites => self.favorite_tab.clear(),
+            ActiveTab::Search => {
+                self.search_tab.clear();
+                self.input_mode = InputMode::Normal;
+            }
+        }
+
+        self.active_tab = tab.clone();
+
+        // Initialize new tab state
+        match tab {
+            ActiveTab::Playlist if !self.playlist_tab.data.is_empty() => {
+                self.playlist_tab.current();
+            }
+            ActiveTab::Songs if !self.tracks_tab.data.is_empty() => {
+                self.tracks_tab.current();
+            }
+            ActiveTab::Artists if !self.artist_tab.data.is_empty() => {
+                self.artist_tab.current();
+            }
+            ActiveTab::Favorites if !self.favorite_tab.data.is_empty() => {
+                self.favorite_tab.current();
+            }
+            ActiveTab::Albums if !self.album_tab.data.is_empty() => {
+                self.album_tab.current();
+            }
+            ActiveTab::Search if !self.search_tab.data.is_empty() => {
+                self.search_tab.current();
+            }
+            _ => {}
+        }
+    }
+    pub fn next_tab(&mut self) {
+        self.active_section = match self.active_section {
+            ActiveSection::Queue => ActiveSection::Others,
+            ActiveSection::Others => ActiveSection::Queue,
+        };
+        match self.active_section {
+            ActiveSection::Queue => {
+                if !self.queue_tab.data.is_empty() {
+                    self.queue_tab.current();
+                }
+            }
+            ActiveSection::Others => match self.active_tab {
+                ActiveTab::Songs => {
+                    self.artist_tab.select(self.tracks_tab.index);
+                }
+                ActiveTab::Favorites => {
+                    self.favorite_tab.current();
+                }
+                ActiveTab::Playlist => {
+                    self.playlist_tab.current();
+                }
+                ActiveTab::Artists => {
+                    self.album_tab.select(self.artist_tab.index);
+                }
+                ActiveTab::Albums => {
+                    self.tracks_tab.select(self.album_tab.index);
+                }
+                ActiveTab::Search => {
+                    self.tracks_tab.select(self.search_tab.index);
+                }
+            },
+        };
+    }
+    pub fn previous_tab(&mut self) {
+        self.next_tab();
+    }
+    pub fn next_item_in_tab(&mut self) {
+        match self.active_section {
+            ActiveSection::Queue => {
+                navigate_list!(self.queue_tab, true);
+            }
+            ActiveSection::Others => match self.active_tab {
+                ActiveTab::Search => {
+                    if !self.search_tab.data.is_empty() {
+                        navigate_list!(self.search_tab, true);
+                    }
+                }
+                ActiveTab::Playlist => {
+                    if !self.playlist_tab.data.is_empty() {
+                        navigate_list!(self.playlist_tab, true);
+                    }
+                }
+                ActiveTab::Songs => {
+                    if !self.tracks_tab.data.is_empty() {
+                        navigate_list!(self.tracks_tab, true);
+                    }
+                }
+                ActiveTab::Favorites => {
+                    if !self.favorite_tab.data.is_empty() {
+                        navigate_list!(self.favorite_tab, true);
+                    }
+                }
+                ActiveTab::Artists => {
+                    if !self.artist_tab.data.is_empty() {
+                        navigate_list!(self.artist_tab, true);
+                    }
+                }
+                ActiveTab::Albums => {
+                    if !self.album_tab.data.is_empty() {
+                        navigate_list!(self.album_tab, true);
+                    }
+                }
+            },
+        }
+    }
+    pub fn previous_item_in_tab(&mut self) {
+        match self.active_section {
+            ActiveSection::Queue => {
+                if !self.queue_tab.data.is_empty() {
+                    navigate_list!(self.queue_tab, false);
+                }
+            }
+            ActiveSection::Others => match self.active_tab {
+                ActiveTab::Favorites => {
+                    if !self.favorite_tab.data.is_empty() {
+                        navigate_list!(self.favorite_tab, false);
+                    }
+                }
+                ActiveTab::Playlist => {
+                    if !self.playlist_tab.data.is_empty() {
+                        navigate_list!(self.playlist_tab, false);
+                    }
+                }
+                ActiveTab::Search => {
+                    if !self.search_tab.data.is_empty() {
+                        navigate_list!(self.search_tab, false);
+                    }
+                }
+                ActiveTab::Songs => {
+                    if !self.tracks_tab.data.is_empty() {
+                        navigate_list!(self.tracks_tab, false);
+                    }
+                }
+                ActiveTab::Artists => {
+                    if !self.artist_tab.data.is_empty() {
+                        navigate_list!(self.artist_tab, false);
+                    }
+                }
+                ActiveTab::Albums => {
+                    if !self.album_tab.data.is_empty() {
+                        navigate_list!(self.album_tab, false);
+                    }
+                }
+            },
+        }
+    }
+}