接着上篇文章Android IMS原理解析的分析，本文主要分析Input事件获取：

Input事件获取

       前面讲到，在start()后会启动InputReaderThread线程不断的从EventHub中抽取原始输入事件并进行加工处理，InputReaderThread继承自C的Thread类，Thread类封装了pthread线程工具，提供了与java层Thread类相似的API。
       C的Thread类提供了一个名为threadLoop()的纯虚函数，当线程开始运行后，将会在内建的线程循环中不断地调用threadLoop()，直到此函数返回false，则退出线程循环，从而结束线程，看一下InputReaderThread的逻辑实现：

bool InputReaderThread::threadLoop() {
    mReader->loopOnce();
    return true;
}

       threadLoop()内部执行了mReader->loopOnce()，然后返回true，即：InputReaderThread启动后，其线程循环不断地执行InputReader.loopOnce()方法。这个loopOnce()函数作为线程循环的循环体包含了InputReader的所有工作。
       注意：C层的Thread类与java层的Thread类有一个显著的区别：
       C层Thread类内建了线程循环，threadLoop()就是一次循环而已，只要返回值为true，threadLoop()将会不断地被内建的循环调用。
       Java层Thread类的run()函数则是整个线程的全部，一旦执行完退出，线程便结束了。
       接下来看一下loopOnce()具体做了什么工作：

void InputReader::loopOnce() {
    .....
    .....
    size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);
    .....
    if (count) {
        processEventsLocked(mEventBuffer, count);
    }
    ......
    mQueuedListener->flush();
}

       InputReader一次线程循环，即执行一次loopOnce()，主要执行了三项工作：
       1.从EventHub中获取未处理的事件列表，读取的结果存储在参数mEventBuffer中，返回值表示事件的个数；当EventHub中无事件可抽取时，此函数的调用将会阻塞直到事件到来或者超时；
       2.通过processEventsLocked()对事件进行处理，对于原始输入事件，进行转译、封装与加工后将结果暂存到mQueuedListener中；
       3.发布事件，所有事件处理完毕后，调用mQueuedListener.flush()将所有暂存的输入事件一次性地交付给InputDispatcher；
       接下来对三项工作进行逐一分析：

1.EventHub->getEvents()

       调用EventHub的getEvents()方法来获取事件列表，EventHub是如何工作的呢？
       EventHub的直译是事件集线器，它将所有的输入事件通过一个接口getEvents()把从多个输入设备节点中读取的事件交给InputReader，它是输入系统最底层的一个组件，使用了INotify与Epoll两套机制，通过构造方法就可以看到：

static const char *DEVICE_PATH = "/dev/input"
EventHub::EventHub(void) : xxxx {
    .......
    //1.使用epoll_create()函数创建一个epoll对象。EPOLL_SIZE_HINT指定最大监听个数为8，
    //这个epoll对象将用来监听设备节点是否有数据可读（有无事件）
    mEpollFd = epoll_create(EPOLL_SIZE_HINT);

    //2.创建一个inotify对象。这个inotify对象将被用来监听设备节点的增删事件
    mINotifyFd = inotify_init();

    //将存储设备节点的路径/dev/input作为监听对象添加到inotify对象中。当此文件夹下的设备节点发生创建与删除事件时，
    //都可以通过mINotifyFd读取事件的详细信息
    int result = inotify_add_watch(mINotifyFd, DEVICE_PATH, IN_DELETE | IN_CREATE);

    //3.将mINotifyFd作为epoll的一个监控对象。当inotify事件到来时，epoll_wait()将立即返回，
    //EventHub便可以从mINotifyFd中读取设备节点的增删信息，并进行相应处理
    struct epoll_event eventItem;
    memset(&eventItem, 0, sizeof(eventItem));
    eventItem.events = EPOLLIN;
    eventItem.data.u32 = EPOLL_ID_INOTIFY;
    //将对mINotifyFd的监听注册到epoll对象中
    result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mINotifyFd, &eventItem);

    //创建一个名为wakeFds的匿名管道
    int wakeFds[2];
    result = pipe(wakeFds);

    mWakeReadPipeFd = wakeFds[0];
    mWakeWritePipeFd = wakeFds[1];

    result = fcntl(mWakeReadPipeFd, F_SETFL, O_NONBLOCK);
    result = fcntl(mWakeWritePipeFd, F_SETFL, O_NONBLOCK);
    eventItem.data.u32 = EPOLL_ID_WAKE;
    //将管道读取端的描述符的可读事件注册到epoll对象中。因为InputReader在执行getEvents()时会因无事件而导致其线程阻塞在
    //epoll_wait()的调用里，然而有时希望能够立刻唤醒InputReader线程使其处理一些请求。此时只需向wakeFds管道的写入端写入任意数据，
    //此时读取端有数据可读，使得epoll_wait()得以返回，从而达到唤醒InputReader线程的目的
    result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mWakeReadPipeFd, &eventItem);
}

       在上面的构造方法内，对Epoll和INotify进行处理，后续有事件到来时就可以获取了，接下来看一下getEvents()的逻辑处理：

size_t EventHub::getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize) {
    .......
    for (;;) {
        .......
        //处理未被InputReader取走的输入事件与设备事件。epoll_wait()所取出的epoll_event存储在mPendingEventItems中，
        //mPendingEventCount指定mPendingEventItems数组所存储的事件个数。而mPendingEventIndex指定尚未处理的epoll_event的索引
        while (mPendingEventIndex < mPendingEventCount) {
            const struct epoll_event& eventItem = mPendingEventItems[mPendingEventIndex++];
            //在这里分析每一个epoll_event 如果表示设备节点可读，则读取原始事件并放置到buffer中。
            //如果表示mINotifyEd可读，则设置mPendingINotify为true，当InputReader将现有的输入事件都取出后读取mINotifyEd中的事件，并加装与卸载相应的设备。
            //另外，如果此epoll_event表示wakeFds的读取端有数据可读，则设置awake标志为true，
            //此时无论此次getEvents()调用是否取到事件，都不会调用epoll_wait()进行事件等待。
            if (eventItem.data.u32 == EPOLL_ID_INOTIFY) {
                if (eventItem.events & EPOLLIN) {
                    mPendingINotify = true;
                }
                continue;
            }

            if (eventItem.data.u32 == EPOLL_ID_WAKE) {
                if (eventItem.events & EPOLLIN) {
                    char buffer[16];
                    ssize_t nRead;
                    do {
                        nRead = read(mWakeReadPipeFd, buffer, sizeof(buffer));
                    } while ((nRead == -1 && errno == EINTR) || nRead == sizeof(buffer));
                }
            }
    }
       .....
       //如果此次getEvents()调用成功获取了一些事件，或者要求唤醒InputReader，则退出循环并结束getEvents()的调用，
       //使InputReader可以立刻处理事件
       if (event != buffer || awoken) {
           break;
       }

        //如果此次getEvents()调用没能获取事件，说明mPendingEventItems中没有事件可用。
        //于是执行epoll_wait()函数等待新的事件到来，将结果存储到mPendingEventItems里，并重置mPendingEventIndex为0
        mPendingEventIndex = 0;
        int pollResult = epoll_wait(mEpollFd, mPendingEventItems, EPOLL_MAX_EVENTS, timeoutMillis);

        if (pollResult == 0) {
            // Timed out.
            mPendingEventCount = 0;
            break;
        }

        if (pollResult < 0) {
            // An error occurred.
            mPendingEventCount = 0;
            if (errno != EINTR) {
                ALOGW("poll failed (errno=%d)\n", errno);
                usleep(100000);
            }
        } else {
            //从epoll_wait()中得到新的事件后，重新循环，对新事件进行处理
            mPendingEventCount = size_t(pollResult);
        }
    }

    //返回本次getEvents()调用所读取的事件数量
    return event - buffer;
}

       getEvents()函数的本质就是读取并处理Epoll事件与INotify事件：包括设备插拔及各种触摸、按钮事件等，可以看做是一个不同设备的集线器，主要面向的是/dev/input目录下的设备节点，比如说/dev/input/event0上的事件就是输入事件，通过EventHub的getEvents()就可以监听并获取该事件，getEvents()将它们封装为RawEvent结构体，并放入buffer中供InputReader进行处理。

2.processEventsLocked()

       当通过EventHub获取到事件即count>0时，对事件进行加工处理，此时调用到processEventsLocked()方法：

void InputReader::processEventsLocked(const RawEvent* rawEvents, size_t count) {
    for (const RawEvent* rawEvent = rawEvents; count;) {
        int32_t type = rawEvent->type;
        size_t batchSize = 1;
        if (type < EventHubInterface::FIRST_SYNTHETIC_EVENT) {
            int32_t deviceId = rawEvent->deviceId;
            while (batchSize < count) {
                if (rawEvent[batchSize].type >= EventHubInterface::FIRST_SYNTHETIC_EVENT
                        || rawEvent[batchSize].deviceId != deviceId) {
                    break;
                }
                batchSize += 1;
            }
            processEventsForDeviceLocked(deviceId, rawEvent, batchSize);
        } else {
            switch (rawEvent->type) {
            case EventHubInterface::DEVICE_ADDED:
                addDeviceLocked(rawEvent->when, rawEvent->deviceId);
                break;
            case EventHubInterface::DEVICE_REMOVED:
                removeDeviceLocked(rawEvent->when, rawEvent->deviceId);
                break;
            case EventHubInterface::FINISHED_DEVICE_SCAN:
                handleConfigurationChangedLocked(rawEvent->when);
                break;
            default:
                ALOG_ASSERT(false); // can't happen
                break;
            }
        }
        count -= batchSize;
        rawEvent += batchSize;
    }
}

       在方法内部调用了processEventsForDeviceLocked()处理来自同一输入设备的一批事件：

void InputReader::processEventsForDeviceLocked(int32_t deviceId,
        const RawEvent* rawEvents, size_t count) {
    ssize_t deviceIndex = mDevices.indexOfKey(deviceId);
    if (deviceIndex < 0) {
        ALOGW("Discarding event for unknown deviceId %d.", deviceId);
        return;
    }

    InputDevice* device = mDevices.valueAt(deviceIndex);
    if (device->isIgnored()) {
        //ALOGD("Discarding event for ignored deviceId %d.", deviceId);
        return;
    }

    device->process(rawEvents, count);
}

       processEventsForDeviceLocked()再将事件列表交给InputDevice::process()处理：

void InputDevice::process(const RawEvent* rawEvents, size_t count) {
    size_t numMappers = mMappers.size();
    for (const RawEvent* rawEvent = rawEvents; count--; rawEvent++) {

        if (mDropUntilNextSync) {
            if (rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT) {
                mDropUntilNextSync = false;
            } else {
            }
        } else if (rawEvent->type == EV_SYN && rawEvent->code == SYN_DROPPED) {
            ALOGI("Detected input event buffer overrun for device %s.", getName().string());
            mDropUntilNextSync = true;
            reset(rawEvent->when);
        } else {
            for (size_t i = 0; i < numMappers; i++) {
                InputMapper* mapper = mMappers[i];
                mapper->process(rawEvent);
            }
        }
    }
}

       可以看到，InputDevice::process()将事件逐个交给每一个InputMapper的process()事件处理。此处就不展开分析了，在调用对应InputMapper实现的process()方法后，会最终调用到getListener()->notifyMotion(&releaseArgs)、getListener()->notifyKey(&args)等等，看一下getListener()：

InputListenerInterface* InputReader::ContextImpl::getListener() {
    return mReader->mQueuedListener.get();
}

       返回的就是mQueuedListener，是QueuedInputListener实例，此处先不分析notifyxx()逻辑，稍后一起分析：

3.mQueuedListener->flush()

       在porceeEventsLocked()后，接下来会执行mQueuedListener->flush()来结束loopOnce()这个方法，mQueuedListener是QueuedInputListener实例，QueuedInputListener位于进入InputListener.cpp里面，一起看一下具体实现逻辑：

void QueuedInputListener::notifyKey(const NotifyKeyArgs* args) {
    mArgsQueue.push(new NotifyKeyArgs(*args));
}

void NotifyKeyArgs::notify(const sp<InputListenerInterface>& listener) const {
    listener->notifyKey(this);
}

void QueuedInputListener::notifyMotion(const NotifyMotionArgs* args) {
    mArgsQueue.push(new NotifyMotionArgs(*args));
}

void NotifyMotionArgs::notify(const sp<InputListenerInterface>& listener) const {
    listener->notifyMotion(this);
}

void QueuedInputListener::flush() {
    size_t count = mArgsQueue.size();
    for (size_t i = 0; i < count; i++) {
        NotifyArgs* args = mArgsQueue[i];
        args->notify(mInnerListener);
        delete args;
    }
    mArgsQueue.clear();
}

QueuedInputListener::QueuedInputListener(const sp<InputListenerInterface>& innerListener) :
        mInnerListener(innerListener) {
}

       可以看到，在第二项工作中调用notifyMotion()后，执行了队列的push，只是将该事件args压入队列中；最后通过flush()来遍历队列，执行对应args的notify()方法，在notify()方法内部执行listener->notifyXX()，该listener是mInnerListener，而mInnerListener是InputListenerInterface，是在创建QueuedInputListener对象时传入的。
       通过前面的代码分析可以知道，QueuedInputListener是在创建InputReader时就创建了，而传入的参数是mInputDispatcher，通过Android IMS原理解析IMS成员关系图可以看到，InputDispatcher继承了InputListenerInterface，所以mInnerListener就是mInputDispatcher，因此在执行flush()后，最终调用到InputDispatcher的逻辑。
       QueuedInputListener避免了在原始事件的加工过程中向InputDispatcher进行事件提交，而是将事件信息缓存起来，在InputReader::loopOnce()函数的末尾，也就是InputReader处理完抽取自EventHub的所有原始输入事件之后，QueuedInputListener::flush()函数的调用将缓存的事件信息取出，并提交给InputDispatcher，事件派发就由此开始了。
       接下来请看Android IMS原理解析之事件派发