Android 可拖拽的GridView效果实现, 长按可拖拽和item实时交换

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

在Android开发中，我们常常用到ListView和GridView，而有的时
候系统的ListView，GridView并不能满足我们的需求，所以我们需要自己定义一个ListView或者GridView,我的上一篇文章中就
是自定义的一个左右滑动删除item的例子，大家有兴趣的可以去看看Android 使用Scroller实现绚丽的ListView左右滑动删除Item效果，今天这篇文章就给大家来自定义GridView的
控件，GridView主要是来显示网格的控件，在Android的开发中使用很普通，相对于TextView，Button这些控件来说要来的复杂些，
今天给大家带来长按GridView的item,然后将其拖拽其他item上面，使得GridView的item发生交换，比较典型的就是我们的
Launcher，网上有很多关于GridView的拖动的Demo，但是大部分都是相同的，而且存在一些Bug,而且大部分都是点击GridView的
item然后进行拖动，或者item之间不进行实时交换，今天给大家更加详细的介绍GridView拖拽，并且将Demo做的更完美，大家更容易接受，也
许很多人听到这个感觉实现起来很复杂，就关掉的这篇文章，其实告诉大家，只要知道了思路就感觉一点都不复杂了，不信大家可以接着往下看看，首先还是跟大家
说说实现的思路

1. 根据手指按下的X,Y坐标来获取我们在GridView上面点击的item
2. 手指按下的时候使用Handler和Runnable来实现一个定时器，假如定时时间为1000毫秒，在1000毫秒内，如果手指抬起了移除定时器，没有抬起并且手指点击在GridView的item所在的区域，则表示我们长按了GridView的item
3. 如果我们长按了item则隐藏item,然后使用WindowManager来添加一个item的镜像在屏幕用来代替刚刚隐藏的item
4. 当我们手指在屏幕移动的时候，更新item镜像的位置，然后在根据我们移动的X,Y的坐标来获取移动到GridView的哪一个位置
5. 到GridView的item过多的时候，可能一屏幕显示不完，我们手指拖动item镜像到屏幕下方，要触发GridView想上滚动，同理，当我们手指拖动item镜像到屏幕上面，触发GridView向下滚动
6. GridView交换数据，刷新界面，移除item的镜像

看完上面的这些思路你是不是找到了些感觉了呢，心里痒痒的想动手试试吧，好吧，接下来就带大家根据思路来实现可拖拽的GridView，新建一个项目就叫DragGridView
新建一个类DragGridView继承GridView,先来看看DragGridView的代码，然后在根据代码进行相关的讲解

1. package com.example.draggridview;
2. import android.annotation.SuppressLint;
3. import android.app.Activity;
4. import android.content.Context;
5. import android.graphics.Bitmap;
6. import android.graphics.PixelFormat;
7. import android.graphics.Rect;
8. import android.os.Handler;
9. import android.os.Vibrator;
10. import android.text.GetChars;
11. import android.util.AttributeSet;
12. import android.view.Gravity;
13. import android.view.MotionEvent;
14. import android.view.View;
15. import android.view.WindowManager;
16. import android.widget.AdapterView;
17. import android.widget.GridView;
18. import android.widget.ImageView;
19. /**
20. * @blog http://blog.csdn.net/xiaanming
21. *
22. * @author xiaanming
23. *
24. */
25. @SuppressLint("NewApi")
26. public class DragGridView extends GridView{
27. /**
28. * DragGridView的item长按响应的时间， 默认是1000毫秒，也可以自行设置
29. */
30. private long dragResponseMS = 1000;
31. /**
32. * 是否可以拖拽，默认不可以
33. */
34. private boolean isDrag = false;
35. private int mDownX;
36. private int mDownY;
37. private int moveX;
38. private int moveY;
39. /**
40. * 正在拖拽的position
41. */
42. private int mDragPosition;
43. /**
44. * 刚开始拖拽的item对应的View
45. */
46. private View mStartDragItemView = null;
47. /**
48. * 用于拖拽的镜像，这里直接用一个ImageView
49. */
50. private ImageView mDragImageView;
51. /**
52. * 震动器
53. */
54. private Vibrator mVibrator;
55. private WindowManager mWindowManager;
56. /**
57. * item镜像的布局参数
58. */
59. private WindowManager.LayoutParams mWindowLayoutParams;
60. /**
61. * 我们拖拽的item对应的Bitmap
62. */
63. private Bitmap mDragBitmap;
64. /**
65. * 按下的点到所在item的上边缘的距离
66. */
67. private int mPoint2ItemTop ;
68. /**
69. * 按下的点到所在item的左边缘的距离
70. */
71. private int mPoint2ItemLeft;
72. /**
73. * DragGridView距离屏幕顶部的偏移量
74. */
75. private int mOffset2Top;
76. /**
77. * DragGridView距离屏幕左边的偏移量
78. */
79. private int mOffset2Left;
80. /**
81. * 状态栏的高度
82. */
83. private int mStatusHeight;
84. /**
85. * DragGridView自动向下滚动的边界值
86. */
87. private int mDownScrollBorder;
88. /**
89. * DragGridView自动向上滚动的边界值
90. */
91. private int mUpScrollBorder;
92. /**
93. * DragGridView自动滚动的速度
94. */
95. private static final int speed = 80;
96. /**
97. * item发生变化回调的接口
98. */
99. private OnChanageListener onChanageListener;
100. public DragGridView(Context context) {
101. this(context, null);
102. }
103. public DragGridView(Context context, AttributeSet attrs) {
104. this(context, attrs, 0);
105. }
106. public DragGridView(Context context, AttributeSet attrs, int defStyle) {
107. super(context, attrs, defStyle);
108. mVibrator = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
109. mWindowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
110. mStatusHeight = getStatusHeight(context); //获取状态栏的高度
111. }
112. private Handler mHandler = new Handler();
113. //用来处理是否为长按的Runnable
114. private Runnable mLongClickRunnable = new Runnable() {
115. @Override
116. public void run() {
117. isDrag = true; //设置可以拖拽
118. mVibrator.vibrate(50); //震动一下
119. mStartDragItemView.setVisibility(View.INVISIBLE);//隐藏该item
120. //根据我们按下的点显示item镜像
121. createDragImage(mDragBitmap, mDownX, mDownY);
122. }
123. };
124. /**
125. * 设置回调接口
126. * @param onChanageListener
127. */
128. public void setOnChangeListener(OnChanageListener onChanageListener){
129. this.onChanageListener = onChanageListener;
130. }
131. /**
132. * 设置响应拖拽的毫秒数，默认是1000毫秒
133. * @param dragResponseMS
134. */
135. public void setDragResponseMS(long dragResponseMS) {
136. this.dragResponseMS = dragResponseMS;
137. }
138. @Override
139. public boolean dispatchTouchEvent(MotionEvent ev) {
140. switch(ev.getAction()){
141. case MotionEvent.ACTION_DOWN:
142. //使用Handler延迟dragResponseMS执行mLongClickRunnable
143. mHandler.postDelayed(mLongClickRunnable, dragResponseMS);
144. mDownX = (int) ev.getX();
145. mDownY = (int) ev.getY();
146. //根据按下的X,Y坐标获取所点击item的position
147. mDragPosition = pointToPosition(mDownX, mDownY);
148. if(mDragPosition == AdapterView.INVALID_POSITION){
149. return super.dispatchTouchEvent(ev);
150. }
151. //根据position获取该item所对应的View
152. mStartDragItemView = getChildAt(mDragPosition - getFirstVisiblePosition());
153. //下面这几个距离大家可以参考我的博客上面的图来理解下
154. mPoint2ItemTop = mDownY - mStartDragItemView.getTop();
155. mPoint2ItemLeft = mDownX - mStartDragItemView.getLeft();
156. mOffset2Top = (int) (ev.getRawY() - mDownY);
157. mOffset2Left = (int) (ev.getRawX() - mDownX);
158. //获取DragGridView自动向上滚动的偏移量，小于这个值，DragGridView向下滚动
159. mDownScrollBorder = getHeight() /4;
160. //获取DragGridView自动向下滚动的偏移量，大于这个值，DragGridView向上滚动
161. mUpScrollBorder = getHeight() * 3/4;
162. //开启mDragItemView绘图缓存
163. mStartDragItemView.setDrawingCacheEnabled(true);
164. //获取mDragItemView在缓存中的Bitmap对象
165. mDragBitmap = Bitmap.createBitmap(mStartDragItemView.getDrawingCache());
166. //这一步很关键，释放绘图缓存，避免出现重复的镜像
167. mStartDragItemView.destroyDrawingCache();
168. break;
169. case MotionEvent.ACTION_MOVE:
170. int moveX = (int)ev.getX();
171. int moveY = (int) ev.getY();
172. //如果我们在按下的item上面移动，只要不超过item的边界我们就不移除mRunnable
173. if(!isTouchInItem(mStartDragItemView, moveX, moveY)){
174. mHandler.removeCallbacks(mLongClickRunnable);
175. }
176. break;
177. case MotionEvent.ACTION_UP:
178. mHandler.removeCallbacks(mLongClickRunnable);
179. mHandler.removeCallbacks(mScrollRunnable);
180. break;
181. }
182. return super.dispatchTouchEvent(ev);
183. }
184. /**
185. * 是否点击在GridView的item上面
186. * @param itemView
187. * @param x
188. * @param y
189. * @return
190. */
191. private boolean isTouchInItem(View dragView, int x, int y){
192. int leftOffset = dragView.getLeft();
193. int topOffset = dragView.getTop();
194. if(x < leftOffset || x > leftOffset + dragView.getWidth()){
195. return false;
196. }
197. if(y < topOffset || y > topOffset + dragView.getHeight()){
198. return false;
199. }
200. return true;
201. }
202. @Override
203. public boolean onTouchEvent(MotionEvent ev) {
204. if(isDrag && mDragImageView != null){
205. switch(ev.getAction()){
206. case MotionEvent.ACTION_MOVE:
207. moveX = (int) ev.getX();
208. moveY = (int) ev.getY();
209. //拖动item
210. onDragItem(moveX, moveY);
211. break;
212. case MotionEvent.ACTION_UP:
213. onStopDrag();
214. isDrag = false;
215. break;
216. }
217. return true;
218. }
219. return super.onTouchEvent(ev);
220. }
221. /**
222. * 创建拖动的镜像
223. * @param bitmap
224. * @param downX
225. *          按下的点相对父控件的X坐标
226. * @param downY
227. *          按下的点相对父控件的X坐标
228. */
229. private void createDragImage(Bitmap bitmap, int downX , int downY){
230. mWindowLayoutParams = new WindowManager.LayoutParams();
231. mWindowLayoutParams.format = PixelFormat.TRANSLUCENT; //图片之外的其他地方透明
232. mWindowLayoutParams.gravity = Gravity.TOP | Gravity.LEFT;
233. mWindowLayoutParams.x = downX - mPoint2ItemLeft + mOffset2Left;
234. mWindowLayoutParams.y = downY - mPoint2ItemTop + mOffset2Top - mStatusHeight;
235. mWindowLayoutParams.alpha = 0.55f; //透明度
236. mWindowLayoutParams.width = WindowManager.LayoutParams.WRAP_CONTENT;
237. mWindowLayoutParams.height = WindowManager.LayoutParams.WRAP_CONTENT;
238. mWindowLayoutParams.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
239. | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE ;
240. mDragImageView = new ImageView(getContext());
241. mDragImageView.setImageBitmap(bitmap);
242. mWindowManager.addView(mDragImageView, mWindowLayoutParams);
243. }
244. /**
245. * 从界面上面移动拖动镜像
246. */
247. private void removeDragImage(){
248. if(mDragImageView != null){
249. mWindowManager.removeView(mDragImageView);
250. mDragImageView = null;
251. }
252. }
253. /**
254. * 拖动item，在里面实现了item镜像的位置更新，item的相互交换以及GridView的自行滚动
255. * @param x
256. * @param y
257. */
258. private void onDragItem(int moveX, int moveY){
259. mWindowLayoutParams.x = moveX - mPoint2ItemLeft + mOffset2Left;
260. mWindowLayoutParams.y = moveY - mPoint2ItemTop + mOffset2Top - mStatusHeight;
261. mWindowManager.updateViewLayout(mDragImageView, mWindowLayoutParams); //更新镜像的位置
262. onSwapItem(moveX, moveY);
263. //GridView自动滚动
264. mHandler.post(mScrollRunnable);
265. }
266. /**
267. * 当moveY的值大于向上滚动的边界值，触发GridView自动向上滚动
268. * 当moveY的值小于向下滚动的边界值，触犯GridView自动向下滚动
269. * 否则不进行滚动
270. */
271. private Runnable mScrollRunnable = new Runnable() {
272. @Override
273. public void run() {
274. int scrollY;
275. if(moveY > mUpScrollBorder){
276. scrollY = -speed;
277. mHandler.postDelayed(mScrollRunnable, 25);
278. }else if(moveY < mDownScrollBorder){
279. scrollY = speed;
280. mHandler.postDelayed(mScrollRunnable, 25);
281. }else{
282. scrollY = 0;
283. mHandler.removeCallbacks(mScrollRunnable);
284. }
285. //当我们的手指到达GridView向上或者向下滚动的偏移量的时候，可能我们手指没有移动，但是DragGridView在自动的滚动
286. //所以我们在这里调用下onSwapItem()方法来交换item
287. onSwapItem(moveX, moveY);
288. View view = getChildAt(mDragPosition - getFirstVisiblePosition());
289. //实现GridView的自动滚动
290. smoothScrollToPositionFromTop(mDragPosition, view.getTop() + scrollY);
291. }
292. };
293. /**
294. * 交换item,并且控制item之间的显示与隐藏效果
295. * @param moveX
296. * @param moveY
297. */
298. private void onSwapItem(int moveX, int moveY){
299. //获取我们手指移动到的那个item的position
300. int tempPosition = pointToPosition(moveX, moveY);
301. //假如tempPosition 改变了并且tempPosition不等于-1,则进行交换
302. if(tempPosition != mDragPosition && tempPosition != AdapterView.INVALID_POSITION){
303. getChildAt(tempPosition - getFirstVisiblePosition()).setVisibility(View.INVISIBLE);//拖动到了新的item,新的item隐藏掉
304. getChildAt(mDragPosition - getFirstVisiblePosition()).setVisibility(View.VISIBLE);//之前的item显示出来
305. if(onChanageListener != null){
306. onChanageListener.onChange(mDragPosition, tempPosition);
307. }
308. mDragPosition = tempPosition;
309. }
310. }
311. /**
312. * 停止拖拽我们将之前隐藏的item显示出来，并将镜像移除
313. */
314. private void onStopDrag(){
315. getChildAt(mDragPosition - getFirstVisiblePosition()).setVisibility(View.VISIBLE);
316. removeDragImage();
317. }
318. /**
319. * 获取状态栏的高度
320. * @param context
321. * @return
322. */
323. private static int getStatusHeight(Context context){
324. int statusHeight = 0;
325. Rect localRect = new Rect();
326. ((Activity) context).getWindow().getDecorView().getWindowVisibleDisplayFrame(localRect);
327. statusHeight = localRect.top;
328. if (0 == statusHeight){
329. Class<?> localClass;
330. try {
331. localClass = Class.forName("com.android.internal.R$dimen");
332. Object localObject = localClass.newInstance();
333. int i5 = Integer.parseInt(localClass.getField("status_bar_height").get(localObject).toString());
334. statusHeight = context.getResources().getDimensionPixelSize(i5);
335. } catch (Exception e) {
336. e.printStackTrace();
337. }
338. }
339. return statusHeight;
340. }
341. /**
342. *
343. * @author xiaanming
344. *
345. */
346. public interface OnChanageListener{
347. /**
348. * 当item交换位置的时候回调的方法，我们只需要在该方法中实现数据的交换即可
349. * @param form
350. *          开始的position
351. * @param to
352. *          拖拽到的position
353. */
354. public void onChange(int form, int to);
355. }
356. }

首先看DragGridView的事件分发方法，不了解Android事件分发的可以先去了
解下，Android事件分发对于自定义控件很重要，简单说下，当我们点击DragGridView的Item,先会去执行
dispatchTouchEvent()方法将事件分发下去，所以我们要重写dispatchTouchEvent()方法在手指按下的时候根据
pointToPosition()方法来获取我们按下的item的position,根据getChildAt()方法来获取该position上面所
对应的View,

并且开启长按的定时器，默认时间为1000毫秒，如果在1000毫秒内手指抬起或者手指在屏幕上滑动出了该item，则取消长按定时器，否则就表示可以进
行拖拽，手机友好的震动一下，隐藏我们长按的Item，屏幕调用createDragImage()方法来创建我们长按的item的镜像，创建Item的
镜像使用的是WindowManager类，该类可以创建一个窗体显示在Activity之上，
再此之前大家先要理解这几个距离，理解这几个距离之前要首先知道getRawX(),getRawY()和getX(),getY()的区
别，getRawX(),getRawY()是相对于屏幕的原点的距离，而getX(),getY()是相对于控件左上方的点的距离，为了方便大家理解我
用Word简单的画了下图，画得不好，大家将就的看下，红色框框为我们的GridView

• mPoint2ItemTop 手指按下的点到该Item的上边缘的距离，如上图的1号线
• mPoint2ItemLeft 手指按下的点到该Item的左边缘的距离，如上图的2号线
• mOffset2Top  DragGridView的上边缘到屏幕上边缘的距离，如上图的3号线，这个距离包裹状态栏，标题栏，或者一些在DragGridView上面的布局的高度，这个很重要我们现实Item镜像需要用到
• mOffset2Left

  DragGridView的左边缘到屏幕左边缘的距离，如上图的4号线，我这个Demo的这个距离为0，因为我设置DragGridView的宽度为充满
  屏幕，但是我们要考虑假如DragGridView与屏幕左边缘设置了间隙或者左边有其他的布局的情形

• mDownScrollBorder 这个距离表示当DragGridView的item过多的时候，手机一屏显示不完全，我们拖动Item镜像到这个高度的时候，DragGridView自动向下滚动，如上图的5号线
• .mUpScrollBorder 这个和mDownScrollBorder相反，当我们大于这个高度的时候，DragGridView自动向上滚动，如上图的6号线

理解了这六个距离，我们就来看看创建Item镜像的方法里面，其他的我不多说，首
先设置format为PixelFormat.TRANSLUCENT，表示除了我们显示图片和文字的其他地方为透明，之后就是x，y这两个距离的计算，
计算的是item的左上角的坐标，理解了上面这六个距离我们很容易得出x,y的坐标，可是你会发现y的坐标减去了状态栏的高度，这点大家需要注意下，另外
我们需要获取item的绘制缓存的Bitmap对象，然后将Bitmap设置到一个ImageView上面，为什么要这么做呢？如果调用
addView()方法将item

直接添加到WindowManager里面，会有异常产生，因为item已经有了自己归属的父容器DragGridView，所有我们这里使用一个
ImageView来代替item添加到WindowManager里面

上面已经完成了开始拖拽的准备工作，要想拖动镜像我们还需要重写onTouchEvent()方法，获取移动的X,Y的坐标，利用
WindowManager的updateViewLayout方法就能对镜像进行拖动，拖动的镜像的时候为了有更好的用户体验，我们还要做item的实
时交换效果，我们利用手指移动的X,Y坐标，利用pointToPosition()来获取拖拽到的position,然后将之前的item显示出来，将
拖拽到的item进行隐藏，这样子就完成了item在界面上面的交换，但是数据交换我这里没有做，所以我提供了回调接口
OnChanageListener，我们只需要自己实现数据的交换逻辑然后刷新DragGridView即可，我们还需要实现DragGridView
的自动向上滚动或者向下滚动，使用Handler和mScrollRunnable利用smoothScrollToPositionFromTop()
来实现DragGridView滚动，具体的实现大家可以看代码
手指离开界面，将item的镜像移除，并将拖拽到的item显示出来，这样子就实现了GirdView的拖拽效果啦，接下来我们来使用下我们自定义可拖拽的GridView吧，先看主界面布局，只有我们自定义的一个DragGridView

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. <com.example.draggridview.DragGridView
6. android:id="@+id/dragGridView"
7. android:listSelector="@android:color/transparent"
8. android:layout_width="match_parent"
9. android:layout_height="match_parent"
10. android:cacheColorHint="@android:color/transparent"
11. android:verticalSpacing="10dip"
12. android:horizontalSpacing="10dip"
13. android:stretchMode="columnWidth"
14. android:gravity="center"
15. android:numColumns="3" >
16. </com.example.draggridview.DragGridView>
17. </RelativeLayout>

接下来我们看看DragGridView的item的布局，上面一个ImageView下面一个TextView

1. <?xml version="1.0" encoding="utf-8"?>
2. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
3. android:layout_width="fill_parent"
4. android:layout_height="wrap_content"
5. android:background="@android:color/transparent" >
6. <ImageView
7. android:id="@+id/item_image"
8. android:scaleType="centerCrop"
9. android:layout_width="wrap_content"
10. android:layout_height="wrap_content"
11. android:layout_centerHorizontal="true" >
12. </ImageView>
13. <TextView
14. android:id="@+id/item_text"
15. android:layout_width="wrap_content"
16. android:layout_height="wrap_content"
17. android:layout_below="@+id/item_image"
18. android:layout_centerHorizontal="true" >
19. </TextView>
20. </RelativeLayout>

布局搞定了我们就来看看主页面MainActivity的代码吧

1. package com.example.draggridview;
2. import java.util.ArrayList;
3. import java.util.Collections;
4. import java.util.HashMap;
5. import java.util.List;
6. import android.app.Activity;
7. import android.os.Bundle;
8. import android.widget.SimpleAdapter;
9. import com.example.draggridview.DragGridView.OnChanageListener;
10. /**
11. * @blog http://blog.csdn.net/xiaanming
12. *
13. * @author xiaanming
14. *
15. */
16. public class MainActivity extends Activity {
17. private List<HashMap<String, Object>> dataSourceList = new ArrayList<HashMap<String, Object>>();
18. @Override
19. protected void onCreate(Bundle savedInstanceState) {
20. super.onCreate(savedInstanceState);
21. setContentView(R.layout.activity_main);
22. DragGridView mDragGridView = (DragGridView) findViewById(R.id.dragGridView);
23. for (int i = 0; i < 30; i++) {
24. HashMap<String, Object> itemHashMap = new HashMap<String, Object>();
25. itemHashMap.put("item_image",R.drawable.com_tencent_open_notice_msg_icon_big);
26. itemHashMap.put("item_text", "拖拽 " + Integer.toString(i));
27. dataSourceList.add(itemHashMap);
28. }
29. final SimpleAdapter mSimpleAdapter = new SimpleAdapter(this, dataSourceList,
30. R.layout.grid_item, new String[] { "item_image", "item_text" },
31. new int[] { R.id.item_image, R.id.item_text });
32. mDragGridView.setAdapter(mSimpleAdapter);
33. mDragGridView.setOnChangeListener(new OnChanageListener() {
34. @Override
35. public void onChange(int from, int to) {
36. HashMap<String, Object> temp = dataSourceList.get(from);
37. //直接交互item
38. //              dataSourceList.set(from, dataSourceList.get(to));
39. //              dataSourceList.set(to, temp);
40. //              dataSourceList.set(to, temp);
41. //这里的处理需要注意下
42. if(from < to){
43. for(int i=from; i<to; i++){
44. Collections.swap(dataSourceList, i, i+1);
45. }
46. }else if(from > to){
47. for(int i=from; i>to; i--){
48. Collections.swap(dataSourceList, i, i-1);
49. }
50. }
51. dataSourceList.set(to, temp);
52. mSimpleAdapter.notifyDataSetChanged();
53. }
54. });
55. }
56. }

这里面的代码还是比较简单，主要讲下onChange()方法，我们要为
mDragGridView设置一个OnChanageListener的回调接口，在onChange()方法里面实现数据的交换逻辑，第一个参数
from为item开始的位置，第二个参数to为item拖拽到的位置，刚开始我使用的交换逻辑是

1. HashMap<String, Object> temp = dataSourceList.get(from);
2. //直接交互item
3. //              dataSourceList.set(from, dataSourceList.get(to));
4. //              dataSourceList.set(to, temp);

直接交换的item的数据，然后看了下网易新闻的拖拽的GridView，他不是直接实现两个item直接的数据交换，所以将数据交换逻辑改成了下面的方式
简单说下，数据的交换逻辑，比如我们将position从5拖拽到7这个位置，我注释掉的逻辑是直接将5和7的数据交换，而后面的那种逻辑是将6的位置数
据移动到5，将7的位置移动到6，然后再7显示5  6->5, 7->6, 5->7不知道大家理解了没有。

接下来我们来运行下项目，在运行之前我们不要忘了在AndroidManifest.xml里面加入震动的权限<uses-permission android:name="android.permission.VIBRATE"/>

好了，今天的讲解就到此结束，效果还不错吧，看完这篇文章你是不是觉得GridView拖拽
也不是那么难实现呢？你心里是不是也大概有自己的一个思路，建议大家自己敲敲看看，可以自己去实现下ListView的拖拽实现，ListView比
GridView简单些，好的学习方法不是看得懂人家的代码，而是看完代码自己根据脑海里的思路自己敲出来，所以还是鼓励大家多敲代码，不明白的同学在下
面留言，我会为大家解答的！

项目源码，点击下载

上面的代码存在兼容性的问题，在4.X以上的机器运行时OK的，但是在2.X的机
器运行就存在错误，原因是因为smoothScrollToPositionFromTop()方法在2.x的api中不存在，如果在2.x的机器上面运
行将smoothScrollToPositionFromTop(mDragPosition, view.getTop() +
scrollY)改成smoothScrollBy(-scrollY, 10); 并且将speed的值适当改小点，不然自动滚动过快