从ScrollView嵌套EditText的滑动事件冲突分析触摸事件的分发机制以及TextView的简要实现和冲突的解决办法

本篇文章假设读者没有任何的触摸事件基础知识，所以我们会从最基本的触摸事件分发处说起。

ScrollView为什么会出现嵌套EditText出现滑动事件冲突呢？相信你会有这种疑问，我们来看这么一种情况：

有一个固定高度的EditText，假设它只能显示3行文本，但是，我们在其中输入的文本多余三行时，那么这时就需要可以在EditText内部进行小幅滚动了。那么将这个EditText放入了ScrollView当中， 并且ScrollView内容过多以致ScrollView也可以滑动，这时候就会出现EditText不能滑动的现象。就像下面这张图所示：

上图中，EditText文本的高度已经超出了EditText本身的高度，所以这时EditText应该是可以滑动的，但是由于被放入到了可滑动的ScrollView当中，那么EditText的触摸事件就被屏蔽掉了。我们接下里以非常详细的过程细说触摸事件的分发机制以及这种滑动事件的处理办法。

我们分析的入口是ScrollView的dispatchTouchEvent方法，为什么入口在这里呢，因为该方法是View触摸事件的第一个入口。

由于ScrollView没有重写dispatchTouchEvent，所以我们找到其父类的实现是在ViewGroup当中：

[java]  view plain  copy

 

1. public boolean dispatchTouchEvent(MotionEvent ev) {  
2.   
3.     ...  
4.   
5.     boolean handled = false;  
6.     if (onFilterTouchEventForSecurity(ev)) {  
7.         final int action = ev.getAction();  
8.         final int actionMasked = action & MotionEvent.ACTION_MASK;  
9.   
10.         ...  
11.   
12.         // Check for interception.  
13.         final boolean intercepted;  
14.         if (actionMasked == MotionEvent.ACTION_DOWN  
15.                 || mFirstTouchTarget != null) {  
16.             final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;  
17.             if (!disallowIntercept) {  
18.                 intercepted = onInterceptTouchEvent(ev);  
19.                 ev.setAction(action); // restore action in case it was changed  
20.             } else {  
21.                 intercepted = false;  
22.             }  
23.         } else {  
24.             intercepted = true;  
25.         }  
26.   
27.         ...  
28.         if (!canceled && !intercepted) {  
29.   
30.             ...  
31.   
32.             if (actionMasked == MotionEvent.ACTION_DOWN  
33.                     || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)  
34.                     || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {  
35.   
36.                 ...  
37.   
38.                 final int childrenCount = mChildrenCount;  
39.                 if (newTouchTarget == null && childrenCount != 0) {  
40.   
41.                     ...  
42.   
43.                     final View[] children = mChildren;  
44.                     for (int i = childrenCount - 1; i >= 0; i--) {  
45.   
46.                         ...  
47.   
48.                         if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {  
49.   
50.                             ...  
51.   
52.                             newTouchTarget = addTouchTarget(child, idBitsToAssign);  
53.                             alreadyDispatchedToNewTouchTarget = true;  
54.                             break;  
55.                         }  
56.   
57.    ...  
58.   
59.                     }  
60.                 }  
61.   
62.   ...  
63.   
64.             }  
65.         }  
66.   
67.         ...  
68.   
69.     }  
70.   
71.     ...  
72.   
73.     return handled;  
74. }  

这里代码不少，我们挑重点部分看：

上图中，在dispatchTouchEvent中发现了在调用onInterceptTouchEvent方法，而onInterceptTouchEvent方法的触发是有条件的：ACTION_DOWN事件或者mFirstTouchTarget != null，并且设置的disallowIntercept为false。

所以，当我们先触发按下事件时，无论是按到了EditText还是ScrollView，那么首先会调用ScrollView的onInterceptTouchEvent方法，为什么我这么肯定呢，难道disallowIntercept不会被置为true吗？因为在每次按下事件触发时，所有的状态都会被初始化，就算是子View提前请求disallowIntercept为true，那么在每次按下时也会被重置为false。

继续往下，程序会执行到这里：

其中，dispatchTransformedTouchEvent方法会调用每一个子View的dispatchTouchEvent方法，来询问子View是否会处理这次事件。如果子View表示要处理，那么这次事件的目标View就是该子View，那么这里mFirstTouchTarget就会指向这个View，由上面的代码可知，接下来的事件都会询问ScrollView是否要拦截，如果子View没有要求不拦截的话。

这时，这次的按下事件就被传入到了EditText的dispatchTouchEvent中去，由于EditText没有重写dispatchTouchEvent，所以这次调用会在View的dispatchTouchEvent方法中进行：

[java]  view plain  copy

 

1. public boolean dispatchTouchEvent(MotionEvent event) {  
2.       
3.   
4.   
5.     if (onFilterTouchEventForSecurity(event)) {  
6.         ListenerInfo li = mListenerInfo;  
7.         if (li != null && li.mOnTouchListener != null  
8.                 && (mViewFlags & ENABLED_MASK) == ENABLED  
9.                 && li.mOnTouchListener.onTouch(this, event)) {  
10.             result = true;  
11.         }  
12.   
13.         if (!result && onTouchEvent(event)) {  
14.             result = true;  
15.         }  
16.     }  
17.   
18.     ...  
19.   
20.     return result;  
21. }  

View的 dispatchTouchEvent要比ViewGroup相对来说简单的多，这里会先调用mOnTouchListener.onTouch方法，如果设置了OnTouchListener的话。不过如果调用了mOnTouchListener.onTouch方法的话，那么View本身的onTouchEvent方法就不会被调用，这两者之间是互斥的。由于我们在这里没有设置OnTouchListener，所以，我们进入onTouchEvent方法，当然这里需要看的是EditText的onTouchEvent方法，该方法位于TextView内部：

总体来说它的内部还是相对简单的，我们挑一些重点来看：

这里有3处方法使用了event对象。先看mEditor.onTouchEvent(event)：

[java]  view plain  copy

 

1. void onTouchEvent(MotionEvent event) {  
2.     updateFloatingToolbarVisibility(event);  
3.   
4.     if (hasSelectionController()) {  
5.         getSelectionController().onTouchEvent(event);  
6.     }  
7.   
8.     if (mShowSuggestionRunnable != null) {  
9.         mTextView.removeCallbacks(mShowSuggestionRunnable);  
10.         mShowSuggestionRunnable = null;  
11.     }  
12.   
13.     if (event.getActionMasked() == MotionEvent.ACTION_DOWN) {  
14.         mLastDownPositionX = event.getX();  
15.         mLastDownPositionY = event.getY();  
16.   
17.         // Reset this state; it will be re-set if super.onTouchEvent  
18.         // causes focus to move to the view.  
19.         mTouchFocusSelected = false;  
20.         mIgnoreActionUpEvent = false;  
21.     }  
22. }  

这个方法位于Editor类的内部，这个类用于对EditText的编辑做辅助功能，这里不是我们所要关心的，所以返回调用处，进入mMovement.onTouchEvent这个地方：

[java]  view plain  copy

 

1. if (mMovement != null) {  
2.     handled |= mMovement.onTouchEvent(this, (Spannable) mText, event);  
3. }  

我们由上下文可知，mMovement的实现位于类android.text.method.ArrowKeyMovementMethod的内部：

[java]  view plain  copy

 

1. public boolean onTouchEvent(TextView widget, Spannable buffer, MotionEvent event) {  
2.     ...  
3.   
4.     boolean handled = Touch.onTouchEvent(widget, buffer, event);  
5.   
6.     if (widget.didTouchFocusSelect() && !isMouse) {  
7.         return handled;  
8.     }  
9.     if (action == MotionEvent.ACTION_DOWN) {  
10.         f (isMouse || isTouchSelecting(isMouse, buffer)) {  
11.   
12.             ...  
13.   
14.             widget.getParent().requestDisallowInterceptTouchEvent(true);  
15.         }  
16.     } else if (widget.isFocused()) {  
17.         if (action == MotionEvent.ACTION_MOVE) {  
18.   
19.             ...  
20.   
21.         } else if (action == MotionEvent.ACTION_UP) {  
22.   
23.             ...  
24.   
25.             return true;  
26.         }  
27.     }  
28.     return handled;  
29. }  

我们将不重要的信息删除，发现这里调用了Touch.onTouchEvent(widget, buffer, event)方法，这个方法是这么解释的：Handles touch events for dragging.  You may want to do other actions like moving the cursor on touch as well.那么就是说它是用来辅助处理TextView内部的事件滑动的：

[java]  view plain  copy

 

1. public static boolean onTouchEvent(TextView widget, Spannable buffer,  
2.                                    MotionEvent event) {  
3.     DragState[] ds;  
4.   
5.     switch (event.getActionMasked()) {  
6.     case MotionEvent.ACTION_DOWN:  
7.         ds = buffer.getSpans(0, buffer.length(), DragState.class);  
8.   
9.         for (int i = 0; i < ds.length; i++) {  
10.             buffer.removeSpan(ds[i]);  
11.         }  
12.   
13.         buffer.setSpan(new DragState(event.getX(), event.getY(),  
14.                         widget.getScrollX(), widget.getScrollY()),  
15.                 0, 0, Spannable.SPAN_MARK_MARK);  
16.         return true;  
17.   
18.     case MotionEvent.ACTION_UP:  
19.         ...  
20.   
21.     case MotionEvent.ACTION_MOVE:  
22.         ds = buffer.getSpans(0, buffer.length(), DragState.class);  
23.   
24.         if (ds.length > 0) {  
25.   
26.             ...  
27.   
28.                 if (!event.isButtonPressed(MotionEvent.BUTTON_PRIMARY)) {  
29.                     scrollTo(widget, layout, nx, ny);  
30.                 }  
31.   
32.                 ...  
33.   
34.                 return true;  
35.             }  
36.         }  
37.     }  
38.   
39.     return false;  
40. }  

这个方法内部的ACTION_DOWN方法也没有做什么处理，到了这里，事件传递的方法调用栈就应该返回了，但是我们的问题还没解决，就是如何解决事件冲突的问题：

因为一开始，我们就知道ScrollView是否会拦截事件是有条件的，那么，执行了一次ACTION_DOWN之后，唯一我们可以动的地方就是更改disallowIntercept的值，我们通过上下文发现，可以更改这个值的唯一方式就是让子类调用requestDisallowInterceptTouchEvent方法，这个方法会一层层将这个标志传递给父布局容器，最后作用到ScrollView这里。试试在EditText的子类中重写onTouchEvent方法，并且在方法结束之前我们调用requestDisallowInterceptTouchEvent方法，并设置其参数为true，是不是它们之间的事件冲突就可以初步解决呢？

其实，到这里，我们的事件冲突就算解决完成了，但是，我们的标题还说要分析TextView的基本实现，没错，其实，我本身的目的是要实现在EditText在内部滑动到顶部或者底部的时候，要触发外部ScrollView的滑动，那么这里我们就需要对滑动事件的处理以及滑动距离的计算方式了如指掌。有了这个问题，我们就需要从ACTION_MOVE的事件开始分析了，我们还是需要从ViewGroup处开始分析，当然在ViewGroup的dispatchTouchEvent方法中，并没有对ACTION_MOVE进行特殊处理，因为它被全部交给了真是的事件处理对象EditText，所以，按照上面的分析方法来说，这一路分析下来，唯一不同的就是Touch.onTouchEvent(widget, buffer, event)方法，它对ACTION_MOVE进行了特别的处理，就像上面最后一部分代码所展示的那样：

这里经过一系列计算之后，又调用了scrollTo方法:

[java]  view plain  copy

 

1. public static void scrollTo(TextView widget, Layout layout, int x, int y) {  
2.        
3. .  
4.   
5.      widget.scrollTo(x, y);  
6. }  

这个方法内部经过一系列的计算，又调用了View的scrollTo方法，这里就涉及到了View的scroll方法，这个方法的原理请自行查找，这里只提一下，就是它会滑动它的内容，如果有注意的话，在调用上面方法时会传入一个Layout类型的参数，这是何物呢？其实，这就是 EditText滑动时滚动的真正内容，我们所有的文本都是直接被放置在这个layout上，我们可以从EditText的onMeasure方法中找到这个layout对象被实例化的地方，那么，如何监听这个layout滚动时的高度信息呢？

如果观察View的scrollTo方法的话，会得知该方法内部会调用onScrollChanged方法，所以，我们在EditText的子类中重写这个方法就好：

[java]  view plain  copy

 

1.    @Override  
2.    protected void onScrollChanged(int horiz, int vert, int oldHoriz, int oldVert) {  
3.        super.onScrollChanged(horiz, vert, oldHoriz, oldVert);  
4. //这里是滑动到底部的示例，滑动到顶部只用计算vert的值是否为0就可以  
5. //这里可以提前计算好一个值，不用每次进行计算，这里只是做示例  
6.        if (vert == mLayoutHeight + paddingTop + paddingBottom - mHeight) {  
7.            //这里触发父布局或祖父布局的滑动事件  
8.            getParent().requestDisallowInterceptTouchEvent(false);  
9.        }  
10.    }  

我来简单解释一下这几个计算参数的作用，如下图所示：

我们实际可滑动的范围就是0~N，N等于 mLayoutHeight + paddingTop + paddingBottom - mHeight，这几个值可在onMeasure方法中获得：

[java]  view plain  copy

 

1. @Override  
2. protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
3.     super.onMeasure(widthMeasureSpec, heightMeasureSpec);  
4.   
5.     mLayout = getLayout();  
6.     mLayoutHeight = mLayout.getHeight();  
7.     paddingTop = getTotalPaddingTop();  
8.     paddingBottom = getTotalPaddingBottom();  
9.     mHeight = getHeight();  
10. }  

那么，整个EditText看起来应该是这样的：

[java]  view plain  copy

 

1. import android.content.Context;  
2. import android.text.Layout;  
3. import android.util.AttributeSet;  
4. import android.view.MotionEvent;  
5. import android.widget.EditText;  
6.   
7. /** 
8.  * Created by Sahadev on 2016/4/20. 
9.  */  
10. public class MyEditText extends EditText {  
11.   
12.     public Layout mLayout;  
13.     public int paddingTop;  
14.     public int paddingBottom;  
15.     public int mHeight;  
16.     public int mLayoutHeight;  
17.   
18.     public MyEditText(Context context) {  
19.         super(context);  
20.         init();  
21.     }  
22.   
23.     public MyEditText(Context context, AttributeSet attrs) {  
24.         super(context, attrs);  
25.         init();  
26.     }  
27.   
28.     public MyEditText(Context context, AttributeSet attrs, int defStyleAttr) {  
29.         super(context, attrs, defStyleAttr);  
30.         init();  
31.     }  
32.   
33.     private void init() {  
34.     }  
35.   
36.     @Override  
37.     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
38.         super.onMeasure(widthMeasureSpec, heightMeasureSpec);  
39.   
40.         mLayout = getLayout();  
41.         mLayoutHeight = mLayout.getHeight();  
42.         paddingTop = getTotalPaddingTop();  
43.         paddingBottom = getTotalPaddingBottom();  
44.         mHeight = getHeight();  
45.     }  
46.   
47.     @Override  
48.     public boolean onTouchEvent(MotionEvent event) {  
49.         boolean result = super.onTouchEvent(event);  
50.         getParent().requestDisallowInterceptTouchEvent(true);  
51.         return result;  
52.     }  
53.   
54.     @Override  
55.     protected void onScrollChanged(int horiz, int vert, int oldHoriz, int oldVert) {  
56.         super.onScrollChanged(horiz, vert, oldHoriz, oldVert);  
57.         //这里是滑动到底部的示例，滑动到顶部只用计算vert的值是否为0就可以  
58.     //这里可以提前计算好一个值，不用每次进行计算，这里只是做示例  
59.         if (vert == mLayoutHeight + paddingTop + paddingBottom - mHeight) {  
60.             //这里触发父布局或祖父布局的滑动事件，下面这行代码只是示例作用，并没有实现真正的效果  
61.             getParent().requestDisallowInterceptTouchEvent(false);  
62.         }  
63.     }  
64.   
65.   
66. }  

好了，以上内容就是这篇文章需要了解的全部内容，基本的内容知识点有：

1.触摸事件分发：ViewGroup的dispatchTouchEvent会对事件按情况进行判断，然后交由自己的onInterceptTouchEvent方法或者传给子View的dispatchTouchEvent，而标准的View收到这个事件后会交由外部设置的OnTouchListener或者自身的onTouchEvent方法，两者只能选其一。

2.子View对父布局或者祖父布局的事件干扰，通过getParent().requestDisallowInterceptTouchEvent(true);方法要求这次事件不被父布局或者祖父布局拦截，当然，该方法应被放置到onTouchEvent中调用。一次事件代表按下、滑动、抬起、取消的整个过程。

requestDisallowInterceptTouchEvent方法会一层层的传给上传布局。

3.对于EditText，因为它的主要实现是由TextView完成的，所以，我们大部分的研究主要在TextView中，而TextView内部有一个Layout用于展示所有的文本内容。当事件被传递到这里时，又会将事件传递给其它的文本辅助控制类，比如编辑辅助类，或者上下滑动辅助类。

4.对于EditText内部滑动距离的简要方法计算，来判断EditText是否到顶，或者是否到底。从而使用户可以自定义自己的行为。

好了，今天要说的就这些，有疑问欢迎留言。

下篇文章描述了如何实现ScrollView嵌套EditText的联带滑动，详情请参见：ScrollView嵌套EditText联带滑动的解决办法