simen-keyboard-listener 1.0.7 → 1.0.9

package/src/native/simen_keyboard_listener.cc

@@ -1,660 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Simen. All rights reserved.
- *  Licensed under the MIT License.
- *--------------------------------------------------------------------------------------------*/
-
-#include <napi.h>
-
-#include <array>
-#include <atomic>
-#include <chrono>
-#include <condition_variable>
-#include <mutex>
-#include <optional>
-#include <string>
-#include <thread>
-
-namespace {
-
-struct KeyEvent {
-	std::string name;
-	std::string state; // "DOWN" | "UP"
-};
-
-std::atomic<bool> g_running{ false };
-std::mutex g_stateMutex;
-
-std::mutex g_startMutex;
-std::condition_variable g_startCv;
-int g_startResult = 0; // 0 = pending, 1 = started, -1 = failed
-
-Napi::ThreadSafeFunction g_tsfn;
-std::thread g_thread;
-
-void setStartResult(int value) {
-	{
-		std::lock_guard<std::mutex> lock(g_startMutex);
-		g_startResult = value;
-	}
-	g_startCv.notify_one();
-}
-
-void emitKeyEvent(const std::string& name, const std::string& state) {
-	if (!g_running.load()) {
-		return;
-	}
-	if (!g_tsfn) {
-		return;
-	}
-
-	KeyEvent* payload = new KeyEvent{ name, state };
-	napi_status status = g_tsfn.NonBlockingCall(payload, [](Napi::Env env, Napi::Function jsCallback, KeyEvent* data) {
-		Napi::HandleScope scope(env);
-		Napi::Object evt = Napi::Object::New(env);
-		evt.Set("name", Napi::String::New(env, data->name));
-		evt.Set("state", Napi::String::New(env, data->state));
-		jsCallback.Call({ evt });
-		delete data;
-	});
-
-	if (status != napi_ok) {
-		delete payload;
-	}
-}
-
-} // namespace
-
-#if defined(__APPLE__)
-
-#include <ApplicationServices/ApplicationServices.h>
-
-namespace {
-
-// Check if the app has accessibility permission (required for CGEventTap)
-static bool macHasAccessibilityPermission() {
-	// AXIsProcessTrusted returns true if the app has accessibility permission
-	return AXIsProcessTrusted();
-}
-
-} // namespace
-
-namespace {
-
-CFMachPortRef g_eventTap = nullptr;
-CFRunLoopSourceRef g_runLoopSource = nullptr;
-CFRunLoopRef g_runLoop = nullptr;
-
-static std::atomic<bool> g_fnDown{ false };
-static std::atomic<bool> g_shiftDown{ false };
-static std::atomic<bool> g_ctrlDown{ false };
-static std::atomic<bool> g_altDown{ false };
-static std::atomic<bool> g_cmdDown{ false };
-
-static bool macHandleFlagsChanged(CGEventRef event) {
-	const CGEventFlags flags = CGEventGetFlags(event);
-	bool shouldBlock = false;
-
-	const bool fnIsDown = (flags & kCGEventFlagMaskSecondaryFn) != 0;
-	const bool fnPrev = g_fnDown.exchange(fnIsDown);
-	if (fnIsDown != fnPrev) {
-		emitKeyEvent("FN", fnIsDown ? "DOWN" : "UP");
-		// Block FN key DOWN from triggering system emoji panel
-		// Only block on key down, not key up, to avoid interfering with other shortcuts
-		if (fnIsDown) {
-			// Check if FN is pressed alone (no other modifiers)
-			const bool hasOtherModifiers = (flags & (kCGEventFlagMaskShift | kCGEventFlagMaskControl |
-		kCGEventFlagMaskAlternate | kCGEventFlagMaskCommand)) != 0;
-			if (!hasOtherModifiers) {
-				shouldBlock = true;
-			}
-		}
-	}
-
-	const bool shiftIsDown = (flags & kCGEventFlagMaskShift) != 0;
-	const bool shiftPrev = g_shiftDown.exchange(shiftIsDown);
-	if (shiftIsDown != shiftPrev) {
-		// Emit a stable name regardless of left/right shift.
-		emitKeyEvent("LEFT SHIFT", shiftIsDown ? "DOWN" : "UP");
-	}
-
-	const bool ctrlIsDown = (flags & kCGEventFlagMaskControl) != 0;
-	const bool ctrlPrev = g_ctrlDown.exchange(ctrlIsDown);
-	if (ctrlIsDown != ctrlPrev) {
-		emitKeyEvent("LEFT CTRL", ctrlIsDown ? "DOWN" : "UP");
-	}
-
-	const bool altIsDown = (flags & kCGEventFlagMaskAlternate) != 0;
-	const bool altPrev = g_altDown.exchange(altIsDown);
-	if (altIsDown != altPrev) {
-		emitKeyEvent("LEFT ALT", altIsDown ? "DOWN" : "UP");
-	}
-
-	const bool cmdIsDown = (flags & kCGEventFlagMaskCommand) != 0;
-	const bool cmdPrev = g_cmdDown.exchange(cmdIsDown);
-	if (cmdIsDown != cmdPrev) {
-		emitKeyEvent("LEFT META", cmdIsDown ? "DOWN" : "UP");
-	}
-
-	return shouldBlock;
-}
-
-static std::optional<std::string> macKeyCodeToName(CGKeyCode keyCode) {
-	switch (keyCode) {
-		// Common keys
-		case 53: return std::string("ESCAPE");
-		case 49: return std::string("SPACE");
-		case 36: return std::string("RETURN");
-		case 48: return std::string("TAB");
-		case 51: return std::string("BACKSPACE");
-		case 117: return std::string("DELETE");
-
-		// Arrow keys
-		case 123: return std::string("LEFT");
-		case 124: return std::string("RIGHT");
-		case 125: return std::string("DOWN");
-		case 126: return std::string("UP");
-
-		// Letters (US keyboard physical mapping)
-		case 0: return std::string("A");
-		case 1: return std::string("S");
-		case 2: return std::string("D");
-		case 3: return std::string("F");
-		case 4: return std::string("H");
-		case 5: return std::string("G");
-		case 6: return std::string("Z");
-		case 7: return std::string("X");
-		case 8: return std::string("C");
-		case 9: return std::string("V");
-		case 11: return std::string("B");
-		case 12: return std::string("Q");
-		case 13: return std::string("W");
-		case 14: return std::string("E");
-		case 15: return std::string("R");
-		case 16: return std::string("Y");
-		case 17: return std::string("T");
-		case 31: return std::string("O");
-		case 32: return std::string("U");
-		case 34: return std::string("I");
-		case 35: return std::string("P");
-		case 37: return std::string("L");
-		case 38: return std::string("J");
-		case 40: return std::string("K");
-		case 45: return std::string("N");
-		case 46: return std::string("M");
-
-		// Numbers row (US keyboard physical mapping)
-		case 18: return std::string("1");
-		case 19: return std::string("2");
-		case 20: return std::string("3");
-		case 21: return std::string("4");
-		case 23: return std::string("5");
-		case 22: return std::string("6");
-		case 26: return std::string("7");
-		case 28: return std::string("8");
-		case 25: return std::string("9");
-		case 29: return std::string("0");
-		default: return std::nullopt;
-	}
-}
-
-static CGEventRef macEventTapCallback(CGEventTapProxy /*proxy*/, CGEventType type, CGEventRef event, void* /*userInfo*/) {
-	if (!g_running.load()) {
-		return event;
-	}
-
-	if (type == kCGEventTapDisabledByTimeout || type == kCGEventTapDisabledByUserInput) {
-		if (g_eventTap) {
-			CGEventTapEnable(g_eventTap, true);
-		}
-		g_fnDown.store(false);
-		g_shiftDown.store(false);
-		g_ctrlDown.store(false);
-		g_altDown.store(false);
-		g_cmdDown.store(false);
-		return event;
-	}
-
-	if (type == kCGEventFlagsChanged) {
-		bool shouldBlock = macHandleFlagsChanged(event);
-		// Block FN key event from reaching the system
-		if (shouldBlock) {
-			return NULL;
-		}
-		return event;
-	}
-
-	if (type == kCGEventKeyDown || type == kCGEventKeyUp) {
-		const CGKeyCode keyCode = static_cast<CGKeyCode>(CGEventGetIntegerValueField(event, kCGKeyboardEventKeycode));
-		const auto name = macKeyCodeToName(keyCode);
-		if (name.has_value()) {
-			emitKeyEvent(*name, type == kCGEventKeyDown ? "DOWN" : "UP");
-		}
-		return event;
-	}
-
-	return event;
-}
-
-static void macThreadMain() {
-	// Pre-check accessibility permission before attempting to create event tap
-	if (!macHasAccessibilityPermission()) {
-		g_running.store(false);
-		setStartResult(-1);
-		return;
-	}
-
-	CGEventMask mask = CGEventMaskBit(kCGEventKeyDown) |
-		CGEventMaskBit(kCGEventKeyUp) |
-		CGEventMaskBit(kCGEventFlagsChanged);
-
-	g_eventTap = CGEventTapCreate(
-		kCGSessionEventTap,
-		kCGHeadInsertEventTap,
-		kCGEventTapOptionDefault,
-		mask,
-		macEventTapCallback,
-		nullptr
-	);
-
-	if (!g_eventTap) {
-		g_running.store(false);
-		setStartResult(-1);
-		return;
-	}
-
-	g_runLoopSource = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, g_eventTap, 0);
-	if (!g_runLoopSource) {
-		CFRelease(g_eventTap);
-		g_eventTap = nullptr;
-		g_running.store(false);
-		setStartResult(-1);
-		return;
-	}
-
-	g_runLoop = CFRunLoopGetCurrent();
-	CFRunLoopAddSource(g_runLoop, g_runLoopSource, kCFRunLoopCommonModes);
-	CGEventTapEnable(g_eventTap, true);
-
-	setStartResult(1);
-
-	while (g_running.load()) {
-		CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.5, true);
-	}
-
-	if (g_eventTap) {
-		CGEventTapEnable(g_eventTap, false);
-	}
-	if (g_runLoopSource) {
-		CFRunLoopRemoveSource(g_runLoop, g_runLoopSource, kCFRunLoopCommonModes);
-		CFRelease(g_runLoopSource);
-		g_runLoopSource = nullptr;
-	}
-	if (g_eventTap) {
-		CFRelease(g_eventTap);
-		g_eventTap = nullptr;
-	}
-	g_runLoop = nullptr;
-
-	g_fnDown.store(false);
-	g_shiftDown.store(false);
-	g_ctrlDown.store(false);
-	g_altDown.store(false);
-	g_cmdDown.store(false);
-}
-
-} // namespace
-
-#elif defined(_WIN32)
-
-#define NOMINMAX
-#include <windows.h>
-
-namespace {
-
-HHOOK g_hook = nullptr;
-DWORD g_threadId = 0;
-UINT_PTR g_timerId = 0;
-// Custom message to wake up the message loop for polling
-constexpr UINT WM_POLL_KEYS = WM_USER + 100;
-
-std::array<bool, 256> g_down{};
-std::array<DWORD, 256> g_lastFlags{};
-
-static std::optional<std::string> winVkToName(DWORD vkCode, DWORD flags);
-
-static bool winIsPhysicallyDown(DWORD vkCode) {
-	return (GetAsyncKeyState(static_cast<int>(vkCode)) & 0x8000) != 0;
-}
-
-static void winPollMissingKeyUps() {
-	for (DWORD vkCode = 0; vkCode < g_down.size(); vkCode++) {
-		if (!g_down[vkCode]) {
-			continue;
-		}
-		if (winIsPhysicallyDown(vkCode)) {
-			continue;
-		}
-
-		const auto name = winVkToName(vkCode, g_lastFlags[vkCode]);
-		if (name.has_value()) {
-			emitKeyEvent(*name, "UP");
-		}
-		g_down[vkCode] = false;
-		g_lastFlags[vkCode] = 0;
-	}
-}
-
-static std::optional<std::string> winVkToName(DWORD vkCode, DWORD flags) {
-	if (vkCode == VK_ESCAPE) {
-		return std::string("ESCAPE");
-	}
-	if (vkCode == VK_LSHIFT) { return std::string("LEFT SHIFT"); }
-	if (vkCode == VK_RSHIFT) { return std::string("RIGHT SHIFT"); }
-
-	// Right Alt: VK_RMENU or VK_MENU with extended flag.
-	if (vkCode == VK_RMENU || (vkCode == VK_MENU && (flags & LLKHF_EXTENDED))) {
-		return std::string("RIGHT ALT");
-	}
-
-	// Left Alt (including VK_MENU without extended flag)
-	if (vkCode == VK_LMENU || vkCode == VK_MENU) { return std::string("LEFT ALT"); }
-
-	// Ctrl
-	if (vkCode == VK_LCONTROL) { return std::string("LEFT CTRL"); }
-	if (vkCode == VK_RCONTROL) { return std::string("RIGHT CTRL"); }
-
-	// Meta (Windows key)
-	if (vkCode == VK_LWIN) { return std::string("LEFT META"); }
-	if (vkCode == VK_RWIN) { return std::string("RIGHT META"); }
-
-	// Common keys
-	if (vkCode == VK_SPACE) { return std::string("SPACE"); }
-	if (vkCode == VK_RETURN) { return std::string("RETURN"); }
-	if (vkCode == VK_TAB) { return std::string("TAB"); }
-	if (vkCode == VK_BACK) { return std::string("BACKSPACE"); }
-	if (vkCode == VK_DELETE) { return std::string("DELETE"); }
-
-	// Arrow keys
-	if (vkCode == VK_LEFT) { return std::string("LEFT"); }
-	if (vkCode == VK_RIGHT) { return std::string("RIGHT"); }
-	if (vkCode == VK_UP) { return std::string("UP"); }
-	if (vkCode == VK_DOWN) { return std::string("DOWN"); }
-
-	// A-Z
-	if (vkCode >= 0x41 && vkCode <= 0x5A) {
-		char c = static_cast<char>(vkCode);
-		return std::string(1, c);
-	}
-
-	// 0-9
-	if (vkCode >= 0x30 && vkCode <= 0x39) {
-		char c = static_cast<char>(vkCode);
-		return std::string(1, c);
-	}
-
-	// Function keys F1-F12
-	if (vkCode >= VK_F1 && vkCode <= VK_F12) {
-		int n = static_cast<int>(vkCode - VK_F1) + 1;
-		return std::string("F") + std::to_string(n);
-	}
-
-	return std::nullopt;
-}
-
-static DWORD winResolveVkCode(const KBDLLHOOKSTRUCT* k) {
-	DWORD vkCode = k->vkCode;
-
-	// For modifier keys, the low-level hook can report generic VK_* values.
-	// Resolve them to stable left/right variants so key up can be matched reliably.
-	if (vkCode == VK_SHIFT) {
-		// Map scan code to extended virtual key to distinguish left/right shift.
-		const UINT mapped = MapVirtualKeyW(k->scanCode, MAPVK_VSC_TO_VK_EX);
-		if (mapped != 0) {
-			vkCode = mapped;
-		}
-	} else if (vkCode == VK_CONTROL) {
-		vkCode = (k->flags & LLKHF_EXTENDED) ? VK_RCONTROL : VK_LCONTROL;
-	} else if (vkCode == VK_MENU) {
-		vkCode = (k->flags & LLKHF_EXTENDED) ? VK_RMENU : VK_LMENU;
-	}
-
-	return vkCode;
-}
-
-static LRESULT CALLBACK LowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam) {
-	if (nCode == HC_ACTION && g_running.load()) {
-		const KBDLLHOOKSTRUCT* k = reinterpret_cast<KBDLLHOOKSTRUCT*>(lParam);
-		const DWORD vkCode = winResolveVkCode(k);
-		const DWORD flags = k->flags;
-
-		const bool isKeyMessage = (wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN || wParam == WM_KEYUP || wParam == WM_SYSKEYUP);
-		if (isKeyMessage) {
-			// For WH_KEYBOARD_LL, LLKHF_UP is the authoritative up/down indicator.
-			const bool isUp = (wParam == WM_KEYUP || wParam == WM_SYSKEYUP) || ((flags & LLKHF_UP) != 0);
-			const bool isDown = !isUp;
-			const auto name = winVkToName(vkCode, flags);
-			if (name.has_value()) {
-				emitKeyEvent(*name, isDown ? "DOWN" : "UP");
-				if (vkCode < g_down.size()) {
-					if (isDown) {
-						g_down[vkCode] = true;
-						g_lastFlags[vkCode] = flags;
-					} else {
-						g_down[vkCode] = false;
-						g_lastFlags[vkCode] = 0;
-					}
-				}
-			}
-		}
-	}
-
-	return CallNextHookEx(g_hook, nCode, wParam, lParam);
-}
-
-// Timer callback that posts a message to wake up the message loop
-static VOID CALLBACK winTimerProc(HWND /*hwnd*/, UINT /*uMsg*/, UINT_PTR /*idEvent*/, DWORD /*dwTime*/) {
-	// Post a custom message to ensure the message loop wakes up and processes polling
-	if (g_threadId != 0) {
-		PostThreadMessageW(g_threadId, WM_POLL_KEYS, 0, 0);
-	}
-}
-
-static void winThreadMain() {
-	g_threadId = GetCurrentThreadId();
-
-	g_hook = SetWindowsHookExW(WH_KEYBOARD_LL, LowLevelKeyboardProc, GetModuleHandleW(nullptr), 0);
-	if (!g_hook) {
-		g_running.store(false);
-		setStartResult(-1);
-		return;
-	}
-
-	// Use SetTimer with a callback to ensure reliable polling even when message queue is idle.
-	// The callback posts WM_POLL_KEYS to wake up GetMessageW.
-	// Interval of 50ms is sufficient for detecting missed key-up events while being efficient.
-	g_timerId = SetTimer(nullptr, 1, 50, winTimerProc);
-
-	setStartResult(1);
-
-	MSG msg;
-	// Use PeekMessage with PM_REMOVE in a loop with MsgWaitForMultipleObjects for better responsiveness.
-	// This ensures we can exit promptly when g_running becomes false.
-	while (g_running.load()) {
-		// Wait for messages with a timeout to allow periodic checks of g_running
-		DWORD waitResult = MsgWaitForMultipleObjects(0, nullptr, FALSE, 100, QS_ALLINPUT);
-
-		if (waitResult == WAIT_TIMEOUT) {
-			// Timeout - check g_running and poll for missed key-ups
-			winPollMissingKeyUps();
-			continue;
-		}
-
-		// Process all pending messages
-		while (PeekMessageW(&msg, nullptr, 0, 0, PM_REMOVE)) {
-			if (msg.message == WM_QUIT) {
-				g_running.store(false);
-				break;
-			}
-
-			if (msg.message == WM_POLL_KEYS) {
-				winPollMissingKeyUps();
-				continue;
-			}
-
-			// WM_TIMER messages from SetTimer with callback are handled by DispatchMessage
-			TranslateMessage(&msg);
-			DispatchMessageW(&msg);
-		}
-	}
-
-	if (g_timerId != 0) {
-		KillTimer(nullptr, g_timerId);
-		g_timerId = 0;
-	}
-
-	if (g_hook) {
-		UnhookWindowsHookEx(g_hook);
-		g_hook = nullptr;
-	}
-
-	g_down.fill(false);
-	g_lastFlags.fill(0);
-
-	g_threadId = 0;
-}
-
-} // namespace
-
-#else
-
-namespace {
-static void unsupportedThreadMain() {
-	g_running.store(false);
-	setStartResult(-1);
-}
-} // namespace
-
-#endif
-
-static Napi::Value Start(const Napi::CallbackInfo& info) {
-	Napi::Env env = info.Env();
-
-	if (info.Length() < 1 || !info[0].IsFunction()) {
-		Napi::TypeError::New(env, "Expected a callback function").ThrowAsJavaScriptException();
-		return Napi::Boolean::New(env, false);
-	}
-
-	std::lock_guard<std::mutex> lock(g_stateMutex);
-	if (g_running.load()) {
-		return Napi::Boolean::New(env, true);
-	}
-
-	Napi::Function cb = info[0].As<Napi::Function>();
-	g_tsfn = Napi::ThreadSafeFunction::New(
-		env,
-		cb,
-		"simen_keyboard_listener",
-		0,
-		1
-	);
-
-	{
-		std::lock_guard<std::mutex> startLock(g_startMutex);
-		g_startResult = 0;
-	}
-
-	g_running.store(true);
-
-#if defined(__APPLE__)
-	g_thread = std::thread(macThreadMain);
-#elif defined(_WIN32)
-	g_thread = std::thread(winThreadMain);
-#else
-	g_thread = std::thread(unsupportedThreadMain);
-#endif
-
-	{
-		std::unique_lock<std::mutex> startLock(g_startMutex);
-		g_startCv.wait_for(startLock, std::chrono::milliseconds(1500), []() { return g_startResult != 0; });
-	}
-
-	if (!g_running.load() || g_startResult != 1) {
-		g_running.store(false);
-
-#if defined(_WIN32)
-		if (g_threadId) {
-			PostThreadMessageW(g_threadId, WM_QUIT, 0, 0);
-		}
-#endif
-
-		if (g_thread.joinable()) {
-			g_thread.join();
-		}
-
-		if (g_tsfn) {
-			g_tsfn.Release();
-			g_tsfn = Napi::ThreadSafeFunction();
-		}
-
-		return Napi::Boolean::New(env, false);
-	}
-
-	return Napi::Boolean::New(env, true);
-}
-
-static Napi::Value Stop(const Napi::CallbackInfo& info) {
-	Napi::Env env = info.Env();
-
-	std::lock_guard<std::mutex> lock(g_stateMutex);
-	if (!g_running.load()) {
-		return env.Undefined();
-	}
-
-	g_running.store(false);
-
-#if defined(_WIN32)
-	if (g_threadId) {
-		PostThreadMessageW(g_threadId, WM_QUIT, 0, 0);
-	}
-#endif
-
-	if (g_thread.joinable()) {
-		g_thread.join();
-	}
-
-	if (g_tsfn) {
-		g_tsfn.Release();
-		g_tsfn = Napi::ThreadSafeFunction();
-	}
-
-	return env.Undefined();
-}
-
-static Napi::Value IsRunning(const Napi::CallbackInfo& info) {
-	return Napi::Boolean::New(info.Env(), g_running.load());
-}
-
-// Check if the app has permission to listen to global keyboard events
-// Returns: true if permission granted, false otherwise
-// On Windows, always returns true (no special permission needed)
-// On macOS, checks accessibility permission
-static Napi::Value CheckPermission(const Napi::CallbackInfo& info) {
-#if defined(__APPLE__)
-	return Napi::Boolean::New(info.Env(), macHasAccessibilityPermission());
-#elif defined(_WIN32)
-	// Windows doesn't require special permission for keyboard hooks
-	return Napi::Boolean::New(info.Env(), true);
-#else
-	return Napi::Boolean::New(info.Env(), false);
-#endif
-}
-
-static Napi::Object Init(Napi::Env env, Napi::Object exports) {
-	exports.Set("start", Napi::Function::New(env, Start));
-	exports.Set("stop", Napi::Function::New(env, Stop));
-	exports.Set("isRunning", Napi::Function::New(env, IsRunning));
-	exports.Set("checkPermission", Napi::Function::New(env, CheckPermission));
-	return exports;
-}
-
-NODE_API_MODULE(simen_keyboard_listener, Init)