Android Messenger 跨进程通信!!!!!!!!!!!!!!!!!!

from: http://www.linuxidc.com/Linux/2012-02/53449.htm

Messenger:信使

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

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

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

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

一般使用方法如下：

１。远程通过

mMessenger = new Messenger(mHandler)  

 创建一个信使对象

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

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

return mMessenger.getBinder();  

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

public void onServiceConnected(ComponentName name, IBinder service) {    

              rMessenger = new Messenger(service);  　　　　

             ......

 }  

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

 public Messenger(IBinder target) {      mTarget = IMessenger.Stub.asInterface(target);  }  

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

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

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

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

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

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

双向通信宣告完成。

以下代码来自ApiDemo

Service code:

[java]

1. public class MessengerService extends Service {  
2.     /** For showing and hiding our notification. */  
3.     NotificationManager mNM;  
4.     /** Keeps track of all current registered clients. */  
5.     ArrayList<Messenger> mClients = new ArrayList<Messenger>();  
6.     /** Holds last value set by a client. */  
7.     int mValue = 0;  
8.       
9.     /** 
10.      * Command to the service to register a client, receiving callbacks 
11.      * from the service.  The Message's replyTo field must be a Messenger of 
12.      * the client where callbacks should be sent. 
13.      */  
14.     static final int MSG_REGISTER_CLIENT = 1;  
15.       
16.     /** 
17.      * Command to the service to unregister a client, ot stop receiving callbacks 
18.      * from the service.  The Message's replyTo field must be a Messenger of 
19.      * the client as previously given with MSG_REGISTER_CLIENT. 
20.      */  
21.     static final int MSG_UNREGISTER_CLIENT = 2;  
22.       
23.     /** 
24.      * Command to service to set a new value.  This can be sent to the 
25.      * service to supply a new value, and will be sent by the service to 
26.      * any registered clients with the new value. 
27.      */  
28.     static final int MSG_SET_VALUE = 3;  
29.       
30.     /** 
31.      * Handler of incoming messages from clients. 
32.      */  
33.     class IncomingHandler extends Handler {  
34.         @Override  
35.         public void handleMessage(Message msg) {  
36.             switch (msg.what) {  
37.                 case MSG_REGISTER_CLIENT:  
38.                     mClients.add(msg.replyTo);  
39.                     break;  
40.                 case MSG_UNREGISTER_CLIENT:  
41.                     mClients.remove(msg.replyTo);  
42.                     break;  
43.                 case MSG_SET_VALUE:  
44.                     mValue = msg.arg1;  
45.                     for (int i = mClients.size() - 1; i >= 0; i --) {  
46.                         try {  
47.                             mClients.get(i).send(Message.obtain(null,  
48.                                     MSG_SET_VALUE, mValue, 0));  
49.                         } catch (RemoteException e) {  
50.                             // The client is dead.  Remove it from the list;   
51.                             // we are going through the list from back to front   
52.                             // so this is safe to do inside the loop.   
53.                             mClients.remove(i);  
54.                         }  
55.                     }  
56.                     break;  
57.                 default:  
58.                     super.handleMessage(msg);  
59.             }  
60.         }  
61.     }  
62.       
63.     /** 
64.      * Target we publish for clients to send messages to IncomingHandler. 
65.      */  
66.     final Messenger mMessenger = new Messenger(new IncomingHandler());  
67.       
68.     @Override  
69.     public void onCreate() {  
70.         mNM = (NotificationManager)getSystemService(NOTIFICATION_SERVICE);  
71.   
72.         // Display a notification about us starting.   
73.         showNotification();  
74.     }  
75.   
76.     @Override  
77.     public void onDestroy() {  
78.         // Cancel the persistent notification.   
79.         mNM.cancel(R.string.remote_service_started);  
80.   
81.         // Tell the user we stopped.   
82.         Toast.makeText(this, R.string.remote_service_stopped, Toast.LENGTH_SHORT).show();  
83.     }  
84.       
85.     /** 
86.      * When binding to the service, we return an interface to our messenger 
87.      * for sending messages to the service. 
88.      */  
89.     @Override  
90.     public IBinder onBind(Intent intent) {  
91.         return mMessenger.getBinder();  
92.     }  
93.   
94.     /** 
95.      * Show a notification while this service is running. 
96.      */  
97.     private void showNotification() {  
98.         // In this sample, we'll use the same text for the ticker and the expanded notification   
99.         CharSequence text = getText(R.string.remote_service_started);  
100.   
101.         // Set the icon, scrolling text and timestamp   
102.         Notification notification = new Notification(R.drawable.stat_sample, text,  
103.                 System.currentTimeMillis());  
104.   
105.         // The PendingIntent to launch our activity if the user selects this notification   
106.         PendingIntent contentIntent = PendingIntent.getActivity(this, 0,  
107.                 new Intent(this, Controller.class), 0);  
108.   
109.         // Set the info for the views that show in the notification panel.   
110.         notification.setLatestEventInfo(this, getText(R.string.remote_service_label),  
111.                        text, contentIntent);  
112.   
113.         // Send the notification.   
114.         // We use a string id because it is a unique number.  We use it later to cancel.   
115.         mNM.notify(R.string.remote_service_started, notification);  
116.     }  
117. } 
     

Client code:

[java]

1. public class MessengerServiceActivities {  
2.     /** 
3.      * Example of binding and unbinding to the remote service. 
4.      * This demonstrates the implementation of a service which the client will 
5.      * bind to, interacting with it through an aidl interface.</p> 
6.      *  
7.      * <p>Note that this is implemented as an inner class only keep the sample 
8.      * all together; typically this code would appear in some separate class. 
9.      */  
10.     public static class Binding extends Activity {  
11.   
12.         /** Messenger for communicating with service. */  
13.         Messenger mService = null;  
14.         /** Flag indicating whether we have called bind on the service. */  
15.         boolean mIsBound;  
16.         /** Some text view we are using to show state information. */  
17.         TextView mCallbackText;  
18.           
19.         /** 
20.          * Handler of incoming messages from service. 
21.          */  
22.         class IncomingHandler extends Handler {  
23.             @Override  
24.             public void handleMessage(Message msg) {  
25.                 switch (msg.what) {  
26.                     case MessengerService.MSG_SET_VALUE:  
27.                         mCallbackText.setText("Received from service: " + msg.arg1);  
28.                         break;  
29.                     default:  
30.                         super.handleMessage(msg);  
31.                 }  
32.             }  
33.         }  
34.           
35.         /** 
36.          * Target we publish for clients to send messages to IncomingHandler. 
37.          */  
38.         final Messenger mMessenger = new Messenger(new IncomingHandler());  
39.           
40.         /** 
41.          * Class for interacting with the main interface of the service. 
42.          */  
43.         private ServiceConnection mConnection = new ServiceConnection() {  
44.             public void onServiceConnected(ComponentName className,  
45.                     IBinder service) {  
46.                 // This is called when the connection with the service has been   
47.                 // established, giving us the service object we can use to   
48.                 // interact with the service.  We are communicating with our   
49.                 // service through an IDL interface, so get a client-side   
50.                 // representation of that from the raw service object.   
51.                 mService = new Messenger(service);  
52.                 mCallbackText.setText("Attached.");  
53.   
54.                 // We want to monitor the service for as long as we are   
55.                 // connected to it.   
56.                 try {  
57.                     Message msg = Message.obtain(null,  
58.                             MessengerService.MSG_REGISTER_CLIENT);  
59.                     msg.replyTo = mMessenger;  
60.                     mService.send(msg);  
61.                       
62.                     // Give it some value as an example.   
63.   
64.                     msg = Message.obtain(null,  
65.                             MessengerService.MSG_SET_VALUE, this.hashCode(), 0);  
66.   
67.                     mService.send(msg);  
68.                 } catch (RemoteException e) {  
69.                     // In this case the service has crashed before we could even   
70.                     // do anything with it; we can count on soon being   
71.                     // disconnected (and then reconnected if it can be restarted)   
72.                     // so there is no need to do anything here.   
73.                 }  
74.                   
75.                 // As part of the sample, tell the user what happened.   
76.                 Toast.makeText(Binding.this, R.string.remote_service_connected,  
77.                         Toast.LENGTH_SHORT).show();  
78.             }  
79.   
80.             public void onServiceDisconnected(ComponentName className) {  
81.                 // This is called when the connection with the service has been   
82.                 // unexpectedly disconnected -- that is, its process crashed.   
83.                 mService = null;  
84.                 mCallbackText.setText("Disconnected.");  
85.   
86.                 // As part of the sample, tell the user what happened.   
87.                 Toast.makeText(Binding.this, R.string.remote_service_disconnected,  
88.                         Toast.LENGTH_SHORT).show();  
89.             }  
90.         };  
91.           
92.         void doBindService() {  
93.             // Establish a connection with the service.  We use an explicit   
94.             // class name because there is no reason to be able to let other   
95.             // applications replace our component.   
96.             bindService(new Intent(Binding.this,   
97.                     MessengerService.class), mConnection, Context.BIND_AUTO_CREATE);  
98.             mIsBound = true;  
99.             mCallbackText.setText("Binding.");  
100.         }  
101.           
102.         void doUnbindService() {  
103.             if (mIsBound) {  
104.                 // If we have received the service, and hence registered with   
105.                 // it, then now is the time to unregister.   
106.                 if (mService != null) {  
107.                     try {  
108.                         Message msg = Message.obtain(null,  
109.                                 MessengerService.MSG_UNREGISTER_CLIENT);  
110.                         msg.replyTo = mMessenger;  
111.                         mService.send(msg);  
112.                     } catch (RemoteException e) {  
113.                         // There is nothing special we need to do if the service   
114.                         // has crashed.   
115.                     }  
116.                 }  
117.                   
118.                 // Detach our existing connection.   
119.                 unbindService(mConnection);  
120.                 mIsBound = false;  
121.                 mCallbackText.setText("Unbinding.");  
122.             }  
123.         }  
124.   
125.           
126.         /** 
127.          * Standard initialization of this activity.  Set up the UI, then wait 
128.          * for the user to poke it before doing anything. 
129.          */  
130.         @Override  
131.         protected void onCreate(Bundle savedInstanceState) {  
132.             super.onCreate(savedInstanceState);  
133.   
134.             setContentView(R.layout.messenger_service_binding);  
135.   
136.             // Watch for button clicks.   
137.             Button button = (Button)findViewById(R.id.bind);  
138.             button.setOnClickListener(mBindListener);  
139.             button = (Button)findViewById(R.id.unbind);  
140.             button.setOnClickListener(mUnbindListener);  
141.               
142.             mCallbackText = (TextView)findViewById(R.id.callback);  
143.             mCallbackText.setText("Not attached.");  
144.         }  
145.   
146.         private OnClickListener mBindListener = new OnClickListener() {  
147.             public void onClick(View v) {  
148.                 doBindService();  
149.             }  
150.         };  
151.   
152.         private OnClickListener mUnbindListener = new OnClickListener() {  
153.             public void onClick(View v) {  
154.                 doUnbindService();  
155.             }  
156.         };  
157.     }  
158. }  

register:

[html]

1. <service Android:name=".app.MessengerService"  
2.         android:process=":remote" />