Difference between revisions of "Uinput"

From Ilianko
 
(26 intermediate revisions by the same user not shown)
Line 1: Line 1:
−
== Виртуална устройство ==
+
==Вход от потрeбителско ниво==
 +
 
 +
Uinput е модул за linux ядрото, който позволява управление на системата за входни данни от приложения работещи на потребителско ниво. Модулът uinput създава виртуално входно устройство.
 +
 
 +
===Създаване на входно устройство===
 +
 
 +
След инсталиране на модула uinput (чрез modprobe или insmod) се създава устройство от буквен тип с име /dev/input/uinput (или /dev/uinput). Това устройство представлява интерфейса между приложението и системата за входни данни на ядрото.
 +
 
 +
За да се използва uinput, то устройството трябва трябва да се отвори само за запис и в неблокиращ режим.
 +
 
 +
#include <linux/input.h>
 +
#include <linux/uinput.h>
 +
...
 +
 +
int fd;
 +
 +
fd = open("/dev/input/uinput", O_WRONLY | O_NONBLOCK);
 +
if(fd < 0) {
 +
    ...
 +
    exit(EXIT_FAILURE);
 +
}
 +
 
 +
 
 +
===Дефиниране на входни събития===
 +
След като е отворено устройството трябва да се конфигурира. Първо трябва да се инициализират типовете входни събития, които ще се ползват. Типовете събития са дефинирани в /usr/include/linux/input.h.
 +
 
 +
Активиране на събития чрез [http://en.wikipedia.org/wiki/Ioctl ioctl]. Следните редове активират събития натискане/отпускане на бутон и синхронизация.
 +
 
 +
 
 +
*EV_KEY събитие за натиснат или отпуснат бутон от клавиатурата,
 +
*EV_REL събитие за относително отместване (преместване на мишка),
 +
*EV_ABS събитие за абсолютно отместване  (позиция от сензорен екран).
 +
*EV_SYN синхронизиращо събитие (изпраща се винаги след движение по относителни координати (мишка)
 +
*EV_REP повтаряне на бутон ???
 +
 
 +
ioctl(fd, UI_SET_EVBIT, EV_KEY);
 +
ioctl(fd, UI_SET_EVBIT, EV_SYN);
 +
ioctl(fd, UI_SET_EVBIT, EV_ABS);
 +
ioctl(fd, UI_SET_EVBIT, EV_REL);
 +
ioctl(fd, UI_SET_EVBIT, EV_REP);
 +
 
 +
===Дефиниране на състояния на събитие===
 +
 
 +
====EV_KEY====
 +
При активиране на ЕV_KEY събитие, трябва да се опишат и възможните бутони, които ще бъдат изпращани. За 'd' се дефинира по следния начин:
 +
 +
ioctl(fd, UI_SET_KEYBIT, KEY_D);
 +
 
 +
Дефиниране на поддръжка на всички възможни бутони
 +
for (i = 0; i < KEY_MAX; i++) {
 +
        if (ioctl(fd, UI_SET_KEYBIT, i) == -1)
 +
            exit(11);
 +
    }
 +
====EV_REL====
 +
Дефиниране на отместване по x i y.
 +
ioctl(fd, UI_SET_RELBIT, REL_X);
 +
ioctl(fd, UI_SET_RELBIT, REL_Y);
 +
 
 +
====EV_ABS====
 +
Дефиниране на отместване по абсолютни координати. Може да работи или относително или абсолютно отместванепо.
 +
ioctl(fd, UI_SET_ABSBIT, ABS_X)
 +
ioctl(fd, UI_SET_ABSBIT, ABS_Y)
 +
ioctl(fd, UI_SET_ABSBIT, 0)
 +
 
 +
===Допълнително конфигуриране===
 +
Задават се:
 +
*Име на входното устойство
 +
*id - описва типа на шината, ...
 +
*absmin and absmax цели числа описващи минимална и максимална координати.
 +
 
 +
struct uinput_user_dev udev
 +
 
 +
memset(&uidev, 0, sizeof(uidev));
 +
snprintf(uidev.name, UINPUT_MAX_NAME_SIZE, "uinput-sample");
 +
uidev.id.bustype = BUS_USB;
 +
uidev.id.vendor  = 0x1;
 +
uidev.id.product = 0x1;
 +
uidev.id.version = 1;
 +
 +
/* необходими само ако се работи с абсолютни координати
 +
uidev.absmin[ABS_X] = -600; //Минимална координата
 +
uidev.absmax[ABS_X] = 600;
 +
uidev.absfuzz[ABS_X] = 0;
 +
uidev.absflat[ABS_X] = 0;
 +
 
 +
uidev.absmin[ABS_Y] = -400;
 +
uidev.absmax[ABS_Y] = 400;
 +
uidev.absfuzz[ABS_Y] = 0;
 +
uidev.absflat[ABS_Y] = 0;
 +
*/
 +
write(fd, &uidev, sizeof(uidev)
 +
 
 +
===Създаване на устройството===
 +
 +
ioctl(fd, UI_DEV_CREATE);
 +
 
 +
===Генериране на събитие===
 +
 
 +
 
 +
*type: EV_KEY, EV_ABS, EV_REL, EV_SYN;
 +
*code: EV_KEY, EV_ABS, EV_REL, SYN_REPORT;
 +
*value: 1 (натискане), 0 (отпускане), (2) задаържане за EV_KEY, или цели числа за EV_ABS и EV_REL.
 +
 
 +
Инжектиране:
 +
  struct input_event event;
 +
  memset(&event, 0, sizeof(event));
 +
  gettimeofday(&event.time, 0); /* This should not be able to fail ever.. */
 +
  event.type = type;
 +
  event.code = code;
 +
  event.value = value;
 +
  write(uinput_fd, &event, sizeof(event)
 +
 
 +
!! След събитие за отнисително движение се изпраща, събитие за синхронизация
 +
!! След събитие за натискане на бутон, трябва да се изпрати събитие за отпускане
 +
 
 +
=== Затваряне на устройството ===
 +
ioctl(fd, UI_DEV_DESTROY);
 +
 
 +
== Виртуално устройство ==
  
 
<code><pre>
 
<code><pre>
 
#include <stdio.h>
 
#include <stdio.h>
 +
#include <string.h>
 
#include <stdlib.h>
 
#include <stdlib.h>
−
#include <string.h>
 
 
#include <unistd.h>
 
#include <unistd.h>
 
#include <fcntl.h>
 
#include <fcntl.h>
−
#include <errno.h>
 
−
#include <linux/input.h>
 
 
#include <linux/uinput.h>
 
#include <linux/uinput.h>
 +
#include <stdint.h>
  
−
#define die(str, args...) do { \
+
int suinput_write(int uinput_fd, uint16_t type, uint16_t code, int32_t value)
−
        perror(str); \
 
−
        exit(EXIT_FAILURE); \
 
−
    } while(0)
 
−
 
 
−
int
 
−
main(void)
 
 
{
 
{
−
     int                    fd;
+
     //генериране на събитие
−
     struct uinput_user_dev uidev;
+
    struct input_event event;
−
     struct input_event     ev;
+
     memset(&event, 0, sizeof(event));
−
     int                    dx, dy;
+
    gettimeofday(&event.time, 0); /* This should not be able to fail ever.. */
−
     int                    i;
+
    event.type = type;
 +
     event.code = code;
 +
     event.value = value;
 +
     if (write(uinput_fd, &event, sizeof(event)) != sizeof(event))
 +
        return -1;
 +
     return 0;
 +
}
  
−
    fd = open("/dev/uinput", O_WRONLY | O_NONBLOCK);
+
int suinput_write_syn(int uinput_fd,
−
     if(fd < 0)
+
                            uint16_t type, uint16_t code, int32_t value)
−
         die("error: open");
+
{ // синхронизиращо събитир
 +
     if (suinput_write(uinput_fd, type, code, value))
 +
         return -1;
 +
    return suinput_write(uinput_fd, EV_SYN, SYN_REPORT, 0);
 +
}
  
−
    if(ioctl(fd, UI_SET_EVBIT, EV_KEY) < 0)
+
int suinput_move_pointer(int uinput_fd, int32_t x, int32_t y)
−
        die("error: ioctl");
+
{ //относително отместване
−
     if(ioctl(fd, UI_SET_KEYBIT, BTN_LEFT) < 0)
+
     if (suinput_write(uinput_fd, EV_REL, REL_X, x))
−
         die("error: ioctl");
+
         return -1;
 +
    return suinput_write_syn(uinput_fd, EV_REL, REL_Y, y);
 +
}
  
−
    if(ioctl(fd, UI_SET_EVBIT, EV_REL) < 0)
 
−
        die("error: ioctl");
 
−
    if(ioctl(fd, UI_SET_RELBIT, REL_X) < 0)
 
−
        die("error: ioctl");
 
−
    if(ioctl(fd, UI_SET_RELBIT, REL_Y) < 0)
 
−
        die("error: ioctl");
 
  
−
    memset(&uidev, 0, sizeof(uidev));
+
int suinput_open(const char* device_name, int abs)
−
  snprintf(uidev.name, UINPUT_MAX_NAME_SIZE, "uinput-sample");
+
{
 +
//създаване на устройство
 +
  int fd, i;
 +
  struct uinput_user_dev uidev;
 +
 +
  fd = open( device_name, O_WRONLY | O_NONBLOCK);
 +
  if (fd == -1)
 +
        exit(1);
 +
 
 +
  memset(&uidev, 0, sizeof(uidev));
 +
    snprintf(uidev.name, UINPUT_MAX_NAME_SIZE, "uinput-sample");
 
     uidev.id.bustype = BUS_USB;
 
     uidev.id.bustype = BUS_USB;
 
     uidev.id.vendor  = 0x1;
 
     uidev.id.vendor  = 0x1;
 
     uidev.id.product = 0x1;
 
     uidev.id.product = 0x1;
 
     uidev.id.version = 1;
 
     uidev.id.version = 1;
 +
  /* Set device to handle following types of events: */
 +
 +
  /* Key and button events */
 +
  if (ioctl(fd, UI_SET_EVBIT, EV_KEY) == -1)
 +
      exit(2);
 +
 +
  /* Key and button repetition events */
 +
  if (ioctl(fd, UI_SET_EVBIT, EV_REP) == -1)
 +
      exit(3);
 +
 
 +
  /* Synchronization events, this is probably set implicitely too. */
 +
    if (ioctl(fd, UI_SET_EVBIT, EV_SYN) == -1)
 +
        exit(3);
 +
 +
if (abs)
 +
{
 +
if (ioctl(fd, UI_SET_EVBIT, EV_REL) == -1)
 +
        exit(3);
 +
 +
/* Configure device to handle relative x and y axis. */
 +
if (ioctl(fd, UI_SET_RELBIT, REL_X) == -1)
 +
exit(3);
 +
   
 +
if (ioctl(fd, UI_SET_RELBIT, REL_Y) == -1)
 +
exit(3);
 +
 +
}
 +
else
 +
{/* Configure device to handle absolute x and y axis. */
 +
if (ioctl(fd, UI_SET_EVBIT, EV_ABS) == -1)
 +
exit(4);
 +
 +
if (ioctl(fd, UI_SET_ABSBIT, ABS_X) == -1)
 +
exit(4);
 +
if (ioctl(fd, UI_SET_ABSBIT, ABS_Y) == -1)
 +
        exit(4);
 +
if (ioctl(fd, UI_SET_ABSBIT, 0) == -1)
 +
exit(4);
 +
 +
uidev.absmin[ABS_X] = -600;
 +
uidev.absmax[ABS_X] = 600;
 +
uidev.absfuzz[ABS_X] = 0;
 +
uidev.absflat[ABS_X] = 0;
 +
 +
uidev.absmin[ABS_Y] = -400;
 +
uidev.absmax[ABS_Y] = 400;
 +
uidev.absfuzz[ABS_Y] = 0;
 +
uidev.absflat[ABS_Y] = 0;
 +
}
 +
 +
    /* Configure device to handle all keys, see linux/input.h. */
 +
    for (i = 0; i < KEY_MAX; i++) {
 +
        if (ioctl(fd, UI_SET_KEYBIT, i) == -1)
 +
            exit(11);
 +
    }
  
 
     if(write(fd, &uidev, sizeof(uidev)) < 0)
 
     if(write(fd, &uidev, sizeof(uidev)) < 0)
−
         die("error: write");
+
         exit(10);
−
 
+
   
 
     if(ioctl(fd, UI_DEV_CREATE) < 0)
 
     if(ioctl(fd, UI_DEV_CREATE) < 0)
−
         die("error: ioctl");
+
         exit(12);
 +
   
 +
    /*
 +
  The reason for generating a small delay is that creating succesfully
 +
  an uinput device does not guarantee that the device is ready to process
 +
  input events. It's probably due the asynchronous nature of the udev.
 +
  However, my experiments show that the device is not ready to process input
 +
  events even after a device creation event is received from udev.
 +
  */
 +
    sleep(2);    return fd;
 +
}
  
−
     sleep(20);
+
int suinput_press(int uinput_fd, uint16_t code)
 +
{
 +
     return suinput_write(uinput_fd, EV_KEY, code, 1);
 +
}
  
−
   
+
int suinput_release(int uinput_fd, uint16_t code)
−
 
+
{
−
            dx = -100;
+
    return suinput_write_syn(uinput_fd, EV_KEY, code, 0);
−
            dy = -10;
+
}
−
         
 
−
     
 
−
            memset(&ev, 0, sizeof(struct input_event));
 
−
            ev.type = EV_REL;
 
−
            ev.code = REL_X;
 
−
            ev.value = dx;
 
−
            if(write(fd, &ev, sizeof(struct input_event)) < 0)
 
−
                die("error: write");
 
  
−
            memset(&ev, 0, sizeof(struct input_event));
 
−
            ev.type = EV_REL;
 
−
            ev.code = REL_Y;
 
−
            ev.value = dy;
 
−
            if(write(fd, &ev, sizeof(struct input_event)) < 0)
 
−
                die("error: write");
 
  
−
            memset(&ev, 0, sizeof(struct input_event));
+
int suinput_set_pointer(int uinput_fd, int32_t x, int32_t y)
−
            ev.type = EV_SYN;
+
{
−
            ev.code = 0;
+
    if (suinput_write(uinput_fd, EV_ABS, ABS_X, x))
−
            ev.value = 0;
+
        return -1;
−
            if(write(fd, &ev, sizeof(struct input_event)) < 0)
+
    return suinput_write_syn(uinput_fd, EV_ABS, ABS_Y, y);
−
                die("error: write");
+
}
  
−
            usleep(15000);
+
int suinput_click(int uinput_fd, uint16_t code)
−
     
+
{
 +
    if (suinput_press(uinput_fd, code))
 +
        return -1;
 +
    return suinput_release(uinput_fd, code);
 +
}
  
−
     if(ioctl(fd, UI_DEV_DESTROY) < 0)
+
int suinput_close(int uinput_fd)
−
        die("error: ioctl");
+
{
 +
    /*
 +
     Sleep before destroying the device because there still can be some
 +
    unprocessed events. This is not the right way, but I am still
 +
    looking for better ways. The question is: how to know whether there
 +
    are any unprocessed uinput events?
 +
  */
 +
    //sleep(2);
  
−
     close(fd);
+
     if (ioctl(uinput_fd, UI_DEV_DESTROY) == -1) {
 +
        close(uinput_fd);
 +
        return -1;
 +
    }
 +
 
 +
    if (close(uinput_fd) == -1)
 +
        return -1;
  
 
     return 0;
 
     return 0;
 
}
 
}
  
 +
 +
int main(void)
 +
{
 +
     
 +
  int  fd;
 +
  fd = suinput_open("/dev/uinput", 0); // 0 - absolute , 1 relative
 +
     
 +
     
 +
  //suinput_move_pointer(fd, 130,130);
 +
  suinput_set_pointer(fd, 60, 60);
 +
 
 +
  suinput_press(fd, 2);
 +
  suinput_release(fd, 2);
 +
  usleep(10000);
 +
  suinput_click(fd,  BTN_LEFT);
 +
 
 +
  usleep(10000);
 +
 
 +
  // suinput_click(fd,  BTN_RIGHT);
 +
  suinput_set_pointer(fd, -60, -60);
 +
  usleep(10000);
 +
 
 +
  suinput_click(fd,  BTN_LEFT);
 +
     
 +
  suinput_press(fd, 3);
 +
  suinput_press(fd, 5);
 +
     
 +
  suinput_close(fd);
 +
 
 +
  return 0;
 +
}
 
</pre></code>
 
</pre></code>
  
 +
 +
== Да се създаде виртуална мишка, която да се управлява чрез стрелките ==
 +
 +
Използвайте директен достъп до клавитурата:
 
<code><pre>
 
<code><pre>
 
#include <linux/input.h>
 
#include <linux/input.h>
Line 127: Line 360:
 
</pre></code>
 
</pre></code>
  
−
== chmod ==
 
−
 
−
~$ sudo chmod 777 /dev/input/event3
 
−
~$ sudo chmod 777 /dev/uinput
 
  
 +
==Връзки==
 +
*[http://thiemonge.org/getting-started-with-uinput Getting started with uinput: the user level input subsystem]
 +
*http://remoteroid.googlecode.com/svn-history/r277/trunk/android/jni/suinput.cpp
  
−
http://web.me.com/haroldsoh/tutorials/technical-skills/using-optical-mice-for-othe-2/
 
 
[[Category:Компютърна периферия]]
 
[[Category:Компютърна периферия]]

Latest revision as of 10:11, 31 March 2013

Вход от потрeбителско ниво

Uinput е модул за linux ядрото, който позволява управление на системата за входни данни от приложения работещи на потребителско ниво. Модулът uinput създава виртуално входно устройство.

Създаване на входно устройство

След инсталиране на модула uinput (чрез modprobe или insmod) се създава устройство от буквен тип с име /dev/input/uinput (или /dev/uinput). Това устройство представлява интерфейса между приложението и системата за входни данни на ядрото.

За да се използва uinput, то устройството трябва трябва да се отвори само за запис и в неблокиращ режим. 

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

int fd;

fd = open("/dev/input/uinput", O_WRONLY | O_NONBLOCK);
if(fd < 0) {
   ...
   exit(EXIT_FAILURE);
}


Дефиниране на входни събития

След като е отворено устройството трябва да се конфигурира. Първо трябва да се инициализират типовете входни събития, които ще се ползват. Типовете събития са дефинирани в /usr/include/linux/input.h.

Активиране на събития чрез ioctl. Следните редове активират събития натискане/отпускане на бутон и синхронизация.


  • EV_KEY събитие за натиснат или отпуснат бутон от клавиатурата,
  • EV_REL събитие за относително отместване (преместване на мишка),
  • EV_ABS събитие за абсолютно отместване (позиция от сензорен екран).
  • EV_SYN синхронизиращо събитие (изпраща се винаги след движение по относителни координати (мишка)
  • EV_REP повтаряне на бутон ???
ioctl(fd, UI_SET_EVBIT, EV_KEY);
ioctl(fd, UI_SET_EVBIT, EV_SYN);
ioctl(fd, UI_SET_EVBIT, EV_ABS); 
ioctl(fd, UI_SET_EVBIT, EV_REL);
ioctl(fd, UI_SET_EVBIT, EV_REP);

Дефиниране на състояния на събитие

EV_KEY

При активиране на ЕV_KEY събитие, трябва да се опишат и възможните бутони, които ще бъдат изпращани. За 'd' се дефинира по следния начин: 

ioctl(fd, UI_SET_KEYBIT, KEY_D);

Дефиниране на поддръжка на всички възможни бутони 

for (i = 0; i < KEY_MAX; i++) {
       if (ioctl(fd, UI_SET_KEYBIT, i) == -1)
           exit(11);
   }

EV_REL

Дефиниране на отместване по x i y. 

ioctl(fd, UI_SET_RELBIT, REL_X);
ioctl(fd, UI_SET_RELBIT, REL_Y);

EV_ABS

Дефиниране на отместване по абсолютни координати. Може да работи или относително или абсолютно отместванепо. 

ioctl(fd, UI_SET_ABSBIT, ABS_X)
ioctl(fd, UI_SET_ABSBIT, ABS_Y)
ioctl(fd, UI_SET_ABSBIT, 0)

Допълнително конфигуриране

Задават се:

  • Име на входното устойство
  • id - описва типа на шината, ...
  • absmin and absmax цели числа описващи минимална и максимална координати.
struct uinput_user_dev udev

memset(&uidev, 0, sizeof(uidev));
snprintf(uidev.name, UINPUT_MAX_NAME_SIZE, "uinput-sample");
uidev.id.bustype = BUS_USB;
uidev.id.vendor  = 0x1;
uidev.id.product = 0x1;
uidev.id.version = 1;

/* необходими само ако се работи с абсолютни координати 
uidev.absmin[ABS_X] = -600; //Минимална координата
uidev.absmax[ABS_X] = 600;
uidev.absfuzz[ABS_X] = 0;
uidev.absflat[ABS_X] = 0;

uidev.absmin[ABS_Y] = -400;
uidev.absmax[ABS_Y] = 400;
uidev.absfuzz[ABS_Y] = 0;
uidev.absflat[ABS_Y] = 0;	
*/
write(fd, &uidev, sizeof(uidev)

Създаване на устройството

ioctl(fd, UI_DEV_CREATE);

Генериране на събитие

  • type: EV_KEY, EV_ABS, EV_REL, EV_SYN;
  • code: EV_KEY, EV_ABS, EV_REL, SYN_REPORT;
  • value: 1 (натискане), 0 (отпускане), (2) задаържане за EV_KEY, или цели числа за EV_ABS и EV_REL.

Инжектиране: 

 struct input_event event;
 memset(&event, 0, sizeof(event));
 gettimeofday(&event.time, 0); /* This should not be able to fail ever.. */
 event.type = type;
 event.code = code;
 event.value = value;
 write(uinput_fd, &event, sizeof(event)

!! След събитие за отнисително движение се изпраща, събитие за синхронизация !! След събитие за натискане на бутон, трябва да се изпрати събитие за отпускане

Затваряне на устройството

ioctl(fd, UI_DEV_DESTROY);

Виртуално устройство

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <linux/uinput.h>
#include <stdint.h>

int suinput_write(int uinput_fd, uint16_t type, uint16_t code, int32_t value)
{
    //генериране на събитие
    struct input_event event;
    memset(&event, 0, sizeof(event));
    gettimeofday(&event.time, 0); /* This should not be able to fail ever.. */
    event.type = type;
    event.code = code;
    event.value = value;
    if (write(uinput_fd, &event, sizeof(event)) != sizeof(event))
        return -1;
    return 0;
}

int suinput_write_syn(int uinput_fd, 
                             uint16_t type, uint16_t code, int32_t value)
{	// синхронизиращо събитир
    if (suinput_write(uinput_fd, type, code, value))
        return -1;
    return suinput_write(uinput_fd, EV_SYN, SYN_REPORT, 0);
}

int suinput_move_pointer(int uinput_fd, int32_t x, int32_t y)
{	//относително отместване
    if (suinput_write(uinput_fd, EV_REL, REL_X, x))
        return -1;
    return suinput_write_syn(uinput_fd, EV_REL, REL_Y, y);
}


int suinput_open(const char* device_name, int abs)
{	
	//създаване на устройство
   int fd, i;
   struct uinput_user_dev uidev;
 
   fd = open( device_name, O_WRONLY | O_NONBLOCK);
   if (fd == -1)
        exit(1);
   
   memset(&uidev, 0, sizeof(uidev));
    snprintf(uidev.name, UINPUT_MAX_NAME_SIZE, "uinput-sample");
    uidev.id.bustype = BUS_USB;
    uidev.id.vendor  = 0x1;
    uidev.id.product = 0x1;
    uidev.id.version = 1;
   /* Set device to handle following types of events: */

   /* Key and button events */
   if (ioctl(fd, UI_SET_EVBIT, EV_KEY) == -1)
       exit(2);

   /* Key and button repetition events */
   if (ioctl(fd, UI_SET_EVBIT, EV_REP) == -1)
       exit(3);
  
   /* Synchronization events, this is probably set implicitely too. */
    if (ioctl(fd, UI_SET_EVBIT, EV_SYN) == -1)
        exit(3);

	if (abs)
	{
		if (ioctl(fd, UI_SET_EVBIT, EV_REL) == -1)
        exit(3);

		/* Configure device to handle relative x and y axis. */
		if (ioctl(fd, UI_SET_RELBIT, REL_X) == -1)
		exit(3);
     
		if (ioctl(fd, UI_SET_RELBIT, REL_Y) == -1)
		exit(3);
	
	}
	else
	{/* Configure device to handle absolute x and y axis. */
		if (ioctl(fd, UI_SET_EVBIT, EV_ABS) == -1)
		exit(4);
		
		if (ioctl(fd, UI_SET_ABSBIT, ABS_X) == -1)
		exit(4);
		if (ioctl(fd, UI_SET_ABSBIT, ABS_Y) == -1)
        exit(4);
		if (ioctl(fd, UI_SET_ABSBIT, 0) == -1)
		exit(4);
	
		uidev.absmin[ABS_X] = -600;
		uidev.absmax[ABS_X] = 600;
		uidev.absfuzz[ABS_X] = 0;
		uidev.absflat[ABS_X] = 0;

		uidev.absmin[ABS_Y] = -400;
		uidev.absmax[ABS_Y] = 400;
		uidev.absfuzz[ABS_Y] = 0;
		uidev.absflat[ABS_Y] = 0;	
	}

    /* Configure device to handle all keys, see linux/input.h. */
    for (i = 0; i < KEY_MAX; i++) {
        if (ioctl(fd, UI_SET_KEYBIT, i) == -1)
            exit(11);
    }

    if(write(fd, &uidev, sizeof(uidev)) < 0)
        exit(10);
    
    if(ioctl(fd, UI_DEV_CREATE) < 0)
        exit(12);
    
    /*
  The reason for generating a small delay is that creating succesfully
  an uinput device does not guarantee that the device is ready to process
  input events. It's probably due the asynchronous nature of the udev.
  However, my experiments show that the device is not ready to process input
  events even after a device creation event is received from udev.
  */
    sleep(2);    return fd;
}

int suinput_press(int uinput_fd, uint16_t code)
{
    return suinput_write(uinput_fd, EV_KEY, code, 1);
}

int suinput_release(int uinput_fd, uint16_t code)
{
    return suinput_write_syn(uinput_fd, EV_KEY, code, 0);
}


int suinput_set_pointer(int uinput_fd, int32_t x, int32_t y)
{
    if (suinput_write(uinput_fd, EV_ABS, ABS_X, x))
        return -1;
    return suinput_write_syn(uinput_fd, EV_ABS, ABS_Y, y);
}

int suinput_click(int uinput_fd, uint16_t code)
{
    if (suinput_press(uinput_fd, code))
        return -1;
    return suinput_release(uinput_fd, code);
}

int suinput_close(int uinput_fd)
{
    /*
    Sleep before destroying the device because there still can be some
    unprocessed events. This is not the right way, but I am still
    looking for better ways. The question is: how to know whether there
    are any unprocessed uinput events?
   */
    //sleep(2);

    if (ioctl(uinput_fd, UI_DEV_DESTROY) == -1) {
        close(uinput_fd);
        return -1;
    }

    if (close(uinput_fd) == -1)
        return -1;

    return 0;
}


int main(void)
{
      
   int  fd;
   fd = suinput_open("/dev/uinput", 0); // 0 - absolute , 1 relative
      
      
   //suinput_move_pointer(fd, 130,130);
   suinput_set_pointer(fd, 60, 60);
   
   suinput_press(fd, 2);
   suinput_release(fd, 2);
   usleep(10000);
   suinput_click(fd,  BTN_LEFT);
   
   usleep(10000);
   
  // suinput_click(fd,  BTN_RIGHT);
   suinput_set_pointer(fd, -60, -60);
   usleep(10000);
   
   suinput_click(fd,  BTN_LEFT);
       
   suinput_press(fd, 3);
   suinput_press(fd, 5);
      
   suinput_close(fd);
  
   return 0;
}


Да се създаде виртуална мишка, която да се управлява чрез стрелките

Използвайте директен достъп до клавитурата: 

#include <linux/input.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>

int main()
{
    int fd;
    struct input_event ev;

    fd = open("/dev/input/event3", O_RDONLY);
    if(fd < 0) {
        printf("error openning");
        return 1;
    }
    
    
    while (1)
    {
    read(fd, &ev, sizeof(struct input_event));

    if(ev.type == 1)
        printf("key %i state %i\n", ev.code, ev.value);

    }
}


Връзки

Retrieved from "https://ilianko.com/index.php?title=Uinput&oldid=4150"