Add per-file progress callback support

Register a native per-file progress callback for plugins and use it to populate per-file progress fields.

- Introduces an unmanaged Cdecl delegate and GCHandle to hold a reverse P/Invoke callback (OnPerFileProgressCallback) and safe registration/unregistration helpers (TryRegisterPerFileProgressCallback, UnregisterPerFileProgressCallback).
- Calls registration before starting preload/download and ensures unregistration in finally blocks.
- OnPerFileProgressCallback updates per-file bytes/percentage inside a try/catch (must not throw when invoked from native AOT).
- Adjusts progress reporting: when the plugin provides per-file updates, use that data (and only mirror speed from aggregate); otherwise fall back to mirroring aggregate values into per-file fields.
- Adds PluginInfo.EnablePerFileProgressCallback and DisablePerFileProgressCallback which call the plugin export SetPerFileProgressCallback (Cdecl) and log failures.

Author: Cryotechnic

CollapseLauncher/Classes/Plugins/PluginGameInstallWrapper.cs

@@ -20,6 +20,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -28,6 +29,9 @@ namespace CollapseLauncher.Plugins;
 #nullable enable
 internal partial class PluginGameInstallWrapper : ProgressBase<PkgVersionProperties>, IGameInstallManager
 {
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    private unsafe delegate void PerFileProgressCallbackNative(InstallPerFileProgress* progress);
+
     private struct InstallProgressProperty
     {
         public int  StateCount;
@@ -61,6 +65,10 @@ public override string GamePath
     private readonly InstallProgressStateDelegate _updateProgressStatusDelegate;
     private          InstallProgressProperty      _updateProgressProperty;
 
+    private PerFileProgressCallbackNative? _perFileProgressDelegate;
+    private GCHandle                       _perFileProgressGcHandle;
+    private bool                           _hasPerFileProgress;
+
     private PluginGameVersionWrapper GameManager =>
         GameVersionManager as PluginGameVersionWrapper ?? throw new InvalidCastException("GameVersionManager is not PluginGameVersionWrapper");
 
@@ -101,10 +109,60 @@ private void ResetAndCancelTokenSource()
 
     public void Dispose()
     {
+        UnregisterPerFileProgressCallback();
         _gameInstaller.Free();
         GC.SuppressFinalize(this);
     }
 
+    private void TryRegisterPerFileProgressCallback()
+    {
+        _perFileProgressDelegate = OnPerFileProgressCallback;
+        _perFileProgressGcHandle = GCHandle.Alloc(_perFileProgressDelegate);
+        nint callbackPtr = Marshal.GetFunctionPointerForDelegate(_perFileProgressDelegate);
+
+        _hasPerFileProgress = _pluginPresetConfig.PluginInfo.EnablePerFileProgressCallback(callbackPtr);
+
+        if (!_hasPerFileProgress)
+        {
+            _perFileProgressGcHandle.Free();
+            _perFileProgressDelegate = null;
+        }
+    }
+
+    private void UnregisterPerFileProgressCallback()
+    {
+        if (!_hasPerFileProgress)
+            return;
+
+        _pluginPresetConfig.PluginInfo.DisablePerFileProgressCallback();
+        _hasPerFileProgress = false;
+
+        if (_perFileProgressGcHandle.IsAllocated)
+            _perFileProgressGcHandle.Free();
+        _perFileProgressDelegate = null;
+    }
+
+    private unsafe void OnPerFileProgressCallback(InstallPerFileProgress* progress)
+    {
+        // IMPORTANT: Called from NativeAOT plugin across reverse P/Invoke. Must never throw.
+        try
+        {
+            long downloaded = progress->PerFileDownloadedBytes;
+            long total = progress->PerFileTotalBytes;
+
+            Progress.ProgressPerFileSizeCurrent = downloaded;
+            Progress.ProgressPerFileSizeTotal   = total;
+            Progress.ProgressPerFilePercentage  = total > 0
+                ? ConverterTool.ToPercentage(total, downloaded)
+                : 0;
+        }
+        catch (Exception ex)
+        {
+            Logger.LogWriteLine($"[PluginGameInstallWrapper::OnPerFileProgressCallback] Exception (swallowed):\r\n{ex}",
+                                LogType.Error, true);
+        }
+    }
+
     [MethodImpl(MethodImplOptions.NoOptimization | MethodImplOptions.NoInlining)]
     public async ValueTask<int> GetInstallationPath(bool isHasOnlyMigrateOption = false)
     {
@@ -230,6 +288,8 @@ public async Task StartPackageDownload(bool skipDialog = false)
             await EnsureDiskSpaceAvailability(GameManager.GameDirPath, sizeToDownload, sizeAlreadyDownloaded);
 
             Logger.LogWriteLine("[PluginGameInstallWrapper::StartPackageDownload] Step 5/5: StartPreloadAsync...", LogType.Debug, true);
+            TryRegisterPerFileProgressCallback();
+
             _gameInstaller.StartPreloadAsync(
                 _updateProgressDelegate,
                 _updateProgressStatusDelegate,
@@ -254,6 +314,7 @@ public async Task StartPackageDownload(bool skipDialog = false)
         finally
         {
             Logger.LogWriteLine("[PluginGameInstallWrapper::StartPackageDownload] Entering finally block.", LogType.Debug, true);
+            UnregisterPerFileProgressCallback();
             Status.IsCompleted = true;
             IsRunning          = false;
             UpdateStatus();
@@ -296,6 +357,8 @@ public async Task StartPackageInstallation()
 
             await EnsureDiskSpaceAvailability(GameManager.GameDirPath, sizeToDownload, sizeAlreadyDownloaded);
 
+            TryRegisterPerFileProgressCallback();
+
             Task routineTask;
             if (_updateProgressProperty.IsUpdateMode)
             {
@@ -327,6 +390,7 @@ public async Task StartPackageInstallation()
         }
         finally
         {
+            UnregisterPerFileProgressCallback();
             Status.IsCompleted = true;
             IsRunning = false;
             UpdateStatus();
@@ -358,11 +422,22 @@ private void UpdateProgressCallback(in InstallProgress delegateProgress)
                 Progress.ProgressAllSizeTotal = downloadedBytesTotal;
                 Progress.ProgressAllSpeed = currentSpeed;
 
-                // Mirror into per-file fields — plugin reports aggregate progress only,
-                // but the preload UI has a left-side panel that reads PerFile values.
-                Progress.ProgressPerFileSizeCurrent = downloadedBytes;
-                Progress.ProgressPerFileSizeTotal   = downloadedBytesTotal;
-                Progress.ProgressPerFileSpeed        = currentSpeed;
+                if (_hasPerFileProgress)
+                {
+                    // V1Ext_Update5: per-file bytes/percentage come from OnPerFileProgressCallback.
+                    // We only set the speed here (overall throughput is the meaningful metric).
+                    Progress.ProgressPerFileSpeed = currentSpeed;
+                }
+                else
+                {
+                    // Fallback: mirror aggregate values into per-file fields for older plugins.
+                    Progress.ProgressPerFileSizeCurrent = downloadedBytes;
+                    Progress.ProgressPerFileSizeTotal   = downloadedBytesTotal;
+                    Progress.ProgressPerFileSpeed       = currentSpeed;
+                    Progress.ProgressPerFilePercentage  = downloadedBytesTotal > 0
+                        ? ConverterTool.ToPercentage(downloadedBytesTotal, downloadedBytes)
+                        : 0;
+                }
 
                 Progress.ProgressAllTimeLeft = downloadedBytesTotal > 0 && currentSpeed > 0
                     ? ConverterTool.ToTimeSpanRemain(downloadedBytesTotal, downloadedBytes, currentSpeed)
@@ -372,8 +447,6 @@ private void UpdateProgressCallback(in InstallProgress delegateProgress)
                     ? ConverterTool.ToPercentage(downloadedBytesTotal, downloadedBytes)
                     : 0;
 
-                Progress.ProgressPerFilePercentage = Progress.ProgressAllPercentage;
-
                 _updateProgressProperty.LastDownloaded = downloadedBytes;
 
                 if (!CheckIfNeedRefreshStopwatch())

CollapseLauncher/Classes/Plugins/PluginInfo.cs

@@ -329,6 +329,43 @@ internal unsafe void ToggleSpeedLimiterService(bool isEnable)
         }
     }
 
+    /// <summary>
+    /// Registers a per-file progress callback with the plugin via the V1Ext_Update5 export.
+    /// Returns <c>true</c> if the plugin supports Update5 and the callback was registered.
+    /// </summary>
+    internal unsafe bool EnablePerFileProgressCallback(nint callbackPtr)
+    {
+        if (!IsLoaded)
+            return false;
+
+        if (!Handle.TryGetExportUnsafe("SetPerFileProgressCallback", out nint setCallbackP))
+            return false;
+
+        HResult hr = ((delegate* unmanaged[Cdecl]<nint, HResult>)setCallbackP)(callbackPtr);
+        if (Marshal.GetExceptionForHR(hr) is { } exception)
+        {
+            Logger.LogWriteLine($"[PluginInfo] Plugin: {Name} failed to register per-file progress callback: {hr} {exception}",
+                                LogType.Error, true);
+            return false;
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// Unregisters the per-file progress callback from the plugin.
+    /// </summary>
+    internal unsafe void DisablePerFileProgressCallback()
+    {
+        if (!IsLoaded)
+            return;
+
+        if (!Handle.TryGetExportUnsafe("SetPerFileProgressCallback", out nint setCallbackP))
+            return;
+
+        ((delegate* unmanaged[Cdecl]<nint, HResult>)setCallbackP)(nint.Zero);
+    }
+
     internal async Task Initialize(CancellationToken token = default)
     {
         if (!IsLoaded)