防手機鎖屏解鎖自定義View

丶淺鹹發表於2020-09-30

View

文章目錄

一、簡介

在Android應用開發的過程中，有的時候為了提高使用者留存，我們就會給應用加入鎖屏桌布的功能。鎖屏桌布解鎖的功能還是相對簡單，有很多種實現的方法，可以使用ObjectAnimator屬性動畫，也可以使用Scroller實現。

二、ObjectAnimator與Scroller實現比較

在寫鎖屏自定義View過程中，曾經嘗試過使用ObjectAnimator或Scroller兩種方式進行實現，不過在實際過程中發現還是Scroller實現比較好。如果使用ObjectAnimator實現鎖屏解鎖的話，有部分機型會出現滑動卡頓的情況，貌似oppo之類的手機就會卡頓。

三、 Scroller實現核心

1、鎖屏解鎖主要有兩個關鍵點

一是手指觸控手機滑動的時候，帶動頁面進行滑動。二是當手指離開螢幕的時候進行判斷解鎖成功還是失敗，成功時候要往上滑動到螢幕頂端進行解鎖，失敗重滑動到原來位置。至於解鎖成的條件主要看業務需求，可以是螢幕高度的40%，或者螢幕寬度的40%,主要取決於你是要水平方向滑動解鎖還是垂直方向滑動解鎖。

2、觸控手機滑動帶動頁面進行滑動

Scroller實現手指觸控手機帶動頁面滑動主要難點在於每次滑動的距離是多少，若使用onTouchEvent事件中ACTION_MOVE滑動的距離來作為頁面滑動距離，會產生卡頓的視覺效果。所以需要藉助手勢檢測器監聽器，在手勢檢測器的onScroll回撥中獲取滑動的距離，這樣頁面在滑動的時候就不會產生卡頓。下面貼出滑動實現程式碼：

	    //每次滑動的距離，整數代表向上滑，負數代表向下滑
    private fun beginScroll(dx: Int, dy: Int, duration: Int?) { 
        Loger.d("beginScroll", " mScroller!!.finalX : ${mScroller!!.finalX} mScroller!!.finalY : ${mScroller!!.finalY}  dx : $dx dy : $dy" )
        if (duration != null) {
            mScroller!!.startScroll(mScroller!!.finalX, mScroller!!.finalY, dx, dy, duration)
        } else {
            mScroller!!.startScroll(mScroller!!.finalX, mScroller!!.finalY, dx, dy)
        }
        //必須執行invalidate()從而呼叫computeScroll()
        invalidate()
    }

然後在手勢檢測器的onScroll回撥中呼叫(五種模式，分別是上下左右和同時支援上下滑動)

 override fun onScroll(e1: MotionEvent?, e2: MotionEvent?, distanceX: Float, distanceY: Float): Boolean {
     when (dragMode) {
         MODE_LEFT -> {
             beginScroll(distanceX.toInt(), 0, null)
         }

         MODE_RIGHT -> {
             beginScroll(distanceX.toInt(), 0, null)
         }

         MODE_UP -> {
             beginScroll(0, distanceY.toInt(), null)
         }

         MODE_DOWN -> {
             beginScroll(0, distanceY.toInt(), null)
         }

         MODE_UP_AND_DOWN -> {
             beginScroll(0, distanceY.toInt(), null)
         }
     }
     return false
 }

3、手指離開螢幕判斷是否解鎖成功

這個時候有兩種情況，解鎖成功或解鎖失敗，判斷的條件可以使用螢幕高度的40%，或者螢幕寬度的40%,主要取決於你是要水平方向滑動解鎖還是垂直方向滑動解鎖。滑動解鎖失敗或成功都要重新滑動到指定的位置，螢幕的頂端，或者恢復到原來位置。滑動到指定位置程式碼如下：

    //滾動到目標位置
  private fun prepareScroll(fx: Int, fy: Int, duration: Int?) {
      val dx = fx - mScroller!!.finalX
      val dy = fy - mScroller!!.finalY
      beginScroll(dx, dy, duration)
      Loger.d("prepareScroll", " mScroller!!.finalX : ${mScroller!!.finalX} mScroller!!.finalY : ${mScroller!!.finalY}" )
  }

當手指離開螢幕ACTION_UP時候呼叫，虛擬碼如下：

 MODE_UP_AND_DOWN -> {
                        //下滑
                        var height = mHeight
                        if (mCurrentOffsetY > 0) {
                            height = -mHeight
                        }

                        if ((abs(mCurrentOffsetY) >= mHeight * releasePercent)) {
                            prepareScroll(0, height, mAnimDuration.toInt())
                            isUnlock = true
                        } else {
                            prepareScroll(0, 0, mAnimDuration.toInt())
                            mDragListener?.onRestore()
                        }
                    }

4、記得重寫computeScroll方法讓滑動生效

    override fun computeScroll() {
      super.computeScroll()
      if (mScroller != null) {
          if (mScroller!!.computeScrollOffset()) {
              scrollTo(mScroller!!.currX, mScroller!!.currY)
              postInvalidate()
          } else {
              if (isUnlock) {
                  mDragListener?.onRelease()
              }
          }
      }

  }

四、 Scroller滑動實現自定義View的所有程式碼如下:

package com.qimiaoptu.camera.lockscreen

import android.content.Context
import android.util.AttributeSet
import android.view.GestureDetector
import android.view.MotionEvent
import android.view.View
import android.widget.FrameLayout
import android.widget.Scroller
import com.qimiaoptu.camera.photostar.ShareUtils
import kotlin.math.abs


/**
 * ┌───┐ ┌───┬───┬───┬───┐ ┌───┬───┬───┬───┐ ┌───┬───┬───┬───┐ ┌───┬───┬───┐
 * │Esc│ │ F1│ F2│ F3│ F4│ │ F5│ F6│ F7│ F8│ │ F9│F10│F11│F12│ │P/S│S L│P/B│ ┌┐    ┌┐    ┌┐
 * └───┘ └───┴───┴───┴───┘ └───┴───┴───┴───┘ └───┴───┴───┴───┘ └───┴───┴───┘ └┘    └┘    └┘
 * ┌──┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┐┌───┬───┬───┐┌───┬───┬───┬───┐
 * │~`│! 1│@ 2│# 3│$ 4│% 5│^ 6│& 7│* 8│( 9│) 0│_ -│+ =│ BacSp ││Ins│Hom│PUp││N L│ / │ * │ - │
 * ├──┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤├───┼───┼───┤├───┼───┼───┼───┤
 * │Tab │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │{ [│} ]│ | \ ││Del│End│PDn││ 7 │ 8 │ 9 │   │
 * ├────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤└───┴───┴───┘├───┼───┼───┤ + │
 * │Caps │ A │ S │ D │ F │ G │ H │ J │ K │ L │: ;│" '│ Enter  │             │ 4 │ 5 │ 6 │   │
 * ├─────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤    ┌───┐    ├───┼───┼───┼───┤
 * │Shift  │ Z │ X │ C │ V │ B │ N │ M │< ,│> .│? /│  Shift   │    │ ↑ │    │ 1 │ 2 │ 3 │   │
 * ├────┬──┴─┬─┴──┬┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤┌───┼───┼───┐├───┴───┼───┤ E││
 * │Ctrl│Ray │Alt │         Space         │ Alt│code│fuck│Ctrl││ ← │ ↓ │ → ││   0   │ . │←─┘│
 * └────┴────┴────┴───────────────────────┴────┴────┴────┴────┘└───┴───┴───┘└───────┴───┴───┘
 *
 * @author Rayhahah
 * @blog http://rayhahah.com
 * @time 2019/10/21
 * @tips 這個類是Object的子類
 * @fuction
 */

class DragView : FrameLayout, GestureDetector.OnGestureListener {

    companion object {
        /**
         * 向左滑動
         */
        const val MODE_LEFT = 0

        /**
         * 向右滑動
         */
        const val MODE_RIGHT = 1
        /**
         * 向上滑動
         */
        const val MODE_UP = 2
        /**
         * 向下滑動
         */
        const val MODE_DOWN = 3
        /**
         * 向上與向下同時相容
         */
        const val MODE_UP_AND_DOWN = 4
    }

    private var mHeight: Int = 0
    private var mWidth: Int = 0
    private var mDownX: Float = 0f
    private var mDownY: Float = 0f
    private var mCurrentX: Float = 0f
    private var mCurrentY: Float = 0f

    private var mCurrentOffsetX: Float = 0f
    private var mCurrentOffsetY: Float = 0f

    private var clickOffSet = 30
    private var moveOffSet = 5

    private var mWrapView: View? = null

    private var mAnimDuration: Long = 500
    private var mDragListener: onDragListener? = null

    var releasePercent: Float = 0.4f
        set(value) {
            field = value
            requestLayout()
            invalidate()
        }

    var dragMode: Int = MODE_UP_AND_DOWN
        set(value) {
            field = value
            requestLayout()
            invalidate()
        }

    private var mScroller: Scroller? = null
    private var mGestureDetector: GestureDetector? = null
    private var isUnlock = false

    constructor(context: Context) : this(context, null)
    constructor(context: Context, attrs: AttributeSet?) : this(context, attrs, 0)
    constructor(context: Context, attrs: AttributeSet?, defStyleAttr: Int) : super(
            context,
            attrs,
            defStyleAttr
    ) {
        mScroller = Scroller(context)
        // 初始化手勢檢測器
        mGestureDetector = GestureDetector(context, this)
    }

    override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
        super.onSizeChanged(w, h, oldw, oldh)
        mWidth = w
        mHeight = h
        mWrapView = getChildAt(0)
    }

    override fun onTouchEvent(ev: MotionEvent): Boolean {
        when (ev.action) {
            MotionEvent.ACTION_DOWN -> {
                mDownX = ev.x
                mDownY = ev.y
                mCurrentX = 0f
                mCurrentY = 0f
                mCurrentOffsetX = 0f
                mCurrentOffsetY = 0f

                return mGestureDetector?.onTouchEvent(ev)!!
            }
            MotionEvent.ACTION_MOVE -> {
                mCurrentX = ev.x
                mCurrentY = ev.y
                if (isMoving()) {
                    return super.onTouchEvent(ev)
                }

                mCurrentOffsetX = mCurrentX - mDownX
                mCurrentOffsetY = mCurrentY - mDownY

                when (dragMode) {
                    MODE_LEFT -> {
                        if ((mCurrentOffsetX < 0)) {
                            if ((abs(mCurrentOffsetX) >= (abs(mCurrentOffsetY) * 2))) {
                                return mGestureDetector?.onTouchEvent(ev)!!
                            }
                        }
                    }
                    MODE_RIGHT -> {
                        if ((mCurrentOffsetX > 0)) {
                            if ((abs(mCurrentOffsetX) >= (abs(mCurrentOffsetY) * 2))) {
                                return mGestureDetector?.onTouchEvent(ev)!!
                            }
                        }
                    }
                    MODE_UP -> {
                        if ((mCurrentOffsetY < 0)) {
                            if ((abs(mCurrentOffsetY) >= (abs(mCurrentOffsetX) * 2))) {
                                return mGestureDetector?.onTouchEvent(ev)!!
                            }
                        }
                    }
                    MODE_DOWN -> {
                        if ((mCurrentOffsetY > 0)) {
                            if ((abs(mCurrentOffsetY) >= (abs(mCurrentOffsetX) * 2))) {
                                return mGestureDetector?.onTouchEvent(ev)!!
                            }
                        }
                    }
                    MODE_UP_AND_DOWN -> {
                        if ((abs(mCurrentOffsetY) >= (abs(mCurrentOffsetX) * 2))) {
                            return mGestureDetector?.onTouchEvent(ev)!!
                        }
                    }
                    else -> {
                    }
                }

                return super.onTouchEvent(ev)
            }
            MotionEvent.ACTION_UP -> {
                if (isSingleClick()) {
                    return super.onTouchEvent(ev)
                }

                mDownX = 0f
                mDownY = 0f
                mCurrentX = 0f
                mCurrentY = 0f
                when (dragMode) {
                    MODE_LEFT -> {
                        if ((mCurrentOffsetX < 0)) {
                            if ((abs(mCurrentOffsetX) >= mWidth * releasePercent)) {
                                prepareScroll(mWidth, 0, mAnimDuration.toInt())
                                isUnlock = true
                            } else {
                                prepareScroll(0, 0, mAnimDuration.toInt())
                                mDragListener?.onRestore()
                            }
                        }
                    }
                    MODE_RIGHT -> {
                        if ((mCurrentOffsetX > 0)) {
                            if ((abs(mCurrentOffsetX) >= mWidth * releasePercent)) {
                                prepareScroll(mWidth, 0, mAnimDuration.toInt())
                                isUnlock = true
                            } else {
                                prepareScroll(0, 0, mAnimDuration.toInt())
                                mDragListener?.onRestore()
                            }
                        }
                    }
                    MODE_UP -> {
                        if ((mCurrentOffsetY < 0)) {
                            if ((abs(mCurrentOffsetY) >= mHeight * releasePercent)) {
                                prepareScroll(0, mHeight, mAnimDuration.toInt())
                                isUnlock = true
                            } else {
                                prepareScroll(0, 0, mAnimDuration.toInt())
                                mDragListener?.onRestore()
                            }
                        }
                    }
                    MODE_DOWN -> {
                        if ((mCurrentOffsetY > 0)) {
                            if ((abs(mCurrentOffsetY) >= mHeight * releasePercent)) {
                                prepareScroll(0, mHeight, mAnimDuration.toInt())
                                isUnlock = true
                            } else {
                                prepareScroll(0, 0, mAnimDuration.toInt())
                                mDragListener?.onRestore()
                            }
                        }
                    }
                    MODE_UP_AND_DOWN -> {
                        //下滑
                        var height = mHeight
                        if (mCurrentOffsetY > 0) {
                            height = -mHeight
                        }

                        if ((abs(mCurrentOffsetY) >= mHeight * releasePercent)) {
                            prepareScroll(0, height, mAnimDuration.toInt())
                            isUnlock = true
                        } else {
                            prepareScroll(0, 0, mAnimDuration.toInt())
                            mDragListener?.onRestore()
                        }
                    }
                    else -> {
                    }
                }


                return true
            }
            else -> {
                return super.onTouchEvent(ev)
            }
        }
    }


    private fun isSingleClick(): Boolean {
        if (mCurrentX <= mDownX + clickOffSet && mCurrentX >= mDownX - clickOffSet
                && mCurrentY <= mDownY + clickOffSet && mCurrentY >= mDownY - clickOffSet
        ) {
            return true
        }
        return false
    }

    private fun isMoving(): Boolean {
        if (mCurrentX <= mDownX + moveOffSet && mCurrentX >= mDownX - moveOffSet
                && mCurrentY <= mDownY + moveOffSet && mCurrentY >= mDownY - moveOffSet
        ) {
            return true
        }
        return false
    }

    fun wrap(view: View) {
        mWrapView = view
        removeAllViews()

        addView(
                mWrapView,
                LayoutParams(
                        LayoutParams.MATCH_PARENT,
                        LayoutParams.MATCH_PARENT
                )
        )
    }

    fun setListener(listener: onDragListener) {
        mDragListener = listener
    }

    public interface onDragListener {
        fun onRelease()
        fun onRestore()
    }

    private var mShareUtils: ShareUtils? = null
    public fun setShareUtils(shareUtils: ShareUtils?) {
        mShareUtils = shareUtils
    }

    private var mLastXIntercept = 0f
    private var mLastYIntercept = 0f
    override fun onInterceptTouchEvent(event: MotionEvent): Boolean {
        var intercepted = false
        var x = event.x
        var y = event.y
        when (event?.action) {
            MotionEvent.ACTION_DOWN -> {
                intercepted = false                              //註解1
                mDownX = event.x
                mDownY = event.y
                mCurrentX = 0f
                mCurrentY = 0f
                mCurrentOffsetX = 0f
                mCurrentOffsetY = 0f
                mGestureDetector?.onTouchEvent(event)!!
            }

            MotionEvent.ACTION_MOVE -> {
                var deltaX = x - mLastXIntercept;
                var deltaY = y - mLastYIntercept;
                intercepted = if (null != mShareUtils && mShareUtils!!.isVisible) {
                    false
                } else {
                    abs(deltaX) < abs(deltaY) && (abs(deltaX) > 5 || abs(deltaY) > 5)
                }
            }

            MotionEvent.ACTION_UP -> {
                intercepted = false
            }

        }
        mLastXIntercept = x
        mLastYIntercept = y

        return intercepted
    }

    override fun computeScroll() {
        super.computeScroll()
        if (mScroller != null) {
            if (mScroller!!.computeScrollOffset()) {
                scrollTo(mScroller!!.currX, mScroller!!.currY)
                postInvalidate()
            } else {
                if (isUnlock) {
                    mDragListener?.onRelease()
                }
            }
        }

    }

    //滾動到目標位置
    private fun prepareScroll(fx: Int, fy: Int, duration: Int?) {
        val dx = fx - mScroller!!.finalX
        val dy = fy - mScroller!!.finalY
        beginScroll(dx, dy, duration)
    }


    //設定滾動的相對偏移
    private fun beginScroll(dx: Int, dy: Int, duration: Int?) { //第一,二個引數起始位置;第三,四個滾動的偏移量
        if (duration != null) {
            mScroller!!.startScroll(mScroller!!.finalX, mScroller!!.finalY, dx, dy, duration)
        } else {
            mScroller!!.startScroll(mScroller!!.finalX, mScroller!!.finalY, dx, dy)
        }
        //必須執行invalidate()從而呼叫computeScroll()
        invalidate()
    }

    override fun onShowPress(e: MotionEvent?) {
    }

    override fun onSingleTapUp(e: MotionEvent?): Boolean {
        return false
    }

    override fun onDown(e: MotionEvent?): Boolean {
        return true
    }

    override fun onFling(e1: MotionEvent?, e2: MotionEvent?, velocityX: Float, velocityY: Float): Boolean {
        return false
    }

    //控制拉動幅度:
    //int disY=(int)((distanceY - 0.5)/2);
    //亦可直接呼叫:
    //smoothScrollBy(0, (int)distanceY);
    // val disY = ((distanceY - 0.5) * 0.8).toInt()
    override fun onScroll(e1: MotionEvent?, e2: MotionEvent?, distanceX: Float, distanceY: Float): Boolean {
        when (dragMode) {
            MODE_LEFT -> {
                beginScroll(distanceX.toInt(), 0, null)
            }

            MODE_RIGHT -> {
                beginScroll(distanceX.toInt(), 0, null)
            }

            MODE_UP -> {
                beginScroll(0, distanceY.toInt(), null)
            }

            MODE_DOWN -> {
                beginScroll(0, distanceY.toInt(), null)
            }

            MODE_UP_AND_DOWN -> {
                beginScroll(0, distanceY.toInt(), null)
            }
        }
        return false
    }

    override fun onLongPress(e: MotionEvent?) {
    }

}

五、 ObjectAnimator滑動實現自定義View的所有程式碼如下:

package com.qimiaoptu.camera.lockscreen

import android.animation.Animator
import android.animation.ValueAnimator
import android.content.Context
import android.util.AttributeSet
import android.view.GestureDetector
import android.view.MotionEvent
import android.view.View
import android.view.animation.LinearInterpolator
import android.widget.FrameLayout
import com.qimiaoptu.camera.log.Loger
import com.qimiaoptu.camera.photostar.ShareUtils
import kotlin.math.abs

/**
 * ┌───┐ ┌───┬───┬───┬───┐ ┌───┬───┬───┬───┐ ┌───┬───┬───┬───┐ ┌───┬───┬───┐
 * │Esc│ │ F1│ F2│ F3│ F4│ │ F5│ F6│ F7│ F8│ │ F9│F10│F11│F12│ │P/S│S L│P/B│ ┌┐    ┌┐    ┌┐
 * └───┘ └───┴───┴───┴───┘ └───┴───┴───┴───┘ └───┴───┴───┴───┘ └───┴───┴───┘ └┘    └┘    └┘
 * ┌──┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┐┌───┬───┬───┐┌───┬───┬───┬───┐
 * │~`│! 1│@ 2│# 3│$ 4│% 5│^ 6│& 7│* 8│( 9│) 0│_ -│+ =│ BacSp ││Ins│Hom│PUp││N L│ / │ * │ - │
 * ├──┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤├───┼───┼───┤├───┼───┼───┼───┤
 * │Tab │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │{ [│} ]│ | \ ││Del│End│PDn││ 7 │ 8 │ 9 │   │
 * ├────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤└───┴───┴───┘├───┼───┼───┤ + │
 * │Caps │ A │ S │ D │ F │ G │ H │ J │ K │ L │: ;│" '│ Enter  │             │ 4 │ 5 │ 6 │   │
 * ├─────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤    ┌───┐    ├───┼───┼───┼───┤
 * │Shift  │ Z │ X │ C │ V │ B │ N │ M │< ,│> .│? /│  Shift   │    │ ↑ │    │ 1 │ 2 │ 3 │   │
 * ├────┬──┴─┬─┴──┬┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤┌───┼───┼───┐├───┴───┼───┤ E││
 * │Ctrl│Ray │Alt │         Space         │ Alt│code│fuck│Ctrl││ ← │ ↓ │ → ││   0   │ . │←─┘│
 * └────┴────┴────┴───────────────────────┴────┴────┴────┴────┘└───┴───┴───┘└───────┴───┴───┘
 *
 * @author Rayhahah
 * @blog http://rayhahah.com
 * @time 2019/10/21
 * @tips 這個類是Object的子類
 * @fuction
 */

class DragView : FrameLayout {

    companion object {
        /**
         * 向左滑動
         */
        const val MODE_LEFT = 0

        /**
         * 向右滑動
         */
        const val MODE_RIGHT = 1
        /**
         * 向上滑動
         */
        const val MODE_UP = 2
        /**
         * 向下滑動
         */
        const val MODE_DOWN = 3
        /**
         * 向上與向下同時相容
         */
        const val  MODE_UP_AND_DOWN = 4
    }

    private var mValueListener: Animator.AnimatorListener? = null
    private var mHeight: Int = 0
    private var mWidth: Int = 0
    private var mDownX: Float = 0f
    private var mDownY: Float = 0f
    private var mCurrentX: Float = 0f
    private var mCurrentY: Float = 0f

    private var mCurrentOffsetX: Float = 0f
    private var mCurrentOffsetY: Float = 0f

    private var clickOffSet = 30
    private var moveOffSet = 5

    private var mWrapView: View? = null

    private var mAnimDuration: Long = 500
    private var mValueAnimator: ValueAnimator? = null
    private var mDragListener: onDragListener? = null

    var releasePercent: Float = 0.4f
        set(value) {
            field = value
            requestLayout()
            invalidate()
        }

    var dragMode: Int = MODE_UP_AND_DOWN
        set(value) {
            field = value
            requestLayout()
            invalidate()
        }

    constructor(context: Context) : this(context, null)
    constructor(context: Context, attrs: AttributeSet?) : this(context, attrs, 0)
    constructor(context: Context, attrs: AttributeSet?, defStyleAttr: Int) : super(
            context,
            attrs,
            defStyleAttr
    ) {
        mValueAnimator = ValueAnimator.ofFloat(0f, 1f)
        mValueAnimator?.apply {
            duration = mAnimDuration
            repeatCount = 0
            repeatMode = ValueAnimator.RESTART
            interpolator = LinearInterpolator()
            mValueListener = object : Animator.AnimatorListener {
                override fun onAnimationRepeat(animation: Animator?) {
                }

                override fun onAnimationEnd(animation: Animator?) {
                    when (dragMode) {
                        MODE_LEFT -> {
                            if ((Math.abs(mCurrentOffsetX) >= mWidth * releasePercent)) {
                                mWrapView?.apply {
                                    visibility = View.VISIBLE
                                    alpha = 0f
                                    translationX = 0f
                                }
                                mDragListener?.onRelease()
                            } else {
                                mDragListener?.onRestore()
                            }
                        }
                        MODE_RIGHT -> {
                            if ((Math.abs(mCurrentOffsetX) >= mWidth * releasePercent)) {
                                mWrapView?.apply {
                                    visibility = View.VISIBLE
                                    alpha = 0f
                                    translationX = 0f
                                }
                                mDragListener?.onRelease()
                            } else {
                                mDragListener?.onRestore()
                            }
                        }
                        MODE_UP -> {
                            if ((Math.abs(mCurrentOffsetY) >= mHeight * releasePercent)) {
                                mWrapView?.apply {
                                    visibility = View.VISIBLE
                                    alpha = 0f
                                    translationY = 0f
                                }
                                mDragListener?.onRelease()
                            } else {
                                mDragListener?.onRestore()
                            }
                        }
                        MODE_DOWN -> {
                            if ((Math.abs(mCurrentOffsetX) >= mWidth * releasePercent)) {
                                mWrapView?.apply {
                                    visibility = View.VISIBLE
                                    alpha = 0f
                                    translationY = 0f
                                }
                                mDragListener?.onRelease()
                            } else {
                                mDragListener?.onRestore()
                            }
                        }
                        MODE_UP_AND_DOWN -> {
                            //MODE_UP
                            if ((mCurrentOffsetY < 0)) {
                                if ((Math.abs(mCurrentOffsetY) >= mHeight * releasePercent)) {
                                    mWrapView?.apply {
                                        visibility = View.VISIBLE
                                        alpha = 0f
                                        translationY = 0f
                                    }
                                    mDragListener?.onRelease()
                                } else {
                                    mDragListener?.onRestore()
                                }
                            } else {//MODE_DOWN
                                if ((Math.abs(mCurrentOffsetY) >= mHeight * releasePercent)) {
                                    mWrapView?.apply {
                                        visibility = View.VISIBLE
                                        alpha = 0f
                                        translationY = 0f
                                    }
                                    mDragListener?.onRelease()
                                } else {
                                    mDragListener?.onRestore()
                                }
                            }
                        }
                        else -> {
                        }
                    }
                }

                override fun onAnimationCancel(animation: Animator?) {
                }

                override fun onAnimationStart(animation: Animator?) {
                }
            }

            addUpdateListener {
                val progress = it.animatedValue as Float
                when (dragMode) {
                    MODE_LEFT -> {
                        if ((Math.abs(mCurrentOffsetX) >= mWidth * releasePercent)) {
                            mWrapView?.apply {
                                val targetOffsetX = progress * (-mWidth - mCurrentOffsetX)
                                translationX = mCurrentOffsetX + targetOffsetX
                            }
                        } else {
                            mWrapView?.apply {
                                val targetOffsetX = progress * (-mCurrentOffsetX)
                                translationX = mCurrentOffsetX + targetOffsetX
                            }
                        }
                    }
                    MODE_RIGHT -> {
                        if ((Math.abs(mCurrentOffsetX) >= mWidth * releasePercent)) {
                            mWrapView?.apply {
                                val targetOffsetX = progress * (mWidth - mCurrentOffsetX)
                                translationX = mCurrentOffsetX + targetOffsetX
                            }
                        } else {
                            mWrapView?.apply {
                                val targetOffsetX = progress * (-mCurrentOffsetX)
                                translationX = mCurrentOffsetX + targetOffsetX
                            }
                        }
                    }
                    MODE_UP -> {
                        if ((Math.abs(mCurrentOffsetY) >= mHeight * releasePercent)) {
                            mWrapView?.apply {
                                val targetOffsetY = progress * (-mHeight - mCurrentOffsetY)
                                translationY = mCurrentOffsetY + targetOffsetY
                            }
                        } else {
                            mWrapView?.apply {
                                val targetOffsetY = progress * (-mCurrentOffsetY)
                                translationY = mCurrentOffsetY + targetOffsetY
                            }
                        }
                    }
                    MODE_DOWN -> {
                        if ((Math.abs(mCurrentOffsetY) >= mHeight * releasePercent)) {
                            mWrapView?.apply {
                                val targetOffsetY = progress * (mHeight - mCurrentOffsetY)
                                translationY = mCurrentOffsetY + targetOffsetY
                            }
                        } else {
                            mWrapView?.apply {
                                val targetOffsetY = progress * (-mCurrentOffsetY)
                                translationY = mCurrentOffsetY + targetOffsetY
                            }
                        }
                    }
                    MODE_UP_AND_DOWN -> {
                        //MODE_UP
                        if ((mCurrentOffsetY < 0)) {
                            if ((Math.abs(mCurrentOffsetY) >= mHeight * releasePercent)) {
                                mWrapView?.apply {
                                    val targetOffsetY = progress * (-mHeight - mCurrentOffsetY)
                                    translationY = mCurrentOffsetY + targetOffsetY
                                }
                            } else {
                                mWrapView?.apply {
                                    val targetOffsetY = progress * (-mCurrentOffsetY)
                                    translationY = mCurrentOffsetY + targetOffsetY
                                }
                            }
                        } else {//MODE_DOWN
                            if ((Math.abs(mCurrentOffsetY) >= mHeight * releasePercent)) {
                                mWrapView?.apply {
                                    val targetOffsetY = progress * (mHeight - mCurrentOffsetY)
                                    translationY = mCurrentOffsetY + targetOffsetY
                                }
                            } else {
                                mWrapView?.apply {
                                    val targetOffsetY = progress * (-mCurrentOffsetY)
                                    translationY = mCurrentOffsetY + targetOffsetY
                                }
                            }
                        }
                    }
                    else -> {
                    }
                }
            }

            addListener(mValueListener)
        }
    }

    override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
        super.onSizeChanged(w, h, oldw, oldh)
        mWidth = w
        mHeight = h
        mWrapView = getChildAt(0)
    }

    override fun onTouchEvent(ev: MotionEvent): Boolean {
        Loger.e("xxxxxxxxxxxxx", " onTouchEvent")
        if (null != mGestureDetector) {
//            mGestureDetector.onTouchEvent(ev)
        }
        when (ev.action) {
            MotionEvent.ACTION_DOWN -> {
                if (mValueAnimator?.isRunning == true) {
                    return super.onTouchEvent(ev)
                }

                mDownX = ev.x
                mDownY = ev.y
                mCurrentX = 0f
                mCurrentY = 0f
                mCurrentOffsetX = 0f
                mCurrentOffsetY = 0f

                return true
            }
            MotionEvent.ACTION_MOVE -> {
                mCurrentX = ev.x
                mCurrentY = ev.y

                if (isMoving()) {
                    return super.onTouchEvent(ev)
                }

                mCurrentOffsetX = mCurrentX - mDownX
                mCurrentOffsetY = mCurrentY - mDownY

                when (dragMode) {
                    MODE_LEFT -> {
                        if ((mCurrentOffsetX < 0)) {
                            if ((Math.abs(mCurrentOffsetX) >= (Math.abs(mCurrentOffsetY) * 2))) {
                                mWrapView?.let {
                                    it.translationX = mCurrentOffsetX
                                }
                            }
                        }
                    }
                    MODE_RIGHT -> {
                        if ((mCurrentOffsetX > 0)) {
                            if ((Math.abs(mCurrentOffsetX) >= (Math.abs(mCurrentOffsetY) * 2))) {
                                mWrapView?.let {
                                    it.translationX = mCurrentOffsetX
                                }
                            }
                        }
                    }
                    MODE_UP -> {
                        if ((mCurrentOffsetY < 0)) {
                            if ((Math.abs(mCurrentOffsetY) >= (Math.abs(mCurrentOffsetX) * 2))) {
                                mWrapView?.let {
                                    it.translationY = mCurrentOffsetY
                                }
                            }
                        }
                    }
                    MODE_DOWN -> {
                        if ((mCurrentOffsetY > 0)) {
                            if ((Math.abs(mCurrentOffsetY) >= (Math.abs(mCurrentOffsetX) * 2))) {
                                mWrapView?.let {
                                    it.translationY = mCurrentOffsetY
                                }
                            }
                        }
                    }
                    MODE_UP_AND_DOWN -> {
                        //MODE_UP
                        if ((mCurrentOffsetY < 0)) {
                            if ((Math.abs(mCurrentOffsetY) >= (Math.abs(mCurrentOffsetX) * 2))) {
                                mWrapView?.let {
                                    it.translationY = mCurrentOffsetY
                                }
                            }
                        } else {//MODE_DOWN
                            if ((Math.abs(mCurrentOffsetY) >= (Math.abs(mCurrentOffsetX) * 2))) {
                                mWrapView?.let {
                                    it.translationY = mCurrentOffsetY
                                }
                            }
                        }
                    }
                    else -> {
                    }
                }

                return super.onTouchEvent(ev)
            }
            MotionEvent.ACTION_UP -> {
                if (isSingleClick()) {
                    return super.onTouchEvent(ev)
                }

                mDownX = 0f
                mDownY = 0f
                mCurrentX = 0f
                mCurrentY = 0f
                when (dragMode) {
                    MODE_LEFT -> {
                        if ((mCurrentOffsetX < 0)) {
                            mValueAnimator?.start()
                        }
                    }
                    MODE_RIGHT -> {
                        if ((mCurrentOffsetX > 0)) {
                            mValueAnimator?.start()
                        }
                    }
                    MODE_UP -> {
                        if ((mCurrentOffsetY < 0)) {
                            mValueAnimator?.start()
                        }
                    }
                    MODE_DOWN -> {
                        if ((mCurrentOffsetY > 0)) {
                            mValueAnimator?.start()
                        }
                    }
                    MODE_UP_AND_DOWN -> {
                        if ((mCurrentOffsetY < 0)) {
                            mValueAnimator?.start()
                        } else{
                            mValueAnimator?.start()
                        }
                    }
                    else -> {
                    }
                }


                return true
            }
            else -> {
                return super.onTouchEvent(ev)
            }
        }
    }


    private fun isSingleClick(): Boolean {
        if (mCurrentX <= mDownX + clickOffSet && mCurrentX >= mDownX - clickOffSet
                && mCurrentY <= mDownY + clickOffSet && mCurrentY >= mDownY - clickOffSet
        ) {
            return true
        }
        return false
    }

    private fun isMoving(): Boolean {
        if (mCurrentX <= mDownX + moveOffSet && mCurrentX >= mDownX - moveOffSet
                && mCurrentY <= mDownY + moveOffSet && mCurrentY >= mDownY - moveOffSet
        ) {
            return true
        }
        return false
    }

    fun wrap(view: View) {
        mWrapView = view
        removeAllViews()

        addView(
                mWrapView,
                LayoutParams(
                        LayoutParams.MATCH_PARENT,
                        LayoutParams.MATCH_PARENT
                )
        )
    }

    fun setListener(listener: onDragListener) {
        mDragListener = listener
    }

    public interface onDragListener {
        fun onRelease()
        fun onRestore()
    }

    private lateinit var mGestureDetector: GestureDetector

    public fun setGestureDetector(gestureDetector: GestureDetector) {
        mGestureDetector = gestureDetector
    }

    private var mShareUtils: ShareUtils? = null
    public fun setShareUtils(shareUtils: ShareUtils?) {
        mShareUtils = shareUtils
    }

    private var mLastXIntercept = 0f
    private var mLastYIntercept = 0f
    override fun onInterceptTouchEvent(event: MotionEvent): Boolean {
        var intercepted = false
        var x = event.x
        var y = event.y
        when (event?.action) {
            MotionEvent.ACTION_DOWN -> {
                intercepted = false                              //註解1
//                if (isMoving()) {                       //註解2
//                    intercepted = true
//                }
                if (mValueAnimator?.isRunning == true) {
                    return super.onInterceptTouchEvent(event)
                }

                mDownX = event.x
                mDownY = event.y
                mCurrentX = 0f
                mCurrentY = 0f
                mCurrentOffsetX = 0f
                mCurrentOffsetY = 0f
            }

            MotionEvent.ACTION_MOVE -> {
                var deltaX = x - mLastXIntercept;
                var deltaY = y - mLastYIntercept;
                intercepted = if(null != mShareUtils && mShareUtils!!.isVisible) {
                    false
                } else {
                    abs(deltaX) < abs(deltaY) && (abs(deltaX) > 5 || abs(deltaY) > 5)
                }
            }

            MotionEvent.ACTION_UP -> {
                intercepted = false
            }

        }
        mLastXIntercept = x
        mLastYIntercept = y

        return intercepted
    }
}

六、總結

鎖屏自定義View的實現方式肯定還有很多方式，不過我只是嘗試了ObjectAnimator和Scroller這個兩種實現方式，這兩種方式比較推薦Scroller實現，畢竟ObjectAnimator實現會存在部分機型動畫卡頓，比如oppo，miui等。

Android 自定義View 滑動解鎖
2020-12-22
AndroidView
Mac使用技巧_蘋果鎖屏介面如何自定義鎖屏訊息？
2020-10-13
Mac蘋果
android 手機監聽螢幕鎖屏,使用者解鎖
2017-12-14
Android
ios10鎖屏怎麼解鎖ios10鎖屏介面解鎖方法
2016-06-15
iOS
解鎖自定義分享功能新姿勢
2019-03-02
Android手機：破解鎖屏密碼
2018-08-24
Android密碼
如何在Mac上設定自定義鎖屏訊息？
2020-09-15
Mac
【填坑往事】Android手機鎖屏人臉解鎖優化過程實錄
2020-11-10
Android優化
Android開屏、鎖屏、解鎖監聽實現
2018-07-04
Android
榮耀手機鎖屏訊息提示怎麼設定？榮耀手機鎖屏訊息提示的設定方法教程
2019-02-05
教你寫一個九宮格鎖屏View
2017-10-21
View
如何在丟失的Mac上設定自定義鎖屏訊息
2020-11-03
Mac
python之GIL全域性直譯器鎖，自定義互斥鎖，死鎖與遞迴鎖
2018-09-07
Python遞迴
iOS指紋解鎖和手勢解鎖
2018-03-14
iOS
iOS手勢解鎖和指紋解鎖
2017-06-20
iOS
redis分散式鎖-spring boot aop+自定義註解實現分散式鎖
2021-05-26
Redis分散式Spring Boot
AQS 自定義同步鎖，挺難的！
2020-10-25
AQS
Android自定義多宮格解鎖控制元件
2019-02-15
Android控制元件
win10鍵盤如何鎖屏_win10電腦鎖屏按什麼鍵解鎖
2020-07-15
Win10
實現宣告式鎖，支援分散式鎖自定義鎖、SpEL和結合事務
2023-04-19
分散式
專案需求討論- 手機鎖屏及APP退到後臺後自動鎖定功能
2017-07-28
APP
自定義VIEW
2019-03-27
View
Android自定義view詳解
2016-07-24
AndroidView
Android 自定義 view 詳解
2016-07-16
AndroidView
iQOO手機隔空解鎖怎麼用？iQOO手機隔空解鎖的設定方法教程
2019-03-15
手機QQ影片兒童鎖在哪兒？手機QQ影片兒童鎖使用教程
2016-11-29
蘋果Apple ID被鎖定了怎麼辦？蘋果手機ID被鎖怎麼解鎖？
2023-04-28
蘋果APP
win10怎麼取消開機鎖屏介面_win10如何關閉開機鎖屏介面
2020-06-03
Win10
iOS 手機螢幕手勢鎖
2016-10-19
iOS
Go 武林外傳 - 解鎖 Micro 新姿勢之自定義服務
2020-03-24
Go
深入瞭解View實現原理以及自定義View詳解
2014-07-30
View
自定義View公式
2017-12-13
View公式
win10怎麼鎖屏介面 win10待機鎖屏設定方法介紹
2022-10-21
Win10
蘋果筆記本快速鎖屏教程 Mac怎麼快速鎖屏？
2017-09-06
蘋果筆記Mac
用喜歡和舒服的方式在Golang中使用鎖、使用channel自定義鎖
2017-08-12
Golang
Android自定義View：View（二）
2019-05-05
AndroidView
win10自動鎖屏怎麼關禁止開機後顯示鎖屏介面的方法
2021-01-11
Win10
蘋果手機使用技巧：iPhone怎麼設定自動鎖屏時間？
2015-03-11
蘋果iPhone

防手機鎖屏解鎖自定義View

文章目錄

一、簡介

二、ObjectAnimator與Scroller實現比較

三、 Scroller實現核心

1、鎖屏解鎖主要有兩個關鍵點

2、觸控手機滑動帶動頁面進行滑動

3、手指離開螢幕判斷是否解鎖成功

4、記得重寫computeScroll方法讓滑動生效

四、 Scroller滑動實現自定義View的所有程式碼如下:

五、 ObjectAnimator滑動實現自定義View的所有程式碼如下:

六、 總結

相關文章

六、總結