Android中事件的分发机制

最新推荐文章于 2022-12-15 17:23:08 发布
最新推荐文章于 2022-12-15 17:23:08 发布
阅读量3k 收藏 5
点赞数 1
分类专栏： Android高级
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiayi_yao/article/details/51138080
版权

Android事件构成

在Android中，事件主要包括点按、长按、拖拽、滑动等，点按又包括单击和双击，另外还包括单指操作和多指操作。所有这些都构成了Android中的事件响应。总的来说，所有的事件都由如下三个部分作为基础：

  • 按下（ACTION_DOWN）
  • 移动（ACTION_MOVE）
  • 抬起（ACTION_UP）

所有的操作事件首先必须执行的是按下操作（ACTIONDOWN），之后所有的操作都是以按下操作作为前提，当按下操作完成后，接下来可能是一段移动（ACTIONMOVE）然后抬起（ACTION_UP），或者是按下操作执行完成后没有移动就直接抬起。这一系列的动作在Android中都可以进行控制。

我们知道，所有的事件操作都发生在触摸屏上，而在屏幕上与我们交互的就是各种各样的视图组件（View），在Android中，所有的视图都继承于View，另外通过各种布局组件（ViewGroup）来对View进行布局，ViewGroup也继承于View。所有的UI控件例如Button、TextView都是继承于View，而所有的布局控件例如RelativeLayout、容器控件例如ListView都是继承于ViewGroup。所以，我们的事件操作主要就是发生在View和ViewGroup之间，那么View和ViewGroup中主要有哪些方法来对这些事件进行响应呢？记住如下3个方法，我们通过查看View和ViewGroup的源码可以看到：

View.java

public boolean dispatchTouchEvent(MotionEvent event)
public boolean onTouchEvent(MotionEvent event)

ViewGroup.java

public boolean dispatchTouchEvent(MotionEvent event)
public boolean onTouchEvent(MotionEvent event) 
public boolean onInterceptTouchEvent(MotionEvent event)

在View和ViewGroup中都存在dispatchTouchEvent和onTouchEvent方法，但是在ViewGroup中还有一个onInterceptTouchEvent方法，那这些方法都是干嘛的呢？别急，我们先看看他们的返回值。这些方法的返回值全部都是boolean型，为什么是boolean型呢，看看本文的标题，“事件传递”，传递的过程就是一个接一个，那到了某一个点后是否要继续往下传递呢？你发现了吗，“是否”二字就决定了这些方法应该用boolean来作为返回值。没错，这些方法都返回true或者是false。在Android中，所有的事件都是从开始经过传递到完成事件的消费，这些方法的返回值就决定了某一事件是否是继续往下传，还是被拦截了，或是被消费了。

接下来就是这些方法的参数，都接受了一个MotionEvent类型的参数，MotionEvent继承于InputEvent，用于标记各种动作事件。之前提到的ACTIONDOWN、ACTIONMOVE、ACTION_UP都是MotinEvent中定义的常量。我们通过MotionEvent传进来的事件类型来判断接收的是哪一种类型的事件。到现在，这三个方法的返回值和参数你应该都明白了，接下来就解释一下这三个方法分别在什么时候处理事件。

  • dispatchTouchEvent方法用于事件的分发，Android中所有的事件都必须经过这个方法的分发，然后决定是自身消费当前事件还是继续往下分发给子控件处理。返回true表示不继续分发，事件没有被消费。返回false则继续往下分发，如果是ViewGroup则分发给onInterceptTouchEvent进行判断是否拦截该事件。
  • onTouchEvent方法用于事件的处理，返回true表示消费处理当前事件，返回false则不处理，交给子控件进行继续分发。
  • onInterceptTouchEvent是ViewGroup中才有的方法，View中没有，它的作用是负责事件的拦截，返回true的时候表示拦截当前事件，不继续往下分发，交给自身的onTouchEvent进行处理。返回false则不拦截，继续往下传。这是ViewGroup特有的方法，因为ViewGroup中可能还有子View，而在Android中View中是不能再包含子View的。

到目前为止，Android中事件的构成以及事件处理方法的作用你应该比较清楚了，接下来我们就通过一个Demo来实际体验实验一下。

Android事件处理

首先在Eclipse新建一个工程，并新建一个类RTButton继承Button，用来实现我们对按钮事件的跟踪。

RTButton.java

<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-size:18px;">public class RTButton extends Button {
	public RTButton(Context context, AttributeSet attrs) {
		super(context, attrs);
	}

	@Override
	public boolean dispatchTouchEvent(MotionEvent event) {
		switch (event.getAction()) {
		case MotionEvent.ACTION_DOWN:
			System.out.println("RTButton---dispatchTouchEvent---DOWN");
			break;
		case MotionEvent.ACTION_MOVE:
			System.out.println("RTButton---dispatchTouchEvent---MOVE");
			break;
		case MotionEvent.ACTION_UP:
			System.out.println("RTButton---dispatchTouchEvent---UP");
			break;
		default:
			break;
		}
		return super.dispatchTouchEvent(event);
	}

	@Override
	public boolean onTouchEvent(MotionEvent event) {
		switch (event.getAction()) {
		case MotionEvent.ACTION_DOWN:
			System.out.println("RTButton---onTouchEvent---DOWN");
			break;
		case MotionEvent.ACTION_MOVE:
			System.out.println("RTButton---onTouchEvent---MOVE");
			break;
		case MotionEvent.ACTION_UP:
			System.out.println("RTButton---onTouchEvent---UP");
			break;
		default:
			break;
		}
		return super.onTouchEvent(event);
	}
}</span></span>


在RTButton中我重写了dispatchTouchEvent和onTouchEvent方法，并获取了MotionEvent各个事件状态，打印输出了每一个状态下的信息。然后在activity_main.xml中直接在根布局下放入自定义的按钮RTButton。

activity_main.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/myLayout"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >
    
    <com.ryantang.eventdispatchdemo.RTButton 
        android:id="@+id/btn"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Button"/>

</LinearLayout>

接下来在Activity中为RTButton设置onTouch和onClick的监听器来跟踪事件传递的过程，另外，Activity中也有一个dispatchTouchEvent方法和一个onTouchEvent方法，我们也重写他们并输出打印信息。

MainActivity.java

public class MainActivity extends Activity {
	private RTButton button;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		button = (RTButton)this.findViewById(R.id.btn);
		button.setOnTouchListener(new OnTouchListener() {
			
			@Override
			public boolean onTouch(View v, MotionEvent event) {
				switch (event.getAction()) {
				case MotionEvent.ACTION_DOWN:
					System.out.println("RTButton---onTouch---DOWN");
					break;
				case MotionEvent.ACTION_MOVE:
					System.out.println("RTButton---onTouch---MOVE");
					break;
				case MotionEvent.ACTION_UP:
					System.out.println("RTButton---onTouch---UP");
					break;
				default:
					break;
				}
				return false;
			}
		});
		
		button.setOnClickListener(new OnClickListener() {
			
			@Override
			public void onClick(View v) {
				System.out.println("RTButton clicked!");
			}
		});
		
	}

	@Override
	public boolean dispatchTouchEvent(MotionEvent event) {
		switch (event.getAction()) {
		case MotionEvent.ACTION_DOWN:
		  System.out.println("Activity---dispatchTouchEvent---DOWN");
		  break;
		case MotionEvent.ACTION_MOVE:
	          System.out.println("Activity---dispatchTouchEvent---MOVE");
		  break;
		case MotionEvent.ACTION_UP:
		  System.out.println("Activity---dispatchTouchEvent---UP");
		  break;
		default:
		  break;
		}
		return super.dispatchTouchEvent(event);
	}

	@Override
	public boolean onTouchEvent(MotionEvent event) {
		switch (event.getAction()) {
		case MotionEvent.ACTION_DOWN:
		  System.out.println("Activity---onTouchEvent---DOWN");
		  break;
		case MotionEvent.ACTION_MOVE:
		  System.out.println("Activity---onTouchEvent---MOVE");
		  break;
		case MotionEvent.ACTION_UP:
		  System.out.println("Activity---onTouchEvent---UP");
		  break;
		default:
		  break;
		}
		return super.onTouchEvent(event);
	}
}

代码部分已经完成了，接下来运行工程，并点击按钮，查看日志输出信息，我们可以看到如下结果：


通过日志输出可以看到，首先执行了Activity的dispatchTouchEvent方法进行事件分发，在MainActivity.java代码第55行，dispatchTouchEvent方法的返回值是super.dispatchTouchEvent(event)，因此调用了父类方法，我们进入Activity.java的源码中看看具体实现。

Activity.java

	/**
     * Called to process touch screen events.  You can override this to
     * intercept all touch screen events before they are dispatched to the
     * window.  Be sure to call this implementation for touch screen events
     * that should be handled normally.
     * 
     * @param ev The touch screen event.
     * 
     * @return boolean Return true if this event was consumed.
     */
    public boolean dispatchTouchEvent(MotionEvent ev) {
        if (ev.getAction() == MotionEvent.ACTION_DOWN) {
            onUserInteraction();
        }
        if (getWindow().superDispatchTouchEvent(ev)) {
            return true;
        }
        return onTouchEvent(ev);
    }

从源码中可以看到，dispatchTouchEvent方法只处理了ACTIONDOWN事件，前面提到过，所有的事件都是以按下为起点的，所以，Android认为当ACTIONDOWN事件没有执行时，后面的事件都是没有意义的，所以这里首先判断ACTION_DOWN事件。如果事件成立，则调用了onUserInteraction方法，该方法可以在Activity中被重写，在事件被分发前会调用该方法。该方法的返回值是void型，不会对事件传递结果造成影响，接着会判断getWindow().superDispatchTouchEvent(ev)的执行结果，看看它的源码：

Activity.java

    /**
     * Used by custom windows, such as Dialog, to pass the touch screen event
     * further down the view hierarchy. Application developers should
     * not need to implement or call this.
     *
     */
    public abstract boolean superDispatchTouchEvent(MotionEvent event);

通过源码注释我们可以了解到这是个抽象方法，用于自定义的Window，例如自定义Dialog传递触屏事件，并且提到开发者不需要去实现或调用该方法，系统会完成，如果我们在MainActivity中将dispatchTouchEvent方法的返回值设为true，那么这里的执行结果就为true，从而不会返回执行onTouchEvent(ev)，如果这里返回false，那么最终会返回执行onTouchEvent方法，由此可知，接下来要调用的就是onTouchEvent方法了。别急，通过日志输出信息可以看到，ACTION_DOWN事件从Activity被分发到了RTButton，接着执行了onTouch和onTouchEvent方法，为什么先执行onTouch方法呢？我们到RTButton中的dispatchTouchEvent看看View中的源码是如何处理的。

View.java

	/**
     * Pass the touch screen motion event down to the target view, or this
     * view if it is the target.
     *
     * @param event The motion event to be dispatched.
     * @return True if the event was handled by the view, false otherwise.
     */
    public boolean dispatchTouchEvent(MotionEvent event) {
        if (mInputEventConsistencyVerifier != null) {
            mInputEventConsistencyVerifier.onTouchEvent(event, 0);
        }

        if (onFilterTouchEventForSecurity(event)) {
            //noinspection SimplifiableIfStatement
            ListenerInfo li = mListenerInfo;
            if (li != null && li.mOnTouchListener != null && (mViewFlags &
 ENABLED_MASK) == ENABLED  && li.mOnTouchListener.onTouch(this, event)) {
                return true;
            }

            if (onTouchEvent(event)) {
                return true;
            }
        }

        if (mInputEventConsistencyVerifier != null) {
            mInputEventConsistencyVerifier.onUnhandledEvent(event, 0);
        }
        return false;
    }

挑选关键代码进行分析，可以看代码第16行，这里有几个条件，当几个条件都满足时该方法就返回true，当条件li.mOnTouchListener不为空时，通过在源码中查找，发现mOnTouchListener是在以下方法中进行设置的。

View.java

	/**
     * Register a callback to be invoked when a touch event is sent to this view.
     * @param l the touch listener to attach to this view
     */
    public void setOnTouchListener(OnTouchListener l) {
        getListenerInfo().mOnTouchListener = l;
    }

这个方法就已经很熟悉了，就是我们在MainActivity.java中为RTButton设置的onTouchListener，条件(mViewFlags & ENABLED_MASK) == ENABLED判断的是当前View是否是ENABLE的，默认都是ENABLE状态的。接着就是li.mOnTouchListener.onTouch(this, event)条件，这里调用了onTouch方法，该方法的调用就是我们在MainActivity.java中为RTButton设置的监听回调，如果该方法返回true，则整个条件都满足，dispatchTouchEvent就返回true，表示该事件就不继续向下分发了，因为已经被onTouch消费了。

如果onTouch返回的是false，则这个判断条件不成立，接着执行onTouchEvent(event)方法进行判断，如果该方法返回true，表示事件被onTouchEvent处理了，则整个dispatchTouchEvent就返回true。到这里，我们就可以回答之前提出的“为什么先执行onTouch方法”的问题了。到目前为止，ACTIONDOWN的事件经过了从Activity到RTButton的分发，然后经过onTouch和onTouchEvent的处理，最终，ACTIONDOWN事件交给了RTButton得onTouchEvent进行处理。

当我们的手（我这里用的Genymotion然后用鼠标进行的操作，用手的话可能会执行一些ACTIONMOVE操作）从屏幕抬起时，会发生ACTIONUP事件。从之前输出的日志信心中可以看到，ACTIONUP事件同样从Activity开始到RTButton进行分发和处理，最后，由于我们注册了onClick事件，当onTouchEvent执行完毕后，就调用了onClick事件，那么onClick是在哪里被调用的呢？继续回到View.java的源代码中寻找。由于onTouchEvent在View.java中的源码比较长，这里就不贴出来了，感兴趣的可以自己去研究一下，通过源码阅读，我们在ACTIONUP的处理分支中可以看到一个performClick()方法，从这个方法的源码中可以看到执行了哪些操作。

View.java

	/**
     * Call this view's OnClickListener, if it is defined.  Performs all normal
     * actions associated with clicking: reporting accessibility event, playing
     * a sound, etc.
     *
     * @return True there was an assigned OnClickListener that was called, false
     *         otherwise is returned.
     */
    public boolean performClick() {
        sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);

        ListenerInfo li = mListenerInfo;
        if (li != null && li.mOnClickListener != null) {
            playSoundEffect(SoundEffectConstants.CLICK);
            li.mOnClickListener.onClick(this);
            return true;
        }

        return false;
    }

在if分支里可以看到执行了li.mOnClickListener.onClick(this);这句代码，这里就执行了我们为RTButton实现的onClick方法，所以，到目前为止，可以回答前一个“onClick是在哪里被调用的呢？”的问题了，onClick是在onTouchEvent中被执行的，并且，onClick要后于onTouch的执行。

到此，点击按钮的事件传递就结束了，我们结合源代码窥探了其中的执行细节，如果我们修改各个事件控制方法的返回值又会发生什么情况呢，带着这个问题，进入下一节的讨论。

Android事件拦截

从上一节分析中，我们知道了在Android中存在哪些事件类型，事件的传递过程以及在源码中对应哪些处理方法。我们可以知道在Android中，事件是通过层级传递的，一次事件传递对应一个完整的层级关系，例如上节中分析的ACTIONDOWN事件从Activity传递到RTButton，ACTIONUP事件也同样。结合源码分析各个事件处理的方法，也可以明确看到事件的处理流程。

之前提过，所有事件处理方法的返回值都是boolean类型的，现在我们来修改这个返回值，首先从Activity开始，根据之前的日志输出结果，首先执行的是Activity的dispatchTouchEvent方法，现在将之前的返回值super.dispatchTouchEvent(event)修改为true，然后重新编译运行并点击按钮，看到如下的日志输出结果。


可以看到，事件执行到dispatchTouchEvent方法就没有再继续往下分发了，这也验证了之前的说法，返回true时，不再继续往下分发，从之前分析过的Activity的dispatchTouchEvent源码中也可知，当返回true时，就没有去执行onTouchEvent方法了。

接着，将上述修改还原，让事件在Activity这继续往下分发，接着就分发到了RTButton，将RTButton的dispatchTouchEvent方法的返回值修改为true，重新编译运行并查看输出日志结果。


从结果可以看到，事件在RTButton的dispatchTouchEvent方法中就没有再继续往下分发了。接着将上述修改还原，将RTButton的onTouchEvent方法返回值修改为true，让其消费事件，根据之前的分析，onClick方法是在onTouchEvent方法中被调用的，事件在这被消费后将不会调用onClick方法了，编译运行，得到如下日志输出结果。


跟分析结果一样，onClick方法并没有被执行，因为事件在RTButton的onTouchEvent方法中被消费了。下图是整个事件传递的流程图。


到目前为止，Android中的事件拦截机制就分析完了。但这里我们只讨论了单布局结构下单控件的情况，如果是嵌套布局，那情况又是怎样的呢？接下来我们就在嵌套布局的情况下对Android的事件传递机制进行进一步的探究和分析。

Android嵌套布局事件传递

首先，新建一个类RTLayout继承于LinearLayout，同样重写dispatchTouchEvent和onTouchEvent方法，另外，还需要重写onInterceptTouchEvent方法，在文章开头介绍过，这个方法只有在ViewGroup和其子类中才存在，作用是控制是否需要拦截事件。这里不要和dispatchTouchEvent弄混淆了，后者是控制对事件的分发，并且后者要先执行。

那么，事件是先传递到View呢，还是先传递到ViewGroup的？通过下面的分析我们可以得出结论。首先，我们需要对工程代码进行一些修改。

RTLayout.java

public class RTLayout extends LinearLayout {
	public RTLayout(Context context, AttributeSet attrs) {
		super(context, attrs);
	}

	@Override
	public boolean dispatchTouchEvent(MotionEvent event) {
		switch (event.getAction()) {
		case MotionEvent.ACTION_DOWN:
		  System.out.println("RTLayout---dispatchTouchEvent---DOWN");
		  break;
		case MotionEvent.ACTION_MOVE:
		  System.out.println("RTLayout---dispatchTouchEvent---MOVE");
		  break;
		case MotionEvent.ACTION_UP:
		  System.out.println("RTLayout---dispatchTouchEvent---UP");
		  break;
		default:
		  break;
		}
		return super.dispatchTouchEvent(event);
	}

	@Override
	public boolean onInterceptTouchEvent(MotionEvent event) {
		switch (event.getAction()) {
		case MotionEvent.ACTION_DOWN:
			System.out.println("RTLayout---onInterceptTouchEvent---DOWN");
			break;
		case MotionEvent.ACTION_MOVE:
			System.out.println("RTLayout---onInterceptTouchEvent---MOVE");
			break;
		case MotionEvent.ACTION_UP:
			System.out.println("RTLayout---onInterceptTouchEvent---UP");
			break;
		default:
			break;
		}
		return super.onInterceptTouchEvent(event);
	}
	
	@Override
	public boolean onTouchEvent(MotionEvent event) {
		switch (event.getAction()) {
		case MotionEvent.ACTION_DOWN:
			System.out.println("RTLayout---onTouchEvent---DOWN");
			break;
		case MotionEvent.ACTION_MOVE:
			System.out.println("RTLayout---onTouchEvent---MOVE");
			break;
		case MotionEvent.ACTION_UP:
			System.out.println("RTLayout---onTouchEvent---UP");
			break;
		default:
			break;
		}
		return super.onTouchEvent(event);
	}
}

同时，在布局文件中为RTButton添加一个父布局，指明为自定义的RTLayout，修改后的布局文件如下。

activity_main.xml

<LinearLayout 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" >

    <com.ryantang.eventdispatchdemo.RTLayout
        android:id="@+id/myLayout"
        android:layout_width="match_parent"
        android:layout_height="match_parent" >

        <com.ryantang.eventdispatchdemo.RTButton
            android:id="@+id/btn"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Button" />
    </com.ryantang.eventdispatchdemo.RTLayout>

</LinearLayout>

最后，我们在Activity中也为RTLayout设置onTouch和onClick事件，在MainActivity中添加如下代码。

MainActivity.java

	rtLayout.setOnTouchListener(new OnTouchListener() {
			
			@Override
			public boolean onTouch(View v, MotionEvent event) {
				switch (event.getAction()) {
				case MotionEvent.ACTION_DOWN:
					System.out.println("RTLayout---onTouch---DOWN");
					break;
				case MotionEvent.ACTION_MOVE:
					System.out.println("RTLayout---onTouch---MOVE");
					break;
				case MotionEvent.ACTION_UP:
					System.out.println("RTLayout---onTouch---UP");
					break;
				default:
					break;
				}
				return false;
			}
		});
		
	rtLayout.setOnClickListener(new OnClickListener() {
			
			@Override
			public void onClick(View v) {
				System.out.println("RTLayout clicked!");
			}
		});

代码修改完毕后，编译运行工程，同样，点击按钮，查看日志输出结果如下：


从日志输出结果我们可以看到，嵌套了RTLayout以后，事件传递的顺序变成了Activity->RTLayout->RTButton，这也就回答了前面提出的问题，Android中事件传递是从ViewGroup传递到View的，而不是反过来传递的。

从输出结果第三行可以看到，执行了RTLayout的onInterceptTouchEvent方法，该方法的作用就是判断是否需要拦截事件，我们到ViewGroup的源码中看看该方法的实现。

ViewGroup.java

public boolean onInterceptTouchEvent(MotionEvent ev) {
        return false;
    }

该方法的实现很简单，只返回了一个false。那么这个方法是在哪被调用的呢，通过日志输出分析可知它是在RTLayout的dispatchTouchEvent执行后执行的，那我们就进到dispatchTouchEvent源码里面去看看。由于源码比较长，我将其中的关键部分截取出来做解释说明。

ViewGroup.java

            // Check for interception.
            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 {
                // There are no touch targets and this action is not an initial down
                // so this view group continues to intercept touches.
                intercepted = true;
            }

从这部分代码中可以看到onInterceptTouchEvent调用后返回值被赋值给intercepted，该变量控制了事件是否要向其子控件分发，所以它起到拦截的作用，如果onInterceptTouchEvent返回false则不拦截，如果返回true则拦截当前事件。我们现在将RTLayout中的该方法返回值修改为true，并重新编译运行，然后点击按钮，查看输出结果如下。


可以看到，我们明明点击的按钮，但输出结果显示RTLayout点击事件被执行了，再通过输出结果分析，对比上次的输出结果，发现本次的输出结果完全没有RTButton的信息，没错，由于onInterceptTouchEvent方法我们返回了true，在这里就将事件拦截了，所以他不会继续分发给RTButton了，反而交给自身的onTouchEvent方法执行了，理所当然，最后执行的就是RTLayout的点击事件了。

总结

以上我们对Android事件传递机制进行了分析，期间结合系统源码对事件传递过程中的处理情况进行了探究。通过单布局情况和嵌套布局情况下的事件传递和处理进行了分析，现总结如下：

  • Android中事件传递按照从上到下进行层级传递，事件处理从Activity开始到ViewGroup再到View。
  • 事件传递方法包括dispatchTouchEvent、onTouchEvent、onInterceptTouchEvent，其中前两个是View和ViewGroup都有的，最后一个是只有ViewGroup才有的方法。这三个方法的作用分别是负责事件分发、事件处理、事件拦截。
  • onTouch事件要先于onClick事件执行，onTouch在事件分发方法dispatchTouchEvent中调用，而onClick在事件处理方法onTouchEvent中被调用，onTouchEvent要后于dispatchTouchEvent方法的调用。

1.Touch事件分发中只有两个主角:ViewGroup和View。ViewGroup包含onInterceptTouchEvent、dispatchTouchEvent、onTouchEvent三个相关事件。View包含dispatchTouchEvent、onTouchEvent两个相关事件。其中ViewGroup又继承于View。

2.ViewGroup和View组成了一个树状结构，根节点为Activity内部包含的一个ViwGroup。

3.触摸事件由Action_Down、Action_Move、Aciton_UP组成，其中一次完整的触摸事件中，Down和Up都只有一个，Move有若干个，可以为0个。

4.当Acitivty接收到Touch事件时，将遍历子View进行Down事件的分发。ViewGroup的遍历可以看成是递归的。分发的目的是为了找到真正要处理本次完整触摸事件的View，这个View会在onTouchuEvent结果返回true。

5.当某个子View返回true时，会中止Down事件的分发，同时在ViewGroup中记录该子View。接下去的Move和Up事件将由该子View直接进行处理。由于子View是保存在ViewGroup中的，多层ViewGroup的节点结构时，上级ViewGroup保存的会是真实处理事件的View所在的ViewGroup对象:如ViewGroup0-ViewGroup1-TextView的结构中，TextView返回了true，它将被保存在ViewGroup1中，而ViewGroup1也会返回true，被保存在ViewGroup0中。当Move和UP事件来时，会先从ViewGroup0传递至ViewGroup1，再由ViewGroup1传递至TextView。

6.当ViewGroup中所有子View都不捕获Down事件时，将触发ViewGroup自身的onTouch事件。触发的方式是调用super.dispatchTouchEvent函数，即父类View的dispatchTouchEvent方法。在所有子View都不处理的情况下，触发Acitivity的onTouchEvent方法。

7.onInterceptTouchEvent有两个作用：1.拦截Down事件的分发。2.中止Up和Move事件向目标View传递，使得目标View所在的ViewGroup捕获Up和Move事件。


补充:

Android 中与 Touch 事件相关的方法包括：dispatchTouchEvent(MotionEvent ev)、onInterceptTouchEvent(MotionEvent ev)、onTouchEvent(MotionEvent ev)；能够响应这些方法的控件包括：ViewGroup 及其子类、Activity。方法与控件的对应关系如下表所示：

Touch 事件相关方法   方法功能  
   ViewGroup   
      Activity     
  public boolean dispatchTouchEvent(MotionEvent ev) 事件分发 
  Yes  Yes
  public boolean onInterceptTouchEvent(MotionEvent ev)  
 事件拦截 
  Yes  No
  public boolean onTouchEvent(MotionEvent ev) 事件响应 
  Yes  Yes

从这张表中我们可以看到 ViewGroup 及其子类对与 Touch 事件相关的三个方法均能响应，而 Activity 对 onInterceptTouchEvent(MotionEvent ev) 也就是事件拦截不进行响应。另外需要注意的是 View 对 dispatchTouchEvent(MotionEvent ev) 和 onInterceptTouchEvent(MotionEvent ev) 的响应的前提是可以向该 View 中添加子 View，如果当前的 View 已经是一个最小的单元 View（比如 TextView），那么就无法向这个最小 View 中添加子 View，也就无法向子 View 进行事件的分发和拦截，所以它没有dispatchTouchEvent(MotionEvent ev) 和 onInterceptTouchEvent(MotionEvent ev)，只有 onTouchEvent(MotionEvent ev)。


▐ 事件分发：public boolean dispatchTouchEvent(MotionEvent ev)

Touch 事件发生时 Activity 的 dispatchTouchEvent(MotionEvent ev) 方法会以隧道方式（从根元素依次往下传递直到最内层子元素或在中间某一元素中由于某一条件停止传递）将事件传递给最外层 View 的 dispatchTouchEvent(MotionEvent ev) 方法，并由该 View 的 dispatchTouchEvent(MotionEvent ev) 方法对事件进行分发。dispatchTouchEvent 的事件分发逻辑如下：

  • 如果 return true，事件会分发给当前 View 并由 dispatchTouchEvent 方法进行消费，同时事件会停止向下传递；
  • 如果 return false，事件分发分为两种情况：
  1. 如果当前 View 获取的事件直接来自 Activity，则会将事件返回给 Activity 的 onTouchEvent 进行消费；
  2. 如果当前 View 获取的事件来自外层父控件，则会将事件返回给父 View 的  onTouchEvent 进行消费。
  • 如果返回系统默认的 super.dispatchTouchEvent(ev)，事件会自动的分发给当前 View 的 onInterceptTouchEvent 方法。

▐ 事件拦截：public boolean onInterceptTouchEvent(MotionEvent ev) 

在外层 View 的 dispatchTouchEvent(MotionEvent ev) 方法返回系统默认的 super.dispatchTouchEvent(ev) 情况下，事件会自动的分发给当前 View 的 onInterceptTouchEvent 方法。onInterceptTouchEvent 的事件拦截逻辑如下：

  • 如果 onInterceptTouchEvent 返回 true，则表示将事件进行拦截，并将拦截到的事件交由当前 View 的 onTouchEvent 进行处理；
  • 如果 onInterceptTouchEvent 返回 false，则表示将事件放行，当前 View 上的事件会被传递到子 View 上，再由子 View 的 dispatchTouchEvent 来开始这个事件的分发；
  • 如果 onInterceptTouchEvent 返回 super.onInterceptTouchEvent(ev)，事件默认会被拦截，并将拦截到的事件交由当前 View 的 onTouchEvent 进行处理。

▐ 事件响应：public boolean onTouchEvent(MotionEvent ev)

在 dispatchTouchEvent 返回 super.dispatchTouchEvent(ev) 并且 onInterceptTouchEvent 返回 true 或返回 super.onInterceptTouchEvent(ev) 的情况下 onTouchEvent 会被调用。onTouchEvent 的事件响应逻辑如下：

  • 如果事件传递到当前 View 的 onTouchEvent 方法，而该方法返回了 false，那么这个事件会从当前 View 向上传递，并且都是由上层 View 的 onTouchEvent 来接收，如果传递到上面的 onTouchEvent 也返回 false，这个事件就会“消失”，而且接收不到下一次事件。
  • 如果返回了 true 则会接收并消费该事件。
  • 如果返回 super.onTouchEvent(ev) 默认处理事件的逻辑和返回 false 时相同。

YaoYong_BigData
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android 滑动冲突拦截法★
zenmela2011的专栏
03-24 2475
分别使用外部拦截、内部拦截方法解决SwipeRefreshLayout+ViewPager事件冲突问题，主要冲突为SwipeRefreshLayout是纵向滑动，而ViewPager是横向滑动。虽然本身源码已经做好了相应的处理，为了巩固事件分发的原理，我们通过自定义代码的方法解决。 期望效果：横向滑动ViewPager，纵向滑动SwipeRefreshLayout 1.内部拦截法 内部拦截法是指父容器不拦截任何触摸事件，所有的触摸事件都传递给子元素，如果子元素需要此触摸事件就直接消耗掉，否者就交由.
Android事件传递机制
calvin367的专栏
01-06 740
本文为InfoQ中文站特供稿件，首发地址为：http://www.infoq.com/cn/articles/android-event-delivery-mechanism。如需转载，请与InfoQ中文站联系。 运用的前提是掌握 掌握的本质是理解 本篇内容将结合Android源码来分析Android的事件传递机制。众所周知，点按、滑动、触摸构成了Android等智能设备的基
android监听传递,android 中事件传递实现分析
weixin_33561910的博客
06-07 148
概述我们在android 应用开发当中经常会用到onClick、onTouch等事件的处理，但是这个事件是如何分发到我们的View上的呢？或者是如果我们在LinearLayout 中的button或者textview 是谁先收到view的触摸或者点击事件呢？是父view先收到然后分发给你了嘛，今天就学习一下android当中关于事件分发机制。同时监听了view的onClick和onTouch哪个消...
Diaolg 点击事件透传给 Activity
FREE_CODER
12-15 1280
Dialog 透传点击事件给 Actiivity
Android中的View的事件分发机制
xiaokang666的博客
09-14 1157
View的事件分发机制
Android View事件分发机制详解
09-01
主要为大家详细介绍了Android View事件分发机制，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Android事件分发机制
01-03
事件分发流程相关 一个事件发生后，首先从Acrtivity开始传递，然后一层一层往下传，从上往下调用dispatchTouchEvent方法传递事件： Activity——>PhoneWindow——>DecorView——>ViewGroup——>…——>View 如果事件...
Android View 事件分发机制详解
09-01
本文主要介绍Android View 事件分发机制，这里整理了相关资料并详细介绍了view分发机制的知识及简单示例代码，有兴趣的小伙伴可以参考下
解析Android点击事件分发机制
01-05
网上关于点击事件分发的文章一搜一大堆，标题一看，不是“30分钟让你弄明白XXX”就是“这是讲解XXX最好的文章”，满怀憧憬与信心，忍不住兴奋的点进去一看，发现不是代码就全是图，我基本上看完了所有相关的文章，...
android ui事件传递,android 事件传递
weixin_42294133的博客
05-27 135
当开始 按下某个按键 的时候 先是驱动层先知道的 然后依次向下传递1)如果return false : 将 "事件" 不会经过Activity 也就是 (MainActivity的父类),而是一层一层的返 回给驱动层 .2)如果return true : 就是防止 "事件" 继续传递而是拦截下来 只在MainActivity 中处理3)如果return super.onKeyDown(key...
Android 事件处理机制
05-17
Android事件处理机制
android事件分发、拦截、处理的示例代码
12-02
自己写的android事件分发、拦截、处理的代码，可以清楚知道事件分发、拦截和处理的过程。
android Touch事件传递机制
01-26
android Touch事件传递机制的实例
安卓常用控件-编辑框
Zero_0318的博客
12-12 110
安卓常用控件-辑框
android的点击事件,Android中点击事件的来源
weixin_39908082的博客
05-26 248
本文将分以下在步骤寻找android中事件的来源：一、activity启动时 创建window以及windowManager的过程。二、调用setContentView设置布局的过程三、Activity在onResume之后创建ViewRootImp将window和DecorView关联的过程四、创建InputChanel 发送给InputManagerService进行注册的过程五、Window...
从不一样的角度描述Android事件传递，读完让你耳目一新
m0_65146387的博客
12-16 221
注意点 一个View需要消费一组事件也即是自己来处理这组事件，并且一组事件只能被消费一次。 一组触摸事件分为按下、移动、抬起，称之为一个事件序列，其中移动事件会有多个。当一个View决定自己消费一组事件需要在按下时就给出结果，反之如果在按下时决定消费意味着这一组事件序列均由自己消费。 1.3 滚动模型的设计 如果仅仅是处理点击事件用上面的方案没有任何问题，可是我们的屏幕还可以滑动啊，而且用户希望既可以点击又可以滑动。如果子View需要能点击，父View需要能滑动怎么办？因为一组事件只能被消费一次，.
android长按事件监听,OnLongClickListener的长按结束监听事件
weixin_30785057的博客
05-27 2921
本人在做一个录音项目的时候，要求一个button要做到三种功能：长按开始录音，手指起来的时候停止录音，点击的时候要播放录音，一开始真的是没有头绪，如果使用OnTouchListener来做，虽然可以使用时间延迟来模仿长按事件，也可以做到长按结束的监听，但是后面还要做到点击的时候播放，后来看了别人写的一些博客关于OnTouchListener、OnLongClickListener、OnClickL...
android 拦截点击事件,Android双击事件拦截方法
weixin_36221941的博客
05-26 1346
下文我们介绍两种双击事件拦截的方式1.通过Android的事件分发机制进行拦截(dispatchTouchEvent)话不多说，直接上代码：/** 判断是否是快速点击 */private static long lastClickTime;public static boolean isFastDoubleClick() {long time = System.currentTimeMillis(...
Android 中的事件分发机制
最新发布
05-18
Android 中的事件分发机制是指当用户在屏幕上进行操作，例如点击、滑动等，系统会将这些操作封装成一个个事件，并将事件分发给对应的 View 进行处理。事件分发机制可以分为三个阶段：分发、拦截和处理。 第一阶段：...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值