ViewRootImpl源码分析事件分发

时间  2019-11-13
标签 viewrootimpl 源码 分析 事件 分发 繁體版
原文   原文链接

前面讲到View与WindowManager与ViewRootImpl中只讲到了ViewRootImpl是如何触发View的绘制的，但ViewRootImpl的功能可不仅是绘制而已，本篇文章最主要介绍ViewRootImpl的事件分发功能。固然，对于事件分发，你们确定很熟悉，可是你们日常所看到的事件分发机制则是在Activity获得触摸事件后的，而后再传递给View处理，那么究竟是谁传递给Activity触摸事件的呢？app

ViewRootImpl事件分发

前面只是介绍到了ViewRootImpl的绘制功能，固然，你在看ViewRootImpl源码的时候会看到不少不少Event之类的，没错ViewRootImpl也是有事件分发的。要知道，当用户点击屏幕产生一个触摸行为，这个触摸行为则是经过底层硬件来传递捕获，而后交给ViewRootImpl，接着将事件传递给DecorView，而DecorView再交给PhoneWindow，PhoneWindow再交给Activity，而后接下来就是咱们常见的View事件分发了。异步

**硬件 -> ViewRootImpl -> DecorView -> PhoneWindow -> Activity **ide

咱们从ViewRootImpl开始看下具体的事件分发过程
首先会到ViewRootImpl的dispatchInputEventthis

public void dispatchInputEvent(InputEvent event, InputEventReceiver receiver) {
        SomeArgs args = SomeArgs.obtain();
        args.arg1 = event;
        args.arg2 = receiver;
        Message msg = mHandler.obtainMessage(MSG_DISPATCH_INPUT_EVENT, args);
        msg.setAsynchronous(true);
        mHandler.sendMessage(msg);
    }

这里有两个参数，InputEvent和InputEventReceiverspa

  • InputEvent：输入事件的基类，它有两个子类，分别是KeyEvent,MotionEvent对应键盘输入事件和屏幕触摸事件，这两个也是咱们比较熟悉的了。线程

  • InputEventReceiver：为应用程序提供了一个低级的机制来接收输入事件。也就是用来接收输入事件的，而后交给ViewRootImpl的dispatchInputEvent去分发。code

上面代码能够看到输入事件接收器经过Handler切换到UI线程中。继承

final class ViewRootHandler extends Handler {
        ...
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                 ...
                case MSG_DISPATCH_INPUT_EVENT: {
                    SomeArgs args = (SomeArgs)msg.obj;
                    InputEvent event = (InputEvent)args.arg1;
                    InputEventReceiver receiver = (InputEventReceiver)args.arg2;
                    enqueueInputEvent(event, receiver, 0, true);
                    args.recycle();
                } break;
                ...
            }
        }

转发到UI线程后，调用到enqueueInputEventtoken

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;
        ...
        //processImmediately则是判断是同步仍是异步，前面咱们在handler中调用的，由于是在UI线程，确定是同步的，因此传递了参数是true，若是是异步，则调用到scheduleProcessInputEvents()
        if (processImmediately) {
            doProcessInputEvents();
        } else {
            scheduleProcessInputEvents();
        }
    }

能够看到enqueueInputEvent将当前的输入事件加入队列中，QueuedInputEvent至关于一个链表,
能够看到里面成员变量有next，用来连接下一个成员接口

private static final class QueuedInputEvent {
        ...
        public QueuedInputEvent mNext;
        public InputEvent mEvent;
        public InputEventReceiver mReceiver;
        ...
}

而obtainQueuedInputEvent则是为当前的输入事件构建一个链表结构，而后连接到以前队列的尾部

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;
        return q;
    }

接着到了

if (processImmediately) {
            doProcessInputEvents();
        } else {
            scheduleProcessInputEvents();
        }

processImmediately则是判断是同步仍是异步，前面咱们在handler中调用的，由于是在UI线程，确定是同步的，因此传递了参数是true，若是是异步，则调用到scheduleProcessInputEvents()

private void scheduleProcessInputEvents() {
        if (!mProcessInputEventsScheduled) {
            mProcessInputEventsScheduled = true;
            Message msg = mHandler.obtainMessage(MSG_PROCESS_INPUT_EVENTS);
            msg.setAsynchronous(true);
            mHandler.sendMessage(msg);
        }
    }

Handler中

case MSG_PROCESS_INPUT_EVENTS:
                mProcessInputEventsScheduled = false;
                doProcessInputEvents();
                break;

能够看到最后仍是调用到了doProcessInputEvents。

void doProcessInputEvents() {
        //循环取出队列中的输入事件
        while (mPendingInputEventHead != null) {
            QueuedInputEvent q = mPendingInputEventHead;
            mPendingInputEventHead = q.mNext;
            ...
            mPendingInputEventCount -= 1;
            ...
            //分发处理
            deliverInputEvent(q);
        }

        //处理完全部输入事件，清楚标志
        if (mProcessInputEventsScheduled) {
            mProcessInputEventsScheduled = false;
            mHandler.removeMessages(MSG_PROCESS_INPUT_EVENTS);
        }
    }

能够看到该方法是用来循环获取队列中的输入事件
接着进行分发处理deliverInputEvent(q)

private void deliverInputEvent(QueuedInputEvent q) {
        //校验输入事件
        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);
        }
    }

这里InputStage则是一个实现处理输入事件责任的阶段，它是一个基类，也就是说InputStage提供一系列处理输入事件的方法，也能够转发给其余事件处理，而具体的处理则是看它的实现类。每种InputStage能够处理必定的事件类型，好比AsyncInputStage、ViewPreImeInputStage、ViewPostImeInputStage等。当一个InputEvent到来时，ViewRootImpl会寻找合适它的InputStage来处理。
InputStage的处理状况为，会先调用deliver开始处理

InputState

最终的事件分发处理则是在apply方法里的onProcess方法。

对于点击事件来讲，InputState的子类ViewPostImeInputStage能够处理它，咱们看下ViewPostImeInputStage的onProcess

@Override
        protected int onProcess(QueuedInputEvent q) {
            if (q.mEvent instanceof KeyEvent) {
                return processKeyEvent(q);
            } else {
                // If delivering a new non-key event, make sure the window is
                // now allowed to start updating.
                handleDispatchWindowAnimationStopped();
                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);
                }
            }
        }

在ViewPostImeInputStage里面有判断是键盘事件仍是触摸事件，这里咱们只看触摸事件，调用到了
processPointerEvent（q）方法

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

            mAttachInfo.mUnbufferedDispatchRequested = false;
            boolean handled = mView.dispatchPointerEvent(event);
            ...
            return handled ? FINISH_HANDLED : FORWARD;
        }

而这里调用到了mView.dispatchPointerEvent，这里的mView就是DecorView，细心的话可能就知道mView是在setView的时候赋值的

public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView) {
        synchronized (this) {
            if (mView == null) {
                mView = view;
                ...
       }
}

再看View的dispatchPointerEvent

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

能够看到，这里会再判断当前事件是不是触摸事件，若是是则调用了dispatchTouchEvent进行分发，
而咱们的DecorView是继承于View的，根据多态，咱们看下DecorView对dispatchTouchEvent的重写

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

能够看到，这里调用了callback.dispatchTouchEvent，Callback是Window里面的一个接口

public interface Callback {
        ...
        public boolean dispatchKeyEvent(KeyEvent event);
        ...
        public boolean dispatchTouchEvent(MotionEvent event);
   }

既然是callback调用了，那么究竟是谁实现了Callback接口去调用的？
正是Activity

public class Activity extends ContextThemeWrapper
        implements LayoutInflater.Factory2,
        Window.Callback, KeyEvent.Callback,
        OnCreateContextMenuListener, ComponentCallbacks2,
        Window.OnWindowDismissedCallback {
        ..
}

而在Activity的attach方法中

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) {
        ...
        mWindow = new PhoneWindow(this);
        mWindow.setCallback(this);
        mWindow.setOnWindowDismissedCallback(this);
        mWindow.getLayoutInflater().setPrivateFactory(this);
  }

PhoneWindow经过设置setCallback将Callback设置为this也就是Activity。到这里，点击事件就传到了Activity，以后的事件分发就是你们比较熟悉的了。

小结

ViewRootImpl事件分发流程图

ViewRootImpl事件分发

做者：Hohohong 连接：https://www.jianshu.com/p/9e6c54739217 来源：简书 简书著做权归做者全部，任何形式的转载都请联系做者得到受权并注明出处。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程