// Package usb provides keyboard input handling via Linux evdev devices. package usb import ( "fmt" "os" "github.com/gvalkov/golang-evdev" ) // Key represents a keyboard key event. type Key struct { Code uint16 // Linux input event code Type string // "press", "release" } // Keyboard represents an input device (keyboard). type Keyboard struct { device *evdev.InputDevice } // ScanForDevices finds all keyboard devices in /dev/input/. func ScanForDevices() ([]*evdev.InputDevice, error) { keyboards := make([]*evdev.InputDevice, 0) devices, err := evdev.ListInputDevices("event*") if err != nil { return nil, fmt.Errorf("failed to list input devices: %w", err) } for _, dev := range devices { // Use CapabilitiesFlat which maps int event type to []int codes if dev.CapabilitiesFlat == nil { continue } keyCaps, ok := dev.CapabilitiesFlat[1] // EV_KEY = 1 if !ok || len(keyCaps) == 0 { continue } // Filter: only consider devices with standard keyboard keys hasSlash := false for _, code := range keyCaps { if code == 1 { // KEY_SLASH hasSlash = true break } } if hasSlash { keyboards = append(keyboards, dev) } } return keyboards, nil } // OpenKeyboard opens a keyboard device at the given path. func OpenKeyboard(devicePath string) (*Keyboard, error) { dev, err := evdev.Open(devicePath) if err != nil { return nil, fmt.Errorf("failed to open %s: %w", devicePath, err) } return &Keyboard{ device: dev, }, nil } // OpenFirstKeyboard opens the first available keyboard device. func OpenFirstKeyboard() (*Keyboard, error) { keyboards, err := ScanForDevices() if err != nil { return nil, err } if len(keyboards) == 0 { return nil, fmt.Errorf("no keyboard devices found in /dev/input/") } dev, err := evdev.Open(keyboards[0].Fn) if err != nil { return nil, fmt.Errorf("failed to open first keyboard %s: %w", keyboards[0].Fn, err) } fmt.Fprintf(os.Stderr, "[usb] Using keyboard: %s (%s)\n", dev.Name, dev.Fn) return &Keyboard{ device: dev, }, nil } // Close releases the keyboard device. func (kb *Keyboard) Close() error { if kb.device != nil { return kb.device.File.Close() } return nil } // ReadKey reads the next key event from the keyboard. // Returns a Key struct or an error. func (kb *Keyboard) ReadKey() (*Key, error) { event, err := kb.device.ReadOne() if err != nil { return nil, fmt.Errorf("failed to read event: %w", err) } if event.Type != 1 { // EV_KEY // Not a key event, try to read again return kb.ReadKey() } key := &Key{ Code: event.Code, Type: "press", } if event.Value == 0 { key.Type = "release" } return key, nil } // GetDeviceInfo returns information about the connected keyboard. func (kb *Keyboard) GetDeviceInfo() string { if kb.device == nil { return "no device" } return fmt.Sprintf("%s (%s)", kb.device.Name, kb.device.Fn) }