Android Messenger 跨進程通訊

Messenger:信使

官方文檔解釋：

它引用了一個Handler對象，以便 others 可以向它發送消息(使用

mMessenger.send(Message msg)

方法)。

該類容許跨進程間基於Message的通訊(即兩個進程間能夠經過Message進行通訊)，在服務端使用Handler建立一個Messenger，客戶端持有這個Messenger就能夠與服務端通訊了。

之前咱們使用Handler+Message的方式進行通訊，都是在同一個進程中，從線程持有一個主線程的Handler對象，並向主線程發送消息。

而Android既然可使用bindler機制進行跨進行通訊，因此咱們固然能夠將Handler與bindler結合起來進行**跨進程**發送消息。

查看API就能夠發現，Messenger就是這種方式的實現。

通常使用方法以下：

1. 遠程經過

   mMessenger = new Messenger(mHandler)

   建立一個信使對象

2. 客戶端使用bindlerService請求鏈接遠程

3. 遠程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獲得的，實際上就是遠程建立的那個。

5. 客戶端可使用這個遠程信使對象向遠程發送消息：

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:

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);  
    }  
}

Client code:

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();  
            }  
        };  
    }  
}

註冊服務：

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