【Android 1.6】View和ViewGroup的touch事件分析和总结

    public boolean dispatchTouchEvent(MotionEvent event) {
        //如果当前view或目标view已经消费了touch事件，则直接返回true，否则调用onTouchEvent方法进行后续点击事件的判断处理
        if (mOnTouchListener != null && (mViewFlags & ENABLED_MASK) == ENABLED &&
                mOnTouchListener.onTouch(this, event)) {
            return true;
        }
        return onTouchEvent(event);
    }

        TextView mTextView = (TextView) findViewById(R.id.text);
        mTextView.setOnTouchListener(new View.OnTouchListener() {
            @Override
            public boolean onTouch(View v, MotionEvent event) {
                Log.d(TAG, "setOnTouchListener");

                // 1.此处返回false，则先响应touch事件，再响应click事件
                // 2.此处返回true，则只响应touch事件，不再响应click事件
                return false;
            }
        });

        mTextView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.d(TAG, "setOnClickListener");
            }
        });

 public boolean onTouchEvent(MotionEvent event) {
        final int viewFlags = mViewFlags;

        // 如果当前View diable了，直接返回不进行事件处理，假如当前view属于可点击的，则返回true,标志应该消费事件；否则返回false
        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));
        }

        // 给当前view的touch代理对象一个机会去处理touch事件，如果当前view的touch代理对象的onTouchEvent方法返回了true，
        // 则此处直接返回true
        if (mTouchDelegate != null) {
            if (mTouchDelegate.onTouchEvent(event)) {
                return true;
            }
        }

        //当是点击事件或长点击事件，则进入循环，处理完之后，返回true
        if (((viewFlags & CLICKABLE) == CLICKABLE ||
                (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)) {
            switch (event.getAction()) {
                case MotionEvent.ACTION_UP:
                    if ((mPrivateFlags & PRESSED) != 0) {//当没有被ACTION_CANCEL时，进入循环
                        // take focus if we don‘t have it already and we should in
                        // touch mode.
                        boolean focusTaken = false;
                        if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {
                            //请求focus，需要聚焦的控件，第一次点击是聚焦，第二次点击才响应点击事件，所以此处一般返回false
                            focusTaken = requestFocus();
                        }

                        if (!mHasPerformedLongPress) {
                            //如果是轻轻的点击，则移除长按事件的检查
                            // This is a tap, so remove the longpress check
                            if (mPendingCheckForLongPress != null) {
                                removeCallbacks(mPendingCheckForLongPress);
                            }

                            // 如果我们已经按压了，且没有focusTaken时，执行点击事件
                            // Only perform take click actions if we were in the pressed state
                            if (!focusTaken) {
                                performClick();//执行点击事件
                            }
                        }

                        if (mUnsetPressedState == null) {
                            //构建取消按压的Runnable对象，提供一个取消按压的能力
                            mUnsetPressedState = new UnsetPressedState();
                        }

                        // 如果取消按压的操作没有执行成功，则立即执行取消按压的动作
                        if (!post(mUnsetPressedState)) {
                            // If the post failed, unpress right now
                            mUnsetPressedState.run();
                        }
                    }
                    break;

                case MotionEvent.ACTION_DOWN: //按下事件
                    mPrivateFlags |= PRESSED; //添加标志，表示已经按压了
                    refreshDrawableState();//更新drawable state
                    if ((mViewFlags & LONG_CLICKABLE) == LONG_CLICKABLE) {//如果是长按事件，则处理长按操作
                        postCheckForLongClick();
                    }
                    break;

                case MotionEvent.ACTION_CANCEL:
                    mPrivateFlags &= ~PRESSED;//添加标志，表示按压要取消掉
                    refreshDrawableState();//更新drawable state
                    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 = ViewConfiguration.get(mContext).getScaledTouchSlop();
                    if ((x < 0 - slop) || (x >= getWidth() + slop) ||
                            (y < 0 - slop) || (y >= getHeight() + slop)) {
                        // 移动到button区域外面了
                        // Outside button
                        if ((mPrivateFlags & PRESSED) != 0) {//当没有被ACTION_CANCEL掉时
                            // Remove any future long press checks
                            if (mPendingCheckForLongPress != null) {
                                //移除长按事件的检查操作
                                removeCallbacks(mPendingCheckForLongPress);
                            }

                            // 将状态切换成not pressed，并更新drawable state
                            // Need to switch from pressed to not pressed
                            mPrivateFlags &= ~PRESSED;
                            refreshDrawableState();
                        }
                    } else {
                        // 移动到button区域内部了
                        // Inside button
                        if ((mPrivateFlags & PRESSED) == 0) {//之前没有按压当前buttion，移动过来才按压上的
                            // Need to switch from not pressed to pressed
                            mPrivateFlags |= PRESSED;
                            refreshDrawableState();
                        }
                    }
                    break;
            }
            return true;
        }

        return false;
    }

 @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        final int action = ev.getAction();
        final float xf = ev.getX();
        final float yf = ev.getY();
        final float scrolledXFloat = xf + mScrollX;
        final float scrolledYFloat = yf + mScrollY;
        final Rect frame = mTempRect;

        boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;

        if (action == MotionEvent.ACTION_DOWN) {
            if (mMotionTarget != null) {
                // this is weird, we got a pen down, but we thought it was
                // already down!
                // XXX: We should probably send an ACTION_UP to the current
                // target.
                mMotionTarget = null;
            }

            // 当前ViewGroup被要求不允许拦截事件，或当前ViewGroup允许去拦截但是并没有真正拦截事件
            // 能否进入if判断去寻找能够处理事件的子view，分为两种情况：
            // 一.disallowIntercept为false,表示子View没有明确要求父View不拦截事件，此时事件是否往子View传递，取决于onInterceptTouchEvent的返回值
            // 1.onInterceptTouchEvent返回false,则进入if判断，表示事件会传递到子View，进入if判断后去寻找处理事件的目标View,如果找到了处理事件的目标view，则将该view赋值给mMotionTarget。
            // 2.onInterceptTouchEvent返回true,则不会进入if判断，也就不会去寻找目标View(此时mMotionTarget不会被赋值，即为null)，表示父View会拦截事件，不会往子View传递事件。
            // 二.disallowIntercept为true,表示子View明确要求父View不拦截事件，不论onInterceptTouchEvent返回true或false，都会进入if判断，去寻找处理事件的目标View。
            // If we‘re disallowing intercept or if we‘re allowing and we didn‘t
            // intercept
            if (disallowIntercept || !onInterceptTouchEvent(ev)) {
                // reset this event‘s action (just to protect ourselves)
                ev.setAction(MotionEvent.ACTION_DOWN);
                // We know we want to dispatch the event down, find a child
                // who can handle it, start with the front-most child.
                final int scrolledXInt = (int) scrolledXFloat;
                final int scrolledYInt = (int) scrolledYFloat;
                final View[] children = mChildren;
                final int count = mChildrenCount;
                for (int i = count - 1; i >= 0; i--) {
                    final View child = children[i];
                    if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE
                            || child.getAnimation() != null) {
                        child.getHitRect(frame);
                        if (frame.contains(scrolledXInt, scrolledYInt)) {
                            // offset the event to the view‘s coordinate system
                            final float xc = scrolledXFloat - child.mLeft;
                            final float yc = scrolledYFloat - child.mTop;
                            ev.setLocation(xc, yc);
                            // child如果是ViewGroup类型，则继续递归调用本类中的dispatchTouchEvent方法
                            // child如果是View类型，则调用View类的dispatchTouchEvent方法,具体见View类的dispatchTouchEvent方法分析
                            if (child.dispatchTouchEvent(ev))  {
                                // Event handled, we have a target now.
                                mMotionTarget = child;
                                return true;
                            }
                            // The event didn‘t get handled, try the next view.
                            // Don‘t reset the event‘s location, it‘s not
                            // necessary here.
                        }
                    }
                }
            }
        }

        boolean isUpOrCancel = (action == MotionEvent.ACTION_UP) ||
                (action == MotionEvent.ACTION_CANCEL);

        if (isUpOrCancel) {
            // 之前已经将FLAG_DISALLOW_INTERCEPT添加到mGroupFlags了，此处将mGroupFlags中的FLAG_DISALLOW_INTERCEPT
            // 取消掉，以重置mGroupFlags
            // Note, we‘ve already copied the previous state to our local
            // variable, so this takes effect on the next event
            mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;
        }

        // The event wasn‘t an ACTION_DOWN, dispatch it to our target if
        // we have one.
        final View target = mMotionTarget;
        if (target == null) {//如果没有找到处理事件的目标View
            // We don‘t have a target, this means we‘re handling the
            // event as a regular view.
            ev.setLocation(xf, yf);
            // 没有找到处理事件的目标View，则直接调用父类的super.dispatchTouchEvent方法
            // 此处可以理解成：
            // FrameLayout内有三个子view，但是这三个子view都没有去处理事件，因此就把FrameLayout当成一个常规的View
            // 然后将touch事件交给它去处理，例如：当为FrameLayout设置touch事件的时候，这个FrameLayout就去响应touch事件
            return super.dispatchTouchEvent(ev);
        }

        // 如果我们有一个子view处理事件，且没有明确要求ViewGroup不拦截事件，再且onInterceptTouchEvent返回true,则当前的ViewGroup传递一个ACTION_CANCEL事件给子View,
        // 并清除子view对象(mMotionTarget置为null)，当下一个move事件进来时，由于target已经被mMotionTarget置null了，所以直接调用上一步的super.dispatchTouchEvent(ev)，
        // 将当前的ViewGroup来当作常规的View类型来处理。
        // 举例理解：
        // 一个自定义的FrameLayout内有包裹着三个子view,当这个自定义的FrameLayout被允许去拦截事件时，就传给之前处理Down事件的这个子view一个ACTION_CANCEL事件，
        // 并把处理Down事件的这个子view对象给清除掉，使这个子view不再处理Down后续的事件，将后续的事件交给这个自定义的FrameLayout来处理(传给onTouchEvent方法)。
        // if have a target, see if we‘re allowed to and want to intercept its
        // events
        if (!disallowIntercept && onInterceptTouchEvent(ev)) {
            final float xc = scrolledXFloat - (float) target.mLeft;
            final float yc = scrolledYFloat - (float) target.mTop;
            ev.setAction(MotionEvent.ACTION_CANCEL);
            ev.setLocation(xc, yc);
            if (!target.dispatchTouchEvent(ev)) {//子View去处理ACTION_CANCEL事件
                // target didn‘t handle ACTION_CANCEL. not much we can do
                // but they should have.
            }
            // clear the target
            mMotionTarget = null;
            // Don‘t dispatch this event to our own view, because we already
            // saw it when intercepting; we just want to give the following
            // event to the normal onTouchEvent().
            return true;
        }

        // 如果是up或cancel事件，则将mMotionTarget置null,清除目标view
        if (isUpOrCancel) {
            mMotionTarget = null;
        }

        // 子View继续处理后续的move,up或cancel事件
        // finally offset the event to the target‘s coordinate system and
        // dispatch the event.
        final float xc = scrolledXFloat - (float) target.mLeft;
        final float yc = scrolledYFloat - (float) target.mTop;
        ev.setLocation(xc, yc);

        return target.dispatchTouchEvent(ev);
    }

package com.android.touchtest;

import android.content.Context;
import android.support.annotation.Nullable;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.widget.TextView;

public class CustomTextView extends TextView {
    private static final String TAG = "kkkkkkkk-CustomTextView";

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

    public CustomTextView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        this(context, attrs, defStyleAttr, 0);
    }

    public CustomTextView(Context context, @Nullable AttributeSet attrs) {
        this(context, attrs, 0);
    }
    
    
    @Override
    public boolean dispatchTouchEvent(MotionEvent event) {
        Log.d(TAG, "dispatchTouchEvent " + codeToString(event.getAction()));
        return super.dispatchTouchEvent(event);
    }

    private String codeToString(int code) {
        switch (code) {
            case MotionEvent.ACTION_DOWN:
                return "ACTION_DOWN";
            case MotionEvent.ACTION_UP:
                return "ACTION_UP";
            case MotionEvent.ACTION_MOVE:
                return "ACTION_MOVE";
            case MotionEvent.ACTION_CANCEL:
                return "ACTION_CANCEL";
            default:
                return "";
        }
    }
}

package com.android.touchtest;

import android.content.Context;
import android.support.annotation.Nullable;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.widget.FrameLayout;

public class CustomFrameLayout extends FrameLayout {
    private static final String TAG = "kkkkkkkk-CustomFrameLayout";

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

    public CustomFrameLayout(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        this(context, attrs, defStyleAttr, 0);
    }

    public CustomFrameLayout(Context context, @Nullable AttributeSet attrs) {
        this(context, attrs, 0);
    }

    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        Log.d(TAG, "onInterceptTouchEvent " + codeToString(ev.getAction()));
        // return super.onInterceptTouchEvent(ev); //super.onInterceptTouchEvent(ev) = false
        return true;//想要拦截事件,具体最后是否会拦截事件，取决于子对父的disallowIntercept的值
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        Log.d(TAG, "onTouchEvent " + codeToString(event.getAction()));
        return super.onTouchEvent(event);
    }

    private String codeToString(int code) {
        switch (code) {
            case MotionEvent.ACTION_DOWN:
                return "ACTION_DOWN";
            case MotionEvent.ACTION_UP:
                return "ACTION_UP";
            case MotionEvent.ACTION_MOVE:
                return "ACTION_MOVE";
            case MotionEvent.ACTION_CANCEL:
                return "ACTION_CANCEL";
            default:
                return "";
        }
    }
}

<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:layout_gravity="center" >

    <com.android.touchtest.CustomFrameLayout
        android:id="@+id/custom_frame_layout"
        android:layout_width="200dip"
        android:layout_height="200dip"
        android:layout_gravity="center"
        android:background="#00ff00" >

        <com.android.touchtest.CustomTextView
            android:id="@+id/custom_text_view"
            android:layout_width="130dip"
            android:layout_height="100dip"
            android:layout_gravity="center"
            android:background="#000000"
            android:text="CustomTextView"
            android:textColor="#FFFFFF" />
    </com.android.touchtest.CustomFrameLayout>

</FrameLayout>

package com.android.touchtest;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;

public class MainActivity extends Activity {
    private static final String TAG = "kkkkkkkk-MainActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        setCustomTextViewListener();
        // setCustomFrameLayoutListener();
    }

    private void setCustomFrameLayoutListener() {
        CustomFrameLayout mCustomFrameLayout = (CustomFrameLayout) findViewById(R.id.custom_frame_layout);
        mCustomFrameLayout.setOnTouchListener(new View.OnTouchListener() {
            @Override
            public boolean onTouch(View v, MotionEvent event) {
                // TODO
                return false;
            }
        });

        mCustomFrameLayout.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.d(TAG, "mCustomFrameLayout setOnClickListener");
            }
        });
    }

    private void setCustomTextViewListener() {
        CustomTextView mCustomTextView = (CustomTextView) findViewById(R.id.custom_text_view);

        // 明确要求父view不拦截事件，此处置为true了，系统会在up或cancel事件时重置为false,所以
        // 如果希望父view一直不拦截事件，则不应该依赖于此处。
        mCustomTextView.getParent().requestDisallowInterceptTouchEvent(true);
        mCustomTextView.setOnTouchListener(new View.OnTouchListener() {
            @Override
            public boolean onTouch(View v, MotionEvent event) {
                // TODO
                return true;
            }
        });

        mCustomTextView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.d(TAG, "mCustomTextView setOnClickListener");
            }
        });
    }

    private String codeToString(int code) {
        switch (code) {
            case MotionEvent.ACTION_DOWN:
                return "ACTION_DOWN";
            case MotionEvent.ACTION_UP:
                return "ACTION_UP";
            case MotionEvent.ACTION_MOVE:
                return "ACTION_MOVE";
            case MotionEvent.ACTION_CANCEL:
                return "ACTION_CANCEL";
            default:
                return "";
        }
    }
}