AIDL如何分片传输大量Parcelable数据列表

在岁月中远行
234 阅读7分钟

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

2024-12-22 23:31:30.158 5883-5883/com.example.kotlindemotest E/JavaBinder: !!! FAILED BINDER TRANSACTION !!! (parcel size = 96) 2024-12-22 23:31:30.159 5883-5883/com.example.kotlindemotest D/tanyonglin: android.os.DeadObjectException: Transaction failed on small parcel; remote process probably died, but this could also be caused by running out of binder buffer space

我们现在来模拟一下大数据传输的场景。 先创建一个AIDL文件，

// IGameManagerSlice.aidl
package com.example.kotlindemotest;

// Declare any non-default types here with import statements
import com.example.kotlindemotest.Game;
//import com.example.kotlindemotest.ParceledListSlice;
interface IGameManager {

List<Game> getGameList();

void addGame(in Game game);


}

这里的Game类是一个实现Parcelable接口的实体类，

package com.example.kotlindemotest;

import android.os.Parcel;
import android.os.Parcelable;

import androidx.annotation.NonNull;

public class Game implements Parcelable {
    public String gameName;
    public String gameDescribe;
    private byte[] data;
    public Game(String gameName,String gameDescribe,byte[] data){
        this.gameName=gameName;
        this.gameDescribe=gameDescribe;
        this.data=data;

    }

    @NonNull
    @Override
    public String toString() {
        return "gameName ="+gameName+"gameDescribe ="+gameDescribe;
    }

    protected Game(Parcel in) {
        gameName=in.readString();
        gameDescribe=in.readString();
        data=in.createByteArray();
    }

    public static final Creator<Game> CREATOR = new Creator<Game>() {
        @Override
        public Game createFromParcel(Parcel in) {
            return new Game(in);
        }

        @Override
        public Game[] newArray(int size) {
            return new Game[size];
        }
    };

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(@NonNull Parcel dest, int flags) {
        dest.writeString(gameName);
        dest.writeString(gameDescribe);
        dest.writeByteArray(data);
    }
}

然后创建一个实现这个AIDL接口的Service，代码如下：

package com.example.kotlindemotest

import android.app.Service
import android.content.Intent
import android.os.Binder
import android.os.IBinder
import android.os.Parcelable
import java.util.concurrent.CopyOnWriteArrayList

/**
 * 变量后缀带有Slice就是实现分片传输
 */

class AIDLService : Service() {
    var mGameList = CopyOnWriteArrayList<Game>()
    private val mBinder: Binder = object : IGameManager.Stub() {
                override fun getGameList():List<Game> {
            return mGameList
        }

        override fun addGame(game: Game?) {
            mGameList.add(game)
        }
    }


    var mGameListSlice = CopyOnWriteArrayList<Game>()
    private val mBinderSlice: Binder = object : IGameManagerSlice.Stub() {
        override fun getGameList(): ParceledListSlice<Game> {
            return ParceledListSlice<Game>(mGameListSlice)
        }

        override fun addGame(game: Game?) {
            mGameListSlice.add(game)
        }
    }

    override fun onBind(intent: Intent?): IBinder? {
         return mBinder
       // return mBinderSlice
    }

    override fun onCreate() {
        super.onCreate()
        repeat(100) {
            //这里每一条数据有1/50M 1024*1024为1M，进程间传递数据大小最大为1M-8k大概为1M
            mGameList.add(Game("英雄联盟", "好玩的游戏", ByteArray(1024 * 1024 * 1/50)))
        }
//        repeat(100) {
//            mGameListSlice.add(Game("英雄联盟", "好玩的游戏", ByteArray(1024 * 1024 * 1/50)))
//        }
    }
}

<service android:name=".AIDLService" android:process=":remote"/>

接着实现一个Activity绑定Service，跨进程取到数据后进行打印：

package com.example.kotlindemotest

import android.content.ComponentName
import android.content.Intent
import android.content.ServiceConnection
import android.os.Bundle
import android.os.IBinder
import android.os.RemoteException
import android.util.Log
import androidx.activity.ComponentActivity

class AIDLActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.wrap_content)
        val mIntent = Intent(this@AIDLActivity, AIDLService::class.java)
        bindService(mIntent, mServiceConnection, BIND_AUTO_CREATE)
    }

    private val mServiceConnection: ServiceConnection = object : ServiceConnection {
        override fun onServiceConnected(name: ComponentName, service: IBinder) {
//            val iGameManagerSlice = IGameManagerSlice.Stub.asInterface(service)
//            try {
//                val mList = iGameManagerSlice.gameList
//                mList.list?.forEachIndexed { index, game ->
//                    Log.d("tanyonglin", "第" + index + "条   " + game.toString())
//                }
//            } catch (e: RemoteException) {
//                Log.d("tanyonglin", e.toString())
//            }

            val iGameManager = IGameManager.Stub.asInterface(service)
            try {
                iGameManager.gameList?.forEachIndexed { index, game ->
                    Log.d("tanyonglin","第"+index+"条   " +game.toString())
                }
            } catch (e: RemoteException) {
                Log.d("tanyonglin", e.toString())
            }
        }

        override fun onServiceDisconnected(name: ComponentName) {}
    }

    override fun onDestroy() {
        super.onDestroy()
        unbindService(mServiceConnection)
    }
}

运行报错，可以看到报错的日志，下面来看一下怎么解决。

a6772c21241a3d12dcc912227b1b48f.png

我们想想在android framework层里面经常会有很多AIDL跨进程的操作，而且涉及大量数据传输场景。所以我们从framwork源码里面也许能找到答案。经过一番寻找发现android.app.ApplicationPackageManager#queryIntentServicesAsUser image.png

我们发现其使用了一个ParceledListSlice类，看下类介绍。 看注释这个类是用来IPC时对大量Parcelable对象传输使用的，但是是framework层的代码不能直接使用，需要直接copy出来一份使用。 它集成了父类BaseParceledListSlice,这个类还有其他子类可以支持多种场景 image.png 我们把父类的代码功能整合到ParceledListSlice类里面去，最终得到完整的ParceledListSlice类代码：

package com.example.kotlindemotest;

import android.os.Binder;
import android.os.IBinder;
import android.os.Parcel;
import android.os.Parcelable;
import android.os.RemoteException;
import android.util.Log;

import java.util.ArrayList;
import java.util.List;

/**
 * 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 = "ParceledListSlice";
    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<?> creator = readParcelableCreator(p, loader);
        Class<?> listElementClass = null;
        //循环遍历读取数据
        int i = 0;
        while (i < N) {
            //这里每读取一条数据的时候readInt()都返回1，如果返回0，那么就是后面的分片读取的逻辑
            //这里p.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()方法，把数据写到replay里
                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;
            }
            //循环遍历replay里的数据，验证并添加数据列表中
            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();
            //写入类名，用于读取时获取ClassLoader
            writeParcelableCreator(mList.get(0), dest);
            int i = 0;
            //循环写入数据，mInlineCountLimit可以由调用方指定，默认Integer.MAX_VALUE
            //MAX_IPC_SIZE 为binder 传输最大大小64 * 1024也就是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) {
                //如果代码逻辑执行到这里，那么说明就需要分片传输
                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 {
                        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);
                        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) {
                            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.example.kotlindemotest;

// Declare any non-default types here with import statements
//parcelable ParceledListSlice;
parcelable ParceledListSlice<T>; //这里一定要注意有个泛型T

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

// IGameManagerSlice.aidl
package com.example.kotlindemotest;

// Declare any non-default types here with import statements
import com.example.kotlindemotest.Game;
import com.example.kotlindemotest.ParceledListSlice;
interface IGameManagerSlice {

ParceledListSlice<Game> getGameList();

void addGame(in Game game);


}

然后使用的话上述有贴代码，把带有silce后缀的变量相关代码放开就行，然后再运行，这样是传输就没问题了。

原理分析：分片传输的原理详见代码注释说明，总体来说就是如果一次性传输的数据过大，Server端会给Client端传递一个Binder过去，Client端拿到这个Binder后不断调用transact()方法来回调Service端Binder的onTransacr()方法，然后Servicer端会在onTransact()方法里传输下一组数据，如此循环直到所有数据传输完毕，设计的很巧妙还是。缺点就是对于单个Parcelable对象可能存在的过大问题还是无法解决。我们需要采用其他方式来解决。

avatar
文章
阅读
粉丝