攻略大全

1. 粘贴攻略

1.1 View基础知识

1.1.1 MotionEvent

事件类型（4种）

事件类型	具体动作
MotionEvent.ACTION_DOWN	按下View（所有事件的开始）
MotionEvent.ACTION_UP	抬起View（与DOWN对应）
MotionEvent.ACTION_MOVE	滑动View
MotionEvent.ACTION_CANCEL	结束事件（非人为原因）

特别说明：事件列

从手指接触屏幕至手指离开屏幕，这个过程产生的一系列事件

注：一般情况下，事件列都是以DOWN事件开始、UP事件结束，中间有无数的MOVE事件，如下图：

即当一个点击事件（MotionEvent ）产生后，系统需把这个事件传递给一个具体的 View 去处理。

通过MotionEvent对象我们可以得到点击事件发生的x和y坐标。为此，系统提供了两组方法：getX/getY和getRawX/getRawY。它们的区别其实很简单，getX/getY返回的是相对于当前View左上角的x和y坐标，而getRawX/getRawY返回的是相对于手机屏幕左上角的x和y坐标。

1.1.2 TouchSlop

TouchSlop是系统所能识别出的被认为是滑动的最小距离，换句话说，当手指在屏幕上滑动时，如果两次滑动之间的距离小于这个常量，那么系统就不认为你是在进行滑动操作。

原因很简单：滑动的距离太短，系统不认为它是滑动。这是一个常量，和设备有关，在不同设备上这个值可能是不同的，通过如下方式即可获取这个常量：ViewConfiguration. get(getContext()).getScaledTouchSlop()。

这个常量有什么意义呢？当我们在处理滑动时，可以利用这个常量来做一些过滤，比如当两次滑动事件的滑动距离小于这个值，我们就可以认为未达到滑动距离的临界值，因此就可以认为它们不是滑动，这样做可以有更好的用户体验。其实如果细心的话，可以在源码中找到这个常量的定义，在frameworks/base/core/res/res/values/config.xml文件中，如下所示。这个“config_viewConfigurationTouchSlop”对应的就是这个常量的定义。

1.1.3 VelocityTracker

速度追踪，用于追踪手指在滑动过程中的速度，包括水平和竖直方向的速度。

VelocityTracker velocityTracker = VelocityTracker.obtain();
// 追踪当前事件的速度
velocityTracker.addMovement(event);

// 获取速度前需先计算进行
// 获取的速度是指一段时间内手指所滑过的像素数
velocityTracker.computeCurrentVelocity(1000);

// 获取X方向的速度
int xVelocity = (int)velocityTracker.getXVelocity();
// 获取Y方向的速度
int yVelocity = (int)velocityTracker.getYVelocity();

// 当不需要使用它的时候，调用clean方法来重置并回收内存
velocityTracker.clean();
velocityTracker.recycler();

1.1.4 GestureDetector

手势检测，用于辅助检测用户的单击、滑动、长按、双击等行为。

mGestureDetector = new GestureDetector(new GestureDetector.OnGestureListener() {
    @Override
    public boolean onDown(MotionEvent e) {
        return false;
    }

    @Override
    public void onShowPress(MotionEvent e) {

    }

    @Override
    public boolean onSingleTapUp(MotionEvent e) {
        return false;
    }

    @Override
    public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
        return false;
    }

    @Override
    public void onLongPress(MotionEvent e) {

    }

    @Override
    public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
        return false;
    }
});

mGestureDetector.setOnDoubleTapListener(new GestureDetector.OnDoubleTapListener() {
    @Override
    public boolean onSingleTapConfirmed(MotionEvent e) {
        return false;
    }

    @Override
    public boolean onDoubleTap(MotionEvent e) {
        return false;
    }

    @Override
    public boolean onDoubleTapEvent(MotionEvent e) {
        return false;
    }
});

// 解决长按屏幕后无法拖动的现象
mGestureDetector.setIsLongpressEnabled(false);

@Override
public boolean onTouchEvent(MotionEvent event) {
    // 接管目标Viwe的OnTouchEvent方法
    return mGestureDetector.onTouchEvent(event);
}

并不是所有的方法都会被时常用到，在日常开发中，比较常用的有：onSingleTapUp（单击）、 onFling（快速滑动）、onScroll（拖动）、onLongPress（长按）和onDoubleTap（双击）。另外这里要说明的是，实际开发中，可以不使用GestureDetector，完全可以自己在View的onTouchEvent方法中实现所需的监听，这个就看个人的喜好了。这里有一个建议供读者参考：如果只是监听滑动相关的，建议自己在onTouchEvent中实现，如果要监听双击这种行为的话，那么就使用GestureDetector。

1.1.5 Scroller

弹性滑动对象，用于实现View的弹性滑动。我们知道，当使用View的scrollTo/scrollBy方法来进行滑动时，其过程是瞬间完成的，这个没有过渡效果的滑动用户体验不好。这个时候就可以使用Scroller来实现有过渡效果的滑动，其过程不是瞬间完成的，而是在一定的时间间隔内完成的。Scroller本身无法让View弹性滑动，它需要和View的computeScroll方法配合使用才能共同完成这个功能。那么如何使用Scroller呢？它的典型代码是固定的，如下所示。

public class DemoView extends View {
    Scroller mScroller;
    Context mContext;

    public DemoView(Context context) {
        super(context);
    }

    public DemoView(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
    }

    public DemoView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    public DemoView(Context context, @Nullable AttributeSet attrs, int defStyleAttr, int defStyleRes) {
        super(context, attrs, defStyleAttr, defStyleRes);
    }

    private void init(){
        mScroller = new Scroller(mContext);
    }


    public void smoothScrollTo(int destX, int destY){
        int scrollX = getScrollX();
        int delta = destX -scrollX;
        // 1000ms内滑向destX，效果就是慢慢滑动
        mScroller.startScroll(scrollX,0,delta,0,1000);
        invalidate();
    }

    @Override
    public void computeScroll() {
        if (mScroller.computeScrollOffset()){
            scrollTo(mScroller.getCurrX(),mScroller.getCurrY());
            postInvalidate();
        }
    }
}

1.2 View的滑动

通过三种方式可以实现View的滑动：

第一种是通过View本身提供的scrollTo/scrollBy方法来实现滑动；操作简单，适合对View内容的滑动。

第二种是通过动画给View施加平移效果来实现滑动；操作简单，主要适用于没有交互的View和实现复杂的动画效果。

第三种是通过改变View的LayoutParams使得View重新布局从而实现滑动；操作稍微复杂，适用于有交互的View。

1.2.1 使用scrollTo/scrollBy

/**
 * Set the scrolled position of your view. This will cause a call to
 * {@link #onScrollChanged(int, int, int, int)} and the view will be
 * invalidated.
 * @param x the x position to scroll to
 * @param y the y position to scroll to
 */
public void scrollTo(int x, int y) {
    if (mScrollX != x || mScrollY != y) {
        int oldX = mScrollX;
        int oldY = mScrollY;
        mScrollX = x;
        mScrollY = y;
        invalidateParentCaches();
        onScrollChanged(mScrollX, mScrollY, oldX, oldY);
        if (!awakenScrollBars()) {
            postInvalidateOnAnimation();
        }
    }
}

/**
 * Move the scrolled position of your view. This will cause a call to
 * {@link #onScrollChanged(int, int, int, int)} and the view will be
 * invalidated.
 * @param x the amount of pixels to scroll by horizontally
 * @param y the amount of pixels to scroll by vertically
 */
public void scrollBy(int x, int y) {
    scrollTo(mScrollX + x, mScrollY + y);
}

从上面的源码可以看出，scrollBy实际上也是调用了scrollTo方法，它实现了基于当前位置的相对滑动，而scrollTo则实现了基于所传递参数的绝对滑动，这个不难理解。

利用scrollTo和scrollBy来实现View的滑动，这不是一件困难的事，但是我们要明白滑动过程中View内部的两个属性mScrollX和mScrollY的改变规则，这两个属性可以通过getScrollX和getScrollY方法分别得到。

这里先简要概况一下：

在滑动过程中，mScrollX的值总是等于View左边缘和View内容左边缘在水平方向的距离，而mScrollY的值总是等于View上边缘和View内容上边缘在竖直方向的距离。
View边缘是指View的位置，由四个顶点组成，而View内容边缘是指View中的内容的边缘，scrollTo和scrollBy只能改变View内容的位置而不能改变View在布局中的位置。
mScrollX和mScrollY的单位为像素，并且当View左边缘在View内容左边缘的右边时，mScrollX为正值，反之为负值；当View上边缘在View内容上边缘的下边时，mScrollY为正值，反之为负值。换句话说，如果从左向右滑动，那么mScrollX为负值，反之为正值；如果从上往下滑动，那么mScrollY为负值，反之为正值。

1.2.2 使用动画

通过动画我们能够让一个View进行平移，而平移就是一种滑动。使用动画来移动View，主要是操作View的translationX和translationY属性，既可以采用传统的View动画，也可以采用属性动画。

1.2.3 改变布局参数

改变布局参数，即改变LayoutParams。这个比较好理解了，比如我们想把一个Button向右平移100px，我们只需要将这个Button的LayoutParams里的marginLeft参数的值增加100px即可，是不是很简单呢？还有一种情形，为了达到移动Button的目的，我们可以在Button的左边放置一个空的View，这个空View的默认宽度为0，当我们需要向右移动Button时，只需要重新设置空View的宽度即可，当空View的宽度增大时（假设Button的父容器是水平方向的LinearLayout）, Button就自动被挤向右边，即实现了向右平移的效果。

1.2.4 弹性滑动

Scroller实现弹性滑动：Scroller本身并不能实现View的滑动，它需要配合View的computeScroll方法才能完成弹性滑动的效果，它不断地让View重绘，而每一次重绘距滑动起始时间会有一个时间间隔，通过这个时间间隔Scroller就可以得出View当前的滑动位置，知道了滑动位置就可以通过scrollTo方法来完成View的滑动。就这样，View的每一次重绘都会导致View进行小幅度的滑动，而多次的小幅度滑动就组成了弹性滑动，这就是Scroller的工作机制。由此可见，Scroller的设计思想是多么值得称赞，整个过程中它对View没有丝毫的引用，甚至在它内部连计时器都没有。

动画实现弹性滑动：动画本身就是一种渐近的过程，因此通过它来实现的滑动天然就具有弹性效果。可以利用动画的特性，在动画的每一帧到来时获取动画完成的比例，然后再根据这个比例计算出当前View所要滑动的距离。可以发现，这个方法的思想其实和Scroller比较类似，都是通过改变一个百分比配合scrollTo方法来完成View的滑动。需要说明一点，采用这种方法除了能够完成弹性滑动以外，还可以实现其他动画效果，我们完全可以在onAnimationUpdate方法中加上我们想要的其他操作。

使用延时策略：它的核心思想是通过发送一系列延时消息从而达到一种渐近式的效果，具体来说可以使用Handler或View的postDelayed方法，也可以使用线程的sleep方法。对于postDelayed方法来说，我们可以通过它来延时发送一个消息，然后在消息中来进行View的滑动，如果接连不断地发送这种延时消息，那么就可以实现弹性滑动的效果。对于sleep方法来说，通过在while循环中不断地滑动View和sleep，就可以实现弹性滑动的效果。

1.3 View的滑动冲突

常见的滑动冲突场景可以简单分为如下三种：

场景1——外部滑动方向和内部滑动方向不一致
场景2——外部滑动方向和内部滑动方向一致
场景3——上面两种情况的嵌套

1.3.1 外部拦截法

所谓外部拦截法是指点击事情都先经过父容器的拦截处理，如果父容器需要此事件就拦截，如果不需要此事件就不拦截，这样就可以解决滑动冲突的问题，这种方法比较符合点击事件的分发机制。外部拦截法需要重写父容器的onInterceptTouchEvent方法，在内部做相应的拦截即可。

1.3.2 内部拦截法

内部拦截法是指父容器不拦截任何事件，所有的事件都传递给子元素，如果子元素需要此事件就直接消耗掉，否则就交由父容器进行处理，这种方法和Android中的事件分发机制不一致，需要配合requestDisallowInterceptTouchEvent方法才能正常工作，使用起来较外部拦截法稍显复杂。

2. 造火箭攻略

2.1 Activity.dispatchTouchEvent()

2.2 ViewGroup.dispatchTouchEvent()

2.3 View.dispatchTouchEvent()

2.4 Touch事件的后续（MOVE、UP）层级传递

若给控件注册了Touch事件，每次点击都会触发一系列action事件（ACTION_DOWN，ACTION_MOVE，ACTION_UP等）
当dispatchTouchEvent（）事件分发时，只有前一个事件（如ACTION_DOWN）返回true，才会收到后一个事件（ACTION_MOVE和ACTION_UP）

即如果在执行ACTION_DOWN时返回false，后面一系列的ACTION_MOVE、ACTION_UP事件都不会执行

从上面对事件分发机制分析可知：

dispatchTouchEvent()、 onTouchEvent() 消费事件、终结事件传递（返回true）
而onInterceptTouchEvent 并不能消费事件，它相当于是一个分叉口起到分流导流的作用，对后续的ACTION_MOVE和ACTION_UP事件接收起到非常大的作用

请记住：接收了ACTION_DOWN事件的函数不一定能收到后续事件（ACTION_MOVE、ACTION_UP）

这里给出ACTION_MOVE和ACTION_UP事件的传递结论：

结论1

若对象（Activity、ViewGroup、View）的dispatchTouchEvent()分发事件后消费了事件（返回true），那么收到ACTION_DOWN的函数也能收到ACTION_MOVE和ACTION_UP

黑线：ACTION_DOWN事件传递方向

红线：ACTION_MOVE 、 ACTION_UP事件传递方向

结论2

若对象（Activity、ViewGroup、View）的onTouchEvent()处理了事件（返回true），那么ACTION_MOVE、ACTION_UP的事件从上往下传到该View后就不再往下传递，而是直接传给自己的onTouchEvent()& 结束本次事件传递过程。

黑线：ACTION_DOWN事件传递方向

红线：ACTION_MOVE、ACTION_UP事件传递方

2.5 onTouch()和onTouchEvent()的区别

该2个方法都是在View.dispatchTouchEvent（）中调用
但onTouch（）优先于onTouchEvent执行；若手动复写在onTouch（）中返回true（即将事件消费掉），将不会再执行onTouchEvent（）

注：若1个控件不可点击（即非enable），那么给它注册onTouch事件将永远得不到执行，具体原因看如下代码

    if (li != null && li.mOnTouchListener != null && (mViewFlags & ENABLED_MASK) == ENABLED 
        && li.mOnTouchListener.onTouch(this, event)) { 
        result = true; 
    }

    if (!result && onTouchEvent(event)) { 
        result = true;
    }

// 对于该类控件，若需监听它的touch事件，就必须通过在该控件中重写onTouchEvent（）来实现

2.6 事件分发的底层流程

IMS在SystemServer中启动，流程如下图。主要工作可以分为两部分，一是启动Native的InputDispatcherThread和InputReaderThread，InputDispatcherThread用于事件派发，InputReaderThread用于事件读取；二是通过InputMonitor建立IMS与WMS的联系。

事件派发中很重要的机制是Native层的InputChannel，InputChannel用于IPC，其中InputPublisher由InputDispatcher派发事件，InputConsumer消费InputDispatcher派发的事件。下图是Java层事件派发的简单流程。

3. 拧螺丝攻略

3.1 Activity.dispatchTouchEvent()

/**
 * 源码分析：Activity.dispatchTouchEvent（）
 */
public boolean dispatchTouchEvent(MotionEvent ev) {

    // 一般事件列开始都是DOWN事件 = 按下事件，故此处基本是true
    if (ev.getAction() == MotionEvent.ACTION_DOWN) {
        onUserInteraction();
        // ->>分析1
    }



    // ->>分析2
    if (getWindow().superDispatchTouchEvent(ev)) {
        return true;

        // 若getWindow().superDispatchTouchEvent(ev)的返回true
        // 则Activity.dispatchTouchEvent（）就返回true，则方法结束。即 ：该点击事件停止往下传递 & 事件传递过程结束
        // 否则：继续往下调用Activity.onTouchEvent
    }

    // ->>分析4
    return onTouchEvent(ev);
}

/**
 * 分析1：onUserInteraction()
 * 作用：实现屏保功能
 * 注：
 * a. 该方法为空方法
 * b. 当此activity在栈顶时，触屏点击按home，back，menu键等都会触发此方法
 */
public void onUserInteraction() {

}

/**
 * 分析2：getWindow().superDispatchTouchEvent(ev)
 * 说明：
 * a. getWindow() = 获取Window类的对象
 * b. Window类是抽象类，其唯一实现类 = PhoneWindow类；即此处的Window类对象 = PhoneWindow类对象
 * c. Window类的superDispatchTouchEvent() = 1个抽象方法，由子类PhoneWindow类实现`
 */
@Override
public boolean superDispatchTouchEvent(MotionEvent event) {
return mDecor.superDispatchTouchEvent(event);
// mDecor = 顶层View（DecorView）的实例对象
// ->> 分析3
}



/**
 * 分析3：mDecor.superDispatchTouchEvent(event)
 * 定义：属于顶层View（DecorView）
 * 说明：
 * a. DecorView类是PhoneWindow类的一个内部类
 * b. DecorView继承自FrameLayout，是所有界面的父类
 * c. FrameLayout是ViewGroup的子类，故DecorView的间接父类 = ViewGroup
 */
public boolean superDispatchTouchEvent(MotionEvent event) {
    // 调用父类的方法 = ViewGroup的dispatchTouchEvent()
    // 即 将事件传递到ViewGroup去处理，详细请看ViewGroup的事件分发机制
    return super.dispatchTouchEvent(event);
}

/**
 * 分析4：Activity.onTouchEvent（）
 * 定义：属于顶层View（DecorView）
 * 说明：
 * a. DecorView类是PhoneWindow类的一个内部类
 * b. DecorView继承自FrameLayout，是所有界面的父类
 * c. FrameLayout是ViewGroup的子类，故DecorView的间接父类 = ViewGroup
 */
public boolean onTouchEvent(MotionEvent event) {

    // 当一个点击事件未被Activity下任何一个View接收 / 处理时
    // 应用场景：处理发生在Window边界外的触摸事件
    // ->> 分析5
    if (mWindow.shouldCloseOnTouch(this, event)) {
        finish();
        return true;
    }
    return false;
    
    // 即 只有在点击事件在Window边界外才会返回true，一般情况都返回false，分析完毕

}

/**
 * 分析5：mWindow.shouldCloseOnTouch(this, event)
 */
public boolean shouldCloseOnTouch(Context context, MotionEvent event) {

    // 主要是对于处理边界外点击事件的判断：是否是DOWN事件，event的坐标是否在边界内等

    if (mCloseOnTouchOutside && event.getAction() == MotionEvent.ACTION_DOWN
    && isOutOfBounds(context, event) && peekDecorView() != null) {
        // 返回true：说明事件在边界外，即 消费事件
        return true;
    }

     // 返回false：未消费（默认）
    return false;
}

3.2 ViewGroup.dispatchTouchEvent()

@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    
    ...

    boolean handled = false;
    if (onFilterTouchEventForSecurity(ev)) {
        final int action = ev.getAction();
        final int actionMasked = action & MotionEvent.ACTION_MASK;

        // Handle an initial down.
        if (actionMasked == MotionEvent.ACTION_DOWN) {
             // 开始新的触摸手势时丢弃所有先前的状态。由于应用程序切换、ANR 或其他一些状态更改，
             框架可能已经放弃了前一个手势的向上或取消事件。
            cancelAndClearTouchTargets(ev);
            resetTouchState();
        }

        // 检测是否拦截事件
        final boolean intercepted;
        if (actionMasked == MotionEvent.ACTION_DOWN
                || mFirstTouchTarget != null) {
            final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
            if (!disallowIntercept) {
                intercepted = onInterceptTouchEvent(ev);
                ev.setAction(action); // restore action in case it was changed
            } else {
                intercepted = false;
            }
        } else {
            // 没有触摸目标，并且此操作不是初始向下，因此此视图组继续拦截触摸。
            intercepted = true;
        }

       ...
       
        // 如果时间没有被CANCEL并且没有进行拦截
        if (!canceled && !intercepted) {
         ...
                if (newTouchTarget == null && childrenCount != 0) {
                    final float x = ev.getX(actionIndex);
                    final float y = ev.getY(actionIndex);
                    // Find a child that can receive the event.
                    // Scan children from front to back.
                    final ArrayList<View> preorderedList = buildTouchDispatchChildList();
                    final boolean customOrder = preorderedList == null
                            && isChildrenDrawingOrderEnabled();
                    final View[] children = mChildren;
                    
                    // 倒序遍历子View
                    for (int i = childrenCount - 1; i >= 0; i--) {
                        // 遍历找到要处理的子View
                        // 遍历中会直接过滤部分View，如不在触摸事件范围内的子View
                        ...
                       
                        // 转换为子View的坐标空间继续传递事件
                        if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) {

                            // 递归中有View消费了事件
                            // 则进行相关记录与处理

                            mLastTouchDownTime = ev.getDownTime();
                            if (preorderedList != null) {
                                // childIndex points into presorted list, find original index
                                for (int j = 0; j < childrenCount; j++) {
                                    if (children[childIndex] == mChildren[j]) {
                                        mLastTouchDownIndex = j;
                                        break;
                                    }
                                }
                            } else {
                                mLastTouchDownIndex = childIndex;
                            }
                            mLastTouchDownX = ev.getX();
                            mLastTouchDownY = ev.getY();
                            newTouchTarget = addTouchTarget(child, idBitsToAssign);
                            alreadyDispatchedToNewTouchTarget = true;
                            break;
                        }
            }
        }
        
        ...

        // Update list of touch targets for pointer up or cancel, if needed.
        if (canceled
                || actionMasked == MotionEvent.ACTION_UP
                || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
            resetTouchState();
        } else if (split && actionMasked == MotionEvent.ACTION_POINTER_UP) {
            final int actionIndex = ev.getActionIndex();
            final int idBitsToRemove = 1 << ev.getPointerId(actionIndex);
            removePointersFromTouchTargets(idBitsToRemove);
        }
    }

    if (!handled && mInputEventConsistencyVerifier != null) {
        mInputEventConsistencyVerifier.onUnhandledEvent(ev, 1);
    }
    // 将递归回来的事件处理结果往上层回调
    return handled;
}

/**
 * 将触摸事件的坐标转化为子View的坐标空间再传递
 */
private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
        View child, int desiredPointerIdBits) {
    final boolean handled;

    // Perform any necessary transformations and dispatch.
    if (child == null) {
        handled = super.dispatchTouchEvent(transformedEvent);
    } else {
        final float offsetX = mScrollX - child.mLeft;
        final float offsetY = mScrollY - child.mTop;
        transformedEvent.offsetLocation(offsetX, offsetY);
        if (! child.hasIdentityMatrix()) {
            transformedEvent.transform(child.getInverseMatrix());
        }
        // 转化坐标后时间传递给子View
        handled = child.dispatchTouchEvent(transformedEvent);
    }

    // Done.
    transformedEvent.recycle();
    return handled;
}

/**
 * 分析1：ViewGroup.onInterceptTouchEvent()
 * 作用：是否拦截事件
 * 说明：
 * a. 返回true = 拦截，即事件停止往下传递（需手动设置，即复写onInterceptTouchEvent（），从而让其返回true）
 * b. 返回false = 不拦截
 */
public boolean onInterceptTouchEvent(MotionEvent ev) {
    if (ev.isFromSource(InputDevice.SOURCE_MOUSE)
            && ev.getAction() == MotionEvent.ACTION_DOWN
            && ev.isButtonPressed(MotionEvent.BUTTON_PRIMARY)
            && isOnScrollbarThumb(ev.getX(), ev.getY())) {
        return true;
    }
    return false;
}

3.3 View.dispatchTouchEvent()

/**
 * 源码分析：View.dispatchTouchEvent（）
 */
public boolean dispatchTouchEvent(MotionEvent event) {

    // 如果是要交给有焦点的View处理的事件
    if (event.isTargetAccessibilityFocus()) {
       // 没有焦点则不处理直接回调回ViewGroup
        if (!isAccessibilityFocusedViewOrHost()) {
            return false;
        }
        // We have focus and got the event, then use normal event dispatch.
        event.setTargetAccessibilityFocus(false);
    }

    boolean result = false;

    ... 

    final int actionMasked = event.getActionMasked();

    // 如果是点击事件
    if (actionMasked == MotionEvent.ACTION_DOWN) {
        // 停止正在进行的嵌套滚动
        stopNestedScroll();
    }

    // 对事件进行过滤
    if (onFilterTouchEventForSecurity(event)) {
        if ((mViewFlags & ENABLED_MASK) == ENABLED && handleScrollBarDragging(event)) {
            result = true;
        }
        
        //noinspection SimplifiableIfStatement
        ListenerInfo li = mListenerInfo;
        if (li != null && li.mOnTouchListener != null
                && (mViewFlags & ENABLED_MASK) == ENABLED
                && li.mOnTouchListener.onTouch(this, event)) {
            result = true;
        }

        if (!result && onTouchEvent(event)) {
            result = true;
        }
    }

    ...

    return result;
}

// 说明：只有以下3个条件都为真，dispatchTouchEvent()才返回true；否则执行onTouchEvent()
// 1. mOnTouchListener != null
// 2. (mViewFlags & ENABLED_MASK) == ENABLED
// 3. mOnTouchListener.onTouch(this, event)


/**
 * 条件1：mOnTouchListener != null
 * 说明：mOnTouchListener变量在View.setOnTouchListener（）方法里赋值
 */
public void setOnTouchListener(OnTouchListener l) {
    mOnTouchListener = l;
    // 即只要我们给控件注册了Touch事件，mOnTouchListener就一定被赋值（不为空）
}

/**
 * 条件2：(mViewFlags & ENABLED_MASK) == ENABLED
 * 说明：
 * a. 该条件是判断当前点击的控件是否enable
 * b. 由于很多View默认enable，故该条件恒定为true
 */


/**
 * 条件3：mOnTouchListener.onTouch(this, event)
 * 说明：即 回调控件注册Touch事件时的onTouch（）；需手动复写设置，具体如下（以按钮Button为例）
 */
button.setOnTouchListener(new OnTouchListener() {
    @Override
    public boolean onTouch(View v, MotionEvent event) {
        return false;
    }
});
// 若在onTouch（）返回true，就会让上述三个条件全部成立，从而使得View.dispatchTouchEvent（）直接返回true，事件分发结束
// 若在onTouch（）返回false，就会使得上述三个条件不全部成立，从而使得View.dispatchTouchEvent（）中跳出If，执行onTouchEvent(event)

3.4 View.onTouchEvent()

public boolean onTouchEvent(MotionEvent event) {
    ...
    
    // 是否可点击
    final boolean clickable = ((viewFlags & CLICKABLE) == CLICKABLE
            || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
            || (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE;

    if ((viewFlags & ENABLED_MASK) == DISABLED) {
        if (action == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {
            setPressed(false);
        }
        mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
        // A disabled view that is clickable still consumes the touch
        // events, it just doesn't respond to them.
        return clickable;
    }
    if (mTouchDelegate != null) {
        if (mTouchDelegate.onTouchEvent(event)) {
            return true;
        }
    }

    // 可点击或者悬停长按时
    // 一定返回true
    if (clickable || (viewFlags & TOOLTIP) == TOOLTIP) {
        switch (action) {
            case MotionEvent.ACTION_UP:
            
                ...
                
                    if (!mHasPerformedLongPress && !mIgnoreNextUpEvent) {
                        // 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
                                performClickInternal();
                            }
                        }
                    }
                ...
                    
                break;
                
            case MotionEvent.ACTION_DOWN:
                if (event.getSource() == InputDevice.SOURCE_TOUCHSCREEN) {
                    mPrivateFlags3 |= PFLAG3_FINGER_DOWN;
                }
                mHasPerformedLongPress = false;

                if (!clickable) {
                    checkForLongClick(0, x, y);
                    break;
                }

                if (performButtonActionOnTouchDown(event)) {
                    break;
                }

                // Walk up the hierarchy to determine if we're inside a scrolling container.
                boolean isInScrollingContainer = isInScrollingContainer();

                // For views inside a scrolling container, delay the pressed feedback for
                // a short period in case this is a scroll.
                if (isInScrollingContainer) {
                    mPrivateFlags |= PFLAG_PREPRESSED;
                    if (mPendingCheckForTap == null) {
                        mPendingCheckForTap = new CheckForTap();
                    }
                    mPendingCheckForTap.x = event.getX();
                    mPendingCheckForTap.y = event.getY();
                    postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
                } else {
                    // Not inside a scrolling container, so show the feedback right away
                    setPressed(true, x, y);
                    checkForLongClick(0, x, y);
                }
                break;

            case MotionEvent.ACTION_CANCEL:
                if (clickable) {
                    setPressed(false);
                }
                removeTapCallback();
                removeLongPressCallback();
                mInContextButtonPress = false;
                mHasPerformedLongPress = false;
                mIgnoreNextUpEvent = false;
                mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
                break;

            case MotionEvent.ACTION_MOVE:
                if (clickable) {
                    drawableHotspotChanged(x, y);
                }

                // Be lenient about moving outside of buttons
                if (!pointInView(x, y, mTouchSlop)) {
                    // Outside button
                    // Remove any future long press/tap checks
                    removeTapCallback();
                    removeLongPressCallback();
                    if ((mPrivateFlags & PFLAG_PRESSED) != 0) {
                        setPressed(false);
                    }
                    mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
                }
                break;
        }

        return true;
    }

    // 否则返回false
    return false;
}

private boolean performClickInternal() {
    // Must notify autofill manager before performing the click actions to avoid scenarios where
    // the app has a click listener that changes the state of views the autofill service might
    // be interested on.
    notifyAutofillManagerOnClick();

    return performClick();
}

public boolean performClick() {
    // We still need to call this method to handle the cases where performClick() was called
    // externally, instead of through performClickInternal()
    notifyAutofillManagerOnClick();

    final boolean result;
    final ListenerInfo li = mListenerInfo;
    if (li != null && li.mOnClickListener != null) {
        playSoundEffect(SoundEffectConstants.CLICK);
        li.mOnClickListener.onClick(this);
        result = true;
        // 只要我们通过setOnClickListener（）为控件View注册1个点击事件
        // 那么就会给mOnClickListener变量赋值（即不为空）
        // 则会往下回调onClick（） & performClick（）返回true
    } else {
        result = false;
    }

    sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);

    notifyEnterOrExitForAutoFillIfNeeded(true);

    return result;
}

3.5 事件分发的底层流程

当屏幕被触摸，首先会通过硬件产生触摸事件传入内核，然后走到FrameWork层，最后经过一系列事件处理到达ViewRootImpl的processPointerEvent方法，接下来就是我们要分析的内容了：

// ViewRootImpl.java

privte int processPointerEvent(QueuedInputEvent q) {
    final MotionEvent event = (MotionEvent)q.mEvent;
    ...
    // mVim分部Touch事件，mView就是DecorView
    boolean handled = mView.dispatchPointerEvent(envent);
    ...
}

// DecorView.java

privte final boolean dispatchPointerEvent(MotionEvent envent) {
   if(event.isTouchEvent()){
       // 分发Touch事件
       return dispatchTouchEvent(event);
   } else {
       return dispatchGenericMotionEvent(event);
   }
}

@Override
public final boolean dispatchTouchEvent(MotionEvent ev) {
    // cb其实就是Activity
   final Window.Callback cb = mWindow.getCallBack();
   return cb!=null && !mWindow.isDestroyed() && mFeatureId < 0 ?
   cb.dispatchTouchEvent(ev) : super.dispatchTouchEvent(ev);
}

// Activity.java

public boolean dispatchTouchEvent(MotionEvent ev) {
   if(ev.getAction == MotionEvent.ACTION_DOWN){
       onUserInteraction();
   }
   if(getWindow().superDispatchTouchEvent(ev)){
       return true;
   }
   
   return onTouchEvent(ev);
}

final attach(){
    // 初始化PhoneWindow
    mWindow = new PhoneWindow(this,window,activityConfigCallback);
    mWindow.setWindowControllerCallback(mWindoControllerCallback);
    mWindow.setCallback(this);
    
    // 和WindowManager关联
    mWindow.setWindowManger((WindowManger)context.getSystemService(Context.WINDOW_SERVICE),
    mToken,mComponent.flattenToString(),
    (info.flags & ActivityInfo.FLAG_HARDWARE_ACCLERATED)!=0);
    
    mWindowManager = mWindow.getWindowManager();
}

// PhoneWindow.java

public boolean superDispatchTouchEvent(MotionEvent ev) {
   return mDecor.superDispatchTouchEvent(ev);
}

// DcorView.java

public boolean superDispatchTouchEvent(MotionEvent ev) {
   return super.dispatchTouchEvent(ev);
}

因此，ViewRootImpl->DecorView->Activity->PhoneWindow->DecorView->ViewGroup。

但是这个流程确实有些奇怪，为什么绕来绕去的呢，光DecorView就走了两遍。

主要原因就是解耦。

ViewRootImpl并不知道有Activity这种东西存在，它只是持有了DecorView。所以先传给了DecorView，而DecorView知道有AC，所以传给了AC。

Activity也不知道有DecorView，它只是持有PhoneWindow，所以这么一段调用链就形成了。

Android View 事件分发攻略

攻略大全

1. 粘贴攻略

1.1 View基础知识

1.1.1 MotionEvent

1.1.2 TouchSlop

1.1.3 VelocityTracker

1.1.4 GestureDetector

1.1.5 Scroller

1.2 View的滑动

1.2.1 使用scrollTo/scrollBy

1.2.2 使用动画

1.2.3 改变布局参数

1.2.4 弹性滑动

1.3 View的滑动冲突

1.3.1 外部拦截法

1.3.2 内部拦截法

2. 造火箭攻略

2.1 Activity.dispatchTouchEvent()

2.2 ViewGroup.dispatchTouchEvent()

2.3 View.dispatchTouchEvent()

2.4 Touch事件的后续（MOVE、UP）层级传递

2.5 onTouch()和onTouchEvent()的区别

2.6 事件分发的底层流程

3. 拧螺丝攻略

3.1 Activity.dispatchTouchEvent()

3.2 ViewGroup.dispatchTouchEvent()

3.3 View.dispatchTouchEvent()

3.4 View.onTouchEvent()

3.5 事件分发的底层流程

4. 复制攻略

4.1 《Adnroid开发艺术探索》

Android View 事件分发 攻略

攻略大全

1. 粘贴攻略

1.1 View基础知识

1.1.1 MotionEvent

1.1.2 TouchSlop

1.1.3 VelocityTracker

1.1.4 GestureDetector

1.1.5 Scroller

1.2 View的滑动

1.2.1 使用scrollTo/scrollBy

1.2.2 使用动画

1.2.3 改变布局参数

1.2.4 弹性滑动

1.3 View的滑动冲突

1.3.1 外部拦截法

1.3.2 内部拦截法

2. 造火箭攻略

2.1 Activity.dispatchTouchEvent()

2.2 ViewGroup.dispatchTouchEvent()

2.3 View.dispatchTouchEvent()

2.4 Touch事件的后续（MOVE、UP）层级传递

2.5 onTouch()和onTouchEvent()的区别

2.6 事件分发的底层流程

3. 拧螺丝攻略

3.1 Activity.dispatchTouchEvent()

3.2 ViewGroup.dispatchTouchEvent()

3.3 View.dispatchTouchEvent()

3.4 View.onTouchEvent()

3.5 事件分发的底层流程

4. 复制攻略

4.1 《Adnroid开发艺术探索》

Android View 事件分发攻略