library: Add export functionality

src/library.rs

@@ -1,8 +1,10 @@
 use std::{
     cell::{OnceCell, RefCell},
     ffi::OsString,
-    fs,
+    fs::{self, File},
+    io::{BufWriter, Read, Write},
     path::{Path, PathBuf},
+    thread,
 };
 
 use adw::{
@@ -14,6 +16,7 @@ use anyhow::{anyhow, Result};
 use chrono::prelude::*;
 use diesel::{dsl::exists, prelude::*, QueryDsl, SqliteConnection};
 use once_cell::sync::Lazy;
+use zip::{write::SimpleFileOptions, ZipWriter};
 
 use crate::{
     db::{self, models::*, schema::*, tables, TranslatedString},
@@ -72,6 +75,39 @@ impl Library {
             .build()
     }
 
+    /// Import from a library archive.
+    pub fn import(&self, _path: impl AsRef<Path>) -> Result<()> {
+        Ok(())
+    }
+
+    /// Export the whole music library to an archive at `path`. If `path` already exists, it will
+    /// be overwritten. The work will be done in a background thread.
+    pub fn export(
+        &self,
+        path: impl AsRef<Path>,
+    ) -> Result<async_channel::Receiver<LibraryProcessMsg>> {
+        let mut binding = self.imp().connection.borrow_mut();
+        let connection = &mut *binding.as_mut().unwrap();
+
+        let path = path.as_ref().to_owned();
+        let library_folder = PathBuf::from(&self.folder());
+        let tracks = tracks::table.load::<tables::Track>(connection)?;
+
+        let (sender, receiver) = async_channel::unbounded::<LibraryProcessMsg>();
+        thread::spawn(move || {
+            if let Err(err) = sender.send_blocking(LibraryProcessMsg::Result(write_zip(
+                path,
+                library_folder,
+                tracks,
+                &sender,
+            ))) {
+                log::error!("Failed to send library action result: {err}");
+            }
+        });
+
+        Ok(receiver)
+    }
+
     pub fn search(&self, query: &LibraryQuery, search: &str) -> Result<LibraryResults> {
         let search = format!("%{}%", search);
         let mut binding = self.imp().connection.borrow_mut();
@@ -1582,3 +1618,55 @@ impl LibraryResults {
             && self.albums.is_empty()
     }
 }
+
+fn write_zip(
+    zip_path: impl AsRef<Path>,
+    library_folder: impl AsRef<Path>,
+    tracks: Vec<tables::Track>,
+    sender: &async_channel::Sender<LibraryProcessMsg>,
+) -> Result<()> {
+    let mut zip = zip::ZipWriter::new(BufWriter::new(fs::File::create(zip_path)?));
+
+    // Start with the database:
+    add_file_to_zip(&mut zip, &library_folder, "musicus.db")?;
+
+    let n_tracks = tracks.len();
+
+    // Include all tracks that are part of the library.
+    for (index, track) in tracks.into_iter().enumerate() {
+        add_file_to_zip(&mut zip, &library_folder, &track.path)?;
+
+        // Ignore if the reveiver has been dropped.
+        let _ = sender.send_blocking(LibraryProcessMsg::Progress(
+            (index + 1) as f64 / n_tracks as f64,
+        ));
+    }
+
+    zip.finish()?;
+
+    Ok(())
+}
+
+// TODO: Cross-platform paths?
+fn add_file_to_zip(
+    zip: &mut ZipWriter<BufWriter<File>>,
+    library_folder: impl AsRef<Path>,
+    library_path: &str,
+) -> Result<()> {
+    let file_path = library_folder.as_ref().join(PathBuf::from(library_path));
+
+    let mut file = File::open(file_path)?;
+    let mut buffer = Vec::new();
+    file.read_to_end(&mut buffer)?;
+
+    zip.start_file(library_path, SimpleFileOptions::default())?;
+    zip.write_all(&buffer)?;
+
+    Ok(())
+}
+
+#[derive(Debug)]
+pub enum LibraryProcessMsg {
+    Progress(f64),
+    Result(Result<()>),
+}

src/library_manager.rs

@@ -1,10 +1,14 @@
 use std::{cell::OnceCell, ffi::OsStr, path::Path};
 
 use adw::{prelude::*, subclass::prelude::*};
+use formatx::formatx;
 use gettextrs::gettext;
-use gtk::glib;
+use gtk::glib::{self, clone};
 
-use crate::{library::Library, window::Window};
+use crate::{
+    library::Library, process::Process, process_manager::ProcessManager, process_row::ProcessRow,
+    window::Window,
+};
 
 mod imp {
     use super::*;
@@ -14,9 +18,12 @@ mod imp {
     pub struct LibraryManager {
         pub navigation: OnceCell<adw::NavigationView>,
         pub library: OnceCell<Library>,
+        pub process_manager: OnceCell<ProcessManager>,
 
         #[template_child]
         pub library_path_row: TemplateChild<adw::ActionRow>,
+        #[template_child]
+        pub process_list: TemplateChild<gtk::ListBox>,
     }
 
     #[glib::object_subclass]
@@ -47,16 +54,28 @@ glib::wrapper! {
 
 #[gtk::template_callbacks]
 impl LibraryManager {
-    pub fn new(navigation: &adw::NavigationView, library: &Library) -> Self {
+    pub fn new(
+        navigation: &adw::NavigationView,
+        library: &Library,
+        process_manager: &ProcessManager,
+    ) -> Self {
         let obj: Self = glib::Object::new();
 
-        obj.imp().navigation.set(navigation.to_owned()).unwrap();
-        obj.imp().library.set(library.to_owned()).unwrap();
+        for process in process_manager.processes() {
+            obj.add_process(&process);
+        }
 
         if let Some(Some(filename)) = Path::new(&library.folder()).file_name().map(OsStr::to_str) {
             obj.imp().library_path_row.set_subtitle(filename);
         }
 
+        obj.imp().navigation.set(navigation.to_owned()).unwrap();
+        obj.imp().library.set(library.to_owned()).unwrap();
+        obj.imp()
+            .process_manager
+            .set(process_manager.to_owned())
+            .unwrap();
+
         obj
     }
 
@@ -85,8 +104,107 @@ impl LibraryManager {
     }
 
     #[template_callback]
-    fn import_archive(&self) {}
+    async fn import_archive(&self) {
+        let dialog = gtk::FileDialog::builder()
+            .title(gettext("Import from library archive"))
+            .modal(true)
+            .build();
+
+        let root = self.root();
+        let window = root
+            .as_ref()
+            .and_then(|r| r.downcast_ref::<gtk::Window>())
+            .and_then(|w| w.downcast_ref::<Window>())
+            .unwrap();
+
+        match dialog.open_future(Some(window)).await {
+            Err(err) => {
+                if !err.matches(gtk::DialogError::Dismissed) {
+                    log::error!("File selection failed: {err}");
+                }
+            }
+            Ok(path) => {
+                if let Some(path) = path.path() {
+                    if let Err(err) = self.imp().library.get().unwrap().import(path) {
+                        log::error!("Failed to import library from archive: {err}");
+                    }
+                }
+            }
+        }
+    }
 
     #[template_callback]
-    fn export_archive(&self) {}
+    async fn export_archive(&self) {
+        let dialog = gtk::FileDialog::builder()
+            .title(gettext("Export library"))
+            .modal(true)
+            .build();
+
+        let root = self.root();
+        let window = root
+            .as_ref()
+            .and_then(|r| r.downcast_ref::<gtk::Window>())
+            .and_then(|w| w.downcast_ref::<Window>())
+            .unwrap();
+
+        match dialog.save_future(Some(window)).await {
+            Err(err) => {
+                if !err.matches(gtk::DialogError::Dismissed) {
+                    log::error!("File selection failed: {err}");
+                }
+            }
+            Ok(path) => {
+                if let Some(path) = path.path() {
+                    match self.imp().library.get().unwrap().export(&path) {
+                        Ok(receiver) => {
+                            let process = Process::new(
+                                &formatx!(
+                                    gettext("Exporting music library to {}"),
+                                    path.file_name()
+                                        .map(|f| f.to_string_lossy().into_owned())
+                                        .unwrap_or(gettext("archive"))
+                                )
+                                .unwrap(),
+                                receiver,
+                            );
+
+                            self.imp()
+                                .process_manager
+                                .get()
+                                .unwrap()
+                                .add_process(&process);
+
+                            self.add_process(&process);
+                        }
+                        Err(err) => log::error!("Failed to export library: {err}"),
+                    }
+                }
+            }
+        }
+    }
+
+    fn add_process(&self, process: &Process) {
+        let row = ProcessRow::new(process);
+
+        row.connect_remove(clone!(
+            #[weak(rename_to = obj)]
+            self,
+            move |row| {
+                obj.imp()
+                    .process_manager
+                    .get()
+                    .unwrap()
+                    .remove_process(&row.process());
+
+                obj.imp().process_list.remove(row);
+
+                if obj.imp().process_list.first_child().is_none() {
+                    obj.imp().process_list.set_visible(false);
+                }
+            }
+        ));
+
+        self.imp().process_list.append(&row);
+        self.imp().process_list.set_visible(true);
+    }
 }

src/main.rs

@@ -4,7 +4,6 @@ mod application;
 mod config;
 mod db;
 mod editor;
-mod search_page;
 mod library;
 mod library_manager;
 mod player;
@@ -12,9 +11,13 @@ mod player_bar;
 mod playlist_item;
 mod playlist_page;
 mod playlist_tile;
+mod process;
+mod process_manager;
+mod process_row;
 mod program;
 mod program_tile;
 mod recording_tile;
+mod search_page;
 mod search_tag;
 mod selector;
 mod tag_tile;

src/process.rs

@@ -0,0 +1,67 @@
+use std::cell::{Cell, OnceCell, RefCell};
+
+use gtk::{
+    glib::{self, Properties},
+    prelude::*,
+    subclass::prelude::*,
+};
+
+use crate::library::LibraryProcessMsg;
+
+mod imp {
+    use super::*;
+
+    #[derive(Properties, Default, Debug)]
+    #[properties(wrapper_type = super::Process)]
+    pub struct Process {
+        #[property(get, construct_only)]
+        pub description: OnceCell<String>,
+        #[property(get, set)]
+        pub progress: Cell<f64>,
+        #[property(get, set)]
+        pub finished: Cell<bool>,
+        #[property(get, set)]
+        pub error: RefCell<Option<String>>,
+    }
+
+    #[glib::object_subclass]
+    impl ObjectSubclass for Process {
+        const NAME: &'static str = "MusicusProcess";
+        type Type = super::Process;
+    }
+
+    #[glib::derived_properties]
+    impl ObjectImpl for Process {}
+}
+
+glib::wrapper! {
+    pub struct Process(ObjectSubclass<imp::Process>);
+}
+
+impl Process {
+    pub fn new(description: &str, receiver: async_channel::Receiver<LibraryProcessMsg>) -> Self {
+        let obj: Self = glib::Object::builder()
+            .property("description", description)
+            .build();
+
+        let obj_clone = obj.clone();
+        glib::spawn_future_local(async move {
+            while let Ok(msg) = receiver.recv().await {
+                match msg {
+                    LibraryProcessMsg::Progress(fraction) => {
+                        obj_clone.set_progress(fraction);
+                    }
+                    LibraryProcessMsg::Result(result) => {
+                        if let Err(err) = result {
+                            obj_clone.set_error(err.to_string());
+                        }
+
+                        obj_clone.set_finished(true);
+                    }
+                }
+            }
+        });
+
+        obj
+    }
+}

src/process_manager.rs

@@ -0,0 +1,57 @@
+use std::cell::RefCell;
+
+use gtk::{
+    glib::{self},
+    subclass::prelude::*,
+};
+
+use crate::process::Process;
+
+mod imp {
+    use super::*;
+
+    #[derive(Debug, Default)]
+    pub struct ProcessManager {
+        pub processes: RefCell<Vec<Process>>,
+    }
+
+    #[glib::object_subclass]
+    impl ObjectSubclass for ProcessManager {
+        const NAME: &'static str = "MusicusProcessManager";
+        type Type = super::ProcessManager;
+    }
+
+    impl ObjectImpl for ProcessManager {}
+}
+
+glib::wrapper! {
+    pub struct ProcessManager(ObjectSubclass<imp::ProcessManager>);
+}
+
+impl ProcessManager {
+    pub fn new() -> Self {
+        glib::Object::new()
+    }
+
+    pub fn add_process(&self, process: &Process) {
+        self.imp().processes.borrow_mut().push(process.to_owned());
+    }
+
+    pub fn processes(&self) -> Vec<Process> {
+        self.imp().processes.borrow().clone()
+    }
+
+    pub fn any_ongoing(&self) -> bool {
+        self.imp().processes.borrow().iter().any(|p| !p.finished())
+    }
+
+    pub fn remove_process(&self, process: &Process) {
+        self.imp().processes.borrow_mut().retain(|p| p != process);
+    }
+}
+
+impl Default for ProcessManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}

src/process_row.rs

@@ -0,0 +1,128 @@
+use std::cell::OnceCell;
+
+use formatx::formatx;
+use gettextrs::gettext;
+use gtk::{
+    glib::{self, subclass::Signal, Properties},
+    prelude::*,
+    subclass::prelude::*,
+};
+use once_cell::sync::Lazy;
+
+use crate::process::Process;
+
+mod imp {
+    use super::*;
+
+    #[derive(Properties, Debug, Default, gtk::CompositeTemplate)]
+    #[properties(wrapper_type = super::ProcessRow)]
+    #[template(file = "data/ui/process_row.blp")]
+    pub struct ProcessRow {
+        #[property(get, construct_only)]
+        pub process: OnceCell<Process>,
+
+        #[template_child]
+        pub description_label: TemplateChild<gtk::Label>,
+        #[template_child]
+        pub success_label: TemplateChild<gtk::Label>,
+        #[template_child]
+        pub error_label: TemplateChild<gtk::Label>,
+        #[template_child]
+        pub remove_button: TemplateChild<gtk::Button>,
+        #[template_child]
+        pub progress_bar: TemplateChild<gtk::ProgressBar>,
+    }
+
+    #[glib::object_subclass]
+    impl ObjectSubclass for ProcessRow {
+        const NAME: &'static str = "MusicusProcessRow";
+        type Type = super::ProcessRow;
+        type ParentType = gtk::ListBoxRow;
+
+        fn class_init(klass: &mut Self::Class) {
+            klass.bind_template();
+            klass.bind_template_instance_callbacks();
+        }
+
+        fn instance_init(obj: &glib::subclass::InitializingObject<Self>) {
+            obj.init_template();
+        }
+    }
+
+    #[glib::derived_properties]
+    impl ObjectImpl for ProcessRow {
+        fn signals() -> &'static [Signal] {
+            static SIGNALS: Lazy<Vec<Signal>> =
+                Lazy::new(|| vec![Signal::builder("remove").build()]);
+
+            SIGNALS.as_ref()
+        }
+
+        fn constructed(&self) {
+            self.parent_constructed();
+
+            self.description_label
+                .set_label(&self.obj().process().description());
+
+            self.obj()
+                .process()
+                .bind_property("progress", &*self.progress_bar, "fraction")
+                .build();
+
+            let obj = self.obj().to_owned();
+            self.obj().process().connect_finished_notify(move |_| {
+                obj.update();
+            });
+
+            self.obj().update();
+        }
+    }
+
+    impl WidgetImpl for ProcessRow {}
+    impl ListBoxRowImpl for ProcessRow {}
+}
+
+glib::wrapper! {
+    pub struct ProcessRow(ObjectSubclass<imp::ProcessRow>)
+        @extends gtk::Widget, gtk::ListBoxRow;
+}
+
+#[gtk::template_callbacks]
+impl ProcessRow {
+    pub fn new(process: &Process) -> Self {
+        glib::Object::builder().property("process", process).build()
+    }
+
+    pub fn connect_remove<F: Fn(&Self) + 'static>(&self, f: F) -> glib::SignalHandlerId {
+        self.connect_local("remove", true, move |values| {
+            let obj = values[0].get::<Self>().unwrap();
+            f(&obj);
+            None
+        })
+    }
+
+    #[template_callback]
+    fn remove(&self) {
+        self.emit_by_name::<()>("remove", &[]);
+    }
+
+    fn update(&self) {
+        if !self.process().finished() {
+            self.imp()
+                .progress_bar
+                .set_fraction(self.process().progress());
+        } else {
+            self.imp().progress_bar.set_visible(false);
+            self.imp().remove_button.set_visible(true);
+
+            if let Some(error) = self.process().error() {
+                self.imp()
+                    .error_label
+                    .set_label(&formatx!(gettext("Process failed: {}"), error).unwrap());
+                self.imp().error_label.set_visible(true);
+            } else {
+                self.imp().success_label.set_visible(true);
+            }
+        }
+    }
+}

src/window.rs

@@ -11,11 +11,15 @@ use crate::{
     player::Player,
     player_bar::PlayerBar,
     playlist_page::PlaylistPage,
+    process_manager::ProcessManager,
     search_page::SearchPage,
     welcome_page::WelcomePage,
 };
 
 mod imp {
+    use adw::prelude::{AlertDialogExt, AlertDialogExtManual};
+    use gettextrs::gettext;
+
     use super::*;
 
     #[derive(Debug, Default, gtk::CompositeTemplate)]
@@ -23,6 +27,7 @@ mod imp {
     pub struct Window {
         pub library: RefCell<Option<Library>>,
         pub player: Player,
+        pub process_manager: ProcessManager,
 
         #[template_child]
         pub stack: TemplateChild<gtk::Stack>,
@@ -72,8 +77,11 @@ mod imp {
             let library_action = gio::ActionEntry::builder("library")
                 .activate(move |_, _, _| {
                     if let Some(library) = &*obj.imp().library.borrow() {
-                        let library_manager =
-                            LibraryManager::new(&obj.imp().navigation_view, library);
+                        let library_manager = LibraryManager::new(
+                            &obj.imp().navigation_view,
+                            library,
+                            &obj.imp().process_manager,
+                        );
                         obj.imp().navigation_view.push(&library_manager);
                     }
                 })
@@ -135,11 +143,38 @@ mod imp {
 
     impl WindowImpl for Window {
         fn close_request(&self) -> glib::signal::Propagation {
-            if let Err(err) = self.obj().save_window_state() {
-                log::warn!("Failed to save window state: {err}");
-            }
+            if self.process_manager.any_ongoing() {
+                let dialog = adw::AlertDialog::builder()
+                    .heading(&gettext("Close window?"))
+                    .body(&gettext(
+                        "There are ongoing processes that will be canceled.",
+                    ))
+                    .build();
 
-            glib::signal::Propagation::Proceed
+                dialog.add_responses(&[
+                    ("cancel", &gettext("Keep open")),
+                    ("close", &gettext("Close window")),
+                ]);
+
+                dialog.set_response_appearance("close", adw::ResponseAppearance::Destructive);
+                dialog.set_close_response("cancel");
+                dialog.set_default_response(Some("cancel"));
+
+                let obj = self.obj().to_owned();
+                glib::spawn_future_local(async move {
+                    if dialog.choose_future(&obj).await == "close" {
+                        obj.destroy();
+                    }
+                });
+
+                glib::signal::Propagation::Stop
+            } else {
+                if let Err(err) = self.obj().save_window_state() {
+                    log::warn!("Failed to save window state: {err}");
+                }
+
+                glib::signal::Propagation::Proceed
+            }
         }
     }