Let import_apkg() take a progress func

rslib/src/backend/progress.rs

@@ -110,6 +110,7 @@ pub(super) fn progress_to_proto(progress: Option<Progress>, tr: &I18n) -> pb::Pr
                 match progress {
                     ImportProgress::Collection => tr.importing_importing_collection(),
                     ImportProgress::Media(n) => tr.importing_processed_media_file(n),
+                    ImportProgress::MediaCheck(n) => tr.media_check_checked(n),
                 }
                 .into(),
             ),

rslib/src/import_export/mod.rs

@@ -9,4 +9,5 @@ pub mod package;
 pub enum ImportProgress {
     Collection,
     Media(usize),
+    MediaCheck(usize),
 }

rslib/src/import_export/package/apkg/import/cards.rs

@@ -65,7 +65,7 @@ impl Collection {
     }
 }
 
-impl<'a> Context<'a> {
+impl<F> Context<'_, F> {
     pub(super) fn import_cards_and_revlog(
         &mut self,
         imported_notes: &HashMap<NoteId, NoteId>,

rslib/src/import_export/package/apkg/import/decks.rs

@@ -26,7 +26,7 @@ impl<'d> DeckContext<'d> {
     }
 }
 
-impl Context<'_> {
+impl<F> Context<'_, F> {
     pub(super) fn import_decks_and_configs(&mut self) -> Result<HashMap<DeckId, DeckId>> {
         let mut ctx = DeckContext::new(self.target_col, self.usn);
         ctx.import_deck_configs(mem::take(&mut self.data.deck_configs))?;

rslib/src/import_export/package/apkg/import/media.rs

@@ -7,9 +7,12 @@ use zip::ZipArchive;
 
 use super::Context;
 use crate::{
-    import_export::package::{
+    import_export::{
-        media::{extract_media_entries, SafeMediaEntry},
+        package::{
-        Meta,
+            media::{extract_media_entries, SafeMediaEntry},
+            Meta,
+        },
+        ImportProgress,
     },
     media::{
         files::{add_hash_suffix_to_file_stem, sha1_of_reader},
@@ -29,14 +32,20 @@ pub(super) struct MediaUseMap {
     unchecked: Vec<SafeMediaEntry>,
 }
 
-impl<'a> Context<'a> {
+impl<F: FnMut(ImportProgress) -> Result<()>> Context<'_, F> {
     pub(super) fn prepare_media(&mut self) -> Result<MediaUseMap> {
-        let existing_sha1s = self.target_col.all_existing_sha1s()?;
+        let progress_fn = |u| (&mut self.progress_fn)(ImportProgress::MediaCheck(u)).is_ok();
+        let existing_sha1s = self.target_col.all_existing_sha1s(progress_fn)?;
         prepare_media(&mut self.archive, &existing_sha1s)
     }
 
     pub(super) fn copy_media(&mut self, media_map: &mut MediaUseMap) -> Result<()> {
+        let mut counter = 0;
         for entry in media_map.used_entries() {
+            counter += 1;
+            if counter % 10 == 0 {
+                (self.progress_fn)(ImportProgress::Media(counter))?;
+            }
             entry.copy_from_archive(&mut self.archive, &self.target_col.media_folder)?;
         }
         Ok(())
@@ -44,9 +53,12 @@ impl<'a> Context<'a> {
 }
 
 impl Collection {
-    fn all_existing_sha1s(&mut self) -> Result<HashMap<String, [u8; 20]>> {
+    fn all_existing_sha1s(
+        &mut self,
+        progress_fn: impl FnMut(usize) -> bool,
+    ) -> Result<HashMap<String, [u8; 20]>> {
         let mgr = MediaManager::new(&self.media_folder, &self.media_db)?;
-        mgr.all_checksums(|_| true, &self.log)
+        mgr.all_checksums(progress_fn, &self.log)
     }
 }
 

rslib/src/import_export/package/apkg/import/mod.rs

@@ -15,32 +15,41 @@ use zip::ZipArchive;
 
 use crate::{
     collection::CollectionBuilder,
-    import_export::{gather::ExchangeData, package::Meta},
+    import_export::{gather::ExchangeData, package::Meta, ImportProgress},
     prelude::*,
     search::SearchNode,
 };
 
-struct Context<'a> {
+struct Context<'a, F> {
     target_col: &'a mut Collection,
     archive: ZipArchive<File>,
     data: ExchangeData,
     usn: Usn,
+    progress_fn: F,
 }
 
 impl Collection {
-    pub fn import_apkg(&mut self, path: impl AsRef<Path>) -> Result<OpOutput<()>> {
+    pub fn import_apkg(
+        &mut self,
+        path: impl AsRef<Path>,
+        progress_fn: impl FnMut(ImportProgress) -> Result<()>,
+    ) -> Result<OpOutput<()>> {
         let file = File::open(path)?;
         let archive = ZipArchive::new(file)?;
 
         self.transact(Op::Import, |col| {
-            let mut ctx = Context::new(archive, col)?;
+            let mut ctx = Context::new(archive, col, progress_fn)?;
             ctx.import()
         })
     }
 }
 
-impl<'a> Context<'a> {
+impl<'a, F: FnMut(ImportProgress) -> Result<()>> Context<'a, F> {
-    fn new(mut archive: ZipArchive<File>, target_col: &'a mut Collection) -> Result<Self> {
+    fn new(
+        mut archive: ZipArchive<File>,
+        target_col: &'a mut Collection,
+        progress_fn: F,
+    ) -> Result<Self> {
         let data =
             ExchangeData::gather_from_archive(&mut archive, SearchNode::WholeCollection, true)?;
         let usn = target_col.usn()?;
@@ -49,6 +58,7 @@ impl<'a> Context<'a> {
             archive,
             data,
             usn,
+            progress_fn,
         })
     }
 

rslib/src/import_export/package/apkg/import/notes.rs

@@ -43,7 +43,7 @@ impl NoteMeta {
     }
 }
 
-impl Context<'_> {
+impl<F> Context<'_, F> {
     pub(super) fn import_notes_and_notetypes(
         &mut self,
         media_map: &mut MediaUseMap,