node/electron外掛: 由監聽 Windows 印表機狀態功能深入理解原生node外掛編寫過程

"RuntimeLibrary": 2, #MultiThreadedDLL /MD
"Optimization": 2,
"RuntimeTypeInfo": "true",
"CompileAsManaged": "true", # /clr
"DebugInformationFormat": 3, #ProgramDatabase /Zi
"ExceptionHandling": 0, #Async /EHa
"BasicRuntimeChecks": 0, #Default

#pragma unmanaged

// safe_async_worker.h
template <typename T>
class SafeAsyncWorker : public Napi::ObjectWrap<T>
{
public:
SafeAsyncWorker(const Napi::CallbackInfo &info);

protected:
virtual void Execute() = 0;
virtual Napi::Value Parse(napi_env env, void *data) = 0;
virtual void Free(void *data) = 0;

// Create a thread-safe function and an async queue work item. We pass the
// thread-safe function to the async queue work item so the latter might have a
// chance to call into JavaScript from the worker thread on which the
// ExecuteWork callback runs.
Napi::Value CreateAsyncWork(const Napi::CallbackInfo &cb);

// This function runs on a worker thread. It has no access to the JavaScript
// environment except through the thread-safe function.
static void OnExecuteWork(napi_env env, void *data);

// This function runs on the main thread after `ExecuteWork` exits.
static void OnWorkComplete(napi_env env, napi_status status, void *data);

// This function is responsible for converting data coming in from the worker
// thread to napi_value items that can be passed into JavaScript, and for
// calling the JavaScript function.
static void OnCallJavaScript(napi_env env, napi_value js_cb, void *context, void *data);

void SubmitWork(void *data);

static Napi::FunctionReference constructor;

private:
napi_async_work work;
napi_threadsafe_function tsfn;
};

// safe_async_worker.inl
template <typename T>
Napi::FunctionReference SafeAsyncWorker<T>::constructor;

template <typename T>
inline SafeAsyncWorker<T>::SafeAsyncWorker(const Napi::CallbackInfo &info)
: Napi::ObjectWrap<T>(info)
{
}

template <typename T>
void printer::SafeAsyncWorker<T>::SubmitWork(void *data)
{
// Initiate the call into JavaScript. The call into JavaScript will not
// have happened when this function returns, but it will be queued.
assert(napi_call_threadsafe_function(tsfn, data, napi_tsfn_blocking) == napi_ok);
}

template <typename T>
Napi::Value SafeAsyncWorker<T>::CreateAsyncWork(const Napi::CallbackInfo &cb)
{
Napi::Env env = cb.Env();
napi_value work_name;

// Create a string to describe this asynchronous operation.
assert(napi_create_string_utf8(env,
typeid(T).name(),
NAPI_AUTO_LENGTH,
&work_name) == napi_ok);

// Convert the callback retrieved from JavaScript into a thread-safe function
// which we can call from a worker thread.
assert(napi_create_threadsafe_function(env,
cb[0],
NULL,
work_name,
0,
1,
NULL,
NULL,
this,
OnCallJavaScript,
&(tsfn)) == napi_ok);

// Create an async work item, passing in the addon data, which will give the
// worker thread access to the above-created thread-safe function.
assert(napi_create_async_work(env,
NULL,
work_name,
OnExecuteWork,
OnWorkComplete,
this,
&(work)) == napi_ok);

// Queue the work item for execution.
assert(napi_queue_async_work(env, work) == napi_ok);

// This causes `undefined` to be returned to JavaScript.
return env.Undefined();
}

template <typename T>
void SafeAsyncWorker<T>::OnExecuteWork(napi_env /*env*/, void *this_pointer)
{
T *self = static_cast<T *>(this_pointer);

// We bracket the use of the thread-safe function by this thread by a call to
// napi_acquire_threadsafe_function() here, and by a call to
// napi_release_threadsafe_function() immediately prior to thread exit.
assert(napi_acquire_threadsafe_function(self->tsfn) == napi_ok);
#ifdef NAPI_CPP_EXCEPTIONS
try
{
self->Execute();
}
catch (const std::exception &e)
{
// TODO
}
#else// NAPI_CPP_EXCEPTIONS
self->Execute();
#endif // NAPI_CPP_EXCEPTIONS

// Indicate that this thread will make no further use of the thread-safe function.
assert(napi_release_threadsafe_function(self->tsfn,
napi_tsfn_release) == napi_ok);
}

template <typename T>
void SafeAsyncWorker<T>::OnWorkComplete(napi_env env, napi_status status, void *this_pointer)
{
T *self = (T *)this_pointer;

// Clean up the thread-safe function and the work item associated with this
// run.
assert(napi_release_threadsafe_function(self->tsfn,
napi_tsfn_release) == napi_ok);
assert(napi_delete_async_work(env, self->work) == napi_ok);

// Set both values to NULL so JavaScript can order a new run of the thread.
self->work = NULL;
self->tsfn = NULL;
}

template <typename T>
void SafeAsyncWorker<T>::OnCallJavaScript(napi_env env, napi_value js_cb, void *this_pointer, void *data)
{
T *self = static_cast<T *>(this_pointer);
if (env != NULL)
{
napi_value undefined;
#ifdef NAPI_CPP_EXCEPTIONS
try
{
napi_value js_value = self->Parse(env, data);
}
catch (const std::exception &e)
{
// TODO
}
#else// NAPI_CPP_EXCEPTIONS
napi_value js_value = self->Parse(env, data);
#endif // NAPI_CPP_EXCEPTIONS

// Retrieve the JavaScript `undefined` value so we can use it as the `this`
// value of the JavaScript function call.
assert(napi_get_undefined(env, &undefined) == napi_ok);

// Call the JavaScript function and pass it the prime that the secondary
// thread found.
assert(napi_call_function(env,
undefined,
js_cb,
1,
&js_value,
NULL) == napi_ok);
}
self->Free(data);
}