Android实现IPC进程间通信的6种方式 （四）Messenger篇

接前三篇
基础篇
Bundle篇
文件共享篇

Messenger即信使，我们可以通过它在进程间传递我们的数据，本篇我们来用Messenger实现进程间通信
服务端
1）首先在服务端定义一个Service服务，用这个Service来处理客户端的请求
2）其次需要通过一个Handler来创建一个Messenger对象，并在Service的onBind方法中返回这个Messenger
3）在Messenger的handleMessage中通过形参Message携带的messenger对象将处理结果发送给客户端

public class MessengerService extends Service {

    public static final String TAG = "myMessagePractise";
    public static final int MSG_FROM_CLIENT = 1;
    public static final int MSG_FROM_SERVER = 2;

    public static class MessengerHandler extends Handler{
        @Override
        public void handleMessage(Message msg){
            switch (msg.what){
                case MSG_FROM_CLIENT:
                    Log.d(TAG,"server receive message, content is \" " + msg.getData().getString("replay") + " \" ");
                    Message sMsg = Message.obtain(null,MSG_FROM_SERVER);
                    Bundle bundle = new Bundle();
                    bundle.putString("replay","hello, this is server! ");
                    sMsg.setData(bundle);
                    Messenger messenger = msg.replyTo;
                    try {
                        messenger.send(sMsg);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }

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

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

客户端
1）我们用一个Activity作为客户端，通过绑定一个ServiceConnection获得服务端的Messenger，并通过这个Messenger项服务端发送消息
2）同时也通过一个Handler来创建Messenger对象
3）最后在给服务端发消息时，将我们客户端的Messenger装载在Mesage中（这里就与服务端的3）相对应）

public class MessengerActivity extends Activity {
    public static final String TAG = "myMessagePractise";
    private Messenger messenger;

    private ServiceConnection connection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            messenger = new Messenger(service);
            Message msg = Message.obtain(null, MessengerService.MSG_FROM_CLIENT);
            Bundle bundle = new Bundle();
            bundle.putString("replay","hello, this is client");
            msg.setData(bundle);
            msg.replyTo = messengerHandler;
            try{
                messenger.send(msg);
            }catch (RemoteException e){
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };

    private Messenger messengerHandler = new Messenger(new MessengerHandler());
    private static class MessengerHandler extends Handler{
        @Override
        public void handleMessage(Message msg){
            switch (msg.what){
                case MessengerService.MSG_FROM_SERVER:
                    Log.d(TAG,"client receive message, content is \" " + msg.getData().getString("replay") + " \" ");
            }
        }
    }

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

        Intent intent = new Intent(this, MessengerService.class);
        bindService(intent,connection, Context.BIND_AUTO_CREATE);
    }

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

Manifest文件
我们需要在Manifest文件中将Service和Activity置于不同的进程中

<activity 
    android:name=".MessengerActivity"
    android:process="com.practise.ipc.client">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>

<service
    android:name="com.practise.ipc.ipcmessenger.MessengerService"
    android:process="com.practise.ipc.server"/>

运行结果
运行结果是预期的，说明我们利用Messengerr完成了进程间的通信

下一篇 AIDL实现进程间通信

特别感谢《Android 开发艺术探索》