Android 进程间的通信☞ Messenger

1、 服务端

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.util.Log;



public class MessengerService extends Service {
    public final static String TAG = "mainActivity";
    public final static String KEY_NAME = "Name";
    public final static String KEY_RESP = "Response";
    public final static String RETURNS_THE_RESULT = "Receive the success";
    public final static int MSG_WHAT_HELLO = 100;
    public final static int MSG_WHAT_RESP = 1001;

    /**
     * 作用于跨进程的序列化对象，携带着IMessenger AIDL接口
     */
    private static final Messenger messenger = new Messenger(new MessengerServerHandler());

    private static class MessengerServerHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            doHandleMessage(msg);
        }
    }

    /**
     * 处理其他进程发过来的消息
     * @param msg
     */
    public static void doHandleMessage(Message msg) {
        if (msg != null) {

            String result= "hello ";
            //接收客户端的消息并处理
            switch (msg.what){
                case MSG_WHAT_HELLO:
                    Log.e(TAG, "MessengerService: receive msg from client =" + msg.getData().getString(KEY_NAME));
                    try {
                        Thread.sleep(1000);
                        result+= msg.getData().getString(KEY_NAME);
                        //把处理结果封装到Message返回给客户端
                        Message reply = Message.obtain(null, 1001);
                        Bundle bundle = new Bundle();
                        bundle.putString(KEY_RESP, result);
                        reply.setData(bundle);
                        //msg.replyTo @ android.os.Messenger类型，Messager.replyTo指向的客户端的Messenger,
                        // 而Messenger又持有客户端的一个Binder对象（MessengerImpl）。服务端正是利用这个Binder对象做的与客户端的通信。
                        if (msg.replyTo != null) {
                            msg.replyTo.send(reply);
                        }
                        Log.d(TAG, "MessengerService: send message ==" + result);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    break;

                case 1002:
                    try {
                        String getData = msg.getData().getString("FmValue").trim();
                        double parseDouble = Double.parseDouble(getData);
                        Log.e(TAG, "MessengerService: receive msg from client 1002 =" + getData +", parseDouble ="+parseDouble);
                        //把处理结果封装到Message返回给客户端
                        Message replyFm = Message.obtain(null, 1002);
                        Bundle bundleFm = new Bundle();
                        bundleFm.putString("FmValue", RETURNS_THE_RESULT);
                        replyFm.setData(bundleFm);

                        if (msg.replyTo != null) {
                            msg.replyTo.send(replyFm);
                        }
                        Log.d(TAG, "MessengerService: send message = 1002 =" + RETURNS_THE_RESULT);


                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    break;

            }

        } else {
            Log.e(TAG, "handle client empty msg");
        }
    }

    @Override
    public IBinder onBind(Intent intent) {
        //返回Messenger的IBinder对象，当bindService 执行时候就会触发该回调，就可以拿到服务端的IBinder对象
        return messenger.getBinder();
    }
}

1.2 注册Service

        <service
            android:name=".activity.MessengerService"
            android:enabled="true"
            android:exported="true">
            <intent-filter>
                <action android:name="com.package.messager"/>

                <category android:name="android.intent.category.DEFAULT" />
            </intent-filter>
        </service>

1.3 开启

startService(new Intent(this,MessengerService.class));

2、客户端 

    /***********************1、Messenger 方式****************************/
    // 服务端的Messenger
    private Messenger serverMessenger;
    // 客户端的Messenger
    private Messenger mMessenger;
    //发送给服务端的消息类型
    private static final int SEND_MESSENGER = 0;
    //接收服务端的消息类型
    private static final int FIND_DEVICE = 1001;
    //用来标记service 是否已绑定
    private boolean isBindMcuService = false;
    /**
     * DFT
     */
    private void bindMcuDftService(Context context){
        Intent intent = new Intent();
        intent.setComponent(new ComponentName("com.package.messager","com.package.messager.activity.MessengerService"));
        isBindMcuService = context.bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE);
        //客户端Messenger
        mMessenger = new Messenger(new ClientHandler());
        Log.d("ModuleService","initView: isBindMcuService ="+isBindMcuService);
    }
    //接收服务连接和断开消息
    ServiceConnection serviceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            Log.d("ModuleService", "service connected");
            serverMessenger = new Messenger(service);
            //由于绑定后服务端没有客户端的Messenger
            // 绑定后先将客户端Messenger发送给服务端
            if (serverMessenger != null) {
                Log.d("ModuleService", "send messenger");
                sendByMessenger(100, "Name", "MCU");
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            Log.d("ModuleService", "service disconnected");
            serverMessenger = null;
        }
    };
    //从服务端接收消息
    public class ClientHandler extends Handler {

        @Override
        public void handleMessage( Message msg) {
            switch (msg.what){
                case FIND_DEVICE:
                    String resp = msg.getData().getString("Response");
                    Log.e("ModuleService", "ClientHandler: connected resp from server to deal ="+resp);
                    break;
                case 1002:
                    String fmValue = msg.getData().getString("FmValue");
                    Log.e("ModuleService", "ClientHandler: 1002 -- resp from server fmValue ="+fmValue);
                    break;

            }
        }
    }

    public void sendByMessenger(int what,String name,String value) {
        Message msg=Message.obtain(null,what);
        Bundle data=new Bundle();
        data.putString(name,value);
        msg.setData(data);
        //Client 发信时指定希望回信人
        // 将客户端进程的Messenger对象设置到Message中
        msg.replyTo = mMessenger;
        try {
            serverMessenger.send(msg);//跨进程传递
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }
    /***********************1、Messenger 方式****************************/

2.1 开启客户端

bindMcuDftService(context);

2.3  send Messager

sendByMessenger(1002, "FmValue", "88.8");