Messenger 跨进程通信

参考： Android应用进程间通信之Messenger信使使用及源码浅析

1，概述：

Messenger实现了IPC通信，其真实原理也是使用了AIDL进行通信，但是和直接使用AIDL不同的是Messenger利用了Handler处理通信，所以它是线程安全的（不支持并发处理）；而我们平时用的AIDL是非线程安全的（支持并发处理）。所以大多数时候我们应用中是不需要处理夸进程并发处理通信的，所以这时选择Messenger会比AIDL更加容易操作

2，例子：

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.yanbo.myapplication" >

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name=".MainActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <!-- ":remote"表示在应用程序里，当需要该service时，会自动创建新的进程
            "remote"表示创建全局进程，不同的应用程序共享该进程 -->
        <service android:name=".RemoteService"
            android:process=":remote">
            <intent-filter>
                <action android:name="com.remote.RemoteService"/>
            </intent-filter>
        </service>

    </application>

</manifest>

工程中的一个独立进程服务端remote源码：

/**
 * 另一个进程中的Service
 */
public class RemoteService extends Service {
    public static final int MSG_TAG_REMOTE = 0x110;
    public static final int MSG_TAG_CLIENT = 0x111;

    private Messenger mRemoteMessenger;
    private RemoteHandler mRemoteHandler;

    private int mCounter = 0;

    @Override
    public void onCreate() {
        super.onCreate();
        mRemoteHandler = new RemoteHandler();
        //实例化一个Messenger传入当前Handler
        mRemoteMessenger = new Messenger(mRemoteHandler);
    }

    @Override
    public IBinder onBind(Intent intent) {
        return (mRemoteMessenger == null) ? null : mRemoteMessenger.getBinder();
    }

    private class RemoteHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_TAG_REMOTE:
                    //为了把消息回传给client端，所以获取client端设置的Messenger
                    Messenger clientMessenger = msg.replyTo;
                    if (clientMessenger != null) {
                        try {
                            //注意obtain第一个参数，前面文章有解释，因为参数target不可序列化
                            clientMessenger.send(Message.obtain(null, MSG_TAG_CLIENT, ++mCounter, 0));
                        } catch (RemoteException e) {
                            e.printStackTrace();
                        }
                    }
                    break;
                default:
                    super.handleMessage(msg);
                    break;
            }
        }
    }
}

工程中的一个独立进程客户端client代码：

public class MainActivity extends Activity {
    private TextView mTextView;
    private Messenger mRemoteMessenger = null;
    private Messenger mClientMessenger;
    private ClientHandler mClientHandler;

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

        mTextView = (TextView) findViewById(R.id.content_show);
        //
        mClientHandler = new ClientHandler();
        mClientMessenger = new Messenger(mClientHandler);
        bindService(new Intent(this, RemoteService.class), connection, Context.BIND_AUTO_CREATE);
    }

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

    private ServiceConnection connection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mRemoteMessenger = new Messenger(service);
            //注意obtain第一个参数，前面文章有解释
            Message message = Message.obtain(null, RemoteService.MSG_TAG_REMOTE);
            message.replyTo = mClientMessenger;
            try {
                mRemoteMessenger.send(message);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {}
    };

    private class ClientHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case RemoteService.MSG_TAG_CLIENT:
                    if (mTextView != null) {
                        mTextView.setText(msg.arg1+"");
                    }
                    break;
                default:
                    super.handleMessage(msg);
                    break;
            }
        }
    }
}

Messenger 的实现过程大致如下图所示：

client 中 在connection中  mRemoteMessenger = new Messenger(service); 客户端拿到远程的Messenger（类RemoteService方法onBind的返回值），

 message.replyTo = mClientMessenger; 远程拿到客户端Messenger
mRemoteMessenger.send(message); 调用远程的handler
把客户端的Messenger 放到message中，传递给服务端，使服务端能调用客户端

3，源码分析