RecyclerView嵌套滑动冲突方案
图一
如图： 外层RecyclerView的第29条(最后一条）item是一个RecyclerView。
内部RecyclerView的touch 和 fling事件都被外部RecyclerView拦截，消费。
目标1： 当向上滚动时，外层RecycelerView可以向上滚动，外层优先滚动。 外层不能滚动了，内层滚动。
目标2：当向下滚动时，内层RecyclerView可以向下滚动，内层优先滚动。内层不能滚动了，外层滚动。
事件流程
本文主要提供5种方案解决滑动冲突问题。
1、外层RecyclerView完全处理。
2、内层RecyclerView完全处理。
3、内层RecyclerView+外层Behavior处理。
4、外层RecyclerView+外层Behavior处理。
5、外层Behavior处理。
方案1和2只解决了touch事件，方案3、4、5不仅解决了touch事件，还解决了fling事件。其他的解决方案，比如内层RecyclerView处理一部分，外层RecyclerView处理一部分，相互协调解决。
第一种方案：外层RecyclerView处理
这种方案是在外层的RecyclerView中处理，所有的逻辑都是在外层RecyclerView中处理的。
1.1、场景： 如果手指向上滑动，如果外层还没有划出屏幕，需要外层先滑动。外层消费。
红色代表手指滑动，蓝色是代表消费。
外层Rv消费
1.2、接着场景1，手指继续向上滑动，此时外层已经划出屏幕了，此时需要内层Rv消费。但是内层Rv的dispatchTouchEvent，onInterceptTouchEvent接收不到事件，原因下面分析。
image.png
//外层RV
public boolean onInterceptTouchEvent(MotionEvent ev) {
switch (ev.getActionMasked()) {
case MotionEvent.ACTION_DOWN:
downY = ev.getY();
mStringBuilder.delete(0, mStringBuilder.length());
break;
case MotionEvent.ACTION_MOVE:
float currentY = ev.getY();
float diffY = downY - currentY;
downY = currentY;
if (innerRecyclerView != null) {
if (diffY > 0) {
if (canScrollVertically(1)) { 场景1
} else if (!canScrollVertically(1)) { 场景2
if (innerRecyclerView.canScrollVertically(1)) {
return false;
}
}
}
}
break;
return super.onInterceptTouchEvent(ev);
}
手指向上滑动，从场景1滑动，外层已经划出屏幕，此时到了场景2，如上代码场景2能调用到吗？ 如果能调用到到的话，return false，内部的Rv就可以消费这个事件。但是是调用不到的，原因是外层一旦消费，之后就不会走自己的拦截方法了。看下分发流程，Rv没有重写dispatchTouchEvent方法，直接调用了ViewGroup的dispatchTouchEvent方法。
//ViewGroup-dispatchTouchEvent
if (actionMasked == MotionEvent.ACTION_DOWN
|| mFirstTouchTarget != null) {
final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
if (!disallowIntercept) {
intercepted = onInterceptTouchEvent(ev);
ev.setAction(action); // restore action in case it was changed
} else {
intercepted = false;
}
}
走自己onInterceptTouchEvent的判断是，down事件和mFirstTouchTarget。mFirstTouchTarget只有子view消费的时候才会赋值，所以自己消费，这个值为null，这个判断进不去。onInterceptTouchEvent不会调用，所以上面代码中的场景2调用不到，事件被外层的RV消费了，所以我们只能在外层Rv的onTouchEvent方法中处理场景2了。
public boolean onTouchEvent(MotionEvent ev) {
switch (ev.getActionMasked()) {
case MotionEvent.ACTION_DOWN:
downY = ev.getY();
mStringBuilder.delete(0, mStringBuilder.length());
break;
case MotionEvent.ACTION_MOVE:
float currentY = ev.getY();
float diffY = downY - currentY;
downY = currentY;
if (innerRecyclerView != null) {
if (diffY > 0) {
if (!canScrollVertically(1)) {
if (innerRecyclerView.canScrollVertically(1)) {
innerRecyclerView.scrollBy(0, (int) diffY);
if (!mStringBuilder.toString().contains("1")) {
mStringBuilder.append("1");
}
return true;
}
}
}
}
}
}
这里直接调用内层RV滚动了，这样场景2touch事件处理完了。
1.3、场景3： 场景1滑动到场景2，场景2继续向上滑动。此时内部RV就开始滚动了，如下图滚动到item6的位置。此时不松手，手指向下滑动。
image.png
因为这些事件一直被外层RV消费的，它的拦截事件已经调用不到了，内层RV已经接收不到这些事件了，所以我们也只能在外层RV的onTouchEvent中处理。
public boolean onTouchEvent(MotionEvent ev) {
if (diffY < 0) {
if (innerRecyclerView.canScrollVertically(-1)) {
innerRecyclerView.scrollBy(0, (int) diffY);
if (!mStringBuilder.toString().contains("2")) {
mStringBuilder.append("2");
}
return true;
}
}
1.4、场景1到场景2，但是由于场景1是外层RV消费，场景2是内层外层滚动，导致外层最开始的点击位置和移动位置，相对于外层RV不准确，所以需要处理一下。
case MotionEvent.ACTION_MOVE:
if (mStringBuilder.toString().contains("2") || mStringBuilder.toString().contains("1")) {
ev.setAction(MotionEvent.ACTION_DOWN);
mStringBuilder.delete(0, mStringBuilder.length());
}
1.5、手指在内层RV向下滚动。
红色代表手指滑动位置和方向。 蓝色代表谁该消费。
image.png
场景4： 如上图： 如果内层RV可以向下滚动，内层RV先滚动。
image.png
场景5： 如上图： 内层RV不能向下滚动，则外层RV滚动。
public boolean onInterceptTouchEvent(MotionEvent ev) {
case MotionEvent.ACTION_MOVE:
float currentY = ev.getY();
float diffY = downY - currentY;
downY = currentY;
if (diffY < 0) {
if (innerRecyclerView.canScrollVertically(-1)) { 场景4
return false;
} else if (!innerRecyclerView.canScrollVertically(-1)) { 场景5
if (canScrollVertically(-1)) {
return super.onInterceptTouchEvent(ev);
}
}
}
}
}
场景4和场景5分别对应上述代码。 如果是各自独立事件，4和5都能被调用。
如果先是由场景4，继续向下下滑，不松手，是不能触发场景5的。为什么了？
RecyclerView-onTouchEvent
if (scrollByInternal(
canScrollHorizontally ? dx : 0,
canScrollVertically ? dy : 0,
e)) {
getParent().requestDisallowInterceptTouchEvent(true);
}
是因为内层RV滚动之后，外层RV就不能再调用onInterceptTouchEvent方法。所以解决办法，就是在dispatchTouchEvent方法中，调用requestDisallowInterceptTouchEvent(false)重置一下这个判断。也可以在内层RV中处理，方案一中的所有代码都是在外层中处理的，所以在dispatchTouchEvent中处理了，至此，通过外层处理了所有的滑动冲突。
方案一上述可能有些麻烦，因为想让内层RV自己可以消费自己的事件，只是部分冲突的事件，在外层调用内层RV去滚动了，没有将所有的事件都通过外层调用的形式。
第二种方案： 内层RecyclerView处理
这种方案，是事件全部在内层的RecyclerView中处理。我们知道事件全部被外层RecyclerView给拦截了，所以在内层，首先要请求外层RecyclerView不要去拦截。
override fun dispatchTouchEvent(ev: MotionEvent?): Boolean {
when (ev?.actionMasked) {
MotionEvent.ACTION_DOWN -> {
parent.requestDisallowInterceptTouchEvent(true)
}
MotionEvent.ACTION_MOVE -> {
var currentY = ev?.getY()
var diffY = touchDownY - currentY
if (diffY > 0) {
if (topRecyclerView?.canScrollVertically(1) == true) {
第一处：
// parent.requestDisallowInterceptTouchEvent(false)
} else if (topRecyclerView?.canScrollVertically(1) == false) {
if (!canScrollVertically(1)) {
第二处
// parent.requestDisallowInterceptTouchEvent(false)
}
}
} else if (diffY < 0) {
if (!canScrollVertically(-1)) {
第三处
// parent.requestDisallowInterceptTouchEvent(false)
}
}
MotionEvent.ACTION_UP -> {
parent.requestDisallowInterceptTouchEvent(false)
}
}
return super.dispatchTouchEvent(ev)
}
上述move中的三处都注释掉了，解释一下。
2.1、场景1
场景1
手指向上滑动，当外层可以滑动时，外层需要先滑动，requestDisallowInterceptTouchEvent(false)就会交给外层去处理，如果这样做了，外层不能向上滑动时，我们需要内层去滑动，由于事件交给了外层消费，之后的move，内层接收不到了，所以事件不能交给外层，所以外层滑动在内层的onTouchEvent中处理。
2.2、场景2、场景3中也都是这样的，不能把事件给外层，给外层了，之后的事件内层接收不到了。
场景1中，不能交给外层，所以在onTouchEvent中处理如下。调用外层Rv去滚动 topRecyclerView.scrollBy()。
override fun onTouchEvent(ev: MotionEvent?): Boolean {
var topRecyclerView = findRecyclerView(this)
when (ev?.action) {
MotionEvent.ACTION_MOVE -> {
if (diffY > 0) {
if (topRecyclerView?.canScrollVertically(1) == true) {
topRecyclerView.scrollBy(0, diffY.toInt())
}
} else if (diffY < 0) {
if (canScrollVertically(-1) == false) {
if (topRecyclerView?.canScrollVertically(-1) == true) {
topRecyclerView.scrollBy(0, diffY.toInt())
return true;
}
}
}
touchDownY = currentY;
}
MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
touchDownY = 0.0f
}
}
return super.onTouchEvent(ev);
}
第三种方案： 内层RecyclerView+外层Behavior处理
3.1、这种方案，就是内层能滚动的时候，内层滚动，内层不能滚动时，外层滚动，前面讲到，内层RecyclerView滚动时，处于拖拽状态，requestDisallowInterceptTouchEvent(true)，会导致外层的onInterceptTouchEvent不会调用，但是子类requestDisallowInterceptTouchEvent(false)，重置false，会导致外层的onInterceptTouchEvent可以调用到move事件等，也就是外层可以拦截。
override fun dispatchTouchEvent(ev: MotionEvent?): Boolean {
when (ev?.action) {
MotionEvent.ACTION_DOWN -> {
parent.requestDisallowInterceptTouchEvent(true)
downY = ev?.getY()
flag = false
}
MotionEvent.ACTION_MOVE -> {
var currentY = ev?.getY()
var diffY = downY - currentY
//内层不能向下滚动时，外层滚动。
if (!canScrollVertically(1) && diffY > 0) {
parent.requestDisallowInterceptTouchEvent(false)
//内层不能向上滚动式，外层滚动
} else if (!canScrollVertically(-1) && diffY < 0) {
parent.requestDisallowInterceptTouchEvent(false)
} else {
//内层可以向下或者向上滑动--内层消费
parent.requestDisallowInterceptTouchEvent(true)
}
}
MotionEvent.ACTION_UP -> {
parent.requestDisallowInterceptTouchEvent(false)
flag = false;
}
return dispatchTouchEvent;
}
}
return super.dispatchTouchEvent(ev)
}
3.2、外层Behavior处理。
public class ExternalRecyclerBehavior2 extends AppBarLayout.ScrollingViewBehavior {
private static final String TAG = "ExternalRecyclerBehavio";
@Override
public void onNestedPreScroll(@NonNull CoordinatorLayout coordinatorLayout, @NonNull View child, @NonNull View target, int dx, int dy, @NonNull int[] consumed, int type) {
super.onNestedPreScroll(coordinatorLayout, child, target, dx, dy, consumed, type);
if (dy > 0) {
//手指在内层滑动，但是上层还没有划出去，让上层先滑出去。
场景3
if (child != target && child.canScrollVertically(1)) {
child.scrollBy(0, dy);
consumed[1] = dy;
}
//手指在内层，滑动之前，先要把内层滑出来。
//场景，外层滑动到底部，然后向上滑，触发外层消费，再向下滑，触发内层消费。
} else if (dy < 0) {
//child == tartget = 外层rv
if (child == target) {
if (nestedRecyclerView != null && nestedRecyclerView.canScrollVertically(-1)) {
场景4
nestedRecyclerView.scrollBy(0, dy);
consumed[1] = dy;
}
}
}
}
@Override
public void onNestedScroll(@NonNull CoordinatorLayout coordinatorLayout, @NonNull View
child, @NonNull View target, int dxConsumed, int dyConsumed, int dxUnconsumed,
int dyUnconsumed, int type, @NonNull int[] consumed) {
super.onNestedScroll(coordinatorLayout, child, target, dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed, type, consumed);
//手指都在外层
if (target == child) {
if (dyConsumed == 0 && dyUnconsumed > 0) {
if (nestedRecyclerView != null && nestedRecyclerView.canScrollVertically(1)) {
场景1
nestedRecyclerView.scrollBy(0, dyUnconsumed);
} else {
consumed[1] = 0;
}
} else if (dyConsumed == 0 && dyUnconsumed < 0) {
if (!child.canScrollVertically(-1)) {
consumed[1] = 0;
}
}
//手指在内层
} else if (target != child) {
if (dyConsumed == 0 && dyUnconsumed > 0) {
if (!target.canScrollVertically(1)) {
consumed[1] = 0;
}
} else if (dyConsumed == 0 && dyUnconsumed < 0) {
if (child.canScrollVertically(-1)) {
场景2
child.scrollBy(0, dyUnconsumed);
} else {
consumed[1] = 0;
}
}
}
}
场景1 ： 手指在外层RV，向上滑动或者fling，外层已经不能滚动了，如果内层可以滑动，内层滚动。
场景2 ：手指在内层RV，向下滚动或者fling, 内层已经不能滚动了，如果外层可以滚动，外层滚动。
场景3：手指在内层RV, 向上滚动，外层还没有没有滚出屏幕，外层优先滚动。
场景4： 手指在外层RV，向下滚动。如果内层可以滚动，内层优先滚动。 这种场景怎么触发了。如下图
场景4.png
先上滑动，内层的RV已经不能滑动了，将事件交给了外层的RV，外层RV接管了事件，此时下滑，需要内部去滑动，所以这部分事件应该内部去消费，内层滚动。
第四种方案： 外层RecyclerView+外层Behavior处理
这种方案的behavior和第三种是一样的，只是事件拦截处理在外层RecyclerView。只要内层的RecyclerView可以滑动，就不拦截。
public boolean onInterceptTouchEvent(MotionEvent ev) {
Log.d(TAG, "onInterceptTouchEvent: ---");
RecyclerView innerRecyclerView = findNestedRecyclerView(getChildAt(getChildCount() - 1));
switch (ev.getActionMasked()) {
case MotionEvent.ACTION_DOWN:
downY = ev.getY();
//这个是为了，滑动到底，事件交给父。否则子recyclerview消费了事件。
if (innerRecyclerView != null && !innerRecyclerView.canScrollVertically(1)) {
return true;
}
break;
case MotionEvent.ACTION_MOVE:
float currentY = ev.getY();
float diffY = downY - currentY;
downY = currentY;
Log.d(TAG, "onInterceptTouchEvent: diffY = " + diffY);
if (innerRecyclerView != null && (innerRecyclerView.canScrollVertically(1) || innerRecyclerView.canScrollVertically(-1))) {
return false;
}
break;
}
return super.onInterceptTouchEvent(ev);
}
上述 在onInterceptTouchEvent的down return true，这个是为了，内层RecyclerView消费之后，父拿不到事件，只有dispatchTouchEvent会被调用，因此我们需要外层处理。
第五种方案：外层Behavior处理
这种方案将内部Behavior的滚动全部由外层RV控制，内层RV不接收任何事件。当然在外层拦截之前，down,move，内层还是能接收到的。外层拦截之后，之后的move事件全部由外层处理。
public class ExternalRecyclerBehavior1 extends AppBarLayout.ScrollingViewBehavior {
private static final String TAG = "ExternalRecyclerBehavio";
@Override
public void onNestedPreScroll(@NonNull CoordinatorLayout coordinatorLayout, @NonNull View child, @NonNull View target, int dx, int dy, @NonNull int[] consumed, int type) {
super.onNestedPreScroll(coordinatorLayout, child, target, dx, dy, consumed, type);
if (dy < 0) {
if (nestedRecyclerView != null && nestedRecyclerView.canScrollVertically(-1)) {
场景2
nestedRecyclerView.scrollBy(0, dy);
consumed[1] = dy;
}
}
}
@Override
public void onNestedScroll(@NonNull CoordinatorLayout coordinatorLayout, @NonNull View child, @NonNull View target, int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed, int type, @NonNull int[] consumed) {
super.onNestedScroll(coordinatorLayout, child, target, dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed, type, consumed);
if (dyConsumed == 0 && dyUnconsumed > 0) {
if (nestedRecyclerView != null && nestedRecyclerView.canScrollVertically(1)) {
场景1
nestedRecyclerView.scrollBy(0, dyUnconsumed);
} else {
consumed[1] = 0;
}
} else if (dyConsumed == 0 && dyUnconsumed < 0) {
if (!target.canScrollVertically(-1)) {
consumed[1] = 0;
}
}
}
}
5.1、场景1： 外层不能滚动了，内层可以滚动，内层滚动。
5.2、场景2： 如果内层可以滚动，优先滚动内层。
总结
方案1和方案2实现了Touch事件，fling事件没有解决，是因为RecyclerView内部监听滚动完成，就立刻停止了滚动，如果想要继续滚动内层或者外层，需要自己实现OverScroller逻辑。
方案3和方案4让内层RV可以自己分发，处理事件，通过外层behavior处理了内部RV和外部RV的滚动的临界点，处理Touch和fling事件。
方案五，让内层RV不能处理事件，只能外层处理事件，内层滚动是由外层去处理的。
