add progress for server side

Author: zsqw123

README.md

@@ -42,13 +42,15 @@ see some examples.
 - [ ] Isolate AsmResult as multiple different errors, and provide a better error message.
 - [ ] GUI interactions
   - [ ] GUI backend:
+    - [x] add progress when loading files
     - [ ] unzip (whatever jar or dex) & parallel read
     - [ ] retrieve metadata and combine multiple metadata for better indexing
     - [x] using metadata to get the real data if needed (e.g. method instructions)
     - [ ] search content, quick search for metadata and slow search for instructions.
   - [ ] GUI frontend:
     - [x] basic window with egui.
     - [x] load files from the backend
+    - [ ] add progress bar UI when loading files
     - [x] show metadata in a tree view
     - [x] show instructions in a list view
     - [ ] quick jump to specific metadata

asm_egui/src/smali.rs

@@ -6,21 +6,21 @@ use java_asm::smali::{SmaliNode, SmaliToken};
 #[derive(Default)]
 struct SmaliHighlighter;
 
+// font, dft_color, dark_mode, smali_node
+impl ComputerMut<(&FontId, Color32, bool, &SmaliNode), LayoutJob> for SmaliHighlighter {
+    fn compute(&mut self, key: (&FontId, Color32, bool, &SmaliNode)) -> LayoutJob {
+        let (font, dft_color, dark_mode, smali_node) = key;
+        let mut job = LayoutJob::default();
+        let smali_style = if dark_mode { SmaliStyle::DARK } else { SmaliStyle::LIGHT };
+        let max_offset_len = max_offset_hint(smali_node).to_string().len();
+        append_node(&font, dft_color, &smali_style, smali_node, &mut job, 0, max_offset_len);
+        job
+    }
+}
+
 pub fn smali_layout(ui: &mut Ui, smali_node: &SmaliNode) {
     let ctx = &mut ui.ctx();
 
-    // font, dft_color, dark_mode, smali_node
-    impl ComputerMut<(&FontId, Color32, bool, &SmaliNode), LayoutJob> for SmaliHighlighter {
-        fn compute(&mut self, key: (&FontId, Color32, bool, &SmaliNode)) -> LayoutJob {
-            let (font, dft_color, dark_mode, smali_node) = key;
-            let mut job = LayoutJob::default();
-            let smali_style = if dark_mode { SmaliStyle::DARK } else { SmaliStyle::LIGHT };
-            let max_offset_len = max_offset_hint(smali_node).to_string().len();
-            append_node(&font, dft_color, &smali_style, smali_node, &mut job, 0, max_offset_len);
-            job
-        }
-    }
-
     type HighlightCache = FrameCache<LayoutJob, SmaliHighlighter>;
 
     let style = ui.ctx().style();

asm_server/src/impls/apk_load.rs

@@ -1,3 +1,4 @@
+use crate::impls::server::{ProgressMessage, ServerMessage};
 use crate::server::OpenFileError;
 use crate::Accessor;
 use java_asm::dex::{ClassDef, DexFile, DexFileAccessor};
@@ -7,6 +8,7 @@ use log::{error, warn};
 use std::collections::HashMap;
 use std::io::{Read, Seek};
 use std::sync::Arc;
+use tokio::sync::mpsc::Sender;
 use zip::ZipArchive;
 
 pub struct ApkAccessor {
@@ -15,7 +17,9 @@ pub struct ApkAccessor {
 
 type ClassPosition = (Arc<DexFileAccessor>, ClassDef);
 
-pub fn read_apk(zip_archive: ZipArchive<impl Read + Seek>) -> Result<ApkAccessor, OpenFileError> {
+pub async fn read_apk(
+    zip_archive: ZipArchive<impl Read + Seek>, sender: Sender<ServerMessage>,
+) -> Result<ApkAccessor, OpenFileError> {
     let mut zip_archive = zip_archive;
     // read dex files
     let mut dex_files = zip_archive
@@ -32,6 +36,7 @@ pub fn read_apk(zip_archive: ZipArchive<impl Read + Seek>) -> Result<ApkAccessor
     }).filter_map(|v|v).collect();
 
     // put dex files
+    let dex_file_count = dex_files.len();
     let dex_files = dex_files.iter().map(|name| {
         let mut file = zip_archive.by_index(*name).map_err(OpenFileError::LoadZip)?;
         let mut bytes = Vec::new();
@@ -46,10 +51,9 @@ pub fn read_apk(zip_archive: ZipArchive<impl Read + Seek>) -> Result<ApkAccessor
                 None
             }
         }
-    }).filter_map(|v| v).collect::<Vec<_>>();
-    let classes_count = dex_files.iter().map(|dex_file| dex_file.file.class_defs.len()).sum();
-    let mut map = HashMap::with_capacity(classes_count);
-    for dex_file in dex_files {
+    }).filter_map(|v| v);
+    let mut map = HashMap::new();
+    for (index, dex_file) in dex_files.enumerate() {
         for class_def in dex_file.file.class_defs.iter() {
             let class_idx = class_def.class_idx;
             let class_name = dex_file.get_type(class_idx);
@@ -63,11 +67,34 @@ pub fn read_apk(zip_archive: ZipArchive<impl Read + Seek>) -> Result<ApkAccessor
                 error!("Error when reading class name {}: {:?}", class_idx, class_name);
             }
         }
+        send_progress(&sender, index + 1, dex_file_count).await;
     };
     map.shrink_to_fit();
+    send_loaded(&sender).await;
     Ok(ApkAccessor { map })
 }
 
+async fn send_progress(
+    sender: &Sender<ServerMessage>, current: usize, total: usize,
+) {
+    let progress = current as f32 / total as f32;
+    let message = ServerMessage::Progress(ProgressMessage {
+        progress,
+        in_loading: true,
+    });
+    sender.send(message).await.unwrap();
+}
+
+async fn send_loaded(
+    sender: &Sender<ServerMessage>,
+) {
+    let message = ServerMessage::Progress(ProgressMessage {
+        progress: 1.0,
+        in_loading: false,
+    });
+    sender.send(message).await.unwrap();
+}
+
 // classes.dex -> 0
 // classes2.dex -> 2
 #[inline]

asm_server/src/impls/mod.rs

@@ -1,2 +1,4 @@
 
 pub(crate) mod apk_load;
+pub(crate) mod server;
+pub(crate) mod util;

asm_server/src/impls/server.rs

@@ -0,0 +1,32 @@
+use crate::ui::AppContainer;
+use crate::AsmServer;
+use log::info;
+use std::time::Instant;
+
+pub enum ServerMessage {
+    Progress(ProgressMessage),
+}
+
+pub struct ProgressMessage {
+    // 0.0 - 1.0
+    pub progress: f32,
+    pub in_loading: bool,
+}
+
+pub struct FileOpenContext {
+    pub path: String,
+    pub start_time: Instant,
+}
+
+
+impl AsmServer {
+    pub fn on_file_opened(
+        &self,
+        context: &FileOpenContext,
+        render_target: AppContainer,
+    ) {
+        let FileOpenContext { path, start_time } = context;
+        info!("open file {path} cost: {:?}", start_time.elapsed());
+        self.render_to_app(render_target);
+    }
+}

asm_server/src/impls/util.rs

@@ -0,0 +1,20 @@
+use std::future::Future;
+use std::sync::Arc;
+use tokio::runtime;
+use tokio::runtime::Runtime;
+
+pub fn new_tokio_thread<F, Fut>(async_logic: F)
+where
+    F: FnOnce(Arc<Runtime>) -> Fut + Send + 'static,
+    Fut: Future,
+{
+    std::thread::spawn(move || {
+        let runtime: Arc<Runtime> = runtime::Builder::new_multi_thread()
+            .enable_all().build().unwrap().into();
+        let copied_runtime = runtime.clone();
+        runtime.block_on(async move {
+            let runtime = copied_runtime;
+            async_logic(runtime).await;
+        });
+    });
+}

asm_server/src/server.rs

@@ -1,4 +1,6 @@
 use crate::impls::apk_load::read_apk;
+use crate::impls::server::{FileOpenContext, ServerMessage};
+use crate::impls::util::new_tokio_thread;
 use crate::ui::{AppContainer, DirInfo, Left};
 use crate::{Accessor, AccessorEnum, AccessorMut, AsmServer, LoadingState, ServerMut};
 use java_asm::smali::SmaliNode;
@@ -7,9 +9,10 @@ use log::{error, info};
 use std::fs::File;
 use std::io::{Read, Seek};
 use std::ops::{Deref, DerefMut};
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
 use std::time::Instant;
-use tokio::runtime;
+use tokio::sync::mpsc;
+use tokio::sync::mpsc::Sender;
 use zip::result::ZipError;
 use zip::ZipArchive;
 
@@ -28,53 +31,61 @@ impl AsmServer {
 
     pub fn smart_open(server: ServerMut, path: &str, render_target: AppContainer) {
         let context = FileOpenContext { path: path.to_string(), start_time: Instant::now() };
-        std::thread::spawn(move || {
-            let tokio_runtime = runtime::Builder::new_multi_thread()
-                .enable_all().build().unwrap();
-            tokio_runtime.block_on(async move {
-                let new_server = AsmServer::new();
-                let path = &context.path;
-                let accessor = new_server.accessor.clone();
-                if path.ends_with(".apk") {
-                    let opened_file = File::open(path);
-                    match opened_file {
-                        Ok(opened_file) => {
-                            let read_result = Self::from_apk(opened_file, accessor);
-                            if let Err(e) = read_result {
-                                error!("resolve file meets an error. {e:?}");
-                            }
+        new_tokio_thread(|runtime| async move {
+            let (sender, receiver) = mpsc::channel::<ServerMessage>(5);
+
+            let new_server = AsmServer::new();
+            *server.lock() = Some(new_server.clone());
+
+            let server_for_receiver = server.clone();
+            runtime.spawn(async move {
+                let server = server_for_receiver;
+                let mut receiver = receiver;
+                while let Some(msg) = receiver.recv().await {
+                    let mut server = server.lock();
+                    let server_ref = server.deref_mut();
+                    let Some(server_ref) = server_ref else { continue };
+                    match msg {
+                        ServerMessage::Progress(progress) => {
+                            println!("progress: {}", progress.progress);
+                            server_ref.loading_state.loading_progress = progress.progress;
+                            server_ref.loading_state.in_loading = progress.in_loading;
                         }
-                        Err(e) => {
-                            let error = OpenFileError::Io(e);
-                            error!("read {path} meet an io error. {error:?}");
+                    }
+                }
+            });
+
+            let path = &context.path;
+            let accessor = new_server.accessor.clone();
+            if path.ends_with(".apk") {
+                let opened_file = File::open(path);
+                match opened_file {
+                    Ok(opened_file) => {
+                        let read_result = Self::from_apk(opened_file, sender, accessor).await;
+                        if let Err(e) = read_result {
+                            error!("resolve file meets an error. {e:?}");
                         }
                     }
-                } else {
-                    error!("unsupported file type: {:?}", path);
-                };
-                *server.lock() = Some(new_server.clone());
-                new_server.on_file_opened(&context, render_target);
-            })
+                    Err(e) => {
+                        let error = OpenFileError::Io(e);
+                        error!("read {path} meet an io error. {error:?}");
+                    }
+                }
+            } else {
+                error!("unsupported file type: {:?}", path);
+            };
+            new_server.on_file_opened(&context, render_target);
         });
     }
 
-    fn on_file_opened(
-        &self,
-        context: &FileOpenContext,
-        render_target: AppContainer,
-    ) {
-        let FileOpenContext { path, start_time } = context;
-        info!("open file {path} cost: {:?}", start_time.elapsed());
-        self.render_to_app(render_target);
-    }
-
-    pub fn from_apk(
+    pub async fn from_apk(
         apk_content: impl Read + Seek,
+        sender: Sender<ServerMessage>,
         accessor: AccessorMut,
     ) -> Result<(), OpenFileError> {
         let zip = ZipArchive::new(apk_content)
             .map_err(OpenFileError::LoadZip)?;
-        let apk_accessor = read_apk(zip)?;
+        let apk_accessor = read_apk(zip, sender).await?;
         // safe unwrap, no other places in current thread will access it.
         *accessor.lock() = Some(AccessorEnum::Apk(apk_accessor));
         Ok(())
@@ -85,10 +96,6 @@ impl AsmServer {
     }
 }
 
-struct FileOpenContext {
-    pub path: String,
-    pub start_time: Instant,
-}
 
 /// input operation processing
 impl AsmServer {