How can I spawn a window every x amount of time? | Tauri Apps | Page 1

vocal thistle Jul 23, 2023, 5:35 PM

#

Hi, I wanted to build an app that requires me to spawn a window every x amount of time. The flow looks like:

Window opens
When event from the frontend (solid.js in my case, but id doesn't matter i guess) is send to the current window it closes
After 10 seconds (doesn't matter, could be 2 hours) the window appears again

I have very little experience with Rust (though learning about it as much as I can). This is what I came up with but it doesn't work. Tauri terminates when I call .close() on the created window.

In addition I don't know how to handle waiting for an event before calling sleep. I am doing appWindow.emit("break-end") on the frontend.

Any suggestions / docs I could look at?

fn main() {
    tauri::Builder::default()
        .setup(|app| {
            let handle = app.handle();

            tauri::async_runtime::spawn(async move {
                loop {
                    // Spawn window
                    let window = tauri::WindowBuilder::new(
                        &handle,
                        "app",
                        tauri::WindowUrl::App("index.html".into()),
                    )
                    .build()
                    .unwrap();

                    // I really would like to make this happen on an event from the solid app.
                    tokio::time::sleep(tokio::time::Duration::from_secs(10)).await;
                    window.close().unwrap(); // This closes the whole app.

                    // Wait for 10 seconds before spawning another window.
                    tokio::time::sleep(tokio::time::Duration::from_secs(10)).await;
                }
            });

            Ok(())
        })
        .run(tauri::generate_context!())
        .unwrap();
}

vocal thistle Jul 23, 2023, 8:38 PM

#

Well, I have found the answer for tauri exiting on window close. This is my code for now.

fn main() {
    let app = tauri::Builder::default()
        .setup(|app| {
            let handle = app.handle();

            tauri::async_runtime::spawn(async move {
                loop {
                    let window = tauri::WindowBuilder::new(
                        &handle,
                        "app",
                        tauri::WindowUrl::App("index.html".into()),
                    )
                    .build()
                    .unwrap();

                    // I really would like to make this happen on an event from the solid app.
                    tokio::time::sleep(tokio::time::Duration::from_secs(10)).await;

                    window.close().unwrap();

                    // Wait for 10 seconds before spawning another window.
                    tokio::time::sleep(tokio::time::Duration::from_secs(10)).await;
                }
            });

            Ok(())
        })
        .build(tauri::generate_context!())
        .expect("failed to build the tauri app");

    app.run(|_app_handle, event| match event {
        tauri::RunEvent::ExitRequested { api, .. } => api.prevent_exit(),
        _ => {}
    })
}

rocky edge Jul 23, 2023, 8:39 PM

#

tauri::Builder::default()
  .build(tauri::generate_context!())
  .expect("error while building tauri application")
  .run(|_app_handle, event| match event {
    tauri::RunEvent::ExitRequested { api, .. } => {
      api.prevent_exit();
    }
    _ => {}
  });

vocal thistle Jul 23, 2023, 8:39 PM

#

Yeah 😄

#

But still, is there a way to block in this async block until event arrives?

#

At the end I would like to have a setTimeout in my solid app, which would emit an event.

rocky edge Jul 23, 2023, 8:41 PM

#

I have a little project that does basically what you wanna do. Just a small learning project, made it yesterday. I can upload it to github in a while, just gotta wake up a bit more

The basics of it is using a channel that you recv so it pauses until you get a signal, and on the window you add listeners for the close event as well as any extra events you need to handle what the user is doing

vocal thistle Jul 23, 2023, 8:42 PM

#

I would love that

#

I want to do my own take-a-break reminder, so it would block my screen for some time each hour, but having an additional button that could leave (or postpone) the break would be pretty useful for some situations, that's why I want to have the break-end to be controlled by the frontend app.

rocky edge Jul 23, 2023, 8:47 PM

#

What my little app does is every N seconds is it pops up a window with a question you gotta answer for it to go away, to help you be forced to learn stuff

vocal thistle Jul 23, 2023, 8:47 PM

#

oh wow, that is really cool.

rocky edge Jul 23, 2023, 8:48 PM

#

#off-topic message

#

Doesnt look so cool x)

#

But it does what it should

vocal thistle Jul 23, 2023, 8:52 PM

#

So, do you have a loop in some thread (or the tokio thing, idk if it is called thread too now, it is 11pm in Poland 😂 ) too?

rocky edge Jul 23, 2023, 8:58 PM

#

I'll upload it to Github as well, just gotta clean up some stuff first, but here's the basics of it (I use version 2 but this stuff should be more or less identical to version 2)

In main.rs I start a new thread with a function that gets an AppHandle, and I register the prevention of exiting

        .setup(|app| {
            let _ = tauri::async_runtime::spawn(crate::quizzer::run(app.handle()));
            Ok(())
        })
        .build(tauri::generate_context!())
        .expect("error while running tauri application")
        .run(|_app_handle, event| match event {
            tauri::RunEvent::ExitRequested { api, .. } => {
                api.prevent_exit();
            }
            _ => {}
        });
}

#

Lets see, this one is longer, how to write it...

#

In quizzer.rs I have a let (tx, mut rx) = tokio::sync::mpsc::channel(1);

#

I register on the quizzer window the destroyed event to emit a signal

            tauri::WindowEvent::Destroyed => {
                {
                    let state = handle.state::<Mutex<QuizzyState>>();
                    let mut lock = state.lock().unwrap();
                    trace!("Decreasing to {}%", lock.timer.decrement);
                    lock.timer.counter = (lock.timer.counter as f64 * lock.timer.decrement) as u64;
                    trace!("Increasing by: {}", lock.timer.increment as u64);
                    lock.timer.counter += lock.timer.increment as u64;
                }
                let l = sender.lock().unwrap();
                futures::executor::block_on(async move {
                    let _ = l.send(()).await;
                });
            }

#

The recv happens last

        trace!("Recving");
        let _ = rx.recv().await.unwrap();
        let state = app.state::<Mutex<QuizzyState>>();
        let sleep_time = state.lock().unwrap().timer.counter.clone();
        trace!("Sleeping for {} seconds", sleep_time);
        quizzer_window.unlisten(fail_handler);
        tokio::time::sleep(tokio::time::Duration::from_secs(sleep_time)).await;

vocal thistle Jul 23, 2023, 9:00 PM

#

oooooooooh right

#

thanks

rocky edge Jul 23, 2023, 9:01 PM

#

No problem 🙂 I'l upload it so you can check the full code but that's the gist of what's going on

vocal thistle Jul 23, 2023, 9:01 PM

#

btw let me know when you put this app on Github

#

I can help with ui a little if you want

rocky edge Jul 23, 2023, 9:01 PM

#

This btw is how I listen to window events

        let handle = app.app_handle();
        let fail_handler = quizzer_window.once("fail", move |_| {
            let state = handle.state::<Mutex<QuizzyState>>();
            let mut lock = state.lock().unwrap();
            let mut decrease = lock.timer.increment * 2.0;
            if lock.timer.counter > 1 {
                while decrease > lock.timer.counter as f64 {
                    decrease = decrease * 0.5;
                }
                trace!("Decreasing by: {}", decrease as u64);
                lock.timer.counter -= decrease as u64;
            }
        });

vocal thistle Jul 23, 2023, 9:03 PM

#

oh, so you are not using sleep for sleeping?

rocky edge Jul 23, 2023, 9:03 PM

#

I am using recv to detect when the window has exited, then once I get the signal I start the sleep

vocal thistle Jul 23, 2023, 9:04 PM

#

rocky edge The recv happens last ```rust trace!("Recving"); let _ = rx.recv...

oh whatever

vocal thistle Jul 23, 2023, 9:06 PM

#

rocky edge This btw is how I listen to window events ```rust let handle = app.app_h...

So this lock.timer.counter decreasing is your "business logic"? I mean it has something to do with how your app works or it is required for the window spawn every 10 seconds?

rocky edge Jul 23, 2023, 9:08 PM

#

https://github.com/simonhyll/skolio

#

There we go

vocal thistle Jul 23, 2023, 9:09 PM

#

Thanks a lot, I will give it a look tomorrow (<24h)

rocky edge Jul 23, 2023, 9:09 PM

#

vocal thistle So this lock.timer.counter decreasing is your "business logic"? I mean it has so...

The timer stuff is part of how my app work, so you could say the "business logic". What I do isn't just statically every like 15 minutes, it asks you a question, if you get it wrong the next question happens faster, so the more you screw up the faster you get questions, and the more correct answers you get the longer the sleep is

vocal thistle Jul 23, 2023, 9:10 PM

#

okay, got it

rocky edge Jul 23, 2023, 9:11 PM

#

Most of the magic you want is in crates/backend/src/quizzer.rs

vocal thistle Jul 23, 2023, 9:15 PM

#

The moment I saw mpsc::channel I remembered I have watched a crust of rust episode abuot channels

#

https://www.youtube.com/watch?v=b4mS5UPHh20&ab_channel=JonGjengset

YouTube

Jon Gjengset

Crust of Rust: Channels

In this (fifth) Crust of Rust video, we cover multi-produce/single-consumer (mpsc) channels, by re-implementing some of the std::sync::mpsc types from the standard library. As part of that, we cover what channels are used for, how they work at a high level, different common channel variants, and common channel implementations. In the process, we...

▶ Play video

rocky edge Jul 23, 2023, 9:16 PM

#

Jon Gjengset has such great videos on Rust 🙂

#How can I spawn a window every x amount of time?