Android View事件分发机制学习笔记

前言

我们都知道：

1. 一个按钮在点击的时候有三种情况DOWN,MOVE,UP，即按下，按住，抬起三种情况，属于OnTouch事件。
2. 有的时候也有两种情况的时候LongClick，Click，即长按与点击，属于OnTouchEven事件。

你或许会感到奇怪按钮只能注册OnTouch，OnClickListener，OnLongClickListener并无法注册OnTouchEven事件，为什么能说两种情况的时候长按与点击，属于OnTouchEven事件呢？这个等会我们在源码讲解的时候再讨论，我们继续向下看。
知道这些我们开发过程中就可以在事件点击事件触发时，在不同的情况下执行什么事务。
例如：随着手指滑动的一个按钮，就需要按下改变颜色，按住跟随手指滑动，抬起恢复初始颜色。
再如：点击一个列表查看详情，长按提示删除。
那么问题来了，这些事件是如何分发的呢？假如我只想执行按下，不想执行按住，抬起怎么办？只想执行长按，不想执行点击事件怎么办？
接下来我们根据代码与源码进行一步步分析。

示例代码

MainActivity中一个按钮，注册一些点击事件即可，注意下列下面代码注释1,2处。

  button.setOnLongClickListener(new View.OnLongClickListener() {
            @Override
            public boolean onLongClick(View view) {
                Log.d(TAG, "onLongClick: ");
                return false;//1
            }
        });

        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Log.d(TAG, "onClick:");
            }
        });
        button.setOnTouchListener(new View.OnTouchListener() {
            @Override
            public boolean onTouch(View view, MotionEvent motionEvent) {
                Log.d(TAG, "onTouch: " + motionEvent.getAction());
                return false;//2
            }
        });

我们分以下情况讨论：

1. 当上列代码1，2处都为false时：
   点击按钮：
   
   长按按钮：
   

2. 当1为true，2为false时：
   点击按钮：
   
   长按按钮：
   

3. 当1，2为都为true时：
   无论长按还是点击：
   

4. 当1为false，2为true时：
   无论长按还是点击：
   

经过以上几个情况你会发现：

1. onTouch始终是先于onTouchEven事件执行的。
2. 当onTouch返回true时，会阻止onTouchEven事件。
3. 而OnLongClick返回true时，会阻止OnClick事件。

接下来，我们通过源码来解释为什么。

源码分析

首先你需要知道一点，只要你触摸到了任何一个控件，就一定会调用该控件的dispatchTouchEvent方法。那当我们去点击按钮的时候，就会去调用Button类里的dispatchTouchEvent方法，可是你会发现Button类里并没有这个方法，那么就到它的父类TextView里去找一找，你会发现TextView里也没有这个方法，那没办法了，只好继续在TextView的父类View里找一找，这个时候你终于在View里找到了这个方法，如下：

dispatchTouchEvent方法的源码

View中dispatchTouchEvent方法的源码：

public boolean dispatchTouchEvent(MotionEvent event) {  
    if (mOnTouchListener != null && (mViewFlags & ENABLED_MASK) == ENABLED &&  
            mOnTouchListener.onTouch(this, event)) {  
        return true;  
    }  
    return onTouchEvent(event);  
}  

如果if中的三个条件都为真，就返回true，否则就去执行onTouchEvent(event)方法并返回。
继续分析3个条件:

1. mOnTouchListener != null
   mOnTouchListener这个变量是在哪里赋值的呢？我们寻找之后在View里发现了如下方法：

public void setOnTouchListener(OnTouchListener l) {  
    mOnTouchListener = l;  
}

也就是说只要我们给控件注册了touch事件，mOnTouchListener就一定被赋值了。

1. (mViewFlags & ENABLED_MASK) == ENABLED
   是判断当前点击的控件是否是enable的，按钮默认都是enable的，因此这个条件恒定为true。

2. mOnTouchListener.onTouch(this, event)
   其实也就是去回调控件注册touch事件时的onTouch方法。也就是说如果我们在onTouch方法里返回值就是这个条件的值。

最后我们得出结论：
我们在onTouch方法里返回true，就会让这三个条件全部成立，从而整个方法直接返回true。如果我们在onTouch方法里返回false，就会再去执行onTouchEvent(event)方法。
结合示例代码中的分析，是不是就能得出OnClick与OnLongClick属于OnTouchEven事件？

onTouchEvent的源码

那我们马上来看下onTouchEvent的源码，如下所示：

public boolean onTouchEvent(MotionEvent event) {  
    final int viewFlags = mViewFlags;  
    if ((viewFlags & ENABLED_MASK) == DISABLED) {  
        // A disabled view that is clickable still consumes the touch  
        // events, it just doesn't respond to them.  
        return (((viewFlags & CLICKABLE) == CLICKABLE ||  
                (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE));  
    }  
    if (mTouchDelegate != null) {  
        if (mTouchDelegate.onTouchEvent(event)) {  
            return true;  
        }  
    }  

    if (((viewFlags & CLICKABLE) == CLICKABLE ||  
            (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)) {  
        switch (event.getAction()) {  
            case MotionEvent.ACTION_UP:  
                boolean prepressed = (mPrivateFlags & PREPRESSED) != 0;  
                if ((mPrivateFlags & PRESSED) != 0 || prepressed) {  
                    // take focus if we don't have it already and we should in  
                    // touch mode.  
                    boolean focusTaken = false;  
                    if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {  
                        focusTaken = requestFocus();  
                    }  
                    if (!mHasPerformedLongPress) {  
                        // This is a tap, so remove the longpress check  
                        removeLongPressCallback();  
                        // Only perform take click actions if we were in the pressed state  
                        if (!focusTaken) {  
                            // Use a Runnable and post this rather than calling  
                            // performClick directly. This lets other visual state  
                            // of the view update before click actions start.  
                            if (mPerformClick == null) {  
                                mPerformClick = new PerformClick();  
                            }  
                            if (!post(mPerformClick)) {  
                                performClick();  
                            }  
                        }  
                    }  
                    if (mUnsetPressedState == null) {  
                        mUnsetPressedState = new UnsetPressedState();  
                    }  
                    if (prepressed) {  
                        mPrivateFlags |= PRESSED;  
                        refreshDrawableState();  
                        postDelayed(mUnsetPressedState,  
                                ViewConfiguration.getPressedStateDuration());  
                    } else if (!post(mUnsetPressedState)) {  
                        // If the post failed, unpress right now  
                        mUnsetPressedState.run();  
                    }  
                    removeTapCallback();  
                }  
                break;  
            case MotionEvent.ACTION_DOWN:  
                if (mPendingCheckForTap == null) {  
                    mPendingCheckForTap = new CheckForTap();  
                }  
                mPrivateFlags |= PREPRESSED;  
                mHasPerformedLongPress = false;  
                postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());  
                break;  
            case MotionEvent.ACTION_CANCEL:  
                mPrivateFlags &= ~PRESSED;  
                refreshDrawableState();  
                removeTapCallback();  
                break;  
            case MotionEvent.ACTION_MOVE:  
                final int x = (int) event.getX();  
                final int y = (int) event.getY();  
                // Be lenient about moving outside of buttons  
                int slop = mTouchSlop;  
                if ((x < 0 - slop) || (x >= getWidth() + slop) ||  
                        (y < 0 - slop) || (y >= getHeight() + slop)) {  
                    // Outside button  
                    removeTapCallback();  
                    if ((mPrivateFlags & PRESSED) != 0) {  
                        // Remove any future long press/tap checks  
                        removeLongPressCallback();  
                        // Need to switch from pressed to not pressed  
                        mPrivateFlags &= ~PRESSED;  
                        refreshDrawableState();  
                    }  
                }  
                break;  
        }  
        return true;  
    }  
    return false;  
}  

orz0.0复杂好多。

1. 第一个if条件：如果当前View是Disabled状态且是可点击则会消费掉事件（return true);可以忽略，不是我们的重点。
2. 第二个if条件：如果设置了mTouchDelegate，则会将事件交给代理者处理，直接return true，如果大家希望自己的View增加它的touch范围，可以尝试使用TouchDelegate，这里也不是重点，可以忽略；
3. 第三个if条件：如果我们的View可以点击或者可以长按，则注意IF的范围，最终一定return true；
   这才是我们关注的重点。接下来分析，其中的 switch (event.getAction())对应的事件：

1. MotionEvent.ACTION_UP

经过种种判断之后，会执行到performClick()方法，那我们进入到这个方法里瞧一瞧：

public boolean performClick() {  
    sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);  
    if (mOnClickListener != null) {  
        playSoundEffect(SoundEffectConstants.CLICK);  
        mOnClickListener.onClick(this);  
        return true;  
    }  
    return false;  
}  

可以看到，只要mOnClickListener不是null，就会去调用它的onClick方法，那mOnClickListener又是在哪里赋值的呢？经过寻找后找到如下方法:

public void setOnClickListener(OnClickListener l) {  
    if (!isClickable()) {  
        setClickable(true);  
    }  
    mOnClickListener = l;  
}  

当我们通过调用setOnClickListener方法来给控件注册一个点击事件时，就会给mOnClickListener赋值。然后每当控件被点击时，都会在performClick()方法里回调被点击控件的onClick方法。

2. MotionEvent.ACTION_DOWN

1. 给mPrivateFlags设置一个PREPRESSED的标识
2. 设置mHasPerformedLongPress=false；表示长按事件还未触发；

3. 发送一个延迟为ViewConfiguration.getTapTimeout()的延迟消息，到达延时时间后会执行CheckForTap()里面的run方法：

   • ViewConfiguration.getTapTimeout()

   • CheckForTap()

private final class CheckForTap implements Runnable {  
      public void run() {  
          mPrivateFlags &= ~PREPRESSED;  
          mPrivateFlags |= PRESSED;  
          refreshDrawableState();  
          if ((mViewFlags & LONG_CLICKABLE) == LONG_CLICKABLE) {  
              postCheckForLongClick(ViewConfiguration.getTapTimeout());  
          }  
      }  
  } 

在run方法里面取消mPrivateFlags的PREPRESSED，然后设置PRESSED标识，刷新背景，如果View支持长按事件，则再发一个延时消息，检测长按；

private void postCheckForLongClick(int delayOffset) {  
       mHasPerformedLongPress = false;  

       if (mPendingCheckForLongPress == null) {  
           mPendingCheckForLongPress = new CheckForLongPress();  
       }  
       mPendingCheckForLongPress.rememberWindowAttachCount();  
       postDelayed(mPendingCheckForLongPress,  
               ViewConfiguration.getLongPressTimeout() - delayOffset);  
   }

class CheckForLongPress implements Runnable {  

        private int mOriginalWindowAttachCount;  

        public void run() {  
            if (isPressed() && (mParent != null)  
                    && mOriginalWindowAttachCount == mWindowAttachCount) {  
                if (performLongClick()) {  
                    mHasPerformedLongPress = true;  
                }  
            }  
        }
        }  

可以看到，当用户按下，首先会设置标识为PREPRESSED
如果115ms后，没有抬起，会将View的标识设置为PRESSED且去掉PREPRESSED标识，然后发出一个检测长按的延迟任务，延时为：ViewConfiguration.getLongPressTimeout() - delayOffset（500ms -115ms），这个115ms刚好时检测额PREPRESSED时间；也就是用户从DOWN触发开始算起，如果500ms内没有抬起则认为触发了长按事件：

如果此时设置了长按的回调，则执行长按时的回调，且如果长按的回调返回true;否则，如果没有设置长按回调或者长按回调返回的是false.

MotionEvent.ACTION_MOVE

1. 拿到当前触摸的x,y坐标；
2. 判断当然触摸点有没有移出我们的View，如果移出了执行：
   
   1. 执行removeTapCallback();
   2. 然后判断是否包含PRESSED标识，如果包含，移除长按的检查：removeLongPressCallback();
   3. 最后把mPrivateFlags中PRESSED标识去除，刷新背景.
      简而言之，就是检测然后在按住按钮的时候你是否在115ms的时候将你的手指移出控件，然后判断是否要进行长按检测。

改变源码控件为ImageView

将按钮替换成ImageView，然后给它也注册一个touch事件，并返回false。如下：

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "MainActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ImageView button = (ImageView) findViewById(R.id.button);

        button.setOnTouchListener(new View.OnTouchListener() {
            @Override
            public boolean onTouch(View view, MotionEvent motionEvent) {
                Log.d(TAG, "onTouch: " + motionEvent.getAction());
                return false;
            }
        });
    }
}

运行一下程序，点击ImageView，你会发现结果如下：
在ACTION_DOWN执行完后，后面的一系列action都不会得到执行了。这又是为什么呢？
因为ImageView和按钮不同，它是默认不可点击的，因此在onTouchEvent的第14行判断时无法进入到if的内部，直接跳出判断返回了false，也就导致后面其它的action都无法执行了。

事件分发流程

所以事件分发的大致流程如下：

总结

从源码中可以看出，这两个方法都是在View的dispatchTouchEvent中调用的，onTouch优先于onTouchEvent执行。如果在onTouch方法中通过返回true将事件消费掉，onTouchEvent将不会再执行。

另外需要注意的是，onTouch能够得到执行需要两个前提条件，第一mOnTouchListener的值不能为空，第二当前点击的控件必须是enable的。因此如果你有一个控件是非enable的，那么给它注册onTouch事件将永远得不到执行。对于这一类控件，如果我们想要监听它的touch事件，就必须通过在该控件中重写onTouchEvent方法来实现。

参考

http://blog.csdn.net/guolin_blog/article/details/9097463

http://blog.csdn.net/lmj623565791/article/details/38960443