0.1.25

backend/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rai-pal"
-version = "0.1.24"
+version = "0.1.25"
 authors = ["Raicuparta"]
 license = "GPL-3.0-or-later"
 repository = "https://github.com/Raicuparta/rai-pal"
@@ -24,7 +24,7 @@ specta = "1.0.5"
 tauri-specta = { version = "1.0.2", features = ["typescript"] }
 serde = { version = "1.0", features = ["derive"] }
 byteorder = "1.5.0"
-tauri = { version = "1.5.2", features = [ "dialog-open", "updater", "shell-open", "dialog"] }
+tauri = { version = "1.5.2", features = [ "dialog-confirm", "dialog-open", "updater", "shell-open", "dialog"] }
 reqwest = "0.11.22"
 goblin = "0.7.1"
 open = "5.0.0"

backend/src/events.rs

@@ -1,32 +1,25 @@
 use serde::Serialize;
 use tauri::Manager;
 
-use crate::{
-	result::Result,
-	serializable_enum,
-};
+use crate::serializable_enum;
 
 serializable_enum!(AppEvent {
 	SyncInstalledGames,
 	SyncOwnedGames,
-	SyncDiscoverGames,
 	SyncMods,
 	ExecutedSteamCommand,
 	GameAdded,
 	GameRemoved,
+	Error,
 });
 
 pub trait EventEmitter {
-	fn emit_event<TPayload: Serialize + Clone>(&self, event: AppEvent, payload: TPayload)
-		-> Result;
+	fn emit_event<TPayload: Serialize + Clone>(&self, event: AppEvent, payload: TPayload);
 }
 
 impl EventEmitter for tauri::AppHandle {
-	fn emit_event<TPayload: Serialize + Clone>(
-		&self,
-		event: AppEvent,
-		payload: TPayload,
-	) -> Result {
-		Ok(self.emit_all(&event.to_string(), payload)?)
+	fn emit_event<TPayload: Serialize + Clone>(&self, event: AppEvent, payload: TPayload) {
+		self.emit_all(&event.to_string(), payload)
+			.unwrap_or_else(|err| eprintln!("Failed to emit event: {err}"));
 	}
 }

backend/src/main.rs

@@ -33,10 +33,6 @@ use result::{
 	Error,
 	Result,
 };
-use steam::{
-	appinfo,
-	id_lists::SteamGame,
-};
 use steamlocate::SteamDir;
 use tauri::{
 	api::dialog::message,
@@ -61,7 +57,6 @@ mod windows;
 struct AppState {
 	installed_games: Mutex<Option<installed_game::Map>>,
 	owned_games: Mutex<Option<Vec<OwnedGame>>>,
-	discover_games: Mutex<Option<Vec<SteamGame>>>,
 	mod_loaders: Mutex<Option<mod_loader::DataMap>>,
 }
 
@@ -106,12 +101,6 @@ async fn get_owned_games(state: tauri::State<'_, AppState>) -> Result<Vec<OwnedG
 	get_state_data(&state.owned_games)
 }
 
-#[tauri::command]
-#[specta::specta]
-async fn get_discover_games(state: tauri::State<'_, AppState>) -> Result<Vec<SteamGame>> {
-	get_state_data(&state.discover_games)
-}
-
 #[tauri::command]
 #[specta::specta]
 async fn get_mod_loaders(state: tauri::State<'_, AppState>) -> Result<mod_loader::DataMap> {
@@ -123,17 +112,15 @@ fn update_state<TData>(
 	data: TData,
 	mutex: &Mutex<Option<TData>>,
 	handle: &tauri::AppHandle,
-) -> Result {
+) {
 	if let Ok(mut mutex_guard) = mutex.lock() {
 		*mutex_guard = Some(data);
 	}
 
 	// Sends a signal to make the frontend request an app state refresh.
 	// I would have preferred to just send the state with the signal,
 	// but it seems like Tauri events are really slow for large data.
-	handle.emit_event(event, ())?;
-
-	Ok(())
+	handle.emit_event(event, ());
 }
 
 #[tauri::command]
@@ -213,7 +200,7 @@ fn refresh_single_game(
 		installed_games,
 		&state.installed_games,
 		handle,
-	)?;
+	);
 
 	Ok(())
 }
@@ -246,20 +233,19 @@ async fn update_data(handle: tauri::AppHandle, state: tauri::State<'_, AppState>
 		mod_loaders.clone(),
 		&state.mod_loaders,
 		&handle,
-	)?;
+	);
 
-	let provider_map = provider::get_map();
-
-	let steam_dir = SteamDir::locate()?;
-	let app_info = appinfo::read(steam_dir.path())?;
+	let provider_map = provider::get_map(&handle);
 
 	let installed_games: HashMap<_, _> = provider_map
 		.values()
 		.flat_map(|provider| match provider.get_installed_games() {
 			Ok(games) => games,
 			Err(err) => {
-				// TODO properly handle these errors message to frontend.
-				eprintln!("Error getting installed games for provider: {}", err);
+				handle.emit_event(
+					AppEvent::Error,
+					format!("Error getting installed games for provider: {err}"),
+				);
 				Vec::default()
 			}
 		})
@@ -274,37 +260,24 @@ async fn update_data(handle: tauri::AppHandle, state: tauri::State<'_, AppState>
 		installed_games.clone(),
 		&state.installed_games,
 		&handle,
-	)?;
-
-	let (discover_games_result, owned_games_result) = futures::future::join(
-		steam::discover_games::get(&app_info),
-		futures::future::join_all(
-			provider_map
-				.values()
-				.map(provider::ProviderActions::get_owned_games),
-		),
-	)
-	.await;
-
-	let owned_games: Vec<OwnedGame> = owned_games_result
-		.into_iter()
-		.flat_map(result::Result::unwrap_or_default)
-		.collect();
+	);
 
-	let discover_games = discover_games_result.unwrap_or_default();
-	update_state(
-		AppEvent::SyncDiscoverGames,
-		discover_games,
-		&state.discover_games,
-		&handle,
-	)?;
+	let owned_games: Vec<OwnedGame> = futures::future::join_all(
+		provider_map
+			.values()
+			.map(provider::ProviderActions::get_owned_games),
+	)
+	.await
+	.into_iter()
+	.flat_map(result::Result::unwrap_or_default)
+	.collect();
 
 	update_state(
 		AppEvent::SyncOwnedGames,
 		owned_games,
 		&state.owned_games,
 		&handle,
-	)?;
+	);
 
 	Ok(())
 }
@@ -335,9 +308,9 @@ async fn add_game(
 		installed_games,
 		&state.installed_games,
 		&handle,
-	)?;
+	);
 
-	handle.emit_event(AppEvent::GameAdded, game_name)?;
+	handle.emit_event(AppEvent::GameAdded, game_name);
 
 	Ok(())
 }
@@ -360,13 +333,20 @@ async fn remove_game(
 		installed_games,
 		&state.installed_games,
 		&handle,
-	)?;
+	);
 
-	handle.emit_event(AppEvent::GameRemoved, game.name)?;
+	handle.emit_event(AppEvent::GameRemoved, game.name);
 
 	Ok(())
 }
 
+#[tauri::command]
+#[specta::specta]
+async fn delete_steam_appinfo_cache() -> Result {
+	let steam_dir = SteamDir::locate()?;
+	steam::appinfo::delete(steam_dir.path())
+}
+
 #[tauri::command]
 #[specta::specta]
 // This command is here just so tauri_specta exports these types.
@@ -392,7 +372,6 @@ fn main() {
 		.manage(AppState {
 			installed_games: Mutex::default(),
 			owned_games: Mutex::default(),
-			discover_games: Mutex::default(),
 			mod_loaders: Mutex::default(),
 		})
 		.setup(|_app| {
@@ -425,7 +404,6 @@ fn main() {
 			update_data,
 			get_installed_games,
 			get_owned_games,
-			get_discover_games,
 			get_mod_loaders,
 			open_game_folder,
 			install_mod,
@@ -436,6 +414,7 @@ fn main() {
 			open_mods_folder,
 			add_game,
 			remove_game,
+			delete_steam_appinfo_cache,
 		]
 	);
 

backend/src/providers/provider.rs

@@ -4,6 +4,10 @@ use async_trait::async_trait;
 use enum_dispatch::enum_dispatch;
 
 use crate::{
+	events::{
+		AppEvent,
+		EventEmitter,
+	},
 	installed_game::InstalledGame,
 	owned_game::OwnedGame,
 	providers::{
@@ -49,23 +53,23 @@ where
 	Ok((TProvider::ID.to_string(), mod_loader))
 }
 
-fn add_entry<TProvider: ProviderActions + ProviderStatic>(map: &mut Map)
+fn add_entry<TProvider: ProviderActions + ProviderStatic>(map: &mut Map, handle: &tauri::AppHandle)
 where
 	Provider: std::convert::From<TProvider>,
 {
 	match create_map_entry::<TProvider>() {
 		Ok((key, value)) => {
 			map.insert(key, value);
 		}
-		Err(err) => eprintln!("Failed to create map entry: {err}"),
+		Err(err) => handle.emit_event(AppEvent::Error, format!("Failed to set up provider: {err}")),
 	}
 }
 
-pub fn get_map() -> Map {
+pub fn get_map(handle: &tauri::AppHandle) -> Map {
 	let mut map = Map::new();
 
-	add_entry::<SteamProvider>(&mut map);
-	add_entry::<ManualProvider>(&mut map);
+	add_entry::<SteamProvider>(&mut map, handle);
+	add_entry::<ManualProvider>(&mut map, handle);
 
 	map
 }

backend/src/steam/appinfo.rs

@@ -340,3 +340,7 @@ pub fn read(steam_path: &Path) -> Result<SteamAppInfoFile> {
 	let mut appinfo_file = BufReader::new(fs::File::open(get_path(steam_path))?);
 	SteamAppInfoFile::load(&mut appinfo_file)
 }
+
+pub fn delete(steam_path: &Path) -> Result {
+	Ok(fs::remove_file(get_path(steam_path))?)
+}

backend/src/steam/command.rs

@@ -8,6 +8,6 @@ use crate::{
 
 pub fn run(command: &str, handle: &tauri::AppHandle) -> Result {
 	open::that_detached(format!("steam://{command}"))?;
-	handle.emit_event(AppEvent::ExecutedSteamCommand, ())?;
+	handle.emit_event(AppEvent::ExecutedSteamCommand, ());
 	Ok(())
 }

backend/src/steam/mod.rs

@@ -1,5 +1,4 @@
 pub mod appinfo;
 pub mod command;
-pub mod discover_games;
 pub mod id_lists;
 pub mod thumbnail;

backend/tauri.conf.json

@@ -30,7 +30,7 @@
       "dialog": {
         "all": false,
         "ask": false,
-        "confirm": false,
+        "confirm": true,
         "message": false,
         "open": true,
         "save": false

frontend/api/bindings.ts

@@ -26,10 +26,6 @@ export function getOwnedGames() {
     return invoke()<OwnedGame[]>("get_owned_games")
 }
 
-export function getDiscoverGames() {
-    return invoke()<SteamGame[]>("get_discover_games")
-}
-
 export function getModLoaders() {
     return invoke()<{ [key: string]: ModLoaderData }>("get_mod_loaders")
 }
@@ -70,12 +66,15 @@ export function removeGame(gameId: string) {
     return invoke()<null>("remove_game", { gameId })
 }
 
+export function deleteSteamAppinfoCache() {
+    return invoke()<null>("delete_steam_appinfo_cache")
+}
+
 export type GameExecutable = { path: string; engine: GameEngine | null; architecture: Architecture | null; operatingSystem: OperatingSystem | null; scriptingBackend: UnityScriptingBackend | null }
 export type InstalledGame = { id: string; name: string; providerId: ProviderId; discriminator: string | null; steamLaunch: SteamLaunchOption | null; executable: GameExecutable; thumbnailUrl: string | null; availableMods: { [key: string]: boolean } }
 export type ProviderId = "Steam" | "Manual"
-export type AppEvent = "SyncInstalledGames" | "SyncOwnedGames" | "SyncDiscoverGames" | "SyncMods" | "ExecutedSteamCommand" | "GameAdded" | "GameRemoved"
-export type SteamGame = { id: string; nsfw: boolean; engine: GameEngineBrand }
 export type GameEngine = { brand: GameEngineBrand; version: GameEngineVersion | null }
+export type AppEvent = "SyncInstalledGames" | "SyncOwnedGames" | "SyncMods" | "ExecutedSteamCommand" | "GameAdded" | "GameRemoved" | "Error"
 export type Mod = { id: string; name: string; scriptingBackend: UnityScriptingBackend | null; engine: GameEngineBrand | null; kind: ModKind; path: string }
 export type ModLoaderData = { id: string; path: string; mods: Mod[] }
 export type OwnedGame = { id: string; providerId: ProviderId; name: string; installed: boolean; osList: OperatingSystem[]; engine: GameEngineBrand; releaseDate: number; thumbnailUrl: string }