Emit change to frontend from rust?!

[FrankLaterza]

I'm working on a serial monitor app with Tauri and I'm trying to figure out how I can use an event to emit change to the frontend. I'm aware of the example listed in the docs, but this seems to only be a solution for the setup only. The serial data is getting updated from a tokio thread and will print whenever there are new serial data.

My current solution is to keep pinging the backend for any new serial data every 25ms. As you can imagine I'm not satisfied with this solution. Let me know if anyone has encountered this or has some solutions they could share. Thank you!

[FabianLars]

but this seems to only be a solution for the setup only

Well, not reallyyy. All you need is access to an AppHandle or Window instance (which you can get from the setup hook, all the event handlers, and tauri commands). If for some reason you can't move an AppHandle into the tokio thread you could look into a OnceCell (part of the latest rust version or the once_cell crate) to make a global-ish AppHandle.

[FrankLaterza]

Success! This was exactly what I needed. If anyone is curious allow me to share my findings.

In the rust, I was able to create a command and pass in the app handle as a parameter.

// define the payload struct
#[derive(Clone, serde::Serialize)]
struct Payload {
    message: String,
}

// make the command
#[tauri::command]
async fn test_app_handle(app: tauri::AppHandle) {
  app.emit_all("event-name", Payload { message: "Tauri is awesome!".into() }).unwrap();
}

In the frontend, we need to start listening for the event. This is how I set it up using typescript

// same type as payload
type Payload = {
    message: string;
};

async function startSerialEventListener() {
    await listen<Payload>('event-name', (event) => {
        console.log("Event triggered from rust!\nPayload: " + event.payload.message);
    });
}

After I defined these I created a button on the frontend that starts listening to the event and calls the tauri command. This will trigger the listener and print your message to the console log. I hope this helps anyone with the same issue. Thanks for the save @FabianLars

[BigBIueWhale]

And who calls test_app_handle?

The original issue is that app.handle() is only available in the .setup

[FabianLars]

The above example is a Tauri command (https://tauri.app/v1/guides/features/command) so it's typically called from the js/frontend side in which case Tauri will inject the AppHandle for you.

[restush]

For someone out there that confused how to make a global AppHandle using once_cell

use tauri::{Manager,App,AppHandle};
use once_cell::sync::OnceCell;

#[derive(Clone, serde::Serialize)]
struct Payload {
  message: String,
}

static GLOBAL_APP_HANDLE: OnceCell<AppHandle> = OnceCell::new();

// this execute on my other script
pub fn MyCallbackOnClick(message: std) {
     if let Some(app_handle) = GLOBAL_APP_HANDLE.get() {
         app_handle.emit_all("onClick", Payload { message: result.into() }).unwrap();
     }    
}


fn main() {
    tauri::Builder::default()
        .build(tauri::generate_context!())
        .expect("Error while running Tauri application")
        .run(|_app_handle, event| match event {
            tauri::RunEvent::Ready => { 
                println!("Window loaded");
                GLOBAL_APP_HANDLE.set(_app_handle.clone()).expect("Failed to set global app handle");
            }
            _ => {}
        })
}