将数据打包，跨进程传输（通过Binder）。看看这货究竟是啥玩意：
Parcel.java ：
public final class Parcel {
private static final boolean DEBUG_RECYCLE = false;
private static final String TAG = "Parcel";
@SuppressWarnings({"UnusedDeclaration"})
private int mNativePtr; // used by native code，非static
/**
* Flag indicating if {@link #mNativePtr} was allocated by this object,
* indicating that we're responsible for its lifecycle.
*/
private boolean mOwnsNativeParcelObject;//非static，从上面解释可以看到，它标识"mNativePtr”是否可用，如果是从NativeCode分配的，则要负责它的生命周期
private RuntimeException mStack;
private static final int POOL_SIZE = 6;
private static final Parcel[] sOwnedPool = new Parcel[POOL_SIZE];//static，类拥有，下同。作为Parcel的缓冲池使用。
private static final Parcel[] sHolderPool = new Parcel[POOL_SIZE];
下面看调用Parcel的obtain（）时的过程：
static protected final Parcel obtain() {
final Parcel[] pool = sHolderPool;//尝试从sHolderPool这个缓冲池取
synchronized (pool) {
Parcel p;
for (int i=0; i<POOL_SIZE; i++) {//POOL_SIZE为6
p = pool[i];
if (p != null) {
pool[i] = null;
if (DEBUG_RECYCLE) {
p.mStack = new RuntimeException();
}
p.init(obj);//找到一个可用的（非null），初始化这个Parcel
return p;
}
}
}
return new Parcel(0);//如果6个都不可用（即缓冲池空了），则新new一个出来
}
private Parcel(int nativePtr) {
if (DEBUG_RECYCLE) {
mStack = new RuntimeException();
}
//Log.i(TAG, "Initializing obj=0x" + Integer.toHexString(obj), mStack);
init(nativePtr);//简单调用
}
private void init(int nativePtr) {
if (nativePtr != 0) {
mNativePtr = nativePtr;
mOwnsNativeParcelObject = false;
} else {
mNativePtr = nativeCreate();//调用Native CODE
mOwnsNativeParcelObject = true;//表明，需要负责本Parcel对象的生命周期。后面有几个方法会根据该boolean值决定是否释放Native CODE生成的对象。
}
}
小结：Parcel(.java)逻辑很简单，从sHolderPool或者sOwnedPool中找不等于null的，取出来重新使用。否则，调用Native Code重新生成一个Parcel。在这里，有mNativePtr和mOwnsNativeParcelObject两个对象的成员变量，用来标识所生成的Native层的Parcel是否需要释放/销毁。
Parcel.h(.cpp)分析：
在Parcel.h中，存在许多字段。实际上，可以将Parcel看作管理一块内存的一个管理者。
status_t mError;
uint8_t* mData;//指针，从字面上看应该是指向数据的指针
size_t mDataSize;//表明数据大小，已经存储的数据大小
size_t mDataCapacity;//应该是内存空间的容量
mutable size_t mDataPos;//mutable修饰，说明这个变量要及时反映出最新值，类比数组中position下标
size_t* mObjects;//指针，可以看作数组。其存储的是每个保存在Parcel对象所申请的内存的大小
size_t mObjectsSize;//与上面数组配合使用
size_t mObjectsCapacity;
mutable size_t mNextObjectHint;
mutable bool mFdsKnown;
mutable bool mHasFds;
bool mAllowFds;
release_func mOwner;
void* mOwnerCookie;
从上面各个字段来看，还是很经典的内存管理方式，这样一般有：内存起始地址（对应上面mData）、内存总容量（对应mDataCapacity）、内存已用容量（对应mDataSize）、当前可用的内存位置（mDataPos）。在Parcel里还更加细分了，每个存储在内存中的对象大小。粒度更细。
Parcel::Parcel()//构造函数
{
initState();
}
...
void Parcel::initState()//简单给各个成员变量赋初值
{
mError = NO_ERROR;
mData = 0;
mDataSize = 0;
mDataCapacity = 0;
mDataPos = 0;
ALOGV("initState Setting data size of %p to %d\n", this, mDataSize);
ALOGV("initState Setting data pos of %p to %d\n", this, mDataPos);
mObjects = NULL;
mObjectsSize = 0;
mObjectsCapacity = 0;
mNextObjectHint = 0;
mHasFds = false;
mFdsKnown = true;
mAllowFds = true;
mOwner = NULL;
}
在setDataCapacity、setDataSize等函数中，调用到continueWrite，这个函数是真正的申请内存函数：
status_t Parcel::continueWrite(size_t desired)
{
// If shrinking, first adjust for any objects that appear
// after the new data size.
size_t objectsSize = mObjectsSize;
if (desired < mDataSize) {//表明需要缩小申请的内存容量
if (desired == 0) {
objectsSize = 0;
} else {
while (objectsSize > 0) {
if (mObjects[objectsSize-1] < desired)//找到一个对象的内存大小小于所要申请的内存大小
break;
objectsSize--;
}
}
}
if (mOwner) {//mOwner是一个回调函数指针
// If the size is going to zero, just release the owner's data.
if (desired == 0) {
freeData();//释放数据
return NO_ERROR;
}
// If there is a different owner, we need to take
// posession.
uint8_t* data = (uint8_t*)malloc(desired);//分配内存
if (!data) {
mError = NO_MEMORY;
return NO_MEMORY;
}
size_t* objects = NULL;
if (objectsSize) {
objects = (size_t*)malloc(objectsSize*sizeof(size_t));//分配objectSize*sizeof(size_t)大小的内存
if (!objects) {
mError = NO_MEMORY;
return NO_MEMORY;
}
// Little hack to only acquire references on objects
// we will be keeping.
size_t oldObjectsSize = mObjectsSize;
mObjectsSize = objectsSize;
acquireObjects();//给各个对象增加强、弱引用计数——加入需要的话
mObjectsSize = oldObjectsSize;
}
if (mData) {
memcpy(data, mData, mDataSize < desired ? mDataSize : desired);//拷贝到data（新申请的）
}
if (objects && mObjects) {
memcpy(objects, mObjects, objectsSize*sizeof(size_t));
}
//ALOGI("Freeing data ref of %p (pid=%d)\n", this, getpid());
mOwner(this, mData, mDataSize, mObjects, mObjectsSize, mOwnerCookie);
mOwner = NULL;
mData = data;
mObjects = objects;
mDataSize = (mDataSize < desired) ? mDataSize : desired;
ALOGV("continueWrite Setting data size of %p to %d\n", this, mDataSize);
mDataCapacity = desired;
mObjectsSize = mObjectsCapacity = objectsSize;
mNextObjectHint = 0;
} else if (mData) {
if (objectsSize < mObjectsSize) {
// Need to release refs on any objects we are dropping.
const sp<ProcessState> proc(ProcessState::self());
for (size_t i=objectsSize; i<mObjectsSize; i++) {
const flat_binder_object* flat
= reinterpret_cast<flat_binder_object*>(mData+mObjects[i]);
if (flat->type == BINDER_TYPE_FD) {
// will need to rescan because we may have lopped off the only FDs
mFdsKnown = false;
}
release_object(proc, *flat, this);//尝试释放对象
}
size_t* objects =
(size_t*)realloc(mObjects, objectsSize*sizeof(size_t));
if (objects) {
mObjects = objects;
}
mObjectsSize = objectsSize;
mNextObjectHint = 0;
}
// We own the data, so we can just do a realloc().
if (desired > mDataCapacity) {
uint8_t* data = (uint8_t*)realloc(mData, desired);//在原mData位置上重新分配内存
if (data) {
mData = data;
mDataCapacity = desired;
} else if (desired > mDataCapacity) {
mError = NO_MEMORY;
return NO_MEMORY;
}
} else {
if (mDataSize > desired) {
mDataSize = desired;
ALOGV("continueWrite Setting data size of %p to %d\n", this, mDataSize);
}
if (mDataPos > desired) {
mDataPos = desired;
ALOGV("continueWrite Setting data pos of %p to %d\n", this, mDataPos);
}
}
} else {
// This is the first data. Easy!
uint8_t* data = (uint8_t*)malloc(desired);//直接申请所需大小
if (!data) {
mError = NO_MEMORY;
return NO_MEMORY;
}
if(!(mDataCapacity == 0 && mObjects == NULL
&& mObjectsCapacity == 0)) {
ALOGE("continueWrite: %d/%p/%d/%d", mDataCapacity, mObjects, mObjectsCapacity, desired);
}
mData = data;
mDataSize = mDataPos = 0;
ALOGV("continueWrite Setting data size of %p to %d\n", this, mDataSize);
ALOGV("continueWrite Setting data pos of %p to %d\n", this, mDataPos);
mDataCapacity = desired;
}
return NO_ERROR;
}
小结：上面内存分配管理比较细致，总的来说就是“要么新申请一块内存”、“要么复用一块内存”，“释放内存”，外加对象的生命周期的控制。