android多个app跨进程通信（IPC）实现（二）_android 跨app通讯

android多个app跨进程通信（IPC）实现（一）

在文章一中实现了一个简单的字符串传递，对不知道怎么使用aidl的可以先去看看实现一，接下来会讲到对象和超过1M的数据怎么传递，

AIDL的传输数据机制基于Binder，Binder对传输数据大小有限制， 传输超过1M的文件就会报android.os.TransactionTooLargeException异常，接下来看看使用匿名共享内存怎么进行大文件传输。

共享内存是进程间通信的一种方式，通过映射一块公共内存到各自的进程空间来达到共享内存的目的。

对于进程间需要传递大量数据的场景下，这种通信方式是十分高效的，但是共享内存并未提供同步机制，也就是说，在第一个进程结束对共享内存的写操作之前，并无自动机制可以阻止第二个进程开始对它进行读取，所以我们通常需要用其他的机制来同步对共享内存的访问，例如信号量。

Android中的匿名共享内存(Ashmem)是基于Linux共享内存的，借助Binder+文件描述符(FileDescriptor)实现了共享内存的传递。它可以让多个进程操作同一块内存区域，并且除了物理内存限制，没有其他大小限制。相对于Linux的共享内存，Ashmem对内存的管理更加精细化，并且添加了互斥锁。Java层在使用时需要用到MemoryFile，它封装了native代码。Android平台上共享内存通常的做法如下：

1. 进程A通过MemoryFile创建共享内存，得到fd(FileDescriptor)
2. 进程A通过fd将数据写入共享内存
3. 进程A将fd封装成实现Parcelable接口的ParcelFileDescriptor对象，通过Binder将ParcelFileDescriptor对象发送给进程B
4. 进程B获从ParcelFileDescriptor对象中获取fd，从fd中读取数据

概念引用其他地方的，重点是接下来的步骤，项目沿用实现一的工程，大体创建文件的步骤类似,创建2个新的module，bigObjectClientApp和bigObjectServerApp。

创建IMyAidlInterface.aidl

interface IMyAidlInterface {
    void clientSendserver(in ParcelFileDescriptor pfd);
}

服务端：

1、创建BigIpcService，实现IMyAidlInterface接口，接收从客户端发来的数据

private val myBinder = object : IMyAidlInterface.Stub() {
	//接收客户端发来的数据
	override fun clientSendserver(pfd: ParcelFileDescriptor?) {
		/*** 从ParcelFileDescriptor中获取FileDescriptor */
		val fileDescriptor = pfd?.fileDescriptor
 
		/*** 根据FileDescriptor构建InputStream对象 */
		val fis = FileInputStream(fileDescriptor)
 
		/*** 从InputStream中读取字节数组 */
		val data = fis.readBytes()
 
		ipcBitmapBinder(data)
	}
}
 
private fun ipcBitmapBinder(byteArray: ByteArray) {
	val intent = Intent(this, MainActivity::class.java)
	val bundle = Bundle()
	bundle.putBinder("bitmap", ImageBinder(byteArray))
	intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK
	intent.putExtras(bundle)
	startActivity(intent)
}

在这里用到了另外一种突破binder只能传递小于1M数据的方法，使用putBinder

客户端：

2、首先bindService，参考前面代码，客户端向服务端发送数据

private fun sendBigImage() {
	ipcAidl?.apply {
		try {
			/*** 读取assets目录下文件 */
			val inputStream = assets.open("client.jpg")
 
			/*** 将inputStream转换成字节数组 */
			val byteArray = inputStream.readBytes()
 
			/*** 创建MemoryFile */
			val memoryFile = MemoryFile("image", byteArray.size)
 
			/*** 向MemoryFile中写入字节数组 */
			memoryFile.writeBytes(byteArray, 0, 0, byteArray.size)
 
			/**
			 * 获取MemoryFile对应的FileDescriptor
			 * MemoryFile下的getFileDescriptor是@hide,在这用反射使用他
			 */
			val fd = getFileDescriptor(memoryFile)
 
			/*** 根据FileDescriptor创建ParcelFileDescriptor */
			val pfd = ParcelFileDescriptor.dup(fd)
 
			/*** 发送数据 */
			ipcAidl?.clientSendserver(pfd)
		} catch (e: IOException) {
			e.printStackTrace()
		} catch (e: RemoteException) {
			e.printStackTrace()
		}
	}
}

读取图片client.jpg，大小有4M多，这里主要注意getFileDescriptor方法，因为他属于hide的，只能通过反射使用，对应如下：

private fun getFileDescriptor(memoryFile: MemoryFile?): FileDescriptor? {
	if (memoryFile == null)
		return null
	//val fd: FileDescriptor?
	return invokeKt(
		"android.os.MemoryFile",
		memoryFile,
		"getFileDescriptor"
	) as FileDescriptor
}
 
private fun invokeKt(
	className: String,
	instance: Any?,
	methodName: String,
): Any? {
	try {
		val c = Class.forName(className)
		val method: Method = c.getDeclaredMethod(methodName)
		method.isAccessible = true
		return method.invoke(instance)
	} catch (e: java.lang.Exception) {
		e.printStackTrace()
	}
	return null
}

自此客户端向服务端发送大图片的流程到底结果，欣赏下效果：

 服务端向客户端发送，主要采用回调方式

服务端：

1、首先在server端创建ICallbackInterface.aidl

interface ICallbackInterface {
    void serverSendclient(in ParcelFileDescriptor pfd);
}

2、在IMyAidlInterface添加注册和取消注册的回调方法

import com.ninjuli.bigobject.ipc.ICallbackInterface;
 
interface IMyAidlInterface {
 
    void clientSendserver(in ParcelFileDescriptor pfd);
 
    void registerCallback(ICallbackInterface callback);
 
    void unregisterCallback(ICallbackInterface callback);
}

注意需要导入回调接口的路径

3、在BigIpcService实现添加的回调方法

private val myBinder = object : IMyAidlInterface.Stub() {
	//接收客户端发来的数据
	override fun clientSendserver(pfd: ParcelFileDescriptor?) {
		……
	}
 
	override fun registerCallback(callback: ICallbackInterface?) {
		callBackList.register(callback)
	}
 
	override fun unregisterCallback(callback: ICallbackInterface?) {
		callBackList.unregister(callback)
	}
}

4、发送数据到客户端

private fun serverToClient(pfd: () -> ParcelFileDescriptor?) {
	val n = callBackList.beginBroadcast()
	for (i in 0 until n) {
		val callback = callBackList.getBroadcastItem(i);
		if (callback != null) {
			try {
				callback.serverSendclient(pfd())
			} catch (e: RemoteException) {
				e.printStackTrace()
			}
		}
	}
	callBackList.finishBroadcast()
}

客户端：

和实现一类似，只是多了一个注册回调的监听registerCallback(serverCallBack)

private val serviceConnection = object : ServiceConnection {
	override fun onServiceConnected(p0: ComponentName?, iBinder: IBinder?) {
		ipcAidl = IMyAidlInterface.Stub.asInterface(iBinder)
		ipcAidl?.registerCallback(serverCallBack)
	}
 
	override fun onServiceDisconnected(p0: ComponentName?) {
		ipcAidl = null
	}
}
 
private val serverCallBack = object : ICallbackInterface.Stub() {
	override fun serverSendclient(pfd: ParcelFileDescriptor?) {
		val fileDescriptor = pfd?.fileDescriptor
		val fis = FileInputStream(fileDescriptor)
		val bytes = fis.readBytes()
		bytes.let {
			val bitMap = BitmapFactory.decodeByteArray(bytes, 0, bytes.size)
			runOnUiThread {
				findViewById<ImageView>(R.id.image).setImageBitmap(bitMap)
			}
		}
	}
}

项目地址：https://github.com/ninjuli/MultipleIPC