探索Android中的Parcel机制（上）

一．先从Serialize说起

         我们都知道JAVA中的Serialize机制，译成串行化、序列化……，其作用是能将数据对象存入字节流其中，在须要时又一次生成对象。主要应用是利用外部存储设备保存对象状态，以及通过网络传输对象等。

二．Android中的新的序列化机制

         在Android系统中，定位为针对内存受限的设备，因此对性能要求更高，另外系统中採用了新的IPC（进程间通信）机制，必定要求使用性能更出色的对象传输方式。在这种环境下，Parcel被设计出来，其定位就是轻量级的高效的对象序列化和反序列化机制。

三．Parcel类的背后

         在Framework中有parcel类，源代码路径是：

Frameworks/base/core/java/android/os/Parcel.java

典型的源代码片断例如以下：

/**<br /> * Write an integer value into the parcel at the current dataPosition(),<br /> * growing dataCapacity() if needed.<br /> */<br /> public final native void writeInt(int val);</p> <p> /**<br /> * Write a long integer value into the parcel at the current dataPosition(),<br /> * growing dataCapacity() if needed.<br /> */<br /> public final native void writeLong(long val);<br />  

         从中我们看到，从这个源程序文件里我们看不到真正的功能是怎样实现的，必须透过JNI往下走了。于是，Frameworks/base/core/jni/android_util_Binder.cpp中找到了线索

 static void android_os_Parcel_writeInt(JNIEnv* env, jobject clazz, jint val)<br />{<br /> Parcel* parcel = parcelForJavaObject(env, clazz);<br /> if (parcel != NULL) {<br /> const status_t err = parcel->writeInt32(val);<br /> if (err != NO_ERROR) {<br /> jniThrowException(env, “java/lang/OutOfMemoryError”, NULL);<br /> }<br /> }<br />}</p> <p>static void android_os_Parcel_writeLong(JNIEnv* env, jobject clazz, jlong val)<br />{<br /> Parcel* parcel = parcelForJavaObject(env, clazz);<br /> if (parcel != NULL) {<br /> const status_t err = parcel->writeInt64(val);<br /> if (err != NO_ERROR) {<br /> jniThrowException(env, “java/lang/OutOfMemoryError”, NULL);<br /> }<br /> }<br />}<br />

         从这里我们能够得到的信息是函数的实现依赖于Parcel指针，因此还须要找到Parcel的类定义，注意，这里的类已经是用C++语言实现的了。

         找到Frameworks/base/include/binder/parcel.h和Frameworks/base/libs/binder/parcel.cpp。最终找到了最终的实现代码了。

         有兴趣的朋友能够自己读一下，不难理解，这里把主要的思路总结一下：

1.       整个读写全是在内存中进行，主要是通过malloc()、realloc()、memcpy()等内存操作进行，所以效率比JAVA序列化中使用外部存储器会高非常多；

2.       读写时是4字节对齐的，能够看到#define PAD_SIZE(s) (((s)+3)&~3)这句宏定义就是在做这件事情；

3.       假设预分配的空间不够时newSize = ((mDataSize+len)*3)/2;会一次多分配50%；

4.       对于普通数据，使用的是mData内存地址，对于IBinder类型的数据以及FileDescriptor使用的是mObjects内存地址。后者是通过flatten_binder()和unflatten_binder()实现的，目的是反序列化时读出的对象就是原对象而不用又一次new一个新对象。

好了，这就是Parcel背后的动作，全是在一块内存里进行读写操作，就不啰嗦了，把parcel的代码贴在这供没有源代码的朋友參考吧。接下来我会用一个小DEMO演示一下Parcel类在应用程序中的使用，详见《探索Android中的Parcel机制（下）》。

 /*<br /> * Copyright (C) 2005 The Android Open Source Project<br /> *<br /> * Licensed under the Apache License, Version 2.0 (the “License”);<br /> * you may not use this file except in compliance with the License.<br /> * You may obtain a copy of the License at<br /> *<br /> * http://www.apache.org/licenses/LICENSE-2.0<br /> *<br /> * Unless required by applicable law or agreed to in writing, software<br /> * distributed under the License is distributed on an “AS IS” BASIS,<br /> * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.<br /> * See the License for the specific language governing permissions and<br /> * limitations under the License.<br /> */</p> <p>#ifndef ANDROID_PARCEL_H<br />#define ANDROID_PARCEL_H</p> <p>#include <cutils/native_handle.h><br />#include <utils/Errors.h><br />#include <utils/RefBase.h><br />#include <utils/String16.h><br />#include <utils/Vector.h></p> <p>// —————————————————————————<br />namespace android {</p> <p>class IBinder;<br />class ProcessState;<br />class String8;<br />class TextOutput;<br />class Flattenable;</p> <p>struct flat_binder_object; // defined in support_p/binder_module.h</p> <p>class Parcel<br />{<br />public:<br /> Parcel();<br /> ~Parcel();</p> <p> const uint8_t* data() const;<br /> size_t dataSize() const;<br /> size_t dataAvail() const;<br /> size_t dataPosition() const;<br /> size_t dataCapacity() const;</p> <p> status_t setDataSize(size_t size);<br /> void setDataPosition(size_t pos) const;<br /> status_t setDataCapacity(size_t size);</p> <p> status_t setData(const uint8_t* buffer, size_t len);</p> <p> status_t appendFrom(Parcel *parcel, size_t start, size_t len);</p> <p> bool hasFileDescriptors() const;</p> <p> status_t writeInterfaceToken(const String16& interface);<br /> bool enforceInterface(const String16& interface) const;<br /> bool checkInterface(IBinder*) const; </p> <p> void freeData();</p> <p> const size_t* objects() const;<br /> size_t objectsCount() const;</p> <p> status_t errorCheck() const;<br /> void setError(status_t err);</p> <p> status_t write(const void* data, size_t len);<br /> void* writeInplace(size_t len);<br /> status_t writeUnpadded(const void* data, size_t len);<br /> status_t writeInt32(int32_t val);<br /> status_t writeInt64(int64_t val);<br /> status_t writeFloat(float val);<br /> status_t writeDouble(double val);<br /> status_t writeIntPtr(intptr_t val);<br /> status_t writeCString(const char* str);<br /> status_t writeString8(const String8& str);<br /> status_t writeString16(const String16& str);<br /> status_t writeString16(const char16_t* str, size_t len);<br /> status_t writeStrongBinder(const sp<IBinder>& val);<br /> status_t writeWeakBinder(const wp<IBinder>& val);<br /> status_t write(const Flattenable& val);</p> <p> // Place a native_handle into the parcel (the native_handle’s file-<br /> // descriptors are dup’ed, so it is safe to delete the native_handle<br /> // when this function returns).<br /> // Doesn’t take ownership of the native_handle.<br /> status_t writeNativeHandle(const native_handle* handle);</p> <p> // Place a file descriptor into the parcel. The given fd must remain<br /> // valid for the lifetime of the parcel.<br /> status_t writeFileDescriptor(int fd);</p> <p> // Place a file descriptor into the parcel. A dup of the fd is made, which<br /> // will be closed once the parcel is destroyed.<br /> status_t writeDupFileDescriptor(int fd);</p> <p> status_t writeObject(const flat_binder_object& val, bool nullMetaData);</p> <p> void remove(size_t start, size_t amt);</p> <p> status_t read(void* outData, size_t len) const;<br /> const void* readInplace(size_t len) const;<br /> int32_t readInt32() const;<br /> status_t readInt32(int32_t *pArg) const;<br /> int64_t readInt64() const;<br /> status_t readInt64(int64_t *pArg) const;<br /> float readFloat() const;<br /> status_t readFloat(float *pArg) const;<br /> double readDouble() const;<br /> status_t readDouble(double *pArg) const;<br /> intptr_t readIntPtr() const;<br /> status_t readIntPtr(intptr_t *pArg) const;</p> <p> const char* readCString() const;<br /> String8 readString8() const;<br /> String16 readString16() const;<br /> const char16_t* readString16Inplace(size_t* outLen) const;<br /> sp<IBinder> readStrongBinder() const;<br /> wp<IBinder> readWeakBinder() const;<br /> status_t read(Flattenable& val) const;</p> <p> // Retrieve native_handle from the parcel. This returns a copy of the<br /> // parcel’s native_handle (the caller takes ownership). The caller<br /> // must free the native_handle with native_handle_close() and<br /> // native_handle_delete().<br /> native_handle* readNativeHandle() const;</p> <p> // Retrieve a file descriptor from the parcel. This returns the raw fd<br /> // in the parcel, which you do not own — use dup() to get your own copy.<br /> int readFileDescriptor() const;</p> <p> const flat_binder_object* readObject(bool nullMetaData) const;</p> <p> // Explicitly close all file descriptors in the parcel.<br /> void closeFileDescriptors();</p> <p> typedef void (*release_func)(Parcel* parcel,<br /> const uint8_t* data, size_t dataSize,<br /> const size_t* objects, size_t objectsSize,<br /> void* cookie);</p> <p> const uint8_t* ipcData() const;<br /> size_t ipcDataSize() const;<br /> const size_t* ipcObjects() const;<br /> size_t ipcObjectsCount() const;<br /> void ipcSetDataReference(const uint8_t* data, size_t dataSize,<br /> const size_t* objects, size_t objectsCount,<br /> release_func relFunc, void* relCookie);</p> <p> void print(TextOutput& to, uint32_t flags = 0) const;</p> <p>private:<br /> Parcel(const Parcel& o);<br /> Parcel& operator=(const Parcel& o);</p> <p> status_t finishWrite(size_t len);<br /> void releaseObjects();<br /> void acquireObjects();<br /> status_t growData(size_t len);<br /> status_t restartWrite(size_t desired);<br /> status_t continueWrite(size_t desired);<br /> void freeDataNoInit();<br /> void initState();<br /> void scanForFds() const;</p> <p> template<class T><br /> status_t readAligned(T *pArg) const;</p> <p> template<class T> T readAligned() const;</p> <p> template<class T><br /> status_t writeAligned(T val);</p> <p> status_t mError;<br /> uint8_t* mData;<br /> size_t mDataSize;<br /> size_t mDataCapacity;<br /> mutable size_t mDataPos;<br /> size_t* mObjects;<br /> size_t mObjectsSize;<br /> size_t mObjectsCapacity;<br /> mutable size_t mNextObjectHint;</p> <p> mutable bool mFdsKnown;<br /> mutable bool mHasFds;</p> <p> release_func mOwner;<br /> void* mOwnerCookie;<br />};</p> <p>// —————————————————————————</p> <p>inline TextOutput& operator<<(TextOutput& to, const Parcel& parcel)<br />{<br /> parcel.print(to);<br /> return to;<br />}</p> <p>// —————————————————————————</p> <p>// Generic acquire and release of objects.<br />void acquire_object(const sp<ProcessState>& proc,<br /> const flat_binder_object& obj, const void* who);<br />void release_object(const sp<ProcessState>& proc,<br /> const flat_binder_object& obj, const void* who);</p> <p>void flatten_binder(const sp<ProcessState>& proc,<br /> const sp<IBinder>& binder, flat_binder_object* out);<br />void flatten_binder(const sp<ProcessState>& proc,<br /> const wp<IBinder>& binder, flat_binder_object* out);<br />status_t unflatten_binder(const sp<ProcessState>& proc,<br /> const flat_binder_object& flat, sp<IBinder>* out);<br />status_t unflatten_binder(const sp<ProcessState>& proc,<br /> const flat_binder_object& flat, wp<IBinder>* out);</p> <p>}; // namespace android</p> <p>// —————————————————————————</p> <p>#endif // ANDROID_PARCEL_H<br />

/*<br /> * Copyright (C) 2005 The Android Open Source Project<br /> *<br /> * Licensed under the Apache License, Version 2.0 (the “License”);<br /> * you may not use this file except in compliance with the License.<br /> * You may obtain a copy of the License at<br /> *<br /> * http://www.apache.org/licenses/LICENSE-2.0<br /> *<br /> * Unless required by applicable law or agreed to in writing, software<br /> * distributed under the License is distributed on an “AS IS” BASIS,<br /> * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.<br /> * See the License for the specific language governing permissions and<br /> * limitations under the License.<br /> */</p> <p>#define LOG_TAG “Parcel”<br />//#define LOG_NDEBUG 0</p> <p>#include <binder/Parcel.h></p> <p>#include <binder/Binder.h><br />#include <binder/BpBinder.h><br />#include <utils/Debug.h><br />#include <binder/ProcessState.h><br />#include <utils/Log.h><br />#include <utils/String8.h><br />#include <utils/String16.h><br />#include <utils/TextOutput.h><br />#include <utils/misc.h><br />#include <utils/Flattenable.h></p> <p>#include <private/binder/binder_module.h></p> <p>#include <stdio.h><br />#include <stdlib.h><br />#include <stdint.h></p> <p>#ifndef INT32_MAX<br />#define INT32_MAX ((int32_t)(2147483647))<br />#endif</p> <p>#define LOG_REFS(…)<br />//#define LOG_REFS(…) LOG(LOG_DEBUG, “Parcel”, __VA_ARGS__)</p> <p>// —————————————————————————</p> <p>#define PAD_SIZE(s) (((s)+3)&~3)</p> <p>// XXX This can be made public if we want to provide<br />// support for typed data.<br />struct small_flat_data<br />{<br /> uint32_t type;<br /> uint32_t data;<br />};</p> <p>namespace android {</p> <p>void acquire_object(const sp<ProcessState>& proc,<br /> const flat_binder_object& obj, const void* who)<br />{<br /> switch (obj.type) {<br /> case BINDER_TYPE_BINDER:<br /> if (obj.binder) {<br /> LOG_REFS(“Parcel %p acquiring reference on local %p”, who, obj.cookie);<br /> static_cast<IBinder*>(obj.cookie)->incStrong(who);<br /> }<br /> return;<br /> case BINDER_TYPE_WEAK_BINDER:<br /> if (obj.binder)<br /> static_cast<RefBase::weakref_type*>(obj.binder)->incWeak(who);<br /> return;<br /> case BINDER_TYPE_HANDLE: {<br /> const sp<IBinder> b = proc->getStrongProxyForHandle(obj.handle);<br /> if (b != NULL) {<br /> LOG_REFS(“Parcel %p acquiring reference on remote %p”, who, b.get());<br /> b->incStrong(who);<br /> }<br /> return;<br /> }<br /> case BINDER_TYPE_WEAK_HANDLE: {<br /> const wp<IBinder> b = proc->getWeakProxyForHandle(obj.handle);<br /> if (b != NULL) b.get_refs()->incWeak(who);<br /> return;<br /> }<br /> case BINDER_TYPE_FD: {<br /> // intentionally blank — nothing to do to acquire this, but we do<br /> // recognize it as a legitimate object type.<br /> return;<br /> }<br /> }</p> <p> LOGD(“Invalid object type 0x%08lx”, obj.type);<br />}</p> <p>void release_object(const sp<ProcessState>& proc,<br /> const flat_binder_object& obj, const void* who)<br />{<br /> switch (obj.type) {<br /> case BINDER_TYPE_BINDER:<br /> if (obj.binder) {<br /> LOG_REFS(“Parcel %p releasing reference on local %p”, who, obj.cookie);<br /> static_cast<IBinder*>(obj.cookie)->decStrong(who);<br /> }<br /> return;<br /> case BINDER_TYPE_WEAK_BINDER:<br /> if (obj.binder)<br /> static_cast<RefBase::weakref_type*>(obj.binder)->decWeak(who);<br /> return;<br /> case BINDER_TYPE_HANDLE: {<br /> const sp<IBinder> b = proc->getStrongProxyForHandle(obj.handle);<br /> if (b != NULL) {<br /> LOG_REFS(“Parcel %p releasing reference on remote %p”, who, b.get());<br /> b->decStrong(who);<br /> }<br /> return;<br /> }<br /> case BINDER_TYPE_WEAK_HANDLE: {<br /> const wp<IBinder> b = proc->getWeakProxyForHandle(obj.handle);<br /> if (b != NULL) b.get_refs()->decWeak(who);<br /> return;<br /> }<br /> case BINDER_TYPE_FD: {<br /> if (obj.cookie != (void*)0) close(obj.handle);<br /> return;<br /> }<br /> }</p> <p> LOGE(“Invalid object type 0x%08lx”, obj.type);<br />}</p> <p>inline static status_t finish_flatten_binder(<br /> const sp<IBinder>& binder, const flat_binder_object& flat, Parcel* out)<br />{<br /> return out->writeObject(flat, false);<br />}</p> <p>status_t flatten_binder(const sp<ProcessState>& proc,<br /> const sp<IBinder>& binder, Parcel* out)<br />{<br /> flat_binder_object obj;</p> <p> obj.flags = 0x7f | FLAT_BINDER_FLAG_ACCEPTS_FDS;<br /> if (binder != NULL) {<br /> IBinder *local = binder->localBinder();<br /> if (!local) {<br /> BpBinder *proxy = binder->remoteBinder();<br /> if (proxy == NULL) {<br /> LOGE(“null proxy”);<br /> }<br /> const int32_t handle = proxy ? proxy->handle() : 0;<br /> obj.type = BINDER_TYPE_HANDLE;<br /> obj.handle = handle;<br /> obj.cookie = NULL;<br /> } else {<br /> obj.type = BINDER_TYPE_BINDER;<br /> obj.binder = local->getWeakRefs();<br /> obj.cookie = local;<br /> }<br /> } else {<br /> obj.type = BINDER_TYPE_BINDER;<br /> obj.binder = NULL;<br /> obj.cookie = NULL;<br /> }</p> <p> return finish_flatten_binder(binder, obj, out);<br />}</p> <p>status_t flatten_binder(const sp<ProcessState>& proc,<br /> const wp<IBinder>& binder, Parcel* out)<br />{<br /> flat_binder_object obj;</p> <p> obj.flags = 0x7f | FLAT_BINDER_FLAG_ACCEPTS_FDS;<br /> if (binder != NULL) {<br /> sp<IBinder> real = binder.promote();<br /> if (real != NULL) {<br /> IBinder *local = real->localBinder();<br /> if (!local) {<br /> BpBinder *proxy = real->remoteBinder();<br /> if (proxy == NULL) {<br /> LOGE(“null proxy”);<br /> }<br /> const int32_t handle = proxy ? proxy->handle() : 0;<br /> obj.type = BINDER_TYPE_WEAK_HANDLE;<br /> obj.handle = handle;<br /> obj.cookie = NULL;<br /> } else {<br /> obj.type = BINDER_TYPE_WEAK_BINDER;<br /> obj.binder = binder.get_refs();<br /> obj.cookie = binder.unsafe_get();<br /> }<br /> return finish_flatten_binder(real, obj, out);<br /> }</p> <p> // XXX How to deal? In order to flatten the given binder,<br /> // we need to probe it for information, which requires a primary<br /> // reference… but we don’t have one.<br /> //<br /> // The OpenBinder implementation uses a dynamic_cast<> here,<br /> // but we can’t do that with the different reference counting<br /> // implementation we are using.<br /> LOGE(“Unable to unflatten Binder weak reference!”);<br /> obj.type = BINDER_TYPE_BINDER;<br /> obj.binder = NULL;<br /> obj.cookie = NULL;<br /> return finish_flatten_binder(NULL, obj, out);</p> <p> } else {<br /> obj.type = BINDER_TYPE_BINDER;<br /> obj.binder = NULL;<br /> obj.cookie = NULL;<br /> return finish_flatten_binder(NULL, obj, out);<br /> }<br />}</p> <p>inline static status_t finish_unflatten_binder(<br /> BpBinder* proxy, const flat_binder_object& flat, const Parcel& in)<br />{<br /> return NO_ERROR;<br />}</p> <p>status_t unflatten_binder(const sp<ProcessState>& proc,<br /> const Parcel& in, sp<IBinder>* out)<br />{<br /> const flat_binder_object* flat = in.readObject(false);</p> <p> if (flat) {<br /> switch (flat->type) {<br /> case BINDER_TYPE_BINDER:<br /> *out = static_cast<IBinder*>(flat->cookie);<br /> return finish_unflatten_binder(NULL, *flat, in);<br /> case BINDER_TYPE_HANDLE:<br /> *out = proc->getStrongProxyForHandle(flat->handle);<br /> return finish_unflatten_binder(<br /> static_cast<BpBinder*>(out->get()), *flat, in);<br /> }<br /> }<br /> return BAD_TYPE;<br />}</p> <p>status_t unflatten_binder(const sp<ProcessState>& proc,<br /> const Parcel& in, wp<IBinder>* out)<br />{<br /> const flat_binder_object* flat = in.readObject(false);</p> <p> if (flat) {<br /> switch (flat->type) {<br /> case BINDER_TYPE_BINDER:<br /> *out = static_cast<IBinder*>(flat->cookie);<br /> return finish_unflatten_binder(NULL, *flat, in);<br /> case BINDER_TYPE_WEAK_BINDER:<br /> if (flat->binder != NULL) {<br /> out->set_object_and_refs(<br /> static_cast<IBinder*>(flat->cookie),<br /> static_cast<RefBase::weakref_type*>(flat->binder));<br /> } else {<br /> *out = NULL;<br /> }<br /> return finish_unflatten_binder(NULL, *flat, in);<br /> case BINDER_TYPE_HANDLE:<br /> case BINDER_TYPE_WEAK_HANDLE:<br /> *out = proc->getWeakProxyForHandle(flat->handle);<br /> return finish_unflatten_binder(<br /> static_cast<BpBinder*>(out->unsafe_get()), *flat, in);<br /> }<br /> }<br /> return BAD_TYPE;<br />}</p> <p>// —————————————————————————</p> <p>Parcel::Parcel()<br />{<br /> initState();<br />}</p> <p>Parcel::~Parcel()<br />{<br /> freeDataNoInit();<br />}</p> <p>const uint8_t* Parcel::data() const<br />{<br /> return mData;<br />}</p> <p>size_t Parcel::dataSize() const<br />{<br /> return (mDataSize > mDataPos ? mDataSize : mDataPos);<br />}</p> <p>size_t Parcel::dataAvail() const<br />{<br /> // TODO: decide what to do about the possibility that this can<br /> // report an available-data size that exceeds a Java int’s max<br /> // positive value, causing havoc. Fortunately this will only<br /> // happen if someone constructs a Parcel containing more than two<br /> // gigabytes of data, which on typical phone hardware is simply<br /> // not possible.<br /> return dataSize() – dataPosition();<br />}</p> <p>size_t Parcel::dataPosition() const<br />{<br /> return mDataPos;<br />}</p> <p>size_t Parcel::dataCapacity() const<br />{<br /> return mDataCapacity;<br />}</p> <p>status_t Parcel::setDataSize(size_t size)<br />{<br /> status_t err;<br /> err = continueWrite(size);<br /> if (err == NO_ERROR) {<br /> mDataSize = size;<br /> LOGV(“setDataSize Setting data size of %p to %d/n”, this, mDataSize);<br /> }<br /> return err;<br />}</p> <p>void Parcel::setDataPosition(size_t pos) const<br />{<br /> mDataPos = pos;<br /> mNextObjectHint = 0;<br />}</p> <p>status_t Parcel::setDataCapacity(size_t size)<br />{<br /> if (size > mDataSize) return continueWrite(size);<br /> return NO_ERROR;<br />}</p> <p>status_t Parcel::setData(const uint8_t* buffer, size_t len)<br />{<br /> status_t err = restartWrite(len);<br /> if (err == NO_ERROR) {<br /> memcpy(const_cast<uint8_t*>(data()), buffer, len);<br /> mDataSize = len;<br /> mFdsKnown = false;<br /> }<br /> return err;<br />}</p> <p>status_t Parcel::appendFrom(Parcel *parcel, size_t offset, size_t len)<br />{<br /> const sp<ProcessState> proc(ProcessState::self());<br /> status_t err;<br /> uint8_t *data = parcel->mData;<br /> size_t *objects = parcel->mObjects;<br /> size_t size = parcel->mObjectsSize;<br /> int startPos = mDataPos;<br /> int firstIndex = -1, lastIndex = -2;</p> <p> if (len == 0) {<br /> return NO_ERROR;<br /> }</p> <p> // range checks against the source parcel size<br /> if ((offset > parcel->mDataSize)<br /> || (len > parcel->mDataSize)<br /> || (offset + len > parcel->mDataSize)) {<br /> return BAD_VALUE;<br /> }</p> <p> // Count objects in range<br /> for (int i = 0; i < (int) size; i++) {<br /> size_t off = objects[i];<br /> if ((off >= offset) && (off < offset + len)) {<br /> if (firstIndex == -1) {<br /> firstIndex = i;<br /> }<br /> lastIndex = i;<br /> }<br /> }<br /> int numObjects = lastIndex – firstIndex + 1;</p> <p> // grow data<br /> err = growData(len);<br /> if (err != NO_ERROR) {<br /> return err;<br /> }</p> <p> // append data<br /> memcpy(mData + mDataPos, data + offset, len);<br /> mDataPos += len;<br /> mDataSize += len;</p> <p> if (numObjects > 0) {<br /> // grow objects<br /> if (mObjectsCapacity < mObjectsSize + numObjects) {<br /> int newSize = ((mObjectsSize + numObjects)*3)/2;<br /> size_t *objects =<br /> (size_t*)realloc(mObjects, newSize*sizeof(size_t));<br /> if (objects == (size_t*)0) {<br /> return NO_MEMORY;<br /> }<br /> mObjects = objects;<br /> mObjectsCapacity = newSize;<br /> }</p> <p> // append and acquire objects<br /> int idx = mObjectsSize;<br /> for (int i = firstIndex; i <= lastIndex; i++) {<br /> size_t off = objects[i] – offset + startPos;<br /> mObjects[idx++] = off;<br /> mObjectsSize++;</p> <p> flat_binder_object* flat<br /> = reinterpret_cast<flat_binder_object*>(mData + off);<br /> acquire_object(proc, *flat, this);</p> <p> if (flat->type == BINDER_TYPE_FD) {<br /> // If this is a file descriptor, we need to dup it so the<br /> // new Parcel now owns its own fd, and can declare that we<br /> // officially know we have fds.<br /> flat->handle = dup(flat->handle);<br /> flat->cookie = (void*)1;<br /> mHasFds = mFdsKnown = true;<br /> }<br /> }<br /> }</p> <p> return NO_ERROR;<br />}</p> <p>bool Parcel::hasFileDescriptors() const<br />{<br /> if (!mFdsKnown) {<br /> scanForFds();<br /> }<br /> return mHasFds;<br />}</p> <p>status_t Parcel::writeInterfaceToken(const String16& interface)<br />{<br /> // currently the interface identification token is just its name as a string<br /> return writeString16(interface);<br />}</p> <p>bool Parcel::checkInterface(IBinder* binder) const<br />{<br /> return enforceInterface(binder->getInterfaceDescriptor());<br />}</p> <p>bool Parcel::enforceInterface(const String16& interface) const<br />{<br /> const String16 str(readString16());<br /> if (str == interface) {<br /> return true;<br /> } else {<br /> LOGW(“**** enforceInterface() expected ‘%s’ but read ‘%s’/n”,<br /> String8(interface).string(), String8(str).string());<br /> return false;<br /> }<br />} </p> <p>const size_t* Parcel::objects() const<br />{<br /> return mObjects;<br />}</p> <p>size_t Parcel::objectsCount() const<br />{<br /> return mObjectsSize;<br />}</p> <p>status_t Parcel::errorCheck() const<br />{<br /> return mError;<br />}</p> <p>void Parcel::setError(status_t err)<br />{<br /> mError = err;<br />}</p> <p>status_t Parcel::finishWrite(size_t len)<br />{<br /> //printf(“Finish write of %d/n”, len);<br /> mDataPos += len;<br /> LOGV(“finishWrite Setting data pos of %p to %d/n”, this, mDataPos);<br /> if (mDataPos > mDataSize) {<br /> mDataSize = mDataPos;<br /> LOGV(“finishWrite Setting data size of %p to %d/n”, this, mDataSize);<br /> }<br /> //printf(“New pos=%d, size=%d/n”, mDataPos, mDataSize);<br /> return NO_ERROR;<br />}</p> <p>status_t Parcel::writeUnpadded(const void* data, size_t len)<br />{<br /> size_t end = mDataPos + len;<br /> if (end < mDataPos) {<br /> // integer overflow<br /> return BAD_VALUE;<br /> }</p> <p> if (end <= mDataCapacity) {<br />restart_write:<br /> memcpy(mData+mDataPos, data, len);<br /> return finishWrite(len);<br /> }</p> <p> status_t err = growData(len);<br /> if (err == NO_ERROR) goto restart_write;<br /> return err;<br />}</p> <p>status_t Parcel::write(const void* data, size_t len)<br />{<br /> void* const d = writeInplace(len);<br /> if (d) {<br /> memcpy(d, data, len);<br /> return NO_ERROR;<br /> }<br /> return mError;<br />}</p> <p>void* Parcel::writeInplace(size_t len)<br />{<br /> const size_t padded = PAD_SIZE(len);</p> <p> // sanity check for integer overflow<br /> if (mDataPos+padded < mDataPos) {<br /> return NULL;<br /> }</p> <p> if ((mDataPos+padded) <= mDataCapacity) {<br />restart_write:<br /> //printf(“Writing %ld bytes, padded to %ld/n”, len, padded);<br /> uint8_t* const data = mData+mDataPos;</p> <p> // Need to pad at end?<br /> if (padded != len) {<br />#if BYTE_ORDER == BIG_ENDIAN<br /> static const uint32_t mask[4] = {<br /> 0x00000000, 0xffffff00, 0xffff0000, 0xff000000<br /> };<br />#endif<br />#if BYTE_ORDER == LITTLE_ENDIAN<br /> static const uint32_t mask[4] = {<br /> 0x00000000, 0x00ffffff, 0x0000ffff, 0x000000ff<br /> };<br />#endif<br /> //printf(“Applying pad mask: %p to %p/n”, (void*)mask[padded-len],<br /> // *reinterpret_cast<void**>(data+padded-4));<br /> *reinterpret_cast<uint32_t*>(data+padded-4) &= mask[padded-len];<br /> }</p> <p> finishWrite(padded);<br /> return data;<br /> }</p> <p> status_t err = growData(padded);<br /> if (err == NO_ERROR) goto restart_write;<br /> return NULL;<br />}</p> <p>status_t Parcel::writeInt32(int32_t val)<br />{<br /> return writeAligned(val);<br />}</p> <p>status_t Parcel::writeInt64(int64_t val)<br />{<br /> return writeAligned(val);<br />}</p> <p>status_t Parcel::writeFloat(float val)<br />{<br /> return writeAligned(val);<br />}</p> <p>status_t Parcel::writeDouble(double val)<br />{<br /> return writeAligned(val);<br />}</p> <p>status_t Parcel::writeIntPtr(intptr_t val)<br />{<br /> return writeAligned(val);<br />}</p> <p>status_t Parcel::writeCString(const char* str)<br />{<br /> return write(str, strlen(str)+1);<br />}</p> <p>status_t Parcel::writeString8(const String8& str)<br />{<br /> status_t err = writeInt32(str.bytes());<br /> if (err == NO_ERROR) {<br /> err = write(str.string(), str.bytes()+1);<br /> }<br /> return err;<br />}</p> <p>status_t Parcel::writeString16(const String16& str)<br />{<br /> return writeString16(str.string(), str.size());<br />}</p> <p>status_t Parcel::writeString16(const char16_t* str, size_t len)<br />{<br /> if (str == NULL) return writeInt32(-1);</p> <p> status_t err = writeInt32(len);<br /> if (err == NO_ERROR) {<br /> len *= sizeof(char16_t);<br /> uint8_t* data = (uint8_t*)writeInplace(len+sizeof(char16_t));<br /> if (data) {<br /> memcpy(data, str, len);<br /> *reinterpret_cast<char16_t*>(data+len) = 0;<br /> return NO_ERROR;<br /> }<br /> err = mError;<br /> }<br /> return err;<br />}</p> <p>status_t Parcel::writeStrongBinder(const sp<IBinder>& val)<br />{<br /> return flatten_binder(ProcessState::self(), val, this);<br />}</p> <p>status_t Parcel::writeWeakBinder(const wp<IBinder>& val)<br />{<br /> return flatten_binder(ProcessState::self(), val, this);<br />}</p> <p>status_t Parcel::writeNativeHandle(const native_handle* handle)<br />{<br /> if (!handle || handle->version != sizeof(native_handle))<br /> return BAD_TYPE;</p> <p> status_t err;<br /> err = writeInt32(handle->numFds);<br /> if (err != NO_ERROR) return err;</p> <p> err = writeInt32(handle->numInts);<br /> if (err != NO_ERROR) return err;</p> <p> for (int i=0 ; err==NO_ERROR && i<handle->numFds ; i++)<br /> err = writeDupFileDescriptor(handle->data[i]);</p> <p> if (err != NO_ERROR) {<br /> LOGD(“write native handle, write dup fd failed”);<br /> return err;<br /> }<br /> err = write(handle->data + handle->numFds, sizeof(int)*handle->numInts);<br /> return err;<br />}</p> <p>status_t Parcel::writeFileDescriptor(int fd)<br />{<br /> flat_binder_object obj;<br /> obj.type = BINDER_TYPE_FD;<br /> obj.flags = 0x7f | FLAT_BINDER_FLAG_ACCEPTS_FDS;<br /> obj.handle = fd;<br /> obj.cookie = (void*)0;<br /> return writeObject(obj, true);<br />}</p> <p>status_t Parcel::writeDupFileDescriptor(int fd)<br />{<br /> flat_binder_object obj;<br /> obj.type = BINDER_TYPE_FD;<br /> obj.flags = 0x7f | FLAT_BINDER_FLAG_ACCEPTS_FDS;<br /> obj.handle = dup(fd);<br /> obj.cookie = (void*)1;<br /> return writeObject(obj, true);<br />}</p> <p>status_t Parcel::write(const Flattenable& val)<br />{<br /> status_t err;</p> <p> // size if needed<br /> size_t len = val.getFlattenedSize();<br /> size_t fd_count = val.getFdCount();</p> <p> err = this->writeInt32(len);<br /> if (err) return err;</p> <p> err = this->writeInt32(fd_count);<br /> if (err) return err;</p> <p> // payload<br /> void* buf = this->writeInplace(PAD_SIZE(len));<br /> if (buf == NULL)<br /> return BAD_VALUE;</p> <p> int* fds = NULL;<br /> if (fd_count) {<br /> fds = new int[fd_count];<br /> }</p> <p> err = val.flatten(buf, len, fds, fd_count);<br /> for (size_t i=0 ; i<fd_count && err==NO_ERROR ; i++) {<br /> err = this->writeDupFileDescriptor( fds[i] );<br /> }</p> <p> if (fd_count) {<br /> delete [] fds;<br /> }</p> <p> return err;<br />}</p> <p>status_t Parcel::writeObject(const flat_binder_object& val, bool nullMetaData)<br />{<br /> const bool enoughData = (mDataPos+sizeof(val)) <= mDataCapacity;<br /> const bool enoughObjects = mObjectsSize < mObjectsCapacity;<br /> if (enoughData && enoughObjects) {<br />restart_write:<br /> *reinterpret_cast<flat_binder_object*>(mData+mDataPos) = val;</p> <p> // Need to write meta-data?<br /> if (nullMetaData || val.binder != NULL) {<br /> mObjects[mObjectsSize] = mDataPos;<br /> acquire_object(ProcessState::self(), val, this);<br /> mObjectsSize++;<br /> }</p> <p> // remember if it’s a file descriptor<br /> if (val.type == BINDER_TYPE_FD) {<br /> mHasFds = mFdsKnown = true;<br /> }</p> <p> return finishWrite(sizeof(flat_binder_object));<br /> }</p> <p> if (!enoughData) {<br /> const status_t err = growData(sizeof(val));<br /> if (err != NO_ERROR) return err;<br /> }<br /> if (!enoughObjects) {<br /> size_t newSize = ((mObjectsSize+2)*3)/2;<br /> size_t* objects = (size_t*)realloc(mObjects, newSize*sizeof(size_t));<br /> if (objects == NULL) return NO_MEMORY;<br /> mObjects = objects;<br /> mObjectsCapacity = newSize;<br /> }</p> <p> goto restart_write;<br />}</p> <p>void Parcel::remove(size_t start, size_t amt)<br />{<br /> LOG_ALWAYS_FATAL(“Parcel::remove() not yet implemented!”);<br />}</p> <p>status_t Parcel::read(void* outData, size_t len) const<br />{<br /> if ((mDataPos+PAD_SIZE(len)) >= mDataPos && (mDataPos+PAD_SIZE(len)) <= mDataSize) {<br /> memcpy(outData, mData+mDataPos, len);<br /> mDataPos += PAD_SIZE(len);<br /> LOGV(“read Setting data pos of %p to %d/n”, this, mDataPos);<br /> return NO_ERROR;<br /> }<br /> return NOT_ENOUGH_DATA;<br />}</p> <p>const void* Parcel::readInplace(size_t len) const<br />{<br /> if ((mDataPos+PAD_SIZE(len)) >= mDataPos && (mDataPos+PAD_SIZE(len)) <= mDataSize) {<br /> const void* data = mData+mDataPos;<br /> mDataPos += PAD_SIZE(len);<br /> LOGV(“readInplace Setting data pos of %p to %d/n”, this, mDataPos);<br /> return data;<br /> }<br /> return NULL;<br />}</p> <p>template<class T><br />status_t Parcel::readAligned(T *pArg) const {<br /> COMPILE_TIME_ASSERT_FUNCTION_SCOPE(PAD_SIZE(sizeof(T)) == sizeof(T));</p> <p> if ((mDataPos+sizeof(T)) <= mDataSize) {<br /> const void* data = mData+mDataPos;<br /> mDataPos += sizeof(T);<br /> *pArg = *reinterpret_cast<const T*>(data);<br /> return NO_ERROR;<br /> } else {<br /> return NOT_ENOUGH_DATA;<br /> }<br />}</p> <p>template<class T><br />T Parcel::readAligned() const {<br /> T result;<br /> if (readAligned(&result) != NO_ERROR) {<br /> result = 0;<br /> }</p> <p> return result;<br />}</p> <p>template<class T><br />status_t Parcel::writeAligned(T val) {<br /> COMPILE_TIME_ASSERT_FUNCTION_SCOPE(PAD_SIZE(sizeof(T)) == sizeof(T));</p> <p> if ((mDataPos+sizeof(val)) <= mDataCapacity) {<br />restart_write:<br /> *reinterpret_cast<T*>(mData+mDataPos) = val;<br /> return finishWrite(sizeof(val));<br /> }</p> <p> status_t err = growData(sizeof(val));<br /> if (err == NO_ERROR) goto restart_write;<br /> return err;<br />}</p> <p>status_t Parcel::readInt32(int32_t *pArg) const<br />{<br /> return readAligned(pArg);<br />}</p> <p>int32_t Parcel::readInt32() const<br />{<br /> return readAligned<int32_t>();<br />}</p> <p>status_t Parcel::readInt64(int64_t *pArg) const<br />{<br /> return readAligned(pArg);<br />}</p> <p>int64_t Parcel::readInt64() const<br />{<br /> return readAligned<int64_t>();<br />}</p> <p>status_t Parcel::readFloat(float *pArg) const<br />{<br /> return readAligned(pArg);<br />}</p> <p>float Parcel::readFloat() const<br />{<br /> return readAligned<float>();<br />}</p> <p>status_t Parcel::readDouble(double *pArg) const<br />{<br /> return readAligned(pArg);<br />}</p> <p>double Parcel::readDouble() const<br />{<br /> return readAligned<double>();<br />}</p> <p>status_t Parcel::readIntPtr(intptr_t *pArg) const<br />{<br /> return readAligned(pArg);<br />}</p> <p>intptr_t Parcel::readIntPtr() const<br />{<br /> return readAligned<intptr_t>();<br />}</p> <p>const char* Parcel::readCString() const<br />{<br /> const size_t avail = mDataSize-mDataPos;<br /> if (avail > 0) {<br /> const char* str = reinterpret_cast<const char*>(mData+mDataPos);<br /> // is the string’s trailing NUL within the parcel’s valid bounds?<br /> const char* eos = reinterpret_cast<const char*>(memchr(str, 0, avail));<br /> if (eos) {<br /> const size_t len = eos – str;<br /> mDataPos += PAD_SIZE(len+1);<br /> LOGV(“readCString Setting data pos of %p to %d/n”, this, mDataPos);<br /> return str;<br /> }<br /> }<br /> return NULL;<br />}</p> <p>String8 Parcel::readString8() const<br />{<br /> int32_t size = readInt32();<br /> // watch for potential int overflow adding 1 for trailing NUL<br /> if (size > 0 && size < INT32_MAX) {<br /> const char* str = (const char*)readInplace(size+1);<br /> if (str) return String8(str, size);<br /> }<br /> return String8();<br />}</p> <p>String16 Parcel::readString16() const<br />{<br /> size_t len;<br /> const char16_t* str = readString16Inplace(&len);<br /> if (str) return String16(str, len);<br /> LOGE(“Reading a NULL string not supported here.”);<br /> return String16();<br />}</p> <p>const char16_t* Parcel::readString16Inplace(size_t* outLen) const<br />{<br /> int32_t size = readInt32();<br /> // watch for potential int overflow from size+1<br /> if (size >= 0 && size < INT32_MAX) {<br /> *outLen = size;<br /> const char16_t* str = (const char16_t*)readInplace((size+1)*sizeof(char16_t));<br /> if (str != NULL) {<br /> return str;<br /> }<br /> }<br /> *outLen = 0;<br /> return NULL;<br />}</p> <p>sp<IBinder> Parcel::readStrongBinder() const<br />{<br /> sp<IBinder> val;<br /> unflatten_binder(ProcessState::self(), *this, &val);<br /> return val;<br />}</p> <p>wp<IBinder> Parcel::readWeakBinder() const<br />{<br /> wp<IBinder> val;<br /> unflatten_binder(ProcessState::self(), *this, &val);<br /> return val;<br />}</p> <p>native_handle* Parcel::readNativeHandle() const<br />{<br /> int numFds, numInts;<br /> status_t err;<br /> err = readInt32(&numFds);<br /> if (err != NO_ERROR) return 0;<br /> err = readInt32(&numInts);<br /> if (err != NO_ERROR) return 0;</p> <p> native_handle* h = native_handle_create(numFds, numInts);<br /> for (int i=0 ; err==NO_ERROR && i<numFds ; i++) {<br /> h->data[i] = dup(readFileDescriptor());<br /> if (h->data[i] < 0) err = BAD_VALUE;<br /> }<br /> err = read(h->data + numFds, sizeof(int)*numInts);<br /> if (err != NO_ERROR) {<br /> native_handle_close(h);<br /> native_handle_delete(h);<br /> h = 0;<br /> }<br /> return h;<br />}</p> <p>int Parcel::readFileDescriptor() const<br />{<br /> const flat_binder_object* flat = readObject(true);<br /> if (flat) {<br /> switch (flat->type) {<br /> case BINDER_TYPE_FD:<br /> //LOGI(“Returning file descriptor %ld from parcel %p/n”, flat->handle, this);<br /> return flat->handle;<br /> }<br /> }<br /> return BAD_TYPE;<br />}</p> <p>status_t Parcel::read(Flattenable& val) const<br />{<br /> // size<br /> const size_t len = this->readInt32();<br /> const size_t fd_count = this->readInt32();</p> <p> // payload<br /> void const* buf = this->readInplace(PAD_SIZE(len));<br /> if (buf == NULL)<br /> return BAD_VALUE;</p> <p> int* fds = NULL;<br /> if (fd_count) {<br /> fds = new int[fd_count];<br /> }</p> <p> status_t err = NO_ERROR;<br /> for (size_t i=0 ; i<fd_count && err==NO_ERROR ; i++) {<br /> fds[i] = dup(this->readFileDescriptor());<br /> if (fds[i] < 0) err = BAD_VALUE;<br /> }</p> <p> if (err == NO_ERROR) {<br /> err = val.unflatten(buf, len, fds, fd_count);<br /> }</p> <p> if (fd_count) {<br /> delete [] fds;<br /> }</p> <p> return err;<br />}<br />const flat_binder_object* Parcel::readObject(bool nullMetaData) const<br />{<br /> const size_t DPOS = mDataPos;<br /> if ((DPOS+sizeof(flat_binder_object)) <= mDataSize) {<br /> const flat_binder_object* obj<br /> = reinterpret_cast<const flat_binder_object*>(mData+DPOS);<br /> mDataPos = DPOS + sizeof(flat_binder_object);<br /> if (!nullMetaData && (obj->cookie == NULL && obj->binder == NULL)) {<br /> // When transferring a NULL object, we don’t write it into<br /> // the object list, so we don’t want to check for it when<br /> // reading.<br /> LOGV(“readObject Setting data pos of %p to %d/n”, this, mDataPos);<br /> return obj;<br /> }</p> <p> // Ensure that this object is valid…<br /> size_t* const OBJS = mObjects;<br /> const size_t N = mObjectsSize;<br /> size_t opos = mNextObjectHint;</p> <p> if (N > 0) {<br /> LOGV(“Parcel %p looking for obj at %d, hint=%d/n”,<br /> this, DPOS, opos);</p> <p> // Start at the current hint position, looking for an object at<br /> // the current data position.<br /> if (opos < N) {<br /> while (opos < (N-1) && OBJS[opos] < DPOS) {<br /> opos++;<br /> }<br /> } else {<br /> opos = N-1;<br /> }<br /> if (OBJS[opos] == DPOS) {<br /> // Found it!<br /> LOGV(“Parcel found obj %d at index %d with forward search”,<br /> this, DPOS, opos);<br /> mNextObjectHint = opos+1;<br /> LOGV(“readObject Setting data pos of %p to %d/n”, this, mDataPos);<br /> return obj;<br /> }</p> <p> // Look backwards for it…<br /> while (opos > 0 && OBJS[opos] > DPOS) {<br /> opos–;<br /> }<br /> if (OBJS[opos] == DPOS) {<br /> // Found it!<br /> LOGV(“Parcel found obj %d at index %d with backward search”,<br /> this, DPOS, opos);<br /> mNextObjectHint = opos+1;<br /> LOGV(“readObject Setting data pos of %p to %d/n”, this, mDataPos);<br /> return obj;<br /> }<br /> }<br /> LOGW(“Attempt to read object from Parcel %p at offset %d that is not in the object list”,<br /> this, DPOS);<br /> }<br /> return NULL;<br />}</p> <p>void Parcel::closeFileDescriptors()<br />{<br /> size_t i = mObjectsSize;<br /> if (i > 0) {<br /> //LOGI(“Closing file descriptors for %d objects…”, mObjectsSize);<br /> }<br /> while (i > 0) {<br /> i–;<br /> const flat_binder_object* flat<br /> = reinterpret_cast<flat_binder_object*>(mData+mObjects[i]);<br /> if (flat->type == BINDER_TYPE_FD) {<br /> //LOGI(“Closing fd: %ld/n”, flat->handle);<br /> close(flat->handle);<br /> }<br /> }<br />}</p> <p>const uint8_t* Parcel::ipcData() const<br />{<br /> return mData;<br />}</p> <p>size_t Parcel::ipcDataSize() const<br />{<br /> return (mDataSize > mDataPos ? mDataSize : mDataPos);<br />}</p> <p>const size_t* Parcel::ipcObjects() const<br />{<br /> return mObjects;<br />}</p> <p>size_t Parcel::ipcObjectsCount() const<br />{<br /> return mObjectsSize;<br />}</p> <p>void Parcel::ipcSetDataReference(const uint8_t* data, size_t dataSize,<br /> const size_t* objects, size_t objectsCount, release_func relFunc, void* relCookie)<br />{<br /> freeDataNoInit();<br /> mError = NO_ERROR;<br /> mData = const_cast<uint8_t*>(data);<br /> mDataSize = mDataCapacity = dataSize;<br /> //LOGI(“setDataReference Setting data size of %p to %lu (pid=%d)/n”, this, mDataSize, getpid());<br /> mDataPos = 0;<br /> LOGV(“setDataReference Setting data pos of %p to %d/n”, this, mDataPos);<br /> mObjects = const_cast<size_t*>(objects);<br /> mObjectsSize = mObjectsCapacity = objectsCount;<br /> mNextObjectHint = 0;<br /> mOwner = relFunc;<br /> mOwnerCookie = relCookie;<br /> scanForFds();<br />}</p> <p>void Parcel::print(TextOutput& to, uint32_t flags) const<br />{<br /> to << “Parcel(“;</p> <p> if (errorCheck() != NO_ERROR) {<br /> const status_t err = errorCheck();<br /> to << “Error: ” << (void*)err << ” /”” << strerror(-err) << “/””;<br /> } else if (dataSize() > 0) {<br /> const uint8_t* DATA = data();<br /> to << indent << HexDump(DATA, dataSize()) << dedent;<br /> const size_t* OBJS = objects();<br /> const size_t N = objectsCount();<br /> for (size_t i=0; i<N; i++) {<br /> const flat_binder_object* flat<br /> = reinterpret_cast<const flat_binder_object*>(DATA+OBJS[i]);<br /> to << endl << “Object #” << i << ” @ ” << (void*)OBJS[i] << “: ”<br /> << TypeCode(flat->type & 0x7f7f7f00)<br /> << ” = ” << flat->binder;<br /> }<br /> } else {<br /> to << “NULL”;<br /> }</p> <p> to << “)”;<br />}</p> <p>void Parcel::releaseObjects()<br />{<br /> const sp<ProcessState> proc(ProcessState::self());<br /> size_t i = mObjectsSize;<br /> uint8_t* const data = mData;<br /> size_t* const objects = mObjects;<br /> while (i > 0) {<br /> i–;<br /> const flat_binder_object* flat<br /> = reinterpret_cast<flat_binder_object*>(data+objects[i]);<br /> release_object(proc, *flat, this);<br /> }<br />}</p> <p>void Parcel::acquireObjects()<br />{<br /> const sp<ProcessState> proc(ProcessState::self());<br /> size_t i = mObjectsSize;<br /> uint8_t* const data = mData;<br /> size_t* const objects = mObjects;<br /> while (i > 0) {<br /> i–;<br /> const flat_binder_object* flat<br /> = reinterpret_cast<flat_binder_object*>(data+objects[i]);<br /> acquire_object(proc, *flat, this);<br /> }<br />}</p> <p>void Parcel::freeData()<br />{<br /> freeDataNoInit();<br /> initState();<br />}</p> <p>void Parcel::freeDataNoInit()<br />{<br /> if (mOwner) {<br /> //LOGI(“Freeing data ref of %p (pid=%d)/n”, this, getpid());<br /> mOwner(this, mData, mDataSize, mObjects, mObjectsSize, mOwnerCookie);<br /> } else {<br /> releaseObjects();<br /> if (mData) free(mData);<br /> if (mObjects) free(mObjects);<br /> }<br />}</p> <p>status_t Parcel::growData(size_t len)<br />{<br /> size_t newSize = ((mDataSize+len)*3)/2;<br /> return (newSize <= mDataSize)<br /> ? (status_t) NO_MEMORY<br /> : continueWrite(newSize);<br />}</p> <p>status_t Parcel::restartWrite(size_t desired)<br />{<br /> if (mOwner) {<br /> freeData();<br /> return continueWrite(desired);<br /> }</p> <p> uint8_t* data = (uint8_t*)realloc(mData, desired);<br /> if (!data && desired > mDataCapacity) {<br /> mError = NO_MEMORY;<br /> return NO_MEMORY;<br /> }</p> <p> releaseObjects();</p> <p> if (data) {<br /> mData = data;<br /> mDataCapacity = desired;<br /> }</p> <p> mDataSize = mDataPos = 0;<br /> LOGV(“restartWrite Setting data size of %p to %d/n”, this, mDataSize);<br /> LOGV(“restartWrite Setting data pos of %p to %d/n”, this, mDataPos);</p> <p> free(mObjects);<br /> mObjects = NULL;<br /> mObjectsSize = mObjectsCapacity = 0;<br /> mNextObjectHint = 0;<br /> mHasFds = false;<br /> mFdsKnown = true;</p> <p> return NO_ERROR;<br />}</p> <p>status_t Parcel::continueWrite(size_t desired)<br />{<br /> // If shrinking, first adjust for any objects that appear<br /> // after the new data size.<br /> size_t objectsSize = mObjectsSize;<br /> if (desired < mDataSize) {<br /> if (desired == 0) {<br /> objectsSize = 0;<br /> } else {<br /> while (objectsSize > 0) {<br /> if (mObjects[objectsSize-1] < desired)<br /> break;<br /> objectsSize–;<br /> }<br /> }<br /> }</p> <p> if (mOwner) {<br /> // If the size is going to zero, just release the owner’s data.<br /> if (desired == 0) {<br /> freeData();<br /> return NO_ERROR;<br /> }</p> <p> // If there is a different owner, we need to take<br /> // posession.<br /> uint8_t* data = (uint8_t*)malloc(desired);<br /> if (!data) {<br /> mError = NO_MEMORY;<br /> return NO_MEMORY;<br /> }<br /> size_t* objects = NULL;</p> <p> if (objectsSize) {<br /> objects = (size_t*)malloc(objectsSize*sizeof(size_t));<br /> if (!objects) {<br /> mError = NO_MEMORY;<br /> return NO_MEMORY;<br /> }</p> <p> // Little hack to only acquire references on objects<br /> // we will be keeping.<br /> size_t oldObjectsSize = mObjectsSize;<br /> mObjectsSize = objectsSize;<br /> acquireObjects();<br /> mObjectsSize = oldObjectsSize;<br /> }</p> <p> if (mData) {<br /> memcpy(data, mData, mDataSize < desired ? mDataSize : desired);<br /> }<br /> if (objects && mObjects) {<br /> memcpy(objects, mObjects, objectsSize*sizeof(size_t));<br /> }<br /> //LOGI(“Freeing data ref of %p (pid=%d)/n”, this, getpid());<br /> mOwner(this, mData, mDataSize, mObjects, mObjectsSize, mOwnerCookie);<br /> mOwner = NULL;</p> <p> mData = data;<br /> mObjects = objects;<br /> mDataSize = (mDataSize < desired) ? mDataSize : desired;<br /> LOGV(“continueWrite Setting data size of %p to %d/n”, this, mDataSize);<br /> mDataCapacity = desired;<br /> mObjectsSize = mObjectsCapacity = objectsSize;<br /> mNextObjectHint = 0;</p> <p> } else if (mData) {<br /> if (objectsSize < mObjectsSize) {<br /> // Need to release refs on any objects we are dropping.<br /> const sp<ProcessState> proc(ProcessState::self());<br /> for (size_t i=objectsSize; i<mObjectsSize; i++) {<br /> const flat_binder_object* flat<br /> = reinterpret_cast<flat_binder_object*>(mData+mObjects[i]);<br /> if (flat->type == BINDER_TYPE_FD) {<br /> // will need to rescan because we may have lopped off the only FDs<br /> mFdsKnown = false;<br /> }<br /> release_object(proc, *flat, this);<br /> }<br /> size_t* objects =<br /> (size_t*)realloc(mObjects, objectsSize*sizeof(size_t));<br /> if (objects) {<br /> mObjects = objects;<br /> }<br /> mObjectsSize = objectsSize;<br /> mNextObjectHint = 0;<br /> }</p> <p> // We own the data, so we can just do a realloc().<br /> if (desired > mDataCapacity) {<br /> uint8_t* data = (uint8_t*)realloc(mData, desired);<br /> if (data) {<br /> mData = data;<br /> mDataCapacity = desired;<br /> } else if (desired > mDataCapacity) {<br /> mError = NO_MEMORY;<br /> return NO_MEMORY;<br /> }<br /> } else {<br /> mDataSize = desired;<br /> LOGV(“continueWrite Setting data size of %p to %d/n”, this, mDataSize);<br /> if (mDataPos > desired) {<br /> mDataPos = desired;<br /> LOGV(“continueWrite Setting data pos of %p to %d/n”, this, mDataPos);<br /> }<br /> }</p> <p> } else {<br /> // This is the first data. Easy!<br /> uint8_t* data = (uint8_t*)malloc(desired);<br /> if (!data) {<br /> mError = NO_MEMORY;<br /> return NO_MEMORY;<br /> }</p> <p> if(!(mDataCapacity == 0 && mObjects == NULL<br /> && mObjectsCapacity == 0)) {<br /> LOGE(“continueWrite: %d/%p/%d/%d”, mDataCapacity, mObjects, mObjectsCapacity, desired);<br /> }</p> <p> mData = data;<br /> mDataSize = mDataPos = 0;<br /> LOGV(“continueWrite Setting data size of %p to %d/n”, this, mDataSize);<br /> LOGV(“continueWrite Setting data pos of %p to %d/n”, this, mDataPos);<br /> mDataCapacity = desired;<br /> }</p> <p> return NO_ERROR;<br />}</p> <p>void Parcel::initState()<br />{<br /> mError = NO_ERROR;<br /> mData = 0;<br /> mDataSize = 0;<br /> mDataCapacity = 0;<br /> mDataPos = 0;<br /> LOGV(“initState Setting data size of %p to %d/n”, this, mDataSize);<br /> LOGV(“initState Setting data pos of %p to %d/n”, this, mDataPos);<br /> mObjects = NULL;<br /> mObjectsSize = 0;<br /> mObjectsCapacity = 0;<br /> mNextObjectHint = 0;<br /> mHasFds = false;<br /> mFdsKnown = true;<br /> mOwner = NULL;<br />}</p> <p>void Parcel::scanForFds() const<br />{<br /> bool hasFds = false;<br /> for (size_t i=0; i<mObjectsSize; i++) {<br /> const flat_binder_object* flat<br /> = reinterpret_cast<const flat_binder_object*>(mData + mObjects[i]);<br /> if (flat->type == BINDER_TYPE_FD) {<br /> hasFds = true;<br /> break;<br /> }<br /> }<br /> mHasFds = hasFds;<br /> mFdsKnown = true;<br />}</p> <p>}; // namespace android<br />

         本文的源代码使用的是Android 2.1版本号。

——欢迎转载，请注明出处 http://blog.csdn.net/caowenbin ——