@mukea/uiohook-napi 1.5.4

package/src/lib/addon.c

@@ -0,0 +1,337 @@
+#include <stdlib.h>
+#include <string.h>
+#include <node_api.h>
+#include <uiohook.h>
+#include "napi_helpers.h"
+#include "uiohook_worker.h"
+
+static napi_threadsafe_function threadsafe_fn = NULL;
+static bool is_worker_running = false;
+
+void dispatch_proc(uiohook_event* const event) {
+  if (threadsafe_fn == NULL) return;
+
+  uiohook_event* copied_event = malloc(sizeof(uiohook_event));
+  memcpy(copied_event, event, sizeof(uiohook_event));
+  if (copied_event->type == EVENT_MOUSE_DRAGGED) {
+    copied_event->type = EVENT_MOUSE_MOVED;
+  }
+
+  napi_status status = napi_call_threadsafe_function(threadsafe_fn, copied_event, napi_tsfn_nonblocking);
+  if (status == napi_closing) {
+    threadsafe_fn = NULL;
+    free(copied_event);
+    return;
+  }
+  NAPI_FATAL_IF_FAILED(status, "dispatch_proc", "napi_call_threadsafe_function");
+}
+
+napi_value uiohook_to_js_event(napi_env env, uiohook_event* event) {
+  napi_status status;
+
+  napi_value event_obj;
+  status = napi_create_object(env, &event_obj);
+  NAPI_FATAL_IF_FAILED(status, "uiohook_to_js_event", "napi_create_object");
+
+  napi_value e_type;
+  status = napi_create_uint32(env, event->type, &e_type);
+  NAPI_FATAL_IF_FAILED(status, "uiohook_to_js_event", "napi_create_uint32");
+
+  napi_value e_altKey;
+  status = napi_get_boolean(env, (event->mask & (MASK_ALT)), &e_altKey);
+  NAPI_FATAL_IF_FAILED(status, "uiohook_to_js_event", "napi_get_boolean");
+
+  napi_value e_ctrlKey;
+  status = napi_get_boolean(env, (event->mask & (MASK_CTRL)), &e_ctrlKey);
+  NAPI_FATAL_IF_FAILED(status, "uiohook_to_js_event", "napi_get_boolean");
+
+  napi_value e_metaKey;
+  status = napi_get_boolean(env, (event->mask & (MASK_META)), &e_metaKey);
+  NAPI_FATAL_IF_FAILED(status, "uiohook_to_js_event", "napi_get_boolean");
+
+  napi_value e_shiftKey;
+  status = napi_get_boolean(env, (event->mask & (MASK_SHIFT)), &e_shiftKey);
+  NAPI_FATAL_IF_FAILED(status, "uiohook_to_js_event", "napi_get_boolean");
+
+  napi_value e_time;
+  status = napi_create_double(env, (double)event->time, &e_time);
+  NAPI_FATAL_IF_FAILED(status, "uiohook_to_js_event", "napi_create_double");
+
+  if (event->type == EVENT_KEY_PRESSED || event->type == EVENT_KEY_RELEASED) {
+    napi_value e_keycode;
+    status = napi_create_uint32(env, event->data.keyboard.keycode, &e_keycode);
+    NAPI_FATAL_IF_FAILED(status, "uiohook_to_js_event", "napi_create_uint32");
+
+    napi_property_descriptor descriptors[] = {
+      { "type",     NULL, NULL, NULL, NULL, e_type,     napi_enumerable, NULL },
+      { "time",     NULL, NULL, NULL, NULL, e_time,     napi_enumerable, NULL },
+      { "altKey",   NULL, NULL, NULL, NULL, e_altKey,   napi_enumerable, NULL },
+      { "ctrlKey",  NULL, NULL, NULL, NULL, e_ctrlKey,  napi_enumerable, NULL },
+      { "metaKey",  NULL, NULL, NULL, NULL, e_metaKey,  napi_enumerable, NULL },
+      { "shiftKey", NULL, NULL, NULL, NULL, e_shiftKey, napi_enumerable, NULL },
+      { "keycode",  NULL, NULL, NULL, NULL, e_keycode,  napi_enumerable, NULL },
+    };
+    status = napi_define_properties(env, event_obj, sizeof(descriptors) / sizeof(descriptors[0]), descriptors);
+    NAPI_FATAL_IF_FAILED(status, "uiohook_to_js_event", "napi_define_properties");
+    return event_obj;
+  }
+  else if (event->type == EVENT_MOUSE_MOVED || event->type == EVENT_MOUSE_PRESSED || event->type == EVENT_MOUSE_RELEASED || event->type == EVENT_MOUSE_CLICKED) {
+    napi_value e_x;
+    status = napi_create_int32(env, event->data.mouse.x, &e_x);
+    NAPI_FATAL_IF_FAILED(status, "uiohook_to_js_event", "napi_create_int32");
+
+    napi_value e_y;
+    status = napi_create_int32(env, event->data.mouse.y, &e_y);
+    NAPI_FATAL_IF_FAILED(status, "uiohook_to_js_event", "napi_create_int32");
+
+    napi_value e_button;
+    status = napi_create_uint32(env, event->data.mouse.button, &e_button);
+    NAPI_FATAL_IF_FAILED(status, "uiohook_to_js_event", "napi_create_uint32");
+
+    napi_value e_clicks;
+    status = napi_create_uint32(env, event->data.mouse.clicks, &e_clicks);
+    NAPI_FATAL_IF_FAILED(status, "uiohook_to_js_event", "napi_create_uint32");
+
+    napi_property_descriptor descriptors[] = {
+      { "type",     NULL, NULL, NULL, NULL, e_type,     napi_enumerable, NULL },
+      { "time",     NULL, NULL, NULL, NULL, e_time,     napi_enumerable, NULL },
+      { "altKey",   NULL, NULL, NULL, NULL, e_altKey,   napi_enumerable, NULL },
+      { "ctrlKey",  NULL, NULL, NULL, NULL, e_ctrlKey,  napi_enumerable, NULL },
+      { "metaKey",  NULL, NULL, NULL, NULL, e_metaKey,  napi_enumerable, NULL },
+      { "shiftKey", NULL, NULL, NULL, NULL, e_shiftKey, napi_enumerable, NULL },
+      { "x",        NULL, NULL, NULL, NULL, e_x,        napi_enumerable, NULL },
+      { "y",        NULL, NULL, NULL, NULL, e_y,        napi_enumerable, NULL },
+      { "button",   NULL, NULL, NULL, NULL, e_button,   napi_enumerable, NULL },
+      { "clicks",   NULL, NULL, NULL, NULL, e_clicks,   napi_enumerable, NULL },
+    };
+    status = napi_define_properties(env, event_obj, sizeof(descriptors) / sizeof(descriptors[0]), descriptors);
+    NAPI_FATAL_IF_FAILED(status, "uiohook_to_js_event", "napi_define_properties");
+    return event_obj;
+  }
+  else if (event->type == EVENT_MOUSE_WHEEL) {
+    napi_value e_x;
+    status = napi_create_int32(env, event->data.wheel.x, &e_x);
+    NAPI_FATAL_IF_FAILED(status, "uiohook_to_js_event", "napi_create_int32");
+
+    napi_value e_y;
+    status = napi_create_int32(env, event->data.wheel.y, &e_y);
+    NAPI_FATAL_IF_FAILED(status, "uiohook_to_js_event", "napi_create_int32");
+
+    napi_value e_clicks;
+    status = napi_create_uint32(env, event->data.wheel.clicks, &e_clicks);
+    NAPI_FATAL_IF_FAILED(status, "uiohook_to_js_event", "napi_create_uint32");
+
+    napi_value e_amount;
+    status = napi_create_uint32(env, event->data.wheel.amount, &e_amount);
+    NAPI_FATAL_IF_FAILED(status, "uiohook_to_js_event", "napi_create_uint32");
+
+    napi_value e_direction;
+    status = napi_create_uint32(env, event->data.wheel.direction, &e_direction);
+    NAPI_FATAL_IF_FAILED(status, "uiohook_to_js_event", "napi_create_uint32");
+
+    napi_value e_rotation;
+    status = napi_create_int32(env, event->data.wheel.rotation, &e_rotation);
+    NAPI_FATAL_IF_FAILED(status, "uiohook_to_js_event", "napi_create_int32");
+
+    napi_property_descriptor descriptors[] = {
+      { "type",      NULL, NULL, NULL, NULL, e_type,      napi_enumerable, NULL },
+      { "time",      NULL, NULL, NULL, NULL, e_time,      napi_enumerable, NULL },
+      { "altKey",    NULL, NULL, NULL, NULL, e_altKey,    napi_enumerable, NULL },
+      { "ctrlKey",   NULL, NULL, NULL, NULL, e_ctrlKey,   napi_enumerable, NULL },
+      { "metaKey",   NULL, NULL, NULL, NULL, e_metaKey,   napi_enumerable, NULL },
+      { "shiftKey",  NULL, NULL, NULL, NULL, e_shiftKey,  napi_enumerable, NULL },
+      { "x",         NULL, NULL, NULL, NULL, e_x,         napi_enumerable, NULL },
+      { "y",         NULL, NULL, NULL, NULL, e_y,         napi_enumerable, NULL },
+      { "clicks",    NULL, NULL, NULL, NULL, e_clicks,    napi_enumerable, NULL },
+      { "amount",    NULL, NULL, NULL, NULL, e_amount,    napi_enumerable, NULL },
+      { "direction", NULL, NULL, NULL, NULL, e_direction, napi_enumerable, NULL },
+      { "rotation",  NULL, NULL, NULL, NULL, e_rotation,  napi_enumerable, NULL },
+    };
+    status = napi_define_properties(env, event_obj, sizeof(descriptors) / sizeof(descriptors[0]), descriptors);
+    NAPI_FATAL_IF_FAILED(status, "uiohook_to_js_event", "napi_define_properties");
+    return event_obj;
+  }
+
+  return NULL; // never
+}
+
+void tsfn_to_js_proxy(napi_env env, napi_value js_callback, void* context, void* _event) {
+  uiohook_event* event = (uiohook_event*)_event;
+
+  if (env == NULL || js_callback == NULL || is_worker_running == false) {
+    free(event);
+    return;
+  }
+
+  napi_status status;
+
+  napi_value event_obj = uiohook_to_js_event(env, event);
+
+  napi_value global;
+  status = napi_get_global(env, &global);
+  NAPI_FATAL_IF_FAILED(status, "tsfn_to_js_proxy", "napi_get_global");
+
+  status = napi_call_function(env, global, js_callback, 1, &event_obj, NULL);
+  NAPI_FATAL_IF_FAILED(status, "tsfn_to_js_proxy", "napi_call_function");
+
+  free(event);
+}
+
+napi_value AddonStart(napi_env env, napi_callback_info info) {
+  if (is_worker_running == true)
+    return NULL;
+
+  napi_status status;
+
+  size_t info_argc = 1;
+  napi_value info_argv[1];
+  status = napi_get_cb_info(env, info, &info_argc, info_argv, NULL, NULL);
+  NAPI_THROW_IF_FAILED(env, status, NULL);
+
+  napi_value cb = info_argv[0];
+
+  napi_value async_resource_name;
+  status = napi_create_string_utf8(env, "UIOHOOK_NAPI", NAPI_AUTO_LENGTH, &async_resource_name);
+  NAPI_THROW_IF_FAILED(env, status, NULL);
+
+  status = napi_create_threadsafe_function(env, cb, NULL, async_resource_name, 0, 1, NULL, NULL, NULL, tsfn_to_js_proxy, &threadsafe_fn);
+  NAPI_THROW_IF_FAILED(env, status, NULL);
+
+  int worker_status = uiohook_worker_start(dispatch_proc);
+
+  if (worker_status != UIOHOOK_SUCCESS) {
+    napi_release_threadsafe_function(threadsafe_fn, napi_tsfn_release);
+    threadsafe_fn = NULL;
+  }
+
+  switch (worker_status) {
+  case UIOHOOK_SUCCESS: {
+    is_worker_running = true;
+    return NULL;
+  }
+  case UIOHOOK_ERROR_THREAD_CREATE:
+    NAPI_THROW(env, "UIOHOOK_ERROR_THREAD_CREATE", "Failed to create worker thread.", NULL);
+  case UIOHOOK_ERROR_OUT_OF_MEMORY:
+    NAPI_THROW(env, "UIOHOOK_ERROR_OUT_OF_MEMORY", "Failed to allocate memory.", NULL);
+  case UIOHOOK_ERROR_X_OPEN_DISPLAY:
+    NAPI_THROW(env, "UIOHOOK_ERROR_X_OPEN_DISPLAY", "Failed to open X11 display.", NULL);
+  case UIOHOOK_ERROR_X_RECORD_NOT_FOUND:
+    NAPI_THROW(env, "UIOHOOK_ERROR_X_RECORD_NOT_FOUND", "Unable to locate XRecord extension.", NULL);
+  case UIOHOOK_ERROR_X_RECORD_ALLOC_RANGE:
+    NAPI_THROW(env, "UIOHOOK_ERROR_X_RECORD_ALLOC_RANGE", "Unable to allocate XRecord range.", NULL);
+  case UIOHOOK_ERROR_X_RECORD_CREATE_CONTEXT:
+    NAPI_THROW(env, "UIOHOOK_ERROR_X_RECORD_CREATE_CONTEXT", "Unable to allocate XRecord context.", NULL);
+  case UIOHOOK_ERROR_X_RECORD_ENABLE_CONTEXT:
+    NAPI_THROW(env, "UIOHOOK_ERROR_X_RECORD_ENABLE_CONTEXT", "Failed to enable XRecord context.", NULL);
+  case UIOHOOK_ERROR_SET_WINDOWS_HOOK_EX:
+    NAPI_THROW(env, "UIOHOOK_ERROR_SET_WINDOWS_HOOK_EX", "Failed to register low level windows hook.", NULL);
+  case UIOHOOK_ERROR_AXAPI_DISABLED:
+    NAPI_THROW(env, "UIOHOOK_ERROR_AXAPI_DISABLED", "Failed to enable access for assistive devices.", NULL);
+  case UIOHOOK_ERROR_CREATE_EVENT_PORT:
+    NAPI_THROW(env, "UIOHOOK_ERROR_CREATE_EVENT_PORT", "Failed to create apple event port.", NULL);
+  case UIOHOOK_ERROR_CREATE_RUN_LOOP_SOURCE:
+    NAPI_THROW(env, "UIOHOOK_ERROR_CREATE_RUN_LOOP_SOURCE", "Failed to create apple run loop source.", NULL);
+  case UIOHOOK_ERROR_GET_RUNLOOP:
+    NAPI_THROW(env, "UIOHOOK_ERROR_GET_RUNLOOP", "Failed to acquire apple run loop.", NULL);
+  case UIOHOOK_ERROR_CREATE_OBSERVER:
+    NAPI_THROW(env, "UIOHOOK_ERROR_CREATE_OBSERVER", "Failed to create apple run loop observer.", NULL);
+  case UIOHOOK_FAILURE:
+  default:
+    NAPI_THROW(env, "UIOHOOK_FAILURE", "An unknown hook error occurred.", NULL);
+  }
+}
+
+napi_value AddonStop(napi_env env, napi_callback_info info) {
+  if (is_worker_running == false)
+    return NULL;
+
+  int status = uiohook_worker_stop();
+
+  switch (status) {
+  case UIOHOOK_SUCCESS: {
+    is_worker_running = false;
+    napi_release_threadsafe_function(threadsafe_fn, napi_tsfn_release);
+    threadsafe_fn = NULL;
+    return NULL;
+  }
+  case UIOHOOK_ERROR_OUT_OF_MEMORY:
+    NAPI_THROW(env, "UIOHOOK_ERROR_OUT_OF_MEMORY", "Failed to allocate memory.", NULL);
+  case UIOHOOK_ERROR_X_RECORD_GET_CONTEXT:
+    NAPI_THROW(env, "UIOHOOK_ERROR_X_RECORD_GET_CONTEXT", "Failed to get XRecord context.", NULL);
+  case UIOHOOK_FAILURE:
+  default:
+    NAPI_THROW(env, "UIOHOOK_FAILURE", "An unknown hook error occurred.", NULL);
+  }
+}
+
+void AddonCleanUp (void* arg) {
+  if (is_worker_running) {
+    uiohook_worker_stop();
+  }
+}
+
+typedef enum {
+  key_tap,
+  key_down,
+  key_up,
+  force_uint = 0xFFFFFFFF
+} key_tap_type;
+
+napi_value AddonKeyTap (napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  size_t info_argc = 2;
+  napi_value info_argv[2];
+  status = napi_get_cb_info(env, info, &info_argc, info_argv, NULL, NULL);
+  NAPI_THROW_IF_FAILED(env, status, NULL);
+
+  // [0] KeyCode
+  uint32_t keycode;
+  status = napi_get_value_uint32(env, info_argv[0], &keycode);
+  NAPI_THROW_IF_FAILED(env, status, NULL);
+
+  // [1] KeyTapType
+  key_tap_type tap_type;
+  status = napi_get_value_uint32(env, info_argv[1], (int32_t*)&tap_type);
+  NAPI_THROW_IF_FAILED(env, status, NULL);
+
+  uiohook_event event;
+  memset(&event, 0, sizeof(event));
+  event.data.keyboard.keycode = keycode;
+
+  if (tap_type != key_up) {
+    event.type = EVENT_KEY_PRESSED;
+    hook_post_event(&event);
+  }
+  if (tap_type != key_down) {
+    event.type = EVENT_KEY_RELEASED;
+    hook_post_event(&event);
+  }
+
+  return NULL;
+}
+
+NAPI_MODULE_INIT() {
+  napi_status status;
+  napi_value export_fn;
+
+  status = napi_create_function(env, NULL, 0, AddonStart, NULL, &export_fn);
+  NAPI_FATAL_IF_FAILED(status, "NAPI_MODULE_INIT", "napi_create_function");
+  status = napi_set_named_property(env, exports, "start", export_fn);
+  NAPI_FATAL_IF_FAILED(status, "NAPI_MODULE_INIT", "napi_set_named_property");
+
+  status = napi_create_function(env, NULL, 0, AddonStop, NULL, &export_fn);
+  NAPI_FATAL_IF_FAILED(status, "NAPI_MODULE_INIT", "napi_create_function");
+  status = napi_set_named_property(env, exports, "stop", export_fn);
+  NAPI_FATAL_IF_FAILED(status, "NAPI_MODULE_INIT", "napi_set_named_property");
+
+  status = napi_create_function(env, NULL, 0, AddonKeyTap, NULL, &export_fn);
+  NAPI_FATAL_IF_FAILED(status, "NAPI_MODULE_INIT", "napi_create_function");
+  status = napi_set_named_property(env, exports, "keyTap", export_fn);
+  NAPI_FATAL_IF_FAILED(status, "NAPI_MODULE_INIT", "napi_set_named_property");
+
+  status = napi_add_env_cleanup_hook(env, AddonCleanUp, NULL);
+  NAPI_FATAL_IF_FAILED(status, "NAPI_MODULE_INIT", "napi_add_env_cleanup_hook");
+
+  return exports;
+}

package/src/lib/napi_helpers.c

@@ -0,0 +1,51 @@
+#include <string.h>
+#include "napi_helpers.h"
+
+napi_value error_create(napi_env env) {
+  napi_status status;
+  napi_value error = NULL;
+  bool is_exception_pending;
+  const napi_extended_error_info* info;
+
+  // We must retrieve the last error info before doing anything else, because
+  // doing anything else will replace the last error info.
+  status = napi_get_last_error_info(env, &info);
+  NAPI_FATAL_IF_FAILED(status, "error_create", "napi_get_last_error_info");
+
+  status = napi_is_exception_pending(env, &is_exception_pending);
+  NAPI_FATAL_IF_FAILED(status, "error_create", "napi_is_exception_pending");
+
+  // A pending exception takes precedence over any internal error status.
+  if (is_exception_pending) {
+    status = napi_get_and_clear_last_exception(env, &error);
+    NAPI_FATAL_IF_FAILED(status, "error_create", "napi_get_and_clear_last_exception");
+  }
+  else {
+    const char* error_message = info->error_message != NULL ?
+      info->error_message : "Error in native callback";
+
+    napi_value message;
+    status = napi_create_string_utf8(
+      env,
+      error_message,
+      strlen(error_message),
+      &message);
+    NAPI_FATAL_IF_FAILED(status, "error_create", "napi_create_string_utf8");
+
+    switch (info->error_code) {
+    case napi_object_expected:
+    case napi_string_expected:
+    case napi_boolean_expected:
+    case napi_number_expected:
+      status = napi_create_type_error(env, NULL, message, &error);
+      NAPI_FATAL_IF_FAILED(status, "error_create", "napi_create_type_error");
+      break;
+    default:
+      status = napi_create_error(env, NULL, message, &error);
+      NAPI_FATAL_IF_FAILED(status, "error_create", "napi_create_error");
+      break;
+    }
+  }
+
+  return error;
+}

package/src/lib/napi_helpers.h

@@ -0,0 +1,53 @@
+#ifndef ADDON_SRC_HELPERS_H_
+#define ADDON_SRC_HELPERS_H_
+
+#include <node_api.h>
+
+#define NAPI_FATAL_IF_FAILED(status, location, message)  \
+  do {                                                   \
+    if ((status) != napi_ok) {                           \
+      napi_fatal_error(location, NAPI_AUTO_LENGTH,       \
+                       message, NAPI_AUTO_LENGTH);       \
+    }                                                    \
+  } while (0)
+
+#define NAPI_THROW_IF_FAILED_VOID(env, status)           \
+  if ((status) != napi_ok) {                             \
+    NAPI_FATAL_IF_FAILED(                                \
+      napi_throw(env, error_create(env)),                \
+      "NAPI_THROW_IF_FAILED_VOID",                       \
+      "napi_throw");                                     \
+    return;                                              \
+  }
+
+#define NAPI_THROW_IF_FAILED(env, status, ...)           \
+  if ((status) != napi_ok) {                             \
+    NAPI_FATAL_IF_FAILED(                                \
+      napi_throw(env, error_create(env)),                \
+      "NAPI_THROW_IF_FAILED_VOID",                       \
+      "napi_throw");                                     \
+    return __VA_ARGS__;                                  \
+  }
+
+#define NAPI_THROW_VOID(env, code, msg)                  \
+  do {                                                   \
+    NAPI_FATAL_IF_FAILED(                                \
+      napi_throw_error(env, (code), (msg)),              \
+      "NAPI_THROW_VOID",                                 \
+      "napi_throw_error");                               \
+    return;                                              \
+  } while (0)
+
+#define NAPI_THROW(env, code, msg, ...)                  \
+  do {                                                   \
+    NAPI_FATAL_IF_FAILED(                                \
+      napi_throw_error(env, (code), (msg)),              \
+      "NAPI_THROW",                                      \
+      "napi_throw_error");                               \
+    return __VA_ARGS__;                                  \
+  } while (0)
+
+
+napi_value error_create(napi_env env);
+
+#endif // !ADDON_SRC_HELPERS_H_

package/src/lib/uiohook_worker.c

@@ -0,0 +1,200 @@
+#include <stdarg.h>
+#include <stdio.h>
+#include <uiohook.h>
+#include <uv.h>
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <pthread.h>
+#include <sched.h>
+#endif
+
+#include "uiohook_worker.h"
+
+// Thread and mutex variables.
+static uv_thread_t hook_thread;
+static int hook_thread_status;
+static uv_mutex_t hook_running_mutex;
+static uv_mutex_t hook_control_mutex;
+static uv_cond_t hook_control_cond;
+
+static dispatcher_t user_dispatcher = NULL;
+
+bool logger_proc(unsigned int level, const char* format, ...) {
+  bool status = false;
+
+  va_list args;
+  switch (level) {
+  case LOG_LEVEL_WARN:
+  case LOG_LEVEL_ERROR:
+    va_start(args, format);
+    status = vfprintf(stderr, format, args) >= 0;
+    va_end(args);
+    break;
+  }
+
+  return status;
+}
+
+// NOTE: The following callback executes on the same thread that hook_run() is called 
+// from.  This is important because hook_run() attaches to the operating systems
+// event dispatcher and may delay event delivery to the target application.
+// Furthermore, some operating systems may choose to disable your hook if it 
+// takes to long to process.  If you need to do any extended processing, please 
+// do so by copying the event to your own queued dispatch thread.
+void worker_dispatch_proc(uiohook_event* const event) {
+  switch (event->type) {
+  case EVENT_HOOK_ENABLED:
+    // Lock the running mutex so we know if the hook is enabled.
+    uv_mutex_lock(&hook_running_mutex);
+
+    // Signal control cond so hook_enable() can continue.
+    uv_mutex_lock(&hook_control_mutex);
+    uv_cond_signal(&hook_control_cond);
+    uv_mutex_unlock(&hook_control_mutex);
+    break;
+
+  case EVENT_HOOK_DISABLED:
+    // Lock the control mutex until we exit.
+    uv_mutex_lock(&hook_control_mutex);
+
+    // Unlock the running mutex so we know if the hook is disabled.
+    uv_mutex_unlock(&hook_running_mutex);
+    break;
+
+  case EVENT_KEY_PRESSED:
+  case EVENT_KEY_RELEASED:
+  // case EVENT_KEY_TYPED:
+  case EVENT_MOUSE_CLICKED:
+  case EVENT_MOUSE_PRESSED:
+  case EVENT_MOUSE_RELEASED:
+  case EVENT_MOUSE_MOVED:
+  case EVENT_MOUSE_DRAGGED:
+  case EVENT_MOUSE_WHEEL: {
+    user_dispatcher(event);
+    break;
+  }
+
+  default:
+    break;
+  }
+}
+
+void hook_thread_proc(void* arg) {
+  #ifdef _WIN32
+  // Attempt to set the thread priority to time critical.
+  HANDLE this_thread = GetCurrentThread();
+  if (SetThreadPriority(this_thread, THREAD_PRIORITY_TIME_CRITICAL) == FALSE) {
+    logger_proc(LOG_LEVEL_WARN, "%s [%u]: Could not set thread priority %li for thread %#p! (%#lX)\n",
+      __FUNCTION__, __LINE__, (long)THREAD_PRIORITY_TIME_CRITICAL,
+      this_thread, (unsigned long)GetLastError());
+  }
+  #else
+  // Raise the thread priority
+  pthread_t this_thread = pthread_self();
+  struct sched_param params = {
+    .sched_priority = (sched_get_priority_max(SCHED_RR) / 2)
+  };
+  if (pthread_setschedparam(this_thread, SCHED_RR, &params) != 0) {
+    logger_proc(LOG_LEVEL_WARN, "%s [%u]: Could not set thread priority %i for thread 0x%lX!\n",
+      __FUNCTION__, __LINE__, params.sched_priority, (unsigned long)this_thread);
+  }
+  #endif
+
+  // Set the hook status.
+  hook_thread_status = hook_run();
+
+  // Make sure we signal that we have passed any exception throwing code for
+  // the waiting hook_enable().
+  uv_cond_signal(&hook_control_cond);
+  uv_mutex_unlock(&hook_control_mutex);
+}
+
+int hook_enable() {
+  // Lock the thread control mutex.  This will be unlocked when the
+  // thread has finished starting, or when it has fully stopped.
+  uv_mutex_lock(&hook_control_mutex);
+
+  // Set the initial status.
+  int status = UIOHOOK_FAILURE;
+
+  if (uv_thread_create(&hook_thread, hook_thread_proc, NULL) == 0) {
+    // Wait for the thread to indicate that it has passed the 
+    // initialization portion by blocking until either a EVENT_HOOK_ENABLED 
+    // event is received or the thread terminates.
+    uv_cond_wait(&hook_control_cond, &hook_control_mutex);
+
+    if (uv_mutex_trylock(&hook_running_mutex) == 0) {
+      // Lock Successful; The hook is not running but the hook_control_cond 
+      // was signaled!  This indicates that there was a startup problem!
+
+      // Get the status back from the thread.
+      uv_thread_join(&hook_thread);
+      status = hook_thread_status;
+    }
+    else {
+      // Lock Failure; The hook is currently running and wait was signaled
+      // indicating that we have passed all possible start checks.  We can 
+      // always assume a successful startup at this point.
+      status = UIOHOOK_SUCCESS;
+    }
+
+    logger_proc(LOG_LEVEL_DEBUG, "%s [%u]: Thread Result: (%#X).\n",
+      __FUNCTION__, __LINE__, status);
+  }
+  else {
+    status = UIOHOOK_ERROR_THREAD_CREATE;
+  }
+
+  // Make sure the control mutex is unlocked.
+  uv_mutex_unlock(&hook_control_mutex);
+
+  return status;
+}
+
+
+int uiohook_worker_start(dispatcher_t dispatch_proc) {
+  // Lock the thread control mutex.  This will be unlocked when the
+  // thread has finished starting, or when it has fully stopped.
+
+  // Create event handles for the thread hook.
+  uv_mutex_init(&hook_running_mutex);
+  uv_mutex_init(&hook_control_mutex);
+  uv_cond_init(&hook_control_cond);
+
+  // Set the logger callback for library output.
+  hook_set_logger_proc(logger_proc);
+
+  // Set the event callback for uiohook events.
+  hook_set_dispatch_proc(worker_dispatch_proc);
+
+  user_dispatcher = dispatch_proc;
+
+  // Start the hook and block.
+  // NOTE If EVENT_HOOK_ENABLED was delivered, the status will always succeed.
+  int status = hook_enable();
+  if (status != UIOHOOK_SUCCESS) {
+    // Close event handles for the thread hook.
+    uv_mutex_destroy(&hook_running_mutex);
+    uv_mutex_destroy(&hook_control_mutex);
+    uv_cond_destroy(&hook_control_cond);
+  }
+
+  return status;
+}
+
+int uiohook_worker_stop() {
+  int status = hook_stop();
+
+  if (status == UIOHOOK_SUCCESS) {
+    uv_thread_join(&hook_thread);
+
+    // Close event handles for the thread hook.
+    uv_mutex_destroy(&hook_running_mutex);
+    uv_mutex_destroy(&hook_control_mutex);
+    uv_cond_destroy(&hook_control_cond);
+  }
+
+  return status;
+}

package/src/lib/uiohook_worker.h

@@ -0,0 +1,12 @@
+#ifndef ADDON_SRC_UIOHOOK_WORKER_H_
+#define ADDON_SRC_UIOHOOK_WORKER_H_
+
+#include <uiohook.h>
+
+#define UIOHOOK_ERROR_THREAD_CREATE				0x10
+
+int uiohook_worker_start(dispatcher_t dispatch_proc);
+
+int uiohook_worker_stop();
+
+#endif // !ADDON_SRC_UIOHOOK_WORKER_H_