creddy/src-tauri/src/main.rs

#![cfg_attr(
    all(not(debug_assertions), target_os = "windows"),
    windows_subsystem = "windows"
)]
use std::error::Error;
use std::sync::mpsc::channel;

use once_cell::sync::OnceCell;
use sqlx::{
    SqlitePool,
    sqlite::SqlitePoolOptions,
    sqlite::SqliteConnectOptions,
};
use tauri::{
    App,
    AppHandle,
    Manager,
    async_runtime as rt,
};
use tauri::api::dialog::{
    MessageDialogBuilder, 
    MessageDialogKind,
};

mod config;
mod errors;
mod clientinfo;
mod ipc;
mod state;
mod server;
mod tray;

use config::AppConfig;
use server::Server;
use errors::*;
use state::AppState;


pub static APP: OnceCell<AppHandle> = OnceCell::new();


async fn setup(app: &mut App) -> Result<(), Box<dyn Error>> {
    APP.set(app.handle()).unwrap();

    let conn_opts = SqliteConnectOptions::new()
        .filename(config::get_or_create_db_path()?)
        .create_if_missing(true);
    let pool_opts = SqlitePoolOptions::new();
    let pool: SqlitePool = pool_opts.connect_with(conn_opts).await?;
    sqlx::migrate!().run(&pool).await?;

    let conf = AppConfig::load(&pool).await?;
    let session = AppState::load_creds(&pool).await?;
    let srv = Server::new(conf.listen_addr, conf.listen_port, app.handle()).await?;

    config::set_auto_launch(conf.start_on_login)?;
    if !conf.start_minimized {
        app.get_window("main")
            .ok_or(RequestError::NoMainWindow)?
            .show()?;
    }

    let state = AppState::new(conf, session, srv, pool);
    app.manage(state);
    Ok(())
}


fn run() -> tauri::Result<()> {
    tauri::Builder::default()
        .system_tray(tray::create())
        .on_system_tray_event(tray::handle_event)
        .invoke_handler(tauri::generate_handler![
            ipc::unlock,
            ipc::respond,
            ipc::get_session_status,
            ipc::save_credentials,
            ipc::get_config,
            ipc::save_config,
        ])
        .setup(|app| rt::block_on(setup(app)))
        .build(tauri::generate_context!())?
        .run(|app, run_event| match run_event {
            tauri::RunEvent::WindowEvent { label, event, .. } => match event {
                tauri::WindowEvent::CloseRequested { api, .. } => {
                    let _ = app.get_window(&label).map(|w| w.hide());
                    api.prevent_close();
                }
                _ => ()
            }
            _ => ()
        });

    Ok(())
}


fn main() {
    if let Err(e) = run() {
        let (tx, rx) = channel();
        MessageDialogBuilder::new(
            "Creddy failed to start",
            format!("{e}")
        )
            .kind(MessageDialogKind::Error)
            .show(move |_| tx.send(true).unwrap());
        rx.recv().unwrap();
    }
}


macro_rules! get_state {
    ($prop:ident as $name:ident) => {
        use tauri::Manager;
        let app = crate::APP.get().unwrap(); // as long as the app is running, this is fine
        let state = app.state::<crate::state::AppState>();
        let $name = state.$prop.read().unwrap(); // only panics if another thread has already panicked
    };
    (config.$prop:ident as $name:ident) => {
        use tauri::Manager;
        let app = crate::APP.get().unwrap();
        let state = app.state::<crate::state::AppState>();
        let config = state.config.read().unwrap();
        let $name = config.$prop;
    };

    (mut $prop:ident as $name:ident) => {
        use tauri::Manager;
        let app = crate::APP.get().unwrap();
        let state = app.state::<crate::state::AppState>();
        let $name = state.$prop.write().unwrap();
    };
    (mut config.$prop:ident as $name:ident) => {
        use tauri::Manager;
        let app = crate::APP.get().unwrap();
        let state = app.state::<crate::state::AppState>();
        let config = state.config.write().unwrap();
        let $name = config.$prop;
    }
}


pub(crate) use get_state;