Android：滾動視圖停止滾動時檢測

Question

我在Android中使用ScrollView，ScrollView的可見部分與Scrollview中的其中一個單元的大小相同。每個「細胞」是相同的高度。所以我試圖做的是在ScrollView已經滾動之後進入位置。

目前我正在檢測用戶何時觸摸了ScrollView，並且他們已經開始滾動並從那裏開始工作，但是它非常麻煩。它也需要工作，當用戶只是輕彈它，它滾動，然後減速。

在iPhone上有一個類似於didDecelerate的功能，我可以在ScrollView完成滾動時做任何代碼。 Android有這樣的事情嗎？還是有一些我可以看看的代碼來找出更好的方法？

我查看了Android文檔，找不到那樣的東西。

Answer 1

請嘗試在StackOverflow上查看this question - 它與您的問題不完全相同，但它提供了一個關於如何管理ScrollView的滾動事件的想法。

基本上，您需要通過擴展ScrollView並覆蓋onScrollChanged(int x, int y, int oldx, int oldy)來創建自己的CustomScrollView。然後，您需要在佈局文件中引用此參數，而不是像com.mypackage.CustomScrollView這樣的標準ScrollView。

Answer 2

我認爲這已經出現在過去。 AFAIK，你不能很容易檢測到。我的建議是，你看看ScrollView.java（這就是我們如何在Android土地:)中做的事情），並找出如何擴展這個類以提供您正在尋找的功能。這是我想嘗試第一次：

@Override 
protected void onScrollChanged(int l, int t, int oldl, int oldt) { 
    if (mScroller.isFinished()) { 
     // do something, for example call a listener 
    } 
} 

Answer 3

 this.getListView().setOnScrollListener(new OnScrollListener(){ 
     @Override 
     public void onScrollStateChanged(AbsListView view, int scrollState) {} 

     @Override 
     public void onScroll(AbsListView view, int firstVisibleItem, 
      int visibleItemCount, int totalItemCount) { 
        if(firstVisibleItem + visibleItemCount >= totalItemCount) 
           // Last item is shown... 

      } 

希望片斷幫助:)

Answer 4

對於像你所說，你也許可以逃脫首要一扔方法在您的自定義滾動視圖一個簡單的例子。每次用戶從屏幕上擡起手指時，都會調用Fling方法來執行「減速」。

所以，你應該做的是這樣的：

1. 子類滾動型。

   public class MyScrollView extends ScrollView { 
   
       private Scroller scroller; 
       private Runnable scrollerTask; 
   
       //... 
   
       public MyScrollView(Context context, AttributeSet attrs) { 
        super(context, attrs); 
   
        scroller = new Scroller(getContext()); //or OverScroller for 3.0+ 
        scrollerTask = new Runnable() { 
         @Override 
         public void run() { 
          scroller.computeScrollOffset(); 
          scrollTo(0, scroller.getCurrY()); 
   
          if (!scroller.isFinished()) { 
           MyScrollView.this.post(this); 
          } else { 
           //deceleration ends here, do your code 
          } 
         } 
        }; 
        //... 
       } 
   } 
   

2. 子類拋出方法和不要調用超類的實現。如果用戶停止舉起他的手指（velocityY == 0）之前滾動

   @Override 
   public void fling(int velocityY) { 
       scroller.fling(getScrollX(), getScrollY(), 0, velocityY, 0, 0, 0, container.getHeight()); 
       post(scrollerTask); 
   
       //add any extra functions you need from android source code: 
       //show scroll bars 
       //change focus 
       //etc. 
   } 
   

3. 一扔不會觸發。如果你想攔截這類事件，也可以重寫onTouchEvent。

   @Override 
   public boolean onTouchEvent(MotionEvent ev) { 
       boolean eventConsumed = super.onTouchEvent(ev); 
       if (eventConsumed && ev.getAction() == MotionEvent.ACTION_UP) { 
        if (scroller.isFinished()) { 
         //do your code 
        } 
       } 
       return eventConsumed; 
   } 
   

注：雖然這個工程，覆蓋一扔方法可能是一個壞主意。它是公開的，但它幾乎沒有爲子類設計。現在它做了3件事 - 它啓動私有mScroller的處理，處理可能的焦點變化並顯示滾動條。這可能會改變未來的Android版本。例如，私人mScroller實例將其類從Scroller更改爲OvershootScroller在2.3和3.0之間。你必須記住所有這些微小的差異。無論如何，準備好將來出現不可預見的後果。

Answer 5

我子類（水平）滾動型，做了這樣的事情：

@Override 
protected void onScrollChanged(int x, int y, int oldX, int oldY) { 
    if (Math.abs(x - oldX) > SlowDownThreshold) { 
     currentlyScrolling = true; 
    } else { 
     currentlyScrolling = false; 
     if (!currentlyTouching) { 
      //scrolling stopped...handle here 
     } 
    } 
    super.onScrollChanged(x, y, oldX, oldY); 
} 

我用值1的SlowDownThreshold，因爲它似乎總是最後一個onScrollChanged事件的差異。

爲了使這個慢慢拖動時表現正常，我不得不這樣做：

@Override 
public boolean onInterceptTouchEvent(MotionEvent event) { 
    switch (event.getAction()) { 
     case MotionEvent.ACTION_DOWN: 
      currentlyTouching = true; 
    } 
    return super.onInterceptTouchEvent(event); 
} 

@Override 
public boolean onTouch(View view, MotionEvent event) { 
    switch (event.getAction()) { 
     case MotionEvent.ACTION_UP: 
     case MotionEvent.ACTION_CANCEL: 
      currentlyTouching = false; 
      if (!currentlyScrolling) { 
       //I handle the release from a drag here 
       return true; 
      } 
    } 
    return false; 
} 

Answer 6

我最近有實現您所描述的功能。我所做的就是通過比較第一次觸發onTouchEvent時由getScrollY（）返回的值與變量newCheck定義的時間後返回的值來讓ScrollView停止滾動，從而讓Runnable檢出。下面

見代碼（工作液）：

public class MyScrollView extends ScrollView{ 

private Runnable scrollerTask; 
private int initialPosition; 

private int newCheck = 100; 
private static final String TAG = "MyScrollView"; 

public interface OnScrollStoppedListener{ 
    void onScrollStopped(); 
} 

private OnScrollStoppedListener onScrollStoppedListener; 

public MyScrollView(Context context, AttributeSet attrs) { 
    super(context, attrs); 

    scrollerTask = new Runnable() { 

     public void run() { 

      int newPosition = getScrollY(); 
      if(initialPosition - newPosition == 0){//has stopped 

       if(onScrollStoppedListener!=null){ 

        onScrollStoppedListener.onScrollStopped(); 
       } 
      }else{ 
       initialPosition = getScrollY(); 
       MyScrollView.this.postDelayed(scrollerTask, newCheck); 
      } 
     } 
    }; 
} 

public void setOnScrollStoppedListener(MyScrollView.OnScrollStoppedListener listener){ 
    onScrollStoppedListener = listener; 
} 

public void startScrollerTask(){ 

    initialPosition = getScrollY(); 
    MyScrollView.this.postDelayed(scrollerTask, newCheck); 
} 

} 

那麼我：

scroll.setOnTouchListener(new OnTouchListener() { 

     public boolean onTouch(View v, MotionEvent event) { 

      if (event.getAction() == MotionEvent.ACTION_UP) { 

       scroll.startScrollerTask(); 
      } 

      return false; 
     } 
}); 
scroll.setOnScrollStoppedListener(new OnScrollStoppedListener() { 

     public void onScrollStopped() { 

      Log.i(TAG, "stopped"); 

     } 
}); 

BTW，我用我一些想法從對方回覆要做到這一點我的應用程序。 希望這有助於。有任何問題請隨時詢問我（們）。 乾杯。

Answer 7

我對這個問題的方法是使用計時器來檢查以下2個「事件」。

1）onScrollChanged（）停止被稱爲

2）用戶的手指擡離了滾動

public class CustomScrollView extends HorizontalScrollView { 

public CustomScrollView(Context context, AttributeSet attrs) { 
    super(context, attrs); 
} 

Timer ntimer = new Timer(); 
MotionEvent event; 

@Override 
protected void onScrollChanged(int l, int t, int oldl, int oldt) 
{ 
    checkAgain(); 
    super.onScrollChanged(l, t, oldl, oldt); 
} 

public void checkAgain(){ 
    try{ 
     ntimer.cancel(); 
     ntimer.purge(); 
    } 
    catch(Exception e){} 
    ntimer = new Timer(); 
    ntimer.schedule(new TimerTask() { 

     @Override 
     public void run() { 

      if(event.getAction() == MotionEvent.ACTION_UP){ 
       // ScrollView Stopped Scrolling and Finger is not on the ScrollView 
      } 
      else{ 
       // ScrollView Stopped Scrolling But Finger is still on the ScrollView 
       checkAgain(); 
      } 
     } 
    },100); 

} 

@Override 
public boolean onTouchEvent(MotionEvent event) { 
    this.event = event; 
    return super.onTouchEvent(event); 
    } 
} 

Answer 8

這裏又是一個固定的，恕我直言，缺少了滾動OnEndScroll事件的錯誤。

它的靈感來自hambonious答案。 只需拖放這個類到你的項目（變化包以符合您自己），並使用如下XML

package com.thecrag.components.ui; 

import android.content.Context; 
import android.util.AttributeSet; 
import android.widget.ScrollView; 

public class ResponsiveScrollView extends ScrollView { 

    public interface OnEndScrollListener { 
     public void onEndScroll(); 
    } 

    private boolean mIsFling; 
    private OnEndScrollListener mOnEndScrollListener; 

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

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

    public ResponsiveScrollView(Context context, AttributeSet attrs, int defStyle) { 
     super(context, attrs, defStyle); 
    } 

    @Override 
    public void fling(int velocityY) { 
     super.fling(velocityY); 
     mIsFling = true; 
    } 

    @Override 
    protected void onScrollChanged(int x, int y, int oldX, int oldY) { 
     super.onScrollChanged(x, y, oldX, oldY); 
     if (mIsFling) { 
      if (Math.abs(y - oldY) < 2 || y >= getMeasuredHeight() || y == 0) { 
       if (mOnEndScrollListener != null) { 
        mOnEndScrollListener.onEndScroll(); 
       } 
       mIsFling = false; 
      } 
     } 
    } 

    public OnEndScrollListener getOnEndScrollListener() { 
     return mOnEndScrollListener; 
    } 

    public void setOnEndScrollListener(OnEndScrollListener mOnEndScrollListener) { 
     this.mOnEndScrollListener = mOnEndScrollListener; 
    } 

} 

再次改變包的名稱以匹配您的項目

<com.thecrag.components.ui.ResponsiveScrollView 
     android:id="@+id/welcome_scroller" 
     android:layout_width="wrap_content" 
     android:layout_height="wrap_content" 
     android:layout_above="@+id/welcome_scroll_command_help_container" 
     android:layout_alignParentLeft="true" 
     android:layout_alignParentRight="true" 
     android:layout_below="@+id/welcome_header_text_thecrag" 
     android:layout_margin="6dp"> 
    .... 
</com.thecrag.components.ui.ResponsiveScrollView> 

Answer 9

我已經做了一些改進以ZeroG的答案。主要是取消多餘的任務調用，並將整個事件作爲私有的OnTouchListener實現，因此所有的滾動檢測代碼都集中在一個地方。

下面的代碼粘貼到你自己的滾動型的實現：

private class ScrollFinishHandler implements OnTouchListener 
{ 
     private static final int SCROLL_TASK_INTERVAL = 100; 

     private Runnable mScrollerTask; 
     private int   mInitialPosition = 0; 

     public ScrollFinishHandler() 
     { 
      mScrollerTask = new Runnable() { 

       public void run() { 

        int newPosition = getScrollY(); 
        if(mInitialPosition - newPosition == 0) 
        {//has stopped 

         onScrollStopped(); // Implement this on your main ScrollView class 
        }else{ 
         mInitialPosition = getScrollY(); 
         ExpandingLinearLayout.this.postDelayed(mScrollerTask, SCROLL_TASK_INTERVAL); 
        } 
       } 
      }; 
     } 

     @Override 
     public boolean onTouch(View v, MotionEvent event) 
     { 
      if (event.getAction() == MotionEvent.ACTION_UP) 
      { 

       startScrollerTask(); 
      } 
      else 
      { 
       stopScrollerTask(); 
      } 

      return false; 
     } 

} 

，然後在滾動型實現：

setOnTouchListener(new ScrollFinishHandler()); 

Answer 10

有一些偉大的答案在這裏，但滾動停止時，我的代碼，可以檢測而無需擴展ScrollView類。每個視圖實例都可以調用getViewTreeObserver（）。當持有ViewTreeObserver的這個實例時，您可以使用函數addOnScrollChangedListener（）添加一個OnScrollChangedListener。

聲明如下：

private ScrollView scrollListener; 
private volatile long milesec; 

private Handler scrollStopDetector; 
private Thread scrollcalled = new Thread() { 

    @Override 
    public void run() { 
     if (System.currentTimeMillis() - milesec > 200) { 
      //scroll stopped - put your code here 
     } 
    } 
}; 

，並在您的onCreate（或其他地方）地址：

scrollListener = (ScrollView) findViewById(R.id.scroll); 

    scrollListener.getViewTreeObserver().addOnScrollChangedListener(new OnScrollChangedListener() { 

     @Override 
     public void onScrollChanged() { 
      milesec = System.currentTimeMillis(); 
      scrollStopDetector.postDelayed(scrollcalled, 200); 
     } 
    }); 

你可能想這個檢查之間需要更長或更慢的時間，但滾動這個時listner被調用得非常快，所以它的工作速度非常快。

Answer 11

我的方法是通過每次調用onScrollChanged（）時更改的時間戳來確定滾動狀態。 確定何時開始和結束滾動很容易。 您也可以更改閾值（我使用100ms）來修復靈敏度。

public class CustomScrollView extends ScrollView { 
    private long lastScrollUpdate = -1; 

    private class ScrollStateHandler implements Runnable { 

     @Override 
     public void run() { 
      long currentTime = System.currentTimeMillis(); 
      if ((currentTime - lastScrollUpdate) > 100) { 
       lastScrollUpdate = -1; 
       onScrollEnd(); 
      } else { 
       postDelayed(this, 100); 
      } 
     } 
    } 

    @Override 
    protected void onScrollChanged(int l, int t, int oldl, int oldt) { 
     super.onScrollChanged(l, t, oldl, oldt); 
     if (lastScrollUpdate == -1) { 
      onScrollStart(); 
      postDelayed(new ScrollStateHandler(), 100); 
     } 

     lastScrollUpdate = System.currentTimeMillis(); 
    } 

    private void onScrollStart() { 
     // do something 
    } 

    private void onScrollEnd() { 
     // do something 
    } 

} 

Answer 12

這裏是我的解決方案，包括滾動跟蹤和滾動結束：

public class ObservableHorizontalScrollView extends HorizontalScrollView { 
    public interface OnScrollListener { 
     public void onScrollChanged(ObservableHorizontalScrollView scrollView, int x, int y, int oldX, int oldY); 
     public void onEndScroll(ObservableHorizontalScrollView scrollView); 
    } 

    private boolean mIsScrolling; 
    private boolean mIsTouching; 
    private Runnable mScrollingRunnable; 
    private OnScrollListener mOnScrollListener; 

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

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

    public ObservableHorizontalScrollView(Context context, AttributeSet attrs, int defStyle) { 
     super(context, attrs, defStyle); 
    } 

    @Override 
    public boolean onTouchEvent(MotionEvent ev) { 
     int action = ev.getAction(); 

     if (action == MotionEvent.ACTION_MOVE) { 
      mIsTouching = true; 
      mIsScrolling = true; 
     } else if (action == MotionEvent.ACTION_UP) { 
      if (mIsTouching && !mIsScrolling) { 
       if (mOnScrollListener != null) { 
        mOnScrollListener.onEndScroll(this); 
       } 
      } 

      mIsTouching = false; 
     } 

     return super.onTouchEvent(ev); 
    } 

    @Override 
    protected void onScrollChanged(int x, int y, int oldX, int oldY) { 
     super.onScrollChanged(x, y, oldX, oldY); 

     if (Math.abs(oldX - x) > 0) { 
      if (mScrollingRunnable != null) { 
       removeCallbacks(mScrollingRunnable); 
      } 

      mScrollingRunnable = new Runnable() { 
       public void run() { 
        if (mIsScrolling && !mIsTouching) { 
         if (mOnScrollListener != null) { 
          mOnScrollListener.onEndScroll(ObservableHorizontalScrollView.this); 
         } 
        } 

        mIsScrolling = false; 
        mScrollingRunnable = null; 
       } 
      }; 

      postDelayed(mScrollingRunnable, 200); 
     } 

     if (mOnScrollListener != null) { 
      mOnScrollListener.onScrollChanged(this, x, y, oldX, oldY); 
     } 
    } 

    public OnScrollListener getOnScrollListener() { 
     return mOnScrollListener; 
    } 

    public void setOnScrollListener(OnScrollListener mOnEndScrollListener) { 
     this.mOnScrollListener = mOnEndScrollListener; 
    } 

} 

Answer 13

這裏又是另一種解決辦法，很簡單，清潔在我看來，通過上述答案自然的啓發。基本上一旦用戶結束了手勢檢查getScrollY（）是否仍然在短暫延遲（此處爲50ms）後發生變化。

public class ScrollViewWithOnStopListener extends ScrollView { 

    OnScrollStopListener listener; 

    public interface OnScrollStopListener { 
     void onScrollStopped(int y); 
    } 

    public ScrollViewWithOnStopListener(Context context) { 
     super(context); 
    } 

    public ScrollViewWithOnStopListener(Context context, AttributeSet attrs) { 
     super(context, attrs); 
    } 

    @Override 
    public boolean onTouchEvent(MotionEvent ev) { 
     switch (ev.getAction()) { 
      case MotionEvent.ACTION_UP: 
       checkIfScrollStopped(); 
     } 

     return super.onTouchEvent(ev); 
    } 

    int initialY = 0; 

    private void checkIfScrollStopped() { 
     initialY = getScrollY(); 
     this.postDelayed(new Runnable() { 
      @Override 
      public void run() { 
       int updatedY = getScrollY(); 
       if (updatedY == initialY) { 
        //we've stopped 
        if (listener != null) { 
         listener.onScrollStopped(getScrollY()); 
        } 
       } else { 
        initialY = updatedY; 
        checkIfScrollStopped(); 
       } 
      } 
     }, 50); 
    } 

    public void setOnScrollStoppedListener(OnScrollStopListener yListener) { 
     listener = yListener; 
    } 
} 

Answer 14

我的解決方案是Lin Yu Cheng的一個很好的解決方案的變體，它還檢測滾動開始和停止的時間。

步驟1.定義一個Horizo​​ntalScrollView和OnScrollChangedListener：

CustomHorizontalScrollView scrollView = (CustomHorizontalScrollView) findViewById(R.id.horizontalScrollView); 

horizontalScrollListener = new CustomHorizontalScrollView.OnScrollChangedListener() { 
    @Override 
    public void onScrollStart() { 
     // Scrolling has started. Insert your code here... 
    } 

    @Override 
    public void onScrollEnd() { 
     // Scrolling has stopped. Insert your code here... 
    } 
}; 

scrollView.setOnScrollChangedListener(horizontalScrollListener); 

第2步：添加CustomHorizo​​ntalScrollView類：

public class CustomHorizontalScrollView extends HorizontalScrollView { 
    public interface OnScrollChangedListener { 
     // Developer must implement these methods. 
     void onScrollStart(); 
     void onScrollEnd(); 
    } 

    private long lastScrollUpdate = -1; 
    private int scrollTaskInterval = 100; 
    private Runnable mScrollingRunnable; 
    public OnScrollChangedListener mOnScrollListener; 

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

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

    public CustomHorizontalScrollView(Context context, AttributeSet attrs, int defStyle) { 
     super(context, attrs, defStyle); 
     init(context); 
    } 

    private void init(Context context) { 
     // Check for scrolling every scrollTaskInterval milliseconds 
     mScrollingRunnable = new Runnable() { 
      public void run() { 
       if ((System.currentTimeMillis() - lastScrollUpdate) > scrollTaskInterval) { 
        // Scrolling has stopped. 
        lastScrollUpdate = -1; 
        //CustomHorizontalScrollView.this.onScrollEnd(); 
        mOnScrollListener.onScrollEnd(); 
       } else { 
        // Still scrolling - Check again in scrollTaskInterval milliseconds... 
        postDelayed(this, scrollTaskInterval); 
       } 
      } 
     }; 
    } 

    public void setOnScrollChangedListener(OnScrollChangedListener onScrollChangedListener) { 
     this.mOnScrollListener = onScrollChangedListener; 
    } 

    public void setScrollTaskInterval(int scrollTaskInterval) { 
     this.scrollTaskInterval = scrollTaskInterval; 
    } 

    //void onScrollStart() { 
    // System.out.println("Scroll started..."); 
    //} 

    //void onScrollEnd() { 
    // System.out.println("Scroll ended..."); 
    //} 

    @Override 
    protected void onScrollChanged(int l, int t, int oldl, int oldt) { 
     super.onScrollChanged(l, t, oldl, oldt); 
     if (mOnScrollListener != null) { 
      if (lastScrollUpdate == -1) { 
       //CustomHorizontalScrollView.this.onScrollStart(); 
       mOnScrollListener.onScrollStart(); 
       postDelayed(mScrollingRunnable, scrollTaskInterval); 
      } 

      lastScrollUpdate = System.currentTimeMillis(); 
     } 
    } 
}