android中输入系统之内核到InputManagerService过程（源码）

愿每一份努力都不会被辜负-陈

总体流程

在Android中，Touch事件的分发分服务端和应用端。在服务端由WindowManagerService（借助InputManagerService）负责采集和分发的，在应用端则
是由ViewRootlmpl（内部有一个mView变量指向View树的根，负责控制View树的Ul绘制和事件消息的分发）负责分发的。当输入设备可用时，比如触屏，Linux内核会在/dev/input中创建对应的设备节点，输入事件所产生的原始信息会被Linux内核中的输入子系统采集，原始信息由Kernel Space的驱动层一直传递到User Space的设备节点。IMS所做的工作就是监听/dev/input下的所有的设备节点，当设备节点有数据时会将数据进行加工处理并找到合适的Window，将输入事件派发给它。

总体来说分为以下三个流程：事件采集，事件中转以及事件分发。

事件的本质

事件的本质其实就是一个个文件，事件产生后由Linux系统将数据保存到dev/input文件夹下。

我们可以通过命令来获取输入事件的信息：

adb shell getevent
adb shell input event 4
adb shell getevent -t -I

Linux-Posix函数(关键函数用到)

• ePoll

  被公认为Linux2.6下性能最好的多路l/O就绪通知方法。

  epoll只有epoll_create,epoll_ctl,epoll_wait 3个系统调用。

  epoll create：当创建好epoll句柄后，它就是会占用一个fd值，在linux下如果查看/proc/进程id/fd/，是能够看到这个fd的，所以在使用完epoll后，必须调用close()关闭，否则可能导致fd被耗尽(无限的创建文件夹同样会导致fd被耗尽)。
  epoll _ctl：epol的事件注册函数，它不同于select（是在监听事件时告诉内核要监听什么类型的事件，而是在这里先注册要监听的事件类型。
  epoll wait：收集在epoll监控的事件中已经发送的事件。参数events是分配好的epoll event结构体数组，epoll将会把发生的事件赋值到levents数组中(events不可以是空指针，内核只负责把数据复制到这个events数组中，不会去帮助我们在用户态中分配内存）。maxevents告之内核这个events有多大，这个maxevents的值不能大于创建epoll create（时的size，参数timeout是超时时间（毫秒，0会立即返回，-1将不确定，也有说法说是永久阻塞）。如果函数调用成功，返回对应/O上已准备好的文件描述符数目，如返回0表示已超时

  具体参考：https://blog.csdn.net/xiajun07061225/article/details/9250579

• iNotify

  它是一个内核用于通知用户空间程序文件系统变化的机制

  int fd = inotify init ():每一个inotify实例对应一个独立的排序的队列

  inotify add watch:fd是 inotify init0返回的文件描述符,path是被监视的目标的路径名（即文件名或目录名）,mask是事件掩码,在头文件linux/inotify.h中定义了每一位代表的事件。可以使用同样的方式来修改事件掩码，即改变希望被通知的inotify 事件。Wd是watch描述符。

  具体用法参考：https://blog.csdn.net/breakout_alex/article/details/89028868

• socketpair

  socketpairO函数用于创建一对无名的、相互连接的套接子。

  具体使用参考：https://blog.csdn.net/weixin_40039738/article/details/81095013

• fd

  linux中，每一个进程在内核中，都对应有一个“打开文件”数组，存放指向文件对象的指针，而fd是这个数组的下标。
  我们对文件进行操作时，系统调用，将fd传入内核，内核通过fd找到文件，对文件进行操作。
  既然是数组下标，fd的类型为int，<0为非法值，>=0为合法值。在ilinux中，一个进程默认可以打开的文件数为1024个，fd的范围为0~1023。可以通
  过设置，改变最大值。
  在linux中，值为0、1、2的fd，分别代表标准输入、标准输出、标准错误输出。

从内核到IMS过程

源码流程

EventHub

• INotify

  INotify是Linux提供的一种文件系统变化通知机制，什么叫文件系统变化？创建，删除，读写通通叫做变化，使用如下代码就可以将某个目录加入到INotify中。

  int inotifyFd = inotify init();
  int wd =inotify_add_watch(inotifyFd,"/dev/input", IN_CREATE|IN_DELETE):
  

  上述两行代码就将”/dev/input”加入到了INotify中，这样，对于外部输入设备的插拔就可以很好的被检测到了。可不幸的是，INotify发现文件系统变化后不
  会主动告诉别人，它需要主动通过reado函数读取inotifyFd描述符来获取具体变化信息。也就是说，你插入了鼠标，INotify马上就知道了这个信息，并且将
  信息更新到了inotifyFd描述符对应的对象当中

• Eventhub

  EventHub 通过读取/dev/input/下的相关文件来判断是否有新事件，并通知InputReader。

  Epoll可以用来监听多个描述符的可读写inotifyFd状态，什么意思呢？比如说上面说到了外部输入设备插拔可以被INotify检测到，并且将相信信息写入到inotifyFd对用的对象中，但是我没法知道INotify什么时候捕获到了这些信息。而Epoll可以监听inotifyFd对应的对象内容是否有变化，一旦有变化马上能进行处理，平常大部分时间没监听到变化时睡大觉（其实Android中的Handler中的消息队列用到了epoll机制）。

  epoll wait大部分时间处于阻塞状态（这点和socket等待连接很相似），一旦/dev/input/evento节点有变化（即产生了输入事件），epoll wait会执行完毕

  //frameworks/native/services/inputflinger/EventHub.cpp
  EventHub::EventHub(void) :
          mBuiltInKeyboardId(NO_BUILT_IN_KEYBOARD), mNextDeviceId(1), mControllerNumbers(),
          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_create(EPOLL_SIZE_HINT);
      LOG_ALWAYS_FATAL_IF(mEpollFd < 0, "Could not create epoll instance.  errno=%d", errno);
  
       //初始化盘符并且监听。
      mINotifyFd = inotify_init();
      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监听mINotifyFd。
      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);
  
      int major, minor;
      getLinuxRelease(&major, &minor);
      // EPOLLWAKEUP was introduced in kernel 3.5
      mUsingEpollWakeup = major > 3 || (major == 3 && minor >= 5);
  }
  

IMS概述

• InputReaderThread

  InputReader会不断的循环读取EventHub中的原始输入事件。

• InputDispatcherThread

  InputDispatcher中保存了WMS中的所有的Window信息（WMS会将窗口的信息实时的更新到InputDispatcher中），这样InputDispatcher就可以将输入事
  件派发给合适的Window

整体流程源码分析

1. 由SystemServer启动一个IMS进程进程，然后进行各个对象的初始化

   SystemServer开启其他服务（这个在之前的博客有详细介绍）

   //com/android/server/SystemServer.java 
   private void startOtherServices() {
         ......
           traceBeginAndSlog("StartInputManagerService");
           inputManager = new InputManagerService(context);
           traceEnd();
       
       //将inputManager与WindowManagerService关联
          wm = WindowManagerService.main(context, inputManager,
                       mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL,
                       !mFirstBoot, mOnlyCore, new PhoneWindowManager());
       //注册wms服务
               ServiceManager.addService(Context.WINDOW_SERVICE, wm, /* allowIsolated= */ false,
                       DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PROTO);
       //注册ims服务
               ServiceManager.addService(Context.INPUT_SERVICE, inputManager,
                       /* allowIsolated= */ false, DUMP_FLAG_PRIORITY_CRITICAL);
         ......
     }
   

   InputManagerService的构造方法

       public InputManagerService(Context context) {
           this.mContext = context;
           this.mHandler = new InputManagerHandler(DisplayThread.get().getLooper());
   
           mUseDevInputEventForAudioJack =
                   context.getResources().getBoolean(R.bool.config_useDevInputEventForAudioJack);
           Slog.i(TAG, "Initializing input manager, mUseDevInputEventForAudioJack="
                   + mUseDevInputEventForAudioJack);
           //调用到jni的初始化方法。
           mPtr = nativeInit(this, mContext, mHandler.getLooper().getQueue());
   
           String doubleTouchGestureEnablePath = context.getResources().getString(
                   R.string.config_doubleTouchGestureEnableFile);
           mDoubleTouchGestureEnableFile = TextUtils.isEmpty(doubleTouchGestureEnablePath) ? null :
               new File(doubleTouchGestureEnablePath);
   
           LocalServices.addService(InputManagerInternal.class, new LocalService());
       }
   

2. 同步会在native层进行初始化，开启一个InputManager对象,开启两个线程,一个Reader线程用来读取触摸信号,一个Dispatcher用来转发信息,EventHub负责采集底层信号。

   通过jni调用到nativeInit方法。

   //frameworks/base/services/core/jni/com_android_server_input_InputManagerService
      
   static jlong nativeInit(JNIEnv* env, jclass /* clazz */,
           jobject serviceObj, jobject contextObj, jobject messageQueueObj) {
       sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, messageQueueObj);
       if (messageQueue == NULL) {
           jniThrowRuntimeException(env, "MessageQueue is not initialized.");
           return 0;
       }
   
       //初始化InputManager
       NativeInputManager* im = new NativeInputManager(contextObj, serviceObj,
               messageQueue->getLooper());
       im->incStrong(0);
       return reinterpret_cast<jlong>(im);
   } 
   

   创建NativeInputManager对象

   ///frameworks/base/services/core/jni/com_android_server_input_InputManagerService.cpp
   NativeInputManager::NativeInputManager(jobject contextObj,
           jobject serviceObj, const sp& looper) :
           mLooper(looper), mInteractive(true) {
       JNIEnv* env = jniEnv();
   
       mContextObj = env->NewGlobalRef(contextObj);
       mServiceObj = env->NewGlobalRef(serviceObj);
   
       {
           AutoMutex _l(mLock);
           mLocked.systemUiVisibility = ASYSTEM_UI_VISIBILITY_STATUS_BAR_VISIBLE;
           mLocked.pointerSpeed = 0;
           mLocked.pointerGesturesEnabled = true;
           mLocked.showTouches = false;
           mLocked.pointerCapture = false;
       }
       mInteractive = true;
   
        //注意此处创建了EventHub
       sp eventHub = new EventHub();
       //并把EventHub作为参数传入到InputManager中
       mInputManager = new InputManager(eventHub, this, this);
   }
   
   

   InputManager构造方法

   /frameworks/native/services/inputflinger/InputManager.cpp
   InputManager::InputManager(
           const sp& eventHub,
           const sp& readerPolicy,
           const sp& dispatcherPolicy) {
       //创建InputDispatcher对象
       mDispatcher = new InputDispatcher(dispatcherPolicy);
       //创建InputReader对象，InputReader在创建之初就与InputDispatcher产生了紧密的关联，后面会使用nQueuedListener->flush()通知事件。
   
       mReader = new InputReader(eventHub, readerPolicy, mDispatcher);
       //初始化
       initialize();
   }
   

   initialize()初始化

   ///frameworks/native/services/inputflinger/InputManager.cpp
   void InputManager::initialize() {
       //创建绣程“InputReader”
       mReaderThread = new InputReaderThread(mReader);
       //创建线程”InputDispatcher“
       mDispatcherThread = new InputDispatcherThread(mDispatcher);
   }
   

   InputReader构造方法

   //frameworks/native/services/inputflinger/InputReader.cpp
   InputReader::InputReader(const sp<EventHubInterface>& eventHub,
           const sp<InputReaderPolicyInterface>& policy,
           const sp<InputListenerInterface>& listener) :
           mContext(this), mEventHub(eventHub), mPolicy(policy),
           mGlobalMetaState(0), mGeneration(1),
           mDisableVirtualKeysTimeout(LLONG_MIN), mNextTimeout(LLONG_MAX),
           mConfigurationChangesToRefresh(0) {
       //创建Listener回调，这个后面会调用nQueuedListener->flush()，记住这个listener是一个InputDispatcher
       mQueuedListener = new QueuedInputListener(listener);
   
       { // acquire lock
           AutoMutex _l(mLock);
   
           refreshConfigurationLocked(0);
           updateGlobalMetaStateLocked();
       } // release lock
   }
   

   InputDispatcher构造方法

   //frameworks/native/services/inputflinger/InputDispatcher.cpp
   InputDispatcher::InputDispatcher(const sp& policy) :
       mPolicy(policy),
       mPendingEvent(NULL), mLastDropReason(DROP_REASON_NOT_DROPPED),
       mAppSwitchSawKeyDown(false), mAppSwitchDueTime(LONG_LONG_MAX),
       mNextUnblockedEvent(NULL),
       mDispatchEnabled(false), mDispatchFrozen(false), mInputFilterEnabled(false),
       mInputTargetWaitCause(INPUT_TARGET_WAIT_CAUSE_NONE) {
       mLooper = new Looper(false);
   
       mKeyRepeatState.lastKeyEntry = NULL;
   
       policy->getDispatcherConfiguration(&mConfig);
   }
   

3. 通过IMS.start启动上面两个线程流程

   inputManager.start()

   //com/android/server/SystemServer.java
   traceBeginAndSlog("StartInputManager");
               inputManager.setWindowManagerCallbacks(wm.getInputMonitor());
               inputManager.start();
               traceEnd();
   

   InputManagerService.start

   //com/android/server/input/InputManagerService.java 
   public void start() {
           Slog.i(TAG, "Starting input manager");
         //jni 开启inputmanager
           nativeStart(mPtr);
   
           // Add ourself to the Watchdog monitors.
           Watchdog.getInstance().addMonitor(this);
   
           registerPointerSpeedSettingObserver();
           registerShowTouchesSettingObserver();
           registerAccessibilityLargePointerSettingObserver();
   
           mContext.registerReceiver(new BroadcastReceiver() {
               @Override
               public void onReceive(Context context, Intent intent) {
                   updatePointerSpeedFromSettings();
                   updateShowTouchesFromSettings();
                   updateAccessibilityLargePointerFromSettings();
               }
           }, new IntentFilter(Intent.ACTION_USER_SWITCHED), null, mHandler);
   
           updatePointerSpeedFromSettings();
           updateShowTouchesFromSettings();
           updateAccessibilityLargePointerFromSettings();
       }
   
   

   nativeStart()

   ///frameworks/base/services/core/jni/com_android_server_input_InputManagerService.cpp
   static void nativeStart(JNIEnv* env, jclass /* clazz */, jlong ptr) {
       NativeInputManager* im = reinterpret_cast(ptr);
   
       status_t result = im->getInputManager()->start();
       if (result) {
           jniThrowRuntimeException(env, "Input manager could not be started.");
       }
   }
   

   ///frameworks/base/services/core/jni/com_android_server_input_InputManagerService.cpp
   status_t InputManager::start() {
       status_t result = mDispatcherThread->run("InputDispatcher", PRIORITY_URGENT_DISPLAY);
       if (result) {
           ALOGE("Could not start InputDispatcher thread due to error %d.", result);
           return result;
       }
   
       result = mReaderThread->run("InputReader", PRIORITY_URGENT_DISPLAY);
       if (result) {
           ALOGE("Could not start InputReader thread due to error %d.", result);
   
           mDispatcherThread->requestExit();
           return result;
       }
   
       return OK;
   }
   

4. InputRerader线程处理过程

   InputRender线程运行。

   ///frameworks/native/services/inputflinger/InputReader.cpp
   bool InputReaderThread::threadLoop() {
       mReader->loopOnce();
       return true;
   }
   

   处理事件

   ///frameworks/native/services/inputflinger/InputReader.cpp
   void InputReader::loopOnce() {
       int32_t oldGeneration;
       int32_t timeoutMillis;
       bool inputDevicesChanged = false;
       Vector inputDevices;
       { // acquire lock
           AutoMutex _l(mLock);
   
           oldGeneration = mGeneration;
           timeoutMillis = -1;
   
           uint32_t changes = mConfigurationChangesToRefresh;
           if (changes) {
               mConfigurationChangesToRefresh = 0;
               timeoutMillis = 0;
               refreshConfigurationLocked(changes);
           } else if (mNextTimeout != LLONG_MAX) {
               nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
               timeoutMillis = toMillisecondTimeoutDelay(now, mNextTimeout);
           }
       } // release lock
   
   	//内部有一个epoll_wait()  挂起
   	//唤醒由linux驱动去更改dev/input下的文件造成  inotify+epoll,从Eventhub中读取事件，这里注意因为之前将的EventHub.getEvent中有epoll wait进行阻塞，若FD发生改变则执行后面代码
       //通过EventHub的getEvents函数获取事件信息，并存放到mEventBuffer中。
   
       size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);
   
       { // acquire lock
           AutoMutex _l(mLock);
           mReaderIsAliveCondition.broadcast();
   
           if (count) {
   			//处理事件信息，如果有事件信息，则进行加工处理。
               processEventsLocked(mEventBuffer, count);
           }
   
           if (mNextTimeout != LLONG_MAX) {
               nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
               if (now >= mNextTimeout) {
   #if DEBUG_RAW_EVENTS
                   ALOGD("Timeout expired, latency=%0.3fms", (now - mNextTimeout) * 0.000001f);
   #endif
                   mNextTimeout = LLONG_MAX;
                   timeoutExpiredLocked(now);
               }
           }
   
           if (oldGeneration != mGeneration) {
               inputDevicesChanged = true;
               getInputDevicesLocked(inputDevices);
           }
       } // release lock
   
       // Send out a message that the describes the changed input devices.
       if (inputDevicesChanged) {
           mPolicy->notifyInputDevicesChanged(inputDevices);
       }
   
       // 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();
   }
   

   处理事件信息:processEventsLocked

   ///frameworks/native/services/inputflinger/InputReader.cpp
   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;
               }
   #if DEBUG_RAW_EVENTS
               ALOGD("BatchSize: %zu Count: %zu", batchSize, count);
   #endif
               //手动注意，继续调用。，处理deviceId所对应的设备的原始输入事件。
               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：

   ///frameworks/native/services/inputflinger/InputReader.cpp
   void InputReader::processEventsForDeviceLocked(int32_t deviceId,
           const RawEvent* rawEvents, size_t count) {
       //从mDevices中获取对应的deviceIndex
       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);
   }
   
   

   调用inputDevice.process()

   ///frameworks/native/services/inputflinger/InputReader.cpp
   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.
       size_t numMappers = mMappers.size();
       //遍历处理该InputDevice的所有事件
       for (const RawEvent* rawEvent = rawEvents; count != 0; rawEvent++) {
   #if DEBUG_RAW_EVENTS
           ALOGD("Input event: device=%d type=0x%04x code=0x%04x value=0x%08x when=%" PRId64,
                   rawEvent->deviceId, rawEvent->type, rawEvent->code, rawEvent->value,
                   rawEvent->when);
   #endif
   
           //mDropUntilNextSync默认值为false，如果设备的输入事件的缓冲区溢出，这个值为true
           if (mDropUntilNextSync) {
               if (rawEvent->type == EV_SYN && rawEvent->code == SYN_REPORT) {
                   mDropUntilNextSync = false;
   #if DEBUG_RAW_EVENTS
                   ALOGD("Recovered from input event buffer overrun.");
   #endif
               } else {
   #if DEBUG_RAW_EVENTS
                   ALOGD("Dropped input event while waiting for next input sync.");
   #endif
               }
           } 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);
               }
           }
           --count;
       }
   }
   
   

   交给对应的设备处理 mapper->process(rawEvent)，这里需要注意，InputMapper有很多的子类，我们要找触摸事件的相关处理就是找到TouchlnputMapper

   ///frameworks/native/services/inputflinger/InputReader.cpp
   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);
       }
   }
   

   继续sync

   ///frameworks/native/services/inputflinger/InputReader.cpp
   void TouchInputMapper::sync(nsecs_t when) {
       const RawState* last = mRawStatesPending.isEmpty() ?
               &mCurrentRawState : &mRawStatesPending.top();
   
       // Push a new state.
       mRawStatesPending.push();
       RawState* next = &mRawStatesPending.editTop();
       next->clear();
       next->when = when;
   
       // Sync button state.
       next->buttonState = mTouchButtonAccumulator.getButtonState()
               | mCursorButtonAccumulator.getButtonState();
   
       // Sync scroll
       next->rawVScroll = mCursorScrollAccumulator.getRelativeVWheel();
       next->rawHScroll = mCursorScrollAccumulator.getRelativeHWheel();
       mCursorScrollAccumulator.finishSync();
   
       // Sync touch
       syncTouch(when, next);
   
       // Assign pointer ids.
       if (!mHavePointerIds) {
           assignPointerIds(last, next);
       }
   
   #if DEBUG_RAW_EVENTS
       ALOGD("syncTouch: pointerCount %d -> %d, touching ids 0x%08x -> 0x%08x, "
               "hovering ids 0x%08x -> 0x%08x",
               last->rawPointerData.pointerCount,
               next->rawPointerData.pointerCount,
               last->rawPointerData.touchingIdBits.value,
               next->rawPointerData.touchingIdBits.value,
               last->rawPointerData.hoveringIdBits.value,
               next->rawPointerData.hoveringIdBits.value);
   #endif
   
       processRawTouches(false /*timeout*/);
   }
   

   processRawTouches（最终的目的是找到数据的最终去向）

   ///frameworks/native/services/inputflinger/InputReader.cpp
   void TouchInputMapper::processRawTouches(bool timeout) {
       if (mDeviceMode == DEVICE_MODE_DISABLED) {
           // Drop all input if the device is disabled.
           mCurrentRawState.clear();
           mRawStatesPending.clear();
           return;
       }
   
       // Drain any pending touch states. The invariant here is that the mCurrentRawState is always
       // valid and must go through the full cook and dispatch cycle. This ensures that anything
       // touching the current state will only observe the events that have been dispatched to the
       // rest of the pipeline.
       const size_t N = mRawStatesPending.size();
       size_t count;
       for(count = 0; count < N; count++) {
           const RawState& next = mRawStatesPending[count];
   
           // A failure to assign the stylus id means that we're waiting on stylus data
           // and so should defer the rest of the pipeline.
           if (assignExternalStylusId(next, timeout)) {
               break;
           }
   
           // All ready to go.
           clearStylusDataPendingFlags();
           mCurrentRawState.copyFrom(next);
           if (mCurrentRawState.when < mLastRawState.when) {
               mCurrentRawState.when = mLastRawState.when;
           }
           cookAndDispatch(mCurrentRawState.when);
       }
       if (count != 0) {
           mRawStatesPending.removeItemsAt(0, count);
       }
   
       if (mExternalStylusDataPending) {
           if (timeout) {
               nsecs_t when = mExternalStylusFusionTimeout - STYLUS_DATA_LATENCY;
               clearStylusDataPendingFlags();
               mCurrentRawState.copyFrom(mLastRawState);
   #if DEBUG_STYLUS_FUSION
               ALOGD("Timeout expired, synthesizing event with new stylus data");
   #endif
               //手动注意
               cookAndDispatch(when);
           } else if (mExternalStylusFusionTimeout == LLONG_MAX) {
               mExternalStylusFusionTimeout = mExternalStylusState.when + TOUCH_DATA_TIMEOUT;
               getContext()->requestTimeoutAtTime(mExternalStylusFusionTimeout);
           }
       }
   }
   

   cookAndDispatch

   ///frameworks/native/services/inputflinger/InputReader.cpp
   void TouchInputMapper::cookAndDispatch(nsecs_t when) {
       // Always start with a clean state.
       mCurrentCookedState.clear();
   
       // Apply stylus buttons to current raw state.
       applyExternalStylusButtonState(when);
   
       // Handle policy on initial down or hover events.
       bool initialDown = mLastRawState.rawPointerData.pointerCount == 0
               && mCurrentRawState.rawPointerData.pointerCount != 0;
   
       uint32_t policyFlags = 0;
       bool buttonsPressed = mCurrentRawState.buttonState & ~mLastRawState.buttonState;
       if (initialDown || buttonsPressed) {
           // If this is a touch screen, hide the pointer on an initial down.
           if (mDeviceMode == DEVICE_MODE_DIRECT) {
               getContext()->fadePointer();
           }
   
           if (mParameters.wake) {
               policyFlags |= POLICY_FLAG_WAKE;
           }
       }
   
       // Consume raw off-screen touches before cooking pointer data.
       // If touches are consumed, subsequent code will not receive any pointer data.
       if (consumeRawTouches(when, policyFlags)) {
           mCurrentRawState.rawPointerData.clear();
       }
   
       // Cook pointer data.  This call populates the mCurrentCookedState.cookedPointerData structure
       // with cooked pointer data that has the same ids and indices as the raw data.
       // The following code can use either the raw or cooked data, as needed.
       cookPointerData();
   
       // Apply stylus pressure to current cooked state.
       applyExternalStylusTouchState(when);
   
       // Synthesize key down from raw buttons if needed.
       synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_DOWN, when, getDeviceId(), mSource,
               policyFlags, mLastCookedState.buttonState, mCurrentCookedState.buttonState);
   
       // Dispatch the touches either directly or by translation through a pointer on screen.
       if (mDeviceMode == DEVICE_MODE_POINTER) {
           for (BitSet32 idBits(mCurrentRawState.rawPointerData.touchingIdBits);
                   !idBits.isEmpty(); ) {
               uint32_t id = idBits.clearFirstMarkedBit();
               const RawPointerData::Pointer& pointer =
                       mCurrentRawState.rawPointerData.pointerForId(id);
               if (pointer.toolType == AMOTION_EVENT_TOOL_TYPE_STYLUS
                       || pointer.toolType == AMOTION_EVENT_TOOL_TYPE_ERASER) {
                   mCurrentCookedState.stylusIdBits.markBit(id);
               } else if (pointer.toolType == AMOTION_EVENT_TOOL_TYPE_FINGER
                       || pointer.toolType == AMOTION_EVENT_TOOL_TYPE_UNKNOWN) {
                   mCurrentCookedState.fingerIdBits.markBit(id);
               } else if (pointer.toolType == AMOTION_EVENT_TOOL_TYPE_MOUSE) {
                   mCurrentCookedState.mouseIdBits.markBit(id);
               }
           }
           for (BitSet32 idBits(mCurrentRawState.rawPointerData.hoveringIdBits);
                   !idBits.isEmpty(); ) {
               uint32_t id = idBits.clearFirstMarkedBit();
               const RawPointerData::Pointer& pointer =
                       mCurrentRawState.rawPointerData.pointerForId(id);
               if (pointer.toolType == AMOTION_EVENT_TOOL_TYPE_STYLUS
                       || pointer.toolType == AMOTION_EVENT_TOOL_TYPE_ERASER) {
                   mCurrentCookedState.stylusIdBits.markBit(id);
               }
           }
   
           // Stylus takes precedence over all tools, then mouse, then finger.
           PointerUsage pointerUsage = mPointerUsage;
           if (!mCurrentCookedState.stylusIdBits.isEmpty()) {
               mCurrentCookedState.mouseIdBits.clear();
               mCurrentCookedState.fingerIdBits.clear();
               pointerUsage = POINTER_USAGE_STYLUS;
           } else if (!mCurrentCookedState.mouseIdBits.isEmpty()) {
               mCurrentCookedState.fingerIdBits.clear();
               pointerUsage = POINTER_USAGE_MOUSE;
           } else if (!mCurrentCookedState.fingerIdBits.isEmpty() ||
                   isPointerDown(mCurrentRawState.buttonState)) {
               pointerUsage = POINTER_USAGE_GESTURES;
           }
   
           dispatchPointerUsage(when, policyFlags, pointerUsage);
       } else {
           if (mDeviceMode == DEVICE_MODE_DIRECT
                   && mConfig.showTouches && mPointerController != NULL) {
               mPointerController->setPresentation(PointerControllerInterface::PRESENTATION_SPOT);
               mPointerController->fade(PointerControllerInterface::TRANSITION_GRADUAL);
   
               mPointerController->setButtonState(mCurrentRawState.buttonState);
               mPointerController->setSpots(mCurrentCookedState.cookedPointerData.pointerCoords,
                       mCurrentCookedState.cookedPointerData.idToIndex,
                       mCurrentCookedState.cookedPointerData.touchingIdBits);
           }
   
           if (!mCurrentMotionAborted) {
               dispatchButtonRelease(when, policyFlags);
               dispatchHoverExit(when, policyFlags);
               //手动注意，分发消息
               dispatchTouches(when, policyFlags);
               dispatchHoverEnterAndMove(when, policyFlags);
               dispatchButtonPress(when, policyFlags);
           }
   
           if (mCurrentCookedState.cookedPointerData.pointerCount == 0) {
               mCurrentMotionAborted = false;
           }
       }
   
       // Synthesize key up from raw buttons if needed.
       synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_UP, when, getDeviceId(), mSource,
               policyFlags, mLastCookedState.buttonState, mCurrentCookedState.buttonState);
   
       // Clear some transient state.
       mCurrentRawState.rawVScroll = 0;
       mCurrentRawState.rawHScroll = 0;
   
       // Copy current touch to last touch in preparation for the next cycle.
       mLastRawState.copyFrom(mCurrentRawState);
       mLastCookedState.copyFrom(mCurrentCookedState);
   }
   
   

   dispatchTouches

   ///frameworks/native/services/inputflinger/InputReader.cpp
   void TouchInputMapper::dispatchTouches(nsecs_t when, uint32_t policyFlags) {
       BitSet32 currentIdBits = mCurrentCookedState.cookedPointerData.touchingIdBits;
       BitSet32 lastIdBits = mLastCookedState.cookedPointerData.touchingIdBits;
       int32_t metaState = getContext()->getGlobalMetaState();
       int32_t buttonState = mCurrentCookedState.buttonState;
   
       if (currentIdBits == lastIdBits) {
           if (!currentIdBits.isEmpty()) {
               // No pointer id changes so this is a move event.
               // The listener takes care of batching moves so we don't have to deal with that here.
               dispatchMotion(when, policyFlags, mSource,
                       AMOTION_EVENT_ACTION_MOVE, 0, 0, metaState, buttonState,
                       AMOTION_EVENT_EDGE_FLAG_NONE,
                       mCurrentCookedState.deviceTimestamp,
                       mCurrentCookedState.cookedPointerData.pointerProperties,
                       mCurrentCookedState.cookedPointerData.pointerCoords,
                       mCurrentCookedState.cookedPointerData.idToIndex,
                       currentIdBits, -1,
                       mOrientedXPrecision, mOrientedYPrecision, mDownTime);
           }
       } else {
           // There may be pointers going up and pointers going down and pointers moving
           // all at the same time.
           BitSet32 upIdBits(lastIdBits.value & ~currentIdBits.value);
           BitSet32 downIdBits(currentIdBits.value & ~lastIdBits.value);
           BitSet32 moveIdBits(lastIdBits.value & currentIdBits.value);
           BitSet32 dispatchedIdBits(lastIdBits.value);
   
           // Update last coordinates of pointers that have moved so that we observe the new
           // pointer positions at the same time as other pointers that have just gone up.
           bool moveNeeded = updateMovedPointers(
                   mCurrentCookedState.cookedPointerData.pointerProperties,
                   mCurrentCookedState.cookedPointerData.pointerCoords,
                   mCurrentCookedState.cookedPointerData.idToIndex,
                   mLastCookedState.cookedPointerData.pointerProperties,
                   mLastCookedState.cookedPointerData.pointerCoords,
                   mLastCookedState.cookedPointerData.idToIndex,
                   moveIdBits);
           if (buttonState != mLastCookedState.buttonState) {
               moveNeeded = true;
           }
   
           // Dispatch pointer up events.
           while (!upIdBits.isEmpty()) {
               uint32_t upId = upIdBits.clearFirstMarkedBit();
   
               //手动注意。
               dispatchMotion(when, policyFlags, mSource,
                       AMOTION_EVENT_ACTION_POINTER_UP, 0, 0, metaState, buttonState, 0,
                       mCurrentCookedState.deviceTimestamp,
                       mLastCookedState.cookedPointerData.pointerProperties,
                       mLastCookedState.cookedPointerData.pointerCoords,
                       mLastCookedState.cookedPointerData.idToIndex,
                       dispatchedIdBits, upId, mOrientedXPrecision, mOrientedYPrecision, mDownTime);
               dispatchedIdBits.clearBit(upId);
           }
   
           // Dispatch move events if any of the remaining pointers moved from their old locations.
           // Although applications receive new locations as part of individual pointer up
           // events, they do not generally handle them except when presented in a move event.
           if (moveNeeded && !moveIdBits.isEmpty()) {
               ALOG_ASSERT(moveIdBits.value == dispatchedIdBits.value);
               dispatchMotion(when, policyFlags, mSource,
                       AMOTION_EVENT_ACTION_MOVE, 0, 0, metaState, buttonState, 0,
                       mCurrentCookedState.deviceTimestamp,
                       mCurrentCookedState.cookedPointerData.pointerProperties,
                       mCurrentCookedState.cookedPointerData.pointerCoords,
                       mCurrentCookedState.cookedPointerData.idToIndex,
                       dispatchedIdBits, -1, mOrientedXPrecision, mOrientedYPrecision, mDownTime);
           }
   
           // Dispatch pointer down events using the new pointer locations.
           while (!downIdBits.isEmpty()) {
               uint32_t downId = downIdBits.clearFirstMarkedBit();
               dispatchedIdBits.markBit(downId);
   
               if (dispatchedIdBits.count() == 1) {
                   // First pointer is going down.  Set down time.
                   mDownTime = when;
               }
   
               dispatchMotion(when, policyFlags, mSource,
                       AMOTION_EVENT_ACTION_POINTER_DOWN, 0, 0, metaState, buttonState, 0,
                       mCurrentCookedState.deviceTimestamp,
                       mCurrentCookedState.cookedPointerData.pointerProperties,
                       mCurrentCookedState.cookedPointerData.pointerCoords,
                       mCurrentCookedState.cookedPointerData.idToIndex,
                       dispatchedIdBits, downId, mOrientedXPrecision, mOrientedYPrecision, mDownTime);
           }
       }
   }
   

   dispatchMotion

   ///frameworks/native/services/inputflinger/InputReader.cpp
   void TouchInputMapper::dispatchMotion(nsecs_t when, uint32_t policyFlags, uint32_t source,
           int32_t action, int32_t actionButton, int32_t flags,
           int32_t metaState, int32_t buttonState, int32_t edgeFlags, uint32_t deviceTimestamp,
           const PointerProperties* properties, const PointerCoords* coords,
           const uint32_t* idToIndex, BitSet32 idBits, int32_t changedId,
           float xPrecision, float yPrecision, nsecs_t downTime) {
       PointerCoords pointerCoords[MAX_POINTERS];
       PointerProperties pointerProperties[MAX_POINTERS];
       uint32_t pointerCount = 0;
       while (!idBits.isEmpty()) {
           uint32_t id = idBits.clearFirstMarkedBit();
           uint32_t index = idToIndex[id];
           pointerProperties[pointerCount].copyFrom(properties[index]);
           pointerCoords[pointerCount].copyFrom(coords[index]);
   
           if (changedId >= 0 && id == uint32_t(changedId)) {
               action |= pointerCount << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
           }
   
           pointerCount += 1;
       }
   
       ALOG_ASSERT(pointerCount != 0);
   
       if (changedId >= 0 && pointerCount == 1) {
           // Replace initial down and final up action.
           // We can compare the action without masking off the changed pointer index
           // because we know the index is 0.
           if (action == AMOTION_EVENT_ACTION_POINTER_DOWN) {
               action = AMOTION_EVENT_ACTION_DOWN;
           } else if (action == AMOTION_EVENT_ACTION_POINTER_UP) {
               action = AMOTION_EVENT_ACTION_UP;
           } else {
               // Can't happen.
               ALOG_ASSERT(false);
           }
       }
   
       NotifyMotionArgs args(when, getDeviceId(), source, policyFlags,
               action, actionButton, flags, metaState, buttonState, edgeFlags,
               mViewport.displayId, deviceTimestamp, pointerCount, pointerProperties, pointerCoords,
               xPrecision, yPrecision, downTime);
       getListener()->notifyMotion(&args);
   }
   
   

   getListener()->notifyMotion(&args);.当前这个getListener实际获取是mQueuedListener=new QueuedlnputListener(listener);实例

   InputReader::InputReader(const sp& eventHub,
           const sp& policy,
           const sp& listener) :
           mContext(this), mEventHub(eventHub), mPolicy(policy),
           mGlobalMetaState(0), mGeneration(1),
           mDisableVirtualKeysTimeout(LLONG_MIN), mNextTimeout(LLONG_MAX),
           mConfigurationChangesToRefresh(0) {
       mQueuedListener = new QueuedInputListener(listener);
   
       { // acquire lock
           AutoMutex _l(mLock);
   
           refreshConfigurationLocked(0);
           updateGlobalMetaStateLocked();
       } // release lock
   }
   

   InputLintener.cpp.QueuedlnputListenernotifyMotion这里我们实际可以看到他就是往一个队列当中添加数据,实际上是我们将触摸相关的事件进行包装之后，将其加入到一个ArgsQueue队列，到此，我们已经将数据加入到参数队列中。

   ///frameworks/native/services/inputflinger/InputListener.cpp
   void QueuedInputListener::notifyMotion(const NotifyMotionArgs* args) {
       mArgsQueue.push(new NotifyMotionArgs(*args));
   }
   

   这时我们在回到上面loopOnce（）方法中processEventsLocked调用之后，发现当前mQueueListener->flush的调用

       // 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();
   

   flush（）

   遍历整个mArgsQueue数组，在input架构中NotifyArgs的实现子类主要有以下几类

   • NotifyConfigurationChangedArgs
   • NotifyKeyArgs
   • NotifyMotionArgs 通知motion事件
   • NotifySwitchArgs
   • NotifvDeviceResetAras

   ///frameworks/native/services/inputflinger/InputListener.cpp
   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();
   }
   
   

   上面的listener根据溯源可以看到是lnputDispatcher，是调用InputDispatcher中的notifyMotion,这里就完成了向InputDispatcher的信息传递

   void NotifyMotionArgs::notify(const sp& listener) const {
   	//实际上就是在调用InputDispatcher.notifyMotion
       listener->notifyMotion(this);
   }
   
   
   InputReader::InputReader(const sp& eventHub,
           const sp& policy,
           const sp& listener) ://注意listener
           mContext(this), mEventHub(eventHub), mPolicy(policy),
           mGlobalMetaState(0), mGeneration(1),
           mDisableVirtualKeysTimeout(LLONG_MIN), mNextTimeout(LLONG_MAX),
           mConfigurationChangesToRefresh(0) {
       mQueuedListener = new QueuedInputListener(listener);//注意这个listener
   
       { // acquire lock
           AutoMutex _l(mLock);
   
           refreshConfigurationLocked(0);
           updateGlobalMetaStateLocked();
       } // release lock
   }
   
   
   InputManager::InputManager(
           const sp& eventHub,
           const sp& readerPolicy,
           const sp& dispatcherPolicy) {
       mDispatcher = new InputDispatcher(dispatcherPolicy);
       mReader = new InputReader(eventHub, readerPolicy, mDispatcher);//注意这个listener实际就是dispatcher
       initialize();
   }
   
   
   

   10.执行notifyMotion中的唤醒操作InputDispatcher.cpp

   ///frameworks/native/services/inputflinger/InputDispatcher.cpp
   void InputDispatcher::notifyMotion(const NotifyMotionArgs* args) {
   #if DEBUG_INBOUND_EVENT_DETAILS
       ALOGD("notifyMotion - eventTime=%" PRId64 ", deviceId=%d, source=0x%x, policyFlags=0x%x, "
               "action=0x%x, actionButton=0x%x, flags=0x%x, metaState=0x%x, buttonState=0x%x,"
               "edgeFlags=0x%x, xPrecision=%f, yPrecision=%f, downTime=%" PRId64,
               args->eventTime, args->deviceId, args->source, args->policyFlags,
               args->action, args->actionButton, args->flags, args->metaState, args->buttonState,
               args->edgeFlags, args->xPrecision, args->yPrecision, args->downTime);
       for (uint32_t i = 0; i < args->pointerCount; i++) {
           ALOGD("  Pointer %d: id=%d, toolType=%d, "
                   "x=%f, y=%f, pressure=%f, size=%f, "
                   "touchMajor=%f, touchMinor=%f, toolMajor=%f, toolMinor=%f, "
                   "orientation=%f",
                   i, args->pointerProperties[i].id,
                   args->pointerProperties[i].toolType,
                   args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_X),
                   args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_Y),
                   args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_PRESSURE),
                   args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_SIZE),
                   args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR),
                   args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR),
                   args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR),
                   args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR),
                   args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION));
       }
   #endif
       if (!validateMotionEvent(args->action, args->actionButton,
                   args->pointerCount, args->pointerProperties)) {
           return;
       }
   
       uint32_t policyFlags = args->policyFlags;
       policyFlags |= POLICY_FLAG_TRUSTED;
   
       android::base::Timer t;
       mPolicy->interceptMotionBeforeQueueing(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();
   
           if (shouldSendMotionToInputFilterLocked(args)) {
               mLock.unlock();
   
               MotionEvent event;
               event.initialize(args->deviceId, args->source, args->action, args->actionButton,
                       args->flags, args->edgeFlags, args->metaState, args->buttonState,
                       0, 0, args->xPrecision, args->yPrecision,
                       args->downTime, args->eventTime,
                       args->pointerCount, args->pointerProperties, args->pointerCoords);
   
               policyFlags |= POLICY_FLAG_FILTERED;
               if (!mPolicy->filterInputEvent(&event, policyFlags)) {
                   return; // event was consumed by the filter
               }
   
               mLock.lock();
           }
   
           // Just enqueue a new motion event.
           MotionEntry* newEntry = new MotionEntry(args->eventTime,
                   args->deviceId, args->source, policyFlags,
                   args->action, args->actionButton, args->flags,
                   args->metaState, args->buttonState,
                   args->edgeFlags, args->xPrecision, args->yPrecision, args->downTime,
                   args->displayId,
                   args->pointerCount, args->pointerProperties, args->pointerCoords, 0, 0);
   
           needWake = enqueueInboundEventLocked(newEntry);
           mLock.unlock();
       } // release lock
   
       if (needWake) {//注意这里唤醒looper。
           mLooper->wake();
       }
   }
   

5. .InputDispatcher线程处理过程

   InputDispatcher线程开启

   ///frameworks/native/services/inputflinger/InputDispatcher.cpp
   bool InputDispatcherThread::threadLoop() {
       mDispatcher->dispatchOnce();
       return true;
   }
   

   dispatchOnce()轮询

   pollOnce这里是等待被唤醒，进入epoll wait等待状态，当发生以下任一情况则退出等待状态：
   callback：通过回调方法来唤醒；
   timeout：到达nextWakeupTime时间，超时唤醒；
   wake:主动调用Looper的wake0方法；

   ///frameworks/native/services/inputflinger/InputDispatcher.cpp
   void InputDispatcher::dispatchOnce() {
       nsecs_t nextWakeupTime = LONG_LONG_MAX;
       { // acquire lock
           AutoMutex _l(mLock);
           mDispatcherIsAliveCondition.broadcast();
   
           // Run a dispatch loop if there are no pending commands.
           // The dispatch loop might enqueue commands to run afterwards.
           if (!haveCommandsLocked()) {
               dispatchOnceInnerLocked(&nextWakeupTime);
           }
   
           // Run all pending commands if there are any.
           // If any commands were run then force the next poll to wake up immediately.
           if (runCommandsLockedInterruptible()) {
               nextWakeupTime = LONG_LONG_MIN;
           }
       } // release lock
   
       // 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);
   }
   

   
dispatchOnceInnerLocked
   
   ```c++
   ///frameworks/native/services/inputflinger/InputDispatcher.cpp
   void InputDispatcher::dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) {
       nsecs_t currentTime = now();
   
       // Reset the key repeat timer whenever normal dispatch is suspended while the
       // device is in a non-interactive state.  This is to ensure that we abort a key
       // repeat if the device is just coming out of sleep.
       if (!mDispatchEnabled) {
           resetKeyRepeatLocked();
       }
   
       // If dispatching is frozen, do not process timeouts or try to deliver any new events.
       //如果InputDispatcher被冻结，则不进行派发操作。
       if (mDispatchFrozen) {
   #if DEBUG_FOCUS
           ALOGD("Dispatch frozen.  Waiting some more.");
   #endif
           return;
       }
   
       // Optimize latency of app switches.
       // Essentially we start a short timeout when an app switch key (HOME / ENDCALL) has
       // been pressed.  When it expires, we preempt dispatch and drop all other pending events.
       //如果isAppSwitchDue为true，则说明没有及时相应Home键操作。
       bool isAppSwitchDue = mAppSwitchDueTime <= currentTime;
       if (mAppSwitchDueTime < *nextWakeupTime) {
           *nextWakeupTime = mAppSwitchDueTime;
       }
   
       // Ready to start a new event.
       // If we don't already have a pending event, go grab one.
       //如果还没有待分发的事件，则在mInboundQueue中取出一个事件。
       if (! mPendingEvent) {
           //如果mInboundQueue为空，并且没有待分发的事件就return。
           if (mInboundQueue.isEmpty()) {
               if (isAppSwitchDue) {
                   // The inbound queue is empty so the app switch key we were waiting
                   // for will never arrive.  Stop waiting for it.
                   resetPendingAppSwitchLocked(false);
                   isAppSwitchDue = false;
               }
   
               // Synthesize a key repeat if appropriate.
               if (mKeyRepeatState.lastKeyEntry) {
                   if (currentTime >= mKeyRepeatState.nextRepeatTime) {
                       mPendingEvent = synthesizeKeyRepeatLocked(currentTime);
                   } else {
                       if (mKeyRepeatState.nextRepeatTime < *nextWakeupTime) {
                           *nextWakeupTime = mKeyRepeatState.nextRepeatTime;
                       }
                   }
               }
   
               // Nothing to do if there is no pending event.
               if (!mPendingEvent) {
                   return;
               }
           } else {
               // Inbound queue has at least one entry.
               //如果mInboundQueue不为空，则取队列头部的EventEntry赋值给mPendingEvent
               mPendingEvent = mInboundQueue.dequeueAtHead();
               traceInboundQueueLengthLocked();
           }
   
           // Poke user activity for this event.
           if (mPendingEvent->policyFlags & POLICY_FLAG_PASS_TO_USER) {
               pokeUserActivityLocked(mPendingEvent);
           }
   
           // Get ready to dispatch the event.
           resetANRTimeoutsLocked();
       }
   
       // Now we have an event to dispatch.
       // All events are eventually dequeued and processed this way, even if we intend to drop them.
       ALOG_ASSERT(mPendingEvent != NULL);
       bool done = false;
       DropReason dropReason = DROP_REASON_NOT_DROPPED;
       if (!(mPendingEvent->policyFlags & POLICY_FLAG_PASS_TO_USER)) {
           dropReason = DROP_REASON_POLICY;
       } else if (!mDispatchEnabled) {
           dropReason = DROP_REASON_DISABLED;
       }
   
       if (mNextUnblockedEvent == mPendingEvent) {
           mNextUnblockedEvent = NULL;
       }
   
       switch (mPendingEvent->type) {
       case EventEntry::TYPE_CONFIGURATION_CHANGED: {
           ConfigurationChangedEntry* typedEntry =
                   static_cast(mPendingEvent);
           done = dispatchConfigurationChangedLocked(currentTime, typedEntry);
           dropReason = DROP_REASON_NOT_DROPPED; // configuration changes are never dropped
           break;
       }
   
       case EventEntry::TYPE_DEVICE_RESET: {
           DeviceResetEntry* typedEntry =
                   static_cast(mPendingEvent);
           done = dispatchDeviceResetLocked(currentTime, typedEntry);
           dropReason = DROP_REASON_NOT_DROPPED; // device resets are never dropped
           break;
       }
   
       case EventEntry::TYPE_KEY: {
           KeyEntry* typedEntry = static_cast(mPendingEvent);
           if (isAppSwitchDue) {
               if (isAppSwitchKeyEventLocked(typedEntry)) {
                   resetPendingAppSwitchLocked(true);
                   isAppSwitchDue = false;
               } else if (dropReason == DROP_REASON_NOT_DROPPED) {
                   dropReason = DROP_REASON_APP_SWITCH;
               }
           }
           if (dropReason == DROP_REASON_NOT_DROPPED
                   && isStaleEventLocked(currentTime, typedEntry)) {
               dropReason = DROP_REASON_STALE;
           }
           if (dropReason == DROP_REASON_NOT_DROPPED && mNextUnblockedEvent) {
               dropReason = DROP_REASON_BLOCKED;
           }
           done = dispatchKeyLocked(currentTime, typedEntry, &dropReason, nextWakeupTime);
           break;
       }
   
       case EventEntry::TYPE_MOTION: {
           MotionEntry* typedEntry = static_cast(mPendingEvent);
           //没有及时响应窗口切换操作
           if (dropReason == DROP_REASON_NOT_DROPPED && isAppSwitchDue) {
               dropReason = DROP_REASON_APP_SWITCH;
           }
           //事件过期
           if (dropReason == DROP_REASON_NOT_DROPPED
                   && isStaleEventLocked(currentTime, typedEntry)) {
               dropReason = DROP_REASON_STALE;
           }
           //阻碍其他窗口获取事件
           if (dropReason == DROP_REASON_NOT_DROPPED && mNextUnblockedEvent) {
               dropReason = DROP_REASON_BLOCKED;
           }
           //手动注意
           done = dispatchMotionLocked(currentTime, typedEntry,
                   &dropReason, nextWakeupTime);
           break;
       }
   
       default:
           ALOG_ASSERT(false);
           break;
       }
   
       if (done) {
        if (dropReason != DROP_REASON_NOT_DROPPED) {
               dropInboundEventLocked(mPendingEvent, dropReason);
        }
           mLastDropReason = dropReason;
   
           //释放本次事件处理对象
        releasePendingEventLocked();
           //使InputDispatcher能够快速处理下一个分发事件。
           *nextWakeupTime = LONG_LONG_MIN;  // force next poll to wake up immediately
       }
   }

dispatchMotionLocked

这里两条线，
1.findTouchedWindowTargetLocked 负责找到要分发的Window
2.dispatchEventLocked 负责具体分发目标

///frameworks/native/services/inputflinger/InputDispatcher.cpp
bool InputDispatcher::dispatchMotionLocked(
        nsecs_t currentTime, MotionEntry* entry, DropReason* dropReason, nsecs_t* nextWakeupTime) {
    // Preprocessing.
    if (! entry->dispatchInProgress) {
        //标记当前已经进入分发流程
        entry->dispatchInProgress = true;

        logOutboundMotionDetailsLocked("dispatchMotion - ", entry);
    }

    //如果事件是需要丢弃的，则返回true，不会为该事件寻找合适的窗口
    // Clean up if dropping the event.
    if (*dropReason != DROP_REASON_NOT_DROPPED) {
        setInjectionResultLocked(entry, *dropReason == DROP_REASON_POLICY
                ? INPUT_EVENT_INJECTION_SUCCEEDED : INPUT_EVENT_INJECTION_FAILED);
        return true;
    }

    bool isPointerEvent = entry->source & AINPUT_SOURCE_CLASS_POINTER;

    // Identify targets.
    Vector inputTargets;

    bool conflictingPointerActions = false;
    int32_t injectionResult;
    if (isPointerEvent) {
        //处理触摸形式的事件，
        // Pointer event.  (eg. touchscreen)负责找到要分发的Window
        injectionResult = findTouchedWindowTargetsLocked(currentTime,
                entry, inputTargets, nextWakeupTime, &conflictingPointerActions);
    } else {
        //处理非触摸形式的事件 比如轨迹球。
        // Non touch event.  (eg. trackball)负责找到要分发的Window
        injectionResult = findFocusedWindowTargetsLocked(currentTime,
                entry, inputTargets, nextWakeupTime);
    }
    //输入事件被挂起，说明找到了窗口并且窗口无响应。
    if (injectionResult == INPUT_EVENT_INJECTION_PENDING) {
        return false;
    }

    setInjectionResultLocked(entry, injectionResult);
    //输入事件没有分发成功，说明没有找到合适的窗口。
    if (injectionResult != INPUT_EVENT_INJECTION_SUCCEEDED) {
        if (injectionResult != INPUT_EVENT_INJECTION_PERMISSION_DENIED) {
            CancelationOptions::Mode mode(isPointerEvent ?
                    CancelationOptions::CANCEL_POINTER_EVENTS :
                 CancelationOptions::CANCEL_NON_POINTER_EVENTS);
            CancelationOptions options(mode, "input event injection failed");
         synthesizeCancelationEventsForMonitorsLocked(options);
        }
     return true;
    }

    //将分发的目标添加到inputTargets列表中。
    addMonitoringTargetsLocked(inputTargets);

    // Dispatch the motion.
    if (conflictingPointerActions) {
        CancelationOptions options(CancelationOptions::CANCEL_POINTER_EVENTS,
                "conflicting pointer actions");
        synthesizeCancelationEventsForAllConnectionsLocked(options);
    }
    //将事件分发给inputTargets列表的目标。
    dispatchEventLocked(currentTime, entry, inputTargets);//负责具体分发目标
    return true;
}

我们先分析findTouchedWindowTargetLocked这条线。

这是一个很长的方法,省略一些无关的代码。大体是判断这个事件的类型，获取能够处理这个事件的forceground window,如果这个window不能够继续处理事件，就是说这个window的主线程被某些耗时操作占据，handleTargetsNotReadyLocked这个方法主要是判定当前的window是否发生ANR如果没有则处理下面的addWindowTargetLocked。

///frameworks/native/services/inputflinger/InputDispatcher.cpp
int32_t InputDispatcher::findTouchedWindowTargetsLocked(nsecs_t currentTime,
        const MotionEntry* entry, Vector& inputTargets, nsecs_t* nextWakeupTime,
        bool* outConflictingPointerActions) {

......
    //确保所有触摸过的前台窗口都为新的输入做好了准备
      for (size_t i = 0; i < mTempTouchState.windows.size(); i++) {
        const TouchedWindow& touchedWindow = mTempTouchState.windows[i];
        if (touchedWindow.targetFlags & InputTarget::FLAG_FOREGROUND) {
            // Check whether the window is ready for more input.
            //检查窗口是否准备好接收更多的输入。
            std::string reason = checkWindowReadyForMoreInputLocked(currentTime,
                    touchedWindow.windowHandle, entry, "touched");
            if (!reason.empty()) {
                //如果窗口没有准备好，则将原因赋值给injectionResult
                injectionResult = handleTargetsNotReadyLocked(currentTime, entry,
                        NULL, touchedWindow.windowHandle, nextWakeupTime, reason.c_str());
                goto Unresponsive;
            }
        }
    }  
    ......
        
        
          // Success!  Output targets.窗口检查成功
    injectionResult = INPUT_EVENT_INJECTION_SUCCEEDED;

    //遍历mTempTouchState中的窗口
    for (size_t i = 0; i < mTempTouchState.windows.size(); i++) {
        const TouchedWindow& touchedWindow = mTempTouchState.windows.itemAt(i);
       //为每个mTempTouchState中的窗口生成inputTargets
        addWindowTargetLocked(touchedWindow.windowHandle, touchedWindow.targetFlags,
                touchedWindow.pointerIds, inputTargets);
    }

    // Drop the outside or hover touch windows since we will not care about them
    // in the next iteration.
    //在下一次迭代中，删除外部窗口或悬停触摸窗口
    mTempTouchState.filterNonAsIsTouchWindows();
    ......
}

addWindowTargetLocked这里主要的目的是将inputChannel添加至InputTarget中

///frameworks/native/services/inputflinger/InputDispatcher.cpp
void InputDispatcher::addWindowTargetLocked(const sp& windowHandle,
        int32_t targetFlags, BitSet32 pointerIds, Vector& inputTargets) {
    inputTargets.push();

    const InputWindowInfo* windowInfo = windowHandle->getInfo();
    InputTarget& target = inputTargets.editTop();
    target.inputChannel = windowInfo->inputChannel;
    target.flags = targetFlags;
    target.xOffset = - windowInfo->frameLeft;
    target.yOffset = - windowInfo->frameTop;
    target.scaleFactor = windowInfo->scaleFactor;
    target.pointerIds = pointerIds;
}

我们在看看另一条线dispatchEventLocked（向目标窗口发送事件）

///frameworks/native/services/inputflinger/InputDispatcher.cpp
void InputDispatcher::dispatchEventLocked(nsecs_t currentTime,
        EventEntry* eventEntry, const Vector& inputTargets) {
#if DEBUG_DISPATCH_CYCLE
    ALOGD("dispatchEventToCurrentInputTargets");
#endif

    ALOG_ASSERT(eventEntry->dispatchInProgress); // should already have been set to true

    pokeUserActivityLocked(eventEntry);

    //遍历inputTargets列表
    for (size_t i = 0; i < inputTargets.size(); i++) {
        const InputTarget& inputTarget = inputTargets.itemAt(i);

        //根据inputTarget内部的inputChannel来获取Connection的索引。
        ssize_t connectionIndex = getConnectionIndexLocked(inputTarget.inputChannel);
        if (connectionIndex >= 0) {
            //获取mConnectionsByFd容器中的Connection
            sp connection = mConnectionsByFd.valueAt(connectionIndex);
            //手动注意
            //根据inputTarget开始事件发送循环。
            prepareDispatchCycleLocked(currentTime, connection, eventEntry, &inputTarget);
        } else {
#if DEBUG_FOCUS
            ALOGD("Dropping event delivery to target with channel '%s' because it "
                    "is no longer registered with the input dispatcher.",
                    inputTarget.inputChannel->getName().c_str());
#endif
        }
    }
}

prepareDispatchCycleLocked

///frameworks/native/services/inputflinger/InputDispatcher.cpp
void InputDispatcher::prepareDispatchCycleLocked(nsecs_t currentTime,
        const sp& connection, EventEntry* eventEntry, const InputTarget* inputTarget) {
#if DEBUG_DISPATCH_CYCLE
    ALOGD("channel '%s' ~ prepareDispatchCycle - flags=0x%08x, "
            "xOffset=%f, yOffset=%f, scaleFactor=%f, "
            "pointerIds=0x%x",
            connection->getInputChannelName().c_str(), inputTarget->flags,
            inputTarget->xOffset, inputTarget->yOffset,
            inputTarget->scaleFactor, inputTarget->pointerIds.value);
#endif

    // Skip this event if the connection status is not normal.
    // We don't want to enqueue additional outbound events if the connection is broken.
    if (connection->status != Connection::STATUS_NORMAL) {
#if DEBUG_DISPATCH_CYCLE
        ALOGD("channel '%s' ~ Dropping event because the channel status is %s",
                connection->getInputChannelName().c_str(), connection->getStatusLabel());
#endif
        return;
    }

    // Split a motion event if needed.
    if (inputTarget->flags & InputTarget::FLAG_SPLIT) {
        ALOG_ASSERT(eventEntry->type == EventEntry::TYPE_MOTION);

        MotionEntry* originalMotionEntry = static_cast(eventEntry);
        if (inputTarget->pointerIds.count() != originalMotionEntry->pointerCount) {
            MotionEntry* splitMotionEntry = splitMotionEvent(
                    originalMotionEntry, inputTarget->pointerIds);
            if (!splitMotionEntry) {
                return; // split event was dropped
            }
#if DEBUG_FOCUS
            ALOGD("channel '%s' ~ Split motion event.",
                    connection->getInputChannelName().c_str());
            logOutboundMotionDetailsLocked("  ", splitMotionEntry);
#endif
            //手动注意
            enqueueDispatchEntriesLocked(currentTime, connection,
                    splitMotionEntry, inputTarget);
            splitMotionEntry->release();
            return;
        }
    }

    // Not splitting.  Enqueue dispatch entries for the event as is.
    enqueueDispatchEntriesLocked(currentTime, connection, eventEntry, inputTarget);
}

enqueueDispatchEntriesLocked

该方法主要功能：

• 根据dispatchMode来决定是否需要加入outboundQueue队列;

• 根据EventEntry,来生成DispatchEntry事件；

• 将dispatchEntry加入到connection的outbound队列.

  执行到这里，其实等于又做了一次搬运的工作，将InputDispatcher中mlnboundQueue中的事件取出后，找到目标window后，封装dispatchEntry加入到connection的outbound队列.

///frameworks/native/services/inputflinger/InputDispatcher.cpp
void InputDispatcher::enqueueDispatchEntriesLocked(nsecs_t currentTime,
        const sp& connection, EventEntry* eventEntry, const InputTarget* inputTarget) {
    bool wasEmpty = connection->outboundQueue.isEmpty();

    //手动注意
    // Enqueue dispatch entries for the requested modes.
    enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
            InputTarget::FLAG_DISPATCH_AS_HOVER_EXIT);
    enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
            InputTarget::FLAG_DISPATCH_AS_OUTSIDE);
    enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
            InputTarget::FLAG_DISPATCH_AS_HOVER_ENTER);
    enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
            InputTarget::FLAG_DISPATCH_AS_IS);
    enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
            InputTarget::FLAG_DISPATCH_AS_SLIPPERY_EXIT);
    enqueueDispatchEntryLocked(connection, eventEntry, inputTarget,
            InputTarget::FLAG_DISPATCH_AS_SLIPPERY_ENTER);

    // If the outbound queue was previously empty, start the dispatch cycle going.
    if (wasEmpty && !connection->outboundQueue.isEmpty()) {
        startDispatchCycleLocked(currentTime, connection);
    }
}

startDispatchCycleLocked

startDispatchCycleLocked的主要功能：从outboundQueue中取出事件,重新放入waitQueue队列

startDispatchCycleLocked触发时机：当起初connection.outboundQueue等于空，经enqueueDispatchEntryLocked处理后,outboundQueue不等于空。

///frameworks/native/services/inputflinger/InputDispatcher.cpp
void InputDispatcher::startDispatchCycleLocked(nsecs_t currentTime,
        const sp& connection) {
#if DEBUG_DISPATCH_CYCLE
    ALOGD("channel '%s' ~ startDispatchCycle",
            connection->getInputChannelName().c_str());
#endif

    while (connection->status == Connection::STATUS_NORMAL
            && !connection->outboundQueue.isEmpty()) {
        DispatchEntry* dispatchEntry = connection->outboundQueue.head;
        dispatchEntry->deliveryTime = currentTime;

        // Publish the event.
        status_t status;
        EventEntry* eventEntry = dispatchEntry->eventEntry;
        switch (eventEntry->type) {
        case EventEntry::TYPE_KEY: {
            KeyEntry* keyEntry = static_cast(eventEntry);

            // Publish the key event.
            status = connection->inputPublisher.publishKeyEvent(dispatchEntry->seq,
                    keyEntry->deviceId, keyEntry->source,
                    dispatchEntry->resolvedAction, dispatchEntry->resolvedFlags,
                    keyEntry->keyCode, keyEntry->scanCode,
                    keyEntry->metaState, keyEntry->repeatCount, keyEntry->downTime,
                    keyEntry->eventTime);
            break;
        }

        case EventEntry::TYPE_MOTION: {
            MotionEntry* motionEntry = static_cast(eventEntry);

            PointerCoords scaledCoords[MAX_POINTERS];
            const PointerCoords* usingCoords = motionEntry->pointerCoords;

            // Set the X and Y offset depending on the input source.
            float xOffset, yOffset;
            if ((motionEntry->source & AINPUT_SOURCE_CLASS_POINTER)
                    && !(dispatchEntry->targetFlags & InputTarget::FLAG_ZERO_COORDS)) {
                float scaleFactor = dispatchEntry->scaleFactor;
                xOffset = dispatchEntry->xOffset * scaleFactor;
                yOffset = dispatchEntry->yOffset * scaleFactor;
                if (scaleFactor != 1.0f) {
                    for (uint32_t i = 0; i < motionEntry->pointerCount; i++) {
                        scaledCoords[i] = motionEntry->pointerCoords[i];
                        scaledCoords[i].scale(scaleFactor);
                    }
                    usingCoords = scaledCoords;
                }
            } else {
                xOffset = 0.0f;
                yOffset = 0.0f;

                // We don't want the dispatch target to know.
                if (dispatchEntry->targetFlags & InputTarget::FLAG_ZERO_COORDS) {
                    for (uint32_t i = 0; i < motionEntry->pointerCount; i++) {
                        scaledCoords[i].clear();
                    }
                    usingCoords = scaledCoords;
                }
            }

            //手动注意
            // Publish the motion event.
            status = connection->inputPublisher.publishMotionEvent(dispatchEntry->seq,
                    motionEntry->deviceId, motionEntry->source, motionEntry->displayId,
                    dispatchEntry->resolvedAction, motionEntry->actionButton,
                    dispatchEntry->resolvedFlags, motionEntry->edgeFlags,
                    motionEntry->metaState, motionEntry->buttonState,
                    xOffset, yOffset, motionEntry->xPrecision, motionEntry->yPrecision,
                    motionEntry->downTime, motionEntry->eventTime,
                    motionEntry->pointerCount, motionEntry->pointerProperties,
                    usingCoords);
            break;
        }

        default:
            ALOG_ASSERT(false);
            return;
        }

        // Check the result.
        if (status) {
            if (status == WOULD_BLOCK) {
                if (connection->waitQueue.isEmpty()) {
                    ALOGE("channel '%s' ~ Could not publish event because the pipe is full. "
                            "This is unexpected because the wait queue is empty, so the pipe "
                            "should be empty and we shouldn't have any problems writing an "
                            "event to it, status=%d", connection->getInputChannelName().c_str(),
                            status);
                    abortBrokenDispatchCycleLocked(currentTime, connection, true /*notify*/);
                } else {
                    // Pipe is full and we are waiting for the app to finish process some events
                    // before sending more events to it.
#if DEBUG_DISPATCH_CYCLE
                    ALOGD("channel '%s' ~ Could not publish event because the pipe is full, "
                            "waiting for the application to catch up",
                            connection->getInputChannelName().c_str());
#endif
                    connection->inputPublisherBlocked = true;
                }
            } else {
                ALOGE("channel '%s' ~ Could not publish event due to an unexpected error, "
                        "status=%d", connection->getInputChannelName().c_str(), status);
                abortBrokenDispatchCycleLocked(currentTime, connection, true /*notify*/);
            }
            return;
        }

        // Re-enqueue the event on the wait queue.
        connection->outboundQueue.dequeue(dispatchEntry);
        traceOutboundQueueLengthLocked(connection);
        connection->waitQueue.enqueueAtTail(dispatchEntry);
        traceWaitQueueLengthLocked(connection);
    }
}

至此调用了connection的inputPublisher的publishMotionEvent方法将事件分发消耗。

///frameworks/native/services/inputflinger/InputTransport.cpp
status_t InputPublisher::publishMotionEvent(
        uint32_t seq,
        int32_t deviceId,
        int32_t source,
        int32_t displayId,
        int32_t action,
        int32_t actionButton,
        int32_t flags,
        int32_t edgeFlags,
        int32_t metaState,
        int32_t buttonState,
        float xOffset,
        float yOffset,
        float xPrecision,
        float yPrecision,
        nsecs_t downTime,
        nsecs_t eventTime,
        uint32_t pointerCount,
        const PointerProperties* pointerProperties,
        const PointerCoords* pointerCoords) {
#if DEBUG_TRANSPORT_ACTIONS
    ALOGD("channel '%s' publisher ~ 
          publishMotionEvent: seq=%u, deviceId=%d, source=0x%x, "
            "action=0x%x, actionButton=0x%08x, flags=0x%x, edgeFlags=0x%x, "
            "metaState=0x%x, buttonState=0x%x, xOffset=%f, yOffset=%f, "
            "xPrecision=%f, yPrecision=%f, downTime=%" PRId64 ", eventTime=%" PRId64 ", "
            "pointerCount=%" PRIu32,
            mChannel->getName().c_str(), seq,
            deviceId, source, action, actionButton, flags, edgeFlags, metaState, buttonState,
            xOffset, yOffset, xPrecision, yPrecision, downTime, eventTime, pointerCount);
#endif

    if (!seq) {
        ALOGE("Attempted to publish a motion event with sequence number 0.");
        return BAD_VALUE;
    }

    if (pointerCount > MAX_POINTERS || pointerCount < 1) {
        ALOGE("channel '%s' publisher ~ Invalid number of pointers provided: %" PRIu32 ".",
                mChannel->getName().c_str(), pointerCount);
        return BAD_VALUE;
    }

    InputMessage msg;
    msg.header.type = InputMessage::TYPE_MOTION;
    msg.body.motion.seq = seq;
    msg.body.motion.deviceId = deviceId;
    msg.body.motion.source = source;
    msg.body.motion.displayId = displayId;
    msg.body.motion.action = action;
    msg.body.motion.actionButton = actionButton;
    msg.body.motion.flags = flags;
    msg.body.motion.edgeFlags = edgeFlags;
    msg.body.motion.metaState = metaState;
    msg.body.motion.buttonState = buttonState;
    msg.body.motion.xOffset = xOffset;
    msg.body.motion.yOffset = yOffset;
    msg.body.motion.xPrecision = xPrecision;
    msg.body.motion.yPrecision = yPrecision;
    msg.body.motion.downTime = downTime;
    msg.body.motion.eventTime = eventTime;
    msg.body.motion.pointerCount = pointerCount;
    for (uint32_t i = 0; i < pointerCount; i++) {
        msg.body.motion.pointers[i].properties.copyFrom(pointerProperties[i]);
        msg.body.motion.pointers[i].coords.copyFrom(pointerCoords[i]);
    }
    //最后将消息发送
    return mChannel->sendMessage(&msg);
}