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实现消息通信；