Android 跨进程调用 service android跨进程通信有哪几种

文章目录

• 1. 写在前面
• 2. 跨进程通信的实现
• 3. 扩展思考
• 4. 参考资料

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(跨进程通信)的库 ，欢迎下载体验

耗费了几天时间，完成了这个 跨进程通信 的代码，后续不断完善吧，下面我讲解下我写这个代码的思路。

解决的问题:
为什么要这么弄，其实很多人会这么问，用AIDL不就好了。

• 只需要 正常的 接口(更易用，简单) 与 原本的实现类 就可以使用.
• 不用去写繁琐的AIDL了，都是接口.
• 封装性更强，就像调用本地的函数一样.

涉及的知识点：

• 动态代理 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);
	// loder，选用的类加载器。因为代理的是zack，所以一般都会用加载zack的类加载器。
	// interfaces，被代理的类所实现的接口，这个接口可以是多个。
	// handler，绑定代理类的一个方法。
    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(LocakSocket - UNIX-domain Socket - IPC通信机制) 来替代，是可以的喔(DBus就是例子)，不过需要使用JSON或者其它方式来序列化，反序列化.
• 注册相应的接口与类，感觉还是比较麻烦，后续准备加入注解的方式支持.

@ClassId("TestData")
public interface ITestData {
    public String testtesttest(int i, String s);
}
@ClassId("TestData")
public class TestData {
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ClassId {
    String value();
}

ClassId classId = clazz.getAnnotation(ClassId.class);  获取注解

• 现在只是类的函数的调用，还需要加入对回调的支持.

// 回调是可以支持的. 需要使用 AIDL callback 的回调.
// 客户单A -> run -> 服务端B 调用接收到，处理参数以及回调.
// 服务器B->回调相关的参数也需要 动态代理进行处理
return Proxy.newProxyInstance(
                clazz.getClassLoader(),
                new Class<?>[]{clazz},
                new XBusCallbackInvocationHandler(mCallback));
                
// 服务器B->动态代理的 invoke 就可以处理 回调的返回.                
public Object invoke(Object proxy, Method method, Object[] objects) {
	// 客户端A的 callback 处理返回的回调参数，然后返回值给服务器B.
}

// 客户端A 的 callback 再次处理.
Result callback(CallbackRequest request) {
	// 根据 erquest 返回的数据参数，传入执行.
	value = method.invoke(callback, parameters);
	// 最后封装的返回值，返回给 value.
}

• 对于单例的函数，该如何处理?? getInstance
• 能否使用自定义的类

// 答案是可以的，但是必须 implements Serializable 或者 Parcelable，不然要崩溃.
public class OtherMode implements Serializable {
}

• Bitmap，View，Drawable 的传输是否有问题，测试一下. 如果使用JSON又这么办？

final Drawable drawable = getResources().getDrawable(R.mipmap.ic_launcher);
final Bitmap bitmap = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888);

// 1. Bundle 传输 Bitmap 毫无问题
// 适中、较小图片，如果图片过大如MB量级的，就不能正常工作了

// 2. Bundle 传输 View，会报错，implements Serializable 也没用
// java.lang.RuntimeException: Parcelable encountered IOException reading a Serializable object (name = com.demo.xbus.TestView)
public class TestView extends Button implements Serializable {
}

// 3. Bundle 传输 Drawable 报错
// java.lang.RuntimeException: Parcel: unable to marshal value android.graphics.drawable.AdaptiveIconDrawable@ddbaeb1
// 但是自定义的 Drawable ，implements Serializable 就没有问题.
public class TestDrawable extends GradientDrawable implements Serializable {
... ...
}

// 看到下面的代码，我感觉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;
}