1. 实现IPC(跨进程)方法一 Bundle
Bundle可以通过Intent在跨进程时带过去，它支持基本数据类型，实现了Parcelable接口的对象，实现了Serializable接口的对象以及其他一些Android支持的特殊对象。
2. 特殊场景
A进程进行一个计算，计算完成后启动B进程的一个组件并把计算结果传递给B进程。问题是该结果不支持放入Bundle。
思考解决方式如下：A进程启动B进程的服务完成计算，B进程的服务把计算结果给目标组件。
3. 实现IPC(跨进程)方法二 文件共享
两个进程读写同一文件可以实现跨进程通信。windows上，一个文件如果被加了排斥锁将会导致其他进程无法对其进行访问，包括读写。而Android是基于Linux的，使得其并发读写文件没有限制。所以文件共享的方式要考虑并发问题。下面的代码是MainActivity中序列化对象到文件，不同进程的SecondActivity反序列化文件到对象。
// 序列化
try {
User user = new User(110, "allen");
File cache = new File(getCacheDir(), "cache.txt");
if (!cache.exists()) {
cache.createNewFile();
}
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(cache.getAbsoluteFile()));
out.writeObject(user);
out.close();
Log.e("aaa","---------"+user.toString());
} catch (IOException e) {
e.printStackTrace();
}
// 反序列化
try {
File cache = new File(getCacheDir(), "cache.txt");
if (!cache.exists()) {
cache.createNewFile();
}
ObjectInputStream in = new ObjectInputStream(new FileInputStream(cache.getAbsoluteFile()));
User newUser = (User) in.readObject();
in.close();
Log.e("aaa","---------"+newUser.toString());
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
文件类型没有要求，比如txt的，xml的。但SharedPreferences是个例外，SharedPrefrences是Android提供的轻量级存储方案，它以键值对的方式来存储数据，在底层实现上采用了xml文件来存储。其目录位于/data/data/packageName/shared_prefs目录下。从本质上来说，SharedPreference也属于文件的一种，但是对于系统对它的读写有一定的缓存策略，即在内存中会有一份SharedPreference文件的缓存。因此在多进程模式下，系统对它的读写就变得不可靠。因此不建议进程间通信使用SharedPreference。
3. Messenger简介
Messanger可以翻译为信使，顾名思义，通过它可以在不同的进程中传递Message对象。它是一种轻量级的IPC方案，它的底层实现了AIDL。(书中说是根据构造方法的写法和aidl相似，有些牵强)。
下面看下Messenger的代码：
public final class Messenger implements Parcelable {
private final IMessenger mTarget;
public Messenger(Handler target) {
mTarget = target.getIMessenger();
}
public void send(Message message) throws RemoteException {
mTarget.send(message);
}
public IBinder getBinder() {
return mTarget.asBinder();
}
// ...
public Messenger(IBinder target) {
mTarget = IMessenger.Stub.asInterface(target);
}
}
重点还是IMessenger是个aidl接口。用everything搜一下可以搜到以下结果：
4. 简单Messenger跨进程实现
服务端：
public class MessengerService extends Service {
private Handler messengerHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case 0:
String text = msg.getData().getString("msg");
Log.e("aaa", text);
break;
}
}
};
private Messenger messenger = new Messenger(messengerHandler);
public MessengerService() {
}
@Override
public IBinder onBind(Intent intent) {
return messenger.getBinder();
}
}
客户端：
public class MessengerActivity extends AppCompatActivity {
Messenger messenger;
ServiceConnection serviceConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
messenger = new Messenger(service);
// 发消息
Message msg = Message.obtain();
msg.what = 0;
Bundle bundle = new Bundle();
bundle.putString("msg", "hello, this is client.");
msg.setData(bundle);
try {
messenger.send(msg);
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_messenger);
Intent intent = new Intent(this, MessengerService.class);
bindService(intent, serviceConnection, BIND_AUTO_CREATE);
}
@Override
protected void onDestroy() {
super.onDestroy();
unbindService(serviceConnection);
}
}
Service定义在单独的进程中
<service
android:name="._2activity.Messenger.MessengerService"
android:enabled="true"
android:exported="true"
android:process=":remote" />
Messenger支持的数据类型实际是Message支持的数据类型，Message支持Bundle，所以适用性很强。
5. 实现客户端发信息并且服务端响应
上面的例子中服务端定义了接受消息的Messenger(也就是参数是Handler的)，客户端通过Binder拿到服务端的Messenger，然后用服务端的Messenger发消息给服务端。同样，服务端要回应，需要有客户端接受消息的Messenger。
Activity中如下：
// 定义客户端接受消息的Messenger
Messenger clientMessenger = new Messenger(new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
Log.e("aaa",msg.getData().getString("reply"));
}
});
// 通过Message的replyto参数给服务端
// 发消息
Message msg = Message.obtain();
msg.what = 0;
Bundle bundle = new Bundle();
bundle.putString("msg", "hello, this is client.");
msg.setData(bundle);
// 把接收消息的Messenger通过Message的replyTo给服务端
msg.replyTo = clientMessenger;
messenger.send(msg);
服务端接收消息后，拿到客户端的Messenger，再给客户端发消息。
private Handler messengerHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case 0:
String text = msg.getData().getString("msg");
Log.e("aaa", text);
// 服务端回应
Messenger clientMessenger = msg.replyTo;
Message message = Message.obtain();
Bundle bundle = new Bundle();
bundle.putString("reply","收到收到已收到");
message.setData(bundle);
try {
clientMessenger.send(message);
} catch (RemoteException e) {
e.printStackTrace();
}
break;
}
}
};
6. 总结
Messenger很强大，它是实现轻量级IPC的方案。在普通开发中，还可以用于Service调Activity中的方法，或者Activity调Service中的方法。之前说Activity调Service中的方法通过Binder，Service调Activity中的方法通过广播，这里又加了一种方案。
另外，Messenger一次发送一个请求，是串行，不存在并发。因此服务端不需要考虑线程同步问题。
