本文针对 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() {

        @Override
        public 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;
        }
    };

    @Override
    public IBinder onBind(Intent intent) {
        return mService;
    }
}

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

<service
    android: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";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_aidl_test);
        bindService(new Intent(this, AIDLTestService.class), this, BIND_AUTO_CREATE);
    }

    @Override
    public 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();
        }
    }

    @Override
    public 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;
    }

    @Override
    public 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.
     */
    @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();
            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() {
                    @Override
                    protected 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>() {
        @Override
        public ParceledListSlice createFromParcel(Parcel in) {
            return new ParceledListSlice(in, getClass().getClassLoader());
        }

        @Override
        public ParceledListSlice createFromParcel(Parcel in, ClassLoader loader) {
            return new ParceledListSlice(in, loader);
        }

        @Override
        public 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() {
    @Override
    public 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();
        // 写入类名，用于读取时获取 ClassLoaderCreator
        writeParcelableCreator(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() {
                @Override
                protected 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;
    }
    // 通过类名读取 creator
    Creator<?> 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 数据列表的方案及原理，希望对大家有所帮助。