<h2>前言</h2>    <p>对于事件的监控和获取做了分析，在拿到事件之后，后续是如何处理分发的呢？本篇文章主要针对在通过getEvent获取到事件之后，后续的相关分发处理流程。</p>    <p><img src="https://simg.open-open.com/show/ae1beac840d72b79ed96d080bda5f873.png"></p>    <p>InputReaderThread函数不断地调用looperOnce函数，不断的从中读取事件，那么下一个问题来了，读取到事件要放置到哪里，又在哪里被消耗掉了呢？也就是事件接下来的流向问题。让我们回到looperOnce之前。</p>    <h2>事件分发</h2>    <p>processEventsLocked</p>    <p>在调用了getEvent之后，又调用了函数 processEventsLocked</p>    <pre>  <code class="language-java">void InputReader::processEventsLocked(const RawEvent* rawEvents, size_t count) {      for (const RawEvent* rawEvent = rawEvents; count;) {          int32_t type = rawEvent->type;          size_t batchSize = 1;          if (type < EventHubInterface::FIRST_SYNTHETIC_EVENT) {              int32_t deviceId = rawEvent->deviceId;              while (batchSize < count) {                  if (rawEvent[batchSize].type >= EventHubInterface::FIRST_SYNTHETIC_EVENT                          || rawEvent[batchSize].deviceId != deviceId) {                      break;                  }                  batchSize += 1;              }              processEventsForDeviceLocked(deviceId, rawEvent, batchSize);          } else {              switch (rawEvent->type) {              case EventHubInterface::DEVICE_ADDED:                  addDeviceLocked(rawEvent->when, rawEvent->deviceId);                  break;              case EventHubInterface::DEVICE_REMOVED:                  removeDeviceLocked(rawEvent->when, rawEvent->deviceId);                  break;              case EventHubInterface::FINISHED_DEVICE_SCAN:                  handleConfigurationChangedLocked(rawEvent->when);                  break;              default:                  ALOG_ASSERT(false); // can't happen                  break;              }          }          count -= batchSize;          rawEvent += batchSize;      }  }</code></pre>    <p>首先对于事件类型进行了判断，如果事件不是合成事件，则会对其DeviceID进行判断，通过对其判断来确定batchSize等，然后对其进行处理，对于其他的类型事件，则会具体判断，判断是设备的添加，设备的移除，完成设备扫描等等，然后对事件分别进行处理，这里我们只关心对于设备自身产生的事件。也就是触摸屏相关的事件。也就是 processEventsForDeviceLocked 函数中所进行的操作。</p>    <p>事件派发到Device</p>    <pre>  <code class="language-java">void InputReader::processEventsForDeviceLocked(int32_t deviceId,          const RawEvent* rawEvents, size_t count) {      ssize_t deviceIndex = mDevices.indexOfKey(deviceId);      if (deviceIndex < 0) {          return;      }        InputDevice* device = mDevices.valueAt(deviceIndex);      if (device->isIgnored()) {          return;      }        device->process(rawEvents, count);  }</code></pre>    <p>根据事件获得相应的设备类型，然后将事件交给相应的设备处理。判断是否忽略该事件，如果不是忽略该事件，则会调用相应设备的process方法进行处理。</p>    <p>事件派发到InputMapper</p>    <p>InputDevice的process方法</p>    <pre>  <code class="language-java">void InputDevice::process(const RawEvent* rawEvents, size_t count) {       ....      for (size_t i = 0; i < numMappers; i++) {             InputMapper* mapper = mMappers[i];             mapper->process(rawEvent);      }      ....  }</code></pre>    <p>这里的事件又交给了InputMapper来处理</p>    <p><img src="https://simg.open-open.com/show/eb7fec2cf3cc15fc4beec5186c1f5ab2.png"></p>    <p>InputMapper对应了很多的子类，这里根据事件的类型进行相应的派发，处理。</p>    <p>事件到了这里之后，如何传递到应用层，这里mapper->process进行了那些处理。这里来看一下对于触摸屏事件的处理函数。</p>    <pre>  <code class="language-java">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);      }  }</code></pre>    <p>通过这里的函数处理，我们继续追踪函数的数据流向。对于相关的事件处理，这里最终执行的是将</p>    <pre>  <code class="language-java">void TouchInputMapper::sync(nsecs_t when) {      .....      processRawTouches(false /*timeout*/);  }</code></pre>    <pre>  <code class="language-java">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);              cookAndDispatch(when);          } else if (mExternalStylusFusionTimeout == LLONG_MAX) {              mExternalStylusFusionTimeout = mExternalStylusState.when + TOUCH_DATA_TIMEOUT;              getContext()->requestTimeoutAtTime(mExternalStylusFusionTimeout);          }      }  }</code></pre>    <p>在相关的函数调用之后，最终调用了 dispatchTouches</p>    <pre>  <code class="language-java">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);  }</code></pre>    <pre>  <code class="language-java">void TouchInputMapper::dispatchTouches(nsecs_t when, uint32_t policyFlags) {        ....      dispatchMotion();        ....  }</code></pre>    <p>对于dispatchTouches中，会根据记录的上一次的触摸位置，对事件的类型进行判断，然后做相应的分发，事件类型有抬起，下落，移动等，然后对相应的事件进行分发。无论是对于何种类型的事件派发，最终被调用到的都是 dispatchMotion() 方法。</p>    <p>对于相关事件的分发最终调用到了dispatchMotion()，对事件数据进行组装之后，调用了</p>    <pre>  <code class="language-java">void TouchInputMapper::dispatchMotion() {     ....     NotifyMotionArgs args(when, getDeviceId(), source, policyFlags,              action, actionButton, flags, metaState, buttonState, edgeFlags,              mViewport.displayId, pointerCount, pointerProperties, pointerCoords,              xPrecision, yPrecision, downTime);      getListener()->notifyMotion(&args);  }</code></pre>    <p>getListener函数</p>    <pre>  <code class="language-java">InputListenerInterface* InputReader::ContextImpl::getListener() {      return mReader->mQueuedListener.get();  }</code></pre>    <p>notifyMotion函数实现</p>    <pre>  <code class="language-java">void QueuedInputListener::notifyMotion(const NotifyMotionArgs* args) {      mArgsQueue.push(new NotifyMotionArgs(*args));  }</code></pre>    <p>这里可以看到，我们将触摸相关的事件进行包装之后，将其加入到一个ArgsQueue队列，到此，我们已经将数据加入到参数队列中，到此事件从设备文件获取到写入流程已经完成，这里让我们再回到loopOnce方法中，最后调用了 QueuedInputListener 的 flush 方法，</p>    <pre>  <code class="language-java">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();  }</code></pre>    <p>NotifyArgs的notify函数实现</p>    <pre>  <code class="language-java">void NotifyMotionArgs::notify(const sp<InputListenerInterface>& listener) const {      listener->notifyMotion(this);  }</code></pre>    <p>对于这个listener的创建来自于InputReader构建的时候。</p>    <pre>  <code class="language-java">mQueuedListener = new QueuedInputListener(listener);</code></pre>    <pre>  <code class="language-java">mReader = new InputReader(eventHub, readerPolicy, mDispatcher);</code></pre>    <p>而这里的Listener则是 InputDispatcher ，InputDispatcher 的notifyMotion实现源码。</p>    <pre>  <code class="language-java">void InputDispatcher::notifyMotion(const NotifyMotionArgs* args) {      .....     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);      ....    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);      ....     if (needWake) {        mLooper->wake();     }  }</code></pre>    <p>在该函数中，所做的事情是对于所传递的参数，构造MotionEntry，然后将其加入到enqueueInboundEventLocked之中。然后唤醒其中的looper。</p>    <pre>  <code class="language-java">bool InputDispatcher::enqueueInboundEventLocked(EventEntry* entry) {      bool needWake = mInboundQueue.isEmpty();      mInboundQueue.enqueueAtTail(entry);      ...      //进行一些事件和窗口相关的判断处理  }</code></pre>    <p>Dispatcher开启的线程中，每次循环的操作如何？</p>    <pre>  <code class="language-java">bool InputDispatcherThread::threadLoop() {      mDispatcher->dispatchOnce();      return true;  }</code></pre>    <p>Dispatcher下dispatchOnce的实现</p>    <pre>  <code class="language-java">void InputDispatcher::dispatchOnce() {      ...     dispatchOnceInnerLocked(&nextWakeupTime);      ...  }</code></pre>    <pre>  <code class="language-java">void InputDispatcher::dispatchOnceInnerLocked(nsecs_t* nextWakeupTime) {     ....     mPendingEvent = mInboundQueue.dequeueAtHead();     ....       switch (mPendingEvent->type) {          case EventEntry::TYPE_MOTION: {          MotionEntry* typedEntry = static_cast<MotionEntry*>(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;      }      ....     }  }</code></pre>    <p>从mInboudQueue中，获取到事件，然后对事件类型进行判断，判断之后调用了dispatchMotionLocked函数，来继续进行事件的传递。</p>    <pre>  <code class="language-java">bool InputDispatcher::dispatchMotionLocked(          nsecs_t currentTime, MotionEntry* entry, DropReason* dropReason, nsecs_t* nextWakeupTime) {        ....        Vector<InputTarget> inputTargets;  if (isPointerEvent) {          // Pointer event.  (eg. touchscreen)        //寻找目标窗口          injectionResult = findTouchedWindowTargetsLocked(currentTime,                  entry, inputTargets, nextWakeupTime, &conflictingPointerActions);      } else {          // Non touch event.  (eg. trackball）          injectionResult = findFocusedWindowTargetsLocked(currentTime,                  entry, inputTargets, nextWakeupTime);      }      ....      dispatchEventLocked(currentTime, entry, inputTargets);      return true;  }</code></pre>    <ul>     <li>dispatchEventLocked</li>    </ul>    <pre>  <code class="language-java">void InputDispatcher::dispatchEventLocked(nsecs_t currentTime,      EventEntry* eventEntry, const Vector<InputTarget>& inputTargets) {      ....      pokeUserActivityLocked(eventEntry);      .....      for (size_t i = 0; i < inputTargets.size(); i++) {          const InputTarget& inputTarget = inputTargets.itemAt(i);            ssize_t connectionIndex = getConnectionIndexLocked(inputTarget.inputChannel);          if (connectionIndex >= 0) {              sp<Connection> connection = mConnectionsByFd.valueAt(connectionIndex);              prepareDispatchCycleLocked(currentTime, connection, eventEntry, &inputTarget);          }       }  }</code></pre>    <p>获得目标输入，根据InputChannel获取相应的连接，然后调用prepareDispatchCycleLocked()，进行事件的派发。</p>    <p>enqueueDispatchEntriesLocked，在该方法中又调用了startDispatchCycleLocked方法。其实现为</p>    <pre>  <code class="language-java">void InputDispatcher::startDispatchCycleLocked(nsecs_t currentTime,          const sp<Connection>& connection) {     EventEntry* eventEntry = dispatchEntry->eventEntry;      ....     switch (eventEntry->type) {        ....      case EventEntry::TYPE_MOTION: {        status = connection->inputPublisher.publishMotionEvent( ....);            break;      }      ....     }      ...  }</code></pre>    <p>至此调用了connection 的inputPublisher的publishMotionEvent方法将事件分发消耗。</p>    <p>InputPublisher定义在InputTransport.cpp中</p>    <pre>  <code class="language-java">status_t InputPublisher::publishMotionEvent(...) {    ....    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.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);  }</code></pre>    <p>该方法所执行的操作是利用传入的触摸信息，构建点击消息，然后通过InputChannel将消息发送出去。这里引出了InputChannel，在此，我们通InputPublisher的创建反推出InputChannel是何时被引入的，何时被创建的。从而进一步分析其作用。在分析之前先让我们来对上述的分析过程做一个总结。</p>    <p><img src="https://simg.open-open.com/show/75e22b4ee48b4ead08f1442abce9d627.png"></p>    <p>ReaderThread开启后会从EventHub中轮询获取时间，获取到事件之后，对手将进行一系列的处理，最终将经过一系列处理封装的事件信息通过InputChannel发送出去。</p>    <p><img src="https://simg.open-open.com/show/a03d601bc5a1dd2d2b3552aa72a8cadf.png"></p>    <p>到此，对于输入事件，我们已经分析到了InputChannel，对于其上的具体分析转化，将是接下来分析的核心。</p>    <p>InputChannel</p>    <p>从上面分析可以看到事件传递部分最后是通过InputChannel所发送出去的，那么InputChannel是在何时被创建的呢？何时被InputManager所使用的呢？同时，InputReaderThread和InputDispatcherThread是运行在SystemServer进程中的，而我们的应用进程是和其不在同一个进程中的。这之间一定也是有进程间的通信机制在里面。具体又是如何实现的呢？对于InputChannel这边是事件传递过程中一个比较核心的点。</p>    <p>InputChannel的创建是在 ViewRootImpl 中 setView 方法中。</p>    <pre>  <code class="language-java">public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {      ....    if ((mWindowAttributes.inputFeatures                          & WindowManager.LayoutParams.INPUT_FEATURE_NO_INPUT_CHANNEL) == 0) {         mInputChannel = new InputChannel();     }    ....    res = mWindowSession.addToDisplay(mWindow, mSeq, mWindowAttributes,                              getHostVisibility(), mDisplay.getDisplayId(),                              mAttachInfo.mContentInsets, mAttachInfo.mStableInsets,                              mAttachInfo.mOutsets, mInputChannel);    ....  }</code></pre>    <p>这里对于ViewRootImpl和WindowSession相关暂且不介绍，对于这方面的知识，需要很大的篇幅来介绍，这里先只是讲到是在这里创建的，对于其相关的内容将在后续的文章中介绍。这里首先是创建了一个InputChannel，然后将其调用了 WindowSession 的 addToDisplay 方法将其作为参数传递。</p>    <pre>  <code class="language-java">public InputChannel() {  }</code></pre>    <p>在InputChannel中的方法都为调用了相应的native方法。这里调用的addToDisplay将会把InputChannel添加到WindowManagerService中。会调用WMS的 addWindow 方法。</p>    <pre>  <code class="language-java">public int addWindow(Session session, IWindow client, int seq,              WindowManager.LayoutParams attrs, int viewVisibility, int displayId,              Rect outContentInsets, Rect outStableInsets, Rect outOutsets,              InputChannel outInputChannel) {        ....          final boolean openInputChannels = (outInputChannel != null                      && (attrs.inputFeatures & INPUT_FEATURE_NO_INPUT_CHANNEL) == 0);        if  (openInputChannels) {            win.openInputChannel(outInputChannel);        }        ....  }</code></pre>    <p>对于InputChannel的相关处理调用了WindowState的openInputChannel方法。</p>    <pre>  <code class="language-java">void openInputChannel(InputChannel outInputChannel) {      if (mInputChannel != null) {          throw new IllegalStateException("Window already has an input channel.");       }       String name = makeInputChannelName();       InputChannel[] inputChannels = InputChannel.openInputChannelPair(name);       mInputChannel = inputChannels[0];       mClientChannel = inputChannels[1];       mInputWindowHandle.inputChannel = inputChannels[0];       if (outInputChannel != null) {         mClientChannel.transferTo(outInputChannel);         mClientChannel.dispose();         mClientChannel = null;        } else {           mDeadWindowEventReceiver = new DeadWindowEventReceiver(mClientChannel);        }         mService.mInputManager.registerInputChannel(mInputChannel, mInputWindowHandle);  }</code></pre>    <p>首先调用了InputChannel的 openInputChannelPair 方法，该方法调用了InputChannel的native方法 nativeOpenInputChannelPair ,创建了两个 InputChannel ，对其中一个通过 InputManager 进行了InputChannel的注册。对于 InputChannel 的相关Native的实现是在InputTransport中， nativeOpenInputChannelPair 的源码如下。</p>    <pre>  <code class="language-java">status_t InputChannel::openInputChannelPair(const String8& name,          sp<InputChannel>& outServerChannel, sp<InputChannel>& outClientChannel) {      int sockets[2];      if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, sockets)) {          status_t result = -errno;          outServerChannel.clear();          outClientChannel.clear();          return result;      }        int bufferSize = SOCKET_BUFFER_SIZE;      setsockopt(sockets[0], SOL_SOCKET, SO_SNDBUF, &bufferSize, sizeof(bufferSize));      setsockopt(sockets[0], SOL_SOCKET, SO_RCVBUF, &bufferSize, sizeof(bufferSize));      setsockopt(sockets[1], SOL_SOCKET, SO_SNDBUF, &bufferSize, sizeof(bufferSize));      setsockopt(sockets[1], SOL_SOCKET, SO_RCVBUF, &bufferSize, sizeof(bufferSize));        String8 serverChannelName = name;      serverChannelName.append(" (server)");      outServerChannel = new InputChannel(serverChannelName, sockets[0]);        String8 clientChannelName = name;      clientChannelName.append(" (client)");      outClientChannel = new InputChannel(clientChannelName, sockets[1]);      return OK;  }</code></pre>    <p>这里的Socket创建用到了 Linux中的Socketpaire，在之前的版本中是通过管道来实现的，但是 创建的管道只能是单向的 -- mode 只能是 "r" 或 "w" 而不能是某种组合--用户只能选择要么往里写，要么从中读，而不能同时在一个管道中进行读写。实际应用中，经常会有同时进行读写的要求。</p>    <p>Linux实现了一个源自BSD的socketpair调用可以实现上述在同一个文件描述符中进行读写的功能（该调用目前也是POSIX规范的一部分 。该系统调用能创建一对已连接的（UNIX族）无名socket。在Linux中，完全可以把这一对socket当成pipe返回的文件描述符一样使用，唯一的区别就是这一对文件描述符中的任何一个都可读和可写。</p>    <p>socketpair产生的文件描述符是一对socket，socket上的标准操作都可以使用，其中也包括shutdown。——利用shutdown，可以实现一个半关闭操作，通知对端本进程不再发送数据，同时仍可以利用该文件描述符接收来自对端的数据。</p>    <pre>  <code class="language-java">status_t InputChannel::sendMessage(const InputMessage* msg) {      size_t msgLength = msg->size();      ssize_t nWrite;      do {          nWrite = ::send(mFd, msg, msgLength, MSG_DONTWAIT | MSG_NOSIGNAL);      } while (nWrite == -1 && errno == EINTR);       .....      return OK;  }</code></pre>    <p>接收消息，通过读socket的方式来读取消息。</p>    <pre>  <code class="language-java">status_t InputChannel::receiveMessage(InputMessage* msg) {      ssize_t nRead;      do {          nRead = ::recv(mFd, msg, sizeof(InputMessage), MSG_DONTWAIT);      } while (nRead == -1 && errno == EINTR);      ......      return OK;  }</code></pre>    <p>通过之前的分析，我们已经追踪到了通过InputChannel发送消息的代码，接收端的消息处理是如何呢？是如何触发开始接收消息，消息如何在传到InputChannel之后，进行的进一步的数据传递呢？分析之前，这里先对上面InputChannel进行一个总结。</p>    <p><img src="https://simg.open-open.com/show/d0fc4e82fafc5ca6d15c0f78939ee860.png"></p>    <p>之前的 setView 中，我们创建了InputChannel之后，开启了对于InputChannel中输入事件的监听。</p>    <pre>  <code class="language-java">if (mInputChannel != null) {     if (mInputQueueCallback != null) {         mInputQueue = new InputQueue();         mInputQueueCallback.onInputQueueCreated(mInputQueue);    }     mInputEventReceiver = new WindowInputEventReceiver(mInputChannel,                              Looper.myLooper());  }</code></pre>    <p>WindowInputEventReceiver的构造函数如下，其继承自InputEventReceiver。</p>    <pre>  <code class="language-java">final class WindowInputEventReceiver extends InputEventReceiver {       public WindowInputEventReceiver(InputChannel inputChannel, Looper looper) {           super(inputChannel, looper);       }        ....  }</code></pre>    <p>InputEventReceiver的构造函数源码如下</p>    <pre>  <code class="language-java">public InputEventReceiver(InputChannel inputChannel, Looper looper) {       ....       mInputChannel = inputChannel;       mMessageQueue = looper.getQueue();       mReceiverPtr = nativeInit(new WeakReference<InputEventReceiver>(this),                  inputChannel, mMessageQueue);    }</code></pre>    <p>这里调用了native方法来做初始化，相关的native方法的实现在 android_view_InputEventReceiver.cpp</p>    <pre>  <code class="language-java">static jlong nativeInit(JNIEnv* env, jclass clazz, jobject receiverWeak,          jobject inputChannelObj, jobject messageQueueObj) {     ....    sp<InputChannel> inputChannel = android_view_InputChannel_getInputChannel(env,              inputChannelObj);    sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, messageQueueObj);    sp<NativeInputEventReceiver> receiver = new NativeInputEventReceiver(env,              receiverWeak, inputChannel, messageQueue);      status_t status = receiver->initialize();    .....  }</code></pre>    <p>根据传入的 InputChannel 和 MessageQueue ，创建一个NativeInputEventReceiver，然后调用其 initialize 方法。</p>    <pre>  <code class="language-java">status_t NativeInputEventReceiver::initialize() {      setFdEvents(ALOOPER_EVENT_INPUT);      return OK;  }</code></pre>    <p>在 initialize() 方法中，只调用了一个函数 setFdEvents ，</p>    <pre>  <code class="language-java">void NativeInputEventReceiver::setFdEvents(int events) {      if (mFdEvents != events) {          mFdEvents = events;          int fd = mInputConsumer.getChannel()->getFd();          if (events) {              mMessageQueue->getLooper()->addFd(fd, 0, events, this, NULL);          } else {              mMessageQueue->getLooper()->removeFd(fd);          }      }  }</code></pre>    <p>从InputConsumer中获取到channel的fd，然后调用Looper的 addFd 方法。</p>    <pre>  <code class="language-java">int ALooper_addFd(ALooper* looper, int fd, int ident, int events,          ALooper_callbackFunc callback, void* data) {      return ALooper_to_Looper(looper)->addFd(fd, ident, events, callback, data);  }</code></pre>    <p>Looper的addFd的实现如下</p>    <pre>  <code class="language-java">int Looper::addFd(int fd, int ident, int events, const sp<LooperCallback>& callback, void* data) {      Request request;      request.fd = fd;      request.ident = ident;      request.events = events;      request.seq = mNextRequestSeq++;      request.callback = callback;       request.data = data;       if (mNextRequestSeq == -1) mNextRequestSeq = 0;       struct epoll_event eventItem;       request.initEventItem(&eventItem);       ssize_t requestIndex = mRequests.indexOfKey(fd);        if (requestIndex < 0) {            int epollResult = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, fd, & eventItem);            if (epollResult < 0) {                  return -1;              }           mRequests.add(fd, request);         }   }</code></pre>    <p>该方法所执行的操作就是对传递的fd添加epoll监控，Looper会循环调用 pollOnce 方法，而 pollOnce 方法的核心实现就是 pollInner 。其代码大致实现内容为等待消息的到来，当有消息到来后，根据消息类型做一些判断处理，然后调用其相关的callback。我们当前是对于开启的socket的一个监听，当有数据到来，我们便会执行相应的回调。这里对于InputChannel的回调是在调用了NativeInputEventReceiver的 handleEvent 方法。</p>    <pre>  <code class="language-java">int NativeInputEventReceiver::handleEvent(int receiveFd, int events, void* data) {      .....     if (events & ALOOPER_EVENT_INPUT) {          JNIEnv* env = AndroidRuntime::getJNIEnv();          status_t status = consumeEvents(env, false /*consumeBatches*/, -1, NULL);          mMessageQueue->raiseAndClearException(env, "handleReceiveCallback");          return status == OK || status == NO_MEMORY ? 1 : 0;      }      ....      return 1;  }</code></pre>    <p>对于Event的处理，这里调用consumeEvents来对事件进行处理。</p>    <pre>  <code class="language-java">status_t NativeInputEventReceiver::consumeEvents(JNIEnv* env,          bool consumeBatches, nsecs_t frameTime, bool* outConsumedBatch) {      ...      for(;;) {        ...       InputEvent* inputEvent;       status_t status = mInputConsumer.consume(&mInputEventFactory,                  consumeBatches, frameTime, &seq, &inputEvent);          ...      }     ...  }</code></pre>    <p>InputConsumer是在InputTransport中做的声明。</p>    <pre>  <code class="language-java">status_t InputConsumer::consume(InputEventFactoryInterface* factory,          bool consumeBatches, nsecs_t frameTime, uint32_t* outSeq, InputEvent** outEvent) {      while (!*outEvent) {           ....           status_t result = mChannel->receiveMessage(&mMsg);            ....      }  }</code></pre>    <p>调用consume方法会持续的调用InputChannel的receiveMessage方法来从socket中读取数据。到这里，我们已经将写入socket的事件读出来了。InputChannel在创建之后，通过为其InputEventReceiver对其fd进行epoll监控，当有变动的时候，调用InputChannel来接收消息。InputChannel又是如何被设置到InputDispatcher之中的呢？在调用 openInputChannel 方法，创建Socket的完成之后，调用该方法。</p>    <pre>  <code class="language-java">public void registerInputChannel(InputChannel inputChannel,              InputWindowHandle inputWindowHandle) {     if (inputChannel == null) {        throw new IllegalArgumentException("inputChannel must not be null.");     }     nativeRegisterInputChannel(mPtr, inputChannel, inputWindowHandle, false);  }</code></pre>    <p>nativeRegisterInputManger</p>    <pre>  <code class="language-java">static void nativeRegisterInputChannel(JNIEnv* env, jclass /* clazz */,          jlong ptr, jobject inputChannelObj, jobject inputWindowHandleObj, jboolean monitor) {      NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);        sp<InputChannel> inputChannel = android_view_InputChannel_getInputChannel(env,              inputChannelObj);      if (inputChannel == NULL) {          throwInputChannelNotInitialized(env);          return;      }        sp<InputWindowHandle> inputWindowHandle =              android_server_InputWindowHandle_getHandle(env, inputWindowHandleObj);        status_t status = im->registerInputChannel(              env, inputChannel, inputWindowHandle, monitor);      if (status) {          String8 message;          message.appendFormat("Failed to register input channel.  status=%d", status);          jniThrowRuntimeException(env, message.string());          return;      }        if (! monitor) {          android_view_InputChannel_setDisposeCallback(env, inputChannelObj,                  handleInputChannelDisposed, im);      }  }</code></pre>    <p>NativeInputManager的 registerInputChannel 还会调用到InputDispatcher的registerInputChannel，会通过InputChannel创建相应的Connection，同时将InputChannel加入到相应的监控之中。在上面对代码的分析之中，获取InputChannel，就是通过这个Connection来获取的。</p>    <pre>  <code class="language-java">status_t InputDispatcher::registerInputChannel(const sp<InputChannel>& inputChannel,          const sp<InputWindowHandle>& inputWindowHandle, bool monitor) {      { // acquire lock          AutoMutex _l(mLock);            if (getConnectionIndexLocked(inputChannel) >= 0) {              return BAD_VALUE;          }            sp<Connection> connection = new Connection(inputChannel, inputWindowHandle, monitor);            int fd = inputChannel->getFd();          mConnectionsByFd.add(fd, connection);            if (monitor) {              mMonitoringChannels.push(inputChannel);          }            mLooper->addFd(fd, 0, ALOOPER_EVENT_INPUT, handleReceiveCallback, this);      } // release lock        // Wake the looper because some connections have changed.      mLooper->wake();      return OK;  }</code></pre>    <p>经过InputManager的层层传递，最终会到达InputDispatcher之中，然后对其进行封装，并在其内部进行保存，同时也传递了相应的窗口的句柄，方便了后期在事件传递的时候，对于窗口的判断。</p>    <p>ViewRootImpl</p>    <p>事件在从socket读出之后，经过传递，最终会调用到ViewRootImpl的 enqueueInputEvent 方法。</p>    <pre>  <code class="language-java">void enqueueInputEvent(InputEvent event,              InputEventReceiver receiver, int flags, boolean processImmediately) {       adjustInputEventForCompatibility(event);       QueuedInputEvent q = obtainQueuedInputEvent(event, receiver, flags);         QueuedInputEvent last = mPendingInputEventTail;       if (last == null) {           mPendingInputEventHead = q;           mPendingInputEventTail = q;        } else {            last.mNext = q;            mPendingInputEventTail = q;        }        mPendingInputEventCount += 1;          if (processImmediately) {            doProcessInputEvents();        } else {            scheduleProcessInputEvents();        }   }</code></pre>    <p>enqueueInputEvent 方法从InputEventReceiver中获取到InputEvent，然后将其加入到当前的事件队列之中，最后调用 doProcessInputEvents 来进行处理。</p>    <pre>  <code class="language-java">void doProcessInputEvents() {      while (mPendingInputEventHead != null) {              QueuedInputEvent q = mPendingInputEventHead;              mPendingInputEventHead = q.mNext;              if (mPendingInputEventHead == null) {                  mPendingInputEventTail = null;              }              q.mNext = null;                mPendingInputEventCount -= 1;                      long eventTime = q.mEvent.getEventTimeNano();              long oldestEventTime = eventTime;              if (q.mEvent instanceof MotionEvent) {                  MotionEvent me = (MotionEvent)q.mEvent;                  if (me.getHistorySize() > 0) {                      oldestEventTime = me.getHistoricalEventTimeNano(0);                  }              }              mChoreographer.mFrameInfo.updateInputEventTime(eventTime, oldestEventTime);               deliverInputEvent(q);          }            if (mProcessInputEventsScheduled) {              mProcessInputEventsScheduled = false;              mHandler.removeMessages(MSG_PROCESS_INPUT_EVENTS);          }      }</code></pre>    <p>遍历所有的消息，如果事件类型为触摸屏事件，对其进行相应的时间修改，最后对于每一个处理完成的事件调用 deliverInputEvent ,</p>    <pre>  <code class="language-java">private void deliverInputEvent(QueuedInputEvent q) {              q.mEvent.getSequenceNumber());       if (mInputEventConsistencyVerifier != null) {           mInputEventConsistencyVerifier.onInputEvent(q.mEvent, 0);        }         InputStage stage;       if (q.shouldSendToSynthesizer()) {            stage = mSyntheticInputStage;        } else {            stage = q.shouldSkipIme() ? mFirstPostImeInputStage : mFirstInputStage;        }         if (stage != null) {            stage.deliver(q);        } else {            finishInputEvent(q);        }   }</code></pre>    <p>在事件分发环节，首先进行事件的一个判断，通过shouldSkipIme来判断是否传递给输入法，然后决定使用何种InputStage进行消息的继续传递，这里实现了多种InputStage，对于每一个类型的InputStage都实现了一个方法 process 方法来针对不同类型的事件做处理，如果是触摸屏类的消息，最终会将事件的处理转交到View的身上。</p>    <p>InputStage中的事件如何传递处理，传递处理之后，如何进行</p>    <p>对于InputStage涉及的篇幅较多，这里也不再展开，当消息到达ViewRootImpl中后，接下来就是在View间的派发。</p>    <p> </p>    <p>来自：https://segmentfault.com/a/1190000012860933</p>    <p> </p>