refactor: Improvements to src-tauri

Signed-off-by: quexeky <[email protected]>

Author: quexeky

Cargo.lock

@@ -1,48 +1,8 @@
-use database::{borrow_db_checked, borrow_db_mut_checked};
+use database::borrow_db_checked;
 use log::debug;
 use tauri::AppHandle;
 use tauri_plugin_autostart::ManagerExt;
 
-pub fn toggle_autostart_logic(app: AppHandle, enabled: bool) -> Result<(), String> {
-    let manager = app.autolaunch();
-    if enabled {
-        manager.enable().map_err(|e| e.to_string())?;
-        debug!("enabled autostart");
-    } else {
-        manager.disable().map_err(|e| e.to_string())?;
-        debug!("eisabled autostart");
-    }
-
-    // Store the state in DB
-    let mut db_handle = borrow_db_mut_checked();
-    db_handle.settings.autostart = enabled;
-    drop(db_handle);
-
-    Ok(())
-}
-
-pub fn get_autostart_enabled_logic(app: AppHandle) -> Result<bool, tauri_plugin_autostart::Error> {
-    // First check DB state
-    let db_handle = borrow_db_checked();
-    let db_state = db_handle.settings.autostart;
-    drop(db_handle);
-
-    // Get actual system state
-    let manager = app.autolaunch();
-    let system_state = manager.is_enabled()?;
-
-    // If they don't match, sync to DB state
-    if db_state != system_state {
-        if db_state {
-            manager.enable()?;
-        } else {
-            manager.disable()?;
-        }
-    }
-
-    Ok(db_state)
-}
-
 // New function to sync state on startup
 pub fn sync_autostart_on_startup(app: &AppHandle) -> Result<(), String> {
     let db_handle = borrow_db_checked();

client/src/autostart.rs

@@ -17,7 +17,7 @@ pub struct QueueUpdateEvent {
     pub queue: Vec<QueueUpdateEventQueueData>,
 }
 
-#[derive(serde::Serialize, Clone)]
+#[derive(Serialize, Clone)]
 pub struct StatsUpdateEvent {
     pub speed: usize,
     pub time: usize,

download_manager/src/frontend_updates.rs

@@ -1,8 +1,16 @@
 #![feature(duration_millis_float)]
+#![feature(nonpoison_mutex)]
+#![feature(sync_nonpoison)]
+
+use std::sync::{nonpoison::Mutex, LazyLock};
+
+use crate::{download_manager_builder::DownloadManagerBuilder, download_manager_frontend::DownloadManager};
 
 pub mod download_manager_builder;
 pub mod download_manager_frontend;
 pub mod downloadable;
 pub mod util;
 pub mod error;
-pub mod frontend_updates;
+pub mod frontend_updates;
+
+pub static DOWNLOAD_MANAGER: LazyLock<Mutex<DownloadManager>> = LazyLock::new(|| todo!());

download_manager/src/lib.rs

@@ -18,6 +18,12 @@ pub struct FetchGameStruct {
     version: Option<GameVersion>,
 }
 
+impl FetchGameStruct {
+    pub fn new(game: Game, status: GameStatusWithTransient, version: Option<GameVersion>) -> Self {
+        Self { game, status, version }
+    }
+}
+
 #[derive(Serialize, Deserialize, Clone, Debug, Default, Encode, Decode)]
 #[serde(rename_all = "camelCase")]
 pub struct Game {
@@ -33,6 +39,11 @@ pub struct Game {
     m_image_library_object_ids: Vec<String>,
     m_image_carousel_object_ids: Vec<String>,
 }
+impl Game {
+    pub fn id(&self) -> &String {
+        &self.id
+    }
+}
 #[derive(serde::Serialize, Clone)]
 pub struct GameUpdateEvent {
     pub game_id: String,

games/src/library.rs

@@ -100,7 +100,7 @@ impl ProcessManager<'_> {
         }
     }
 
-    fn get_log_dir(&self, game_id: String) -> PathBuf {
+    pub fn get_log_dir(&self, game_id: String) -> PathBuf {
         self.log_output_dir.join(game_id)
     }
 

process/src/process_manager.rs

@@ -6,16 +6,18 @@ use std::{
 };
 
 use bitcode::{Decode, DecodeOwned, Encode};
-use database::{borrow_db_checked, Database};
-use http::{header::{CONTENT_TYPE}, response::Builder as ResponseBuilder, Response};
+use database::{Database, borrow_db_checked};
+use http::{Response, header::CONTENT_TYPE, response::Builder as ResponseBuilder};
 
 use crate::error::{CacheError, RemoteAccessError};
 
 #[macro_export]
 macro_rules! offline {
     ($var:expr, $func1:expr, $func2:expr, $( $arg:expr ),* ) => {
 
-        async move { if $crate::borrow_db_checked().settings.force_offline || $crate::lock!($var).status == $crate::AppStatus::Offline {
+        async move { 
+            if ::database::borrow_db_checked().settings.force_offline 
+            || ::utils::lock!($var).status == ::client::app_status::AppStatus::Offline {
             $func2( $( $arg ), *).await
         } else {
             $func1( $( $arg ), *).await
@@ -81,10 +83,7 @@ pub fn get_cached_object_db<D: DecodeOwned>(
 pub fn clear_cached_object(key: &str) -> Result<(), RemoteAccessError> {
     clear_cached_object_db(key, &borrow_db_checked())
 }
-pub fn clear_cached_object_db(
-    key: &str,
-    db: &Database,
-) -> Result<(), RemoteAccessError> {
+pub fn clear_cached_object_db(key: &str, db: &Database) -> Result<(), RemoteAccessError> {
     delete_sync(&db.cache_dir, key).map_err(RemoteAccessError::Cache)?;
     Ok(())
 }
@@ -103,9 +102,9 @@ impl ObjectCache {
     }
 }
 
-impl TryFrom<Response<Vec<u8>>> for ObjectCache {    
+impl TryFrom<Response<Vec<u8>>> for ObjectCache {
     type Error = CacheError;
-    
+
     fn try_from(value: Response<Vec<u8>>) -> Result<Self, Self::Error> {
         Ok(ObjectCache {
             content_type: value
@@ -118,21 +117,24 @@ impl TryFrom<Response<Vec<u8>>> for ObjectCache {
             body: value.body().clone(),
             expiry: get_sys_time_in_secs() + 60 * 60 * 24,
         })
-
     }
 }
 impl TryFrom<ObjectCache> for Response<Vec<u8>> {
     type Error = CacheError;
     fn try_from(value: ObjectCache) -> Result<Self, Self::Error> {
         let resp_builder = ResponseBuilder::new().header(CONTENT_TYPE, value.content_type);
-        resp_builder.body(value.body).map_err(CacheError::ConstructionError)
+        resp_builder
+            .body(value.body)
+            .map_err(CacheError::ConstructionError)
     }
 }
 impl TryFrom<&ObjectCache> for Response<Vec<u8>> {
     type Error = CacheError;
 
     fn try_from(value: &ObjectCache) -> Result<Self, Self::Error> {
         let resp_builder = ResponseBuilder::new().header(CONTENT_TYPE, value.content_type.clone());
-        resp_builder.body(value.body.clone()).map_err(CacheError::ConstructionError)
+        resp_builder
+            .body(value.body.clone())
+            .map_err(CacheError::ConstructionError)
     }
 }

remote/src/cache.rs

@@ -11,10 +11,14 @@ use serde::Deserialize;
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
-struct DropHealthcheck {
+pub struct DropHealthcheck {
     app_name: String,
 }
-
+impl DropHealthcheck {
+    pub fn app_name(&self) -> &String{
+        &self.app_name
+    }
+}
 static DROP_CERT_BUNDLE: LazyLock<Vec<Certificate>> = LazyLock::new(fetch_certificates);
 pub static DROP_CLIENT_SYNC: LazyLock<reqwest::blocking::Client> = LazyLock::new(get_client_sync);
 pub static DROP_CLIENT_ASYNC: LazyLock<reqwest::Client> = LazyLock::new(get_client_async);

remote/src/utils.rs

@@ -80,11 +80,12 @@ bytes = "1.10.1"
 
 
 # Workspaces
-client = { path = "../client" }
+client = { version = "0.1.0", path = "../client" }
 database = { path = "../database" }
 process = { path = "../process" }
-remote = { path = "../remote" }
+remote = { version = "0.1.0", path = "../remote" }
 utils = { path = "../utils" }
+games = { version = "0.1.0", path = "../games" }
 
 [dependencies.dynfmt]
 version = "0.1.5"

src-tauri/Cargo.toml

@@ -1,4 +1,10 @@
-use crate::{lock, AppState};
+use database::{borrow_db_checked, borrow_db_mut_checked};
+use log::{debug, error};
+use tauri::AppHandle;
+use tauri_plugin_autostart::ManagerExt;
+use utils::lock;
+
+use crate::{AppState};
 
 #[tauri::command]
 pub fn fetch_state(
@@ -31,10 +37,39 @@ pub fn cleanup_and_exit(app: &AppHandle, state: &tauri::State<'_, std::sync::Mut
 
 #[tauri::command]
 pub fn toggle_autostart(app: AppHandle, enabled: bool) -> Result<(), String> {
-    toggle_autostart_logic(app, enabled)
+    let manager = app.autolaunch();
+    if enabled {
+        manager.enable().map_err(|e| e.to_string())?;
+        debug!("enabled autostart");
+    } else {
+        manager.disable().map_err(|e| e.to_string())?;
+        debug!("eisabled autostart");
+    }
+
+    // Store the state in DB
+    let mut db_handle = borrow_db_mut_checked();
+    db_handle.settings.autostart = enabled;
+    Ok(())
 }
 
 #[tauri::command]
 pub fn get_autostart_enabled(app: AppHandle) -> Result<bool, tauri_plugin_autostart::Error> {
-    get_autostart_enabled_logic(app)
+    let db_handle = borrow_db_checked();
+    let db_state = db_handle.settings.autostart;
+    drop(db_handle);
+
+    // Get actual system state
+    let manager = app.autolaunch();
+    let system_state = manager.is_enabled()?;
+
+    // If they don't match, sync to DB state
+    if db_state != system_state {
+        if db_state {
+            manager.enable()?;
+        } else {
+            manager.disable()?;
+        }
+    }
+
+    Ok(db_state)
 }