Android 使用Scroller实现绚丽的ListView左右滑动删除Item效果

转帖请注明本文出自xiaanming的博客（http://blog.csdn.net/xiaanming/article/details/17539199），请尊重他人的辛勤劳动成果，谢谢！

我在上一篇文章中Android 带你从源码的角度解析Scroller的滚动实现原理从源码的角度介绍了Scroller的滚动实现原理，相信大家对Scroller的使用有一定的了解，这篇文章就给大家带来使用Scroller的小例子，来帮助大家更加熟悉的掌握Scroller的使用，掌握好了Scroller的使用我们就能实现很多滑动的效果。例如侧滑菜单，launcher，ListView的下拉刷新等等效果，我今天实现的是ListView的item的左右滑动删除item的效果，现在很多朋友看到这个效果应该是在Android的通知栏下拉中看到这个滑动删除的效果吧，我看到这个效果是在我之前的三星手机上左右滑动打电话发短信的效果，感觉很棒，不过现在很多手机联系人滑动都不是我之前那台手机的效果啦，网上很多朋友也写了关于滑动删除ListView的item的例子，有些是滑动手指离开之后然后给item加向左或者向右的移动动画，我觉得这样子的用户体验不是很好，所以今天自己也写了一个关于ListView左右滑动删除Item的小例子,ListView的item会随着手指在屏幕上的滑动而滑动，手指离开屏幕的时候item会根据判断向左或者向右划出屏幕，就是跟通知栏的效果差不多，接下来就带大家来实现这个效果。

先说下实现该效果的主要思路

1. 先根据手指触摸的点来获取点击的是ListView的哪一个item
2. 手指在屏幕中滑动我们利用scrollBy()来使该item跟随手指一起滑动
3. 手指放开的时候，我们判断手指拖动的距离来判断item到底是滑出屏幕还是回到开始位置

主要思路就是上面这三步，接下来我们就用代码来实现吧，首先我们新建一个项目，叫SlideCutListView

根据需求我们需要自己自定义一个ListView来实现该功能，接下来先贴出代码再讲解具体的实现

[java]  view plain  copy

 

1. package com.example.slidecutlistview;  
2.   
3. import android.content.Context;  
4. import android.util.AttributeSet;  
5. import android.view.MotionEvent;  
6. import android.view.VelocityTracker;  
7. import android.view.View;  
8. import android.view.ViewConfiguration;  
9. import android.view.WindowManager;  
10. import android.widget.AdapterView;  
11. import android.widget.ListView;  
12. import android.widget.Scroller;  
13.   
14. /** 
15.  * @blog http://blog.csdn.net/xiaanming 
16.  *  
17.  * @author xiaanming 
18.  *  
19.  */  
20. public class SlideCutListView extends ListView {  
21.     /** 
22.      * 当前滑动的ListView　position 
23.      */  
24.     private int slidePosition;  
25.     /** 
26.      * 手指按下X的坐标 
27.      */  
28.     private int downY;  
29.     /** 
30.      * 手指按下Y的坐标 
31.      */  
32.     private int downX;  
33.     /** 
34.      * 屏幕宽度 
35.      */  
36.     private int screenWidth;  
37.     /** 
38.      * ListView的item 
39.      */  
40.     private View itemView;  
41.     /** 
42.      * 滑动类 
43.      */  
44.     private Scroller scroller;  
45.     private static final int SNAP_VELOCITY = 600;  
46.     /** 
47.      * 速度追踪对象 
48.      */  
49.     private VelocityTracker velocityTracker;  
50.     /** 
51.      * 是否响应滑动，默认为不响应 
52.      */  
53.     private boolean isSlide = false;  
54.     /** 
55.      * 认为是用户滑动的最小距离 
56.      */  
57.     private int mTouchSlop;  
58.     /** 
59.      *  移除item后的回调接口 
60.      */  
61.     private RemoveListener mRemoveListener;  
62.     /** 
63.      * 用来指示item滑出屏幕的方向,向左或者向右,用一个枚举值来标记 
64.      */  
65.     private RemoveDirection removeDirection;  
66.   
67.     // 滑动删除方向的枚举值  
68.     public enum RemoveDirection {  
69.         RIGHT, LEFT;  
70.     }  
71.   
72.   
73.     public SlideCutListView(Context context) {  
74.         this(context, null);  
75.     }  
76.   
77.     public SlideCutListView(Context context, AttributeSet attrs) {  
78.         this(context, attrs, 0);  
79.     }  
80.   
81.     public SlideCutListView(Context context, AttributeSet attrs, int defStyle) {  
82.         super(context, attrs, defStyle);  
83.         screenWidth = ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay().getWidth();  
84.         scroller = new Scroller(context);  
85.         mTouchSlop = ViewConfiguration.get(getContext()).getScaledTouchSlop();  
86.     }  
87.       
88.     /** 
89.      * 设置滑动删除的回调接口 
90.      * @param removeListener 
91.      */  
92.     public void setRemoveListener(RemoveListener removeListener) {  
93.         this.mRemoveListener = removeListener;  
94.     }  
95.   
96.     /** 
97.      * 分发事件，主要做的是判断点击的是那个item, 以及通过postDelayed来设置响应左右滑动事件 
98.      */  
99.     @Override  
100.     public boolean dispatchTouchEvent(MotionEvent event) {  
101.         switch (event.getAction()) {  
102.         case MotionEvent.ACTION_DOWN: {  
103.             addVelocityTracker(event);  
104.   
105.             // 假如scroller滚动还没有结束，我们直接返回  
106.             if (!scroller.isFinished()) {  
107.                 return super.dispatchTouchEvent(event);  
108.             }  
109.             downX = (int) event.getX();  
110.             downY = (int) event.getY();  
111.   
112.             slidePosition = pointToPosition(downX, downY);  
113.   
114.             // 无效的position, 不做任何处理  
115.             if (slidePosition == AdapterView.INVALID_POSITION) {  
116.                 return super.dispatchTouchEvent(event);  
117.             }  
118.   
119.             // 获取我们点击的item view  
120.             itemView = getChildAt(slidePosition - getFirstVisiblePosition());  
121.             break;  
122.         }  
123.         case MotionEvent.ACTION_MOVE: {  
124.             if (Math.abs(getScrollVelocity()) > SNAP_VELOCITY  
125.                     || (Math.abs(event.getX() - downX) > mTouchSlop && Math  
126.                             .abs(event.getY() - downY) < mTouchSlop)) {  
127.                 isSlide = true;  
128.                   
129.             }  
130.             break;  
131.         }  
132.         case MotionEvent.ACTION_UP:  
133.             recycleVelocityTracker();  
134.             break;  
135.         }  
136.   
137.         return super.dispatchTouchEvent(event);  
138.     }  
139.   
140.     /** 
141.      * 往右滑动，getScrollX()返回的是左边缘的距离，就是以View左边缘为原点到开始滑动的距离，所以向右边滑动为负值 
142.      */  
143.     private void scrollRight() {  
144.         removeDirection = RemoveDirection.RIGHT;  
145.         final int delta = (screenWidth + itemView.getScrollX());  
146.         // 调用startScroll方法来设置一些滚动的参数，我们在computeScroll()方法中调用scrollTo来滚动item  
147.         scroller.startScroll(itemView.getScrollX(), 0, -delta, 0,  
148.                 Math.abs(delta));  
149.         postInvalidate(); // 刷新itemView  
150.     }  
151.   
152.     /** 
153.      * 向左滑动，根据上面我们知道向左滑动为正值 
154.      */  
155.     private void scrollLeft() {  
156.         removeDirection = RemoveDirection.LEFT;  
157.         final int delta = (screenWidth - itemView.getScrollX());  
158.         // 调用startScroll方法来设置一些滚动的参数，我们在computeScroll()方法中调用scrollTo来滚动item  
159.         scroller.startScroll(itemView.getScrollX(), 0, delta, 0,  
160.                 Math.abs(delta));  
161.         postInvalidate(); // 刷新itemView  
162.     }  
163.   
164.     /** 
165.      * 根据手指滚动itemView的距离来判断是滚动到开始位置还是向左或者向右滚动 
166.      */  
167.     private void scrollByDistanceX() {  
168.         // 如果向左滚动的距离大于屏幕的二分之一，就让其删除  
169.         if (itemView.getScrollX() >= screenWidth / 2) {  
170.             scrollLeft();  
171.         } else if (itemView.getScrollX() <= -screenWidth / 2) {  
172.             scrollRight();  
173.         } else {  
174.             // 滚回到原始位置,为了偷下懒这里是直接调用scrollTo滚动  
175.             itemView.scrollTo(0, 0);  
176.         }  
177.   
178.     }  
179.   
180.     /** 
181.      * 处理我们拖动ListView item的逻辑 
182.      */  
183.     @Override  
184.     public boolean onTouchEvent(MotionEvent ev) {  
185.         if (isSlide && slidePosition != AdapterView.INVALID_POSITION) {  
186.             requestDisallowInterceptTouchEvent(true);  
187.             addVelocityTracker(ev);  
188.             final int action = ev.getAction();  
189.             int x = (int) ev.getX();  
190.             switch (action) {  
191.             case MotionEvent.ACTION_DOWN:  
192.                 break;  
193.             case MotionEvent.ACTION_MOVE:  
194.                   
195.                 MotionEvent cancelEvent = MotionEvent.obtain(ev);  
196.                 cancelEvent.setAction(MotionEvent.ACTION_CANCEL |  
197.                            (ev.getActionIndex()<< MotionEvent.ACTION_POINTER_INDEX_SHIFT));  
198.                 onTouchEvent(cancelEvent);  
199.                   
200.                 int deltaX = downX - x;  
201.                 downX = x;  
202.   
203.                 // 手指拖动itemView滚动, deltaX大于0向左滚动，小于0向右滚  
204.                 itemView.scrollBy(deltaX, 0);  
205.                   
206.                 return true;  //拖动的时候ListView不滚动  
207.             case MotionEvent.ACTION_UP:  
208.                 int velocityX = getScrollVelocity();  
209.                 if (velocityX > SNAP_VELOCITY) {  
210.                     scrollRight();  
211.                 } else if (velocityX < -SNAP_VELOCITY) {  
212.                     scrollLeft();  
213.                 } else {  
214.                     scrollByDistanceX();  
215.                 }  
216.                   
217.                 recycleVelocityTracker();  
218.                 // 手指离开的时候就不响应左右滚动  
219.                 isSlide = false;  
220.                 break;  
221.             }  
222.         }  
223.   
224.         //否则直接交给ListView来处理onTouchEvent事件  
225.         return super.onTouchEvent(ev);  
226.     }  
227.   
228.     @Override  
229.     public void computeScroll() {  
230.         // 调用startScroll的时候scroller.computeScrollOffset()返回true，  
231.         if (scroller.computeScrollOffset()) {  
232.             // 让ListView item根据当前的滚动偏移量进行滚动  
233.             itemView.scrollTo(scroller.getCurrX(), scroller.getCurrY());  
234.               
235.             postInvalidate();  
236.   
237.             // 滚动动画结束的时候调用回调接口  
238.             if (scroller.isFinished()) {  
239.                 if (mRemoveListener == null) {  
240.                     throw new NullPointerException("RemoveListener is null, we should called setRemoveListener()");  
241.                 }  
242.                   
243.                 itemView.scrollTo(0, 0);  
244.                 mRemoveListener.removeItem(removeDirection, slidePosition);  
245.             }  
246.         }  
247.     }  
248.   
249.     /** 
250.      * 添加用户的速度跟踪器 
251.      *  
252.      * @param event 
253.      */  
254.     private void addVelocityTracker(MotionEvent event) {  
255.         if (velocityTracker == null) {  
256.             velocityTracker = VelocityTracker.obtain();  
257.         }  
258.   
259.         velocityTracker.addMovement(event);  
260.     }  
261.   
262.     /** 
263.      * 移除用户速度跟踪器 
264.      */  
265.     private void recycleVelocityTracker() {  
266.         if (velocityTracker != null) {  
267.             velocityTracker.recycle();  
268.             velocityTracker = null;  
269.         }  
270.     }  
271.   
272.     /** 
273.      * 获取X方向的滑动速度,大于0向右滑动，反之向左 
274.      *  
275.      * @return 
276.      */  
277.     private int getScrollVelocity() {  
278.         velocityTracker.computeCurrentVelocity(1000);  
279.         int velocity = (int) velocityTracker.getXVelocity();  
280.         return velocity;  
281.     }  
282.   
283.     /** 
284.      *  
285.      * 当ListView item滑出屏幕，回调这个接口 
286.      * 我们需要在回调方法removeItem()中移除该Item,然后刷新ListView 
287.      *  
288.      * @author xiaanming 
289.      * 
290.      */  
291.     public interface RemoveListener {  
292.         public void removeItem(RemoveDirection direction, int position);  
293.     }  
294.   
295. }  

• 首先我们重写dispatchTouchEvent（）方法，该方法是事件的分发方法，我们在里面只做了一些简单的步骤，我们按下屏幕的时候，如果某个item正在进行滚动，我们直接交给SlideCutListView的父类处理分发事件，否则根据点击的X,Y坐标利用pointToPosition(int x, int y)来获取点击的是ListView的哪一个position，从而获取到我们需要滑动的item的View，我们还在该方法加入了滑动速度的检测，并且在ACTION_MOVE的时候来判断是否响应item的左右移动，用isSlide来记录是否响应左右滑动
• 然后就是重写onTouchEvent()方法，我们先判断isSlide为true,并且我们点击的是ListView上面的有效的position,否则直接交给SlideCutListView的父类也就是ListView来处理，在ACTION_MOVE中调用scrollBy()来移动item,scrollBy()是相对item的上一个位置进行移动的，所以我们每次都要用现在移动的距离减去上一个位置的距离然后赋给scrollBy()方法，这样子我们就实现了item的平滑移动，当我们将手指抬起的时候，我们先根据手指滑动的速度来确定是item是滑出屏幕还是滑动至原始位置，如果向右的速度大于我们设置的SNAP_VELOCITY，item就调用scrollRight()方法滚出屏幕，如果向左的速度小于-SNAP_VELOCITY，则调用scrollLeft()向左滚出屏幕，如果我们是缓慢的移动item，则调用scrollByDistanceX（）方法来判断是滚到那个位置

在scrollRight()和scrollLeft()方法中我们使用Scroller类的startScroll()方法先设置滚动的参数，然后调用postInvalidate()来刷新界面，界面刷新就会调用computeScroll()方法，我们在里面处理滚动逻辑就行了，值得一提的是computeScroll()里面的这段代码

[java]  view plain  copy

 

1. itemView.scrollTo(0, 0);  

我们需要将该item滚动在（0, 0 ）这个点，因为我们只是将ListView的Item滚动出屏幕而已，并没有将该item移除，而且我们不能手动调用removeView()来从ListView中移除该item，我们只能通过改变ListView的数据，然后通过notifyDataSetChanged()来刷新ListView,所以我们需要将其滚动至(0, 0),这里比较关键。

定义好了我们左右滑动的ListView,接下来就来使用它，布局很简单，一个RelativeLayout包裹我们自定义的ListView

[html]  view plain  copy

 

1. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"  
2.     xmlns:tools="http://schemas.android.com/tools"  
3.     android:layout_width="match_parent"  
4.     android:layout_height="match_parent"  
5.     android:background="@android:color/darker_gray">  
6.   
7.     <com.example.slidecutlistview.SlideCutListView  
8.         android:id="@+id/slideCutListView"  
9.         android:layout_width="match_parent"  
10.         android:layout_height="match_parent"   
11.         android:listSelector="@android:color/transparent"  
12.         android:divider="@drawable/reader_item_divider"  
13.         android:cacheColorHint="@android:color/transparent">  
14.     </com.example.slidecutlistview.SlideCutListView>  
15.   
16. </RelativeLayout>  

接下来我们来看看ListView的item的布局

[html]  view plain  copy

 

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
3.     android:layout_width="fill_parent"  
4.     android:layout_height="wrap_content" >  
5.   
6.     <LinearLayout  
7.         android:layout_width="fill_parent"  
8.         android:layout_height="wrap_content"  
9.         android:background="@drawable/friendactivity_comment_detail_list2" >  
10.   
11.         <TextView  
12.             android:id="@+id/list_item"  
13.             android:layout_width="match_parent"  
14.             android:layout_height="wrap_content"  
15.             android:layout_margin="15dip" />  
16.     </LinearLayout>  
17.   
18. </LinearLayout>  

还记得我在上一篇文章中提到过调用scrollTo()方法是对里面的子View进行滚动的，而不是对整个布局进行滚动的，所以我们用LinearLayout来套住我们的item的布局，这点需要注意一下，不然滚动的只是TextView。

主页面MainActivity里面的代码比较简单,里面使用的也是ArrayAdapter，相信大家都能看懂

[html]  view plain  copy

 

1. package com.example.slidecutlistview;  
2.   
3. import java.util.ArrayList;  
4. import java.util.List;  
5.   
6. import android.app.Activity;  
7. import android.os.Bundle;  
8. import android.view.View;  
9. import android.widget.AdapterView;  
10. import android.widget.AdapterView.OnItemClickListener;  
11. import android.widget.ArrayAdapter;  
12. import android.widget.Toast;  
13.   
14. import com.example.slidecutlistview.SlideCutListView.RemoveDirection;  
15. import com.example.slidecutlistview.SlideCutListView.RemoveListener;  
16.   
17. public class MainActivity extends Activity implements RemoveListener{  
18.     private SlideCutListView slideCutListView ;  
19.     private ArrayAdapter<String> adapter;  
20.     private List<String> dataSourceList = new ArrayList<String>();  
21.   
22.     @Override  
23.     protected void onCreate(Bundle savedInstanceState) {  
24.         super.onCreate(savedInstanceState);  
25.         setContentView(R.layout.activity_main);  
26.         init();  
27.     }  
28.   
29.     private void init() {  
30.         slideCutListView = (SlideCutListView) findViewById(R.id.slideCutListView);  
31.         slideCutListView.setRemoveListener(this);  
32.           
33.         for(int i=0; i<20; i++){  
34.             dataSourceList.add("滑动删除" + i);   
35.         }  
36.           
37.         adapter = new ArrayAdapter<String>(this, R.layout.listview_item, R.id.list_item, dataSourceList);  
38.         slideCutListView.setAdapter(adapter);  
39.           
40.         slideCutListView.setOnItemClickListener(new OnItemClickListener() {  
41.   
42.             @Override  
43.             public void onItemClick(AdapterView<?> parent, View view,  
44.                     int position, long id) {  
45.                 Toast.makeText(MainActivity.this, dataSourceList.get(position), Toast.LENGTH_SHORT).show();  
46.             }  
47.         });  
48.     }  
49.   
50.       
51.     //滑动删除之后的回调方法  
52.     @Override  
53.     public void removeItem(RemoveDirection direction, int position) {  
54.         adapter.remove(adapter.getItem(position));  
55.         switch (direction) {  
56.         case RIGHT:  
57.             Toast.makeText(this, "向右删除  "+ position, Toast.LENGTH_SHORT).show();  
58.             break;  
59.         case LEFT:  
60.             Toast.makeText(this, "向左删除  "+ position, Toast.LENGTH_SHORT).show();  
61.             break;  
62.   
63.         default:  
64.             break;  
65.         }  
66.           
67.     }     
68.   
69.   
70. }  

这里面需要对SlideCutListView设置RemoveListener，然后我们在回调方法removeItem(RemoveDirection direction, int position)中删除该position的数据，在调用notifyDataSetChanged()刷新ListView,我这里用的是ArrayAdatper,直接调用remove()就可以了。

所有的代码就编写完了，我们来运行下程序看看效果吧

好了，今天的讲解就到此结束了，有疑问的朋友可以在下面留言，我会帮大家解答的。今天是2013年的最后一天，希望大家开开心心度过2013，也开开心心的迎接2014，提前祝大家元旦快乐！

项目源码，点击下载