ViewDragHelper使用詳解

一、基本介紹

前輩們已經總結的很多了，所以從別人的博客裏直接複製的比較多，用到的源碼我也會經過修改。用到的博客我會在下方註釋。

最近發下一篇寫的不錯的ViewDragHelper的博客，比較清晰，調理，看完這一片再看下面的效果會更好點點擊跳轉。

2013年穀歌i/o大會上介紹了兩個新的layout： SlidingPaneLayout和DrawerLayout，現在這倆個類被廣泛的運用，其實研究他們的源碼你會發現這兩個類都運用了ViewDragHelper來處理拖動。ViewDragHelper是framework中不爲人知卻非常有用的一個工具。

ViewDragHelper解決了Android中手勢處理過於複雜的問題，在DrawerLayout出現之前，側滑菜單都是由第三方開源代碼實現的，其中著名的當屬MenuDrawer（現在用android.support.v4.widget.DrawerLayout）。

其實ViewDragHelper並不是第一個用於分析手勢處理的類，gesturedetector也是，但是在和拖動相關的手勢分析方面gesturedetector只能說是勉爲其難。

關於ViewDragHelper有如下幾點：

1、ViewDragHelper.Callback是連接ViewDragHelper與view之間的橋樑（這個view一般是指擁子view的容器即parentView）；

2、ViewDragHelper的實例是通過靜態工廠方法創建的；

3、你能夠指定拖動的方向；

4、ViewDragHelper可以檢測到是否觸及到邊緣；

5、ViewDragHelper並不是直接作用於要被拖動的View，而是使其控制的視圖容器中的子View可以被拖動，如果要指定某個子view的行爲，需要在Callback中想辦法；

6、ViewDragHelper的本質其實是分析onInterceptTouchEvent和onTouchEvent的MotionEvent參數，然後根據分析的結果去改變一個容器中被拖動子View的位置（通過offsetTopAndBottom(int offset)和offsetLeftAndRight(int offset)方法），他能在觸摸的時候判斷當前拖動的是哪個子View；

7、雖然ViewDragHelper的實例方法 ViewDragHelper create(ViewGroup forParent, Callback cb) 可以指定一個被

ViewDragHelper處理拖動事件的對象，但ViewDragHelper類的設計決定了其適用於被包含在一個自定義ViewGroup之中，而不是對

任意一個佈局上的視圖容器使用ViewDragHelper。

注意：ViewDragHelper是作用在一個ViewGroup上，也就是說他不能直接作用到被拖拽的view，其實這也很好理

解，因爲view在佈局中的位置是父ViewGroup決定的。

如何使用ViewGroup實現一個可以拖動的view？

1、獲取ViewDragHelper的實例，注意，這裏不能直接new，而是使用ViewDragHelper的一個靜態方法：

ViewDragHelper.create(ViewGroup forParent, float sensitivity, ViewDragHelper.Callback cb);

參數1：一個ViewGroup，也就是ViewDragHelper將要用來拖拽誰下面的子view

參數2：靈敏度，一般設置爲1.0f就行

參數3：一個回調，用來處理拖動到位置

2、在Callback對象裏面，下面幾個方法非常重要。

（1） public int clampViewPositionHorizontal(View child, int left, int dx)

這個是返回被橫向移動的子控件child的左座標left，和移動距離dx，我們可以根據這些值來返回child的新的left。

返回值該child現在的位置， 這個方法必須重寫，要不然就不能移動了。

（2）public int clampViewPositionVertical(View child, int top, int dy)

這個和上面的方法一個意思，就是換成了垂直方向的移動和top座標。

如果有垂直移動，這個也必須重寫，要不默認返回0，也不能移動了。

（3）public abstract boolean tryCaptureView(View child, int pointerId)

表示嘗試捕獲子view，這裏一定要返回true，返回true表示允許。

這個方法用來返回可以被移動的View對象，我們可以通過判斷child與我們想移動的View是的相等來控制誰能移動。

（4）public int getViewVerticalDragRange(View child)

這個用來控制垂直移動的邊界範圍，單位是像素。

（5）public int getViewHorizontalDragRange(View child)

和上面一樣，就是是橫向的邊界範圍。

（6）public void onViewReleased(View releasedChild, float xvel, float yvel)

當releasedChild被釋放的時候，xvel和yvel是x和y方向的加速度

（7）public void onViewPositionChanged(View changedView, int left, int top, int dx, int dy)

這個是當changedView的位置發生變化時調用，我們可以在這裏面控制View的顯示位置和移動。

我們前面雖然獲取了ViewDragHelper的對象，但是現在我們還是不能接收到事件的，我們需要在onTouch()和onInterceptTouchEvent()裏面，將觸摸事件傳入到ViewDragHelper裏面，才能進行處理，就像下面這樣，注意需要在clampViewPositionHorizontal和clampViewPositionHorizontal中做一點工作，以防止view超出了邊界。

[java] view plain copy

@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
…
return mDragHelper.shouldInterceptTouchEvent(ev);
}

[java] view plain copy

public boolean onTouchEvent(MotionEvent event) {
…
mDragHelper.processTouchEvent(event);
return true;
}

傳遞給ViewDragHelper之後，我們就可以在Callback的各個事件裏面進行處理了。

二、實戰1

例1：

[java] view plain copy

public class CustomView extends LinearLayout {
private ViewDragHelper mDragHelper;
public CustomView(Context context) {
super(context);
init();
}
public CustomView(Context context, AttributeSet attrs) {
super(context, attrs);
init();
}
public CustomView(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
init();
}
private void init() {
/**
* @params ViewGroup forParent 必須是一個ViewGroup
* @params float sensitivity 靈敏度
* @params Callback cb 回調
*/
mDragHelper = ViewDragHelper.create(this, 1.0f, new ViewDragCallback());
}
private class ViewDragCallback extends ViewDragHelper.Callback {
/**
* 嘗試捕獲子view，一定要返回true
* @param View child 嘗試捕獲的view
* @param int pointerId 指示器id？
* 這裏可以決定哪個子view可以拖動
*/
@Override
public boolean tryCaptureView(View view, int pointerId) {
// return mCanDragView == view;
return true;
}
/**
* 處理水平方向上的拖動
* @param View child 被拖動到view
* @param int left 移動到達的x軸的距離
* @param int dx 建議的移動的x距離
*/
@Override
public int clampViewPositionHorizontal(View child, int left, int dx) {
System.out.println("left = " + left + ", dx = " + dx);
// 兩個if主要是爲了讓viewViewGroup裏
if(getPaddingLeft() > left) {
return getPaddingLeft();
}
if(getWidth() - child.getWidth() < left) {
return getWidth() - child.getWidth();
}
return left;
}
/**
* 處理豎直方向上的拖動
* @param View child 被拖動到view
* @param int top 移動到達的y軸的距離
* @param int dy 建議的移動的y距離
*/
@Override
public int clampViewPositionVertical(View child, int top, int dy) {
// 兩個if主要是爲了讓viewViewGroup裏
if(getPaddingTop() > top) {
return getPaddingTop();
}
if(getHeight() - child.getHeight() < top) {
return getHeight() - child.getHeight();
}
return top;
}
/**
* 當拖拽到狀態改變時回調
* @params 新的狀態
*/
@Override
public void onViewDragStateChanged(int state) {
switch (state) {
case ViewDragHelper.STATE_DRAGGING: // 正在被拖動
break;
case ViewDragHelper.STATE_IDLE: // view沒有被拖拽或者正在進行fling/snap
break;
case ViewDragHelper.STATE_SETTLING: // fling完畢後被放置到一個位置
break;
}
super.onViewDragStateChanged(state);
}
}
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
switch (ev.getAction()) {
case MotionEvent.ACTION_CANCEL:
case MotionEvent.ACTION_DOWN:
mDragHelper.cancel(); // 相當於調用 processTouchEvent收到ACTION_CANCEL
break;
}
/**
* 檢查是否可以攔截touch事件
* 如果onInterceptTouchEvent可以return true 則這裏return true
*/
return mDragHelper.shouldInterceptTouchEvent(ev);
}
@Override
public boolean onTouchEvent(MotionEvent event) {
/**
* 處理攔截到的事件
* 這個方法會在返回前分發事件
*/
mDragHelper.processTouchEvent(event);
return true;
}
}

layout：

[java] view plain copy

<span style="color:#999999;"><RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
tools:context=".MainActivity" >
<com.bluemor.reddotface.view.CustomView
android:layout_width="match_parent"
android:layout_height="match_parent">
<View
android:layout_width="100dp"
android:layout_height="100dp"
android:background="#FFFF0000" />
</com.bluemor.reddotface.view.CustomView>
</RelativeLayout></span>

三、實戰2

DragLayout.Java

[java] view plain copy

public class DragLayout extends FrameLayout {
private Context context;
private GestureDetectorCompat gestureDetector;
private ViewDragHelper dragHelper;
private DragListener dragListener;
/** 水平可以滾動的範圍 */
private int horizontalRange;
/** 垂直可以滾動的範圍 */
private int verticalRange;
/** 默認滾動式水平的 */
private Orientation orientation = Orientation.Horizontal;
private int viewWidth;
private int viewHeight;
private int distanceLeft;
private int distanceTop;
private ViewGroup layoutMenu;
private ViewGroup layoutContent;
private Status status = Status.Close;
public DragLayout(Context context) {
this(context, null);
}
public DragLayout(Context context, AttributeSet attrs) {
this(context, attrs, 0);
this.context = context;
}
public DragLayout(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
gestureDetector = new GestureDetectorCompat(context,
new XYScrollDetector());
dragHelper = ViewDragHelper.create(this, dragHelperCallback);
}
class XYScrollDetector extends SimpleOnGestureListener {
@Override
public boolean onScroll(MotionEvent e1, MotionEvent e2, float dx,
float dy) {
if (orientation == Orientation.Vertical) {
return Math.abs(dy) >= Math.abs(dx);
}
return Math.abs(dy) <= Math.abs(dx);
}
}
private ViewDragHelper.Callback dragHelperCallback = new ViewDragHelper.Callback() {
// 這個是返回被橫向移動的子控件child的左座標left，和移動距離dx，我們可以根據這些值來返回child的新的left。
// 這個方法必須重寫，要不然就不能移動了。
// 返回橫向座標左右邊界值
@Override
public int clampViewPositionHorizontal(View child, int left, int dx) {
if (orientation == Orientation.Vertical)
return 0;
if (distanceLeft + dx < 0) {
// 右邊界
return 0;
} else if (distanceLeft + dx > horizontalRange) {
// 左邊界
return horizontalRange;
} else {
// 左右邊界範圍內
return left;
}
}
// 這個方法用來返回可以被移動的View對象，我們可以通過判斷child與我們想移動的View是的相等來控制誰能移動。
@Override
public boolean tryCaptureView(View child, int pointerId) {
return true;
}
// 橫向的邊界範圍
@Override
public int getViewHorizontalDragRange(View child) {
return horizontalRange;
}
public int clampViewPositionVertical(View child, int top, int dy) {
if (orientation == Orientation.Horizontal)
return 0;
if (distanceTop + dy < 0) {
return 0;
} else if (distanceTop + dy > verticalRange) {
return verticalRange;
} else {
return top;
}
}
public int getViewVerticalDragRange(View child) {
return verticalRange;
};
// ACTION_UP事件後調用其方法
// 當releasedChild被釋放的時候，xvel和yvel是x和y方向的加速度
@Override
public void onViewReleased(View releasedChild, float xvel, float yvel) {
super.onViewReleased(releasedChild, xvel, yvel);
if (orientation == Orientation.Vertical) {
if (releasedChild == layoutMenu)
return;
if (yvel > 0) {
// 加速度向下
open();
} else if (yvel < 0) {
// 加速度向上
close();
} else if (releasedChild == layoutContent
&& distanceTop > verticalRange * 0.3) {
// 如果釋放時，手指在內容區且內容區離左邊的距離是range * 0.3
open();
} else {
close();
}
} else {
if (xvel > 0) {
// 加速度向
open();
} else if (xvel < 0) {
// 加速度向左
close();
} else if (releasedChild == layoutContent
&& distanceLeft > horizontalRange * 0.3) {
// 如果釋放時，手指在內容區且內容區離左邊的距離是range * 0.3
open();
} else if (releasedChild == layoutMenu
&& distanceLeft > horizontalRange * 0.7) {
// 如果釋放時，手指在菜單區且內容區離左邊的距離是range * 0.7
open();
} else {
close();
}
}
}
// view在拖動過程座標發生變化時會調用此方法，包括兩個時間段：手動拖動和自動滾動
@Override
public void onViewPositionChanged(View changedView, int left, int top,
int dx, int dy) {
if (orientation == Orientation.Horizontal) {
if (changedView == layoutContent) {
distanceLeft = left;
} else {
distanceLeft = distanceLeft + left;
}
if (distanceLeft < 0) {
distanceLeft = 0;
} else if (distanceLeft > horizontalRange) {
distanceLeft = horizontalRange;
}
layoutMenu.layout(0, 0, viewWidth, viewHeight);
layoutContent.layout(distanceLeft, 0, distanceLeft + viewWidth,
viewHeight);
dispatchDragEvent(distanceLeft);
} else {
distanceTop = top;
if (distanceTop < 0) {
distanceTop = 0;
} else if (distanceTop > verticalRange) {
distanceTop = verticalRange;
}
layoutMenu.layout(0, 0, viewWidth, viewHeight);
layoutContent.layout(0, distanceTop, viewWidth, distanceTop
+ viewHeight);
dispatchDragEvent(distanceTop);
}
}
};
public interface DragListener {
/** 已經打開 */
public void onOpen();
/** 已經關閉 */
public void onClose();
/** 真在拖拽 */
public void onDrag(float percent);
}
public void setDragListener(DragListener dragListener) {
this.dragListener = dragListener;
}
@Override
protected void onFinishInflate() {
super.onFinishInflate();
layoutMenu = (ViewGroup) getChildAt(0);
layoutContent = (ViewGroup) getChildAt(1);
layoutMenu.setClickable(true);
layoutContent.setClickable(true);
}
@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
super.onSizeChanged(w, h, oldw, oldh);
viewWidth = layoutMenu.getMeasuredWidth();
viewHeight = layoutMenu.getMeasuredHeight();
horizontalRange = (int) (viewWidth * 0.7);
verticalRange = (int) (viewHeight * 0.9);
}
@Override
protected void onLayout(boolean changed, int left, int top, int right,
int bottom) {
layoutMenu.layout(0, 0, viewWidth, viewHeight);
if (orientation == Orientation.Horizontal) {
layoutContent.layout(distanceLeft, 0, distanceLeft + viewWidth,
viewHeight);
} else {
layoutContent.layout(0, distanceTop, viewWidth, distanceTop
+ viewHeight);
}
}
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
if (orientation == Orientation.Vertical) {
if ((Status.Open == getStatus() && ev.getY() < verticalRange)) {
return false;
}
}
return dragHelper.shouldInterceptTouchEvent(ev)
&& gestureDetector.onTouchEvent(ev);
}
@Override
public boolean onTouchEvent(MotionEvent e) {
try {
// 在processTouchEvent中對ACTION_DOWN、ACTION_MOVE和ACTION_UP事件進行了處理：
// 1.在ACTION_DOWN中調用回調接口中的tryCaptureView方法，看當前touch的view是否允許拖動
// 在此項目中的是直接return true，兩個view都是允許拖動的
// 2.在ACTION_MOVE中，view的座標發生改變，調用回調接口中的onViewPositionChanged方法，
// 根據座標信息對view進行layout，通過ViewHelper這個類中的setScaleX、setScaleY方法，實現在
// 拖動的過程中view在XY座標上進行相應比例的縮放；
// 3.在ACTION_UP後調用回調接口中的onViewReleased方法，此方法中一個重要的任務是在ACTION_UP事件
dragHelper.processTouchEvent(e);
} catch (Exception ex) {
ex.printStackTrace();
}
return false;
}
private void dispatchDragEvent(int mainLeft) {
float percent;
if (orientation == Orientation.Horizontal) {
percent = mainLeft / (float) horizontalRange;
animateView(percent);
} else {
percent = mainLeft / (float) verticalRange;
}
Status lastStatus = status;
if (dragListener == null)
return;
dragListener.onDrag(percent);
if (lastStatus != getStatus() && status == Status.Close) {
dragListener.onClose();
} else if (lastStatus != getStatus() && status == Status.Open) {
dragListener.onOpen();
}
}
private void animateView(float percent) {
float f1 = 1 - percent * 0.3f;
ViewHelper.setScaleX(layoutContent, f1);
ViewHelper.setScaleY(layoutContent, f1);
ViewHelper.setTranslationX(
layoutMenu,
-layoutMenu.getWidth() / 2.3f
+ layoutMenu.getWidth() / 2.3f * percent);
ViewHelper.setScaleX(layoutMenu, 0.5f + 0.5f * percent);
ViewHelper.setScaleY(layoutMenu, 0.5f + 0.5f * percent);
ViewHelper.setAlpha(layoutMenu, percent);
getBackground().setColorFilter(
evaluate(percent, Color.BLACK, Color.TRANSPARENT),
Mode.SRC_OVER);
}
private Integer evaluate(float fraction, Object startValue, Integer endValue) {
int startInt = (Integer) startValue;
int startA = (startInt >> 24) & 0xff;
int startR = (startInt >> 16) & 0xff;
int startG = (startInt >> 8) & 0xff;
int startB = startInt & 0xff;
int endInt = (Integer) endValue;
int endA = (endInt >> 24) & 0xff;
int endR = (endInt >> 16) & 0xff;
int endG = (endInt >> 8) & 0xff;
int endB = endInt & 0xff;
return (int) ((startA + (int) (fraction * (endA - startA))) << 24)
| (int) ((startR + (int) (fraction * (endR - startR))) << 16)
| (int) ((startG + (int) (fraction * (endG - startG))) << 8)
| (int) ((startB + (int) (fraction * (endB - startB))));
}
@Override
public void computeScroll() {
if (dragHelper.continueSettling(true)) {
ViewCompat.postInvalidateOnAnimation(this);
}
}
public enum Status {
Drag, Open, Close
}
public enum Orientation {
Horizontal, Vertical;
}
public Status getStatus() {
if (orientation == Orientation.Horizontal) {
if (distanceLeft == 0) {
status = Status.Close;
} else if (distanceLeft == horizontalRange) {
status = Status.Open;
} else {
status = Status.Drag;
}
} else {
if (distanceTop == 0) {
status = Status.Close;
} else if (distanceTop == verticalRange) {
status = Status.Open;
} else {
status = Status.Drag;
}
}
return status;
}
public ViewGroup getlayoutContent() {
return layoutContent;
}
public ViewGroup getlayoutMenu() {
return layoutMenu;
}
public void setOrientation(Orientation orientation) {
this.orientation = orientation;
}
public void open() {
open(true);
}
public void open(boolean animate) {
if (animate) {
if (orientation == Orientation.Horizontal) {
if (dragHelper.smoothSlideViewTo(layoutContent,
horizontalRange, 0)) {
ViewCompat.postInvalidateOnAnimation(this);
}
} else {
if (dragHelper.smoothSlideViewTo(layoutContent, 0,
verticalRange)) {
ViewCompat.postInvalidateOnAnimation(this);
}
}
} else {
layoutContent.layout(horizontalRange, 0, horizontalRange
+ viewWidth, viewHeight);
dispatchDragEvent(horizontalRange);
}
}
public void close() {
close(true);
}
public void close(boolean animate) {
if (animate) {
if (dragHelper.smoothSlideViewTo(layoutContent, 0, 0)) {
ViewCompat.postInvalidateOnAnimation(this);
}
} else {
layoutContent.layout(0, 0, viewWidth, viewHeight);
dispatchDragEvent(0);
}
}
}

layout.xml

[java] view plain copy

<com.bluemor.reddotface.view.DragLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/dl"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="@drawable/bg" >
<RelativeLayout
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingBottom="30dp"
android:paddingLeft="30dp"
android:onClick="true"
android:paddingTop="50dp" >
<LinearLayout
android:id="@+id/ll1"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="horizontal" >
<ImageView
android:id="@+id/iv_bottom"
android:layout_width="70dp"
android:layout_height="70dp"
android:src="@drawable/ic_launcher" />
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center_vertical"
android:layout_marginLeft="20dp"
android:text="BlueMor"
android:textColor="#ffffff"
android:textSize="25sp" />
</LinearLayout>
<ListView
android:id="@+id/lv"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_below="@id/ll1"
android:layout_marginBottom="30dp"
android:layout_marginTop="20dp"
android:cacheColorHint="#00000000"
android:divider="@null"
android:textColor="#ffffff" />
</RelativeLayout>
<RelativeLayout
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="#eeeeee" >
<RelativeLayout
android:id="@+id/rl_title"
android:layout_width="match_parent"
android:layout_height="55dp"
android:background="#009990" >
<ImageView
android:id="@+id/iv_icon"
android:layout_width="42dp"
android:layout_height="42dp"
android:layout_centerVertical="true"
android:layout_marginLeft="10dp"
android:scaleType="centerCrop"
android:src="@drawable/ic_launcher" />
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerInParent="true"
android:text="系統相冊"
android:textColor="#ffffff"
android:textSize="20sp" />
</RelativeLayout>
<GridView
android:id="@+id/gv_img"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_below="@id/rl_title"
android:cacheColorHint="#00000000"
android:numColumns="4"
android:verticalSpacing="20dp" >
</GridView>
</RelativeLayout>
</com.bluemor.reddotface.view.DragLayout>

activity

[java] view plain copy

dl = (DragLayout) findViewById(R.id.dl);
dl.setOrientation(Orientation.Vertical);
// dl.setDragListener(new DragListener() {
// @Override
// public void onOpen() {
// lv.smoothScrollToPosition(new Random().nextInt(30));
// }
//
// @Override
// public void onClose() {
//
// }
//
// @Override
// public void onDrag(float percent) {
//
// }
// });

四、實戰3

例3：

ViewDragHelper一般用在一個自定義ViewGroup的內部，比如下面自定義了一個繼承於LinearLayout的DragLayout，DragLayout內部有一個子viewmDragView作爲成員變量：

[html] view plain copy

public class DragLayout extends LinearLayout {
private final ViewDragHelper mDragHelper;
private View mDragView;
public DragLayout(Context context) {
this(context, null);
}
public DragLayout(Context context, AttributeSet attrs) {
this(context, attrs, 0);
}
public DragLayout(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
}

創建一個帶有回調接口的ViewDragHelper

[html] view plain copy

public DragLayout(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
mDragHelper = ViewDragHelper.create(this, 1.0f, new DragHelperCallback());
}

其中1.0f是敏感度參數參數越大越敏感。第一個參數爲this，表示該類生成的對象，他是ViewDragHelper的拖動處理對象，必須爲ViewGroup。

要讓ViewDragHelper能夠處理拖動需要將觸摸事件傳遞給ViewDragHelper，這點和gesturedetector是一樣的：

[html] view plain copy

@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
final int action = MotionEventCompat.getActionMasked(ev);
if (action == MotionEvent.ACTION_CANCEL || action == MotionEvent.ACTION_UP) {
mDragHelper.cancel();
return false;
}
return mDragHelper.shouldInterceptTouchEvent(ev);
}
@Override
public boolean onTouchEvent(MotionEvent ev) {
mDragHelper.processTouchEvent(ev);
return true;
}

接下來，你就可以在回調中處理各種拖動行爲了。

2.拖動行爲的處理

處理橫向的拖動：

在DragHelperCallback中實現clampViewPositionHorizontal方法，並且返回一個適當的數值就能實現橫向拖動效果，clampViewPositionHorizontal的第二個參數是指當前拖動子view應該到達的x座標。所以按照常理這個方法原封返回第二個參數就可以了，但爲了讓被拖動的view遇到邊界之後就不在拖動，對返回的值做了更多的考慮。

@Override
public int clampViewPositionHorizontal(View child, int left, int dx) {
Log.d("DragLayout", "clampViewPositionHorizontal " + left + "," + dx);
final int leftBound = getPaddingLeft();
final int rightBound = getWidth() - mDragView.getWidth();
final int newLeft = Math.min(Math.max(left, leftBound), rightBound);
return newLeft;
}

同上，處理縱向的拖動：

在DragHelperCallback中實現clampViewPositionVertical方法，實現過程同clampViewPositionHorizontal

[html] view plain copy

@Override
public int clampViewPositionVertical(View child, int top, int dy) {
final int topBound = getPaddingTop();
final int bottomBound = getHeight() - mDragView.getHeight();
final int newTop = Math.min(Math.max(top, topBound), bottomBound);
return newTop;
}

clampViewPositionHorizontal 和 clampViewPositionVertical必須要重寫，因爲默認它返回的是0。事實上我們在這兩個方法中所能做的事情很有限。個人覺得這兩個方法的作用就是給了我們重新定義目的座標的機會。

通過DragHelperCallback的tryCaptureView方法的返回值可以決定一個parentview中哪個子view可以拖動，現在假設有兩個子views (mDragView1和mDragView2) ，如下實現tryCaptureView之後，則只有mDragView1是可以拖動的。

@Override

public boolean tryCaptureView(View child, int pointerId) {

returnchild == mDragView1;

}

滑動邊緣:

分爲滑動左邊緣還是右邊緣：EDGE_LEFT和EDGE_RIGHT，下面的代碼設置了可以處理滑動左邊緣：

[html] view plain copy

mDragHelper.setEdgeTrackingEnabled(ViewDragHelper.EDGE_LEFT);

假如如上設置，onEdgeTouched方法會在左邊緣滑動的時候被調用，這種情況下一般都是沒有和子view接觸的情況。

[html] view plain copy

@Override
public void onEdgeTouched(int edgeFlags, int pointerId) {
super.onEdgeTouched(edgeFlags, pointerId);
Toast.makeText(getContext(), "edgeTouched", Toast.LENGTH_SHORT).show();
}

如果你想在邊緣滑動的時候根據滑動距離移動一個子view，可以通過實現onEdgeDragStarted方法，並在onEdgeDragStarted方法中手動指定要移動的子View

[html] view plain copy

@Override
public void onEdgeDragStarted(int edgeFlags, int pointerId) {
mDragHelper.captureChildView(mDragView2, pointerId);
}

ViewDragHelper讓我們很容易實現一個類似於YouTube視頻瀏覽效果的控件，效果如下：

代碼中的關鍵點：

1.tryCaptureView返回了唯一可以被拖動的header view；

2.拖動範圍drag range的計算是在onLayout中完成的；

3.注意在onInterceptTouchEvent和onTouchEvent中使用的ViewDragHelper的若干方法；

4.在computeScroll中使用continueSettling方法（因爲ViewDragHelper使用了scroller）

5.smoothSlideViewTo方法來完成拖動結束後的慣性操作。

需要注意的是代碼仍然有很大改進空間。

activity_main.xml

[html] view plain copy

<FrameLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent">
<ListView
android:id="@+id/listView"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:tag="list"
/>
<com.example.vdh.YoutubeLayout
android:layout_width="match_parent"
android:layout_height="match_parent"
android:id="@+id/youtubeLayout"
android:orientation="vertical"
android:visibility="visible">
<TextView
android:id="@+id/viewHeader"
android:layout_width="match_parent"
android:layout_height="128dp"
android:fontFamily="sans-serif-thin"
android:textSize="25sp"
android:tag="text"
android:gravity="center"
android:textColor="@android:color/white"
android:background="#AD78CC"/>
<TextView
android:id="@+id/viewDesc"
android:tag="desc"
android:textSize="35sp"
android:gravity="center"
android:text="Loreum Loreum"
android:textColor="@android:color/white"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="#FF00FF"/>
</com.example.vdh.YoutubeLayout>
</FrameLayout>

YoutubeLayout.javaml] view plain copy

public class YoutubeLayout extends ViewGroup {
private final ViewDragHelper mDragHelper;
private View mHeaderView;
private View mDescView;
private float mInitialMotionX;
private float mInitialMotionY;
private int mDragRange;
private int mTop;
private float mDragOffset;
public YoutubeLayout(Context context) {
this(context, null);
}
public YoutubeLayout(Context context, AttributeSet attrs) {
this(context, attrs, 0);
}
@Override
protected void onFinishInflate() {
mHeaderView = findViewById(R.id.viewHeader);
mDescView = findViewById(R.id.viewDesc);
}
public YoutubeLayout(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
mDragHelper = ViewDragHelper.create(this, 1f, new DragHelperCallback());
}
public void maximize() {
smoothSlideTo(0f);
}
boolean smoothSlideTo(float slideOffset) {
final int topBound = getPaddingTop();
int y = (int) (topBound + slideOffset * mDragRange);
if (mDragHelper.smoothSlideViewTo(mHeaderView, mHeaderView.getLeft(), y)) {
ViewCompat.postInvalidateOnAnimation(this);
return true;
}
return false;
}
private class DragHelperCallback extends ViewDragHelper.Callback {
@Override
public boolean tryCaptureView(View child, int pointerId) {
return child == mHeaderView;
}
@Override
public void onViewPositionChanged(View changedView, int left, int top, int dx, int dy) {
mTop = top;
mDragOffset = (float) top / mDragRange;
mHeaderView.setPivotX(mHeaderView.getWidth());
mHeaderView.setPivotY(mHeaderView.getHeight());
mHeaderView.setScaleX(1 - mDragOffset / 2);
mHeaderView.setScaleY(1 - mDragOffset / 2);
mDescView.setAlpha(1 - mDragOffset);
requestLayout();
}
@Override
public void onViewReleased(View releasedChild, float xvel, float yvel) {
int top = getPaddingTop();
if (yvel > 0 || (yvel == 0 && mDragOffset > 0.5f)) {
top += mDragRange;
}
mDragHelper.settleCapturedViewAt(releasedChild.getLeft(), top);
}
@Override
public int getViewVerticalDragRange(View child) {
return mDragRange;
}
@Override
public int clampViewPositionVertical(View child, int top, int dy) {
final int topBound = getPaddingTop();
final int bottomBound = getHeight() - mHeaderView.getHeight() - mHeaderView.getPaddingBottom();
final int newTop = Math.min(Math.max(top, topBound), bottomBound);
return newTop;
}
}
@Override
public void computeScroll() {
if (mDragHelper.continueSettling(true)) {
ViewCompat.postInvalidateOnAnimation(this);
}
}
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
final int action = MotionEventCompat.getActionMasked(ev);
if (( action != MotionEvent.ACTION_DOWN)) {
mDragHelper.cancel();
return super.onInterceptTouchEvent(ev);
}
if (action == MotionEvent.ACTION_CANCEL || action == MotionEvent.ACTION_UP) {
mDragHelper.cancel();
return false;
}
final float x = ev.getX();
final float y = ev.getY();
boolean interceptTap = false;
switch (action) {
case MotionEvent.ACTION_DOWN: {
mInitialMotionX = x;
mInitialMotionY = y;
interceptTap = mDragHelper.isViewUnder(mHeaderView, (int) x, (int) y);
break;
}
case MotionEvent.ACTION_MOVE: {
final float adx = Math.abs(x - mInitialMotionX);
final float ady = Math.abs(y - mInitialMotionY);
final int slop = mDragHelper.getTouchSlop();
if (ady > slop && adx > ady) {
mDragHelper.cancel();
return false;
}
}
}
return mDragHelper.shouldInterceptTouchEvent(ev) || interceptTap;
}
@Override
public boolean onTouchEvent(MotionEvent ev) {
mDragHelper.processTouchEvent(ev);
final int action = ev.getAction();
final float x = ev.getX();
final float y = ev.getY();
boolean isHeaderViewUnder = mDragHelper.isViewUnder(mHeaderView, (int) x, (int) y);
switch (action & MotionEventCompat.ACTION_MASK) {
case MotionEvent.ACTION_DOWN: {
mInitialMotionX = x;
mInitialMotionY = y;
break;
}
case MotionEvent.ACTION_UP: {
final float dx = x - mInitialMotionX;
final float dy = y - mInitialMotionY;
final int slop = mDragHelper.getTouchSlop();
if (dx * dx + dy * dy < slop * slop && isHeaderViewUnder) {
if (mDragOffset == 0) {
smoothSlideTo(1f);
} else {
smoothSlideTo(0f);
}
}
break;
}
}
return isHeaderViewUnder && isViewHit(mHeaderView, (int) x, (int) y) || isViewHit(mDescView, (int) x, (int) y);
}
private boolean isViewHit(View view, int x, int y) {
int[] viewLocation = new int[2];
view.getLocationOnScreen(viewLocation);
int[] parentLocation = new int[2];
this.getLocationOnScreen(parentLocation);
int screenX = parentLocation[0] + x;
int screenY = parentLocation[1] + y;
return screenX >= viewLocation[0] && screenX < viewLocation[0] + view.getWidth() &&
screenY >= viewLocation[1] && screenY < viewLocation[1] + view.getHeight();
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
measureChildren(widthMeasureSpec, heightMeasureSpec);
int maxWidth = MeasureSpec.getSize(widthMeasureSpec);
int maxHeight = MeasureSpec.getSize(heightMeasureSpec);
setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, 0),
resolveSizeAndState(maxHeight, heightMeasureSpec, 0));
}
@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
mDragRange = getHeight() - mHeaderView.getHeight();
mHeaderView.layout(
0,
mTop,
r,
mTop + mHeaderView.getMeasuredHeight());
mDescView.layout(
0,
mTop + mHeaderView.getMeasuredHeight(),
r,
mTop + b);
}

代碼下載地址：https://github.com/flavienlaurent/flavienlaurent.com

不管是menudrawer 還是本文實現的DragLayout都體現了一種設計哲學，即可拖動的控件都是封裝在一個自定義的Layout中的，爲什麼這樣做？爲什麼不直接將ViewDragHelper.create(this, 1f, new DragHelperCallback())中的this替換成任何已經佈局好的容器，這樣這個容器中的子View就能被拖動了，而往往是單獨定義一個Layout來處理?個人認爲如果在一般的佈局中去拖動子view並不會出現什麼問題，只是原本規則的世界被打亂了，而單獨一個Layout來完成拖動，無非是說，他本來就沒有什麼規則可言，拖動一下也無妨。

參考：http://www.xuebuyuan.com/2225442.html

http://blog.csdn.net/pi9nc/article/details/39583377

https://software.intel.com/zh-cn/blogs/2015/03/05/android-zlistview-listview-0

本文轉載自：http://blog.csdn.net/l25000/article/details/46345051#reply；