Android IMS原理解析之InputReader

       接着上篇文章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& listener) const {
    listener->notifyKey(this);
}

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

void NotifyMotionArgs::notify(const sp& 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& 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原理解析之事件派发

你可能感兴趣的:(Android IMS原理解析之InputReader)