Add new arguments on GameManagerExtension.RunGameFromGameManagerAsync

Author: neon-nyan

SharedStatic.Generic.cs

@@ -3,6 +3,7 @@
 using Hi3Helper.Plugin.Core.Utility;
 using Microsoft.Extensions.Logging;
 using System;
+using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Threading;
@@ -45,9 +46,18 @@ static SharedStatic()
 
     /// <summary>
     /// This method is an ABI proxy function between the PInvoke Export and the actual plugin's method.<br/>
-    /// See the documentation for <see cref="SharedStatic.LaunchGameFromGameManagerCoreAsync(RunGameFromGameManagerContext, CancellationToken)"/> method for more information.
+    /// See the documentation for <see cref="SharedStatic.LaunchGameFromGameManagerCoreAsync(RunGameFromGameManagerContext, string?, bool, ProcessPriorityClass, CancellationToken)"/> method for more information.
     /// </summary>
-    public static unsafe int LaunchGameFromGameManagerAsync(nint gameManagerP, nint pluginP, nint presetConfigP, nint printGameLogCallbackP, ref Guid cancelToken, out nint taskResult)
+    public static unsafe int LaunchGameFromGameManagerAsync(nint     gameManagerP,
+                                                            nint     pluginP,
+                                                            nint     presetConfigP,
+                                                            nint     printGameLogCallbackP,
+                                                            nint     arguments,
+                                                            int      argumentsLen,
+                                                            int      runBoostedInt,
+                                                            int      processPriorityInt,
+                                                            ref Guid cancelToken,
+                                                            out nint taskResult)
     {
         taskResult = nint.Zero;
         try
@@ -104,8 +114,24 @@ public static unsafe int LaunchGameFromGameManagerAsync(nint gameManagerP, nint
                 PluginHandle         = nint.Zero
             };
 
+            bool                 isRunBoosted         = runBoostedInt == 1;
+            ProcessPriorityClass processPriorityClass = (ProcessPriorityClass)processPriorityInt;
+
+            string? startArguments = null;
+            if (argumentsLen > 0)
+            {
+                char* argumentsP = (char*)arguments;
+                ReadOnlySpan<char> argumentsSpan = Mem.CreateSpanFromNullTerminated<char>(argumentsP);
+                if (argumentsSpan.Length > argumentsLen)
+                {
+                    argumentsSpan = argumentsSpan[..argumentsLen];
+                }
+
+                startArguments = argumentsSpan.IsEmpty ? null : argumentsSpan.ToString();
+            }
+
             taskResult = ThisPluginExport
-                .LaunchGameFromGameManagerCoreAsync(context, cts?.Token ?? CancellationToken.None)
+                .LaunchGameFromGameManagerCoreAsync(context, startArguments, isRunBoosted, processPriorityClass, cts?.Token ?? CancellationToken.None)
                 .AsResult();
             return 0;
         }

SharedStatic.cs

@@ -4,11 +4,14 @@
 using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Runtime.InteropServices.Marshalling;
 using System.Threading;
 using System.Threading.Tasks;
+
 using static Hi3Helper.Plugin.Core.Utility.GameManagerExtension;
+
 // ReSharper disable CommentTypo
 
 #if MANUALCOM
@@ -124,7 +127,7 @@ static unsafe SharedStatic()
     protected unsafe delegate void  GetPluginUpdateCdnListDelegate(int* count, ushort*** ptr);
     protected        delegate void  SetCallbackPointerDelegate(nint callbackP);
 
-    internal delegate int LaunchGameFromGameManagerAsyncDelegate(nint gameManagerP, nint pluginP, nint presetConfigP, nint printGameLogCallbackP, ref Guid cancelToken, out nint taskResult);
+    internal delegate int LaunchGameFromGameManagerAsyncDelegate(nint gameManagerP, nint pluginP, nint presetConfigP, nint printGameLogCallbackP, nint arguments, int argumentsLen, int runBoostedInt, int processPriorityInt, ref Guid cancelToken, out nint taskResult);
     internal delegate int WaitRunningGameAsyncDelegate(nint gameManagerP, nint pluginP, nint presetConfigP, ref Guid cancelToken, out nint taskResult);
     internal delegate int IsGameRunningDelegate(nint gameManagerP, nint presetConfigP, out int isGameRunning);
 
@@ -374,6 +377,9 @@ public static unsafe int TryGetApiExportPointer(char* apiExportName, void** dele
     /// Asynchronously launch the game using plugin's built-in game launch mechanism and wait until the game exit.
     /// </summary>
     /// <param name="context">The context to launch the game from <see cref="IGameManager"/>.</param>
+    /// <param name="startArgument">The additional argument to run the game executable.</param>
+    /// <param name="isRunBoosted">Based on <see cref="Process.PriorityBoostEnabled"/>, boost the process temporarily when the game window is focused (Default: false).</param>
+    /// <param name="processPriority">Based on <see cref="Process.PriorityClass"/>, run the game process with specific priority (Default: <see cref="ProcessPriorityClass.Normal"/>).</param>
     /// <param name="token">
     /// Cancellation token to pass into the plugin's game launch mechanism.<br/>
     /// If cancellation is requested, it will cancel the awaiting but not killing the game process.
@@ -382,7 +388,7 @@ public static unsafe int TryGetApiExportPointer(char* apiExportName, void** dele
     /// Returns <c>false</c> if the plugin doesn't have game launch mechanism (or API Standard is equal or lower than v0.1.0) or if this method isn't overriden.<br/>
     /// Otherwise, <c>true</c> if the plugin supports game launch mechanism.
     /// </returns>
-    public virtual Task<bool> LaunchGameFromGameManagerCoreAsync(RunGameFromGameManagerContext context, CancellationToken token)
+    public virtual Task<bool> LaunchGameFromGameManagerCoreAsync(RunGameFromGameManagerContext context, string? startArgument, bool isRunBoosted, ProcessPriorityClass processPriority, CancellationToken token)
     {
         return Task.FromResult(false);
     }

Utility/GameManagerExtension.cs

@@ -1,6 +1,7 @@
 using Hi3Helper.Plugin.Core.Management;
 using Hi3Helper.Plugin.Core.Management.PresetConfig;
 using System;
+using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.InteropServices;
 using System.Runtime.InteropServices.Marshalling;
@@ -54,6 +55,9 @@ public class RunGameFromGameManagerContext
     /// Asynchronously launch the game using plugin's built-in game launch mechanism and wait until the game exit.
     /// </summary>
     /// <param name="context">The context to launch the game from <see cref="IGameManager"/>.</param>
+    /// <param name="startArgument">The additional argument string to run the game executable (Default: null).</param>
+    /// <param name="isRunBoosted">Based on <see cref="Process.PriorityBoostEnabled"/>, boost the process temporarily when the game window is focused (Default: false).</param>
+    /// <param name="processPriority">Based on <see cref="Process.PriorityClass"/>, run the game process with specific priority (Default: <see cref="ProcessPriorityClass.Normal"/>).</param>
     /// <param name="token">
     /// Cancellation token to pass into the plugin's game launch mechanism.<br/>
     /// If cancellation is requested, it will cancel the awaiting but not killing the game process.
@@ -64,7 +68,10 @@ public class RunGameFromGameManagerContext
     /// </returns>
     public static async Task<(bool IsSuccess, Exception? Error)>
         RunGameFromGameManagerAsync(this RunGameFromGameManagerContext context,
-                                    CancellationToken                  token)
+                                    string?                            startArgument   = null,
+                                    bool                               isRunBoosted    = false,
+                                    ProcessPriorityClass               processPriority = ProcessPriorityClass.Normal,
+                                    CancellationToken                  token           = default)
     {
         ArgumentNullException.ThrowIfNull(context, nameof(context));
         if (!context.PluginHandle.TryGetExport("LaunchGameFromGameManagerAsync", out SharedStatic.LaunchGameFromGameManagerAsyncDelegate launchGameFromGameManagerAsyncCallback))
@@ -97,8 +104,20 @@ public class RunGameFromGameManagerContext
             return (false, new COMException("Cannot cast PrintGameLog delegate/callback to pointer!"));
         }
 
+        nint argumentsP   = startArgument.GetPinnableStringPointerSafe();
+        int  argumentsLen = startArgument?.Length ?? 0;
+
         Guid cancelTokenGuid = Guid.CreateVersion7();
-        int hResult = launchGameFromGameManagerAsyncCallback(gameManagerP, pluginP, presetConfigP, printGameLogCallbackP, ref cancelTokenGuid, out nint taskResult);
+        int hResult = launchGameFromGameManagerAsyncCallback(gameManagerP,
+                                                             pluginP, 
+                                                             presetConfigP,
+                                                             printGameLogCallbackP,
+                                                             argumentsP,
+                                                             argumentsLen,
+                                                             isRunBoosted ? 1 : 0,
+                                                             (int)processPriority,
+                                                             ref cancelTokenGuid,
+                                                             out nint taskResult);
 
         if (taskResult == nint.Zero)
         {