笔记View_System之事件传递

事件传递
Activity
public boolean dispatchTouchEvent(MotionEvent ev) {
if (ev.getAction() == MotionEvent.ACTION_DOWN) {
onUserInteraction();
}
//事件交给window分发处理，如果window没有消耗事件，则activity的onTouchEvent处理事件
if (getWindow().superDispatchTouchEvent(ev)) {
return true;
}
return onTouchEvent(ev);
}

public boolean onTouchEvent(MotionEvent event) {
    if (mWindow.shouldCloseOnTouch(this, event)) {
        finish();
        return true;
    }

    return false;
}

window的实体PhoneWindow

@Override
public boolean superDispatchTouchEvent(MotionEvent event) {
    //事件交给了DecorView，我们知道DecorView是一个FrameLayout，即事件交给了ViewGroup
    return mDecor.superDispatchTouchEvent(event);
}

View系统
viewGroup

public boolean dispatchTouchEvent(MotionEvent ev) {

    if (onFilterTouchEventForSecurity(ev)) {

        //只有down事件才走流程判断（因为一个事件的开始就是down），
        //FLAG_DISALLOW_INTERCEPT是子view requestDisallowInterceptTouchEvent（）控制的，即子view请求父类是否拦截
        if (actionMasked == MotionEvent.ACTION_DOWN || mFirstTouchTarget != null) {
            final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
            if (!disallowIntercept) {

                **//先判断是否拦截**
                intercepted = onInterceptTouchEvent(ev);
                ev.setAction(action); // restore action in case it was changed
            } else {
                intercepted = false;
            }
        } else {
            intercepted = true;
        }

    }

}

//子view请求父类是否拦截
public void requestDisallowInterceptTouchEvent(boolean disallowIntercept) {

    if (disallowIntercept == ((mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0)) {
        // We're already in this state, assume our ancestors are too
        return;
    }

    if (disallowIntercept) {
        mGroupFlags |= FLAG_DISALLOW_INTERCEPT;
    } else {
        mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;
    }

    //递归父类
    if (mParent != null) {
        mParent.requestDisallowInterceptTouchEvent(disallowIntercept);
    }
}

public boolean dispatchTouchEvent(MotionEvent ev) {

    if (!canceled && !intercepted) {


        final int childrenCount = mChildrenCount;
        if (newTouchTarget == null && childrenCount != 0) {


            //这里api注释说，在vg里从前到后查询能接收事件的child
            //即有俩个关键点1：从前到后，说明是vg中view是有顺序的
            //2.能接收事件，说明不是所有child都能接收，那么这个能力怎么来的

            final ArrayList<View> preorderedList = buildTouchDispatchChildList();
            final boolean customOrder = preorderedList == null && isChildrenDrawingOrderEnabled();

            //1.vg中child的顺序，我们知道我们addview的时候可以添加index
            final View[] children = mChildren;


            for (int i = childrenCount - 1; i >= 0; i--) {

                //2.接收能力
                final int childIndex = getAndVerifyPreorderedIndex(childrenCount, i, customOrder);
                final View child = getAndVerifyPreorderedView(preorderedList, children, childIndex);


                **vg不拦截，然后传给child分发**
                if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {
                        // Child wants to receive touch within its bounds.
                        mLastTouchDownTime = ev.getDownTime();
                        if (preorderedList != null) {
                            // childIndex points into presorted list, find original index
                            for (int j = 0; j < childrenCount; j++) {
                                if (children[childIndex] == mChildren[j]) {
                                    mLastTouchDownIndex = j;
                                    break;
                                }
                            }
                        } else {
                            mLastTouchDownIndex = childIndex;
                        }
                        mLastTouchDownX = ev.getX();
                        mLastTouchDownY = ev.getY();
                        newTouchTarget = addTouchTarget(child, idBitsToAssign);
                        alreadyDispatchedToNewTouchTarget = true;
                        break;
                }
            }
      }

}


vg中
private View[] mChildren;成员变量，保存所有child
private int mChildrenCount;保存所有child数量

mChildren的创建和添加
addView()-->addViewInner()-->addInArray()
private void addInArray(View child, int index) {
    View[] children = mChildren;
    final int count = mChildrenCount;
    final int size = children.length;

    //索引从0开始，即 索引 = 数量 -1
    //当前要添加的child索引是最后一个，直接add到最后一个
    if (index == count) {
        if (size == count) {
            //扩容
            mChildren = new View[size + ARRAY_CAPACITY_INCREMENT];
            System.arraycopy(children, 0, mChildren, 0, size);
            children = mChildren;
        }
        children[mChildrenCount++] = child;

    //当前要添加的child索引是不最后一个，证明是插入
    } else if (index < count) {
        if (size == count) {
            mChildren = new View[size + ARRAY_CAPACITY_INCREMENT];
            System.arraycopy(children, 0, mChildren, 0, index);
            System.arraycopy(children, index, mChildren, index + 1, count - index);
            children = mChildren;
        } else {
            System.arraycopy(children, index, children, index + 1, count - index);
        }
        children[index] = child;
        mChildrenCount++;
        if (mLastTouchDownIndex >= index) {
            mLastTouchDownIndex++;
        }
    } else {

        //索引越界
        throw new IndexOutOfBoundsException("index=" + index + " count=" + count);
    }
}


private static View getAndVerifyPreorderedView(ArrayList<View> preorderedList, View[] children,
        int childIndex) {
    final View child;
    if (preorderedList != null) {
        child = preorderedList.get(childIndex);
        if (child == null) {
            throw new RuntimeException();
        }
    } else {
        child = children[childIndex];
    }
    return child;
}


关键在于preorderedList
ArrayList<View> buildOrderedChildList() {

    final int childrenCount = mChildrenCount;
    if (childrenCount <= 1 || !hasChildWithZ()) return null;

    //不存在创建
    if (mPreSortedChildren == null) {
        mPreSortedChildren = new ArrayList<>(childrenCount);
    } else {
    //存在为了安全起见，扩容
        mPreSortedChildren.clear();
        mPreSortedChildren.ensureCapacity(childrenCount);
    }


    final boolean customOrder = isChildrenDrawingOrderEnabled();

    //按照顺寻添加到临时托儿所中
    for (int i = 0; i < childrenCount; i++) {

        //获取具备接收事件的child
        final int childIndex = getAndVerifyPreorderedIndex(childrenCount, i, customOrder);
        final View nextChild = mChildren[childIndex];
        final float currentZ = nextChild.getZ();

        //按照的这个z轴排序，前面我们分析activity和window都有z轴概念，即图层
        int insertIndex = i;
        while (insertIndex > 0 && mPreSortedChildren.get(insertIndex - 1).getZ() > currentZ) {
            insertIndex--;
        }
        mPreSortedChildren.add(insertIndex, nextChild);
    }
    return mPreSortedChildren;
}

//临时托儿所，专门管理vg中child的
private ArrayList<View> mPreSortedChildren;

 /**
 * 指示ViewGroup是否按定义的顺序绘制其子元素    false otherwise
 *
 * @see #setChildrenDrawingOrderEnabled(boolean)
 * @see #getChildDrawingOrder(int, int)
 */
@ViewDebug.ExportedProperty(category = "drawing")
protected boolean isChildrenDrawingOrderEnabled() {
    return (mGroupFlags & FLAG_USE_CHILD_DRAWING_ORDER) == FLAG_USE_CHILD_DRAWING_ORDER;
}


private int getAndVerifyPreorderedIndex(int childrenCount, int i, boolean customOrder) {
    final int childIndex;
    if (customOrder) {
        final int childIndex1 = getChildDrawingOrder(childrenCount, i);
        if (childIndex1 >= childrenCount) {
            throw new IndexOutOfBoundsException(）；
        }
        childIndex = childIndex1;
    } else {
        childIndex = i;
    }
    return childIndex;
}


public boolean dispatchTouchEvent(MotionEvent ev) {

    **拦截事件，自己处理**
    if (mFirstTouchTarget == null) {
        handled = dispatchTransformedTouchEvent(ev, canceled, null,TouchTarget.ALL_POINTER_IDS);
    } else {
        dispatchTransformedTouchEvent(ev, cancelChild,target.child, target.pointerIdBits)
    }

}


因为vg拦截事件自己处理，和不拦截事件child处理都会走这个方法，只能通过参数看不同了
其中参数View child是重点
private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
        View child, int desiredPointerIdBits) {
    final boolean handled;

    final int oldAction = event.getAction();
    if (cancel || oldAction == MotionEvent.ACTION_CANCEL) {
        event.setAction(MotionEvent.ACTION_CANCEL);
        if (child == null) {
            handled = super.dispatchTouchEvent(event);
        } else {
            handled = child.dispatchTouchEvent(event);
        }
        event.setAction(oldAction);
        return handled;
    }

    final int oldPointerIdBits = event.getPointerIdBits();
    final int newPointerIdBits = oldPointerIdBits & desiredPointerIdBits;

    if (newPointerIdBits == 0) {
        return false;
    }

    final MotionEvent transformedEvent;
    if (newPointerIdBits == oldPointerIdBits) {
        if (child == null || child.hasIdentityMatrix()) {
            if (child == null) {
                handled = super.dispatchTouchEvent(event);
            } else {
                final float offsetX = mScrollX - child.mLeft;
                final float offsetY = mScrollY - child.mTop;
                event.offsetLocation(offsetX, offsetY);

                handled = child.dispatchTouchEvent(event);

                event.offsetLocation(-offsetX, -offsetY);
            }
            return handled;
        }
        transformedEvent = MotionEvent.obtain(event);
    } else {
        transformedEvent = event.split(newPointerIdBits);
    }

    if (child == null) {
        handled = super.dispatchTouchEvent(transformedEvent);
    } else {
        final float offsetX = mScrollX - child.mLeft;
        final float offsetY = mScrollY - child.mTop;
        transformedEvent.offsetLocation(offsetX, offsetY);
        if (! child.hasIdentityMatrix()) {
            transformedEvent.transform(child.getInverseMatrix());
        }

        handled = child.dispatchTouchEvent(transformedEvent);
    }

    // Done.
    transformedEvent.recycle();
    return handled;
}

上面方法，可见如果Child存在，就把事件传给child做，否则就传给super（View，vg继承自View，即传给自己处理）
除此之外还有一个如果是cancel事件，直接处理，其他事件还要进行一次处理，介于MotionEvent都是native的方法，等我有能力再说
但是不管怎么说，都是把事件传给了childView，或者selfView的分发

view
public boolean dispatchTouchEvent(MotionEvent event) {

    ...稍后

    if (onFilterTouchEventForSecurity(event)) {
        if ((mViewFlags & ENABLED_MASK) == ENABLED && handleScrollBarDragging(event)) {
            result = true;
        }

        ListenerInfo li = mListenerInfo;
        if (li != null && li.mOnTouchListener != null
                && (mViewFlags & ENABLED_MASK) == ENABLED
                && li.mOnTouchListener.onTouch(this, event)) {
            result = true;
        }

        if (!result && onTouchEvent(event)) {
            result = true;
        }
    }

    ...稍后
 }

对事件进行过滤，判断是窗体是否被遮盖，如果没有被遮盖即可以进行事件处理流程
判断enable属性和是否设置了onTouchListener,以及OnTouchListener.onTouch的返回值
如果enable=true，OnTouchListener.onTouch=true，则不会调用该view的onTouchEvent处理事件
否则事件交给view的onTouchEvent处理

理解分发的逻辑流程，需要先了解一下内容：

1.view的属性enable，可以在布局中设置，也可以在代码中设置

//enable = true的值
static final int ENABLED = 0x00000000;
//enable = false的值
static final int DISABLED = 0x00000020;
//enable默认值false
static final int ENABLED_MASK = 0x00000020;

从源码中(mViewFlags & ENABLED_MASK) == ENABLED可以看出，view的enable属性是用mViewFlags保存的

mViewFlags的由来（view源码）
public View(Context context, @Nullable AttributeSet attrs, int defStyleAttr, int defStyleRes) {
    this(context);

    布局属性获取
    final TypedArray a = context.obtainStyledAttributes(
            attrs, com.android.internal.R.styleable.View, defStyleAttr, defStyleRes);
    final int N = a.getIndexCount();
    for (int i = 0; i < N; i++) {
        int attr = a.getIndex(i);
        switch (attr) {
            case com.android.internal.R.styleable.View_background:
                background = a.getDrawable(attr);
                break;
            case com.android.internal.R.styleable.View_padding:
                padding = a.getDimensionPixelSize(attr, -1);
                mUserPaddingLeftInitial = padding;
                mUserPaddingRightInitial = padding;
                leftPaddingDefined = true;
                rightPaddingDefined = true;
                break;
              ......
        }
    }

    if (viewFlagMasks != 0) {
        setFlags(viewFlagValues, viewFlagMasks);
    }
}

void setFlags(int flags, int mask) {
    mViewFlags = (mViewFlags & ~mask) | (flags & mask);
}
可以看到mViewFlags是view的属性进行一系列的位运算得到的。而mViewFlags与ENABLED_MASK的位运算就是获取enable属性的值

2.view的内部类ListenerInfo，封装了所有view的监听功能的对象，我们设置监听即是给这个静态内部类的成员赋值的过程，而回调也是
view通过ListenerInfo获取到对应的监听器，然后回调
比如
public void setOnScrollChangeListener(OnScrollChangeListener l) {
getListenerInfo().mOnScrollChangeListener = l;
}
ListenerInfo getListenerInfo() {
if (mListenerInfo != null) {
return mListenerInfo;
}
mListenerInfo = new ListenerInfo();
return mListenerInfo;
}
if (mListenerInfo != null && mListenerInfo.mOnScrollChangeListener != null) {
mListenerInfo.mOnScrollChangeListener.onScrollChange(this, l, t, oldl, oldt);
}

ListenerInfo内部具体的监听器：
static class ListenerInfo {
    //光标变化
    protected OnFocusChangeListener mOnFocusChangeListener;

    //布局变化，不止一个，所以是集合保存，add添加，remove移除等
    private ArrayList<OnLayoutChangeListener> mOnLayoutChangeListeners;

    //滑动变化
    protected OnScrollChangeListener mOnScrollChangeListener;

    //view挂接和断开window的监听 onViewAttachedToWindow(View v)，onViewDetachedFromWindow(View v)
    private CopyOnWriteArrayList<OnAttachStateChangeListener> mOnAttachStateChangeListeners;

    //点击监听
    public OnClickListener mOnClickListener;

    //长点击监听
    protected OnLongClickListener mOnLongClickListener;

    //api 23新增的上下文点击监听（为什么要加上下文？）
    protected OnContextClickListener mOnContextClickListener;

    //创建上下文菜单监听onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo)
    protected OnCreateContextMenuListener mOnCreateContextMenuListener;

    //键盘事件
    private OnKeyListener mOnKeyListener;

    //触摸事件
    private OnTouchListener mOnTouchListener;

    //悬浮事件，html的鼠标悬浮
    private OnHoverListener mOnHoverListener;

    //任意的手势时回调
    private OnGenericMotionListener mOnGenericMotionListener;

    //当view被拖动时回调 
    private OnDragListener mOnDragListener;

    //监控并动态控制到SystemUi（状态栏）的显示与隐藏，setSystemUiVisibility(int visibility)
    private OnSystemUiVisibilityChangeListener mOnSystemUiVisibilityChangeListener;

    OnApplyWindowInsetsListener mOnApplyWindowInsetsListener;

    //api 26新增 指针捕获监听....
    OnCapturedPointerListener mOnCapturedPointerListener;
}

3.onFilterTouchEventForSecurity（event）事件过滤，判断是否需要进行事件分发逻辑

public boolean onFilterTouchEventForSecurity(MotionEvent event) {

    //如果窗体被覆盖，被遮挡。此时的窗体是window呢还是view
    if ((mViewFlags & FILTER_TOUCHES_WHEN_OBSCURED) != 0
            && (event.getFlags() & MotionEvent.FLAG_WINDOW_IS_OBSCURED) != 0) {
        return false;
    }
    return true;
}

4.handleScrollBarDragging(event)

在看返回的boolean值，发现分发的返回值都是onTouchEvent或者listener回调的onTouch的返回值。
即控制上一层能不能处理事件

遗留问题:事件怎么产生？事件MotionEvent是个啥？native的东西怎么搞？

总结
不论多少层view嵌套
事件都是从最外层（最大层）开始分发传递，所以找好复杂的问题分析的源头
viewGroup才有拦截方法，拦截方法可以控制事件分发方法，但是拦截也是受到约束的，比如子层可以申请不被拦截requestDisallowInterceptTouchEvent
viewgroup继承自view，所以即使事件被拦截，vg要走view的分发方法，转给onTouchEvent处理（自己处理事件）
而setOnTouchListener的返回值会优先决定是否会走onTouchEvent方法的，同时setOnTouchListener也会受到属性enable的影响
事件被传到下一层处理完毕后，能否再传回到上层处理的决定者是onTouchEvent或者setOnTouchListene.onTouch的返回值