Parcel 包裹类

1.Parcel类的声明

class Parcel{public:    class ReadableBlob;    class WritableBlob;                        Parcel();                        ~Parcel();        const uint8_t*      data() const;    size_t              dataSize() const;    size_t              dataAvail() const;    size_t              dataPosition() const;    size_t              dataCapacity() const;    status_t            setDataSize(size_t size);    void                setDataPosition(size_t pos) const;    status_t            setDataCapacity(size_t size);        status_t            setData(const uint8_t* buffer, size_t len);    status_t            appendFrom(const Parcel *parcel,                                   size_t start, size_t len);    bool                pushAllowFds(bool allowFds);    void                restoreAllowFds(bool lastValue);    bool                hasFileDescriptors() const;    // Writes the RPC header.    status_t            writeInterfaceToken(const String16& interface);    // Parses the RPC header, returning true if the interface name    // in the header matches the expected interface from the caller.    //    // Additionally, enforceInterface does part of the work of    // propagating the StrictMode policy mask, populating the current    // IPCThreadState, which as an optimization may optionally be    // passed in.    bool                enforceInterface(const String16& interface,                                         IPCThreadState* threadState = NULL) const;    bool                checkInterface(IBinder*) const;    void                freeData();    const size_t*       objects() const;    size_t              objectsCount() const;        status_t            errorCheck() const;    void                setError(status_t err);        status_t            write(const void* data, size_t len);    void*               writeInplace(size_t len);    status_t            writeUnpadded(const void* data, size_t len);    status_t            writeInt32(int32_t val);    status_t            writeInt64(int64_t val);    status_t            writeFloat(float val);    status_t            writeDouble(double val);    status_t            writeIntPtr(intptr_t val);    status_t            writeCString(const char* str);    status_t            writeString8(const String8& str);    status_t            writeString16(const String16& str);    status_t            writeString16(const char16_t* str, size_t len);    status_t            writeStrongBinder(const sp<IBinder>& val);    status_t            writeWeakBinder(const wp<IBinder>& val);    status_t            write(const Flattenable& val);    // Place a native_handle into the parcel (the native_handle's file-    // descriptors are dup'ed, so it is safe to delete the native_handle    // when this function returns).     // Doesn't take ownership of the native_handle.    status_t            writeNativeHandle(const native_handle* handle);        // Place a file descriptor into the parcel.  The given fd must remain    // valid for the lifetime of the parcel.    // The Parcel does not take ownership of the given fd unless you ask it to.    status_t            writeFileDescriptor(int fd, bool takeOwnership = false);        // Place a file descriptor into the parcel.  A dup of the fd is made, which    // will be closed once the parcel is destroyed.    status_t            writeDupFileDescriptor(int fd);    // Writes a blob to the parcel.    // If the blob is small, then it is stored in-place, otherwise it is    // transferred by way of an anonymous shared memory region.    // The caller should call release() on the blob after writing its contents.    status_t            writeBlob(size_t len, WritableBlob* outBlob);    status_t            writeObject(const flat_binder_object& val, bool nullMetaData);    // Like Parcel.java's writeNoException().  Just writes a zero int32.    // Currently the native implementation doesn't do any of the StrictMode    // stack gathering and serialization that the Java implementation does.    status_t            writeNoException();    void                remove(size_t start, size_t amt);        status_t            read(void* outData, size_t len) const;    const void*         readInplace(size_t len) const;    int32_t             readInt32() const;    status_t            readInt32(int32_t *pArg) const;    int64_t             readInt64() const;    status_t            readInt64(int64_t *pArg) const;    float               readFloat() const;    status_t            readFloat(float *pArg) const;    double              readDouble() const;    status_t            readDouble(double *pArg) const;    intptr_t            readIntPtr() const;    status_t            readIntPtr(intptr_t *pArg) const;    const char*         readCString() const;    String8             readString8() const;    String16            readString16() const;    const char16_t*     readString16Inplace(size_t* outLen) const;    sp<IBinder>         readStrongBinder() const;    wp<IBinder>         readWeakBinder() const;    status_t            read(Flattenable& val) const;    // Like Parcel.java's readExceptionCode().  Reads the first int32    // off of a Parcel's header, returning 0 or the negative error    // code on exceptions, but also deals with skipping over rich    // response headers.  Callers should use this to read & parse the    // response headers rather than doing it by hand.    int32_t             readExceptionCode() const;    // Retrieve native_handle from the parcel. This returns a copy of the    // parcel's native_handle (the caller takes ownership). The caller    // must free the native_handle with native_handle_close() and     // native_handle_delete().    native_handle*     readNativeHandle() const;        // Retrieve a file descriptor from the parcel.  This returns the raw fd    // in the parcel, which you do not own -- use dup() to get your own copy.    int                 readFileDescriptor() const;    // Reads a blob from the parcel.    // The caller should call release() on the blob after reading its contents.    status_t            readBlob(size_t len, ReadableBlob* outBlob) const;    const flat_binder_object* readObject(bool nullMetaData) const;    // Explicitly close all file descriptors in the parcel.    void                closeFileDescriptors();        typedef void        (*release_func)(Parcel* parcel,                                        const uint8_t* data, size_t dataSize,                                        const size_t* objects, size_t objectsSize,                                        void* cookie);                            const uint8_t*      ipcData() const;    size_t              ipcDataSize() const;    const size_t*       ipcObjects() const;    size_t              ipcObjectsCount() const;    void                ipcSetDataReference(const uint8_t* data, size_t dataSize,                                            const size_t* objects, size_t objectsCount,                                            release_func relFunc, void* relCookie);        void                print(TextOutput& to, uint32_t flags = 0) const;private:                        Parcel(const Parcel& o);    Parcel&             operator=(const Parcel& o);        status_t            finishWrite(size_t len);    void                releaseObjects();    void                acquireObjects();    status_t            growData(size_t len);    status_t            restartWrite(size_t desired);    status_t            continueWrite(size_t desired);    void                freeDataNoInit();    void                initState();    void                scanForFds() const;                            template<class T>    status_t            readAligned(T *pArg) const;    template<class T>   T readAligned() const;    template<class T>    status_t            writeAligned(T val);    status_t            mError;    uint8_t*            mData;    size_t              mDataSize;    size_t              mDataCapacity;    mutable size_t      mDataPos;    size_t*             mObjects;    size_t              mObjectsSize;    size_t              mObjectsCapacity;    mutable size_t      mNextObjectHint;    mutable bool        mFdsKnown;    mutable bool        mHasFds;    bool                mAllowFds;        release_func        mOwner;    void*               mOwnerCookie;    class Blob {    public:        Blob();        ~Blob();        void release();        inline size_t size() const { return mSize; }    protected:        void init(bool mapped, void* data, size_t size);        void clear();        bool mMapped;        void* mData;        size_t mSize;    };public:    class ReadableBlob : public Blob {        friend class Parcel;    public:        inline const void* data() const { return mData; }    };    class WritableBlob : public Blob {        friend class Parcel;    public:        inline void* data() { return mData; }    };};