Android Messenger 跨进程通信

转自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

    public class MessengerService extends Service {          /** For showing and hiding our notification. */          NotificationManager mNM;          /** Keeps track of all current registered clients. */          ArrayList<Messenger> mClients = new ArrayList<Messenger>();          /** Holds last value set by a client. */          int mValue = 0;                    /**          * Command to the service to register a client, receiving callbacks          * from the service.  The Message's replyTo field must be a Messenger of          * the client where callbacks should be sent.          */          static final int MSG_REGISTER_CLIENT = 1;                    /**          * Command to the service to unregister a client, ot stop receiving callbacks          * from the service.  The Message's replyTo field must be a Messenger of          * the client as previously given with MSG_REGISTER_CLIENT.          */          static final int MSG_UNREGISTER_CLIENT = 2;                    /**          * Command to service to set a new value.  This can be sent to the          * service to supply a new value, and will be sent by the service to          * any registered clients with the new value.          */          static final int MSG_SET_VALUE = 3;                    /**          * Handler of incoming messages from clients.          */          class IncomingHandler extends Handler {              @Override              public void handleMessage(Message msg) {                  switch (msg.what) {                      case MSG_REGISTER_CLIENT:                          mClients.add(msg.replyTo);                          break;                      case MSG_UNREGISTER_CLIENT:                          mClients.remove(msg.replyTo);                          break;                      case MSG_SET_VALUE:                          mValue = msg.arg1;                          for (int i = mClients.size() - 1; i >= 0; i --) {                              try {                                  mClients.get(i).send(Message.obtain(null,                                          MSG_SET_VALUE, mValue, 0));                              } catch (RemoteException e) {                                  // The client is dead.  Remove it from the list;                                   // we are going through the list from back to front                                   // so this is safe to do inside the loop.                                   mClients.remove(i);                              }                          }                          break;                      default:                          super.handleMessage(msg);                  }              }          }                    /**          * Target we publish for clients to send messages to IncomingHandler.          */          final Messenger mMessenger = new Messenger(new IncomingHandler());                    @Override          public void onCreate() {              mNM = (NotificationManager)getSystemService(NOTIFICATION_SERVICE);                    // Display a notification about us starting.               showNotification();          }                @Override          public void onDestroy() {              // Cancel the persistent notification.               mNM.cancel(R.string.remote_service_started);                    // Tell the user we stopped.               Toast.makeText(this, R.string.remote_service_stopped, Toast.LENGTH_SHORT).show();          }                    /**          * When binding to the service, we return an interface to our messenger          * for sending messages to the service.          */          @Override          public IBinder onBind(Intent intent) {              return mMessenger.getBinder();          }                /**          * Show a notification while this service is running.          */          private void showNotification() {              // In this sample, we'll use the same text for the ticker and the expanded notification               CharSequence text = getText(R.string.remote_service_started);                    // Set the icon, scrolling text and timestamp               Notification notification = new Notification(R.drawable.stat_sample, text,                      System.currentTimeMillis());                    // The PendingIntent to launch our activity if the user selects this notification               PendingIntent contentIntent = PendingIntent.getActivity(this, 0,                      new Intent(this, Controller.class), 0);                    // Set the info for the views that show in the notification panel.               notification.setLatestEventInfo(this, getText(R.string.remote_service_label),                             text, contentIntent);                    // Send the notification.               // We use a string id because it is a unique number.  We use it later to cancel.               mNM.notify(R.string.remote_service_started, notification);          }      }  

    public class MessengerServiceActivities {          /**          * Example of binding and unbinding to the remote service.          * This demonstrates the implementation of a service which the client will          * bind to, interacting with it through an aidl interface.</p>          *           * <p>Note that this is implemented as an inner class only keep the sample          * all together; typically this code would appear in some separate class.          */          public static class Binding extends Activity {                    /** Messenger for communicating with service. */              Messenger mService = null;              /** Flag indicating whether we have called bind on the service. */              boolean mIsBound;              /** Some text view we are using to show state information. */              TextView mCallbackText;                            /**              * Handler of incoming messages from service.              */              class IncomingHandler extends Handler {                  @Override                  public void handleMessage(Message msg) {                      switch (msg.what) {                          case MessengerService.MSG_SET_VALUE:                              mCallbackText.setText("Received from service: " + msg.arg1);                              break;                          default:                              super.handleMessage(msg);                      }                  }              }                            /**              * Target we publish for clients to send messages to IncomingHandler.              */              final Messenger mMessenger = new Messenger(new IncomingHandler());                            /**              * Class for interacting with the main interface of the service.              */              private ServiceConnection mConnection = new ServiceConnection() {                  public void onServiceConnected(ComponentName className,                          IBinder service) {                      // This is called when the connection with the service has been                       // established, giving us the service object we can use to                       // interact with the service.  We are communicating with our                       // service through an IDL interface, so get a client-side                       // representation of that from the raw service object.                       mService = new Messenger(service);                      mCallbackText.setText("Attached.");                            // We want to monitor the service for as long as we are                       // connected to it.                       try {                          Message msg = Message.obtain(null,                                  MessengerService.MSG_REGISTER_CLIENT);                          msg.replyTo = mMessenger;                          mService.send(msg);                                                    // Give it some value as an example.                                 msg = Message.obtain(null,                                  MessengerService.MSG_SET_VALUE, this.hashCode(), 0);                                mService.send(msg);                      } catch (RemoteException e) {                          // In this case the service has crashed before we could even                           // do anything with it; we can count on soon being                           // disconnected (and then reconnected if it can be restarted)                           // so there is no need to do anything here.                       }                                            // As part of the sample, tell the user what happened.                       Toast.makeText(Binding.this, R.string.remote_service_connected,                              Toast.LENGTH_SHORT).show();                  }                        public void onServiceDisconnected(ComponentName className) {                      // This is called when the connection with the service has been                       // unexpectedly disconnected -- that is, its process crashed.                       mService = null;                      mCallbackText.setText("Disconnected.");                            // As part of the sample, tell the user what happened.                       Toast.makeText(Binding.this, R.string.remote_service_disconnected,                              Toast.LENGTH_SHORT).show();                  }              };                            void doBindService() {                  // Establish a connection with the service.  We use an explicit                   // class name because there is no reason to be able to let other                   // applications replace our component.                   bindService(new Intent(Binding.this,                           MessengerService.class), mConnection, Context.BIND_AUTO_CREATE);                  mIsBound = true;                  mCallbackText.setText("Binding.");              }                            void doUnbindService() {                  if (mIsBound) {                      // If we have received the service, and hence registered with                       // it, then now is the time to unregister.                       if (mService != null) {                          try {                              Message msg = Message.obtain(null,                                      MessengerService.MSG_UNREGISTER_CLIENT);                              msg.replyTo = mMessenger;                              mService.send(msg);                          } catch (RemoteException e) {                              // There is nothing special we need to do if the service                               // has crashed.                           }                      }                                            // Detach our existing connection.                       unbindService(mConnection);                      mIsBound = false;                      mCallbackText.setText("Unbinding.");                  }              }                                  /**              * Standard initialization of this activity.  Set up the UI, then wait              * for the user to poke it before doing anything.              */              @Override              protected void onCreate(Bundle savedInstanceState) {                  super.onCreate(savedInstanceState);                        setContentView(R.layout.messenger_service_binding);                        // Watch for button clicks.                   Button button = (Button)findViewById(R.id.bind);                  button.setOnClickListener(mBindListener);                  button = (Button)findViewById(R.id.unbind);                  button.setOnClickListener(mUnbindListener);                                    mCallbackText = (TextView)findViewById(R.id.callback);                  mCallbackText.setText("Not attached.");              }                    private OnClickListener mBindListener = new OnClickListener() {                  public void onClick(View v) {                      doBindService();                  }              };                    private OnClickListener mUnbindListener = new OnClickListener() {                  public void onClick(View v) {                      doUnbindService();                  }              };          }      }