From e12045697ed326c8442ab1449939ab0e6303449e Mon Sep 17 00:00:00 2001 From: LynithDev <61880709+LynithDev@users.noreply.github.com> Date: Sun, 31 Mar 2024 22:00:42 +0200 Subject: [PATCH] feat: Settings manager --- onelauncher/src/lib.rs | 18 +++++++++++ onelauncher/src/settings.rs | 61 +++++++++++++++++++++++++++++++++++++ src-tauri/src/api/game.rs | 24 +++++++-------- src-tauri/src/api/mod.rs | 17 +++-------- 4 files changed, 94 insertions(+), 26 deletions(-) create mode 100644 onelauncher/src/settings.rs diff --git a/onelauncher/src/lib.rs b/onelauncher/src/lib.rs index 2e6fa70e..3a2e2bbb 100644 --- a/onelauncher/src/lib.rs +++ b/onelauncher/src/lib.rs @@ -7,6 +7,24 @@ pub mod error; pub mod game; pub mod logger; pub mod utils; +pub mod settings; pub use error::*; pub use logger::start_logger; + +pub struct AppState { + pub settings: settings::SettingsManager, + pub clients: game::client_manager::ClientManager, +} + +unsafe impl Send for AppState {} +unsafe impl Sync for AppState {} + +impl AppState { + pub fn new() -> crate::Result { + Ok(Self { + settings: settings::SettingsManager::new()?, + clients: game::client_manager::ClientManager::new()?, + }) + } +} diff --git a/onelauncher/src/settings.rs b/onelauncher/src/settings.rs new file mode 100644 index 00000000..14a274e0 --- /dev/null +++ b/onelauncher/src/settings.rs @@ -0,0 +1,61 @@ +use std::fs; + +use serde::{Deserialize, Serialize}; + +use crate::utils::dirs; + +#[derive(Debug, Serialize, Deserialize)] +#[serde(default)] +pub struct Setings { + pub discord_rpc: bool, +} + +impl Default for Setings { + fn default() -> Self { + Self { + discord_rpc: true, + } + } +} + +pub struct SettingsManager { + pub settings: Setings, +} + +impl SettingsManager { + pub fn new() -> crate::Result { + let path = dirs::app_config_dir()?.join("settings.json"); + + if path.exists() { + let file = fs::read_to_string(path)?; + let settings: Setings = serde_json::from_str(&file)?; + + return Ok(Self { + settings + }); + } + + let this = Self { + settings: Setings::default() + }; + + this.save()?; + Ok(this) + } + + pub fn get_settings(&self) -> &Setings { + &self.settings + } + + pub fn get_settings_mut(&mut self) -> &mut Setings { + &mut self.settings + } + + pub fn save(&self) -> crate::Result<()> { + let path = dirs::app_config_dir()?.join("settings.json"); + fs::create_dir_all(path.parent().unwrap())?; + fs::write(path, serde_json::to_string(&self.settings)?)?; + + Ok(()) + } +} \ No newline at end of file diff --git a/src-tauri/src/api/game.rs b/src-tauri/src/api/game.rs index 3f7ab183..86d4b2b0 100644 --- a/src-tauri/src/api/game.rs +++ b/src-tauri/src/api/game.rs @@ -1,20 +1,18 @@ -use onelauncher::game::{client::{Cluster, LaunchCallbacks, Manifest}, clients::ClientType}; +use onelauncher::{game::{client::{Cluster, LaunchCallbacks, Manifest}, clients::ClientType}, AppState}; use tauri::{Manager, State}; use tokio::sync::Mutex; use uuid::Uuid; -use super::GameManagerState; - #[tauri::command] pub async fn create_cluster( - state: State<'_, Mutex>, + state: State<'_, Mutex>, name: String, version: String, client: ClientType, cover: Option, group: Option, ) -> Result { - let manager = &mut state.lock().await.client_manager; + let manager = &mut state.lock().await.clients; let uuid = manager .create_cluster(name, version, cover, group, client) .await?; @@ -23,18 +21,18 @@ pub async fn create_cluster( #[tauri::command] pub async fn get_clusters( - state: State<'_, Mutex>, + state: State<'_, Mutex>, ) -> Result, String> { - let manager = &mut state.lock().await.client_manager; + let manager = &mut state.lock().await.clients; Ok(manager.get_clusters_owned()) } #[tauri::command] pub async fn get_cluster( - state: State<'_, Mutex>, + state: State<'_, Mutex>, uuid: Uuid, ) -> Result { - let manager = &mut state.lock().await.client_manager; + let manager = &mut state.lock().await.clients; let instance = manager.get_cluster(uuid)?; Ok(instance.clone()) } @@ -42,10 +40,10 @@ pub async fn get_cluster( #[tauri::command] pub async fn launch_cluster( app: tauri::AppHandle, - state: State<'_, Mutex>, + state: State<'_, Mutex>, uuid: Uuid, ) -> Result { - let manager = &mut state.lock().await.client_manager; + let manager = &mut state.lock().await.clients; let on_launch_app = app.clone(); let on_stdout_app = app.clone(); @@ -71,10 +69,10 @@ pub async fn launch_cluster( #[tauri::command] pub async fn get_manifest( - state: State<'_, Mutex>, + state: State<'_, Mutex>, uuid: Uuid, ) -> Result { - let manager = &mut state.lock().await.client_manager; + let manager = &mut state.lock().await.clients; let manifest = manager.get_manifest(uuid)?; Ok(manifest.clone()) } diff --git a/src-tauri/src/api/mod.rs b/src-tauri/src/api/mod.rs index f81d57fd..1b72849c 100644 --- a/src-tauri/src/api/mod.rs +++ b/src-tauri/src/api/mod.rs @@ -1,23 +1,14 @@ -use onelauncher::game::client_manager::ClientManager; +use onelauncher::{game::client_manager::ClientManager, AppState}; use tauri::{plugin::TauriPlugin, Manager, State}; use tokio::sync::Mutex; mod auth; mod game; -pub struct GameManagerState { - pub client_manager: ClientManager, -} - -unsafe impl Send for GameManagerState {} -unsafe impl Sync for GameManagerState {} - pub fn init() -> TauriPlugin { tauri::plugin::Builder::new("onelauncher") .setup(|app, _| { - app.manage(Mutex::new(GameManagerState { - client_manager: ClientManager::new().expect("Failed to initialize client manager"), - })); + app.manage(Mutex::new(AppState::new()?)); Ok(()) }) @@ -35,8 +26,8 @@ pub fn init() -> TauriPlugin { #[tauri::command] #[tracing::instrument(skip_all)] -async fn refresh_client_manager(state: State<'_, Mutex>) -> Result<(), String> { +async fn refresh_client_manager(state: State<'_, Mutex>) -> Result<(), String> { let mut state = state.lock().await; - state.client_manager = ClientManager::new()?; + state.clients = ClientManager::new()?; Ok(()) }