閱讀440 返回首頁    go 阿裏雲 go 技術社區[雲棲]

Android 可拖拽的GridView效果實現, 長按可拖拽和item實時交換

在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.   
  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.util.AttributeSet;  
  11. import android.view.Gravity;  
  12. import android.view.MotionEvent;  
  13. import android.view.View;  
  14. import android.view.WindowManager;  
  15. import android.widget.AdapterView;  
  16. import android.widget.GridView;  
  17. import android.widget.ImageView;  
  18.   
  19. /** 
  20.  * @blog https://blog.csdn.net/xiaanming  
  21.  *  
  22.  * @author xiaanming 
  23.  * 
  24.  */  
  25. public class DragGridView extends GridView{  
  26.     /** 
  27.      * DragGridView的item長按響應的時間， 默認是1000毫秒，也可以自行設置 
  28.      */  
  29.     private long dragResponseMS = 1000;  
  30.       
  31.     /** 
  32.      * 是否可以拖拽，默認不可以 
  33.      */  
  34.     private boolean isDrag = false;  
  35.       
  36.     private int mDownX;  
  37.     private int mDownY;  
  38.     private int moveX;  
  39.     private int moveY;  
  40.     /** 
  41.      * 正在拖拽的position 
  42.      */  
  43.     private int mDragPosition;  
  44.       
  45.     /** 
  46.      * 剛開始拖拽的item對應的View 
  47.      */  
  48.     private View mStartDragItemView = null;  
  49.       
  50.     /** 
  51.      * 用於拖拽的鏡像，這裏直接用一個ImageView 
  52.      */  
  53.     private ImageView mDragImageView;  
  54.       
  55.     /** 
  56.      * 震動器 
  57.      */  
  58.     private Vibrator mVibrator;  
  59.       
  60.     private WindowManager mWindowManager;  
  61.     /** 
  62.      * item鏡像的布局參數 
  63.      */  
  64.     private WindowManager.LayoutParams mWindowLayoutParams;  
  65.       
  66.     /** 
  67.      * 我們拖拽的item對應的Bitmap 
  68.      */  
  69.     private Bitmap mDragBitmap;  
  70.       
  71.     /** 
  72.      * 按下的點到所在item的上邊緣的距離 
  73.      */  
  74.     private int mPoint2ItemTop ;   
  75.       
  76.     /** 
  77.      * 按下的點到所在item的左邊緣的距離 
  78.      */  
  79.     private int mPoint2ItemLeft;  
  80.       
  81.     /** 
  82.      * DragGridView距離屏幕頂部的偏移量 
  83.      */  
  84.     private int mOffset2Top;  
  85.       
  86.     /** 
  87.      * DragGridView距離屏幕左邊的偏移量 
  88.      */  
  89.     private int mOffset2Left;  
  90.       
  91.     /** 
  92.      * 狀態欄的高度 
  93.      */  
  94.     private int mStatusHeight;   
  95.       
  96.     /** 
  97.      * DragGridView自動向下滾動的邊界值 
  98.      */  
  99.     private int mDownScrollBorder;  
  100.       
  101.     /** 
  102.      * DragGridView自動向上滾動的邊界值 
  103.      */  
  104.     private int mUpScrollBorder;  
  105.       
  106.     /** 
  107.      * DragGridView自動滾動的速度 
  108.      */  
  109.     private static final int speed = 20;  
  110.       
  111.     /** 
  112.      * item發生變化回調的接口 
  113.      */  
  114.     private OnChanageListener onChanageListener;  
  115.       
  116.       
  117.       
  118.     public DragGridView(Context context) {  
  119.         this(context, null);  
  120.     }  
  121.       
  122.     public DragGridView(Context context, AttributeSet attrs) {  
  123.         this(context, attrs, 0);  
  124.     }  
  125.   
  126.     public DragGridView(Context context, AttributeSet attrs, int defStyle) {  
  127.         super(context, attrs, defStyle);  
  128.         mVibrator = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);  
  129.         mWindowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);  
  130.         mStatusHeight = getStatusHeight(context); //獲取狀態欄的高度  
  131.           
  132.     }  
  133.       
  134.     private Handler mHandler = new Handler();  
  135.       
  136.     //用來處理是否為長按的Runnable  
  137.     private Runnable mLongClickRunnable = new Runnable() {  
  138.           
  139.         @Override  
  140.         public void run() {  
  141.             isDrag = true; //設置可以拖拽  
  142.             mVibrator.vibrate(50); //震動一下  
  143.             mStartDragItemView.setVisibility(View.INVISIBLE);//隱藏該item  
  144.               
  145.             //根據我們按下的點顯示item鏡像  
  146.             createDragImage(mDragBitmap, mDownX, mDownY);  
  147.         }  
  148.     };  
  149.       
  150.     /** 
  151.      * 設置回調接口 
  152.      * @param onChanageListener 
  153.      */  
  154.     public void setOnChangeListener(OnChanageListener onChanageListener){  
  155.         this.onChanageListener = onChanageListener;  
  156.     }  
  157.       
  158.     /** 
  159.      * 設置響應拖拽的毫秒數，默認是1000毫秒 
  160.      * @param dragResponseMS 
  161.      */  
  162.     public void setDragResponseMS(long dragResponseMS) {  
  163.         this.dragResponseMS = dragResponseMS;  
  164.     }  
  165.   
  166.     @Override  
  167.     public boolean dispatchTouchEvent(MotionEvent ev) {  
  168.         switch(ev.getAction()){  
  169.         case MotionEvent.ACTION_DOWN:  
  170.             mDownX = (int) ev.getX();  
  171.             mDownY = (int) ev.getY();  
  172.               
  173.             //根據按下的X,Y坐標獲取所點擊item的position  
  174.             mDragPosition = pointToPosition(mDownX, mDownY);  
  175.               
  176.               
  177.             if(mDragPosition == AdapterView.INVALID_POSITION){  
  178.                 return super.dispatchTouchEvent(ev);  
  179.             }  
  180.               
  181.             //使用Handler延遲dragResponseMS執行mLongClickRunnable  
  182.             mHandler.postDelayed(mLongClickRunnable, dragResponseMS);  
  183.               
  184.             //根據position獲取該item所對應的View  
  185.             mStartDragItemView = getChildAt(mDragPosition - getFirstVisiblePosition());  
  186.               
  187.             //下麵這幾個距離大家可以參考我的博客上麵的圖來理解下  
  188.             mPoint2ItemTop = mDownY - mStartDragItemView.getTop();  
  189.             mPoint2ItemLeft = mDownX - mStartDragItemView.getLeft();  
  190.               
  191.             mOffset2Top = (int) (ev.getRawY() - mDownY);  
  192.             mOffset2Left = (int) (ev.getRawX() - mDownX);  
  193.               
  194.             //獲取DragGridView自動向上滾動的偏移量，小於這個值，DragGridView向下滾動  
  195.             mDownScrollBorder = getHeight() /4;  
  196.             //獲取DragGridView自動向下滾動的偏移量，大於這個值，DragGridView向上滾動  
  197.             mUpScrollBorder = getHeight() * 3/4;  
  198.               
  199.               
  200.               
  201.             //開啟mDragItemView繪圖緩存  
  202.             mStartDragItemView.setDrawingCacheEnabled(true);  
  203.             //獲取mDragItemView在緩存中的Bitmap對象  
  204.             mDragBitmap = Bitmap.createBitmap(mStartDragItemView.getDrawingCache());  
  205.             //這一步很關鍵，釋放繪圖緩存，避免出現重複的鏡像  
  206.             mStartDragItemView.destroyDrawingCache();  
  207.               
  208.               
  209.             break;  
  210.         case MotionEvent.ACTION_MOVE:  
  211.             int moveX = (int)ev.getX();  
  212.             int moveY = (int) ev.getY();  
  213.               
  214.             //如果我們在按下的item上麵移動，隻要不超過item的邊界我們就不移除mRunnable  
  215.             if(!isTouchInItem(mStartDragItemView, moveX, moveY)){  
  216.                 mHandler.removeCallbacks(mLongClickRunnable);  
  217.             }  
  218.             break;  
  219.         case MotionEvent.ACTION_UP:  
  220.             mHandler.removeCallbacks(mLongClickRunnable);  
  221.             mHandler.removeCallbacks(mScrollRunnable);  
  222.             break;  
  223.         }  
  224.         return super.dispatchTouchEvent(ev);  
  225.     }  
  226.   
  227.       
  228.     /** 
  229.      * 是否點擊在GridView的item上麵 
  230.      * @param itemView 
  231.      * @param x 
  232.      * @param y 
  233.      * @return 
  234.      */  
  235.     private boolean isTouchInItem(View dragView, int x, int y){  
  236.         if(dragView == null){  
  237.             return false;  
  238.         }  
  239.         int leftOffset = dragView.getLeft();  
  240.         int topOffset = dragView.getTop();  
  241.         if(x < leftOffset || x > leftOffset + dragView.getWidth()){  
  242.             return false;  
  243.         }  
  244.           
  245.         if(y < topOffset || y > topOffset + dragView.getHeight()){  
  246.             return false;  
  247.         }  
  248.           
  249.         return true;  
  250.     }  
  251.       
  252.       
  253.   
  254.     @Override  
  255.     public boolean onTouchEvent(MotionEvent ev) {  
  256.         if(isDrag && mDragImageView != null){  
  257.             switch(ev.getAction()){  
  258.             case MotionEvent.ACTION_MOVE:  
  259.                 moveX = (int) ev.getX();  
  260.                 moveY = (int) ev.getY();  
  261.                 //拖動item  
  262.                 onDragItem(moveX, moveY);  
  263.                 break;  
  264.             case MotionEvent.ACTION_UP:  
  265.                 onStopDrag();  
  266.                 isDrag = false;  
  267.                 break;  
  268.             }  
  269.             return true;  
  270.         }  
  271.         return super.onTouchEvent(ev);  
  272.     }  
  273.       
  274.       
  275.     /** 
  276.      * 創建拖動的鏡像 
  277.      * @param bitmap  
  278.      * @param downX 
  279.      *          按下的點相對父控件的X坐標 
  280.      * @param downY 
  281.      *          按下的點相對父控件的X坐標 
  282.      */  
  283.     private void createDragImage(Bitmap bitmap, int downX , int downY){  
  284.         mWindowLayoutParams = new WindowManager.LayoutParams();  
  285.         mWindowLayoutParams.format = PixelFormat.TRANSLUCENT; //圖片之外的其他地方透明  
  286.         mWindowLayoutParams.gravity = Gravity.TOP | Gravity.LEFT;  
  287.         mWindowLayoutParams.x = downX - mPoint2ItemLeft + mOffset2Left;  
  288.         mWindowLayoutParams.y = downY - mPoint2ItemTop + mOffset2Top - mStatusHeight;  
  289.         mWindowLayoutParams.alpha = 0.55f; //透明度  
  290.         mWindowLayoutParams.width = WindowManager.LayoutParams.WRAP_CONTENT;    
  291.         mWindowLayoutParams.height = WindowManager.LayoutParams.WRAP_CONTENT;    
  292.         mWindowLayoutParams.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE    
  293.                     | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE ;  
  294.             
  295.         mDragImageView = new ImageView(getContext());    
  296.         mDragImageView.setImageBitmap(bitmap);    
  297.         mWindowManager.addView(mDragImageView, mWindowLayoutParams);    
  298.     }  
  299.       
  300.     /** 
  301.      * 從界麵上麵移動拖動鏡像 
  302.      */  
  303.     private void removeDragImage(){  
  304.         if(mDragImageView != null){  
  305.             mWindowManager.removeView(mDragImageView);  
  306.             mDragImageView = null;  
  307.         }  
  308.     }  
  309.       
  310.     /** 
  311.      * 拖動item，在裏麵實現了item鏡像的位置更新，item的相互交換以及GridView的自行滾動 
  312.      * @param x 
  313.      * @param y 
  314.      */  
  315.     private void onDragItem(int moveX, int moveY){  
  316.         mWindowLayoutParams.x = moveX - mPoint2ItemLeft + mOffset2Left;  
  317.         mWindowLayoutParams.y = moveY - mPoint2ItemTop + mOffset2Top - mStatusHeight;  
  318.         mWindowManager.updateViewLayout(mDragImageView, mWindowLayoutParams); //更新鏡像的位置  
  319.         onSwapItem(moveX, moveY);  
  320.           
  321.         //GridView自動滾動  
  322.         mHandler.post(mScrollRunnable);  
  323.     }  
  324.       
  325.       
  326.     /** 
  327.      * 當moveY的值大於向上滾動的邊界值，觸發GridView自動向上滾動 
  328.      * 當moveY的值小於向下滾動的邊界值，觸犯GridView自動向下滾動 
  329.      * 否則不進行滾動 
  330.      */  
  331.     private Runnable mScrollRunnable = new Runnable() {  
  332.           
  333.         @Override  
  334.         public void run() {  
  335.             int scrollY;  
  336.             if(moveY > mUpScrollBorder){  
  337.                  scrollY = speed;  
  338.                  mHandler.postDelayed(mScrollRunnable, 25);  
  339.             }else if(moveY < mDownScrollBorder){  
  340.                 scrollY = -speed;  
  341.                  mHandler.postDelayed(mScrollRunnable, 25);  
  342.             }else{  
  343.                 scrollY = 0;  
  344.                 mHandler.removeCallbacks(mScrollRunnable);  
  345.             }  
  346.               
  347.             //當我們的手指到達GridView向上或者向下滾動的偏移量的時候，可能我們手指沒有移動，但是DragGridView在自動的滾動  
  348.             //所以我們在這裏調用下onSwapItem()方法來交換item  
  349.             onSwapItem(moveX, moveY);  
  350.               
  351.               
  352.             smoothScrollBy(scrollY, 10);  
  353.         }  
  354.     };  
  355.       
  356.       
  357.     /** 
  358.      * 交換item,並且控製item之間的顯示與隱藏效果 
  359.      * @param moveX 
  360.      * @param moveY 
  361.      */  
  362.     private void onSwapItem(int moveX, int moveY){  
  363.         //獲取我們手指移動到的那個item的position  
  364.         int tempPosition = pointToPosition(moveX, moveY);  
  365.           
  366.         //假如tempPosition 改變了並且tempPosition不等於-1,則進行交換  
  367.         if(tempPosition != mDragPosition && tempPosition != AdapterView.INVALID_POSITION){  
  368.             if(onChanageListener != null){  
  369.                 onChanageListener.onChange(mDragPosition, tempPosition);  
  370.             }  
  371.               
  372.             getChildAt(tempPosition - getFirstVisiblePosition()).setVisibility(View.INVISIBLE);//拖動到了新的item,新的item隱藏掉  
  373.             getChildAt(mDragPosition - getFirstVisiblePosition()).setVisibility(View.VISIBLE);//之前的item顯示出來  
  374.               
  375.             mDragPosition = tempPosition;  
  376.         }  
  377.     }  
  378.       
  379.       
  380.     /** 
  381.      * 停止拖拽我們將之前隱藏的item顯示出來，並將鏡像移除 
  382.      */  
  383.     private void onStopDrag(){  
  384.         View view = getChildAt(mDragPosition - getFirstVisiblePosition());  
  385.         if(view != null){  
  386.             view.setVisibility(View.VISIBLE);  
  387.         }  
  388.         ((DragAdapter)this.getAdapter()).setItemHide(-1);  
  389.         removeDragImage();  
  390.     }  
  391.       
  392.     /** 
  393.      * 獲取狀態欄的高度 
  394.      * @param context 
  395.      * @return 
  396.      */  
  397.     private static int getStatusHeight(Context context){  
  398.         int statusHeight = 0;  
  399.         Rect localRect = new Rect();  
  400.         ((Activity) context).getWindow().getDecorView().getWindowVisibleDisplayFrame(localRect);  
  401.         statusHeight = localRect.top;  
  402.         if (0 == statusHeight){  
  403.             Class<?> localClass;  
  404.             try {  
  405.                 localClass = Class.forName("com.android.internal.R$dimen");  
  406.                 Object localObject = localClass.newInstance();  
  407.                 int i5 = Integer.parseInt(localClass.getField("status_bar_height").get(localObject).toString());  
  408.                 statusHeight = context.getResources().getDimensionPixelSize(i5);  
  409.             } catch (Exception e) {  
  410.                 e.printStackTrace();  
  411.             }   
  412.         }  
  413.         return statusHeight;  
  414.     }  
  415.   
  416.       
  417.     /** 
  418.      *  
  419.      * @author xiaanming 
  420.      * 
  421.      */  
  422.     public interface OnChanageListener{  
  423.           
  424.         /** 
  425.          * 當item交換位置的時候回調的方法，我們隻需要在該方法中實現數據的交換即可 
  426.          * @param form 
  427.          *          開始的position 
  428.          * @param to  
  429.          *          拖拽到的position 
  430.          */  
  431.         public void onChange(int form, int to);  
  432.     }  
  433. }  

首先看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="https://schemas.android.com/apk/res/android"  
  2.     xmlns:tools="https://schemas.android.com/tools"  
  3.     android:layout_width="match_parent"  
  4.     android:layout_height="match_parent" >  
  5.   
  6.     <com.example.draggridview.DragGridView  
  7.         android:id="@+id/dragGridView"  
  8.         android:listSelector="@android:color/transparent"  
  9.         android:layout_width="match_parent"  
  10.         android:layout_height="match_parent"  
  11.         android:cacheColorHint="@android:color/transparent"  
  12.         android:verticalSpacing="10dip"  
  13.         android:horizontalSpacing="10dip"  
  14.         android:stretchMode="columnWidth"    
  15.         android:gravity="center"   
  16.         android:numColumns="3" >  
  17.     </com.example.draggridview.DragGridView>  
  18.   
  19. </RelativeLayout>  
接下來我們看看DragGridView的item的布局，上麵一個ImageView下麵一個TextView
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <RelativeLayout xmlns:android="https://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.   
  7.     <ImageView  
  8.         android:id="@+id/item_image"  
  9.         android:scaleType="centerCrop"  
  10.         android:layout_width="wrap_content"  
  11.         android:layout_height="wrap_content"  
  12.         android:layout_centerHorizontal="true" >  
  13.     </ImageView>  
  14.   
  15.     <TextView  
  16.         android:id="@+id/item_text"  
  17.         android:layout_width="wrap_content"  
  18.         android:layout_height="wrap_content"  
  19.         android:layout_below="@+id/item_image"  
  20.         android:layout_centerHorizontal="true" >  
  21.     </TextView>  
  22.   
  23. </RelativeLayout>  
布局搞定了我們就來看看主頁麵MainActivity的代碼吧
  1. package com.example.draggridview;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.Collections;  
  5. import java.util.HashMap;  
  6. import java.util.List;  
  7.   
  8. import android.app.Activity;  
  9. import android.os.Bundle;  
  10. import android.widget.SimpleAdapter;  
  11.   
  12. import com.example.draggridview.DragGridView.OnChanageListener;  
  13.   
  14. /** 
  15.  * @blog https://blog.csdn.net/xiaanming  
  16.  *  
  17.  * @author xiaanming 
  18.  * 
  19.  */  
  20. public class MainActivity extends Activity {  
  21.     private List<HashMap<String, Object>> dataSourceList = new ArrayList<HashMap<String, Object>>();  
  22.   
  23.     @Override  
  24.     protected void onCreate(Bundle savedInstanceState) {  
  25.         super.onCreate(savedInstanceState);  
  26.         setContentView(R.layout.activity_main);  
  27.   
  28.         DragGridView mDragGridView = (DragGridView) findViewById(R.id.dragGridView);  
  29.         for (int i = 0; i < 30; i++) {  
  30.             HashMap<String, Object> itemHashMap = new HashMap<String, Object>();  
  31.             itemHashMap.put("item_image",R.drawable.com_tencent_open_notice_msg_icon_big);  
  32.             itemHashMap.put("item_text", "拖拽 " + Integer.toString(i));  
  33.             dataSourceList.add(itemHashMap);  
  34.         }  
  35.           
  36.   
  37.         final SimpleAdapter mSimpleAdapter = new SimpleAdapter(this, dataSourceList,  
  38.                 R.layout.grid_item, new String[] { "item_image", "item_text" },  
  39.                 new int[] { R.id.item_image, R.id.item_text });  
  40.           
  41.         mDragGridView.setAdapter(mSimpleAdapter);  
  42.           
  43.         mDragGridView.setOnChangeListener(new OnChanageListener() {  
  44.               
  45.             @Override  
  46.             public void onChange(int from, int to) {  
  47.                 HashMap<String, Object> temp = dataSourceList.get(from);  
  48.                 //直接交互item  
  49. //              dataSourceList.set(from, dataSourceList.get(to));  
  50. //              dataSourceList.set(to, temp);  
  51. //              dataSourceList.set(to, temp);  
  52.                   
  53.                   
  54.                 //這裏的處理需要注意下  
  55.                 if(from < to){  
  56.                     for(int i=from; i<to; i++){  
  57.                         Collections.swap(dataSourceList, i, i+1);  
  58.                     }  
  59.                 }else if(from > to){  
  60.                     for(int i=from; i>to; i--){  
  61.                         Collections.swap(dataSourceList, i, i-1);  
  62.                     }  
  63.                 }  
  64.                   
  65.                 dataSourceList.set(to, temp);  
  66.                   
  67.                 mSimpleAdapter.notifyDataSetChanged();  
  68.                   
  69.                   
  70.             }  
  71.         });  
  72.           
  73.     }  
  74.   
  75. }  
這裏麵的代碼還是比較簡單，主要講下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以上的機器不出現朋友們所說的問題了，非常感謝大家提出的問題！

修改版源碼，點擊下載

再次聲明， 在修改版的源碼中還存在一點小BUG,不過已解決，正如28樓所說的一樣，是因為我在MainActivity的onChange()方法中調用了mDragAdapter.setItemHide(to)方法，主要是為了實現拖動到新的位置隱藏該Item, 使得mHidePosition不為-1，忘記在停止拖動onStopDrag()方法中將mHidePosition設置為-1了，所以為了解決28樓所說的問題，隻需要在onStopDrag()方法添加一句 ((DragAdapter)this.getAdapter()).setItemHide(-1)就行了

最後更新：2017-04-03 12:56:01

  上一篇：go 關於文件結構
  下一篇：go 九度1464：Hello World for U