int
main (int argc, char **argv) {
int rc;
int fd;
const char *path;
struct libevdev *dev;
struct measurements measurements = {0};
if (argc < 2)
return usage();
path = argv[1];
if (path[0] == '-')
return usage();
fd = open(path, O_RDONLY|O_NONBLOCK);
if (fd < 0) {
fprintf(stderr, "Error opening the device: %s\n", strerror(errno));
return 1;
}
rc = libevdev_new_from_fd(fd, &dev);
if (rc != 0) {
fprintf(stderr, "Error fetching the device info: %s\n", strerror(-rc));
return 1;
}
if (libevdev_grab(dev, LIBEVDEV_GRAB) != 0) {
fprintf(stderr, "Error: cannot grab the device, something else is grabbing it.\n");
fprintf(stderr, "Use 'fuser -v %s' to find processes with an open fd\n", path);
return 1;
}
libevdev_grab(dev, LIBEVDEV_UNGRAB);
printf("Mouse %s on %s\n", libevdev_get_name(dev), path);
printf("Move the device 250mm/10in or more along the x-axis.\n");
printf("Pause 3 seconds before movement to reset, Ctrl+C to exit.\n");
setbuf(stdout, NULL);
rc = mainloop(dev, &measurements);
printf("\n");
print_summary(&measurements);
printf("\n");
printf("Entry for hwdb match (replace XXX with the resolution in DPI):\n"
"mouse:%s:v%04xp%04x:name:%s:\n"
" MOUSE_DPI=XXX@%d\n",
bustype(libevdev_get_id_bustype(dev)),
libevdev_get_id_vendor(dev),
libevdev_get_id_product(dev),
libevdev_get_name(dev),
(int)measurements.max_frequency);
libevdev_free(dev);
close(fd);
return rc;
}
struct adhoc* adhoc_init(int fd) {
struct adhoc *adhoc = calloc(1, sizeof(struct adhoc));
int r = libevdev_new_from_fd(fd, &adhoc->dev);
if (r) {
error(0, -r, "libevdev_new_from_fd failed");
goto creation_error;
}
const char *name = libevdev_get_name(adhoc->dev);
if (strcmp(name, "SMART SB680 Interactive Whiteboard") == 0)
adhoc->internal_calls = internal_calls_sb680;
else if (strcmp(name, "SMART SB885 Interactive Whiteboard") == 0)
adhoc->internal_calls = internal_calls_sb885;
else {
fprintf(stderr, "unknown device: %s\n", name);
goto device_error;
}
#ifdef DEBUG
fprintf(stderr, "device: %s\n", name);
#endif
if (adhoc->internal_calls.init(adhoc))
goto device_error;
return adhoc;
device_error:
libevdev_free(adhoc->dev);
creation_error:
free(adhoc);
return NULL;
}
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));
}
void joystick_linux::open_joystick(const char *p_path) {
int joy_num = get_free_joy_slot();
int fd = open(p_path, O_RDONLY | O_NONBLOCK);
if (fd != -1 && joy_num != -1) {
int rc = libevdev_new_from_fd(fd, &joysticks[joy_num].dev);
if (rc < 0) {
fprintf(stderr, "Failed to init libevdev (%s)\n", strerror(-rc));
return;
}
libevdev *dev = joysticks[joy_num].dev;
//check if the device supports basic gamepad events, prevents certain keyboards from
//being detected as joysticks
if (libevdev_has_event_type(dev, EV_ABS) && libevdev_has_event_type(dev, EV_KEY) &&
(libevdev_has_event_code(dev, EV_KEY, BTN_A) || libevdev_has_event_code(dev, EV_KEY, BTN_THUMBL) || libevdev_has_event_code(dev, EV_KEY, BTN_TOP))) {
char uid[128];
String name = libevdev_get_name(dev);
uint16_t bus = __bswap_16(libevdev_get_id_bustype(dev));
uint16_t vendor = __bswap_16(libevdev_get_id_vendor(dev));
uint16_t product = __bswap_16(libevdev_get_id_product(dev));
uint16_t version = __bswap_16(libevdev_get_id_version(dev));
joysticks[joy_num].reset();
Joystick &joy = joysticks[joy_num];
joy.fd = fd;
joy.devpath = String(p_path);
setup_joystick_properties(joy_num);
sprintf(uid, "%04x%04x", bus, 0);
if (vendor && product && version) {
sprintf(uid + String(uid).length(), "%04x%04x%04x%04x%04x%04x", vendor,0,product,0,version,0);
input->joy_connection_changed(joy_num, true, name, uid);
}
else {
String uidname = uid;
int uidlen = MIN(name.length(), 11);
for (int i=0; i<uidlen; i++) {
uidname = uidname + _hex_str(name[i]);
}
uidname += "00";
input->joy_connection_changed(joy_num, true, name, uidname);
}
}
else {
//device is not a gamepad, clean up
libevdev_free(dev);
close(fd);
}
}
}
evdevDevice::evdevDevice(const std::string& devnode) : m_devfile(devnode)
{
// The device file will be read on one of the main threads, so we open in non-blocking mode.
m_fd = open(devnode.c_str(), O_RDWR | O_NONBLOCK);
int ret = libevdev_new_from_fd(m_fd, &m_dev);
if (ret != 0)
{
// This useally fails because the device node isn't an evdev device, such as /dev/input/js0
m_initialized = false;
close(m_fd);
return;
}
m_name = StripSpaces(libevdev_get_name(m_dev));
// Controller buttons (and keyboard keys)
int num_buttons = 0;
for (int key = 0; key < KEY_MAX; key++)
if (libevdev_has_event_code(m_dev, EV_KEY, key))
AddInput(new Button(num_buttons++, key, m_dev));
// Absolute axis (thumbsticks)
int num_axis = 0;
for (int axis = 0; axis < 0x100; axis++)
if (libevdev_has_event_code(m_dev, EV_ABS, axis))
{
AddAnalogInputs(new Axis(num_axis, axis, false, m_dev),
new Axis(num_axis, axis, true, m_dev));
num_axis++;
}
// Force feedback
if (libevdev_has_event_code(m_dev, EV_FF, FF_PERIODIC))
{
for (auto type : {FF_SINE, FF_SQUARE, FF_TRIANGLE, FF_SAW_UP, FF_SAW_DOWN})
if (libevdev_has_event_code(m_dev, EV_FF, type))
AddOutput(new ForceFeedback(type, m_dev));
}
if (libevdev_has_event_code(m_dev, EV_FF, FF_RUMBLE))
{
AddOutput(new ForceFeedback(FF_RUMBLE, m_dev));
}
// TODO: Add leds as output devices
m_initialized = true;
m_interesting = num_axis >= 2 || num_buttons >= 8;
}
END_TEST
START_TEST(device_ids)
{
struct litest_device *dev = litest_current_device();
const char *name;
unsigned int pid, vid;
name = libevdev_get_name(dev->evdev);
pid = libevdev_get_id_product(dev->evdev);
vid = libevdev_get_id_vendor(dev->evdev);
ck_assert_str_eq(name,
libinput_device_get_name(dev->libinput_device));
ck_assert_int_eq(pid,
libinput_device_get_id_product(dev->libinput_device));
ck_assert_int_eq(vid,
libinput_device_get_id_vendor(dev->libinput_device));
}
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));
}
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;
}
static int consider_device(const char* devpath, internal_state_t* state)
{
int fd = -1;
struct libevdev* evdev = NULL;
if (!is_character_device(devpath))
{
goto mismatch;
}
if ((fd = open(devpath, O_RDWR)) < 0)
{
perror("open");
fprintf(stderr, "Unable to open device %s for inspection", devpath);
goto mismatch;
}
if (libevdev_new_from_fd(fd, &evdev) < 0)
{
fprintf(stderr, "Note: device %s is not supported by libevdev\n", devpath);
goto mismatch;
}
if (!is_multitouch_device(evdev))
{
goto mismatch;
}
int score = 10000;
if (libevdev_has_event_code(evdev, EV_ABS, ABS_MT_TOOL_TYPE))
{
int tool_min = libevdev_get_abs_minimum(evdev, ABS_MT_TOOL_TYPE);
int tool_max = libevdev_get_abs_maximum(evdev, ABS_MT_TOOL_TYPE);
if (tool_min > MT_TOOL_FINGER || tool_max < MT_TOOL_FINGER)
{
fprintf(stderr, "Note: device %s is a touch device, but doesn't"
" support fingers\n", devpath);
goto mismatch;
}
score -= tool_max - MT_TOOL_FINGER;
}
if (libevdev_has_event_code(evdev, EV_ABS, ABS_MT_SLOT))
{
score += 1000;
// Some devices, e.g. Blackberry PRIV (STV100) have more than one surface
// you can touch. On the PRIV, the keypad also acts as a touch screen
// that you can swipe and scroll with. The only differences between the
// touch devices are that one is named "touch_display" and the other
// "touch_keypad", the keypad only supports 3 contacts and the display
// up to 9, and the keypad has a much lower resolution. Therefore
// increasing the score by the number of contacts should be a relatively
// safe bet, though we may also want to decrease the score by, say, 1,
// if the device name contains "key" just in case they decide to start
// supporting more contacts on both touch surfaces in the future.
int num_slots = libevdev_get_abs_maximum(evdev, ABS_MT_SLOT);
score += num_slots;
}
// For Blackberry devices, see above.
const char* name = libevdev_get_name(evdev);
if (strstr(name, "key") != NULL)
{
score -= 1;
}
// Alcatel OneTouch Idol 3 has an `input_mt_wrapper` device in addition
// to direct input. It seems to be related to accessibility, as it shows
// a touchpoint that you can move around, and then tap to activate whatever
// is under the point. That wrapper device lacks the direct property.
if (libevdev_has_property(evdev, INPUT_PROP_DIRECT))
{
score += 10000;
}
// Some devices may have an additional screen. For example, Meizu Pro7 Plus
// has a small screen on the back side of the device called sub_touch, while
// the boring screen in the front is called main_touch. The resolution on
// the sub_touch device is much much lower. It seems like a safe bet
// to always prefer the larger device, as long as the score adjustment is
// likely to be lower than the adjustment we do for INPUT_PROP_DIRECT.
if (libevdev_has_event_code(evdev, EV_ABS, ABS_MT_POSITION_X))
{
int x = libevdev_get_abs_maximum(evdev, ABS_MT_POSITION_X);
int y = libevdev_get_abs_maximum(evdev, ABS_MT_POSITION_Y);
score += sqrt(x * y);
}
if (state->evdev != NULL)
{
if (state->score >= score)
{
fprintf(stderr, "Note: device %s was outscored by %s (%d >= %d)\n",
devpath, state->path, state->score, score);
goto mismatch;
}
else
{
fprintf(stderr, "Note: device %s was outscored by %s (%d >= %d)\n",
state->path, devpath, score, state->score);
}
}
libevdev_free(state->evdev);
state->fd = fd;
state->score = score;
strncpy(state->path, devpath, sizeof(state->path));
state->evdev = evdev;
return 1;
mismatch:
libevdev_free(evdev);
if (fd >= 0)
{
close(fd);
}
return 0;
}
int main(int argc, char* argv[])
{
const char* pname = argv[0];
const char* devroot = "/dev/input";
char* device = NULL;
char* sockname = DEFAULT_SOCKET_NAME;
char* stdin_file = NULL;
int use_stdin = 0;
int opt;
while ((opt = getopt(argc, argv, "d:n:vif:h")) != -1) {
switch (opt) {
case 'd':
device = optarg;
break;
case 'n':
sockname = optarg;
break;
case 'v':
g_verbose = 1;
break;
case 'i':
use_stdin = 1;
break;
case 'f':
stdin_file = optarg;
break;
case '?':
usage(pname);
return EXIT_FAILURE;
case 'h':
usage(pname);
return EXIT_SUCCESS;
}
}
internal_state_t state = {0};
if (device != NULL)
{
if (!consider_device(device, &state))
{
fprintf(stderr, "%s is not a supported touch device\n", device);
return EXIT_FAILURE;
}
}
else
{
if (walk_devices(devroot, &state) != 0)
{
fprintf(stderr, "Unable to crawl %s for touch devices\n", devroot);
return EXIT_FAILURE;
}
}
if (state.evdev == NULL)
{
fprintf(stderr, "Unable to find a suitable touch device\n");
return EXIT_FAILURE;
}
state.has_mtslot =
libevdev_has_event_code(state.evdev, EV_ABS, ABS_MT_SLOT);
state.has_tracking_id =
libevdev_has_event_code(state.evdev, EV_ABS, ABS_MT_TRACKING_ID);
state.has_key_btn_touch =
libevdev_has_event_code(state.evdev, EV_KEY, BTN_TOUCH);
state.has_touch_major =
libevdev_has_event_code(state.evdev, EV_ABS, ABS_MT_TOUCH_MAJOR);
state.has_width_major =
libevdev_has_event_code(state.evdev, EV_ABS, ABS_MT_WIDTH_MAJOR);
state.has_pressure =
libevdev_has_event_code(state.evdev, EV_ABS, ABS_MT_PRESSURE);
state.min_pressure = state.has_pressure ?
libevdev_get_abs_minimum(state.evdev, ABS_MT_PRESSURE) : 0;
state.max_pressure= state.has_pressure ?
libevdev_get_abs_maximum(state.evdev, ABS_MT_PRESSURE) : 0;
state.max_x = libevdev_get_abs_maximum(state.evdev, ABS_MT_POSITION_X);
state.max_y = libevdev_get_abs_maximum(state.evdev, ABS_MT_POSITION_Y);
state.max_tracking_id = state.has_tracking_id
? libevdev_get_abs_maximum(state.evdev, ABS_MT_TRACKING_ID)
: INT_MAX;
if (!state.has_mtslot && state.max_tracking_id == 0)
{
// The touch device reports incorrect values. There would be no point
// in supporting ABS_MT_TRACKING_ID at all if the maximum value was 0
// (i.e. one contact). This happens on Lenovo Yoga Tablet B6000-F,
// which actually seems to support ~10 contacts. So, we'll just go with
// as many as we can and hope that the system will ignore extra contacts.
state.max_tracking_id = MAX_SUPPORTED_CONTACTS - 1;
fprintf(stderr,
"Note: type A device reports a max value of 0 for ABS_MT_TRACKING_ID. "
"This means that the device is most likely reporting incorrect "
"information. Guessing %d.\n",
state.max_tracking_id
);
}
state.max_contacts = state.has_mtslot
? libevdev_get_abs_maximum(state.evdev, ABS_MT_SLOT) + 1
: (state.has_tracking_id ? state.max_tracking_id + 1 : 2);
state.tracking_id = 0;
int contact;
for (contact = 0; contact < MAX_SUPPORTED_CONTACTS; ++contact)
{
state.contacts[contact].enabled = 0;
}
fprintf(stderr,
"%s touch device %s (%dx%d with %d contacts) detected on %s (score %d)\n",
state.has_mtslot ? "Type B" : "Type A",
libevdev_get_name(state.evdev),
state.max_x, state.max_y, state.max_contacts,
state.path, state.score
);
if (state.max_contacts > MAX_SUPPORTED_CONTACTS) {
fprintf(stderr, "Note: hard-limiting maximum number of contacts to %d\n",
MAX_SUPPORTED_CONTACTS);
state.max_contacts = MAX_SUPPORTED_CONTACTS;
}
FILE* input;
FILE* output;
if (use_stdin || stdin_file != NULL)
{
if (stdin_file != NULL)
{
// Reading from a file
input = fopen(stdin_file, "r");
if (NULL == input)
{
fprintf(stderr, "Unable to open '%s': %s\n",
stdin_file, strerror(errno));
exit(EXIT_FAILURE);
}
else
{
fprintf(stderr, "Reading commands from '%s'\n",
stdin_file);
}
}
else
{
// Reading from terminal
input = stdin;
fprintf(stderr, "Reading from STDIN\n");
}
output = stderr;
io_handler(input, output, &state);
fclose(input);
fclose(output);
exit(EXIT_SUCCESS);
}
struct sockaddr_un client_addr;
socklen_t client_addr_length = sizeof(client_addr);
int server_fd = start_server(sockname);
if (server_fd < 0)
{
fprintf(stderr, "Unable to start server on %s\n", sockname);
return EXIT_FAILURE;
}
while (1)
{
int client_fd = accept(server_fd, (struct sockaddr *) &client_addr,
&client_addr_length);
if (client_fd < 0)
{
perror("accepting client");
exit(1);
}
fprintf(stderr, "Connection established\n");
input = fdopen(client_fd, "r");
if (input == NULL)
{
fprintf(stderr, "%s: fdopen(client_fd,'r')\n", strerror(errno));
exit(1);
}
output = fdopen(dup(client_fd), "w");
if (output == NULL)
{
fprintf(stderr, "%s: fdopen(client_fd,'w')\n", strerror(errno));
exit(1);
}
io_handler(input, output, &state);
fprintf(stderr, "Connection closed\n");
fclose(input);
fclose(output);
close(client_fd);
}
close(server_fd);
libevdev_free(state.evdev);
close(state.fd);
return EXIT_SUCCESS;
}
