Kotlin教程

Android 嵌套滑动总结,kotlin框架

本文主要是介绍Android 嵌套滑动总结,kotlin框架,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

<TextView

android:layout_width=“match_parent”

android:layout_height=“64dp”

android:layout_gravity=“bottom”

android:text=“Top”

android:textSize=“32sp”

android:textColor="@color/white"

android:gravity=“center”

android:textStyle=“bold”/>

</com.google.android.material.appbar.AppBarLayout>

<androidx.recyclerview.widget.RecyclerView

android:id="@+id/rv"

android:layout_width=“match_parent”

android:layout_height=“wrap_content”

app:layout_behavior="@string/appbar_scrolling_view_behavior"/>

</androidx.coordinatorlayout.widget.CoordinatorLayout>

AppBarLayout 中需要上滑隐藏的部分的 scrollFlag 指定为 scroll ,在RecyclerView 中指定 behaviorappbar_scrolling_view_behavior 就可以实现最简单的吸顶嵌套滑动,如下:

看起来像带有 header 的 RecyclerView 在滑动,但其实是嵌套滑动。

layout_scrollFlagslayout_behavior 有很多可选值,配合起来可以实现多种效果,不只限于嵌套滑动。具体可以参考 API 文档。

使用 CoordinatorLayout 实现嵌套滑动比手动实现要好得多,既可以实现连贯的吸顶嵌套滑动,又支持 fling。而且是官方提供的布局,可以放心使用,出 bug 的几率很小,性能也不会有问题。不过也正是因为官方将其封装得很好,使用 CoordinatorLayout 很难实现比较复杂的嵌套滑动布局,比如多级嵌套滑动。

3、嵌套滑动组件 NestedScrollingParent 和 NestedScrollingChild

NestedScrollingParentNestedScrollingChild 是 google 官方提供地一套专门用来解决嵌套滑动地组件。它们是两个接口,代码如下:

public interface NestedScrollingParent2 extends NestedScrollingParent {

boolean onStartNestedScroll(@NonNull View child, @NonNull View target, @ScrollAxis int axes,

@NestedScrollType int type);

void onNestedScrollAccepted(@NonNull View child, @NonNull View target, @ScrollAxis int axes,

@NestedScrollType int type);

void onStopNestedScroll(@NonNull View target, @NestedScrollType int type);

void onNestedScroll(@NonNull View target, int dxConsumed, int dyConsumed,

int dxUnconsumed, int dyUnconsumed, @NestedScrollType int type);

void onNestedPreScroll(@NonNull View target, int dx, int dy, @NonNull int[] consumed,

@NestedScrollType int type);

}

public interface NestedScrollingChild2 extends NestedScrollingChild {

boolean startNestedScroll(@ScrollAxis int axes, @NestedScrollType int type);

void stopNestedScroll(@NestedScrollType int type);

boolean hasNestedScrollingParent(@NestedScrollType int type);

boolean dispatchNestedScroll(int dxConsumed, int dyConsumed,

int dxUnconsumed, int dyUnconsumed, @Nullable int[] offsetInWindow,

@NestedScrollType int type);

boolean dispatchNestedPreScroll(int dx, int dy, @Nullable int[] consumed,

@Nullable int[] offsetInWindow, @NestedScrollType int type);

}

需要嵌套滑动的 View 可以实现这两个接口,复写其中的方法。这套组件实现嵌套滑动的核心原理很简单,主要是以下三步:

  • NestedScrollingChildonTouchEvent 方法中先将 ACITON_MOVE 事件产生的位移 dx 和 dy 通过 dispatchNestedPreScroll 传递给 NestedScrollingParent

  • NestedScrollingParentonNestedPreScroll 中接受到 dx 和 dy 并进行消费。并将消费掉的位移放入 int[] consumed 中,consumed 数组是一个长度为 2 的 int 类型数组,consumed[0] 代表 x 轴的消耗,consumed[1] 代表 y 轴的消耗

  • NestedScrollingChild 之后从 int[] consumed 数组中拿到 NestedScrollingParent 已经消费掉的位移,减去之后得到剩余的位移,再由自己消费

滑动位移传递方向由 child -> parent -> child,如下图。如果 child 是 Recyclerview ,它会先把位移给父布局消费,这时父布局滑动。当父布局滑动顶到不能滑动时,Recyclerview 这时会消费全部位移,这时它自己开始滑动,这样就形成了嵌套滑动,效果正如之前的例子中所看到的。

位移传递流程

dispatchNestedScrollonNestedScroll 的作用原理上述 preScroll 的方法类似,只不过这两个方法构造的嵌套滑动顺序和 preScroll 的相反,是子 View 先消费,子 View 消费不了的时候,再由父 View 再消费。

这套机制还支持 fling,在手指离开 view 的时候,即产生 ACITON_UP 事件时,child 将此时的 Velocity 转化为位移 dxdy,并重复之前的流程。通过 @NestedScrollType int type 的值来判断是 TYPE_TOUCH 还是 TYPE_NON_TOUCHTYPE_TOUCH 就是滑动, TYPE_NON_TOUCH 就是 fling。

Android 中哪些 View 使用了这套滑动机制?
  • 实现 NestedScrollingParent 接口的 View 有:NestedScrollViewCoordinatorLayoutMotionLayout

  • 实现 NestedScrollingChild 接口的 View 有:NestedScrollViewRecyclerView

  • NestedScrollView 是唯一同时实现两个接口的 View,这意味着它可以用作中介来实现多级嵌套滑动,后面会说到。

从上面可以看到,实际上,之前提到的 CoordinatorLayout 实现的嵌套滑动,本质上也是通过这套 NestedScrolling 接口来实现的。但是由于它封装得太好,我们没办法做过多定制。而直接使用这套接口,就可以根据自己的需求做定制。

大部分的场景中,我们不需要去实现 NestedScrollingChild 接口,因为 RecyclerView 已经做了这个实现,而涉及到嵌套滑动场景的子 View 基本也都是 RecyclerView。我们看看 RecyclerView 的相关源码:

public boolean onTouchEvent(MotionEvent e) {

case MotionEvent.ACTION_MOVE: {

// 计算 dx,dy

int dx = mLastTouchX - x;

int dy = mLastTouchY - y;

mReusableIntPair[0] = 0;

mReusableIntPair[1] = 0;

// 分发 preScroll

if (dispatchNestedPreScroll(

canScrollHorizontally ? dx : 0,

canScrollVertically ? dy : 0,

mReusableIntPair, mScrollOffset, TYPE_TOUCH

)) {

// 减去父 view 消费掉的位移

dx -= mReusableIntPair[0];

dy -= mReusableIntPair[1];

mNestedOffsets[0] += mScrollOffset[0];

mNestedOffsets[1] += mScrollOffset[1];

getParent().requestDisallowInterceptTouchEvent(true);

}

} break;

}

boolean scrollByInternal(int x, int y, MotionEvent ev) {

int unconsumedX = 0;

int unconsumedY = 0;

int consumedX = 0;

int consumedY = 0;

if (mAdapter != null) {

mReusableIntPair[0] = 0;

mReusableIntPair[1] = 0;

// 先消耗掉自己的 scroll

scrollStep(x, y, mReusableIntPair);

consumedX = mReusableIntPair[0];

consumedY = mReusableIntPair[1];

// 计算剩余的量

unconsumedX = x - consumedX;

unconsumedY = y - consumedY;

}

mReusableIntPair[0] = 0;

mReusableIntPair[1] = 0;

// 分发 nestedScroll 给父 View,顺序和 preScroll 刚好相反

dispatchNestedScroll(consumedX, consumedY, unconsumedX, unconsumedY, mScrollOffset,

TYPE_TOUCH, mReusableIntPair);

unconsumedX -= mReusableIntPair[0];

unconsumedY -= mReusableIntPair[1];

}

RecyclerView 是怎么调到父 View 的 onNestedPreSrollonNestedScroll 的呢?分析一下 dispatchNestedPreScroll 的代码,如下,dispatchNestedScroll 的代码原理和此类似,不再贴出:

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

int type) {

return getScrollingChildHelper().dispatchNestedPreScroll(dx, dy, consumed, offsetInWindow,type);

}

// NestedScrollingChildHelper.java

public boolean dispatchNestedPreScroll(int dx, int dy, @Nullable int[] consumed,

@Nullable int[] offsetInWindow, @NestedScrollType int type) {

if (isNestedScrollingEnabled()) {

final ViewParent parent = getNestedScrollingParentForType(type);

if (parent == null) {

return false;

}

if (dx != 0 || dy != 0) {

consumed[0] = 0;

consumed[1] = 0;

ViewParentCompat.onNestedPreScroll(parent, mView, dx, dy, consumed, type);

}

}

return false;

}

// ViewCompat.java

public static void onNestedPreScroll(ViewParent parent, View target, int dx, int dy,

int[] consumed, int type) {

if (parent instanceof NestedScrollingParent2) {

// First try the NestedScrollingParent2 API

((NestedScrollingParent2) parent).onNestedPreScroll(target, dx, dy, consumed, type);

} else if (type == ViewCompat.TYPE_TOUCH) {

// Else if the type is the default (touch), try the NestedScrollingParent API

if (Build.VERSION.SDK_INT >= 21) {

try {

parent.onNestedPreScroll(target, dx, dy, consumed);

} catch (AbstractMethodError e) {

Log.e(TAG, "ViewParent " + parent + " does not implement interface "

  • “method onNestedPreScroll”, e);

}

} else if (parent instanceof NestedScrollingParent) {

((NestedScrollingParent) parent).onNestedPreScroll(target, dx, dy, consumed);

}

}

}

可以看到,RecyclerView 通过一个代理类 NestedScrollingChildHelper 完成滑动分发,最后交给 ViewCompat 的静态方法来让父 View 处理 onNestedPreScrollViewCompat 的主要作用是用来兼容不同版本的滑动接口。

实现 onNestedPreScroll 方法

从上面的代码可以清楚地看到 RecyclerView 对于 NestedScrollingChild 的实现,以及触发嵌套滑动的时机。如果我们要实现嵌套滑动,并且内部的滑动子 View 是 RecyclerView,那么只需要让外层的父 View 实现 NestedScrollingParent 的方法就行了,比如在 onNestedPreScroll 方法中,

@Override

public void onNestedPreScroll(@NonNull View target, int dx, int dy, @NonNull int[] consumed, int type) {

// 滑动 dy 距离

scrollBy(0, dy);

// 将消耗掉的 dy 放入 consumed 数组通知子 view

consumed[1] = dy;

}

这样就实现了最简单的嵌套滑动。当然,实际情况中,还要对滑动距离进行判断,不能让父 View 一直消费子 View 的位移。

关于 Nested

《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》

【docs.qq.com/doc/DSkNLaERkbnFoS0ZF】 完整内容开源分享

ScrollView

NestedScrollView 这样的类,由于它内部实现了 onNestedScroll,所以在下滑时,它能在内部的 RecyclerView 下滑直到列表顶端时,外层继续下滑而不用抬起手指。另外也实现了 onNestedPreScroll方法,只不过它在该方法中把滑动继续向上传递,自己没有消费,如下代码:

// NestedScrollView.java

public void onNestedPreScroll(@NonNull View target, int dx, int dy, @NonNull int[] consumed,

int type) {

// 只分发了 preScroll 自己并没有消费。之所以能分发是因为 NestedScrollView 同时实现了 NestedScrollingChild 接口

dispatchNestedPreScroll(dx, dy, consumed, null, type);

}

@Override

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

int type) {

return mChildHelper.dispatchNestedPreScroll(dx, dy, consumed, offsetInWindow, type);

}

// NestedScrollingChildHelper.java

public boolean dispatchNestedPreScroll(int dx, int dy, @Nullable int[] consumed,

@Nullable int[] offsetInWindow, @NestedScrollType int type) {

if (isNestedScrollingEnabled()) {

final ViewParent parent = getNestedScrollingParentForType(type);

if (parent == null) {

return false;

}

if (dx != 0 || dy != 0) {

consumed[0] = 0;

consumed[1] = 0;

ViewParentCompat.onNestedPreScroll(parent, mView, dx, dy, consumed, type);

}

}

return false;

}

所以如果直接在 RecyclerView 的外层套 NestedScrollView 是没有办法实现完整的嵌套滑动的,你会发现在上滑的时候,没有嵌套滑动的效果,而下滑的时候有嵌套滑动的效果。

没有考虑到的问题

其实,在之前所说的内容中,默认了手指从子 Viw 开始滑动。假如手指从外层的父 View 开始滑动,当父 View fling 到顶后,子 View 是无法继续 fling,会立马停住,无法实现连贯的嵌套滑动。

这是因为嵌套滑动组件中,位移的消费只能从 NestedScrollingChildNestedScrollingParent,而不能从 NestedScrollingParentNestedScrollingChild ,因为只有 NestedScrollingChild 才能 dispatch,NestedScrollingParent 不能 dispatch。

如果想要实现从 NestedScrollingParentNestedScrollingChild 连贯的滑动,暂时没有特别好的办法,只能重写父 View 的事件分发,将父 View 滑动到顶后剩余的位移手动分发给它的子 View。(先挖个坑,看看有没有更好的办法,可以通过扩展嵌套滑动组件达到目的)

Tips

NestedScrollingParentNestedScrollingChild 一共有 3 个版本。

最早的是 NestedScrollingParentNestedScrollingChild,这一套接口把 scroll 和 fling 分别进行处理,造成了不必要的复杂性。

后来有了 NestedScrollingParent2NestedScrollingChild2 继承自一代,不过它将 fling 转化为 scroll 的距离统一进行处理。上述的嵌套滑动组件均指二代。

再后来又有了 NestedScrollingParent3NestedScrollingChild 继承自二代,它们相比于 2 代增加了 dispatchNestedScrollonNestedScroll 消耗部分滑动位移的功能,即在父 View 消耗位移之后,将消耗值放入 consumed 数组通知子 View。而二代是不会让子 View 知道父 View 的消耗值的。一般来说,要自己实现嵌套滑动,只需要实现 2 代及以上接口即可。一代基本不再使用。

注意:使用 NestedScrollView 有一个地方需要注意,当它的子 View 是 RecyclerView 这种 content 可以无限长的布局时,要注意限制这些子 View 的高度,不要使用 wrap_content 设置 RecyclerView 的高度。因为 NestedScrollView 在测量时给子 View 的限制是 UNSPECIFIED ,即不做限制,RecyclerView 想要多高就有多高。像 RecyclerView 如果内部 item 数量太多,RecyclerView 在 wrap_content 的情况下会把所有 item 都显示出来,相当于没有回收。这样会对内存造成很大消耗。如果调用 setVisibility 改变可见性的话,当从不可见到可见,更是会瞬间调用所有 item 的测量布局流程,造成卡顿。这是我在项目中实际遇到的问题。

三、多级嵌套滑动

我们知道了 NestedScrollingParentNestedScrollingChild可以用来定制化地实现自己地嵌套滑动。很容易想到,如果一个 View 同时实现了两个接口,那么它既可以接受 child 的滑动,又可以分发滑动给 parent,这样就形成了一个链条。而多级嵌套滑动的核心原理就来自于此,如图:

image-20210304170155409.png

原理其实并不复杂,下面用伪代码表示一下:

  • 对于 NestedScrollingParent

@Override

public void onNestedPreScroll(@NonNull View target, int dx, int dy, @NonNull int[] consumed, int type) {

scrollByMe(dx, dy);

consumed[0] = dxConsumed;

consumed[1] = dyConsumed;

}

  • 对于中介者,即同时实现了 NestedScrollingParentNestedScrollingChild 的中间 View 来说

@Override

public void onNestedPreScroll(@NonNull View target, int dx, int dy, @NonNull int[] consumed, int type) {

// 先分发,再消费。当然也可以先以先消费,再分发,这取决于业务

dispatchNestedPreScroll(dispatchNestedPreScroll(dx, dy, consumed, null, type);

int dx -= consumed[0];

int dy -= consumed[1];

这篇关于Android 嵌套滑动总结,kotlin框架的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!