IssueTracker

Re comment#33, try the solution from comment#18 - using NestedScrollableHost directly.

If that doesn't work, check out what it does and follow a similar pattern, the key is wrapping an element in a ViewGroup (e.g. FrameLayout) and calling requestDisallowInterceptTouchEvent when appropriate. In case it requires a custom solution like this, share it here so others can benefit.

Before recommending migration from ViewPager documentation must declare features removed - like nested scroll, scroll interpolators, ability to use Adapter not bound to RecyclerView. It's total pita to restore current functionality provided by ViewPager by default :(

I was unable to get horizontal scrolls with NestedScrollableHost to work when I had ViewPager2 (H) > ViewPager2 (V) > ViewPager2 (H) because it would only check to see if the immediate ancestor ViewPager2 would scroll in the same direction. I made a modification to solve this issue, which checks all ancestor ViewPager2s.

package live.spin.ui.main

/*
 * Copyright 2019 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import android.content.Context
import android.util.AttributeSet
import android.view.MotionEvent
import android.view.View
import android.view.ViewConfiguration
import android.widget.FrameLayout
import androidx.viewpager2.widget.ViewPager2
import androidx.viewpager2.widget.ViewPager2.ORIENTATION_HORIZONTAL
import kotlin.math.absoluteValue
import kotlin.math.sign

/**
 * Based on https://github.com/android/views-widgets-samples/blob/master/ViewPager2/app/src/main/java/androidx/viewpager2/integration/testapp/NestedScrollableHost.kt
 * but modified by Seth Westphal (westy92@gmail.com) to support nested ViewPager2.
 */

/**
 * Layout to wrap a scrollable component inside a ViewPager2. Provided as a solution to the problem
 * where pages of ViewPager2 have nested scrollable elements that scroll in the same direction as
 * ViewPager2. The scrollable element needs to be the immediate and only child of this host layout.
 *
 * This solution has limitations when using multiple levels of nested scrollable elements
 * (e.g. a horizontal RecyclerView in a vertical RecyclerView in a horizontal ViewPager2).
 */
class NestedScrollableHost : FrameLayout {
    constructor(context: Context) : super(context)
    constructor(context: Context, attrs: AttributeSet?) : super(context, attrs)

    private var touchSlop = 0
    private var initialX = 0f
    private var initialY = 0f
    private val ancestorViewPagers: List<ViewPager2>
        get() {
            val ancestors = mutableListOf<ViewPager2>()
            var v: View? = parent as? View
            while (v != null) {
                if (v is ViewPager2) ancestors.add(v)
                v = v.parent as? View
            }
            return ancestors
        }

    private val child: View? get() = if (childCount > 0) getChildAt(0) else null

    init {
        touchSlop = ViewConfiguration.get(context).scaledTouchSlop
    }

    private fun canChildScroll(orientation: Int, delta: Float): Boolean {
        val direction = -delta.sign.toInt()
        return when (orientation) {
            0 -> child?.canScrollHorizontally(direction) ?: false
            1 -> child?.canScrollVertically(direction) ?: false
            else -> throw IllegalArgumentException()
        }
    }

    override fun onInterceptTouchEvent(e: MotionEvent): Boolean {
        handleInterceptTouchEvent(e)
        return super.onInterceptTouchEvent(e)
    }

    private fun handleInterceptTouchEvent(e: MotionEvent) {
        for (ancestor in ancestorViewPagers) {
            val orientation = ancestor.orientation

            // Early return if child can't scroll in same direction as parent
            if (!canChildScroll(orientation, -1f) && !canChildScroll(orientation, 1f)) {
                continue
            }

            if (e.action == MotionEvent.ACTION_DOWN) {
                initialX = e.x
                initialY = e.y
                parent.requestDisallowInterceptTouchEvent(true)
            } else if (e.action == MotionEvent.ACTION_MOVE) {
                val dx = e.x - initialX
                val dy = e.y - initialY
                val isVpHorizontal = orientation == ORIENTATION_HORIZONTAL

                // assuming ViewPager2 touch-slop is 2x touch-slop of child
                val scaledDx = dx.absoluteValue * if (isVpHorizontal) .5f else 1f
                val scaledDy = dy.absoluteValue * if (isVpHorizontal) 1f else .5f

                if (scaledDx > touchSlop || scaledDy > touchSlop) {
                    if (isVpHorizontal == (scaledDy > scaledDx)) {
                        // Gesture is perpendicular, allow all parents to intercept
                        parent.requestDisallowInterceptTouchEvent(false)
                    } else {
                        // Gesture is parallel, query child if movement in that direction is possible
                        if (canChildScroll(orientation, if (isVpHorizontal) dx else dy)) {
                            // Child can scroll, disallow all parents to intercept
                            parent.requestDisallowInterceptTouchEvent(true)
                        } else {
                            // Child cannot scroll, allow all parents to intercept
                            parent.requestDisallowInterceptTouchEvent(false)
                        }
                    }
                }
            }
        }
    }
}

westy92@gmail.com, thank you for sharing the adjusted NestedScrollableHost that takes multiple ViewPager2 ancestors into account. Would you be interested in porting that back to the AOSP codebase?

Yes, I'd be happy to! Feel free to email me information on where to start that process.

Unfortunately, the workaround #18 dose not suitable for the case that a ScrollerView or NestedScrollView that has the same orientation in a ViewPager2.
Any other solution will be appreciated.

Re #43. Finally I found a workaround after some modifications.
It also suitable for the following case: ViewPager2(V) -> NestedScrollView(V) -> RecyclerView(H) (See comments)

Just simply intercept events if child view do not need to scroll.
Also, don't change the touch slop since it seems that the ScrollView will consume the event which result in we can't receive enough move distance.
https://gist.github.com/liangchenhe55/25452c4bece3c18a1c5f5164c7089f1b

When sliding quickly, NestedScrollableHost.onInterceptTouchEvent will not be called, nested scrollable view cannot scroll to the edge.

If ViewPager2 is nested with an imageview that supports zooming/panning, and then quickly swipe after zooming in, the displayed image is only the width of the screen.

Hi

any update on this?

As many have written here, NestedScrollableHost workaround doesn't work for fast scrolling (even on the newest version 1.1.0). This would annoy users, so I went back to ViewPager.

Why fix obvious flaws when you can work on AI, AI, AI...