Stable 1.82.13 Hotfix

CollapseLauncher/Classes/AnimatedVisuals/Lottie/NewLogoTitleIntro.cs

@@ -156,7 +156,7 @@ void EnsureImageLoadingStarted()
             if (!_isImageLoadingStarted)
             {
                 var eventHandler = new TypedEventHandler<LoadedImageSurface, LoadedImageSourceLoadCompletedEventArgs>(HandleLoadCompleted);
-                _image_image_0 = LoadedImageSurface.StartLoadFromStream(File.OpenRead(Path.Combine(LauncherConfig.AppFolder, @"Assets\CollapseLauncherLogo.png")).AsRandomAccessStream());
+                _image_image_0 = LoadedImageSurface.StartLoadFromStream(File.OpenRead(Path.Combine(LauncherConfig.AppExecutableDir, @"Assets\CollapseLauncherLogo.png")).AsRandomAccessStream());
                 _image_image_0.LoadCompleted += eventHandler;
                 _isImageLoadingStarted = true;
             }

CollapseLauncher/Classes/CachesManagement/Honkai/Fetch.cs

@@ -7,6 +7,7 @@
 using Hi3Helper.Http;
 using Hi3Helper.UABT;
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -17,6 +18,7 @@
 using static Hi3Helper.Data.ConverterTool;
 using static Hi3Helper.Locale;
 using static Hi3Helper.Logger;
+// ReSharper disable SwitchStatementHandlesSomeKnownEnumValuesWithDefault
 
 namespace CollapseLauncher
 {
@@ -41,34 +43,39 @@ private async Task<List<CacheAsset>> Fetch(CancellationToken token)
             await BuildGameRepoURL(downloadClient, token);
 
             // Iterate type and do fetch
-            foreach (CacheAssetType type in Enum.GetValues<CacheAssetType>())
-            {
-                // Skip for unused type
-                switch (type)
+            await Parallel.ForEachAsync(
+                Enum.GetValues<CacheAssetType>(),
+                new ParallelOptions
                 {
-                    case CacheAssetType.Unused:
-                    case CacheAssetType.Dispatcher:
-                    case CacheAssetType.Gateway:
-                    case CacheAssetType.General:
-                    case CacheAssetType.IFix:
-                    case CacheAssetType.DesignData:
-                    case CacheAssetType.Lua:
-                        continue;
-                }
-
-                // uint = Count of the assets available
-                // long = Total size of the assets available
-                (int, long) count = await FetchByType(type, downloadClient, returnAsset, token);
-
-                // Write a log about the metadata
-                LogWriteLine($"Cache Metadata [T: {type}]:", LogType.Default, true);
-                LogWriteLine($"    Cache Count = {count.Item1}", LogType.NoTag, true);
-                LogWriteLine($"    Cache Size = {SummarizeSizeSimple(count.Item2)}", LogType.NoTag, true);
-
-                // Increment the Total Size and Count
-                _progressAllCountTotal += count.Item1;
-                _progressAllSizeTotal += count.Item2;
-            }
+                    MaxDegreeOfParallelism = _threadCount,
+                    CancellationToken      = token
+                },
+                async (type, ctx) =>
+                {
+                    switch (type)
+                    {
+                        case CacheAssetType.Data:
+                        case CacheAssetType.Event:
+                        case CacheAssetType.AI:
+                            {
+                                // uint = Count of the assets available
+                                // long = Total size of the assets available
+                                (int, long) count = await FetchByType(type, downloadClient, returnAsset, ctx);
+
+                                // Write a log about the metadata
+                                LogWriteLine($"Cache Metadata [T: {type}]:",                         LogType.Default, true);
+                                LogWriteLine($"    Cache Count = {count.Item1}",                     LogType.NoTag,   true);
+                                LogWriteLine($"    Cache Size = {SummarizeSizeSimple(count.Item2)}", LogType.NoTag,   true);
+
+                                // Increment the Total Size and Count
+                                Interlocked.Add(ref _progressAllCountTotal, count.Item1);
+                                Interlocked.Add(ref _progressAllSizeTotal,  count.Item2);
+                            }
+                            break;
+                        default:
+                            return;
+                    }
+                });
 
             // Return asset index
             return returnAsset;
@@ -230,7 +237,7 @@ private IEnumerable<CacheAsset> EnumerateCacheTextAsset(CacheAssetType type, IEn
             }
         }
 
-        private async ValueTask<(int, long)> BuildAssetIndex(CacheAssetType type, string baseURL, Stream stream,
+        private async ValueTask<ValueTuple<int, long>> BuildAssetIndex(CacheAssetType type, string baseURL, Stream stream,
                                             List<CacheAsset> assetIndex, CancellationToken token)
         {
             int count = 0;
@@ -258,6 +265,9 @@ private IEnumerable<CacheAsset> EnumerateCacheTextAsset(CacheAssetType type, IEn
                 .SetAllowedDecompression(DecompressionMethods.None)
                 .Create();
 
+            // Use ConcurrentQueue for adding assets in parallel.
+            ConcurrentQueue<CacheAsset> assetQueue = [];
+
             // Iterate lines of the TextAsset in parallel
             await Parallel.ForEachAsync(EnumerateCacheTextAsset(type, dataTextAsset.GetStringList(), baseURL),
                 new ParallelOptions
@@ -283,9 +293,18 @@ await Parallel.ForEachAsync(EnumerateCacheTextAsset(type, dataTextAsset.GetStrin
                         if (!urlStatus.IsSuccessStatusCode) return;
                     }
 
-                    assetIndex.Add(content);
+                    // Append the content to the queue
+                    assetQueue.Enqueue(content);
+
+                    // Increment the count and size
+                    Interlocked.Increment(ref count);
+                    Interlocked.Add(ref size, content.CS);
                 });
 
+            // Take out from the ConcurrentQueue
+            assetIndex.AddRange(assetQueue);
+            assetQueue.Clear();
+
             // Return the count and the size
             return (count, size);
         }

CollapseLauncher/Classes/FileDialog/FileDialogHelper.cs

@@ -150,7 +150,7 @@ private static bool IsProgramFilesPath(ReadOnlySpan<char> path)
 
         private static bool IsCollapseProgramPath(ReadOnlySpan<char> path)
         {
-            string collapseProgramPath = LauncherConfig.AppFolder;
+            string collapseProgramPath = LauncherConfig.AppExecutableDir;
             if (path.StartsWith(collapseProgramPath))
                 return true;
 

CollapseLauncher/Classes/GameManagement/GameSettings/Honkai/RegistryClass/Preset.cs

@@ -68,7 +68,7 @@ public Preset(string presetJSONPath, JsonTypeInfo<Dictionary<string, T1>?> jsonT
         /// <returns>The instance of preset</returns>
         public static Preset<T1, TObjectType> LoadPreset(GameNameType gameType, JsonTypeInfo<Dictionary<string, T1>?> jsonType)
         {
-            string presetPath = Path.Combine(AppFolder, $"Assets\\Presets\\{gameType}\\", $"{typeof(T1).Name}.json");
+            string presetPath = Path.Combine(AppExecutableDir, $"Assets\\Presets\\{gameType}\\", $"{typeof(T1).Name}.json");
             return new Preset<T1, TObjectType>(presetPath, jsonType);
         }
 

CollapseLauncher/Classes/Helper/HttpClientBuilder.cs

@@ -2,7 +2,6 @@
 using Hi3Helper.Shared.Region;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Net;
 using System.Net.Http;
 using System.Net.Security;
@@ -15,23 +14,23 @@ public class HttpClientBuilder : HttpClientBuilder<SocketsHttpHandler>;
 
     public class HttpClientBuilder<THandler> where THandler : HttpMessageHandler, new()
     {
-        private const int _maxConnectionsDefault = 32;
-        private const double _httpTimeoutDefault = 90; // in Seconds
+        private const int MaxConnectionsDefault = 32;
+        private const double HttpTimeoutDefault = 90; // in Seconds
 
         private bool IsUseProxy              { get; set; } = true;
         private bool IsUseSystemProxy        { get; set; } = true;
         private bool IsAllowHttpRedirections { get; set; }
         private bool IsAllowHttpCookies      { get; set; }
         private bool IsAllowUntrustedCert    { get; set; }
 
-        private int                         MaxConnections            { get; set; } = _maxConnectionsDefault;
+        private int                         MaxConnections            { get; set; } = MaxConnectionsDefault;
         private DecompressionMethods        DecompressionMethod       { get; set; } = DecompressionMethods.All;
         private WebProxy?                   ExternalProxy             { get; set; }
         private Version                     HttpProtocolVersion       { get; set; } = HttpVersion.Version30;
         private string?                     HttpUserAgent             { get; set; } = GetDefaultUserAgent();
         private string?                     HttpAuthHeader            { get; set; }
         private HttpVersionPolicy           HttpProtocolVersionPolicy { get; set; } = HttpVersionPolicy.RequestVersionOrLower;
-        private TimeSpan                    HttpTimeout               { get; set; } = TimeSpan.FromSeconds(_httpTimeoutDefault);
+        private TimeSpan                    HttpTimeout               { get; set; } = TimeSpan.FromSeconds(HttpTimeoutDefault);
         private Uri?                        HttpBaseUri               { get; set; }
         private Dictionary<string, string?> HttpHeaders               { get; set; } = new(StringComparer.OrdinalIgnoreCase);
 
@@ -45,12 +44,11 @@ public HttpClientBuilder<THandler> UseProxy(bool isUseSystemProxy = true)
         private static string GetDefaultUserAgent()
         {
             Version operatingSystemVer = Environment.OSVersion.Version;
-            FileVersionInfo winAppSDKVer = FileVersionInfo.GetVersionInfo("Microsoft.ui.xaml.dll");
 
             return $"Mozilla/5.0 (Windows NT {operatingSystemVer}; Win64; x64) "
                 + $"{RuntimeInformation.FrameworkDescription.Replace(' ', '/')} (KHTML, like Gecko) "
                 + $"Collapse/{LauncherUpdateHelper.LauncherCurrentVersionString}-{(LauncherConfig.IsPreview ? "Preview" : "Stable")} "
-                + $"WinAppSDK/{winAppSDKVer.ProductVersion}";
+                + $"WinAppSDK/{LauncherConfig.WindowsAppSdkVersion}";
         }
 
         public HttpClientBuilder<THandler> UseExternalProxy(string host, string? username = null, string? password = null)
@@ -81,7 +79,7 @@ public HttpClientBuilder<THandler> UseExternalProxy(Uri hostUri, string? usernam
             return this;
         }
 
-        public HttpClientBuilder<THandler> UseLauncherConfig(int maxConnections = _maxConnectionsDefault)
+        public HttpClientBuilder<THandler> UseLauncherConfig(int maxConnections = MaxConnectionsDefault)
         {
             bool lIsUseProxy = LauncherConfig.GetAppConfigValue("IsUseProxy").ToBool();
             bool lIsAllowHttpRedirections = LauncherConfig.GetAppConfigValue("IsAllowHttpRedirections").ToBool();
@@ -112,7 +110,7 @@ public HttpClientBuilder<THandler> UseLauncherConfig(int maxConnections = _maxCo
             return this;
         }
 
-        public HttpClientBuilder<THandler> SetMaxConnection(int maxConnections = _maxConnectionsDefault)
+        public HttpClientBuilder<THandler> SetMaxConnection(int maxConnections = MaxConnectionsDefault)
         {
             if (maxConnections < 2)
                 maxConnections = 2;
@@ -160,18 +158,18 @@ public HttpClientBuilder<THandler> SetHttpVersion(Version? version = null, HttpV
             return this;
         }
 
-        public HttpClientBuilder<THandler> SetTimeout(double fromSeconds = _httpTimeoutDefault)
+        public HttpClientBuilder<THandler> SetTimeout(double fromSeconds = HttpTimeoutDefault)
         {
             if (double.IsNaN(fromSeconds) || double.IsInfinity(fromSeconds))
-                fromSeconds = _httpTimeoutDefault;
+                fromSeconds = HttpTimeoutDefault;
 
             return SetTimeout(TimeSpan.FromSeconds(fromSeconds));
         }
 
         public HttpClientBuilder<THandler> SetTimeout(TimeSpan? timeout = null)
         {
-            timeout ??= TimeSpan.FromSeconds(_httpTimeoutDefault);
-            HttpTimeout = timeout.Value;
+            timeout     ??= TimeSpan.FromSeconds(HttpTimeoutDefault);
+            HttpTimeout =   timeout.Value;
             return this;
         }
 

CollapseLauncher/Classes/Helper/Image/ImageLoaderHelper.cs

@@ -89,8 +89,8 @@ private static Waifu2X CreateWaifu2X()
             {
                 waifu2X.SetParam(Param.Noise, -1);
                 waifu2X.SetParam(Param.Scale, 2);
-                waifu2X.Load(Path.Combine(AppFolder!, @"Assets\Waifu2X_Models\scale2.0x_model.param.bin"),
-                    Path.Combine(AppFolder!, @"Assets\Waifu2X_Models\scale2.0x_model.bin"));
+                waifu2X.Load(Path.Combine(AppExecutableDir, @"Assets\Waifu2X_Models\scale2.0x_model.param.bin"),
+                    Path.Combine(AppExecutableDir, @"Assets\Waifu2X_Models\scale2.0x_model.bin"));
                 _cachedStatus = waifu2X.Status;
             }
             return waifu2X;
@@ -179,7 +179,7 @@ private static async Task<FileStream> SpawnImageCropperDialog(string filePath, s
             imageCropper.Opacity = 0;
 
             // Path of image
-            Uri overlayImageUri = new Uri(Path.Combine(AppFolder!, @"Assets\Images\ImageCropperOverlay",
+            Uri overlayImageUri = new Uri(Path.Combine(AppExecutableDir, @"Assets\Images\ImageCropperOverlay",
                                                        GetAppConfigValue("WindowSizeProfile").ToString() == "Small" ? "small.png" : "normal.png"));
 
             // Why not use ImageBrush?

CollapseLauncher/Classes/Helper/Image/Waifu2X.cs

@@ -28,7 +28,7 @@ static Waifu2XPInvoke()
 
         private static IntPtr DllImportResolver(string libraryName, Assembly assembly, DllImportSearchPath? searchPath)
         {
-            appDirPath ??= LauncherConfig.AppFolder;
+            appDirPath ??= LauncherConfig.AppExecutableDir;
 
             if (DllImportSearchPath.AssemblyDirectory != searchPath
              && DllImportSearchPath.ApplicationDirectory != searchPath)

CollapseLauncher/Classes/Helper/TaskSchedulerHelper.cs

@@ -233,7 +233,7 @@ private static async Task<int> GetInvokeCommandReturnCode(string argument)
             const string retValMark = "RETURNVAL_";
 
             // Get the applet path and check if the file exist
-            string appletPath = Path.Combine(LauncherConfig.AppFolder, "Lib", "win-x64", "Hi3Helper.TaskScheduler.exe");
+            string appletPath = Path.Combine(LauncherConfig.AppExecutableDir, "Lib", "win-x64", "Hi3Helper.TaskScheduler.exe");
             if (!File.Exists(appletPath))
             {
                 Logger.LogWriteLine($"Task Scheduler Applet does not exist in this path: {appletPath}", LogType.Error, true);

CollapseLauncher/Classes/Helper/Update/LauncherUpdateHelper.cs

@@ -5,6 +5,8 @@
 using Hi3Helper.Shared.Region;
 using System;
 using System.Threading.Tasks;
+using System.Diagnostics.CodeAnalysis;
+
 #if !USEVELOPACK
 using Squirrel;
 using Squirrel.Sources;
@@ -20,26 +22,13 @@ namespace CollapseLauncher.Helper.Update
 {
     internal static class LauncherUpdateHelper
     {
-        static LauncherUpdateHelper()
-        {
-            string? versionString = LauncherConfig.AppCurrentVersionString;
-            if (string.IsNullOrEmpty(versionString))
-                throw new NullReferenceException("App cannot retrieve the current version of the executable!");
-
-            _launcherCurrentVersion = new GameVersion(versionString);
-            _launcherCurrentVersionString = _launcherCurrentVersion.VersionString;
-        }
-
         internal static AppUpdateVersionProp? AppUpdateVersionProp;
         internal static bool IsLauncherUpdateAvailable;
 
-        private static readonly GameVersion _launcherCurrentVersion;
-        internal static GameVersion? LauncherCurrentVersion
-            => _launcherCurrentVersion;
+        internal static GameVersion? LauncherCurrentVersion => field ??= new(LauncherConfig.AppCurrentVersionString);
 
-        private static readonly string _launcherCurrentVersionString;
-        internal static string LauncherCurrentVersionString
-            => _launcherCurrentVersionString;
+        [field: AllowNull, MaybeNull]
+        internal static string LauncherCurrentVersionString => field = LauncherConfig.AppCurrentVersionString;
 
         internal static async Task RunUpdateCheckDetached()
         {