Preview 1.83.2 Hotfix (#746)

# What's Changed?
- **[Fix]** SharingViolation errors while installing/updating games with
Sophon mode (eg. Genshin Impact and Zenless Zone Zero), by @neon-nyan
- **[Imp]** Streamline submodule branches to main for Hi3Helper.EncTool,
Hi3Helper.Http and Hi3Helper.Sophon for easier maintainability, by
@neon-nyan
- **[Imp+Fix]** Rewriting the whole Genshin Impact's Game Repair
pipelines to match game in-game download behavior, by @neon-nyan.
This fixes most bugs, including some NotFound error, misplaced files and
duplicate files due to the code still runs in how Genshin's in-game
download behaves prior < 5.x
- **[Fix]** Binding issues causing lags on SettingsPage's initial load,
by @neon-nyan
- **[Fix]** ``FileMigrationProcess`` pipelines
  - Fix where the migration might remove unwanted non-game files.
  - Fix where some old empty folders aren't getting removed.
- Fix [#727](#727)
where user can't move the game files into a subfolder inside of the
current folder.
- **[Imp]** Borrow some functions from ``GenshinRepair`` instance on
File Clean-up on Genshin Impact, by @neon-nyan
- **[Fix]** Some race condition due to ``Lock`` misuses, by @neon-nyan

Author: neon-nyan

CONTRIBUTING.md

@@ -15,17 +15,14 @@ If you wish to add new language that isn't yet listed in the Crowdin project, pl
 
 ## Tools Needed
 Below is a list of tools needed to contribute to this project:
-1. **Visual Studio 2022 (Any Edition - 17.8 or later)**
+1. **Visual Studio 2022 (Any Edition - latest version)**
    - Select .NET desktop development component
 2. **Windows SDK (10.0.26100.0 ONLY)** via Visual Studio Installer
-3. .NET 8 SDK: [**(8.0.0 or later)**](https://dotnet.microsoft.com/en-us/download/dotnet/8.0)
-4. WinUI 3: [**(WindowsAppSDK 1.4.0 Stable Runtime)**](https://aka.ms/windowsappsdk/1.4/latest/windowsappruntimeinstall-x64.exe)
+3. .NET 9 SDK: [**(9.0.4 or later)**](https://dotnet.microsoft.com/en-us/download/dotnet/9.0)
 
 > **Note**:
-> 
-> Starting from November 21<sup>st</sup> 2023, you <b>must</b> have Visual Studio 2022 version 17.8+ installed on your computer due to the updated minimum system requirement of `WindowsAppSDK` and `.NET 8`.
-> 
-> Using a lower Visual Studio version (like VS2019) is not possible due to requirement from WindowsAppSDK used in this project.
+> Make sure to always use the latest version of Visual Studio in order to be able to open the project.
+
 ## Restrictions for New Feature(s)
 While this software is fully open source and not affiliated with HoYoverse, Cognosphere, or any of its related entities in any way, we are nonetheless bound to their Terms of Service and Code of Conduct when developing Collapse. This means that there are some features that we will **not** implement. We will close any issue or PRs that are made to add such functionality to Collapse. Such features include, but are not limited to:
 - Anything that, in any way, interacts with the miHoYo SDK and/or API, including their Authentication and Payment Processing endpoints.
@@ -48,8 +45,9 @@ While this software is fully open source and not affiliated with HoYoverse, Cogn
 - [Genshin Impact Terms of Service](https://genshin.hoyoverse.com/en/company/terms)
 - [Honkai Impact 3rd Terms of Service](https://honkaiimpact3.hoyoverse.com/global/en-us/terms)
 - [Honkai: Star Rail Terms of Service](https://hsr.hoyoverse.com/en-us/company/terms)
+- [Zenless Zone Zero Terms of Service](https://zenless.hoyoverse.com/en-us/company/terms)
 - [HoYoLAB Forum Terms of Service](https://www.hoyolab.com/agreement)
 
 # A Humble Thank You
 As contributors, we always feel grateful for all your contributions to the project, whether it be through helping with localizing the app, coming up with new features, reporting bugs, and even using this launcher. Through everyone's effort, we can keep this project alive by bringing even more features and quality-of-life (QoL) upgrades over the existing launchers (including official) that are out there.
-Thank you ❤️
+Thank you ❤️

CollapseLauncher/Classes/Extension/UIElementExtensions.cs

@@ -1025,5 +1025,21 @@ internal static IEnumerable<object> EnumerateSelectableElementChildren(this Fram
                 yield return item;
             }
         }
+
+        internal static bool IsElementVisible(this FrameworkElement? element)
+        {
+            if (element == null)
+            {
+                return false;
+            }
+
+            if (element.Visibility == Visibility.Collapsed || element.Opacity < 1)
+            {
+                return false;
+            }
+
+            return VisualTreeHelper.GetParent(element) is not FrameworkElement parentElement ||
+                   (parentElement.Visibility != Visibility.Collapsed && !(element.Opacity < 1));
+        }
     }
 }

CollapseLauncher/Classes/FileMigrationProcess/FileMigrationProcess.cs

@@ -1,11 +1,16 @@
 using CollapseLauncher.FileDialogCOM;
 using CollapseLauncher.Helper;
+using CollapseLauncher.Helper.StreamUtility;
 using Hi3Helper;
 using Hi3Helper.Shared.Region;
+using Hi3Helper.Win32.ManagedTools;
+using Hi3Helper.Win32.Native.ManagedTools;
 using Microsoft.UI.Dispatching;
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -49,7 +54,7 @@ internal async Task<string> StartRoutine()
             _currentFileCountMoved = 0;
             _totalFileSize = 0;
             _totalFileCount = 0;
-            FileMigrationProcessUIRef? uiRef = null;
+            FileMigrationProcessUIRef uiRef = null;
 
             try
             {
@@ -62,20 +67,20 @@ internal async Task<string> StartRoutine()
                 }
 
                 uiRef = BuildMainMigrationUI();
-                string outputPath = await StartRoutineInner(uiRef.Value);
-                uiRef.Value.MainDialogWindow!.Hide();
+                string outputPath = await StartRoutineInner(uiRef);
+                uiRef.MainDialogWindow!.Hide();
                 isSuccess = true;
 
                 return outputPath;
             }
             catch when (!isSuccess) // Throw if the isSuccess is not set to true
             {
-                if (!uiRef.HasValue || uiRef.Value.MainDialogWindow == null)
+                if (uiRef?.MainDialogWindow == null)
                 {
                     throw;
                 }
 
-                uiRef.Value.MainDialogWindow.Hide();
+                uiRef.MainDialogWindow.Hide();
                 await Task.Delay(500); // Give artificial delay to give main dialog window thread to close first
                 throw;
             }
@@ -122,7 +127,7 @@ private async Task<string> MoveFile(FileMigrationProcessUIRef uiRef)
             else
             {
                 Logger.LogWriteLine($"[FileMigrationProcess::MoveFile()] Moving file across different drives from: {inputPathInfo.FullName} to {outputPathInfo.FullName}", LogType.Default, true);
-                await MoveWriteFile(uiRef, inputPathInfo, outputPathInfo, TokenSource?.Token ?? default);
+                await MoveWriteFile(uiRef, inputPathInfo, outputPathInfo, TokenSource?.Token ?? CancellationToken.None);
             }
 
             return outputPathInfo.FullName;
@@ -134,51 +139,115 @@ private async Task<string> MoveDirectory(FileMigrationProcessUIRef uiRef)
             DirectoryInfo outputPathInfo = new DirectoryInfo(OutputPath);
             outputPathInfo.Create();
 
-            int parentInputPathLength = inputPathInfo.Parent!.FullName.Length + 1;
-            string outputDirBaseNamePath = inputPathInfo.FullName.Substring(parentInputPathLength);
-            string outputDirPath = Path.Combine(OutputPath, outputDirBaseNamePath);
+            bool isMoveBackward = inputPathInfo.FullName.StartsWith(outputPathInfo.FullName, StringComparison.OrdinalIgnoreCase) &&
+                                  !inputPathInfo.FullName.Equals(outputPathInfo.FullName, StringComparison.OrdinalIgnoreCase);
+
+            // Listing all the existed files first
+            List <FileInfo> inputFileList = [];
+            inputFileList.AddRange(inputPathInfo
+                                  .EnumerateFiles("*", SearchOption.AllDirectories)
+                                  .EnumerateNoReadOnly()
+                                  .Where(x => isMoveBackward || IsNotInOutputDir(x)));
+
+            // Check if both destination and source are SSDs. If true, enable multi-threading.
+            // Disabling multi-threading while either destination or source are HDDs could help
+            // reduce massive seeking, hence improving speed.
+            bool isBothSsd = DriveTypeChecker.IsDriveSsd(InputPath) &&
+                             DriveTypeChecker.IsDriveSsd(OutputPath);
+            ParallelOptions parallelOptions = new ParallelOptions
+            {
+                CancellationToken = TokenSource?.Token ?? CancellationToken.None,
+                MaxDegreeOfParallelism = isBothSsd ? LauncherConfig.AppCurrentThread : 1
+            };
+
+            // Get old list of empty directories so it can be removed later.
+            StringComparer comparer = StringComparer.OrdinalIgnoreCase;
+            HashSet<string> oldDirectoryList = new(inputFileList
+                                                  .Select(x => x.DirectoryName)
+                                                  .Where(x => !string.IsNullOrEmpty(x) && !x.Equals(inputPathInfo.FullName, StringComparison.OrdinalIgnoreCase))
+                                                  .Distinct(comparer)
+                                                  .OrderDescending(), comparer);
+
+            // Perform file migration task
+            await Parallel.ForEachAsync(inputFileList, parallelOptions, Impl);
+            foreach (string dir in oldDirectoryList)
+            {
+                RemoveEmptyDirectory(dir);
+            }
 
-            await Parallel.ForEachAsync(
-                inputPathInfo.EnumerateFiles("*", SearchOption.AllDirectories),
-                new ParallelOptions
-                {
-                    CancellationToken = TokenSource?.Token ?? default,
-                    MaxDegreeOfParallelism = LauncherConfig.AppCurrentThread
-                },
-                async (inputFileInfo, cancellationToken) =>
-                {
-                    int parentInputPathLengthLocal = inputPathInfo.Parent!.FullName.Length + 1;
-                    string inputFileBasePath = inputFileInfo!.FullName[parentInputPathLengthLocal..];
+            return OutputPath;
 
-                    // Update path display
-                    UpdateCountProcessed(uiRef, inputFileBasePath);
+            bool IsNotInOutputDir(FileInfo fileInfo)
+            {
+                bool isEmpty = string.IsNullOrEmpty(fileInfo.DirectoryName);
+                if (isEmpty)
+                {
+                    return false;
+                }
 
-                    string outputTargetPath = Path.Combine(outputPathInfo.FullName, inputFileBasePath);
-                    string outputTargetDirPath = Path.GetDirectoryName(outputTargetPath) ?? Path.GetPathRoot(outputTargetPath);
+                bool isStartsWith = fileInfo.DirectoryName.StartsWith(outputPathInfo.FullName);
+                return !isStartsWith;
+            }
 
-                    if (string.IsNullOrEmpty(outputTargetDirPath)) 
-                        throw new InvalidOperationException(string.Format(Locale.Lang._Dialogs.InvalidGameDirNewTitleFormat,
-                                                                          InputPath));
-                    
-                    DirectoryInfo outputTargetDirInfo = new DirectoryInfo(outputTargetDirPath);
-                    outputTargetDirInfo.Create();
+            void RemoveEmptyDirectory(string dir)
+            {
+                foreach (string innerDir in Directory.EnumerateDirectories(dir))
+                {
+                    RemoveEmptyDirectory(innerDir);
+                }
 
-                    if (IsSameOutputDrive)
-                    {
-                        Logger.LogWriteLine($"[FileMigrationProcess::MoveDirectory()] Moving directory content in the same drive from: {inputFileInfo.FullName} to {outputTargetPath}", LogType.Default, true);
-                        inputFileInfo.MoveTo(outputTargetPath, true);
-                        UpdateSizeProcessed(uiRef, inputFileInfo.Length);
-                    }
-                    else
+                try
+                {
+                    _ = FindFiles.TryIsDirectoryEmpty(dir, out bool isEmpty);
+                    if (!isEmpty)
                     {
-                        Logger.LogWriteLine($"[FileMigrationProcess::MoveDirectory()] Moving directory content across different drives from: {inputFileInfo.FullName} to {outputTargetPath}", LogType.Default, true);
-                        FileInfo outputFileInfo = new FileInfo(outputTargetPath);
-                        await MoveWriteFile(uiRef, inputFileInfo, outputFileInfo, cancellationToken);
+                        string parentDir = Path.GetDirectoryName(dir);
+                        if (!string.IsNullOrEmpty(parentDir))
+                        {
+                            RemoveEmptyDirectory(parentDir);
+                        }
                     }
-                });
 
-            inputPathInfo.Delete(true);
-            return outputDirPath;
+                    Directory.Delete(dir);
+                    Logger.LogWriteLine($"[FileMigrationProcess::MoveDirectory()] Empty directory: {dir} has been deleted!", LogType.Default, true);
+                }
+                catch (IOException)
+                {
+                    // ignored
+                }
+            }
+
+            async ValueTask Impl(FileInfo inputFileInfo, CancellationToken cancellationToken)
+            {
+                string inputFileRelativePath = inputFileInfo.FullName
+                    .AsSpan(InputPath.Length)
+                    .TrimStart("\\/")
+                    .ToString();
+
+                string outputNewFilePath = Path.Combine(OutputPath, inputFileRelativePath);
+                string outputNewFileDir = Path.GetDirectoryName(outputNewFilePath) ?? Path.GetPathRoot(outputNewFilePath);
+                if (!string.IsNullOrEmpty(outputNewFileDir))
+                    Directory.CreateDirectory(outputNewFileDir);
+
+                // Update path display
+                UpdateCountProcessed(uiRef, inputFileRelativePath);
+                if (string.IsNullOrEmpty(outputNewFileDir))
+                    throw new InvalidOperationException(string.Format(Locale.Lang._Dialogs.InvalidGameDirNewTitleFormat,
+                                                                      InputPath));
+
+                if (IsSameOutputDrive)
+                {
+                    Logger.LogWriteLine($"[FileMigrationProcess::MoveDirectory()] Moving directory content in the same drive from: {inputFileInfo.FullName} to {outputNewFilePath}", LogType.Default, true);
+                    inputFileInfo.MoveTo(outputNewFilePath, true);
+                    UpdateSizeProcessed(uiRef, inputFileInfo.Length);
+                }
+                else
+                {
+                    Logger.LogWriteLine($"[FileMigrationProcess::MoveDirectory()] Moving directory content across different drives from: {inputFileInfo.FullName} to {outputNewFilePath}", LogType.Default, true);
+                    FileInfo outputFileInfo = new FileInfo(outputNewFilePath);
+                    await MoveWriteFile(uiRef, inputFileInfo, outputFileInfo, cancellationToken);
+                }
+            }
         }
     }
 }

CollapseLauncher/Classes/FileMigrationProcess/FileMigrationProcessRef.cs

@@ -4,13 +4,13 @@
 
 namespace CollapseLauncher
 {
-    internal struct FileMigrationProcessUIRef
+    internal class FileMigrationProcessUIRef
     {
-        internal ContentDialogCollapse MainDialogWindow;
-        internal TextBlock PathActivitySubtitle;
-        internal Run SpeedIndicatorSubtitle;
-        internal Run FileCountIndicatorSubtitle;
-        internal Run FileSizeIndicatorSubtitle;
-        internal ProgressBar ProgressBarIndicator;
+        internal ContentDialogCollapse MainDialogWindow           { get; set; }
+        internal TextBlock             PathActivitySubtitle       { get; set; }
+        internal Run                   SpeedIndicatorSubtitle     { get; set; }
+        internal Run                   FileCountIndicatorSubtitle { get; set; }
+        internal Run                   FileSizeIndicatorSubtitle  { get; set; }
+        internal ProgressBar           ProgressBarIndicator       { get; set; }
     }
 }

CollapseLauncher/Classes/FileMigrationProcess/Statics.cs

@@ -56,7 +56,7 @@ private static bool IsOutputPathSameAsInput(string inputPath, string outputPath,
             bool isStringEmpty = string.IsNullOrEmpty(outputPath);
 
             if (!isFilePath) inputPath = Path.GetDirectoryName(inputPath);
-            bool isPathEqual = inputPath.AsSpan().TrimEnd('\\').SequenceEqual(outputPath.AsSpan().TrimEnd('\\'));
+            bool isPathEqual = inputPath.AsSpan().TrimEnd("\\/").SequenceEqual(outputPath.AsSpan().TrimEnd("\\/"));
 
             return isStringEmpty || isPathEqual;
         }