Add load and unload triggers

Author: mcpiroman

scripts/Attributes.cs

@@ -0,0 +1,65 @@
+using System;
+
+namespace UnityNativeTool
+{
+    /// <summary>
+    /// Member native functions in types with this attributes will be mocked. This attribute is redundant if "Mock all native functions" option is true.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false, Inherited = false)]
+    public class MockNativeDeclarationsAttribute : Attribute
+    {
+
+    }
+
+    /// <summary>
+    /// Native functions with this attribute will be mocked. This attribute is redundant if "Mock all native functions" option is true.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
+    public class MockNativeDeclarationAttribute : Attribute
+    {
+
+    }
+
+    /// <summary>
+    /// Applied to native function, prevents it from being mocked.
+    /// Applied to class, prevents all member native functions from being mocked.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false, Inherited = false)]
+    public class DisableMockingAttribute : Attribute
+    {
+
+    }
+
+    /// <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
+    {
+
+    }
+
+    /// <summary>
+    /// 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.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
+    public class NativeDllBeforeUnloadTriggerAttribute : Attribute
+    {
+
+    }
+
+    /// <summary>
+    /// 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.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
+    public class NativeDllAfterUnloadTriggerAttribute : Attribute
+    {
+
+    }
+}

scripts/DllManipulator.cs

@@ -30,6 +30,9 @@ 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;
 
         /// <summary>
         /// Initialization.
@@ -78,6 +81,18 @@ 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)))
+                        {
+                            RegisterTriggerMethod(method, ref _customBeforeUnloadTriggers);
+                        }
+                        else if (method.IsDefined(typeof(NativeDllAfterUnloadTriggerAttribute)))
+                        {
+                            RegisterTriggerMethod(method, ref _customAfterUnloadTriggers);
+                        }
                     }
                 }
             }
@@ -86,6 +101,21 @@ internal static void Initialize(int unityMainThreadId, string assetsPath)
                 LoadAll();
         }
 
+        private static void RegisterTriggerMethod(MethodInfo method, ref List<MethodInfo> triggersList)
+        {
+            var parameters = method.GetParameters();
+            if (parameters.Length == 0 || parameters.Length == 1 && parameters[0].ParameterType == typeof(NativeDll))
+            {
+                if (triggersList == null)
+                    triggersList = new List<MethodInfo>(2);
+                triggersList.Add(method);
+            }
+            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}");
+            }
+        }
+
         /// <summary>
         /// Loads all DLLs and functions for mocked methods
         /// </summary>
@@ -124,12 +154,14 @@ public static void UnloadAll()
                     if (dll.handle != IntPtr.Zero)
                     {
                         LowLevelPluginManager.OnBeforeDllUnload(dll);
+                        InvokeCustomTriggers(_customBeforeUnloadTriggers, dll);
 
                         bool success = SysUnloadDll(dll.handle);
                         if (!success)
                             Debug.LogWarning($"Error while unloading DLL \"{dll.name}\" at path \"{dll.path}\"");
 
                         dll.ResetAsUnloaded();
+                        InvokeCustomTriggers(_customAfterUnloadTriggers, dll);
                     }
                 }
             }
@@ -449,6 +481,7 @@ internal static void LoadTargetFunction(NativeFunction nativeFunction, bool igno
                 else
                 {
                     dll.loadingError = false;
+                    InvokeCustomTriggers(_customLoadedTriggers, dll);
                     LowLevelPluginManager.OnDllLoaded(dll);
                 }
             }
@@ -476,6 +509,20 @@ internal static void LoadTargetFunction(NativeFunction nativeFunction, bool igno
             }
         }
 
+        private static void InvokeCustomTriggers(List<MethodInfo> triggers, NativeDll dll)
+        {
+            if (triggers == null)
+                return;
+
+            foreach(var triggerMethod in triggers)
+            {
+                if (triggerMethod.GetParameters().Length == 1)
+                    triggerMethod.Invoke(null, new object[] { dll });
+                else
+                    triggerMethod.Invoke(null, Array.Empty<object>());
+            }
+        }
+
         /// <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/MockAttributes.cs

@@ -1,9 +1,9 @@
 using System;
 using System.Collections.Generic;
 
-namespace UnityNativeTool.Internal
+namespace UnityNativeTool
 {
-    internal class NativeDll
+    public class NativeDll
     {
         public readonly string name;
         public string path;
@@ -30,7 +30,10 @@ public void ResetAsUnloaded()
             }
         }
     }
+}
 
+namespace UnityNativeTool.Internal
+{
     public class NativeDllInfo
     {
         public string name;

scripts/NativeDll.cs

@@ -1,8 +1,8 @@
 using System;
 
-namespace UnityNativeTool.Internal
+namespace UnityNativeTool
 {
-    internal struct NativeFunctionIdentity
+    public struct NativeFunctionIdentity
     {
         public string symbol;
         public string containingDllName;
@@ -30,7 +30,7 @@ public override int GetHashCode()
         }
     }
 
-    internal class NativeFunction
+    public class NativeFunction
     {
         public readonly NativeFunctionIdentity identity;
         public NativeDll containingDll;