demo-app: Extract reusable code for desktop-app

uklotzde · uklotzde · commit ae9eec75b867 · 2024-02-16T01:25:48.000+01:00
diff --git a/crates/desktop-app/src/collection/mod.rs b/crates/desktop-app/src/collection/mod.rs
@@ -3,17 +3,24 @@
 
 use std::{
     borrow::Cow,
+    future::Future,
     path::{Path, PathBuf},
+    sync::{Arc, Mutex},
     time::Instant,
 };
 
+use discro::{Publisher, Subscriber};
 use url::Url;
 
-use aoide_backend_embedded::batch::{
-    self,
-    synchronize_collection_vfs::{
-        OrphanedMediaSources, UnsynchronizedTracks, UntrackedFiles, UntrackedMediaSources,
+use aoide_backend_embedded::{
+    batch::{
+        self,
+        synchronize_collection_vfs::{
+            OrphanedMediaSources, Outcome, Progress, UnsynchronizedTracks, UntrackedFiles,
+            UntrackedMediaSources,
+        },
     },
+    media::predefined_faceted_tag_mapping_config,
 };
 use aoide_core::{
     collection::{Collection, Entity, EntityUid, MediaSourceConfig},
@@ -845,3 +852,91 @@ where
     .await
     .map_err(Into::into)
 }
+
+#[derive(Debug)]
+pub struct SynchronizeVfsTask {
+    started_at: Instant,
+    progress: Subscriber<Option<Progress>>,
+    join_handle: tokio::task::JoinHandle<Option<Outcome>>,
+}
+
+impl SynchronizeVfsTask {
+    #[must_use]
+    #[allow(clippy::missing_panics_doc)]
+    pub fn spawn(
+        rt: &tokio::runtime::Handle,
+        handle: Handle,
+        collection: Arc<ObservableState>,
+    ) -> Self {
+        let started_at = Instant::now();
+        let progress_pub = Publisher::new(None);
+        let progress = progress_pub.subscribe();
+        let report_progress_fn = {
+            // TODO: How to avoid wrapping the publisher?
+            let progress_pub = Arc::new(Mutex::new(progress_pub));
+            move |progress: Option<Progress>| {
+                progress_pub.lock().unwrap().write(progress);
+            }
+        };
+        let task = synchronize_vfs_task(handle, collection, report_progress_fn);
+        let join_handle = rt.spawn(task);
+        Self {
+            started_at,
+            progress,
+            join_handle,
+        }
+    }
+
+    #[must_use]
+    pub const fn started_at(&self) -> Instant {
+        self.started_at
+    }
+
+    #[must_use]
+    pub const fn progress(&self) -> &Subscriber<Option<Progress>> {
+        &self.progress
+    }
+
+    pub fn abort(&self) {
+        self.join_handle.abort();
+    }
+
+    #[must_use]
+    pub fn is_finished(&self) -> bool {
+        self.join_handle.is_finished()
+    }
+
+    pub async fn join(self) -> anyhow::Result<Option<Outcome>> {
+        self.join_handle.await.map_err(Into::into)
+    }
+}
+
+#[allow(clippy::manual_async_fn)] // Required to specify the trait bounds of the returned `Future` explicitly.
+fn synchronize_vfs_task(
+    handle: Handle,
+    state: Arc<ObservableState>,
+    mut report_progress_fn: impl FnMut(Option<Progress>) + Clone + Send + 'static,
+) -> impl Future<Output = Option<Outcome>> + Send + 'static {
+    async move {
+        log::debug!("Synchronizing collection...");
+        let import_track_config = ImportTrackConfig {
+            // TODO: Customize faceted tag mapping
+            faceted_tag_mapping: predefined_faceted_tag_mapping_config(),
+            ..Default::default()
+        };
+        let outcome = {
+            let mut report_progress_fn = report_progress_fn.clone();
+            let report_progress_fn = move |progress| {
+                report_progress_fn(Some(progress));
+            };
+            state
+                .synchronize_vfs(&handle, import_track_config, report_progress_fn)
+                .await
+        };
+        report_progress_fn(None);
+        log::debug!("Synchronizing collection finished: {outcome:?}");
+        // Implicitly refresh the state from the database to reflect the changes.
+        state.refresh_from_db(&handle).await;
+        outcome
+    }
+}
diff --git a/demo-app/src/library/collection.rs b/demo-app/src/library/collection.rs
@@ -1,19 +1,9 @@
 // SPDX-FileCopyrightText: Copyright (C) 2018-2024 Uwe Klotz <uwedotklotzatgmaildotcom> et al.
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
-use std::{
-    future::Future,
-    sync::{Arc, Mutex},
-    time::Instant,
-};
+use discro::Subscriber;
 
-use discro::{Publisher, Subscriber};
-
-use aoide::{
-    backend_embedded::media::predefined_faceted_tag_mapping_config,
-    desktop_app::{collection, Handle},
-    media_file::io::import::ImportTrackConfig,
-};
+use aoide::desktop_app::collection;
 
 use crate::NoReceiverForEvent;
 
@@ -43,101 +33,3 @@ where
         }
     }
 }
-
-pub struct RescanTask {
-    started_at: Instant,
-    progress:
-        Subscriber<Option<aoide::backend_embedded::batch::synchronize_collection_vfs::Progress>>,
-    join_handle: tokio::task::JoinHandle<
-        Option<aoide::backend_embedded::batch::synchronize_collection_vfs::Outcome>,
-    >,
-}
-
-impl RescanTask {
-    pub fn spawn(
-        rt: &tokio::runtime::Handle,
-        handle: Handle,
-        collection: Arc<collection::ObservableState>,
-    ) -> Self {
-        let started_at = Instant::now();
-        let progress_pub = Publisher::new(None);
-        let progress = progress_pub.subscribe();
-        let report_progress_fn = {
-            // TODO: How to avoid wrapping the publisher?
-            let progress_pub = Arc::new(Mutex::new(progress_pub));
-            move |progress: Option<
-                aoide::backend_embedded::batch::synchronize_collection_vfs::Progress,
-            >| {
-                progress_pub.lock().unwrap().write(progress);
-            }
-        };
-        let task = synchronize_music_dir_task(handle, collection, report_progress_fn);
-        let join_handle = rt.spawn(task);
-        Self {
-            started_at,
-            progress,
-            join_handle,
-        }
-    }
-
-    pub const fn started_at(&self) -> Instant {
-        self.started_at
-    }
-
-    pub const fn progress(
-        &self,
-    ) -> &Subscriber<Option<aoide::backend_embedded::batch::synchronize_collection_vfs::Progress>>
-    {
-        &self.progress
-    }
-
-    pub fn abort(&self) {
-        self.join_handle.abort();
-    }
-
-    pub fn is_finished(&self) -> bool {
-        self.join_handle.is_finished()
-    }
-
-    pub async fn join(
-        self,
-    ) -> anyhow::Result<Option<aoide::backend_embedded::batch::synchronize_collection_vfs::Outcome>>
-    {
-        self.join_handle.await.map_err(Into::into)
-    }
-}
-
-#[allow(clippy::manual_async_fn)] // Required to specify the trait bounds of the returned `Future` explicitly.
-fn synchronize_music_dir_task(
-    handle: Handle,
-    state: Arc<ObservableState>,
-    mut report_progress_fn: impl FnMut(Option<aoide::backend_embedded::batch::synchronize_collection_vfs::Progress>)
-        + Clone
-        + Send
-        + 'static,
-) -> impl Future<Output = Option<aoide::backend_embedded::batch::synchronize_collection_vfs::Outcome>>
-       + Send
-       + 'static {
-    async move {
-        log::debug!("Synchronizing collection with music directory...");
-        let import_track_config = ImportTrackConfig {
-            // TODO: Customize faceted tag mapping
-            faceted_tag_mapping: predefined_faceted_tag_mapping_config(),
-            ..Default::default()
-        };
-        let outcome = {
-            let mut report_progress_fn = report_progress_fn.clone();
-            let report_progress_fn = move |progress| {
-                report_progress_fn(Some(progress));
-            };
-            state
-                .synchronize_vfs(&handle, import_track_config, report_progress_fn)
-                .await
-        };
-        report_progress_fn(None);
-        log::debug!("Synchronizing collection with music directory finished: {outcome:?}");
-        // Implicitly refresh the state from the database to reflect the changes.
-        state.refresh_from_db(&handle).await;
-        outcome
-    }
-}
diff --git a/demo-app/src/library/mod.rs b/demo-app/src/library/mod.rs
@@ -5,7 +5,10 @@ use std::{num::NonZeroUsize, path::PathBuf, sync::Arc};
 
 use aoide::{
     api::media::source::ResolveUrlFromContentPath,
-    desktop_app::{fs::DirPath, track::repo_search::FetchMoreSucceeded, Handle, ObservableReader},
+    desktop_app::{
+        collection::SynchronizeVfsTask, fs::DirPath, track::repo_search::FetchMoreSucceeded,
+        Handle, ObservableReader,
+    },
 };
 
 use crate::NoReceiverForEvent;
@@ -97,7 +100,7 @@ impl LibraryState {
 pub struct Library {
     handle: Handle,
     state: LibraryState,
-    pending_rescan_collection_task: Option<collection::RescanTask>,
+    pending_rescan_collection_task: Option<SynchronizeVfsTask>,
 }
 
 impl Library {
@@ -145,7 +148,7 @@ impl Library {
         log::info!("Spawning rescan collection task");
         let handle = self.handle.clone();
         let collection = Arc::clone(&self.state.collection);
-        let rescan_collection_task = collection::RescanTask::spawn(rt, handle, collection);
+        let rescan_collection_task = SynchronizeVfsTask::spawn(rt, handle, collection);
         self.pending_rescan_collection_task = Some(rescan_collection_task);
         true
     }
@@ -162,11 +165,11 @@ impl Library {
         changed
     }
 
-    pub const fn pending_rescan_collection_task(&self) -> Option<&collection::RescanTask> {
-        self.pending_rescan_collection_task.as_ref()
+    pub const fn has_pending_rescan_collection_task(&self) -> bool {
+        self.pending_rescan_collection_task.is_some()
     }
 
-    pub fn abort_pending_rescan_collection_task(&mut self) -> Option<collection::RescanTask> {
+    pub fn abort_pending_rescan_collection_task(&mut self) -> Option<SynchronizeVfsTask> {
         let pending_rescan_collection_task = self.pending_rescan_collection_task.take();
         let Some(rescan_collection_task) = pending_rescan_collection_task else {
             return None;
@@ -191,9 +194,8 @@ impl Library {
             resolve_url_from_content_path,
         };
         // Argument is consumed when updating succeeds
-        if self.state.track_search.update_params(&mut params) {
-            log::debug!("Track search params updated: {params:?}");
-        } else {
+        log::debug!("Updating track search params: {params:?}");
+        if !self.state.track_search.update_params(&mut params) {
             log::debug!("Track search params not updated: {params:?}");
         }
     }
diff --git a/demo-app/src/main.rs b/demo-app/src/main.rs
@@ -522,7 +522,7 @@ impl eframe::App for App {
                     if ui
                         .add_enabled(
                             collection_state.is_ready()
-                                && self.library.pending_rescan_collection_task().is_none(),
+                                && !self.library.has_pending_rescan_collection_task(),
                             Button::new("Rescan collection"),
                         )
                         .clicked()

Original file line number	Diff line number	Diff line change
`@@ -522,7 +522,7 @@ impl eframe::App for App {`
`522`	`522`	`if ui`
`523`	`523`	`.add_enabled(`
`524`	`524`	`collection_state.is_ready()`
`525`		`- && self.library.pending_rescan_collection_task().is_none(),`
	`525`	`+ && !self.library.has_pending_rescan_collection_task(),`
`526`	`526`	`Button::new("Rescan collection"),`
`527`	`527`	`)`
`528`	`528`	`.clicked()`