Save invokers in resource instead of statically and create public usable ChannelTickSchedulerFactory

Author: FabianTerhorst

api/AltV.Net.Async/ChannelTickSchedulerFactory.cs

@@ -0,0 +1,12 @@
+using System.Threading;
+
+namespace AltV.Net.Async
+{
+    public class ChannelTickSchedulerFactory : ITickSchedulerFactory
+    {
+        public TickScheduler Create(Thread mainThread)
+        {
+            return new ChannelTickScheduler(mainThread);
+        }
+    }
+}

api/AltV.Net/Native/AltV.Invoker.cs

@@ -8,7 +8,8 @@ internal class Invoker : IDisposable
     {
         public static Invoker Create(MValue.Function function)
         {
-            return new Invoker(AltNative.MValueCreate.Invoker_Create(function));
+            return new Invoker(
+                AltNative.MValueCreate.Invoker_Create(Alt.Module.CSharpNativeResource.NativePointer, function));
         }
 
         internal IntPtr NativePointer { get; }
@@ -20,7 +21,7 @@ private Invoker(IntPtr nativePointer)
 
         public void Destroy()
         {
-            AltNative.MValueCreate.Invoker_Destroy(NativePointer);
+            AltNative.MValueCreate.Invoker_Destroy(Alt.Module.CSharpNativeResource.NativePointer, NativePointer);
         }
 
         public void Dispose()

api/AltV.Net/Native/AltV.MValue.cs

@@ -12,10 +12,10 @@ internal static partial class AltNative
         internal static class MValueCreate
         {
             [DllImport(DllName, CallingConvention = NativeCallingConvention)]
-            internal static extern IntPtr Invoker_Create(MValue.Function function);
+            internal static extern IntPtr Invoker_Create(IntPtr csharpResourcePointer, MValue.Function function);
 
             [DllImport(DllName, CallingConvention = NativeCallingConvention)]
-            internal static extern void Invoker_Destroy(IntPtr invokerPointer);
+            internal static extern void Invoker_Destroy(IntPtr csharpResourcePointer, IntPtr invokerPointer);
 
             [DllImport(DllName, CallingConvention = NativeCallingConvention)]
             internal static extern void MValue_CreateNil(ref MValue mValue);

runtime/include/CSharpResource.h

@@ -62,6 +62,24 @@
 #pragma clang diagnostic pop
 #endif
 
+typedef void (* MValueFunctionCallback)(alt::MValueList*, alt::MValue*);
+
+class CustomInvoker : public alt::MValueFunction::Invoker {
+public:
+    MValueFunctionCallback mValueFunctionCallback;
+
+    explicit CustomInvoker(MValueFunctionCallback mValueFunctionCallback) {
+        this->mValueFunctionCallback = mValueFunctionCallback;
+    }
+
+    alt::MValue Invoke(alt::MValueList args) override {
+        //auto list = args.Get<alt::MValue::List>();
+        alt::MValue result;
+        mValueFunctionCallback(&args, &result);
+        return result;
+    }
+};
+
 typedef void (* MainDelegate_t)(alt::IServer* server, alt::IResource* resource, const char* resourceName,
                               const char* entryPoint);
 typedef void (* TickDelegate_t)();
@@ -194,6 +212,8 @@ class CSharpResource : public alt::IResource {
 
     void* runtimeHost;
     unsigned int domainId;
+
+    alt::Array<CustomInvoker*>* invokers;
 };
 
 EXPORT void CSharpResource_SetExport(CSharpResource* resource, const char* key, const alt::MValue &val);

runtime/src/CSharpResource.cpp

@@ -7,6 +7,7 @@ auto resourcesCache = new alt::Array<CSharpResource*>;
 CSharpResource::CSharpResource(alt::IServer* server, CoreClr* coreClr, alt::IResource::CreationInfo* info)
         : alt::IResource(info) {
     this->server = server;
+    this->invokers = new alt::Array<CustomInvoker*>();
     resourcesCache->Push(this);
 
     auto isDll = true;
@@ -207,8 +208,9 @@ bool CSharpResource::Start() {
 
 bool CSharpResource::Stop() {
     alt::IResource::Stop();
-    for (int i = 0; i < invokers.GetSize(); i++) {
-        delete invokers[i];
+    this->server->LogInfo("resource stopping");
+    for (int i = 0, length = invokers->GetSize(); i < length; i++) {
+        delete invokers->operator[](i);
     }
     if (OnStopDelegate == nullptr) return false;
     OnStopDelegate();

runtime/src/altv-c-api/mvalue.cpp

@@ -1,15 +1,22 @@
 #include "mvalue.h"
 
-alt::Array<CustomInvoker*> invokers;
-
-CustomInvoker* Invoker_Create(MValueFunctionCallback val) {
+CustomInvoker* Invoker_Create(CSharpResource* resource, MValueFunctionCallback val) {
     auto invoker = new CustomInvoker(val);
-    invokers.Push(invoker);
+    resource->invokers->Push(invoker);
     return invoker;
 }
 
-void Invoker_Destroy(CustomInvoker* val) {
+void Invoker_Destroy(CSharpResource* resource, CustomInvoker* val) {
+    auto newInvokers = new alt::Array<CustomInvoker*>();
+    for (int i = 0, length = resource->invokers->GetSize(); i < length; i++) {
+        auto invoker = resource->invokers->operator[](i);
+        if (invoker != val) {
+            newInvokers->Push(invoker);
+        }
+    }
     delete val;
+    delete resource->invokers;
+    resource->invokers = newInvokers;
 }
 
 void MValue_CreateNil(alt::MValue &mValue) {

runtime/src/altv-c-api/mvalue.h

@@ -7,37 +7,18 @@
 #endif
 
 #include <altv-cpp-api/SDK.h>
+#include <CSharpResource.h>
 
 #ifdef __clang__
 #pragma clang diagnostic pop
 #endif
 
-typedef void (* MValueFunctionCallback)(alt::MValueList*, alt::MValue*);
-
-class CustomInvoker : public alt::MValueFunction::Invoker {
-public:
-    MValueFunctionCallback mValueFunctionCallback;
-
-    explicit CustomInvoker(MValueFunctionCallback mValueFunctionCallback) {
-        this->mValueFunctionCallback = mValueFunctionCallback;
-    }
-
-    alt::MValue Invoke(alt::MValueList args) override {
-        //auto list = args.Get<alt::MValue::List>();
-        alt::MValue result;
-        mValueFunctionCallback(&args, &result);
-        return result;
-    }
-};
-
-extern alt::Array<CustomInvoker*> invokers;
-
 #ifdef __cplusplus
 extern "C"
 {
 #endif
-EXPORT CustomInvoker* Invoker_Create(MValueFunctionCallback val);
-EXPORT void Invoker_Destroy(CustomInvoker* val);
+EXPORT CustomInvoker* Invoker_Create(CSharpResource* resource, MValueFunctionCallback val);
+EXPORT void Invoker_Destroy(CSharpResource* resource, CustomInvoker* val);
 
 EXPORT void MValue_CreateNil(alt::MValue &mValue);
 EXPORT void MValue_CreateBool(bool val, alt::MValue &mValue);