手勢滑動之玩轉onTouchEvent()與Scroller

時間  2019-11-24
標籤 手勢 滑動 ontouchevent scroller 简体版
原文   原文鏈接

和我一個超級要好的朋友聊起自定義view和手勢滑動，正好羣裏好多小夥伴老是問關於onTouchEvent()與Scroller的處理，因此就正好寫一篇這樣的博客，但願能夠幫到須要的朋友。java

今天的效果很是很是的簡單，因此只能說是入門級，重在理解其中的精髓，今天主要講兩個東西，一個是View#onTouchEvent(MotionEvent)方法，另外一個是Scroller類，通常涉及到手勢操做的都離不開它倆。android

本demo源代碼下載：download.csdn.net/detail/yanz…api

效果預覽

彈性效果
仿ViewPager彈性翻頁

原理分析與知識普及

不講道理的說，咱們不是要作這兩個才分析，而是由於分析了View#onTouchEvent(MotionEvent)和Scroller才作出的這兩個，因此且聽我細細道來。ide

scrollTo(int, int)與scrollBy(int, int)

咱們要發生滾動就的知道View的兩個方法：View#scrollTo(int, int)和View#scrollBy(int, int)，這兩個方法都是讓View來發生滾動的，他們有什麼區別呢？佈局

  • View#scrollTo(int, int)
    讓View的content滾動到相對View初始位置的(x, y)處。post

  • View#scrollBy(int, int)
    讓View的content滾動到相對於View當前位置的(x, y)處。動畫

不知道你理解了木有？什麼，還沒理解？好那咱們來一個sample，先來看看佈局：this

 

  
  
  

 

    
    
複製代碼

這是java代碼：spa

ViewGroup mContentRoot;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    ...

    mContentRoot = (ViewGroup) findViewById(R.id.content_scroll_method);
    findViewById(R.id.btn_scroll_to).setOnClickListener(this);
    findViewById(R.id.btn_scroll_by).setOnClickListener(this);
}

@Override
private void onClick(View v) {
    int id = v.getId();
    switch (id) {
        case R.id.btn_scroll_to: {
            mContentRoot.scrollTo(100, 100);
            break;
        }
        case R.id.btn_scroll_by: {
            mContentRoot.scrollBy(10, 20);
            break;
        }
    }
}複製代碼

這個很好理解了，點擊scrollTo()按鈕的時候調用Layout的scrollTo(int, int)放，讓Layout的content滾動到相對Layout初始位置的(100, 100)處；點擊scrooBy()按鈕的時候調用Layout的scrollBy(int, int)讓Layout的content滾動到相對Layout當前位置的(10, 20)處，來看看效果吧：.net

scrooTo()與scrooBy()

咱們發現點擊scrollTo()按鈕的時候，滾動了一下，而後再點就不動了，由於此時Layout的content已經滾動到相對於它初始位置的(100,100)處了，因此再點它仍是到這裏，因此再次點擊就看起來不動了。

點擊scrollBy()按鈕的時候，發現Layout的content一直有在滾動，是由於不管什麼時候，content的相對位置與當前位置都是不一樣的，因此它老是會去到一個新的位置，因此再次點擊會一直滾動。

注意：這裏咱們也發現scrollTo(int, int)與scrollBy(int, int)傳入的值都是正數，通過我實驗得出，x傳入正數則向左移動，傳入負數則向右移動；y傳入正數則向上移動，傳入負數則向下移動，且這個xy的值是像素。這裏和Android座標系是相反的，不日我將新開一篇博客來專門講這個問題。

咱們理解了View#scrollTo(int, int)和View#scrollBy(int, int)後結合View#onTouchEvent(MotionEvent)就能夠作不少事了。

View#onTouchEvent(MotionEvent)

對於View#onTouchEvent(MotionEvent)方法，它是當View接受到觸摸事件時被調用（暫不關心事件分發），第一咱們從它能夠拿到DOWN、MOVE、UP、CANCEL幾個關鍵事件，第二咱們能夠拿到每一個DOWN等事件發生時手指在屏幕上的位置和手指在View內的位置。基於此咱們能夠想到作不少事，假如咱們在手指DOWN時記錄手指的xy，在MOVE時根據DOWN時的xy來計算手指滑動的距離，而後讓View發生一個移動，在手指UP/CANCEL時讓View回到最開始的位置，所以咱們作了第一個效果，下面來作具體的代碼分析。

咱們定義一個ScrollLayout，而後繼承自LinearLayout，在xml中引用，而後在ScrollLayout中放一個TextView，並讓內容居中：

 

  
  
  

 
    
  
  
  

 
複製代碼

佈局就是這樣的，根據上面的分析咱們實現ScrollLayout的具體代碼，請看：

// 手指最後在View中的座標。
private int mLastX;
private int mLastY;

// 手指按下時View的相對座標。
private int mDownViewX;
private int mDownViewY;

@Override
public boolean onTouchEvent(MotionEvent event) {
    // 第一步，記錄手指在view的座標。
    int x = (int) event.getRawX();
    int y = (int) event.getRawY();
    int action = event.getAction();
    switch (action) {
        case MotionEvent.ACTION_DOWN: {
            // 記錄View相對於初始位置的滾動座標。
            mDownViewX = getScrollX();
            mDownViewY = getScrollY();

            // 更新手指此時的座標。
            mLastX = x;
            mLastY = y;
            return true;
        }
        case MotionEvent.ACTION_MOVE: {
            // 計算手指此時的座標和上次的座標滑動的距離。
            int dy = y - mLastY;
            int dx = x - mLastX;

            // 更新手指此時的座標。
            mLastX = x;
            mLastY = y;

            // 滑動相對距離。
            scrollBy(-dx, -dy);
            return true;
        }
        case MotionEvent.ACTION_UP:
        case MotionEvent.ACTION_CANCEL: {
            scrollTo(mDownViewX, mDownViewY);
            return true;
        }
    }
    return super.onTouchEvent(event);
}複製代碼

那麼這裏再來講明兩個方法：

  • View#getScrollX()
    獲取View相對於它初始位置X方向的滾動量。

  • View#getScrollY()
    獲取View相對於它初始位置Y方向的滾動量。

根據咱們上面的分析，這裏處理了四個事件，分別是：

  1. MotionEvent.ACTION_DOWN
  2. MotionEvent.ACTION_MOVE
  3. MotionEvent.ACTION_UP
  4. MotionEvent.ACTION_CANCEL

  • 第一步，由於ACTION_DOWN、ACTION_MOVE中都須要記錄手指當前座標，因此一進入就記錄了event.getRawX()和event.getRawY()。

  • 第二步，ACTION_DOWN手指按下時被調用，在一次觸摸中只會被調用一次，在ACTION_DOWN的時候記錄了content相對於最開始滾動的座標getScrollX()和getScrollY()，在咱們咱們手指鬆開時它滾動了多少getScrollX()和多少getScrollY()，那麼咱們就調用scrollTo(int, int)滾動多少-getScrollX()和多少-getScrollY()，這樣它不就回到初始位置了嗎？同時記錄了手指此時的座標，用來在ACTION_MOVE的時候計算第一次ACTION_MOVE時的移動距離。

  • 第三步，ACTION_MOVE會在手指移動的時候調用，因此它會調用屢次，因此每次須要計算與上次的手指座標的滑動距離，而且更新本次的手指座標，而後調用scrollBy(int, int)去滑動當前手指與上次手指的座標（當前View的位置）的距離。

  • 第四步，ACTION_UP在手指擡起時被調用，ACTION_CANCEL在手指滑動這個View的區域時被調用，此時咱們調用scrollTo(int, int)回到最初的位置。

咱們來看看效果：

這裏寫圖片描述

嗯效果已經實現了，可是咱們發現和開頭演示的效果有點出入，就是手指鬆開時View一會兒就回去了而不是平滑的回到最初的位置，所以咱們須要用到Scroller。

Scroller

Scroller是手指滑動中比較重要的一個輔助類，能夠輔助咱們完成一些動畫參數的計算等，下面把它的幾個重要的方法作個簡單解釋。

  • Scroller#startScroll(int startX, int startY, int dx, int dy)

  • Scroller#startScroll(int startX, int startY, int dx, int dy, int duration)
    這倆方法幾乎是同樣的，用來標記一個View想要從哪裏移動到哪裏。
    startX，x方向從哪裏開始移動。
    startY，y方向從哪裏開始移動。
    dx，x方向移動多遠。
    dy，y方向移動多遠。
    duration，這個移動操做須要多少時間執行完，默認是250毫秒。

固然光這個方法是不夠的，它只是標記一個位置和時間，那麼怎麼計算呢？

  • Scroller#computeScrollOffset()
    這個方法用來計算當前你想知道的一個新位置，Scroller會自動根據標記時的座標、時間、當前位置計算出一個新位置，記錄到內部，咱們能夠經過Scroller#getCurrX()和Scroller#getCurrY()獲取的新的位置。

    要知道的是，它計算出的新位置是一個閉區間[x, y]，並且會在你調用startScroll傳入的時間內漸漸從你指定的int startX和int startY移動int dx和int dy的距離，因此咱們每次調用Scroller#computeScrollOffset()後再調用View的scrollTo(int, int)而後傳入Scroller#getCurrX()和Scroller#getCurrY()就能夠獲得一個漸漸移動的效果。

    同時這個方法有一個返回值是boolean類型的，內部是用一個boolean來記錄是否完成的，在調用Scroller#startScroll)時會把這個boolean參數置爲false。內部邏輯是先判斷startScroll()動畫是否還在繼續，若是沒有完成則計算最新位置，計算最新位置前會對duration作判斷，第一若是時間沒到，則真正的計算位置，而且返回true，第二若是時間到了，把記錄是否繼續的boolean成員變量標記完成，並直接賦值最新位置爲最終目的位置，而且返回true；若是startScroll()已經完成則直接返回false。咱們判斷Scroller#computeScrollOffset()是true時說明還沒完成，此時拿到Scroller#getCurrX()和Scroller#getCurrY()作一個滾動，待會代碼中能夠看到這個邏輯。

  • Scroller#getCurrX()

  • Scroller#getCurrY()
    這兩個方法就是拿到經過Scroller#computeScrollOffset()計算出的新的位置，上面也解釋過了。

  • Scroller.isFinished()
    上次的動畫是否完成。

  • Scroller.abortAnimation()
    取消上次的動畫。

這裏要強調的是Scroller.isFinished()和通常是配套使用的，通常咋ACTION_DWON的時候判斷是否完成，若是沒有完成咋取消動畫。

基於此，咱們完善上面的效果，讓它平滑滾動，因此咱們來完善一下。

View#onTouchEvent(MotionEvent)與Scroller結合完善動畫

private Scroller mScroller;
private int mLastX;
private int mLastY;

 public ScrollLayout(Context context) {
    this(context, null, 0);
}

public ScrollLayout(Context context, AttributeSet attrs) {
    this(context, attrs, 0);
}

public ScrollLayout(Context context, AttributeSet attrs, int defStyleAttr) {
    super(context, attrs, defStyleAttr);
    mScroller = new Scroller(context);
}

@Override
public boolean onTouchEvent(MotionEvent event) {
    int x = (int) event.getRawX();
    int y = (int) event.getRawY();

    int action = event.getAction();
    switch (action) {
        case MotionEvent.ACTION_DOWN: {
            if (!mScroller.isFinished()) { // 若是上次的調用沒有執行完就取消。
                mScroller.abortAnimation();
            }
            mLastX = x;
            mLastY = y;
            return true;
        }
        case MotionEvent.ACTION_MOVE: {
            int dy = y - mLastY;
            int dx = x - mLastX;

            mLastX = x;
            mLastY = y;

            scrollBy(-dx, -dy);
            return true;
        }
        case MotionEvent.ACTION_UP:
        case MotionEvent.ACTION_CANCEL: {
            // XY都從滑動的距離回去，最後一個參數是多少毫秒內執行完這個動做。
            mScroller.startScroll(getScrollX(), getScrollY(), -getScrollX(), -getScrollY(), 1000);
            invalidate();
            return true;
        }
    }
    return super.onTouchEvent(event);
}

/**
 * 這個方法在調用了invalidate()後被回調。
 */
@Override
public void computeScroll() {
    if (mScroller.computeScrollOffset()) { // 計算新位置，並判斷上一個滾動是否完成。
        scrollTo(mScroller.getCurrX(), mScroller.getCurrY());
        invalidate();// 再次調用computeScroll。
    }
}複製代碼
  • 第一步，在構造方法中初始化Scroller。
  • 第二步，在ACTION_DOWN時去掉最開始記錄的content的初始位置，下面講爲何。而且判斷Scroller的動畫是否完成，沒有完成則取消。
  • 第三步，在ACTION_MOVE的時候調用滾動，讓View跟着手指走。

  • 第四步，在ACTION_UP和ACTION_CANCEL時讓View平滑滾動到最初位置。
    根據上面Scroller的分析，這裏能夠調用Scroller#startScroll(startX, startY, dx, dy, duration)記錄開始位置，和滑動的距離以及指定動畫完成的時間。

    1. (startX, startY)傳入當前content的相對與最開始滾動的位置(getScrollX(), getScrollY())。
    2. (dx, dy)要傳入要平滑滑動的距離，那麼傳什麼呢？既然它滾動了(getScrollX(), getScrollY())，那麼咱們就讓它滾這麼多的距離回去不久行了？因此咱們傳入(-getScrollX(), -getScrollY())。
    3. duration滾動時間，咱們傳個800毫秒，1000毫秒的均可以，默認是250毫秒。

  • 第五步，調用invalidate()/postInvalidate()刷新View，最底層View會調用一系列方法，這裏咱們重寫其中computeScroll()方法。

    1. 咱們看到invalidate()和postInvalidate()，invalidate()在當前線程調用，也就是主線程，這裏咱們使用invalidate()；postInvalidate()通常在子線程須要刷新View時調用。
    2. computeScroll()方法是用來計算滾動的，咱們平滑滾動時不就是要它麼。
  • 第六步，根據上面Scroller的分析，在computeScroll()中此時調用Scroller.computeScrollOffset()再好不過了，計算出一個新的相對位置，而後調用scrollTo(int, int)滑動過去。
  • 第七步，在computeScroll()中scrollTo(int, int)後調用invalidate()computeScroll刷新視圖，呈現出一個動畫的效果。

彈性效果

View#onTouchEvent(MotionEvent)與Scroller再升級

View#onTouchEvent(MotionEvent)與Scroller結合再升級，這一節是基於上一節的，若是你沒看上一節，那麼最好看完再看這個，否則很是可能看不懂。下面咱們來完成文中開頭的第二個效果，一個模擬ViewPager翻頁且加彈性動畫的效果。

上面的自定義ScrollLayout是繼承LinearLayout的，下面咱們新建一個ScrollPager的繼承ViewGroup，來完成目標：

public class ScrollPager extends ViewGroup {
    public ScrollPager(Context context) {
        this(context, null, 0);
    }

    public ScrollPager(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public ScrollPager(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }
}複製代碼

而後咱們把佈局寫好，放三個Layout，高度爲100dp，寬度都爲match_parent：

 

  
  
  

 

    
  
  
  

 

        
  
  
  

 

    

    
  
  
  

 

        
  
  
  

 

    

    
  
  
  

 

        
  
  
  

 

    
複製代碼

佈局蠻簡單了，就是一個ViewGroup中三個高度爲100dp，寬度都爲match_parent的LinearLayout，寬度爲match_parent是爲了佔滿一屏的寬。而後每一個LinearLayout中一個TextView，分別爲第一頁、第二頁、第三頁。

分析一下，ViewPager首先要每一屏一個Layout/View，加上繼承ViewGroup必需要重寫ViewGroup#onLayout()，ViewGroup#onLayout()是用來佈局子View的，也就是在它裏面決定哪一個View放在哪裏。

爲了新建的ScrollPager中的View橫向鋪開，因此咱們接着實現ScrollPager#onLayout()，可是要想佈局子View，就得知道子View的寬高，因此先要測量寬高，所以還得重寫ScrollPager#onMeasure方法測量View大小，所以咱們有了下面的代碼：

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    int childCount = getChildCount();
    // 在Layout 子view以前測量子view大小，在layout的時候才能調用getMeasuredWidth()和getMeasuredHeight()。
    for (int i = 0; i < childCount; i++) {
        View childView = getChildAt(i);
        measureChild(childView, widthMeasureSpec, heightMeasureSpec);
    }
}

@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
    if (changed) {
        int childCount = getChildCount();
        for (int i = 0; i < childCount; i++) {
            View childView = getChildAt(i);
            int childW = childView.getMeasuredWidth();

            // 把全部子view放在水平方向，依次排開。
            // left:  0, w, 2w, 3w..
            // top:   0...
            // right: w, 2w, 3w...
            // topL   h...
            childView.layout(i * childW, 0, childW * i + childW, childView.getMeasuredHeight());
        }
    }
}複製代碼

onMeasure()沒神馬好解釋的，就是挨個測量子View的大小，若是細節不懂能夠自行搜索。那麼onLayout()中調用子View的View#layout()方法把子View佈局到ScrollPager上，而且依次橫向排開。

而後咱們把'onTouchEvent()'中的滑動處理一下：

// 手指每次移動時須要更新xy，記錄上次手指所處的座標。
private float mLastX;

@Override
public boolean onTouchEvent(MotionEvent event) {
    float x = event.getRawX();

    int action = event.getAction();
    switch (action) {
        case MotionEvent.ACTION_DOWN:
            mLastX = x;
            return true;
        case MotionEvent.ACTION_MOVE:
            int dxMove = (int) (mLastX - x);
            scrollBy(dxMove, 0);
            mLastX = x;
            return true;
        case MotionEvent.ACTION_UP:
        case MotionEvent.ACTION_CANCEL: {
            // 鬆開時處理慣性滑動。
            break;
        }
    }
    return super.onTouchEvent(event);
}複製代碼

這裏咱們只是沒有處理ACTION_UP和ACTION_CANCEL事件，咱們來運行一把看看：

簡陋的Pager效果

哦喲，出來了，但是沒有像ViewPager那樣鬆開時自動動切換到某一頁，因此咱們還要處理ACTION_UP和ACTION_CANCEL事件。

要想有鬆開時平滑滑動到某一頁，咱們分析一下，確定是須要Scroller的，而後還要重寫View#computeScroll()方法，下面是完成的代碼：

private Scroller mScroller;

// 手指每次移動時須要更新xy，記錄上次手指所處的座標。
private float mLastX;

public ScrollPager(Context context) {
    this(context, null, 0);
}

public ScrollPager(Context context, AttributeSet attrs) {
    this(context, attrs, 0);
}

public ScrollPager(Context context, AttributeSet attrs, int defStyleAttr) {
    super(context, attrs, defStyleAttr);
    mScroller = new Scroller(context);
}

@Override
public boolean onTouchEvent(MotionEvent event) {
    float x = event.getRawX();

    int action = event.getAction();
    switch (action) {
        case MotionEvent.ACTION_DOWN:
            if (!mScroller.isFinished()) { // 若是上次的調用沒有執行完就取消。
                mScroller.abortAnimation();
            }
            mLastX = x;
            return true;
        case MotionEvent.ACTION_MOVE:
            int dxMove = (int) (mLastX - x);
            scrollBy(dxMove, 0);
            mLastX = x;
            return true;
        case MotionEvent.ACTION_UP:
        case MotionEvent.ACTION_CANCEL: {
            int sonIndex = (getScrollX() + getWidth() / 2) / getWidth();

            // 若是滑動超過最後一頁，就退回到最後一頁。
            int childCount = getChildCount();
            if (sonIndex >= childCount)
                sonIndex = childCount - 1;

            // 如今滑動的相對距離。
            int dx = sonIndex * getWidth() - getScrollX();
            // Y方向不變，X方向到目的地。
            mScroller.startScroll(getScrollX(), 0, dx, 0, 500);
            invalidate();
            break;
        }
    }
    return super.onTouchEvent(event);
}

@Override
public void computeScroll() {
    if (mScroller.computeScrollOffset()) {
        scrollTo(mScroller.getCurrX(), mScroller.getCurrY());
        invalidate();
    }
}

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    int childCount = getChildCount();
    // 在Layout 子view以前測量子view大小，在onLayout的時候才能調用getMeasuredWidth()和getMeasuredHeight()。
    for (int i = 0; i < childCount; i++) {
        View childView = getChildAt(i);
        measureChild(childView, widthMeasureSpec, heightMeasureSpec);
    }
}

@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
    if (changed) {
        int childCount = getChildCount();
        for (int i = 0; i < childCount; i++) {
            View childView = getChildAt(i);
            int childW = childView.getMeasuredWidth();

            // 把全部子view放在水平方向，依次排開。
            // left:  0, w, 2w, 3w..
            // top:   0...
            // right: w, 2w, 3w...
            // topL   h...
            childView.layout(i * childW, 0, childW * i + childW, childView.getMeasuredHeight());
        }
    }
}複製代碼

這裏須要解釋的只有這一段代碼：

case MotionEvent.ACTION_UP:
case MotionEvent.ACTION_CANCEL: {
    int sonIndex = (getScrollX() + getWidth() / 2) / getWidth();

    // 若是滑動頁面超過當前頁面數，那麼把屏index定爲最大頁面數的index。
    int childCount = getChildCount();
    if (sonIndex >= childCount)
        sonIndex = childCount - 1;

    // 如今滑動的相對距離。
    int dx = sonIndex * getWidth() - getScrollX();
    // Y方向不變，X方向到目的地。
    mScroller.startScroll(getScrollX(), 0, dx, 0, 500);
    invalidate();
    break;
}複製代碼

當手指鬆開的時候怎麼平滑過分到某一頁呢？

  • 先來看int sonIndex = (getScrollX() + getWidth() / 2) / getWidth();，這句話的意思是拿到從最開始滑動到當前位置的距離 加上 Layout一半的Layout寬 除以Layout寬，獲得的結果是在屏幕上顯示的較多區域的這一屏的子View的index。

    是什麼意思呢？，舉個例子來講，當前向左滑動了一屏，那麼getScrollX()的距離和getWidth的寬度就是相等的，由於滑動了一屏的距離，這個時候若是直接用getScrollX()/getWidth()那麼獲得的結果是1沒有問題。

    若是如今從0屏開始滑，滑了小半屏，此時的getScrollX() < getWidth()，那麼計算出的int必將是0，假如我滑了大半屏，此時計算出的結果又是0，可是根據慣性和四捨五入，咱們滑動大半屏的時候，應該跑到下一屏，因此咱們在getScrollX()/getWidth()以前給getScrollX()加了getWidth()/2的距離，這樣不滿一屏的將會自動補滿一屏。

  • 而後int dx = sonIndex * getWidth() - getScrollX();，目標位置的距離sonIndex * getWidth()減掉已經滑動的距離getScrollX()得出的如今要滑動的相對距離。

此時運行一把，咱們將獲得正確的效果：

仿ViewPager彈性翻頁
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程