//go:build darwin
|
|
package hotkey
|
|
/*
|
#cgo CFLAGS: -x objective-c
|
#cgo LDFLAGS: -framework Cocoa -framework ApplicationServices
|
#import <Cocoa/Cocoa.h>
|
#include <ApplicationServices/ApplicationServices.h>
|
#include <pthread.h>
|
static volatile int g_keysDown[128];
|
static volatile double g_lastDownAt[128];
|
static volatile int g_monitorStarted = 0;
|
static volatile int g_monitorLaunching = 0;
|
static CFMachPortRef g_eventTap = NULL;
|
static CFRunLoopSourceRef g_eventTapSource = NULL;
|
static volatile unsigned long long g_monitorStartAttempts = 0;
|
static volatile unsigned long long g_eventTapCreateFailures = 0;
|
static volatile unsigned long long g_eventTapDisabledCount = 0;
|
static volatile unsigned long long g_altEventSeq[2];
|
static volatile int g_altEventDown[2];
|
static volatile int g_altEventType[2];
|
static volatile unsigned long long g_altEventFlags[2];
|
static volatile double g_altEventAt[2];
|
static id g_activityToken = nil;
|
|
static double nowSeconds(void) {
|
return CFAbsoluteTimeGetCurrent();
|
}
|
|
static void handleKeyEvent(unsigned short keyCode, BOOL isDown) {
|
if (keyCode >= 128) return;
|
g_keysDown[keyCode] = isDown ? 1 : 0;
|
if (isDown) g_lastDownAt[keyCode] = nowSeconds();
|
}
|
|
static int altIndexForKey(unsigned short keyCode) {
|
if (keyCode == 58) return 0; // L-Option
|
if (keyCode == 61) return 1; // R-Option
|
return -1;
|
}
|
|
static void recordAltEvent(unsigned short keyCode, int eventType, CGEventFlags flags) {
|
int index = altIndexForKey(keyCode);
|
if (index < 0) return;
|
g_altEventSeq[index]++;
|
g_altEventDown[index] = g_keysDown[keyCode] ? 1 : 0;
|
g_altEventType[index] = eventType;
|
g_altEventFlags[index] = flags;
|
g_altEventAt[index] = nowSeconds();
|
}
|
|
static unsigned long long modifierMaskForKey(unsigned short keyCode) {
|
switch (keyCode) {
|
case 59: // L-Ctrl
|
case 62: // R-Ctrl
|
return kCGEventFlagMaskControl;
|
case 58: // L-Option
|
case 61: // R-Option
|
return kCGEventFlagMaskAlternate;
|
case 56: // L-Shift
|
case 60: // R-Shift
|
return kCGEventFlagMaskShift;
|
case 55: // L-Command
|
case 54: // R-Command
|
return kCGEventFlagMaskCommand;
|
default:
|
return 0;
|
}
|
}
|
|
static void handleModifierEvent(unsigned short keyCode, CGEventFlags flags) {
|
if (keyCode >= 128) return;
|
|
unsigned long long mask = modifierMaskForKey(keyCode);
|
if (mask == 0) return;
|
|
BOOL physicalDown = CGEventSourceKeyState(kCGEventSourceStateHIDSystemState, (CGKeyCode)keyCode);
|
BOOL eventDown = (flags & mask) ? YES : NO;
|
handleKeyEvent(keyCode, (physicalDown || eventDown) ? YES : NO);
|
recordAltEvent(keyCode, 3, flags);
|
}
|
|
static CGEventRef keyboardEventTapCallback(CGEventTapProxy proxy, CGEventType type, CGEventRef event, void *refcon) {
|
if (type == kCGEventTapDisabledByTimeout || type == kCGEventTapDisabledByUserInput) {
|
g_eventTapDisabledCount++;
|
if (g_eventTap != NULL) CGEventTapEnable(g_eventTap, true);
|
return event;
|
}
|
|
if (type != kCGEventKeyDown && type != kCGEventKeyUp && type != kCGEventFlagsChanged) {
|
return event;
|
}
|
|
unsigned short keyCode = (unsigned short)CGEventGetIntegerValueField(event, kCGKeyboardEventKeycode);
|
if (type == kCGEventFlagsChanged) {
|
handleModifierEvent(keyCode, CGEventGetFlags(event));
|
} else {
|
handleKeyEvent(keyCode, type == kCGEventKeyDown);
|
recordAltEvent(keyCode, type == kCGEventKeyDown ? 1 : 2, CGEventGetFlags(event));
|
}
|
return event;
|
}
|
|
static void startEventTapMonitor(void) {
|
if (g_monitorStarted) {
|
g_monitorLaunching = 0;
|
return;
|
}
|
g_monitorStartAttempts++;
|
|
CGEventMask eventMask = CGEventMaskBit(kCGEventKeyDown) |
|
CGEventMaskBit(kCGEventKeyUp) |
|
CGEventMaskBit(kCGEventFlagsChanged);
|
|
g_eventTap = CGEventTapCreate(kCGHIDEventTap,
|
kCGHeadInsertEventTap,
|
kCGEventTapOptionListenOnly,
|
eventMask,
|
keyboardEventTapCallback,
|
NULL);
|
if (g_eventTap == NULL) {
|
g_eventTapCreateFailures++;
|
g_monitorLaunching = 0;
|
return;
|
}
|
|
g_eventTapSource = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, g_eventTap, 0);
|
if (g_eventTapSource == NULL) {
|
g_eventTapCreateFailures++;
|
CFRelease(g_eventTap);
|
g_eventTap = NULL;
|
g_monitorLaunching = 0;
|
return;
|
}
|
|
CFRunLoopAddSource(CFRunLoopGetCurrent(), g_eventTapSource, kCFRunLoopCommonModes);
|
CGEventTapEnable(g_eventTap, true);
|
g_monitorStarted = 1;
|
g_monitorLaunching = 0;
|
CFRunLoopRun();
|
g_monitorStarted = 0;
|
}
|
|
static int ensureAccessibility(void) {
|
NSDictionary* opts = @{(__bridge NSString*)kAXTrustedCheckOptionPrompt: @YES};
|
return AXIsProcessTrustedWithOptions((__bridge CFDictionaryRef)opts) ? 1 : 0;
|
}
|
|
static void beginHotkeyActivity(void) {
|
if (g_activityToken != nil) return;
|
g_activityToken = [[NSProcessInfo processInfo]
|
beginActivityWithOptions:NSActivityUserInitiatedAllowingIdleSystemSleep
|
reason:@"PrivateVoice Dictation global hotkey listener"];
|
}
|
|
static void* eventTapThreadMain(void* arg) {
|
(void)arg;
|
@autoreleasepool {
|
startEventTapMonitor();
|
}
|
g_monitorLaunching = 0;
|
return NULL;
|
}
|
|
static void startKeyMonitor(void) {
|
if (g_monitorStarted || g_monitorLaunching) return;
|
g_monitorLaunching = 1;
|
pthread_t thread;
|
int err = pthread_create(&thread, NULL, eventTapThreadMain, NULL);
|
if (err != 0) {
|
g_monitorLaunching = 0;
|
g_eventTapCreateFailures++;
|
return;
|
}
|
pthread_detach(thread);
|
}
|
|
// isModifierDown polls the current system modifier flags via CGEventSource.
|
// This works globally without needing event tap or NSEvent monitor callbacks.
|
static int isModifierDown(unsigned long long flagMask) {
|
CGEventFlags flags = CGEventSourceFlagsState(kCGEventSourceStateHIDSystemState);
|
return (flags & flagMask) ? 1 : 0;
|
}
|
|
static int isSideModifierDown(int keyCode) {
|
if (keyCode >= 0 && keyCode < 128) {
|
if (CGEventSourceKeyState(kCGEventSourceStateHIDSystemState, (CGKeyCode)keyCode)) return 1;
|
unsigned long long mask = modifierMaskForKey((unsigned short)keyCode);
|
int modifierDown = mask != 0 ? isModifierDown(mask) : 0;
|
double age = g_lastDownAt[keyCode] > 0 ? nowSeconds() - g_lastDownAt[keyCode] : 999.0;
|
if (g_keysDown[keyCode]) {
|
if (modifierDown) return 1;
|
if (age < 0.25) return 1;
|
g_keysDown[keyCode] = 0;
|
return 0;
|
}
|
if (age < 0.12) return 1;
|
}
|
return 0;
|
}
|
|
static int isKeyDown(int keyCode) {
|
if (keyCode >= 0 && keyCode < 128) {
|
if (CGEventSourceKeyState(kCGEventSourceStateHIDSystemState, (CGKeyCode)keyCode)) return 1;
|
if (g_keysDown[keyCode] && g_lastDownAt[keyCode] > 0 && nowSeconds() - g_lastDownAt[keyCode] < 0.25) return 1;
|
if (g_keysDown[keyCode]) g_keysDown[keyCode] = 0;
|
if (g_lastDownAt[keyCode] > 0 && nowSeconds() - g_lastDownAt[keyCode] < 0.12) return 1;
|
}
|
return 0;
|
}
|
|
static int isPhysicalKeyDown(int keyCode) {
|
if (keyCode < 0 || keyCode >= 128) return 0;
|
return CGEventSourceKeyState(kCGEventSourceStateHIDSystemState, (CGKeyCode)keyCode) ? 1 : 0;
|
}
|
|
static int isTrackedKeyDown(int keyCode) {
|
if (keyCode < 0 || keyCode >= 128) return 0;
|
return g_keysDown[keyCode] ? 1 : 0;
|
}
|
|
static int isRecentKeyDown(int keyCode) {
|
if (keyCode < 0 || keyCode >= 128 || g_lastDownAt[keyCode] <= 0) return 0;
|
return nowSeconds() - g_lastDownAt[keyCode] < 0.12 ? 1 : 0;
|
}
|
|
static double lastKeyDownAge(int keyCode) {
|
if (keyCode < 0 || keyCode >= 128 || g_lastDownAt[keyCode] <= 0) return -1;
|
return nowSeconds() - g_lastDownAt[keyCode];
|
}
|
|
static int isMonitorStarted(void) {
|
return g_monitorStarted;
|
}
|
|
static int isMonitorLaunching(void) {
|
return g_monitorLaunching;
|
}
|
|
static unsigned long long monitorStartAttempts(void) {
|
return g_monitorStartAttempts;
|
}
|
|
static unsigned long long eventTapCreateFailures(void) {
|
return g_eventTapCreateFailures;
|
}
|
|
static unsigned long long eventTapDisabledCount(void) {
|
return g_eventTapDisabledCount;
|
}
|
|
static unsigned long long altEventSeq(int index) {
|
if (index < 0 || index > 1) return 0;
|
return g_altEventSeq[index];
|
}
|
|
static int altEventDown(int index) {
|
if (index < 0 || index > 1) return 0;
|
return g_altEventDown[index];
|
}
|
|
static int altEventType(int index) {
|
if (index < 0 || index > 1) return 0;
|
return g_altEventType[index];
|
}
|
|
static unsigned long long altEventFlags(int index) {
|
if (index < 0 || index > 1) return 0;
|
return g_altEventFlags[index];
|
}
|
|
static double altEventAge(int index) {
|
if (index < 0 || index > 1 || g_altEventAt[index] <= 0) return -1;
|
return nowSeconds() - g_altEventAt[index];
|
}
|
*/
|
import "C"
|
|
import (
|
"fmt"
|
"time"
|
"voicesnap/internal/logger"
|
)
|
|
// macOS modifier flag masks for CGEventSourceFlagsState polling.
|
const (
|
maskControl = 0x40000 // kCGEventFlagMaskControl
|
maskShift = 0x20000 // kCGEventFlagMaskShift
|
maskOption = 0x80000 // kCGEventFlagMaskAlternate
|
maskCommand = 0x100000 // kCGEventFlagMaskCommand
|
maskCapsLock = 0x10000 // kCGEventFlagMaskAlphaShift
|
)
|
|
// Generic modifier VK codes use flag polling; left/right variants use physical
|
// key polling because CGEvent modifier flags do not distinguish sides.
|
var vkToFlagMask = map[int]C.ulonglong{
|
0x11: maskControl, // Ctrl
|
0x12: maskOption, // Alt
|
0x10: maskShift, // Shift
|
0x14: maskCapsLock, // Caps Lock
|
0x5B: maskCommand, // Cmd
|
0x5C: maskCommand, // Cmd
|
}
|
|
var vkToPhysicalModifier = map[int]int{
|
0xA2: 59, // L-Ctrl
|
0xA3: 62, // R-Ctrl
|
0xA4: 58, // L-Alt / Option
|
0xA5: 61, // R-Alt / Option
|
0xA0: 56, // L-Shift
|
0xA1: 60, // R-Shift
|
0x5B: 55, // L-Cmd
|
0x5C: 54, // R-Cmd
|
}
|
|
// macOS key code mapping for non-modifier keys.
|
var vkToMac = map[int]int{
|
0x20: 0x31, // Space
|
0x09: 0x30, // Tab
|
0x0D: 0x24, // Enter/Return
|
0x1B: 0x35, // Esc
|
}
|
|
type darwinListener struct {
|
lastAltSeq map[int]uint64
|
lastAltState map[int]bool
|
lastMonitorRetry time.Time
|
}
|
|
func newPlatformListener() Listener {
|
C.beginHotkeyActivity()
|
trusted := C.ensureAccessibility()
|
if trusted == 0 {
|
logger.Info("Accessibility permission not granted for current app identity — hotkey won't work until PrivateVoice Dictation is removed and re-added in System Settings > Privacy & Security > Accessibility")
|
} else {
|
logger.Info("Accessibility permission granted")
|
}
|
C.startKeyMonitor()
|
deadline := time.Now().Add(time.Second)
|
for C.isMonitorStarted() == 0 && C.isMonitorLaunching() != 0 && time.Now().Before(deadline) {
|
time.Sleep(50 * time.Millisecond)
|
}
|
if C.isMonitorStarted() == 0 {
|
logger.Error(
|
"Keyboard event tap not running yet; attempts=%d failures=%d launching=%t. Physical hotkey polling fallback is enabled.",
|
uint64(C.monitorStartAttempts()),
|
uint64(C.eventTapCreateFailures()),
|
C.isMonitorLaunching() != 0,
|
)
|
} else {
|
logger.Info(
|
"Keyboard event tap started; attempts=%d failures=%d disabled=%d",
|
uint64(C.monitorStartAttempts()),
|
uint64(C.eventTapCreateFailures()),
|
uint64(C.eventTapDisabledCount()),
|
)
|
}
|
return &darwinListener{
|
lastAltSeq: map[int]uint64{},
|
lastAltState: map[int]bool{},
|
lastMonitorRetry: time.Now(),
|
}
|
}
|
|
func (l *darwinListener) IsKeyDown(vk int) bool {
|
l.retryMonitorIfNeeded()
|
if keyCode, ok := vkToPhysicalModifier[vk]; ok {
|
down := C.isSideModifierDown(C.int(keyCode)) != 0
|
l.logAltDiagnostics(vk, keyCode, down)
|
return down
|
}
|
// Generic modifier keys: poll system flags directly.
|
if mask, ok := vkToFlagMask[vk]; ok {
|
return C.isModifierDown(mask) != 0
|
}
|
// Regular keys: check NSEvent-tracked state
|
macKey, ok := vkToMac[vk]
|
if !ok {
|
if vk >= 0x41 && vk <= 0x5A {
|
macKey = vkToMacAlpha(vk)
|
} else {
|
return false
|
}
|
}
|
return C.isKeyDown(C.int(macKey)) != 0
|
}
|
|
func (l *darwinListener) retryMonitorIfNeeded() {
|
if C.isMonitorStarted() != 0 || C.isMonitorLaunching() != 0 {
|
return
|
}
|
if time.Since(l.lastMonitorRetry) < 10*time.Second {
|
return
|
}
|
l.lastMonitorRetry = time.Now()
|
logger.Info(
|
"Keyboard event tap retry requested; attempts=%d failures=%d disabled=%d",
|
uint64(C.monitorStartAttempts()),
|
uint64(C.eventTapCreateFailures()),
|
uint64(C.eventTapDisabledCount()),
|
)
|
C.startKeyMonitor()
|
}
|
|
func (l *darwinListener) logAltDiagnostics(vk, keyCode int, down bool) {
|
index := altDiagnosticIndex(keyCode)
|
if index < 0 {
|
return
|
}
|
|
physicalDown := C.isPhysicalKeyDown(C.int(keyCode)) != 0
|
trackedDown := C.isTrackedKeyDown(C.int(keyCode)) != 0
|
recentDown := C.isRecentKeyDown(C.int(keyCode)) != 0
|
|
seq := uint64(C.altEventSeq(C.int(index)))
|
if seq != l.lastAltSeq[vk] {
|
l.lastAltSeq[vk] = seq
|
logger.Info(
|
"Hotkey event tap: key=%s vk=0x%X keyCode=%d seq=%d event=%s eventDown=%t pollDown=%t physicalDown=%t trackedDown=%t recentDown=%t flags=0x%X age=%.3fs tapStarted=%t",
|
GetKeyName(vk),
|
vk,
|
keyCode,
|
seq,
|
altEventTypeName(int(C.altEventType(C.int(index)))),
|
C.altEventDown(C.int(index)) != 0,
|
down,
|
physicalDown,
|
trackedDown,
|
recentDown,
|
uint64(C.altEventFlags(C.int(index))),
|
float64(C.altEventAge(C.int(index))),
|
C.isMonitorStarted() != 0,
|
)
|
}
|
|
if previous, ok := l.lastAltState[vk]; !ok || previous != down {
|
l.lastAltState[vk] = down
|
logger.Info(
|
"Hotkey poll: key=%s vk=0x%X keyCode=%d down=%t source=%s physicalDown=%t trackedDown=%t recentDown=%t tapStarted=%t",
|
GetKeyName(vk),
|
vk,
|
keyCode,
|
down,
|
hotkeySource(down, physicalDown, trackedDown, recentDown),
|
physicalDown,
|
trackedDown,
|
recentDown,
|
C.isMonitorStarted() != 0,
|
)
|
}
|
}
|
|
func hotkeySource(down, physicalDown, trackedDown, recentDown bool) string {
|
switch {
|
case !down:
|
return "none"
|
case physicalDown:
|
return "physical"
|
case trackedDown:
|
return "eventTap"
|
case recentDown:
|
return "recent"
|
default:
|
return "unknown"
|
}
|
}
|
|
func altDiagnosticIndex(keyCode int) int {
|
switch keyCode {
|
case 58:
|
return 0
|
case 61:
|
return 1
|
default:
|
return -1
|
}
|
}
|
|
func altEventTypeName(eventType int) string {
|
switch eventType {
|
case 1:
|
return "keyDown"
|
case 2:
|
return "keyUp"
|
case 3:
|
return "flagsChanged"
|
default:
|
return fmt.Sprintf("unknown(%d)", eventType)
|
}
|
}
|
|
func (l *darwinListener) IsAnyOtherKeyPressed(excludeVK int) bool {
|
return l.IsAnyOtherKeyPressedSince(excludeVK, time.Time{})
|
}
|
|
func (l *darwinListener) IsAnyOtherKeyPressedSince(excludeVK int, since time.Time) bool {
|
excludeGroup := modifierGroup(excludeVK)
|
|
modifiers := []int{0x11, 0xA2, 0xA3, 0x12, 0xA4, 0xA5, 0x10, 0xA0, 0xA1}
|
for _, k := range modifiers {
|
if k == excludeVK {
|
continue
|
}
|
if excludeGroup != 0 && modifierGroup(k) == excludeGroup {
|
continue
|
}
|
if l.wasPressedSince(k, since) {
|
logger.Info("Hotkey combination source: key=%s vk=0x%X", GetKeyName(k), k)
|
return true
|
}
|
}
|
for vk := 0x41; vk <= 0x5A; vk++ {
|
if vk == excludeVK {
|
continue
|
}
|
if l.wasPressedSince(vk, since) {
|
logger.Info("Hotkey combination source: key=%s vk=0x%X", GetKeyName(vk), vk)
|
return true
|
}
|
}
|
return false
|
}
|
|
func (l *darwinListener) wasPressedSince(vk int, since time.Time) bool {
|
if since.IsZero() {
|
return l.IsKeyDown(vk)
|
}
|
|
keyCode, ok := macKeyCodeForVK(vk)
|
if !ok {
|
return false
|
}
|
age := float64(C.lastKeyDownAge(C.int(keyCode)))
|
if age < 0 {
|
return false
|
}
|
return time.Since(since).Seconds()-age >= -0.02
|
}
|
|
func modifierGroup(vk int) int {
|
switch vk {
|
case 0x11, 0xA2, 0xA3:
|
return 1
|
case 0x12, 0xA4, 0xA5:
|
return 2
|
case 0x10, 0xA0, 0xA1:
|
return 3
|
default:
|
return 0
|
}
|
}
|
|
func isGenericModifier(vk int) bool {
|
return vk == 0x11 || vk == 0x12 || vk == 0x10
|
}
|
|
func vkToMacAlpha(vk int) int {
|
alphaMap := map[int]int{
|
0x41: 0x00, 0x42: 0x0B, 0x43: 0x08, 0x44: 0x02,
|
0x45: 0x0E, 0x46: 0x03, 0x47: 0x05, 0x48: 0x04,
|
0x49: 0x22, 0x4A: 0x26, 0x4B: 0x28, 0x4C: 0x25,
|
0x4D: 0x2E, 0x4E: 0x2D, 0x4F: 0x1F, 0x50: 0x23,
|
0x51: 0x0C, 0x52: 0x0F, 0x53: 0x01, 0x54: 0x11,
|
0x55: 0x20, 0x56: 0x09, 0x57: 0x0D, 0x58: 0x07,
|
0x59: 0x10, 0x5A: 0x06,
|
}
|
if code, ok := alphaMap[vk]; ok {
|
return code
|
}
|
return 0
|
}
|
|
func macKeyCodeForVK(vk int) (int, bool) {
|
if keyCode, ok := vkToPhysicalModifier[vk]; ok {
|
return keyCode, true
|
}
|
if keyCode, ok := vkToMac[vk]; ok {
|
return keyCode, true
|
}
|
if vk >= 0x41 && vk <= 0x5A {
|
return vkToMacAlpha(vk), true
|
}
|
return 0, false
|
}
|
