参考Android开发艺术探索
Messenger
Messenger：信使，通过它可以不同进程中传递Message 对象，在Message 中放入我们需要传递的数据，就可以轻松的在不同进程中实现数据的传递了。
Messenger 是一种轻量级的IPC 方案，它的底层实现是 AIDL。从它的两个构造方法上就可以看出AIDL的使用痕迹。
/**
* Create a Messenger from a raw IBinder, which had previously been
* retrieved with {@link #getBinder}.
*
* @param target The IBinder this Messenger should communicate with.
*/
public Messenger(IBinder target) {
mTarget = IMessenger.Stub.asInterface(target);
}
/**
* Create a new Messenger pointing to the given Handler. Any Message
* objects sent through this Messenger will appear in the Handler as if
* {@link Handler#sendMessage(Message) Handler.sendMessage(Message)} had
* been called directly.
*
* @param target The Handler that will receive sent messages.
*/
public Messenger(Handler target) {
mTarget = target.getIMessenger();
}
Messenger 对AIDL做了一层封装，使用方法上要简单不少，可以更简便的实现进程间通信。由于Messenger 一次只处理一个请求，因此在服务端我们不用考虑线程同步的问题，这是因为服务端不存在并发执行的情形。
实现步骤
举个栗子：存在两个进程，分为服务端与客户端。
客户端发送消息给服务端，服务端收到消息后自动回复消息给客户端。
服务端
首先，我们需要在服务端创建一个 Service 来处理客户端的连接请求，同时创建一个Handler用来创建一个Messenger 对象并在Handler 中处理消息，然后在 Service的 onBind中返回这个 Messenger 对象底层的 Binder即可。
/**
* 服务端的典型代码
*/
public class MessengerService extends Service {
private static final String TAG = "MessengerService";
/**
* 用来处理客户端发来的消息的Handler
*/
private static class MessengerHandler extends Handler {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MyCons.MSG_FROM_CLIENT:
Log.i(TAG, "receive msg from client: " + msg.getData().getString("msg"));
// 通过客户端传递replyTo参数传递过来的Messenger对象来向客户端回复消息
Messenger client = msg.replyTo;
Message replyMsg = Message.obtain(null, MyCons.MSG_FROM_SERVICE);
Bundle bundle = new Bundle();
bundle.putString("reply", " 嗯， 你的消息我已经收到了。。");
replyMsg.setData(bundle);
try {
client.send(replyMsg);
} catch (RemoteException e) {
e.printStackTrace();
}
break;
default:
super.handleMessage(msg);
break;
}
}
}
/**
* 用来接收客户端消息的 Messenger
*/
private final Messenger mMessenger = new Messenger(new MessengerHandler());
@Nullable
@Override
public IBinder onBind(Intent intent) {
return mMessenger.getBinder();
}
}
上述代码中，我们在 MessengerHandler 中处理客户端发来的消息，并从消息中取出客户端发来的文本信息。而 mMessenger 是一个Messenger对象，它和 MessengerHandler 相关联，并在 onBind方法中返回它里面的 Binder对象。可以看出这里Messenger的作用就是将 客户端发送的消息传递给 MessengerHandler来处理。
注册Service
<service
android:name=".aidl.MessengerService"
android:process=":remote" />
客户端
public class MessengerActivity extends AppCompatActivity {
private static final String TAG = "MessengerActivity";
private Messenger mService;
private ServiceConnection mConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
mService = new Messenger(service);
Message msg = Message.obtain(null, MyCons.MSG_FROM_CLIENT);
Bundle data = new Bundle();
data.putString("msg", "hello, this is client");
msg.setData(data);
//将需要接受服务端消息的Messenger通过Message的replyTo参数传递给服务端
msg.replyTo = mGetReplyMessenger;
try {
mService.send(msg);
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
}
};
/**
* 用来传递服务端返回的消息的Messenger
*/
private Messenger mGetReplyMessenger = new Messenger(new MessengerHandler());
/**
* 用来处理服务端返回的消息的Handler
*/
private static class MessengerHandler extends Handler {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MyCons.MSG_FROM_SERVICE:
Log.i(TAG, "receive msg from service: " + msg.getData().getString("reply"));
break;
default:
super.handleMessage(msg);
break;
}
}
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_messenger);
//绑定服务
bindService(new Intent(this, MessengerService.class), mConnection, Context.BIND_AUTO_CREATE);
}
@Override
protected void onDestroy() {
//解绑服务
unbindService(mConnection);
super.onDestroy();
}
}
首先需要绑定远程进程的 MessengerService，绑定成功后，根据服务端返回的 Binder 对象创建 Messenger 对象并使用此对象像服务端发送信息。
Message 传递数据时，能使用的载体只有what、arg1、arg2、Bundle、replyTo。另一个字段 obj 在同一个进程中是非常实用，但是在进程间通信时有点局限。在Android 2.2 以前 obj字段不支持跨进程传输；2.2以后，也仅仅是系统提供的实现了Parcelable接口的对象才可以通过它来传输。这意味着自定义的Parcelable 对象是无法通过obj传输的，导致 obj的实用性大大降低。所以一般都是通过bundle 来传输数据。
