Android应用程序消息处理机制（Looper、Handler）分析（6）

3. 消息的处理

        前面在分析消息循环时，说到应用程序的主线程是在Looper类的loop成员函数中进行消息循环过程的，这个函数定义在frameworks/base/core/java/android/os/Looper.java文件中：

1. public class Looper {  
2.     ......  
3.   
4.     public static final void loop() {  
5.         Looper me = myLooper();  
6.         MessageQueue queue = me.mQueue;  
7.   
8.         ......  
9.   
10.         while (true) {  
11.             Message msg = queue.next(); // might block  
12.             ......  
13.   
14.             if (msg != null) {  
15.                 if (msg.target == null) {  
16.                     // No target is a magic identifier for the quit message.  
17.                     return;  
18.                 }  
19.   
20.                 ......  
21.   
22.                 msg.target.dispatchMessage(msg);  
23.                   
24.                 ......  
25.   
26.                 msg.recycle();  
27.             }  
28.         }  
29.     }  
30.   
31.     ......  
32. }  

它从消息队列中获得消息对象msg后，就会调用它的target成员变量的dispatchMessage函数来处理这个消息。在前面分析消息的发送时说过，这个消息对象msg的成员变量target是在发送消息的时候设置好的，一般就通过哪个Handler来发送消息，就通过哪个Handler来处理消息。

        我们继续以前面分析消息的发送时所举的例子来分析消息的处理过程。前面说到，在Android应用程序启动过程源代码分析这篇文章的Step 30中，ActivityManagerService通过调用ApplicationThread类的scheduleLaunchActivity函数通知应用程序，它可以加载应用程序的默认Activity了，而ApplicationThread类的scheduleLaunchActivity函数最终把这个请求封装成一个消息，然后通过ActivityThread类的成员变量mH来把这个消息加入到应用程序的消息队列中去。现在要对这个消息进行处理了，于是就会调用H类的dispatchMessage函数进行处理。

        H类没有实现自己的dispatchMessage函数，但是它继承了父类Handler的dispatchMessage函数，这个函数定义在frameworks/base/core/java/android/os/ Handler.java文件中：

1. public class Handler {  
2.     ......  
3.   
4.     public void dispatchMessage(Message msg) {  
5.         if (msg.callback != null) {  
6.             handleCallback(msg);  
7.         } else {  
8.             if (mCallback != null) {  
9.                 if (mCallback.handleMessage(msg)) {  
10.                     return;  
11.                 }  
12.             }  
13.             handleMessage(msg);  
14.         }  
15.     }  
16.   
17.     ......  
18. }  

   这里的消息对象msg的callback成员变量和Handler类的mCallBack成员变量一般都为null，于是，就会调用Handler类的handleMessage函数来处理这个消息，由于H类在继承Handler类时，重写了handleMessage函数，因此，这里调用的实际上是H类的handleMessage函数，这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

1. public final class ActivityThread {    
2.     
3.     ......    
4.     
5.     private final class H extends Handler {    
6.     
7.         ......    
8.     
9.         public void handleMessage(Message msg) {    
10.             ......    
11.             switch (msg.what) {    
12.             case LAUNCH_ACTIVITY: {    
13.                 ActivityClientRecord r = (ActivityClientRecord)msg.obj;    
14.     
15.                 r.packageInfo = getPackageInfoNoCheck(    
16.                     r.activityInfo.applicationInfo);    
17.                 handleLaunchActivity(r, null);    
18.             } break;    
19.             ......    
20.             }    
21.     
22.         ......    
23.     
24.     }    
25.     
26.     ......    
27. }    

 因为前面在分析消息的发送时所举的例子中，发送的消息的类型为H.LAUNCH_ACTIVITY，因此，这里就会调用ActivityThread类的handleLaunchActivity函数来真正地处理这个消息了，后面的具体过程就可以参考Android应用程序启动过程源代码分析这篇文章了。

         至此，我们就从消息循环、消息发送和消息处理三个部分分析完Android应用程序的消息处理机制了，为了更深理解，这里我们对其中的一些要点作一个总结：

         A. Android应用程序的消息处理机制由消息循环、消息发送和消息处理三个部分组成的。

         B. Android应用程序的主线程在进入消息循环过程前，会在内部创建一个Linux管道（Pipe），这个管道的作用是使得Android应用程序主线程在消息队列为空时可以进入空闲等待状态，并且使得当应用程序的消息队列有消息需要处理时唤醒应用程序的主线程。

         C. Android应用程序的主线程进入空闲等待状态的方式实际上就是在管道的读端等待管道中有新的内容可读，具体来说就是是通过Linux系统的Epoll机制中的epoll_wait函数进行的。

         D. 当往Android应用程序的消息队列中加入新的消息时，会同时往管道中的写端写入内容，通过这种方式就可以唤醒正在等待消息到来的应用程序主线程。

         E. 当应用程序主线程在进入空闲等待前，会认为当前线程处理空闲状态，于是就会调用那些已经注册了的IdleHandler接口，使得应用程序有机会在空闲的时候处理一些事情。1