Merge branch 'master' into upm-support

Author: rogerbarton

README.md

@@ -34,6 +34,8 @@ 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
+- Unload and load all DLLs via shortcut `Alt+D` and `Alt+Shfit+D` respectively. Editable in the Shortcut Manager for 2019.1+
 
 ## Limitations
 - Marshaling parameter attributes other than `[MarshalAs]`, `[In]` and `[Out]` are not supported.

scripts/Attributes.cs

@@ -31,12 +31,33 @@ public class DisableMockingAttribute : Attribute
     }
 
     /// <summary>
-    /// Methods with this attribute are called directly after a native DLL has been loaded.
+    /// Such a method must be static and have one of the following signatures:
+    /// <code>
+    /// public static void Func()
+    /// public static void Func(NativeDll dll)
+    /// public static void Func(NativeDll dll, int mainThreadId)
+    /// </code>
+    /// </summary>
+    [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, if it is not 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. Native functions can be used within such a method.
+    /// This is called after <c>UnityPluginLoad</c>.<br/>
     /// 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.
+    /// which indicates the state of the dll being loaded. Please treat this parameter as readonly.<br/>
+    /// Preloaded: only called once all native methods have been loaded. 
+    /// <br/><inheritdoc cref="TriggerAttribute"/>
     /// </summary>
     [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
-    public class NativeDllLoadedTriggerAttribute : Attribute
+    public class NativeDllLoadedTriggerAttribute : TriggerAttribute
     {
 
     }
@@ -45,9 +66,10 @@ public class NativeDllLoadedTriggerAttribute : Attribute
     /// Methods with this attribute are called directly before a native DLL is going to be unloaded.
     /// 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 unloaded. Please treat this parameter as readonly.
+    /// <br/><inheritdoc cref="TriggerAttribute"/>
     /// </summary>
     [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
-    public class NativeDllBeforeUnloadTriggerAttribute : Attribute
+    public class NativeDllBeforeUnloadTriggerAttribute : TriggerAttribute
     {
 
     }
@@ -56,9 +78,10 @@ public class NativeDllBeforeUnloadTriggerAttribute : Attribute
     /// Methods with this attribute are called directly after a native DLL has been unloaded.
     /// 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 unloaded. Please treat this parameter as readonly.
+    /// <br/><inheritdoc cref="TriggerAttribute"/>
     /// </summary>
     [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
-    public class NativeDllAfterUnloadTriggerAttribute : Attribute
+    public class NativeDllAfterUnloadTriggerAttribute : TriggerAttribute
     {
 
     }

scripts/DllManipulator.cs

@@ -42,10 +42,11 @@ 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;
+        
         /// <summary>
         /// Initialization.
         /// Finds and mocks relevant native function declarations.
@@ -91,17 +92,16 @@ internal static void Initialize(int unityMainThreadId, string assetsPath)
                             if (Options.mockAllNativeFunctions || method.IsDefined(typeof(MockNativeDeclarationAttribute)) || method.DeclaringType.IsDefined(typeof(MockNativeDeclarationsAttribute)))
                                 MockNativeFunction(method);
                         }
-                        else if(method.IsDefined(typeof(NativeDllLoadedTriggerAttribute)))
-                        {
-                            RegisterTriggerMethod(method, ref _customLoadedTriggers);
-                        }
-                        else if (method.IsDefined(typeof(NativeDllBeforeUnloadTriggerAttribute)))
+                        else
                         {
-                            RegisterTriggerMethod(method, ref _customBeforeUnloadTriggers);
-                        }
-                        else if (method.IsDefined(typeof(NativeDllAfterUnloadTriggerAttribute)))
-                        {
-                            RegisterTriggerMethod(method, ref _customAfterUnloadTriggers);
+                            if (method.IsDefined(typeof(NativeDllLoadedTriggerAttribute)))
+                                RegisterTriggerMethod(method, ref _customLoadedTriggers, method.GetCustomAttribute<NativeDllLoadedTriggerAttribute>());
+
+                            if (method.IsDefined(typeof(NativeDllBeforeUnloadTriggerAttribute)))
+                                RegisterTriggerMethod(method, ref _customBeforeUnloadTriggers, method.GetCustomAttribute<NativeDllBeforeUnloadTriggerAttribute>());
+
+                            if (method.IsDefined(typeof(NativeDllAfterUnloadTriggerAttribute)))
+                                RegisterTriggerMethod(method, ref _customAfterUnloadTriggers, method.GetCustomAttribute<NativeDllAfterUnloadTriggerAttribute>());
                         }
                     }
                 }
@@ -111,18 +111,34 @@ internal static void Initialize(int unityMainThreadId, string assetsPath)
                 LoadAll();
         }
 
-        private static void RegisterTriggerMethod(MethodInfo method, ref List<MethodInfo> triggersList)
+        /// <summary>
+        /// Will unload/forget all dll's and reset the state 
+        /// </summary>
+        public static void Reset()
+        {
+            UnloadAll();
+            ForgetAllDlls();
+            ClearCrashLogs();
+            
+            _customLoadedTriggers?.Clear();
+            _customAfterUnloadTriggers?.Clear();
+            _customBeforeUnloadTriggers?.Clear();
+        }
+
+        private static void RegisterTriggerMethod(MethodInfo method, ref List<Tuple<MethodInfo, bool>> triggersList, TriggerAttribute attribute)
         {
             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, attribute.UseMainThreadQueue));
             }
             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, one parameter of type {nameof(NativeDll)} or one of type {nameof(NativeDll)} and one int. " +
+                               $"See the TriggerAttribute for more details. Violation on method {method.Name} in {method.DeclaringType.FullName}");
             }
         }
 
@@ -142,6 +158,11 @@ public static void LoadAll()
                         {
                             LoadTargetFunction(nativeFunction, false);
                         }
+                        
+                        // Notify that the dll and its functions have been loaded in preload mode
+                        // This here allows use of native functions in the triggers
+                        if(Options.loadingMode == DllLoadingMode.Preload)
+                            InvokeCustomTriggers(_customLoadedTriggers, dll);
                     }
                 }
             }
@@ -491,8 +512,12 @@ internal static void LoadTargetFunction(NativeFunction nativeFunction, bool igno
                 else
                 {
                     dll.loadingError = false;
-                    InvokeCustomTriggers(_customLoadedTriggers, dll);
                     LowLevelPluginManager.OnDllLoaded(dll);
+                    
+                    // Call the custom triggers once UnityPluginLoad has been called
+                    // For Lazy mode call the triggers immediately, preload waits until all functions are loaded (in LoadAll)
+                    if(Options.loadingMode == DllLoadingMode.Lazy)
+                        InvokeCustomTriggers(_customLoadedTriggers, dll);
                 }
             }
 
@@ -519,17 +544,28 @@ 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)
+                    DllManipulatorScript.MainThreadTriggerQueue.Enqueue(() => methodInfo.Invoke(null, args));
                 else
-                    triggerMethod.Invoke(null, Array.Empty<object>());
+                    methodInfo.Invoke(null, args);
             }
         }
 
@@ -664,6 +700,33 @@ public class DllManipulatorOptions
         public bool mockAllNativeFunctions;
         public bool onlyInEditor;
         public bool enableInEditMode;
+
+        public DllManipulatorOptions CloneTo(DllManipulatorOptions other)
+        {
+            other.dllPathPattern = dllPathPattern;
+            other.assemblyPaths = (string[]) assemblyPaths.Clone();
+            other.loadingMode = loadingMode;
+            other.posixDlopenFlags = posixDlopenFlags;
+            other.threadSafe = threadSafe;
+            other.enableCrashLogs = enableCrashLogs;
+            other.crashLogsDir = crashLogsDir;
+            other.crashLogsStackTrace = crashLogsStackTrace;
+            other.mockAllNativeFunctions = mockAllNativeFunctions;
+            other.onlyInEditor = onlyInEditor;
+            other.enableInEditMode = enableInEditMode;
+            
+            return other;
+        }
+
+        public bool Equals(DllManipulatorOptions other)
+        {
+            return other.dllPathPattern == dllPathPattern && other.assemblyPaths.SequenceEqual(assemblyPaths) &&
+                   other.loadingMode == loadingMode && other.posixDlopenFlags == posixDlopenFlags &&
+                   other.threadSafe == threadSafe && other.enableCrashLogs == enableCrashLogs &&
+                   other.crashLogsDir == crashLogsDir && other.crashLogsStackTrace == crashLogsStackTrace &&
+                   other.mockAllNativeFunctions == mockAllNativeFunctions && other.onlyInEditor == onlyInEditor &&
+                   other.enableInEditMode == enableInEditMode;
+        }
     }
 
     public enum DllLoadingMode

scripts/DllManipulatorScript.cs

@@ -1,8 +1,7 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Reflection;
 using System.Threading;
-using System.Linq;
 using UnityEngine;
 using UnityNativeTool.Internal;
 #if UNITY_EDITOR
@@ -39,6 +38,8 @@ public class DllManipulatorScript : MonoBehaviour
             onlyInEditor = true,
             enableInEditMode = false
         };
+        
+        public static ConcurrentQueue<Action> MainThreadTriggerQueue = new ConcurrentQueue<Action>();
 
         private void OnEnable()
         {
@@ -47,7 +48,7 @@ private void OnEnable()
             {
                 if (EditorApplication.isPlaying)
                     Destroy(gameObject);
-                else
+                else if(_singletonInstance != this)
                     enabled = false; //Don't destroy as the user may be editing a Prefab
                 return;
             }
@@ -58,6 +59,11 @@ private void OnEnable()
 
             if(EditorApplication.isPlaying || Options.enableInEditMode)
                 Initialize();
+            
+            // Ensure update is called every frame in edit mode, ExecuteInEditMode only calls Update when the scene changes
+            if(!EditorApplication.isPlaying && Options.enableInEditMode)
+                EditorApplication.update += Update;
+
 #else
             if (Options.onlyInEditor) 
                 return;
@@ -84,6 +90,32 @@ private void Initialize()
             initTimer.Stop();
             InitializationTime = initTimer.Elapsed;
         }
+        
+        /// <summary>
+        /// Note: also called in edit mode if Options.enableInEditMode is set.
+        /// </summary>
+        private void Update()
+        {
+            InvokeMainThreadQueue();
+        }
+
+        /// <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();
+        }
+
+#if UNITY_EDITOR
+        private void OnDisable()
+        {
+            if(!EditorApplication.isPlaying && Options.enableInEditMode)
+                EditorApplication.update -= Update;
+        }
+#endif
 
         private void OnDestroy()
         {
@@ -93,9 +125,8 @@ private void OnDestroy()
                 //On Preloaded mode this leads to NullReferenceException, but on Lazy mode the DLL and function would be just reloaded so we would up with loaded DLL after game exit.
                 //Thankfully thread safety with Lazy mode is not implemented yet.
 
-                DllManipulator.UnloadAll();
-                DllManipulator.ForgetAllDlls();
-                DllManipulator.ClearCrashLogs();
+                if (DllManipulator.Options != null) // Check that we have initialized
+                    DllManipulator.Reset();
                 _singletonInstance = null;
             }
         }