Remove unreferenced private members

.github/workflows/ci-build.yml

@@ -77,12 +77,19 @@ jobs:
       - name: Package ${{ matrix.platform }}
         run: python .\utils\post-build.py .\bin\${{ matrix.platform }}\Release\output . ${{ env.VERSION }}
 
+      - name: Stage ${{ matrix.platform }} artifact folder
+        shell: pwsh
+        run: |
+          $artifactRoot = ".\bin\${{ matrix.platform }}\Release\artifact"
+          New-Item -ItemType Directory -Path $artifactRoot -Force | Out-Null
+          Copy-Item -Path ".\bin\${{ matrix.platform }}\Release\DS4Windows" -Destination $artifactRoot -Recurse -Force
+
       - name: Upload ${{ matrix.platform }} artifact
         id: upload
         uses: actions/upload-artifact@v4
         with:
-          name: DS4Windows-${{ matrix.platform }}
-          path: .\bin\${{ matrix.platform }}\Release\DS4Windows_${{ env.VERSION }}_${{ matrix.platform }}.zip
+          name: DS4Windows_${{ env.VERSION }}_${{ matrix.platform }}
+          path: .\bin\${{ matrix.platform }}\Release\artifact
           if-no-files-found: error
 
       - name: Publish artifact link to run summary
@@ -92,5 +99,5 @@ jobs:
           echo "" >> "$GITHUB_STEP_SUMMARY"
           echo "Version: \`${{ env.VERSION }}\`" >> "$GITHUB_STEP_SUMMARY"
           echo "" >> "$GITHUB_STEP_SUMMARY"
-          echo "[Download DS4Windows-${{ matrix.platform }} (zip)](${{ steps.upload.outputs.artifact-url }})" >> "$GITHUB_STEP_SUMMARY"
+          echo "[Download DS4Windows_${{ env.VERSION }}_${{ matrix.platform }} (contains DS4Windows folder)](${{ steps.upload.outputs.artifact-url }})" >> "$GITHUB_STEP_SUMMARY"
 

.github/workflows/release.yml

@@ -35,18 +35,18 @@ jobs:
         echo "SHORT_VERSION=${VERSION%-*}" >> $GITHUB_ENV
       shell: bash
     - name: Build X64
-      run: dotnet publish .\DS4Windows\DS4WinWPF.csproj -c Release  /p:platform=x64 /p:AssemblyVersion=${{ env.SHORT_VERSION }} /p:FileVersion=${{ env.SHORT_VERSION }} /p:Version=${{ env.VERSION }} -o .\bin\x64\Release\output
+      run: dotnet publish .\DS4Windows\DS4WinWPF.csproj -c Release  /p:platform=x64 /p:AssemblyVersion=${{ env.SHORT_VERSION }} /p:FileVersion=${{ env.SHORT_VERSION }} /p:Version=${{ env.VERSION }} /p:InformationalVersion=${{ env.VERSION }} -o .\bin\x64\Release\output
     - name: Post-Build script X64
       run: python .\utils\post-build.py .\bin\x64\Release\output . ${{env.VERSION}}
     - name: Publish release Build X64
       run: gh release upload ${{github.event.release.tag_name}} .\bin\x64\Release\DS4Windows_${{env.VERSION}}_x64.zip
       env:
         GITHUB_TOKEN: ${{ github.TOKEN }}
     - name: Build X86
-      run: dotnet publish .\DS4Windows\DS4WinWPF.csproj -c Release  /p:platform=x86 /p:AssemblyVersion=${{ env.SHORT_VERSION }} /p:FileVersion=${{ env.SHORT_VERSION }} /p:Version=${{ env.VERSION }} -o .\bin\x86\Release\output
+      run: dotnet publish .\DS4Windows\DS4WinWPF.csproj -c Release  /p:platform=x86 /p:AssemblyVersion=${{ env.SHORT_VERSION }} /p:FileVersion=${{ env.SHORT_VERSION }} /p:Version=${{ env.VERSION }} /p:InformationalVersion=${{ env.VERSION }} -o .\bin\x86\Release\output
     - name: Post-Build script X86
       run: python .\utils\post-build.py .\bin\x86\Release\output . ${{env.VERSION}}
     - name: Publish release Build X86
       run: gh release upload ${{github.event.release.tag_name}} .\bin\x86\Release\DS4Windows_${{env.VERSION}}_x86.zip
       env:
-        GITHUB_TOKEN: ${{ github.TOKEN }}
+        GITHUB_TOKEN: ${{ github.TOKEN }}

DS4Windows/App.xaml.cs

@@ -25,6 +25,8 @@ You should have received a copy of the GNU General Public License
 using System.IO.MemoryMappedFiles;
 using System.Net.Http;
 using System.Runtime.InteropServices;
+using System.Security.AccessControl;
+using System.Security.Principal;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
@@ -89,10 +91,30 @@ private void Application_Startup(object sender, StartupEventArgs e)
             runShutdown = true;
             skipSave = true;
 
+            if (DS4Windows.GameBarIntegration.TryRunProbeCommand(e.Args))
+            {
+                runShutdown = false;
+                Current.Shutdown();
+                return;
+            }
+
             ArgumentParser parser = new ArgumentParser();
             parser.Parse(e.Args);
             CheckOptions(parser);
 
+            try
+            {
+                string exeDir = Path.GetDirectoryName(DS4Windows.Global.exelocation);
+                if (!string.IsNullOrEmpty(exeDir))
+                {
+                    Environment.CurrentDirectory = exeDir;
+                }
+            }
+            catch
+            {
+                // Keep startup going. A bad working directory should not block DS4Windows.
+            }
+
             if (exitApp)
             {
                 return;
@@ -119,8 +141,8 @@ private void Application_Startup(object sender, StartupEventArgs e)
             try
             {
                 if (EventWaitHandleAcl.TryOpenExisting(SingleAppComEventName,
-                System.Security.AccessControl.EventWaitHandleRights.Synchronize |
-                System.Security.AccessControl.EventWaitHandleRights.Modify,
+                EventWaitHandleRights.Synchronize |
+                EventWaitHandleRights.Modify,
                 out EventWaitHandle tempComEvent))
                 {
                     tempComEvent.Set();  // signal the other instance.
@@ -133,7 +155,11 @@ private void Application_Startup(object sender, StartupEventArgs e)
             }
             catch (System.UnauthorizedAccessException)
             {
-                // Ignore exception
+                // An existing elevated instance can deny this process access if it was
+                // started by an older build. Do not continue into a second mapper.
+                runShutdown = false;
+                Current.Shutdown();
+                return;
             }
 
             // Allow sleep time durations less than 16 ms
@@ -143,7 +169,18 @@ private void Application_Startup(object sender, StartupEventArgs e)
             DS4Windows.Global.RefreshViGEmBusInfo();
 
             // Create the Event handle
-            threadComEvent = new EventWaitHandle(false, EventResetMode.ManualReset, SingleAppComEventName);
+            try
+            {
+                threadComEvent = CreateSingleAppComEvent();
+            }
+            catch (UnauthorizedAccessException)
+            {
+                // Another elevated instance can win the race with older event security.
+                runShutdown = false;
+                Current.Shutdown();
+                return;
+            }
+
             CreateTempWorkerThread();
 
             CreateControlService(parser);
@@ -181,7 +218,7 @@ private void Application_Startup(object sender, StartupEventArgs e)
             DispatcherUnhandledException += App_DispatcherUnhandledException;
             AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
             Logger logger = logHolder.Logger;
-            string version = DS4Windows.Global.exeversion;
+            string version = DS4Windows.Global.exeDisplayVersion;
             logger.Info($"DS4Windows version {version}");
             logger.Info($"DS4Windows exe file: {DS4Windows.Global.exeFileName}");
             logger.Info($"DS4Windows Assembly Architecture: {(Environment.Is64BitProcess ? "x64" : "x86")}");
@@ -190,8 +227,12 @@ private void Application_Startup(object sender, StartupEventArgs e)
             logger.Info($"OS Release ID: {DS4Windows.Util.GetOSReleaseId()}");
             logger.Info($"System Architecture: {(Environment.Is64BitOperatingSystem ? "x64" : "x86")}");
             logger.Info("Logger created");
+            StartupDiag(logger, $"App bootstrap pid={Environment.ProcessId} admin={DS4Windows.Global.IsAdministrator()} cwd=\"{Environment.CurrentDirectory}\" cmd=\"{Environment.CommandLine}\"");
+            StartupDiag(logger, $"Exe location=\"{DS4Windows.Global.exelocation}\" configPath=\"{DS4Windows.Global.appdatapath}\" firstRun={firstRun}");
 
+            StartupDiag(logger, "Global.Load begin");
             bool readAppConfig = DS4Windows.Global.Load();
+            StartupDiag(logger, $"Global.Load end readAppConfig={readAppConfig}");
             if (!firstRun && !readAppConfig)
             {
                 logger.Info($@"Profiles.xml not read at location ${DS4Windows.Global.appdatapath}\Profiles.xml. Using default app settings");
@@ -224,26 +265,41 @@ private void Application_Startup(object sender, StartupEventArgs e)
 
             skipSave = false;
 
+            StartupDiag(logger, "Global.LoadActions begin");
             if (!DS4Windows.Global.LoadActions())
             {
+                StartupDiag(logger, "Global.LoadActions failed; CreateStdActions begin");
                 DS4Windows.Global.CreateStdActions();
+                StartupDiag(logger, "CreateStdActions end");
+            }
+            else
+            {
+                StartupDiag(logger, "Global.LoadActions end success");
             }
 
             // Have app use selected culture
             SetUICulture(DS4Windows.Global.UseLang);
             DS4Windows.AppThemeChoice themeChoice = DS4Windows.Global.UseCurrentTheme;
             ChangeTheme(DS4Windows.Global.UseCurrentTheme, false);
 
+            StartupDiag(logger, "LoadLinkedProfiles begin");
             DS4Windows.Global.LoadLinkedProfiles();
+            StartupDiag(logger, "LoadLinkedProfiles end");
+            StartupDiag(logger, "MainWindow ctor begin");
             DS4Forms.MainWindow window = new DS4Forms.MainWindow(parser);
+            StartupDiag(logger, "MainWindow ctor end");
             MainWindow = window;
             window.IsInitialShow = true;
+            StartupDiag(logger, "MainWindow.Show begin");
             window.Show();
+            StartupDiag(logger, "MainWindow.Show end");
             window.IsInitialShow = false;
 
             // Set up hooks for IPC command calls
             HwndSource source = PresentationSource.FromVisual(window) as HwndSource;
+            StartupDiag(logger, "CreateIPCClassNameMMF begin");
             CreateIPCClassNameMMF(source.Handle);
+            StartupDiag(logger, "CreateIPCClassNameMMF end");
 
             window.CheckMinStatus();
 
@@ -252,11 +308,28 @@ private void Application_Startup(object sender, StartupEventArgs e)
 
             if (DS4Windows.Global.hidHideInstalled)
             {
+                StartupDiag(logger, "CheckHidHidePresence begin");
                 rootHub.CheckHidHidePresence();
+                StartupDiag(logger, "CheckHidHidePresence end");
             }
 
+            StartupDiag(logger, "LoadPermanentSlotsConfig begin");
             rootHub.LoadPermanentSlotsConfig();
+            StartupDiag(logger, "LoadPermanentSlotsConfig end");
+            StartupDiag(logger, "MainWindow.LateChecks begin");
             window.LateChecks(parser);
+            StartupDiag(logger, "MainWindow.LateChecks returned");
+        }
+
+        private static void StartupDiag(Logger logger, string message)
+        {
+            if (!DS4Windows.Global.VerboseStartupLogging)
+            {
+                return;
+            }
+
+            logger.Info($"[StartupDiag][T{Thread.CurrentThread.ManagedThreadId}] {message}");
+            LogManager.Flush(TimeSpan.FromSeconds(1));
         }
 
         private void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
@@ -293,6 +366,29 @@ private void CurrentDomain_UnhandledException(object sender, UnhandledExceptionE
             }
         }
 
+        private static EventWaitHandle CreateSingleAppComEvent()
+        {
+            EventWaitHandleSecurity security = new EventWaitHandleSecurity();
+            EventWaitHandleRights appRights = EventWaitHandleRights.Synchronize |
+                EventWaitHandleRights.Modify |
+                EventWaitHandleRights.ReadPermissions;
+
+            SecurityIdentifier authenticatedUsersSid = new SecurityIdentifier(
+                WellKnownSidType.AuthenticatedUserSid, null);
+            security.AddAccessRule(new EventWaitHandleAccessRule(authenticatedUsersSid,
+                appRights, AccessControlType.Allow));
+
+            SecurityIdentifier currentUserSid = WindowsIdentity.GetCurrent().User;
+            if (currentUserSid != null)
+            {
+                security.AddAccessRule(new EventWaitHandleAccessRule(currentUserSid,
+                    EventWaitHandleRights.FullControl, AccessControlType.Allow));
+            }
+
+            return EventWaitHandleAcl.Create(false, EventResetMode.ManualReset,
+                SingleAppComEventName, out _, security);
+        }
+
         private void App_DispatcherUnhandledException(object sender, System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e)
         {
             //Debug.WriteLine("App Crashed");
@@ -746,16 +842,28 @@ private void CleanShutdown()
         {
             if (runShutdown)
             {
+                bool shutdownTimedOut = false;
                 if (rootHub != null)
                 {
-                    Task.Run(() =>
+                    Task shutdownTask = Task.Run(() =>
                     {
                         if (rootHub.running)
                         {
-                            rootHub.Stop(immediateUnplug: true);
+                            rootHub.Stop(immediateUnplug: true, disposeViGEm: false);
                             rootHub.ShutDown();
                         }
-                    }).Wait();
+                    });
+
+                    if (!shutdownTask.Wait(TimeSpan.FromSeconds(8)))
+                    {
+                        shutdownTimedOut = true;
+                        try
+                        {
+                            logHolder?.Logger?.Warn("Timed out while stopping controller service during shutdown. Forcing process exit to avoid a stale single-instance lock.");
+                            rootHub.PrepareAbort();
+                        }
+                        catch { }
+                    }
                 }
 
                 if (!skipSave)
@@ -770,15 +878,23 @@ private void CleanShutdown()
                 if (threadComEvent != null)
                 {
                     threadComEvent.Set();  // signal the other instance.
-                    while (testThread.IsAlive)
-                        Thread.SpinWait(500);
+                    if (testThread != null && !testThread.Join(2000))
+                    {
+                        shutdownTimedOut = true;
+                        logHolder?.Logger?.Warn("Timed out waiting for single-instance worker thread to exit.");
+                    }
                     threadComEvent.Close();
                 }
 
                 if (ipcClassNameMMF != null) ipcClassNameMMF.Dispose();
 
                 LogManager.Flush();
                 LogManager.Shutdown();
+
+                if (shutdownTimedOut)
+                {
+                    Environment.Exit(0);
+                }
             }
         }
     }