0

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

转帖(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.app.Activity;
  3. import android.content.Context;
  4. import android.graphics.Bitmap;
  5. import android.graphics.PixelFormat;
  6. import android.graphics.Rect;
  7. import android.os.Handler;
  8. import android.os.Vibrator;
  9. import android.util.AttributeSet;
  10. import android.view.Gravity;
  11. import android.view.MotionEvent;
  12. import android.view.View;
  13. import android.view.WindowManager;
  14. import android.widget.AdapterView;
  15. import android.widget.GridView;
  16. import android.widget.ImageView;
  17. /**
  18.  * @blog http://blog.csdn.net/xiaanming 
  19.  * 
  20.  * @author xiaanming
  21.  *
  22.  */
  23. public class DragGridView extends GridView{
  24.     /**
  25.      * DragGridView的item长按响应的时间, 默认是1000毫秒,也可以自行设置
  26.      */
  27.     private long dragResponseMS = 1000;
  28.     /**
  29.      * 是否可以拖拽,默认不可以
  30.      */
  31.     private boolean isDrag = false;
  32.     private int mDownX;
  33.     private int mDownY;
  34.     private int moveX;
  35.     private int moveY;
  36.     /**
  37.      * 正在拖拽的position
  38.      */
  39.     private int mDragPosition;
  40.     /**
  41.      * 刚开始拖拽的item对应的View
  42.      */
  43.     private View mStartDragItemView = null;
  44.     /**
  45.      * 用于拖拽的镜像,这里直接用一个ImageView
  46.      */
  47.     private ImageView mDragImageView;
  48.     /**
  49.      * 震动器
  50.      */
  51.     private Vibrator mVibrator;
  52.     private WindowManager mWindowManager;
  53.     /**
  54.      * item镜像的布局参数
  55.      */
  56.     private WindowManager.LayoutParams mWindowLayoutParams;
  57.     /**
  58.      * 我们拖拽的item对应的Bitmap
  59.      */
  60.     private Bitmap mDragBitmap;
  61.     /**
  62.      * 按下的点到所在item的上边缘的距离
  63.      */
  64.     private int mPoint2ItemTop ;
  65.     /**
  66.      * 按下的点到所在item的左边缘的距离
  67.      */
  68.     private int mPoint2ItemLeft;
  69.     /**
  70.      * DragGridView距离屏幕顶部的偏移量
  71.      */
  72.     private int mOffset2Top;
  73.     /**
  74.      * DragGridView距离屏幕左边的偏移量
  75.      */
  76.     private int mOffset2Left;
  77.     /**
  78.      * 状态栏的高度
  79.      */
  80.     private int mStatusHeight;
  81.     /**
  82.      * DragGridView自动向下滚动的边界值
  83.      */
  84.     private int mDownScrollBorder;
  85.     /**
  86.      * DragGridView自动向上滚动的边界值
  87.      */
  88.     private int mUpScrollBorder;
  89.     /**
  90.      * DragGridView自动滚动的速度
  91.      */
  92.     private static final int speed = 20;
  93.     /**
  94.      * item发生变化回调的接口
  95.      */
  96.     private OnChanageListener onChanageListener;
  97.     public DragGridView(Context context) {
  98.         this(context, null);
  99.     }
  100.     public DragGridView(Context context, AttributeSet attrs) {
  101.         this(context, attrs, 0);
  102.     }
  103.     public DragGridView(Context context, AttributeSet attrs, int defStyle) {
  104.         super(context, attrs, defStyle);
  105.         mVibrator = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
  106.         mWindowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
  107.         mStatusHeight = getStatusHeight(context); //获取状态栏的高度
  108.     }
  109.     private Handler mHandler = new Handler();
  110.     //用来处理是否为长按的Runnable
  111.     private Runnable mLongClickRunnable = new Runnable() {
  112.         @Override
  113.         public void run() {
  114.             isDrag = true//设置可以拖拽
  115.             mVibrator.vibrate(50); //震动一下
  116.             mStartDragItemView.setVisibility(View.INVISIBLE);//隐藏该item
  117.             //根据我们按下的点显示item镜像
  118.             createDragImage(mDragBitmap, mDownX, mDownY);
  119.         }
  120.     };
  121.     /**
  122.      * 设置回调接口
  123.      * @param onChanageListener
  124.      */
  125.     public void setOnChangeListener(OnChanageListener onChanageListener){
  126.         this.onChanageListener = onChanageListener;
  127.     }
  128.     /**
  129.      * 设置响应拖拽的毫秒数,默认是1000毫秒
  130.      * @param dragResponseMS
  131.      */
  132.     public void setDragResponseMS(long dragResponseMS) {
  133.         this.dragResponseMS = dragResponseMS;
  134.     }
  135.     @Override
  136.     public boolean dispatchTouchEvent(MotionEvent ev) {
  137.         switch(ev.getAction()){
  138.         case MotionEvent.ACTION_DOWN:
  139.             mDownX = (int) ev.getX();
  140.             mDownY = (int) ev.getY();
  141.             //根据按下的X,Y坐标获取所点击item的position
  142.             mDragPosition = pointToPosition(mDownX, mDownY);
  143.             if(mDragPosition == AdapterView.INVALID_POSITION){
  144.                 return super.dispatchTouchEvent(ev);
  145.             }
  146.             //使用Handler延迟dragResponseMS执行mLongClickRunnable
  147.             mHandler.postDelayed(mLongClickRunnable, dragResponseMS);
  148.             //根据position获取该item所对应的View
  149.             mStartDragItemView = getChildAt(mDragPosition – getFirstVisiblePosition());
  150.             //下面这几个距离大家可以参考我的博客上面的图来理解下
  151.             mPoint2ItemTop = mDownY – mStartDragItemView.getTop();
  152.             mPoint2ItemLeft = mDownX – mStartDragItemView.getLeft();
  153.             mOffset2Top = (int) (ev.getRawY() – mDownY);
  154.             mOffset2Left = (int) (ev.getRawX() – mDownX);
  155.             //获取DragGridView自动向上滚动的偏移量,小于这个值,DragGridView向下滚动
  156.             mDownScrollBorder = getHeight() /4;
  157.             //获取DragGridView自动向下滚动的偏移量,大于这个值,DragGridView向上滚动
  158.             mUpScrollBorder = getHeight() * 3/4;
  159.             //开启mDragItemView绘图缓存
  160.             mStartDragItemView.setDrawingCacheEnabled(true);
  161.             //获取mDragItemView在缓存中的Bitmap对象
  162.             mDragBitmap = Bitmap.createBitmap(mStartDragItemView.getDrawingCache());
  163.             //这一步很关键,释放绘图缓存,避免出现重复的镜像
  164.             mStartDragItemView.destroyDrawingCache();
  165.             break;
  166.         case MotionEvent.ACTION_MOVE:
  167.             int moveX = (int)ev.getX();
  168.             int moveY = (int) ev.getY();
  169.             //如果我们在按下的item上面移动,只要不超过item的边界我们就不移除mRunnable
  170.             if(!isTouchInItem(mStartDragItemView, moveX, moveY)){
  171.                 mHandler.removeCallbacks(mLongClickRunnable);
  172.             }
  173.             break;
  174.         case MotionEvent.ACTION_UP:
  175.             mHandler.removeCallbacks(mLongClickRunnable);
  176.             mHandler.removeCallbacks(mScrollRunnable);
  177.             break;
  178.         }
  179.         return super.dispatchTouchEvent(ev);
  180.     }
  181.     /**
  182.      * 是否点击在GridView的item上面
  183.      * @param itemView
  184.      * @param x
  185.      * @param y
  186.      * @return
  187.      */
  188.     private boolean isTouchInItem(View dragView, int x, int y){
  189.         if(dragView == null){
  190.             return false;
  191.         }
  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.             smoothScrollBy(scrollY, 10);
  289.         }
  290.     };
  291.     /**
  292.      * 交换item,并且控制item之间的显示与隐藏效果
  293.      * @param moveX
  294.      * @param moveY
  295.      */
  296.     private void onSwapItem(int moveX, int moveY){
  297.         //获取我们手指移动到的那个item的position
  298.         int tempPosition = pointToPosition(moveX, moveY);
  299.         //假如tempPosition 改变了并且tempPosition不等于-1,则进行交换
  300.         if(tempPosition != mDragPosition && tempPosition != AdapterView.INVALID_POSITION){
  301.             if(onChanageListener != null){
  302.                 onChanageListener.onChange(mDragPosition, tempPosition);
  303.             }
  304.             getChildAt(tempPosition – getFirstVisiblePosition()).setVisibility(View.INVISIBLE);//拖动到了新的item,新的item隐藏掉
  305.             getChildAt(mDragPosition – getFirstVisiblePosition()).setVisibility(View.VISIBLE);//之前的item显示出来
  306.             mDragPosition = tempPosition;
  307.         }
  308.     }
  309.     /**
  310.      * 停止拖拽我们将之前隐藏的item显示出来,并将镜像移除
  311.      */
  312.     private void onStopDrag(){
  313.         View view = getChildAt(mDragPosition – getFirstVisiblePosition());
  314.         if(view != null){
  315.             view.setVisibility(View.VISIBLE);
  316.         }
  317.         ((DragAdapter)this.getAdapter()).setItemHide(-1);
  318.         removeDragImage();
  319.     }
  320.     /**
  321.      * 获取状态栏的高度
  322.      * @param context
  323.      * @return
  324.      */
  325.     private static int getStatusHeight(Context context){
  326.         int statusHeight = 0;
  327.         Rect localRect = new Rect();
  328.         ((Activity) context).getWindow().getDecorView().getWindowVisibleDisplayFrame(localRect);
  329.         statusHeight = localRect.top;
  330.         if (0 == statusHeight){
  331.             Class<?> localClass;
  332.             try {
  333.                 localClass = Class.forName(“com.android.internal.R$dimen”);
  334.                 Object localObject = localClass.newInstance();
  335.                 int i5 = Integer.parseInt(localClass.getField(“status_bar_height”).get(localObject).toString());
  336.                 statusHeight = context.getResources().getDimensionPixelSize(i5);
  337.             } catch (Exception e) {
  338.                 e.printStackTrace();
  339.             }
  340.         }
  341.         return statusHeight;
  342.     }
  343.     /**
  344.      * 
  345.      * @author xiaanming
  346.      *
  347.      */
  348.     public interface OnChanageListener{
  349.         /**
  350.          * 当item交换位置的时候回调的方法,我们只需要在该方法中实现数据的交换即可
  351.          * @param form
  352.          *          开始的position
  353.          * @param to 
  354.          *          拖拽到的position
  355.          */
  356.         public void onChange(int form, int to);
  357.     }
  358. }

首先看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简单些,好的学习方法不是看得懂人家的代码,而是看完代码自己根据脑海里的思路自己敲出来,所以还是鼓励大家多敲代码,不明白的同学在下面留言,我会为大家解答的!
PS:上面的代码在4.0以上的机器上面运行是OK的,但是在4.0以下的机器存在几个问题,首先是兼容性的问题,首先smoothScrollToPositionFromTop()方法在2.x的机器是不存在的,但是我们可以使用smoothScrollBy()来代替上面的方法使得GridView滚动
注意:很多朋友说运行在2.3的机器上面拖动的时候出现某些item无缘无故的隐藏了,笔者在写demo的时候一直用的是4.0的真机运行的,后面博主使用模拟器运行在2.3的机器上面,确实存在很多朋友反应的问题,原因就是因为博主使用的是SimpleAdapter,SimpleAdapter会复用Item,所以才导致本不该隐藏的item隐藏了,但是为什么运行在博主4.0的机器上面不出现问题,博主也很纳闷,现在我对其做出了修改,采用自定义Adapter,对item不采用复用的原则,虽然效率上面有点点不足,但是如果对于item不多的GridView,效率不足可以忽略,新修改的代码可以运行在2.X以上的机器不出现朋友们所说的问题了,并且添加了Item的移动动画效果,非常感谢大家提出的问题!

 

天边的星星