Messenger
Messenger翻译为信使，即它可以在不同进程中传递Message对象。在Message中放入我们需要传递的数据，就可以轻松地实现地实现数据的数据间传递了。它的底层实现是AIDL。从构造函数可以明显看到AILD的痕迹，不管是IMessenger还是Stub.asInterface这种使用方法都是表面它的底层的AIDL。
public Messenger(Handler target) {
mTarget = target.getIMessenger();
}
public Messenger(IBinder target) {
mTarget = IMessenger.Stub.asInterface(target);
}
使用Messenger进行跨进程通信
- 服务端进程
需要在服务端创建一个Service来处理客户端的连接请求，同时创建一个Handler并通过它来创建一个Messenger对象，然后在Service的onBind中返回这个Messenger对象底层的Binder即可。 - 客户端进程中，首先要绑定服务端的Service,绑定成功后用服务端返回的IBinder对象创建一个Messenger,通过这个Messenger就可以向服务端发送消息了。发送消息类型是Messeage对象。如果需要服务端能够回应客户端，就和服务端一样，我们还需要创建一个Handler并创建一个新的Messenger,并把这个Messenger对象通过Message的replyTo参数传递给服务器，服务器通过这个replyTo参数就可以回应客户端。
服务端的代码
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 MyConstants.MSG_FROM_CLIENT:
Log.i(TAG, "来自客户端的消息" + msg.getData().getString("msg"));
Messenger client = msg.replyTo;
Message relpyMessage = Message.obtain(null, MyConstants.MSG_FROM_SERVICE);
Bundle bundle = new Bundle();
bundle.putString("reply", "嗯，你的消息我已经收到，稍后会回复你。");
relpyMessage.setData(bundle);
try {
client.send(relpyMessage);
} catch (RemoteException e) {
e.printStackTrace();
}
break;
default:
super.handleMessage(msg);
}
}
}
private final Messenger mMessenger = new Messenger(new MessengerHandler());
@Override
public IBinder onBind(Intent intent) {
return mMessenger.getBinder();
}
@Override
public void onCreate() {
super.onCreate();
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
return super.onStartCommand(intent, flags, startId);
}
}
解析：可以看到MessengerHandler 是用来处理客户端发送过来的消息，mMessenger 是一个Messenger对象，它和MessengerHandler相关联，并在onBind方法中返回它里面的Binder对象，可以看出，这里的Messenger的作用是将客户端发送的消息传递给MessengerHandler处理。注意，注册service，让其运行在单独的进程中：
<service
android:name=".Messenger.MessengerService"
android:process=":remote"
android:exported="true">
<intent-filter>
<action android:name="com.lu.ipc.remote" />
</intent-filter>
</service>
客户端的代码
在onCreate()中绑定远程进程的MessengerService。
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Intent intent = new Intent("com.lu.ipc.remote");
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP)
intent=createExplicitFromImplicitIntent(this,intent);
bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
}
绑定成功后根据服务端返回的binder对象创建Messenger对象并使用此对象向服务端发送消息，代码中创建的Bundle包括了文本消息和客户端的Messenger对象，此对象可以是接收来自服务端的消息。
private ServiceConnection mConnection = new ServiceConnection() {
public void onServiceConnected(ComponentName className, IBinder service) {
mService = new Messenger(service);
Log.d(TAG, "bind service");
Message msg = Message.obtain(null, MyConstants.MSG_FROM_CLIENT);
Bundle data = new Bundle();
data.putString("msg", "从服务端发送消息");
msg.setData(data);
msg.replyTo = mGetReplyMessenger;
try {
mService.send(msg);
} catch (RemoteException e) {
e.printStackTrace();
}
}
public void onServiceDisconnected(ComponentName className) {
}
};
接收来自服务端的消息
private Messenger mGetReplyMessenger = new Messenger(new MessengerHandler());
private static class MessengerHandler extends Handler {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MyConstants.MSG_FROM_SERVICE:
Log.i(TAG, "接收到来自服务端的消息:" + msg.getData().getString("reply"));
break;
default:
super.handleMessage(msg);
}
}
}
总结
上面的例子是个很经典的使用Messenger进行跨进程通信的例子，所以是在同一个应用中，但是服务端是在不同的进程的，这个和分别在两个不同的应用道理是一样的，有兴趣可以自己试试。在Messenger中进行数据传递必须将数据放入Message中，而Messenger和Message都实现了Parcelable接口，因此可以进行跨进程的通信。
