Manage Global State in Tauri

Managing global application state in Tauri is simple and versatile, whether for database connection pools, like using sqlx with Tauri or sharing an in-memory key-value store across threads.

First let's start with a basic struct to hold some global state and tell tauri to manage it in the setup hook inside of lib.rs.

use tauri::Manager;
 
struct AppState {
    message: &'static str,
}
#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    tauri::Builder::default()
        .plugin(tauri_plugin_shell::init())
        .invoke_handler(tauri::generate_handler![greet])
        .setup(|app| {
            app.manage(AppState {
                message: "Bad Chicken, Mess you up!",
            });
 
            Ok(())
        })
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

Here we import the tauri::Manager trait so we can call app.manage() later. Next, we define a struct called AppState with a message field.
Inside of the setup() hook we call app.manage() and create a new instance of AppState.

If we want to access this elsewhere, like in a command, we can pass the state into the command with tauri::State<T>.

#[tauri::command]
fn get_message(state: tauri::State<AppState>) -> &'static str {
    &state.message
}

Another way is to access the state from the app handle, this can be handy if we're accessing the state in a background thread.

pub fn run() {
    tauri::Builder::default()
        .plugin(tauri_plugin_shell::init())
        .invoke_handler(tauri::generate_handler![get_message])
        .setup(|app| {
            app.manage(AppState {
                message: "Bad Chicken, Mess you up!",
            });
 
            let handle = app.handle().clone();
 
            thread::spawn(move || {
                let state = handle.state::<AppState>();
 
                println!("message from new thread {}", state.message);
            });
 
            Ok(())
        })
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

Here we modify our run command to create a clone of an AppHandle, spawn a new thread moving the handle into it then we get the app state using app.state() with the "turbo fish" syntax to type hint AppState, then we finally print the message.

Now a single static message isn't very useful, but it can be handy in some apps to have a shared, mutable, key value store.

All we really have to do is tell the app to manage a Mutex with a HashMap inside like this:

.setup(|app| {
    use std::sync::Mutex;
    use std::collections::HashMap;
 
    let mut hash_map: HashMap<String, String> = HashMap::new();
    hash_map.insert("foo".into(), "bar".into());
 
    app.manage(Mutex::new(hash_map));
})...

However to access this we'd have to type hint like this:

let state = app.state::<Mutex<HashMap<String, String>>>();

It's not only a lot to type, but it's a little vague. So, we can type alias it.

type KeyValueStore = Mutex<HashMap<String, String>>;
 
 
// then access like this
let state = app.state::<KeyValueStore>();

Now if we wanted to insert new values or get them using commands we can write commands like this:

#[tauri::command]
fn insert(state: tauri::State<KeyValueStore>, key: String, value: String) {
    let mut hash_map = state.lock().unwrap();
 
    hash_map.insert(key, value);
}
 
#[tauri::command]
fn get_value(state: tauri::State<KeyValueStore>, key: String) -> Option<String> {
    let hash_map = state.lock().unwrap();
 
    hash_map.get(&key).cloned()
}

Because we're using a mutex to safely share the HashMap between threads we have to first call the lock() function on the mutex to gain access to the data, then we can insert or read a value from our key-value store.

In my first professional Tauri app, I used this approach to track nearby Bluetooth devices, storing their MAC addresses as keys and device info as values. New devices were added in a background thread, while the list was accessed via commands, which is very similar to what we just created.