3【Android 12】InputReader读取事件

在Input相关服务的创建和启动中，我们知道了InputManager在start函数中会创建一个InputReader，其内部有一个线程会循环调用InputReader.loopOnce，实现InputReader对输入事件的持续读取，那么我们以此为起点，分析一下InputReader读取事件流程。
void InputReader::loopOnce() {
    ......
    // 1. 从EventHub读取原始事件
    size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);
    { // acquire lock
        std::scoped_lock _l(mLock);
        mReaderIsAliveCondition.notify_all();
        // 2. InputReader.processEventsLocked处理事件。
        if (count) {
            processEventsLocked(mEventBuffer, count);
    ......
    // 3. QueuedInputListener分发事件
    // Flush queued events out to the listener.
    // This must happen outside of the lock because the listener could potentially call
    // back into the InputReader's methods, such as getScanCodeState, or become blocked
    // on another thread similarly waiting to acquire the InputReader lock thereby
    // resulting in a deadlock.  This situation is actually quite plausible because the
    // listener is actually the input dispatcher, which calls into the window manager,
    // which occasionally calls into the input reader.
    mQueuedListener->flush();
可以分为三部分：
1)、EventHub.getEvent获取输入事件。
2)、InputReader.processEventsLocked处理事件。
3)、QueuedInputListener分发事件。
一、从EventHub读取原始事件
    size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);
EventHub.getEvents函数内容很庞大，这里先挖个坑暂不分析，总结就是如果此时有输入事件，那么通过EventHub.getEvent来读取事件，将输入事件封装为RawEvent对象。否则，InputReader读取线程就会睡眠在EventHub.getEvent函数上：
        int pollResult = epoll_wait(mEpollFd, mPendingEventItems, EPOLL_MAX_EVENTS, timeoutMillis);
epoll_wait，等待epoll文件描述符上的I / O事件。
最终将从EventHub中读取的原始事件保存到mEventBuffer中，count代表了原始事件的个数。
二、加工原始事件
Key和Motion分发流程类似，因此在这里以Key事件为例看一下整个流程时序图：
上一步中将从EventHub中读取到的原始信息保存在了RawEvent类型的mEventBuffer中，接着使用InputReader.processEventsLocked方法进一步处理事件。
1 InputReader.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) {
			......
            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;
这里将普通的事件输入事件和设备的输入事件分开处理：
1)、输入设备事件的定义在EventHub.h：
    // Synthetic raw event type codes produced when devices are added or removed.
    enum {
        // Sent when a device is added.
        DEVICE_ADDED = 0x10000000,
        // Sent when a device is removed.
        DEVICE_REMOVED = 0x20000000,
        // Sent when all added/removed devices from the most recent scan have been reported.
        // This event is always sent at least once.
        FINISHED_DEVICE_SCAN = 0x30000000,
        FIRST_SYNTHETIC_EVENT = DEVICE_ADDED,
DEVICE_ADDED对应一次设备添加事件，DEVICE_REMOVED对应一次设备删除事件，FINISHED_DEVICE_SCAN对应一次所有设备的扫描事件。
2)、如果事件type小于FIRST_SYNTHETIC_EVENT，那么此次不是一次增加/删除/扫描设备事件，调用InputReader.processEventsForDeviceLocked，让对应设备去处理本次输入事件。
2 InputReader.processEventsForDeviceLocked
void InputReader::processEventsForDeviceLocked(int32_t eventHubId, const RawEvent* rawEvents,
                                               size_t count) {
    auto deviceIt = mDevices.find(eventHubId);
	......
    std::shared_ptr<InputDevice>& device = deviceIt->second;
    ......
    device->process(rawEvents, count);
从mDevices中获取当前事件对应的设备对象InputDevice，然后调用InputDevice.process处理RawEvent。
3 InputDevice.process
void InputDevice::process(const RawEvent* rawEvents, size_t count) {
    // Process all of the events in order for each mapper.
    // We cannot simply ask each mapper to process them in bulk because mappers may
    // have side-effects that must be interleaved.  For example, joystick movement events and
    // gamepad button presses are handled by different mappers but they should be dispatched
    // in the order received.
    for (const RawEvent* rawEvent = rawEvents; count != 0; rawEvent++) {
        ......
        if (mDropUntilNextSync) {
            ......
        } else if (rawEvent->type == EV_SYN && rawEvent->code == SYN_DROPPED) {
            ......
        } else {
            for_each_mapper_in_subdevice(rawEvent->deviceId, [rawEvent](InputMapper& mapper) {
                mapper.process(rawEvent);
        --count;
这里出现了一个新概念，InputMapper：
 /* An input mapper transforms raw input events into cooked event data.
 * A single input device can have multiple associated input mappers in order to interpret
 * different classes of events.
InputMapper用来将原始的输入事件转换为处理过的输入数据，一个输入设备可能对应多个InputMapper。
InputMapper有多个子类，TouchInputMapper、KeyboardInputMapper、SensorInputMapper等等，用来处理不同类型的输入事件。
上一步中，我们找到了一个输入设备可以处理当前输入事件，那么这一步就是遍历调用该InputDevice对应的所有InputMapper，调用InputMapper的proces函数，去处理输入事件。
4 InputMapper处理原始输入事件
我们重点分析键盘事件和触摸屏事件。
4.1 键盘事件
键盘设备对应的InputMapper是KeyboardInputMapper。
4.1.1 KeyboardInputMapper.process
void KeyboardInputMapper::process(const RawEvent* rawEvent) {
    switch (rawEvent->type) {
        case EV_KEY: {
            int32_t scanCode = rawEvent->code;
            int32_t usageCode = mCurrentHidUsage;
            mCurrentHidUsage = 0;
            if (isKeyboardOrGamepadKey(scanCode)) {
                processKey(rawEvent->when, rawEvent->readTime, rawEvent->value != 0, scanCode,
                           usageCode);
            break;
        case EV_MSC: {
            ......
        case EV_SYN: {
            ......
查阅资料，Linux系统中总共有这几种输入事件：
EV_SYN 0x00 同步事件
EV_KEY 0x01 按键事件，如KEY_VOLUMEDOWN
EV_REL 0x02 相对坐标,   如shubiao上报的坐标
EV_ABS 0x03 绝对坐标，如触摸屏上报的坐标
EV_MSC 0x04 其它
EV_LED 0x11 LED
EV_SND 0x12 声音
EV_REP 0x14 Repeat
EV_FF 0x15 力反馈
EV_PWR       电源
EV_FF_STATUS   状态
暂不分析其他事件，那么对于键盘事件中的按键事件，调用KeyboardInputMapper.processKey函数继续进行处理。
4.1.2. KeyboardInputMapper.processKey
void KeyboardInputMapper::processKey(nsecs_t when, nsecs_t readTime, bool down, int32_t scanCode,
                                     int32_t usageCode) {
    int32_t keyCode;
    int32_t keyMetaState;
    uint32_t policyFlags;
    ......
    NotifyKeyArgs args(getContext()->getNextId(), when, readTime, getDeviceId(), mSource,
                       getDisplayId(), policyFlags,
                       down ? AKEY_EVENT_ACTION_DOWN : AKEY_EVENT_ACTION_UP,
                       AKEY_EVENT_FLAG_FROM_SYSTEM, keyCode, scanCode, keyMetaState, downTime);
    getListener()->notifyKey(&args);
将原始的输入数据封装为NotifyKeyArgs类型，然后通知listener。
4.2 触摸屏事件
触摸屏设备对应的InputMapper是TouchInputMapper。
4.2.1 TouchInputMapper.process
void TouchInputMapper::process(const RawEvent* rawEvent) {
    mCursorButtonAccumulator.process(rawEvent);
    mCursorScrollAccumulator.process(rawEvent);
    mTouchButtonAccumulator.process(rawEvent);
    if (rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT) {
        sync(rawEvent->when, rawEvent->readTime);
1)、mCursorButtonAccumulator用来处理鼠标和触摸盘按键事件，mCursorScrollAccumulator用来处理鼠标滑动事件，mTouchButtonAccumulator用来处理手写笔和之类的事件。
2)、调用TouchInputMapper.sync函数进行事件的同步。
4.2.2 TouchInputMapper.sync
4.2.3 TouchInputMapper.processRawTouches
4.2.4 TouchInputMapper.cookAndDispatch
4.2.5 TouchInputMapper.dispatchTouches
4.2.6 TouchInputMapper.dispatchMotion
void TouchInputMapper::dispatchMotion(nsecs_t when, nsecs_t readTime, uint32_t policyFlags,
                                      uint32_t source, int32_t action, int32_t actionButton,
                                      int32_t flags, int32_t metaState, int32_t buttonState,
                                      int32_t edgeFlags, const PointerProperties* properties,
                                      const PointerCoords* coords, const uint32_t* idToIndex,
                                      BitSet32 idBits, int32_t changedId, float xPrecision,
                                      float yPrecision, nsecs_t downTime) {
    ......
    const int32_t deviceId = getDeviceId();
    std::vector<TouchVideoFrame> frames = getDeviceContext().getVideoFrames();
    std::for_each(frames.begin(), frames.end(),
                  [this](TouchVideoFrame& frame) { frame.rotate(this->mSurfaceOrientation); });
    NotifyMotionArgs args(getContext()->getNextId(), when, readTime, deviceId, source, displayId,
                          policyFlags, action, actionButton, flags, metaState, buttonState,
                          MotionClassification::NONE, edgeFlags, pointerCount, pointerProperties,
                          pointerCoords, xPrecision, yPrecision, xCursorPosition, yCursorPosition,
                          downTime, std::move(frames));
    getListener()->notifyMotion(&args);
将原始的输入数据封装为NotifyMotionArgs类型，然后通知listener。
5 QueuedInputListener.notifyKey & QueuedInputListener.notifyMotion
从上面的分析可以看到：
1)、对于键盘事件，通过KeyboardInputMapper的处理，最终将原始输入事件封装为NotifyKeyArgs对象，然后通过getListener获取到传递对象，调用notifyKey将封装好的事件传过去。
2)、对于触摸屏事件，通过TouchInputMapper的处理，最终将原始输入事件封装为NotifyMotionArgs对象，然后通过getListener获取到传递对象，调用notifyMotion将封装好的事件传过去。
这里直接放结论，InputMapper.getListener函数返回了InputReader.mQueuedListener。
InputListenerInterface* InputReader::ContextImpl::getListener() {
    return mReader->mQueuedListener.get();
那么上面无论是键盘事件：
getListener()->notifyKey(&args);
或者触摸事件：
getListener()->notifyMotion(&args);
调用的都是QueuedInputListener的相关函数：
void QueuedInputListener::notifyKey(const NotifyKeyArgs* args) {
    traceEvent(__func__, args->id);
    mArgsQueue.push_back(new NotifyKeyArgs(*args));
void QueuedInputListener::notifyMotion(const NotifyMotionArgs* args) {
    traceEvent(__func__, args->id);
    mArgsQueue.push_back(new NotifyMotionArgs(*args));
最终的结果是，将封装的NotifyKeyArgs和NotifyMotionArgs加入到了QueuedInputListener的成员变量mArgsQueue中。
三、通知InputDispatcher有新事件发生
Key和Motion分发流程类似，因此在这里以Key事件为例看一下整个流程时序图：
    // Flush queued events out to the listener.
    // This must happen outside of the lock because the listener could potentially call
    // back into the InputReader's methods, such as getScanCodeState, or become blocked
    // on another thread similarly waiting to acquire the InputReader lock thereby
    // resulting in a deadlock.  This situation is actually quite plausible because the
    // listener is actually the input dispatcher, which calls into the window manager,
    // which occasionally calls into the input reader.
    mQueuedListener->flush();
上一步中，调用了InputReader.processEventsLocked函数，将所有原始事件加工为了NotifyArgs类型，并且加入到了mQueuedListener.mArgsQueue，那么这一步就是调用QueuedInputListener.flush将加工好的事件分发给InputReader相应的listener。
1 QueuedInputListener.flush
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();
这里的mArgsQueue队列中已经有了从EventHub中读取到的并且已经被加工为NotifyArgs类型的事件了，接着调用NotifyArgs.notify函数。
2 NotifyKeyArgs.notify & NotifyMotionArgs.notify
void NotifyKeyArgs::notify(const sp<InputListenerInterface>& listener) const {
    listener->notifyKey(this);
......
void NotifyMotionArgs::notify(const sp<InputListenerInterface>& listener) const {
    listener->notifyMotion(this);
NotifyArgs是NotifyKeyArgs和NotifyMotionArgs的基类，根据事件类型分别调用不同子类的notify函数。
这里传入的listener是QueueInputListener.mInnerListener，在之前的分析中我们知道它对应的是一个InputClassifier对象。
3 InputClassifier.notifyKey & InputClassifier.notifyMotion
void InputClassifier::notifyKey(const NotifyKeyArgs* args) {
    // pass through
    mListener->notifyKey(args);
void InputClassifier::notifyMotion(const NotifyMotionArgs* args) {
    std::scoped_lock lock(mLock);
    // MotionClassifier is only used for touch events, for now
    const bool sendToMotionClassifier = mMotionClassifier && isTouchEvent(*args);
    if (!sendToMotionClassifier) {
        mListener->notifyMotion(args);
        return;
    NotifyMotionArgs newArgs(*args);
    newArgs.classification = mMotionClassifier->classify(newArgs);
    mListener->notifyMotion(&newArgs);
在之前的分析我们知道了，InputClassifier.mListener指向了一个InputDispatcher，那么这里调用的自然也是InputDispatcher的相关函数。
3.1 InputDispatcher.notifyKey
void InputDispatcher::notifyKey(const NotifyKeyArgs* args) {
    ......
    KeyEvent event;
    event.initialize(args->id, args->deviceId, args->source, args->displayId, INVALID_HMAC,
                     args->action, flags, keyCode, args->scanCode, metaState, repeatCount,
                     args->downTime, args->eventTime);
    android::base::Timer t;
    mPolicy->interceptKeyBeforeQueueing(&event, /*byref*/ policyFlags);
    if (t.duration() > SLOW_INTERCEPTION_THRESHOLD) {
        ALOGW("Excessive delay in interceptKeyBeforeQueueing; took %s ms",
              std::to_string(t.duration().count()).c_str());
    bool needWake;
    { // acquire lock
        ......
        std::unique_ptr<KeyEntry> newEntry =
                std::make_unique<KeyEntry>(args->id, args->eventTime, args->deviceId, args->source,
                                           args->displayId, policyFlags, args->action, flags,
                                           keyCode, args->scanCode, metaState, repeatCount,
                                           args->downTime);
        needWake = enqueueInboundEventLocked(std::move(newEntry));
        mLock.unlock();
    } // release lock
    if (needWake) {
        mLooper->wake();
1)、根据传入的NotifyKeyArgs的信息封装一个KeyEvent对象，在将输入事件传给Activity之前，调用NativeInputManager.interceptKeyBeforeQueueing对KeyEvent进行预处理，最终会调用到PhoneWindowManager#interceptKeyBeforeQueueing中，决定是否要把输入事件发送给用户。
2)、根据传入的NotifyKeyArgs的信息封装一个KeyEntry对象，然后调用InputDispatcher.InputDispatcher.enqueueInboundEventLocked。
3)、如果InputDispatcher.InputDispatcher.enqueueInboundEventLocked返回true，那么说明需要唤醒InputDispatcher的分发线程。
3.2 InputDispatcher.notifyMotion
void InputDispatcher::notifyMotion(const NotifyMotionArgs* args) {
    ......
    uint32_t policyFlags = args->policyFlags;
    policyFlags |= POLICY_FLAG_TRUSTED;
    android::base::Timer t;
    mPolicy->interceptMotionBeforeQueueing(args->displayId, args->eventTime, /*byref*/ policyFlags);
    if (t.duration() > SLOW_INTERCEPTION_THRESHOLD) {
        ALOGW("Excessive delay in interceptMotionBeforeQueueing; took %s ms",
              std::to_string(t.duration().count()).c_str());
    bool needWake;
    { // acquire lock
        mLock.lock();
		......
        // Just enqueue a new motion event.
        std::unique_ptr<MotionEntry> newEntry =
                std::make_unique<MotionEntry>(args->id, args->eventTime, args->deviceId,
                                              args->source, args->displayId, policyFlags,
                                              args->action, args->actionButton, args->flags,
                                              args->metaState, args->buttonState,
                                              args->classification, args->edgeFlags,
                                              args->xPrecision, args->yPrecision,
                                              args->xCursorPosition, args->yCursorPosition,
                                              args->downTime, args->pointerCount,
                                              args->pointerProperties, args->pointerCoords, 0, 0);
        needWake = enqueueInboundEventLocked(std::move(newEntry));
        mLock.unlock();
    } // release lock
    if (needWake) {
        mLooper->wake();
内容和InputDispatcher.notifyKey相似：
1)、在将输入事件传给Activity之前，将传入的NotifyMotionArgs的信息发送给NativeInputManager.interceptMotionBeforeQueueing进行预处理，最终会调用PhoneWindowManager#interceptMotionBeforeQueueing，由PhoneWindowManager决定是否要拦截此次事件。
2)、根据传入的NotifyMotionArgs的信息封装一个MotionEntry对象，然后调用InputDispatcher.InputDispatcher.enqueueInboundEventLocked。
3)、如果InputDispatcher.InputDispatcher.enqueueInboundEventLocked返回true，那么说明需要唤醒InputDispatcher的分发线程。
3.3 InputDispatcher.enqueueInboundEventLocked
不管是Key事件还是Motion事件，在经过PhoneWindowManager预处理后，如果PhoneWindowManager不拦截此次事件，那么接下来就是调用InputDispatcher.enqueueInboundEventLocked函数继续分发事件给相关窗口。
bool InputDispatcher::enqueueInboundEventLocked(std::unique_ptr<EventEntry> newEntry) {
    bool needWake = mInboundQueue.empty();
    mInboundQueue.push_back(std::move(newEntry));
    EventEntry& entry = *(mInboundQueue.back());
    traceInboundQueueLengthLocked();
    switch (entry.type) {
        case EventEntry::Type::KEY: {
			......
        case EventEntry::Type::MOTION: {
			......
        case EventEntry::Type::FOCUS: {
            LOG_ALWAYS_FATAL("Focus events should be inserted using enqueueFocusEventLocked");
            break;
        case EventEntry::Type::CONFIGURATION_CHANGED:
        case EventEntry::Type::DEVICE_RESET:
        case EventEntry::Type::SENSOR:
        case EventEntry::Type::POINTER_CAPTURE_CHANGED:
        case EventEntry::Type::DRAG: {
            // nothing to do
            break;
    return needWake;
首先判断mInboundQueue是否为空，将本次处理的EventEntry加入到mInboundQueue中。接着判断是否要唤醒InputDispatcher的分发线程，有三种唤醒情况：
1)、mInboundQueue为空。
2)、mInboundQueue不为空，此时为按键事件。如果当前按键事件将触发App切换，并且如果此时该按键抬起，需要丢弃之前所有的事件，并且唤醒InputDispatcher分发线程。
3)、mInboundQueue不为空，此时为触摸事件。如果当前触摸事件之前的事件需要被删除，那么唤醒InputDispatcher分发线程。
4 InputDispatcher分发线程的唤醒
将输入事件加入InputDispatcher.mInboundQueue中，下一步就是唤醒InputDispatcher分发线程。
先来补充一下Looper的睡眠和唤醒机制：
C++类Looper中的睡眠和唤醒机制是通过pollOnce和wake函数提供的，它们又是利用操作系统（Linux内核）的epoll机制来完成的。
在Looper的构造函数中，会创建一个管道，然后调用epoll_create获取一个epoll的实例的描述符，最后将管道读端描述符作为一个事件报告项添加给epoll。
Looper的pollOnce函数将最终调用到其pollInner函数。在后者里面，将调用epoll_wait睡眠等待其监控的文件描述符是否有可I/O事件的到来，若有（哪怕只有一个），epoll_wait将会醒来。
Looper的wake函数用于向管道中写入字符，pollOnce将会从epoll_wait中唤醒。
我们知道InputDispatcher内部有一个的分发线程，在循环调用dispatchOnce来进行事件的分发，但即使是循环调用，这个线程也不可能真的无限制在一直分发，而是当有事件可读时，才进行分发，其他时间分发线程进入休眠状态。
InputDispatcher.dispatchOnce函数的最后，在事件分发完成后会调用Looper.pollOnce将当前线程睡眠：
void InputDispatcher::dispatchOnce() {
	......
    // 上面是分发事件的具体内容    
    // Wait for callback or timeout or wake.  (make sure we round up, not down)
    nsecs_t currentTime = now();
    int timeoutMillis = toMillisecondTimeoutDelay(currentTime, nextWakeupTime);
    mLooper->pollOnce(timeoutMillis);
那么上面在InputDispatcher.notifyKey或者是InputDispatcher.notifyMotion中调用Looper.wake的时候：
    if (needWake) {
        mLooper->wake();
InputDispatcher.dispatchOnce中的Looper.pollOnce函数就可以返回，上一次的InputDispatcher.dispatchOnce函数才会全部执行完成并且返回，进而可以循环进行下一次的InputDispatcher.dispatchOnce，开启新一轮事件分发。
1)、InputReader通过EventHub.getEvents读取原始事件RawEvent。
2)、InputReader调用InputReader.processEventsLocked函数将原始事件加工为NotifyArgs类型，然后存储到InputReader的QueuedInputListener类型的成员变量mQueuedListener内部的mArgsQueue中进行排队等待分发。
3)、InputReader调用QueuedInputListener.flush函数，将QueuedInputListener.mArgsQueue存储的事件一次性发送到InputDispatcher，最终事件是被封装成了EventEntry类型，添加到了InputDispatcher.mInboundQueue中，InputReader并且唤醒了InputDispatcher的分发线程，后续InputDispatcher分发线程会重新调用InputDispatcher.dispatchOnce函数来进行事件的分发。