Is there any way to call the backend without freezing the web window?

[Xoffio]

Hi,

First of all, Thanks you so much for the Tauri team. This code really is a game changer !

I am using Tauri to load some images from rust. My front end code looks something like this:

function startCaching(){

        for (let nFrame=0; nFrame<9; nFrame++){

            imageNumber = 1 + nFrame;
            invoke('get_image_raw_data', { imageNumber, canvasW, canvasH }).then((data_from_rust) => {
                rawImagesFrames.push(data_from_rust);
            })
        }
    }

And my backend code looks something like this:

#[tauri::command]
fn get_image_raw_data(image_number: i32, canvas_w: f32, canvas_h: f32) -> Result<Vec<u8>, String> {
  use image::GenericImageView;
  
  ...
  
  // Return raw image
  Ok(img_raw_data)

The problem is that when I call get_image_raw_data the main window freezes until I get all my data. Is this a bug or am I doing something wrong ?

P.S:

I found this issue that might be the same problem I am having. If this is actually a bug, is there any workaround while I white for the tauri team to solve it?

[FabianLars]

Make the command async, either by changing it to async fn or #[tauri::command(async)]. This way it doesn't run on the main thread.

[FabianLars]

tauri-invoke-http is faster than the main ipc, but not as fast as it could be since the payload still gets serialized to a string first.
So yeah, a completely separate system would be faster than invoke-http, yes, but using rocket for this sounds slightly overkill/too heavy to me :P

[Xoffio]

Great to heard that! I haven't used rocket. I was just searching on the internet for something that can help me solve this problem and that's how I found it. If you know something less overkill I would love to know. Thanks!

[FabianLars]

Well, my current go-to library (both in usage and recommendation) is axum, and before that came a long i liked warp too.

Lately I'm really going crazy and use the std TcpListener on way too many occasions, so if you like the pain, that could be an alternative too.

But yeah rocket may be a good choice if you're used to server frameworks in other high-level languages, probably a good starting point and it should be relatively easy to swap it out if needed.

[Xoffio]

I'll just post this code here in case someone has the same problem as me.

use axum::{
  routing::{get},
  Router,
};
use std::net::SocketAddr;

#[tokio::main]
async fn main() {

  tokio::spawn(async {
    // build our application with a route
    let app = Router::new()
    // `GET /` goes to `root`
    .route("/", get(root));
  
    // run our app with hyper
    // `axum::Server` is a re-export of `hyper::Server`
    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    println!("listening on {}", addr);
    //tracing::debug!("listening on {}", addr);
    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
  });

  tauri::Builder::default()
    .invoke_handler(tauri::generate_handler![get_image_raw_data])
    .run(tauri::generate_context!())
    .expect("error while running tauri application");
}

// basic handler that responds with a static string
async fn root() -> &'static str {
  "This should return my raw Image"
}

@FabianLars I decided to go for Axum as your recommendation. For now this seems to be working. Tomorrow I'll try with an image an see the performance. @FabianLars Do you see anything wrong doing it this way? I had to make the main function async and call axum with a thread. I saw in this discussion you did it differently but I coun't replicated here.. After this Ill leave you alone. Thank you so much for all the help !!

[FabianLars]

Yep that's totally fine, you just need to give tauri a handle to the tokio runtime so that it won't try to spawn it's own (would result in a crash).
https://docs.rs/tauri/1.0.0-rc.13/tauri/async_runtime/fn.set.html