wip

Author: KevinEady

napi-inl.h

@@ -4272,7 +4272,7 @@ inline ThreadSafeFunctionEx<ContextType> ThreadSafeFunctionEx<ContextType>::New(
                                                   ContextType* context,
                                                   Finalizer finalizeCallback,
                                                   FinalizerDataType* data,
-                                                  napi_threadsafe_function_call_js call_js_cb) {
+                                                  ThreadSafeFunctionCallJS call_js_cb) {
   return New(env, callback, resource, resourceName, maxQueueSize,
              initialThreadCount, context, finalizeCallback, data,
              details::ThreadSafeFinalize<ContextType, Finalizer,
@@ -4362,7 +4362,7 @@ inline ThreadSafeFunctionEx<ContextType> ThreadSafeFunctionEx<ContextType>::New(
                                                   Finalizer finalizeCallback,
                                                   FinalizerDataType* data,
                                                   napi_finalize wrapper,
-                                                  napi_threadsafe_function_call_js call_js_cb) {
+                                                  ThreadSafeFunctionCallJS call_js_cb) {
   static_assert(details::can_make_string<ResourceString>::value
       || std::is_convertible<ResourceString, napi_value>::value,
       "Resource name should be convertible to the string type");
@@ -4372,7 +4372,15 @@ inline ThreadSafeFunctionEx<ContextType> ThreadSafeFunctionEx<ContextType>::New(
       FinalizerDataType>({ data, finalizeCallback });
   napi_status status = napi_create_threadsafe_function(env, callback, resource,
       Value::From(env, resourceName), maxQueueSize, initialThreadCount,
-      finalizeData, wrapper, context, call_js_cb, &tsfn._tsfn);
+      finalizeData, wrapper, context, 
+  //     [=](napi_env env, napi_value jsCallback, void* context, void* data) {
+  //         if (env == nullptr && jsCallback == nullptr) {
+  //   return;
+  // }
+  //     call_js_cb( Napi::Env(env), Function(env, jsCallback), static_cast<ContextType*>(context), data);
+  //     },
+      CallJS,
+       &tsfn._tsfn);
   if (status != napi_ok) {
     delete finalizeData;
     NAPI_THROW_IF_FAILED(env, status, ThreadSafeFunctionEx<ContextType>());
@@ -4381,6 +4389,23 @@ inline ThreadSafeFunctionEx<ContextType> ThreadSafeFunctionEx<ContextType>::New(
   return tsfn;
 }
 
+template <typename ContextType>
+inline void
+ThreadSafeFunctionEx<ContextType>::CallJS(napi_env env, napi_value jsCallback,
+                                          void *context, void *data) {
+  if (env == nullptr && jsCallback == nullptr) {
+    return;
+  }
+
+  if (data != nullptr) {
+    auto* callbackWrapper = static_cast<CallbackWrapper*>(data);
+    (*callbackWrapper)(env, Function(env, jsCallback));
+    delete callbackWrapper;
+  } else if (jsCallback != nullptr) {
+    Function(env, jsCallback).Call({});
+  }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // ThreadSafeFunction class
 ////////////////////////////////////////////////////////////////////////////////

napi.h

@@ -2037,9 +2037,13 @@ namespace Napi {
 
   #if (NAPI_VERSION > 3)
 
-  template <typename ContextType>
+  
+  template <typename ContextType, typename DataType>
   class ThreadSafeFunctionEx {
   public:
+
+    using ThreadSafeFunctionCallJS = std::function<void(Napi::Env, Napi::Function, ContextType *context, DataType *data)>;
+
     // This API may only be called from the main thread.
     template <typename ResourceString, typename Finalizer, typename FinalizerDataType>
     static ThreadSafeFunctionEx<ContextType> New(napi_env env,
@@ -2051,7 +2055,7 @@ namespace Napi {
                                   ContextType* context,
                                   Finalizer finalizeCallback,
                                   FinalizerDataType* data,
-                                  napi_threadsafe_function_call_js call_js_cb);
+                                  ThreadSafeFunctionCallJS call_js_cb);
 
     ThreadSafeFunctionEx<ContextType>();
     ThreadSafeFunctionEx<ContextType>(napi_threadsafe_function tsFunctionValue);
@@ -2062,14 +2066,12 @@ namespace Napi {
     // napi_status BlockingCall() const;
 
     // This API may be called from any thread.
-    template <typename DataType = void>
     napi_status BlockingCall(DataType* data = nullptr) const;
 
     // // This API may be called from any thread.
     // napi_status NonBlockingCall() const;
 
     // This API may be called from any thread.
-    template <typename DataType = void>
     napi_status NonBlockingCall(DataType* data = nullptr) const;
 
     // This API may only be called from the main thread.
@@ -2091,7 +2093,7 @@ namespace Napi {
     ContextType* GetContext() const;
 
   private:
-    using CallbackWrapper = std::function<void(Napi::Env, Napi::Function, ContextType* context)>;
+    // using CallbackWrapper = std::function<void(Napi::Env, Napi::Function, ContextType* context)>;
 
     template <typename ResourceString,
               typename Finalizer, typename FinalizerDataType>
@@ -2105,7 +2107,15 @@ namespace Napi {
                                   Finalizer finalizeCallback,
                                   FinalizerDataType* data,
                                   napi_finalize wrapper,
-                                  napi_threadsafe_function_call_js call_js_cb);
+                                  ThreadSafeFunctionCallJS call_js_cb);
+
+    static void CallJS(napi_env env,
+                       napi_value jsCallback,
+                       void* context,
+                       void* data);
+
+  protected:
+    void CallJS
 
     napi_threadsafe_function _tsfn;
   };

test/threadsafe_function/threadsafe_function_ex.cc

@@ -79,9 +79,9 @@ TSFNWrap::TSFNWrap(const CallbackInfo &info)
         delete ctx;
       },
       static_cast<void*>(nullptr),                                 // FinalizerDataType* data,
-      [](napi_env, napi_value, void *context, void *data) { // call_js_cb
+      [](Napi::Env, Napi::Value, TSFNContext *context, void *data) { // call_js_cb
         std::unique_ptr<CallJsData> callData(static_cast<CallJsData*>(data));
-        callData->resolve(static_cast<TSFNContext*>(context));
+        callData->resolve(context);
       });
 }
 } // namespace