static void
set_abs(struct libevdev *dev, unsigned int changes,
unsigned int axis, struct input_absinfo *absinfo)
{
int rc;
struct input_absinfo abs;
const struct input_absinfo *a;
if ((a = libevdev_get_abs_info(dev, axis)) == NULL) {
fprintf(stderr,
"Device '%s' doesn't have axis %s\n",
libevdev_get_name(dev),
libevdev_event_code_get_name(EV_ABS, axis));
return;
}
abs = *a;
if (changes & OPT_MIN)
abs.minimum = absinfo->minimum;
if (changes & OPT_MAX)
abs.maximum = absinfo->maximum;
if (changes & OPT_FUZZ)
abs.fuzz = absinfo->fuzz;
if (changes & OPT_FLAT)
abs.flat = absinfo->flat;
if (changes & OPT_RES)
abs.resolution = absinfo->resolution;
rc = libevdev_kernel_set_abs_info(dev, axis, &abs);
if (rc != 0)
fprintf(stderr,
"Failed to set absinfo %s: %s",
libevdev_event_code_get_name(EV_ABS, axis),
strerror(-rc));
}
END_TEST
START_TEST(test_code_syn_name)
{
ck_assert_str_eq(libevdev_event_code_get_name(EV_SYN, SYN_REPORT), "SYN_REPORT");
ck_assert_str_eq(libevdev_event_code_get_name(EV_SYN, SYN_CONFIG), "SYN_CONFIG");
ck_assert_str_eq(libevdev_event_code_get_name(EV_SYN, SYN_MT_REPORT), "SYN_MT_REPORT");
ck_assert_str_eq(libevdev_event_code_get_name(EV_SYN, SYN_DROPPED), "SYN_DROPPED");
/* there is no SYN_MAX */
}
END_TEST
START_TEST(test_code_snd_name)
{
/* pick out a few only */
ck_assert_str_eq(libevdev_event_code_get_name(EV_SND, SND_CLICK), "SND_CLICK");
ck_assert_str_eq(libevdev_event_code_get_name(EV_SND, SND_TONE), "SND_TONE");
ck_assert_str_eq(libevdev_event_code_get_name(EV_SND, SND_MAX), "SND_MAX");
ck_assert(libevdev_event_code_get_name(EV_SND, SND_MAX - 1) == NULL);
}
END_TEST
START_TEST(test_code_led_name)
{
/* pick out a few only */
ck_assert_str_eq(libevdev_event_code_get_name(EV_LED, LED_NUML), "LED_NUML");
ck_assert_str_eq(libevdev_event_code_get_name(EV_LED, LED_KANA), "LED_KANA");
ck_assert_str_eq(libevdev_event_code_get_name(EV_LED, LED_MAX), "LED_MAX");
ck_assert(libevdev_event_code_get_name(EV_LED, LED_MAX - 1) == NULL);
}
END_TEST
START_TEST(test_code_rel_name)
{
/* pick out a few only */
ck_assert_str_eq(libevdev_event_code_get_name(EV_REL, REL_X), "REL_X");
ck_assert_str_eq(libevdev_event_code_get_name(EV_REL, REL_Y), "REL_Y");
ck_assert_str_eq(libevdev_event_code_get_name(EV_REL, REL_MISC), "REL_MISC");
ck_assert_str_eq(libevdev_event_code_get_name(EV_REL, REL_MAX), "REL_MAX");
ck_assert(libevdev_event_code_get_name(EV_REL, REL_MAX - 1) == NULL);
}
END_TEST
START_TEST(test_code_ff_name)
{
/* pick out a few only */
ck_assert_str_eq(libevdev_event_code_get_name(EV_FF, FF_STATUS_STOPPED), "FF_STATUS_STOPPED");
ck_assert_str_eq(libevdev_event_code_get_name(EV_FF, FF_FRICTION), "FF_FRICTION");
ck_assert_str_eq(libevdev_event_code_get_name(EV_FF, FF_CUSTOM), "FF_CUSTOM");
ck_assert_str_eq(libevdev_event_code_get_name(EV_FF, FF_MAX), "FF_MAX");
ck_assert(libevdev_event_code_get_name(EV_FF, FF_MAX - 1) == NULL);
}
END_TEST
START_TEST(test_code_sw_name)
{
/* pick out a few only */
ck_assert_str_eq(libevdev_event_code_get_name(EV_SW, SW_LID), "SW_LID");
ck_assert_str_eq(libevdev_event_code_get_name(EV_SW, SW_RFKILL_ALL), "SW_RFKILL_ALL");
ck_assert_str_eq(libevdev_event_code_get_name(EV_SW, SW_LINEIN_INSERT), "SW_LINEIN_INSERT");
ck_assert_str_eq(libevdev_event_code_get_name(EV_SW, SW_MAX), "SW_MAX");
ck_assert(libevdev_event_code_get_name(EV_SW, SW_MAX - 1) == NULL);
}
END_TEST
START_TEST(test_code_msc_name)
{
/* pick out a few only */
ck_assert_str_eq(libevdev_event_code_get_name(EV_MSC, MSC_SERIAL), "MSC_SERIAL");
ck_assert_str_eq(libevdev_event_code_get_name(EV_MSC, MSC_RAW), "MSC_RAW");
#ifdef MSC_TIMESTAMP
ck_assert_str_eq(libevdev_event_code_get_name(EV_MSC, MSC_TIMESTAMP), "MSC_TIMESTAMP");
#endif
ck_assert_str_eq(libevdev_event_code_get_name(EV_MSC, MSC_MAX), "MSC_MAX");
ck_assert(libevdev_event_code_get_name(EV_MSC, MSC_MAX - 1) == NULL);
}
int
touchpad_handle_event(struct touchpad *tp,
void *userdata,
const struct input_event *ev)
{
int rc = 0;
#if 0
printf("%s %s: %d\n", libevdev_event_type_get_name(ev->type),
libevdev_event_code_get_name(ev->type, ev->code),
ev->value);
#endif
switch(ev->type) {
case EV_ABS:
touchpad_update_abs_state(tp, ev);
break;
case EV_KEY:
touchpad_update_button_state(tp, ev);
break;
/* we never get a SYN_DROPPED, it's filtered higer up */
case EV_SYN:
touchpad_pre_process_touches(tp);
touchpad_post_events(tp, userdata);
touchpad_post_process_touches(tp);
break;
}
return rc;
}
int
tp_process_button(struct tp_dispatch *tp,
const struct input_event *e,
uint64_t time)
{
struct libinput *libinput = tp_libinput_context(tp);
uint32_t mask = 1 << (e->code - BTN_LEFT);
/* Ignore other buttons on clickpads */
if (tp->buttons.is_clickpad && e->code != BTN_LEFT) {
log_bug_kernel(libinput,
"received %s button event on a clickpad\n",
libevdev_event_code_get_name(EV_KEY, e->code));
return 0;
}
if (e->value) {
tp->buttons.state |= mask;
tp->queued |= TOUCHPAD_EVENT_BUTTON_PRESS;
} else {
tp->buttons.state &= ~mask;
tp->queued |= TOUCHPAD_EVENT_BUTTON_RELEASE;
}
return 0;
}
static void
set_led(struct libevdev *dev, unsigned int led, int led_state)
{
int rc;
enum libevdev_led_value state =
led_state ? LIBEVDEV_LED_ON : LIBEVDEV_LED_OFF;
if (!libevdev_has_event_code(dev, EV_LED, led)) {
fprintf(stderr,
"Device '%s' doesn't have %s\n",
libevdev_get_name(dev),
libevdev_event_code_get_name(EV_LED, led));
return;
}
rc = libevdev_kernel_set_led_value(dev, led, state);
if (rc != 0)
fprintf(stderr,
"Failed to set LED %s: %s",
libevdev_event_code_get_name(EV_LED, led),
strerror(-rc));
}
std::string evdevDevice::Button::GetName() const
{
// Buttons below 0x100 are mostly keyboard keys, and the names make sense
if (m_code < 0x100)
{
const char* name = libevdev_event_code_get_name(EV_KEY, m_code);
if (name)
return StripSpaces(name);
}
// But controllers use codes above 0x100, and the standard label often doesn't match.
// We are better off with Button 0 and so on.
return "Button " + std::to_string(m_index);
}
static int forward_event(struct libevdev_uinput *uidev, struct input_event *ev, struct chord* state)
{
int ret;
enum touch t = NUM_TOUCHES;
switch(ev->code){
case KEY_A: t = TOUCH_A; break;
case KEY_S: t = TOUCH_S; break;
case KEY_D: t = TOUCH_E; break;
case KEY_F: t = TOUCH_T; break;
case KEY_J: t = TOUCH_N; break;
case KEY_K: t = TOUCH_I; break;
case KEY_L: t = TOUCH_O; break;
case KEY_SEMICOLON: t = TOUCH_P; break;
}
if(t < NUM_TOUCHES){
//fprintf(stderr, "current chord: 0x%02x\n", chord_state_bitmap(state));
switch(ev->value){
case 1: chord_touch_start(state, t); break;
case 0: chord_touch_end(state, t); break;
}
if(chord_state_is_empty(state)){
lookup_key k = chord_accumulator_bitmap(state);
int keycode = lookup_keycode(k);
if(keycode != KEY_RESERVED){
fprintf(stderr, "chord 0x%02x %s\n", k, libevdev_event_code_get_name(EV_KEY, keycode));
ret = libevdev_uinput_write_event(uidev, EV_KEY, keycode , 1);
if (ret < 0) {perror("Failed to write event"); return -1;}
ret = libevdev_uinput_write_event(uidev, EV_KEY, keycode , 0);
if (ret < 0) {perror("Failed to write event"); return -1;}
ret = libevdev_uinput_write_event(uidev, EV_SYN, SYN_REPORT, 0);
if (ret < 0) {perror("Failed to write event"); return -1;}
}
chord_reset(state);
}
} else {
// printf("%s, %s, %d\n",
// libevdev_event_type_get_name(ev->type),
// libevdev_event_code_get_name(ev->type, ev->code),
// ev->value);
ret = libevdev_uinput_write_event(uidev, EV_KEY, ev->code , ev->value);
if (ret < 0) {perror("Failed to write event"); return -1;}
ret = libevdev_uinput_write_event(uidev, EV_SYN, SYN_REPORT, 0);
if (ret < 0) {perror("Failed to write event"); return -1;}
}
return 0;
}
END_TEST
START_TEST(test_code_abs_name)
{
/* pick out a few only */
ck_assert_str_eq(libevdev_event_code_get_name(EV_ABS, ABS_X), "ABS_X");
ck_assert_str_eq(libevdev_event_code_get_name(EV_ABS, ABS_Y), "ABS_Y");
ck_assert_str_eq(libevdev_event_code_get_name(EV_ABS, ABS_MT_SLOT), "ABS_MT_SLOT");
ck_assert_str_eq(libevdev_event_code_get_name(EV_ABS, ABS_MISC), "ABS_MISC");
ck_assert_str_eq(libevdev_event_code_get_name(EV_ABS, ABS_MAX), "ABS_MAX");
ck_assert(libevdev_event_code_get_name(EV_ABS, ABS_MAX - 1) == NULL);
}
int next_event_wrapper(struct adhoc *adhoc, struct input_event *event) {
int r = libevdev_next_event(adhoc->dev, LIBEVDEV_READ_FLAG_NORMAL | LIBEVDEV_READ_FLAG_BLOCKING, event);
if (r < 0) {
error(0, -r, "libevdev_next_event failed");
return r;
}
if (r == LIBEVDEV_READ_STATUS_SYNC) {
fprintf(stderr, "libevdev_next_event returned LIBEVDEV_READ_STATUS_SYNC, handling not implemented!\n");
return 0;
}
#ifdef DEBUG
fprintf(stderr,
"event [type: %s, code: %s, value: %d]\n",
libevdev_event_type_get_name(event->type),
libevdev_event_code_get_name(event->type, event->code),
event->value);
#endif
return 0;
}
std::string evdevDevice::ForceFeedback::GetName() const
{
// We have some default names.
switch (m_type)
{
case FF_SINE:
return "Sine";
case FF_TRIANGLE:
return "Triangle";
case FF_SQUARE:
return "Square";
case FF_RUMBLE:
return "LeftRight";
default:
{
const char* name = libevdev_event_code_get_name(EV_FF, m_type);
if (name)
return StripSpaces(name);
return "Unknown";
}
}
}
static void
all_codes_create(struct litest_device *d)
{
int events[KEY_MAX * 2 + 2];
int code, idx;
for (idx = 0, code = 0; code < KEY_MAX; code++) {
const char *name = libevdev_event_code_get_name(EV_KEY, code);
if (name && strneq(name, "BTN_", 4))
continue;
events[idx++] = EV_KEY;
events[idx++] = code;
}
events[idx++] = -1;
events[idx++] = -1;
d->uinput = litest_create_uinput_device_from_description(NAME,
&input_id,
NULL,
events);
}
END_TEST
START_TEST(test_code_key_name)
{
/* pick out a few only */
ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_RESERVED), "KEY_RESERVED");
ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_ESC), "KEY_ESC");
ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_1), "KEY_1");
ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_2), "KEY_2");
ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_UNKNOWN), "KEY_UNKNOWN");
ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_0), "BTN_0");
ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_LEFT), "BTN_LEFT");
ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_TRIGGER), "BTN_TRIGGER");
ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_A), "BTN_SOUTH");
ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_TOOL_PEN), "BTN_TOOL_PEN");
ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_TOUCHPAD_TOGGLE), "KEY_TOUCHPAD_TOGGLE");
ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_TRIGGER_HAPPY), "BTN_TRIGGER_HAPPY1");
ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_MAX), "KEY_MAX");
ck_assert(libevdev_event_code_get_name(EV_KEY, KEY_MAX - 1) == NULL);
/* special cases that resolve to something else */
ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_HANGUEL), "KEY_HANGEUL");
ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, KEY_SCREENLOCK), "KEY_COFFEE");
ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_MISC), "BTN_0");
ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_MOUSE), "BTN_LEFT");
ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_JOYSTICK), "BTN_TRIGGER");
ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_GAMEPAD), "BTN_SOUTH");
ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_DIGI), "BTN_TOOL_PEN");
ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_WHEEL), "BTN_GEAR_DOWN");
ck_assert_str_eq(libevdev_event_code_get_name(EV_KEY, BTN_TRIGGER_HAPPY), "BTN_TRIGGER_HAPPY1");
}
bool
evdev_middlebutton_filter_button(struct evdev_device *device,
uint64_t time,
int button,
enum libinput_button_state state)
{
enum evdev_middlebutton_event event;
bool is_press = state == LIBINPUT_BUTTON_STATE_PRESSED;
int rc;
unsigned int bit = (button - BTN_LEFT);
uint32_t old_mask = 0;
if (!device->middlebutton.enabled)
return false;
switch (button) {
case BTN_LEFT:
if (is_press)
event = MIDDLEBUTTON_EVENT_L_DOWN;
else
event = MIDDLEBUTTON_EVENT_L_UP;
break;
case BTN_RIGHT:
if (is_press)
event = MIDDLEBUTTON_EVENT_R_DOWN;
else
event = MIDDLEBUTTON_EVENT_R_UP;
break;
/* BTN_MIDDLE counts as "other" and resets middle button
* emulation */
case BTN_MIDDLE:
default:
event = MIDDLEBUTTON_EVENT_OTHER;
break;
}
if (button < BTN_LEFT ||
bit >= sizeof(device->middlebutton.button_mask) * 8) {
log_bug_libinput(device->base.seat->libinput,
"Button mask too small for %d\n",
libevdev_event_code_get_name(EV_KEY,
button));
return true;
}
rc = evdev_middlebutton_handle_event(device, time, event);
old_mask = device->middlebutton.button_mask;
if (is_press)
device->middlebutton.button_mask |= 1 << bit;
else
device->middlebutton.button_mask &= ~(1 << bit);
if (old_mask != device->middlebutton.button_mask &&
device->middlebutton.button_mask == 0) {
evdev_middlebutton_handle_event(device,
time,
MIDDLEBUTTON_EVENT_ALL_UP);
evdev_middlebutton_apply_config(device);
}
return rc;
}
int main(int argc, char const *argv[])
{
if (argc < 5) {
printf("Usage: evmpd HOSTNAME PORT DEVICE HALT_COMMAND\n");
return EXIT_FAILURE;
}
struct mpd_connection *client = connect(argv[1], strtol(argv[2], NULL, 10));
struct libevdev *dev = NULL;
int fd;
int rc = 1;
fd = open(argv[3], O_RDONLY | O_NONBLOCK);
rc = libevdev_new_from_fd(fd, &dev);
if (rc < 0) {
fprintf(stderr, "Failed to init libevdev (%d)\n", strerror(-rc));
return EXIT_FAILURE;
}
printf("Input device name: \"%s\"\n", libevdev_get_name(dev));
printf("Input device ID: bus %#x vendor %#x product %#x\n",
libevdev_get_id_bustype(dev),
libevdev_get_id_vendor(dev), libevdev_get_id_product(dev));
do {
struct input_event ev;
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
if (rc == 0 && ev.value == 0) {
if (libevdev_event_is_code(&ev, EV_KEY, KEY_F4)) {
system(argv[4]);
printf("shutdown\n");
} else if (libevdev_event_is_code(&ev, EV_KEY, KEY_PLAYPAUSE)) {
struct mpd_status *status = mpd_run_status(client);
enum mpd_state state = mpd_status_get_state(status);
if (state != MPD_STATE_PLAY && state != MPD_STATE_PAUSE) {
mpd_run_play(client);
printf("play\n");
} else {
mpd_run_toggle_pause(client);
printf("toggle-pause\n");
}
} else if (libevdev_event_is_code(&ev, EV_KEY, KEY_STOPCD)) {
mpd_run_stop(client);
printf("stop\n");
} else if (libevdev_event_is_code(&ev, EV_KEY, KEY_PREVIOUSSONG)) {
mpd_run_previous(client);
printf("previous\n");
} else if (libevdev_event_is_code(&ev, EV_KEY, KEY_NEXTSONG)) {
mpd_run_next(client);
printf("next\n");
} else if (libevdev_event_is_code(&ev, EV_KEY, KEY_VOLUMEUP)) {
struct mpd_status *status = mpd_run_status(client);
int volume = mpd_status_get_volume(status);
volume += 5;
if (volume > 100) {
volume = 100;
}
mpd_run_set_volume(client, volume);
printf("set-volume %d\n", volume);
} else if (libevdev_event_is_code(&ev, EV_KEY, KEY_VOLUMEDOWN)) {
struct mpd_status *status = mpd_run_status(client);
int volume = mpd_status_get_volume(status);
volume -= 5;
if (volume < 0) {
volume = 0;
}
mpd_run_set_volume(client, volume);
printf("set-volume %d\n", volume);
} else {
printf("Event: %s %s %d\n",
libevdev_event_type_get_name(ev.type),
libevdev_event_code_get_name(ev.type, ev.code),
ev.value);
}
}
}
while (rc == LIBEVDEV_READ_STATUS_SUCCESS ||
rc == LIBEVDEV_READ_STATUS_SYNC ||
rc == -EAGAIN);
printf("rc: %d\n", rc);
if (client != NULL) {
mpd_connection_free(client);
}
return EXIT_SUCCESS;
}
