实现拖拽效果一 自定义带拖拽功能的GridView

实现拖拽效果一 自定义带拖拽功能的GridView

因为demo适配了公司的业务，具体图层不好放出来，难受。但是这毕竟只是记录学习，自己知道实现了就好！

首先、既然是GridView实现拖拽效果，这肯定涉及事件分发，需要了解一下事件分发，这个可以去了解一下。我自己关于事件分发的学习也会发出来。

首先要实现拖拽功能的GridView，要关注几点

1. 事件分发和消费，手指点击下去，down代表一个新的事件开始了，up和cancel表示事件结束了，千万不要忽略了cancel事件。
2. 长按反馈，因为你长按开启拖动，所以好歹要让用户知道长按结束了，可以拖动了吧，可以通过震动和镜像变大实现。
3. 创建镜像，这个是为了第二个服务的，但是这个是很重要的，要认真开，涉及windows的窗口。同时包括移除和创建和缓存。
4. 屏幕适配。适当的行列数和间隔都是要考虑的。
5. 滚动，因为如果开启了拖拽事件，gridView的滚动事件就报销了，需要我们自己来定义实现新的滚动事件了。
6. 长按和滚动的线程开启。
7. 持久化

废话不多说了，直接上源码和资源文件了，相关部分解释源码都有注解，还可以自己点击查看android源码更方便。

自定义的GridView

public class DragGridView extends GridView {
    public static final String TAG = DragGridView.class.getSimpleName();
    /**
     * DragGridView的item长按响应的时间， 默认是1000毫秒，也可以自行设置
     */
    private long dragResponseMS = 1000;

    /**
     * 是否可以拖拽，默认不可以
     */
    private boolean isDrag = true;

    private int mDownX;
    private int mDownY;
    private int moveX;
    private int moveY;
    /**
     * 正在拖拽的position
     */
    private int mDragPosition;

    /**
     * 刚开始拖拽的item对应的View
     */
    private View mStartDragItemView = null;

    /**
     * 用于拖拽的镜像，这里直接用一个ImageView
     */
    private ImageView mDragImageView;

    /**
     * 用于拖拽的镜像，这里直接放入拖动的 Image
     */
    private FrameLayout mDragLayout;

    /**
     * 震动器
     */
    private Vibrator mVibrator;

    /**
     *  Windows窗口获取一个View，用于镜像
     */
    private WindowManager mWindowManager;
    /**
     * item镜像的布局参数
     */
    private WindowManager.LayoutParams mWindowLayoutParams;

    /**
     * 我们拖拽的item对应的Bitmap
     */
    private Bitmap mDragBitmap;

    /**
     * 按下的点到所在item的上边缘的距离
     */
    private int mPoint2ItemTop;

    /**
     * 按下的点到所在item的左边缘的距离
     */
    private int mPoint2ItemLeft;

    /**
     * DragGridView距离屏幕顶部的偏移量
     */
    private int mOffset2Top;

    /**
     * DragGridView距离屏幕左边的偏移量
     */
    private int mOffset2Left;

    /**
     * 状态栏的高度
     */
    private int mStatusHeight;

    /**
     * DragGridView自动向下滚动的边界值
     */
    private int mDownScrollBorder;

    /**
     * DragGridView自动向上滚动的边界值
     */
    private int mUpScrollBorder;

    /**
     * DragGridView自动滚动的速度
     */
    private static final int speed = 20;

    /**
     * 交换动画
     */
    private boolean mAnimationEnd = true;
    /**
     * 适配器
     */
    private DragGridBaseAdapter mDragAdapter;
    /**
     * 行数列数
     */
    private int mNumColumns;
    private int mColumnWidth;
    /**
     * 是否设置
     */
    private boolean mNumColumnsSet;
    /**
     * 间隔
     */
    private int mHorizontalSpacing;
    /**
     * View的高度
     */
    private int mViewHeight;
    /**
     * 拖动时景象放大倍数
     */
    private float mDragScale = 1.2f;
    /**
     * 大小变化时间单位毫秒
     */
    private int mScaleMill = 200;
    /**
     * 最后一个 position是否能够移动
     */
    private boolean mDragLastPosition = false;
    /**
     * position 位置的可以开始拖动
     */
    private int mDragStartPosition = 7;
    /**
     * 是否正在执行缩放动画
     */
    private boolean mIsScaleAnima = false;
    /**
     * 是否震动
     */
    private boolean mIsVibrator = false;

    public DragGridView(Context context) {
        this(context, null);
    }

    public DragGridView(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public DragGridView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        initView();
        /**
         * 自定义属性
         */
        TypedArray typedArray = context.obtainStyledAttributes(attrs, R.styleable.DragGridView);
        mDragScale = typedArray.getFloat(R.styleable.DragGridView_drag_scale, 1.2f);
        mScaleMill = typedArray.getInteger(R.styleable.DragGridView_scale_mill, 200);
        mDragStartPosition = typedArray.getInteger(R.styleable.DragGridView_drag_start_position, 7);
        mDragLastPosition = typedArray.getBoolean(R.styleable.DragGridView_drag_last_position, false);
        mIsVibrator = typedArray.getBoolean(R.styleable.DragGridView_vibrator, false);
        //回收自定义属性，因为自定义属性是通过池+单例实现的所有要释放回收
        typedArray.recycle();
        /**
         * 自定义控件，这里防止可视化编译器无法识别。编辑模式下返回true
         */
        if (!isInEditMode()) {
            mVibrator = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
            mWindowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
            mStatusHeight = getStatusHeight(context); // 获取状态栏的高度

        }
        if (!mNumColumnsSet) {
            mNumColumns = AUTO_FIT; //尽可能填满可用空间
        }

    }

    /**
     * 设置间隔
     */
    private void initView(){
        int mSpacing = 10;
        FrameLayout.LayoutParams params = new FrameLayout.LayoutParams(
                ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
        if (Build.MODEL.equals("N3")){
            mSpacing = 7;
        }
        setHorizontalSpacing(mSpacing);
        setVerticalSpacing(mSpacing);
        setLayoutParams(params);
        //初始化适配器
    }


    private Handler mHandler = new Handler();

    // 用来处理是否为长按的Runnable
    private Runnable mLongClickRunnable = new Runnable() {

        @Override
        public void run() {
            isDrag = true; // 设置可以拖拽
            if (mIsVibrator) mVibrator.vibrate(50); // 震动一下
            mStartDragItemView.setVisibility(View.INVISIBLE);// 隐藏该item
            // 根据我们按下的点显示item镜像
            createDragImage(mDragBitmap, mDownX, mDownY);
        }
    };

    /**
     * 加载适配器
     * @param adapter
     */
    @Override
    public void setAdapter(ListAdapter adapter) {
        super.setAdapter(adapter);
        if (!isInEditMode()) {
            if (adapter instanceof DragGridBaseAdapter) {
                mDragAdapter = (DragGridBaseAdapter) adapter;
            } else {
                throw new IllegalStateException(
                        "the adapter must be implements DragGridAdapter");
            }
        }
    }

    /**
     * 设置第几位可以开始拖动
     * @param dragStartPosition
     */
    public void setDragStartPosition(int dragStartPosition) {
        mDragStartPosition = dragStartPosition;
    }

    @Override
    public void setNumColumns(int numColumns) {
        super.setNumColumns(numColumns);
        mNumColumnsSet = true;
        this.mNumColumns = numColumns;
    }

    @Override
    public void setColumnWidth(int columnWidth) {
        super.setColumnWidth(columnWidth);
        mColumnWidth = columnWidth;
    }

    @Override
    public void setHorizontalSpacing(int horizontalSpacing) {
        super.setHorizontalSpacing(horizontalSpacing);
        this.mHorizontalSpacing = horizontalSpacing;
    }

    /**
     * 若设置为AUTO_FIT，计算有多少列
     */
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        if (mNumColumns == AUTO_FIT) {
            int numFittedColumns;
            if (mColumnWidth > 0) {
                int gridWidth = Math.max(MeasureSpec.getSize(widthMeasureSpec)
                        - getPaddingLeft() - getPaddingRight(), 0);
                numFittedColumns = gridWidth / mColumnWidth;
                if (numFittedColumns > 0) {
                    while (numFittedColumns != 1) {
                        if (numFittedColumns * mColumnWidth
                                + (numFittedColumns - 1) * mHorizontalSpacing > gridWidth) {
                            numFittedColumns--;
                        } else {
                            break;
                        }
                    }
                } else {
                    numFittedColumns = 1;
                }
            } else {
                numFittedColumns = 2;
            }
            mNumColumns = numFittedColumns;
        }

        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    }

    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        super.onLayout(changed, l, t, r, b);
        mViewHeight =  t ;
    }

    /**
     * 设置响应拖拽的毫秒数，默认是1000毫秒
     *
     * @param dragResponseMS
     */
    public void setDragResponseMS(long dragResponseMS) {
        this.dragResponseMS = dragResponseMS;
    }

    /**
     * 事件分发开始，这里是控制事件分发
     * @param ev
     * @return
     */
    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN:
                mDownX = (int) ev.getX();
                mDownY = (int) ev.getY();
                // 根据按下的X,Y坐标获取所点击item的position
                mDragPosition = pointToPosition(mDownX, mDownY);
                //如果是前mDragStartPosition不执行长按
                if (mDragPosition < mDragStartPosition) {
                    return super.dispatchTouchEvent(ev);
                }
                //如果是最后一位不交换
//                if (null != getAdapter() && mDragPosition == (getAdapter().getCount() - 1) && !mDragLastPosition) {
//                    return super.dispatchTouchEvent(ev);
//                }

                if (mDragPosition == AdapterView.INVALID_POSITION) {
                    return super.dispatchTouchEvent(ev);
                }

                // 使用Handler延迟dragResponseMS执行mLongClickRunnable
                mHandler.postDelayed(mLongClickRunnable, dragResponseMS);

                // 根据position获取该item所对应的View
                mStartDragItemView = getChildAt(mDragPosition - getFirstVisiblePosition());

                // 属性定义有解释 可以看一下Android的View坐标系了解一下
                mPoint2ItemTop = mDownY - mStartDragItemView.getTop();
                mPoint2ItemLeft = mDownX - mStartDragItemView.getLeft();

                mOffset2Top = (int) (ev.getRawY() - mDownY);
                mOffset2Left = (int) (ev.getRawX() - mDownX);

                //启动拖拽事件，滚动事件会失效
                // 获取DragGridView自动向上滚动的偏移量，小于这个值，DragGridView向下滚动
                mDownScrollBorder = getHeight() / 5;
                // 获取DragGridView自动向下滚动的偏移量，大于这个值，DragGridView向上滚动
                mUpScrollBorder = getHeight() * 4 / 5;

                // 开启mDragItemView绘图缓存
                mStartDragItemView.setDrawingCacheEnabled(true);
                // 获取mDragItemView在缓存中的Bitmap对象
                Bitmap drawingCache = mStartDragItemView.getDrawingCache();
                // mDragBitmap = Bitmap.createBitmap(drawingCache);
                mDragBitmap = Bitmap.createScaledBitmap(drawingCache, (int) (drawingCache.getWidth() * mDragScale), (int) (drawingCache.getHeight() * mDragScale), true);

                // 这一步很关键，释放绘图缓存，避免出现重复的镜像
                mStartDragItemView.destroyDrawingCache();

                break;
            case MotionEvent.ACTION_MOVE:
                int moveX = (int) ev.getX();
                int moveY = (int) ev.getY();
                // 如果我们在按下的item上面移动，只要不超过item的边界我们就不移除mRunnable
                if (!isTouchInItem(mStartDragItemView, moveX, moveY) ||  Math.abs(moveY - mDownY) > 100) {
                    mHandler.removeCallbacks(mLongClickRunnable);
                }
                break;
            case MotionEvent.ACTION_UP:     //这里注意UP和Cancel都要处理的，防止长按起来图标，然后没拖拽，就抬起手指，放弃了
            case MotionEvent.ACTION_CANCEL:
                mHandler.removeCallbacks(mLongClickRunnable);
                mHandler.removeCallbacks(mScrollRunnable);
                break;
        }
        return super.dispatchTouchEvent(ev);
    }

    /**
     * 是否点击在GridView的item上面
     *
     * @param x
     * @param y
     * @return
     */
    private boolean isTouchInItem(View dragView, int x, int y) {
        if (dragView == null) {
            return false;
        }
        int leftOffset = dragView.getLeft();
        int topOffset = dragView.getTop();
        if (x < leftOffset || x > leftOffset + dragView.getWidth()) {
            return false;
        }

        if (y < topOffset || y > topOffset + dragView.getHeight()) {
            return false;
        }

        return true;
    }

    /**
     * 事件消费
     * @param ev
     * @return
     */
    @Override
    public boolean onTouchEvent(MotionEvent ev) {
        if (isDrag &