多进程通信Messenger使用

Messenger

Messenger是一种轻量级的IPC方案。适用于进程间通信，可以在不同进程中传递Message对象，在Message中放入需要传递的数据，就可以实现数据的进程间传递了。

使用步骤
首先创建MessengerService 继承 Service，并创建MessengerHandler继承Handler用于接收消息。

private static class MessengerHandler extends Handler{
        @Override
        public void handleMessage(Message msg) {
                    super.handleMessage(msg);
        }
    }

创建Messenger

 private Messenger mMessenger = new Messenger(new MessengerHandler());

并在onBind()方法中将mMessenger.getBinder()返回。

Service当然要在AndroidManifest.xml文件中注册，并单独启一个进程。

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

接下来创建MessengerActivity和Service建立连接并开启服务。

 private ServiceConnection mServiceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            //创建Messenger
            Messenger messenger = new Messenger(service);
			//创建Message
            Message message = Message.obtain();
            //标识
            message.what = Constants.MSGCLIENT;
            //创建Bundle
            Bundle bundle = new Bundle();
            //保存数据
            bundle.putString("msg","你好啊，送你一朵小发发");
            //赋值
            message.setData(bundle);
            
            try {
            	//发送数据
                messenger.send(message);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };
    private void initData() {
        Intent intent = new Intent(this, MessengerService.class);
        bindService(intent,mServiceConnection, Context.BIND_AUTO_CREATE);

    }

  @Override
    protected void onDestroy() {
        unbindService(mServiceConnection);
        super.onDestroy();
    }

然后修改MessengerService中的MessengerHandler 中对消息进行接收。

 private static class MessengerHandler extends Handler{
        @Override
        public void handleMessage(Message msg) {

            switch (msg.what){
                case Constants.MSGCLIENT:
                    Log.e(TAG, "handleMessage: clientmessage"+msg.getData().getString("msg"));
                    break;
                default:
                    super.handleMessage(msg);
                    break;
            }
        }
    }

运行程序即可看到发送给MessengerService的消息。

如果这个时候需要MessengerService对 MessengerActivity做出回应怎么处理呢。

在MessengerActivity中创建MessengerActivityHandler

 private static class MessengerActivityHandler extends Handler{
        @Override
        public void handleMessage(Message msg) {
                super.handleMessage(msg);
        }
    };

并创建mReplyMessenger

 private Messenger mReplyMessenger = new Messenger(new MessengerActivityHandler ());

在给MessengerService发送消息的时候将mReplyMessenger 传递过去。

 			/**
             * 重要  将mReplyMessenger给回去
             */
            message.replyTo = mReplyMessenger;

MessengerService中处理

private static class MessengerHandler extends Handler{
        @Override
        public void handleMessage(Message msg) {

            switch (msg.what){
                case Constants.MSGCLIENT:
                    Log.e(TAG, "handleMessage: clientmessage"+msg.getData().getString("msg"));
                    //拿到Messenger对象
                    Messenger messenger = msg.replyTo;
                    //创建Message
                    Message replyMessage = Message.obtain();
                    //标识
                    replyMessage.what = Constants.MSGSERVICE;
                    //创建Bundle
                    Bundle bundle = new Bundle();
                    //保存数据
                    bundle.putString("reply","收到了你的消息，但我就是不想理你");
                    //赋值
                    replyMessage.setData(bundle);

                    try {
                        //发送数据
                        messenger.send(replyMessage);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }


                    break;
                default:
                    super.handleMessage(msg);
                    break;
            }
        }
    }

然后在MessengerActivity中对数据进行接收

 private static class MessengerActivityHandler  extends Handler{
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what){
                case Constants.MSGSERVICE:
                    Log.e(TAG, "handleMessage: servicemessage"+msg.getData().getString("reply"));
                    break;
                default:
                    super.handleMessage(msg);
                    break;
            }
        }
    };

运行程序，如图:

完整代码
MessengerService

package com.example.test.service;

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;
import android.support.annotation.Nullable;
import android.util.Log;

import com.example.test.utils.Constants;

/**
 * Description:
 */

public class MessengerService extends Service {

    private static final String TAG = "MessengerService";

    private static class MessengerHandler extends Handler{
        @Override
        public void handleMessage(Message msg) {

            switch (msg.what){
                case Constants.MSGCLIENT:
                    Log.e(TAG, "handleMessage: clientmessage"+msg.getData().getString("msg"));
                    //拿到Messenger对象
                    Messenger messenger = msg.replyTo;
                    //创建Message
                    Message replyMessage = Message.obtain();
                    //标识
                    replyMessage.what = Constants.MSGSERVICE;
                    //创建Bundle
                    Bundle bundle = new Bundle();
                    //保存数据
                    bundle.putString("reply","收到了你的消息，但我就是不想理你");
                    //赋值
                    replyMessage.setData(bundle);

                    try {
                        //发送数据
                        messenger.send(replyMessage);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }


                    break;
                default:
                    super.handleMessage(msg);
                    break;
            }
        }
    }

    private Messenger mMessenger = new Messenger(new MessengerHandler());

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return mMessenger.getBinder();
    }
}

MessengerActivity

package com.example.test.process;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
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.os.Bundle;
import android.util.Log;

import com.example.test.R;
import com.example.test.service.MessengerService;
import com.example.test.utils.Constants;

/**
 * messenger
 */
public class MessengerActivity extends AppCompatActivity {
    private static final String TAG = "MessengerActivity";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_messenger);
        initData();
    }
    private Messenger mReplyMessenger = new Messenger(new MessengerActivityHandler ());
    private static class MessengerActivityHandler  extends Handler{
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what){
                case Constants.MSGSERVICE:
                    Log.e(TAG, "handleMessage: servicemessage"+msg.getData().getString("reply"));
                    break;
                default:
                    super.handleMessage(msg);
                    break;
            }
        }
    };



    private ServiceConnection mServiceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            //创建Messenger
            Messenger messenger = new Messenger(service);
            //创建Message
            Message message = Message.obtain();
            //标识
            message.what = Constants.MSGCLIENT;
            //创建Bundle
            Bundle bundle = new Bundle();
            //保存数据
            bundle.putString("msg","你好啊，送你一朵小发发");
            //赋值
            message.setData(bundle);


            /**
             * 重要  将mReplyMessenger给回去
             */
            message.replyTo = mReplyMessenger;
            try {
                //发送数据
                messenger.send(message);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };
    private void initData() {
        Intent intent = new Intent(this, MessengerService.class);
        bindService(intent,mServiceConnection, Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onDestroy() {
        unbindService(mServiceConnection);
        super.onDestroy();
    }
}