Android事件分发机制

1.Android事件类型

public boolean onTouchEvent(MotionEvent event) {
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                break;
            case MotionEvent.ACTION_MOVE:
                break;
            case MotionEvent.ACTION_UP:
                break;
            case MotionEvent.ACTION_CANCEL:
                break;
        }
        return true;
    }

如上图所示android主要有四种事件类型,Down、Move、Up、Cancel。

在一次事件流中:

Down触发一次,手指在屏幕按下时。

Move事件会触发0次或多次,手指在屏幕上滑动时。

Up事件会触发0次或一次,手指在屏幕抬起时。

Cancel事件会触发0次或一次,滑动超出空间边界时。

2.android App层事件分发机制调用链是怎么样的?

App层事件分发的入口在Activity中,dispatchTouchEvent是在Framework层的WindowManagerService掉用的,WMS中的事件是来源于Native层,Linux层,这块的事件传递有机会在写文章进行分析,这篇文章主要分析Android事件分发机制在App成是如何展现的。

 public boolean dispatchTouchEvent(MotionEvent ev) {
        if (ev.getAction() == MotionEvent.ACTION_DOWN) {
            onUserInteraction();
        }
        if (getWindow().superDispatchTouchEvent(ev)) {
            return true;
        }
        return onTouchEvent(ev);
    }

getWindow()返回的是PhoneWindow对象。

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

mDecor是DecorView,是PhoneWindow的一个内部类,继承FrameLayout。

FrameLayout继承自ViewGroup,接下来看事件传递在ViewGroup中是如何处理的。事件传递的主要逻辑就在ViewGroup中。

接下来看ViewGroup,dispatchToucheEvent(MotionEvent ev)是如何对事件进行分发的。

public class ViewGroup {
    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        boolean handled = false;
        final int action = ev.getAction();
        final int actionMasked = action & MotionEvent.ACTION_MASK;
        // Check for interception.
        //按下后,第一次调用时actionMasked=down,mFirstTouchTarget=null
        //一直按着 actionMasked=move, 如果mFirstTouchTarget!=null说明有子view处理了touch事件
        final boolean intercepted;
        if (actionMasked == MotionEvent.ACTION_DOWN
                || mFirstTouchTarget != null) {
            final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
            if (!disallowIntercept) {
                //调用子类复写的方法 如果为true表示拦截,false表示不拦截
                intercepted = onInterceptTouchEvent(ev);
                ev.setAction(action); // restore action in case it was changed
            } else {
                intercepted = false;
            }
        } else {
            // There are no touch targets and this action is not an initial down
            // so this view group continues to intercept touches.
            //如果没有子view处理touch事件,并且不是第一次按下的down事件,group会对touch事件进行拦截
            intercepted = true;
        }

        TouchTarget newTouchTarget = null;
        //第一次按下时,判断view是否处理事件的标志
        boolean alreadyDispatchedToNewTouchTarget = false;
        //如果不拦截,则进入事件分发
        if (!canceled && !intercepted) {
            //注意,只有ACTION_DOWN时才会遍历子View
            if (actionMasked == MotionEvent.ACTION_DOWN
                    || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
                    || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {

                final int childrenCount = mChildrenCount;
                if (newTouchTarget == null && childrenCount != 0) {
                    final ArrayList preorderedList = buildTouchDispatchChildList();
                    final View[] children = mChildren;
                    //开始遍历子view
                    for (int i = childrenCount - 1; i >= 0; i--) {
                        final View child = getAndVerifyPreorderedView(
                                preorderedList, children, childIndex);
                        //isTransformedTouchPointInView 通过比对坐标,来判断事件是否落在了child上,
                        // true是,false不是
                        if (!canViewReceivePointerEvents(child)
                                || !isTransformedTouchPointInView(x, y, child, null)) {
                            ev.setTargetAccessibilityFocus(false);
                            // 如果事件没有落在child上,则跳过此次循环,执行下一次循环
                            continue;
                        }
                        //通过遍历TouchTarget链表查找TouchTarget,如果找到了,则break跳出循环
                        newTouchTarget = getTouchTarget(child);
                        if (newTouchTarget != null) {
                            // Child is already receiving touch within its bounds.
                            // Give it the new pointer in addition to the ones it is handling.
                            newTouchTarget.pointerIdBits |= idBitsToAssign;
                            break;
                        }
                        //第一次进来newTouchTarget==null,进入下面的逻辑
                        //如果dispatchTransformedTouchEvent 返回true,表示子view对事件进行了处理,则跳出此循环,
                        // 不会再向子view进行分发
                        if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
                            // Child wants to receive touch within its bounds.
                            //将child缓存到TouchTarget的链表中
                            newTouchTarget = addTouchTarget(child, idBitsToAssign);
                            //注意这个标志位,true,下面的逻辑会用到
                            alreadyDispatchedToNewTouchTarget = true;
                            break;
                        }

                    }
                    if (preorderedList != null) preorderedList.clear();
                }

            }
        }

        // Dispatch to touch targets.
        //ACTION_DOWN和ACTION_MOVE 的时都会执行下面逻辑
        //mFirstTouchTarget==null 说明没有子View处理touch事件,dispatchTransformedTouchEvent的第三个参数为null。
        if (mFirstTouchTarget == null) {
            // No touch targets so treat this as an ordinary view.
            handled = dispatchTransformedTouchEvent(ev, canceled, null,
                    TouchTarget.ALL_POINTER_IDS);
        } else {
            // Dispatch to touch targets, excluding the new touch target if we already
            // dispatched to it.  Cancel touch targets if necessary.
            //对 TouchTarget 链表进行遍历,TouchTarget里缓存了处理事件的view,
            //一次完整事件,move会调用多次,所以在ACTION_DOWN时找到的对应的view,缓存起来,
            // 而不是每次都遍历ViewGroup的子View,这样太损坏性能
            TouchTarget target = mFirstTouchTarget;
            //开始对链表进行遍历,为啥是一个链表呢,这是为了进行多点触摸,会有多个view响应触摸事件。
            while (target != null) {
                final TouchTarget next = target.next;
                //alreadyDispatchedToNewTouchTarget ==true ,并且缓存的target和newTouchTarget是同一个
                //直接将handled置为true,防止ACTION_DOWN时dispatchTransformedTouchEvent方法重复调用
                if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
                    handled = true;
                } else {
                    if (dispatchTransformedTouchEvent(ev, cancelChild,
                            target.child, target.pointerIdBits)) {
                        handled = true;
                    }
                }
                target = next;
            }
        }
        //将handled 返回dispatchTouchEvent的调用者。
        return handled;
    }
    
    /**
     * Gets the touch target for specified child view.
     * Returns null if not found.
     * 通过遍历TouchTarget 链表,找到touch target
     */
    private TouchTarget getTouchTarget(@NonNull View child) {
        for (TouchTarget target = mFirstTouchTarget; target != null; target = target.next) {
            if (target.child == child) {
                return target;
            }
        }
        return null;
    }
    /**
     * Adds a touch target for specified child to the beginning of the list.
     * Assumes the target child is not already present.
     * 将TouchTarget和view进行关联,并且把这个TouchTarget放在链表的头部
     */
    private TouchTarget addTouchTarget(@NonNull View child, int pointerIdBits) {
        final TouchTarget target = TouchTarget.obtain(child, pointerIdBits);
        target.next = mFirstTouchTarget;
        mFirstTouchTarget = target;
        return target;
    }
    
    private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
                                                  View child, int desiredPointerIdBits) {
        final boolean handled;
        // 只看最关键的两行代码
        if (child == null) {
            //如果child为null,没有子view处理touch事件,则调用父类View的dispatchTouchEvent。
            handled = super.dispatchTouchEvent(transformedEvent);
        } else {
            //如果child不为空,则调用child view 的dispatchTouchEvent
            //这行代码很关键,如果child是ViewGroup则继续在ViewGoup的进行事件分发,这会是一个递归调用
            //如果child 是一个View,则调用View的dispatchTouchEvent,进行事件的分发。
            handled = child.dispatchTouchEvent(transformedEvent);
        }
        //以上两行代码最终会调用到View的dispatchTouchEvent方法。
        return handled;
    }
}

接下来看View dispatchTouchEvent如何处理的

public class View {

    public boolean dispatchTouchEvent(MotionEvent ev) {
        boolean result = false;
        ListenerInfo li = mListenerInfo;
        //如果view设置了mOnTouchListener,先调用mOnTouchListener.onTouch,
        //如果返回true,则表示消费了此事件,不在向下传递,为啥这样说?那是因为,通过他的返回值,进行了逻辑判断
        if (li != null && li.mOnTouchListener != null
                && (mViewFlags & ENABLED_MASK) == ENABLED
                && li.mOnTouchListener.onTouch(this, event)) {
            result = true;
        }
        //如果result为false,则调用View.onTouchEvent方法
        if (!result && onTouchEvent(event)) {
            result = true;
        }
        return result;
    }
    public boolean onTouchEvent(MotionEvent event) {
        switch (action) {
            case MotionEvent.ACTION_UP:
                if (mPerformClick == null) {
                    mPerformClick = new PerformClick();
                }
                if (!post(mPerformClick)) {
                    //调用performClick mOnClickListener.onClick()方法
                    performClickInternal();
                }
                break;
            case MotionEvent.ACTION_DOWN:
                break;
            case MotionEvent.ACTION_CANCEL:
                break;
            case MotionEvent.ACTION_MOVE:
                break;
        }

        return false;
    }

    public boolean performClick() {

        final boolean result;
        final ListenerInfo li = mListenerInfo;
        if (li != null && li.mOnClickListener != null) {
            playSoundEffect(SoundEffectConstants.CLICK);
            li.mOnClickListener.onClick(this);
            result = true;
        } else {
            result = false;
        }

        return result;
    }

}

如果仔细看了ViewGroup和View事件分发逻辑代码。我们可以总结为以下几点。

1.ViewGroup接收到DispatchTouchEvent调用后,先调用了onInterceptTouchEvent,通过返回值进行判断是否对事件进行拦截。我们可以在代码中复写这个方法来进行事件的拦截。

2.down事件后,ViewGoup会遍历子View,找到处理Touch事件的View,并且缓存到了TouchTarget链表中,一次事件流中,只有down的时候才会进行子View的遍历。

只有做的好处提升了性能,缓存的链表中也是为了多点触摸,会有多个view响应触摸事件。

move事件时,则会从这个链表中进行遍历,通过调用dispatchTransformedTouchEvent方法进行事件的传递。

3.在dispatchTransformedTouchEvent方法中,根据child的值是否为null进入不同的分发流程。

1)如果为null说明没有子view没有响应事件,则调用父类View的dispatchTouchEvent--->onTouchEvent方法。

2)如果child值不为null。则调用child的dispatchTouchEvent方法,

      此时如果child是一个ViewGoup则还是执行ViewGoup中的分发逻辑,进行递归调用。

     如果child是一个View,则调用View的dispatchTouchEvent--->onTouchEvent方法。

4.在View的dispatchTouchEvent方法中:

   1)listener的onTouch优先级要高于View的onTouchEvent

   2)会先调用mOnTouchListener.onTouch方法,并根据返回值进行判断是否消费事件。

   3)如果上面的返回值为false,则会调用View的onTouchEvent方法。

5.在View的onTouchEvent方法中UP事件时,才会调用View设置的onClickListener的监听事件。

   这就是为什么了,同时给一个View设置了onTouch监听和lonClickListener监听时,当onTouch返回true无法调用onClick事件的原因。

你可能感兴趣的:(android开发,android)