refactor: Create a download manager crate, create a common structs crate.

Author: ccgauche

Cargo.lock

@@ -1,8 +1,10 @@
 [workspace]
 resolver = "3"
-members = ["crates/database","crates/player", "crates/ytermusic", "crates/ytpapi2"]
+members = ["crates/common-structs","crates/database", "crates/download-manager","crates/player", "crates/ytermusic", "crates/ytpapi2"]
 
 [workspace.dependencies]
 player = { path = "crates/player" }
 ytpapi2 = { path = "crates/ytpapi2" }
 database = { path = "crates/database" }
+download-manager = { path = "crates/download-manager" }
+common-structs = { path = "crates/common-structs" }

Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "common-structs"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

crates/common-structs/Cargo.toml

@@ -0,0 +1,6 @@
+#[derive(PartialEq, Debug, Clone)]
+pub enum AppStatus {
+    Paused,
+    Playing,
+    NoMusic,
+}

crates/common-structs/src/app_status.rs

@@ -0,0 +1,5 @@
+mod app_status;
+mod music_download_status;
+
+pub use app_status::AppStatus;
+pub use music_download_status::MusicDownloadStatus;

crates/common-structs/src/lib.rs

@@ -0,0 +1,25 @@
+#[derive(PartialEq, Debug, Clone, Copy)]
+pub enum MusicDownloadStatus {
+    NotDownloaded,
+    Downloaded,
+    Downloading(usize),
+    DownloadFailed,
+}
+
+impl MusicDownloadStatus {
+    pub fn character(&self, playing: Option<bool>) -> String {
+        match self {
+            Self::NotDownloaded => {
+                if let Some(e) = playing {
+                    if e { '▶' } else { '⏸' }
+                } else {
+                    ' '
+                }
+            }
+            Self::Downloaded => ' ',
+            Self::Downloading(progress) => return format!("⭳ [{:02}%]", progress),
+            Self::DownloadFailed => '⚠',
+        }
+        .into()
+    }
+}

crates/common-structs/src/music_download_status.rs

@@ -0,0 +1,19 @@
+[package]
+name = "download-manager"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+ytpapi2.workspace = true
+flume = "0.11.0"
+once_cell = "1.19.0"
+tokio = { version = "1.36.0", features = ["rt-multi-thread"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+database.workspace = true
+common-structs.workspace = true
+
+#  --- YT Download ---
+rusty_ytdl = { git = "https://github.com/Mithronn/rusty_ytdl/", branch = "main", features = ["rustls-tls", "search", "live"], default-features = false}
+
+log = "0.4.20"

crates/download-manager/Cargo.toml

@@ -0,0 +1,104 @@
+mod task;
+
+use std::{
+    collections::{HashSet, VecDeque},
+    path::PathBuf,
+    sync::{Arc, Mutex},
+    time::Duration,
+};
+
+use database::YTLocalDatabase;
+use flume::Receiver;
+use tokio::{select, task::JoinHandle, time::sleep};
+use ytpapi2::YoutubeMusicVideoRef;
+
+use common_structs::MusicDownloadStatus;
+
+pub type MessageHandler = Arc<dyn Fn(DownloadManagerMessage) + Send + Sync + 'static>;
+
+pub enum DownloadManagerMessage {
+    VideoStatusUpdate(String, MusicDownloadStatus),
+}
+
+pub struct DownloadManager {
+    database: &'static YTLocalDatabase,
+    cache_dir: PathBuf,
+    handles: Mutex<Vec<JoinHandle<()>>>,
+    download_list: Mutex<VecDeque<YoutubeMusicVideoRef>>,
+    in_download: Mutex<HashSet<String>>,
+}
+
+impl DownloadManager {
+    pub fn new(cache_dir: PathBuf, database: &'static YTLocalDatabase) -> Self {
+        Self {
+            database,
+            cache_dir,
+            handles: Mutex::new(Vec::new()),
+            download_list: Mutex::new(VecDeque::new()),
+            in_download: Mutex::new(HashSet::new()),
+        }
+    }
+
+    pub fn remove_from_in_downloads(&self, video: &String) {
+        self.in_download.lock().unwrap().remove(video);
+    }
+
+    fn take(&self) -> Option<YoutubeMusicVideoRef> {
+        self.download_list.lock().unwrap().pop_front()
+    }
+
+    /// This has to be called as a service stream
+    /// HANDLES.lock().unwrap().push(run_service(async move {
+    ///     run_service_stream(sender);
+    /// }));
+    pub fn run_service_stream(&'static self, cancelation: Receiver<()>, sender: MessageHandler) {
+        let fut = async move {
+            loop {
+                if let Some(id) = self.take() {
+                    self.start_download(id, sender.clone()).await;
+                } else {
+                    sleep(Duration::from_millis(200)).await;
+                }
+            }
+        };
+        let service = tokio::task::spawn(async move {
+            select! {
+                _ = fut => {},
+                _ = cancelation.recv_async() => {},
+            }
+        });
+        self.handles.lock().unwrap().push(service);
+    }
+
+    pub fn spawn_system(&'static self, cancelation: Receiver<()>, sender: MessageHandler) {
+        for _ in 0..DOWNLOADER_COUNT {
+            self.run_service_stream(cancelation.clone(), sender.clone());
+        }
+    }
+
+    pub fn clean(&'static self, cancelation: Receiver<()>, sender: MessageHandler) {
+        self.download_list.lock().unwrap().clear();
+        self.in_download.lock().unwrap().clear();
+        {
+            let mut handle = self.handles.lock().unwrap();
+            for i in handle.iter() {
+                i.abort()
+            }
+            handle.clear();
+        }
+        self.spawn_system(cancelation, sender);
+    }
+
+    pub fn set_download_list(&self, to_add: impl IntoIterator<Item = YoutubeMusicVideoRef>) {
+        let mut list = self.download_list.lock().unwrap();
+        list.clear();
+        list.extend(to_add);
+    }
+
+    pub fn add_to_download_list(&self, to_add: impl IntoIterator<Item = YoutubeMusicVideoRef>) {
+        let mut list = self.download_list.lock().unwrap();
+        list.extend(to_add);
+    }
+}
+
+const DOWNLOADER_COUNT: usize = 4;