usb 2.3.1 → 2.4.2

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## [2.4.2] - 2022-05-27
+
+### Fixed
+- Fixed multiple events with device detection on Windows - [`512`](https://github.com/node-usb/node-usb/pull/512) ([Alba Mendez](https://github.com/mildsunrise))
+
+## [2.4.1] - 2022-05-07
+
+### Fixed
+- Fixed node engine ranges in package.json - ([Rob Moran](https://github.com/thegecko))
+
+## [2.4.0] - 2022-05-02
+
+### Fixed
+- Made addon context aware - [`512`](https://github.com/node-usb/node-usb/pull/512) ([Rob Moran](https://github.com/thegecko) & [Alba Mendez](https://github.com/mildsunrise))
+- Fixed deprecation of `libusb_set_option` - [`510`](https://github.com/node-usb/node-usb/pull/510) ([Rob Moran](https://github.com/thegecko))
+
+### Changed
+- **Breaking:** Updated to N-API version 6 (Node >=10.20.0 <11.x, >=12.17.0 <13.0, >=14.0.0) - [`509`](https://github.com/node-usb/node-usb/pull/509) ([Rob Moran](https://github.com/thegecko))
+
+### Added
+- Added `rebuild` command - [`511`](https://github.com/node-usb/node-usb/pull/511) ([Rob Moran](https://github.com/thegecko))
+
+### Removed
+- Removed `USE_POLL` build definition to simplify code - [`507`](https://github.com/node-usb/node-usb/pull/507) ([Rob Moran](https://github.com/thegecko))
+
 ## [2.3.1] - 2022-04-11
 
 ### Changed

package/README.md

@@ -10,7 +10,7 @@ This is a refactoring / rewrite of Christopher Klein's [node-usb](https://github
 
 # Prerequisites
 
-[Node.js >= v10.16.0](https://nodejs.org), which includes `npm`.
+[Node.js >= v10.20.0](https://nodejs.org), which includes `npm`.
 
 ## Windows
 

package/binding.gyp

@@ -19,6 +19,7 @@
         './src/node_usb.cc',
         './src/device.cc',
         './src/transfer.cc',
+        './src/thread_name.cc',
       ],
       'cflags_cc': [
         '-std=c++14'
@@ -26,13 +27,12 @@
       'defines': [
         '_FILE_OFFSET_BITS=64',
         '_LARGEFILE_SOURCE',
-        'NAPI_VERSION=<(napi_build_version)',
+        'NAPI_VERSION=6',
       ],
       'include_dirs+': [
         'src/',
         "<!@(node -p \"require('node-addon-api').include\")"
       ],
-
       'conditions' : [
           ['use_system_libusb=="false" and OS!="freebsd"', {
             'dependencies': [
@@ -93,7 +93,8 @@
                 'AdditionalOptions': [ '/EHsc' ],
               },
             },
-          }]
+          }
+        ]
       ]
     },
   ]

package/package.json

@@ -2,10 +2,10 @@
   "name": "usb",
   "description": "Library to access USB devices",
   "license": "MIT",
-  "version": "2.3.1",
+  "version": "2.4.2",
   "main": "dist/index.js",
   "engines": {
-    "node": ">=10.16.0"
+    "node": ">=10.20.0 <11.x || >=12.17.0 <13.0 || >=14.0.0"
   },
   "repository": {
     "type": "git",
@@ -38,6 +38,7 @@
   "scripts": {
     "prepare": "yarn compile",
     "install": "node-gyp-build",
+    "rebuild": "node-gyp rebuild",
     "clean": "git clean -dfx",
     "compile": "tsc && yarn lint && yarn docs",
     "lint": "eslint . --ext .ts",
@@ -46,8 +47,8 @@
     "full-test": "mocha --require coffeescript/register test/*.coffee",
     "valgrind": "coffee -c test/*.coffee; valgrind --leak-check=full --show-possibly-lost=no node --expose-gc --trace-gc node_modules/mocha/bin/_mocha -R spec",
     "docs": "typedoc",
-    "prebuild": "prebuildify --napi --target 10.16.0 --strip",
-    "prebuild-cross": "prebuildify-cross --napi --target 10.16.0 --strip",
+    "prebuild": "prebuildify --napi --strip",
+    "prebuild-cross": "prebuildify-cross --napi --strip",
     "prepublishOnly": "prebuildify-ci download",
     "prebuild-download": "prebuildify-ci download"
   },
@@ -72,7 +73,7 @@
   },
   "binary": {
     "napi_versions": [
-      4
+      6
     ]
   }
 }

package/src/device.cc

@@ -9,22 +9,24 @@
 
 #define MAX_PORTS 7
 
-Napi::FunctionReference Device::constructor;
-
-Device::Device(const Napi::CallbackInfo & info) : Napi::ObjectWrap<Device>(info), device_handle(0), refs_(0)
-#ifndef USE_POLL
-, completionQueue(handleCompletion)
-#endif
-{
+Device::Device(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Device>(info), env(0), device_handle(0), refs_(0), completionQueue(handleCompletion) {
+	env = info.Env();
 	device = info[0].As<Napi::External<libusb_device>>().Data();
 	libusb_ref_device(device);
+
+	std::map<libusb_device*, Device*>& byPtr = env.GetInstanceData<ModuleData>()->byPtr;
 	byPtr[device] = this;
+
 	DEBUG_LOG("Created device %p", this);
 	Constructor(info);
 }
 
-Device::~Device(){
+Device::~Device() {
 	DEBUG_LOG("Freed device %p", this);
+
+	ModuleData* instanceData = env.GetInstanceData<ModuleData>();
+	std::map<libusb_device*, Device*>& byPtr = instanceData->byPtr;
+
 	auto it = byPtr.find(device);
 	if (it != byPtr.end() && it->second == this)
 		byPtr.erase(it);
@@ -32,12 +34,12 @@ Device::~Device(){
 	libusb_unref_device(device);
 }
 
-// Map pinning each libusb_device to a particular V8 instance
-std::map<libusb_device*, Device*> Device::byPtr;
-
 // Get a V8 instance for a libusb_device: either the existing one from the map,
 // or create a new one and add it to the map.
-Napi::Object Device::get(napi_env env, libusb_device* dev){
+Napi::Object Device::get(Napi::Env env, libusb_device* dev) {
+	ModuleData* instanceData = env.GetInstanceData<ModuleData>();
+	std::map<libusb_device*, Device*>& byPtr = instanceData->byPtr;
+
 	auto it = byPtr.find(dev);
 	if (it != byPtr.end()) {
 		auto value = it->second->Value();
@@ -46,7 +48,7 @@ Napi::Object Device::get(napi_env env, libusb_device* dev){
 			return value;
 	}
 
-	Napi::Object obj = Device::constructor.New({ Napi::External<libusb_device>::New(env, dev) });
+	Napi::Object obj = instanceData->deviceConstructor.New({ Napi::External<libusb_device>::New(env, dev) });
 	return obj;
 }
 
@@ -90,7 +92,7 @@ Napi::Value Device::Constructor(const Napi::CallbackInfo& info) {
 	return info.This();
 }
 
-Napi::Object Device::cdesc2V8(napi_env env, libusb_config_descriptor * cdesc){
+Napi::Object Device::cdesc2V8(Napi::Env env, libusb_config_descriptor * cdesc) {
 	Napi::Object v8cdesc = Napi::Object::New(env);
 
 	STRUCT_TO_V8(v8cdesc, *cdesc, bLength)
@@ -166,7 +168,7 @@ Napi::Value Device::GetConfigDescriptor(const Napi::CallbackInfo& info) {
 	return v8cdesc;
 }
 
-Napi::Value Device::GetAllConfigDescriptors(const Napi::CallbackInfo& info){
+Napi::Value Device::GetAllConfigDescriptors(const Napi::CallbackInfo& info) {
 	ENTER_METHOD(Device, 0);
 	libusb_config_descriptor * cdesc;
 	struct libusb_device_descriptor dd;
@@ -180,7 +182,7 @@ Napi::Value Device::GetAllConfigDescriptors(const Napi::CallbackInfo& info){
 	return v8cdescriptors;
 }
 
-Napi::Value Device::GetParent(const Napi::CallbackInfo& info){
+Napi::Value Device::GetParent(const Napi::CallbackInfo& info) {
 	ENTER_METHOD(Device, 0);
 	libusb_device* dev = libusb_get_parent(self->device);
 	if(dev)
@@ -193,9 +195,7 @@ Napi::Value Device::Open(const Napi::CallbackInfo& info) {
 	ENTER_METHOD(Device, 0);
 	if (!self->device_handle){
 		CHECK_USB(libusb_open(self->device, &self->device_handle));
-#ifndef USE_POLL
 		completionQueue.start(info.Env());
-#endif
 	}
 	return env.Undefined();
 }
@@ -205,9 +205,7 @@ Napi::Value Device::Close(const Napi::CallbackInfo& info) {
 	if (self->canClose()){
 		libusb_close(self->device_handle);
 		self->device_handle = NULL;
-#ifndef USE_POLL
 		completionQueue.stop();
-#endif        
 	}else{
 		THROW_ERROR("Can't close device with a pending request");
 	}
@@ -410,8 +408,8 @@ Napi::Object Device::Init(Napi::Env env, Napi::Object exports) {
 		});
 	exports.Set("Device", func);
 
-	Device::constructor = Napi::Persistent(func);
-	Device::constructor.SuppressDestruct();
+	ModuleData* instanceData = env.GetInstanceData<ModuleData>();
+	instanceData->deviceConstructor = Napi::Persistent(func);
 
 	return exports;
 }

package/src/node_usb.cc

@@ -1,6 +1,5 @@
 #include "node_usb.h"
-#include "uv_async_queue.h"
-#include <thread>
+#include "thread_name.h"
 
 Napi::Value SetDebugLevel(const Napi::CallbackInfo& info);
 Napi::Value UseUsbDkBackend(const Napi::CallbackInfo& info);
@@ -12,87 +11,87 @@ Napi::Value RefHotplugEvents(const Napi::CallbackInfo& info);
 Napi::Value UnrefHotplugEvents(const Napi::CallbackInfo& info);
 void initConstants(Napi::Object target);
 
-libusb_context* usb_context;
-struct HotPlug {
-	libusb_device* device;
-	libusb_hotplug_event event;
-};
+void handleHotplug(HotPlug* info){
+	Napi::ObjectReference* hotplugThis = info->hotplugThis;
+	Napi::Env env = hotplugThis->Env();
+	Napi::HandleScope scope(env);
 
-#ifdef USE_POLL
-#include <poll.h>
-#include <uv.h>
-#include <sys/time.h>
+	libusb_device* dev = info->device;
+	libusb_hotplug_event event = info->event;
 
-std::map<int, uv_poll_t*> pollByFD;
+	DEBUG_LOG("HandleHotplug %p %i", dev, event);
 
-struct timeval zero_tv = {0, 0};
+	Napi::Value v8dev = Device::get(env, dev);
+	libusb_unref_device(dev);
 
-void onPollSuccess(uv_poll_t* handle, int status, int events){
-	libusb_handle_events_timeout(usb_context, &zero_tv);
-}
+	Napi::String eventName;
+	if (LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED == event) {
+		DEBUG_LOG("Device arrived");
+		eventName = Napi::String::New(env, "attach");
 
-void LIBUSB_CALL onPollFDAdded(int fd, short events, void *user_data){
-	uv_poll_t *poll_fd;
-	auto it = pollByFD.find(fd);
-	if (it != pollByFD.end()){
-		poll_fd = it->second;
-	}else{
-		poll_fd = (uv_poll_t*) malloc(sizeof(uv_poll_t));
-		uv_poll_init(uv_default_loop(), poll_fd, fd);
-		pollByFD.insert(std::make_pair(fd, poll_fd));
+	} else if (LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT == event) {
+		DEBUG_LOG("Device left");
+		eventName = Napi::String::New(env, "detach");
+
+	} else {
+		DEBUG_LOG("Unhandled hotplug event %d\n", event);
+		return;
 	}
 
-	DEBUG_LOG("Added pollfd %i, %p", fd, poll_fd);
-	unsigned flags = ((events&POLLIN) ? UV_READABLE:0)
-	               | ((events&POLLOUT)? UV_WRITABLE:0);
-	uv_poll_start(poll_fd, flags, onPollSuccess);
+	hotplugThis->Get("emit").As<Napi::Function>().MakeCallback(hotplugThis->Value(), { eventName, v8dev });
+	delete info;
 }
 
-void LIBUSB_CALL onPollFDRemoved(int fd, void *user_data){
-	auto it = pollByFD.find(fd);
-	if (it != pollByFD.end()){
-		DEBUG_LOG("Removed pollfd %i, %p", fd, it->second);
-		uv_poll_stop(it->second);
-		uv_close((uv_handle_t*) it->second, (uv_close_cb) free);
-		pollByFD.erase(it);
+void USBThreadFn(ModuleData* instanceData) {
+	SetThreadName("node-usb events");
+	libusb_context* usb_context = instanceData->usb_context;
+
+	while(true) {
+		if (instanceData->handlingEvents == false) {
+			break;
+		}
+		libusb_handle_events(usb_context);
 	}
 }
 
-#else
-std::thread usb_thread;
+ModuleData::ModuleData(libusb_context* usb_context) : usb_context(usb_context), hotplugQueue(handleHotplug) {
+	handlingEvents = true;
+	usb_thread = std::thread(USBThreadFn, this);
+}
+
+ModuleData::~ModuleData() {
+	handlingEvents = false;
+	libusb_interrupt_event_handler(usb_context);
+	usb_thread.join();
 
-void USBThreadFn(){
-	while(1) libusb_handle_events(usb_context);
+	if (usb_context != nullptr) {
+		libusb_exit(usb_context);
+		usb_context = nullptr;
+	}
+}
+
+int LIBUSB_CALL hotplug_callback(libusb_context* ctx, libusb_device* device,
+                     libusb_hotplug_event event, void* user_data) {
+	libusb_ref_device(device);
+	ModuleData* instanceData = (ModuleData*)user_data;
+	instanceData->hotplugQueue.post(new HotPlug {device, event, &instanceData->hotplugThis});
+	return 0;
 }
-#endif
 
 Napi::Object Init(Napi::Env env, Napi::Object exports) {
 	Napi::HandleScope scope(env);
-
 	initConstants(exports);
 
 	// Initialize libusb. On error, halt initialization.
+	libusb_context* usb_context = nullptr;
 	int res = libusb_init(&usb_context);
+
 	exports.Set("INIT_ERROR", Napi::Number::New(env, res));
 	if (res != 0) {
 		return exports;
 	}
 
-	#ifdef USE_POLL
-	assert(libusb_pollfds_handle_timeouts(usb_context));
-	libusb_set_pollfd_notifiers(usb_context, onPollFDAdded, onPollFDRemoved, NULL);
-
-	const struct libusb_pollfd** pollfds = libusb_get_pollfds(usb_context);
-	assert(pollfds);
-	for(const struct libusb_pollfd** i=pollfds; *i; i++){
-		onPollFDAdded((*i)->fd, (*i)->events, NULL);
-	}
-	free(pollfds);
-
-	#else
-	usb_thread = std::thread(USBThreadFn);
-	usb_thread.detach();
-	#endif
+	env.SetInstanceData(new ModuleData(usb_context));
 
 	Device::Init(env, exports);
 	Transfer::Init(env, exports);
@@ -117,7 +116,8 @@ Napi::Value SetDebugLevel(const Napi::CallbackInfo& info) {
 		THROW_BAD_ARGS("Usb::SetDebugLevel argument is invalid. [uint:[0-4]]!")
 	}
 
-	libusb_set_debug(usb_context, info[0].As<Napi::Number>().Int32Value());
+	libusb_context* usb_context = env.GetInstanceData<ModuleData>()->usb_context;
+	libusb_set_option(usb_context, LIBUSB_OPTION_LOG_LEVEL, info[0].As<Napi::Number>().Int32Value());
 	return env.Undefined();
 }
 
@@ -125,6 +125,7 @@ Napi::Value UseUsbDkBackend(const Napi::CallbackInfo& info) {
 	Napi::Env env = info.Env();
 	Napi::HandleScope scope(env);
 
+	libusb_context* usb_context = env.GetInstanceData<ModuleData>()->usb_context;
 	libusb_set_option(usb_context, LIBUSB_OPTION_USE_USBDK);
 	return env.Undefined();
 }
@@ -132,7 +133,9 @@ Napi::Value UseUsbDkBackend(const Napi::CallbackInfo& info) {
 Napi::Value GetDeviceList(const Napi::CallbackInfo& info) {
 	Napi::Env env = info.Env();
 	Napi::HandleScope scope(env);
-	libusb_device **devs;
+	libusb_device** devs;
+
+	libusb_context* usb_context = env.GetInstanceData<ModuleData>()->usb_context;
 	int cnt = libusb_get_device_list(usb_context, &devs);
 	CHECK_USB(cnt);
 
@@ -156,62 +159,28 @@ Napi::Value GetLibusbCapability(const Napi::CallbackInfo& info) {
 	return Napi::Number::New(env, res);
 }
 
-Napi::ObjectReference hotplugThis;
-
-void handleHotplug(HotPlug* info){
-	Napi::Env env = hotplugThis.Env();
-	Napi::HandleScope scope(env);
-
-	libusb_device* dev = info->device;
-	libusb_hotplug_event event = info->event;
-	delete info;
-
-	DEBUG_LOG("HandleHotplug %p %i", dev, event);
-
-	Napi::Value v8dev = Device::get(env, dev);
-	libusb_unref_device(dev);
-
-	Napi::String eventName;
-	if (LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED == event) {
-		DEBUG_LOG("Device arrived");
-		eventName = Napi::String::New(env, "attach");
-
-	} else if (LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT == event) {
-		DEBUG_LOG("Device left");
-		eventName = Napi::String::New(env, "detach");
-
-	} else {
-		DEBUG_LOG("Unhandled hotplug event %d\n", event);
-		return;
-	}
-
-	hotplugThis.Get("emit").As<Napi::Function>().MakeCallback(hotplugThis.Value(), { eventName, v8dev });
-}
-
-bool hotplugEnabled = 0;
-libusb_hotplug_callback_handle hotplugHandle;
-UVQueue<HotPlug*> hotplugQueue(handleHotplug);
-
-int LIBUSB_CALL hotplug_callback(libusb_context *ctx, libusb_device *device,
-                     libusb_hotplug_event event, void *user_data) {
-	libusb_ref_device(device);
-	hotplugQueue.post(new HotPlug {device, event});
-	return 0;
-}
-
 Napi::Value EnableHotplugEvents(const Napi::CallbackInfo& info) {
 	Napi::Env env = info.Env();
 	Napi::HandleScope scope(env);
+	ModuleData* instanceData = env.GetInstanceData<ModuleData>();
 
-	if (!hotplugEnabled) {
-		hotplugThis.Reset(info.This().As<Napi::Object>(), 1);
-		hotplugThis.SuppressDestruct();
-		CHECK_USB(libusb_hotplug_register_callback(usb_context,
+	if (!instanceData->hotplugEnabled) {
+		instanceData->hotplugThis.Reset(info.This().As<Napi::Object>(), 1);
+
+		libusb_context* usb_context = instanceData->usb_context;
+		CHECK_USB(libusb_hotplug_register_callback(
+			usb_context,
 			(libusb_hotplug_event)(LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED | LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT),
-			(libusb_hotplug_flag)0, LIBUSB_HOTPLUG_MATCH_ANY, LIBUSB_HOTPLUG_MATCH_ANY, LIBUSB_HOTPLUG_MATCH_ANY,
-			hotplug_callback, NULL, &hotplugHandle));
-		hotplugQueue.start(env);
-		hotplugEnabled = true;
+			(libusb_hotplug_flag)0,
+			LIBUSB_HOTPLUG_MATCH_ANY,
+			LIBUSB_HOTPLUG_MATCH_ANY,
+			LIBUSB_HOTPLUG_MATCH_ANY,
+			hotplug_callback,
+			instanceData,
+			&instanceData->hotplugHandle
+		));
+		instanceData->hotplugQueue.start(env);
+		instanceData->hotplugEnabled = true;
 	}
 	return env.Undefined();
 }
@@ -219,10 +188,13 @@ Napi::Value EnableHotplugEvents(const Napi::CallbackInfo& info) {
 Napi::Value DisableHotplugEvents(const Napi::CallbackInfo& info) {
 	Napi::Env env = info.Env();
 	Napi::HandleScope scope(env);
-	if (hotplugEnabled) {
-		libusb_hotplug_deregister_callback(usb_context, hotplugHandle);
-		hotplugQueue.stop();
-		hotplugEnabled = false;
+	ModuleData* instanceData = env.GetInstanceData<ModuleData>();
+
+	if (instanceData->hotplugEnabled) {
+		libusb_context* usb_context = instanceData->usb_context;
+		libusb_hotplug_deregister_callback(usb_context, instanceData->hotplugHandle);
+		instanceData->hotplugQueue.stop();
+		instanceData->hotplugEnabled = false;
 	}
 	return env.Undefined();
 }
@@ -230,8 +202,10 @@ Napi::Value DisableHotplugEvents(const Napi::CallbackInfo& info) {
 Napi::Value RefHotplugEvents(const Napi::CallbackInfo& info) {
 	Napi::Env env = info.Env();
 	Napi::HandleScope scope(env);
-	if (hotplugEnabled) {
-		hotplugQueue.ref(env);
+	ModuleData* instanceData = env.GetInstanceData<ModuleData>();
+
+	if (instanceData->hotplugEnabled) {
+		instanceData->hotplugQueue.ref(env);
 	}
 	return env.Undefined();
 }
@@ -239,8 +213,10 @@ Napi::Value RefHotplugEvents(const Napi::CallbackInfo& info) {
 Napi::Value UnrefHotplugEvents(const Napi::CallbackInfo& info) {
 	Napi::Env env = info.Env();
 	Napi::HandleScope scope(env);
-	if (hotplugEnabled) {
-		hotplugQueue.unref(env);
+	ModuleData* instanceData = env.GetInstanceData<ModuleData>();
+
+	if (instanceData->hotplugEnabled) {
+		instanceData->hotplugQueue.unref(env);
 	}
 	return env.Undefined();
 }
@@ -362,7 +338,7 @@ void initConstants(Napi::Object target){
 	DEFINE_CONSTANT(target, LIBUSB_ERROR_OTHER);
 }
 
-Napi::Error libusbException(napi_env env, int errorno) {
+Napi::Error libusbException(Napi::Env env, int errorno) {
 	const char* err = libusb_error_name(errorno);
 	Napi::Error e  = Napi::Error::New(env, err);
 	e.Set("errno", (double)errorno);

package/src/node_usb.h

@@ -8,35 +8,36 @@
 #ifdef _WIN32
 #include <WinSock2.h>
 #endif
-#include <libusb.h>
 
-#define NAPI_VERSION 4
+#include <thread>
+#include <libusb.h>
 #include <napi.h>
 #include <node_buffer.h>
 
 #include "helpers.h"
-
-#ifndef USE_POLL
 #include "uv_async_queue.h"
-#endif
+
+struct HotPlug {
+	libusb_device* device;
+	libusb_hotplug_event event;
+	Napi::ObjectReference* hotplugThis;
+};
 
 struct Transfer;
 
-Napi::Error libusbException(napi_env env, int errorno);
+Napi::Error libusbException(Napi::Env env, int errorno);
 void handleCompletion(Transfer* self);
 
 struct Device: public Napi::ObjectWrap<Device> {
+	Napi::Env env;
 	libusb_device* device;
 	libusb_device_handle* device_handle;
 
 	int refs_;
-
-#ifndef USE_POLL
 	UVQueue<Transfer*> completionQueue;
-#endif
 
 	static Napi::Object Init(Napi::Env env, Napi::Object exports);
-	static Napi::Object get(napi_env env, libusb_device* handle);
+	static Napi::Object get(Napi::Env env, libusb_device* handle);
 
 	inline void ref(){ refs_ = Ref();}
 	inline void unref(){ refs_ = Unref();}
@@ -45,8 +46,7 @@ struct Device: public Napi::ObjectWrap<Device> {
 	Device(const Napi::CallbackInfo& info);
 	~Device();
 
-	static Napi::Object cdesc2V8(napi_env env, libusb_config_descriptor * cdesc);
-
+	static Napi::Object cdesc2V8(Napi::Env env, libusb_config_descriptor * cdesc);
 
 	Napi::Value GetConfigDescriptor(const Napi::CallbackInfo& info);
 	Napi::Value GetAllConfigDescriptors(const Napi::CallbackInfo& info);
@@ -67,12 +67,24 @@ struct Device: public Napi::ObjectWrap<Device> {
 
 	Napi::Value ClearHalt(const Napi::CallbackInfo& info);
 protected:
-	static std::map<libusb_device*, Device*> byPtr;
-	static Napi::FunctionReference constructor;
-	
 	Napi::Value Constructor(const Napi::CallbackInfo& info);
 };
 
+struct ModuleData {
+	libusb_context* usb_context;
+	std::thread usb_thread;
+	std::atomic<bool> handlingEvents;
+
+	bool hotplugEnabled = 0;
+	libusb_hotplug_callback_handle hotplugHandle;
+	UVQueue<HotPlug*> hotplugQueue;
+	Napi::ObjectReference hotplugThis;
+	std::map<libusb_device*, Device*> byPtr;
+	Napi::FunctionReference deviceConstructor;
+
+    ModuleData(libusb_context* usb_context);
+	~ModuleData();
+};
 
 struct Transfer: public Napi::ObjectWrap<Transfer> {
 	libusb_transfer* transfer;

package/src/thread_name.cc

@@ -0,0 +1,79 @@
+// Definition of a SetThreadName function with an emphasis in "portability",
+// meaning we prefer cautiously failing over creating build errors (or crashes)
+// on exotic platforms. To do this, we only include/link against very
+// few & widely available symbols.
+#include "thread_name.h"
+
+#if defined(__linux__)
+
+    // For Linux use the prctl API directly. prctl symbol
+    // should be available under any libc.
+    #include <sys/prctl.h>
+
+    // Define here to avoid relying on kernel headers being present
+    #define PR_SET_NAME    15		/* Set process name */
+
+    bool SetThreadName(const char* name) {
+        return prctl(PR_SET_NAME, name, 0, 0, 0) >= 0;
+    }
+
+#elif defined(__APPLE__)
+
+    // For MacOS use the dynamic linker because I don't
+    // want to take any risks
+    #include <dlfcn.h>
+
+    extern "C" typedef int (*SetNameFn)(const char*);
+
+    bool SetThreadName(const char* name) {
+        auto pthread_setname_np = reinterpret_cast<SetNameFn>(
+            dlsym(RTLD_DEFAULT, "pthread_setname_np"));
+        if (pthread_setname_np == nullptr)
+            return false;
+        return pthread_setname_np(name) == 0;
+    }
+
+#elif defined(_WIN32)
+
+    // For Windows, we use the new SetThreadDescription API which
+    // is only available in newish versions. To avoid taking any
+    // risks (and because on certain versions it's the only
+    // option to access the API), we use the dynamic linker
+    #include <windows.h>
+
+    extern "C" typedef HRESULT (WINAPI *SetThreadDescriptionFn)(HANDLE, PCWSTR);
+
+    static SetThreadDescriptionFn RetrieveSymbol(const char* objectName) {
+        auto mod = GetModuleHandleA(objectName);
+        if (mod == nullptr) return nullptr;
+        auto symbol = GetProcAddress(mod, "SetThreadDescription");
+        return reinterpret_cast<SetThreadDescriptionFn>(symbol);
+    }
+
+    #include <locale>
+    #include <codecvt>
+    #include <string>
+
+    bool SetThreadName(const char* name) {
+        auto SetThreadDescription = RetrieveSymbol("Kernel32.dll");
+        // apparently, MSDN is wrong and the symbol is defined in
+        // KernelBase.dll, so try that too
+        if (SetThreadDescription == nullptr)
+            SetThreadDescription = RetrieveSymbol("KernelBase.dll");
+
+        if (SetThreadDescription == nullptr) return false;
+
+        std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
+        std::wstring wide_name = converter.from_bytes(name);
+
+        auto result = SetThreadDescription(GetCurrentThread(), wide_name.c_str());
+        return SUCCEEDED(result);
+    }
+
+#else
+
+    bool SetThreadName(const char* name) {
+        return false;
+    }
+
+#endif

package/src/thread_name.h

@@ -0,0 +1,11 @@
+/**
+ * Sets the name of the calling thread to `name`, which is
+ * a NUL terminated UTF-8 string. Returns true if success,
+ * false if error or unsupported platform.
+ *
+ * Since this is an OS-dependent operation, the requirements
+ * of `name` may vary depending on platform. For example on
+ * Linux, the maximum length (excluding the terminator) is
+ * 16 bytes, and UTF-8 isn't strictly required (only conventional).
+ */
+bool SetThreadName(const char* name);

package/src/transfer.cc

@@ -84,12 +84,7 @@ extern "C" void LIBUSB_CALL usbCompletionCb(libusb_transfer *transfer){
 	Transfer* t = static_cast<Transfer*>(transfer->user_data);
 	DEBUG_LOG("Completion callback %p", t);
 	assert(t != NULL);
-
-	#ifdef USE_POLL
-	handleCompletion(t);
-	#else
 	t->device->completionQueue.post(t);
-	#endif
 }
 
 void handleCompletion(Transfer* self){

package/test/usb.coffee

@@ -4,6 +4,7 @@ usb = require('../').usb
 getDeviceList = require('../').getDeviceList
 findByIds = require('../').findByIds
 findBySerialNumber = require('../').findBySerialNumber
+Worker = require('worker_threads').Worker
 
 if typeof gc is 'function'
 	# running with --expose-gc, do a sweep between tests so valgrind blames the right one
@@ -20,14 +21,14 @@ describe 'USB Module', ->
 		assert.throws -> usb.Device()
 		assert.throws -> usb.Device.prototype.open.call({})
 
-	describe 'setDebugLevel', ->
-		it 'should throw when passed invalid args', ->
-			assert.throws((-> usb.setDebugLevel()), TypeError)
-			assert.throws((-> usb.setDebugLevel(-1)), TypeError)
-			assert.throws((-> usb.setDebugLevel(5)), TypeError)
+describe 'setDebugLevel', ->
+	it 'should throw when passed invalid args', ->
+		assert.throws((-> usb.setDebugLevel()), TypeError)
+		assert.throws((-> usb.setDebugLevel(-1)), TypeError)
+		assert.throws((-> usb.setDebugLevel(5)), TypeError)
 
-		it 'should succeed with good args', ->
-			assert.doesNotThrow(-> usb.setDebugLevel(0))
+	it 'should succeed with good args', ->
+		assert.doesNotThrow(-> usb.setDebugLevel(0))
 
 describe 'getDeviceList', ->
 	it 'should return at least one device', ->
@@ -201,3 +202,13 @@ describe 'Device', ->
 
 	after ->
 		device.close()
+
+if process.platform != 'win32'
+	describe 'Context Aware', ->
+		it 'should handle opening the same device from different contexts', ->
+			for n in [1..5]
+				worker = new Worker('./test/worker.cjs')
+				worker.on 'message', (serial) ->
+					assert.equal(serial, 'TEST_DEVICE')
+				worker.on 'exit', (code) ->
+					assert.equal(code, 0)

package/test/worker.cjs

@@ -0,0 +1,9 @@
+const parentPort = require('worker_threads').parentPort
+const findByIds = require('../dist').findByIds;
+
+const device = findByIds(0x59e3, 0x0a23);
+device.open();
+device.getStringDescriptor(device.deviceDescriptor.iSerialNumber, (_, serial) => {
+    parentPort.postMessage(serial);
+    device.close();
+});