devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

一个实现item可手动拖拽的ListView和GridView_安卓listview内部item可随意拖动放置

作者：很楠不爱3 | 2024-03-13 06:14:26

赞

踩

安卓listview内部item可随意拖动放置

 

上篇博客分享了一个实现ListView中item交换动画的控件（戳这里查看），但是有些情况下我们的需求比这种效果要复杂。比如说需要手动拖拽item来完成item交换的交互。像这样：

还有这样：

 

这次分享的控件就实现这样的功能，下面开始正文。

先说实现item拖拽功能的DragListView。上代码：

  1. public class DragListView extends ListView {
  2.  
  3.     /**
  4.      * 速度模板，影响视图移动时的速度变化
  5.      * <p>
  6.      * MODE_LINEAR                 // 线性变化模式
  7.      * MODE_ACCELERATE             // 加速模式
  8.      * MODE_DECELERATE             // 减速模式
  9.      * MODE_ACCELERATE_DECELERATE  // 先加速后加速模式
  10.      */
  11.     public static final int MODE_LINEAR = 0x001;
  12.     public static final int MODE_ACCELERATE = 0x002;
  13.     public static final int MODE_DECELERATE = 0x003;
  14.     public static final int MODE_ACCELERATE_DECELERATE = 0x004;
  15.  
  16.     private Context context;
  17.  
  18.     // 拖动时的视图
  19.     private View dragView;
  20.  
  21.  
  22.     private WindowManager windowManager;
  23.     private WindowManager.LayoutParams windowLayoutParams;
  24.     private BaseDragAdapter adapter;
  25.  
  26.  
  27.     /**
  28.      * 可设置选项
  29.      */
  30.     // 移动动画储持续时间，单位毫秒
  31.     private long duration = 300;
  32.  
  33.     // 速度模板
  34.     private int speedMode = MODE_ACCELERATE_DECELERATE;
  35.  
  36.     // 自动滚动的速度
  37.     private int scrollSpeed = 50;
  38.  
  39.  
  40.     /**
  41.      * 运行参数
  42.      */
  43.     // 拖动块的原始坐标
  44.     private int originalPosition = -1;
  45.  
  46.     // 拖动块当前所在坐标
  47.     private int currentPosition = -1;
  48.  
  49.     // 用于记录上次点击事件MotionEvent.getX();
  50.     private int lastX;
  51.  
  52.     // 用于记录上次点击事件MotionEvent.getY();
  53.     private int lastY;
  54.  
  55.     // 用于记录上次点击事件MotionEvent.getRawX();
  56.     private int lastRawX;
  57.  
  58.     // 用于记录上次点击事件MotionEvent.getRawY();
  59.     private int lastRawY;
  60.  
  61.     // 拖动块中心点x坐标，用于判断拖动块所处的列表位置
  62.     private int dragCenterX;
  63.  
  64.     // 拖动块中心点y坐标，用于判断拖动块所处的列表位置
  65.     private int dragCenterY;
  66.  
  67.     // 滑动上边界，拖动块中心超过该边界时列表自动向下滑动
  68.     private int upScrollBorder;
  69.  
  70.     // 滑动下边界，拖动块中心超过该边界时列表自动向上滑动
  71.     private int downScrollBorder;
  72.  
  73.     // 状态栏高度
  74.     private int statusHeight;
  75.  
  76.     // 拖动时的列表刷新标识符
  77.     private boolean dragRefresh;
  78.  
  79.     // 拖动锁定标记，为false时选中块可被拖动
  80.     private boolean dragLock = true;
  81.  
  82.     // 动画列表，存放当前屏幕上正在播放的所有滑动动画的动画对象
  83.     private ArrayList<Animator> animatorList;
  84.  
  85.     // 视图列表，存放当前屏幕上正在播放的所有滑动动画的视图对象
  86.     private ArrayList<View> dragViews;
  87.  
  88.  
  89.     /**
  90.      * 可监听接口
  91.      */
  92.     // 拖动块视图对象生成器，可通过设置该接口自定义一个拖动视图的样式，不设置时会有默认实现
  93.     private DragViewCreator dragViewCreator;
  94.  
  95.     // 拖动监听接口，拖动开始和结束时会在该接口回调
  96.     private OnDragingListener dragingListener;
  97.  
  98.     // 当前拖动目标位置改变时，每次改变都会在该接口回调
  99.     private OnDragTargetChangedListener targetChangedListener;
  100.  
  101.  
  102.     // 内部接口，动画观察者，滑动动画结束是回调
  103.     private AnimatorObserver animatorObserver;
  104.  
  105.     private Handler handler = new Handler();
  106.  
  107.     // 列表自动滚动线程
  108.     private Runnable scrollRunnable = new Runnable() {
  109.         @Override
  110.         public void run() {
  111.             int scrollY;
  112.  
  113.             // 滚动到顶或到底时停止滚动
  114.             if (getFirstVisiblePosition() == 0 || getLastVisiblePosition() == getCount() - 1) {
  115.                 handler.removeCallbacks(scrollRunnable);
  116.             }
  117.  
  118.             // 触控点y坐标超过上边界时，出发列表自动向下滚动
  119.             if (lastY > upScrollBorder) {
  120.                 scrollY = scrollSpeed;
  121.                 handler.postDelayed(scrollRunnable, 25);
  122.             }
  123.             // 触控点y坐标超过下边界时，出发列表自动向上滚动
  124.             else if (lastY < downScrollBorder) {
  125.                 scrollY = -scrollSpeed;
  126.                 handler.postDelayed(scrollRunnable, 25);
  127.             }
  128.             // // 触控点y坐标处于上下边界之间时，停止滚动
  129.             else {
  130.                 scrollY = 0;
  131.                 handler.removeCallbacks(scrollRunnable);
  132.             }
  133.  
  134.             smoothScrollBy(scrollY, 10);
  135.         }
  136.     };
  137.  
  138.     public DragListView(Context context) {
  139.         super(context);
  140.         init(context);
  141.     }
  142.  
  143.     public DragListView(Context context, AttributeSet attrs) {
  144.         super(context, attrs);
  145.         init(context);
  146.     }
  147.  
  148.     public DragListView(Context context, AttributeSet attrs, int defStyleAttr) {
  149.         super(context, attrs, defStyleAttr);
  150.         init(context);
  151.     }
  152.  
  153.     /**
  154.      * 初始化方法
  155.      *
  156.      * @param context
  157.      */
  158.     private void init(Context context) {
  159.         this.context = context;
  160.         statusHeight = getStatusHeight();
  161.         windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
  162.         animatorList = new ArrayList<>();
  163.         dragViews = new ArrayList<>();
  164.  
  165.         // 拖动块视图对象生成器的默认实现，返回一个与被拖动项外观一致的ImageView
  166.         dragViewCreator = new DragViewCreator() {
  167.             @Override
  168.             public View createDragView(int width, int height, Bitmap viewCache) {
  169.                 ImageView imageView = new ImageView(DragListView.this.context);
  170.                 imageView.setImageBitmap(viewCache);
  171.  
  172.                 return imageView;
  173.             }
  174.         };
  175.     }
  176.  
  177.     @Override
  178.     public boolean dispatchTouchEvent(MotionEvent motionEvent) {
  179.  
  180.         switch (motionEvent.getAction()) {
  181.             case MotionEvent.ACTION_DOWN:
  182.  
  183.                 downScrollBorder = getHeight() / 5;
  184.                 upScrollBorder = getHeight() * 4 / 5;
  185.  
  186.                 // 手指按下时记录相关坐标
  187.                 lastX = (int) motionEvent.getX();
  188.                 lastY = (int) motionEvent.getY();
  189.                 lastRawX = (int) motionEvent.getRawX();
  190.                 lastRawY = (int) motionEvent.getRawY();
  191.  
  192.                 currentPosition = pointToPosition(lastRawX, lastRawY);
  193.  
  194.                 if (currentPosition == AdapterView.INVALID_POSITION || !adapter.isDragAvailable(currentPosition)) {
  195.                     return true;
  196.                 }
  197.  
  198.                 originalPosition = currentPosition;
  199.  
  200.                 break;
  201.         }
  202.  
  203.         return super.dispatchTouchEvent(motionEvent);
  204.     }
  205.  
  206.     @Override
  207.     public boolean onTouchEvent(MotionEvent motionEvent) {
  208.         switch (motionEvent.getAction()) {
  209.             case MotionEvent.ACTION_MOVE:
  210.  
  211.                 if (!dragLock) {
  212.                     int currentRawX = (int) motionEvent.getRawX();
  213.                     int currentRawY = (int) motionEvent.getRawY();
  214.  
  215.                     if (dragView == null) {
  216.                         createDragImageView(getChildAt(pointToPosition(lastRawX, lastRawY) - getFirstVisiblePosition()));
  217.  
  218.                         getChildAt(originalPosition - getFirstVisiblePosition()).setVisibility(View.INVISIBLE);
  219.  
  220.                         if (dragingListener != null) {
  221.                             dragingListener.onStart(originalPosition);
  222.                         }
  223.                     }
  224.                     drag(currentRawY - lastRawY);
  225.                     if (dragingListener != null) {
  226.                         dragingListener.onDraging((int) motionEvent.getX(), (int) motionEvent.getY(), currentRawX, currentRawY);
  227.                     }
  228.  
  229.                     int position = pointToPosition(dragCenterX, dragCenterY);
  230.  
  231.                     // 满足交换条件时让目标位置的原有视图上滑或下滑
  232.                     if (position != AdapterView.INVALID_POSITION && currentPosition != position && adapter.isDragAvailable(position)) {
  233.                         translation(position, currentPosition);
  234.                         currentPosition = position;
  235.  
  236.                         if (targetChangedListener != null) {
  237.                             targetChangedListener.onTargetChanged(currentPosition);
  238.                         }
  239.                     }
  240.  
  241.                     // 更新点击位置
  242.                     lastX = (int) motionEvent.getX();
  243.                     lastY = (int) motionEvent.getY();
  244.                     lastRawX = currentRawX;
  245.                     lastRawY = currentRawY;
  246.  
  247.                     // 返回true消耗掉这次点击事件，防止ListView本身接收到这次点击事件后触发滚动
  248.                     return true;
  249.                 }
  250.                 break;
  251.             case MotionEvent.ACTION_UP:
  252.                 // 手指抬起时，如果所有滑动动画都已播放完毕，则直接执行拖动完成逻辑
  253.                 if (animatorList.size() == 0) {
  254.                     resetDataAndView();
  255.                     if (dragingListener != null) {
  256.                         dragingListener.onFinish(currentPosition);
  257.                     }
  258.                 }
  259.                 // 如果还有未播放完成的滑动动画，则注册观察者，延时执行拖动完成逻辑
  260.                 else {
  261.                     animatorObserver = new AnimatorObserver() {
  262.                         @Override
  263.                         public void onAllAnimatorFinish() {
  264.                             resetDataAndView();
  265.                             if (dragingListener != null) {
  266.                                 dragingListener.onFinish(currentPosition);
  267.                             }
  268.                         }
  269.                     };
  270.                 }
  271.                 break;
  272.         }
  273.  
  274.         return super.onTouchEvent(motionEvent);
  275.     }
  276.  
  277.     /**
  278.      * 创建拖动块视图方法
  279.      *
  280.      * @param view 被拖动位置的视图对象
  281.      */
  282.     private void createDragImageView(View view) {
  283.  
  284.         if (view == null) {
  285.             return;
  286.         }
  287.  
  288.         removeDragImageView();
  289.         int[] location = new int[2];
  290.  
  291.         view.getLocationOnScreen(location);
  292.         view.setDrawingCacheEnabled(true);
  293.         Bitmap bitmap = Bitmap.createBitmap(view.getDrawingCache());
  294.         view.destroyDrawingCache();
  295.  
  296.         windowLayoutParams = new WindowManager.LayoutParams();
  297.         windowLayoutParams.width = ViewGroup.LayoutParams.MATCH_PARENT;
  298.         windowLayoutParams.height = ViewGroup.LayoutParams.WRAP_CONTENT;
  299.         windowLayoutParams.format = PixelFormat.TRANSPARENT;
  300.         windowLayoutParams.gravity = Gravity.TOP | Gravity.LEFT;
  301.         windowLayoutParams.x = location[0];
  302.         windowLayoutParams.y = location[1] - statusHeight;
  303.         windowLayoutParams.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE;
  304.  
  305.         dragCenterX = windowLayoutParams.x + view.getWidth() / 2;
  306.         dragCenterY = windowLayoutParams.y + view.getHeight() / 2;
  307.  
  308.         dragView = dragViewCreator.createDragView(view.getWidth(), view.getHeight(), bitmap);
  309.  
  310.         if (dragView == null) {
  311.             throw new NullPointerException("dragView can not be null");
  312.         } else {
  313.             windowManager.addView(dragView, windowLayoutParams);
  314.         }
  315.     }
  316.  
  317.     /**
  318.      * 移除拖动视图方法
  319.      */
  320.     private void removeDragImageView() {
  321.         if (dragView != null && windowManager != null) {
  322.             windowManager.removeView(dragView);
  323.             dragView = null;
  324.             windowLayoutParams = null;
  325.         }
  326.     }
  327.  
  328.     /**
  329.      * 拖动方法
  330.      *
  331.      * @param dy
  332.      */
  333.     private void drag(int dy) {
  334.         dragCenterY += dy;
  335.         windowLayoutParams.y += dy;
  336.         windowManager.updateViewLayout(dragView, windowLayoutParams);
  337.  
  338.         handler.post(scrollRunnable);
  339.     }
  340.  
  341.     /**
  342.      * 移动指定位置视图方法
  343.      *
  344.      * @param fromPosition 移动起始位置
  345.      * @param toPosition   移动目标位置
  346.      */
  347.     private void translation(int fromPosition, int toPosition) {
  348.  
  349.         View fromView = getChildAt(fromPosition - getFirstVisiblePosition());
  350.         View toView = getChildAt(toPosition - getFirstVisiblePosition());
  351.  
  352.         if (fromView == null || toView == null) {
  353.             return;
  354.         }
  355.  
  356.         float distance = (toView.getY() - toView.getTranslationY()) - (fromView.getY() - fromView.getTranslationY());
  357.  
  358.         ObjectAnimator animator = ObjectAnimator.ofFloat(fromView, "translationY", 0, distance);
  359.         animator.setDuration(duration);
  360.         animator.setInterpolator(getAnimatorInterpolator());
  361.         animator.addListener(new AnimatorListenerAdapter() {
  362.             @Override
  363.             public void onAnimationEnd(Animator animation) {
  364.                 animatorList.remove(animation);
  365.                 // 所有滑动动画都播放结束时，执行相关操作
  366.                 if (animatorList.size() == 0) {
  367.                     // 重置所有滑动过的视图的translateY，避免列表刷新后视图重叠
  368.                     resetTranslate(dragViews);
  369.                     dragViews.clear();
  370.                     adapter.exchangeData(originalPosition, currentPosition);
  371.                     addOnLayoutChangeListener(new OnLayoutChangeListener() {
  372.                         @Override
  373.                         public void onLayoutChange(View v, int left, int top, int right, int bottom, int oldLeft, int oldTop, int oldRight, int oldBottom) {
  374.                             if (dragRefresh) {
  375.                                 removeOnLayoutChangeListener(this);
  376.                                 resetChildVisibility();
  377.                                 getChildAt(currentPosition - getFirstVisiblePosition()).setVisibility(View.INVISIBLE);
  378.                                 originalPosition = currentPosition;
  379.                                 dragRefresh = false;
  380.  
  381.                                 if (animatorObserver != null) {
  382.                                     animatorObserver.onAllAnimatorFinish();
  383.                                     animatorObserver = null;
  384.                                 }
  385.                             }
  386.                         }
  387.                     });
  388.                     dragRefresh = true;
  389.                     adapter.notifyDataSetChanged();
  390.                 }
  391.             }
  392.         });
  393.  
  394.         animatorList.add(animator);
  395.         dragViews.add(fromView);
  396.         animator.start();
  397.     }
  398.  
  399.     /**
  400.      * 重置列表所有项的可见性方法
  401.      */
  402.     private void resetChildVisibility() {
  403.         for (int i = 0; i < getChildCount(); i++) {
  404.             View child = getChildAt(i);
  405.             if (child != null) {
  406.                 child.setVisibility(VISIBLE);
  407.             }
  408.         }
  409.     }
  410.  
  411.     /**
  412.      * 重置指定视图的translateY属性方法
  413.      *
  414.      * @param list
  415.      */
  416.     private void resetTranslate(ArrayList<View> list) {
  417.         for (int i = 0; i < list.size(); i++) {
  418.             if (list.get(i) != null) {
  419.                 list.get(i).setTranslationY(0);
  420.             }
  421.         }
  422.     }
  423.  
  424.     /**
  425.      * 重置数据和视图相关数据方法
  426.      */
  427.     private void resetDataAndView() {
  428.         if (currentPosition == -1) {
  429.             return;
  430.         }
  431.         getChildAt(currentPosition - getFirstVisiblePosition()).setVisibility(View.VISIBLE);
  432.         originalPosition = -1;
  433.         currentPosition = -1;
  434.         handler.removeCallbacks(scrollRunnable);
  435.         removeDragImageView();
  436.     }
  437.  
  438.     @Override
  439.     public void setAdapter(ListAdapter adapter) {
  440.         if (adapter instanceof BaseDragAdapter) {
  441.             this.adapter = (BaseDragAdapter) adapter;
  442.             super.setAdapter(adapter);
  443.         } else {
  444.             throw new IllegalStateException("the adapter must extends BaseDragAdapter");
  445.         }
  446.     }
  447.  
  448.     /**
  449.      * 根据速度模板创建动画迭代器
  450.      *
  451.      * @return
  452.      */
  453.     private Interpolator getAnimatorInterpolator() {
  454.         switch (speedMode) {
  455.             case MODE_LINEAR:
  456.                 return new LinearInterpolator();
  457.             case MODE_ACCELERATE:
  458.                 return new AccelerateInterpolator();
  459.             case MODE_DECELERATE:
  460.                 return new DecelerateInterpolator();
  461.             case MODE_ACCELERATE_DECELERATE:
  462.                 return new AccelerateDecelerateInterpolator();
  463.             default:
  464.                 return null;
  465.         }
  466.     }
  467.  
  468.     /**
  469.      * 拖动解锁方法，调用者需手动调用该方法后才能开启列表拖动功能
  470.      */
  471.     public void unlockDrag() {
  472.         dragLock = false;
  473.     }
  474.  
  475.     /**
  476.      * 拖动锁定方法，调用者调用该方法后关闭列表拖动功能
  477.      */
  478.     public void lockDrag() {
  479.         dragLock = true;
  480.     }
  481.  
  482.     /**
  483.      * 设置移动动画持续时间
  484.      *
  485.      * @param duration 时间，单位毫秒
  486.      */
  487.     public void setDuration(long duration) {
  488.         this.duration = duration;
  489.     }
  490.  
  491.     /**
  492.      * 设置速度模式，可选项：
  493.      * MODE_LINEAR                线性变化模式
  494.      * MODE_ACCELERATE            加速模式
  495.      * MODE_DECELERATE            减速模式
  496.      * MODE_ACCELERATE_DECELERATE 先加速后加速模式
  497.      *
  498.      * @param speedMode
  499.      */
  500.     public void setSpeedMode(int speedMode) {
  501.         this.speedMode = speedMode;
  502.     }
  503.  
  504.     /**
  505.      * 设置自动滚动速度
  506.      *
  507.      * @param scrollSpeed 速度，单位：dp/10ms
  508.      */
  509.     public void setScrollSpeed(int scrollSpeed) {
  510.         this.scrollSpeed = scrollSpeed;
  511.     }
  512.  
  513.     /**
  514.      * 设置拖动块视图对象生成器方法
  515.      *
  516.      * @param creator
  517.      */
  518.     public void setDragViewCreator(DragViewCreator creator) {
  519.         if (creator == null) {
  520.             return;
  521.         }
  522.  
  523.         this.dragViewCreator = creator;
  524.     }
  525.  
  526.     /**
  527.      * 设置拖动监听接口
  528.      *
  529.      * @param dragingListener
  530.      */
  531.     public void setOnDragingListener(OnDragingListener dragingListener) {
  532.         this.dragingListener = dragingListener;
  533.     }
  534.  
  535.     /**
  536.      * 设置拖动目标位置改变监听接口
  537.      *
  538.      * @param targetChangedListener
  539.      */
  540.     public void setOnDragTargetChangedListener(OnDragTargetChangedListener targetChangedListener) {
  541.         this.targetChangedListener = targetChangedListener;
  542.     }
  543.  
  544.     private int getStatusHeight() {
  545.         int resourceId = context.getResources().getIdentifier("status_bar_height", "dimen", "android");
  546.         if (resourceId > 0) {
  547.             return context.getResources().getDimensionPixelSize(resourceId);
  548.         }
  549.  
  550.         return 0;
  551.     }
  552.  
  553.     /**
  554.      * 动画观察者
  555.      */
  556.     private interface AnimatorObserver {
  557.  
  558.         /**
  559.          * 滑动动画播放结束时回调
  560.          */
  561.         void onAllAnimatorFinish();
  562.  
  563.     }
  564.  
  565.     /**
  566.      * 拖动块视图对象生成器
  567.      */
  568.     public interface DragViewCreator {
  569.  
  570.         /**
  571.          * 创建拖动块视图对象方法，可通过实现该方法自定义拖动块样式
  572.          */
  573.         View createDragView(int width, int height, Bitmap viewCache);
  574.  
  575.     }
  576.  
  577.     /**
  578.      * 拖动监听接口
  579.      */
  580.     public interface OnDragingListener {
  581.  
  582.         /**
  583.          * 拖动开始时回调
  584.          *
  585.          * @param startPosition 拖动起始坐标
  586.          */
  587.         void onStart(int startPosition);
  588.  
  589.         /**
  590.          * 拖动过程中回调
  591.          *
  592.          * @param x    触控点相对ListView的x坐标
  593.          * @param y    触控点相对ListView的y坐标
  594.          * @param rawX 触控点相对屏幕的x坐标
  595.          * @param rawY 触控点相对屏幕的y坐标
  596.          */
  597.         void onDraging(int x, int y, int rawX, int rawY);
  598.  
  599.         /**
  600.          * 拖动结束时回调
  601.          *
  602.          * @param finalPosition 拖动终点坐标
  603.          */
  604.         void onFinish(int finalPosition);
  605.  
  606.     }
  607.  
  608.     /**
  609.      * 拖动目标位置改变监听接口
  610.      */
  611.     public interface OnDragTargetChangedListener {
  612.  
  613.         /**
  614.          * 拖动过程中，每次目标位置改变，会在该方法回调
  615.          *
  616.          * @param targetPosition 拖动目标位置坐标
  617.          */
  618.         void onTargetChanged(int targetPosition);
  619.  
  620.     }
  621. }

简单讲一下实现原理。手指按下时通过ListView的getChildAt方法获得按下位置的item并获取其视图缓存，也就是这句话：

  1. view.setDrawingCacheEnabled(true);
  2. Bitmap bitmap = Bitmap.createBitmap(view.getDrawingCache());
  3. view.destroyDrawingCache();

然后新建一个View把这个缓存塞进去并置于屏幕之上，并隐藏原来的item，让人看起来就好像是item被“拽”了下来，也就是这句话：

windowManager.addView(dragView, windowLayoutParams);

手指移动时，改变这个View的LayoutParams的y坐标值，让它跟随手指移动，也就是这两句话：

  1. windowLayoutParams.y += dy;
  2. windowManager.updateViewLayout(dragView, windowLayoutParams);

拖拽过程中，当判定交换行为发生时，用一个属性动画不断改变目标item的translationY属性来实现交换效果，也就是这句话：

ObjectAnimator animator = ObjectAnimator.ofFloat(fromView, "translationY", 0, distance);

具体代码大家可以看注释，应该写得比较清楚了。

要特别说明的是，DragListView的setAdapter方法被重写了，只接收BaseDragAdapter的继承类，BaseDragAdapter长这样：
 

  1. public abstract class BaseDragAdapter extends BaseAdapter {
  2.  
  3.     /**
  4.      * 调用者需实现该方法，返回列表的所有数据集合
  5.      *
  6.      * @return
  7.      */
  8.     public abstract List getDataList();
  9.  
  10.     /**
  11.      * 调用者可实现该方法自定义某一项是否可被拖动
  12.      *
  13.      * @param position
  14.      * @return
  15.      */
  16.     public abstract boolean isDragAvailable(int position);
  17.  
  18.     /**
  19.      * 实现数据交换方法
  20.      *
  21.      * @param oldPosition
  22.      * @param newPosition
  23.      */
  24.     public void exchangeData(int oldPosition, int newPosition) {
  25.  
  26.         List list = getDataList();
  27.         if (list == null) {
  28.             return;
  29.         }
  30.         Object temp = list.get(oldPosition);
  31.         if (oldPosition < newPosition) {
  32.             for (int i = oldPosition; i < newPosition; i++) {
  33.                 Collections.swap(list, i, i + 1);
  34.             }
  35.         } else if (oldPosition > newPosition) {
  36.             for (int i = oldPosition; i > newPosition; i--) {
  37.                 Collections.swap(list, i, i - 1);
  38.             }
  39.         }
  40.         list.set(newPosition, temp);
  41.     }
  42. }

BaseDragAdapter的目的是替调用者封装一些必要的操作，它给普通的BaseAdapter增加了两个需要实现的抽象方法：getDataList()和isDragAvailable()。getDataList()返回ListView 的数据列表即可，isDragAvailable()用来让调用者决定某个item是否可被拖拽，比如说需求是列表的第一项不可被拖拽，只需要实现isDragAvailable方法，在position=0时返回false即可。

然后就可以使用了。先写一个item的布局：
 

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3.     android:id="@+id/item_layout"
  4.     android:layout_width="match_parent"
  5.     android:layout_height="wrap_content"
  6.     android:background="#FFFAFA"
  7.     android:orientation="vertical">
  8.  
  9.     <TextView
  10.         android:id="@+id/content_textview"
  11.         android:layout_width="wrap_content"
  12.         android:layout_height="wrap_content"
  13.         android:paddingLeft="15dp"
  14.         android:paddingTop="20dp"
  15.         android:paddingRight="15dp"
  16.         android:paddingBottom="20dp"
  17.         android:text="我是内容"
  18.         android:textSize="20sp" />
  19.  
  20.     <View
  21.         android:id="@+id/divider_line"
  22.         android:layout_width="match_parent"
  23.         android:layout_height="1dp"
  24.         android:layout_marginLeft="15dp"
  25.         android:background="#eeeeee" />
  26.  
  27. </LinearLayout>

再简单写一个适配器TestListViewAdapter继承自BaseDragAdapter：

  1. public class TestListViewAdapter extends BaseDragAdapter {
  2.  
  3.     private Context context;
  4.     private int resourceId;
  5.     private ArrayList<String> list;
  6.  
  7.     private Vibrator vibrator;
  8.  
  9.     private OnItemLongClickListener listener;
  10.  
  11.     public TestListViewAdapter(Context context, int resourceId, ArrayList<String> list) {
  12.         this.context = context;
  13.         this.resourceId = resourceId;
  14.         this.list = list;
  15.         this.vibrator = (Vibrator) context.getSystemService(context.VIBRATOR_SERVICE);
  16.     }
  17.  
  18.     @Override
  19.     public List getDataList() {
  20.         return list;
  21.     }
  22.  
  23.     @Override
  24.     public boolean isDragAvailable(int position) {
  25.         return true;
  26.     }
  27.  
  28.     @Override
  29.     public int getCount() {
  30.         return list.size();
  31.     }
  32.  
  33.     @Override
  34.     public Object getItem(int position) {
  35.         return list.get(position);
  36.     }
  37.  
  38.     @Override
  39.     public long getItemId(int position) {
  40.         return position;
  41.     }
  42.  
  43.     @Override
  44.     public View getView(final int position, View convertView, ViewGroup parent) {
  45.         View view;
  46.         ViewHolder viewHolder;
  47.         if (convertView == null) {
  48.             view = LayoutInflater.from(context).inflate(resourceId, null);
  49.             viewHolder = new ViewHolder();
  50.             viewHolder.itemLayout = view.findViewById(R.id.item_layout);
  51.             viewHolder.contentTextView = view.findViewById(R.id.content_textview);
  52.             viewHolder.dividerLine = view.findViewById(R.id.divider_line);
  53.             view.setTag(viewHolder);
  54.         } else {
  55.             view = convertView;
  56.             viewHolder = (ViewHolder) view.getTag();
  57.         }
  58.  
  59.         viewHolder.contentTextView.setText(list.get(position));
  60.  
  61.         viewHolder.dividerLine.setVisibility(position != list.size() - 1 ? View.VISIBLE : View.INVISIBLE);
  62.  
  63.         viewHolder.itemLayout.setOnLongClickListener(new View.OnLongClickListener() {
  64.             @Override
  65.             public boolean onLongClick(View v) {
  66.                 vibrator.vibrate(100);
  67.  
  68.                 if (listener != null) {
  69.                     listener.onItemLongClick(position);
  70.                 }
  71.  
  72.                 return false;
  73.             }
  74.         });
  75.  
  76.         return view;
  77.     }
  78.  
  79.     public void setOnItemLongClickListener(OnItemLongClickListener listener) {
  80.         this.listener = listener;
  81.     }
  82.  
  83.     public interface OnItemLongClickListener {
  84.  
  85.         void onItemLongClick(int position);
  86.  
  87.     }
  88.  
  89.     class ViewHolder {
  90.         LinearLayout itemLayout;
  91.         TextView contentTextView;
  92.         View dividerLine;
  93.     }
  94. }

代码很简单，就不多说了。

最后就可以使用了，Activity里这样写：
 

  1. private DragListView dragListView;
  2.  
  3. private TestListViewAdapter adapter;
  4.  
  5. private ArrayList<String> list;
  6.  
  7. @Override
  8. protected void onCreate(Bundle savedInstanceState) {
  9.     super.onCreate(savedInstanceState);
  10.     setContentView(R.layout.activity_drag_listview_test);
  11.  
  12.     initData();
  13.     initView();
  14. }
  15.  
  16. private void initData() {
  17.     list = new ArrayList<>();
  18.  
  19.     for (int i = 1; i <= 40; i++) {
  20.         list.add("我是第" + i + "条数据");
  21.     }
  22. }
  23.  
  24. private void initView() {
  25.     dragListView = findViewById(R.id.drag_listview);
  26.  
  27.     dragListView.setOnDragingListener(new DragListView.OnDragingListener() {
  28.         @Override
  29.         public void onStart(int startPosition) {
  30.  
  31.         }
  32.  
  33.         @Override
  34.         public void onDraging(int x, int y, int rawX, int rawY) {
  35.  
  36.         }
  37.  
  38.         @Override
  39.         public void onFinish(int finalPosition) {
  40.             dragListView.lockDrag();
  41.         }
  42.     });
  43.  
  44.     adapter = new TestListViewAdapter(this, R.layout.item_test_listview, list);
  45.  
  46.     adapter.setOnItemLongClickListener(new TestListViewAdapter.OnItemLongClickListener() {
  47.         @Override
  48.         public void onItemLongClick(int position) {
  49.             dragListView.unlockDrag();
  50.         }
  51.     });
  52.  
  53.     dragListView.setAdapter(adapter);
  54. }

用法和普通的ListView一样，通过调用unlockDrag()来解锁拖动（示例代码中通过长按操作来解锁），通过调用lockDrag()方法来锁定拖动。之后还可以通过设置OnDragingListener来监听拖拽过程。开启和锁定拖动操作的条件视项目需求而定，比如长安开启，或者按编辑按钮开启等等。

最后运行一下就可以看到开头的效果了。

控件支持自定义拖拽View的样式。可以通过setDragViewCreator()方法来实现。比如说我想给拖拽的View加一个高亮效果，就可以这样写：

  1. dragListView.setDragViewCreator(new DragListView.DragViewCreator() {
  2.     @Override
  3.     public View createDragView(int width, int height, Bitmap viewCache) {
  4.         RelativeLayout layout = new RelativeLayout(DragListViewTestActivity.this);
  5.  
  6.         ImageView imageView = new ImageView(DragListViewTestActivity.this);
  7.         imageView.setImageBitmap(viewCache);
  8.         layout.addView(imageView, new RelativeLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, height));
  9.  
  10.         View view = new View(DragListViewTestActivity.this);
  11.         view.setBackground(getDrawable(R.drawable.edging_red));
  12.         layout.addView(view, new RelativeLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, height));
  13.  
  14.         return layout;
  15.     }
  16. });

其中高亮的资源edging_red.xml长这样：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <shape xmlns:android="http://schemas.android.com/apk/res/android">
  3.  
  4.     <stroke
  5.         android:width="1dp"
  6.         android:color="#FF6347" />
  7.  
  8.     <solid android:color="#70FFC0CB" />
  9.  
  10. </shape>

代码很简单，就是新建一个Layout，里面放一张图片，再在之上加一层高亮遮罩，并将这个layout返回给DragViewCreator接口即可。运行一下看一下效果：

 

同样的原理再写一个支持item拖拽的GridView，上源码：

  1. public class DragGridView extends GridView {
  2.  
  3.     /**
  4.      * 速度模板，影响视图移动时的速度变化
  5.      * <p>
  6.      * MODE_LINEAR                 // 线性变化模式
  7.      * MODE_ACCELERATE             // 加速模式
  8.      * MODE_DECELERATE             // 减速模式
  9.      * MODE_ACCELERATE_DECELERATE  // 先加速后加速模式
  10.      */
  11.     public static final int MODE_LINEAR = 0x001;
  12.     public static final int MODE_ACCELERATE = 0x002;
  13.     public static final int MODE_DECELERATE = 0x003;
  14.     public static final int MODE_ACCELERATE_DECELERATE = 0x004;
  15.  
  16.     private Context context;
  17.  
  18.     // 拖动时的视图
  19.     private View dragView;
  20.  
  21.  
  22.     private WindowManager windowManager;
  23.     private WindowManager.LayoutParams windowLayoutParams;
  24.     private BaseDragAdapter adapter;
  25.  
  26.     /**
  27.      * 可设置选项
  28.      */
  29.     // 移动动画储持续时间，单位毫秒
  30.     private long duration = 300;
  31.  
  32.     // 速度模板
  33.     private int speedMode = MODE_ACCELERATE_DECELERATE;
  34.  
  35.     // 自动滚动的速度
  36.     private int scrollSpeed = 50;
  37.  
  38.  
  39.     /**
  40.      * 运行参数
  41.      */
  42.     // 拖动块的原始坐标
  43.     private int originalPosition = -1;
  44.  
  45.     // 拖动块当前所在坐标
  46.     private int currentPosition = -1;
  47.  
  48.     // 用于记录上次点击事件MotionEvent.getX();
  49.     private int lastX;
  50.  
  51.     // 用于记录上次点击事件MotionEvent.getY();
  52.     private int lastY;
  53.  
  54.     // 用于记录上次点击事件MotionEvent.getRawX();
  55.     private int lastRawX;
  56.  
  57.     // 用于记录上次点击事件MotionEvent.getRawY();
  58.     private int lastRawY;
  59.  
  60.     // 拖动块中心点x坐标，用于判断拖动块所处的列表位置
  61.     private int dragCenterX;
  62.  
  63.     // 拖动块中心点y坐标，用于判断拖动块所处的列表位置
  64.     private int dragCenterY;
  65.  
  66.     // 滑动上边界，拖动块中心超过该边界时列表自动向下滑动
  67.     private int upScrollBorder;
  68.  
  69.     // 滑动下边界，拖动块中心超过该边界时列表自动向上滑动
  70.     private int downScrollBorder;
  71.  
  72.     // 状态栏高度
  73.     private int statusHeight;
  74.  
  75.     // 拖动时的列表刷新标识符
  76.     private boolean dragRefresh;
  77.  
  78.     // 拖动锁定标记，为false时选中块可被拖动
  79.     private boolean dragLock = true;
  80.  
  81.     // 动画列表，存放当前屏幕上正在播放的所有滑动动画的动画对象
  82.     private ArrayList<Animator> animatorList;
  83.  
  84.     // 视图列表，存放当前屏幕上正在播放的所有滑动动画的视图对象
  85.     private ArrayList<View> dragViews;
  86.  
  87.     /**
  88.      * 可监听接口
  89.      */
  90.     // 拖动块视图对象生成器，可通过设置该接口自定义一个拖动视图的样式，不设置时会有默认实现
  91.     private DragViewCreator dragViewCreator;
  92.  
  93.     // 拖动监听接口，拖动开始和结束时会在该接口回调
  94.     private OnDragingListener dragingListener;
  95.  
  96.     // 当前拖动目标位置改变时，每次改变都会在该接口回调
  97.     private OnDragTargetChangedListener targetChangedListener;
  98.  
  99.  
  100.     // 内部接口，动画观察者，滑动动画结束是回调
  101.     private AnimatorObserver animatorObserver;
  102.  
  103.     private Handler handler = new Handler();
  104.  
  105.     // 列表自动滚动线程
  106.     private Runnable scrollRunnable = new Runnable() {
  107.         @Override
  108.         public void run() {
  109.             int scrollY;
  110.  
  111.             // 滚动到顶或到底时停止滚动
  112.             if (getFirstVisiblePosition() == 0 || getLastVisiblePosition() == getCount() - 1) {
  113.                 handler.removeCallbacks(scrollRunnable);
  114.             }
  115.  
  116.             // 触控点y坐标超过上边界时，出发列表自动向下滚动
  117.             if (lastY > upScrollBorder) {
  118.                 scrollY = scrollSpeed;
  119.                 handler.postDelayed(scrollRunnable, 25);
  120.             }
  121.             // 触控点y坐标超过下边界时，出发列表自动向上滚动
  122.             else if (lastY < downScrollBorder) {
  123.                 scrollY = -scrollSpeed;
  124.                 handler.postDelayed(scrollRunnable, 25);
  125.             }
  126.             // // 触控点y坐标处于上下边界之间时，停止滚动
  127.             else {
  128.                 scrollY = 0;
  129.                 handler.removeCallbacks(scrollRunnable);
  130.             }
  131.  
  132.             smoothScrollBy(scrollY, 10);
  133.         }
  134.     };
  135.  
  136.     public DragGridView(Context context) {
  137.         super(context);
  138.         init(context);
  139.     }
  140.  
  141.     public DragGridView(Context context, AttributeSet attrs) {
  142.         super(context, attrs);
  143.         init(context);
  144.     }
  145.  
  146.     public DragGridView(Context context, AttributeSet attrs, int defStyleAttr) {
  147.         super(context, attrs, defStyleAttr);
  148.         init(context);
  149.     }
  150.  
  151.     /**
  152.      * 初始化方法
  153.      *
  154.      * @param context
  155.      */
  156.     private void init(Context context) {
  157.         this.context = context;
  158.         statusHeight = getStatusHeight();
  159.         windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
  160.         animatorList = new ArrayList<>();
  161.         dragViews = new ArrayList<>();
  162.  
  163.         // 拖动块视图对象生成器的默认实现，返回一个与被拖动项外观一致的ImageView
  164.         dragViewCreator = new DragGridView.DragViewCreator() {
  165.             @Override
  166.             public View createDragView(int width, int height, Bitmap viewCache) {
  167.                 ImageView imageView = new ImageView(DragGridView.this.context);
  168.                 imageView.setImageBitmap(viewCache);
  169.  
  170.                 return imageView;
  171.             }
  172.         };
  173.     }
  174.  
  175.     @Override
  176.     public boolean dispatchTouchEvent(MotionEvent motionEvent) {
  177.  
  178.         switch (motionEvent.getAction()) {
  179.             case MotionEvent.ACTION_DOWN:
  180.  
  181.                 downScrollBorder = getHeight() / 5;
  182.                 upScrollBorder = getHeight() * 4 / 5;
  183.  
  184.                 // 手指按下时记录相关坐标
  185.                 lastX = (int) motionEvent.getX();
  186.                 lastY = (int) motionEvent.getY();
  187.                 lastRawX = (int) motionEvent.getRawX();
  188.                 lastRawY = (int) motionEvent.getRawY();
  189.  
  190.                 currentPosition = pointToPosition(lastRawX, lastRawY);
  191.  
  192.                 if (currentPosition == AdapterView.INVALID_POSITION || !adapter.isDragAvailable(currentPosition)) {
  193.                     return true;
  194.                 }
  195.  
  196.                 originalPosition = currentPosition;
  197.  
  198.                 break;
  199.         }
  200.  
  201.         return super.dispatchTouchEvent(motionEvent);
  202.     }
  203.  
  204.     @Override
  205.     public boolean onTouchEvent(MotionEvent motionEvent) {
  206.         switch (motionEvent.getAction()) {
  207.             case MotionEvent.ACTION_MOVE:
  208.                 if (!dragLock) {
  209.                     int currentRawX = (int) motionEvent.getRawX();
  210.                     int currentRawY = (int) motionEvent.getRawY();
  211.  
  212.                     if (dragView == null) {
  213.                         createDragImageView(getChildAt(pointToPosition(lastRawX, lastRawY) - getFirstVisiblePosition()));
  214.  
  215.                         getChildAt(originalPosition - getFirstVisiblePosition()).setVisibility(View.INVISIBLE);
  216.  
  217.                         if (dragingListener != null) {
  218.                             dragingListener.onStart(originalPosition);
  219.                         }
  220.                     }
  221.                     drag(currentRawX - lastRawX, currentRawY - lastRawY);
  222.                     if (dragingListener != null) {
  223.                         dragingListener.onDraging((int) motionEvent.getX(), (int) motionEvent.getY(), currentRawX, currentRawY);
  224.                     }
  225.  
  226.                     int position = pointToPosition(dragCenterX, dragCenterY);
  227.  
  228.                     if (position != AdapterView.INVALID_POSITION
  229.                             && currentPosition != position
  230.                             && adapter.isDragAvailable(position)
  231.                             && animatorList.size() == 0) {
  232.  
  233.                         translation(position, currentPosition);
  234.  
  235.                         currentPosition = position;
  236.  
  237.                         if (targetChangedListener != null) {
  238.                             targetChangedListener.onTargetChanged(currentPosition);
  239.                         }
  240.                     }
  241.  
  242.                     // 更新点击位置
  243.                     lastX = (int) motionEvent.getX();
  244.                     lastY = (int) motionEvent.getY();
  245.                     lastRawX = currentRawX;
  246.                     lastRawY = currentRawY;
  247.  
  248.                     // 返回true消耗掉这次点击事件，防止ListView本身接收到这次点击事件后触发滚动
  249.                     return true;
  250.                 }
  251.                 break;
  252.             case MotionEvent.ACTION_UP:
  253.                 // 手指抬起时，如果所有滑动动画都已播放完毕，则直接执行拖动完成逻辑
  254.                 if (animatorList.size() == 0) {
  255.                     resetDataAndView();
  256.                     if (dragingListener != null) {
  257.                         dragingListener.onFinish(currentPosition);
  258.                     }
  259.                 }
  260.                 // 如果还有未播放完成的滑动动画，则注册观察者，延时执行拖动完成逻辑
  261.                 else {
  262.                     animatorObserver = new AnimatorObserver() {
  263.                         @Override
  264.                         public void onAllAnimatorFinish() {
  265.                             resetDataAndView();
  266.                             if (dragingListener != null) {
  267.                                 dragingListener.onFinish(currentPosition);
  268.                             }
  269.                         }
  270.                     };
  271.                 }
  272.                 break;
  273.         }
  274.  
  275.         return super.onTouchEvent(motionEvent);
  276.     }
  277.  
  278.     /**
  279.      * 创建拖动块视图方法
  280.      *
  281.      * @param view 被拖动位置的视图对象
  282.      */
  283.     private void createDragImageView(View view) {
  284.  
  285.         if (view == null) {
  286.             return;
  287.         }
  288.  
  289.         removeDragImageView();
  290.         int[] location = new int[2];
  291.  
  292.         view.getLocationOnScreen(location);
  293.         view.setDrawingCacheEnabled(true);
  294.         Bitmap bitmap = Bitmap.createBitmap(view.getDrawingCache());
  295.         view.destroyDrawingCache();
  296.  
  297.         windowLayoutParams = new WindowManager.LayoutParams();
  298.         windowLayoutParams.width = ViewGroup.LayoutParams.WRAP_CONTENT;
  299.         windowLayoutParams.height = ViewGroup.LayoutParams.WRAP_CONTENT;
  300.         windowLayoutParams.format = PixelFormat.TRANSPARENT;
  301.         windowLayoutParams.gravity = Gravity.TOP | Gravity.LEFT;
  302.         windowLayoutParams.x = location[0];
  303.         windowLayoutParams.y = location[1] - statusHeight;
  304.         windowLayoutParams.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE;
  305.  
  306.         dragCenterX = windowLayoutParams.x + view.getWidth() / 2;
  307.         dragCenterY = windowLayoutParams.y + view.getHeight() / 2;
  308.  
  309.         dragView = dragViewCreator.createDragView(view.getWidth(), view.getHeight(), bitmap);
  310.  
  311.         if (dragView == null) {
  312.             throw new NullPointerException("dragView can not be null");
  313.         } else {
  314.             windowManager.addView(dragView, windowLayoutParams);
  315.         }
  316.     }
  317.  
  318.     /**
  319.      * 移除拖动视图方法
  320.      */
  321.     private void removeDragImageView() {
  322.         if (dragView != null && windowManager != null) {
  323.             windowManager.removeView(dragView);
  324.             dragView = null;
  325.             windowLayoutParams = null;
  326.         }
  327.     }
  328.  
  329.     /**
  330.      * 拖动方法
  331.      *
  332.      * @param dx
  333.      * @param dy
  334.      */
  335.     private void drag(int dx, int dy) {
  336.  
  337.         dragCenterX += dx;
  338.         dragCenterY += dy;
  339.         windowLayoutParams.x += dx;
  340.         windowLayoutParams.y += dy;
  341.         windowManager.updateViewLayout(dragView, windowLayoutParams);
  342.  
  343.         handler.post(scrollRunnable);
  344.     }
  345.  
  346.     /**
  347.      * 移动指定位置视图方法
  348.      *
  349.      * @param fromPosition 移动起始位置
  350.      * @param toPosition   移动目标位置
  351.      */
  352.     private void translation(int fromPosition, int toPosition) {
  353.         ArrayList<Animator> list = new ArrayList<>();
  354.         if (toPosition > fromPosition) {
  355.             for (int position = fromPosition; position < toPosition; position++) {
  356.                 View view = getChildAt(position - getFirstVisiblePosition());
  357.                 dragViews.add(view);
  358.                 if ((position + 1) % getNumColumns() == 0) {
  359.                     list.add(createTranslationAnimations(view,
  360.                             0,
  361.                             -(view.getWidth() + getVerticalSpacing()) * (getNumColumns() - 1),
  362.                             0,
  363.                             view.getHeight() + getHorizontalSpacing()));
  364.                 } else {
  365.                     list.add(createTranslationAnimations(view,
  366.                             0,
  367.                             view.getWidth() + getVerticalSpacing(),
  368.                             0,
  369.                             0));
  370.                 }
  371.             }
  372.         } else {
  373.             for (int position = fromPosition; position > toPosition; position--) {
  374.                 View view = getChildAt(position - getFirstVisiblePosition());
  375.                 dragViews.add(view);
  376.                 if (position % getNumColumns() == 0) {
  377.                     list.add(createTranslationAnimations(view,
  378.                             0,
  379.                             (view.getWidth() + getVerticalSpacing()) * (getNumColumns() - 1),
  380.                             0,
  381.                             -(view.getHeight() + getHorizontalSpacing())));
  382.                 } else {
  383.                     list.add(createTranslationAnimations(view,
  384.                             0,
  385.                             -(view.getWidth() + getVerticalSpacing()),
  386.                             0,
  387.                             0));
  388.                 }
  389.             }
  390.         }
  391.  
  392.         AnimatorSet animatorSet = new AnimatorSet();
  393.         animatorSet.playTogether(list);
  394.         animatorSet.setDuration(duration);
  395.         animatorSet.setInterpolator(getAnimatorInterpolator());
  396.         animatorSet.addListener(new AnimatorListenerAdapter() {
  397.             @Override
  398.             public void onAnimationEnd(Animator animation) {
  399.                 animatorList.remove(animation);
  400.                 // 所有滑动动画都播放结束时，执行相关操作
  401.                 if (animatorList.size() == 0) {
  402.                     // 重置所有滑动过的视图的translateY，避免列表刷新后视图重叠
  403.                     resetTranslate(dragViews);
  404.                     dragViews.clear();
  405.                     adapter.exchangeData(originalPosition, currentPosition);
  406.                     addOnLayoutChangeListener(new OnLayoutChangeListener() {
  407.                         @Override
  408.                         public void onLayoutChange(View v, int left, int top, int right, int bottom, int oldLeft, int oldTop, int oldRight, int oldBottom) {
  409.                             if (dragRefresh) {
  410.                                 removeOnLayoutChangeListener(this);
  411.                                 resetChildVisibility();
  412.                                 getChildAt(currentPosition - getFirstVisiblePosition()).setVisibility(View.INVISIBLE);
  413.                                 originalPosition = currentPosition;
  414.                                 dragRefresh = false;
  415.  
  416.                                 if (animatorObserver != null) {
  417.                                     animatorObserver.onAllAnimatorFinish();
  418.                                     animatorObserver = null;
  419.                                 }
  420.                             }
  421.                         }
  422.                     });
  423.                     dragRefresh = true;
  424.                     adapter.notifyDataSetChanged();
  425.                 }
  426.             }
  427.         });
  428.  
  429.         animatorList.add(animatorSet);
  430.         animatorSet.start();
  431.     }
  432.  
  433.     /**
  434.      * 生成移动动画方法
  435.      *
  436.      * @param view   需要移动的视图
  437.      * @param startX 移动起始x坐标
  438.      * @param endX   移动终点x坐标
  439.      * @param startY 移动起始y坐标
  440.      * @param endY   移动终点y坐标
  441.      * @return
  442.      */
  443.     private Animator createTranslationAnimations(View view, float startX, float endX, float startY, float endY) {
  444.         ObjectAnimator animatorX = ObjectAnimator.ofFloat(view, "translationX", startX, endX);
  445.         ObjectAnimator animatorY = ObjectAnimator.ofFloat(view, "translationY", startY, endY);
  446.         AnimatorSet animatorSet = new AnimatorSet();
  447.         animatorSet.playTogether(animatorX, animatorY);
  448.         return animatorSet;
  449.     }
  450.  
  451.     /**
  452.      * 重置列表所有项的可见性方法
  453.      */
  454.     private void resetChildVisibility() {
  455.         for (int i = 0; i < getChildCount(); i++) {
  456.             View child = getChildAt(i);
  457.             if (child != null) {
  458.                 child.setVisibility(VISIBLE);
  459.             }
  460.         }
  461.     }
  462.  
  463.     /**
  464.      * 重置指定视图的translateY属性方法
  465.      *
  466.      * @param list
  467.      */
  468.     private void resetTranslate(ArrayList<View> list) {
  469.         for (int i = 0; i < list.size(); i++) {
  470.             if (list.get(i) != null) {
  471.                 list.get(i).setTranslationX(0);
  472.                 list.get(i).setTranslationY(0);
  473.             }
  474.         }
  475.     }
  476.  
  477.     /**
  478.      * 重置数据和视图相关数据方法
  479.      */
  480.     private void resetDataAndView() {
  481.         if (currentPosition == -1) {
  482.             return;
  483.         }
  484.         getChildAt(currentPosition - getFirstVisiblePosition()).setVisibility(View.VISIBLE);
  485.         originalPosition = -1;
  486.         currentPosition = -1;
  487.         dragLock = true;
  488.         handler.removeCallbacks(scrollRunnable);
  489.         removeDragImageView();
  490.     }
  491.  
  492.     @Override
  493.     public void setAdapter(ListAdapter adapter) {
  494.         if (adapter instanceof BaseDragAdapter) {
  495.             this.adapter = (BaseDragAdapter) adapter;
  496.             super.setAdapter(adapter);
  497.         } else {
  498.             throw new IllegalStateException("the adapter must extends BaseDragAdapter");
  499.         }
  500.     }
  501.  
  502.     /**
  503.      * 根据速度模板创建动画迭代器
  504.      *
  505.      * @return
  506.      */
  507.     private Interpolator getAnimatorInterpolator() {
  508.         switch (speedMode) {
  509.             case MODE_LINEAR:
  510.                 return new LinearInterpolator();
  511.             case MODE_ACCELERATE:
  512.                 return new AccelerateInterpolator();
  513.             case MODE_DECELERATE:
  514.                 return new DecelerateInterpolator();
  515.             case MODE_ACCELERATE_DECELERATE:
  516.                 return new AccelerateDecelerateInterpolator();
  517.             default:
  518.                 return null;
  519.         }
  520.     }
  521.  
  522.     /**
  523.      * 拖动解锁方法，调用者需手动调用该方法后才能开启列表拖动功能
  524.      */
  525.     public void unlockDrag() {
  526.         dragLock = false;
  527.     }
  528.  
  529.     /**
  530.      * 拖动锁定方法，调用者调用该方法后关闭列表拖动功能
  531.      */
  532.     public void lockDrag() {
  533.         dragLock = true;
  534.     }
  535.  
  536.     /**
  537.      * 设置移动动画持续时间
  538.      *
  539.      * @param duration 时间，单位毫秒
  540.      */
  541.     public void setDuration(long duration) {
  542.         this.duration = duration;
  543.     }
  544.  
  545.     /**
  546.      * 设置速度模式，可选项：
  547.      * MODE_LINEAR                线性变化模式
  548.      * MODE_ACCELERATE            加速模式
  549.      * MODE_DECELERATE            减速模式
  550.      * MODE_ACCELERATE_DECELERATE 先加速后加速模式
  551.      *
  552.      * @param speedMode
  553.      */
  554.     public void setSpeedMode(int speedMode) {
  555.         this.speedMode = speedMode;
  556.     }
  557.  
  558.     /**
  559.      * 设置自动滚动速度
  560.      *
  561.      * @param scrollSpeed 速度，单位：dp/10ms
  562.      */
  563.     public void setScrollSpeed(int scrollSpeed) {
  564.         this.scrollSpeed = scrollSpeed;
  565.     }
  566.  
  567.     /**
  568.      * 设置拖动块视图对象生成器方法
  569.      *
  570.      * @param creator
  571.      */
  572.     public void setDragViewCreator(DragViewCreator creator) {
  573.         if (creator == null) {
  574.             return;
  575.         }
  576.  
  577.         this.dragViewCreator = creator;
  578.     }
  579.  
  580.     /**
  581.      * 设置拖动监听接口
  582.      *
  583.      * @param dragingListener
  584.      */
  585.     public void setOnDragingListener(OnDragingListener dragingListener) {
  586.         this.dragingListener = dragingListener;
  587.     }
  588.  
  589.     /**
  590.      * 设置拖动目标位置改变监听接口
  591.      *
  592.      * @param targetChangedListener
  593.      */
  594.     public void setOnDragTargetChangedListener(OnDragTargetChangedListener targetChangedListener) {
  595.         this.targetChangedListener = targetChangedListener;
  596.     }
  597.  
  598.     private int getStatusHeight() {
  599.         int resourceId = context.getResources().getIdentifier("status_bar_height", "dimen", "android");
  600.         if (resourceId > 0) {
  601.             return context.getResources().getDimensionPixelSize(resourceId);
  602.         }
  603.  
  604.         return 0;
  605.     }
  606.  
  607.     /**
  608.      * 动画观察者
  609.      */
  610.     private interface AnimatorObserver {
  611.  
  612.         /**
  613.          * 滑动动画播放结束时回调
  614.          */
  615.         void onAllAnimatorFinish();
  616.  
  617.     }
  618.  
  619.     /**
  620.      * 拖动块视图对象生成器
  621.      */
  622.     public interface DragViewCreator {
  623.  
  624.         /**
  625.          * 创建拖动块视图对象方法，可通过实现该方法自定义拖动块样式
  626.          */
  627.         View createDragView(int width, int height, Bitmap viewCache);
  628.  
  629.     }
  630.  
  631.     /**
  632.      * 拖动监听接口
  633.      */
  634.     public interface OnDragingListener {
  635.  
  636.         /**
  637.          * 拖动开始时回调
  638.          *
  639.          * @param startPosition 拖动起始坐标
  640.          */
  641.         void onStart(int startPosition);
  642.  
  643.         /**
  644.          * 拖动过程中回调
  645.          *
  646.          * @param x    触控点相对ListView的x坐标
  647.          * @param y    触控点相对ListView的y坐标
  648.          * @param rawX 触控点相对屏幕的x坐标
  649.          * @param rawY 触控点相对屏幕的y坐标
  650.          */
  651.         void onDraging(int x, int y, int rawX, int rawY);
  652.  
  653.         /**
  654.          * 拖动结束时回调
  655.          *
  656.          * @param finalPosition 拖动终点坐标
  657.          */
  658.         void onFinish(int finalPosition);
  659.  
  660.     }
  661.  
  662.     /**
  663.      * 拖动目标位置改变监听接口
  664.      */
  665.     public interface OnDragTargetChangedListener {
  666.  
  667.         /**
  668.          * 拖动过程中，每次目标位置改变，会在该方法回调
  669.          *
  670.          * @param targetPosition 拖动目标位置坐标
  671.          */
  672.         void onTargetChanged(int targetPosition);
  673.  
  674.     }
  675. }

实现原理和DragListView差不多，就不多做解释了。DragGridView的setAdapter方法同样只接收BaseDragAdapter的继承类，用法和DragListView一样。

简单使用一下，先写一个item布局item_test_gridview.xml:

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3.     android:id="@+id/item_layout"
  4.     android:layout_width="match_parent"
  5.     android:minHeight="130dp"
  6.     android:layout_height="match_parent"
  7.     android:background="#FFFAFA"
  8.     android:gravity="center_horizontal"
  9.     android:orientation="vertical">
  10.  
  11.     <TextView
  12.         android:id="@+id/content_textview"
  13.         android:layout_width="match_parent"
  14.         android:layout_height="0dp"
  15.         android:layout_weight="1"
  16.         android:gravity="center"
  17.         android:padding="15dp"
  18.         android:text="我是内容"
  19.         android:textSize="20sp" />
  20.  
  21. </LinearLayout>

再写一个适配器TestGridViewAdapter：

  1. public class TestGridViewAdapter extends BaseDragAdapter {
  2.  
  3.     private Context context;
  4.     private int resourceId;
  5.     private ArrayList<String> list;
  6.  
  7.     private Vibrator vibrator;
  8.  
  9.     private OnItemLongClickListener listener;
  10.  
  11.     public TestGridViewAdapter(Context context, int resourceId, ArrayList<String> list) {
  12.         this.context = context;
  13.         this.resourceId = resourceId;
  14.         this.list = list;
  15.         this.vibrator = (Vibrator) context.getSystemService(context.VIBRATOR_SERVICE);
  16.     }
  17.  
  18.     @Override
  19.     public List getDataList() {
  20.         return list;
  21.     }
  22.  
  23.     @Override
  24.     public boolean isDragAvailable(int position) {
  25.         return true;
  26.     }
  27.  
  28.     @Override
  29.     public int getCount() {
  30.         return list.size();
  31.     }
  32.  
  33.     @Override
  34.     public Object getItem(int position) {
  35.         return list.get(position);
  36.     }
  37.  
  38.     @Override
  39.     public long getItemId(int position) {
  40.         return position;
  41.     }
  42.  
  43.     @Override
  44.     public View getView(final int position, View convertView, ViewGroup parent) {
  45.         View view;
  46.         ViewHolder viewHolder;
  47.         if (convertView == null) {
  48.             view = LayoutInflater.from(context).inflate(resourceId, null);
  49.             viewHolder = new ViewHolder();
  50.             viewHolder.itemLayout = view.findViewById(R.id.item_layout);
  51.             viewHolder.contentTextView = view.findViewById(R.id.content_textview);
  52.             view.setTag(viewHolder);
  53.         } else {
  54.             view = convertView;
  55.             viewHolder = (ViewHolder) view.getTag();
  56.         }
  57.  
  58.         viewHolder.contentTextView.setText(list.get(position));
  59.  
  60.         viewHolder.itemLayout.setOnLongClickListener(new View.OnLongClickListener() {
  61.             @Override
  62.             public boolean onLongClick(View v) {
  63.                 vibrator.vibrate(100);
  64.  
  65.                 if (listener != null) {
  66.                     listener.onItemLongClick(position);
  67.                 }
  68.  
  69.                 return false;
  70.             }
  71.         });
  72.  
  73.         return view;
  74.     }
  75.  
  76.     public void setOnItemLongClickListener(OnItemLongClickListener listener) {
  77.         this.listener = listener;
  78.     }
  79.  
  80.     public interface OnItemLongClickListener {
  81.  
  82.         void onItemLongClick(int position);
  83.  
  84.     }
  85.  
  86.     class ViewHolder {
  87.         LinearLayout itemLayout;
  88.         TextView contentTextView;
  89.     }
  90. }

最后Activity这样写：

  1.     private DragGridView dragGridView;
  2.  
  3.     private TestGridViewAdapter adapter;
  4.  
  5.     private ArrayList<String> list;
  6.  
  7.     @Override
  8.     protected void onCreate(@Nullable Bundle savedInstanceState) {
  9.         super.onCreate(savedInstanceState);
  10.         setContentView(R.layout.activity_drag_gridview_test);
  11.  
  12.         initData();
  13.         initView();
  14.     }
  15.  
  16.     private void initData() {
  17.         list = new ArrayList<>();
  18.  
  19.         for (int i = 1; i <= 40; i++) {
  20.             list.add("我是第" + i + "条数据");
  21.         }
  22.     }
  23.  
  24.     private void initView() {
  25.         dragGridView = findViewById(R.id.drag_gridview);
  26.         
  27.         dragGridView.setOnDragingListener(new DragGridView.OnDragingListener() {
  28.             @Override
  29.             public void onStart(int startPosition) {
  30.  
  31.             }
  32.  
  33.             @Override
  34.             public void onDraging(int x, int y, int rawX, int rawY) {
  35.  
  36.             }
  37.  
  38.             @Override
  39.             public void onFinish(int finalPosition) {
  40.                 dragGridView.lockDrag();
  41.             }
  42.         });
  43.  
  44.         adapter = new TestGridViewAdapter(this, R.layout.item_test_gridview, list);
  45.  
  46.         adapter.setOnItemLongClickListener(new TestGridViewAdapter.OnItemLongClickListener() {
  47.             @Override
  48.             public void onItemLongClick(int position) {
  49.                 dragGridView.unlockDrag();
  50.             }
  51.         });
  52.  
  53.         dragGridView.setAdapter(adapter);
  54.     }

用法和DragListView一毛一样。运行一下就能看到开头的效果了。

DragGridView同样可以自定义拖拽View的样式，同样通过setDragViewCreator()方法来实现。比如说添加一个高亮效果：

  1. dragGridView.setDragViewCreator(new DragGridView.DragViewCreator() {
  2.     @Override
  3.     public View createDragView(int width, int height, Bitmap viewCache) {
  4.         RelativeLayout layout = new RelativeLayout(DragGridViewTestActivity.this);
  5.  
  6.         ImageView imageView = new ImageView(DragGridViewTestActivity.this);
  7.         imageView.setImageBitmap(viewCache);
  8.         layout.addView(imageView, new RelativeLayout.LayoutParams(width, height));
  9.  
  10.         View view = new View(DragGridViewTestActivity.this);
  11.         view.setBackground(getDrawable(R.drawable.edging_red));
  12.         layout.addView(view, new RelativeLayout.LayoutParams(width, height));
  13.  
  14.         return layout;
  15.     }
  16. });

看看效果：

 

以上就是全部内容了，最后来总结一下。


DragListView和DragGridView分别实现ListView和GridView的item拖拽功能。接收Adapter必须是BaseDragAdapter的继承类，通过unlockDrag()方法和lockDrag()方法来开启和关闭拖动。提供OnDragingListener接口来监听拖动过程，提供DragViewCreator接口来自定义拖拽样式。

 

最后的最后，附上源码地址：https://download.csdn.net/download/Sure_Min/12572918

这次的内容就到这里，我们下次再见。
 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/228198
推荐阅读

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。