Android 输入系统EventHub
Posted kiydkafa
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Android 输入系统EventHub相关的知识,希望对你有一定的参考价值。
1 EventHub初始化
由上一篇可知,EventHub对象是在NativeInputManager构造函数中创建的。先看一下EventHub构造函数中都做了些什么
- EventHub::EventHub(void) :
- mBuiltInKeyboardId(NO_BUILT_IN_KEYBOARD), mNextDeviceId(1),
- mOpeningDevices(0), mClosingDevices(0),
- mNeedToSendFinishedDeviceScan(false),
- mNeedToReopenDevices(false), mNeedToScanDevices(true),
- mPendingEventCount(0), mPendingEventIndex(0), mPendingINotify(false) {
- acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_ID);
- //创建epoll对象,mEpollFd为epoll对象的描述符
- mEpollFd = epoll_create(EPOLL_SIZE_HINT);
- LOG_ALWAYS_FATAL_IF(mEpollFd < 0, "Could not create epoll instance. errno=%d", errno);
- //创建inotify对象,mINotifyFd为inotify对象的描述符
- mINotifyFd = inotify_init();
- //DEVICE_PATH值为"/dev/input",监听该目录下的设备节点创建与删除操作。通过read函数读取事件。
- int result = inotify_add_watch(mINotifyFd, DEVICE_PATH, IN_DELETE | IN_CREATE);
- LOG_ALWAYS_FATAL_IF(result < 0, "Could not register INotify for %s. errno=%d",
- DEVICE_PATH, errno);
- struct epoll_event eventItem;
- memset(&eventItem, 0, sizeof(eventItem));
- eventItem.events = EPOLLIN; //监听可读事件
- eventItem.data.u32 = EPOLL_ID_INOTIFY;
- //EPOLL_CTL_ADD表示增加事件
- //epoll_ctl将事件监听添加到epoll对象中去。
- result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mINotifyFd, &eventItem);
- LOG_ALWAYS_FATAL_IF(result != 0, "Could not add INotify to epoll instance. errno=%d", errno);
- int wakeFds[2];
- result = pipe(wakeFds);
- LOG_ALWAYS_FATAL_IF(result != 0, "Could not create wake pipe. errno=%d", errno);
- mWakeReadPipeFd = wakeFds[0];
- mWakeWritePipeFd = wakeFds[1];
- result = fcntl(mWakeReadPipeFd, F_SETFL, O_NONBLOCK);
- LOG_ALWAYS_FATAL_IF(result != 0, "Could not make wake read pipe non-blocking. errno=%d",
- errno);
- result = fcntl(mWakeWritePipeFd, F_SETFL, O_NONBLOCK);
- LOG_ALWAYS_FATAL_IF(result != 0, "Could not make wake write pipe non-blocking. errno=%d",
- errno);
- eventItem.data.u32 = EPOLL_ID_WAKE;
- result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mWakeReadPipeFd, &eventItem);
- LOG_ALWAYS_FATAL_IF(result != 0, "Could not add wake read pipe to epoll instance. errno=%d",
- errno);
- }
这段代码主要工作:
1.初始化一些成员变量
2.创建epoll对象,EPOLL_SIZE_HINT = 8代表最大监听数为8.
3.创建inotify对象,监听/dev/input下设备节点的增删。
4.将mINotifyFd添加到epoll中,作为一个监控对象。
5.创建管道,将管道读取端的可读事件添加到epoll中。使epoll_wait()返回,唤醒InputReader线程。
2 EventHub::getEvents()
EventHub的主要工作都是在getEvents函数中,InputReaderThread通过循环调用EventHub的getEvents()函数获取输入事件。getEvents中做了些什么,现在看一看。
- size_t EventHub::getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize) {
- ALOG_ASSERT(bufferSize >= 1);
- AutoMutex _l(mLock);
- struct input_event readBuffer[bufferSize];
- //每存一个事件,event指针向后移动一个元素。
- RawEvent* event = buffer;
- //capacity存buffer中剩余端元素数量,capacity为0,表示buffer已满。
- size_t capacity = bufferSize;
- bool awoken = false;
- for (;;) {
- ...............
- //循环体。
- }
- // All done, return the number of events we read.
- return event - buffer;
- }
以上是getEvents()的整体模型,接着看循环体中的方法。
2.1 重新打开设备(mNeedToReopenDevices)
- //获取系统当前时间(native层的方法)。
- nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
- // Reopen input devices if needed.
- if (mNeedToReopenDevices) {//判断是否需要重新打开设备
- mNeedToReopenDevices = false;
- ALOGI("Reopening all input devices due to a configuration change.");
- closeAllDevicesLocked();//关闭、卸载所有设备
- mNeedToScanDevices = true; //下次扫描设备
- break; // return to the caller before we actually rescan
- }
由EventHub构造函数可知mNeedToReopenDevices为初始值false,第一次调用getEvents()时不会运行上面的代码块。其中调用了closeAllDevicesLocked()函数
void EventHub::closeAllDevicesLocked() {
while (mDevices.size() > 0) {
closeDeviceLocked(mDevices.valueAt(mDevices.size() - 1));
}
}
closeAllDevicesLocked()函数中遍历mDevices,通过closeDeviceLocked()函数卸载所有这些设备。closeDeviceLocked()函数如下
- void EventHub::closeDeviceLocked(Device* device) {
- ALOGI("Removed device: path=%s name=%s id=%d fd=%d classes=0x%x\n",
- device->path.string(), device->identifier.name.string(), device->id,
- device->fd, device->classes);
- if (device->id == mBuiltInKeyboardId) {
- ALOGW("built-in keyboard device %s (id=%d) is closing! the apps will not like this",
- device->path.string(), mBuiltInKeyboardId);
- mBuiltInKeyboardId = NO_BUILT_IN_KEYBOARD;
- }
- //判断是否是虚拟设备
- if (!device->isVirtual()) {
- //从epoll中删除对这些设备的监听
- if (epoll_ctl(mEpollFd, EPOLL_CTL_DEL, device->fd, NULL)) {
- ALOGW("Could not remove device fd from epoll instance. errno=%d", errno);
- }
- }
- //移除设备
- mDevices.removeItem(device->id);
- device->close();
- // Unlink for opening devices list if it is present.
- Device* pred = NULL;
- bool found = false;
- for (Device* entry = mOpeningDevices; entry != NULL; ) {
- if (entry == device) {
- found = true;
- break;
- }
- pred = entry;
- entry = entry->next;
- }
- if (found) {
- // Unlink the device from the opening devices list then delete it.
- // We don‘t need to tell the client that the device was closed because
- // it does not even know it was opened in the first place.
- ALOGI("Device %s was immediately closed after opening.", device->path.string());
- if (pred) {
- pred->next = device->next;
- } else {
- mOpeningDevices = device->next;
- }
- delete device;
- } else {
- // Link into closing devices list.
- // The device will be deleted later after we have informed the client.
- //把这些设备添加到mClosingDevices,用来生成DEVICE_REMOVED事件
- device->next = mClosingDevices;
- mClosingDevices = device;
- }
- }
closeDeviceLocked()函数主要工作:
1.从Epoll中删除监听(EPOLL_CTL_DEL)。
2.mDevices中删除Device对象
3.将删除端Device对象添加到mClosingDevices中。用于之后向InputReader发送DEVICE_REMOVED事件
2.2 DEVICE_REMOVED事件(mClosingDevices)
- // Report any devices that had last been added/removed.
- //遍历mClosingDevices,生成DEVICE_REMOVED事件
- while (mClosingDevices) {
- Device* device = mClosingDevices;
- ALOGV("Reporting device closed: id=%d, name=%s\n",
- device->id, device->path.string());
- mClosingDevices = device->next;
- event->when = now;//设置事件的时间戳
- event->deviceId = device->id == mBuiltInKeyboardId ? BUILT_IN_KEYBOARD_ID : device->id; //设置事件对应的设备id
- event->type = DEVICE_REMOVED; //设在事件类型DEVICE_REMOVED
- event += 1; //event指向下一个RawEvent对象
- delete device; //释放不需要的device
- mNeedToSendFinishedDeviceScan = true;
- //capacity为0时,表示buffer已满,则停止循环将事件返回给调用者(也就是InputReader),剩余的事件等下次getEvents调用
- if (--capacity == 0) {
- break;
- }
- }
mClosingDevices初始值为0,所以刚开始调用getEvents()函数不会运行上述代码块。该块中主要是遍历mClosingDevices,生成DEVICE_REMOVED事件。
2.3 扫描加载设备(mNeedToScanDevices)
- if (mNeedToScanDevices) {
- mNeedToScanDevices = false;
- scanDevicesLocked(); //打开/dev/input下所有输入设备
- mNeedToSendFinishedDeviceScan = true;
- }
mNeedToScanDevices初始值为true,所以第一次getEvents会运行该代码块。该代码块主要工作:
1 mNeedToScanDevices赋值为false,避免重复扫描打开设备。
2 调用scanDevicesLocked(),//打开/dev/input下所有输入设备。
3 mNeedToSendFinishedDeviceScan赋值为true,用于生成FINISHED_DEVICE_SCAN事件。
接着看一下scanDevicesLocked()函数
- void EventHub::scanDevicesLocked() {
- status_t res = scanDirLocked(DEVICE_PATH);
- if(res < 0) {
- ALOGE("scan dir failed for %s\n", DEVICE_PATH);
- }
- //创建一个虚拟的输入设备(这个不太清楚)。
- if (mDevices.indexOfKey(VIRTUAL_KEYBOARD_ID) < 0) {
- createVirtualKeyboardLocked();
- }
- }
scanDevicesLocked()函数中调用了scanDirLocked()函数,接着看scanDirLocked()函数:
- status_t EventHub::scanDirLocked(const char *dirname)
- {
- char devname[PATH_MAX];
- char *filename;
- DIR *dir;
- struct dirent *de;
- dir = opendir(dirname);
- if(dir == NULL)
- return -1;
- strcpy(devname, dirname);
- filename = devname + strlen(devname);
- *filename++ = ‘/‘;
- while((de = readdir(dir))) {
- if(de->d_name[0] == ‘.‘ &&
- (de->d_name[1] == ‘\0‘ ||
- (de->d_name[1] == ‘.‘ && de->d_name[2] == ‘\0‘)))
- continue;
- strcpy(filename, de->d_name);
- openDeviceLocked(devname); //
- }
- closedir(dir);
- return 0;
- }
scanDirLocked()函数遍历/dev/input文件夹下的所有设备节点,并分别执行openDeviceLocked(devname),加载设备。openDeviceLocked()函数比较长,就不全部贴出来了,只将一些重要的部分弄出来。
- status_t EventHub::openDeviceLocked(const char *devicePath) {
- //打开设备节点
- int fd = open(devicePath, O_RDWR | O_CLOEXEC);
- if(fd < 0) {
- ALOGE("could not open %s, %s\n", devicePath, strerror(errno));
- return -1;
- }
- //获取device的name、driver version、id等。
- 。。。。。。
- //创建Device
- int32_t deviceId = mNextDeviceId++;
- Device* device = new Device(fd, deviceId, String8(devicePath), identifier);
- 。。。。。。
- // Load the configuration file for the device. 加载配置信息
- loadConfigurationLocked(device);
- // Figure out the kinds of events the device reports.
- //设置device->classes,为设备分配类别(鼠标、键盘、触摸板等)
- // Register with epoll.将设备节点描述符的可读事件添加到Epoll中。
- struct epoll_event eventItem;
- memset(&eventItem, 0, sizeof(eventItem));
- eventItem.events = EPOLLIN;
- eventItem.data.u32 = deviceId; //设备id
- if (epoll_ctl(mEpollFd, EPOLL_CTL_ADD, fd, &eventItem)) {
- ALOGE("Could not add device fd to epoll instance. errno=%d", errno);
- delete device;
- return -1;
- }
- 。。。。。
- //将device添加到mDevice中。
- addDeviceLocked(device);
- return 0;
- }
addDeviceLocked将Device添加到mDevice中,同时也会添加到mOpeningDevices中,用来生成DEVICE_ADDED事件,发送给InputReader。这之后就可以通过getEvents读取到设备产生的输入事件了。
2.4 DEVICE_ADDED事件(mOpeningDevices)
- while (mOpeningDevices != NULL) {
- Device* device = mOpeningDevices;
- ALOGD("Reporting device opened: id=%d, name=%s\n",
- device->id, device->path.string());
- mOpeningDevices = device->next;
- event->when = now; //设置事件端时间戳
- event->deviceId = device->id == mBuiltInKeyboardId ? 0 : device->id;
- event->type = DEVICE_ADDED; //设置事件类型DEVICE_ADDED
- event += 1; //event指向下一个RawEvent对象,用于填写下一次事件
- mNeedToSendFinishedDeviceScan = true;
- if (--capacity == 0) { //查看buffer是否已满
- break;
- }
- }
由于上面scanDevicesLocked时将/dev/input下的设备节点打开,并添加到mOpeningDevices中,所以会运行此代码块。这里主要是遍历mOpeningDevices,设置DEVICE_ADDED事件。
2.5 FINISHED_DEVICE_SCAN事件(mNeedToSendFinishedDeviceScan)
- if (mNeedToSendFinishedDeviceScan) {
- mNeedToSendFinishedDeviceScan = false;
- event->when = now; //设置事件端时间戳
- event->type = FINISHED_DEVICE_SCAN; //设置事件类型FINISHED_DEVICE_SCAN
- event += 1;
- if (--capacity == 0) {
- break;
- }
- }
上述三个代码块都会将mNeedToSendFinishedDeviceScan设为true,所以接着生成FINISHED_DEVICE_SCAN类型的事件。也就是当设备增删事件后,需要向getEvents()函数调用者发送FINISHED_DEVICE_SCAN事件。
由代码顺序可以知道DEVICE_REMOVED事件优先级最高、然后DEVICE_ADDED事件、FINISHED_DEVICE_SCAN事件最低。只有高优先级的事件处理完之后才会处理低优先级的事件。
2.6 iNotify事件、管道事件
接着是while循环,检查是否有未处理的设备事件。
- while (mPendingEventIndex < mPendingEventCount) {
- const struct epoll_event& eventItem = mPendingEventItems[mPendingEventIndex++];
- //EPOLL_ID_INOTIFY是EventHub初始化时,用来检测/dev/input下添加、删除设备事件。
- if (eventItem.data.u32 == EPOLL_ID_INOTIFY) {
- if (eventItem.events & EPOLLIN) {
- mPendingINotify = true; //符合条件标记inotify事件待处理。
- } else {
- ALOGW("Received unexpected epoll event 0x%08x for INotify.", eventItem.events);
- }
- continue;//继续处理mPendingEventItems中的事件
- }
- 。。。。。。
- }
- // readNotify() will modify the list of devices so this must be done after
- // processing all other events to ensure that we read all remaining events
- // before closing the devices.
- //判断是否有待处理的inotify事件。
- if (mPendingINotify && mPendingEventIndex >= mPendingEventCount) {
- mPendingINotify = false;
- readNotifyLocked();
- deviceChanged = true;
- }
- ALOGD("getEvents -----9 deviceChanged:%d",deviceChanged);
- // Report added or removed devices immediately.
- if (deviceChanged) {
- continue;//如果处理有inotify事件,处理后,进行下一次循环,生成设备增删事件。
- }
- 。。。。。。
mPendingINotify赋值为false,表示之后没有待处理的inotify事件。
readNotifyLocked() 处理inotify事件。
deviceChanged设置为true,进行下一次循环,生成设备增删事件。
接着看一下readNotifyLocked()函数中做了些什么。
- status_t EventHub::readNotifyLocked() {
- int res;
- char devname[PATH_MAX];
- char *filename;
- char event_buf[512];
- int event_size;
- int event_pos = 0;
- struct inotify_event *event;
- ALOGD("EventHub::readNotify nfd: %d\n", mINotifyFd);
- //从mINotifyFd读取inotify事件,存到event_buf中,
- res = read(mINotifyFd, event_buf, sizeof(event_buf));
- if(res < (int)sizeof(*event)) {
- if(errno == EINTR)
- return 0;
- ALOGW("could not get event, %s\n", strerror(errno));
- return -1;
- }
- //printf("got %d bytes of event information\n", res);
- strcpy(devname, DEVICE_PATH);
- filename = devname + strlen(devname);
- *filename++ = ‘/‘;
- while(res >= (int)sizeof(*event)) {
- event = (struct inotify_event *)(event_buf + event_pos);
- //printf("%d: %08x \"%s\"\n", event->wd, event->mask, event->len ? event->name : "");
- if(event->len) {
- strcpy(filename, event->name);
- if(event->mask & IN_CREATE) {//判断事件类型是否是IN_CREATE
- openDeviceLocked(devname); //加载对应设备
- } else { //事件类型不是IN_CREATE,则是IN_DELETE
- ALOGI("Removing device ‘%s‘ due to inotify event\n", devname);
- closeDeviceByPathLocked(devname); //卸载对应设备
- }
- }
- //移动到下一个事件。
- event_size = sizeof(*event) + event->len;
- res -= event_size;
- event_pos += event_size;
- }
- return 0;
- }
主要工作
1 通过read()函数读取iNotify事件
2 遍历所有的iNotify事件
3 判断iNotify事件类型,IN_CREATE类型则加载设备,IN_DELETE类型则卸载设备。
接着是判断是否是管道事件
- while (mPendingEventIndex < mPendingEventCount) {
- 。。。。。
- if (eventItem.data.u32 == EPOLL_ID_WAKE) {
- if (eventItem.events & EPOLLIN) {
- ALOGD("awoken after wake()");
- awoken = true; //用来唤醒InputRead线程
- char buffer[16];
- ssize_t nRead;
- do {//从mWakeReadPipeFd读取管道事件
- nRead = read(mWakeReadPipeFd, buffer, sizeof(buffer));
- } while ((nRead == -1 && errno == EINTR) || nRead == sizeof(buffer));
- } else {
- ALOGW("Received unexpected epoll event 0x%08x for wake read pipe.",
- eventItem.events);
- }
- continue;
- }
- 。。。。
- }
- 。。。。
- // Return now if we have collected any events or if we were explicitly awoken.
- if (event != buffer || awoken) {
- break; //退出循环返回到InputReader。
- }
2.7 输入事件
接着到输入事件了。根据输入事件,进行设置时间戳、id、类型、值等。拥有返回给调用者InputReader。
- while (mPendingEventIndex < mPendingEventCount) {
- 。。。。。
- //通过eventItem.data.u32 获取设备id
- ssize_t deviceIndex = mDevices.indexOfKey(eventItem.data.u32);
- if (deviceIndex < 0) {
- ALOGW("Received unexpected epoll event 0x%08x for unknown device id %d.",
- eventItem.events, eventItem.data.u32);
- continue;
- }
- //从mDevices获取设备
- Device* device = mDevices.valueAt(deviceIndex);
- if (eventItem.events & EPOLLIN) {//epoll事件是EPOLLIN,可读,读取结果保存在readBuffer中,capacity是限制一次读取事件的个数
- int32_t readSize = read(device->fd, readBuffer,
- sizeof(struct input_event) * capacity);
- if (readSize == 0 || (readSize < 0 && errno == ENODEV)) {
- //读取有问题
- // Device was removed before INotify noticed.
- ALOGW("could not get event, removed? (fd: %d size: %d bufferSize: %d "
- "capacity: %d errno: %d)\n",
- device->fd, readSize, bufferSize, capacity, errno);
- deviceChanged = true;
- closeDeviceLocked(device);//关闭该设备
- } else if (readSize < 0) {
- if (errno != EAGAIN && errno != EINTR) {
- ALOGW("could not get event (errno=%d)", errno);
- }
- } else if ((readSize % sizeof(struct input_event)) != 0) {
- ALOGE("could not get event (wrong size: %d)", readSize);
- } else {
- int32_t deviceId = device->id == mBuiltInKeyboardId ? 0 : device->id;
- size_t count = size_t(readSize) / sizeof(struct input_event);
- //遍历所有读取的输入事件
- for (size_t i = 0; i < count; i++) {
- struct input_event& iev = readBuffer[i];
- if (iev.type == EV_MSC) {
- if (iev.code == MSC_android_TIME_SEC) {
- device->timestampOverrideSec = iev.value;
- continue;
- } else if (iev.code == MSC_ANDROID_TIME_USEC) {
- device->timestampOverrideUsec = iev.value;
- continue;
- }
- }
- if (device->timestampOverrideSec || device->timestampOverrideUsec) {
- iev.time.tv_sec = device->timestampOverrideSec;
- iev.time.tv_usec = device->timestampOverrideUsec;
- if (iev.type == EV_SYN && iev.code == SYN_REPORT) {
- device->timestampOverrideSec = 0;
- device->timestampOverrideUsec = 0;
- }
- ALOGV("applied override time %d.%06d",
- int(iev.time.tv_sec), int(iev.time.tv_usec));
- }
- #ifdef HAVE_POSIX_CLOCKS
- //设置更准确的时间
- event->when = nsecs_t(iev.time.tv_sec) * 1000000000LL
- + nsecs_t(iev.time.tv_usec) * 1000LL;
- ALOGV("event time %lld, now %lld", event->when, now);
- if (event->when >= now + 10 * 1000000000LL) {
- // Double-check. Time may have moved on.
- nsecs_t time = systemTime(SYSTEM_TIME_MONOTONIC);
- if (event->when > time) {
- ALOGW("An input event from %s has a timestamp that appears to "
- "have been generated using the wrong clock source "
- "(expected CLOCK_MONOTONIC): "
- "event time %lld, current time %lld, call time %lld. "
- "Using current time instead.",
- device->path.string(), event->when, time, now);
- event->when = time;
- } else {
- ALOGV("Event time is ok but failed the fast path and required "
- "an extra call to systemTime: "
- "event time %lld, current time %lld, call time %lld.",
- event->when, time, now);
- }
- }
- #else
- event->when = now;
- #endif
- //设置一些信息
- event->deviceId = deviceId;
- event->type = iev.type;
- event->code = iev.code;
- event->value = iev.value;
- event += 1; //移动到下一该可用元素
- capacity -= 1; //可用数量减少1
- }
- if (capacity == 0) {//buffer存满了,mPendingEventIndex至为-1,下一次循环处理未完的事件。
- // The result buffer is full. Reset the pending event index
- // so we will try to read the device again on the next iteration.
- mPendingEventIndex -= 1;
- break;
- }
- }
- } else if (eventItem.events & EPOLLHUP) {//事件类型为挂起
- ALOGI("Removing device %s due to epoll hang-up event.",
- device->identifier.name.string());
- deviceChanged = true;
- closeDeviceLocked(device); //卸载设备
- } else {
- ALOGW("Received unexpected epoll event 0x%08x for device %s.",
- eventItem.events, device->identifier.name.string());
- }
- }
- 。。。。。。
- rerutn event-buffer;//返回事件数量
- }
while循环后面是判断是否有inotify事件,wake事件。接着是获取epoll事件 。先获取到epoll事件,下次循环才会处理while循环。
通过mEpollFd描述符,获取epoll事件。保存在mPendingEventItems中,EPOLL_MAX_EVENTS(16)为限制一次最大读取事件次数,timeoutMillis为超时时间。
- mPendingEventIndex = 0;
- mLock.unlock(); // release lock before poll, must be before release_wake_lock
- release_wake_lock(WAKE_LOCK_ID);
- //等待事件
- int pollResult = epoll_wait(mEpollFd, mPendingEventItems, EPOLL_MAX_EVENTS, timeoutMillis);
- acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_ID);
- mLock.lock(); // reacquire lock after poll, must be after acquire_wake_lock
- if (pollResult == 0) {
- // Timed out.
- mPendingEventCount = 0;
- break;
- }
- if (pollResult < 0) {
- // An error occurred.
- mPendingEventCount = 0;
- // Sleep after errors to avoid locking up the system.
- // Hopefully the error is transient.
- if (errno != EINTR) {
- ALOGW("poll failed (errno=%d)\n", errno);
- usleep(100000);
- }
- } else {
- // Some events occurred.
- //保存epoll事件数量,用于下次for循环处理
- mPendingEventCount = size_t(pollResult);
- }
- }
到现在getEvents函数基本上就完了。还有许多内容待揣摩。
3 总结
EventHub主要工作:设备管理(加载、卸载)、输入事件读取。核心代码就是getEvent(),该代码中完成了这些事情。
其中使用到的epoll、inotify、管道这些技术可以好好研究下。。。。
。。。。。。
以上是关于Android 输入系统EventHub的主要内容,如果未能解决你的问题,请参考以下文章