I modified TouchInterceptor.java for my purpose. It can deal with various height items.

CustomizedTouchInterceptor

package com.music;

/*
 * Copyright (C) 2008 The Android Open Source Project
 *
 * 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.
 */

import java.util.ArrayList;
import java.util.Timer;
import java.util.TimerTask;

import android.app.Activity;
import android.content.Context;
import android.content.SharedPreferences;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.Color;
import android.graphics.PixelFormat;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.util.AttributeSet;
import android.util.Log;
import android.view.GestureDetector;
import android.view.GestureDetector.SimpleOnGestureListener;
import android.view.Gravity;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.ViewGroup;
import android.view.WindowManager;
import android.widget.AdapterView;
import android.widget.ImageView;
import android.widget.ListView;

public class TouchInterceptor extends ListView {

	private ImageView mDragView;
	private WindowManager mWindowManager;
	private WindowManager.LayoutParams mWindowParams;
	/**
	 * At which position is the item currently being dragged. Note that this
	 * takes in to account header items.
	 */
	private int mDragPos;
	/**
	 * At which position was the item being dragged originally
	 */
	private int mSrcDragPos;
	private int mDragPointX; // at what x offset inside the item did the user
								// grab it
	private int mDragPointY; // at what y offset inside the item did the user
								// grab it
	private int mXOffset; // the difference between screen coordinates and
							// coordinates in this view
	private int mYOffset; // the difference between screen coordinates and
							// coordinates in this view
	private DragListener mDragListener;
	private DropListener mDropListener;
	private RemoveListener mRemoveListener;
	private int mUpperBound;
	private int mLowerBound;
	private int mHeight;
	private GestureDetector mGestureDetector;
	private static final int FLING = 0;
	private static final int SLIDE = 1;
	private static final int TRASH = 2;
	private int mRemoveMode = -1;
	private Rect mTempRect = new Rect();
	private Bitmap mDragBitmap;
	private final int mTouchSlop;
	private int mItemHeightNormal;
	private int mItemHeightExpanded;
	private int mItemHeightHalf;
	private Drawable mTrashcan;

	public TouchInterceptor(Context context, AttributeSet attrs) {
		super(context, attrs);
		// おそらく元のアプリの設定
		// SharedPreferences pref = context.getSharedPreferences("Music", 3);
		// mRemoveMode = pref.getInt("deletemode", -1);
		mRemoveMode = FLING; // FLINGにすると横縦自由に移動ができる
		// mRemoveMode = SLIDE; // SLIDEは上下のみ移動可能
		mTouchSlop = ViewConfiguration.get(context).getScaledTouchSlop();
		final float scale = getContext().getResources().getDisplayMetrics().density;

		// アイテムの高さに関する設定。そのままではR.dimenなどにエラーが出て使えない
		// Resources res = getResources();
		// mItemHeightNormal = res.getDimensionPixelSize(R.dimen.normal_height);
		// mItemHeightHalf = mItemHeightNormal / 2;
		// mItemHeightExpanded = res
		// .getDimensionPixelSize(R.dimen.expanded_height);

	}

	private Activity ac;

	public void setActivity(Activity ac) {
		this.ac = ac;
	}

	@Override
	public boolean onInterceptTouchEvent(MotionEvent ev) {
		if (mRemoveListener != null && mGestureDetector == null) {
			if (mRemoveMode == FLING) {
				mGestureDetector = new GestureDetector(getContext(),
						new SimpleOnGestureListener() {
							@Override
							public boolean onFling(MotionEvent e1,
									MotionEvent e2, float velocityX,
									float velocityY) {
								if (mDragView != null) {
									if (velocityX > 1000) {
										Rect r = mTempRect;
										mDragView.getDrawingRect(r);
										if (e2.getX() > r.right * 2 / 3) {
											// fast fling right with release
											// near the right edge of the screen
											stopDragging();
											mRemoveListener.remove(mSrcDragPos);
											unExpandViews(true);
										}
									}
									// flinging while dragging should have no
									// effect
									return true;
								}
								return false;
							}
						});
			}
		}
		if (mDragListener != null || mDropListener != null) {
			switch (ev.getAction()) {
			case MotionEvent.ACTION_DOWN:
				int x = (int) ev.getX();
				int y = (int) ev.getY();
				int itemnum = pointToPosition(x, y);
				if (itemnum == AdapterView.INVALID_POSITION) {
					break;
				}

				// TextView item = (TextView) getChildAt(itemnum
				// - getFirstVisiblePosition());

				View item = getChildAt(itemnum - getFirstVisiblePosition());

				for (int i = 0; i < viewsheight.size() - 1; i++) {
					viewsheight.set(i, getChildAt(i).getHeight());
				}

				// Log.d("to","itemtostirng:" + item.getText());

				mDragPointX = x - item.getLeft();
				mDragPointY = y - item.getTop();
				mXOffset = ((int) ev.getRawX()) - x;
				mYOffset = ((int) ev.getRawY()) - y;

				// The left side of the item is the grabber for dragging the
				// item
				if (x < 64) {
					item.setDrawingCacheEnabled(true);
					// 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());
					Log.d("to", "createBitmap");
					item.setDrawingCacheEnabled(false);
					startDragging(bitmap, x, y);
					mDragPos = itemnum;
					mSrcDragPos = mDragPos;
					mHeight = getHeight();
					int touchSlop = mTouchSlop;
					mUpperBound = Math.min(y - touchSlop, mHeight / 3);
					mLowerBound = Math.max(y + touchSlop, mHeight * 2 / 3);
					return false;
				}
				stopDragging();
				break;
			}
		}
		return super.onInterceptTouchEvent(ev);
	}

	public ArrayList<Integer> viewsheight = new ArrayList<Integer>();

	/*
	 * pointToPosition() doesn't consider invisible views, but we need to, so
	 * implement a slightly different version.
	 */
	private int myPointToPosition(int x, int y) {

		// 結局このメソッドは使わず。

		if (y < 0) {
			// when dragging off the top of the screen, calculate position
			// by going back from a visible item
			int pos = myPointToPosition(x, y + mItemHeightNormal);
			if (pos > 0) {
				return pos - 1;
			}
		}

		Rect frame = mTempRect;
		final int count = getChildCount();
		for (int i = count - 1; i >= 0; i--) {
			final View child = getChildAt(i);
			Log.d("to", "child height" + " " + i + " " + child.getHeight()
					+ "y:  " + child.getY());
			child.getHitRect(frame); // childの座標・範囲をframeに渡している
			if (frame.contains(x, y)) {
				return getFirstVisiblePosition() + i;
			}
		}
		return INVALID_POSITION;
	}

	private int getItemForPosition(int y) {
		int adjustedy = y - mDragPointY - mItemHeightHalf;

		// int adjustedy = y - mDragPointY - mItemHeightHalf;

		// Log.d("to","adjustedy:" + adjustedy);

		int pos = myPointToPosition(0, adjustedy);
		// int pos = myPointToPosition(0, y);
		if (pos >= 0) {
			if (pos <= mSrcDragPos) {

				// Log.d("to", "incri: " + pos +": msrc " + mSrcDragPos);

				pos += 1;
			}
		}

		else if (adjustedy < 0) {
			// this shouldn't happen anymore now that myPointToPosition deals
			// with this situation
			pos = 0;
		}
		return pos;
	}

	private void adjustScrollBounds(int y) {
		if (y >= mHeight / 3) {
			mUpperBound = mHeight / 3;
		}
		if (y <= mHeight * 2 / 3) {
			mLowerBound = mHeight * 2 / 3;
		}
	}

	/*
	 * Restore size and visibility for all listitems
	 */
	private void unExpandViews(boolean deletion) {
		for (int i = 0;; i++) {
			// Log.d("to","unExpandViews");
			View v = getChildAt(i);
			if (v == null) {
				if (deletion) {
					// HACK force update of mItemCount
					Log.d("to", "hackpoint");
					int position = getFirstVisiblePosition();
					int y = getChildAt(0).getTop();
					setAdapter(getAdapter());
					setSelectionFromTop(position, y);
					// end hack
				}
				try {
					layoutChildren(); // force children to be recreated where
										// needed
					v = getChildAt(i);
				} catch (IllegalStateException ex) {
					// layoutChildren throws this sometimes, presumably because
					// we're
					// in the process of being torn down but are still getting
					// touch
					// events
				}
				if (v == null) {
					return;
				}
			}
			ViewGroup.LayoutParams params = v.getLayoutParams();
			// params.height = mItemHeightNormal;
			v.setLayoutParams(params);

			// v.find

			v.setVisibility(View.VISIBLE);
		}
	}

	/*
	 * Adjust visibility and size to make it appear as though an item is being
	 * dragged around and other items are making room for it: If dropping the
	 * item would result in it still being in the same place, then make the
	 * dragged listitem's size normal, but make the item invisible. Otherwise,
	 * if the dragged listitem is still on screen, make it as small as possible
	 * and expand the item below the insert point. If the dragged item is not on
	 * screen, only expand the item below the current insertpoint.
	 */
	private void doExpansion() {
		int childnum = mDragPos - getFirstVisiblePosition();

		Log.d("to", "childnum: " + childnum + "dragpos:"
				+ (mDragPos - getFirstVisiblePosition()));
		if (mDragPos > mSrcDragPos) {
			childnum++;
		}
		int numheaders = getHeaderViewsCount();

		View first = getChildAt(mSrcDragPos - getFirstVisiblePosition());

		if (first == null) {
			Log.d("to", "first null pos "
					+ (mSrcDragPos - getFirstVisiblePosition()));
			return;
		}

		// Log.d("to","gettext: " + ((TextView)first).getText() +
		// " numheaders: " + numheaders);

		for (int i = 0;; i++) {
			View vv = getChildAt(i);
			if (vv == null) {
				Log.d("to", "vv= null");
				break;
			}

			int height = mItemHeightNormal;
			int visibility = View.VISIBLE;
			if (mDragPos < numheaders && i == numheaders) {

				Log.d("to", "mdragpos: " + mDragPos + " numheaders:"
						+ numheaders + " i :" + i);
				// dragging on top of the header item, so adjust the item below
				// instead
				if (vv.equals(first)) {
					visibility = View.INVISIBLE;

					ViewGroup.LayoutParams params = vv.getLayoutParams();
					// params.height = height;
					vv.setLayoutParams(params);
					vv.setVisibility(visibility);
				} else {
					// height = mItemHeightExpanded;

					ViewGroup.LayoutParams params = vv.getLayoutParams();
					// params.height = height;
					vv.setLayoutParams(params);
					vv.setVisibility(visibility);
				}
			} else if (vv.equals(first)) {

				// processing the item that is being dragged
				if (mDragPos == mSrcDragPos
						|| getPositionForView(vv) == getCount() - 1) {
					// hovering over the original location
					Log.d("to", "i:" + i + " mdragpos: " + mDragPos
							+ " mSrcDragPos:" + mSrcDragPos + " i :" + i);
					visibility = View.INVISIBLE;
					Log.d("to", "View.INVISIBLE");

					ViewGroup.LayoutParams params = vv.getLayoutParams();
					// params.height = height;
					vv.setLayoutParams(params);
					vv.setVisibility(visibility);

				} else {
					Log.d("to", "View.INVISIBLE else");

					Log.d("to", "i:" + i + " mdragpos: " + mDragPos
							+ " mSrcDragPos:" + mSrcDragPos + " i :" + i);
					Log.d("to", "gpv: " + getPositionForView(vv)
							+ " getcount()-1: " + (getCount() - 1));
					// Log.d("","");
					// not hovering over it
					// Ideally the item would be completely gone, but neither
					// setting its size to 0 nor settings visibility to GONE
					// has the desired effect.
					height = 1;
					// visibility = View.INVISIBLE;

					ViewGroup.LayoutParams params = vv.getLayoutParams();
					// params.height = height;
					vv.setLayoutParams(params);
					vv.setVisibility(visibility);
				}
			} else if (i == childnum) {
				if (mDragPos >= numheaders && mDragPos < getCount() - 1) {
					Log.d("to", "i==childnum");
					height = mItemHeightExpanded;

					ViewGroup.LayoutParams params = vv.getLayoutParams();
					// params.height = height;
					vv.setLayoutParams(params);
					vv.setVisibility(visibility);
				}
			}

		}
	}

	private Rect srcBound;
	private View transparentView;
	private View srcChild;

	@Override
	public boolean onTouchEvent(MotionEvent ev) {

		// Log.d("touch","ontouchevent");
		if (mGestureDetector != null) {
			mGestureDetector.onTouchEvent(ev);
		}
		if ((mDragListener != null || mDropListener != null)
				&& mDragView != null) {
			int action = ev.getAction();
			switch (action) {
			case MotionEvent.ACTION_UP:
				if (scrollTimer != null) {
					scrollTimer.cancel();
				}

			case MotionEvent.ACTION_CANCEL:
				if (scrollTimer != null) {
					scrollTimer.cancel();
				}
				Rect r = mTempRect;
				Log.d("to", "action_cancel");
				mDragView.getDrawingRect(r);
				stopDragging();
				if (mRemoveMode == SLIDE && ev.getX() > r.right * 3 / 4) {
					if (mRemoveListener != null) {
						mRemoveListener.remove(mSrcDragPos);
					}
					Log.d("to", "unex true");
					unExpandViews(true);
				} else {
					if (mDropListener != null && mDragPos >= 0
							&& mDragPos < getCount()) {
						mDropListener.drop(mSrcDragPos, mDragPos);
					}
					Log.d("to", "unex false");
					unExpandViews(false);
				}
				break;

			case MotionEvent.ACTION_DOWN:

				// preparation
				if (transparentView != null) {
					transparentView.setVisibility(VISIBLE);
					transparentView = null;
				}

				// Before dragging, saving srcBound to use for getting item's
				// position user points later.

				srcBound = new Rect();

				int cldCount = getChildCount();
				int srcPos = 0;
				for (int i = cldCount - 1; i >= 0; i--) {
					srcChild = getChildAt(i);
					srcChild.getHitRect(srcBound);
					if (srcBound.contains((int) ev.getX(), (int) ev.getY())) {
						srcPos = i;
						srcChild.setVisibility(INVISIBLE);
						break;
					}
				}
				Log.d("to", "srcPos" + srcPos + "getx: " + ev.getX()
						+ " gety: " + ev.getY());
				break;

			case MotionEvent.ACTION_MOVE:
				int x = (int) ev.getX();
				int y = (int) ev.getY();
				dragView(x, y);

				// Log.d("to", "x: " + x + " y: " + y);

				// depreciated
				// int itemnum = getItemForPosition(y);
				// int itemnum = pointToPosition(x, y);

				// getItemForPosition-like func which also can deal with various
				// height items;　高さの違うアイテムに対応する処理。
				Rect rect = new Rect();
				int itemnum = INVALID_POSITION;
				int cCount = getChildCount();
				View child = null;
				for (int i = cCount - 1; i >= 0; i--) {
					child = getChildAt(i);
					// tell rect child's bound
					child.getHitRect(rect);

					// know which is bigger bound
					// ２つの順序を交換するアイテムでどちらが大きいかで処理を少し変更するのに使う
					// この処理がないと、アイテムの高さが異なる場合アイテムがちらついて上手く描写されない。
					boolean isBigger = false;

					if (srcBound.height() < rect.height()) {
						isBigger = true;
					}

					if (rect.contains(x, y)) {

						if (mDragPos < itemnum) {
							if (isBigger) {
								int sub = rect.height() - srcBound.height();
								Rect check = new Rect(rect.left,
										rect.top + sub, rect.right, rect.bottom);
								if (check.contains(x, y)) {
									// getFirstVisiblePositionは一番上の
									// 見えているアイテムがリストビューの何番目かを知るスレッド
									// iは見えているアイテムで上から何番目かを示すので、
									// itemnumはリストビューの中で何番目かを示す。
									itemnum = getFirstVisiblePosition() + i;
								}
							} else {
								itemnum = getFirstVisiblePosition() + i;
							}
						} else if (itemnum < mDragPos) {
							if (isBigger) {
								int sub = rect.height() - srcBound.height();
								Rect check = new Rect(rect.left, rect.top,
										rect.right, rect.bottom - sub);
								if (check.contains(x, y))
									itemnum = getFirstVisiblePosition() + i;
							} else {
								itemnum = getFirstVisiblePosition() + i;
							}
						}
						break;
					}
				}

				// Log.d("to", "itemnum: " + itemnum);
				if (itemnum >= 0) {
					if (action == MotionEvent.ACTION_DOWN
							|| itemnum != mDragPos) { // inform posFrom and
														// posTo to listener
						if (mDragListener != null) {
							if (transparentView != null) {
								transparentView.setVisibility(VISIBLE);
							}
							srcChild.setVisibility(VISIBLE);
							transparentView = child;
							transparentView.setVisibility(INVISIBLE);

							// users have to implement process exchanging
							// adapter's item in listener
							mDragListener.drag(mDragPos, itemnum);
						}
					}
					mDragPos = itemnum;
					// doExpansion();
				}
				int speed = 0;
				adjustScrollBounds(y);
				if (y > mLowerBound) {
					// scroll the list up a bit
					if (getLastVisiblePosition() < getCount() - 1) {
						speed = y > (mHeight + mLowerBound) / 2 ? 16 : 4;
						// speed = 16;
					} else {
						speed = 1;
					}
				} else if (y < mUpperBound) {
					// scroll the list down a bit
					speed = y < mUpperBound / 2 ? -16 : -4;
					if (getFirstVisiblePosition() == 0
							&& getChildAt(0).getTop() >= getPaddingTop()) {
						// if we're already at the top, don't try to scroll,
						// because
						// it causes the framework to do some extra drawing
						// that messes
						// up our animation
						speed = 0;
					}
				}
				if (speed != 0) {
					// smoothScrollBy(speed, 30);
					if (prevSpeed == 0 || prevSpeed != speed) {
						prevSpeed = speed;
						doSmoothScroll(speed * 4, 30);
					}

				} else {
					if (scrollTimer != null) {
						prevSpeed = 0;
						scrollTimer.cancel();
					}
				}
				break;
			}
			return true;
		}
		return super.onTouchEvent(ev);

	}

	private Timer scrollTimer;
	private int prevSpeed;

	private void doSmoothScroll(final int speed, final int duration) {
		if (scrollTimer != null) {
			scrollTimer.cancel();
			scrollTimer = null;
		}
		scrollTimer = new Timer();
		scrollTimer.schedule(new TimerTask() {

			@Override
			public void run() {
				ac.runOnUiThread(new Runnable() {
					@Override
					public void run() {
						smoothScrollBy(speed, duration);
					}
				});
			}
		}, 0, 10);
	}

	private void startDragging(Bitmap bm, int x, int y) {
		stopDragging();

		mWindowParams = new WindowManager.LayoutParams();
		mWindowParams.gravity = Gravity.TOP | Gravity.LEFT;
		mWindowParams.x = x - mDragPointX + mXOffset;
		mWindowParams.y = y - mDragPointY + mYOffset;

		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);
		// int backGroundColor =
		// context.getResources().getColor(R.color.);
		
		//背景色の設定
		v.setBackgroundColor(Color.LTGRAY);
		// v.setBackgroundColor(backGroundColor);

		// v.setBackgroundResource(R.drawable.);
		v.setPadding(0, 0, 0, 0);
		v.setImageBitmap(bm);
		mDragBitmap = bm;

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

	private void dragView(int x, int y) {
		if (mRemoveMode == SLIDE) {
			float alpha = 1.0f;
			int width = mDragView.getWidth();
			if (x > width / 2) {
				alpha = ((float) (width - x)) / (width / 2);
			}
			mWindowParams.alpha = alpha;
		}

		//ドラッグをして横方向に動けるかどうか
		if (mRemoveMode == FLING || mRemoveMode == TRASH) {
			mWindowParams.x = x - mDragPointX + mXOffset;
		} else {
			mWindowParams.x = 0;
		}

		mWindowParams.y = y - mDragPointY + mYOffset;
		mWindowManager.updateViewLayout(mDragView, mWindowParams);

		if (mTrashcan != null) {
			int width = mDragView.getWidth();
			if (y > getHeight() * 3 / 4) {
				mTrashcan.setLevel(2);
			} else if (width > 0 && x > width / 4) {
				mTrashcan.setLevel(1);
			} else {
				mTrashcan.setLevel(0);
			}
		}
	}

	private void stopDragging() {
		if (mDragView != null) {
			mDragView.setVisibility(GONE);
			WindowManager wm = (WindowManager) getContext().getSystemService(
					Context.WINDOW_SERVICE);
			wm.removeView(mDragView);
			mDragView.setImageDrawable(null);
			mDragView = null;
		}
		if (mDragBitmap != null) {
			mDragBitmap.recycle();
			mDragBitmap = null;
		}
		if (mTrashcan != null) {
			mTrashcan.setLevel(0);
		}
	}

	public void setTrashcan(Drawable trash) {
		mTrashcan = trash;
		mRemoveMode = TRASH;
	}

	public void setDragListener(DragListener l) {
		mDragListener = l;
	}

	public void setDropListener(DropListener l) {
		mDropListener = l;
	}

	public void setRemoveListener(RemoveListener l) {
		mRemoveListener = l;
	}

	public interface DragListener {
		void drag(int from, int to);
	}

	public interface DropListener {
		void drop(int from, int to);
	}

	public interface RemoveListener {
		void remove(int which);
	}
}