Is this the idiomatic Slint way of communicating with UI from separate thread?

[maxenko]

I am learning Rust because of Slint.
Coming from .net I often use mailbox processor to drive the application (F#/C#), with UI getting updates from other threads (via Dispatcher).

After some experimentation I got this pattern to work in test Slint/Rust app.

My question is, does Slint have built in facilities for that or is one expected to use std::sync::mpsc::channel ?

I am currently using it like this (excerpt) :

    let ui = AppWindow::new()?;
    let ui_a = Arc::new(ui);
    let ui_handle = ui_a.as_weak();
    let (tx, rx) = std::sync::mpsc::channel::<i32>();
    let sender = Arc::new(Mutex::new(tx));

    let mailbox_processor = async_std::task::block_on(
        {
            let sender = sender.clone();
            mb(
                Arc::new(
                    {   
                        let sender = sender.clone();
                        move |state| {
                            let sender = sender.clone();
                            println!("State updated to: {}", state);
                            std::thread::spawn(move || {
                                sender.lock().unwrap().send(state).expect("Failed to send update");
                            });
                        }
                    }
                )
            )
        }
    );

    // message polling thread
    thread::spawn(move || {
        for received in rx {
            println!("Received: {}", received);

            // send msg to main (thread)
            let ui_handle_clone = ui_handle.clone();
            let _ = slint::invoke_from_event_loop(move || {
                if let Some(ui) = ui_handle_clone.upgrade() {
                    ui.set_counter(received);
                }
            });
        }
    });

Thank you.

[ogoffart]

The problem with the code you gave is that it doesn't seem to run the event loop in the main thread. You probably shouldn't call async_std::task::block_on in the main thread.
Instead, you can use slint::spawn_local https://docs.rs/slint/latest/slint/fn.spawn_local.html to run a future in the main event loop. But don't forget to call slint::run_event_loop after spawning your thread

[maxenko]

Thank you for the link, slint::spawn_local didn't quiet fit the design, i need to update ui from mailbox_processor event(s) which are async, but digging further slint::invoke_from_event_loop does fit perfectly, updated:

use std::sync::Arc;

mod types;
mod state;
mod runtime;
mod event;

slint::include_modules!();

#[async_std::main]
async fn main() -> Result<(), slint::PlatformError> {

    let ui = AppWindow::new()?;
    let runtime = Arc::new(runtime::Runtime::new().await);
    let ui_handle = ui.as_weak();

    // runtime wraps mailbox_processor
    runtime.on_state_change.lock().await.subscribe({

        move |state| {
            let ui_handle = ui_handle.clone();
            slint::invoke_from_event_loop( move || {
                let ui = ui_handle.unwrap();
                ui.set_counter(state.message_count as i32);
            }).unwrap();
            println!("State counter 2: {}", state.message_count);
        }
    });

    ui.on_request_increase_value(
        move || {
            runtime.clone().send(types::InMessageType::State);
        }
    );

    ui.run()
}