Android嵌套滑动上篇

作者: leilifengxingmw | 来源:发表于2020-12-02 19:56 被阅读0次

Android嵌套滑动下篇
Android嵌套滑动上篇
Android NestedScrolling嵌套滑动机制
自定义View事件篇进阶篇(三)-CoordinatorLayo
一种非嵌套滑动冲突的解决方案
使用Android系统的双滚动实现掌阅的书架效果
Android 嵌套滑动总结
Android 嵌套滑动总结
Android 收藏
ScrollView 嵌套 RecyclerVeiw, 轻松解决

本片文章学习分析一下Android中的嵌套滑动。涉及到的类有

NestedScrollingChild
NestedScrollingParent
ViewParent
RecyclerView

下一篇会分析NestedScrolling2相关的内容。

为了方便叙述，我们把在内部的滑动View称为内层控件。外部滑动的控件称为外层控件。

内层控件需要实现NestedScrollingChild接口。比如RecyclerView是实现了NestedScrollingChild接口的。

在Build.VERSION.SDK_INT小于21版本以下，外层控件必须实现NestedScrollingParent接口。在21及以上版本，外层控件不再需要实现NestedScrollingParent接口，因为ViewParent接口中已经定义了嵌套滑动外层控件相关的方法，ViewGroup实现了ViewParent接口。

本篇文章会实现NestedScrollingParent接口来自定义一个外层控件StickyNavLayout。内层控件，我们直接使用RecyclerView。最终实现的一个效果图如下所示：

嵌套滑动版本1.gif

GitHub源码

我们看到这个滑动效果并不是很流畅，下一篇会分析NestedScrolling2相关的内容就可以解决。

嵌套滑动的整个流程是从内层控件发起的。先看一下流程图。

NestedScrolling流程.jpg

我们以RecyclerView为例进行分析。注意：我们的是android-25版本里面的RecyclerView源码。

public class RecyclerView extends ViewGroup implements ScrollingView, NestedScrollingChild {
    //...
}

RecyclerView的onTouchEvent方法精简版

@Override
public boolean onTouchEvent(MotionEvent e) {
    //...
    final MotionEvent vtev = MotionEvent.obtain(e);
    final int action = MotionEventCompat.getActionMasked(e);
    final int actionIndex = MotionEventCompat.getActionIndex(e);

    if (action == MotionEvent.ACTION_DOWN) {
        mNestedOffsets[0] = mNestedOffsets[1] = 0;
    }
    vtev.offsetLocation(mNestedOffsets[0], mNestedOffsets[1]);

    switch (action) {
        case MotionEvent.ACTION_DOWN: {
            //...
            //注释1处
            startNestedScroll(nestedScrollAxis);
        } break;
        case MotionEvent.ACTION_MOVE: {
            final int index = e.findPointerIndex(mScrollPointerId);
               
            final int x = (int) (e.getX(index) + 0.5f);
            final int y = (int) (e.getY(index) + 0.5f);
            int dx = mLastTouchX - x;
            int dy = mLastTouchY - y;
            //注释2处
            if (dispatchNestedPreScroll(dx, dy, mScrollConsumed, mScrollOffset)) {
                //注释3处
                dx -= mScrollConsumed[0];
                dy -= mScrollConsumed[1];
                vtev.offsetLocation(mScrollOffset[0], mScrollOffset[1]);
                // Updated the nested offsets
                mNestedOffsets[0] += mScrollOffset[0];
                mNestedOffsets[1] += mScrollOffset[1];
            }
            //...
            if (mScrollState == SCROLL_STATE_DRAGGING) {
                mLastTouchX = x - mScrollOffset[0];
                mLastTouchY = y - mScrollOffset[1];
                //注释4处
                if (scrollByInternal(
                        canScrollHorizontally ? dx : 0,
                        canScrollVertically ? dy : 0,
                        vtev)) {
                    getParent().requestDisallowInterceptTouchEvent(true);
                }   
            }
        } break;
        case MotionEvent.ACTION_UP: {
            mVelocityTracker.addMovement(vtev);
            eventAddedToVelocityTracker = true;
                
            mVelocityTracker.computeCurrentVelocity(1000, mMaxFlingVelocity);
            //计算fling速度
            final float xvel = canScrollHorizontally ?
                    -VelocityTrackerCompat.getXVelocity(mVelocityTracker, mScrollPointerId) : 0;
            final float yvel = canScrollVertically ?
                    -VelocityTrackerCompat.getYVelocity(mVelocityTracker, mScrollPointerId) : 0;
            //注释5处
            if (!((xvel != 0 || yvel != 0) && fling((int) xvel, (int) yvel))) {
                setScrollState(SCROLL_STATE_IDLE);
            }
            //注释6处
            resetTouch();
        } break;           
    }
    //...
    return true;
}

ACTION_DOWN的注释1处

//注释1处
startNestedScroll(nestedScrollAxis);

这里开始嵌套滑动的整个流程。

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

调用NestedScrollingChildHelper的startNestedScroll方法。

/**
 *
 * @param axes 支持嵌套滚动的方向。
 *             
 * @return true 如果找到了协作的嵌套滑动的父控件并成功启动嵌套滑动则返回true。
 */
public boolean startNestedScroll(int axes) {
    if (hasNestedScrollingParent()) {
        // 已经在嵌套滑动中了，直接返回true
        return true;
    }
    //启用了嵌套滑动
    if (isNestedScrollingEnabled()) {
        //获取父控件
        ViewParent p = mView.getParent();
        View child = mView;
        //注释1处，向上遍历View层级，找到处理嵌套滑动的ViewParent
        while (p != null) {
            //注释2处
            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;
}

注释1处，向上遍历View层级，找到处理嵌套滑动的ViewParent。

注释2处，调用ViewParentCompat.onStartNestedScroll来询问是否某个父级控件想处理嵌套滑动，如果ViewParentCompat.onStartNestedScroll返回true，说明父控件想要处理处理嵌套滑动。

ViewParentCompat的onStartNestedScroll方法。

public static boolean onStartNestedScroll(ViewParent parent, View child, View target,
            int nestedScrollAxes) {
    //找到对应的ViewParentCompatImpl来处理
    return IMPL.onStartNestedScroll(parent, child, target, nestedScrollAxes);
}

static final ViewParentCompatImpl IMPL;
static {
    final int version = Build.VERSION.SDK_INT;
    if (version >= 21) {
        IMPL = new ViewParentCompatLollipopImpl();
    } else if (version >= 19) {
        IMPL = new ViewParentCompatKitKatImpl();
    } else if (version >= 14) {
        IMPL = new ViewParentCompatICSImpl();
    } else {
        IMPL = new ViewParentCompatStubImpl();
    }
}

ViewParentCompatImpl在不同的版本中有不同的实现。在Build.VERSION.SDK_INT小于21版本以下，外层控件必须实现NestedScrollingParent接口。在21及以上版本，外层控件不再需要实现NestedScrollingParent接口，因为ViewParent接口中已经定义了嵌套滑动外层控件相关的方法，ViewGroup实现了ViewParent接口。

这里我们就看21以上的版本。

ViewParentCompatLollipopImpl的onStartNestedScroll方法。

@Override
public boolean onStartNestedScroll(ViewParent parent, View child, View target,
                int nestedScrollAxes) {
    return ViewParentCompatLollipop.onStartNestedScroll(parent, child, target,
                nestedScrollAxes);
}

ViewParentCompatLollipop的onStartNestedScroll方法。

public static boolean onStartNestedScroll(ViewParent parent, View child, View target,
            int nestedScrollAxes) {
    try {
        //注释1处
        return parent.onStartNestedScroll(child, target, nestedScrollAxes);
    } catch (AbstractMethodError e) {
        Log.e(TAG, "ViewParent " + parent + " does not implement interface " +
                    "method onStartNestedScroll", e);
        return false;
    }
}

注释1处，最终调用ViewParent的onStartNestedScroll方法。如果返回true，紧接着会调用ViewParent的onNestedScrollAccepted方法。

public static void onNestedScrollAccepted(ViewParent parent, View child, View target,
            int nestedScrollAxes) {
    try {
        //调用ViewParent的onNestedScrollAccepted方法。
        parent.onNestedScrollAccepted(child, target, nestedScrollAxes);
    } catch (AbstractMethodError e) {
        Log.e(TAG, "ViewParent " + parent + " does not implement interface " +
                    "method onNestedScrollAccepted", e);
    }
}

我们回到RecyclerView的onTouchEvent方法的ACTION_MOVE处

//注释2处
if (dispatchNestedPreScroll(dx, dy, mScrollConsumed, mScrollOffset)) {
    //注释3处
    dx -= mScrollConsumed[0];
    dy -= mScrollConsumed[1];
    vtev.offsetLocation(mScrollOffset[0], mScrollOffset[1]);
    // Updated the nested offsets
    mNestedOffsets[0] += mScrollOffset[0];
    mNestedOffsets[1] += mScrollOffset[1];
 }

注释2处，在内层控件开始滑动之前先询问外层控件是否要先处理滑动，如果dispatchNestedPreScroll返回true，表明外层控件消耗了某些滑动距离，所以我们在注释3处减去外层控件消耗的滑动距离。

@Override
public boolean dispatchNestedPreScroll(int dx, int dy, int[] consumed, int[] offsetInWindow) {
    return getScrollingChildHelper().dispatchNestedPreScroll(dx, dy, consumed, offsetInWindow);
}

/**
 * Dispatch one step of a nested pre-scrolling operation to the current nested scrolling parent.
 *
 * @return true 如果外层控件消耗了滑动距离，返回true。
 */
public boolean dispatchNestedPreScroll(int dx, int dy, int[] consumed, int[] offsetInWindow) {
    //启用了嵌套滑动并且有父控件处理嵌套滑动
    if (isNestedScrollingEnabled() && mNestedScrollingParent != null) {
        if (dx != 0 || dy != 0) {
            int startX = 0;
            int startY = 0;
            if (offsetInWindow != null) {
                mView.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;
            //注释1处
            ViewParentCompat.onNestedPreScroll(mNestedScrollingParent, mView, dx, dy, consumed);

            if (offsetInWindow != null) {
                mView.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;
}

注释一处，调用外层控件的onNestedPreScroll方法。

public static void onNestedPreScroll(ViewParent parent, View target, int dx, int dy,
            int[] consumed) {
    try {
        parent.onNestedPreScroll(target, dx, dy, consumed);
    } catch (AbstractMethodError e) {
        Log.e(TAG, "ViewParent " + parent + " does not implement interface " +
                "method onNestedPreScroll", e);
    }
}

我们回到RecyclerView的onTouchEvent方法的ACTION_MOVE处：

//注释4处
if (scrollByInternal(
        canScrollHorizontally ? dx : 0,
        canScrollVertically ? dy : 0,
        vtev)) {
    getParent().requestDisallowInterceptTouchEvent(true);
}

boolean scrollByInternal(int x, int y, MotionEvent ev) {
    //...
    if (mAdapter != null) {
        if (x != 0) {
            //注释1处
            consumedX = mLayout.scrollHorizontallyBy(x, mRecycler, mState);
            unconsumedX = x - consumedX;
        }
        if (y != 0) {
            //注释2处
            consumedY = mLayout.scrollVerticallyBy(y, mRecycler, mState);
            unconsumedY = y - consumedY;
        }
    }
    //注释3处
    if (dispatchNestedScroll(consumedX, consumedY, unconsumedX, unconsumedY, mScrollOffset)) {
    //...
    }
}

注释1处，注释2处，RecyclerView先自己滑动，计算出消耗的滑动距离consumedX、consumedY，没有消耗的滑动距离 unconsumedX、unconsumedY。

注释3处，自身滑动之后通知外层控件。最终会调用外层控件的onNestedScroll方法。

public static void onNestedScroll(ViewParent parent, View target, int dxConsumed,
            int dyConsumed, int dxUnconsumed, int dyUnconsumed) {
    try {
        //调用外层控件的onNestedScroll方法。
        parent.onNestedScroll(target, dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed);
    } catch (AbstractMethodError e) {
        Log.e(TAG, "ViewParent " + parent + " does not implement interface " +
                "method onNestedScroll", e);
    }
}

我们回到RecyclerView的onTouchEvent方法的ACTION_UP处：

//注释5处
if (!((xvel != 0 || yvel != 0) && fling((int) xvel, (int) yvel))) {
    setScrollState(SCROLL_STATE_IDLE);
}
//注释6处
resetTouch();

注释5处，开始惯性滑动。

public boolean fling(int velocityX, int velocityY) {
  //...
  //注释1处
  if (!dispatchNestedPreFling(velocityX, velocityY)) {
     //内层控件自身是否可以滑动
     final boolean canScroll = canScrollHorizontal || canScrollVertical;
     //注释2处
     dispatchNestedFling(velocityX, velocityY, canScroll);

     if (mOnFlingListener != null && mOnFlingListener.onFling(velocityX, velocityY)) {
         return true;
     }

     if (canScroll) {
         velocityX = Math.max(-mMaxFlingVelocity, Math.min(velocityX, mMaxFlingVelocity));
         velocityY = Math.max(-mMaxFlingVelocity, Math.min(velocityY, mMaxFlingVelocity));
         //注释3处
         mViewFlinger.fling(velocityX, velocityY);
         return true;
     }
  }
  return false;
}

注释1处，先询问外层控件是否要处理惯性滑动，如果要处理，直接返回false，RecyclerView 自身不滑动。

public static boolean onNestedPreFling(ViewParent parent, View target, float velocityX,
            float velocityY) {
    try {
        //调用外层控件的onNestedPreFling方法。
        return parent.onNestedPreFling(target, velocityX, velocityY);
    } catch (AbstractMethodError e) {
        Log.e(TAG, "ViewParent " + parent + " does not implement interface " +
                "method onNestedPreFling", e);
        return false;
    }
}

注释2处，最终会调用外层控件的onNestedFling方法。

public static boolean onNestedFling(ViewParent parent, View target, float velocityX,
            float velocityY, boolean consumed) {
    try {
        return parent.onNestedFling(target, velocityX, velocityY, consumed);
    } catch (AbstractMethodError e) {
        Log.e(TAG, "ViewParent " + parent + " does not implement interface " +
                "method onNestedFling", e);
        return false;
    }
}

开始，很疑惑，注释处，dispatchNestedPreFling返回了false，为什么在注释2处还要调用dispatchNestedFling方法呢。我想了想，这里调用dispatchNestedFling方法，紧接着又在注释3处处调用了RecyclerView的fling，可以实现外层控件和内层控件同时滑动。

注释3处，内层控件自身滑动。

 mViewFlinger.fling(velocityX, velocityY);

这里简单说一下mViewFlinger，ViewFlinger实现了Runnable接口，然后通过OverScroller来实现fling。当OverScroller计算滚动还没结束的时候，就将ViewFlinger当做一个Runnable接口post出去(接受帧信后)，在下一帧到来的时候在run方法中实现滚动。在ViewFlinger的run方法中，并没有再调用和嵌套滑动相关的逻辑。

ViewFlinger的run方法的精简版。

@Override
public void run() {
    if (mLayout == null) {
        stop();
        return; // no layout, cannot scroll.
    }
    // ...
    final OverScroller scroller = mScroller;
    final SmoothScroller smoothScroller = mLayout.mSmoothScroller;
    if (scroller.computeScrollOffset()) {
        //...
        if (mAdapter != null) {
            //...
            if (dx != 0) {
                //调用LayoutManager的来实现滑动
                 hresult = mLayout.scrollHorizontallyBy(dx, mRecycler, mState);
                 overscrollX = dx - hresult;
            }
            if (dy != 0) {
                //调用LayoutManager的来实现滑动
                vresult = mLayout.scrollVerticallyBy(dy, mRecycler, mState);
                overscrollY = dy - vresult;
            }
            //...
        }
               
        //滚动结束了
        if (scroller.isFinished() || !fullyConsumedAny) {
            setScrollState(SCROLL_STATE_IDLE); // setting state to idle will stop this.
        } else {
            //滚动没结束，继续post
            postOnAnimation();
        }
    }
    //...
}

我们回到RecyclerView的onTouchEvent方法的ACTION_UP处：

//注释6处
resetTouch();

private void resetTouch() {
    if (mVelocityTracker != null) {
        mVelocityTracker.clear();
    }
    //停止嵌套滑动
    stopNestedScroll();
    releaseGlows();
}

public static void onStopNestedScroll(ViewParent parent, View target) {
    try {
        //注释1处
        parent.onStopNestedScroll(target);
    } catch (AbstractMethodError e) {
        Log.e(TAG, "ViewParent " + parent + " does not implement interface " +
                "method onStopNestedScroll", e);
    }
}

注释1处，最终调用外层控件的onStopNestedScroll方法。一次完整的嵌套滑动流程结束。

这里注意一下：外层控件的onStopNestedScroll方法被调用的时候，外层控件或者内层控件的惯性滑动可能并没有结束。

参考链接：

Android嵌套滑动下篇
上篇文章 Android嵌套滑动上篇[https://www.jianshu.com/p/9312362dec29...
Android嵌套滑动上篇
本片文章学习分析一下Android中的嵌套滑动。涉及到的类有 NestedScrollingChild Neste...
Android NestedScrolling嵌套滑动机制
Android NestedScrolling嵌套滑动机制 Android在发布5.0之后加入了嵌套滑动机制Nes...
自定义View事件篇进阶篇(三)-CoordinatorLayo
前言在上篇文章中，我们介绍了NestedScrolling(嵌套滑动)机制，介绍了子控件与父控件嵌套滑动的处理。...
一种非嵌套滑动冲突的解决方案
非嵌套滑动 | 嵌套滑动 Android 系统的触摸事件分发总是从父布局开始分发，从最顶层的子 View 开始...
使用Android系统的双滚动实现掌阅的书架效果
十分钟Android中的嵌套滚动机制 Android NestedScrolling机制完全解析带你玩转嵌套滑动...
Android 嵌套滑动总结
一、什么是嵌套滑动嵌套滑动是 android 开发中常见的一种 UI 效果。当一个布局中包含多个可以滑动的 Vi...
Android 嵌套滑动总结
一、什么是嵌套滑动嵌套滑动是 android 开发中常见的一种 UI 效果。当一个布局中包含多个可以滑动的 Vi...
Android 收藏
图解 Android 事件分发机制 ViewPager，ScrollView 嵌套ViewPager滑动冲突解决
ScrollView 嵌套 RecyclerVeiw, 轻松解决
滑动冲突在开发android中，滑动冲突是一常见的事件冲突。列如：在scrollView中嵌套listView...