keylock/Sources/EventHandler.swift at main · kfv/keylock · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
import Foundation
import CoreGraphics

enum KeyCode: CGKeyCode {
    case u = 0x20
}

class EventHandler {
    var debug: Bool
    var isLocked = true

    init(debug: Bool) {
        self.debug = debug
    }

    func debugLog(_ message: String) {
        if debug {
            print(message)
        }
    }

    func scheduleTimer(duration: Int?) {
        guard let duration = duration else { return }
        let timer = Timer(timeInterval: TimeInterval(duration),
                          repeats: false) { _ in
            let message = "Timer expired ⏱️\n"
            if let data = message.data(using: .utf8) {
                FileHandle.standardError.write(data)
            }

            CFRunLoopStop(CFRunLoopGetCurrent())
        }
        RunLoop.current.add(timer, forMode: .common)
    }


    func run() {
        print("""

        ╭────────────────────────────────────────╮
        │                                        │
        │          Input Devices Locked          │
        │                                        │
        │        Press Ctrl + U to Unlock        │
        │                                        │
        ╰────────────────────────────────────────╯

        """)
        setupEventTap() // Setup event tap to capture key events
        CFRunLoopRun()  // Start the run loop to handle events
    }

    private func setupEventTap() {
        let keyboardEvents = (1 << CGEventType.keyDown.rawValue) |
                             (1 << CGEventType.keyUp.rawValue)

        let mouseClickEvents = (1 << CGEventType.leftMouseDown.rawValue)  |
                               (1 << CGEventType.leftMouseUp.rawValue)    |
                               (1 << CGEventType.rightMouseDown.rawValue) |
                               (1 << CGEventType.rightMouseUp.rawValue)

        let mouseMotionEvents = (1 << CGEventType.mouseMoved.rawValue) |
                                (1 << CGEventType.scrollWheel.rawValue)

        let mouseDragEvents = (1 << CGEventType.leftMouseDragged.rawValue)  |
                              (1 << CGEventType.rightMouseDragged.rawValue) |
                              (1 << CGEventType.otherMouseDragged.rawValue)

        let mouseOtherEvents = (1 << CGEventType.otherMouseDown.rawValue) |
                               (1 << CGEventType.otherMouseUp.rawValue)

        let eventMask = CGEventMask(keyboardEvents    |
                                    mouseClickEvents  |
                                    mouseMotionEvents |
                                    mouseDragEvents   |
                                    mouseOtherEvents)

        guard let eventTap = CGEvent.tapCreate(
            tap: .cghidEventTap,
            place: .headInsertEventTap,
            options: .defaultTap,
            eventsOfInterest: eventMask,
            callback: globalKeyEventHandler,
            userInfo: UnsafeMutableRawPointer(Unmanaged
                .passUnretained(self)
                .toOpaque())
        ) else {
            fatalError("Failed to create event tap")
        }

        let runLoopSource = CFMachPortCreateRunLoopSource(
            kCFAllocatorDefault,
            eventTap,
            0)
        CFRunLoopAddSource(CFRunLoopGetCurrent(), runLoopSource, .commonModes)
        CGEvent.tapEnable(tap: eventTap, enable: true)
    }

    func handleKeyEvent(
        proxy: CGEventTapProxy,
        type: CGEventType,
        event: CGEvent) -> Unmanaged<CGEvent>? {

        if type == .keyDown || type == .keyUp {
            let keyCode = event.getIntegerValueField(.keyboardEventKeycode)
            let controlFlag = event.flags.contains(.maskControl)
            let eventType = type == .keyDown ? "pressed" : "released"

            debugLog("Key Code: \(keyCode),\t" +
                     "Control Flag: \(controlFlag),\t" +
                     "Event Type: (\(type.rawValue)) \(eventType)")

            if controlFlag && keyCode == KeyCode.u.rawValue && type == .keyDown {
                debugLog("Input devices unlocked")
                CFRunLoopStop(CFRunLoopGetCurrent())
            }
        } else {
            let eventType = switch type {
                case .leftMouseDown: "left pressed"
                case .leftMouseUp: "left released"
                case .rightMouseDown: "right pressed"
                case .rightMouseUp: "right released"
                case .mouseMoved: "moved"
                case .scrollWheel: "scrolled"
                default: "other"
            }
            debugLog("Mouse Event: (\(type.rawValue)) \(eventType)")
        }

        return isLocked ? nil : Unmanaged.passRetained(event)
    }
}

func globalKeyEventHandler(
    proxy: CGEventTapProxy,
    type: CGEventType,
    event: CGEvent,
    refcon: UnsafeMutableRawPointer?) -> Unmanaged<CGEvent>? {
    guard let refcon = refcon else { return Unmanaged.passRetained(event) }
    let mySelf = Unmanaged<EventHandler>.fromOpaque(refcon).takeUnretainedValue()
    return mySelf.handleKeyEvent(proxy: proxy, type: type, event: event)
}