安卓Messenger跨进程双向通信

要实现IPC（跨进程通信），可以使用官方给我们提供的Messenger机制和AIDL机制。

其中Messenger使用简单，适用于大部分多进程、单线程的应用，
AIDL适用于较为复杂的多进程、多线程的应用。

这里我们介绍Messenger的用法，其底层也是使用AIDL实现的。

来看下Messenger用法

Reference to a Handler, which others can use to send messages to it.
This allows for the implementation of message-based communication across
processes, by creating a Messenger pointing to a Handler in one process,
and handing that Messenger to another process.

Messenger需要传递一个Handler，用于处理跨进程消息
构造：Messenger(Handler target)
发送消息：send(Message message) throws RemoteException
传递给客户端：可以通过IBinder机制 IBinder getBinder()

要使用这套机制，必须为通信双方建立各自的Messenger，然后Service的Messenger依然是通过IBinder传递到Activity，Activity也可以将自己的Messenger通过Message的replyTo属性传递到Service。

注意：跨进程通信使用Bundle，否则会报错Java.lang.RuntimeException: Can’t marshal non-Parcelable objects across processes.

双向通讯例子：
客户端给服务端发送消息，服务端接收到后对值进行累计
累计到10后，给客户端发送消息，客户端显示升级

多进程服务声明

<service
 android:name=".Messenger.MessengerService"
 android:process=":it"
 android:enabled="true"
 android:exported="true"
 >service>

服务端

/*
 * Copyright (c) 2020.
 * author:  duck
 */

package com.ducky.cachepicasso.Messenger;

import android.app.Service;
import android.content.Context;
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;
import android.widget.Toast;

import androidx.annotation.NonNull;

public class MessengerService extends Service {

    static final String TAG = "Messenger-Service";

    private int sum = 0;

    public MessengerService() {
    }

    private Messenger messenger = new Messenger(new ServiceHandler());
    private Messenger mClient;

    public class ServiceHandler extends Handler{
        private static final int SIG_GET_PLUS = 0;
        private static final int SIG_SEND_UPDATE = 1;

        @Override
        public void handleMessage(@NonNull Message msg) {
            // 处理消息
            switch(msg.what){
                case SIG_GET_PLUS:
                    Bundle bundle = msg.getData();
                    sum += bundle.getInt("value");
                    Toast.makeText(MessengerService.this, sum+"", Toast.LENGTH_SHORT).show();
                    // =10 给客户端发送消息
                    mClient = msg.replyTo;
                    if (null == mClient) {
                       return;
                    }
                    if (sum == 10) {
                        Message message = Message.obtain(null, SIG_SEND_UPDATE);
                        try {
                            mClient.send(message);
                        } catch (RemoteException e) {
                            e.printStackTrace();
                        }
                    }
                    break;
                default:
                    break;
            }

        }
    }

    @Override
    public IBinder onBind(Intent intent) {
        Log.i(TAG, "service bind");
        return messenger.getBinder();
    }

    @Override
    public boolean onUnbind(Intent intent) {
        Log.i(TAG, "service unbind");
        return super.onUnbind(intent);
    }
}

客户端

/*
 * Copyright (c) 2020.
 * author:  duck
 */

package com.ducky.cachepicasso.Messenger;

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.util.Log;
import android.view.View;
import android.widget.Toast;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;

import com.ducky.cachepicasso.R;

public class MessengerActivity extends AppCompatActivity {

    static final String TAG = "Messenger-Activity";

    // 服务端的Messenger
    private Messenger mService;
    // 客户端的Messenger
    private Messenger mMessenger;

    // 向服务端发送的信号
    private static final int SIG_SEND_PLUS = 0;


    ServiceConnection serviceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            Log.i(TAG, "service connected");
            mService = new Messenger(service);
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            Log.i(TAG, "service disconnected");
            mService = null;
        }
    };

    public class ClientHandler extends Handler{
        // 从服务端接收的信号
        private static final int SIG_GET_UPDATE = 1;

        @Override
        public void handleMessage(@NonNull Message msg) {
            switch (msg.what){
                case SIG_GET_UPDATE:
                    Toast.makeText(MessengerActivity.this, "升级！", Toast.LENGTH_SHORT).show();
                    break;
            }
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.layout_messenger);
        // 客户端Messenger
        mMessenger = new Messenger(new ClientHandler());
        // 绑定服务
        bindService(new Intent(this, MessengerService.class), serviceConnection, Context.BIND_AUTO_CREATE);

        // 点击按钮 向服务端发送一次消息 服务端去做+
        // 当服务端累计值达到10时 给客户端发送消息
        findViewById(R.id.button).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (mService != null) {
                    try {
                        Message message = Message.obtain(null, SIG_SEND_PLUS);
                        Bundle bundle = new Bundle();
                        bundle.putInt("value", 1);
                        message.setData(bundle);
                        message.replyTo = mMessenger;
                        mService.send(message);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
    }

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