如何在不使用ScrollView的情况下让RelativeLayout可滚动？

Hey there! Great question—let’s break down how to make your RelativeLayout scrollable without wrapping it in a ScrollView. Here are a couple of solid, practical approaches you can implement:

1. Custom Scrollable RelativeLayout with Scroller #

The most direct way is to create a custom subclass of RelativeLayout that handles touch gestures and scrolls itself using Android's built-in Scroller class. This gives you full control over the scrolling behavior.

First, create the custom view class:

import android.content.Context
import android.util.AttributeSet
import android.view.MotionEvent
import android.view.VelocityTracker
import android.widget.RelativeLayout
import android.widget.Scroller

class ScrollableRelativeLayout @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null,
    defStyleAttr: Int = 0
) : RelativeLayout(context, attrs, defStyleAttr) {

    private val scroller = Scroller(context)
    private var lastTouchY = 0f
    private var velocityTracker: VelocityTracker? = null

    override fun onTouchEvent(event: MotionEvent): Boolean {
        // Initialize or reuse VelocityTracker to handle fling gestures
        velocityTracker?.addMovement(event) ?: run {
            velocityTracker = VelocityTracker.obtain().apply { addMovement(event) }
        }

        when (event.action) {
            MotionEvent.ACTION_DOWN -> {
                // Stop any ongoing scroll animation when user touches the screen
                if (!scroller.isFinished) scroller.abortAnimation()
                lastTouchY = event.y
                return true // Claim the touch event
            }
            MotionEvent.ACTION_MOVE -> {
                // Calculate vertical scroll delta and apply it
                val deltaY = lastTouchY - event.y
                scrollBy(0, deltaY.toInt())
                lastTouchY = event.y
                return true
            }
            MotionEvent.ACTION_UP -> {
                velocityTracker?.apply {
                    computeCurrentVelocity(1000)
                    // Trigger fling animation based on touch velocity
                    scroller.fling(scrollX, scrollY, 0, -yVelocity.toInt(), 0, 0, -Int.MAX_VALUE, Int.MAX_VALUE)
                    invalidate()
                    recycle() // Clean up to avoid memory leaks
                }
                velocityTracker = null
                return true
            }
        }
        return super.onTouchEvent(event)
    }

    override fun computeScroll() {
        // Update scroll position during animation
        if (scroller.computeScrollOffset()) {
            scrollTo(scroller.currX, scroller.currY)
            invalidate()
        }
    }

    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
        // Measure children without restricting them to parent height
        super.onMeasure(widthMeasureSpec, MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED))
        // Set parent height to match container, but allow children to be taller
        val parentHeight = MeasureSpec.getSize(heightMeasureSpec)
        setMeasuredDimension(measuredWidth, minOf(measuredHeight, parentHeight))
    }

    // Prevent over-scrolling beyond content bounds
    override fun scrollTo(x: Int, y: Int) {
        val maxScrollY = maxOf(0, measuredHeight - height)
        val clampedY = y.coerceIn(-maxScrollY, 0)
        super.scrollTo(x, clampedY)
    }
}

Then replace your regular RelativeLayout in XML with this custom class:

<com.yourpackage.ScrollableRelativeLayout
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <!-- Add your child views here—make sure their total height exceeds the parent to enable scrolling -->

</com.yourpackage.ScrollableRelativeLayout>

Key Notes for This Approach: #

• The onMeasure override ensures your layout doesn't force children to fit within the parent's height (critical for scrolling).
• The scrollTo clamp prevents users from scrolling past the top or bottom of your content.
• VelocityTracker adds natural fling behavior, making the scroll feel smooth.

2. Simplified Touch Handling with GestureDetector #

If you want cleaner touch event code, use GestureDetector to handle scroll and fling callbacks automatically:

import android.content.Context
import android.util.AttributeSet
import android.view.GestureDetector
import android.view.MotionEvent
import android.widget.RelativeLayout
import android.widget.Scroller

class GestureScrollableRelativeLayout @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null,
    defStyleAttr: Int = 0
) : RelativeLayout(context, attrs, defStyleAttr) {

    private val scroller = Scroller(context)
    private val gestureDetector = GestureDetector(context, object : GestureDetector.SimpleOnGestureListener() {
        override fun onScroll(e1: MotionEvent?, e2: MotionEvent?, distanceX: Float, distanceY: Float): Boolean {
            scrollBy(0, distanceY.toInt())
            return true
        }

        override fun onFling(e1: MotionEvent?, e2: MotionEvent?, velocityX: Float, velocityY: Float): Boolean {
            scroller.fling(scrollX, scrollY, 0, velocityY.toInt(), 0, 0, -Int.MAX_VALUE, Int.MAX_VALUE)
            invalidate()
            return true
        }
    })

    override fun onTouchEvent(event: MotionEvent): Boolean {
        return gestureDetector.onTouchEvent(event) || super.onTouchEvent(event)
    }

    override fun computeScroll() {
        if (scroller.computeScrollOffset()) {
            scrollTo(scroller.currX, scroller.currY)
            invalidate()
        }
    }

    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
        super.onMeasure(widthMeasureSpec, MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED))
        val parentHeight = MeasureSpec.getSize(heightMeasureSpec)
        setMeasuredDimension(measuredWidth, minOf(measuredHeight, parentHeight))
    }

    override fun scrollTo(x: Int, y: Int) {
        val maxScrollY = maxOf(0, measuredHeight - height)
        val clampedY = y.coerceIn(-maxScrollY, 0)
        super.scrollTo(x, clampedY)
    }
}

This approach delegates touch logic to GestureDetector, which handles edge cases like scroll thresholds and velocity calculations out of the box.

Important Considerations #

• Child View Interaction: If your layout has clickable/scrollable children (buttons, EditTexts), override onInterceptTouchEvent to decide when the parent should take over the touch event. For example, intercept only when the user is scrolling vertically and the child isn't handling the gesture.
• Performance: Both methods use efficient Android framework classes, but always recycle VelocityTracker and avoid unnecessary invalidations.
• Over-Scroll Effects: To add glow or bounce effects when scrolling beyond bounds, override overScrollBy to customize the behavior.

内容的提问来源于stack exchange，提问作者Andrea Bassi