dev_uinput.c

Go to the documentation of this file.

/*
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 *
 */

#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>

#include <fcntl.h>

#include <linux/input.h>
#include <linux/uinput.h>

#define KEY_PRESSED     1
#define KEY_RELEASED    0

#define X_AXIS_MAX              240
#define X_AXIS_MIN              0
#define Y_AXIS_MAX              320
#define Y_AXIS_MIN              0
#define PRESSURE_MIN            0
#define PRESSURE_MAX            15000


static char *devs[] = {
        "/dev/misc/uinput",
        "/dev/input/uinput",
        "/dev/devfs/misc/uinput",
        "/dev/uinput",
        NULL
};

int uinput_open_device(void) {
  struct uinput_user_dev dev;
  int fd = -1;
  int i  =  0;

  while (devs[i] != NULL) {
    if ( (fd = open(devs[i++], O_RDWR)) >= 0) {
      break;
    } // end of [if]
  } // end of [while]

  if (fd < 0) { perror("failed to open uinput device"); return -1; }

  memset(&dev, 0, sizeof(dev));
  if (write(fd, &dev, sizeof(dev)) < 0) {
    fprintf (stderr,"failed to write uinputdev: %s\n", strerror(errno));
    close(fd);
    return -1;
  }

  return fd;
} // end of [uinput_open_device]

int dev_uinput_init_mouse (char *name) {
  struct uinput_user_dev dev;
  int fd_mouse;  // FileHandle for Mouse-Events

  fd_mouse = uinput_open_device();

  if (fd_mouse) {
    memset(&dev, 0, sizeof(dev));
    strncpy(dev.name, name, UINPUT_MAX_NAME_SIZE);

    dev.id.bustype = BUS_HOST;
    dev.id.vendor  = 0x1F;
    dev.id.product = 0x1E;
    dev.id.version = 0x00;

    dev.absmax[ABS_X] = X_AXIS_MAX;
    dev.absmin[ABS_X] = X_AXIS_MIN;
    dev.absmax[ABS_Y] = Y_AXIS_MAX;
    dev.absmin[ABS_Y] = Y_AXIS_MIN;
    dev.absmax[ABS_PRESSURE] = PRESSURE_MAX;
    dev.absmin[ABS_PRESSURE] = PRESSURE_MIN;
    write(fd_mouse, &dev, sizeof(dev));

    ioctl(fd_mouse, UI_SET_EVBIT, EV_KEY);
    ioctl(fd_mouse, UI_SET_EVBIT, EV_ABS);
    ioctl(fd_mouse, UI_SET_EVBIT, EV_SYN);

    ioctl(fd_mouse, UI_SET_ABSBIT, ABS_X);
    ioctl(fd_mouse, UI_SET_ABSBIT, ABS_Y);
    ioctl(fd_mouse, UI_SET_ABSBIT, ABS_PRESSURE);
// ioctl(fd_mouse, UI_SET_RELBIT, REL_WHEEL);

// ioctl(fd_mouse, UI_SET_KEYBIT, BTN_LEFT);
// ioctl(fd_mouse, UI_SET_KEYBIT, BTN_RIGHT);
// ioctl(fd_mouse, UI_SET_KEYBIT, BTN_MIDDLE);
    ioctl(fd_mouse, UI_SET_KEYBIT, BTN_TOUCH);

    if (ioctl(fd_mouse, UI_DEV_CREATE) != 0) { perror("set evbit: UI_DEV_CREATE"); close(fd_mouse); return -1; }
  } // end of [if]

  return fd_mouse;
};

int dev_uinput_init_kbd(char* name) {
  struct uinput_user_dev dev;
  int
    fd_keyb,   // FileHandle for Key-Events

    aux;

  fd_keyb =  uinput_open_device();

  if (fd_keyb) {
    memset(&dev, 0, sizeof(dev));
    strncpy(dev.name, name, UINPUT_MAX_NAME_SIZE);

    dev.id.bustype = BUS_HOST;
    dev.id.vendor  = 0x1F;
    dev.id.product = 0x1F;
    dev.id.version = 0x00;
    write(fd_keyb, &dev, sizeof(dev));

    if (ioctl(fd_keyb, UI_SET_EVBIT, EV_KEY) != 0) { perror("set evbit: EV_KEY"); close(fd_keyb); return -1; }
    if (ioctl(fd_keyb, UI_SET_EVBIT, EV_REP) != 0) { perror("set evbit: EV_REP"); close(fd_keyb); return -1; }
    for (aux = KEY_RESERVED; aux <= KEY_UNKNOWN; aux++)
      if (ioctl(fd_keyb, UI_SET_KEYBIT, aux) != 0) { perror("set evbit: UI_SET_KEYBIT"); close(fd_keyb); return -1; }

    if (ioctl(fd_keyb, UI_DEV_CREATE) != 0) { perror("set evbit: UI_DEV_CREATE"); close(fd_keyb); return -1; }
  } // end of [if]
  return fd_keyb;
}

int dev_uinput_key(int fd, unsigned short code, int pressed) {
  struct input_event event;

        memset(&event, 0, sizeof(event));
        event.type  = EV_KEY;
        event.code  = code;
        event.value = pressed;

  return (write(fd, &event, sizeof(event)));
}

void ptr_abs(int fd, int x, int y) {
 struct input_event event;
        memset(&event, 0, sizeof(event));

        gettimeofday(&event.time, NULL);
        event.type  = EV_ABS;
        event.code  = ABS_X;
        event.value = x;
        write(fd, &event, sizeof(event));

        gettimeofday(&event.time, NULL);
        event.type  = EV_ABS;
        event.code  = ABS_Y;
        event.value = y;
        write(fd, &event, sizeof(event));
}

void dev_uinput_sync(int fd) {
        struct input_event ev;

        gettimeofday(&ev.time, NULL);
        ev.type  = EV_SYN;
        ev.code  = SYN_REPORT;
        ev.value = 0;
        write(fd, &ev, sizeof(ev));
}

void button_click(int fd, int down) {
        struct input_event ev;
        int
          pressure = 0;

        if (down) { pressure = 10000; }

        memset(&ev, 0, sizeof(ev));
        gettimeofday(&ev.time, NULL);

        ev.type  = EV_KEY;
        ev.value = down;
        ev.code  = BTN_TOUCH;
        // ev.code  = BTN_LEFT;
        write(fd, &ev, sizeof(ev));

        ev.type = EV_ABS;
        ev.value = pressure;
        ev.code = ABS_PRESSURE;
        write(fd, &ev, sizeof(ev));
}

void dev_uinput_close(int fd) {
        ioctl(fd, UI_DEV_DESTROY);
        close(fd);

}

---