NestedScrollingParent & NestedScrollingChild

嵌套滚动:NestedScrollingParent和NestedScrollingChild,这两个东西,可能好多人有点陌生,但我们在很多场景下,已经在不识不觉中使用它了,比如说CoordinatorLayout,它是一个NestedScrollingParent,还有RecycleView,它是一个NestedScrollingChild。

一个最常见的效果:列表向上滚动,ToolBar收起,反之,当列表向下滚动时,ToolBar随着列表的滚动出现。这个效果,用NestedScrolling来实现,可以非常简单。

嵌套滚动原理:

至于它的原理,很简单:在NestedScrollingChild滚动过程中,它和NestedScrollingParent会一直"保持通讯",比如:

  • 当Child滚动之前,会通知Parent:"我要开始滚动啦,你看你要不要做点什么"。
  • 当Child在滚动的时候,也会每次通知Parent:"我这次消费了xxx,你看你还要做什么"。
  • 当Child滚动完成,Parent也会收到通知:"我滚动完成了"。

当然了,除了手指触摸滚动的,还有惯性滚动,但原理和流程是一样的。

1. 谁实现 NestedScrollingChild,谁实现NestedScrollingParent ?

在实际项目中,我们往往会遇到这样一种需求,当ViewA还显示的时候,往上滑动到viewA不可见时,才开始滑动viewB, 又或者向下滑动到viewB不能滑动时,才开始向上滑动viewC. 如果列表滑动、上拉加载和下拉刷新的view都封装成一个组件的话,那滑动逻辑就是刚刚这样。而这其中列表就要实现nestedScrollingChild, 最外层的Container实现nestedScrollingParent. 如果最外层的Container希望在其它布局中仍然能够将滑动事件继续往上冒泡,那么container在实现nestedScrollingParent的同时也要实现nestedScrollingChild。 如下示意图所示。

NestedScrollingParent & NestedScrollingChild_第1张图片

触发滑动的组件或者接受到滑动事件且需要继续往上传递的是nestedScrollingChild.

布局是nestedScrollingChild的父布局,且需要消费传递的滑动事件就是nestedScrollingParent.

2.nestedScrollingChildnestedScrollingParent有哪些api.

public interface NestedScrollingChild {
   
    public void setNestedScrollingEnabled(boolean enabled);
    
    public boolean isNestedScrollingEnabled();

    public boolean startNestedScroll(int axes);

    public void stopNestedScroll();

    public boolean hasNestedScrollingParent();

    public boolean dispatchNestedScroll(int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed, int[] offsetInWindow);

    public boolean dispatchNestedPreScroll(int dx, int dy, int[] consumed, int[] offsetInWindow);

    public boolean dispatchNestedFling(float velocityX, float velocityY, boolean consumed);

    public boolean dispatchNestedPreFling(float velocityX, float velocityY);
}
public interface NestedScrollingParent {
   
    public boolean onStartNestedScroll(View child, View target, int nestedScrollAxes);

    public void onNestedScrollAccepted(View child, View target, int nestedScrollAxes);

    public void onStopNestedScroll(View target);

    public void onNestedScroll(View target, int dxConsumed, int dyConsumed,  int dxUnconsumed, int dyUnconsumed);

    public void onNestedPreScroll(View target, int dx, int dy, int[] consumed);

    public boolean onNestedFling(View target, float velocityX, float velocityY, boolean consumed);

    public int getNestedScrollAxes();
}

因为child是产生滑动的造势者,所以它的api都是以直接的动词开头,而parent的滑动响应是child通知parent的,所以都是以监听on开头:
parent ----> onXXXX()
child -----> verbXXXX()

2.1 滑动事件的是如何传递的

那既然能传递,说明这个滑动事件一定产生了,如何产生滑动事件?当然是用户手指在屏幕上滑动了呀。为了不说的这么枯燥,我们拿最熟悉熟悉的小伙伴RecyclerView来作为nestedScrollingChild讲解。这里我引入的版本是:25.3.1
implementation 'com.android.support:recyclerview-v7:25.3.1'

2.1.1 滑动事件传递从哪里产生?

     switch (action) {
          case MotionEvent.ACTION_DOWN: 
                int nestedScrollAxis = ViewCompat.SCROLL_AXIS_NONE;
                if (canScrollHorizontally) {
                    nestedScrollAxis |= ViewCompat.SCROLL_AXIS_HORIZONTAL;
                }
                if (canScrollVertically) {
                    nestedScrollAxis |= ViewCompat.SCROLL_AXIS_VERTICAL;
                }
                startNestedScroll(nestedScrollAxis);
            } 
          break;
    }

我们可以发现,当我的小手按在RecyclerView上时,调用了nestedScrollingChildstartNestedScroll(nestedScrollAxis), 这里我们再多让我们的大脑接受一点信息,那就是这个方法的参数:nestedScrollAxis, 滑动的坐标轴。 RecylerView是不是既可以水平滑动,又可以纵向滑动,那这里就是传递的就是RecyclerView可以滑动的坐标轴。

发现了startNestedScroll(axis),看看走到了哪里。

 @Override
    public boolean startNestedScroll(int axes) {
        return getScrollingChildHelper().startNestedScroll(axes);
    }

NestedScrollingChildHelper:

public boolean startNestedScroll(int axes) {
        if (hasNestedScrollingParent()) {
            // Already in progress
            return true;
        }
        if (isNestedScrollingEnabled()) {
            ViewParent p = mView.getParent();
            View child = mView;
            while (p != null) {
                if (ViewParentCompat.onStartNestedScroll(p, child, mView, axes)) {
                    mNestedScrollingParent = p;
                    ViewParentCompat.onNestedScrollAccepted(p, child, mView, axes);
                    return true;
                }
                if (p instanceof View) {
                    child = (View) p;
                }
                p = p.getParent();
            }
        }
        return false;
    }

这个方法我是原封不动拷贝下来:
第一句: 判断 mNestedScrollingParent是不是 null。 在NestedScrollingChildHelper这个类,全类只有两处给它赋值了,一个赋有值,就是上面代码中的while循环里面,一个是赋空值,在方法stopNestedScroll,这个方法什么时候调用啊,在你美丽的小手离开屏幕的时候。所以只要你的小手在屏幕上,这个startedNestedScroll 这个方法只会调用一次。也就是通知parent我美丽的小手指要滑动啦,通知过你,我就不通知了。

第二句: 判断mIsNestedScrollingEnabled 是否要true. 这个变量也是至关重要的,它的作用是 要不要向上冒泡滑动事件,所以说哪天小仙女不开心了,直接调用了:setNestedScrollingEnabled(false), 父布局是怎么都不知道小手指有没有滑动的。

第三句+第四句:这里的p就是父布局了,这里的mView是在初始化这个类的时候,传递过来的,所以在RecyclerView中,可以找到这句话:mScrollingChildHelper = new NestedScrollingChildHelper(this);. 这里的mView就是RecyclerView 这位小仙女啦。

第五句:进入while循环了,为什么这里要while循环,因为它要确保使命必达,不管我的父布局有多深,我都要找到你,并通知到你。

第六句:if里的逻辑说明,如果parent监听到即将要在这个轴上有滑动事件,并且正是parent需要的事件,那么就会调用onNestedScrollAccept。 这里的ViewParentCompat.onStartNestedScroll(p, child, mView, axes) 会最终调用到实现nestedScrollingParent组件中的onStartNestedScroll方法,这个方法就是parent 判断收到该滑动通知时,是不是天时地利人和,如果是,我就返回true,后面一系列的小手指滑动都要告知我。如果返回false,说明parent此时在处理别的事情,后面小手指滑动的弧线再怎么优美,都不要来烦我。

第七句:onNestedScrollAccepted 说明parent正式接收了此child也就是recyclerView的滑动通知,最终会调用到parentonNestedScrollAccept方法中,如果此parent还实现了接口nestedScrollingChild, 可以在这个方法继续向parentparent上报了。

所以整个流程可以概括为:通知
ACTION_DOWN
--> child.startNestedScroll
--> childHelper.startNestedScroll
--> parent.onStartNestedScroll
--> parent.onNestedScrollAccept

2.1.2 小手指滑动的时候,childparent之间是如何通信的?

 case MotionEvent.ACTION_MOVE: {
         if (dispatchNestedPreScroll(dx, dy, mScrollConsumed, mScrollOffset)) {
             dx -= mScrollConsumed[0];
             dy -= mScrollConsumed[1];
             vtev.offsetLocation(mScrollOffset[0], mScrollOffset[1]);
         }

        if (mScrollState == SCROLL_STATE_DRAGGING) {
            mLastTouchX = x - mScrollOffset[0];
            mLastTouchY = y - mScrollOffset[1];

            if (scrollByInternal(canScrollHorizontally ? dx : 0,canScrollVertically ? dy : 0,
            vtev)) {
                 getParent().requestDisallowInterceptTouchEvent(true);
        }
    break;
}

这里呢,有两个重要的方法:dispatchNestedPreScroll 和 scrollByInternal.

第一句: dispatchNestedPreScroll(dx, dy, consumed, offsetInWindow),这里的参数中只有dx,dy两个参数在前面赋值了,而后面两个参数在哪里操作的呢?这里我们留个问号?首先这个方法会走到NestedScrollingChildHelper类中的方法:dispatchNestedPreScroll调用ViewParentCompat.onNestedPreScroll(mNestedScrollingParent, mView, dx, dy, consumed);

public boolean dispatchNestedPreScroll(int dx, int dy, int[] consumed, int[] offsetInWindow) {
        ViewParentCompat.onNestedPreScroll(mNestedScrollingParent, mView, dx, dy, consumed);
 }

最终目的地来到了parentonNestedPreScroll()。所以我们可以大胆猜测,consumed, offsetInwindow, 是在parent这里赋值的,当然你可以不用赋值,不赋值的话,值也就是保留上一次的值。

  dx -= mScrollConsumed[0];
  dy -= mScrollConsumed[1];

dispatchNestedPreScroll()这个方法返回true后,发现重新计算了dx,dy, 在方法scrollByInternal()方法中,用的是最新的dx,dy值。说明当小手指产生滑动位移的时候,先分发给parent,让parent先消耗,并在方法中将parent消耗的位移传递过来,那么剩下的位移,ok,那充当childRecyclerView内部消费了。

 if (scrollByInternal(canScrollHorizontally ? dx : 0,canScrollVertically ? dy : 0,vtev)) {
      getParent().requestDisallowInterceptTouchEvent(true);
 }
boolean scrollByInternal(int x, int y, MotionEvent ev) {
        int unconsumedX = 0, unconsumedY = 0;
        int consumedX = 0, consumedY = 0;
        if (mAdapter != null) {
            if (y != 0) {
                consumedY = mLayout.scrollVerticallyBy(y, mRecycler, mState);
                unconsumedY = y - consumedY;
            }          
        }
        if (dispatchNestedScroll(consumedX, consumedY, unconsumedX, unconsumedY, mScrollOffset)) {
            // Update the last touch co-ords, taking any scroll offset into account
            mLastTouchX -= mScrollOffset[0];
            mLastTouchY -= mScrollOffset[1];
            if (ev != null) {
                ev.offsetLocation(mScrollOffset[0], mScrollOffset[1]);
            }
            mNestedOffsets[0] += mScrollOffset[0];
            mNestedOffsets[1] += mScrollOffset[1];
        } 
        return consumedX != 0 || consumedY != 0;
    }

第二句:scrollByInternal()就是内部滑动消耗了,在这个方法里面,我们发现继续往parent分发了事件:dispatchNestedScroll(consumeX, consumeY, unconsumeX, unconsumeY), 把自己未消耗的滑动位移继续移交给parent,这个时候最终会走到parent的方法:onNestedScroll()。 在这里,如果parent还实现了nestedScrollingChild,可以将未消耗的滑动位移继续移交给自己的parent.

@Override
  public void onNestedScroll(View target, int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed) {
    if(isNestedScrollingEnabled()) {
      dispatchNestedScroll(dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed, mParentOffsetInWindow);
    }
  }

所以我们可以总结如下:通信

ACTION_MOVE : 小手指滑动位移为:dy
--> childHelper.dispatchNestedPreScroll(dy)
--> parent.onNestedPreScroll(dy), consumedY = parent.onNestedPreScroll(dy)
--> dy' = dy - consumeY                 
recyclerView.scrollByInternal(dy')                          unconsumeY = dy' - recyclerView.scrollByInternal(dy')
--> parent.startNestedScroll(unconsumeY)

2.1.3 小手指滑累了,离开屏幕时,又有哪些事件传递?

  case MotionEvent.ACTION_UP: {
        if (!((xvel != 0 || yvel != 0) && fling((int) xvel, (int) yvel))) {
                    setScrollState(SCROLL_STATE_IDLE);
         }
        resetTouch();
   } 
  break;



public boolean fling(int velocityX, int velocityY) {
        if (!dispatchNestedPreFling(velocityX, velocityY)) {
            final boolean canScroll = canScrollHorizontal || canScrollVertical;
            dispatchNestedFling(velocityX, velocityY, canScroll);
            if (canScroll) {
                mViewFlinger.fling(velocityX, velocityY);
                return true;
            }
        }
        return false;
    }  

 private void resetTouch() {
        stopNestedScroll();
    }

这里我们发现先是child执行fling方法,也就是当手松开时仍然有速度,那么会执行一段惯性滑动,而在这惯性滑动中, 这里就很奇妙了,先是通过dispatchNestedPreFling()将滑动速度传递给parent, 如果parent不消耗的话,再次通过dispatchNestedFlingparent传递,只是这次的传递会带上child自己是否有能力消费惯性滑动,最后不管parent有没有消费,child也就是recyclerview都会执行自己的fling.也就是:

mViewFlinger.fling(velocityX, velocityY);

走完了惯性滑动,就会走到stopNestedScroll(). 按照上面的逻辑处理,我们应该可以猜到接下来的逻辑就是走到NestedScrollingChildHelper这个类。然后目的地会到达parentonStopNestedScroll方法。这里,parent就可以处理当小手指离开屏幕时的一些逻辑了。这条路很简单,没有返回值,也没有传递什么变量。还是很好理解的。

    public void stopNestedScroll() {
        if (mNestedScrollingParent != null) {
            ViewParentCompat.onStopNestedScroll(mNestedScrollingParent, mView);
            mNestedScrollingParent = null;
        }
    }

这里呢,我们可以总结如下:

ACTION_UP

--> childHelper.dispatchNestedPreFling
--> parent.onNestedPreFling
--> childHelper.dispatchNestedFling
--> parent.onNestedFling
--> child.fling
--> childHelper.stopNestedScroll
--> parent.onStopNestedScroll

这样,我们整个nestedScrollingChildnestedScrollingParent之间的丝丝缕缕都讲解完了。



转载链接:一篇文章让你轻松弄懂NestedScrollingParent & NestedScrollingChild

你可能感兴趣的:(Android)