How to extract builder setup function and make it async?

[HuakunShen]

I am trying to start a local http server with Tauri app then verify that it's running in the setup function, if server is not running then an event should be emitted.

2 Questions:

1. Not sure what the function signature for setup function should be, the current version I use doesn't give me error.
2. Problem: there is error when I make setup() async
   • the verify_local_server() function is async, thus I have to make setup async, and this causes error in .setup(setup).

The error is:

expected `for<'a> fn(&'a mut App) -> impl Future<Output = Result<(), Box<(dyn Error + 'static)>>> {setup}` to be a fn item that returns `Result<(), Box<(dyn Error + 'static)>>`, but it returns `impl Future<Output = Result<(), Box<(dyn Error + 'static)>>>`
    expected enum `Result<(), Box<(dyn StdError + 'static)>>`
found opaque type `impl Future<Output = Result<(), Box<(dyn StdError + 'static)>>>`

I don't know how to fix this error. It seems like it's caused by async.

fn start_server() -> Result<(), Box<dyn Error>> {
    tauri::async_runtime::spawn(
        get_server()?
    );
    Ok(())
}

async fn setup<'a>(app: &'a mut tauri::App) -> Result<(), Box<dyn std::error::Error>> {
    start_server()?;
    let verify_result = verify_local_server().await;
    match verify_result {
        Ok(_) => {
            println!("Local Server is running");
        }
        Err(err) => {
            app.emit_all("local-server-down", ());
            println!("Local Server is not running");
            println!("{}", err);
        }
    }
    Ok(())
}

fn main() {
    tauri::Builder::default()
        .setup(setup)
        .invoke_handler(tauri::generate_handler![verify_local_server_cmd, emit_app])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

[HuakunShen]

How to use app in a Thread

I tried to put the async function call in a thread like the following

fn setup<'a>(app: &'a mut tauri::App) -> Result<(), Box<dyn std::error::Error>> {
    start_server()?;
    tauri::async_runtime::spawn(async {    // added this line
        let verify_result = verify_local_server().await;
        match verify_result {
            Ok(_) => {
                println!("Local Server is running");
            }
            Err(err) => {
                app.emit_all("local-server-down", ());
                println!("Local Server is not running");
                println!("{}", err);
            }
        }
    });
    Ok(())
}

Got another error on the inner async function.

`Rc<tao::event_loop::EventLoopWindowTarget<tauri_runtime_wry::Message<EventLoopMessage>>>` cannot be shared between threads safely
within `tauri::App`, the trait `std::marker::Sync` is not implemented for `Rc<tao::event_loop::EventLoopWindowTarget<tauri_runtime_wry::Message<EventLoopMessage>>>`
required for `&tauri::App` to implement `Send`

Tauri Command

app.emit_all + thread seem to work in a tauri command function

#[tauri::command]
pub fn emit_app<R: Runtime>(_app: AppHandle<R>) -> Result<(), String> {
    tauri::async_runtime::spawn(async move {
        _app.emit_all(
            "local-server-down",
            ReceiveCodePayload {
                code: String::from("test"),
            },
        )
    });
    Ok(())
}

[FabianLars]

1. Not sure what the function signature for setup function should be, the current version I use doesn't give me error.

minus the async part you basically got it right already. It's fn setup<'a>(app: &'a mut tauri::App) -> Result<(), Box<dyn std::error::Error>> -> https://docs.rs/tauri/latest/tauri/struct.Builder.html#method.setup

2. Problem: there is error when I make setup() async

The setup function itself just can't be async, simple as that. But as you figured out yourself, you can use tauri::async_runtime to spawn async tasks, or block on them (block_on to execute async functions as if they'd be sync).

Now the almost-solution you posted was almost there. The reason why your command worked is because it uses an AppHandle instead of App, so if you get an AppHandle via app.handle() in the setup hook and move that into the async task it should compile:

fn setup<'a>(app: &'a mut tauri::App) -> Result<(), Box<dyn std::error::Error>> {
    start_server()?;

  // This one
  let handle = app.handle();

    tauri::async_runtime::spawn(async move { // also added move here
        let verify_result = verify_local_server().await;
        match verify_result {
            Ok(_) => {
                println!("Local Server is running");
            }
            Err(err) => {
                handle.emit_all("local-server-down", ()); // changed this to handle.
                println!("Local Server is not running");
                println!("{}", err);
            }
        }
    });
    Ok(())
}

[HuakunShen]

Thank you so much for your help!!

[SurajRaika]

thank you so much

[Skarian]

This was extremely helpful, thank you!