AIDL 如何分片传输大量 Parcelable 数据列表-编程知识

本文针对 AIDL 跨进程传输大量 Parcelable 数据所产生的问题总结出一套分片传输的解决方案，并分析了一下其实现的原理。

1. 概述

大家在通过 AIDL 实现跨进程数据传输的时候，可能会遇到数据量过大导致异常的情况，通常抛出的异常如下：

E/BpBinderRecord: Too many binder proxy objects sent to pid xxx from pid xxx (2500 proxies held)
E/JavaBinder: !!! FAILED BINDER TRANSACTION !!! (parcel size = 96)
android.os.DeadObjectException: Transaction failed on small parcel; remote process probably died

下面就来讲述一个分片传输的处理方案，来解决这类数据过大的问题。

2. 问题模拟

首先让我们写个 demo 来模拟一下大数据传输的场景。
先创建一个 AIDL 文件，并定义一个返回数据列表的接口：

import android.app.Notification;interface IAIDLTest {List<Notification> getNotifications();
}

这里使用的 Notification 是 Android 提供的一个实现 Parcelable 接口的实体类，因为其内容比较复杂，所以我们用这个类来进行测试。
然后创建一个实现这个 AIDL 接口的 Service，代码如下：

public class AIDLTestService extends Service {private final IBinder mService = new IAIDLTest.Stub() {@Overridepublic List<Notification> getNotifications() {List<Notification> notifications = new ArrayList<>();for (int i = 0; i < 50; i++) { // 先构建 50 条数据看效果，后面再作增加notifications.add(new Notification.Builder(AIDLTestService.this,"CHANNEL_ID").setSmallIcon(R.mipmap.ic_launcher).setLargeIcon(Icon.createWithResource(AIDLTestService.this,R.drawable.ic_avatar)).setContentTitle("标题文本" + i).setContentText("正文文本" + i).setContentIntent(NotificationUtils.createActivityPendingIntent(AIDLTestService.this, "AIDL 测试" + i)).setAutoCancel(true).addAction(0, "按钮 1",NotificationUtils.createActivityPendingIntent(AIDLTestService.this, "按钮 1" + i)).addAction(0, "按钮 2",NotificationUtils.createReceiverPendingIntent(AIDLTestService.this, "按钮 2" + i)).build());}return notifications;}};@Overridepublic IBinder onBind(Intent intent) {return mService;}
}

这里先构建 50 条数据看下正常传输的效果，后面再模拟过大的情况。
接下来在 AndroidManifest.xml 文件里定义这个 Service：

<serviceandroid:name=".AIDLTestService"android:enabled="true"android:exported="true"android:process=":remote" />

因为要测试跨进程传输，所以这个 Service 定义在另一个 remote 进程中。
接着实现一个 Activity 绑定这个 Service，跨进程取到数据后进行打印：

public class AIDLTestActivity extends AppCompatActivity implements ServiceConnection {private static final String TAG = "AIDLTestActivity";@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_aidl_test);bindService(new Intent(this, AIDLTestService.class), this, BIND_AUTO_CREATE);}@Overridepublic void onServiceConnected(ComponentName name, IBinder service) {IAIDLTest aidlTest = IAIDLTest.Stub.asInterface(service);try {for (Notification notification : aidlTest.getNotifications()) {Log.d(TAG, "onServiceConnected: notification title = "+ notification.extras.get(Notification.EXTRA_TITLE));}} catch (Exception e) {e.printStackTrace();}}@Overridepublic void onServiceDisconnected(ComponentName name) {}
}

运行后打印的结果部分截图如下：

打印结果

现在把数据量改大，改成 500 条运行试试：

报错啦

Boom！！！可以看到出现报错的情况了。
下面来看一下该如何解决。

3. 解决方案

熟悉 framework 的同学应该知道 framework 里经常会有 AIDL 跨进程的操作，那么里面肯定会考虑这种大量数据传输场景的，因此我们看一看 framework 里是如何处理的。
例如 framework 中 PackageManagerService 的 getInstalledApplications() 方法定义：

PackageManagerService.java

我们发现其使用了一个 ParceledListSlice 类做数据分片的，看下这个类的定义：

ParceledListSlice.java

完整代码见：https://cs.android.com/android/platform/superproject/main/+/main:frameworks/base/core/java/android/content/pm/ParceledListSlice.java
看注释这个类是用来 IPC 时对大量 Parcelable 对象传输使用的，但这个类是不支持 App 直接使用的，那么我们将其复制出来一份使用。
它继承了父类 BaseParceledListSlice，这个类有多个子类可以支持多种场景，但我们暂不需要，因此我将这两个类的代码合到了一起，并处理了一些运行时报错的问题（具体的报错问题这里不做展开），最终处理完的类的完整代码如下：

/*** Transfer a large list of Parcelable objects across an IPC.  Splits into* multiple transactions if needed.* <p>* Caveat: for efficiency and security, all elements must be the same concrete type.* In order to avoid writing the class name of each object, we must ensure that* each object is the same type, or else unparceling then reparceling the data may yield* a different result if the class name encoded in the Parcelable is a Base type.*/
public class ParceledListSlice<T extends Parcelable> implements Parcelable {private static final String TAG = "NotificationParceledListSlice";private static final boolean DEBUG = false;private static final int MAX_IPC_SIZE = IBinder.getSuggestedMaxIpcSizeBytes();private final List<T> mList;private int mInlineCountLimit = Integer.MAX_VALUE;public ParceledListSlice(List<T> list) {mList = list;}private ParceledListSlice(Parcel p, ClassLoader loader) {final int N = p.readInt();mList = new ArrayList<T>(N);if (DEBUG) Log.d(TAG, "Retrieving " + N + " items");if (N <= 0) {return;}Creator<?> creator = readParcelableCreator(p, loader);Class<?> listElementClass = null;int i = 0;while (i < N) {if (p.readInt() == 0) {break;}listElementClass = readVerifyAndAddElement(creator, p, loader, listElementClass);if (DEBUG) Log.d(TAG, "Read inline #" + i + ": " + mList.get(mList.size() - 1));i++;}if (i >= N) {return;}final IBinder retriever = p.readStrongBinder();while (i < N) {if (DEBUG) Log.d(TAG, "Reading more @" + i + " of " + N + ": retriever=" + retriever);Parcel data = Parcel.obtain();Parcel reply = Parcel.obtain();data.writeInt(i);try {retriever.transact(IBinder.FIRST_CALL_TRANSACTION, data, reply, 0);} catch (RemoteException e) {Log.w(TAG, "Failure retrieving array; only received " + i + " of " + N, e);return;}while (i < N && reply.readInt() != 0) {listElementClass = readVerifyAndAddElement(creator, reply, loader,listElementClass);if (DEBUG) Log.d(TAG, "Read extra #" + i + ": " + mList.get(mList.size() - 1));i++;}reply.recycle();data.recycle();}}private Class<?> readVerifyAndAddElement(Creator<?> creator, Parcel p,ClassLoader loader, Class<?> listElementClass) {final T parcelable = readCreator(creator, p, loader);if (listElementClass == null) {listElementClass = parcelable.getClass();} else {verifySameType(listElementClass, parcelable.getClass());}mList.add(parcelable);return listElementClass;}@SuppressWarnings("unchecked")private T readCreator(Creator<?> creator, Parcel p, ClassLoader loader) {if (creator instanceof ClassLoaderCreator<?>) {ClassLoaderCreator<?> classLoaderCreator =(ClassLoaderCreator<?>) creator;return (T) classLoaderCreator.createFromParcel(p, loader);}return (T) creator.createFromParcel(p);}private static void verifySameType(final Class<?> expected, final Class<?> actual) {if (!actual.equals(expected)) {throw new IllegalArgumentException("Can't unparcel type "+ actual.getName() + " in list of type "+ (expected == null ? null : expected.getName()));}}public List<T> getList() {return mList;}/*** Set a limit on the maximum number of entries in the array that will be included* inline in the initial parcelling of this object.*/public void setInlineCountLimit(int maxCount) {mInlineCountLimit = maxCount;}@Overridepublic int describeContents() {int contents = 0;final List<T> list = getList();for (int i = 0; i < list.size(); i++) {contents |= list.get(i).describeContents();}return contents;}/*** Write this to another Parcel. Note that this discards the internal Parcel* and should not be used anymore. This is so we can pass this to a Binder* where we won't have a chance to call recycle on this.*/@Overridepublic void writeToParcel(Parcel dest, int flags) {final int N = mList.size();final int callFlags = flags;dest.writeInt(N);if (DEBUG) Log.d(TAG, "Writing " + N + " items");if (N > 0) {final Class<?> listElementClass = mList.get(0).getClass();writeParcelableCreator(mList.get(0), dest);int i = 0;while (i < N && i < mInlineCountLimit && dest.dataSize() < MAX_IPC_SIZE) {dest.writeInt(1);final T parcelable = mList.get(i);verifySameType(listElementClass, parcelable.getClass());writeElement(parcelable, dest, callFlags);if (DEBUG) Log.d(TAG, "Wrote inline #" + i + ": " + mList.get(i));i++;}if (i < N) {dest.writeInt(0);Binder retriever = new Binder() {@Overrideprotected boolean onTransact(int code, Parcel data, Parcel reply, int flags)throws RemoteException {if (code != FIRST_CALL_TRANSACTION) {return super.onTransact(code, data, reply, flags);}int i = data.readInt();if (DEBUG) Log.d(TAG, "Writing more @" + i + " of " + N);while (i < N && reply.dataSize() < MAX_IPC_SIZE) {reply.writeInt(1);final T parcelable = mList.get(i);verifySameType(listElementClass, parcelable.getClass());writeElement(parcelable, reply, callFlags);if (DEBUG) Log.d(TAG, "Wrote extra #" + i + ": " + mList.get(i));i++;}if (i < N) {if (DEBUG) Log.d(TAG, "Breaking @" + i + " of " + N);reply.writeInt(0);}return true;}};if (DEBUG) Log.d(TAG, "Breaking @" + i + " of " + N + ": retriever=" + retriever);dest.writeStrongBinder(retriever);}}}protected void writeElement(T parcelable, Parcel reply, int callFlags) {parcelable.writeToParcel(reply, callFlags);}protected void writeParcelableCreator(T parcelable, Parcel dest) {dest.writeParcelableCreator(parcelable);}protected Creator<?> readParcelableCreator(Parcel from, ClassLoader loader) {return from.readParcelableCreator(loader);}@SuppressWarnings("unchecked")public static final ClassLoaderCreator<ParceledListSlice> CREATOR= new ClassLoaderCreator<ParceledListSlice>() {@Overridepublic ParceledListSlice createFromParcel(Parcel in) {return new ParceledListSlice(in, getClass().getClassLoader());}@Overridepublic ParceledListSlice createFromParcel(Parcel in, ClassLoader loader) {return new ParceledListSlice(in, loader);}@Overridepublic ParceledListSlice[] newArray(int size) {return new ParceledListSlice[size];}};
}

别忘了加一下对应的 ParceledListSlice.aidl 文件：

package com.jimmysun.notificationdemo;parcelable NotificationParceledListSlice<T>;

现在来修改一下我们 AIDL 接口文件：

import android.app.Notification;
import com.jimmysun.notificationdemo.ParceledListSlice;interface IAIDLTest {ParceledListSlice<Notification> getNotifications();
}

然后在我们 Service 里的代码修改如下：

private final IBinder mService = new IAIDLTest.Stub() {@Overridepublic ParceledListSlice<Notification> getNotifications() {List<Notification> notifications = new ArrayList<>();for (int i = 0; i < 500; i++) {notifications.add(new Notification.Builder(AIDLTestService.this,"CHANNEL_ID").setSmallIcon(R.mipmap.ic_launcher).setLargeIcon(Icon.createWithResource(AIDLTestService.this,R.drawable.ic_avatar)).setContentTitle("标题文本" + i).setContentText("正文文本" + i).setContentIntent(NotificationUtils.createActivityPendingIntent(AIDLTestService.this, "AIDL 测试" + i)).setAutoCancel(true).addAction(0, "按钮 1",NotificationUtils.createActivityPendingIntent(AIDLTestService.this, "按钮 1" + i)).addAction(0, "按钮 2",NotificationUtils.createReceiverPendingIntent(AIDLTestService.this, "按钮 2" + i)).build());}return new ParceledListSlice<>(notifications);}
};

最后在 Activity 里使用如下：

for (Notification notification : aidlTest.getNotifications().getList()) {Log.d(TAG, "onServiceConnected: notification title = "+ notification.extras.get(Notification.EXTRA_TITLE));
}

运行一下，输出结果部分日志如下：

输出结果

以上输出的结果验证了该方案没有问题~

4. 原理分析

下面来分析一下分片传输的原理，首先贴上写操作的代码，代码说明见注释：

@Override
public void writeToParcel(Parcel dest, int flags) {final int N = mList.size();final int callFlags = flags;// 写入数据长度，为了读取时知道数据列表有多少数据dest.writeInt(N);if (DEBUG) Log.d(TAG, "Writing " + N + " items");if (N > 0) {final Class<?> listElementClass = mList.get(0).getClass();// 写入类名，用于读取时获取 ClassLoaderCreatorwriteParcelableCreator(mList.get(0), dest);int i = 0;// 循环写入数据，mInlineCountLimit 可以由调用方指定，默认为 MAX_VALUE；// MAX_IPC_SIZE 为 binder 传输最大大小（64KB）while (i < N && i < mInlineCountLimit && dest.dataSize() < MAX_IPC_SIZE) {// 写入 1 代表一条数据dest.writeInt(1);final T parcelable = mList.get(i);// 校验当前写入的对象是不是和第一个对象是同一个类，如果不是则抛异常，方法定义见后面verifySameType(listElementClass, parcelable.getClass());// 写入当前数据，方法定义见后面writeElement(parcelable, dest, callFlags);if (DEBUG) Log.d(TAG, "Wrote inline #" + i + ": " + mList.get(i));i++;}if (i < N) {// 如果走到这里，说明上面没写完，需要分片传输了，先写个 0 说明还要读取dest.writeInt(0);// 下面写入 binder，这里是核心了，在读取的时候通过拿到 binder，一次一次调用 transact()// 方法，来回调这里的 onTransact() 方法，每次传输尽可能多的数据，以达到分片传输的目的Binder retriever = new Binder() {@Overrideprotected boolean onTransact(int code, Parcel data, Parcel reply, int flags)throws RemoteException {// 如果 code 不为 FIRST_CALL_TRANSACTION 则执行默认操作if (code != FIRST_CALL_TRANSACTION) {return super.onTransact(code, data, reply, flags);}// data 是读取方发来的数据，先告诉我现在读取到列表的哪个位置了int i = data.readInt();if (DEBUG) Log.d(TAG, "Writing more @" + i + " of " + N);// 循环给 reply 写入数据，直到超出或结束while (i < N && reply.dataSize() < MAX_IPC_SIZE) {// 写入 1 代表一条数据reply.writeInt(1);// 验证并写入数据final T parcelable = mList.get(i);verifySameType(listElementClass, parcelable.getClass());writeElement(parcelable, reply, callFlags);if (DEBUG) Log.d(TAG, "Wrote extra #" + i + ": " + mList.get(i));i++;}if (i < N) {// 走到这里写入 0 来代表还没有读完if (DEBUG) Log.d(TAG, "Breaking @" + i + " of " + N);reply.writeInt(0);}return true;}};if (DEBUG) Log.d(TAG, "Breaking @" + i + " of " + N + ": retriever=" + retriever);dest.writeStrongBinder(retriever);}}
}private static void verifySameType(final Class<?> expected, final Class<?> actual) {if (!actual.equals(expected)) {throw new IllegalArgumentException("Can't unparcel type "+ actual.getName() + " in list of type "+ (expected == null ? null : expected.getName()));}
}protected void writeElement(T parcelable, Parcel reply, int callFlags) {parcelable.writeToParcel(reply, callFlags);
}

接下来贴上读取的代码：

private final List<T> mList;private NotificationParceledListSlice(Parcel p, ClassLoader loader) {// 读取数据长度final int N = p.readInt();// 创建数据列表mList = new ArrayList<T>(N);if (DEBUG) Log.d(TAG, "Retrieving " + N + " items");if (N <= 0) {return;}// 通过类名读取 creatorCreator<?> creator = readParcelableCreator(p, loader);Class<?> listElementClass = null;// 循环遍历读取数据int i = 0;while (i < N) {// 这里每读取一条数据的时候 readInt() 都返回 1，如果返回 0 就要走后面的分片读取的逻辑了if (p.readInt() == 0) {break;}// 验证读取数据的类型，并加入数据列表中，方法定义见后面listElementClass = readVerifyAndAddElement(creator, p, loader, listElementClass);if (DEBUG) Log.d(TAG, "Read inline #" + i + ": " + mList.get(mList.size() - 1));i++;}// 如果读取完了就直接 return 掉if (i >= N) {return;}// 读取 binder 来进行分片传输final IBinder retriever = p.readStrongBinder();while (i < N) {if (DEBUG) Log.d(TAG, "Reading more @" + i + " of " + N + ": retriever=" + retriever);Parcel data = Parcel.obtain();Parcel reply = Parcel.obtain();// 写入当前数据列表已经读取的位置data.writeInt(i);try {// 调用 transact 来回调发送方 onTransact() 方法，把数据写到 reply 里retriever.transact(IBinder.FIRST_CALL_TRANSACTION, data, reply, 0);} catch (RemoteException e) {Log.w(TAG, "Failure retrieving array; only received " + i + " of " + N, e);return;}// 循环遍历 reply 里的数据，验证并添加数据到列表中while (i < N && reply.readInt() != 0) {listElementClass = readVerifyAndAddElement(creator, reply, loader,listElementClass);if (DEBUG) Log.d(TAG, "Read extra #" + i + ": " + mList.get(mList.size() - 1));i++;}reply.recycle();data.recycle();}
}private Class<?> readVerifyAndAddElement(Creator<?> creator, Parcel p,ClassLoader loader, Class<?> listElementClass) {final T parcelable = readCreator(creator, p, loader);if (listElementClass == null) {listElementClass = parcelable.getClass();} else {verifySameType(listElementClass, parcelable.getClass());}mList.add(parcelable);return listElementClass;
}@SuppressWarnings("unchecked")
private T readCreator(Creator<?> creator, Parcel p, ClassLoader loader) {if (creator instanceof ClassLoaderCreator<?>) {ClassLoaderCreator<?> classLoaderCreator =(ClassLoaderCreator<?>) creator;return (T) classLoaderCreator.createFromParcel(p, loader);}return (T) creator.createFromParcel(p);
}

总结来说就是如果一次传输的数据量过大，Server 端会给 Client 端传递一个 Binder 过去，Client 端拿到这个 Binder 后通过不断调用 transact() 方法来回调 Server 端 Binder 的 onTransact() 方法，然后 Server 端会在 onTransact() 方法里传输下一组数据，如此循环直到所有数据传输完毕。
以上就是分片传输原理代码的分析了，不得不说设计的还是很巧妙的。不过该方案只能解决数据列表过多的问题，对于单个 Parcelable 对象可能存在的过大问题是无法解决的。

以上就是分片传输 Parcelable 数据列表的方案及原理，希望对大家有所帮助。