Add possibility to auto-detect the multi touch input device

Author: coder-hugo

configure.ac

@@ -20,10 +20,7 @@ AC_CHECK_HEADERS([linux/input.h linux/uinput.h], [], [AC_MSG_ERROR([The linux he
 
 # Checks for typedefs, structures, and compiler characteristics.
 AC_CHECK_HEADER_STDBOOL
-AC_TYPE_INT32_T
 AC_TYPE_SIZE_T
-AC_TYPE_UINT32_T
-AC_TYPE_UINT8_T
 
 # Checks for library functions.
 AC_FUNC_MALLOC

src/configuraion.c

@@ -34,7 +34,7 @@
 char *directions[4] = { "up", "down", "left", "right" };
 
 static void clean_config(configuration_t *config) {
-  int32_t i, j, k;
+  int i, j, k;
   for (i = 0; i < MAX_FINGERS; i++) {
     for (j = 0; j < DIRECTIONS_COUNT; j++) {
       for (k = 0; k < MAX_KEYS_PER_GESTURE; k++) {
@@ -47,7 +47,7 @@ static void clean_config(configuration_t *config) {
 static void fill_keys_array(int (*keys_array)[MAX_KEYS_PER_GESTURE], char *keys) {
   if (keys) {
     char *ptr = strtok(keys, "+");
-    uint8_t i = 0;
+    unsigned int i = 0;
     while (ptr) {
       if (i >= MAX_KEYS_PER_GESTURE) {
         fprintf(stderr, "error: for each gesture only %d keystrokes are allowed\n", MAX_KEYS_PER_GESTURE);
@@ -75,23 +75,22 @@ configuration_t read_config(const char *filename) {
       strcpy(result.touch_device_path, touch_device_path);
     }
   } else {
-    errno = EINVAL;
-    die("error: no touch device defined");
+    result.touch_device_path = NULL;
   }
-  result.retries = (uint8_t) iniparser_getint(ini, "general:retries", 2);
-  result.retry_delay = (uint8_t) iniparser_getint(ini, "general:retrydelay", 5);
+  result.retries = (unsigned int) iniparser_getint(ini, "general:retries", 2);
+  result.retry_delay = (unsigned int) iniparser_getint(ini, "general:retrydelay", 5);
   result.scroll.vert = iniparser_getboolean(ini, "scroll:vertical", false);
   result.scroll.horz = iniparser_getboolean(ini, "scroll:horizontal", false);
-  result.scroll.vert_delta = (int8_t) iniparser_getint(ini, "scroll:verticaldelta", 79);
-  result.scroll.horz_delta = (int8_t) iniparser_getint(ini, "scroll:horizontaldelta", 30);
+  result.scroll.vert_delta = (int) iniparser_getint(ini, "scroll:verticaldelta", 79);
+  result.scroll.horz_delta = (int) iniparser_getint(ini, "scroll:horizontaldelta", 30);
   result.scroll.invert_vert = iniparser_getboolean(ini, "scroll:invertvertical", false);
   result.scroll.invert_horz = iniparser_getboolean(ini, "scroll:inverthorizontal", false);
   result.vert_threshold_percentage = iniparser_getint(ini, "thresholds:vertical", 15);
   result.horz_threshold_percentage = iniparser_getint(ini, "thresholds:horizontal", 15);
   result.zoom.enabled = iniparser_getboolean(ini, "zoom:enabled", false);
-  result.zoom.delta = (uint8_t) iniparser_getint(ini, "zoom:delta", 200);
+  result.zoom.delta = (unsigned int) iniparser_getint(ini, "zoom:delta", 200);
 
-  uint8_t i, j;
+  unsigned int i, j;
   for (i = 0; i < MAX_FINGERS; i++) {
     for (j = 0; j < DIRECTIONS_COUNT; j++) {
       char ini_key[16];

src/configuraion.h

@@ -41,22 +41,22 @@ typedef struct keys_array {
 
 typedef struct configuration {
   char *touch_device_path;
-  uint8_t retries;
-  uint8_t retry_delay;
+  unsigned int retries;
+  unsigned int retry_delay;
   struct scroll_options {
     bool vert;
     bool horz;
-    int8_t vert_delta;
-    int8_t horz_delta;
+    int vert_delta;
+    int horz_delta;
     bool invert_vert;
     bool invert_horz;
   } scroll;
   struct zoom_options {
     bool enabled;
-    uint8_t delta;
+    unsigned int delta;
   } zoom;
-  uint8_t vert_threshold_percentage;
-  uint8_t horz_threshold_percentage;
+  unsigned int vert_threshold_percentage;
+  unsigned int horz_threshold_percentage;
   keys_array_t swipe_keys[MAX_FINGERS][DIRECTIONS_COUNT];
 } configuration_t;
 

src/gesture_detection.c

@@ -49,7 +49,7 @@ typedef struct point {
 } point_t;
 
 typedef struct mt_slots {
-  uint8_t active;
+  unsigned int active;
   point_t points[2];
   point_t last_points[2];
 } mt_slots_t;
@@ -67,7 +67,7 @@ typedef struct gesture_start {
 } gesture_start_t;
 
 typedef struct scroll_thread_params {
-  uint8_t delta;
+  unsigned int delta;
   int code;
   bool invert;
   void (*callback)(input_event_array_t*);
@@ -77,7 +77,7 @@ typedef enum gesture { NO_GESTURE, SCROLL, ZOOM, SWIPE } gesture_t;
 
 mt_slots_t mt_slots;
 gesture_start_t gesture_start;
-uint8_t finger_count;
+unsigned int finger_count;
 volatile scroll_t scroll;
 gesture_t current_gesture;
 double last_zoom_distance;
@@ -93,7 +93,7 @@ static int test_grab(int fd) {
 }
 
 static double calculate_distance(point_t p1, point_t p2) {
-  int32_t x_distance, y_distance;
+  int x_distance, y_distance;
   x_distance = p1.x - p2.x;
   y_distance = p1.y - p2.y;
   return sqrt((x_distance * x_distance) + (y_distance * y_distance));
@@ -123,8 +123,8 @@ static void init_gesture() {
 /*
  * @return number of fingers on touch device
  */
-static uint8_t process_key_event(struct input_event event) {
-  uint8_t finger_count;
+static unsigned int process_key_event(struct input_event event) {
+  unsigned int finger_count;
   if (event.value == 1 && !is_click) {
     switch (event.code) {
       case BTN_TOOL_FINGER:
@@ -166,7 +166,7 @@ static uint8_t process_key_event(struct input_event event) {
  * @return velocity in distance per milliseconds
  */
 static double calcualte_velocity(struct input_event event1, struct input_event event2) {
-  int32_t distance = event2.value - event1.value;
+  int distance = event2.value - event1.value;
   double time_delta = 
     event2.time.tv_sec * 1000 + event2.time.tv_usec / 1000 - event1.time.tv_sec * 1000 - event1.time.tv_usec / 1000;
   return distance / time_delta;
@@ -223,7 +223,7 @@ static void set_input_event(struct input_event *input_event, int type, int code,
 #define set_key_event(key_event, code, value) set_input_event(key_event, EV_KEY, code, value)
 #define set_rel_event(rel_event, code, value) set_input_event(rel_event, EV_REL, code, value)
 
-static input_event_array_t *do_scroll(double distance, int32_t delta, int rel_code, bool invert) {
+static input_event_array_t *do_scroll(double distance, int delta, int rel_code, bool invert) {
   input_event_array_t *result = NULL;
   // increment the scroll width by the current moved distance
   scroll.width += distance * (invert ? -1 : 1);
@@ -239,7 +239,7 @@ static input_event_array_t *do_scroll(double distance, int32_t delta, int rel_co
   return result;
 }
 
-static input_event_array_t *do_zoom(double distance, int32_t delta) {
+static input_event_array_t *do_zoom(double distance, int delta) {
   input_event_array_t *result = NULL;
   input_event_array_t *tmp = do_scroll(distance, delta, REL_WHEEL, false);
   if (tmp) {
@@ -320,7 +320,7 @@ static bool check_mt_slots() {
   return result;
 }
 
-uint32_t syn_counter = 0;
+unsigned int syn_counter = 0;
 
 static input_event_array_t *process_syn_event(struct input_event event,
                                               configuration_t config,
@@ -354,7 +354,7 @@ static input_event_array_t *process_syn_event(struct input_event event,
       }
       last_zoom_distance = finger_distance;
     } else {
-      int32_t x_distance, y_distance;
+      int x_distance, y_distance;
       x_distance = gesture_start.point.x - mt_slots.points[0].x;
       y_distance = gesture_start.point.y - mt_slots.points[0].y;
       if (fabs(x_distance) > fabs(y_distance)) {
@@ -388,7 +388,7 @@ static input_event_array_t *process_syn_event(struct input_event event,
       }
     }
     if (direction != NONE) {
-      uint8_t i;
+      unsigned int i;
       for (i = MAX_KEYS_PER_GESTURE; i > 0; i--) {
         int key = config.swipe_keys[FINGER_TO_INDEX(finger_count)][direction].keys[i - 1];
         if (key > 0) {
@@ -411,15 +411,15 @@ static input_event_array_t *process_syn_event(struct input_event event,
   return result ? result : new_input_event_array(0);
 }
 
-static int32_t get_axix_threshold(int fd, int axis, uint8_t percentage) {
+static int get_axix_threshold(int fd, int axis, unsigned int percentage) {
   struct input_absinfo absinfo;
   if (ioctl(fd, EVIOCGABS(axis), &absinfo) < 0) {
     return -1;
   }
   return (absinfo.maximum - absinfo.minimum) * percentage / 100;
 }
 
-static int32_t get_axix_offset(int fd, int axis) {
+static int get_axix_offset(int fd, int axis) {
   struct input_absinfo absinfo;
   if (ioctl(fd, EVIOCGABS(axis), &absinfo) < 0) {
     return -1;
@@ -472,7 +472,7 @@ void process_events(int fd, configuration_t config, void (*callback)(input_event
   offsets.x = get_axix_offset(fd, ABS_X);
   offsets.y = get_axix_offset(fd, ABS_Y);
 
-  pthread_t scroll_thread = NULL;
+  pthread_t scroll_thread = (pthread_t) NULL;
 
   if (thresholds.x < 0 || thresholds.y < 0) {
     return;

src/gestures_device.c

@@ -81,7 +81,7 @@ int destroy_uinput(int fd) {
 }
 
 void send_events(int fd, input_event_array_t *input_events) {
-  uint8_t i;
+  unsigned int i;
   if (input_events->length > 0) {
     for (i = 0; i < input_events->length; i++) {
       if (write(fd, &input_events->data[i], sizeof(struct input_event)) < 0) {

src/keys.c

@@ -446,7 +446,7 @@ struct key keys[KEYS_COUNT] = {
 };
 
 int get_key_code(char *key_name) {
-  uint32_t low, high, mid;
+  unsigned int low, high, mid;
   low = 0;
   high = KEYS_COUNT - 1;
   while (low <= high) {

src/main.c

@@ -28,22 +28,34 @@
 #include <unistd.h>
 #include <fcntl.h>
 #include <errno.h>
+#include <dirent.h>
 
 #include <linux/input.h>
 
 #include "common.h"
 #include "gestures_device.h"
 #include "gesture_detection.h"
 
+
+#define DEV_INPUT_EVENT "/dev/input"
+#define EVENT_DEV_NAME "event"
+
+#define BITS_PER_LONG (sizeof(long) * 8)
+#define NBITS(x) ((((x)-1)/BITS_PER_LONG)+1)
+#define OFF(x)  ((x)%BITS_PER_LONG)
+#define BIT(x)  (1UL<<OFF(x))
+#define LONG(x) ((x)/BITS_PER_LONG)
+#define test_bit(bit, array) ((array[LONG(bit)] >> OFF(bit)) & 1)
+
 int uinput_fd, touch_device_fd;
 
 static void execute_events(input_event_array_t *input_events) {
   send_events(uinput_fd, input_events);
 }
 
 static int_array_t *get_keys_array(configuration_t config) {
-  uint8_t i, j, k;
-  uint8_t keys_count = 0;
+  unsigned int i, j, k;
+  unsigned int keys_count = 0;
   int_array_t *keys = new_int_array(MAX_FINGERS * DIRECTIONS_COUNT * MAX_KEYS_PER_GESTURE);
   for (i = 0; i < MAX_FINGERS; i++) {
     for (j = 0; j < DIRECTIONS_COUNT; j++) {
@@ -59,27 +71,96 @@ static int_array_t *get_keys_array(configuration_t config) {
   return keys;
 }
 
+static int is_event_device(const struct dirent *dir) {
+  return strncmp(EVENT_DEV_NAME, dir->d_name, 5) == 0;
+}
+
+static bool check_device(char *device_name) {
+  char filename[64];
+  int fd = -1;
+  char name[256] = "???";
+  unsigned long bit[NBITS(KEY_MAX)];
+
+  snprintf(filename, sizeof(filename), "%s/%s", DEV_INPUT_EVENT, device_name);
+  fd = open(filename, O_RDONLY);
+  if (fd < 0) {
+    return false;
+  }
+
+  memset(bit, 0, sizeof(bit));
+  ioctl(fd, EVIOCGBIT(EV_KEY, KEY_MAX), bit);
+
+  ioctl(fd, EVIOCGNAME(sizeof(name)), name);
+  close(fd);
+
+  if (test_bit(BTN_TOOL_QUINTTAP, bit)) {
+    printf("Found multi-touch input device: %s\n", name);
+    return true;
+  }
+
+  return false;
+}
+
+static char* scan_devices(void) {
+  struct dirent **namelist;
+
+  int devnum = -1;
+  int ndev = scandir(DEV_INPUT_EVENT, &namelist, is_event_device, alphasort);
+  if (ndev <= 0) {
+    return NULL;
+  }
+
+  for (int i = 0; i < ndev; i++) {
+    if (devnum == -1 && check_device(namelist[i]->d_name)) {
+      sscanf(namelist[i]->d_name, "event%i", &devnum);
+    }
+    free(namelist[i]);
+  }
+
+  if (devnum == -1) {
+    return NULL;
+  }
+
+  char *filename = (char*) malloc(64 * sizeof(char));
+  sprintf(filename, "%s/%s%i", DEV_INPUT_EVENT, EVENT_DEV_NAME, devnum);
+  return filename;
+}
+
+static int open_touch_device(configuration_t config, int retry) {
+  if (config.touch_device_path) {
+    printf("Looking for input device: %s (Attempt %i/%i)\n", config.touch_device_path, retry + 1, config.retries + 1);
+    return open(config.touch_device_path, O_RDONLY);
+  } else {
+    printf("Looking for multi-touch input device: (Attempt %i/%i)\n", retry + 1, config.retries + 1);
+    char *filename = scan_devices();
+    if (filename) {
+      return open(filename, O_RDONLY);
+    } else {
+      return -1;
+    }
+  }
+}
+
 int main(int argc, char *argv[]) {
   if (argc > 1) {
     configuration_t config = read_config(argv[1]);
     int_array_t *keys = get_keys_array(config);
     uinput_fd = init_uinput(keys);
     free(keys);
 
-    int8_t retries = 0;
-    while (retries < config.retries + 1) {
-      printf("Looking for input device: %s (Attempt %i/%i)\n", config.touch_device_path, retries + 1, config.retries + 1);
-      touch_device_fd = open(config.touch_device_path, O_RDONLY);
+    int retry = 0;
+    while (retry < config.retries + 1) {
+      touch_device_fd = open_touch_device(config, retry);
       if (touch_device_fd > 0) {
         break;
       }
       sleep(config.retry_delay);
-      retries++;
+      retry++;
     }
     if (touch_device_fd < 0) {
       die("Failed to open input device");
     }
-    printf("Opened input device: %s\n", config.touch_device_path);
+    printf("Opened input device\n");
     process_events(touch_device_fd, config, &execute_events);
 
     close(touch_device_fd);