@[TOC]
1. 写在前面
Android 进程间通信 的 几种方式：
- 四大组件间传递Bundle
- 使用文件共享方式，多进程读写一个相同的文件，获取文件内容进行交互；
- 使用Messenger，一种轻量级的跨进程通讯方案，底层使用AIDL实现（实现比较简单，博主开始本文前也想了一下是否要说一下这个东西，最后还是觉得没有这个必要，Google一下就能解决的问题，就不啰嗦了）；
- 使用AIDL(Android Interface Definition Language)，Android接口定义语言，用于定义跨进程通讯的接口；
- 使用ContentProvider，常用于多进程共享数据，比如系统的相册，音乐等，我们也可以通过ContentProvider访问到；
- Socket(Domain Socket)，Linux 桌面的DBus就是使用此方式实现的.
- ... ...
各个优缺点对比：
在这里插入图片描述
多个app通过统一的接口操作，不建议起线程的耗时任务，支持 RPC(远程过程调用，进程A调用进程B提供的 函数/方法)
比如 登陆接口，支付，定位服务 等等
这里唯一比较好的应该属于 AIDL 的方式了，不仅有回调，还可以传参数，返回参数。
但是 通常要写很多代码，操作繁杂，麻烦；不同业务的跨进程调用，不易复用。
我们在下面的文章将讲解用另一种简洁的方式实现。
2. 跨进程通信的实现
我编写 了一个 XBus(跨进程通信)的库 ，欢迎下载体验
在这里插入图片描述
耗费了几天时间，完成了这个 跨进程通信 的代码，后续不断完善吧，下面我讲解下我写这个代码的思路。
涉及的知识点：
- 动态代理 Proxy.newProxyInstance，InvocationHandler
- JSON 或者 Bundle(文章使用此方法)
- AIDL
- 反射(joor Refalect)
- 序列化/反序列化
流程图：
在这里插入图片描述
大概思路如下：
第1步：进程A 绑定 进程B 的AIDL 服务 并 返回 一个 XBusAidl.Stub 的AIDL；进程B注册好需要被调用的函数.
// 绑定服务
Intent intent = new Intent(context, XBusService.class);
context.bindService(intent, mServiceConnection, Context.BIND_AUTO_CREATE);
// 绑定回调(成功，失败的处理)
ServiceConnection mServiceConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
mXBusAidl = XBusAidl.Stub.asInterface(service);
}
};
// AIDL 接口，主要用于传输相应的调用参数以及返回. 关于 Response，Request 可以查看相应的代码.
interface XBusAidl {
Response run(in Request request);
}
// 进程B 注册需要被调用的相关函数
XBus.getInstance().register(ITestData.class, TestData.class);
// 之所以要注册，是因为接口的调用与实现的类不能一一对应起来，所以需要提前注册.
public void register(Class<?> face, Class<?> impl) {
mRegisterClassMap.put(face, impl);
}
第2步：函数调用，触发 动态代理，将 类名，函数，参数，调用 绑定服务返回的 XBusAidl.Stub 的AIDL 的 run函数传过去
// 准备被调用的接口
// @ClassId("TestData")
public interface ITestData {
public String testtesttest(int i, String s);
}
// 动过动态代理，然后调用，触发 invoke，然后将 类名，函数，参数传过去，接受返回值，搞定.
ITestData testData = XBus.getInstance().getCreateCall(ITestData.class);
String result = testData.testtesttest(10, "测试函数");
public <T> T getCreateCall(Class<T> tClass) {
Class<?>[] interfaces = new Class[]{tClass};
XBusHandler handler = new XBusHandler(tClass, mXBusAidl);
Object proxy = Proxy.newProxyInstance(tClass.getClassLoader(), interfaces, handler);
return (T) proxy;
}
class XBusHandler implements InvocationHandler {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String methodName = method.getName();
String clazzName = clazz.getName();
// 1. 创建 Request.
Request request = new Request();
// 这里使用了 JSON 与 Bundle的传参数与接收返回值 的方式，还需要继续测试，才知道那种方式更优.
// 主要是思路，无论是 JSON 还是 Bundle，斗不过是将数据传输过去而已，本文章使用Bundle讲解.
// 2. bundle 传递 args参数. 方法，类名
Bundle bundle = new Bundle();
bundle.putSerializable(Request.ARGS_KEY, args);
bundle.putString(Request.METHOD_KEY, methodName);
bundle.putString(Request.CLAZZ_KEY, clazzName);
request.setBundle(bundle);
// 3. AIDL 远程调用函数run （函数执行过程)
Response response = xBusAidl.run(request);
// 4. 处理 返回值.
Bundle bundle1 = response.getBResult();
return bundle1.getSerializable(Response.RESULT_KEY);
}
}
第3步：处理 函数执行，返回值.
// 绑定服务返回的 XBusAidl.Stub 的AIDL 的 run 函数 执行.
public Response run(Request request) throws RemoteException {
return runBundle(request);
}
private Response runBundle(Request request) {
Bundle bundle = request.getBundle();
Object[] bargs = (Object[]) bundle.getSerializable(Request.ARGS_KEY);
String clazzName = bundle.getString(Request.CLAZZ_KEY);
String method = bundle.getString(Request.METHOD_KEY);
// 1. 创建Response.
Response response = new Response();
// 2. 函数调用
Class<?> iclazz = Reflect.on(clazzName).get();
Object createObject = XBus.getInstance().getCreateObject(iclazz); // 获取已经注册的相关函数
Object result = Reflect.on(createObject).call(method, bargs).get();
// 3. 处理返回值
bundle.putSerializable(Response.RESULT_KEY, (Serializable) result);
response.setBResult(bundle);
// 4. 返回response，response 带有 code, message，主要是标志函数是否执行成功等信息.
return response;
}
// 这里是进程B已经注册的函数
public <T> T getCreateObject(Class<?> face) {
if (mRegisterClassMap.containsKey(face)) {
Class<?> aClass = mRegisterClassMap.get(face); // 根据对应的接口找到对应的类
return Reflect.on(aClass).create().get(); // 创建对应的类
}
return null;
}
原理已经分析完了，大概步骤就是，注册AIDL服务，使用动态代理调用函数，处理函数执行，返回处理，没了，就是这么简单.
在这里插入图片描述
3. 扩展思考
- 是否考虑过一种方式，只提供中转分发(服务一直存在)，不作为提供服务。
- AIDL 是否可以使用 Socket 来替代，是可以的喔(DBus就是例子)，不过需要使用JSON或者其它方式来序列化，反序列化.
- 注册相应的接口与类，感觉还是比较麻烦，后续准备加入注解的方式支持.
@ClassId("TestData")
public interface ITestData {
public String testtesttest(int i, String s);
}
- 现在只是类的函数的调用，还需要加入对回调的支持.
- Bitmap，View，Drawable 的传输是否有问题，测试一下. 如果使用JSON又这么办？
// 看到下面的代码，我感觉JSON的使用，心都凉了一半.
// 来自网上的一段代码，关于 Bitmap 转换成JSON的，感觉效果应该不是很好吧(如果图片几MB).
/*
* This functions converts Bitmap picture to a string which can be
* JSONified.
* */
private String getStringFromBitmap(Bitmap bitmapPicture) {
final int COMPRESSION_QUALITY = 100;
String encodedImage;
ByteArrayOutputStream byteArrayBitmapStream = new ByteArrayOutputStream();
bitmapPicture.compress(Bitmap.CompressFormat.PNG, COMPRESSION_QUALITY,
byteArrayBitmapStream);
byte[] b = byteArrayBitmapStream.toByteArray();
encodedImage = Base64.encodeToString(b, Base64.DEFAULT);
return encodedImage;
}
/*
* This Function converts the String back to Bitmap
* */
private Bitmap getBitmapFromString(String stringPicture) {
byte[] decodedString = Base64.decode(stringPicture, Base64.DEFAULT);
Bitmap decodedByte = BitmapFactory.decodeByteArray(decodedString, 0, decodedString.length);
return decodedByte;
}
4. 参考资料
https://github.com/LiushuiXiaoxia/Bifrost
跨进程通信框架. https://github.com/Xiaofei-it/Hermes
爱奇艺的跨进程通信框架 https://github.com/iqiyi/Andromeda
