Thread safe functionThreadSafeFunction

Napi::ThreadSafeFunction()

method

structure

Create emptyNapi::ThreadSafeFunctionInstance

Napi::Function::ThreadSafeFunction();

structure

Create a new Napi::ThreadSafeFunction object instance

Napi::ThreadSafeFunction::ThreadSafeFunction(napi_threadsafe_function tsfn);

New

New(napi_env env,
    const Function& callback,
    const Object& resource,
    ResourceString resourceName,
    size_t maxQueueSize,
    size_t initialThreadCount,
    ContextType* context,
    Finalizer finalizeCallback,
    FinalizzerDataType* data);

• env:structureNapi::ThreadSafeFunctionObject environment
• callback: A function called by another thread

example:

#include <chrono>
#include <napi.h>
#include <windows.h>

using namespace Napi;
std::string res;

ThreadSafeFunction tsfn;

Napi::Value Debug(Napi::CallbackInfo &info)
{
  Napi::Env env = info.Env();

  return Napi::String::New(env, res);
}

std::string dllcbk(std::string out)
{
  auto callback = [](Napi::Env env, Function jsCallback, std::string *res)
  {
    jsCallback.Call({String::New(env, *res)});

    delete res;
  };

  std::string *dllout = new std::string(out);

  tsfn.BlockingCall(dllout, callback);

  return "a";
}

Value Start( const CallbackInfo& info )
{
  Napi::Env env = info.Env();

  if ( !info[0].IsFunction() )
  {
    throw TypeError::New( env, "Expected first arg to be function" );
  }

  HMODULE module = LoadLibrary("DLL.dll");
  typedef std::string (*pCallback)(std::string out);
  typedef std::string (*InitFunc)(pCallback dllcallback);

  InitFunc dllfunc = (InitFunc)GetProcAddress(module, "Background_DLL_Initialise");

  // Create a ThreadSafeFunction
  tsfn = ThreadSafeFunction::New(
      env,
      info[0].As<Function>(),  // JavaScript function called asynchronously
      "Resource Name",         // Name
      0,                       // Unlimited queue
      1,                       // Only one thread will use this initially
      [](Napi::Env){}
      /*[]( Napi::Env ) {        // Finalizer used to clean threads up
        nativeThread.join();
      } */);

  return String::New(env, dllfunc(dllcbk));
}

Napi::Value Ver(Napi::CallbackInfo& info)
{
  Napi::Env env = info.Env();

  return Napi::Number::New(env, Napi::VersionManagement::GetNapiVersion(env));
}

Napi::Object Init( Napi::Env env, Object exports )
{
  exports.Set( "start", Function::New( env, Start ) );
  exports.Set("ver", Napi::Function::New(env, Ver));
  exports.Set("Debug", Napi::Function::New(env, Debug));
  return exports;
}

NODE_API_MODULE( clock, Init )

Asynchronous call (AsyncWorker)

example:

#include <napi.h>
#include <windows.h>
#include "async.h"

typedef std::string (*pCallBack)(std::string out);
typedef std::string (*DllCBK)(pCallBack callback);

// Inherited from AsyncWorker, where asynchronous calls are implemented
class PiWorker : public Napi::AsyncWorker { 
 public:
  PiWorker(Napi::Function& callback)
    : Napi::AsyncWorker(callback), estimate(0) {}
  ~PiWorker() {}

  // Executed inside the worker-thread.
  // It is not safe to access JS engine data structure
  // here, so everything we need for input and output
  // should go on `this`.
     // The executive body is here
  void Execute () {
      volatile int i = 0; 
      while(--i < 0);
  }

  // Executed when the async work is complete
  // this function will be run inside the main event loop
  // so it is safe to use JS engine data again
     // This will be called after execution
  void OnOK() {
    Napi::HandleScope scope(Env());
    Callback().Call({Napi::String::New(Env(), "Async Call")});
  }

  void Notify(std::string res) {
      Napi::HandleScope scope(Env());
      Callback().Call({Napi::String::New(Env(),res)});
  }

 private:
  int points;
  double estimate;
};

PiWorker* piWorker;

std::string DllCallBack(std::string out)
{
   piWorker->Notify(out);
   return "";
}

Napi::Value calltst(const Napi::CallbackInfo& info)
{
  piWorker->Notify("testasync");

  return info.Env().Null();
}

// Asynchronous access to the `Estimate()` function
Napi::Value CalculateAsync(const Napi::CallbackInfo& info) {
  Napi::Function callback = info[0].As<Napi::Function>();
  PiWorker* piWorker = new PiWorker(callback);
  piWorker->Queue();
//  HMODULE module = LoadLibrary("DLL.dll");
//  DllCBK cbk = (DllCBK)GetProcAddress(module, "Background_DLL_Initialise");
//  cbk(DllCallBack);


  return info.Env().Undefined();
}

Napi::Object Init(Napi::Env env, Napi::Object exports)
{
    exports.Set(Napi::String::New(env, "Call"), Napi::Function::New(env, CalculateAsync));
    exports.Set(Napi::String::New(env, "Test"), Napi::Function::New(env, calltst));

    return exports;
}

NODE_API_MODULE(NODE_GYP_MODULE_NAME, Init)