前言

相信大家对Android的事件分发机制很熟悉，都知道事件分发是从ViewGroup的dispatchTouchEvent()开始。那么你是否知道ViewGroup的事件是从哪里来的呢？本文将带你去一探究竟。

事件的产生

总所周知，当我们触摸屏幕的时候就会有触摸事件的产生，不过从在硬件的产生到我们应用层的传递不在本文的讨论范围之内，有兴趣的可以查看Android触摸事件全过程分析。下面我们将从应用层接受到事件开始分析。

事件的传递

InputEventReceiver

    
    // Called from native code.
    @SuppressWarnings("unused")
    @UnsupportedAppUsage
    private void dispatchInputEvent(int seq, InputEvent event, int displayId) {
        mSeqMap.put(event.getSequenceNumber(), seq);
        onInputEvent(event, displayId);
    }

应用层接受输入事件的地方在InputEventReceiver的dispatchInputEvent()，从注释可以看到这里完成了事件从native到应用层的传递。在方法里面把事件通过onInputEvent()传递下去。接着就来到了InputEventReceiver的子类WindowInputEventReceiver，它重写了onInputEvent()。

WindowInputEventReceiver

    @Override
    public void onInputEvent(InputEvent event, int displayId) {
        enqueueInputEvent(event, this, 0, true);
    }

WindowInputEventReceiver又是ViewRootImpl的内部类，在里面它调用了ViewRootImpl的enqueueInputEvent()

ViewRootImpl

    @UnsupportedAppUsage
    void enqueueInputEvent(InputEvent event,
            InputEventReceiver receiver, int flags, boolean processImmediately) {
        adjustInputEventForCompatibility(event);
        QueuedInputEvent q = obtainQueuedInputEvent(event, receiver, flags);

        // QueuedInputEvent是一个单链表结构，把输入事件按顺序连接起来
        if (last == null) {
            mPendingInputEventHead = q;
            mPendingInputEventTail = q;
        } else {
            last.mNext = q;
            mPendingInputEventTail = q;
        }
        mPendingInputEventCount += 1;
        Trace.traceCounter(Trace.TRACE_TAG_INPUT, mPendingInputEventQueueLengthCounterName,
                mPendingInputEventCount);

        if (processImmediately) {
            doProcessInputEvents();
        } else {
            scheduleProcessInputEvents();
        }
    }
    
    //将InputEvent包装进QueuedInputEvent，和obtainMessage()很类似有木有
    private QueuedInputEvent obtainQueuedInputEvent(InputEvent event,
            InputEventReceiver receiver, int flags) {
        QueuedInputEvent q = mQueuedInputEventPool;
        if (q != null) {
            mQueuedInputEventPoolSize -= 1;
            mQueuedInputEventPool = q.mNext;
            q.mNext = null;
        } else {
            q = new QueuedInputEvent();
        }

        q.mEvent = event;
        q.mReceiver = receiver;
        q.mFlags = flags;   //注意这个flags，传进来的是0
        return q;
    }

从上面的调用我们知道processImmediately参数传入的是true，所以接下来会调用doProcessInputEvents()

    void doProcessInputEvents() {
        // 使用while循环，一个个的传递QueuedInputEvent中待处理的事件
        while (mPendingInputEventHead != null) {
            //取出第一个输入事件，并从QueuedInputEvent链表中断开
            QueuedInputEvent q = mPendingInputEventHead;
            mPendingInputEventHead = q.mNext;
            if (mPendingInputEventHead == null) {
                mPendingInputEventTail = null;
            }
            q.mNext = null;

            mPendingInputEventCount -= 1;
            Trace.traceCounter(Trace.TRACE_TAG_INPUT, mPendingInputEventQueueLengthCounterName,
                    mPendingInputEventCount);

            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);
        }

        // We are done processing all input events that we can process right now
        // so we can clear the pending flag immediately.
        if (mProcessInputEventsScheduled) {
            mProcessInputEventsScheduled = false;
            mHandler.removeMessages(MSG_PROCESS_INPUT_EVENTS);
        }
    }

从上面得知会通过deliverInputEvent()将事件一个个的传递下去

    private void deliverInputEvent(QueuedInputEvent q) {
        Trace.asyncTraceBegin(Trace.TRACE_TAG_VIEW, "deliverInputEvent",
                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 (q.mEvent instanceof KeyEvent) {
            mUnhandledKeyManager.preDispatch((KeyEvent) q.mEvent);
        }

        if (stage != null) {
            handleWindowFocusChanged();
            stage.deliver(q);
        } else {
            finishInputEvent(q);
        }
    }
    
    //在前面的obtainQueuedInputEvent()我们知道，mFlags的值为0
    //所以这里的返回值为false
    public static final int FLAG_UNHANDLED = 1 << 5;
    public boolean shouldSendToSynthesizer() {
        if ((mFlags & FLAG_UNHANDLED) != 0) {
            return true;
        }

        return false;
    }
    
    
    public static final int FLAG_DELIVER_POST_IME = 1 << 0;
    public boolean shouldSkipIme() {
        if ((mFlags & FLAG_DELIVER_POST_IME) != 0) {
            return true;
        }
        //对于我们分析的MotionEvent来说这是返回true的
        return mEvent instanceof MotionEvent
                && (mEvent.isFromSource(InputDevice.SOURCE_CLASS_POINTER)
                || mEvent.isFromSource(InputDevice.SOURCE_ROTARY_ENCODER);
    }

其中的InputStage是用于处理输入事件的基类，里面有个mNext变量保存了下一个InputStage的引用，所以会把输入事件一层层的传递下去进行处理。

由上面的判断可知，最终InputStage的值为mFirstPostImeInputStage，这个值会在setView()的时候被赋值。

  public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
        synchronized (this) {
            if (mView == null) {
                mView = view;
                ...
                InputStage viewPostImeStage = new ViewPostImeInputStage(mSyntheticInputStage);
                InputStage nativePostImeStage = new NativePostImeInputStage(viewPostImeStage,
                        "aq:native-post-ime:" + counterSuffix);
                InputStage earlyPostImeStage = new EarlyPostImeInputStage(nativePostImeStage);
                InputStage imeStage = new ImeInputStage(earlyPostImeStage,
                        "aq:ime:" + counterSuffix);
                InputStage viewPreImeStage = new ViewPreImeInputStage(imeStage);
                InputStage nativePreImeStage = new NativePreImeInputStage(viewPreImeStage,
                        "aq:native-pre-ime:" + counterSuffix);

                mFirstInputStage = nativePreImeStage;
                mFirstPostImeInputStage = earlyPostImeStage;   
            }
        }
  }

那么再回到上面，stage!=null，则它会调用deliver开始传递输入事件

   public static final int FLAG_FINISHED = 1 << 2;
    /**
     * Delivers an event to be processed.
     */
    public final void deliver(QueuedInputEvent q) {
        //mFlags==0
        if ((q.mFlags & QueuedInputEvent.FLAG_FINISHED) != 0) {
            forward(q);
        } else if (shouldDropInputEvent(q)) {
            finish(q, false);
        } else {
            apply(q, onProcess(q));
        }
    }
    
    //这里返回false
    protected boolean shouldDropInputEvent(QueuedInputEvent q) {
        if (mView == null || !mAdded) {
            Slog.w(mTag, "Dropping event due to root view being removed: " + q.mEvent);
            return true;
        } else if ((!mAttachInfo.mHasWindowFocus
            && !q.mEvent.isFromSource(InputDevice.SOURCE_CLASS_POINTER)
            && !isAutofillUiShowing()) || mStopped
            || (mIsAmbientMode && !q.mEvent.isFromSource(InputDevice.SOURCE_CLASS_BUTTON))
            || (mPausedForTransition && !isBack(q.mEvent))) {
            // This is a focus event and the window doesn't currently have input focus or
            // has stopped. This could be an event that came back from the previous stage
            // but the window has lost focus or stopped in the meantime.
            if (isTerminalInputEvent(q.mEvent)) {
                // Don't drop terminal input events, however mark them as canceled.
                q.mEvent.cancel();
                Slog.w(mTag, "Cancelling event due to no window focus: " + q.mEvent);
                return false;
            }

            // Drop non-terminal input events.
            Slog.w(mTag, "Dropping event due to no window focus: " + q.mEvent);
            return true;
        }
        return false;
    }

所以这里首先会进入EarlyPostImeInputStage的apply(q, onProcess(q));，不过它并没有处理掉输入事件，而是进一步的把事件传递下去，由于调用比较多这里就不展开来说了，有兴趣的自行看源码。我们直接来看下ViewPostImeInputStage的onProcess()方法。

ViewPostImeInputStage

    @Override
    protected int onProcess(QueuedInputEvent q) {
        if (q.mEvent instanceof KeyEvent) {
            return processKeyEvent(q);
        } else {
            final int source = q.mEvent.getSource();
            if ((source & InputDevice.SOURCE_CLASS_POINTER) != 0) {
                return processPointerEvent(q);
            } else if ((source & InputDevice.SOURCE_CLASS_TRACKBALL) != 0) {
                return processTrackballEvent(q);
            } else {
                return processGenericMotionEvent(q);
            }
        }
    }

因为我们是触摸事件，所以会进入到processPointerEvent()

    private int processPointerEvent(QueuedInputEvent q) {
        final MotionEvent event = (MotionEvent)q.mEvent;

        mAttachInfo.mUnbufferedDispatchRequested = false;
        mAttachInfo.mHandlingPointerEvent = true;
        
        boolean handled = mView.dispatchPointerEvent(event);
        
        maybeUpdatePointerIcon(event);
        maybeUpdateTooltip(event);
        mAttachInfo.mHandlingPointerEvent = false;
        if (mAttachInfo.mUnbufferedDispatchRequested && !mUnbufferedInputDispatch) {
            mUnbufferedInputDispatch = true;
            if (mConsumeBatchedInputScheduled) {
                scheduleConsumeBatchedInputImmediately();
            }
        }
        return handled ? FINISH_HANDLED : FORWARD;
    }

可以看到其中调用了mView.dispatchPointerEvent(event)，这个mView就是上面在setView()的时候赋值的，值为DecorView。而DecorView继承于FrameLayout，所以我们看下View的dispatchPointerEvent()的具体实现即可。

View

    public final boolean dispatchPointerEvent(MotionEvent event) {
        if (event.isTouchEvent()) {
            return dispatchTouchEvent(event);
        } else {
            return dispatchGenericMotionEvent(event);
        }
    }

因为是触摸事件，所以会执行dispatchTouchEvent()，而DecorView重写了该方法。

DecordView

    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        final Window.Callback cb = mWindow.getCallback();
        return cb != null && !mWindow.isDestroyed() && mFeatureId < 0
                ? cb.dispatchTouchEvent(ev) : super.dispatchTouchEvent(ev);
    }

里面的Window就是PhoneWindow，那么它的Callback是谁呢？没错，就是我们最熟悉的Activity了。

Activity

    public class Activity extends ContextThemeWrapper
        implements LayoutInflater.Factory2,
        Window.Callback, KeyEvent.Callback,
        OnCreateContextMenuListener, ComponentCallbacks2,
        Window.OnWindowDismissedCallback, WindowControllerCallback,
        AutofillManager.AutofillClient
        
    final void attach(Context context, ActivityThread aThread,
            Instrumentation instr, IBinder token, int ident,
            Application application, Intent intent, ActivityInfo info,
            CharSequence title, Activity parent, String id,
            NonConfigurationInstances lastNonConfigurationInstances,
            Configuration config, String referrer, IVoiceInteractor voiceInteractor,
            Window window, ActivityConfigCallback activityConfigCallback) {
        attachBaseContext(context);

        mFragments.attachHost(null /*parent*/);

        mWindow = new PhoneWindow(this, window, activityConfigCallback);
        mWindow.setWindowControllerCallback(this);
        mWindow.setCallback(this);
        mWindow.setOnWindowDismissedCallback(this);
    }
    
    public boolean dispatchTouchEvent(MotionEvent ev) {
        if (ev.getAction() == MotionEvent.ACTION_DOWN) {
            onUserInteraction();
        }
        if (getWindow().superDispatchTouchEvent(ev)) {
            return true;
        }
        return onTouchEvent(ev);
    }

Activity实现了Window的Callback接口，在attach()中实例化了PhoneWindow，并设置了Callback。但是在Activity的dispatchTouchEvent()中，又把触摸事件传递给了PhoneWindow的superDispatchTouchEvent()。

PhoneWindow

    @Override
    public boolean superDispatchTouchEvent(MotionEvent event) {
        return mDecor.superDispatchTouchEvent(event);
    }

嗯？又调用mDecor.superDispatchTouchEvent()，这个mDecor仍然是DecorView。

DecordView

    public boolean superDispatchTouchEvent(MotionEvent event) {
        //ViewGroup
        return super.dispatchTouchEvent(event);
    }

最终就回到了我们的dispatchTouchEvent()，从而开始了我们熟悉的事件分发机制。

总结

触摸事件由硬件处产生，在应用层的传递流程为InputEventReceiver->ViewRootImpl->DecorView->Activity(实现了Window.Callback)->PhoneWindow->DecorView->ViewGroup->View