可拖拽 GridView

package com.example.myapp;

import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.AnimatorSet;
import android.animation.ObjectAnimator;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.PixelFormat;
import android.os.Handler;
import android.os.Vibrator;
import android.util.AttributeSet;
import android.util.Log;
import android.view.*;
import android.view.animation.AccelerateDecelerateInterpolator;
import android.widget.GridView;
import android.widget.ImageView;

import java.util.LinkedList;
import java.util.List;

/**
* Created by yp-tc-m-2781 on 16/5/3.
*/
public class MyGridView extends GridView {

private final String tag = "#myapp.MyGridView";

private View mStartDragItemView = null;
private ImageView mDragImageView;
private Bitmap mDragBitmap;
private WindowManager mWindowManager;
private WindowManager.LayoutParams mWindowLayoutParams;
private Handler mHandler;
private long dragResponseMS = 800;
private boolean isDrag;
private boolean normalMove;
private int mDownX;
private int mDownY;
private int itemHeight;
private int mDragPosition;
private Vibrator mVibrator;
private int mPoint2ItemLeft;
private int mPoint2ItemTop;
private boolean mAnimationEnd = true;
private int paddingTop;
private int paddingBottom;
int mNumColumns;

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

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

public MyGridView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
mVibrator = (Vibrator) getContext().getSystemService(Context.VIBRATOR_SERVICE);
mWindowManager = (WindowManager)getContext().getSystemService(Context.WINDOW_SERVICE);
mHandler = new Handler();
paddingTop = getPaddingTop();
paddingBottom = getPaddingBottom();
}

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

private Runnable mLongClickRunnable = new Runnable() {

@Override
public void run() {
isDrag = true;
mVibrator.vibrate(50);
mStartDragItemView.setVisibility(View.INVISIBLE);
itemHeight = mStartDragItemView.getHeight();
createDragImage(mDragBitmap, mDownX, mDownY);
}
};

@Override
public boolean dispatchTouchEvent(MotionEvent ev) {

switch (ev.getAction()) {
case MotionEvent.ACTION_DOWN:
normalMove = false;
mDownX = (int)ev.getX();
mDownY = (int)ev.getY();
mDragPosition = pointToPosition(mDownX,mDownY);
if(mDragPosition == INVALID_POSITION)
{
return super.dispatchTouchEvent(ev);
}
mHandler.postDelayed(mLongClickRunnable,dragResponseMS);
mStartDragItemView = getChildAt(mDragPosition - getFirstVisiblePosition());
mStartDragItemView.setDrawingCacheEnabled(true);
mDragBitmap = Bitmap.createBitmap(mStartDragItemView.getDrawingCache());
mStartDragItemView.destroyDrawingCache();
mPoint2ItemTop = mDownY - mStartDragItemView.getTop();
mPoint2ItemLeft = mDownX - mStartDragItemView.getLeft();
break;
case MotionEvent.ACTION_MOVE:
int moveX = (int)ev.getX();
int moveY = (int) ev.getY();
if(!isTouchInItem( moveX, moveY)){
normalMove = true;
mHandler.removeCallbacks(mLongClickRunnable);
}
break;
case MotionEvent.ACTION_UP:
mHandler.removeCallbacks(mLongClickRunnable);
break;
}
return super.dispatchTouchEvent(ev);
}

@Override
public boolean onTouchEvent(MotionEvent ev) {
Log.i(tag,"onTouchEvent");
if(isDrag && mDragImageView != null){
switch(ev.getAction()){
case MotionEvent.ACTION_MOVE:
onDragItem((int)ev.getX(),(int)ev.getY());
break;
case MotionEvent.ACTION_UP:
onStopDrag();
break;
}
return true;
}
return super.onTouchEvent(ev);
}

private void onStopDrag(){
View view = getChildAt(mDragPosition - getFirstVisiblePosition());
if(view != null){
view.setVisibility(View.VISIBLE);
}
removeDragImage();
isDrag = false;
if(onChangeListener != null)
{
onChangeListener.onStop();
}
}

private void createDragImage(Bitmap bitmap, int downX , int downY)
{
mWindowLayoutParams = new WindowManager.LayoutParams();
mWindowLayoutParams.format = PixelFormat.TRANSLUCENT;
mWindowLayoutParams.gravity = Gravity.TOP | Gravity.LEFT;
mWindowLayoutParams.x = downX - mPoint2ItemLeft + getLeft();
mWindowLayoutParams.y = downY - mPoint2ItemTop + getTop();
mWindowLayoutParams.alpha = 0.55f;
mWindowLayoutParams.width = WindowManager.LayoutParams.WRAP_CONTENT;
mWindowLayoutParams.height = WindowManager.LayoutParams.WRAP_CONTENT;
mWindowLayoutParams.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
| WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE ;
mDragImageView = new ImageView(getContext());
mDragImageView.setImageBitmap(bitmap);
mWindowManager.addView(mDragImageView, mWindowLayoutParams);
}

private boolean isTouchInItem(int x, int y){
if(isDrag || normalMove)
{
return true;
}
int disX = Math.abs(x - mDownX);
int disY = Math.abs(y - mDownY);
if(disX > 1 || disY > 1)
{
return false;
}
return true;
}

private void removeDragImage(){
if(mDragImageView != null){
mWindowManager.removeView(mDragImageView);
mDragImageView = null;
}
}

private void onDragItem(int moveX, int moveY){
mWindowLayoutParams.x = (moveX - mPoint2ItemLeft + getLeft());
mWindowLayoutParams.y = (moveY - mPoint2ItemTop + getTop());
int trans = itemHeight/4;
if((getBottom()-mWindowLayoutParams.y - paddingBottom) <= (itemHeight+trans))
{
smoothScrollBy(itemHeight,1500);
}
else if((mWindowLayoutParams.y - trans) <= (getTop() + paddingTop))
{
smoothScrollBy(-itemHeight,1500);
}
else
{
smoothScrollBy(0,0);
}
mWindowManager.updateViewLayout(mDragImageView, mWindowLayoutParams);
final int newPosition = pointToPosition(moveX,moveY);
if(newPosition != mDragPosition && newPosition != INVALID_POSITION && mAnimationEnd)
{
if(onChangeListener != null) {
onChangeListener.onChange(mDragPosition, newPosition);
}
final ViewTreeObserver observer = getViewTreeObserver();
observer.addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() {
@Override
public boolean onPreDraw() {
observer.removeOnPreDrawListener(this);
animateReorder(mDragPosition, newPosition);
mDragPosition = newPosition;
return true;
}
} );
}
}

private void animateReorder(final int oldPosition, final int newPosition) {
boolean isForward = newPosition > oldPosition;
List<Animator> resultList = new LinkedList<Animator>();
if (isForward) {
for (int pos = oldPosition; pos < newPosition; pos++) {
View view = getChildAt(pos - getFirstVisiblePosition());
if ((pos + 1) % mNumColumns == 0) {
resultList.add(createTranslationAnimations(view,
- (view.getWidth() ) * (mNumColumns - 1), 0,
view.getHeight() , 0));
} else {
resultList.add(createTranslationAnimations(view,
view.getWidth() , 0, 0, 0));
}
}
} else {
for (int pos = oldPosition; pos > newPosition; pos--) {
View view = getChildAt(pos - getFirstVisiblePosition());
if ((pos) % mNumColumns == 0) {
resultList.add(createTranslationAnimations(view,
(view.getWidth() ) * (mNumColumns - 1), 0,
-view.getHeight() , 0));
} else {
resultList.add(createTranslationAnimations(view,
-view.getWidth() , 0, 0, 0));
}
}
}

AnimatorSet resultSet = new AnimatorSet();
resultSet.playTogether(resultList);
resultSet.setDuration(300);
resultSet.setInterpolator(new AccelerateDecelerateInterpolator());
resultSet.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationStart(Animator animation) {
mAnimationEnd = false;
}

@Override
public void onAnimationEnd(Animator animation) {
mAnimationEnd = true;
}
});
resultSet.start();
}

private AnimatorSet createTranslationAnimations(View view, float startX,
float endX, float startY, float endY) {
ObjectAnimator animX = ObjectAnimator.ofFloat(view, "translationX",
startX, endX);
ObjectAnimator animY = ObjectAnimator.ofFloat(view, "translationY",
startY, endY);
AnimatorSet animSetXY = new AnimatorSet();
animSetXY.playTogether(animX, animY);
return animSetXY;
}

private OnChangeListener onChangeListener;

public void setOnChangeListener(OnChangeListener onChangeListener) {
this.onChangeListener = onChangeListener;
}

interface OnChangeListener
{
void onChange(int drayPosition,int swapPosition);
void onStop();
}

//    @Override
//    public void onChange(int drayPosition, int swapPosition) {
//        mHidePosition = swapPosition;
//        Integer integer = list.get(drayPosition);
//        list.remove(drayPosition);
//        list.add(swapPosition,integer);
//        notifyDataSetChanged();
//    }
//
//    @Override
//    public void onStop() {
//        mHidePosition = -1;
//    }
}