android事件分发机制

android

简介:

当用户在android设备屏幕上触碰或者作出手势动作后,android系统硬件设备将接收到信息，并转化为相关信号发送到窗口，然后窗口通过层级视图控件将指针事件一层一层向子视图分发，拦截，以及响应。

既然是底层发出的硬件指令，上层必定有接收的入口，在SDK中有这么一个隐藏的类，叫 InputEventReceiver，它的注解如下：

1
2
3
4
/**
 * Provides a low-level mechanism for an application to receive input events.
 * @hide
 */

从注解以及类名可以看出这是一个接收底层输入事件的类，继续跟踪，发现在ViewRootImpl 这个类里的内部类有一个类叫 WindowInputEventReceiver继承了 InputEventReceiver类，从类名上我们先猜想这是一个窗口接收输入事件的类，我们来看源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
final class WindowInputEventReceiver extends InputEventReceiver {
       public WindowInputEventReceiver(InputChannel inputChannel, Looper looper) {
           super(inputChannel, looper);
       }
       @Override
       public void onInputEvent(InputEvent event) {
           enqueueInputEvent(event, this, 0, true);
       }
       @Override
       public void onBatchedInputEventPending() {
           if (mUnbufferedInputDispatch) {
               super.onBatchedInputEventPending();
           } else {
               scheduleConsumeBatchedInput();
           }
       }
       @Override
       public void dispose() {
           unscheduleConsumeBatchedInput();
           super.dispose();
       }
   }

源码里面我们看出onInputEvent()方法是用来执行处理输入事件的，它将输入事件传递给enqueueInputEvent()方法，通过方法名我们先猜想一下，这个方法应该是将输入事件放入队列中，继续追踪

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
void enqueueInputEvent(InputEvent event,
            InputEventReceiver receiver, int flags, boolean processImmediately) {
        adjustInputEventForCompatibility(event);
        QueuedInputEvent q = obtainQueuedInputEvent(event, receiver, flags);
        // Always enqueue the input event in order, regardless of its time stamp.
        // We do this because the application or the IME may inject key events
        // in response to touch events and we want to ensure that the injected keys
        // are processed in the order they were received and we cannot trust that
        // the time stamp of injected events are monotonic.
        QueuedInputEvent last = mPendingInputEventTail;
        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();
        }
    }

从这个方法里我们看出来 obtainQueuedInputEvent()方法将事件封装成QueuedInputEvent对象，然后替换mPendingInputEventTail对象，这里很容易看出来这是一个链表队列，接下来我们继续看 doProcessInputEvents() 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
void doProcessInputEvents() {
       // Deliver all pending input events in the queue.
       while (mPendingInputEventHead != null) {
           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()发送事件，继续追踪

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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 (stage != null) {
            stage.deliver(q);
        } else {
            finishInputEvent(q);
        }
    }

这里我们看到有一个InputStage的抽象内部类将事件接收并进行处理，通过它的注解看出，这个类是对输入事件的不同阶段进行处理的类，对事件进行转发，处理，完成等工作，

1
2
3
4
5
6
7
8
9
public final void deliver(QueuedInputEvent q) {
           if ((q.mFlags & QueuedInputEvent.FLAG_FINISHED) != 0) {
               forward(q);
           } else if (shouldDropInputEvent(q)) {
               finish(q, false);
           } else {
               apply(q, onProcess(q));
           }
       }

对于InputStage,它有多个子类，这里我们看到ViewRootImpl里ViewPostImeInputStage这个内部类，它重写了父类的onProcess()方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@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()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
private int processPointerEvent(QueuedInputEvent q) {
            final MotionEvent event = (MotionEvent)q.mEvent;
            mAttachInfo.mUnbufferedDispatchRequested = false;
            final View eventTarget =
                    (event.isFromSource(InputDevice.SOURCE_MOUSE) && mCapturingView != null) ?
                            mCapturingView : mView;
            mAttachInfo.mHandlingPointerEvent = true;
            boolean handled = eventTarget.dispatchPointerEvent(event);
            maybeUpdatePointerIcon(event);
            mAttachInfo.mHandlingPointerEvent = false;
            if (mAttachInfo.mUnbufferedDispatchRequested && !mUnbufferedInputDispatch) {
                mUnbufferedInputDispatch = true;
                if (mConsumeBatchedInputScheduled) {
                    scheduleConsumeBatchedInputImmediately();
                }
            }
            return handled ? FINISH_HANDLED : FORWARD;
        }

到了这里我们终于看到触摸事件传递给View对象了，我们继续跟踪dispatchPointerEvent()方法

1
2
3
4
5
6
7
public final boolean dispatchPointerEvent(MotionEvent event) {
        if (event.isTouchEvent()) {
            return dispatchTouchEvent(event);
        } else {
            return dispatchGenericMotionEvent(event);
        }
    }

这里对指针事件做了一个分类处理，区分是点击事件还是手势事件，这里还只是View类的方法，那么事件如何到界面的根视图，我们知道一个Activity,内部包含了一个phoneWindow窗口，phoneWindow将DecorView作为应用窗口的根View。
这里我们看一下下面这三个方法

1）public boolean dispatchTouchEvent(MotionEvent ev) 这个方法用来分发TouchEvent

2）public boolean onInterceptTouchEvent(MotionEvent ev) 这个方法用来拦截TouchEvent

3）public boolean onTouchEvent(MotionEvent ev) 这个方法用来处理TouchEvent

当TouchEvent发生时，首先Activity将TouchEvent传递给最顶层的View， TouchEvent最先到达最顶层 view 的 dispatchTouchEvent ，然后由 dispatchTouchEvent 方法进行分发，如果dispatchTouchEvent返回true ，则交给这个view的onTouchEvent处理，如果dispatchTouchEvent返回 false ，则交给这个 view 的 interceptTouchEvent 方法来决定是否要拦截这个事件，如果 interceptTouchEvent 返回 true ，也就是拦截掉了，则交给它的 onTouchEvent 来处理，如果 interceptTouchEvent 返回 false ，那么就传递给子 view ，由子 view 的 dispatchTouchEvent 再来开始这个事件的分发。如果事件传递到某一层的子 view 的 onTouchEvent 上了，这个方法返回了 false ，那么这个事件会从这个 view 往上传递，都是 onTouchEvent 来接收。而如果传递到最上面的 onTouchEvent 也返回 false 的话，这个事件就会“消失”，而且接收不到下一次事件。