Emitting Event During Loop

[genericblueprint]

Is it possible to emit a message to the frontend (JS) during a long loop running in the backend (Rust)? If so, may I see an example?

Essentially I would like to do some long running processes on the backend thread with Rust and I would like to send progress messages back to the frontend during them.

[genericblueprint]

Never mind, I was able to piece it together using std::thread.

[vanzylv]

Thanks for reply @FabianLars. I ended up doing this, unfortunately the event only seems to publish once the loop has run and only once.

while let Some(chunk) = stream.chunk().await.unwrap() {
        let window = window.clone();
        let id = id.clone();
        std::thread::spawn(move || {
            window.emit(
                "download://progress",
                ProgressPayload {
                    id,
                    progress: chunk.len() as u64,
                    total: total as u64,
                },
            ).unwrap();
        });
    }

And on the UI :

import { appWindow } from '@tauri-apps/api/window'

await appWindow.listen(Event.DOWNLOAD_PROGRESS, (event) => {
    console.log(event.payload, Event.DOWNLOAD_PROGRESS)
})

Console :

Complete Rust command:

#[tauri::command]
async fn download(id: String, download_dir: String, window: Window) {
    println!("id: {}", id);
    println!("download_dir: {}", download_dir);

    let video_options = VideoOptions {
        quality: VideoQuality::Lowest,
        filter: VideoSearchOptions::Video,
        ..Default::default()
    };

    let video = Video::new_with_options(&id, video_options).unwrap();
    let stream = video.stream().await.unwrap();
    let total = stream.content_length();

    println!("total: {}", total);

    while let Some(chunk) = stream.chunk().await.unwrap() {

        let window = window.clone();
        let id = id.clone();

        std::thread::spawn(move || {
            window.emit(
                "download://progress",
                ProgressPayload {
                    id,
                    progress: chunk.len() as u64,
                    total: total as u64,
                },
            ).unwrap();
        });
    }

    // Or direct download to path
    let path = std::path::Path::new("/Users/xxx/Downloads/test.mp4");

    video.download(path).await.unwrap();
}

When I do this it works fine :

 for i in 1..100 {
     std::thread::sleep(std::time::Duration::from_millis(150));
     // emit a download progress event to all listeners registed in the webview
     window.emit("download://progress", i);
 }

[FabianLars]

This looks like a "problem" with the download. chunk.len() == total means that the loop indeed only triggered once for the whole download. Looking at the source code of the crate (https://docs.rs/rusty_ytdl/latest/src/rusty_ytdl/info.rs.html#362) it sets a chunk size of 10mb by default, which is 10485760 in chunk size which is more than the video you tried to download (if the total size is correct of course).

[vanzylv]

@FabianLars, you're a genius. Thank you kindly for looking into that. Question, like mentioned before, I have next to no experience with Rust, can you see any obvious horrible errors I'm making in my code. The cloning feels a bit wrong, especially window, or would this be relatively normal practice.

[FabianLars]

Your code is mostly alright. The only thing a bit concerning is a thread::spawn. Spawning threads is relatively slow and if we're talking about long videos that actually trigger the loop multiple times it's fairly inefficient. Also it's not really required here as far as i can see, and if you remove it you can remove the window clone too.
btw, cloning AppHandle and Window instances is relatively cheap so don't break your back trying to get rid of all clone calls.

[vanzylv]

Excellent thanks again @FabianLars

[elibroftw]

@FabianLars how about if we wanted an infinite loop that does async tasks? How would we go about using app_handle then that doesn't surmount to https://github.com/rfdonnelly/tauri-async-example/blob/main/src-tauri/src/main.rs

This is what I got so far. But the emit all in the function is not seen by the frontend. I can verify the listen is set up correctly, since I did another test, but in that test of the infinite loop, it doesn't work past the first time.

What I want

.setup(|app| {
       let app_handle = app.handle();
        tauri::async_runtime::spawn(async move {
        status_stream_process(&app_handle).await;
      });
}

pub async fn status_stream_process<R: tauri::Runtime>(manager: impl Manager<R>) { ... }

The test that doesn't work

.setup(|app| {
let app_handle = app.handle();
tauri::async_runtime::spawn(async move {
   loop {
     tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
     app_handle.emit_all("daemonStatusUpdate", "testUpdate").unwrap();
   }
});
}

[FabianLars]

Sorry for the long delay. Both of your code snippets look fine as far as i can see (except the missing & for the manager argument). At least if rust compiles it should work.

There was an issue that prevented global events from reaching window specific listeners so make sure all your rust packages (js and rust) are on the latest versions. If that still doesn't work check if appWindow.listen and event.listen behave differently.

but in that test of the infinite loop, it doesn't work past the first time.

tbh that sounds like the frontend somehow just unlistened to the event 🤔

[elibroftw]

Thanks the reply. I figured it out this past weekend. The original code had a break inside a match inside the loop which would break out the loop. Once removed the code works as desired.

I usually don't code in rust which is why I either forgot or never knew that a break applies to all loops and that continue is what I was looking for.

[Marcelo-maga]

Hi, sorry for reopening such an old topic, but I'm not sure how I can proceed, I have a piece of code basically the same as elibroftw, but I have a function to use the abort() method in this thread, but even the code apparently being executed, the loop within async_runtime does not stop. Is there any way to finish it?