Communicating with backend tokio event loop from UI

[jacklund]

Hi, I'm using Slint as a front-end UI with Rust, with a backend event loop using tokio. I'm new to Slint, but have some experience with Rust and concurrency.

I want to kick off the tokio event loop from a button in the UI, but I also want to communicate from the UI to the tokio loop while the latter is running. The typical way I'd do this is with a tokio channel, but when I try to do this, I run into ownership/copying issues passing the receive end of the channel to the backend. Here's what my code looks like:

#![deny(unsafe_code)]

#[cfg(target_arch = "wasm32")]
use wasm_bindgen::prelude::*;

use log::{debug, error, info};
use tokio::{select, sync::mpsc};
use my_crate::create_event_handler;

slint::include_modules!();

pub enum SlintEvent {
    Connect(String, String),
}

#[cfg_attr(target_arch = "wasm32", wasm_bindgen(start))]
pub fn main() {
    // This provides better error messages in debug mode.
    // It's disabled in release mode so it doesn't bloat up the file size.
    #[cfg(all(debug_assertions, target_arch = "wasm32"))]
    console_error_panic_hook::set_once();

    // Logging
    env_logger::init();

    // Create our app
    let app = App::new().unwrap();

    let app_handle = app.as_weak();

    // Get channel for communication
    let (tx, mut rx) = mpsc::unbounded_channel();

    // Start backend event loop from UI callback
    app.on_config(
        move || {
            let app_handle = app_handle.clone();
            // Spawn from UI thread
            slint::spawn_local(async_compat::Compat::new(async move {
                let mut event_handler = match create_event_handler().await
                {
                    Ok(event_handler) => event_handler,
                    Err(error) => {
                        error!("Error starting event handler: {}", error),
                        return;
                    }
                };

                // Start the event loop
                loop {
                    select! {
                        // Listen for events sent from the event handler to the UI
                        caller_event = event_handler.get_caller_event() => {
                            match caller_event {
                                // Match on events...
                             },
                        },

                        // Listen for events from the UI to the event handler
                        slint_event = rx.recv() => {   <--- Error occurs here
                            match slint_event {
                                // Match on events...
                            }
                        },
                    }
                }
            }))
            .unwrap();
        },
    );

This gives me an error, error[E0507]: cannot move out of 'rx', a captured variable in an 'FnMut' closure, which makes sense since I'm doing a "move" (although I wish there was a way to claim ownership of the variable in the closure, but 🤷).

My question is: is this the "canonical" way to do this? Is there a better way to send information from the UI thread back to the backend event loop? This all works fine if I don't trigger it from a UI callback, but I need some way of passing the initial values to the backend from a UI dialog.

Thanks for any help,

-Jack

[ogoffart]

I'm not sure what the config callback does. But it looks like it could be a problem if it is called several times. Do you really want to start several event loop?
Perhaps you should call the slint::spawn_local directly from main and not in on_config.

[jacklund]

It's a fair point. I probably should have explained that more (or at all). The config callback is from a dialog box which supplies the parameters for creating the event handler in the code snippet above (I removed the arguments to keep the code sample simple). My idea was that, once the parameters were supplied and the code running, I would disable the button for the config dialog box so it couldn't be called again (probably add some guards in the backend code to make sure of that as well).

I did originally call it directly from main, and that worked fine, but I do need input from the user as to the arguments to set up the event handler, so I switched to a dialog box and the above callback.

I am, however, open to any suggestions on better ways to accomplish this - I'm not a UI programmer, not even remotely, so I'm pretty much flying by the seat of my pants with the UI stuff. 😸

[jacklund]

Reading what I wrote, I realized that it really still doesn't explain what I'm trying to do.

Basically, I have an "event handler", which runs its own event loop in a separate thread and handles things like incoming network connections, events coming from the front-end, etc. The way I originally spiked it out was to just instantiate the event handler in main() (with some hardcoded values), run its event loop, and then call into it from any callbacks, which "worked", but I didn't have any way of passing in the values from the user.

When I changed it to having the config callback instantiate it, I realized that it'll be instantiated in the closure for the callback, so I figured I'd use the channel to communicate to it from the other callbacks (which, now that I'm thinking about it, probably won't work either). I think the fundamental problem I'm having is, how to instantiate an object in a callback (or somehow configure it if it's actually created in the main()), and then call it from the various callback closures. Since the event handler isn't Copy or Clone, I don't think I'll be able to even call it from the callback closures (unless I wrap it in an Arc or something, but that might not even work).

It occurred to me that maybe I'm trying to force a "backend-y" solution when there might be a simpler, "frontend-y" one that I don't know about, so I figured I'd ask here.

Sorry this so long and complicated 😞