事件分发四部曲之二《嵌套滑动事件分析》

事件分发四部曲之二《嵌套滑动事件分析》

Android小彩虹2021-08-21 3:55:37220A+A-

 本文是Android事件分发四部曲之二

 1. 事件分发四部曲之一《深度遍历讲解Android事件分发机制》

 2. 事件分发四部曲之二《嵌套滑动事件分析》

 3. 事件分发四部曲之三《CoordinatorLayout事件分析》

 4. 事件分发四部曲之四《Put All Together》

温馨提示:Android事件分发机制是Android嵌套滑动机制的基石,阅读本文前请务必保证熟练掌握Android事件分发机制。传送门->事件分发四步曲之一《深度遍历讲解Android事件分发机制》

本文大纲

1. 嵌套ScrollView同向滑动

2. 传统事件分发和嵌套滑动事件分发

3. NestedScrollingChild&NestedScrollingParent

4. 结合案例讲解嵌套滑动事件分发顺序

1. 嵌套ScrollView同向滑动

所谓嵌套ScrollView同向滑动,是指两个可滑动的View内外嵌套,并且他们的方向是相同的。
嵌套ScrollView
当在内部ScrollView中上下滑动时,会有两种情况。

  1. 外部ScrollView优先获取上下滑动的权力,在蓝色区域上下滑动,内部ScrollView并不会上下滑动

非嵌套滑动.gif

  1. 内部的ScrollView优先获取上下滑动的权力,在蓝色区域内上下滑动,内部ScrollView上下滑动

嵌套滑动.gif

在Android未提供嵌套滑动机制之前,嵌套ScrollView同向滑动的效果是情况一,内部ScrollView优先获得DOWN事件的处理机会,外部的ScrollView优先获得MOVE事件的处理机会(yDiff > mTouchSlop)。原因如下:

当外部ScrollView嵌套内部ScrollView时,DOWN事件在内部ScrollView的onTouchEvent中返回true,内部ScrollView处理了DOWN事件。MOVE事件首先到达外部ScrollView的onInterceptTouchEvent方法,当滑动距离大于mTouchSlop时,会拦截掉MOVE事件,给内部ScrollView发出CANCEL事件,从而外部ScrollView获得了事件的处理权,内部ScrollView失去了事件的处理权。

ScrollView#onTouchEvent方法返回true。根据传统事件分发机制,内部ScrollView优先获得DOWN事件的处理机会。

    //ScrollView#onTouchEvent
    public boolean onTouchEvent(MotionEvent ev) {
        initVelocityTrackerIfNotExists();

        MotionEvent vtev = MotionEvent.obtain(ev);

        final int actionMasked = ev.getActionMasked();

        if (actionMasked == MotionEvent.ACTION_DOWN) {
            mNestedYOffset = 0;
        }
        vtev.offsetLocation(0, mNestedYOffset);

        switch (actionMasked) {
            case MotionEvent.ACTION_DOWN: {
                if (getChildCount() == 0) {
                    return false;
                }
                if ((mIsBeingDragged = !mScroller.isFinished())) {
                    final ViewParent parent = getParent();
                    if (parent != null) {
                        parent.requestDisallowInterceptTouchEvent(true);
                    }
                }

                /* * If being flinged and user touches, stop the fling. isFinished * will be false if being flinged. */
                if (!mScroller.isFinished()) {
                    mScroller.abortAnimation();
                    if (mFlingStrictSpan != null) {
                        mFlingStrictSpan.finish();
                        mFlingStrictSpan = null;
                    }
                }

                // Remember where the motion event started
                mLastMotionY = (int) ev.getY();
                mActivePointerId = ev.getPointerId(0);
                startNestedScroll(SCROLL_AXIS_VERTICAL);
                break;
            }
            //此处省略其它事件的代码
        }

        if (mVelocityTracker != null) {
            mVelocityTracker.addMovement(vtev);
        }
        vtev.recycle();
        return true;
    }

关于MOVE事件,首先会调用外部ScrollView的onInterceptTouchEvent方法,如果返回false,MOVE事件会调用内部ScrollView的onTouchEvent方法,如果返回true,会调用外部ScrollView的onTouchEvent方法。当yDiff > mTouchSlop时,方法返回true。

    public boolean onInterceptTouchEvent(MotionEvent ev) {
        
        final int action = ev.getAction();
        if ((action == MotionEvent.ACTION_MOVE) && (mIsBeingDragged)) {
            return true;
        }

        if (super.onInterceptTouchEvent(ev)) {
            return true;
        }

        
        if (getScrollY() == 0 && !canScrollVertically(1)) {
            return false;
        }

        switch (action & MotionEvent.ACTION_MASK) {
            case MotionEvent.ACTION_MOVE: {
                 
                final int activePointerId = mActivePointerId;
                if (activePointerId == INVALID_POINTER) {
                    // If we don't have a valid id, the touch down wasn't on content.
                    break;
                }

                final int pointerIndex = ev.findPointerIndex(activePointerId);
                if (pointerIndex == -1) {
                    Log.e(TAG, "Invalid pointerId=" + activePointerId
                            + " in onInterceptTouchEvent");
                    break;
                }

                final int y = (int) ev.getY(pointerIndex);
                final int yDiff = Math.abs(y - mLastMotionY);
                if (yDiff > mTouchSlop && (getNestedScrollAxes() & SCROLL_AXIS_VERTICAL) == 0) {
                    mIsBeingDragged = true;
                    mLastMotionY = y;
                    initVelocityTrackerIfNotExists();
                    mVelocityTracker.addMovement(ev);
                    mNestedYOffset = 0;
                    if (mScrollStrictSpan == null) {
                        mScrollStrictSpan = StrictMode.enterCriticalSpan("ScrollView-scroll");
                    }
                    final ViewParent parent = getParent();
                    if (parent != null) {
                        parent.requestDisallowInterceptTouchEvent(true);
                    }
                }
                break;
            }
            //此处省略其它事件的代码
        }
        
        return mIsBeingDragged;
    }

这种效果显然不能满足用户的需求。内部的ScrollView永远无法获得上下滑动的机会。用户希望在内部ScrollView的区域上下滑动时,内部ScrollView优先获得事件的分发权力。Android嵌套滑动机制,很好的解决了ScrollView嵌套时内部ScrollView无法优先处理滑动事件的问题。

2. 传统事件分发和嵌套滑动事件分发

传统事件分发在事件分发四步曲之一《深度遍历讲解Android事件分发机制》中已经详细讲解过,这里不做详细的讲解。事件会调用父控件的onInterceptTouchEvent方法,判断是否拦截事件。换言之传统的事件分发,生杀大权掌握在父控件上,只有父控件不拦截事件,子控件才有处理事件的机会。

传统事件分发树形图如下传统事件分发树形图

而嵌套滑动事件分发则区别于传统事件分发,事件分发的生杀大权并不掌握在父控件上。当DOWN事件传递到NestedScrollingChild时,NestedScrollingChild控件会向上寻找愿意响应后代View发出嵌套滑动请求的NestedScrollingParent控件,告诉NestedScrollingParent控件,后续的MOVE事件,不要再拦截,事件优先交给NestedScrollingChild处理,如果MOVE滑动超过mTouchSlop阈值,NestedScrollingChild向上请求"不拦截事件"->"parent.requestDisallowInterceptTouchEvent(true)",从此NestedScrollingChild的所有父控件,对事件全部不拦截,直达NestedScrollingChild控件。

嵌套滑动事件分发树形图如下嵌套滑动事件分发树形图
总结:传统事件分发,父View会优先获取事件的分发权,并且如果事件被某个View处理了,那么它的父View无法获得事件分发的机会。嵌套滑动事件分发,NestedScrollingChild处理DOWN事件时,会告诉它的NestedScrollingParent,后续的MOVE、UP等事件,NestedScrollingParent不拦截,直接交由NestedScrollingChild处理,而且它的父View有机会再次获得事件分发的机会。

3. NestedScrollingChild&NestedScrollingParent

嵌套滑动机制提供了NestedScrollingChild和NestedScrollingParent接口。

NestedScrollingChild

NestedScrollingParent

定义控件节点如下

控件节点

  • NestedScrollingChild节点表示实现了NestedScrollingChild接口的View或者ViewGroup
  • NestedScrollingParent节点表示实现了NestedScrollingParent接口的ViewGroup
  • Both 表示两个接口都实现了的ViewGroup

NSC和NSP是成对出现的,一个NestedScrollingChild只能对应一个NestedScrollingParent,而一个NestedScrollingParent可以对应多个NestedScrollingChild。一个控件即可以同时实现NSC和NSP接口,它对于父的NSP控件而言是一个NSC可以主动发起嵌套滑动的请求,对于它的NSC控件而言是一个NSP,它可以响应后代控件发起的嵌套滑动请求。当NSC的滑动嵌套请求(startNestedScroll)被NSP响应了(onStartNestedScroll返回true)称NSC和NSP为pair(天生一对),NSC可能和最近的祖先NSP组成Pair,也可能与非最近的祖先NSP组成pair。下面我们分析几个Case。

  1. NestedScrollingParent和NestedScrollingChild是有效的pair

  1. NestedScrollingParent和NestedScrollingChild是无效的pair

  1. NestedScrollingParent2和NestedScrollingChild是有效的pair,NestedScrollingParent1和NestedScrollingChild也有可能是有效的pair(当NSP2不响应嵌套滑动,而NSP1响应 好好思考一下 下面的Case相同,不表)

  1. NestedScrollingParent和Both是有效的pair,Both和NestedScrollingChild是有效的pair

  1. NestedScrollingParent和NestedScrollingChild是有效的pair,尽管中间隔了一个普通的ViewGroup

  1. NestedScrollingParent和NestedScrollingChild1是有效的pair,NestedScrollingParent和NestedScrollingChild2是有效的pair

NestedScrollingChild方法以及作用

  1.  控制嵌套滑动机制是否开启->NestedScrollingChild#setNestedScrollingEnable和NestedScrollingChild#isNestedScrollingEnable。
 //View.java
  public void setNestedScrollingEnabled(boolean enabled) {
      if (enabled) {
          mPrivateFlags3 |= PFLAG3_NESTED_SCROLLING_ENABLED;
      } else {
          stopNestedScroll();
          mPrivateFlags3 &= ~PFLAG3_NESTED_SCROLLING_ENABLED;
      }
  }
  
  public boolean isNestedScrollingEnabled() {
      return (mPrivateFlags3 & PFLAG3_NESTED_SCROLLING_ENABLED) ==
              PFLAG3_NESTED_SCROLLING_ENABLED;
  }

  1. 通知NestedScrollingParent不拦截MOVE、UP等事件->NestedScrollingChild#startNestedScroll。
//View.java
public boolean startNestedScroll(int axes) {
    //如果已经找到的NSP返回
    if (hasNestedScrollingParent()) {
        // Already in progress
        return true;
    }
    //如果开启了嵌套滑动
    if (isNestedScrollingEnabled()) {
        //往上查找NestedScrollingParent
        ViewParent p = getParent();
        View child = this;
        while (p != null) {
            try {
              //如果NSP的onStartNestedScroll返回true,表示响应NSC的嵌套滑动
                if (p.onStartNestedScroll(child, this, axes)) {
                    //设置NSC的mNestedScrollingParent对象,下次不用再查找了
                    mNestedScrollingParent = p;
                    p.onNestedScrollAccepted(child, this, axes);
                    return true;
                }
            } catch (AbstractMethodError e) {
                Log.e(VIEW_LOG_TAG, "ViewParent " + p + " does not implement interface " +
                        "method onStartNestedScroll", e);
                // Allow the search upward to continue
            }
            if (p instanceof View) {
                child = (View) p;
            }
            p = p.getParent();
        }
    }
    //如果没找到返回false
    return false;
}

如上图,假设NestedScrollingParent2的onStartNestedScroll返回false,NestedScrollingParent1的onStartNestedScroll返回true。当NestedScrollingChild调用startNestedScroll方法时。NestedScrollingParent1和NestedScrollingChild是有效的Pair

调用时机,以ScrollView为例子,ScrollView实现了NSC接口,一般在Down事件中调用,或者在NSP的onNestedScrollAccepted中

  • 调用时机1 ScrollView#onInterceptTouchEvent
public boolean onInterceptTouchEvent(MotionEvent ev) {
    final int action = ev.getAction();
    if ((action == MotionEvent.ACTION_MOVE) && (mIsBeingDragged)) {
        return true;
    }
    if (super.onInterceptTouchEvent(ev)) {
        return true;
    }
    
    if (getScrollY() == 0 && !canScrollVertically(1)) {
        return false;
    }
    switch (action & MotionEvent.ACTION_MASK) {

        //这里省略其它事件

        case MotionEvent.ACTION_DOWN: {
            final int y = (int) ev.getY();
            if (!inChild((int) ev.getX(), (int) y)) {
                mIsBeingDragged = false;
                recycleVelocityTracker();
                break;
            }
            mLastMotionY = y;
            mActivePointerId = ev.getPointerId(0);

            initOrResetVelocityTracker();
            mVelocityTracker.addMovement(ev);
            
            mScroller.computeScrollOffset();
            mIsBeingDragged = !mScroller.isFinished();
            if (mIsBeingDragged && mScrollStrictSpan == null) {
                mScrollStrictSpan = StrictMode.enterCriticalSpan("ScrollView-scroll");
            }
            //调用时机1
            startNestedScroll(SCROLL_AXIS_VERTICAL);
            break;
        }
    }
    return mIsBeingDragged;
}

  • 调用时机2 ScrollView#onTouchEvent
    public boolean onTouchEvent(MotionEvent ev) {
        initVelocityTrackerIfNotExists();

        //省略代码
        switch (actionMasked) {
            case MotionEvent.ACTION_DOWN: {
                if (getChildCount() == 0) {
                    return false;
                }
                if ((mIsBeingDragged = !mScroller.isFinished())) {
                    final ViewParent parent = getParent();
                    if (parent != null) {
                        parent.requestDisallowInterceptTouchEvent(true);
                    }
                }

                if (!mScroller.isFinished()) {
                    mScroller.abortAnimation();
                    if (mFlingStrictSpan != null) {
                        mFlingStrictSpan.finish();
                        mFlingStrictSpan = null;
                    }
                }

                // Remember where the motion event started
                mLastMotionY = (int) ev.getY();
                mActivePointerId = ev.getPointerId(0);
                //调用时机2
                startNestedScroll(SCROLL_AXIS_VERTICAL);
                break;
            }
            
        }
        //省略代码
        return true;
    }

  • 调用时机3 ScrollView#onNestedScrollAccepted
public void onNestedScrollAccepted(View child, View target, int axes) {
    super.onNestedScrollAccepted(child, target, axes);
    //调用时机3。NSP往上找它的NSP 对应Case4中的Both往上找NSP
    startNestedScroll(SCROLL_AXIS_VERTICAL);
}

  1. 处理滑动事件之前,将滑动事件的处理权交由NestedScrollingParent处理->(NestedScrollingChild#dispatchNestedPreScroll)。(这里叨唠一下,子View虽然优先获取了事件分发的权力,但是在滑动之前,还是会把事件交给父View去处理。传统事件分发,父View如果获取了分发权,子View就无法获取分发权。滑动嵌套即使子View获取了分发权,它还是会征询父View,是否要处理掉事件的一部分滑动,父View可以选择处理或者不处理,子View再处理事件剩余滑动距离)。
//View.java
public boolean dispatchNestedPreScroll(int dx, int dy, @Nullable @Size(2) int[] consumed, @Nullable @Size(2) int[] offsetInWindow) {
    if (isNestedScrollingEnabled() && mNestedScrollingParent != null) {
        if (dx != 0 || dy != 0) {
            int startX = 0;
            int startY = 0;
            if (offsetInWindow != null) {
                getLocationInWindow(offsetInWindow);
                startX = offsetInWindow[0];
                startY = offsetInWindow[1];
            }

            if (consumed == null) {
                if (mTempNestedScrollConsumed == null) {
                    mTempNestedScrollConsumed = new int[2];
                }
                consumed = mTempNestedScrollConsumed;
            }
            consumed[0] = 0;
            consumed[1] = 0;
            mNestedScrollingParent.onNestedPreScroll(this, dx, dy, consumed);

            if (offsetInWindow != null) {
                getLocationInWindow(offsetInWindow);
                offsetInWindow[0] -= startX;
                offsetInWindow[1] -= startY;
            }
            return consumed[0] != 0 || consumed[1] != 0;
        } else if (offsetInWindow != null) {
            offsetInWindow[0] = 0;
            offsetInWindow[1] = 0;
        }
    }
    return false;
}

调用时机,一般在NSC真正处理MOVE事件之前

ScrollView#onTouchEvent

public boolean onTouchEvent(MotionEvent ev) {
    initVelocityTrackerIfNotExists();

    MotionEvent vtev = MotionEvent.obtain(ev);

    final int actionMasked = ev.getActionMasked();

    if (actionMasked == MotionEvent.ACTION_DOWN) {
        mNestedYOffset = 0;
    }
    vtev.offsetLocation(0, mNestedYOffset);

    switch (actionMasked) {

        case MotionEvent.ACTION_MOVE:
            final int activePointerIndex = ev.findPointerIndex(mActivePointerId);
            if (activePointerIndex == -1) {
                Log.e(TAG, "Invalid pointerId=" + mActivePointerId + " in onTouchEvent");
                break;
            }

            final int y = (int) ev.getY(activePointerIndex);
            int deltaY = mLastMotionY - y;
            //调用时机,在NSC真正处理MOVE事件之前
            if (dispatchNestedPreScroll(0, deltaY, mScrollConsumed, mScrollOffset)) {
                deltaY -= mScrollConsumed[1];
                vtev.offsetLocation(0, mScrollOffset[1]);
                mNestedYOffset += mScrollOffset[1];
            }
            //伪代码 真正处理MOVE事件
            //if (overScrollBy(0, deltaY, 0, mScrollY, 0, range, 0, mOverscrollDistance, true)
            // && !hasNestedScrollingParent()) {
            // 
            //}
            
             //当NSC滚动到底或者到顶了,unconsumedY不为0
             //if (dispatchNestedScroll(0, scrolledDeltaY, 0, unconsumedY, mScrollOffset)) {
             // mLastMotionY -= mScrollOffset[1];
            // vtev.offsetLocation(0, mScrollOffset[1]);
            // mNestedYOffset += mScrollOffset[1];
            // } 

            break;

    }

    return true;
}

  1. NestedScrollingChild处理完滑动事件后,如果有剩余的滑动距离没有处理掉,会交给NestedScrollingParent去处理剩余的滑动距离->NestedScrollingChild#dispatchNestedScoll,如果NestedScrollingParent处理了剩余的距离,NestedScrollingChild会校正mLastMotionY。
public boolean dispatchNestedScroll(int dxConsumed, int dyConsumed,
            int dxUnconsumed, int dyUnconsumed, @Nullable @Size(2) int[] offsetInWindow) {
        if (isNestedScrollingEnabled() && mNestedScrollingParent != null) {
            //NSC如果有滑动距离没消耗掉,会交给Pair对应的NSP去处理
            if (dxConsumed != 0 || dyConsumed != 0 || dxUnconsumed != 0 || dyUnconsumed != 0) {
                int startX = 0;
                int startY = 0;
                if (offsetInWindow != null) {
                    getLocationInWindow(offsetInWindow);
                    startX = offsetInWindow[0];
                    startY = offsetInWindow[1];
                }

                mNestedScrollingParent.onNestedScroll(this, dxConsumed, dyConsumed,
                        dxUnconsumed, dyUnconsumed);

                if (offsetInWindow != null) {
                    getLocationInWindow(offsetInWindow);
                    offsetInWindow[0] -= startX;
                    offsetInWindow[1] -= startY;
                }
                return true;
            } else if (offsetInWindow != null) {
                // No motion, no dispatch. Keep offsetInWindow up to date.
                offsetInWindow[0] = 0;
                offsetInWindow[1] = 0;
            }
        }
        return false;
    }

调用时机有两个

  • 调用时机1 ScrollView#onTouchEvent中 NSC处理完事件后,调用
public boolean onTouchEvent(MotionEvent ev) {
    initVelocityTrackerIfNotExists();

    MotionEvent vtev = MotionEvent.obtain(ev);

    final int actionMasked = ev.getActionMasked();

    if (actionMasked == MotionEvent.ACTION_DOWN) {
        mNestedYOffset = 0;
    }
    vtev.offsetLocation(0, mNestedYOffset);

    switch (actionMasked) {
         
        case MotionEvent.ACTION_MOVE:
            final int activePointerIndex = ev.findPointerIndex(mActivePointerId);
            if (activePointerIndex == -1) {
                Log.e(TAG, "Invalid pointerId=" + mActivePointerId + " in onTouchEvent");
                break;
            }

            final int y = (int) ev.getY(activePointerIndex);
            int deltaY = mLastMotionY - y;
            if (dispatchNestedPreScroll(0, deltaY, mScrollConsumed, mScrollOffset)) {
                deltaY -= mScrollConsumed[1];
                vtev.offsetLocation(0, mScrollOffset[1]);
                mNestedYOffset += mScrollOffset[1];
            }
            if (!mIsBeingDragged && Math.abs(deltaY) > mTouchSlop) {
                final ViewParent parent = getParent();
                if (parent != null) {
                    parent.requestDisallowInterceptTouchEvent(true);
                }
                mIsBeingDragged = true;
                if (deltaY > 0) {
                    deltaY -= mTouchSlop;
                } else {
                    deltaY += mTouchSlop;
                }
            }
            if (mIsBeingDragged) {
                // Scroll to follow the motion event
                mLastMotionY = y - mScrollOffset[1];

                final int oldY = mScrollY;
                final int range = getScrollRange();
                final int overscrollMode = getOverScrollMode();
                boolean canOverscroll = overscrollMode == OVER_SCROLL_ALWAYS ||
                        (overscrollMode == OVER_SCROLL_IF_CONTENT_SCROLLS && range > 0);

                // Calling overScrollBy will call onOverScrolled, which
                // calls onScrollChanged if applicable.
                if (overScrollBy(0, deltaY, 0, mScrollY, 0, range, 0, mOverscrollDistance, true)
                        && !hasNestedScrollingParent()) {
                    // Break our velocity if we hit a scroll barrier.
                    mVelocityTracker.clear();
                }

                final int scrolledDeltaY = mScrollY - oldY;
                final int unconsumedY = deltaY - scrolledDeltaY;
                #调用时机1
                if (dispatchNestedScroll(0, scrolledDeltaY, 0, unconsumedY, mScrollOffset)) {
                    mLastMotionY -= mScrollOffset[1];
                    vtev.offsetLocation(0, mScrollOffset[1]);
                    mNestedYOffset += mScrollOffset[1];
                } else if (canOverscroll) {
                    final int pulledToY = oldY + deltaY;
                    if (pulledToY < 0) {
                        mEdgeGlowTop.onPull((float) deltaY / getHeight(),
                                ev.getX(activePointerIndex) / getWidth());
                        if (!mEdgeGlowBottom.isFinished()) {
                            mEdgeGlowBottom.onRelease();
                        }
                    } else if (pulledToY > range) {
                        mEdgeGlowBottom.onPull((float) deltaY / getHeight(),
                                1.f - ev.getX(activePointerIndex) / getWidth());
                        if (!mEdgeGlowTop.isFinished()) {
                            mEdgeGlowTop.onRelease();
                        }
                    }
                    if (mEdgeGlowTop != null
                            && (!mEdgeGlowTop.isFinished() || !mEdgeGlowBottom.isFinished())) {
                        postInvalidateOnAnimation();
                    }
                }
            }
            break;
    }

    if (mVelocityTracker != null) {
        mVelocityTracker.addMovement(vtev);
    }
    vtev.recycle();
    return true;
}

  • 调用时机2 ScrollView#onNestedScroll NSP处理完剩余的滚动之后,如果还有剩余滚动距离
public void onNestedScroll(View target, int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed) {
    final int oldScrollY = mScrollY;
    scrollBy(0, dyUnconsumed);
    final int myConsumed = mScrollY - oldScrollY;
    final int myUnconsumed = dyUnconsumed - myConsumed;
    dispatchNestedScroll(0, myConsumed, 0, myUnconsumed, null);
}
  1. fling的逻辑比较特殊,这里以ScrollView为例,先把fling交给NSP的onNestedPreFling处理,如果返回true结束,如果返回false,先判断NSC能否滑动,如果能交给NSC处理,如果不能让NSP重复该步骤。这里有一个递归的逻辑
 public boolean dispatchNestedPreFling(float velocityX, float velocityY) {
    if (isNestedScrollingEnabled() && mNestedScrollingParent != null) {
        return mNestedScrollingParent.onNestedPreFling(this, velocityX, velocityY);
    }
    return false;
}
 private void flingWithNestedDispatch(int velocityY) {
        final boolean canFling = (mScrollY > 0 || velocityY > 0) &&
                (mScrollY < getScrollRange() || velocityY < 0);
        if (!dispatchNestedPreFling(0, velocityY)) {
            dispatchNestedFling(0, velocityY, canFling);
            if (canFling) {
                fling(velocityY);
            }
        }
    }

NestedScrollingChild事件处理步骤

  1. 获取事件的优先处理权-> 调用startNestedScroll

  2. 处理滑动之前先问NesteScrollingParent要不要处理一部分距离

  3. NesteScrollingParent处理完之后,NestedScrollingChild再来处理剩余的距离

  4. NestedScrollingChild处理完之后还有剩余的距离,交给NesteScrollingParent去处理

NestedScrollingParent接口只能被ViewGroup实现。View实现该接口没有意义。NestedScrollingParent主要有两个作用。作用一、响应NesteScrollingChild的嵌套滑动请求,配合NesteScrollingChild完成嵌套滑动机制的交互。作用二、处理NestedScrollingChild滑动前和滑动后传递过来的事件剩余距离。

NestedScrollingParent方法以及作用

  1. getNestedScrollAxes返回嵌套滑动的方向,垂直方向或者水平方向。NestedScrollingParent正是通过该标志位,决定要不要拦截MOVE事件

  2. onNestedScrollAccepted在onStartNestedScroll返回true时,会被调用,该方法体会给mNestedScrollAxes赋值。

//ViewGroup.java
public int getNestedScrollAxes() {
    return mNestedScrollAxes;
}
//ScrollView.java
public void onNestedScrollAccepted(View child, View target, int axes) {
     super.onNestedScrollAccepted(child, target, axes);
     startNestedScroll(SCROLL_AXIS_VERTICAL);
}
  1. onStartNestedScroll():Boolean方法与NestedScrollingChild#startNestedScroll方法相对应。如果返回true表示NestedScrollingParent响应NestedScrollingChild的嵌套滑动,反之表示不响应嵌套滑动。一般做法是外部ScrollView滑动方向和内部ScrollView滑动方向一致返回true。
//ScrollView.java
public boolean onStartNestedScroll(View child, View target, int nestedScrollAxes) {
    return (nestedScrollAxes & SCROLL_AXIS_VERTICAL) != 0;
}
  1. onNestedPreScroll方法会在NestedScrollingChild正式处理滑动事件之前调用。
//ScrollView#onNestedPreScroll 默认分发给父NSP
public void onNestedPreScroll(View target, int dx, int dy, int[] consumed) {
    dispatchNestedPreScroll(dx, dy, consumed, null);
}
  1. onNestedScroll方法会在NestedScrollingChild正式处理滑动事件之后调用
//ScrollView.java
public void onNestedScroll(View target, int dxConsumed, int dyConsumed,
            int dxUnconsumed, int dyUnconsumed) {
        final int oldScrollY = mScrollY;
        //NSP先滑动NSC未消费完的
        scrollBy(0, dyUnconsumed);
        final int myConsumed = mScrollY - oldScrollY;
        final int myUnconsumed = dyUnconsumed - myConsumed;
        //还有没消费完的继续向上分发
        dispatchNestedScroll(0, myConsumed, 0, myUnconsumed, null);
    }
  1. onNestedPreFling与onNestedPreScroll类似

  2. onNesteFling如果NSC不可滑动了,则NSP分发。分发逻辑前面已经讲过

public boolean onNestedFling(View target, float velocityX, float velocityY, boolean consumed) {
        if (!consumed) {
            flingWithNestedDispatch((int) velocityY);
            return true;
        }
        return false;
}
  1. onStopNestedScroll会向上递归调用stopNestedScroll,mNestedScrollAxes置为0
public void onStopNestedScroll(View child) {
        // Stop any recursive nested scrolling.
        stopNestedScroll();
        mNestedScrollAxes = 0;
    }

4.结合案例讲解嵌套滑动事件分发顺序

嵌套滑动.gif
上述效果代码如下

自定义的ScrollView,主要是在相关事件方法中加入日志打印

package com.peter.viewgrouptutorial.touchevent

import android.content.Context
import android.os.Build
import android.util.AttributeSet
import android.util.Log
import android.view.MotionEvent
import android.view.View
import android.widget.ScrollView
import androidx.annotation.RequiresApi

@RequiresApi(Build.VERSION_CODES.LOLLIPOP)
class MyScrollView @JvmOverloads constructor(
    context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0
) : ScrollView(context, attrs, defStyleAttr) {
    init {
        isNestedScrollingEnabled = true
    }
    var name = ""
    @RequiresApi(Build.VERSION_CODES.KITKAT)
    override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
        Log.d("NestScrollingTest"," ")
        Log.d("NestScrollingTest"," ")
        Log.d("NestScrollingTest", "MyScrollView $name onInterceptTouchEvent before ${MotionEvent.actionToString(ev.action)}")
        val intercept = super.onInterceptTouchEvent(ev)
        Log.d("NestScrollingTest", "MyScrollView $name onInterceptTouchEvent after ${MotionEvent.actionToString(ev.action)} $intercept")
        return intercept
    }

    @RequiresApi(Build.VERSION_CODES.KITKAT)
    override fun onTouchEvent(ev: MotionEvent): Boolean {
        Log.d("NestScrollingTest"," ")
        Log.d("NestScrollingTest"," ")


        Log.d("NestScrollingTest","MyScrollView $name onTouchEvent before ${MotionEvent.actionToString(ev.action)} ")

        val touch = super.onTouchEvent(ev)
        Log.d("NestScrollingTest","MyScrollView $name onTouchEvent after ${MotionEvent.actionToString(ev.action)} $touch")
        return touch
    }

    override fun dispatchNestedScroll( dxConsumed: Int, dyConsumed: Int, dxUnconsumed: Int, dyUnconsumed: Int, offsetInWindow: IntArray? ): Boolean {
        Log.d("NestScrollingTest", "MyScrollView $name dispatchNestedScroll")
        return super.dispatchNestedScroll(
            dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed, offsetInWindow
        )
    }

    override fun dispatchNestedPreFling(velocityX: Float, velocityY: Float): Boolean {
        Log.d("NestScrollingTest", "MyScrollView $name dispatchNestedPreFling")
        return super.dispatchNestedPreFling(velocityX, velocityY)
    }

    override fun dispatchNestedFling( velocityX: Float, velocityY: Float, consumed: Boolean ): Boolean {
        Log.d("NestScrollingTest", "MyScrollView $name dispatchNestedFling")

        return super.dispatchNestedFling(velocityX, velocityY, consumed)
    }

    override fun dispatchNestedPreScroll( dx: Int, dy: Int, consumed: IntArray?, offsetInWindow: IntArray? ): Boolean {
        Log.d("NestScrollingTest", "MyScrollView $name dispatchNestedPreScroll dx:$dx dy:$dy")
        return super.dispatchNestedPreScroll(dx, dy, consumed, offsetInWindow)
    }

    override fun onStopNestedScroll(target: View?) {
        Log.d("NestScrollingTest", "MyScrollView $name onStopNestedScroll")
        super.onStopNestedScroll(target)
    }

    override fun onStartNestedScroll(child: View?, target: View?, nestedScrollAxes: Int): Boolean {
        Log.d("NestScrollingTest", "MyScrollView $name onStartNestedScroll")
        return super.onStartNestedScroll(child, target, nestedScrollAxes)
    }

    override fun onNestedPreScroll(target: View?, dx: Int, dy: Int, consumed: IntArray?) {
        Log.d("NestScrollingTest", "MyScrollView $name onNestedPreScroll")
        super.onNestedPreScroll(target, dx, dy, consumed)
    }

    override fun onNestedScroll( target: View?, dxConsumed: Int, dyConsumed: Int, dxUnconsumed: Int, dyUnconsumed: Int ) {
        Log.d("NestScrollingTest", "MyScrollView $name onNestedScroll")
        super.onNestedScroll(target, dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed)
    }


}

Activity代码

package com.peter.viewgrouptutorial.nestedscroll

import android.os.Build
import android.os.Bundle
import androidx.annotation.RequiresApi
import androidx.appcompat.app.AppCompatActivity
import com.peter.viewgrouptutorial.R
import com.peter.viewgrouptutorial.touchevent.MyScrollView

class ScrollTwoActivity : AppCompatActivity() {
    @RequiresApi(Build.VERSION_CODES.LOLLIPOP)
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_scroll_one)
        var outerScroll = findViewById<MyScrollView>(R.id.outerScroll)
        outerScroll.name = "Outer scroll"
        var innerScroll = findViewById<MyScrollView>(R.id.innerScroll)
        innerScroll.name = "Inner scroll"
        outerScroll.isNestedScrollingEnabled = false
    }
}

布局文件

<?xml version="1.0" encoding="utf-8"?>
<com.peter.viewgrouptutorial.touchevent.MyScrollView xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/outerScroll"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="#ff0">
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="vertical">
        <TextView
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:text="@string/long_outer_string"></TextView>
        <com.peter.viewgrouptutorial.touchevent.MyScrollView
            android:id="@+id/innerScroll"
            android:layout_width="match_parent"
            android:layout_height="300dp"
            android:background="#00f">
            <TextView
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:text="@string/long_inner_string">
            </TextView>
        </com.peter.viewgrouptutorial.touchevent.MyScrollView>
        <TextView
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:text="@string/long_outer_string">
        </TextView>
    </LinearLayout>
</com.peter.viewgrouptutorial.touchevent.MyScrollView>

我们把布局文件转化成树形图
布局文件树形图

关于树中的节点,介绍如下
树中节点

日志打印如下 日志

OuterScrollView拦截MOVE事件条件:滑动距离>mTouchSlop&&OuterScrollView未响应嵌套滑动机制。

  1. DOWN事件到达OuterScrollView#onInterceptTouchEvent,不拦截。

  2. DOWN事件到达InnerScrollView#onInterceptTouchEvent,接着调用InnerScrollView#startNestedScroll,触发OuterScrollView#onStartNested,接着调用InnerScrollView#dispatchTouchEvent,由于是DOWN事件,会调用View#dispatchTouchEvent,调用stopNestedScroll,触发OuterScrollView#onStopNestedScroll。

  3. DOWN事件到达InnerScrollView#onTouchEvent方法,调用startNestedScroll,触发OuterScrollView#onStartNestedScroll,OuterScrollView响应嵌套滑动机制。

  4. MOVE事件到达OuterScrollView#onInterceptTouchEvent,拦截条件不成立,不拦截。

  5. MOVE事件到达InnerScrollView#onTouchEvent,调用InnerScrollView#dispatchNestedPreScroll,由于dy=0 dx=0,不会触发OuterScrollView的onNestedPreScroll。

  6. MOVE事件到达OuterScrollView#onInterceptTouchEvent,拦截条件不成立,不拦截。

  7. MOVE事件到达InnerScrollView#onTouchEvent,dy<mTouchSlop,只会触发InnerScrollView#dispatchNestedPreScroll,不会触发dispatchNestedScroll。

  8. MOVE事件到达OuterScrollView#onInterceptTouchEvent,拦截条件不成立,不拦截。

  9. MOVE事件到达InnerScrollView#onTouchEvent,dy<mTouchSlop,只会触发InnerScrollView#dispatchNestedPreScroll,不会触发dispatchNestedScroll。

  10. MOVE事件到达OuterScrollView#onInterceptTouchEvent,拦截条件不成立,不拦截。

  11. MOVE事件到达InnerScrollView#onTouchEvent,dy<mTouchSlop,只会触发InnerScrollView#dispatchNestedPreScroll,不会触发dispatchNestedScroll。

  12. MOVE事件到达OuterScrollView#onInterceptTouchEvent,拦截条件不成立,不拦截。

  13. MOVE事件到达InnerScrollView#onTouchEvent,(dy=31)>mTouchSlop,会同时触发InnerScrollView#dispatchNestedPreScroll和dispatchNestedScroll,同时会调用parent.requestDisallowInterceptTouchEvent(true)。从此MOVE事件直达InnerScrollView#onTouchEvent

  14. MOVE事件直达InnerScrollView#onTouchEvent

  15. MOVE事件直达InnerScrollView#onTouchEvent

  16. 处理UP事件

总结DOWN事件和MOVE事件在NestedScrollingChild中的分发逻辑

  1. DOWN事件到达NestedScrollingChild#onInterceptTouchEvent方法会调用startNestedScroll方法。

  2. DOWN事件到达NestedScrollingChild#dispathTouchEvent方法会调用stopNestedScroll方法。

  3. MOVE事件到达NestedScrollingChild#onTouchEvent方法,调用dispatchNestedPreScroll方法。如果mIsBeingDragged为true。会调用dispatchNestedScroll方法。从非dragged状态变成dragged状态时,会调用ViewParent#requestDisallowInterceptTouchEvent(true)。

我的开源项目

我开源了一个方便RecyclerView吸顶的Android库,欢迎您访问吸顶项目地址,如果您使用本库,请提出您的宝贵意见。

它目前支持以下功能:

  • 支持复杂吸顶View功能
  • 支持多类型吸顶功能
  • 支持开启和关闭吸顶功能
  • 支持设置吸顶偏移量
  • 支持兼容ItemDecoration和ItemAnimator
  • 支持RecyclerView数据变化和滚动到指定位置
  • 其它更多功能

如果你有任何问题,欢迎通过以下方式联系我 欢迎扫码关注公众号

点击这里复制本文地址 以上内容由权冠洲的博客整理呈现,请务必在转载分享时注明本文地址!如对内容有疑问,请联系我们,谢谢!

支持Ctrl+Enter提交

联系我们| 本站介绍| 留言建议 | 交换友链 | 域名展示
本站资源来自互联网收集,仅供用于学习和交流,请遵循相关法律法规,本站一切资源不代表本站立场,如有侵权、后门、不妥请联系本站删除

权冠洲的博客 © All Rights Reserved.  Copyright quanguanzhou.top All Rights Reserved
苏公网安备 32030302000848号   苏ICP备20033101号-1
本网站由 提供CDN/云存储服务

联系我们