Android Messenger 跨進程通訊

 

若是你須要在不一樣進程間通訊，你能夠在Service中使用Messenger來實現進程中通訊。

若是使用這種方式，Service中須要定義一個Handler對象(負責對客戶端發送過來的Message進行響應)。

Messenger能夠共享給client一個IBinder對象，client經過這個IBinder對象向Service發送Message，而前面提到的Handler對象是這一切的基礎。

注：使用這種方式進行通訊是不支持多線程的。

那就讓咱們來看看使用這種方式進行通訊吧！

注：Service在聲明時必須對外開放，即android:exported="true"，且本文是經過Intent啓動的Service，因此在聲明時該Service能夠接收特定的Action。

一、在Service中建立一個Handler對象，來處理從client發過來的Message

二、根據建立的Handler對象建立一個Messenger對象

三、使用Messenger的getBinder方法獲得一個IBinder對象，並在Service的onBind方法中將其反出去

四、client在onServiceConnected中根據IBinder參數建立一個Messenger對象(可參考Messenger的構造函數)

五、client能夠使用上一步獲得的Messenger對象來給Service發送Message了

通過上面的五部咱們就能讓client與Service進行通訊。client使用Messenger對象給Service發送Message後，Service中的Handler將會對消息做出響應。

上面實現的僅僅是單向通訊，即client給Service發送消息，若是我須要Service給client發送消息又該怎樣作呢？

其實，這也是很容易實現的，下面就讓咱們接着上面的步驟來實現雙向通訊吧~

六、在client中建立一個Handler對象，用於處理Service發過來的消息

七、根據client中的Handler對象建立一個client本身的Messenger對象

八、咱們在第5步的時候得到了Service的Messenger對象，並經過它來給Service發送消息。這時候，咱們將client的Messenger對象賦給待發送的Message對象的replyTo字段

九、在Service的Handler處理Message時將client的Messenger解析出來，並使用client的Messenger對象給client發送消息

這樣咱們就實現了client和Service的雙向通訊。client和Service都有本身的Handler和Messenger對象，使得對方能夠給本身發送消息，值得注意的是client的Messenger是經過Message的replyTo傳遞給Service的。

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" />