Custom triggers optional execute on main thread

Allow custom triggers to be executed on the main thread in a queue. We need this internally to repaint the editor GUI as it uses the Unity API.

Author: rogerbarton

README.md

@@ -30,6 +30,7 @@ Tool created mainly to solve old problem with reloading [native plugins](https:/
 - If something is not working, first check out available options (and read their descriptions), then [report an issue](https://github.com/mcpiroman/UnityNativeTool/issues/new).
 - Options are accessible via `DllManipulatorScript` editor or window.
 - Although this tool presumably works in built game, it's intended to be used in editor.
+- Get callbacks in C# when the dll load state has changed with attributes like `[NativeDllLoadedTrigger]`, see `Attributes.cs` for more information
 
 ## Limitations
 - Marshaling parameter attributes other than `[MarshalAs]`, `[In]` and `[Out]` are not supported.

scripts/Attributes.cs

@@ -30,13 +30,24 @@ public class DisableMockingAttribute : Attribute
 
     }
 
+    [AttributeUsage(AttributeTargets.Method, AllowMultiple = true, Inherited = false)]
+    public class TriggerAttribute : Attribute
+    {
+        /// <summary>
+        /// Should the method always be executed on the main thread, to allow use of the Unity API.
+        /// Note: this means the method is not immediately executed but put in a queue.
+        /// For consistent behaviour, the method is put in the queue even if it is triggered from the main thread.
+        /// </summary>
+        public bool UseMainThreadQueue = false;
+    }
+    
     /// <summary>
     /// Methods with this attribute are called directly after a native DLL has been loaded.
     /// Such method must be <see langword="static"/> and either have no parameters or one parameter of type <see cref="NativeDll"/>
     /// which indicates the state of the dll being loaded. Please treat this parameter as readonly.
     /// </summary>
     [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
-    public class NativeDllLoadedTriggerAttribute : Attribute
+    public class NativeDllLoadedTriggerAttribute : TriggerAttribute
     {
 
     }
@@ -47,7 +58,7 @@ public class NativeDllLoadedTriggerAttribute : Attribute
     /// which indicates the state of the dll being unloaded. Please treat this parameter as readonly.
     /// </summary>
     [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
-    public class NativeDllBeforeUnloadTriggerAttribute : Attribute
+    public class NativeDllBeforeUnloadTriggerAttribute : TriggerAttribute
     {
 
     }
@@ -58,7 +69,7 @@ public class NativeDllBeforeUnloadTriggerAttribute : Attribute
     /// which indicates the state of the dll being unloaded. Please treat this parameter as readonly.
     /// </summary>
     [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
-    public class NativeDllAfterUnloadTriggerAttribute : Attribute
+    public class NativeDllAfterUnloadTriggerAttribute : TriggerAttribute
     {
 
     }

scripts/DllManipulator.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
@@ -30,10 +31,12 @@ public partial class DllManipulator
         private static List<NativeFunction> _mockedNativeFunctions = new List<NativeFunction>();
         private static int _createdDelegateTypes = 0;
         private static int _lastNativeCallIndex = 0; //Use with synchronization
-        private static List<MethodInfo> _customLoadedTriggers = null;
-        private static List<MethodInfo> _customBeforeUnloadTriggers = null;
-        private static List<MethodInfo> _customAfterUnloadTriggers = null;
-
+        
+        private static List<Tuple<MethodInfo, bool>> _customLoadedTriggers = null; //List of callbacks to run, whether to run them on the main thread.
+        private static List<Tuple<MethodInfo, bool>> _customBeforeUnloadTriggers = null;
+        private static List<Tuple<MethodInfo, bool>> _customAfterUnloadTriggers = null;
+        private static ConcurrentQueue<Tuple<MethodInfo, object[]>> _mainThreadTriggerQueue = new ConcurrentQueue<Tuple<MethodInfo, object[]>>();
+        
         /// <summary>
         /// Initialization.
         /// Finds and mocks relevant native function declarations.
@@ -84,13 +87,13 @@ internal static void Initialize(int unityMainThreadId, string assetsPath)
                         else
                         {
                             if (method.IsDefined(typeof(NativeDllLoadedTriggerAttribute)))
-                                RegisterTriggerMethod(method, ref _customLoadedTriggers);
+                                RegisterTriggerMethod(method, ref _customLoadedTriggers, method.GetCustomAttribute<NativeDllLoadedTriggerAttribute>().UseMainThreadQueue);
 
                             if (method.IsDefined(typeof(NativeDllBeforeUnloadTriggerAttribute)))
-                                RegisterTriggerMethod(method, ref _customBeforeUnloadTriggers);
+                                RegisterTriggerMethod(method, ref _customBeforeUnloadTriggers, method.GetCustomAttribute<NativeDllBeforeUnloadTriggerAttribute>().UseMainThreadQueue);
 
                             if (method.IsDefined(typeof(NativeDllAfterUnloadTriggerAttribute)))
-                                RegisterTriggerMethod(method, ref _customAfterUnloadTriggers);
+                                RegisterTriggerMethod(method, ref _customAfterUnloadTriggers, method.GetCustomAttribute<NativeDllAfterUnloadTriggerAttribute>().UseMainThreadQueue);
                         }
                     }
                 }
@@ -113,19 +116,20 @@ public static void Reset()
             _customAfterUnloadTriggers?.Clear();
             _customBeforeUnloadTriggers?.Clear();
         }
-        
-        private static void RegisterTriggerMethod(MethodInfo method, ref List<MethodInfo> triggersList)
+
+        private static void RegisterTriggerMethod(MethodInfo method, ref List<Tuple<MethodInfo, bool>> triggersList, bool runOnMainThread)
         {
             var parameters = method.GetParameters();
-            if (parameters.Length == 0 || parameters.Length == 1 && parameters[0].ParameterType == typeof(NativeDll))
+            if (parameters.Length == 0 || parameters.Length == 1 && parameters[0].ParameterType == typeof(NativeDll)
+                                       || parameters.Length == 2 && parameters[0].ParameterType == typeof(NativeDll) && parameters[1].ParameterType == typeof(int))
             {
                 if (triggersList == null)
-                    triggersList = new List<MethodInfo>(2);
-                triggersList.Add(method);
+                    triggersList = new List<Tuple<MethodInfo, bool>>();
+                triggersList.Add(new Tuple<MethodInfo, bool>(method, runOnMainThread));
             }
             else
             {
-                Debug.LogError($"Trigger method must either take no parameters or one parameter of type {nameof(NativeDll)}. Violation on method {method.Name} in {method.DeclaringType.FullName}");
+                Debug.LogError($"Trigger method must either take no parameters or one parameter of type {nameof(NativeDll)} or two of type {nameof(NativeDll)} and int. Violation on method {method.Name} in {method.DeclaringType.FullName}");
             }
         }
 
@@ -522,20 +526,41 @@ internal static void LoadTargetFunction(NativeFunction nativeFunction, bool igno
             }
         }
 
-        private static void InvokeCustomTriggers(List<MethodInfo> triggers, NativeDll dll)
+        private static void InvokeCustomTriggers(List<Tuple<MethodInfo, bool>> triggers, NativeDll dll)
         {
             if (triggers == null)
                 return;
 
-            foreach(var triggerMethod in triggers)
+            foreach(var (methodInfo, useMainThreadQueue) in triggers)
             {
-                if (triggerMethod.GetParameters().Length == 1)
-                    triggerMethod.Invoke(null, new object[] { dll });
+                object[] args;
+                
+                // Determine args for method
+                if (methodInfo.GetParameters().Length == 2)
+                    args = new object[] { dll, _unityMainThreadId };
+                else if (methodInfo.GetParameters().Length == 1)
+                    args = new object[] { dll };
+                else
+                    args =  Array.Empty<object>();
+                
+                // Execute now or queue to the main thread
+                if (useMainThreadQueue /*&& Thread.CurrentThread.ManagedThreadId != _unityMainThreadId*/)
+                    _mainThreadTriggerQueue.Enqueue(new Tuple<MethodInfo, object[]>(methodInfo, args));
                 else
-                    triggerMethod.Invoke(null, Array.Empty<object>());
+                    methodInfo.Invoke(null, args);
             }
         }
 
+        /// <summary>
+        /// Executes queued methods.
+        /// Should be called from the main thread in Update.
+        /// </summary>
+        public static void InvokeMainThreadQueue()
+        {
+            while (_mainThreadTriggerQueue.TryDequeue(out var action))
+                action.Item1.Invoke(null, action.Item2);
+        }
+
         /// <summary>
         /// Logs native function's call to file. If that file exists, it is overwritten. One file is maintained for each thread.
         /// Note: This method is being called by dynamically generated code. Be careful when changing its signature.

scripts/DllManipulatorScript.cs

@@ -57,6 +57,10 @@ private void OnEnable()
 
             if(EditorApplication.isPlaying || Options.enableInEditMode)
                 Initialize();
+            
+            if(!EditorApplication.isPlaying && Options.enableInEditMode)
+                EditorApplication.update += Update;
+
 #else
             if (Options.onlyInEditor) 
                 return;
@@ -83,6 +87,20 @@ private void Initialize()
             initTimer.Stop();
             InitializationTime = initTimer.Elapsed;
         }
+        
+        /// <summary>
+        /// Note: also called in edit mode if Options.enableInEditMode is set.
+        /// </summary>
+        private void Update()
+        {
+            DllManipulator.InvokeMainThreadQueue();
+        }
+
+        private void OnDisable()
+        {
+            if(!EditorApplication.isPlaying && Options.enableInEditMode)
+                EditorApplication.update -= Update;
+        }
 
         private void OnDestroy()
         {

scripts/Editor/DllManipulatorEditor.cs

@@ -348,8 +348,8 @@ public static void UnloadAll()
             DllManipulator.UnloadAll();
         }
 
-        [NativeDllLoadedTrigger]
-        [NativeDllAfterUnloadTrigger]
+        [NativeDllLoadedTrigger(UseMainThreadQueue = true)]
+        [NativeDllAfterUnloadTrigger(UseMainThreadQueue = true)]
         public static void RepaintAll()
         {
             RepaintAllEditors.Invoke();