Android输入系统(一)

首先我们明白，在PC或者手机上我们都支持热插拔，比如现在有个键盘，现在键盘插入USB接口，就会检测到。那么系统怎么知道有设备插入，又怎么识别这个设备呢？

---

设备识别的两种方式

一.hotplug机制    1.内核发现键盘接入或者拔出    2.启动一个进程(hotplug进程)    3.进程发送消息告诉输入系统    4.这个输入系统处理这个消息二.inotify机制    系统检测/dev/input目录    发生变化进行对应处理

当然Android系统就是使用inotify机制，而使用inotify机制的核心是：

• inotify函数（用于监测目录中文件是否有删除，增加等）
• epoll函数（用于监测多个文件内容的变化）
  
  • 有无数据读入
  • 有无数据读出

储备知识一（监测文件）

使用inotify函数流程

@(参考frameworks\native\services\inputflinger\EventHub.cpp)
- fd=inotify_init()—用于初始化
- inotify_add_watch(目录名称,监测类型)—用于查看什么东西
- read(fd,…)—用于读取监测结果，返回值是inotify_event结构体

#include <unistd.h>#include <stdio.h>#include <sys/inotify.h>#include <string.h>#include <errno.h>int read_process_inotify_fd(int fd){    int res;    char event_buf[512];    int event_size;    int event_pos = 0;    struct inotify_event *event;    /* 此时read函数为阻塞式 */      res = read(fd, event_buf, sizeof(event_buf));    if(res < (int)sizeof(*event)) {        if(errno == EINTR)            return 0;        printf("could not get event, %s\n", strerror(errno));        return -1;    }    /*      * 读到的数据是1个或多个inotify_event     * 由于结构体的长度不一样     * 所以逐个处理     */    while(res >= (int)sizeof(*event)) {        event = (struct inotify_event *)(event_buf + event_pos);        if(event->len) {            if(event->mask & IN_CREATE) {                printf("create file: %s\n", event->name);            } else {                printf("delete file: %s\n", event->name);            }        }        event_size = sizeof(*event) + event->len;        res -= event_size;        event_pos += event_size;    }    return 0;}int main(int argc, char **argv){    int mINotifyFd;    int result;    if (argc != 2)    {        printf("Usage: %s <dir>\n", argv[0]);        return -1;    }    /* inotify_init */    mINotifyFd = inotify_init();    /* add watch */    result = inotify_add_watch(mINotifyFd, argv[1], IN_DELETE | IN_CREATE);    /* read */    while (1)    {        read_process_inotify_fd(mINotifyFd);    }    return 0;}

测试方法

$ gcc -o inotify inotify.c$ mkdir tmp$ ./inotify tmp &$ echo > tmp/1$ echo > tmp/2$ rm tmp/1 tmp/2

使用epoll函数流程

@(参考frameworks\native\services\inputflinger\EventHub.cpp)
- epoll_create()—创建fd
- 对每个文件执行epoll_ctl(…,EPOLL_CTL_ADD,…)—表示监测
- 执行epoll_wait(等待某个文件可用)
- 不再想监测某文件，可以执行epoll_ctl(…,EPOLL_CTL_DEL,…)

#include <sys/epoll.h>#include <stdio.h>#include <unistd.h>#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>#include <string.h>#if 0typedef union epoll_data {   void        *ptr;   int          fd;   uint32_t     u32;   uint64_t     u64;} epoll_data_t;#endif#define DATA_MAX_LEN 500/* usage: epoll <file1> [file2] [file3] ... */int add_to_epoll(int fd, int epollFd){    int result;    struct epoll_event eventItem;    memset(&eventItem, 0, sizeof(eventItem));    eventItem.events = EPOLLIN;//当文件有数据的时候就可以监测到    eventItem.data.fd = fd;    result = epoll_ctl(epollFd, EPOLL_CTL_ADD, fd, &eventItem);    return result;}/*从epoll中删除需要监测的文件*/void rm_from_epoll(int fd, int epollFd){    epoll_ctl(epollFd, EPOLL_CTL_DEL, fd, NULL);}int main(int argc, char **argv){    int mEpollFd;    int i;    char buf[DATA_MAX_LEN];    // Maximum number of signalled FDs to handle at a time.    static const int EPOLL_MAX_EVENTS = 16;    // The array of pending epoll events and the index of the next event to be handled.    struct epoll_event mPendingEventItems[EPOLL_MAX_EVENTS];    if (argc < 2)    {        printf("Usage: %s <file1> [file2] [file3] ...\n", argv[0]);        return -1;    }    /* epoll_create */    mEpollFd = epoll_create(8);    /* for each file:     * open it     * add it to epoll: epoll_ctl(...EPOLL_CTL_ADD...)     */    for (i = 1; i < argc; i++)       {        //int tmpFd = open(argv[i], O_RDONLY|O_NONBLOCK);        int tmpFd = open(argv[i], O_RDWR);        add_to_epoll(tmpFd, mEpollFd);    }    /* epoll_wait */    while (1)    {        int pollResult = epoll_wait(mEpollFd, mPendingEventItems, EPOLL_MAX_EVENTS, -1);        for (i = 0; i < pollResult; i++)        {            printf("Reason: 0x%x\n", mPendingEventItems[i].events);            int len = read(mPendingEventItems[i].data.fd, buf, DATA_MAX_LEN);            buf[len] = '\0';            printf("get data: %s\n", buf);            //sleep(3);        }    }    return 0;}

测试方法

$ gcc -o -epoll epoll.c$ mkfifo tmp/2$ ./epoll tmp /1 tmp/2 tmp/3$ echo aa>tmp/1$ echo bb>tmp/2

储备知识二（通信）

首先思考一个问题，如果让你自己设计一个输入系统会怎么做呢？

• 首先创建一个进程，用于读取分发那些事件
• 写出应用程序，用于处理应用事件，并对进程状态做出回馈

@(可以看出读取进程和APP进程之间是需要双向通信)

此时我们知道Binder系统在Android中承担大部分的进程通信角色
但是在输入系统中，是不是照样适用呢？答案是否定的。
因为Binder是单向通信，Clinet发出指令，Server接收指令，Server不能主动
如果需要双向通信，Binder的任何一端口都是Server+Client，这样会使得系统很复杂。所以输入系统中用的是SocketPair

缺点：（只适用如下情况：）

• 适用于线程通信
• 具有亲缘关系的进程间通信

如果我们要在两个APP之间进行通讯，那就必须把其中的一个文件句柄比如fd2通过Binder传递给另一个APP

使用socketpair函数流程

@(参考frameworks\native\libs\input\InputTransport.cpp)
- pthread_create—创建线程1
- read—读数据: 线程1发出的数据
- sprintf—main thread向thread1 发出: Hello, thread1
- 子线程sprintf— 向 main线程发出: Hello, main thread
- read—读取数据(main线程发回的数据)

#include <pthread.h>#include <unistd.h>#include <stdio.h>#include <sys/types.h>         #include <sys/socket.h>#define SOCKET_BUFFER_SIZE      (32768U)void *function_thread1 (void *arg){    int fd = (int)arg;    char buf[500];    int len;    int cnt = 0;    while (1)    {        /* 向 main线程发出: Hello, main thread  */        len = sprintf(buf, "Hello, main thread, cnt = %d", cnt++);        write(fd, buf, len);        /* 读取数据(main线程发回的数据) */        len = read(fd, buf, 500);        buf[len] = '\0';        printf("%s\n", buf);        sleep(5);    }    return NULL;}int main(int argc, char **argv){    int sockets[2];    socketpair(AF_UNIX, SOCK_SEQPACKET, 0, sockets);    int bufferSize = SOCKET_BUFFER_SIZE;    setsockopt(sockets[0], SOL_SOCKET, SO_SNDBUF, &bufferSize, sizeof(bufferSize));    setsockopt(sockets[0], SOL_SOCKET, SO_RCVBUF, &bufferSize, sizeof(bufferSize));    setsockopt(sockets[1], SOL_SOCKET, SO_SNDBUF, &bufferSize, sizeof(bufferSize));    setsockopt(sockets[1], SOL_SOCKET, SO_RCVBUF, &bufferSize, sizeof(bufferSize));    /* 创建线程1 */    pthread_t threadID;    pthread_create(&threadID, NULL, function_thread1, (void *)sockets[1]);    char buf[500];    int len;    int cnt = 0;    int fd = sockets[0];    while(1)    {        /* 读数据: 线程1发出的数据 */        len = read(fd, buf, 500);        buf[len] = '\0';        printf("%s\n", buf);        /* main thread向thread1 发出: Hello, thread1 */        len = sprintf(buf, "Hello, thread1, cnt = %d", cnt++);        write(fd, buf, len);    }}

测试方法

gcc -o socketpair socketpari.c -lpthread./socketpari

既然我们上面说了，socketpair不能在不同APP之间通信，那么怎么做才达到在不同APP之间通信的目的呢？
@(要明白这个道理，就必须了解文件句柄与进程和线程的关系)

我们知道task_struct表示进程结构体，在进程结构体中有struct files_struct * files;
struct files_struct中有struct file __ruc **fd;数组这个数组的下标就是对应的fd。
同样对于进程2也会有一个数组
此时如果我要把APP1进程里面的fd传递给APP2，此时就会先在APP2的进程的file__ruc数组中找出一个空项，然后让这个空项指向APP1对应的file__ruc[X]
使用binder传输file\__ruc[X]