Krys4lide/tauri/src-tauri/src/main.rs

// Prevents additional console window on Windows in release, DO NOT REMOVE!!
#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]

use futures::executor::block_on;

use tauri::http::{Response, Uri};

// Enable the services methods on Axum Router
use tower::{Service, ServiceExt};


/*** ROUTEUR ***/

async fn route_test() -> &'static str {
    "Hello, `/test/` !"
}

async fn route_root() -> &'static str {
    "Hello, `/` !"
}

async fn route_fallback(uri: axum::http::Uri) -> (axum::http::StatusCode, String) {
    (axum::http::StatusCode::NOT_FOUND, format!("No route for {uri}"))
}

/*** TAURI ***/

fn build_axum_request(uri: Uri) -> axum::http::Request<axum::body::Body> {
    axum::http::Request::builder()
        .uri(uri.to_string())
        .body(axum::body::Body::empty())
        .unwrap()
}

async fn call_axum(uri: Uri) -> axum::http::Response<axum::body::Body> {
    let mut routeur: axum::Router = axum::Router::new()
        .route("/test", axum::routing::get(route_test))
        .route("/", axum::routing::get(route_root))
        .fallback(route_fallback);

    let request = build_axum_request(uri);

    routeur
        .as_service()
        .ready()
        .await
        .unwrap()
        .call(request)
        .await
        .unwrap()
}

async fn build_tauri_response(axum_response: axum::http::Response<axum::body::Body>) -> Response<Vec<u8>> {
    let (parts, body) = axum_response.into_parts();

    let body_bytes = axum::body::to_bytes(body, usize::MAX).await.unwrap().to_vec();

    Response::builder()
        .status(parts.status.as_u16())
        .header("Content-Type", "text/html")
        .body(body_bytes)
        .unwrap()
}

// Learn more about Tauri commands at https://tauri.app/v1/guides/features/command
#[tauri::command]
fn greet(name: &str) -> String {
    format!("Hello, {}! You've been greeted from Rust!", name)
}

fn main() {
    tauri::Builder::default()
        // Tauri example using the tauri-plugin-shell
        .plugin(tauri_plugin_shell::init())
        .invoke_handler(tauri::generate_handler![greet])
        // Handling of the clego:// protocol through Axum
        .register_asynchronous_uri_scheme_protocol("clego", |_app, request, responder| {
            let uri = request.uri().clone();

            std::thread::spawn(move || {
                // Open this thread to execute asynchronous code avoid blocking the main thread while waiting for the response
                let axum_response = block_on(call_axum(uri));
                let response = block_on(build_tauri_response(axum_response));
                responder.respond(response);
            });
        })
        // Tauri execution
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}