crossmate

HardwareKeyboardInputView.swift (9264B)

---

 import SwiftUI
 import UIKit
 
 struct HardwareKeyboardEvent {
     let keyCode: UIKeyboardHIDUsage
     let charactersIgnoringModifiers: String
     let modifierFlags: UIKeyModifierFlags
 }
 
 struct HardwareKeyboardInputView: UIViewRepresentable {
     private static let suspendCaptureNotification = Notification.Name(
         "HardwareKeyboardInputView.suspendCapture"
     )
     private static let resumeCaptureNotification = Notification.Name(
         "HardwareKeyboardInputView.resumeCapture"
     )
     @MainActor private static var isCaptureSuspended = false
 
     var onPress: (HardwareKeyboardEvent) -> Bool
     /// When false, the capture view relinquishes first responder so another
     /// view (the rebus text field) can own input and raise the system keyboard.
     var isActive: Bool = true
 
     func makeUIView(context: Context) -> KeyCaptureView {
         let view = KeyCaptureView()
         view.onPress = onPress
         view.setActive(isActive)
         return view
     }
 
     func updateUIView(_ uiView: KeyCaptureView, context: Context) {
         uiView.onPress = onPress
         uiView.setActive(isActive)
     }
 
     /// Temporarily yields hardware-keyboard ownership to UIKit content
     /// presented above the puzzle, such as the Save to Files filename field.
     @MainActor static func setCaptureSuspended(_ suspended: Bool) {
         isCaptureSuspended = suspended
         NotificationCenter.default.post(
             name: suspended ? suspendCaptureNotification : resumeCaptureNotification,
             object: nil
         )
     }
 
     final class KeyCaptureView: UIView {
         var onPress: ((HardwareKeyboardEvent) -> Bool)?
         private var isActive = true
         private var isSuspended = false
 
         override init(frame: CGRect) {
             super.init(frame: frame)
             isSuspended = HardwareKeyboardInputView.isCaptureSuspended
             observeCaptureNotifications()
         }
 
         required init?(coder: NSCoder) {
             super.init(coder: coder)
             isSuspended = HardwareKeyboardInputView.isCaptureSuspended
             observeCaptureNotifications()
         }
 
         deinit {
             NotificationCenter.default.removeObserver(self)
         }
 
         override var canBecomeFirstResponder: Bool { true }
 
         override var keyCommands: [UIKeyCommand]? {
             let letters = "abcdefghijklmnopqrstuvwxyz".map {
                 UIKeyCommand(
                     input: String($0),
                     modifierFlags: [],
                     action: #selector(handleKeyCommand(_:))
                 )
             }
 
             let digits = "0123456789".map {
                 UIKeyCommand(
                     input: String($0),
                     modifierFlags: [],
                     action: #selector(handleKeyCommand(_:))
                 )
             }
 
             // Undo/redo (⌘Z, ⇧⌘Z) are vended by the app menu (PuzzleCommands) so
             // they show in the hold-⌘ shortcut overlay; leaving them out here
             // lets those presses bubble up to that menu command.
             return letters + digits + [
                 UIKeyCommand(input: UIKeyCommand.inputLeftArrow, modifierFlags: [], action: #selector(handleKeyCommand(_:))),
                 UIKeyCommand(input: UIKeyCommand.inputRightArrow, modifierFlags: [], action: #selector(handleKeyCommand(_:))),
                 UIKeyCommand(input: UIKeyCommand.inputLeftArrow, modifierFlags: .command, action: #selector(handleKeyCommand(_:))),
                 UIKeyCommand(input: UIKeyCommand.inputRightArrow, modifierFlags: .command, action: #selector(handleKeyCommand(_:))),
                 UIKeyCommand(input: UIKeyCommand.inputUpArrow, modifierFlags: [], action: #selector(handleKeyCommand(_:))),
                 UIKeyCommand(input: UIKeyCommand.inputDownArrow, modifierFlags: [], action: #selector(handleKeyCommand(_:))),
                 UIKeyCommand(input: "\u{8}", modifierFlags: [], action: #selector(handleKeyCommand(_:))),
                 UIKeyCommand(input: "\u{7F}", modifierFlags: [], action: #selector(handleKeyCommand(_:))),
                 UIKeyCommand(input: "\t", modifierFlags: [], action: #selector(handleKeyCommand(_:))),
                 UIKeyCommand(input: "\t", modifierFlags: .shift, action: #selector(handleKeyCommand(_:))),
                 UIKeyCommand(input: " ", modifierFlags: [], action: #selector(handleKeyCommand(_:))),
                 UIKeyCommand(input: "\r", modifierFlags: [], action: #selector(handleKeyCommand(_:))),
                 UIKeyCommand(input: UIKeyCommand.inputEscape, modifierFlags: [], action: #selector(handleKeyCommand(_:)))
             ]
         }
 
         override func didMoveToWindow() {
             super.didMoveToWindow()
             ensureFirstResponder()
         }
 
         func setActive(_ active: Bool) {
             isActive = active
             if active {
                 ensureFirstResponder()
             } else if isFirstResponder {
                 resignFirstResponder()
             }
         }
 
         func ensureFirstResponder() {
             guard isActive, !isSuspended, window != nil, !isFirstResponder else { return }
             Task { @MainActor in
                 guard self.isActive,
                       !self.isSuspended,
                       self.window != nil,
                       !self.isFirstResponder else { return }
                 self.becomeFirstResponder()
             }
         }
 
         private func observeCaptureNotifications() {
             NotificationCenter.default.addObserver(
                 self,
                 selector: #selector(suspendCapture),
                 name: HardwareKeyboardInputView.suspendCaptureNotification,
                 object: nil
             )
             NotificationCenter.default.addObserver(
                 self,
                 selector: #selector(resumeCapture),
                 name: HardwareKeyboardInputView.resumeCaptureNotification,
                 object: nil
             )
         }
 
         @objc private func suspendCapture() {
             isSuspended = true
             if isFirstResponder {
                 resignFirstResponder()
             }
         }
 
         @objc private func resumeCapture() {
             isSuspended = false
             ensureFirstResponder()
         }
 
         override func pressesBegan(_ presses: Set<UIPress>, with event: UIPressesEvent?) {
             var unhandled: [UIPress] = []
 
             for press in presses {
                 guard let key = press.key else {
                     unhandled.append(press)
                     continue
                 }
 
                 let event = HardwareKeyboardEvent(
                     keyCode: key.keyCode,
                     charactersIgnoringModifiers: key.charactersIgnoringModifiers,
                     modifierFlags: key.modifierFlags
                 )
 
                 if onPress?(event) != true {
                     unhandled.append(press)
                 }
             }
 
             if !unhandled.isEmpty {
                 super.pressesBegan(Set(unhandled), with: event)
             }
         }
 
         @objc private func handleKeyCommand(_ command: UIKeyCommand) {
             guard let event = HardwareKeyboardEvent(
                 characters: command.input ?? "",
                 modifierFlags: command.modifierFlags
             ) else { return }
             _ = onPress?(event)
         }
     }
 }
 
 private extension HardwareKeyboardEvent {
     init?(characters: String, modifierFlags: UIKeyModifierFlags) {
         let keyCode: UIKeyboardHIDUsage
 
         switch characters {
         case UIKeyCommand.inputLeftArrow:
             keyCode = .keyboardLeftArrow
         case UIKeyCommand.inputRightArrow:
             keyCode = .keyboardRightArrow
         case UIKeyCommand.inputUpArrow:
             keyCode = .keyboardUpArrow
         case UIKeyCommand.inputDownArrow:
             keyCode = .keyboardDownArrow
         case UIKeyCommand.inputEscape:
             keyCode = .keyboardEscape
         case "\u{8}":
             keyCode = .keyboardDeleteOrBackspace
         case "\u{7F}":
             keyCode = .keyboardDeleteForward
         case "\t":
             keyCode = .keyboardTab
         case " ":
             keyCode = .keyboardSpacebar
         case "\r":
             keyCode = .keyboardReturnOrEnter
         case "a"..."z", "A"..."Z":
             guard let scalar = characters.uppercased().unicodeScalars.first,
                   let code = UIKeyboardHIDUsage(rawValue: Int(scalar.value - 65) + UIKeyboardHIDUsage.keyboardA.rawValue) else {
                 return nil
             }
             keyCode = code
         case "1"..."9":
             // HID usages run keyboard1…keyboard9 contiguously (keyboard0 sits
             // after, handled separately below).
             guard let digit = characters.first?.wholeNumberValue,
                   let code = UIKeyboardHIDUsage(rawValue: UIKeyboardHIDUsage.keyboard1.rawValue + (digit - 1)) else {
                 return nil
             }
             keyCode = code
         case "0":
             keyCode = .keyboard0
         default:
             return nil
         }
 
         self.init(
             keyCode: keyCode,
             charactersIgnoringModifiers: characters,
             modifierFlags: modifierFlags
         )
     }
 }