Adroid读代码 Parcel - （1）

关键字：Android, Parcel

20180824 tjy

转载请注明出处

从今天开始写Android Parcel的代码。Android代码使用http://androidxref.com/8.1.0_r33/上面的代码。

我觉得有必要解释下读代码的方式。
比较简单的解释直接用注释的方式写在代码里面；
如果代码有深层次的方法调用或者横跨Java和C++，会直接在函数下面列出来调用的函数的代码以及目录文件位置，同时会注明是C++代码还是Java代码。这样的好处是传递的参数的值能一目了然，缺点是不适合写在网页里面，因为有时候调用会很深，并且有代码使用了goto语句，破坏了从上到下的调用结构。
不过，这里是网页，所以我会尽可能的把代码分开来解释。

Let's go

先从 Parcel.java开始。
Parcel.java 是Parcel在Java的描述，其实现用C++在Parcel.cpp描述，Java描述和C++描述通过JNI连接。

Parcel.java有很长的英文注释，作者写的这么仔细，不研读下岂不可惜。

在注释里面，作者说Parcel是一个data 和 object reference 的容器，能够在IBinder之间进行传递，
这是Parcel最主要的作用。作者强调Parcel不是一个通用的序列化机制，不能把数据放入Parcel后将其持久化。

//http://androidxref.com/8.1.0_r33/xref/frameworks/base/core/java/android/os/Parcel.java
/**
 * Container for a message (data and object references) that can
 * be sent through an IBinder.  A Parcel can contain both flattened data
 * that will be unflattened on the other side of the IPC (using the various
 * methods here for writing specific types, or the general
 * {@link Parcelable} interface), and references to live {@link IBinder}
 * objects that will result in the other side receiving a proxy IBinder
 * connected with the original IBinder in the Parcel.
 *
 * <p class="note">Parcel is <strong>not</strong> a general-purpose
 * serialization mechanism.  This class (and the corresponding
 * {@link Parcelable} API for placing arbitrary objects into a Parcel) is
 * designed as a high-performance IPC transport.  As such, it is not
 * appropriate to place any Parcel data in to persistent storage: changes
 * in the underlying implementation of any of the data in the Parcel can
 * render older data unreadable.</p>
 *
 * <p>The bulk of the Parcel API revolves around reading and writing data
 * of various types.  There are six major classes of such functions available.</p>
 *
 * <h3>Primitives</h3>
 *
 * <p>The most basic data functions are for writing and reading primitive
 * data types: {@link #writeByte}, {@link #readByte}, {@link #writeDouble},
 * {@link #readDouble}, {@link #writeFloat}, {@link #readFloat}, {@link #writeInt},
 * {@link #readInt}, {@link #writeLong}, {@link #readLong},
 * {@link #writeString}, {@link #readString}.  Most other
 * data operations are built on top of these.  The given data is written and
 * read using the endianess of the host CPU.</p>
 *
 * <h3>Primitive Arrays</h3>
 *
 * <p>There are a variety of methods for reading and writing raw arrays
 * of primitive objects, which generally result in writing a 4-byte length
 * followed by the primitive data items.  The methods for reading can either
 * read the data into an existing array, or create and return a new array.
 * These available types are:</p>
 *
 * <ul>
 * <li> {@link #writeBooleanArray(boolean[])},
 * {@link #readBooleanArray(boolean[])}, {@link #createBooleanArray()}
 * <li> {@link #writeByteArray(byte[])},
 * {@link #writeByteArray(byte[], int, int)}, {@link #readByteArray(byte[])},
 * {@link #createByteArray()}
 * <li> {@link #writeCharArray(char[])}, {@link #readCharArray(char[])},
 * {@link #createCharArray()}
 * <li> {@link #writeDoubleArray(double[])}, {@link #readDoubleArray(double[])},
 * {@link #createDoubleArray()}
 * <li> {@link #writeFloatArray(float[])}, {@link #readFloatArray(float[])},
 * {@link #createFloatArray()}
 * <li> {@link #writeIntArray(int[])}, {@link #readIntArray(int[])},
 * {@link #createIntArray()}
 * <li> {@link #writeLongArray(long[])}, {@link #readLongArray(long[])},
 * {@link #createLongArray()}
 * <li> {@link #writeStringArray(String[])}, {@link #readStringArray(String[])},
 * {@link #createStringArray()}.
 * <li> {@link #writeSparseBooleanArray(SparseBooleanArray)},
 * {@link #readSparseBooleanArray()}.
 * </ul>
 *
 * <h3>Parcelables</h3>
 *
 * <p>The {@link Parcelable} protocol provides an extremely efficient (but
 * low-level) protocol for objects to write and read themselves from Parcels.
 * You can use the direct methods {@link #writeParcelable(Parcelable, int)}
 * and {@link #readParcelable(ClassLoader)} or
 * {@link #writeParcelableArray} and
 * {@link #readParcelableArray(ClassLoader)} to write or read.  These
 * methods write both the class type and its data to the Parcel, allowing
 * that class to be reconstructed from the appropriate class loader when
 * later reading.</p>
 *
 * <p>There are also some methods that provide a more efficient way to work
 * with Parcelables: {@link #writeTypedObject}, {@link #writeTypedArray},
 * {@link #writeTypedList}, {@link #readTypedObject},
 * {@link #createTypedArray} and {@link #createTypedArrayList}.  These methods
 * do not write the class information of the original object: instead, the
 * caller of the read function must know what type to expect and pass in the
 * appropriate {@link Parcelable.Creator Parcelable.Creator} instead to
 * properly construct the new object and read its data.  (To more efficient
 * write and read a single Parcelable object that is not null, you can directly
 * call {@link Parcelable#writeToParcel Parcelable.writeToParcel} and
 * {@link Parcelable.Creator#createFromParcel Parcelable.Creator.createFromParcel}
 * yourself.)</p>
 *
 * <h3>Bundles</h3>
 *
 * <p>A special type-safe container, called {@link Bundle}, is available
 * for key/value maps of heterogeneous values.  This has many optimizations
 * for improved performance when reading and writing data, and its type-safe
 * API avoids difficult to debug type errors when finally marshalling the
 * data contents into a Parcel.  The methods to use are
 * {@link #writeBundle(Bundle)}, {@link #readBundle()}, and
 * {@link #readBundle(ClassLoader)}.
 *
 * <h3>Active Objects</h3>
 *
 * <p>An unusual feature of Parcel is the ability to read and write active
 * objects.  For these objects the actual contents of the object is not
 * written, rather a special token referencing the object is written.  When
 * reading the object back from the Parcel, you do not get a new instance of
 * the object, but rather a handle that operates on the exact same object that
 * was originally written.  There are two forms of active objects available.</p>
 *
 * <p>{@link Binder} objects are a core facility of Android's general cross-process
 * communication system.  The {@link IBinder} interface describes an abstract
 * protocol with a Binder object.  Any such interface can be written in to
 * a Parcel, and upon reading you will receive either the original object
 * implementing that interface or a special proxy implementation
 * that communicates calls back to the original object.  The methods to use are
 * {@link #writeStrongBinder(IBinder)},
 * {@link #writeStrongInterface(IInterface)}, {@link #readStrongBinder()},
 * {@link #writeBinderArray(IBinder[])}, {@link #readBinderArray(IBinder[])},
 * {@link #createBinderArray()},
 * {@link #writeBinderList(List)}, {@link #readBinderList(List)},
 * {@link #createBinderArrayList()}.</p>
 *
 * <p>FileDescriptor objects, representing raw Linux file descriptor identifiers,
 * can be written and {@link ParcelFileDescriptor} objects returned to operate
 * on the original file descriptor.  The returned file descriptor is a dup
 * of the original file descriptor: the object and fd is different, but
 * operating on the same underlying file stream, with the same position, etc.
 * The methods to use are {@link #writeFileDescriptor(FileDescriptor)},
 * {@link #readFileDescriptor()}.
 *
 * <h3>Untyped Containers</h3>
 *
 * <p>A final class of methods are for writing and reading standard Java
 * containers of arbitrary types.  These all revolve around the
 * {@link #writeValue(Object)} and {@link #readValue(ClassLoader)} methods
 * which define the types of objects allowed.  The container methods are
 * {@link #writeArray(Object[])}, {@link #readArray(ClassLoader)},
 * {@link #writeList(List)}, {@link #readList(List, ClassLoader)},
 * {@link #readArrayList(ClassLoader)},
 * {@link #writeMap(Map)}, {@link #readMap(Map, ClassLoader)},
 * {@link #writeSparseArray(SparseArray)},
 * {@link #readSparseArray(ClassLoader)}.
 */

先看构造函数。
构造函数接受一个 long 参数，也可以传入0。由于底层使用C++实现，这个参数表示C++ 的 Parcel指针，传入非0值表示底层用这个参数代表的C++的Parcel对象，传入0表示重新创建C++的Parcel*对象。
下面在代码中用注释的方式简单作了下解释。

//from http://androidxref.com/8.1.0_r33/xref/frameworks/base/core/java/android/os/Parcel.java#3048

private Parcel(long nativePtr) {
    if (DEBUG_RECYCLE) {
        mStack = new RuntimeException();
    }
    //Log.i(TAG, "Initializing obj=0x" + Integer.toHexString(obj), mStack);
    init(nativePtr);
}

private void init(long nativePtr) {
    if (nativePtr != 0) {
        /*
            传入非0值，直接用这个值赋值给mNativePtr，
            后续使用这个mNativePtr操作C++的Parcel对象。
            传入1运行会发生什么？不过这个构造函数是private。
        */
        mNativePtr = nativePtr;
        mOwnsNativeParcelObject = false;
    } else {
        /*
            传入0值，会调用底层的C++代码创建C++ Parcel对象。
            mNativePtr保存C++ Parcel对象指针。
            用mOwnsNativeParcelObject作标记。
        */
        mNativePtr = nativeCreate();
        mOwnsNativeParcelObject = true;
    }
}

//下面代码是C++代码
//from http://androidxref.com/8.1.0_r33/xref/frameworks/base/core/jni/android_os_Parcel.cpp#816
 {"nativeCreate",              "()J", (void*)android_os_Parcel_create},

//from http://androidxref.com/8.1.0_r33/xref/frameworks/base/core/jni/android_os_Parcel.cpp#android_os_Parcel_create
static jlong android_os_Parcel_create(JNIEnv* env, jclass clazz)
{
    Parcel* parcel = new Parcel();
    /*
        下面有个指针的转换，把Parcel*转成jlong，传递到Java空间。
    */
    return reinterpret_cast<jlong>(parcel);
}

既然构造函数是private，肯定有public创建Parcel对象的方法，就是obtain方法。
这里使用了6个元素的池子来重复利用Parcel对象，避免了多次创建和销毁的开销。
当调用obtain的时候，如果池子里面有可用的对象，则直接返回这个可用对象；如果池子里面现成的对象用完了，这个时候才会创建Parcel对象。

//from http://androidxref.com/8.1.0_r33/xref/frameworks/base/core/java/android/os/Parcel.java
 
 /*
    定义池子大小和元素池
 */
 private static final int POOL_SIZE = 6;
 private static final Parcel[] sOwnedPool = new Parcel[POOL_SIZE];
 private static final Parcel[] sHolderPool = new Parcel[POOL_SIZE];

/**
 * Retrieve a new Parcel object from the pool.
 */
public static Parcel obtain() {
    final Parcel[] pool = sOwnedPool;
    /*
        由于sOwnedPool属性是static，
        所以这个synchronized是类级别的锁，是多线程安全的。
        这里的synchronized (pool)和synchronized (sOwnedPool)是没有区别的。
    */
    synchronized (pool) {
        Parcel p;
        for (int i=0; i<POOL_SIZE; i++) {
            p = pool[i];//从池子里面拿出来一个对象
            if (p != null) {//对象不为空表示对象可用
                /*
                    pool[i]的引用指向null，
                    其他obtain调用者就无法“看到”p引用的对象了。
                */
                pool[i] = null;
                if (DEBUG_RECYCLE) {
                    p.mStack = new RuntimeException();
                }
                //ReadWriteHelper.DEFAULT是ReadWriteHelper的单例static对象
                p.mReadWriteHelper = ReadWriteHelper.DEFAULT;
                return p;//返回p
            }
        }
    }
    /*
        如果找遍了池子都没有找到可用的对象，则创建一个新的Parcel对象。
    */
    return new Parcel(0);
}

池子也会回收不用的对象。recycle方法做这件事情，在注释里面，作者说，一旦调用recycle方法，就不能再“碰”这个对象了，读也不行。

/**
 * Put a Parcel object back into the pool.  You must not touch
 * the object after this call.
 */
public final void recycle() {
    if (DEBUG_RECYCLE) mStack = null;
    /*
        freeBuffer方法把C++的数据清空(写入Parcel的数据存在C++代码里面)。
        并重置一些状态。
        后面再来看这个方法。
    */
    freeBuffer();

    final Parcel[] pool;
    /*
        在构造函数里面，如果是自己创建的C++对象，
        则mOwnsNativeParcelObject=true。
        这里会检查mOwnsNativeParcelObject的值，
        判断是自己创建的C++对象还是传递过来的C++对象指针。
    */
    if (mOwnsNativeParcelObject) {
        //自己创建的C++对象
        pool = sOwnedPool;
    } else {
        //传递过来的C++对象指针
        mNativePtr = 0;
        pool = sHolderPool;
    }

    synchronized (pool) {
        for (int i=0; i<POOL_SIZE; i++) {
            if (pool[i] == null) {//pool[i] == null表示pool[i]是一个空的”萝卜坑“
            //把对象放入池子的“萝卜坑”里(获取被回收对象的引用)
                pool[i] = this;
                return;
            }
        }
    }
}

这是最简单的部分，后面待续。。