Android组件间通信利器EventBus详解教程

现在的Android应用功能越来越多了，为了保证应用的各部分保持高效的通信，这时候就需要用到Android组件间通信利器EventBus。

概述及基本概念

**EventBus**是一个Android端优化的publish/subscribe消息总线，简化了应用程序内各组件间、组件与后台线程间 的通信。比如请求网络，等网络返回时通过Handler或Broadcast通知UI，两个Fragment之间需要通过Listener通信，这些需求 都可以通过**EventBus**实现。

作为一个消息总线，有三个主要的元素：

    Event：事件
    Subscriber：事件订阅者，接收特定的事件
    Publisher:事件发布者，用于通知Subscriber有事件发生

Event

**Event**可以是任意类型的对象。

Subscriber

在EventBus中，使用约定来指定事件订阅者以简化使用。即所有事件订阅都都是以onEvent开头的函数，具体来说，函数的名字是 onEvent，onEventMainThread，onEventBackgroundThread，onEventAsync这四个，这个和 ThreadMode有关，后面再说。

Publisher

可以在任意线程任意位置发送事件，直接调用EventBus的`post(Object)`方法，可以自己实例化EventBus对象，但一般使用 默认的单例就好了：`EventBus.getDefault()`，根据post函数参数的类型，会自动调用订阅相应类型事件的函数。

ThreadMode

前面说了，Subscriber函数的名字只能是那4个，因为每个事件订阅函数都是和一个`ThreadMode`相关联的，ThreadMode指定了会调用的函数。有以下四个ThreadMode：

    PostThread：事件的处理在和事件的发送在相同的进程，所以事件处理时间不应太长，不然影响事件的发送线程，而这个线程可能是UI线程。对应的函数名是onEvent。
    MainThread: 事件的处理会在UI线程中执行。事件处理时间不能太长，这个不用说的，长了会ANR的，对应的函数名是onEventMainThread。
    BackgroundThread：事件的处理会在一个后台线程中执行，对应的函数名是onEventBackgroundThread，虽然名 字是BackgroundThread，事件处理是在后台线程，但事件处理时间还是不应该太长，因为如果发送事件的线程是后台线程，会直接执行事件，如果 当前线程是UI线程，事件会被加到一个队列中，由一个线程依次处理这些事件，如果某个事件处理时间太长，会阻塞后面的事件的派发或处理。
    Async：事件处理会在单独的线程中执行，主要用于在后台线程中执行耗时操作，每个事件会开启一个线程（有线程池），但最好限制线程的数目。

根据事件订阅都函数名称的不同，会使用不同的ThreadMode，比如果在后台线程加载了数据想在UI线程显示，订阅者只需把函数命名为onEventMainThread。

简单使用

基本的使用步骤就是如下4步，点击此链接查看例子及介绍。

    定义事件类型：
    `public class MyEvent {}`
    定义事件处理方法：
    `public void onEventMainThread`
    注册订阅者：
    `EventBus.getDefault().register(this)`
    发送事件：
    `EventBus.getDefault().post(new MyEvent())`

实现

**EventBus**使用方法很简单，但用一个东西，如果不了解它的实现用起来心里总是没底，万一出问题咋办都不知道，所以还是研究一下它的实 现，肯定要Read the fucking Code。其实主要是`EventBus`这一个类，在看看Code时需要了解几个概念与成员，了解了这些后实现就很好理解了。

    EventType：onEvent*函数中的参数，表示事件的类型
    Subscriber：订阅源，即调用register注册的对象，这个对象内包含onEvent*函数
    SubscribMethod：`Subscriber`内某一特定的onEvent*方法，内部成员包含一个`Method`类型的 method成员表示这个onEvent*方法，一个`ThreadMode`成员threadMode表示事件的处理线程，一个 `Class<?>`类型的eventType成员表示事件的类型`EventType`。
    Subscription，表示一个订阅对象，包含订阅源`Subscriber`，订阅源中的某一特定方法`SubscribMethod`，这个订阅的优先级`priopity`


了解了以上几个概念后就可以看`EventBus`中的几个重要成员了

代码如下

复制代码

// EventType -> List<Subscription>，事件到订阅对象之间的映射 private final Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType; // Subscriber -> List<EventType>，订阅源到它订阅的的所有事件类型的映射 private final Map<Object, List<Class<?>>> typesBySubscriber; // stickEvent事件，后面会看到 private final Map<Class<?>, Object> stickyEvents; // EventType -> List<? extends EventType>，事件到它的父事件列表的映射。即缓存一个类的所有父类 private static final Map<Class<?>, List<Class<?>>> eventTypesCache = new HashMap<Class<?>, List<Class<?>>>();

注册事件：Register

通过`EventBus.getDefault().register`方法可以向`EventBus`注册来订阅事件，`register`有很 多种重载形式，但大都被标记为`Deprecated`了，所以还是不用为好，前面说了事件处理方法都是以*onEvent*开头，其实是可以通过 register方法修改的，但相应的方法被废弃了，还是不要用了，就用默认的*onEvent*，除下废弃的register方法，还有以下4 个**public**的`register`方法

代码如下

复制代码

public void register(Object subscriber) {     register(subscriber, defaultMethodName, false, 0); } public void register(Object subscriber, int priority) {     register(subscriber, defaultMethodName, false, priority); } public void registerSticky(Object subscriber) {     register(subscriber, defaultMethodName, true, 0); } public void registerSticky(Object subscriber, int priority) {     register(subscriber, defaultMethodName, true, priority); }

可以看到，这4个方法都调用了同一个方法：

代码如下	复制代码
private synchronized void register(Object subscriber, String methodName, boolean sticky, int priority) {     List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriber.getClass(), methodName);     for (SubscriberMethod subscriberMethod : subscriberMethods) {         subscribe(subscriber, subscriberMethod, sticky, priority);     } }

第一个参数就是订阅源，第二个参数就是用到指定方法名约定的，默认为*onEvent*开头，说默认是其实是可以通过参数修改的，但前面说了，方法已被废弃，最好不要用。第三个参数表示是否是*Sticky Event*，第4个参数是优先级，这两个后面再说。

在上面这个方法中，使用了一个叫`SubscriberMethodFinder`的类，通过其`findSubscriberMethods`方 法找到了一个`SubscriberMethod`列表，前面知道了`SubscriberMethod`表示Subcriber内一个 onEvent*方法，可以看出来`SubscriberMethodFinder`类的作用是在Subscriber中找到所有以 methodName（即默认的onEvent）开头的方法，每个找到的方法被表示为一个`SubscriberMethod`对象。

`SubscriberMethodFinder`就不再分析了，但有两点需要知道：

    所有事件处理方法**必需是`public void`类型**的，并且只有一个参数表示*EventType*。
    `findSubscriberMethods`不只查找*Subscriber*内的事件处理方法，**同时还会查到它的继承体系中的所有基类中的事件处理方法**。

找到*Subscriber*中的所有事件处理方法后，会对每个找到的方法（表示为`SubscriberMethod`对象）调用`subscribe`方法注册。`subscribe`方法干了三件事：

    根据`SubscriberMethod`中的*EventType*类型将`Subscribtion`对象存放在`subscriptionsByEventType`中。建立*EventType*到*Subscription*的映射，每个事件可以有多个订阅者。
    根据`Subscriber`将`EventType`存放在`typesBySubscriber`中，建立*Subscriber*到*EventType*的映射，每个Subscriber可以订阅多个事件。
    如果是*Sticky*类型的订阅者，直接向它发送上个保存的事件（如果有的话）。

通过*Subscriber*到*EventType*的映射，我们就可以很方便地使一个Subscriber取消接收事件，通过*EventType*到*Sucscribtion*的映射，可以方便地将相应的事件发送到它的每一个订阅者。

 

Post事件

直接调用`EventBus.getDefault().post(Event)就可以发送事件，根据Event的类型就可以发送到相应事件的订阅者。

代码如下

复制代码

public void post(Object event) {     PostingThreadState postingState = currentPostingThreadState.get();     List<Object> eventQueue = postingState.eventQueue;     eventQueue.add(event);     if (postingState.isPosting) {         return;     } else {         postingState.isMainThread = Looper.getMainLooper() == Looper.myLooper();         postingState.isPosting = true;         if (postingState.canceled) {             throw new EventBusException("Internal error. Abort state was not reset");         }         try {             while (!eventQueue.isEmpty()) {                 postSingleEvent(eventQueue.remove(0), postingState);             }         } finally {             postingState.isPosting = false;             postingState.isMainThread = false;             }     } }

可以看到post内使用了`PostingThreadState`的对象，并且是`ThreadLocal`，来看`PostingThreadState`的定义：

代码如下	复制代码
final static class PostingThreadState {     List<Object> eventQueue = new ArrayList<Object>();     boolean isPosting;     boolean isMainThread;     Subscription subscription;     Object event;     boolean canceled; }

主要是有个成员`eventQueue`，由于是ThreadLocal，所以 结果就是，每个线程有一个`PostingThreadState`对象，这个对象内部有一个事件的队列，并且有一个成员`isPosting`表示现在 是否正在派发事件，当发送事件开始时，会依次取出队列中的事件发送出去，如果正在派发事件，那么post直接把事件加入队列后返回，还有个成员 `isMainThread`，这个成员在实际派发事件时会用到，在`postSingleEvent`中会用到。

代码如下

复制代码

private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {     Class<? extends Object> eventClass = event.getClass();     List<Class<?>> eventTypes = findEventTypes(eventClass); // 1     boolean subscriptionFound = false;     int countTypes = eventTypes.size();     for (int h = 0; h < countTypes; h++) { // 2         Class<?> clazz = eventTypes.get(h);         CopyOnWriteArrayList<Subscription> subscriptions;         synchronized (this) {             subscriptions = subscriptionsByEventType.get(clazz);         }         if (subscriptions != null && !subscriptions.isEmpty()) { // 3             for (Subscription subscription : subscriptions) {                 postingState.event = event;                 postingState.subscription = subscription;                 boolean aborted = false;                 try {                     postToSubscription(subscription, event, postingState.isMainThread); // 4                     aborted = postingState.canceled;                 } finally {                     postingState.event = null;                     postingState.subscription = null;                     postingState.canceled = false;                 }                 if (aborted) {                     break;                 }             }             subscriptionFound = true;         }     }     if (!subscriptionFound) {         Log.d(TAG, "No subscribers registered for event " + eventClass);         if (eventClass != NoSubscriberEvent.class && eventClass != SubscriberExceptionEvent.class) {             post(new NoSubscriberEvent(this, event));         }     } }

来看一下`postSingleEvent`这个函数，首先看第一点，调用了`findEventTypes`这个函数，代码不帖了，这个函数的应用就是，把这个类的类对象、实现的接口及父类的类对象存到一个List中返回.

接下来进入第二步，遍历第一步中得到的List，对List中的每个类对象（即事件类型）执行第三步操作，即找到这个事件类型的所有订阅者向其发送 事件。可以看到，**当我们Post一个事件时，这个事件的父事件（事件类的父类的事件）也会被Post，所以如果有个事件订阅者接收Object类型的 事件，那么它就可以接收到所有的事件**。

还可以看到，实际是通过第四步中的`postToSubscription`来发送事件的，在发送前把事件及订阅者存入了`postingState`中。再来看`postToSubscription`

代码如下

复制代码

private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {     switch (subscription.subscriberMethod.threadMode) {     case PostThread:         invokeSubscriber(subscription, event);         break;     case MainThread:         if (isMainThread) {             invokeSubscriber(subscription, event);         } else {             mainThreadPoster.enqueue(subscription, event);         }         break;     case BackgroundThread:         if (isMainThread) {             backgroundPoster.enqueue(subscription, event);         } else {             invokeSubscriber(subscription, event);         }         break;     case Async:         asyncPoster.enqueue(subscription, event);         break;     default:         throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);     } }

这里就用到`ThreadMode`了：

    如果是PostThread，直接执行
    如果是MainThread，判断当前线程，如果本来就是UI线程就直接执行，否则加入`mainThreadPoster`队列
    如果是后台线程，如果当前是UI线程，加入`backgroundPoster`队列，否则直接执行
    如果是Async，加入`asyncPoster`队列

BackgroundPoster

代码如下	复制代码
private final PendingPostQueue queue; public void enqueue(Subscription subscription, Object event) {     PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);     synchronized (this) {         queue.enqueue(pendingPost);         if (!executorRunning) {             executorRunning = true;             EventBus.executorService.execute(this);         }     } }

代码比较简单，其实就是，待发送的事件被封装成了`PendingPost`对 象，`PendingPostQueue`是一个`PendingPost`对象的队列，当`enqueue`时就把这个事件放到队列 中，`BackgroundPoster`其实就是一个Runnable对象，当`enqueue`时，如果这个Runnable对象当前没被执行，就将 `BackgroundPoster`加入EventBus中的一个线程池中，当`BackgroundPoster`被执行时，会依次取出队列中的事件 进行派发。当长时间无事件时`BackgroundPoster`所属的线程被会销毁，下次再Post事件时再创建新的线程。

 

HandlerPoster

`mainThreadPoster`是一个`HandlerPoster`对象，`HandlerPoster`继承自`Handler`，构造 函数中接收一个`Looper`对象，当向`HandlerPoster` enqueue事件时，会像`BackgroundPoster`一样把这个事件加入队列中， 只是如果当前没在派发消息就向自身发送Message

代码如下

复制代码

void enqueue(Subscription subscription, Object event) {     PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);     synchronized (this) {         queue.enqueue(pendingPost);         if (!handlerActive) {             handlerActive = true;             if (!sendMessage(obtainMessage())) {                 throw new EventBusException("Could not send handler message");             }         }     } }

在`handleMessage`中会依次取出队列中的消息交由 `EventBus`直接调用事件处理函数，而`handleMessage`执行所在的线程就是构造函数中传进来的`Looper`所属的线程，在 `EventBus`中构造`mainThreadPoster`时传进来的是MainLooper，所以会在UI线程中执行。

 

AsyncPoster

`AsyncPoster`就简单了，把每个事件都加入线程池中处理

代码如下	复制代码
public void enqueue(Subscription subscription, Object event) {     PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);     queue.enqueue(pendingPost);     EventBus.executorService.execute(this); }

Stick Event

通过`registerSticky`可以注册Stick事件处理函数，前面我们知道了，无论是`register`还是`registerSticky`最后都会调用`Subscribe`函数，在`Subscribe`中有这么一段代码：

也就是会根据事件类型从`stickyEvents`中查找是否有对应的事件，如果有，直接发送这个事件到这个订阅者。而这个事件是什么时候存起来 的呢，同`register`与`registerSticky`一样，和`post`一起的还有一个`postSticky`函数：

代码如下

复制代码

if (sticky) {     Object stickyEvent;     synchronized (stickyEvents) {         stickyEvent = stickyEvents.get(eventType);     }     if (stickyEvent != null) {         // If the subscriber is trying to abort the event, it will fail (event is not tracked in posting state)         // --> Strange corner case, which we don't take care of here.         postToSubscription(newSubscription, stickyEvent, Looper.getMainLooper() == Looper.myLooper());     } }

当通过`postSticky`发送一个事件时，这个类型的事件的最后一次事件会被缓存起来，当有订阅者通过`registerSticky`注册时，会把之前缓存起来的这个事件直接发送给它。

 

事件优先级Priority

`register`的函数重载中有一个可以指定订阅者的优先级，我们知道`EventBus`中有一个事件类型到 List<Subscription>的映射，在这个映射中，所有的Subscription是按priority排序的，这样当post事 件时，优先级高的会先得到机会处理事件。

优先级的一个应用就事，高优先级的事件处理函数可以终于事件的传递，通过`cancelEventDelivery`方法，但有一点需要注意，`这个事件的ThreadMode必须是PostThread`，并且只能终于它在处理的事件。

# 缺点
无法进程间通信，如果一个应用内有多个进程的话就没办法了

# 注意事项及要点

    同一个onEvent函数不能被注册两次，所以不能在一个类中注册同时还在父类中注册
    当Post一个事件时，这个事件类的父类的事件也会被Post。
    Post的事件无Subscriber处理时会Post `NoSubscriberEvent`事件，当调用Subscriber失败时会Post `SubscriberExceptionEvent`事件。

其他

`EventBus`中还有个Util包，主要作用是可以通过`AsyncExecutor`执行一个Runnable，通过内部的 RunnableEx(可以搜索异常的Runnable)当Runnable抛出异常时通过`EventBus`发消息显示错误对话框。没太大兴趣，不作 分析

项目主页：https://github.com/greenrobot/EventBus

 一个很简单的Demo，Activity中包含列表和详情两个Fragment，Activity启动时加载一个列表，点击列表后更新详情数据：EventBusDemo

本文我们来分享一个android开发的ListView中嵌套GridView显示不完的解决方法，如果你也遇到了这个问题，以下就是解决办法。

项目需要，在ListView中显示多张图片，用到了GridView，不过如果使用普通的GridView，Item仅仅只是显示一部分，超出第一行以后的都无法显示了，这个很无语，所以又得继承下GridView重写onMeasure方法去测量子控件的宽高了..

这里只是贴出自定义GridView的代码，直接在xml中使用，ListView的Adapter中调用即可：

代码如下

复制代码

public class GridViewForListView extends GridView {     public GridViewForListView(Context context) {         super(context);     }     public GridViewForListView(Context context, AttributeSet attrs) {         super(context, attrs);     }     @Override     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {         int expandSpec = MeasureSpec.makeMeasureSpec(Integer.MAX_VALUE >> 2,                 MeasureSpec.AT_MOST);         super.onMeasure(widthMeasureSpec, expandSpec);     } }

现在的智能手机都是触屏的，现在我们来学习一下Android开发的Touch（触屏）事件，看了本文章后你可以在30分钟之内快速明白Touch事件分发机制。

Touch事件分发中只有两个主角:ViewGroup和View。Activity的Touch事件事实上是调用它内部的ViewGroup的Touch事件，可以直接当成ViewGroup处理。

View在ViewGroup内，ViewGroup也可以在其他ViewGroup内，这时候把内部的ViewGroup当成View来分析。

ViewGroup的相关事件有三个：onInterceptTouchEvent、dispatchTouchEvent、onTouchEvent。View的相关事件只有两个：dispatchTouchEvent、onTouchEvent。

先分析 ViewGroup的处理流程：首先得有个结构模型概念：ViewGroup和View组成了一棵树形结构，最顶层为Activity的 ViewGroup，下面有若干的ViewGroup节点，每个节点之下又有若干的ViewGroup节点或者View节点，依次类推。如图：

当一个 Touch事件(触摸事件为例)到达根节点，即Acitivty的ViewGroup时，它会依次下发，下发的过程是调用子 View(ViewGroup)的dispatchTouchEvent方法实现的。简单来说，就是ViewGroup遍历它包含着的子View，调用每个View的dispatchTouchEvent方法，而当子View为ViewGroup时，又会通过调用ViwGroup的 dispatchTouchEvent方法继续调用其内部的View的dispatchTouchEvent方法。上述例子中的消息下发顺序是这样的：①-②-⑤-⑥-⑦-③-④。dispatchTouchEvent方法只负责事件的分发，它拥有boolean类型的返回值，当返回为true时，顺序下发会中断。在上述例子中如果⑤的dispatchTouchEvent返回结果为true，那么⑥-⑦-③-④将都接收不到本次Touch事件。来个简单版的代码加深理解：

 

代码如下

复制代码

/**      * ViewGroup      * @param ev      * @return      */     public boolean dispatchTouchEvent(MotionEvent ev){         ....//其他处理，在此不管         View[] views=getChildView();         for(int i=0;i<views.length;i++){            //判断下Touch到屏幕上的点在该子View上面             if(...){             if(views[i].dispatchTouchEvent(ev))               return true;              }         }         ...//其他处理，在此不管     }     /**      * View      * @param ev      * @return      */     public boolean dispatchTouchEvent(MotionEvent ev){         ....//其他处理，在此不管         return false;     }

 

在此可以看出，ViewGroup的dispatchTouchEvent是真正在执行“分发”工作，而View的dispatchTouchEvent方法，并不执行分发工作，或者说它分发的对象就是自己，决定是否把touch事件交给自己处理，而处理的方法，便是onTouchEvent事件，事实上子View 的dispatchTouchEvent方法真正执行的代码是这样的

 

代码如下	复制代码
/**      * View      * @param ev      * @return      */     public boolean dispatchTouchEvent(MotionEvent ev){         ....//其他处理，在此不管         return onTouchEvent(event);     }

 

一般情况下，我们不该在普通View内重写dispatchTouchEvent方法，因为它并不执行分发逻辑。当Touch事件到达View时，我们该做的就是是否在onTouchEvent事件中处理它。

那么，ViewGroup的onTouchEvent事件是什么时候处理的呢?当ViewGroup所有的子View都返回false 时，onTouchEvent事件便会执行。由于ViewGroup是继承于View的，它其实也是通过调用View的 dispatchTouchEvent方法来执行onTouchEvent事件。

在目前的情况看来，似乎只要我们把所有的onTouchEvent都返回false，就能保证所有的子控件都响应本次Touch事件了。但必须要说明的是，这里的 Touch事件，只限于Acition_Down事件，即触摸按下事件,而Aciton_UP和Action_MOVE却不会执行。事实上，一次完整的 Touch事件，应该是由一个Down、一个Up和若干个Move组成的。Down方式通过dispatchTouchEvent分发，分发的目的是为了找到真正需要处理完整Touch请求的View。当某个View或者ViewGroup的onTouchEvent事件返回true时，便表示它是真正要处理这次请求的View，之后的Aciton_UP和Action_MOVE将由它处理。当所有子View的onTouchEvent都返回false 时，这次的Touch请求就由根ViewGroup，即Activity自己处理了。

看看改进后的ViewGroup的dispatchTouchEvent方法

 

代码如下

复制代码

View mTarget=null;//保存捕获Touch事件处理的View     public boolean dispatchTouchEvent(MotionEvent ev) {         //....其他处理，在此不管                 if(ev.getAction()==KeyEvent.ACTION_DOWN){             //每次Down事件，都置为Null             if(!onInterceptTouchEvent()){             mTarget=null;             View[] views=getChildView();             for(int i=0;i<views.length;i++){                 if(views[i].dispatchTouchEvent(ev))                     mTarget=views[i];                     return true;             }           }         }         //当子View没有捕获down事件时，ViewGroup自身处理。这里处理的Touch事件包含Down、Up和Move         if(mTarget==null){             return super.dispatchTouchEvent(ev);         }         //...其他处理，在此不管         if(onInterceptTouchEvent()){          //...其他处理，在此不管             } //这一步在Action_Down中是不会执行到的，只有Move和UP才会执行到。         return mTarget.dispatchTouchEvent(ev);     }

 

ViewGroup还有个onInterceptTouchEvent，看名字便知道这是个拦截事件。这个拦截事件需要分两种情况来说明：

1.假如我们在某个ViewGroup的onInterceptTouchEvent中，将Action为Down的Touch事件返回true，那便表示将该 ViewGroup的所有下发操作拦截掉，这种情况下，mTarget会一直为null，因为mTarget是在Down事件中赋值的。由于mTarge 为null，该ViewGroup的onTouchEvent事件被执行。这种情况下可以把这个ViewGroup直接当成View来对待。

2.假如我们在某个ViewGroup的onInterceptTouchEvent中，将Acion为Down的Touch事件都返回false，其他的都返回 True，这种情况下，Down事件能正常分发，若子View都返回false，那mTarget还是为空，无影响。若某个子View返回了 true，mTarget被赋值了，在Action_Move和Aciton_UP分发到该ViewGroup时，便会给mTarget分发一个 Action_Delete的MotionEvent，同时清空mTarget的值，使得接下去的Action_Move(如果上一个操作不是UP)将由 ViewGroup的onTouchEvent处理。

情况一用到的比较多，情况二个人还未找到使用场景。

从头到尾总结一下：

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使用BitmapShader图形渲染实现圆形、圆角和椭圆自定义图片View，本篇我们来讲讲另外一个更为常见的图形渲染方法Xfermode。

一：简介：

在上一篇《Android使用BitmapShader图形渲染实现圆形、圆角和椭圆自定义图片View》中，采用BitmapShader方法实现自定义的圆形、圆角等自定义ImageView，这篇我们将采用更为常见的Xfermode渲染模式方案来实现圆形、圆角和椭圆样式的ImageView，同样本实例也是直接继承ImageView，

这样可以省很多事情，比如测量步骤，以及不需要自己去写设置图片的方法，本文使用Xfermode模式中的DST_IN模式来实现要达到的效果，当然大家也可以采用其他的模式，比如SRC_IN等都可以实现该效果。

(照例完整源代码在文章的最后给出下载地址哈)

二：效果图：

三、Xfermode渲染模式简介：

xfermode影响在Canvas已经有的图像上绘制新的颜色的方式

* 正常的情况下,在图像上绘制新的形状,如果新的Paint不是透明的,那么会遮挡下面的颜色.

* 如果新的Paint是透明的,那么会被染成下面的颜色

下面的Xfermode子类可以改变这种行为：

AvoidXfermode 指定了一个颜色和容差，强制Paint避免在它上面绘图(或者只在它上面绘图)。

PixelXorXfermode 当覆盖已有的颜色时，应用一个简单的像素XOR操作。

PorterDuffXfermode 这是一个非常强大的转换模式，使用它，可以使用图像合成的16条Porter-Duff规则的任意一条来控制Paint如何与已有的Canvas图像进行交互。

这里不得不提到那个经典的图：

上面的16种模式的说明如下：

从上面我们可以看到PorterDuff.Mode为枚举类,一共有16个枚举值:

1.PorterDuff.Mode.CLEAR

所绘制不会提交到画布上。

2.PorterDuff.Mode.SRC

显示上层绘制图片

3.PorterDuff.Mode.DST

显示下层绘制图片

4.PorterDuff.Mode.SRC_OVER

正常绘制显示，上下层绘制叠盖。

5.PorterDuff.Mode.DST_OVER

上下层都显示。下层居上显示。

6.PorterDuff.Mode.SRC_IN

取两层绘制交集。显示上层。

7.PorterDuff.Mode.DST_IN

取两层绘制交集。显示下层。

8.PorterDuff.Mode.SRC_OUT

取上层绘制非交集部分。

9.PorterDuff.Mode.DST_OUT

取下层绘制非交集部分。

10.PorterDuff.Mode.SRC_ATOP

取下层非交集部分与上层交集部分

11.PorterDuff.Mode.DST_ATOP

取上层非交集部分与下层交集部分

12.PorterDuff.Mode.XOR

异或：去除两图层交集部分

13.PorterDuff.Mode.DARKEN

取两图层全部区域，交集部分颜色加深

14.PorterDuff.Mode.LIGHTEN

取两图层全部，点亮交集部分颜色

15.PorterDuff.Mode.MULTIPLY

取两图层交集部分叠加后颜色

16.PorterDuff.Mode.SCREEN

取两图层全部区域，交集部分变为透明色

四、自定义圆形、圆角和椭圆的ImageView的实现

1、测量View的大小,对圆形作特殊处理

 

 

代码如下

复制代码

/**      * 测量view的大小      */     @Override     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {         // TODO Auto-generated method stub         super.onMeasure(widthMeasureSpec, heightMeasureSpec);         //如果类型是圆形，则强制设置view的宽高一致，取宽高的较小值         if(mType == TYPE_CIRCLE){             int width = Math.min(getMeasuredWidth(),getMeasuredHeight());             setMeasuredDimension(width, width);         }     }

 

 

2、绘制不同图形的Bitmap，供onDraw()绘制的时候用

 

 

代码如下

复制代码

/**      * 绘制不同的图形Bitmap      */     private Bitmap getDrawBitmap(){         Bitmap bitmap = Bitmap.createBitmap(getWidth(), getHeight(),                  Bitmap.Config.ARGB_8888);          Canvas canvas = new Canvas(bitmap);          Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);          paint.setColor(Color.BLACK);            if(mType == TYPE_CIRCLE)         {//绘制圆形             canvas.drawCircle(getWidth() / 2, getWidth() / 2, getWidth() / 2,                      paint);         }else if(mType == TYPE_ROUND)          {//绘制圆角矩形             canvas.drawRoundRect(new RectF(0, 0, getWidth(), getHeight()),                      mRoundBorderRadius, mRoundBorderRadius, paint);          }else if(mType == TYPE_OVAL ){          //绘制椭圆             canvas.drawOval(new RectF(0, 0, getWidth(), getHeight()), mPaint);         }           return bitmap;      }

 

 

3、在onDraw()中绘制出来

 

代码如下

复制代码

/**      * 绘制view的内容      */     @Override     protected void onDraw(Canvas canvas) {         // TODO Auto-generated method stub         //从缓存中取出bitmap         Bitmap bmp = (mBufferBitmap == null ? null:mBufferBitmap.get());         if(bmp == null || bmp.isRecycled()){             //如果没有缓存存在的情况             //获取drawable             Drawable drawable = getDrawable();             //获取drawable的宽高             int dwidth = drawable.getIntrinsicWidth();             int dheight = drawable.getIntrinsicHeight();             Log.v("czm","dwidth="+dwidth+",width="+getWidth());             if(null != drawable){                 bmp = Bitmap.createBitmap(getWidth(), getHeight(),                          Config.ARGB_8888);                 float scale = 1.0f;                 //创建画布                 Canvas drawCanvas = new Canvas(bmp);                 //按照bitmap的宽高，以及view的宽高，计算缩放比例；因为设置的src宽高                 //比例可能和imageview的宽高比例不同，这里我们不希望图片失真；                                  if(mType == TYPE_CIRCLE)                  {//如果是圆形                      scale = getWidth() * 1.0F / Math.min(dwidth, dheight);                  }else if (mType == TYPE_ROUND || mType == TYPE_OVAL)                  {//如果是圆角矩形或椭圆                     // 如果图片的宽或者高与view的宽高不匹配，计算出需要缩放的比例；                     //缩放后的图片的宽高，一定要大于我们view的宽高；所以我们这里取大值；                      scale = Math.max(getWidth() * 1.0f / dwidth, getHeight()                              * 1.0f / dheight);                  }                 Log.v("czm","scale="+scale);                 //根据缩放比例，设置bounds，即相当于做缩放图片                  drawable.setBounds(0, 0, (int)(scale * dwidth), (int)(scale * dheight));                 drawable.draw(drawCanvas);                 //获取bitmap，即圆形、圆角或椭圆的bitmap                 if(mMaskBitmap == null || mMaskBitmap.isRecycled()){                     mMaskBitmap = getDrawBitmap();                 }                 //为paint设置Xfermode 渲染模式                 mPaint.reset();                 mPaint.setFilterBitmap(false);                 mPaint.setXfermode(mXfermode);                 //绘制不同形状                 drawCanvas.drawBitmap(mMaskBitmap, 0, 0,mPaint);                 mPaint.setXfermode(null);                                 //将准备好的bitmap绘制出来                  canvas.drawBitmap(bmp, 0, 0, null);                  //bitmap缓存起来，避免每次调用onDraw，分配内存                  mBufferBitmap = new WeakReference<Bitmap>(bmp);             }                     }else{             //如果缓存还存在的情况             mPaint.setXfermode(null);              canvas.drawBitmap(bmp, 0.0f, 0.0f, mPaint);              return;         }     }

 

 

 

4、因为使用了弱引用的缓存技术，所以需要在重写invalidate()方法中做些释放回收资源等处理：

 

 

代码如下	复制代码
/**      * 因为使用了缓存技术，所以需要在invalidate中做些回收释放资源的处理      */     @Override     public void invalidate() {         // TODO Auto-generated method stub         mBufferBitmap = null;         if(mMaskBitmap != null){             mMaskBitmap.recycle();             mMaskBitmap = null;         }         super.invalidate();     }

 

 

五、视图布局的实现：

 

 

代码如下

复制代码

<ScrollView 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"      >     <LinearLayout         android:layout_width="match_parent"         android:layout_height="wrap_content"         android:gravity="center_horizontal"         android:layout_marginTop="10dp"         android:layout_marginBottom="55dp"         android:orientation="vertical" >         <com.czm.myroundimageview.XCRoundImageViewByXfermode             android:id="@+id/cicleImageView"             android:layout_width="150dp"             android:layout_height="150dp"             android:src="@drawable/img1" />         <com.czm.myroundimageview.XCRoundImageViewByXfermode             android:id="@+id/roundRectImageView"             android:layout_width="125dp"             android:layout_height="145dp"             android:layout_marginTop="15dp"             android:src="@drawable/img2" />         <com.czm.myroundimageview.XCRoundImageViewByXfermode             android:id="@+id/ovalImageView"             android:layout_width="140dp"             android:layout_height="184dp"             android:layout_marginTop="15dp"             android:src="@drawable/img3" />     </LinearLayout> </ScrollView>

 

 

六、使用和测试自定义ImageView

上面直接绘制的自定义ImageView写完了，下面就是使用这个自定义的ImageView了，使用方法和普通的ImageView一样，当作普通控件使用即可。

 

 

代码如下

复制代码

package com.czm.myroundimageview; import android.app.Activity; import android.os.Bundle; public class MainActivity extends Activity {     private XCRoundImageViewByXfermode circleImageView;//圆形图片     private XCRoundImageViewByXfermode roundRectImageView;//圆角矩形图片     private XCRoundImageViewByXfermode ovalImageView;//椭圆图片     @Override     protected void onCreate(Bundle savedInstanceState) {         super.onCreate(savedInstanceState);         setContentView(R.layout.activity_main);         initViews();     }     /**      * 初始化Views      */     private void initViews(){         circleImageView = (XCRoundImageViewByXfermode)findViewById(R.id.cicleImageView);         roundRectImageView = (XCRoundImageViewByXfermode)findViewById(R.id.roundRectImageView);         ovalImageView = (XCRoundImageViewByXfermode)findViewById(R.id.ovalImageView);                 roundRectImageView.setType(XCRoundImageViewByXfermode.TYPE_ROUND);         roundRectImageView.setRoundBorderRadius(100);                 ovalImageView.setType(XCRoundImageViewByXfermode.TYPE_OVAL);         ovalImageView.setRoundBorderRadius(50);             } }

 

 

圆角图片在Android开发中比较常用，现在我们来介绍在Android如何实现圆形、圆角和椭圆自定义图片View，这时主要是使用BitmapShader图形渲染。

一、概述

Android实现圆角矩形，圆形或者椭圆等图形，一般主要是个自定义View加上使用Xfermode实现的。实现圆角图片的方法其实不少，常见的就是利用Xfermode，Shader。本文直接继承ImageView，使用BitmapShader方法来实现圆形、圆角和椭圆的绘制，等大家看我本文的方法后，其他的类似形状也就都能举一反三来来画出来了。

二、效果图：

三、BitmapShader简介

BitmapShader是Shader的子类，可以通过Paint.setShader(Shader shader)进行设置、

我们这里只关注BitmapShader，构造方法：

mBitmapShader = new BitmapShader(bitmap, TileMode.CLAMP, TileMode.CLAMP);

参数1：bitmap

参数2，参数3：TileMode;

TileMode的取值有三种：

CLAMP 拉伸

REPEAT 重复

MIRROR 镜像

如果大家给电脑屏幕设置屏保的时候，如果图片太小，可以选择重复、拉伸、镜像;

重复：就是横向、纵向不断重复这个bitmap

镜像：横向不断翻转重复，纵向不断翻转重复;

拉伸：这个和电脑屏保的模式应该有些不同，这个拉伸的是图片最后的那一个像素;横向的最后一个横行像素，不断的重复，纵项的那一列像素，不断的重复;

public BitmapShader(Bitmap bitmap,Shader.TileMode tileX,Shader.TileMode tileY)

调用这个方法来产生一个画有一个位图的渲染器(Shader)。

bitmap 在渲染器内使用的位图

tileX The tiling mode for x to draw the bitmap in. 在位图上X方向花砖模式

tileY The tiling mode for y to draw the bitmap in. 在位图上Y方向花砖模式

TileMode：(一共有三种)

CLAMP ：如果渲染器超出原始边界范围，会复制范围内边缘染色。

REPEAT ：横向和纵向的重复渲染器图片，平铺。

MIRROR ：横向和纵向的重复渲染器图片，这个和REPEAT 重复方式不一样，他是以镜像方式平铺。

四、自定义圆形、圆角和椭圆的图片View的实现

1. 测量View的大小

 

代码如下

复制代码

@Override     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {         // TODO Auto-generated method stub         super.onMeasure(widthMeasureSpec, heightMeasureSpec);         // 如果是绘制圆形，则强制宽高大小一致         if (mType == TYPE_CIRCLE) {             mWidth = Math.min(getMeasuredWidth(), getMeasuredHeight());             mRadius = mWidth / 2;             setMeasuredDimension(mWidth, mWidth);         }     }

 

2、设置BitmapShader和画笔Paint

 

代码如下

复制代码

/**      * 设置BitmapShader      */     private void setBitmapShader() {         Drawable drawable = getDrawable();         if (null == drawable) {             return;         }         Bitmap bitmap = drawableToBitmap(drawable);         // 将bitmap作为着色器来创建一个BitmapShader         mBitmapShader = new BitmapShader(bitmap, TileMode.CLAMP, TileMode.CLAMP);         float scale = 1.0f;         if (mType == TYPE_CIRCLE) {             // 拿到bitmap宽或高的小值             int bSize = Math.min(bitmap.getWidth(), bitmap.getHeight());             scale = mWidth * 1.0f / bSize;         } else if (mType == TYPE_ROUND || mType == TYPE_OVAL) {             // 如果图片的宽或者高与view的宽高不匹配，计算出需要缩放的比例；缩放后的图片的宽高，一定要大于我们view的宽高；所以我们这里取大值；             scale = Math.max(getWidth() * 1.0f / bitmap.getWidth(), getHeight() * 1.0f / bitmap.getHeight());         }         // shader的变换矩阵，我们这里主要用于放大或者缩小         mMatrix.setScale(scale, scale);         // 设置变换矩阵         mBitmapShader.setLocalMatrix(mMatrix);         mPaint.setShader(mBitmapShader);     }

 

 

3.最后就是绘制出来圆角、圆形和椭圆的图片，肯定在onDraw里面啦，根本原理就是使用了上面mBitmapShader渲染的画笔来绘制

 

代码如下

复制代码

@Override     protected void onDraw(Canvas canvas) {         if (null == getDrawable()) {             return;         }         setBitmapShader();         if (mType == TYPE_CIRCLE) {             canvas.drawCircle(mRadius, mRadius, mRadius, mPaint);         } else if (mType == TYPE_ROUND) {             mPaint.setColor(Color.RED);             canvas.drawRoundRect(mRect, mRoundRadius, mRoundRadius, mPaint);         }else if(mType == TYPE_OVAL){             canvas.drawOval(mRect, mPaint);         }     }

 

 

五、视图布局实现

这个很简单，就是3个自定义的view：

 

 

代码如下

复制代码

<ScrollView 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"     tools:context=".MainActivity" >     <LinearLayout         android:layout_width="match_parent"         android:layout_height="wrap_content"         android:gravity="center_horizontal"         android:layout_marginTop="5dp"         android:layout_marginBottom="25dp"         android:orientation="vertical" >         <com.czm.viewdrawtest.XCRoundAndOvalImageView             android:id="@+id/cicleImageView"             android:layout_width="200dp"             android:layout_height="200dp"             android:src="@drawable/img1" />         <com.czm.viewdrawtest.XCRoundAndOvalImageView             android:id="@+id/roundRectImageView"             android:layout_width="200dp"             android:layout_height="240dp"             android:layout_marginTop="5dp"             android:src="@drawable/img2" />         <com.czm.viewdrawtest.XCRoundAndOvalImageView             android:id="@+id/ovalImageView"             android:layout_width="wrap_content"             android:layout_height="wrap_content"             android:layout_marginTop="5dp"             android:src="@drawable/img3" />     </LinearLayout> </ScrollView>

 

六、使用和测试自定义View

上面直接绘制的自定义View写完了，下面就是使用这个View了，使用方法和普通的ImageView一样，当作普通控件使用即可。

 

 

代码如下

复制代码

package com.czm.viewdrawtest; import android.app.Activity; import android.os.Bundle; import android.view.Window; import android.view.WindowManager; /**  * 使用自定义ImageView  * @author caizhiming  *  */ public class MainActivity extends Activity {     private XCRoundAndOvalImageView circleImageView;//圆形图片     private XCRoundAndOvalImageView roundRectImageView;//圆角矩形图片     private XCRoundAndOvalImageView ovalImageView;//椭圆图片     @Override     protected void onCreate(Bundle savedInstanceState) {         super.onCreate(savedInstanceState);         //设置无标题          requestWindowFeature(Window.FEATURE_NO_TITLE);          //设置全屏          getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,                   WindowManager.LayoutParams.FLAG_FULLSCREEN);          setContentView(R.layout.activity_main);                 initViews();     }     /**      * 初始化Views      */     private void initViews(){         circleImageView = (XCRoundAndOvalImageView)findViewById(R.id.cicleImageView);         roundRectImageView = (XCRoundAndOvalImageView)findViewById(R.id.roundRectImageView);         ovalImageView = (XCRoundAndOvalImageView)findViewById(R.id.ovalImageView);                 roundRectImageView.setType(XCRoundAndOvalImageView.TYPE_ROUND);         roundRectImageView.setRoundRadius(100);                 ovalImageView.setType(XCRoundAndOvalImageView.TYPE_OVAL);         ovalImageView.setRoundRadius(50);             } }