Android拖拽的ExpandableListView

正如我们知道的listview在Android中是一个常用的控件，很多app都喜欢在Listview上面做文章，拖动排序就是一中常见的，github上面有一个很好的demo。ExpandableListView顾名思义就是Listview的一个扩展，用来分组Listview，比如QQ好友列表，既然Listview可以拖拽排序，ExpandableListView当然也是可以排序的，看到了一些demo觉得github这个还是不错的DragNDropListView。代码比较简洁清晰，但它和常见的可以拖拽ExpandableListView一样支持跨组拖动，跨组拖动在有些时候是不必要的，因此我也是在它的代码上面改了下控制不可以跨组拖动

     首先我们需要知道ExpandableListView的两个方法getPackedPositionGroup 返回当前条目所在的组的位置

getPackedPositionChild返回当前条目在改组中的位置

 /**
     * Gets the group position from a packed position. See
     * {@link #getPackedPositionForChild(int, int)}.
     * 
     * @param packedPosition The packed position from which the group position
     *            will be returned.
     * @return The group position portion of the packed position. If this does
     *         not contain a group, returns -1.
     */
    public static int getPackedPositionGroup(long packedPosition) {
        // Null
        if (packedPosition == PACKED_POSITION_VALUE_NULL) return -1;
        
        return (int) ((packedPosition & PACKED_POSITION_MASK_GROUP) >> PACKED_POSITION_SHIFT_GROUP);
    }

/**
     * Gets the child position from a packed position that is of
     * {@link #PACKED_POSITION_TYPE_CHILD} type (use {@link #getPackedPositionType(long)}).
     * To get the group that this child belongs to, use
     * {@link #getPackedPositionGroup(long)}. See
     * {@link #getPackedPositionForChild(int, int)}.
     * 
     * @param packedPosition The packed position from which the child position
     *            will be returned.
     * @return The child position portion of the packed position. If this does
     *         not contain a child, returns -1.
     */
    public static int getPackedPositionChild(long packedPosition) {
        // Null
        if (packedPosition == PACKED_POSITION_VALUE_NULL) return -1;
        
        // Group since a group type clears this bit
        if ((packedPosition & PACKED_POSITION_MASK_TYPE) != PACKED_POSITION_MASK_TYPE) return -1;

        return (int) (packedPosition & PACKED_POSITION_MASK_CHILD);
    }

知道这两个方法就很好办了，说白了当遇到两个交换的条目不再同一组中就不支持拖动，也就是拖动无效。直接列修改的 ExpandableListView的代码了，注释在代码中

/*
 * Copyright (C) 2012 Sreekumar SH
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.dragdrop.listview;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.PixelFormat;
import android.os.Handler;
import android.util.AttributeSet;
import android.util.Log;
import android.view.Display;
import android.view.Gravity;
import android.view.MotionEvent;
import android.view.View;
import android.view.WindowManager;
import android.widget.ExpandableListAdapter;
import android.widget.ExpandableListView;
import android.widget.ImageView;

import com.android.dragdrop.R;

/**
 * Custom ExpandableListView which enables drag and drop
 * 
 * @author <a href="http://sreekumar.sh" >Sreekumar SH </a>
 *         (sreekumar.sh@gmail.com)
 * 
 */
public class DragNDropListView extends ExpandableListView {
	public interface DragNDropListeners {

		public void onDrag(float x, float y);

		/**
		 * Event fired when an item is picked. position[0] - group position
		 * position[1] - child position
		 * 
		 * @param position
		 */
		public void onPick(int[] position);

		/**
		 * Event fired when an item is dropped. from - position from where item
		 * is picked. to - position at which item is dropped. from[0] - group
		 * position from[1] - child position
		 * 
		 * @param position
		 */
		public void onDrop(int[] from, int[] to);
	}

	private static final String TAG = "DragNDropListView";
	private boolean mDragMode;
	private boolean limitHorizontalDrag = true;
	private int[] mStartPosition = new int[2];
	private int[] mEndPosition = new int[2];
	private int mDragPointOffset; // Used to adjust drag view location
	private int mStartFlatPosition;
	private int prevY = -1;
	private int backgroundColor = 0xe0103010; // different color to identify
	private int defaultBackgroundColor;
	private float screenHeight;
	private float dragRatio;//计算拖动速度
	private ImageView mDragView;
	private DragNDropAdapter adapter;
	private DragNDropListeners listeners;
	private int dragOffset = 50;
	private boolean dragOnLongPress;
	private boolean pressedItem;
	private Handler handler = new Handler();

	public DragNDropListView(Context context, AttributeSet attrs) {
		super(context, attrs);
		WindowManager wm = (WindowManager) context
				.getSystemService(Context.WINDOW_SERVICE);
		Display display = wm.getDefaultDisplay();
		screenHeight = display.getHeight();
	}

	public void setSelectedBackgroud(int color) {
		backgroundColor = color;
	}

	@Override
	public boolean onTouchEvent(MotionEvent event) {
		return touchHandler(event);
	}

	private boolean touchHandler(final MotionEvent event) {
		final int action = event.getAction();
		final int x = (int) event.getX();
		final int y = (int) event.getY();
		if (prevY < 0) {
			prevY = y;
		}
		Log.d(TAG, "Motion event " + event.getAction());
		int flatPosition = pointToPosition(x, y);
		dragRatio = getHeight() / screenHeight;
		long packagedPosition = getExpandableListPosition(flatPosition);

		if (action == MotionEvent.ACTION_DOWN
				&& getPackedPositionType(packagedPosition) == 1) {
			if (dragOnLongPress) {
				if (pressedItem) {
					mDragMode = true;
					pressedItem = false;
				} else {
					pressedItem = true;
					Runnable r = new Runnable() {
						@Override
						public void run() {
							// y coordinate is changing for no reason ??
							event.setLocation(x, y);
							touchHandler(event);
						}
					};
					handler.postDelayed(r, 200);
					return true;
				}
			} else if (x < dragOffset) {
				mDragMode = true;
			}
		}

		if (!mDragMode) {
			/** when user action on other areas */
			if ((pressedItem && Math.abs(prevY - y) > 30)
					|| event.getAction() != MotionEvent.ACTION_MOVE) {
				pressedItem = false;
				handler.removeCallbacksAndMessages(null);
			}
			return super.onTouchEvent(event);
		}
		switch (action) {
		case MotionEvent.ACTION_DOWN:
			mStartFlatPosition = flatPosition;
			mStartPosition[0] = getPackedPositionGroup(packagedPosition);
			System.out.println("packagedPosition第" + packagedPosition + "组");
			mStartPosition[1] = getPackedPositionChild(packagedPosition);
			if (packagedPosition != PACKED_POSITION_VALUE_NULL) {

				int mItemPosition = flatPosition - getFirstVisiblePosition();
				mDragPointOffset = y - getChildAt(mItemPosition).getTop();
				mDragPointOffset -= ((int) event.getRawY()) - y;
				startDrag(mItemPosition, y);
				if (listeners != null) {
					listeners.onPick(mStartPosition);
					System.out.println("group" + mStartPosition[0]);
					System.out.println("child" + mStartPosition[0]);

				}
				drag(x, y);
			}
			break;
		case MotionEvent.ACTION_MOVE:
			int speed = (int) ((y - prevY) * dragRatio);
			if (getLastVisiblePosition() < getCount() && speed > 0) {
				smoothScrollBy(speed, 1);
			}
			if (getFirstVisiblePosition() > 0 && speed < 0) {
				smoothScrollBy(speed, 1);
			}
			drag(x, y);// replace 0 with x if desired
			if (listeners != null) {
				listeners.onDrag(x, y);
			}
			break;
		case MotionEvent.ACTION_CANCEL:
		case MotionEvent.ACTION_UP:
		default:

			mDragMode = false;
			if (getPackedPositionType(packagedPosition) == 0) {
				mEndPosition[0] = getPackedPositionGroup(packagedPosition);// 返回值为组的id
				mEndPosition[1] = 0;
			} else {
				mEndPosition[0] = getPackedPositionGroup(packagedPosition);
				mEndPosition[1] = getPackedPositionChild(packagedPosition);// 返回值为子元素的id
			}

			stopDrag(mStartFlatPosition);
			if (packagedPosition != PACKED_POSITION_VALUE_NULL) {
				if (adapter != null) {
					if (mStartPosition[0] == mEndPosition[0]) {// 只有在同一组中可以拖动，去掉条件就是可以跨组拖动
						adapter.onDrop(mStartPosition, mEndPosition);
						System.out.println("group" + mStartPosition[0]);
						System.out.println("child" + mStartPosition[0]);
					}
				}
				if (listeners != null) {
					if (mStartPosition[0] == mEndPosition[0]) {// 只有在同一组中可以拖动，去掉条件就是可以跨组拖动
						listeners.onDrop(mStartPosition, mEndPosition);
						System.out.println("group" + mStartPosition[0]);
						System.out.println("child" + mStartPosition[0]);
					}
				}
			}
			break;
		}
		prevY = y;
		return true;
	}

	// move the drag view
	private void drag(int x, int y) {
		if (mDragView != null) {
			WindowManager.LayoutParams layoutParams = (WindowManager.LayoutParams) mDragView
					.getLayoutParams();
			if (!limitHorizontalDrag) {// no need to move if horizontal drag is
										// limited
				layoutParams.x = x;
			}
			if (dragOnLongPress) {
				// to show that item is detached from the list
				layoutParams.y = y - mDragPointOffset - 20;
			} else {
				layoutParams.y = y - mDragPointOffset;
			}

			WindowManager mWindowManager = (WindowManager) getContext()
					.getSystemService(Context.WINDOW_SERVICE);
			mWindowManager.updateViewLayout(mDragView, layoutParams);
		}
	}

	// enable the drag view for dragging
	private void startDrag(int itemIndex, int y) {
		// stopDrag(itemIndex);

		View item = getChildAt(itemIndex);
		if (item == null)
			return;
		hideItem(item, mStartPosition);

		// Create a copy of the drawing cache so that it does not get recycled
		// by the framework when the list tries to clean up memory
		Bitmap bitmap = Bitmap.createBitmap(item.getDrawingCache());
		item.setBackgroundColor(defaultBackgroundColor);
		WindowManager.LayoutParams mWindowParams = new WindowManager.LayoutParams();
		mWindowParams.gravity = Gravity.TOP;
		mWindowParams.x = 0;
		mWindowParams.y = y - mDragPointOffset;

		mWindowParams.height = WindowManager.LayoutParams.WRAP_CONTENT;
		mWindowParams.width = WindowManager.LayoutParams.WRAP_CONTENT;
		mWindowParams.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
				| WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE
				| WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
				| WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN
				| WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS;
		mWindowParams.format = PixelFormat.TRANSLUCENT;
		mWindowParams.windowAnimations = 0;

		Context context = getContext();
		ImageView v = new ImageView(context);
		v.setImageBitmap(bitmap);

		WindowManager mWindowManager = (WindowManager) context
				.getSystemService(Context.WINDOW_SERVICE);
		mWindowManager.addView(v, mWindowParams);
		mDragView = v;
	}

	@Override
	public void setAdapter(ExpandableListAdapter adapter) {
		// TODO Auto-generated method stub
		super.setAdapter(adapter);
		this.adapter = (DragNDropAdapter) adapter;
	}

	private void hideItem(View itemView, int[] position) {
		if (adapter != null) {
			adapter.onPick(position);
		}
		itemView.setVisibility(View.INVISIBLE); // make the item invisible as we
												// have picked it
		itemView.setDrawingCacheEnabled(true);
		defaultBackgroundColor = itemView.getDrawingCacheBackgroundColor();
		itemView.setBackgroundColor(backgroundColor);
		ImageView iv = (ImageView) itemView
				.findViewById(R.id.move_icon_customizer_item);
		if (iv != null)
			iv.setVisibility(View.INVISIBLE);
	}

	public void showItem(View itemView) {
		if (itemView != null) {
			itemView.setVisibility(View.VISIBLE);
			itemView.setBackgroundColor(defaultBackgroundColor);
			itemView.setDrawingCacheEnabled(false);
			ImageView iv = (ImageView) itemView
					.findViewById(R.id.move_icon_customizer_item);
			if (iv != null)
				iv.setVisibility(View.VISIBLE);
		}

	}

	/**
	 * destroy the drag view
	 * 
	 * @param itemIndex
	 *            Index of the item
	 */

	private void stopDrag(int itemIndex) {
		int firstPosition = getFirstVisiblePosition() - getHeaderViewsCount();
		int wantedChild = itemIndex - firstPosition;
		if (mDragView != null) {
			if (wantedChild < 0 || wantedChild >= getChildCount()) {
				// no need to do anything
			} else {
				showItem(getChildAt(wantedChild));
			}
			mDragView.setVisibility(GONE);
			WindowManager wm = (WindowManager) getContext().getSystemService(
					Context.WINDOW_SERVICE);
			wm.removeView(mDragView);
			mDragView.setImageDrawable(null);
			mDragView = null;
		}
	}

	/**
	 * @return the limitHorizontalDrag
	 */
	public boolean isLimitHorizontalDrag() {
		return limitHorizontalDrag;
	}

	/**
	 * @param limitHorizontalDrag
	 *            the limitHorizontalDrag to set
	 */
	public void setLimitHorizontalDrag(boolean limitHorizontalDrag) {
		this.limitHorizontalDrag = limitHorizontalDrag;
	}

	/**
	 * @return the listeners
	 */
	public DragNDropListeners getListeners() {
		return listeners;
	}

	/**
	 * @param listeners
	 *            the listeners to set
	 */
	public void setListeners(DragNDropListeners listeners) {
		this.listeners = listeners;
	}

	/**
	 * @return the dragOffset
	 */
	public int getDragOffset() {
		return dragOffset;
	}

	/**
	 * @param dragOffset
	 *            the dragOffset to set
	 */
	public void setDragOffset(int dragOffset) {
		this.dragOffset = dragOffset;
	}

	public boolean isDragOnLongPress() {
		return dragOnLongPress;
	}

	/**
	 * set this to drag an item by long press
	 * 
	 * @param flag
	 */
	public void setDragOnLongPress(boolean flag) {
		dragOnLongPress = flag;
		if (flag) {

		}
	}

}

源码下载