1.view的滑动，六种滑动方式：
一：通过layout来实现滑动效果
package com.example.testdragview;
import android.content.Context;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;
public class DragView extends View{
private int lastX;
private int lastY;
public DragView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
}
public DragView(Context context, AttributeSet attrs) {
super(context, attrs);
}
public DragView(Context context) {
super(context);
}
public boolean onTouchEvent(MotionEvent event) {
// Log.d("付勇焜----->","TouchEvent");
// Log.d("付勇焜----->",super.onTouchEvent(event)+"");
//获取到手指处的横坐标和纵坐标
int x = (int) event.getX();
int y = (int) event.getY();
switch(event.getAction())
{
case MotionEvent.ACTION_DOWN:
lastX = x;
lastY = y;
break;
case MotionEvent.ACTION_MOVE:
//计算移动的距离
int offX = x - lastX;
int offY = y - lastY;
//调用layout方法来重新放置它的位置
layout(getLeft()+offX, getTop()+offY,
getRight()+offX , getBottom()+offY);
break;
}
return true;
}
}
二、offsetLeftAndRight()和offsetTopAndBottom()方法来实现
其实这两个方法分别是对左右移动和上下移动的封装，传入的就是偏移量。此时将DragView中的onTouchEvent代码简单替换即可，如下：
1 public boolean onTouchEvent(MotionEvent event) {
2
3 //获取到手指处的横坐标和纵坐标
4 int x = (int) event.getX();
5 int y = (int) event.getY();
6
7 switch(event.getAction())
8 {
9 case MotionEvent.ACTION_DOWN:
10
11 lastX = x;
12 lastY = y;
13
14 break;
15
16 case MotionEvent.ACTION_MOVE:
17
18 //计算移动的距离
19 int offX = x - lastX;
20 int offY = y - lastY;
21
22 offsetLeftAndRight(offX);
23 offsetTopAndBottom(offY);
24
25 break;
26 }
27
28 return true;
29 }
红色部分就是关键代码了，运行一下程序，跟上面的效果是一样的，不再贴图。
三、使用LayoutParams来实现
依旧修改DragView的onTouchEvent代码，如下：
1 public boolean onTouchEvent(MotionEvent event) {
2
3 //获取到手指处的横坐标和纵坐标
4 int x = (int) event.getX();
5 int y = (int) event.getY();
6
7 switch(event.getAction())
8 {
9 case MotionEvent.ACTION_DOWN:
10
11 lastX = x;
12 lastY = y;
13
14 break;
15
16 case MotionEvent.ACTION_MOVE:
17
18 //计算移动的距离
19 int offX = x - lastX;
20 int offY = y - lastY;
21
22 ViewGroup.MarginLayoutParams mlp =
23 (MarginLayoutParams) getLayoutParams();
24
25 mlp.leftMargin = getLeft()+offX;
26 mlp.topMargin = getTop()+offY;
27
28 setLayoutParams(mlp);
29
30 break;
31 }
32
33 return true;
34 }
红色部分依旧是关键代码。注意这里我们一般通过改变view的Margin属性来改变其位置的。
运行程序，结果依旧，不再贴图。
四、通过scrollTo和scrollBy方法，不是弹性滑动，感觉会很突兀
在一个view中，系统也提供了scrollTo和scrollBy方法来移动view。很好理解，sceollTo(x,y)传入的应该是移动的终点坐标，而scrollBy(dx,dy)传入的是
移动的增量。这两个方法要在view所在的viewGroup中使用！但是一定要注意：通过scrollBy传入的值应该是你需要的那个增量的相反数！这样子才能达到你想
要的效果！！切记切记
依旧是hi修改DragView的onTouchEvent代码，如下：
public boolean onTouchEvent(MotionEvent event) {
//获取到手指处的横坐标和纵坐标
int x = (int) event.getX();
int y = (int) event.getY();
switch(event.getAction())
{
case MotionEvent.ACTION_DOWN:
lastX = x;
lastY = y;
break;
case MotionEvent.ACTION_MOVE:
//计算移动的距离
int offX = x - lastX;
int offY = y - lastY;
((View) getParent()).scrollBy(-offX,- offY);
break;
}
return true;
}
五.使用Scroller来实现弹性滑动
上面我们提到了使用scrollTo/scrollBy方法实现View的滑动效果不是平滑的，好消息是我们可以使用Scroller方法来辅助实现View的弹性滑动。使用Scroller实现弹性滑动的惯用代码如下：
1 Scroller scroller = new Scroller(mContext); 2 3 private void smoothScrollTo(int dstX, int dstY) { 4 int scrollX = getScrollX(); 5 int delta = dstX - scrollX; 6 scroller.startScroll(scrollX, 0, delta, 0, 1000); 7 invalidate(); 8 } 9 10 @Override 11 public void computeScroll() { 12 if (scroller.computeScrollOffset()) { 13 scrollTo(scroller.getCurrX(), scroller.getCurY()); 14 postInvalidate(); 15 } 16 }
我们来看一下以上的代码。第4行中，我们获取到View的mScrollX参数并存到scrollX变量中。然后在第5行计算要滑动的位移量。第6行调用了startScroll方法，我们来看看startScroll方法的源码：
1 public void startScroll(int startX, int startY, int dx, int dy, int duration) { 2 mMode = SCROLL_MODE; 3 mFinished = false; 4 mDuration = duration; 5 mStartTime = AnimationUtils.currentAnimationTimeMillis(); 6 mStartX = startX; 7 mStartY = startY; 8 mFinalX = startX + dx; 9 mFinalY = startY + dy; 10 mDeltaX = dx; 11 mDeltaY = dy; 12 mDurationReciprocal = 1.0f / (float) mDuration; 13 14 mViscousFluidScale = 8.0f; 15 16 mViscousFluidNormalize = 1.0f; 17 mViscousFluidNormalize = 1.0f / viscousFluid(1.0f); 18 }
从以上的源码我们可以看到，startScroll方法中并没有进行实际的滚动操作，而是把startX、startY、deltaX、deltaY等参数都保存了下来。那么究竟怎么实现View的滑动的呢？我们先回到Scroller惯用代码。我们看到第7行调用了invalidate方法，这个方法会请求重绘View，这会导致View的draw的方法被调用，draw的方法内部会调用computeScroll方法。我们来看看第13行，调用了scrollTo方法，并传入mScroller.getCurrX()和mScroller.getCurrY()方法作为参数。那么获取到的这两个参数是什么呢？这两个参数是在第12行调用的computeScrollOffset方法中设置的，我们来看看这个方法中设置这两个参数的相关代码：
1 public boolean computeScrollOffset() { 2 ... 3 int timePassed = (int) (AnimationUtils.currentAnimationTimeMillis() - mStartTime); 4 if (timePassed < mDuration) { 5 switch (mMode) { 6 case SCROLL_MODE: 7 final float x = mInterpolator.getInterpolation(timePassed * mDurationReciprocal); 8 mCurrX = mStartX + Math.round(x * mDeltaX); 9 mCurrY = mStartY + Math.rounc(y * mDeltaY); 10 break; 11 ... 12 } 13 } 14 return true; 15 }
以上代码中第8行和第9行设置的mCurrX和mCurrY即为以上scrollTo的两个参数，表示本次滑动的目标位置。computeScrollOffset方法返回true表示滑动过程还未结束，否则表示结束。
通过以上的分析，我们大概了解了Scroller实现弹性滑动的原理：invaldate方法会导致View的draw方法被调用，而draw会调用computeScroll方法，因此重写了computeScroll方法，而computeScrollOffset方法会根据时间的流逝动态的计算出很小的一段时间应该滑动多少距离。也就是把一次滑动拆分成无数次小距离滑动从而实现“弹性滑动”。
六.使用动画来实现滑动
使用动画来实现View的滑动主要通过改变View的translationX和translationY参数来实现，使用动画的好处在于滑动效果是平滑的。上面我们提到过，View的x、y参数决定View的当前位置，通过改变translationX和translationY，我们就可以改变View的当前位置。我们可以使用属性动画或者补间动画来实现View的平移。
首先，我们先来看一下如何使用补间动画来实现View的平移。补间动画资源定义如下（anim.xml):
<?xml version="1.0" encoding="utf-8"?> <set xmlns:android="http://schemas.android.com/apk/res/android" android:fillAfter="true"> <translate android:duration="100" android:fromXDelta="0" android:fromYDelta="0" android:interpolator="@android:anim/linear_interpolator" android:toXDelta="100" android:toYDelta="100"/> </set>
然后在onCreat方法中调用startAnimation方法即可。使用补间动画实现View的滑动有一个缺陷，那就是移动的知识View的“影像”，这意味着其实View并未真正的移动，只是我们看起来它移动了而已。拿Button来举例，假若我们通过补间动画移动了一个Button，我们会发现，在Button的原来位置点击屏幕会出发点击事件，而在移动后的Button上点击不会触发点击事件。
接下来，我们看看如何用属性动画来实现View的平移。使用属性动画实现View的平移更加简单，只需要以下一条语句：
ObjectAnimator.ofFloat(targetView, "translationX", 0, 100).setDuration(100).start();以上代码即实现了使用属性动画把targetView在100ms内向右平移100px。使用属性动画的限制在于真正的属性动画只可以在Android 3.0+使用（一些第三方库实现的兼容低版本的属性动画不是真正的属性动画），优点就是它可以真正的移动View而不是仅仅移动View的影像。
经过以上的描述，使用属性动画实现View的滑动看起来是个不错的选择，而且一些View的复杂的滑动效果只有通过动画才能比较方便的实现。
2.View的滑动冲突
在Android开发中，如果是一些简单的布局，都很容易搞定，但是一旦涉及到复杂的页面，特别是为了兼容小屏手机而使用了ScrollView以后，就会出现很多点击事件的冲突，最经典的就是ScrollView中嵌套了ListView。我想大部分刚开始接触Android的同学们都踩到过这个坑，下面跟着小编一起来看看解决方案吧。。
同方向滑动冲突
比如ScrollView嵌套ListView，或者是ScrollView嵌套自己
这里先看一张效果图
上图是在购物软件上常见的上拉查看图文详情，关于这中动画效果的实现，其实实现整体的效果，办法是有很多的，网上有很多相关的例子，但是对某些细节的处理不是很清晰，比如，下拉之后显示的部分（例如底部的图文详情）又是一个类ScrollView的控件（比如WebView）的话，又会产生新的问题。这里就以下拉查看图文详情为背景做一下同方向滑动冲突的分析。
整体思路
这里看下图
java和
.NET开发,SEO,SEM,电商,互动营销等 软件开发、网络营销等专业,学完推荐就业查 看
多个ScrollView嵌套示意图
首先，关于这张图做一些设定：
1.黑色的框代表手机屏幕
2.绿色的框代表一个外层的ScrollView
3.两个红色的框代表嵌套在里面的两个类ScrollView控件，这里我们就暂时简称为 SUp,SDown
好了，接下来就分析一下实现整个流程的过程。
这里必须明确的一点，无论何时，SUp和SDown可见的部分始终是手机屏幕的高度。知道了这一点，我们就可以按以下步骤展开
首先，我们确保外部的ScrollView不拦截滑动事件，这样SUp必然获得此次事件，然后根据其Action_Move事件，当其为向下滑动且自身滑动距离+屏幕高度=其自身高度 时，即可认为SUp滑动到了底部，此时外部ScrollView可拦截滑动事件，从而保证整个视图能够继续向下滑动，这个时候底部SDown就显示出来了。
同理，这时候不允许外部ScrollView拦截滑动事件，由SDown处理，根据其Action_move事件，当其为向上滑动，且自身可滑动距离为0时，就说明SDown已经滑动到了顶部，这时外部ScrollView又可以获得拦截滑动事件的权利，从而保证整个视图能够向上继续滑动，此时SUp再次显示，又开始新一轮循环拦截。
这样整体的一个流程就可以实现动图中的效果。好了，说完原理，还是看代码。
代码实现
SUp实现
12
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
public
class
UpScrollViewextends
ScrollView {
/**
*
屏幕高度
*/
private
int
mScreenHeight;
/**
*
上一次的坐标
*/
private
float
mLastY;
/**
*
当前View滑动距离
*/
private
int
mScrollY;
/**
*
当前View内子控件高度
*/
private
int
mChildH;
public
UpScrollView(Context context) {
super(context);
init(context);
}
public
UpScrollView(Context context, AttributeSet attrs) {
super(context,
attrs);
init(context);
}
public
UpScrollView(Context context, AttributeSet attrs,int
defStyleAttr) {
super(context,
attrs, defStyleAttr);
init(context);
}
private
void
init(Context context) {
WindowManager
wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
DisplayMetrics
dm =new
DisplayMetrics();
wm.getDefaultDisplay().getMetrics(dm);
mScreenHeight
= dm.heightPixels;
}
@Override
public
boolean
onTouchEvent(MotionEvent ev) {
//默认设定顶层View不拦截
getParent().getParent().requestDisallowInterceptTouchEvent(true);
switch
(ev.getAction()) {
case
MotionEvent.ACTION_DOWN:
mLastY
= (int)
ev.getY();
break;
case
MotionEvent.ACTION_MOVE:
float
y = ev.getY();
float
deltaY = y - mLastY;
mChildH
=this.getChildAt(0).getMeasuredHeight();
int
translateY = mChildH - mScrollY;
//向上滑动时，如果translateY等于屏幕高度时，即表明滑动到底部，可又顶层View控制滑动
if
(deltaY <0
&& translateY == mScreenHeight) {
getParent().getParent().requestDisallowInterceptTouchEvent(false);
}
break;
default:
break;
}
return
super.onTouchEvent(ev);
}
@Override
protected
void
onScrollChanged(int
l,int
t,int
oldl,int
oldt) {
super.onScrollChanged(l,
t, oldl, oldt);
mScrollY
= t;
}
}这里在ACTION_MOVE里做了减法，其实道理是一样的。
onScrollChanged 是在View类中实现，查看其API可以看到其第二个参数t解释
1
@param
t Current vertical scroll origin.即为当前View此次滑动的距离
SDown实现
12
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
public
class
MyWebViewextends
WebView {
public
float
oldY;
private
int
t;
public
MyWebView(Context context) {
super(context);
init();
}
public
MyWebView(Context context, AttributeSet attrs) {
super(context,
attrs);
init();
}
public
MyWebView(Context context, AttributeSet attrs,int
defStyleAttr) {
super(context,
attrs, defStyleAttr);
init();
}
private
void
init() {
WebSettings
settings = getSettings();
settings.setJavaScriptEnabled(true);
setWebViewClient(new
WebViewClient() {
@Override
public
boolean
shouldOverrideUrlLoading(WebView view, String url) {
view.loadUrl(url);
return
true;
}
});
}
@Override
public
boolean
onTouchEvent(MotionEvent ev) {
getParent().getParent().requestDisallowInterceptTouchEvent(true);
switch
(ev.getAction()) {
case
MotionEvent.ACTION_DOWN:
oldY
= ev.getY();
break;
case
MotionEvent.ACTION_MOVE:
float
Y = ev.getY();
float
Ys = Y - oldY;
if
(Ys >0
&& t ==0)
{
getParent().getParent().requestDisallowInterceptTouchEvent(false);
}
break;
}
return
super.onTouchEvent(ev);
}
@Override
protected
void
onScrollChanged(int
l,int
t,int
oldl,int
oldt) {
this.t
= t;
super.onScrollChanged(l,
t, oldl, oldt);
}
}以上看到，这里底部的View并没有继承ScrollView，而是选择继承了WebView，这里只是为了方便，当然继承ScrollView也是没有问题。这里只是需要按实际情况考虑，因为底部图文详情的内容就是一个WebView加载数据。
这个类的实现，按照之前说的原理应该很好理解。
外部ScrollView
12
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
public
class
CustomerScrollViewsextends
ScrollView {
/**
*
屏幕高度
*/
private
int
mScreenHeight;
private
UpScrollView upScrollView;
private
MyWebView myWebView;
private
boolean
init =false;
private
float
fator =0.2f;
private
int
factorHeight;
private
boolean
upShow =true;
public
CustomerScrollViews(Context context) {
super(context);
init(context);
}
public
CustomerScrollViews(Context context, AttributeSet attrs) {
super(context,
attrs);
init(context);
}
public
CustomerScrollViews(Context context, AttributeSet attrs,int
defStyleAttr) {
super(context,
attrs, defStyleAttr);
init(context);
}
private
void
init(Context context) {
WindowManager
wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
DisplayMetrics
dm =new
DisplayMetrics();
wm.getDefaultDisplay().getMetrics(dm);
mScreenHeight
= dm.heightPixels;
factorHeight
= (int)
(mScreenHeight * fator);
}
@Override
protected
void
onMeasure(int
widthMeasureSpec,int
heightMeasureSpec) {
if
(!init) {
LinearLayout
parentView = (LinearLayout) getChildAt(0);
//获得内部的两个子view
upScrollView
= (UpScrollView) parentView.getChildAt(0);
myWebView
= (MyWebView) parentView.getChildAt(2);
//
//并设定其高度为屏幕高度
upScrollView.getLayoutParams().height
= mScreenHeight;
myWebView.getLayoutParams().height
= mScreenHeight;
init
=true;
}
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);
if
(changed) {
scrollTo(0,
0);
}
}
@Override
public
boolean
onTouchEvent(MotionEvent ev) {
switch
(ev.getAction()) {
case
MotionEvent.ACTION_UP:
int
scrollY = getScrollY();
if
(upShow) {
if
(scrollY <= factorHeight) {
smoothScrollTo(0,
0);
}
else
{
smoothScrollTo(0,
mScreenHeight);
upShow
=false;
}
}
else
{
int
scrollpadding = mScreenHeight - scrollY;
if
(scrollpadding >= factorHeight) {
this.smoothScrollTo(0,
0);
upShow
=true;
}
else
{
this.smoothScrollTo(0,
mScreenHeight);
}
}
return
true;
}
return
super.onTouchEvent(ev);
}
}这个类的实现，就很灵活了，在onMeasure方法中初始化完内部的View之后，在OnTouch方法中就可以根据实际需求完成不同的逻辑实现，这里只是为了仿照查看图文详情的效果，对整个视图通过ScrollView的smoothScrollTo方法进行位移变化，这个逻辑很简单。
这里重点说一下一个地方：
12
upScrollView
= (UpScrollView) parentView.getChildAt(0);
myWebView
= (MyWebView) parentView.getChildAt(2);你可能会奇怪中间的child(1)去了哪里？这里还要从MainActivity的布局文件说起
dual_scrollview_activity_layout1.xml
12
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
<?xml
version="1.0"
encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical">
<com.example.dreamwork.activity.superscrollview.CustomerScrollViews
android:layout_width="match_parent"
android:layout_height="match_parent">
<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="vertical">
<com.example.dreamwork.activity.superscrollview.UpScrollView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:scrollbars="vertical">
<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="vertical">
<ImageView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:scaleType="fitXY"
android:src="@drawable/taobao"
/>
<ImageView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:scaleType="fitXY"
android:src="@drawable/taobao"
/>
<TextView
android:textSize="20sp"
android:padding="10dp"
android:gravity="center"
android:layout_marginTop="20dp"
android:layout_marginBottom="60dp"
android:text="查看图文详情"
android:layout_width="match_parent"
android:layout_height="wrap_content"
/>
</LinearLayout>
</com.example.dreamwork.activity.superscrollview.UpScrollView>
<include
layout="@layout/selector_tab_items"
/>
<com.example.dreamwork.activity.superscrollview.MyWebView
android:id="@+id/web"
android:layout_width="match_parent"
android:layout_height="match_parent"/>
</LinearLayout>
</com.example.dreamwork.activity.superscrollview.CustomerScrollViews>
</LinearLayout>整个布局文件可以看出，我们在CustomerScrollViews这个最外层的自定义ScrollView内部又放置了两个自定义的ScrollView（就如我们看到的原理图那样），只不过在这两个ScrollView类控件的中间通过layout又放置一个LinearLayout，里面的内容就是在动图中看到的那个中间的写着qq,baidu字样的用于切换WebView内容的一个View。这里就不贴代码了。
这样，你就可以理解之前的child(1)为什么被跳过了吧。
使用
12
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
public
class
DualScrollViewActivity1extends
Activityimplements
View.OnClickListener {
private
MyWebView webView;
private
TextView sinaTv, qqTv, baiduTv;
private
View line1, line2, line3;
private
final
String BAIDU ="http://www.baidu.com";
private
final
String QQ ="http://www.qq.com";
private
final
String SINA ="http://sina.cn";
@Override
protected
void
onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_NO_TITLE);
InitView();
sinaTv.performClick();
}
private
void
InitView() {
setContentView(R.layout.dual_scrollview_activity_layout1);
webView
= V.f(this,
R.id.web);
sinaTv
= V.f(this,
R.id.one);
sinaTv.setOnClickListener(this);
qqTv
= V.f(this,
R.id.two);
qqTv.setOnClickListener(this);
baiduTv
= V.f(this,
R.id.three);
baiduTv.setOnClickListener(this);
line1
= V.f(this,
R.id.line1);
line2
= V.f(this,
R.id.line2);
line3
= V.f(this,
R.id.line3);
}
@Override
public
void
onClick(View v) {
reset();
String
url ="";
switch
(v.getId()) {
case
R.id.one:
line1.setVisibility(View.VISIBLE);
url
= SINA;
break;
case
R.id.two:
line2.setVisibility(View.VISIBLE);
url
= QQ;
break;
case
R.id.three:
line3.setVisibility(View.VISIBLE);
url
= BAIDU;
break;
default:
break;
}
webView.loadUrl(url);
}
private
void
reset(){
line1.setVisibility(View.GONE);
line2.setVisibility(View.GONE);
line3.setVisibility(View.GONE);
}
}关于底部View内容更新，WebView 通过加载不同URL实现不同视图效果，只是作为Demo测试，实际中应考虑通过fragment切换实现。
这里对滑动冲突的解决方法，是由内而外的展开，默认使顶层View失去拦截能力，在由底部View的滑动距离，做出不同逻辑判断控制了顶层的拦截与否；这也是比较容易理解和实现的思路。当然，对于此类滑动冲突，有很多不同思路，这里只是列举其一。
实际开发开发中，这种带有同方向滑动特性的控件嵌套时，产生的问题不只是滑动冲突，有时候会有内容显示不全或不显示的情况。
最常见如ScrollView嵌套ListView，这种情况只需自定义ListView使其高度计算为一个很大的值，某种意义上让其失去了滑动的特性，但是这样也让ListView貌似失去了视图回收机制，这种时候如果加载很多很多很多图片，效果就会很不理想。对于这种情况，通过对ListView添加headView及footView也是一种解决的办法，但也得实际UI情况允许。
ScrollView嵌套RecyclerView时稍微麻烦一点，需要自定义ScrollView，还需要自定义实现LinearLayoutManager。
不同方向滑动冲突
比如ScrollView嵌套ViewPager，或者是ViewPager嵌套ScrollView，这种情况其实很典型。现在大部分应用最外层都是ViewPager+Fragment 的底部切换（比如微信）结构，这种时候，就很容易出现滑动冲突。不过ViewPager里面无论是嵌套ListView还是ScrollView，滑动冲突是没有的，毕竟是官方的东西，可能已经考虑到了这些，所以比较完善。
复杂一点的滑动冲突，基本上就是这两个冲突结合的结果。
滑动冲突解决思路
滑动冲突，就其本质来说，两个不同方向（或者是同方向）的View，其中有一个是占主导地位的，每次总是抢着去处理外界的滑动行为，这样就导致一种很别扭的用户体验，明明只是横向的滑动了一下，纵向的列表却在垂直方向发生了动作。就是说，这个占主导地位的View，每一次都身不由己的拦截了这个滑动的动作，因此，要解决滑动冲突，就是得明确告诉这个占主导地位的View，什么时候你该拦截，什么时候你不应该拦截，应该由下一层的View去处理这个滑动动作。
这里不明白的同学，可以去了解一下Android Touch事件的分发机制，这也是解决滑动冲突的核心知识。
滑动冲突
这里，说一下背景情况。之前做下拉刷新、上拉加载更多时一直使用的是PullToRefreshView这个控件，因为很方便，不用导入三方工程。在其内部可以放置ListView，GridView及ScrollView，非常方便，用起来可谓是屡试不爽。但是直到有一天，因项目需要，在ListView顶部加了一个轮播图控件BannerView（这个可以参考之前写的一篇学习笔记）。结果发现轮播图滑动的时候，和纵向的下拉刷新组件冲突了。
如之前所说，解决滑动冲突的关键，就是明确告知接收到Touch的View，是否需要拦截此次事件。
解决方法
解决方案1，从外部拦截机制考虑
这里，相当于是PullToRefreshView嵌套了ViewPager，那么每次优先接收到Touch事件的必然是PullToRefreshView。这样就清楚了，看代码：
在PullToRefreshView中：
12
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
@Override
public
boolean
onInterceptTouchEvent(MotionEvent e) {
int
y = (int)
e.getRawY();
int
x = (int)
e.getRawX();
boolean
resume =false;
switch
(e.getAction()) {
case
MotionEvent.ACTION_DOWN:
//
发生down事件时,记录y坐标
mLastMotionY
= y;
mLastMotionX
= x;
resume
=false;
break;
case
MotionEvent.ACTION_MOVE:
//
deltaY > 0 是向下运动,< 0是向上运动
int
deltaY = y - mLastMotionY;
int
deleaX = x - mLastMotionX;
if
(Math.abs(deleaX) > Math.abs(deltaY)) {
resume
=false;
}
else
{
//当前正处于滑动
if
(isRefreshViewScroll(deltaY)) {
resume
=true;
}
}
break;
case
MotionEvent.ACTION_UP:
case
MotionEvent.ACTION_CANCEL:
break;
}
return
resume;
}这里最关键的代码就是这行
12
3
if
(Math.abs(deleaX) > Math.abs(deltaY)) {
resume
=false;
}横向滑动距离大于纵向时，无须拦截这次滑动事件。其实，就是这么简单，但前提是你必须明确了解Android Touch事件的传递机制，期间各个方法执行的顺序及意义。
解决方案2，从内容逆向思维分析
有时候，我们不想去修改引入的第三方控件，或者说是无法修改时。就必须考虑从当前从Touch传递事件中最后的那个View逆向考虑。首先，由Android中View的Touch事件传递机制，我们知道Touch事件，首先必然由最外层View拦截，如果无法更改这个最外层View，那么是不是就没辙了呢？其实不然，Android这么高大上的系统必然考虑到了这个问题，好了废话不说，先看代码
12
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
private
BannerView carouselView;
private
Context mContext;
private
PullToRefreshView refreshView;
.........
refreshView.setOnTouchListener(new
View.OnTouchListener() {
@Override
public
boolean
onTouch(View v, MotionEvent event) {
carouselView.getParent().requestDisallowInterceptTouchEvent(false);
return
false;
}
});
carouselView.setOnTouchListener(new
View.OnTouchListener() {
@Override
public
boolean
onTouch(View v, MotionEvent event) {
carouselView.getParent().requestDisallowInterceptTouchEvent(true);
int
x = (int)
event.getRawX();
int
y = (int)
event.getRawY();
switch
(event.getAction()) {
case
MotionEvent.ACTION_DOWN:
lastX
= x;
lastY
= y;
break;
case
MotionEvent.ACTION_MOVE:
int
deltaY = y - lastY;
int
deltaX = x - lastX;
if
(Math.abs(deltaX) < Math.abs(deltaY)) {
carouselView.getParent().requestDisallowInterceptTouchEvent(false);
}
else
{
carouselView.getParent().requestDisallowInterceptTouchEvent(true);
}
default:
break;
}
return
false;
}
});首先说一下这个方法
1
public
abstract
void
requestDisallowInterceptTouchEvent (boolean
disallowIntercept)API里的意思很明确，子View如果不希望其父View拦截Touch事件时，可调用此方法。当disallowIntercept这个参数为true时，父View将不拦截。
PS:这个方法的命名和其参数的使用逻辑，让我想到了一句很有意思的话，敌人的敌人就是朋友，真不知道Google的大神们怎么想的，非要搞一个反逻辑。
言归正传。这里拦截直接也很明确，在carouselView的onTouch方法中每次进入就设定父View不拦截此次事件，然后在MOTION_MOVE时候，根据滑动的距离判断再决定是父View是否有权利拦截Touch事件（即滑动行为）。
总结
好了，本文内容到这基本就结束了，本篇文章只是提供一种解决方法的思路，在具体的场景下，交互往往是贴合具体业务需求的。但是不管怎么样，找出点击事件截断和处理的时机是最重要的，围绕这个关键点，总能找出相应的解决方法。
