Android实现侧滑recycleView+CardVeiw卡片阴影效果

关于

  本篇主要实现侧滑菜单栏+卡片布局+无间距效果

效果图

  普通的侧滑删除（这不是本篇重点）

  主题卡片阴影的侧滑删除（间隙效果）

  主题卡片阴影的侧滑删除无间距效果

第一步，定义基本SlideRecyclerView

  定义侧滑删除的recycleView，网上一搜一大堆，这里就不做讲解了。基本上就是通过VelocityTracker判断是否有x坐标的移动，有则进行拦截处理事件。

class SlideRecyclerView : RecyclerView {
   
   
    /**滑动的itemView */
    private var mMoveView: ViewGroup? = null

    /**itemView中菜单控件宽度 */
    private var mMenuWidth = 0
    private var mVelocity: VelocityTracker? = null

    /**触碰时的首个横坐标 */
    private var mFirstX = 0

    /**触碰时的首个纵坐标 */
    private var mFirstY = 0

    /**触碰末次的横坐标 */
    private var mLastX = 0

    /**最小滑动距离 */
    private var mTouchSlop = 0
    private var mScroller: Scroller? = null


    /**是否正在水平滑动 */
    private var mMoving = false

    /**是否由onInterceptTouchEvent（）方法拦截 */
    private var mIntercepted = false

    constructor(context: Context?) : super(context!!) {
   
   
        init()
    }

    constructor(context: Context?, attrs: AttributeSet?) : super(
        context!!, attrs
    ) {
   
   
        init()
    }

    constructor(context: Context?, attrs: AttributeSet?, defStyle: Int) : super(
        context!!, attrs, defStyle
    ) {
   
   
        init()
    }

    private fun init() {
   
   
        mTouchSlop = ViewConfiguration.get(context).scaledTouchSlop
        mScroller = Scroller(context)
    }

    override fun onInterceptTouchEvent(e: MotionEvent): Boolean {
   
   
        val x = e.x.toInt()
        val y = e.y.toInt()
        addVelocityEvent(e)
        when (e.action) {
   
   
            MotionEvent.ACTION_DOWN -> {
   
   
                //若Scroller处于动画中，则终止动画
                if (!mScroller!!.isFinished) {
   
   
                    mScroller!!.abortAnimation()
                }
                mFirstX = x
                mFirstY = y
                mLastX = x
                //获取点击区域所在的itemView
                val view = findChildViewUnder(x.toFloat(), y.toFloat()) as ViewGroup?
                //在点击区域以外的itemView开着菜单，则关闭菜单并拦截该次触碰事件
                if (mMoveView != null && view !== mMoveView && mMoveView!!.scrollX != 0) {
   
   
                    closeMenu()
                    mIntercepted = true
                    return true
                }
                mMoveView = view
                //获取itemView中菜单的宽度（规定itemView中为两个子View）
                mMenuWidth = if (mMoveView != null && mMoveView!!.childCount == 2) {
   
   
                    mMoveView!!.getChildAt(1).width
                } else {
   
   
                    -1
                }
            }
            MotionEvent.ACTION_MOVE -> {
   
   
                mVelocity!!.computeCurrentVelocity(1000)
                val velocityX = Math.abs(mVelocity!!.xVelocity).toInt()
                val velocityY = Math.abs(mVelocity!!.yVelocity).toInt()
                val moveX = Math.abs(x - mFirstX)
                val moveY = Math.abs(y - mFirstY)
                //满足如下条件其一则判定为水平滑动：
                //1、水平速度大于竖直速度,且水平速度大于最小速度
                //2、水平位移大于竖直位移,且大于最小移动距离
                //必需条件：itemView菜单栏宽度大于0，且recyclerView处于静止状态（即并不在竖直滑动）
                val isHorizontalMove =
                    (Math.abs(velocityX) >= MINIMUM_VELOCITY && velocityX > velocityY || moveX > moveY
                            && moveX > mTouchSlop) && mMenuWidth > 0 && scrollState == 0
                if (isHorizontalMove) {
   
   
                    mIntercepted = true
                    return true
                }
            }
            MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
   
   
                releaseVelocity()
                //itemView以及其子view触发点击事件，菜单未关闭则直接关闭
                closeMenuNow()
            }
            else -> {
   
   
            }
        }
        return super.onInterceptTouchEvent(e)
    }


    override fun onTouchEvent(e: MotionEvent): Boolean {
   
   
        val x = e.x.toInt()
        val y = e.y.toInt()
        addVelocityEvent(e)
        when (e.action) {
   
   
            MotionEvent.ACTION_DOWN ->                 //若是通过onInterceptTouchEvent（）方法ACTION_DOWN拦截而来的，则丢弃此次事件
                if (mIntercepted) {
   
   
                    mIntercepted = false
                    return false
                }
            MotionEvent.ACTION_MOVE -> {
   
   
                mVelocity!!.computeCurrentVelocity(1000)
                val velocityX = Math.abs(mVelocity!!.xVelocity).toInt()
                val velocityY = Math.abs(mVelocity!!.yVelocity).toInt()
                val moveX = Math.abs(x - mFirstX)
                val moveY = Math.abs(y - mFirstY)
                val isHorizontalMove =
                    mIntercepted || mMoving || (Math.abs(velocityX) >= MINIMUM_VELOCITY && velocityX > velocityY
                            || moveX > moveY && moveX > mTouchSlop) && mMenuWidth > 0 && scrollState == 0
                if (isHorizontalMove) {
   
   
                    val dx = mLastX - x
                    //让itemView在规定区域随手指移动
                    if (mMoveView!!.scrollX + dx in 0..mMenuWidth) {
   
   
                        mMoveView!!.scrollBy(dx, 0)
                    }
                    mLastX = x
                    //设置正处于水平滑动状态
                    mMoving = true
                    mIntercepted = false
                    return true
                }
            }
            MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
   
   
                if (mMoving) {
   
   
                    mMoving = false
                    mVelocity!!.