android ipc声音播放,Android IPC机制－Messenger的使用

本文内容基于《Android开发艺术探索》，强烈推荐，值得一看。

Messenger是一种轻量级的IPC解决方案，通过它可以在不同进程之间传递Message对象，从而实现进程间通信，首先我们来看一下它部分源码：

public Messenger(Handler target) {

mTarget = target.getIMessenger();

}

public Messenger(IBinder target) {

mTarget = IMessenger.Stub.asInterface(target);

}

public void send(Message message) throws RemoteException {

mTarget.send(message);

}

public IBinder getBinder() {

return mTarget.asBinder();

}

从IMessenger或是Stub.asInterface可以看出来Messenger多进程通信，底层实现还是AIDL，IMessenger.aidl的实现如下

package android.os;

import android.os.Message;

/** @hide */

oneway interface IMessenger {

void send(in Message msg);

}

接下来我们看一下如何使用Messenger实现多进程通信

服务端

public class MessengerService extends Service {

private static final String TAG = MessengerService.class.getSimpleName();

private Messenger mMessenger = new Messenger(new Handler() {

@Override

public void handleMessage(Message msg) {

switch (msg.what) {

case 1:

Log.e(TAG, "receive msg from Client:" + msg.getData().getString("msg"));

Messenger client = msg.replyTo;

Message relpyMessage = Message.obtain(null, 0);

Bundle bundle = new Bundle();

bundle.putString("reply", "嗯，你的消息我已经收到，稍后会回复你。");

relpyMessage.setData(bundle);

try {

client.send(relpyMessage);

} catch (RemoteException e) {

e.printStackTrace();

}

break;

default:

super.handleMessage(msg);

}

}

});

@Nullable

@Override

public IBinder onBind(Intent intent) {

return mMessenger.getBinder();

}

}

客户端

public class MainActivity extends AppCompatActivity {

private static final String TAG = MainActivity.class.getSimpleName();

private Messenger messenger;

private Messenger replyMessager = new Messenger(new Handler(){

@Override

public void handleMessage(Message msg) {

switch (msg.what){

case 0:

Log.e(TAG, "receive msg from Server:" + msg.getData().getString("reply"));

break;

default:

break;

}

}

});

private ServiceConnection connection = new ServiceConnection() {

@Override

public void onServiceConnected(ComponentName name, IBinder service) {

messenger = new Messenger(service);

Message m = Message.obtain(null, 1);

Bundle b = new Bundle();

b.putString("msg", "我是客户端,我找你");

m.setData(b);

m.replyTo = replyMessager;

try {

messenger.send(m);

} catch (RemoteException e) {

e.printStackTrace();

}

}

@Override

public void onServiceDisconnected(ComponentName name) {

}

};

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

Intent intent = new Intent(this, MessengerService.class); //这边我是在同一个应用中指定MessengerService的android:process属性实现多线程所以用的是显示调用，不同应用要通过隐式调用

bindService(intent, connection, BIND_AUTO_CREATE);

}

}

服务端我们主要的操作有：

创建了一个Service来处理客户端的请求;

通过创建的Handler对象来创建Messenger对象，用Handler中的MessengerImpl对象为Messenger的mTarget赋值;

在onBind方法中返回Messenger中的IBinder对象(即mTarget.asBinder())，客户的可以用来创建Messenger对象向服务端发送消息

从客户的传来的Message对象中获取客户端的Messenger对象，通过Messenger#send(Message msg)发送消息给客户的。

客户端我们的主要操作有：

绑定服务，用服务端返回的IBinder对象初始化Messenger对象，用来向服务端发送消息；

通过创建的Handler对象来创建自己的Messenger对象，用Handler中的MessengerImpl对象为Messenger的mTarget赋值;

创建消息把自己的Messenger对象赋值给Message.replyTo，服务端接收消息后从Message对象中取出客户端的Messenger对象向客户端发送消息

从最上面Messenger的部分源码我们可以知道，Messenger#send(Message msg)发送消息是调用了IMessenger#send(in Message msg)，从Handler中的相关源码(如下)可以看出Messenger发送消息本质上还是用Handler发送的。

final IMessenger getIMessenger() {

synchronized (mQueue) {

if (mMessenger != null) {

return mMessenger;

}

mMessenger = new MessengerImpl();

return mMessenger;

}

}

private final class MessengerImpl extends IMessenger.Stub { //AIDL，实现IMessenger.Stub

public void send(Message msg) {

Handler.this.sendMessage(msg);//由 Handler来发送消息

}

}

我理解的Messenger多进程通信，希望大家指正

服务端通过客户端绑定服务时，把服务端Hanlder中的MessengerImpl对象(继承自IMessenger.Stub，IMessenger.Stub继承自android.os.Binder并实现IMessenger接口，它持有Handler对象的引用)返回给客户端，客户绑定服务时用服务端返回的MessengerImpl对象创建用于向服务端发送消息的Messenger对象，最终客户端通过该Messenger对象中MessengerImpl对象持有的服务端的Handler对象的引用发送消息给服务端，消息中带有客户端自己的Messenger对象引用，服务端通过调用客户端Messenger对象的引用继而调用客户端中的Handler对象回复消息，从而实现进程间通信。

注：Messenger通信本质上也就是Hanlder发送处理消息，一次只处理一个请求，所以不需要考虑线程同步的问题。

本人技术有限，欢迎指正，谢谢！