Unresponsive UI on task

[apertureless]

Hey. Sorry for the maybe dumb question, but I am trying out slint for the first time (and also a rust beginner).
I have a small application that, after you enter your password, will read an encrypted json file and decrypt it.

However looking at the docs, I am not sure how the communication should work in detail. Because most examples are quite basic.

Currently I have everything in the callback I defined in the slint file, after you click the start button.

#[derive(Debug)]
enum Keytype {
    Userkey,
    Masterkey,
}

fn read_key_file<P: AsRef<Path>>(path: P) -> Result<KeyFile, Box<dyn Error>> {
    let file = File::open(path).expect("Failed to open keyfile");
    let reader = BufReader::new(file);
    let u = serde_json::from_reader(reader)?;
    Ok(u)
}

fn get_keytype(input: &str) -> Keytype {
    match input {
        "User" => Keytype::Userkey,
        "Master" => Keytype::Masterkey,
        _ => panic!("Unexpected keytype {}", input),
    }
}

fn get_key_path(input: Keytype) -> String {
    match input {
        Keytype::Userkey => String::from("user_keys.json"),
        Keytype::Masterkey => String::from("master_keys.json"),
    }
}
fn main() -> Result<(), slint::PlatformError> {
    let ui = AppUi::new()?;
    let ui_handle = ui.as_weak();

    ui.on_start_decrypt(move | password | {
        let ui = ui_handle.unwrap();
        let key = ui.get_current_key();
        let key_type = get_keytype(&key);
        let key_path = get_key_path(key_type);

        let kf = read_key_file(key_path).expect("Failed to read keyfile.");
        let wallet_result = Wallet::unlock(kf, &password);

        match wallet_result {
            Ok(w) => {
                let _ = process_reports("reports.json", w).expect("Failed process reports");
            }
            Err(e) => ui.invoke_show_error_popup(),
        };
    });

    ui.run()
}

process_reports will use BufReader to stream the json and decrypt each entry and write it to a new json.
However, after pressing the button, the whole UI becomes unresponsive until it finished. So I guess it's kinda blocked.

Are there any examples on how to handle longer running tasks?

[bjorn]

Are there any examples on how to handle longer running tasks?

Since your task appears to be CPU-bound, I think you'll want to spawn a thread to do the work and eventually move the result back to the main thread to show in the UI. Slint provides slint::invoke_from_event_loop for this, and I think the example provided in the documentation should help.

[apertureless]

Ah, gotcha! Thanks. Thats what I was missing. I tried threads, but got crashes. Now its working.
Even tho I am not sure if its the best / cleanest way. :D

fn main() -> Result<(), slint::PlatformError> {
    let app_ui = AppUi::new().unwrap();
    let app_ui_weak = app_ui.as_weak();
    let ui_response = app_ui_weak.as_weak();

    app_ui.on_start_decrypt(move |password| {
        let handle = app_ui_weak.clone();
        let key = handle.unwrap().get_current_key();
        let key_type = get_keytype(&key);
        let key_path = get_key_path(key_type);

        let worker = thread::spawn({
            let handle_copy = ui_response.clone();
            move || {
                let kf = read_key_file(key_path).expect("Failed to read keyfile.");
                let wallet_result = Wallet::unlock(kf, &password);

                match wallet_result {
                    Ok(w) => {
                        let p = process_reports("reports.json", w);

                        match p {
                            Ok(_) => slint::invoke_from_event_loop(move || {
                                handle_copy.unwrap().invoke_show_success_popup()
                            })
                            .unwrap(),
                            Err(_) => slint::invoke_from_event_loop(move || {
                                handle_copy.unwrap().invoke_show_error_popup()
                            })
                            .unwrap(),
                        }
                    }
                    Err(_) => {
                        slint::invoke_from_event_loop(move || {
                            handle_copy.unwrap().invoke_show_error_popup()
                        })
                        .unwrap();
                    }
                }
            }
        });
    });

    app_ui.run()
}

[bjorn]

Yeah, just a few things you could change to improve your code:

• Instead of let ui_response = app_ui_weak.as_weak(); you could write let ui_response = app_ui_weak.clone();, which I think is more clear, and this line can be moved inside the callback handler.

• You don't need let handle = app_ui_weak.clone();, since it's just used once, you could instead directly do let key = app_ui_weak.unwrap().get_current_key();.

• Instead of:

  slint::invoke_from_event_loop(move || {
      handle_copy.unwrap().invoke_show_success_popup()
  })

  you can write:

  handle_copy.upgrade_in_event_loop(move |handle|
      handle.invoke_show_success_popup()
  })

• It seems to me there is no point in the additional move || { block just after spawning the thread. Maybe you'd need move || in thread::spawn(move || { instead (not sure, but that's what the example does).
  (never mind this one, I wasn't familiar with this way of scoping the variables that will be moved)

• If you can more clearly separate your code in the CPU-intensive part and the UI-updating part, you should only need a single invoke_from_event_loop or upgrade_in_event_loop call.

[apertureless]

Thanks for the suggestions @bjorn . 🙏
Well I need the handle multiple times, as I am also setting progress state etc. It is just not in the example here, to keep the code shorter.

Just another small question: At least on MacOs, after cargo build --release and run the program, it will always also open the terminal. Is this normal behaviour? Or do I have to do some additional build settings?

[bjorn]

Hmm, I only know the terminal popping up issue on Windows. For removing it on Windows, see #3235. I'm not sure why you're seeing that on macOS though.