Android IPC机制之Messenger

Messenger：两个进程通过Messenger传递消息，进程1和进程2中都需要创建一个Messenger，创建过程：首先进程2需要创建一个服务，

并在服务中创建一个Messenger对象，进程1通过绑定进程2的服务，在绑定服务时进程2通过Messenger返回一个IBinder对象，

进程1通过绑定服务后返回的IBinder对象，创建一个进程1的Messenger对象这样就和进程2建立联系，就可以通过Messenger进行消息传递

服务端：
1、在服务中创建一个Messenger，用于向客户端发送消息；
2、服务端服务在被绑定时通过Messenger获取IBinder对象并返回，这时就和客户端建立了联系。
3、客户端发送消息后，在服务端的Handler回调中的，可通过msg.reply方法获取客户端传递过来的messenger，

然后创建messge，加入messenger中，并由messenger传递给客户端

客户端：
1、首先绑定服务端的服务，服务端通过创建Messenger，从Messenger中获取客户端需要的IBinder对象并返回，

客户端根据服务端返回的IBinder对象，创建客户端的Messenger对象，通过Messenger和服务端建立联系，并进行消息传递；
2、客户端创建一个Message，由Messenger携带并传入服务端

示例代码如下：

首先是服务端代码：

 package com.jiao.myaidl;

 import android.app.Service;
 import android.content.Intent;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.IBinder;
 import android.os.Message;
 import android.os.Messenger;
 import android.os.RemoteException;

 public class MessengerService extends Service {
     public MessengerService() {
     }

     //创建Messenger对象
     private final Messenger mMessenger = new Messenger(new ServiceHandler());

     //消息回调，处理客户端传递过来的message对象
     private class ServiceHandler extends Handler {

         @Override
         public void handleMessage(Message msg) {
             super.handleMessage(msg);

             switch (msg.what) {
                 case 0:

                     System.out.println("客户端发过来的：" + msg.getData().getString("client"));
                     Messenger clientMessenger = msg.replyTo;//获取客户端传过来的Messenger对象
                     Message replyMessage = Message.obtain();//创建一个返回的message对象
                     replyMessage.what = 1;
                     Bundle bundle = new Bundle();
                     bundle.putString("server_reply", "i come from server");
                     replyMessage.setData(bundle);

                     try {
                         //通过客户端传过来的Messenger 将返回数据带回去
                         clientMessenger.send(replyMessage);
                     } catch (RemoteException e) {
                         e.printStackTrace();
                     }
                     break;
             }
         }
     }

     ;

     @Override
     public IBinder onBind(Intent intent) {
         //通过Messenger获取IBinder对象并返回
         return mMessenger.getBinder();
     }

 }

在清单文件中注册服务：

    <service android:name="com.jiao.myaidl.MessengerService">
             <intent-filter>
                 <action android:name="com.jiao.myaidl.action.MESSENGER_SERVICE" />
                 <category android:name="android.intent.category.DEFAULT" />
             </intent-filter>
         </service>

客户端代码：

 package com.jiao.myaidl;

 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.ServiceConnection;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.IBinder;
 import android.os.Message;
 import android.os.Messenger;
 import android.os.RemoteException;
 import android.support.v7.app.AppCompatActivity;
 import android.view.View;
 import android.widget.Button;

 import com.jiao.myaidl.client.R;

 public class MessengerActivity extends AppCompatActivity {

     private Messenger mMessenger;

     private class clientHandler extends Handler {

         @Override
         public void handleMessage(Message msg) {
             super.handleMessage(msg);
             switch (msg.what) {

                 case 1:
                     String server_reply = msg.getData().getString("server_reply");
                     System.out.println("服务器返回：" + server_reply);
                     break;
             }
         }
     }

     private ServiceConnection mConnection = new ServiceConnection() {
         @Override
         public void onServiceConnected(ComponentName name, IBinder service) {
             mMessenger = new Messenger(service);
             System.out.println("绑定服务成功");
         }

         @Override
         public void onServiceDisconnected(ComponentName name) {

             bindService();
         }
     };

     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_messenger);

         bindService();

         Button bt = (Button) findViewById(R.id.bt_messenger);
         bt.setOnClickListener(new View.OnClickListener() {
             @Override
             public void onClick(View v) {
                 sendToService();
             }
         });
     }

     private void bindService() {

         Intent it = new Intent();
         it.setAction("com.jiao.myaidl.action.MESSENGER_SERVICE");
         it.setPackage("com.jiao.myaidl.server");
         bindService(it, mConnection, Context.BIND_AUTO_CREATE);
     }

     private void sendToService() {
         Message messageClient = Message.obtain(null, 0);
         //用于传递给服务端回复的Messenger
         Messenger replyMessenger = new Messenger(new clientHandler());
         Bundle bundle = new Bundle();
         bundle.putString("client", "i come from client");
         messageClient.setData(bundle);
         //通过Message的replyTo属性将Messenger对象传递到服务端
         messageClient.replyTo = replyMessenger;
         try {
             mMessenger.send(messageClient);
         } catch (RemoteException e) {
             e.printStackTrace();
         }
     }

 }

以上就是两个进程之间通过Messenger实现消息通信；