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

  2. 消息的发送

        应用程序的主线程准备就好消息队列并且进入到消息循环后，其它地方就可以往这个消息队列中发送消息了。我们继续以文章开始介绍的Android应用程序启动过程源代码分析一文中的应用程序启动过为例，说明应用程序是如何把消息加入到应用程序的消息队列中去的。

        在Android应用程序启动过程源代码分析这篇文章的Step 30中，ActivityManagerService通过调用ApplicationThread类的scheduleLaunchActivity函数通知应用程序，它可以加载应用程序的默认Activity了，这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

1. public final class ActivityThread {    
2.     
3.     ......    
4.     
5.     private final class ApplicationThread extends ApplicationThreadNative {    
6.     
7.         ......    
8.     
9.         // we use token to identify this activity without having to send the    
10.         // activity itself back to the activity manager. (matters more with ipc)    
11.         public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,    
12.                 ActivityInfo info, Bundle state, List<ResultInfo> pendingResults,    
13.                 List<Intent> pendingNewIntents, boolean notResumed, boolean isForward) {    
14.             ActivityClientRecord r = new ActivityClientRecord();    
15.     
16.             r.token = token;    
17.             r.ident = ident;    
18.             r.intent = intent;    
19.             r.activityInfo = info;    
20.             r.state = state;    
21.     
22.             r.pendingResults = pendingResults;    
23.             r.pendingIntents = pendingNewIntents;    
24.     
25.             r.startsNotResumed = notResumed;    
26.             r.isForward = isForward;    
27.     
28.             queueOrSendMessage(H.LAUNCH_ACTIVITY, r);    
29.         }    
30.     
31.         ......    
32.     
33.     }    
34.     
35.     ......    
36. }    

  这里把相关的参数都封装成一个ActivityClientRecord对象r，然后调用queueOrSendMessage函数来往应用程序的消息队列中加入一个新的消息（H.LAUNCH_ACTIVITY），这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中：

1. public final class ActivityThread {    
2.     
3.     ......    
4.     
5.     private final class ApplicationThread extends ApplicationThreadNative {    
6.     
7.         ......    
8.     
9.         // if the thread hasn't started yet, we don't have the handler, so just    
10.         // save the messages until we're ready.    
11.         private final void queueOrSendMessage(int what, Object obj) {    
12.             queueOrSendMessage(what, obj, 0, 0);    
13.         }    
14.     
15.         ......    
16.     
17.         private final void queueOrSendMessage(int what, Object obj, int arg1, int arg2) {    
18.             synchronized (this) {    
19.                 ......    
20.                 Message msg = Message.obtain();    
21.                 msg.what = what;    
22.                 msg.obj = obj;    
23.                 msg.arg1 = arg1;    
24.                 msg.arg2 = arg2;    
25.                 mH.sendMessage(msg);    
26.             }    
27.         }    
28.     
29.         ......    
30.     
31.     }    
32.     
33.     ......    
34. }    

 在queueOrSendMessage函数中，又进一步把上面传进来的参数封装成一个Message对象msg，然后通过mH.sendMessage函数把这个消息对象msg加入到应用程序的消息队列中去。这里的mH是ActivityThread类的成员变量，它的类型为H，继承于Handler类，它定义在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.             ......    
13.             }    
14.     
15.         ......    
16.     
17.     }    
18.     
19.     ......    
20. }   

 这个H类就是通过其成员函数handleMessage函数来处理消息的了，后面我们分析消息的处理过程时会看到。