Android事件分发传递回传机制详解

转载本专栏每一篇博客请注明转载出处地址，尊重原创。此博客转载链接地址：点击打开链接   http://blog.csdn.net/qq_32059827/article/details/52577017

之前对这篇文章写的不够详细，觉得有必要在对这篇文章完善一下。本文使用Log方式分析，不涉及源码。log方式更直观易懂一些。

首先，View的几个基本的继承关系：

本博客案例的图层：

要实现上边这个图层结构，需要自定义View，并在里面加入log打印，只有自定义View才能测试log情况。我们这里自定义View只需要重写几个分发事件方法即可。如下：

MainActivity：

public class MainActivity extends Activity {
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
 
    /**
     * activity的
     */
    @Override
    public boolean dispatchTouchEvent(MotionEvent event) {
    	ActionUtiles.processEvent(event, "Activity+分发+dispatchTouchEvent");
    	return super.dispatchTouchEvent(event);
    }
 
    /**
     * activity的
     */
    @Override
    public boolean onTouchEvent(MotionEvent event) {
    	ActionUtiles.processEvent(event, "Activity+处理+onTouchEvent");
    	return super.onTouchEvent(event);
    }
}

由于Activity只有dispatchTouchEvent和onTouchEvent两个方法。因此重写之
然后，新建两个容器类型的View：

自定义View，第一个容器View----类型属于ViewGroup：（LinearLayout就属于容器类型的View，因此继承自它。继承其他容器View也可以比如RelativeLayout也可以的）

public class ViewGroupOne extends LinearLayout {
 
	public ViewGroupOne(Context context, AttributeSet attrs) {
		super(context, attrs);
	}
 
	public ViewGroupOne(Context context) {
		super(context);
	}
 
	/**
	 * 分发事件
	 */
	@Override
	public boolean dispatchTouchEvent(MotionEvent event) {
		ActionUtiles.processEvent(event, "ViewGroupOne+分发+dispatchTouchEvent");
		return super.dispatchTouchEvent(event);
		//return true;
		//return false;
	}
 
	/**
	 * 拦截事件
	 */
	@Override
	public boolean onInterceptTouchEvent(MotionEvent event) {
		ActionUtiles.processEvent(event, "ViewGroupOne+拦截+onInterceptTouchEvent");
		return super.onInterceptTouchEvent(event);
//		return true;
//		return false;
	}
 
	/**
	 * 处理事件
	 */
	@Override
	public boolean onTouchEvent(MotionEvent event) {
		ActionUtiles.processEvent(event, "ViewGroupOne+处理+onTouchEvent");
		return super.onTouchEvent(event);
//		return true;
	}
 
}

自定义View，第二个容器View----属于ViewGroup：

public class ViewGroupTwo extends LinearLayout {
 
	public ViewGroupTwo(Context context, AttributeSet attrs) {
		super(context, attrs);
	}
 
	public ViewGroupTwo(Context context) {
		super(context);
	}
 
	@Override
	public boolean dispatchTouchEvent(MotionEvent event) {
		//getParent().requestDisallowInterceptTouchEvent(true);//本质上不让父组件的dispatchtouchevent生效
		ActionUtiles.processEvent(event, "ViewGroupTwo+分发+dispatchTouchEvent");
		return super.dispatchTouchEvent(event);
//		return false;
//		return true;
	}
 
	@Override
	public boolean onInterceptTouchEvent(MotionEvent event) {
		ActionUtiles.processEvent(event, "ViewGroupTwo+拦截+onInterceptTouchEvent");
		return super.onInterceptTouchEvent(event);
//		return true;
	}
 
	@Override
	public boolean onTouchEvent(MotionEvent event) {
		ActionUtiles.processEvent(event, "ViewGroupTwo+处理+onTouchEvent");
		return super.onTouchEvent(event);
	}
 
}

加入一个没有子组件的View，类型类似TextView:

public class MyTextView extends TextView {
 
	public MyTextView(Context context, AttributeSet attrs) {
		super(context, attrs);
	}
 
	public MyTextView(Context context) {
		super(context);
	}
 
	@Override
	public boolean dispatchTouchEvent(MotionEvent event) {
		ActionUtiles.processEvent(event, "MyTextView+分发+dispatchTouchEvent");
		return super.dispatchTouchEvent(event);
	}
 
	@Override
	public boolean onTouchEvent(MotionEvent event) {
		ActionUtiles.processEvent(event, "MyTextView+处理+onTouchEvent");
		  return super.onTouchEvent(event);//回传机制
		//return true;//事件消费，不回传
		//return false;//和默认效果一样，回传机制
	}
}

因为每个类，每个事件方法都需要写如下代码：

switch (event.getAction()) {
        case MotionEvent.ACTION_DOWN:
            Log.i(name, "按下ACTION_DOWN");
            break;
        case MotionEvent.ACTION_CANCEL:
            Log.d(name, "取消ACTION_CANCEL");
            break;
        case MotionEvent.ACTION_MOVE:
            Log.e(name, "移动ACTION_MOVE");
            break;
        case MotionEvent.ACTION_UP:
            Log.w(name, "松开ACTION_UP");
            break;
        case MotionEvent.ACTION_OUTSIDE:
            Log.v(name, "点击外面ACTION_OUTSIDE");
            break;

default:
            break;
        }

功能大家都一样，因此抽取一个Utis类来处理这个方法即可，如下：

public class ActionUtiles {
	/**
	 *
	 * @param event处理的事件
	 * @param name组件的名称哪个类触发打印的）
	 */
	public static void processEvent(MotionEvent event,String name){
		switch (event.getAction()) {
		case MotionEvent.ACTION_DOWN:
			Log.i(name, "按下ACTION_DOWN");
			break;
		case MotionEvent.ACTION_CANCEL:
			Log.d(name, "取消ACTION_CANCEL");
			break;
		case MotionEvent.ACTION_MOVE:
			Log.e(name, "移动ACTION_MOVE");
			break;
		case MotionEvent.ACTION_UP:
			Log.w(name, "松开ACTION_UP");
			break;
		case MotionEvent.ACTION_OUTSIDE:
			Log.v(name, "点击外面ACTION_OUTSIDE");
			break;
 
		default:
			break;
		}
	}
}

为了测试不同事件的打印情况，log使用不同的日志级别进行区分。

接着写一个复合上边图层的布局：

<com.example.event.ViewGroupOne
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="#ff0000"
    android:orientation="vertical" >
 
    <com.example.event.ViewGroupTwo
        android:layout_width="200dp"
        android:layout_height="200dp"
        android:background="#00ff00" >
 
        <com.example.event.MyTextView
            android:layout_width="100dp"
            android:layout_height="100dp"
            android:background="#0000ff" >
        </com.example.event.MyTextView>
    </com.example.event.ViewGroupTwo>
 
</com.example.event.ViewGroupOne>

注意：记得自定义View需要写类的全称。

好了，废话不多说，直接运行程序说话。通多点击手机屏幕。对所有的可能情况全部罗列如下：

一、默认情况，对生成的事件方法返回值什么也不做。返回值都是默认情况：

事件1：点击红色位置。看log输出

按下：可以看到，整个事件是Activity先得到事件，调用它的dispatchTouchEvent分发事件，Activity返回值默认传递给ViewGroupOne，调用ViewGroupOne的dispatchTouchEvent方法，此时这个返回值默认return super.dispatchTouchEvent(event);默认的时候它会把事件传递给自己的onInterceptTouchEvent(MotionEvent event)拦截事件看自己是否需要拦截这个事件，但是由于它的返回值也是默return super.onInterceptTouchEvent(event);认，即没做拦截；事件继续传递，传递给自己的onTouchEvent(MotionEvent event)看自己是否处理这个事件；  自己的onTouchEvent(MotionEvent event)处理方法被调用，但是返回值也是默认，return super.onTouchEvent(event);自己并不处理事件。这样事件到了最里层的View也没有被消费，事件开始回传，回传给父容器Activity的onTouchEvent(MotionEvent event) ，Activity也是默认返回值，表示不做任何处理。整个过程事件都没有做处理和拦截，事件作废。松开后：看一下松开事件：由Activity的dispatchTouchEvent开始分发事件自己返回值是默认情况，把事件直接分发给自己的onTouchEvent(MotionEvent event)方法处理事件，自己返回值是默认情况，事件作废。 整个事件过程，并没有任何地方要处理事件， 由up事件log日志，也可以看到：最后松手时的事件，已经与ViewGroupOne没有任何关系。

事件2：点击绿色区域l。看log输出：

这里就会显而易见了。多了ViewGroupTwo，就多往下传递一层，最里面这层没做处理，最后还是回传回来。一直回传到activity事件全部消失

事件3：点击蓝色区域：

这个肯定在意料之中，不用解释也很清楚为何打印此log了。

二、增加处理：

处理1：蓝色区域，MyTextView修改如下代码：

@Override
	public boolean onTouchEvent(MotionEvent event) {
		ActionUtiles.processEvent(event, "MyTextView+处理+onTouchEvent");
 
		return true;//事件消费，不回传
	}

此时要重新运行程序了再点击蓝色区域，看log：

MyTextView的onTouchEvent(MotionEvent event)返回true的意思是，事件由我来处理。它处理了事件，就不可能出现回传了，出现这种log也是顺理成章了。再看UP事件与分发拦截是一致的。最后在MyTextView中消失。这个时候可以对比一了，一都是默认，可以称之为狭义的回传机制，而二的处理1：我们可以称之为狭义的拦截机制，每一次的往下分发，又可称为狭义的传递机制（称之为狭义，可能逼格略高些，是因为不能代表全部，却也不失一般性；最起码拦截与回传分发大致是什么很清楚了）。那接着就细致开来，从狭义走到广义。

处理2：蓝色区域，MyTextView修改如下代码：

@Override
	public boolean onTouchEvent(MotionEvent event) {
		ActionUtiles.processEvent(event, "MyTextView+处理+onTouchEvent");
 
		return false;//和默认效果一样，回传机制
	}

再运行，打印看log：

和默认效果是一样的。回看默认解析。

处理3：蓝色区域，MyTextView的dispatchTouchEvent方法修改如下代码：

@Override
    public boolean dispatchTouchEvent(MotionEvent event) {
        ActionUtiles.processEvent(event, "MyTextView+分发+dispatchTouchEvent");
 
        return true;
 
    }

看log：

MyTextView的dispatchTouchEvent(MotionEvent event)返回值为true，表示不再分发事件也可以说是拦截事件。此时MyTextView的onTouchEvent方法不会被调用，既然是拦截了事件也不会回传。

处理4：蓝色区域，MyTextView的dispatchTouchEvent方法修改如下代码：

@Override
    public boolean dispatchTouchEvent(MotionEvent event) {
        ActionUtiles.processEvent(event, "MyTextView+分发+dispatchTouchEvent");
        return false;
    }

看log输出：

MyTextView的dispatchTouchEvent(MotionEvent event)返回值为false，表示我自己MyTextView不做事件的分发，那么，我自己的后续方法（onTouchEvent方法）不再被调用执行。直接回传给父控件的onTouchEvent处理方法处理事件，父控件都是默认情况。事件一直回传，直到Activity，事件消失。

说明：上边都是针对蓝色区域点击；这是因为，只有点击了蓝色位置，事件才有可能传递到MyTextView，点击其他位置根本不会调MyTextView的任何方法。

第一次总结：

TextView（没有子组件类型）

dispatchTouchEvent(MotionEvent event)

return true; //不再分发事件，表示拦截事件，拦截掉不会回传，事件在此消失
            return false;//表示不做分发事件，事件不被拦截，回传给父控件的处理方法

return super.onTouchEvent() ;//事件传递机制，传递给自己的onTouchEvent方法。

onTouchEvent()
            return true; //自己处理消费掉事件，事件消费不再回传
            return false;或者 return super.onTouchEvent() ;//效果一样，事件回传给父组件

处理5：点击绿色区域，ViewGroupTwo的dispatchTouchEvent方法做如下修改：

@Override
	public boolean dispatchTouchEvent(MotionEvent event) {
		ActionUtiles.processEvent(event, "ViewGroupTwo+分发+dispatchTouchEvent");
		return true;
	}

看log：

由于ViewGroupTwo的dispatchTouchEvent方法返回值为true，则事件被拦截，不会往下传递同时也不会回传。事件在此消失。

处理6：点击绿色区域，ViewGroupTwo的dispatchTouchEvent方法做如下修改：

@Override
    public boolean dispatchTouchEvent(MotionEvent event) {
        ActionUtiles.processEvent(event, "ViewGroupTwo+分发+dispatchTouchEvent");
        return false;
    }

看log：

由于ViewGroupTwo的dispatchTouchEvent方法返回值为false，这跟MyTextView的dispatchTouchEvent返回值为false时候原因是一样的。这个时候，表示我自己不做事件分发，自己的onInterceptTouchEvent方法不会被调用（由于MyTextView没有onInterceptTouchEvent，它是onTouchEvent方法不会被调用），做回传机制。回传给父控件的处理方法，调用父控件的 onTouchEvent方法。父控件默认值，一直传递到Activity，最终事件消失。

说明：这里点击绿色区域和蓝色区域效果是一样的，确切的说没必要点击蓝色区域测试。因为，dispatchTouchEvent并不会直接影响子控件的调用情况。他只决定自己的onInterceptTouchEvent方法是否会被调用。

处理6：点击蓝色区域，ViewGroupTwo的onInterceptTouchEvent方法做如下修改：

@Override
    public boolean onInterceptTouchEvent(MotionEvent event) {
        ActionUtiles.processEvent(event, "ViewGroupTwo+拦截+onInterceptTouchEvent");
        return true;
    }

看log：

由于ViewGroupTwo的onInterceptTouchEvent方法返回值为true,表示我要拦截事件，而且事件交给我自己的处理事件，看处理不处理，如果不处理，则回传机制，回传事件给父控件的处理方法，看是否处理事件。

说明：这里点击绿色区域和蓝色区域效果是一样的，虽然ViewGroupTwo的onInterceptTouchEvent方法可能与孩子控件的dispatchTouchEvent方法有影响，但是由于自己的onInterceptTouchEvent的返回值为true，表示拦截事件，那么直接调用自己的onTouchEvent方法，而不会去调用孩子的dispatchTouchEvent方法。因而，点击蓝色绿色位置其实效果是一样的。

处理7：点击蓝色区域，ViewGroupTwo的onInterceptTouchEvent方法做如下修改：

@Override
    public boolean onInterceptTouchEvent(MotionEvent event) {
        ActionUtiles.processEvent(event, "ViewGroupTwo+拦截+onInterceptTouchEvent");
 
        return false;
    }

可以看到，此时跟默认return super.onInterceptTouchEvent(event);效果是一摸一样的。

说明：这个时候点击绿色区域就不行了。因为点击绿色区域，看不到事件传递给孩子组件的过程。

处理8：点击蓝色区域，ViewGroupTwo的onTouchEvent方法做如下修改：

注意：这个方法想要执行，前提是在ViewGroupTwo的onInterceptTouchEvent方法返回true的时候，或者孩子组件都不做事件处理的时候。因为，自己的onInterceptTouchEvent为true拦截后调用自己的onTouchEvent方法是否做处理。孩子组件如果都是默认，为回传机制，最终肯定会回到自己的onTouchEvent处理事件。

@Override
	public boolean onTouchEvent(MotionEvent event) {
		ActionUtiles.processEvent(event, "ViewGroupTwo+处理+onTouchEvent");
 
		return true;
 
	}

看log：

ViewGroupTwo的onTouchEvent方法返回了true，表示调用了我之后，我就做处理事件。由于ViewGroupTwo的onInterceptTouchEvent返回值为默认或者false，不会立即调用自己的onTouchEvent处理事件， 我们按下的时候，事件还是继续分发给孩子组件，孩子组件没处理事件，就会回传给自己的onTouchEvent，问自己是否处理？true，处理事件，事件在此消失。同样地，这里点击绿色区域也没法测试，原因同上。我们可以看一下UP事件，UP事件直观的告诉我们，事件是由自己处理的。

测试ViewGroupTwo的onTouchEvent方法返回了false的时候，跟默认的return super.onTouchEvent(event);效果是一样的。这个可以自行测试。

处理9：混合处理。点击蓝色区域，ViewGroupTwo的onTouchEvent方法和onInterceptTouchEvent方法做如下修改：

@Override
	public boolean onInterceptTouchEvent(MotionEvent event) {
		ActionUtiles.processEvent(event, "ViewGroupTwo+拦截+onInterceptTouchEvent");
		return true;
	}
 
	@Override
	public boolean onTouchEvent(MotionEvent event) {
		ActionUtiles.processEvent(event, "ViewGroupTwo+处理+onTouchEvent");
		return true;
	}

看log日志：

相信这是在意料之中的事情了吧？由于我自己的onInterceptTouchEvent方法返回值true，表示我要做拦截事件，那么孩子的任何方法肯定不会被调用了，不会得到事件。直接调用自己的处理方法onTouchEvent。问自己处理不处理？返回值为true，处理事件了，则事件终止，被自己消费掉。这个时候，点击绿色区域效果也是一样的，这是因为自己的onInterceptTouchEvent方法返回值true，孩子压根得不到点击事件。

第二次总结：

2,ViewGroup
      dispatchTouchEvent
            return true;//事件分发拦截、事件回传拦截。自己消费，不往下（子组件）（不分发）、不往上传递（不回传）
            return false;//事件拦截、事件回传。自己不处理，回传给父组件onTouchEvent方法处理
            return super.dis.....;//事件分发。问自己onInterceptTouchEvent是否拦截
                   问自己  >onInterceptTouchEvent
                                true:  肯定会调用自己onTouchEvent();看是否自己消费事件。但是可能会去孩子那里执行一下MotionEvent.ACTION_CANCEL:，给孩子打声招呼。
                                false 或  super: 两者效果相同，事件传递，默认往下传递，调用孩子组件的dispatchTouchEvent
                              
                                   onInterceptTouchEvent返回true时：问自己>onTouchEvent()
                                              true: 自己消费（不回传）
                                              false 或 super: 两者效果相同，继续回传，回传给父亲组件的onTouchEvent()

处理10：ViewGroupOne的dispatchTouchEvent方法做如下修改，点击任意区域：

	@Override
	public boolean dispatchTouchEvent(MotionEvent event) {
		ActionUtiles.processEvent(event, "ViewGroupOne+分发+dispatchTouchEvent");
		return true;
	}

运行程序，点击蓝色位置看log：

其实你会发现。不管点击屏幕哪个位置，都打印这样的log

这是因为，ViewGroupOne的dispatchTouchEvent返回true了，相当于在ViewGroupOne的分发事件地方就拦截了事件（称之为拦截，也因为没有回传，从UP日志里也可以看出没有回传）。事件消失。

处理11：ViewGroupOne的dispatchTouchEvent方法做如下修改，点击任意位置：

@Override
	public boolean dispatchTouchEvent(MotionEvent event) {
		ActionUtiles.processEvent(event, "ViewGroupOne+分发+dispatchTouchEvent");
 
		return false;
	}

返回false，表示自己的dispatchTouchEvent不做处理，即不做分发事件。做回传，回传给activity的onTouchEvent处理，最后事件消失。这里同样点击任意位置都是这个log，因为dispatchTouchEvent只有返回默认的时候，才会分发事件。

注意：ViewGroupOne的dispatchTouchEvent方法默认返回super.dispatchTouchEvent(event);的时候是要传递给自己的onInterceptTouchEvent方法的，问这个方式是否做拦截。上边其实已经不知不觉介绍了这个情况。此时可以总结，只有在ViewGroupOne的dispatchTouchEvent方法默认返回super.dispatchTouchEvent(event);的时候才会去调用自己的onInterceptTouchEvent(MotionEvent event) 拦截事件。其他都属于拦截事件，返回true的话甚至连回传机制都消失。

处理12：ViewGroupOne的onInterceptTouchEvent方法做如下修改，点击红色区域：

@Override
	public boolean onInterceptTouchEvent(MotionEvent event) {
		ActionUtiles.processEvent(event, "ViewGroupOne+拦截+onInterceptTouchEvent");
		return true;
	}

log情况

自己的onInterceptTouchEvent(MotionEvent event)拦截事件返回为true，表名自己要拦截，不向下传递。调用自己的onTouchEvent(MotionEvent event)问自己是否处理。由于自己默认不处理，又回传到activity事件消失。同样的，这里点击任何位置log日志都是如此。因为，我拦截事件，只允许事件调用自己的onTouchEvent方法问是否自己做处理，如果自己不作处理事件回传了，如果自己处理事件，事件就会消失。

处理13：ViewGroupOne的onInterceptTouchEvent(MotionEvent event)拦截事件返回false

@Override
	public boolean onInterceptTouchEvent(MotionEvent event) {
		ActionUtiles.processEvent(event, "ViewGroupOne+拦截+onInterceptTouchEvent");
		return false;
	}

又是默认的机制。

处理14：ViewGroupOne的onTouchEvent做如下处理：

注意：这个方法想要执行，前提是在ViewGroupOne的onInterceptTouchEvent方法返回true的时候，或者孩子组件都不做事件处理的时候。因为，自己的onInterceptTouchEvent为true拦截后调用自己的onTouchEvent方法是否做处理。孩子组件如果都是默认，为回传机制，最终肯定会回到自己的onTouchEvent处理事件。

@Override
	public boolean onTouchEvent(MotionEvent event) {
		ActionUtiles.processEvent(event, "ViewGroupOne+处理+onTouchEvent");
		return true;
	}

看log：

返回true。当孩子组件都做默认处理，事件会回传到自己的onTouchEvent方法。  自己处理事件，也就没了回传机制。事件在此消失。

处理15：ViewGroupOne的onTouchEvent返回为false。不用打印也可以清楚，与默认效果是一样的。

处理16：混合处理。ViewGroupOne的onTouchEvent和onInterceptTouchEvent做如下处理，点击蓝色区域：

	@Override
	public boolean onInterceptTouchEvent(MotionEvent event) {
		ActionUtiles.processEvent(event, "ViewGroupOne+拦截+onInterceptTouchEvent");
		return true;
	}
 
	@Override
	public boolean onTouchEvent(MotionEvent event) {
		ActionUtiles.processEvent(event, "ViewGroupOne+处理+onTouchEvent");
		return true;
 	}

看log：

由于自己的onInterceptTouchEvent方法返回为true，表示我要处理事件，不再往下传递事件，调用自己的onTouchEvent方法，问自己是否处理，返回了true，说明自己处理事件。事件在此消费，事件消失。

对于ViewGroupTwo和ViewGroupOne总结部分是一摸一样的。就不再多赘述。最后，再用一张草图做一个收尾：：

此草图虽然潦草，但是最能说明问题，基本包含了所有可能的情况。

对于拦截机制详细介绍就完毕了，但是除了上边这些情况外，还有许多的分支情况；但是大同小异，仔细分析一下，就能得出正确的结论。以后此专栏可能还会再次探讨类似问题，下一次讨论应该是直接通过源码来分析这个问题。

喜欢的话可以关注我博客，有问题大家一起交流。也可以动手微信扫描下方二维码查看更多安卓文章：

打开微信搜索公众号  Android程序员开发指南  或者手机扫描下方二维码 在公众号阅读更多Android文章。

微信公众号图片：