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(); 
     } 
    } 
}