Rewrite tauri_plugin_localhost to fix Linux resource loading issues

bins/ayaka-gui/src-tauri/Cargo.toml

@@ -12,7 +12,10 @@ flexi_logger = { version = "0.24", default-features = false, features = ["colors
 serde_json = "1.0"
 serde = { version = "1.0", features = ["derive"] }
 tauri = { version = "1.2", features = ["cli", "protocol-all", "window-all"] }
-tauri-plugin-localhost = "0.1"
+tiny_http = "0.12"
+url = "2.3"
+minreq = "2.6"
+mime_guess = "2.0"
 portpicker = "0.1"
 trylog = "0.2"
 

bins/ayaka-gui/src-tauri/src/asset_resolver.rs

@@ -0,0 +1,103 @@
+use std::{path::PathBuf, sync::OnceLock};
+use tauri::{
+    plugin::{Builder, TauriPlugin},
+    Runtime,
+};
+use tiny_http::{Header, Server};
+
+pub(crate) static ROOT_PATH: OnceLock<PathBuf> = OnceLock::new();
+
+pub fn init<R: Runtime>(dev_url: String, port: u16) -> TauriPlugin<R> {
+    Builder::new("asset_resolver")
+        .setup(move |app| {
+            let asset_resolver = app.asset_resolver();
+            std::thread::spawn(move || {
+                let server = Server::http(format!("127.0.0.1:{port}"))
+                    .expect("Unable to start local server");
+                for req in server.incoming_requests() {
+                    let url = req.url().to_string();
+                    if cfg!(debug_assertions) {
+                        let _ = asset_resolver;
+                    } else if url.starts_with("/assets/")
+                        || url == "/"
+                        || url == "/live2d.min.js"
+                        || url == "/live2dcubismcore.min.js"
+                    {
+                        let asset = asset_resolver.get(url).unwrap();
+                        let mut resp = tiny_http::Response::from_data(asset.bytes);
+                        resp.add_header(
+                            Header::from_bytes("Content-Type", asset.mime_type)
+                                .expect("Unable to convert mime_type to Content-Type"),
+                        );
+                        req.respond(resp).expect("Unable to setup response");
+                        continue;
+                    }
+                    if url.starts_with("/fs/") {
+                        let path = ROOT_PATH
+                            .get()
+                            .unwrap()
+                            .clone()
+                            .join(url.strip_prefix("/fs/").unwrap());
+                        let file = if path.is_file() {
+                            std::fs::File::open(&path).unwrap()
+                        } else if path.is_dir() {
+                            match std::fs::File::open(path.join("index.html")) {
+                                Ok(file) => file,
+                                Err(_) => {
+                                    req.respond(tiny_http::Response::empty(404))
+                                        .expect("Unable to setup response");
+                                    continue;
+                                }
+                            }
+                        } else {
+                            req.respond(tiny_http::Response::empty(404))
+                                .expect("Unable to setup response");
+                            continue;
+                        };
+                        let mut resp = tiny_http::Response::from_file(file);
+                        if let Some(mime) = mime_guess::from_path(url).first() {
+                            resp.add_header(
+                                Header::from_bytes("Content-Type", mime.essence_str())
+                                    .expect("Unable to convert mime_type to Content-Type"),
+                            );
+                        }
+                        req.respond(resp).expect("Unable to setup response");
+                    } else if cfg!(debug_assertions) {
+                        let req_url = url::Url::parse(&dev_url).unwrap().join(&url).unwrap();
+                        let req_url = if req_url
+                            .path_segments()
+                            .unwrap()
+                            .last()
+                            .unwrap_or_default()
+                            .is_empty()
+                        {
+                            req_url.join("index.html").unwrap()
+                        } else {
+                            req_url
+                        };
+                        let resp = minreq::get(req_url).send().expect("Unable to send request");
+                        req.respond(tiny_http::Response::new(
+                            resp.status_code.into(),
+                            resp.headers
+                                .iter()
+                                .map(|(k, v)| {
+                                    Header::from_bytes(k.as_bytes(), v.as_bytes())
+                                        .expect("Unable to convert Header")
+                                })
+                                .collect(),
+                            resp.as_bytes(),
+                            None,
+                            None,
+                        ))
+                        .expect("Unable to setup response")
+                    } else {
+                        let _ = dev_url;
+                        req.respond(tiny_http::Response::empty(404))
+                            .expect("Unable to setup response")
+                    }
+                }
+            });
+            Ok(())
+        })
+        .build()
+}

bins/ayaka-gui/src-tauri/src/main.rs

@@ -2,7 +2,9 @@
     all(not(debug_assertions), target_os = "windows"),
     windows_subsystem = "windows"
 )]
-#![feature(absolute_path)]
+#![feature(once_cell)]
+
+mod asset_resolver;
 
 use ayaka_runtime::{
     anyhow::{self, anyhow, Result},
@@ -14,9 +16,11 @@ use serde::{Deserialize, Serialize};
 use std::{
     collections::{HashMap, HashSet},
     fmt::Display,
-    path::PathBuf,
+    path::Path,
+};
+use tauri::{
+    async_runtime::Mutex, command, utils::config::AppUrl, AppHandle, Manager, State, WindowUrl,
 };
-use tauri::{async_runtime::Mutex, command, AppHandle, Manager, State};
 use trylog::TryLog;
 
 type CommandResult<T> = std::result::Result<T, CommandError>;
@@ -70,7 +74,6 @@ impl OpenGameStatus {
 struct Storage {
     ident: String,
     config: String,
-    root_path: PathBuf,
     records: Mutex<Vec<ActionRecord>>,
     context: Mutex<Option<Context>>,
     current: Mutex<Option<RawContext>>,
@@ -81,15 +84,9 @@ struct Storage {
 impl Storage {
     pub fn new(ident: impl Into<String>, config: impl Into<String>) -> Self {
         let config = config.into();
-        let root_path = std::path::absolute(&config)
-            .unwrap()
-            .parent()
-            .unwrap()
-            .to_path_buf();
         Self {
             ident: ident.into(),
             config,
-            root_path,
             ..Default::default()
         }
     }
@@ -113,8 +110,8 @@ impl GameInfo {
 }
 
 #[command]
-fn absolute_path(storage: State<'_, Storage>, path: String) -> CommandResult<String> {
-    Ok(storage.root_path.join(path).to_string_lossy().into_owned())
+fn absolute_path(path: String) -> CommandResult<String> {
+    Ok(Path::new("/fs/").join(path).to_string_lossy().into_owned())
 }
 
 #[command]
@@ -426,9 +423,14 @@ fn main() -> Result<()> {
     let port =
         portpicker::pick_unused_port().ok_or_else(|| anyhow!("failed to find unused port"))?;
     info!("Picked port {}", port);
+    let mut context = tauri::generate_context!();
+    let window_url = WindowUrl::External(format!("http://127.0.0.1:{port}").parse().unwrap());
+    let dev_url = context.config().build.dev_path.to_string();
+    context.config_mut().build.dist_dir = AppUrl::Url(window_url.clone());
+    context.config_mut().build.dev_path = AppUrl::Url(window_url);
     tauri::Builder::default()
-        .plugin(tauri_plugin_localhost::Builder::new(port).build())
-        .setup(|app| {
+        .plugin(asset_resolver::init(dev_url, port))
+        .setup(move |app| {
             let ident = app.config().tauri.bundle.identifier.clone();
             let spec = LogSpecification::parse("warn,ayaka=debug")?;
             let log_handle = if cfg!(debug_assertions) {
@@ -467,6 +469,12 @@ fn main() -> Result<()> {
                         .to_string_lossy()
                         .into_owned()
                 });
+            let root_path = std::fs::canonicalize(&config)
+                .expect("configuration file not found")
+                .parent()
+                .unwrap()
+                .to_path_buf();
+            asset_resolver::ROOT_PATH.set(root_path).unwrap();
             app.manage(Storage::new(ident, config));
             Ok(())
         })
@@ -493,6 +501,6 @@ fn main() -> Result<()> {
             switch,
             history,
         ])
-        .run(tauri::generate_context!())?;
+        .run(context)?;
     Ok(())
 }

bins/ayaka-gui/src/interop/index.ts

@@ -1,9 +1,9 @@
-import { convertFileSrc, invoke } from "@tauri-apps/api/tauri"
+import { invoke } from "@tauri-apps/api/tauri"
 import { Locale } from 'vue-i18n'
 
 export async function conv_src(path?: string): Promise<string | undefined> {
     if (path) {
-        return decodeURIComponent(convertFileSrc(await invoke("absolute_path", { path: path })))
+        return decodeURIComponent(await invoke("absolute_path", { path: path }))
     }
     return undefined
 }