[fix]: fpfc launch delay

assets/jsons/translations/en.json

@@ -561,6 +561,16 @@
                 "actions": {
                     "STEAM_NOT_RUNNING": "Launch Steam"
                 }
+            },
+            "warnings": {
+                "titles": {
+                    "FPFC_NEED_ADMIN": "FPFC mode setup incomplete",
+                    "UNABLE_TO_LAUNCH_STEAM": "Could not launch Steam"
+                },
+                "msg": {
+                    "FPFC_NEED_ADMIN": "BSManager needs administrator privileges to properly set up FPFC mode. Run BSManager as administrator for the best experience.",
+                    "UNABLE_TO_LAUNCH_STEAM": "Steam could not be started automatically."
+                }
             }
         },
         "steam": {

src/main/services/bs-launcher/steam-launcher.service.ts

@@ -38,14 +38,25 @@
         return this.steam.getGameFolder(STEAMVR_APP_ID, "SteamVR");
     }
 
-    private async backupSteamVR(): Promise<void> {
+    private timedRename(src: string, dest: string): Promise<void> {
+        return Promise.race([
+            rename(src, dest),
+            new Promise<never>((_, reject) => setTimeout(() => reject(new Error("Rename timed out")), 5000)),
+        ]);
+    }
+
+    private async backupSteamVR(): Promise<boolean> {
         const steamVrFolder = await this.getSteamVRPath();
-        if (!(await pathExists(steamVrFolder))) {
-            return;
+        if (!steamVrFolder || !(await pathExists(steamVrFolder))) {
+            return false;
+        }
+        try {
+            await this.timedRename(steamVrFolder, `${steamVrFolder}.bak`);
+            return false;
+        } catch (err) {
+            log.warn("Could not backup SteamVR folder, skipping", err);
+            return err?.code === "EPERM" || err?.message?.includes("timed out");
         }
-        return rename(steamVrFolder, `${steamVrFolder}.bak`).catch(err => {
-            log.error("Error while create backup of SteamVR", err);
-        });
     }
 
     private getStartBsAsAdminExePath(): string {
@@ -54,14 +65,11 @@
 
     public async restoreSteamVR(): Promise<void> {
         const steamVrFolder = await this.getSteamVRPath();
+        if (!steamVrFolder) { return; }
         const steamVrBackup = `${steamVrFolder}.bak`;
-
-        if (!(await pathExists(steamVrBackup))) {
-            return;
-        }
-
-        return rename(steamVrBackup, steamVrFolder).catch(err => {
-            log.error("Error while restoring SteamVR", err);
+        if (!(await pathExists(steamVrBackup))) { return; }
+        return this.timedRename(steamVrBackup, steamVrFolder).catch(err => {
+            log.warn("Could not restore SteamVR folder", err);
         });
     }
 
@@ -109,7 +117,7 @@
 
     public launch(launchOptions: LaunchOption): Observable<BSLaunchEventData>{
 
         return new Observable<BSLaunchEventData>(obs => {(async () => {
 
             const bsFolderPath = await this.localVersions.getInstalledVersionPath(launchOptions.version);
             const bsExePath = path.join(bsFolderPath, BS_EXECUTABLE);
@@ -136,12 +144,16 @@
                 obs.next({ type: BSLaunchEvent.SKIPPING_STEAM_LAUNCH});
             }
 
-            // Backup SteamVR when desktop mode is enabled
-            if(launchOptions.launchMods?.includes(LaunchMods.FPFC)){
-                await this.backupSteamVR().catch(() => {
-                    return this.restoreSteamVR();
+            const isFpfc = launchOptions.launchMods?.includes(LaunchMods.FPFC);
+            const isOculus = launchOptions.launchMods?.includes(LaunchMods.OCULUS);
+            if(isFpfc && !isOculus){
+                const backupPermError = await this.backupSteamVR().catch(() => {
+                    return this.restoreSteamVR().then(() => false);
                 });
-            } else {
+                if(backupPermError){
+                    obs.next({type: BSLaunchWarning.FPFC_NEED_ADMIN});
+                }
+            } else if(!isFpfc) {
                 await this.restoreSteamVR().catch(log.error);
             }
 

src/renderer/services/bs-launcher.service.ts

@@ -45,10 +45,15 @@
     }
 
     private handleLaunchEvents(events$: Observable<BSLaunchEventData>): Observable<BSLaunchEventData>{
-        const eventToFilter = [...Object.values(BSLaunchWarning), BSLaunchEvent.STEAM_LAUNCHED]
+        const warningTypes: string[] = Object.values(BSLaunchWarning);
+        const eventToFilter = [...warningTypes, BSLaunchEvent.STEAM_LAUNCHED]
 
         return events$.pipe(tap({
             next: event => {
+                if(warningTypes.includes(event.type)){
+                    this.notificationService.notifyWarning({title: `notifications.bs-launch.warnings.titles.${event.type}`, desc: `notifications.bs-launch.warnings.msg.${event.type}`, duration: sToMs(9)});
+                    return;
+                }
                 if(eventToFilter.includes(event.type)){ return; }
                 this.notificationService.notifySuccess({title: `notifications.bs-launch.success.titles.${event.type}`, desc: `notifications.bs-launch.success.msg.${event.type}`});
             },

src/shared/models/bs-launch/launch-event.model.ts

@@ -29,6 +29,7 @@ export enum BSLaunchEvent{
 
 export enum BSLaunchWarning{
     UNABLE_TO_LAUNCH_STEAM = "UNABLE_TO_LAUNCH_STEAM",
+    FPFC_NEED_ADMIN = "FPFC_NEED_ADMIN",
 }
 
 export type BSLaunchEventType = BSLaunchEvent | BSLaunchWarning;