Android信使Messager

原文地址：http://xwangly.iteye.com/blog/1109424

Messenger:信使

官方文档解释：它引用了一个Handler对象，以便others能够向它发送消息(使用mMessenger.send(Message msg)方法)。该类允许跨进程间基于Message的通信(即两个进程间可以通过Message进行通信)，在服务端使用Handler创建一个Messenger，客户端持有这个Messenger就可以与服务端通信了。

 

以前我们使用Handler+Message的方式进行通信，都是在同一个进程中，从线程持有一个主线程的Handler对象，并向主线程发送消息。

而Android既然可以使用bindler机制进行跨进行通信，所以我们当然可以将Handler与bindler结合起来进行跨进程发送消息。

查看API就可以发现，Messenger就是这种方式的实现。

一般使用方法如下：

１。远程通过

Java代码  

1. mMessenger = new Messenger(mHandler)  

 创建一个信使对象

２。客户端使用bindlerService请求连接远程

３。远程onBind方法返回一个bindler

Java代码  

1. return mMessenger.getBinder();  

 4.客户端使用远程返回的bindler得到一个信使（即得到远程信使）

Java代码  

1. public void onServiceConnected(ComponentName name, IBinder service) {  
2.     rMessenger = new Messenger(service);  
3. 　　　　　......  
4. }  

 这里虽然是new了一个Messenger，但我们查看它的实现

Java代码  

1. /** 
2.  * Create a Messenger from a raw IBinder, which had previously been 
3.  * retrieved with {@link #getBinder}. 
4.  *  
5.  * @param target The IBinder this Messenger should communicate with. 
6.  */  
7. public Messenger(IBinder target) {  
8.     mTarget = IMessenger.Stub.asInterface(target);  
9. }  

 发现它的mTarget是通过Aidl得到的，实际上就是远程创建的那个。

５。客户端可以使用这个远程信使对象向远程发送消息：rMessenger.send(msg);

这样远程服务端的Handler对象就能收到消息了，然后可以在其handlerMessage(Message msg)方法中进行处理。（该Handler对象就是第一步服务端创建Messenger时使用的参数mHandler）.

 

经过这５个步骤貌似只有客户端向服务端发送消息，这样的消息传递是单向的，那么如何实现双向传递呢？

首先需要在第５步稍加修改，在send(msg)前通过msm.replyTo = mMessenger将自己的信使设置到消息中，这样服务端接收到消息时同时也得到了客户端的信使对象了，然后服务端可以通过

Java代码  

1. //得到客户端的信使对象，并向它发送消息  
2. cMessenger = msg.replyTo;  
3. cMessenger.send(message);  

 即完成了从服务端向客户端发送消息的功能，这样客服端可以在自己的Handler对象的handlerMessage方法中接收服务端发送来的message进行处理。

双向通信宣告完成。

 

下面改写ApiDemos工程实现Messenger通信

MessengerService.java

Java代码  

1. package com.xwangly.apidemo.app;  
2.   
3. import java.util.Random;  
4.   
5. import android.app.Service;  
6. import android.content.Intent;  
7. import android.os.Handler;  
8. import android.os.IBinder;  
9. import android.os.Message;  
10. import android.os.Messenger;  
11. import android.os.RemoteException;  
12. import android.util.Log;  
13.   
14. public class MessengerService extends Service {  
15.     private String TAG = "MessengerService";  
16.   
17.     @Override  
18.     public void onDestroy() {  
19.         // TODO Auto-generated method stub  
20.         Log.i(TAG, "onDestroy");  
21.         cMessenger = null;  
22.         super.onDestroy();  
23.     }  
24.   
25.     @Override  
26.     public boolean onUnbind(Intent intent) {  
27.         // TODO Auto-generated method stub  
28.         Log.i(TAG, "onUnbind");  
29.         return super.onUnbind(intent);  
30.     }  
31.   
32.     static final int MSG_REGISTER_CLIENT = 1;  
33.     static final int MSG_UNREGISTER_CLIENT = 2;  
34.     static final int MSG_SET_VALUE = 3;  
35.   
36.     private Random random = new Random();  
37.   
38.     private Handler mHandler = new Handler() {  
39.   
40.         @Override  
41.         public void handleMessage(Message msg) {  
42.             // TODO Auto-generated method stub  
43.             Log.i(TAG, "handleMessage");  
44.             switch (msg.what) {  
45.             case MSG_SET_VALUE:  
46.                 try {  
47.                     Message message = Message.obtain(null,  
48.                             MessengerService.MSG_SET_VALUE);  
49.                     message.arg1 = random.nextInt(100);  
50.                       
51.                     //得到客户端的信使对象，并向它发送消息  
52.                     cMessenger = msg.replyTo;  
53.                     cMessenger.send(message);  
54.                 } catch (RemoteException e) {  
55.                     // TODO Auto-generated catch block  
56.                     e.printStackTrace();  
57.                 }  
58.                 break;  
59.             default:  
60.                 super.handleMessage(msg);  
61.             }  
62.   
63.         }  
64.     };  
65.   
66.     /** 
67.      * 自己的信使对象 
68.      */  
69.     private Messenger mMessenger = new Messenger(mHandler);  
70.   
71.     /** 
72.      * 客户的信使 
73.      */  
74.     private Messenger cMessenger;  
75.   
76.     @Override  
77.     public IBinder onBind(Intent intent) {  
78.         // TODO Auto-generated method stub  
79.         Log.i(TAG, "onBind");  
80.         //返回自己信使的bindler,以供客户端通过这个bindler得到服务端的信使对象（通过new Messenger(bindler)）  
81.         return mMessenger.getBinder();  
82.     }  
83.   
84.     @Override  
85.     public void onRebind(Intent intent) {  
86.         // TODO Auto-generated method stub  
87.         Log.i(TAG, "onRebind");  
88.   
89.     }  
90.   
91. }  

 MessengerServiceActivities.java

Java代码  

1. package com.xwangly.apidemo.app;  
2.   
3. import com.xwangly.apidemo.R;  
4.   
5. import android.app.Activity;  
6. import android.content.ComponentName;  
7. import android.content.Intent;  
8. import android.content.ServiceConnection;  
9. import android.os.Bundle;  
10. import android.os.Handler;  
11. import android.os.IBinder;  
12. import android.os.Message;  
13. import android.os.Messenger;  
14. import android.os.RemoteException;  
15. import android.util.Log;  
16. import android.view.View;  
17. import android.widget.TextView;  
18.   
19. public class MessengerServiceActivities {  
20.     public static class Binding extends Activity implements  
21.             View.OnClickListener {  
22.         private String TAG = "Binding";  
23.   
24.         TextView mCallbackText;  
25.   
26.         private boolean isBound;  
27.   
28.         @Override  
29.         protected void onCreate(Bundle savedInstanceState) {  
30.             // TODO Auto-generated method stub  
31.             super.onCreate(savedInstanceState);  
32.             setContentView(R.layout.messenger_service_binding);  
33.             findViewById(R.id.bind).setOnClickListener(this);  
34.             findViewById(R.id.unbind).setOnClickListener(this);  
35.   
36.             mCallbackText = (TextView) findViewById(R.id.callback);  
37.             mCallbackText.setText("Not attached.");  
38.   
39.         }  
40.   
41.         private Handler mHandler = new Handler() {  
42.             @Override  
43.             public void handleMessage(Message msg) {  
44.                 Log.i(TAG, "handleMessage");  
45.                 switch (msg.what) {  
46.                 case MessengerService.MSG_SET_VALUE:  
47.                     mCallbackText.setText("Received from service: " + msg.arg1);  
48.                     break;  
49.                 default:  
50.                     super.handleMessage(msg);  
51.                 }  
52.             }  
53.         };  
54.   
55.         /** 
56.          * 自己的信使 
57.          */  
58.         private Messenger mMessenger;  
59.           
60.         /** 
61.          * 远程服务的信使 
62.          */  
63.         private Messenger rMessenger;  
64.           
65.         private ServiceConnection connection = new ServiceConnection() {  
66.   
67.             public void onServiceConnected(ComponentName name, IBinder service) {  
68.                 // TODO Auto-generated method stub  
69.                 Log.i(TAG, "onServiceConnected");  
70.                 rMessenger = new Messenger(service);  
71.                 mMessenger = new Messenger(mHandler);  
72.                   
73.                 sendMessage();  
74.             }  
75.   
76.   
77.             public void onServiceDisconnected(ComponentName name) {  
78.                 // TODO Auto-generated method stub  
79.                 rMessenger = null;  
80.             }  
81.         };  
82.   
83.         public void onClick(View v) {  
84.             // TODO Auto-generated method stub  
85.             Intent intent = new Intent(  
86.                     "com.xwangly.apidemo.app.messenger_service");  
87.             switch (v.getId()) {  
88.             case R.id.bind:  
89.                 if (!isBound) {  
90.                     isBound = bindService(intent, connection, BIND_AUTO_CREATE);  
91.                     //isBound = true;  
92.                 }else {  
93.                     sendMessage();  
94.                 }  
95.                 break;  
96.             case R.id.unbind:  
97.                 if (isBound) {  
98.                     unbindService(connection);  
99.                     isBound = false;  
100.                 }  
101.                 break;  
102.             default:  
103.                 break;  
104.             }  
105.         }  
106.           
107.         /** 
108.          * 使用服务端的信使向它发送一个消息。 
109.          */  
110.         private void sendMessage() {  
111.             // TODO Auto-generated method stub  
112.             Message message = Message.obtain(null, MessengerService.MSG_SET_VALUE);  
113.             message.replyTo = mMessenger;  
114.             try {  
115.                 rMessenger.send(message);  
116.             } catch (RemoteException e) {  
117.                 // TODO Auto-generated catch block  
118.                 e.printStackTrace();  
119.             }  
120.         }  
121.   
122.     }  
123.   
124. }  

 AndroidManifest.xml相关配置如下：

Xml代码  

1. <service android:name=".app.MessengerService" >  
2.     <intent-filter>  
3.         <action android:name="com.xwangly.apidemo.app.messenger_service" />  
4.     </intent-filter>  
5. </service>  
6.       <activity android:name=".app.MessengerServiceActivities$Binding"  
7.               android:label="@string/activity_messenger_service_binding"  
8.               android:launchMode="singleTop">  
9.           <intent-filter>  
10.               <action android:name="android.intent.action.MAIN" />  
11.               <category android:name="android.intent.category.LAUNCHER" />  
12.           </intent-filter>  
13.       </activity>  

 至于layout就不帖了，两个按钮一个文本域。