[Android 从零到一] Custom View 触摸反馈与手势冲突解决

Android 从零到一：Custom View 触摸反馈与手势冲突解决

在自定义 View 开发中，触摸反馈和手势冲突是两个绕不开的话题。用户点击没反应、滑动卡顿、父子 View 抢事件，这些问题在复杂交互场景中频繁出现。本文从触摸反馈的视觉呈现到多层级手势冲突的系统化解决方案，带你建立完整的交互处理思路。

触摸反馈：让用户感知到"点击生效了"

状态列表 Drawable：最快的反馈方案

Android 提供 StateListDrawable 让 View 在不同状态下自动切换背景：

xml 复制代码

<!-- res/drawable/button_background.xml -->
<selector xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:state_pressed="true" android:drawable="@color/blue_pressed"/>
    <item android:state_enabled="false" android:drawable="@color/gray_disabled"/>
    <item android:drawable="@color/blue_normal"/>
</selector>

在自定义 View 中启用状态：

kotlin 复制代码

class CustomButton @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null
) : View(context, attrs) {
    
    init {
        isClickable = true // 必须设置，否则 pressed 状态不生效
        background = ContextCompat.getDrawable(context, R.drawable.button_background)
    }
}

关键点 ：必须设置 isClickable = true 或 isFocusable = true，否则 View 不会进入 pressed 状态。

代码控制反馈：drawableState 定制

当需要更复杂的状态（如 loading、selected + pressed 组合），可以重写 onCreateDrawableState：

kotlin 复制代码

class StatusIndicator @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null
) : View(context, attrs) {
    
    var isLoading = false
        set(value) {
            field = value
            refreshDrawableState() // 刷新状态
        }
    
    override fun onCreateDrawableState(extraSpace: Int): IntArray {
        val drawableState = super.onCreateDrawableState(extraSpace + 1)
        if (isLoading) {
            mergeDrawableStates(drawableState, STATE_LOADING)
        }
        return drawableState
    }
    
    companion object {
        private val STATE_LOADING = intArrayOf(R.attr.state_loading)
    }
}

对应的 selector：

xml 复制代码

<selector>
    <item app:state_loading="true" android:drawable="@drawable/ic_loading"/>
    <item android:state_pressed="true" android:drawable="@color/blue_pressed"/>
    <item android:drawable="@color/blue_normal"/>
</selector>

属性动画反馈：更流畅的视觉体验

状态切换可能生硬，结合属性动画提升体验：

kotlin 复制代码

override fun setPressed(pressed: Boolean) {
    super.setPressed(pressed)
    
    animate().cancel()
    animate()
        .scaleX(if (pressed) 0.95f else 1f)
        .scaleY(if (pressed) 0.95f else 1f)
        .alpha(if (pressed) 0.8f else 1f)
        .setDuration(100)
        .start()
}

注意：setPressed 会在触摸事件中频繁调用，动画要轻量，避免创建大量对象。

手势冲突：父子 View 的事件争夺战

冲突场景：ScrollView 里的自定义滑块

典型场景：ScrollView 包含一个可横向滑动的自定义 SeekBar，用户横向滑动时 ScrollView 也跟着滚动。

原因：默认情况下，子 View 消费不了的事件会传递给父 View。

解决方案一：requestDisallowInterceptTouchEvent

子 View 在需要独占事件时，通知父 View "别拦截我"：

kotlin 复制代码

class HorizontalSeekBar @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null
) : View(context, attrs) {
    
    private var isDragging = false
    
    override fun onTouchEvent(event: MotionEvent): Boolean {
        when (event.action) {
            MotionEvent.ACTION_DOWN -> {
                isDragging = true
                parent.requestDisallowInterceptTouchEvent(true) // 通知父 View
                return true
            }
            MotionEvent.ACTION_MOVE -> {
                if (isDragging) {
                    // 处理滑动逻辑
                    updateProgress(event.x)
                    return true
                }
            }
            MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
                isDragging = false
                parent.requestDisallowInterceptTouchEvent(false) // 归还控制权
                return true
            }
        }
        return super.onTouchEvent(event)
    }
    
    private fun updateProgress(x: Float) {
        val progress = (x / width).coerceIn(0f, 1f)
        // 更新进度并刷新
        invalidate()
    }
}

关键点：

ACTION_DOWN 时立即请求独占，避免父 View 提前拦截
ACTION_UP 或 ACTION_CANCEL 时释放独占，恢复父 View 的滑动能力

解决方案二：父 View 的智能拦截逻辑

如果需要父 View 根据滑动方向判断是否拦截，可以重写 onInterceptTouchEvent：

kotlin 复制代码

class SmartScrollView @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null
) : ScrollView(context, attrs) {
    
    private var lastX = 0f
    private var lastY = 0f
    
    override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
        when (ev.action) {
            MotionEvent.ACTION_DOWN -> {
                lastX = ev.x
                lastY = ev.y
                // 不拦截 DOWN 事件，让子 View 有机会处理
                return false
            }
            MotionEvent.ACTION_MOVE -> {
                val dx = abs(ev.x - lastX)
                val dy = abs(ev.y - lastY)
                
                // 如果竖向滑动距离大于横向，拦截事件自己处理
                if (dy > dx && dy > touchSlop) {
                    return true
                }
            }
        }
        return super.onInterceptTouchEvent(ev)
    }
    
    private val touchSlop by lazy {
        ViewConfiguration.get(context).scaledTouchSlop
    }
}

关键点：

用 touchSlop 作为滑动判定阈值，避免误判
横向滑动时返回 false，让子 View 继续处理
竖向滑动时返回 true，拦截事件交给自己的 onTouchEvent

多层嵌套：ViewPager2 + RecyclerView + 自定义滑动卡片

更复杂的场景：ViewPager2（横向翻页） → RecyclerView（竖向列表） → 横向滑动卡片。

策略：越底层的 View 越早请求独占，但需要精确判断用户意图。

kotlin 复制代码

class SwipeableCard @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null
) : FrameLayout(context, attrs) {
    
    private var initialX = 0f
    private var initialY = 0f
    private var hasDeterminedScrollDirection = false
    private var isHorizontalScroll = false
    
    override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
        when (ev.action) {
            MotionEvent.ACTION_DOWN -> {
                initialX = ev.x
                initialY = ev.y
                hasDeterminedScrollDirection = false
                return false
            }
            MotionEvent.ACTION_MOVE -> {
                if (!hasDeterminedScrollDirection) {
                    val dx = abs(ev.x - initialX)
                    val dy = abs(ev.y - initialY)
                    
                    if (dx > touchSlop || dy > touchSlop) {
                        hasDeterminedScrollDirection = true
                        isHorizontalScroll = dx > dy
                        
                        if (isHorizontalScroll) {
                            // 横向滑动，请求父 View 不拦截
                            parent.requestDisallowInterceptTouchEvent(true)
                            return true // 拦截事件，交给自己的 onTouchEvent
                        }
                    }
                }
            }
            MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
                parent.requestDisallowInterceptTouchEvent(false)
            }
        }
        return false
    }
    
    override fun onTouchEvent(event: MotionEvent): Boolean {
        if (isHorizontalScroll) {
            when (event.action) {
                MotionEvent.ACTION_MOVE -> {
                    val offsetX = event.x - initialX
                    translationX = offsetX
                    return true
                }
                MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
                    // 根据滑动距离决定是否关闭卡片
                    if (abs(translationX) > width / 3) {
                        animateRemove()
                    } else {
                        animate().translationX(0f).setDuration(200).start()
                    }
                    return true
                }
            }
        }
        return super.onTouchEvent(event)
    }
    
    private fun animateRemove() {
        animate()
            .translationX(width * if (translationX > 0) 1f else -1f)
            .alpha(0f)
            .setDuration(300)
            .withEndAction { visibility = View.GONE }
            .start()
    }
    
    private val touchSlop by lazy {
        ViewConfiguration.get(context).scaledTouchSlop
    }
}

设计思路：

在 onInterceptTouchEvent 中判断方向，而不是 onTouchEvent
一旦确定为横向滑动，立即请求独占并拦截后续事件
竖向滑动时不拦截，让 RecyclerView 正常滚动

边界情况处理

ACTION_CANCEL 的正确响应

当父 View 决定拦截事件时，会向子 View 发送 ACTION_CANCEL，此时子 View 必须清理状态：

kotlin 复制代码

override fun onTouchEvent(event: MotionEvent): Boolean {
    when (event.action) {
        MotionEvent.ACTION_CANCEL -> {
            // 取消动画、重置状态
            animate().cancel()
            translationX = 0f
            alpha = 1f
            isDragging = false
            parent.requestDisallowInterceptTouchEvent(false)
            return true
        }
    }
    return super.onTouchEvent(event)
}

多指触控：处理 MotionEvent.ACTION_POINTER_DOWN

用户可能先单指滑动，再用另一只手指点击其他区域，此时需要根据 actionIndex 判断是否继续处理：

kotlin 复制代码

override fun onTouchEvent(event: MotionEvent): Boolean {
    when (event.actionMasked) {
        MotionEvent.ACTION_DOWN -> {
            activePointerId = event.getPointerId(0)
            lastX = event.x
            return true
        }
        MotionEvent.ACTION_POINTER_DOWN -> {
            // 有新手指按下，如果需要取消当前操作：
            parent.requestDisallowInterceptTouchEvent(false)
            isDragging = false
            return false
        }
        MotionEvent.ACTION_MOVE -> {
            val index = event.findPointerIndex(activePointerId)
            if (index == -1) return false // 追踪的手指已抬起
            
            val x = event.getX(index)
            // 继续处理滑动
        }
    }
    return super.onTouchEvent(event)
}

private var activePointerId = MotionEvent.INVALID_POINTER_ID

工程化建议

可视化调试：打印事件分发日志

在复杂嵌套场景中，用日志追踪事件流向：

kotlin 复制代码

override fun dispatchTouchEvent(ev: MotionEvent): Boolean {
    Log.d("TouchDebug", "${javaClass.simpleName} dispatchTouchEvent: ${ev.actionToString()}")
    return super.dispatchTouchEvent(ev)
}

override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
    val result = super.onInterceptTouchEvent(ev)
    Log.d("TouchDebug", "${javaClass.simpleName} onInterceptTouchEvent: ${ev.actionToString()} -> $result")
    return result
}

private fun MotionEvent.actionToString(): String = when (actionMasked) {
    MotionEvent.ACTION_DOWN -> "DOWN"
    MotionEvent.ACTION_MOVE -> "MOVE"
    MotionEvent.ACTION_UP -> "UP"
    MotionEvent.ACTION_CANCEL -> "CANCEL"
    else -> "OTHER($action)"
}

封装手势工具类：减少重复代码

kotlin 复制代码

class GestureInterceptor(
    private val view: View,
    private val onHorizontalScroll: (dx: Float) -> Unit,
    private val onScrollEnd: () -> Unit
) {
    
    private var initialX = 0f
    private var initialY = 0f
    private var isIntercepting = false
    private val touchSlop = ViewConfiguration.get(view.context).scaledTouchSlop
    
    fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
        when (ev.action) {
            MotionEvent.ACTION_DOWN -> {
                initialX = ev.x
                initialY = ev.y
                isIntercepting = false
                return false
            }
            MotionEvent.ACTION_MOVE -> {
                if (!isIntercepting) {
                    val dx = abs(ev.x - initialX)
                    val dy = abs(ev.y - initialY)
                    if (dx > touchSlop && dx > dy) {
                        isIntercepting = true
                        view.parent.requestDisallowInterceptTouchEvent(true)
                        return true
                    }
                }
            }
        }
        return false
    }
    
    fun onTouchEvent(ev: MotionEvent): Boolean {
        if (isIntercepting) {
            when (ev.action) {
                MotionEvent.ACTION_MOVE -> {
                    onHorizontalScroll(ev.x - initialX)
                    return true
                }
                MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
                    onScrollEnd()
                    view.parent.requestDisallowInterceptTouchEvent(false)
                    isIntercepting = false
                    return true
                }
            }
        }
        return false
    }
}

使用时：

kotlin 复制代码

class MyCustomView : View {
    private val gestureInterceptor = GestureInterceptor(
        view = this,
        onHorizontalScroll = { dx -> translationX = dx },
        onScrollEnd = { animateToFinalPosition() }
    )
    
    override fun onInterceptTouchEvent(ev: MotionEvent) = 
        gestureInterceptor.onInterceptTouchEvent(ev)
    
    override fun onTouchEvent(ev: MotionEvent) = 
        gestureInterceptor.onTouchEvent(ev) || super.onTouchEvent(ev)
}

小结

触摸反馈和手势冲突看似独立，实则共同决定用户交互体验。触摸反馈让用户感知到操作生效，手势冲突解决确保复杂嵌套场景下事件准确传递。掌握 requestDisallowInterceptTouchEvent 的时机、onInterceptTouchEvent 的判断逻辑、ACTION_CANCEL 的清理责任，就能应对大多数自定义 View 的交互挑战。遇到问题时，先用日志追踪事件流向，再逐层调整拦截策略，最终建立稳定可维护的触摸处理机制。