CoordinatorLayout里Behavior简单分析

一时失言乱红尘 2022-07-26 02:01 182阅读 0赞

当给CoordinatorLayout的直接子View设置Behavior的时候，CoordinatorLayout里面的一些事件就可以传入到Behavior，Behavior又可以指导View做一些相应的处理。

#### Behavior对象是怎么被实例化的 ####

CoordinatorLayout里面的子View是怎么拿到Behavior对象的。设置Bevior有两种方式  
1. 代码里面直接设置(LayoutParams)child.getLayoutParams().setBehavior()这个就好说了。  
2. XML里面去设置app:layout\_behavior=”” 。

对应第二种情况Behavior是怎么实例化的。  
CoordinatorLayout里面LayoutParams两个参数的构造函数。

LayoutParams(Context context, AttributeSet attrs) {
        super(context, attrs);
    
        final TypedArray a = context.obtainStyledAttributes(attrs,
                R.styleable.CoordinatorLayout_LayoutParams);
    
        this.gravity = a.getInteger(
                R.styleable.CoordinatorLayout_LayoutParams_android_layout_gravity,
                Gravity.NO_GRAVITY);
        mAnchorId = a.getResourceId(R.styleable.CoordinatorLayout_LayoutParams_layout_anchor,
                View.NO_ID);
        this.anchorGravity = a.getInteger(
                R.styleable.CoordinatorLayout_LayoutParams_layout_anchorGravity,
                Gravity.NO_GRAVITY);
    
        this.keyline = a.getInteger(R.styleable.CoordinatorLayout_LayoutParams_layout_keyline,
                -1);
    
        mBehaviorResolved = a.hasValue(
                R.styleable.CoordinatorLayout_LayoutParams_layout_behavior);
        if (mBehaviorResolved) {
            mBehavior = parseBehavior(context, attrs, a.getString(
                    R.styleable.CoordinatorLayout_LayoutParams_layout_behavior));
        }
    
        a.recycle();
    }

第20行是否设置了app:layout\_behavior=”” 如果设置了调用parseBehavior函数。利用反射去实例化出Behavior对象。

#### Behavior简单分析 ####

Behavior都是配合CoordinatorLayout来使用的。  
对于Behavior我们分三种情况来考虑。  
1. Behavior的onInterceptTouchEvent + onTouchEvent。  
2. Behavior的layoutDependsOn + onDependentViewChanged + onDependentViewRemoved。View引起的变化。  
3. Behavior的onStartNestedScroll + onNestedScrollAccepted + onStopNestedScroll + onNestedScroll + onNestedPreScroll + onNestedFling + onNestedPreFling。嵌套滑动引起的变化。  
大概的去知道每种情况里面每个函数的调用时机。和大概的作用。

#### Behavior的onInterceptTouchEvent + onTouchEvent ####

分两部分来考虑。  
1. CoordinatorLayout里面是怎么调用到我们指定View的Behavior的onInterceptTouchEvent和onTouchEvent里面去的。  
2. View的Behavior里面onInterceptTouchEvent和onTouchEvent里面干了什么事情。(这个一般是我们自定义Behavior的时候处理，这个先不管)。

CoordinatorLayout里面是怎么调用到我们指定View的Behavior的onInterceptTouchEvent和onTouchEvent里面去的。直接CoordinatorLayout的onInterceptTouchEvent函数和onTouchEvent函数里面了先CoordinatorLayout类的onInterceptTouchEvent函数。

@Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        MotionEvent cancelEvent = null;
    
        final int action = MotionEventCompat.getActionMasked(ev);
    
        // Make sure we reset in case we had missed a previous important event.
        if (action == MotionEvent.ACTION_DOWN) {
            resetTouchBehaviors();
        }
    
        final boolean intercepted = performIntercept(ev, TYPE_ON_INTERCEPT);
    
        if (cancelEvent != null) {
            cancelEvent.recycle();
        }
    
        if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
            resetTouchBehaviors();
        }
    
        return intercepted;
    }

第12行调用了performIntercept函数，参数type TYPE\_ON\_INTERCEPT表示从onInterceptTouchEvent函数进来的，TYPE\_ON\_TOUCH表示从onTouchEvent函数进来的。

private boolean performIntercept(MotionEvent ev, final int type) {
        boolean intercepted = false;
        boolean newBlock = false;
    
        MotionEvent cancelEvent = null;
    
        final int action = MotionEventCompat.getActionMasked(ev);
    
        final List<View> topmostChildList = mTempList1;
        getTopSortedChildren(topmostChildList);
    
        // Let topmost child views inspect first
        final int childCount = topmostChildList.size();
        for (int i = 0; i < childCount; i++) {
            final View child = topmostChildList.get(i);
            final LayoutParams lp = (LayoutParams) child.getLayoutParams();
            final Behavior b = lp.getBehavior();
    
            if ((intercepted || newBlock) && action != MotionEvent.ACTION_DOWN) {
                // Cancel all behaviors beneath the one that intercepted.
                // If the event is "down" then we don't have anything to cancel yet.
                if (b != null) {
                    if (cancelEvent == null) {
                        final long now = SystemClock.uptimeMillis();
                        cancelEvent = MotionEvent.obtain(now, now,
                                MotionEvent.ACTION_CANCEL, 0.0f, 0.0f, 0);
                    }
                    switch (type) {
                        case TYPE_ON_INTERCEPT:
                            b.onInterceptTouchEvent(this, child, cancelEvent);
                            break;
                        case TYPE_ON_TOUCH:
                            b.onTouchEvent(this, child, cancelEvent);
                            break;
                    }
                }
                continue;
            }
    
            if (!intercepted && b != null) {
                switch (type) {
                    case TYPE_ON_INTERCEPT:
                        intercepted = b.onInterceptTouchEvent(this, child, ev);
                        break;
                    case TYPE_ON_TOUCH:
                        intercepted = b.onTouchEvent(this, child, ev);
                        break;
                }
                if (intercepted) {
                    mBehaviorTouchView = child;
                }
            }
    
            // Don't keep going if we're not allowing interaction below this.
            // Setting newBlock will make sure we cancel the rest of the behaviors.
            final boolean wasBlocking = lp.didBlockInteraction();
            final boolean isBlocking = lp.isBlockingInteractionBelow(this, child);
            newBlock = isBlocking && !wasBlocking;
            if (isBlocking && !newBlock) {
                // Stop here since we don't have anything more to cancel - we already did
                // when the behavior first started blocking things below this point.
                break;
            }
        }
    
        topmostChildList.clear();
    
        return intercepted;
    }

第14行开始，遍历CoordinatorLayout所有的View，第19行第一个if做的事情是如果现在已经有View对应的Behavoir拦截了的，并且不是ACTION\_DOWN的时候，其他View的Behavoir都会收到ACTION\_CANCEL事件。  
第40行第二个if如果没有被拦截并且有Behavoir则调用Behavoir对应的函数onInterceptTouchEvent或者onTouchEvent函数。

CoordinatorLayout的onTouchEvent函数

@Override
    public boolean onTouchEvent(MotionEvent ev) {
        boolean handled = false;
        boolean cancelSuper = false;
        MotionEvent cancelEvent = null;
    
        final int action = MotionEventCompat.getActionMasked(ev);
    
        if (mBehaviorTouchView != null || (cancelSuper = performIntercept(ev, TYPE_ON_TOUCH))) {
            // Safe since performIntercept guarantees that
            // mBehaviorTouchView != null if it returns true
            final LayoutParams lp = (LayoutParams) mBehaviorTouchView.getLayoutParams();
            final Behavior b = lp.getBehavior();
            if (b != null) {
                handled = b.onTouchEvent(this, mBehaviorTouchView, ev);
            }
        }
    
        // Keep the super implementation correct
        if (mBehaviorTouchView == null) {
            handled |= super.onTouchEvent(ev);
        } else if (cancelSuper) {
            if (cancelEvent != null) {
                final long now = SystemClock.uptimeMillis();
                cancelEvent = MotionEvent.obtain(now, now,
                        MotionEvent.ACTION_CANCEL, 0.0f, 0.0f, 0);
            }
            super.onTouchEvent(cancelEvent);
        }
    
        if (!handled && action == MotionEvent.ACTION_DOWN) {
    
        }
    
        if (cancelEvent != null) {
            cancelEvent.recycle();
        }
    
        if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
            resetTouchBehaviors();
        }
    
        return handled;
    }

CoordinatorLayout的onTouchEvent函数就是看下当前事件是不是有哪个View的Behavior感兴趣。如果感兴趣就给View的Behavior做处理，不敢兴趣就给CoordinatorLayout自己处理。  
这样Behavior的onInterceptTouchEvent + onTouchEvent。两个函数的调用也引导进去了。

#### Behavior的layoutDependsOn + onDependentViewChanged + onDependentViewRemoved ####

/** * child是否要依赖dependency * @param parent CoordinatorLayout * @param child 该Behavior对应的那个View * @param dependency 要检查的View(child是否要依赖这个dependency) * @return true 依赖, false 不依赖 */
        public boolean layoutDependsOn(CoordinatorLayout parent, V child, View dependency) {
            return false;
        }
    
        /** * 在layoutDependsOn返回true的基础上之后，及时报告dependency的状态变化 * @param parent CoordinatorLayout * @param child 该Behavior对应的那个View * @param dependency child依赖dependency * @return true 处理了, false 没处理 */
        public boolean onDependentViewChanged(CoordinatorLayout parent, V child, View dependency) {
            return false;
        }
    
        /** * 在layoutDependsOn返回true的基础上之后，报告dependency被移除了 * @param parent CoordinatorLayout * @param child 该Behavior对应的那个View * @param dependency child依赖dependency */
        public void onDependentViewRemoved(CoordinatorLayout parent, V child, View dependency) {
        }

所有的源头都在CoordinatorLayout类里面  
CoordinatorLayout类里面onAttachedToWindow

@Override
    public void onAttachedToWindow() {
        super.onAttachedToWindow();
        resetTouchBehaviors();
        if (mNeedsPreDrawListener) {
            if (mOnPreDrawListener == null) {
                mOnPreDrawListener = new OnPreDrawListener();
            }
            final ViewTreeObserver vto = getViewTreeObserver();
            vto.addOnPreDrawListener(mOnPreDrawListener);
        }
        if (mLastInsets == null && ViewCompat.getFitsSystemWindows(this)) {
            // We're set to fitSystemWindows but we haven't had any insets yet...
            // We should request a new dispatch of window insets
            ViewCompat.requestApplyInsets(this);
        }
        mIsAttachedToWindow = true;
    }

第10行给ViewTreeObserver添加了一个OnPreDrawListener的监听。OnPreDrawListener代码如下

class OnPreDrawListener implements ViewTreeObserver.OnPreDrawListener { 
        @Override
        public boolean onPreDraw() {
            dispatchOnDependentViewChanged(false);
            return true;
        }
    }

OnPreDrawListener实现了ViewTreeObserver.OnPreDrawListener接口重写了onPreDraw函数，onPreDraw在每次draw的时候都会调用。就是在CoordinatorLayout每次重绘的时候调用。View状态发生变化的时候调用。这样重点就到了dispatchOnDependentViewChanged函数了参数false表示不是嵌套滑动引起的变化是View状态改变引起的变化。

void dispatchOnDependentViewChanged(final boolean fromNestedScroll) {
        final int layoutDirection = ViewCompat.getLayoutDirection(this);
        final int childCount = mDependencySortedChildren.size();
        for (int i = 0; i < childCount; i++) {
            final View child = mDependencySortedChildren.get(i);
            final LayoutParams lp = (LayoutParams) child.getLayoutParams();
    
            // Check child views before for anchor
            for (int j = 0; j < i; j++) {
                final View checkChild = mDependencySortedChildren.get(j);
    
                if (lp.mAnchorDirectChild == checkChild) {
                    offsetChildToAnchor(child, layoutDirection);
                }
            }
    
            // Did it change? if not continue
            final Rect oldRect = mTempRect1;
            final Rect newRect = mTempRect2;
            getLastChildRect(child, oldRect);
            getChildRect(child, true, newRect);
            if (oldRect.equals(newRect)) {
                continue;
            }
            recordLastChildRect(child, newRect);
    
            // Update any behavior-dependent views for the change
            for (int j = i + 1; j < childCount; j++) {
                final View checkChild = mDependencySortedChildren.get(j);
                final LayoutParams checkLp = (LayoutParams) checkChild.getLayoutParams();
                final Behavior b = checkLp.getBehavior();
    
                if (b != null && b.layoutDependsOn(this, checkChild, child)) {
                    if (!fromNestedScroll && checkLp.getChangedAfterNestedScroll()) {
                        // If this is not from a nested scroll and we have already been changed
                        // from a nested scroll, skip the dispatch and reset the flag
                        checkLp.resetChangedAfterNestedScroll();
                        continue;
                    }
    
                    final boolean handled = b.onDependentViewChanged(this, checkChild, child);
    
                    if (fromNestedScroll) {
                        // If this is from a nested scroll, set the flag so that we may skip
                        // any resulting onPreDraw dispatch (if needed)
                        checkLp.setChangedAfterNestedScroll(handled);
                    }
                }
            }
        }
    }

第3行 mDependencySortedChildren里面放的是CoordinatorLayout所有的子View，只不过把相关连的View放到一起了(相关联有两种一种是直接xml里面设置了layout\_anchor，一种是Behavior里面设置了关联layoutDependsOn函数)。接着遍历所有的View。  
第9行到15行找到哪个View设置了layout\_anchor也就是说设置显示坐标的锚点 哪个View的layout\_anchor对应child。调整位置，这个应该好理解点layout\_anchor设置的View和当前的View是相关会一起变化的。  
第28行到49行找到哪个View的Behavior depend on child这个View。第0行调用了Behavior的layoutDependsOn判断是否依赖。如果依赖继续调用Behavior的onDependentViewChanged函数。

到这里Behavior的layoutDependsOn和onDependentViewChanged的调用的地方和调用的时机我们都知道了。还差一个onDependentViewRemoved函数。继续看CoordinatorLayout里面的HierarchyChangeListener里 在哪里用到了呢构造函数里面super.setOnHierarchyChangeListener(new HierarchyChangeListener());设置了去监听ViewGroup中的View的层次变化当View removed掉的时候这里能够监听到了会调用onChildViewRemoved。

final class HierarchyChangeListener implements OnHierarchyChangeListener { 
        @Override
        public void onChildViewAdded(View parent, View child) {
            if (mOnHierarchyChangeListener != null) {
                mOnHierarchyChangeListener.onChildViewAdded(parent, child);
            }
        }
    
        @Override
        public void onChildViewRemoved(View parent, View child) {
            dispatchDependentViewRemoved(child);
    
            if (mOnHierarchyChangeListener != null) {
                mOnHierarchyChangeListener.onChildViewRemoved(parent, child);
            }
        }
    }

继续dispatchDependentViewRemoved函数。

void dispatchDependentViewRemoved(View removedChild) {
        final int childCount = getChildCount();
        for (int i = 0; i < childCount; i++) {
            final View child = getChildAt(i);
            final LayoutParams lp = (LayoutParams) child.getLayoutParams();
            final Behavior b = lp.getBehavior();
    
            if (b != null && b.layoutDependsOn(this, child, removedChild)) {
                b.onDependentViewRemoved(this, child, removedChild);
            }
        }
    }

找到对应View的Behavior 如果是layoutDependsOn的就去调用Behavior的onDependentViewRemoved。  
到此Behavior的layoutDependsOn + onDependentViewChanged + onDependentViewRemoved三个函数的调用时机和调用顺序都结束了。

#### Behavior的onStartNestedScroll + onNestedScrollAccepted + onStopNestedScroll + onNestedScroll + onNestedPreScroll + onNestedFling + onNestedPreFling ####

/** * 有嵌套滑动到来了，问下该Behavior是否接受嵌套滑动 * * @param coordinatorLayout CoordinatorLayout * @param child 该Behavior对应的View * @param directTargetChild 嵌套滑动对应的父类的子类(因为嵌套滑动对于的父View不一定是一级就能找到的，可能挑了两级父View的父View， directTargetChild>=target) * @param target 具体嵌套滑动的那个子类 * @param nestedScrollAxes 支持嵌套滚动轴。水平方向，垂直方向，或者不指定 * @return 是否接受该嵌套滑动 */
        public boolean onStartNestedScroll(CoordinatorLayout coordinatorLayout,
                                           V child,
                                           View directTargetChild,
                                           View target,
                                           int nestedScrollAxes) {
            return false;
        }
    
        /** * Behavior接受了嵌套滑动的请求该函数调用。onStartNestedScroll返回true该函数会被调用。 参数和onStartNestedScroll一样 */
        public void onNestedScrollAccepted(CoordinatorLayout coordinatorLayout,
                                           V child,
                                           View directTargetChild,
                                           View target,
                                           int nestedScrollAxes) {
            // Do nothing
        }
    
        /** * 停止嵌套滑动 * * @param coordinatorLayout CoordinatorLayout * @param child 该Behavior对应的View * @param target 具体嵌套滑动的那个子类 */
        public void onStopNestedScroll(CoordinatorLayout coordinatorLayout, V child, View target) {
            // Do nothing
        }
    
        /** * 嵌套滑动的子View在滑动之后报告过来的滑动情况 * * @param coordinatorLayout CoordinatorLayout * @param child 该Behavior对应的View * @param target 具体嵌套滑动的那个子类 * @param dxConsumed 水平方向嵌套滑动的子View滑动的距离(消耗的距离) * @param dyConsumed 垂直方向嵌套滑动的子View滑动的距离(消耗的距离) * @param dxUnconsumed 水平方向嵌套滑动的子View未滑动的距离(未消耗的距离) * @param dyUnconsumed 垂直方向嵌套滑动的子View未滑动的距离(未消耗的距离) */
        public void onNestedScroll(CoordinatorLayout coordinatorLayout,
                                   V child,
                                   View target,
                                   int dxConsumed,
                                   int dyConsumed,
                                   int dxUnconsumed,
                                   int dyUnconsumed) {
            // Do nothing
        }
    
        /** * 在嵌套滑动的子View未滑动之前告诉过来的准备滑动的情况 * * @param coordinatorLayout CoordinatorLayout * @param child 该Behavior对应的View * @param target 具体嵌套滑动的那个子类 * @param dx 水平方向嵌套滑动的子View想要变化的距离 * @param dy 垂直方向嵌套滑动的子View想要变化的距离 * @param consumed 这个参数要我们在实现这个函数的时候指定，回头告诉子View当前父View消耗的距离 consumed[0] 水平消耗的距离，consumed[1] 垂直消耗的距离 好让子view做出相应的调整 */
        public void onNestedPreScroll(CoordinatorLayout coordinatorLayout, V child, View target, int dx, int dy, int[] consumed) {
            // Do nothing
        }
    
        /** * 嵌套滑动的子View在fling之后报告过来的fling情况 * * @param coordinatorLayout CoordinatorLayout * @param child 该Behavior对应的View * @param target 具体嵌套滑动的那个子类 * @param velocityX 水平方向速度 * @param velocityY 垂直方向速度 * @param consumed 子view是否fling了 * @return true Behavior是否消耗了fling */
        public boolean onNestedFling(CoordinatorLayout coordinatorLayout,
                                     V child,
                                     View target,
                                     float velocityX,
                                     float velocityY,
                                     boolean consumed) {
            return false;
        }
    
        /** * 在嵌套滑动的子View未fling之前告诉过来的准备fling的情况 * * @param coordinatorLayout CoordinatorLayout * @param child 该Behavior对应的View * @param target 具体嵌套滑动的那个子类 * @param velocityX 水平方向速度 * @param velocityY 垂直方向速度 * @return true Behavior是否消耗了fling */
        public boolean onNestedPreFling(CoordinatorLayout coordinatorLayout, V child, View target, float velocityX, float velocityY) {
            return false;
        }

嵌套滑动引起的变化，根据前一篇文章[Android 嵌套滑动分析][Android]的分析CoordinatorLayout 实现了 NestedScrollingParent，有嵌套滑动的时候会调用到CoordinatorLayout里面的onStartNestedScroll onNestedScrollAccepted onStopNestedScroll onNestedScroll onNestedPreScroll onNestedFling onNestedPreFling这些函数。至于是怎么调用到的这些函数可以看看[Android 嵌套滑动分析][Android]的介绍。这些函数里面做的事情也都是大同小异的都是直接过度给了Behavior里面对应的函数。  
这样我们就知道了Behavior的onStartNestedScroll + onNestedScrollAccepted + onStopNestedScroll + onNestedScroll + onNestedPreScroll + onNestedFling + onNestedPreFling。的调用时机是有嵌套滑动的时候会被调用到。

最后的最后给个简单的DEMO [DEMO下载地址][DEMO]

[Android]: http://blog.csdn.net/wuyuxing24/article/details/51112645
[DEMO]: http://download.csdn.net/detail/wuyuxing24/9491936