Android ViewGroup事件分发机制

转载请标明出处：http://blog.csdn.net/lmj623565791/article/details/39102591，本文出自【张鸿洋的博客】

上一篇已经完整的解析了Android View的事件分发机制，今天给大家代码ViewGroup事件分发的源码解析~~凡是自定义ViewGroup实现各种滑动效果的，不可避免的会出现很多事件的冲突，对ViewGroup事件分发机制的了解，也有益于大家了解冲突产生的原因，以及对冲突进行处理~

1、案例

首先我们接着上一篇的代码，在代码中添加一个自定义的LinearLayout：

[java] view plain copy

  1. package com.example.zhy_event03;
  2. import android.content.Context;
  3. import android.util.AttributeSet;
  4. import android.util.Log;
  5. import android.view.MotionEvent;
  6. import android.widget.LinearLayout;
  7. public class MyLinearLayout extends LinearLayout
  8. {
  9. private static final String TAG = MyLinearLayout.class.getSimpleName();
  10. public MyLinearLayout(Context context, AttributeSet attrs)
  11. {
  12. super(context, attrs);
  13. }
  14. @Override
  15. public boolean dispatchTouchEvent(MotionEvent ev)
  16. {
  17. int action = ev.getAction();
  18. switch (action)
  19. {
  20. case MotionEvent.ACTION_DOWN:
  21. Log.e(TAG, "dispatchTouchEvent ACTION_DOWN");
  22. break;
  23. case MotionEvent.ACTION_MOVE:
  24. Log.e(TAG, "dispatchTouchEvent ACTION_MOVE");
  25. break;
  26. case MotionEvent.ACTION_UP:
  27. Log.e(TAG, "dispatchTouchEvent ACTION_UP");
  28. break;
  29. default:
  30. break;
  31. }
  32. return super.dispatchTouchEvent(ev);
  33. }
  34. @Override
  35. public boolean onTouchEvent(MotionEvent event)
  36. {
  37. int action = event.getAction();
  38. switch (action)
  39. {
  40. case MotionEvent.ACTION_DOWN:
  41. Log.e(TAG, "onTouchEvent ACTION_DOWN");
  42. break;
  43. case MotionEvent.ACTION_MOVE:
  44. Log.e(TAG, "onTouchEvent ACTION_MOVE");
  45. break;
  46. case MotionEvent.ACTION_UP:
  47. Log.e(TAG, "onTouchEvent ACTION_UP");
  48. break;
  49. default:
  50. break;
  51. }
  52. return super.onTouchEvent(event);
  53. }
  54. @Override
  55. public boolean onInterceptTouchEvent(MotionEvent ev)
  56. {
  57. int action = ev.getAction();
  58. switch (action)
  59. {
  60. case MotionEvent.ACTION_DOWN:
  61. Log.e(TAG, "onInterceptTouchEvent ACTION_DOWN");
  62. break;
  63. case MotionEvent.ACTION_MOVE:
  64. Log.e(TAG, "onInterceptTouchEvent ACTION_MOVE");
  65. break;
  66. case MotionEvent.ACTION_UP:
  67. Log.e(TAG, "onInterceptTouchEvent ACTION_UP");
  68. break;
  69. default:
  70. break;
  71. }
  72. return super.onInterceptTouchEvent(ev);
  73. }
  74. @Override
  75. public void requestDisallowInterceptTouchEvent(boolean disallowIntercept)
  76. {
  77. Log.e(TAG, "requestDisallowInterceptTouchEvent ");
  78. super.requestDisallowInterceptTouchEvent(disallowIntercept);
  79. }
  80. }

继承LinearLayout，然后复写了与事件分发机制有关的代码，添加上了日志的打印~

然后看我们的布局文件：

[html] view plain copy

  1. <com.example.zhy_event03.MyLinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  2. xmlns:tools="http://schemas.android.com/tools"
  3. android:layout_width="match_parent"
  4. android:layout_height="match_parent"
  5. tools:context=".MainActivity" >
  6. <com.example.zhy_event03.MyButton
  7. android:id="@+id/id_btn"
  8. android:layout_width="wrap_content"
  9. android:layout_height="wrap_content"
  10. android:text="click me" />
  11. </com.example.zhy_event03.MyLinearLayout>

MyLinearLayout中包含一个MyButton，MyButton都上篇博客中已经出现过，这里就不再贴代码了，不清楚可以去查看~

然后MainActivity就是直接加载布局，没有任何代码~~~

直接运行我们的代码，然后点击我们的Button，依然是有意的MOVE一下，不然不会触发MOVE事件，看一下日志的输出：

[html] view plain copy

  1. 09-06 09:57:27.287: E/MyLinearLayout(959): dispatchTouchEvent ACTION_DOWN
  2. 09-06 09:57:27.287: E/MyLinearLayout(959): onInterceptTouchEvent ACTION_DOWN
  3. 09-06 09:57:27.287: E/MyButton(959): dispatchTouchEvent ACTION_DOWN
  4. 09-06 09:57:27.297: E/MyButton(959): onTouchEvent ACTION_DOWN
  5. 09-06 09:57:27.297: E/MyButton(959): onTouchEvent ACTION_MOVE
  6. 09-06 09:57:27.327: E/MyLinearLayout(959): dispatchTouchEvent ACTION_MOVE
  7. 09-06 09:57:27.327: E/MyLinearLayout(959): onInterceptTouchEvent ACTION_MOVE
  8. 09-06 09:57:27.337: E/MyButton(959): dispatchTouchEvent ACTION_MOVE
  9. 09-06 09:57:27.337: E/MyButton(959): onTouchEvent ACTION_MOVE
  10. 09-06 09:57:27.457: E/MyLinearLayout(959): dispatchTouchEvent ACTION_UP
  11. 09-06 09:57:27.457: E/MyLinearLayout(959): onInterceptTouchEvent ACTION_UP
  12. 09-06 09:57:27.457: E/MyButton(959): dispatchTouchEvent ACTION_UP
  13. 09-06 09:57:27.457: E/MyButton(959): onTouchEvent ACTION_UP

可以看到大体的事件流程为：

MyLinearLayout的dispatchTouchEvent
-> MyLinearLayout的onInterceptTouchEvent
-> MyButton的dispatchTouchEvent ->Mybutton的onTouchEvent

可以看出，在View上触发事件，最先捕获到事件的为View所在的ViewGroup，然后才会到View自身~

下面我们按照日志的输出，进入源码~

2、源码分析

ViewGroup - dispatchTouchEvent

1、ViewGroup - dispatchTouchEvent - ACTION_DOWN

首先是ViewGroup的dispatchTouchEvent方法：

[java] view plain copy

  1. @Override
  2. public boolean dispatchTouchEvent(MotionEvent ev) {
  3. if (!onFilterTouchEventForSecurity(ev)) {
  4. return false;
  5. }
  6. final int action = ev.getAction();
  7. final float xf = ev.getX();
  8. final float yf = ev.getY();
  9. final float scrolledXFloat = xf + mScrollX;
  10. final float scrolledYFloat = yf + mScrollY;
  11. final Rect frame = mTempRect;
  12. boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
  13. if (action == MotionEvent.ACTION_DOWN) {
  14. if (mMotionTarget != null) {
  15. // this is weird, we got a pen down, but we thought it was
  16. // already down!
  17. // XXX: We should probably send an ACTION_UP to the current
  18. // target.
  19. mMotionTarget = null;
  20. }
  21. // If we‘re disallowing intercept or if we‘re allowing and we didn‘t
  22. // intercept
  23. if (disallowIntercept || !onInterceptTouchEvent(ev)) {
  24. // reset this event‘s action (just to protect ourselves)
  25. ev.setAction(MotionEvent.ACTION_DOWN);
  26. // We know we want to dispatch the event down, find a child
  27. // who can handle it, start with the front-most child.
  28. final int scrolledXInt = (int) scrolledXFloat;
  29. final int scrolledYInt = (int) scrolledYFloat;
  30. final View[] children = mChildren;
  31. final int count = mChildrenCount;
  32. for (int i = count - 1; i >= 0; i--) {
  33. final View child = children[i];
  34. if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE
  35. || child.getAnimation() != null) {
  36. child.getHitRect(frame);
  37. if (frame.contains(scrolledXInt, scrolledYInt)) {
  38. // offset the event to the view‘s coordinate system
  39. final float xc = scrolledXFloat - child.mLeft;
  40. final float yc = scrolledYFloat - child.mTop;
  41. ev.setLocation(xc, yc);
  42. child.mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;
  43. if (child.dispatchTouchEvent(ev))  {
  44. // Event handled, we have a target now.
  45. mMotionTarget = child;
  46. return true;
  47. }
  48. // The event didn‘t get handled, try the next view.
  49. // Don‘t reset the event‘s location, it‘s not
  50. // necessary here.
  51. }
  52. }
  53. }
  54. }
  55. }                                                                                                                                                  ....//other code omitted

代码比较长，决定分段贴出，首先贴出的是ACTION_DOWN事件相关的代码。

16行：进入ACTION_DOWN的处理

17-23行：将mMotionTarget置为null

26行：进行判断：if(disallowIntercept || !onInterceptTouchEvent(ev))

两种可能会进入IF代码段

1、当前不允许拦截，即disallowIntercept =true，

2、当前允许拦截但是不拦截，即disallowIntercept =false,但是onInterceptTouchEvent(ev)返回false ;

注：disallowIntercept 可以通过viewGroup.requestDisallowInterceptTouchEvent(boolean);进行设置，后面会详细说；而onInterceptTouchEvent(ev)可以进行复写。

36-57行：开始遍历所有的子View

41行：进行判断当前的x,y坐标是否落在子View身上，如果在，47行，执行child.dispatchTouchEvent(ev)，就进入了View的dispatchTouchEvent代码中了，如果不了解请参考：Android View的事件分发机制，当child.dispatchTouchEvent(ev)返回true，则为mMotionTarget=child;然后return true;

ViewGroup的ACTION_DOWN分析结束，总结一下：

ViewGroup实现捕获到DOWN事件，如果代码中不做TOUCH事件拦截，则开始查找当前x,y是否在某个子View的区域内，如果在，则把事件分发下去。

按照日志，接下来到达ACTION_MOVE

2、ViewGroup - dispatchTouchEvent - ACTION_MOVE

首先我们源码进行删减，只留下MOVE相关的代码：

[java] view plain copy

  1. @Override
  2. public boolean dispatchTouchEvent(MotionEvent ev) {
  3. final int action = ev.getAction();
  4. final float xf = ev.getX();
  5. final float yf = ev.getY();
  6. final float scrolledXFloat = xf + mScrollX;
  7. final float scrolledYFloat = yf + mScrollY;
  8. final Rect frame = mTempRect;
  9. boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
  10. //...ACTION_DOWN
  11. //...ACTIN_UP or ACTION_CANCEL
  12. // The event wasn‘t an ACTION_DOWN, dispatch it to our target if
  13. // we have one.
  14. final View target = mMotionTarget;
  15. // if have a target, see if we‘re allowed to and want to intercept its
  16. // events
  17. if (!disallowIntercept && onInterceptTouchEvent(ev)) {
  18. //....
  19. }
  20. // finally offset the event to the target‘s coordinate system and
  21. // dispatch the event.
  22. final float xc = scrolledXFloat - (float) target.mLeft;
  23. final float yc = scrolledYFloat - (float) target.mTop;
  24. ev.setLocation(xc, yc);
  25. return target.dispatchTouchEvent(ev);
  26. }

18行：把ACTION_DOWN时赋值的mMotionTarget，付给target ;

23行：if (!disallowIntercept && onInterceptTouchEvent(ev)) 当前允许拦截且拦截了，才进入IF体，当然了默认是不会拦截的~这里执行了onInterceptTouchEvent(ev)

28-30行：把坐标系统转化为子View的坐标系统

32行：直接return target.dispatchTouchEvent(ev);

可以看到，正常流程下，ACTION_MOVE在检测完是否拦截以后，直接调用了子View.dispatchTouchEvent，事件分发下去；

最后就是ACTION_UP了

3、ViewGroup - dispatchTouchEvent - ACTION_UP

[java] view plain copy

  1. public boolean dispatchTouchEvent(MotionEvent ev) {
  2. if (!onFilterTouchEventForSecurity(ev)) {
  3. return false;
  4. }
  5. final int action = ev.getAction();
  6. final float xf = ev.getX();
  7. final float yf = ev.getY();
  8. final float scrolledXFloat = xf + mScrollX;
  9. final float scrolledYFloat = yf + mScrollY;
  10. final Rect frame = mTempRect;
  11. boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
  12. if (action == MotionEvent.ACTION_DOWN) {...}
  13. boolean isUpOrCancel = (action == MotionEvent.ACTION_UP) ||
  14. (action == MotionEvent.ACTION_CANCEL);
  15. if (isUpOrCancel) {
  16. mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;
  17. }
  18. final View target = mMotionTarget;
  19. if(target ==null ){...}
  20. if (!disallowIntercept && onInterceptTouchEvent(ev)) {...}
  21. if (isUpOrCancel) {
  22. mMotionTarget = null;
  23. }
  24. // finally offset the event to the target‘s coordinate system and
  25. // dispatch the event.
  26. final float xc = scrolledXFloat - (float) target.mLeft;
  27. final float yc = scrolledYFloat - (float) target.mTop;
  28. ev.setLocation(xc, yc);
  29. return target.dispatchTouchEvent(ev);
  30. }

17行：判断当前是否是ACTION_UP

21，28行：分别重置拦截标志位以及将DOWN赋值的mMotionTarget置为null，都UP了，当然置为null，下一次DOWN还会再赋值的~

最后，修改坐标系统，然后调用target.dispatchTouchEvent(ev);

正常情况下，即我们上例整个代码的流程我们已经走完了：

1、ACTION_DOWN中，ViewGroup捕获到事件，然后判断是否拦截，如果没有拦截，则找到包含当前x,y坐标的子View，赋值给mMotionTarget，然后调用 mMotionTarget.dispatchTouchEvent

2、ACTION_MOVE中，ViewGroup捕获到事件，然后判断是否拦截，如果没有拦截，则直接调用mMotionTarget.dispatchTouchEvent(ev)

3、ACTION_UP中，ViewGroup捕获到事件，然后判断是否拦截，如果没有拦截，则直接调用mMotionTarget.dispatchTouchEvent(ev)

当然了在分发之前都会修改下坐标系统，把当前的x，y分别减去child.left 和 child.top ，然后传给child;

3、关于拦截

1、如何拦截

上面的总结都是基于：如果没有拦截；那么如何拦截呢？

复写ViewGroup的onInterceptTouchEvent方法：

[java] view plain copy

  1. @Override
  2. public boolean onInterceptTouchEvent(MotionEvent ev)
  3. {
  4. int action = ev.getAction();
  5. switch (action)
  6. {
  7. case MotionEvent.ACTION_DOWN:
  8. //如果你觉得需要拦截
  9. return true ;
  10. case MotionEvent.ACTION_MOVE:
  11. //如果你觉得需要拦截
  12. return true ;
  13. case MotionEvent.ACTION_UP:
  14. //如果你觉得需要拦截
  15. return true ;
  16. }
  17. return false;
  18. }

默认是不拦截的，即返回false；如果你需要拦截，只要return
true就行了，这要该事件就不会往子View传递了，并且如果你在DOWN retrun true
，则DOWN,MOVE,UP子View都不会捕获事件；如果你在MOVE return true , 则子View在MOVE和UP都不会捕获事件。

原因很简单，当onInterceptTouchEvent(ev) return true的时候，会把mMotionTarget 置为null ;

2、如何不被拦截

如果ViewGroup的onInterceptTouchEvent(ev) 当ACTION_MOVE时return true ，即拦截了子View的MOVE以及UP事件；

此时子View希望依然能够响应MOVE和UP时该咋办呢？

Android给我们提供了一个方法：requestDisallowInterceptTouchEvent(boolean) 用于设置是否允许拦截，我们在子View的dispatchTouchEvent中直接这么写：

[java] view plain copy

  1. @Override
  2. public boolean dispatchTouchEvent(MotionEvent event)
  3. {
  4. getParent().requestDisallowInterceptTouchEvent(true);
  5. int action = event.getAction();
  6. switch (action)
  7. {
  8. case MotionEvent.ACTION_DOWN:
  9. Log.e(TAG, "dispatchTouchEvent ACTION_DOWN");
  10. break;
  11. case MotionEvent.ACTION_MOVE:
  12. Log.e(TAG, "dispatchTouchEvent ACTION_MOVE");
  13. break;
  14. case MotionEvent.ACTION_UP:
  15. Log.e(TAG, "dispatchTouchEvent ACTION_UP");
  16. break;
  17. default:
  18. break;
  19. }
  20. return super.dispatchTouchEvent(event);
  21. }

getParent().requestDisallowInterceptTouchEvent(true);  这样即使ViewGroup在MOVE的时候return true，子View依然可以捕获到MOVE以及UP事件。

从源码也可以解释：

ViewGroup MOVE和UP拦截的源码是这样的：

[java] view plain copy

  1. if (!disallowIntercept && onInterceptTouchEvent(ev)) {
  2. final float xc = scrolledXFloat - (float) target.mLeft;
  3. final float yc = scrolledYFloat - (float) target.mTop;
  4. mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;
  5. ev.setAction(MotionEvent.ACTION_CANCEL);
  6. ev.setLocation(xc, yc);
  7. if (!target.dispatchTouchEvent(ev)) {
  8. // target didn‘t handle ACTION_CANCEL. not much we can do
  9. // but they should have.
  10. }
  11. // clear the target
  12. mMotionTarget = null;
  13. // Don‘t dispatch this event to our own view, because we already
  14. // saw it when intercepting; we just want to give the following
  15. // event to the normal onTouchEvent().
  16. return true;
  17. }

当我们把disallowIntercept设置为true时，!disallowIntercept直接为false，于是拦截的方法体就被跳过了~

注：如果ViewGroup在onInterceptTouchEvent(ev)  ACTION_DOWN里面直接return true了，那么子View是木有办法的捕获事件的~~~

4、如果没有找到合适的子View

我们的实例，直接点击ViewGroup内的按钮，当然直接很顺利的走完整个流程；

但是有两种特殊情况

1、ACTION_DOWN的时候，子View.dispatchTouchEvent(ev)返回的为false ; 

如果你仔细看了，你会注意到ViewGroup的dispatchTouchEvent(ev)的ACTION_DOWN代码是这样的

[java] view plain copy

  1. if (child.dispatchTouchEvent(ev))  {
  2. // Event handled, we have a target now.
  3. mMotionTarget = child;
  4. return true;
  5. }

只有在child.dispatchTouchEvent(ev)返回true了，才会认为找到了能够处理当前事件的View，即mMotionTarget = child;

但是如果返回false,那么mMotionTarget 依然是null

mMotionTarget 为null会咋样呢？

其实ViewGroup也是View的子类，如果没有找到能够处理该事件的子View，或者干脆就没有子View；

那么，它作为一个View，就相当于View的事件转发了~~直接super.dispatchTouchEvent(ev);

源码是这样的：

[java] view plain copy

  1. final View target = mMotionTarget;
  2. if (target == null) {
  3. // We don‘t have a target, this means we‘re handling the
  4. // event as a regular view.
  5. ev.setLocation(xf, yf);
  6. if ((mPrivateFlags & CANCEL_NEXT_UP_EVENT) != 0) {
  7. ev.setAction(MotionEvent.ACTION_CANCEL);
  8. mPrivateFlags &= ~CANCEL_NEXT_UP_EVENT;
  9. }
  10. return super.dispatchTouchEvent(ev);
  11. }

我们没有一个能够处理该事件的目标元素，意味着我们需要自己处理~~~就相当于传统的View~

2、那么什么时候子View.dispatchTouchEvent(ev)返回的为true

如果你仔细看了上篇博客，你会发现只要子View支持点击或者长按事件一定返回true~~

源码是这样的：

[java] view plain copy

  1. if (((viewFlags & CLICKABLE) == CLICKABLE ||
  2. (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)) {
  3. return true ;                                                                                                                                                                                                                                                                                                   }

5、总结

关于代码流程上面已经总结过了~

1、如果ViewGroup找到了能够处理该事件的View，则直接交给子View处理，自己的onTouchEvent不会被触发；

2、可以通过复写onInterceptTouchEvent(ev)方法，拦截子View的事件（即return true），把事件交给自己处理，则会执行自己对应的onTouchEvent方法

3、子View可以通过调用getParent().requestDisallowInterceptTouchEvent(true);  阻止ViewGroup对其MOVE或者UP事件进行拦截；

好了，那么实际应用中能解决哪些问题呢？

比如你需要写一个类似slidingmenu的左侧隐藏menu，主Activity上有个Button、ListView或者任何可以响应点击的View，你在当前View上死命的滑动，菜单栏也出不来；因为MOVE事件被子View处理了~
你需要这么做：在ViewGroup的dispatchTouchEvent中判断用户是不是想显示菜单，如果是，则在onInterceptTouchEvent(ev)拦截子View的事件；自己进行处理，这样自己的onTouchEvent就可以顺利展现出菜单栏了~~

时间： 2024-08-02 11:56:27

Android ViewGroup事件分发机制的相关文章

（转）Android ViewGroup事件分发机制

3.关于拦截 1.如何拦截 上面的总结都是基于:如果没有拦截:那么如何拦截呢? 复写ViewGroup的onInterceptTouchEvent方法: [java] view plain copy @Override public boolean onInterceptTouchEvent(MotionEvent ev) { int action = ev.getAction(); switch (action) { case MotionEvent.ACTION_DOWN: //如果你觉得需

Android View 事件分发机制 源码解析 （上）

一直想写事件分发机制的文章,不管咋样,也得自己研究下事件分发的源码,写出心得~ 首先我们先写个简单的例子来测试View的事件转发的流程~ 1.案例 为了更好的研究View的事件转发,我们自定以一个MyButton继承Button,然后把跟事件传播有关的方法进行复写,然后添加上日志~ MyButton [java] view plain copy package com.example.zhy_event03; import android.content.Context; import andr

Android：ViewGroup事件分发机制

关于ViewGroup事件分发机制的文章已经有很多了,推荐郭霖和鸿洋的两篇文章, http://blog.csdn.net/guolin_blog/article/details/9153747 http://blog.csdn.net/lmj623565791/article/details/39102591 结合他们写的,自己简单总结一下,可能只适用个人. 流程 在上一篇文章中讲到,当你操作一个控件时,不管是按下.移动.抬起,在事件中途未被消费的情况下系统会按照View.dispatchTo

Android View 事件分发机制源码详解(View篇)

前言 在Android View 事件分发机制源码详解(ViewGroup篇)一文中,主要对ViewGroup#dispatchTouchEvent的源码做了相应的解析,其中说到在ViewGroup把事件传递给子View的时候,会调用子View的dispatchTouchEvent,这时分两种情况,如果子View也是一个ViewGroup那么再执行同样的流程继续把事件分发下去,即调用ViewGroup#dispatchTouchEvent:如果子View只是单纯的一个View,那么调用的是Vie

Android View框架总结（八）ViewGroup事件分发机制

请尊重分享成果,转载请注明出处: http://blog.csdn.net/hejjunlin/article/details/52298780 上篇分析了View的事件分发流程,留了一个问题:如果上面的EventButton继承TextView的话,按下抬起,会有一个现象,我可以告诉大家现象:就是只有dispatchTouchEvent ACTION_DOWN,onTouch ACTION_DOWN,onTouchEvent ACTION_DOWN这三个,你移动,或者抬起,是没有MOVE,或者

Android Touch事件分发机制学习

Android  事件分发机制 ViewGroup dispatchTouchEvent 返回true dispatchTouchEvent: Activity ACTION_DOWN MyrelativeLayout dispatchTouchEvent: ACTION_DOWN dispatchTouchEvent: Activity ACTION_UP MyrelativeLayout dispatchTouchEvent: ACTION_UP ViewGroup自己在dispatchTo

Android触摸事件分发机制

Android中的事件分为按键事件和触摸事件,这里对触摸事件进行阐述.Touch事件是由一个ACTION_DOWN,n个ACTION_MOVE,一个ACTION_UP组成onClick,onLongClick,onScroll等事件.Android中的控件都是继承View这个基类的,而控件分为两种:一种是继承View不能包含其他控件的控件:一种是继承ViewGroup可以包含其他控件的控件,暂且称为容器控件,比如ListView,GridView,LinearLayout等. 这里先对几个函数讲

Android View 事件分发机制梳理

View初探 一直以来对View的事件分发机制很晕,今天就在这里梳理一下 MyView 首先继承View类,自定义一个MyView.并在初始化时打印View类是否可点击,这里从View点击事件分发的角度出发,所以不考虑绘制,测量相关方法的实现. public class MyView extends View { String TAG = "Activity"; public MyView(Context context) { super(context); init(); } pub

Android View事件分发机制

最近在开发中遇到view滑动冲突的问题,由于一开始就知道这个问题与view事件分发有关,之后在网上看了几篇关于事件分发的资料后,开发中遇到的问题很快便得到解决. 在这里总结一下我对view事件分发的理解. 首先,看下事件分发流程图: Button事件演示 在对view的事件分发机制进行分析前,我们可以通过一个demo看看Button的事件处理的流程. 在布局文件中添加一个button控件,然后在代码中实现Button的setOnClickListener和setOnTouchListener方法