一．先从Serialize说起

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

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

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

三．Parcel类的背后

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

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

典型的源码片断如下：

[java] view plaincopyprint?
  1. /**
  2. * Write an integer value into the parcel at the current dataPosition(),
  3. * growing dataCapacity() if needed.
  4. */
  5. public final native void writeInt(int val);
  6. /**
  7. * Write a long integer value into the parcel at the current dataPosition(),
  8. * growing dataCapacity() if needed.
  9. */
  10. public final native void writeLong(long val);

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

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

[java] view plaincopyprint?
  1. static void android_os_Parcel_writeInt(JNIEnv* env, jobject clazz, jint val)
  2. {
  3. Parcel* parcel = parcelForJavaObject(env, clazz);
  4. if (parcel != NULL) {
  5. const status_t err = parcel->writeInt32(val);
  6. if (err != NO_ERROR) {
  7. jniThrowException(env, "java/lang/OutOfMemoryError", NULL);
  8. }
  9. }
  10. }
  11. static void android_os_Parcel_writeLong(JNIEnv* env, jobject clazz, jlong val)
  12. {
  13. Parcel* parcel = parcelForJavaObject(env, clazz);
  14. if (parcel != NULL) {
  15. const status_t err = parcel->writeInt64(val);
  16. if (err != NO_ERROR) {
  17. jniThrowException(env, "java/lang/OutOfMemoryError", NULL);
  18. }
  19. }
  20. }

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

从这里我们可以得到的信息是函数的实现依赖于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机制（下）》。

[cpp] view plaincopyprint?
  1. /*
  2. * Copyright (C) 2005 The Android Open Source Project
  3. *
  4. * Licensed under the Apache License, Version 2.0 (the "License");
  5. * you may not use this file except in compliance with the License.
  6. * You may obtain a copy of the License at
  7. *
  8. *      http://www.apache.org/licenses/LICENSE-2.0
  9. *
  10. * Unless required by applicable law or agreed to in writing, software
  11. * distributed under the License is distributed on an "AS IS" BASIS,
  12. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13. * See the License for the specific language governing permissions and
  14. * limitations under the License.
  15. */
  16. #ifndef ANDROID_PARCEL_H
  17. #define ANDROID_PARCEL_H
  18. #include <cutils/native_handle.h>
  19. #include <utils/Errors.h>
  20. #include <utils/RefBase.h>
  21. #include <utils/String16.h>
  22. #include <utils/Vector.h>
  23. // ---------------------------------------------------------------------------
  24. namespace android {
  25. class IBinder;
  26. class ProcessState;
  27. class String8;
  28. class TextOutput;
  29. class Flattenable;
  30. struct flat_binder_object;  // defined in support_p/binder_module.h
  31. class Parcel
  32. {
  33. public:
  34. Parcel();
  35. ~Parcel();
  36. const uint8_t*      data() const;
  37. size_t              dataSize() const;
  38. size_t              dataAvail() const;
  39. size_t              dataPosition() const;
  40. size_t              dataCapacity() const;
  41. status_t            setDataSize(size_t size);
  42. void                setDataPosition(size_t pos) const;
  43. status_t            setDataCapacity(size_t size);
  44. status_t            setData(const uint8_t* buffer, size_t len);
  45. status_t            appendFrom(Parcel *parcel, size_t start, size_t len);
  46. bool                hasFileDescriptors() const;
  47. status_t            writeInterfaceToken(const String16& interface);
  48. bool                enforceInterface(const String16& interface) const;
  49. bool                checkInterface(IBinder*) const;
  50. void                freeData();
  51. const size_t*       objects() const;
  52. size_t              objectsCount() const;
  53. status_t            errorCheck() const;
  54. void                setError(status_t err);
  55. status_t            write(const void* data, size_t len);
  56. void*               writeInplace(size_t len);
  57. status_t            writeUnpadded(const void* data, size_t len);
  58. status_t            writeInt32(int32_t val);
  59. status_t            writeInt64(int64_t val);
  60. status_t            writeFloat(float val);
  61. status_t            writeDouble(double val);
  62. status_t            writeIntPtr(intptr_t val);
  63. status_t            writeCString(const char* str);
  64. status_t            writeString8(const String8& str);
  65. status_t            writeString16(const String16& str);
  66. status_t            writeString16(const char16_t* str, size_t len);
  67. status_t            writeStrongBinder(const sp<IBinder>& val);
  68. status_t            writeWeakBinder(const wp<IBinder>& val);
  69. status_t            write(const Flattenable& val);
  70. // Place a native_handle into the parcel (the native_handle's file-
  71. // descriptors are dup'ed, so it is safe to delete the native_handle
  72. // when this function returns).
  73. // Doesn't take ownership of the native_handle.
  74. status_t            writeNativeHandle(const native_handle* handle);
  75. // Place a file descriptor into the parcel.  The given fd must remain
  76. // valid for the lifetime of the parcel.
  77. status_t            writeFileDescriptor(int fd);
  78. // Place a file descriptor into the parcel.  A dup of the fd is made, which
  79. // will be closed once the parcel is destroyed.
  80. status_t            writeDupFileDescriptor(int fd);
  81. status_t            writeObject(const flat_binder_object& val, bool nullMetaData);
  82. void                remove(size_t start, size_t amt);
  83. status_t            read(void* outData, size_t len) const;
  84. const void*         readInplace(size_t len) const;
  85. int32_t             readInt32() const;
  86. status_t            readInt32(int32_t *pArg) const;
  87. int64_t             readInt64() const;
  88. status_t            readInt64(int64_t *pArg) const;
  89. float               readFloat() const;
  90. status_t            readFloat(float *pArg) const;
  91. double              readDouble() const;
  92. status_t            readDouble(double *pArg) const;
  93. intptr_t            readIntPtr() const;
  94. status_t            readIntPtr(intptr_t *pArg) const;
  95. const char*         readCString() const;
  96. String8             readString8() const;
  97. String16            readString16() const;
  98. const char16_t*     readString16Inplace(size_t* outLen) const;
  99. sp<IBinder>         readStrongBinder() const;
  100. wp<IBinder>         readWeakBinder() const;
  101. status_t            read(Flattenable& val) const;
  102. // Retrieve native_handle from the parcel. This returns a copy of the
  103. // parcel's native_handle (the caller takes ownership). The caller
  104. // must free the native_handle with native_handle_close() and
  105. // native_handle_delete().
  106. native_handle*     readNativeHandle() const;
  107. // Retrieve a file descriptor from the parcel.  This returns the raw fd
  108. // in the parcel, which you do not own -- use dup() to get your own copy.
  109. int                 readFileDescriptor() const;
  110. const flat_binder_object* readObject(bool nullMetaData) const;
  111. // Explicitly close all file descriptors in the parcel.
  112. void                closeFileDescriptors();
  113. typedef void        (*release_func)(Parcel* parcel,
  114. const uint8_t* data, size_t dataSize,
  115. const size_t* objects, size_t objectsSize,
  116. void* cookie);
  117. const uint8_t*      ipcData() const;
  118. size_t              ipcDataSize() const;
  119. const size_t*       ipcObjects() const;
  120. size_t              ipcObjectsCount() const;
  121. void                ipcSetDataReference(const uint8_t* data, size_t dataSize,
  122. const size_t* objects, size_t objectsCount,
  123. release_func relFunc, void* relCookie);
  124. void                print(TextOutput& to, uint32_t flags = 0) const;
  125. private:
  126. Parcel(const Parcel& o);
  127. Parcel&             operator=(const Parcel& o);
  128. status_t            finishWrite(size_t len);
  129. void                releaseObjects();
  130. void                acquireObjects();
  131. status_t            growData(size_t len);
  132. status_t            restartWrite(size_t desired);
  133. status_t            continueWrite(size_t desired);
  134. void                freeDataNoInit();
  135. void                initState();
  136. void                scanForFds() const;
  137. template<class T>
  138. status_t            readAligned(T *pArg) const;
  139. template<class T>   T readAligned() const;
  140. template<class T>
  141. status_t            writeAligned(T val);
  142. status_t            mError;
  143. uint8_t*            mData;
  144. size_t              mDataSize;
  145. size_t              mDataCapacity;
  146. mutable size_t      mDataPos;
  147. size_t*             mObjects;
  148. size_t              mObjectsSize;
  149. size_t              mObjectsCapacity;
  150. mutable size_t      mNextObjectHint;
  151. mutable bool        mFdsKnown;
  152. mutable bool        mHasFds;
  153. release_func        mOwner;
  154. void*               mOwnerCookie;
  155. };
  156. // ---------------------------------------------------------------------------
  157. inline TextOutput& operator<<(TextOutput& to, const Parcel& parcel)
  158. {
  159. parcel.print(to);
  160. return to;
  161. }
  162. // ---------------------------------------------------------------------------
  163. // Generic acquire and release of objects.
  164. void acquire_object(const sp<ProcessState>& proc,
  165. const flat_binder_object& obj, const void* who);
  166. void release_object(const sp<ProcessState>& proc,
  167. const flat_binder_object& obj, const void* who);
  168. void flatten_binder(const sp<ProcessState>& proc,
  169. const sp<IBinder>& binder, flat_binder_object* out);
  170. void flatten_binder(const sp<ProcessState>& proc,
  171. const wp<IBinder>& binder, flat_binder_object* out);
  172. status_t unflatten_binder(const sp<ProcessState>& proc,
  173. const flat_binder_object& flat, sp<IBinder>* out);
  174. status_t unflatten_binder(const sp<ProcessState>& proc,
  175. const flat_binder_object& flat, wp<IBinder>* out);
  176. }; // namespace android
  177. // ---------------------------------------------------------------------------
  178. #endif // ANDROID_PARCEL_H

/* * Copyright (C) 2005 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */#ifndef ANDROID_PARCEL_H#define ANDROID_PARCEL_H#include <cutils/native_handle.h>#include <utils/Errors.h>#include <utils/RefBase.h>#include <utils/String16.h>#include <utils/Vector.h>// ---------------------------------------------------------------------------namespace android {class IBinder;class ProcessState;class String8;class TextOutput;class Flattenable;struct flat_binder_object; // defined in support_p/binder_module.hclass Parcel{public: 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(Parcel *parcel, size_t start, size_t len); bool hasFileDescriptors() const; status_t writeInterfaceToken(const String16& interface); bool enforceInterface(const String16& interface) 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. status_t writeFileDescriptor(int fd); // 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); status_t writeObject(const flat_binder_object& val, bool nullMetaData); 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; // 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; 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; release_func mOwner; void* mOwnerCookie;};// ---------------------------------------------------------------------------inline TextOutput& operator<<(TextOutput& to, const Parcel& parcel){ parcel.print(to); return to;}// ---------------------------------------------------------------------------// Generic acquire and release of objects.void acquire_object(const sp<ProcessState>& proc, const flat_binder_object& obj, const void* who);void release_object(const sp<ProcessState>& proc, const flat_binder_object& obj, const void* who);void flatten_binder(const sp<ProcessState>& proc, const sp<IBinder>& binder, flat_binder_object* out);void flatten_binder(const sp<ProcessState>& proc, const wp<IBinder>& binder, flat_binder_object* out);status_t unflatten_binder(const sp<ProcessState>& proc, const flat_binder_object& flat, sp<IBinder>* out);status_t unflatten_binder(const sp<ProcessState>& proc, const flat_binder_object& flat, wp<IBinder>* out);}; // namespace android// ---------------------------------------------------------------------------#endif // ANDROID_PARCEL_H

[cpp] view plaincopyprint?
  1. /*
  2. * Copyright (C) 2005 The Android Open Source Project
  3. *
  4. * Licensed under the Apache License, Version 2.0 (the "License");
  5. * you may not use this file except in compliance with the License.
  6. * You may obtain a copy of the License at
  7. *
  8. *      http://www.apache.org/licenses/LICENSE-2.0
  9. *
  10. * Unless required by applicable law or agreed to in writing, software
  11. * distributed under the License is distributed on an "AS IS" BASIS,
  12. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13. * See the License for the specific language governing permissions and
  14. * limitations under the License.
  15. */
  16. #define LOG_TAG "Parcel"
  17. //#define LOG_NDEBUG 0
  18. #include <binder/Parcel.h>
  19. #include <binder/Binder.h>
  20. #include <binder/BpBinder.h>
  21. #include <utils/Debug.h>
  22. #include <binder/ProcessState.h>
  23. #include <utils/Log.h>
  24. #include <utils/String8.h>
  25. #include <utils/String16.h>
  26. #include <utils/TextOutput.h>
  27. #include <utils/misc.h>
  28. #include <utils/Flattenable.h>
  29. #include <private/binder/binder_module.h>
  30. #include <stdio.h>
  31. #include <stdlib.h>
  32. #include <stdint.h>
  33. #ifndef INT32_MAX
  34. #define INT32_MAX ((int32_t)(2147483647))
  35. #endif
  36. #define LOG_REFS(...)
  37. //#define LOG_REFS(...) LOG(LOG_DEBUG, "Parcel", __VA_ARGS__)
  38. // ---------------------------------------------------------------------------
  39. #define PAD_SIZE(s) (((s)+3)&~3)
  40. // XXX This can be made public if we want to provide
  41. // support for typed data.
  42. struct small_flat_data
  43. {
  44. uint32_t type;
  45. uint32_t data;
  46. };
  47. namespace android {
  48. void acquire_object(const sp<ProcessState>& proc,
  49. const flat_binder_object& obj, const void* who)
  50. {
  51. switch (obj.type) {
  52. case BINDER_TYPE_BINDER:
  53. if (obj.binder) {
  54. LOG_REFS("Parcel %p acquiring reference on local %p", who, obj.cookie);
  55. static_cast<IBinder*>(obj.cookie)->incStrong(who);
  56. }
  57. return;
  58. case BINDER_TYPE_WEAK_BINDER:
  59. if (obj.binder)
  60. static_cast<RefBase::weakref_type*>(obj.binder)->incWeak(who);
  61. return;
  62. case BINDER_TYPE_HANDLE: {
  63. const sp<IBinder> b = proc->getStrongProxyForHandle(obj.handle);
  64. if (b != NULL) {
  65. LOG_REFS("Parcel %p acquiring reference on remote %p", who, b.get());
  66. b->incStrong(who);
  67. }
  68. return;
  69. }
  70. case BINDER_TYPE_WEAK_HANDLE: {
  71. const wp<IBinder> b = proc->getWeakProxyForHandle(obj.handle);
  72. if (b != NULL) b.get_refs()->incWeak(who);
  73. return;
  74. }
  75. case BINDER_TYPE_FD: {
  76. // intentionally blank -- nothing to do to acquire this, but we do
  77. // recognize it as a legitimate object type.
  78. return;
  79. }
  80. }
  81. LOGD("Invalid object type 0x%08lx", obj.type);
  82. }
  83. void release_object(const sp<ProcessState>& proc,
  84. const flat_binder_object& obj, const void* who)
  85. {
  86. switch (obj.type) {
  87. case BINDER_TYPE_BINDER:
  88. if (obj.binder) {
  89. LOG_REFS("Parcel %p releasing reference on local %p", who, obj.cookie);
  90. static_cast<IBinder*>(obj.cookie)->decStrong(who);
  91. }
  92. return;
  93. case BINDER_TYPE_WEAK_BINDER:
  94. if (obj.binder)
  95. static_cast<RefBase::weakref_type*>(obj.binder)->decWeak(who);
  96. return;
  97. case BINDER_TYPE_HANDLE: {
  98. const sp<IBinder> b = proc->getStrongProxyForHandle(obj.handle);
  99. if (b != NULL) {
  100. LOG_REFS("Parcel %p releasing reference on remote %p", who, b.get());
  101. b->decStrong(who);
  102. }
  103. return;
  104. }
  105. case BINDER_TYPE_WEAK_HANDLE: {
  106. const wp<IBinder> b = proc->getWeakProxyForHandle(obj.handle);
  107. if (b != NULL) b.get_refs()->decWeak(who);
  108. return;
  109. }
  110. case BINDER_TYPE_FD: {
  111. if (obj.cookie != (void*)0) close(obj.handle);
  112. return;
  113. }
  114. }
  115. LOGE("Invalid object type 0x%08lx", obj.type);
  116. }
  117. inline static status_t finish_flatten_binder(
  118. const sp<IBinder>& binder, const flat_binder_object& flat, Parcel* out)
  119. {
  120. return out->writeObject(flat, false);
  121. }
  122. status_t flatten_binder(const sp<ProcessState>& proc,
  123. const sp<IBinder>& binder, Parcel* out)
  124. {
  125. flat_binder_object obj;
  126. obj.flags = 0x7f | FLAT_BINDER_FLAG_ACCEPTS_FDS;
  127. if (binder != NULL) {
  128. IBinder *local = binder->localBinder();
  129. if (!local) {
  130. BpBinder *proxy = binder->remoteBinder();
  131. if (proxy == NULL) {
  132. LOGE("null proxy");
  133. }
  134. const int32_t handle = proxy ? proxy->handle() : 0;
  135. obj.type = BINDER_TYPE_HANDLE;
  136. obj.handle = handle;
  137. obj.cookie = NULL;
  138. } else {
  139. obj.type = BINDER_TYPE_BINDER;
  140. obj.binder = local->getWeakRefs();
  141. obj.cookie = local;
  142. }
  143. } else {
  144. obj.type = BINDER_TYPE_BINDER;
  145. obj.binder = NULL;
  146. obj.cookie = NULL;
  147. }
  148. return finish_flatten_binder(binder, obj, out);
  149. }
  150. status_t flatten_binder(const sp<ProcessState>& proc,
  151. const wp<IBinder>& binder, Parcel* out)
  152. {
  153. flat_binder_object obj;
  154. obj.flags = 0x7f | FLAT_BINDER_FLAG_ACCEPTS_FDS;
  155. if (binder != NULL) {
  156. sp<IBinder> real = binder.promote();
  157. if (real != NULL) {
  158. IBinder *local = real->localBinder();
  159. if (!local) {
  160. BpBinder *proxy = real->remoteBinder();
  161. if (proxy == NULL) {
  162. LOGE("null proxy");
  163. }
  164. const int32_t handle = proxy ? proxy->handle() : 0;
  165. obj.type = BINDER_TYPE_WEAK_HANDLE;
  166. obj.handle = handle;
  167. obj.cookie = NULL;
  168. } else {
  169. obj.type = BINDER_TYPE_WEAK_BINDER;
  170. obj.binder = binder.get_refs();
  171. obj.cookie = binder.unsafe_get();
  172. }
  173. return finish_flatten_binder(real, obj, out);
  174. }
  175. // XXX How to deal?  In order to flatten the given binder,
  176. // we need to probe it for information, which requires a primary
  177. // reference...  but we don't have one.
  178. //
  179. // The OpenBinder implementation uses a dynamic_cast<> here,
  180. // but we can't do that with the different reference counting
  181. // implementation we are using.
  182. LOGE("Unable to unflatten Binder weak reference!");
  183. obj.type = BINDER_TYPE_BINDER;
  184. obj.binder = NULL;
  185. obj.cookie = NULL;
  186. return finish_flatten_binder(NULL, obj, out);
  187. } else {
  188. obj.type = BINDER_TYPE_BINDER;
  189. obj.binder = NULL;
  190. obj.cookie = NULL;
  191. return finish_flatten_binder(NULL, obj, out);
  192. }
  193. }
  194. inline static status_t finish_unflatten_binder(
  195. BpBinder* proxy, const flat_binder_object& flat, const Parcel& in)
  196. {
  197. return NO_ERROR;
  198. }
  199. status_t unflatten_binder(const sp<ProcessState>& proc,
  200. const Parcel& in, sp<IBinder>* out)
  201. {
  202. const flat_binder_object* flat = in.readObject(false);
  203. if (flat) {
  204. switch (flat->type) {
  205. case BINDER_TYPE_BINDER:
  206. *out = static_cast<IBinder*>(flat->cookie);
  207. return finish_unflatten_binder(NULL, *flat, in);
  208. case BINDER_TYPE_HANDLE:
  209. *out = proc->getStrongProxyForHandle(flat->handle);
  210. return finish_unflatten_binder(
  211. static_cast<BpBinder*>(out->get()), *flat, in);
  212. }
  213. }
  214. return BAD_TYPE;
  215. }
  216. status_t unflatten_binder(const sp<ProcessState>& proc,
  217. const Parcel& in, wp<IBinder>* out)
  218. {
  219. const flat_binder_object* flat = in.readObject(false);
  220. if (flat) {
  221. switch (flat->type) {
  222. case BINDER_TYPE_BINDER:
  223. *out = static_cast<IBinder*>(flat->cookie);
  224. return finish_unflatten_binder(NULL, *flat, in);
  225. case BINDER_TYPE_WEAK_BINDER:
  226. if (flat->binder != NULL) {
  227. out->set_object_and_refs(
  228. static_cast<IBinder*>(flat->cookie),
  229. static_cast<RefBase::weakref_type*>(flat->binder));
  230. } else {
  231. *out = NULL;
  232. }
  233. return finish_unflatten_binder(NULL, *flat, in);
  234. case BINDER_TYPE_HANDLE:
  235. case BINDER_TYPE_WEAK_HANDLE:
  236. *out = proc->getWeakProxyForHandle(flat->handle);
  237. return finish_unflatten_binder(
  238. static_cast<BpBinder*>(out->unsafe_get()), *flat, in);
  239. }
  240. }
  241. return BAD_TYPE;
  242. }
  243. // ---------------------------------------------------------------------------
  244. Parcel::Parcel()
  245. {
  246. initState();
  247. }
  248. Parcel::~Parcel()
  249. {
  250. freeDataNoInit();
  251. }
  252. const uint8_t* Parcel::data() const
  253. {
  254. return mData;
  255. }
  256. size_t Parcel::dataSize() const
  257. {
  258. return (mDataSize > mDataPos ? mDataSize : mDataPos);
  259. }
  260. size_t Parcel::dataAvail() const
  261. {
  262. // TODO: decide what to do about the possibility that this can
  263. // report an available-data size that exceeds a Java int's max
  264. // positive value, causing havoc.  Fortunately this will only
  265. // happen if someone constructs a Parcel containing more than two
  266. // gigabytes of data, which on typical phone hardware is simply
  267. // not possible.
  268. return dataSize() - dataPosition();
  269. }
  270. size_t Parcel::dataPosition() const
  271. {
  272. return mDataPos;
  273. }
  274. size_t Parcel::dataCapacity() const
  275. {
  276. return mDataCapacity;
  277. }
  278. status_t Parcel::setDataSize(size_t size)
  279. {
  280. status_t err;
  281. err = continueWrite(size);
  282. if (err == NO_ERROR) {
  283. mDataSize = size;
  284. LOGV("setDataSize Setting data size of %p to %d/n", this, mDataSize);
  285. }
  286. return err;
  287. }
  288. void Parcel::setDataPosition(size_t pos) const
  289. {
  290. mDataPos = pos;
  291. mNextObjectHint = 0;
  292. }
  293. status_t Parcel::setDataCapacity(size_t size)
  294. {
  295. if (size > mDataSize) return continueWrite(size);
  296. return NO_ERROR;
  297. }
  298. status_t Parcel::setData(const uint8_t* buffer, size_t len)
  299. {
  300. status_t err = restartWrite(len);
  301. if (err == NO_ERROR) {
  302. memcpy(const_cast<uint8_t*>(data()), buffer, len);
  303. mDataSize = len;
  304. mFdsKnown = false;
  305. }
  306. return err;
  307. }
  308. status_t Parcel::appendFrom(Parcel *parcel, size_t offset, size_t len)
  309. {
  310. const sp<ProcessState> proc(ProcessState::self());
  311. status_t err;
  312. uint8_t *data = parcel->mData;
  313. size_t *objects = parcel->mObjects;
  314. size_t size = parcel->mObjectsSize;
  315. int startPos = mDataPos;
  316. int firstIndex = -1, lastIndex = -2;
  317. if (len == 0) {
  318. return NO_ERROR;
  319. }
  320. // range checks against the source parcel size
  321. if ((offset > parcel->mDataSize)
  322. || (len > parcel->mDataSize)
  323. || (offset + len > parcel->mDataSize)) {
  324. return BAD_VALUE;
  325. }
  326. // Count objects in range
  327. for (int i = 0; i < (int) size; i++) {
  328. size_t off = objects[i];
  329. if ((off >= offset) && (off < offset + len)) {
  330. if (firstIndex == -1) {
  331. firstIndex = i;
  332. }
  333. lastIndex = i;
  334. }
  335. }
  336. int numObjects = lastIndex - firstIndex + 1;
  337. // grow data
  338. err = growData(len);
  339. if (err != NO_ERROR) {
  340. return err;
  341. }
  342. // append data
  343. memcpy(mData + mDataPos, data + offset, len);
  344. mDataPos += len;
  345. mDataSize += len;
  346. if (numObjects > 0) {
  347. // grow objects
  348. if (mObjectsCapacity < mObjectsSize + numObjects) {
  349. int newSize = ((mObjectsSize + numObjects)*3)/2;
  350. size_t *objects =
  351. (size_t*)realloc(mObjects, newSize*sizeof(size_t));
  352. if (objects == (size_t*)0) {
  353. return NO_MEMORY;
  354. }
  355. mObjects = objects;
  356. mObjectsCapacity = newSize;
  357. }
  358. // append and acquire objects
  359. int idx = mObjectsSize;
  360. for (int i = firstIndex; i <= lastIndex; i++) {
  361. size_t off = objects[i] - offset + startPos;
  362. mObjects[idx++] = off;
  363. mObjectsSize++;
  364. flat_binder_object* flat
  365. = reinterpret_cast<flat_binder_object*>(mData + off);
  366. acquire_object(proc, *flat, this);
  367. if (flat->type == BINDER_TYPE_FD) {
  368. // If this is a file descriptor, we need to dup it so the
  369. // new Parcel now owns its own fd, and can declare that we
  370. // officially know we have fds.
  371. flat->handle = dup(flat->handle);
  372. flat->cookie = (void*)1;
  373. mHasFds = mFdsKnown = true;
  374. }
  375. }
  376. }
  377. return NO_ERROR;
  378. }
  379. bool Parcel::hasFileDescriptors() const
  380. {
  381. if (!mFdsKnown) {
  382. scanForFds();
  383. }
  384. return mHasFds;
  385. }
  386. status_t Parcel::writeInterfaceToken(const String16& interface)
  387. {
  388. // currently the interface identification token is just its name as a string
  389. return writeString16(interface);
  390. }
  391. bool Parcel::checkInterface(IBinder* binder) const
  392. {
  393. return enforceInterface(binder->getInterfaceDescriptor());
  394. }
  395. bool Parcel::enforceInterface(const String16& interface) const
  396. {
  397. const String16 str(readString16());
  398. if (str == interface) {
  399. return true;
  400. } else {
  401. LOGW("**** enforceInterface() expected '%s' but read '%s'/n",
  402. String8(interface).string(), String8(str).string());
  403. return false;
  404. }
  405. }
  406. const size_t* Parcel::objects() const
  407. {
  408. return mObjects;
  409. }
  410. size_t Parcel::objectsCount() const
  411. {
  412. return mObjectsSize;
  413. }
  414. status_t Parcel::errorCheck() const
  415. {
  416. return mError;
  417. }
  418. void Parcel::setError(status_t err)
  419. {
  420. mError = err;
  421. }
  422. status_t Parcel::finishWrite(size_t len)
  423. {
  424. //printf("Finish write of %d/n", len);
  425. mDataPos += len;
  426. LOGV("finishWrite Setting data pos of %p to %d/n", this, mDataPos);
  427. if (mDataPos > mDataSize) {
  428. mDataSize = mDataPos;
  429. LOGV("finishWrite Setting data size of %p to %d/n", this, mDataSize);
  430. }
  431. //printf("New pos=%d, size=%d/n", mDataPos, mDataSize);
  432. return NO_ERROR;
  433. }
  434. status_t Parcel::writeUnpadded(const void* data, size_t len)
  435. {
  436. size_t end = mDataPos + len;
  437. if (end < mDataPos) {
  438. // integer overflow
  439. return BAD_VALUE;
  440. }
  441. if (end <= mDataCapacity) {
  442. restart_write:
  443. memcpy(mData+mDataPos, data, len);
  444. return finishWrite(len);
  445. }
  446. status_t err = growData(len);
  447. if (err == NO_ERROR) goto restart_write;
  448. return err;
  449. }
  450. status_t Parcel::write(const void* data, size_t len)
  451. {
  452. void* const d = writeInplace(len);
  453. if (d) {
  454. memcpy(d, data, len);
  455. return NO_ERROR;
  456. }
  457. return mError;
  458. }
  459. void* Parcel::writeInplace(size_t len)
  460. {
  461. const size_t padded = PAD_SIZE(len);
  462. // sanity check for integer overflow
  463. if (mDataPos+padded < mDataPos) {
  464. return NULL;
  465. }
  466. if ((mDataPos+padded) <= mDataCapacity) {
  467. restart_write:
  468. //printf("Writing %ld bytes, padded to %ld/n", len, padded);
  469. uint8_t* const data = mData+mDataPos;
  470. // Need to pad at end?
  471. if (padded != len) {
  472. #if BYTE_ORDER == BIG_ENDIAN
  473. static const uint32_t mask[4] = {
  474. 0x00000000, 0xffffff00, 0xffff0000, 0xff000000
  475. };
  476. #endif
  477. #if BYTE_ORDER == LITTLE_ENDIAN
  478. static const uint32_t mask[4] = {
  479. 0x00000000, 0x00ffffff, 0x0000ffff, 0x000000ff
  480. };
  481. #endif
  482. //printf("Applying pad mask: %p to %p/n", (void*)mask[padded-len],
  483. //    *reinterpret_cast<void**>(data+padded-4));
  484. *reinterpret_cast<uint32_t*>(data+padded-4) &= mask[padded-len];
  485. }
  486. finishWrite(padded);
  487. return data;
  488. }
  489. status_t err = growData(padded);
  490. if (err == NO_ERROR) goto restart_write;
  491. return NULL;
  492. }
  493. status_t Parcel::writeInt32(int32_t val)
  494. {
  495. return writeAligned(val);
  496. }
  497. status_t Parcel::writeInt64(int64_t val)
  498. {
  499. return writeAligned(val);
  500. }
  501. status_t Parcel::writeFloat(float val)
  502. {
  503. return writeAligned(val);
  504. }
  505. status_t Parcel::writeDouble(double val)
  506. {
  507. return writeAligned(val);
  508. }
  509. status_t Parcel::writeIntPtr(intptr_t val)
  510. {
  511. return writeAligned(val);
  512. }
  513. status_t Parcel::writeCString(const char* str)
  514. {
  515. return write(str, strlen(str)+1);
  516. }
  517. status_t Parcel::writeString8(const String8& str)
  518. {
  519. status_t err = writeInt32(str.bytes());
  520. if (err == NO_ERROR) {
  521. err = write(str.string(), str.bytes()+1);
  522. }
  523. return err;
  524. }
  525. status_t Parcel::writeString16(const String16& str)
  526. {
  527. return writeString16(str.string(), str.size());
  528. }
  529. status_t Parcel::writeString16(const char16_t* str, size_t len)
  530. {
  531. if (str == NULL) return writeInt32(-1);
  532. status_t err = writeInt32(len);
  533. if (err == NO_ERROR) {
  534. len *= sizeof(char16_t);
  535. uint8_t* data = (uint8_t*)writeInplace(len+sizeof(char16_t));
  536. if (data) {
  537. memcpy(data, str, len);
  538. *reinterpret_cast<char16_t*>(data+len) = 0;
  539. return NO_ERROR;
  540. }
  541. err = mError;
  542. }
  543. return err;
  544. }
  545. status_t Parcel::writeStrongBinder(const sp<IBinder>& val)
  546. {
  547. return flatten_binder(ProcessState::self(), val, this);
  548. }
  549. status_t Parcel::writeWeakBinder(const wp<IBinder>& val)
  550. {
  551. return flatten_binder(ProcessState::self(), val, this);
  552. }
  553. status_t Parcel::writeNativeHandle(const native_handle* handle)
  554. {
  555. if (!handle || handle->version != sizeof(native_handle))
  556. return BAD_TYPE;
  557. status_t err;
  558. err = writeInt32(handle->numFds);
  559. if (err != NO_ERROR) return err;
  560. err = writeInt32(handle->numInts);
  561. if (err != NO_ERROR) return err;
  562. for (int i=0 ; err==NO_ERROR && i<handle->numFds ; i++)
  563. err = writeDupFileDescriptor(handle->data[i]);
  564. if (err != NO_ERROR) {
  565. LOGD("write native handle, write dup fd failed");
  566. return err;
  567. }
  568. err = write(handle->data + handle->numFds, sizeof(int)*handle->numInts);
  569. return err;
  570. }
  571. status_t Parcel::writeFileDescriptor(int fd)
  572. {
  573. flat_binder_object obj;
  574. obj.type = BINDER_TYPE_FD;
  575. obj.flags = 0x7f | FLAT_BINDER_FLAG_ACCEPTS_FDS;
  576. obj.handle = fd;
  577. obj.cookie = (void*)0;
  578. return writeObject(obj, true);
  579. }
  580. status_t Parcel::writeDupFileDescriptor(int fd)
  581. {
  582. flat_binder_object obj;
  583. obj.type = BINDER_TYPE_FD;
  584. obj.flags = 0x7f | FLAT_BINDER_FLAG_ACCEPTS_FDS;
  585. obj.handle = dup(fd);
  586. obj.cookie = (void*)1;
  587. return writeObject(obj, true);
  588. }
  589. status_t Parcel::write(const Flattenable& val)
  590. {
  591. status_t err;
  592. // size if needed
  593. size_t len = val.getFlattenedSize();
  594. size_t fd_count = val.getFdCount();
  595. err = this->writeInt32(len);
  596. if (err) return err;
  597. err = this->writeInt32(fd_count);
  598. if (err) return err;
  599. // payload
  600. void* buf = this->writeInplace(PAD_SIZE(len));
  601. if (buf == NULL)
  602. return BAD_VALUE;
  603. int* fds = NULL;
  604. if (fd_count) {
  605. fds = new int[fd_count];
  606. }
  607. err = val.flatten(buf, len, fds, fd_count);
  608. for (size_t i=0 ; i<fd_count && err==NO_ERROR ; i++) {
  609. err = this->writeDupFileDescriptor( fds[i] );
  610. }
  611. if (fd_count) {
  612. delete [] fds;
  613. }
  614. return err;
  615. }
  616. status_t Parcel::writeObject(const flat_binder_object& val, bool nullMetaData)
  617. {
  618. const bool enoughData = (mDataPos+sizeof(val)) <= mDataCapacity;
  619. const bool enoughObjects = mObjectsSize < mObjectsCapacity;
  620. if (enoughData && enoughObjects) {
  621. restart_write:
  622. *reinterpret_cast<flat_binder_object*>(mData+mDataPos) = val;
  623. // Need to write meta-data?
  624. if (nullMetaData || val.binder != NULL) {
  625. mObjects[mObjectsSize] = mDataPos;
  626. acquire_object(ProcessState::self(), val, this);
  627. mObjectsSize++;
  628. }
  629. // remember if it's a file descriptor
  630. if (val.type == BINDER_TYPE_FD) {
  631. mHasFds = mFdsKnown = true;
  632. }
  633. return finishWrite(sizeof(flat_binder_object));
  634. }
  635. if (!enoughData) {
  636. const status_t err = growData(sizeof(val));
  637. if (err != NO_ERROR) return err;
  638. }
  639. if (!enoughObjects) {
  640. size_t newSize = ((mObjectsSize+2)*3)/2;
  641. size_t* objects = (size_t*)realloc(mObjects, newSize*sizeof(size_t));
  642. if (objects == NULL) return NO_MEMORY;
  643. mObjects = objects;
  644. mObjectsCapacity = newSize;
  645. }
  646. goto restart_write;
  647. }
  648. void Parcel::remove(size_t start, size_t amt)
  649. {
  650. LOG_ALWAYS_FATAL("Parcel::remove() not yet implemented!");
  651. }
  652. status_t Parcel::read(void* outData, size_t len) const
  653. {
  654. if ((mDataPos+PAD_SIZE(len)) >= mDataPos && (mDataPos+PAD_SIZE(len)) <= mDataSize) {
  655. memcpy(outData, mData+mDataPos, len);
  656. mDataPos += PAD_SIZE(len);
  657. LOGV("read Setting data pos of %p to %d/n", this, mDataPos);
  658. return NO_ERROR;
  659. }
  660. return NOT_ENOUGH_DATA;
  661. }
  662. const void* Parcel::readInplace(size_t len) const
  663. {
  664. if ((mDataPos+PAD_SIZE(len)) >= mDataPos && (mDataPos+PAD_SIZE(len)) <= mDataSize) {
  665. const void* data = mData+mDataPos;
  666. mDataPos += PAD_SIZE(len);
  667. LOGV("readInplace Setting data pos of %p to %d/n", this, mDataPos);
  668. return data;
  669. }
  670. return NULL;
  671. }
  672. template<class T>
  673. status_t Parcel::readAligned(T *pArg) const {
  674. COMPILE_TIME_ASSERT_FUNCTION_SCOPE(PAD_SIZE(sizeof(T)) == sizeof(T));
  675. if ((mDataPos+sizeof(T)) <= mDataSize) {
  676. const void* data = mData+mDataPos;
  677. mDataPos += sizeof(T);
  678. *pArg =  *reinterpret_cast<const T*>(data);
  679. return NO_ERROR;
  680. } else {
  681. return NOT_ENOUGH_DATA;
  682. }
  683. }
  684. template<class T>
  685. T Parcel::readAligned() const {
  686. T result;
  687. if (readAligned(&result) != NO_ERROR) {
  688. result = 0;
  689. }
  690. return result;
  691. }
  692. template<class T>
  693. status_t Parcel::writeAligned(T val) {
  694. COMPILE_TIME_ASSERT_FUNCTION_SCOPE(PAD_SIZE(sizeof(T)) == sizeof(T));
  695. if ((mDataPos+sizeof(val)) <= mDataCapacity) {
  696. restart_write:
  697. *reinterpret_cast<T*>(mData+mDataPos) = val;
  698. return finishWrite(sizeof(val));
  699. }
  700. status_t err = growData(sizeof(val));
  701. if (err == NO_ERROR) goto restart_write;
  702. return err;
  703. }
  704. status_t Parcel::readInt32(int32_t *pArg) const
  705. {
  706. return readAligned(pArg);
  707. }
  708. int32_t Parcel::readInt32() const
  709. {
  710. return readAligned<int32_t>();
  711. }
  712. status_t Parcel::readInt64(int64_t *pArg) const
  713. {
  714. return readAligned(pArg);
  715. }
  716. int64_t Parcel::readInt64() const
  717. {
  718. return readAligned<int64_t>();
  719. }
  720. status_t Parcel::readFloat(float *pArg) const
  721. {
  722. return readAligned(pArg);
  723. }
  724. float Parcel::readFloat() const
  725. {
  726. return readAligned<float>();
  727. }
  728. status_t Parcel::readDouble(double *pArg) const
  729. {
  730. return readAligned(pArg);
  731. }
  732. double Parcel::readDouble() const
  733. {
  734. return readAligned<double>();
  735. }
  736. status_t Parcel::readIntPtr(intptr_t *pArg) const
  737. {
  738. return readAligned(pArg);
  739. }
  740. intptr_t Parcel::readIntPtr() const
  741. {
  742. return readAligned<intptr_t>();
  743. }
  744. const char* Parcel::readCString() const
  745. {
  746. const size_t avail = mDataSize-mDataPos;
  747. if (avail > 0) {
  748. const char* str = reinterpret_cast<const char*>(mData+mDataPos);
  749. // is the string's trailing NUL within the parcel's valid bounds?
  750. const char* eos = reinterpret_cast<const char*>(memchr(str, 0, avail));
  751. if (eos) {
  752. const size_t len = eos - str;
  753. mDataPos += PAD_SIZE(len+1);
  754. LOGV("readCString Setting data pos of %p to %d/n", this, mDataPos);
  755. return str;
  756. }
  757. }
  758. return NULL;
  759. }
  760. String8 Parcel::readString8() const
  761. {
  762. int32_t size = readInt32();
  763. // watch for potential int overflow adding 1 for trailing NUL
  764. if (size > 0 && size < INT32_MAX) {
  765. const char* str = (const char*)readInplace(size+1);
  766. if (str) return String8(str, size);
  767. }
  768. return String8();
  769. }
  770. String16 Parcel::readString16() const
  771. {
  772. size_t len;
  773. const char16_t* str = readString16Inplace(&len);
  774. if (str) return String16(str, len);
  775. LOGE("Reading a NULL string not supported here.");
  776. return String16();
  777. }
  778. const char16_t* Parcel::readString16Inplace(size_t* outLen) const
  779. {
  780. int32_t size = readInt32();
  781. // watch for potential int overflow from size+1
  782. if (size >= 0 && size < INT32_MAX) {
  783. *outLen = size;
  784. const char16_t* str = (const char16_t*)readInplace((size+1)*sizeof(char16_t));
  785. if (str != NULL) {
  786. return str;
  787. }
  788. }
  789. *outLen = 0;
  790. return NULL;
  791. }
  792. sp<IBinder> Parcel::readStrongBinder() const
  793. {
  794. sp<IBinder> val;
  795. unflatten_binder(ProcessState::self(), *this, &val);
  796. return val;
  797. }
  798. wp<IBinder> Parcel::readWeakBinder() const
  799. {
  800. wp<IBinder> val;
  801. unflatten_binder(ProcessState::self(), *this, &val);
  802. return val;
  803. }
  804. native_handle* Parcel::readNativeHandle() const
  805. {
  806. int numFds, numInts;
  807. status_t err;
  808. err = readInt32(&numFds);
  809. if (err != NO_ERROR) return 0;
  810. err = readInt32(&numInts);
  811. if (err != NO_ERROR) return 0;
  812. native_handle* h = native_handle_create(numFds, numInts);
  813. for (int i=0 ; err==NO_ERROR && i<numFds ; i++) {
  814. h->data[i] = dup(readFileDescriptor());
  815. if (h->data[i] < 0) err = BAD_VALUE;
  816. }
  817. err = read(h->data + numFds, sizeof(int)*numInts);
  818. if (err != NO_ERROR) {
  819. native_handle_close(h);
  820. native_handle_delete(h);
  821. h = 0;
  822. }
  823. return h;
  824. }
  825. int Parcel::readFileDescriptor() const
  826. {
  827. const flat_binder_object* flat = readObject(true);
  828. if (flat) {
  829. switch (flat->type) {
  830. case BINDER_TYPE_FD:
  831. //LOGI("Returning file descriptor %ld from parcel %p/n", flat->handle, this);
  832. return flat->handle;
  833. }
  834. }
  835. return BAD_TYPE;
  836. }
  837. status_t Parcel::read(Flattenable& val) const
  838. {
  839. // size
  840. const size_t len = this->readInt32();
  841. const size_t fd_count = this->readInt32();
  842. // payload
  843. void const* buf = this->readInplace(PAD_SIZE(len));
  844. if (buf == NULL)
  845. return BAD_VALUE;
  846. int* fds = NULL;
  847. if (fd_count) {
  848. fds = new int[fd_count];
  849. }
  850. status_t err = NO_ERROR;
  851. for (size_t i=0 ; i<fd_count && err==NO_ERROR ; i++) {
  852. fds[i] = dup(this->readFileDescriptor());
  853. if (fds[i] < 0) err = BAD_VALUE;
  854. }
  855. if (err == NO_ERROR) {
  856. err = val.unflatten(buf, len, fds, fd_count);
  857. }
  858. if (fd_count) {
  859. delete [] fds;
  860. }
  861. return err;
  862. }
  863. const flat_binder_object* Parcel::readObject(bool nullMetaData) const
  864. {
  865. const size_t DPOS = mDataPos;
  866. if ((DPOS+sizeof(flat_binder_object)) <= mDataSize) {
  867. const flat_binder_object* obj
  868. = reinterpret_cast<const flat_binder_object*>(mData+DPOS);
  869. mDataPos = DPOS + sizeof(flat_binder_object);
  870. if (!nullMetaData && (obj->cookie == NULL && obj->binder == NULL)) {
  871. // When transferring a NULL object, we don't write it into
  872. // the object list, so we don't want to check for it when
  873. // reading.
  874. LOGV("readObject Setting data pos of %p to %d/n", this, mDataPos);
  875. return obj;
  876. }
  877. // Ensure that this object is valid...
  878. size_t* const OBJS = mObjects;
  879. const size_t N = mObjectsSize;
  880. size_t opos = mNextObjectHint;
  881. if (N > 0) {
  882. LOGV("Parcel %p looking for obj at %d, hint=%d/n",
  883. this, DPOS, opos);
  884. // Start at the current hint position, looking for an object at
  885. // the current data position.
  886. if (opos < N) {
  887. while (opos < (N-1) && OBJS[opos] < DPOS) {
  888. opos++;
  889. }
  890. } else {
  891. opos = N-1;
  892. }
  893. if (OBJS[opos] == DPOS) {
  894. // Found it!
  895. LOGV("Parcel found obj %d at index %d with forward search",
  896. this, DPOS, opos);
  897. mNextObjectHint = opos+1;
  898. LOGV("readObject Setting data pos of %p to %d/n", this, mDataPos);
  899. return obj;
  900. }
  901. // Look backwards for it...
  902. while (opos > 0 && OBJS[opos] > DPOS) {
  903. opos--;
  904. }
  905. if (OBJS[opos] == DPOS) {
  906. // Found it!
  907. LOGV("Parcel found obj %d at index %d with backward search",
  908. this, DPOS, opos);
  909. mNextObjectHint = opos+1;
  910. LOGV("readObject Setting data pos of %p to %d/n", this, mDataPos);
  911. return obj;
  912. }
  913. }
  914. LOGW("Attempt to read object from Parcel %p at offset %d that is not in the object list",
  915. this, DPOS);
  916. }
  917. return NULL;
  918. }
  919. void Parcel::closeFileDescriptors()
  920. {
  921. size_t i = mObjectsSize;
  922. if (i > 0) {
  923. //LOGI("Closing file descriptors for %d objects...", mObjectsSize);
  924. }
  925. while (i > 0) {
  926. i--;
  927. const flat_binder_object* flat
  928. = reinterpret_cast<flat_binder_object*>(mData+mObjects[i]);
  929. if (flat->type == BINDER_TYPE_FD) {
  930. //LOGI("Closing fd: %ld/n", flat->handle);
  931. close(flat->handle);
  932. }
  933. }
  934. }
  935. const uint8_t* Parcel::ipcData() const
  936. {
  937. return mData;
  938. }
  939. size_t Parcel::ipcDataSize() const
  940. {
  941. return (mDataSize > mDataPos ? mDataSize : mDataPos);
  942. }
  943. const size_t* Parcel::ipcObjects() const
  944. {
  945. return mObjects;
  946. }
  947. size_t Parcel::ipcObjectsCount() const
  948. {
  949. return mObjectsSize;
  950. }
  951. void Parcel::ipcSetDataReference(const uint8_t* data, size_t dataSize,
  952. const size_t* objects, size_t objectsCount, release_func relFunc, void* relCookie)
  953. {
  954. freeDataNoInit();
  955. mError = NO_ERROR;
  956. mData = const_cast<uint8_t*>(data);
  957. mDataSize = mDataCapacity = dataSize;
  958. //LOGI("setDataReference Setting data size of %p to %lu (pid=%d)/n", this, mDataSize, getpid());
  959. mDataPos = 0;
  960. LOGV("setDataReference Setting data pos of %p to %d/n", this, mDataPos);
  961. mObjects = const_cast<size_t*>(objects);
  962. mObjectsSize = mObjectsCapacity = objectsCount;
  963. mNextObjectHint = 0;
  964. mOwner = relFunc;
  965. mOwnerCookie = relCookie;
  966. scanForFds();
  967. }
  968. void Parcel::print(TextOutput& to, uint32_t flags) const
  969. {
  970. to << "Parcel(";
  971. if (errorCheck() != NO_ERROR) {
  972. const status_t err = errorCheck();
  973. to << "Error: " << (void*)err << " /"" << strerror(-err) << "/"";
  974. } else if (dataSize() > 0) {
  975. const uint8_t* DATA = data();
  976. to << indent << HexDump(DATA, dataSize()) << dedent;
  977. const size_t* OBJS = objects();
  978. const size_t N = objectsCount();
  979. for (size_t i=0; i<N; i++) {
  980. const flat_binder_object* flat
  981. = reinterpret_cast<const flat_binder_object*>(DATA+OBJS[i]);
  982. to << endl << "Object #" << i << " @ " << (void*)OBJS[i] << ": "
  983. << TypeCode(flat->type & 0x7f7f7f00)
  984. << " = " << flat->binder;
  985. }
  986. } else {
  987. to << "NULL";
  988. }
  989. to << ")";
  990. }
  991. void Parcel::releaseObjects()
  992. {
  993. const sp<ProcessState> proc(ProcessState::self());
  994. size_t i = mObjectsSize;
  995. uint8_t* const data = mData;
  996. size_t* const objects = mObjects;
  997. while (i > 0) {
  998. i--;
  999. const flat_binder_object* flat
  1000. = reinterpret_cast<flat_binder_object*>(data+objects[i]);
  1001. release_object(proc, *flat, this);
  1002. }
  1003. }
  1004. void Parcel::acquireObjects()
  1005. {
  1006. const sp<ProcessState> proc(ProcessState::self());
  1007. size_t i = mObjectsSize;
  1008. uint8_t* const data = mData;
  1009. size_t* const objects = mObjects;
  1010. while (i > 0) {
  1011. i--;
  1012. const flat_binder_object* flat
  1013. = reinterpret_cast<flat_binder_object*>(data+objects[i]);
  1014. acquire_object(proc, *flat, this);
  1015. }
  1016. }
  1017. void Parcel::freeData()
  1018. {
  1019. freeDataNoInit();
  1020. initState();
  1021. }
  1022. void Parcel::freeDataNoInit()
  1023. {
  1024. if (mOwner) {
  1025. //LOGI("Freeing data ref of %p (pid=%d)/n", this, getpid());
  1026. mOwner(this, mData, mDataSize, mObjects, mObjectsSize, mOwnerCookie);
  1027. } else {
  1028. releaseObjects();
  1029. if (mData) free(mData);
  1030. if (mObjects) free(mObjects);
  1031. }
  1032. }
  1033. status_t Parcel::growData(size_t len)
  1034. {
  1035. size_t newSize = ((mDataSize+len)*3)/2;
  1036. return (newSize <= mDataSize)
  1037. ? (status_t) NO_MEMORY
  1038. : continueWrite(newSize);
  1039. }
  1040. status_t Parcel::restartWrite(size_t desired)
  1041. {
  1042. if (mOwner) {
  1043. freeData();
  1044. return continueWrite(desired);
  1045. }
  1046. uint8_t* data = (uint8_t*)realloc(mData, desired);
  1047. if (!data && desired > mDataCapacity) {
  1048. mError = NO_MEMORY;
  1049. return NO_MEMORY;
  1050. }
  1051. releaseObjects();
  1052. if (data) {
  1053. mData = data;
  1054. mDataCapacity = desired;
  1055. }
  1056. mDataSize = mDataPos = 0;
  1057. LOGV("restartWrite Setting data size of %p to %d/n", this, mDataSize);
  1058. LOGV("restartWrite Setting data pos of %p to %d/n", this, mDataPos);
  1059. free(mObjects);
  1060. mObjects = NULL;
  1061. mObjectsSize = mObjectsCapacity = 0;
  1062. mNextObjectHint = 0;
  1063. mHasFds = false;
  1064. mFdsKnown = true;
  1065. return NO_ERROR;
  1066. }
  1067. status_t Parcel::continueWrite(size_t desired)
  1068. {
  1069. // If shrinking, first adjust for any objects that appear
  1070. // after the new data size.
  1071. size_t objectsSize = mObjectsSize;
  1072. if (desired < mDataSize) {
  1073. if (desired == 0) {
  1074. objectsSize = 0;
  1075. } else {
  1076. while (objectsSize > 0) {
  1077. if (mObjects[objectsSize-1] < desired)
  1078. break;
  1079. objectsSize--;
  1080. }
  1081. }
  1082. }
  1083. if (mOwner) {
  1084. // If the size is going to zero, just release the owner's data.
  1085. if (desired == 0) {
  1086. freeData();
  1087. return NO_ERROR;
  1088. }
  1089. // If there is a different owner, we need to take
  1090. // posession.
  1091. uint8_t* data = (uint8_t*)malloc(desired);
  1092. if (!data) {
  1093. mError = NO_MEMORY;
  1094. return NO_MEMORY;
  1095. }
  1096. size_t* objects = NULL;
  1097. if (objectsSize) {
  1098. objects = (size_t*)malloc(objectsSize*sizeof(size_t));
  1099. if (!objects) {
  1100. mError = NO_MEMORY;
  1101. return NO_MEMORY;
  1102. }
  1103. // Little hack to only acquire references on objects
  1104. // we will be keeping.
  1105. size_t oldObjectsSize = mObjectsSize;
  1106. mObjectsSize = objectsSize;
  1107. acquireObjects();
  1108. mObjectsSize = oldObjectsSize;
  1109. }
  1110. if (mData) {
  1111. memcpy(data, mData, mDataSize < desired ? mDataSize : desired);
  1112. }
  1113. if (objects && mObjects) {
  1114. memcpy(objects, mObjects, objectsSize*sizeof(size_t));
  1115. }
  1116. //LOGI("Freeing data ref of %p (pid=%d)/n", this, getpid());
  1117. mOwner(this, mData, mDataSize, mObjects, mObjectsSize, mOwnerCookie);
  1118. mOwner = NULL;
  1119. mData = data;
  1120. mObjects = objects;
  1121. mDataSize = (mDataSize < desired) ? mDataSize : desired;
  1122. LOGV("continueWrite Setting data size of %p to %d/n", this, mDataSize);
  1123. mDataCapacity = desired;
  1124. mObjectsSize = mObjectsCapacity = objectsSize;
  1125. mNextObjectHint = 0;
  1126. } else if (mData) {
  1127. if (objectsSize < mObjectsSize) {
  1128. // Need to release refs on any objects we are dropping.
  1129. const sp<ProcessState> proc(ProcessState::self());
  1130. for (size_t i=objectsSize; i<mObjectsSize; i++) {
  1131. const flat_binder_object* flat
  1132. = reinterpret_cast<flat_binder_object*>(mData+mObjects[i]);
  1133. if (flat->type == BINDER_TYPE_FD) {
  1134. // will need to rescan because we may have lopped off the only FDs
  1135. mFdsKnown = false;
  1136. }
  1137. release_object(proc, *flat, this);
  1138. }
  1139. size_t* objects =
  1140. (size_t*)realloc(mObjects, objectsSize*sizeof(size_t));
  1141. if (objects) {
  1142. mObjects = objects;
  1143. }
  1144. mObjectsSize = objectsSize;
  1145. mNextObjectHint = 0;
  1146. }
  1147. // We own the data, so we can just do a realloc().
  1148. if (desired > mDataCapacity) {
  1149. uint8_t* data = (uint8_t*)realloc(mData, desired);
  1150. if (data) {
  1151. mData = data;
  1152. mDataCapacity = desired;
  1153. } else if (desired > mDataCapacity) {
  1154. mError = NO_MEMORY;
  1155. return NO_MEMORY;
  1156. }
  1157. } else {
  1158. mDataSize = desired;
  1159. LOGV("continueWrite Setting data size of %p to %d/n", this, mDataSize);
  1160. if (mDataPos > desired) {
  1161. mDataPos = desired;
  1162. LOGV("continueWrite Setting data pos of %p to %d/n", this, mDataPos);
  1163. }
  1164. }
  1165. } else {
  1166. // This is the first data.  Easy!
  1167. uint8_t* data = (uint8_t*)malloc(desired);
  1168. if (!data) {
  1169. mError = NO_MEMORY;
  1170. return NO_MEMORY;
  1171. }
  1172. if(!(mDataCapacity == 0 && mObjects == NULL
  1173. && mObjectsCapacity == 0)) {
  1174. LOGE("continueWrite: %d/%p/%d/%d", mDataCapacity, mObjects, mObjectsCapacity, desired);
  1175. }
  1176. mData = data;
  1177. mDataSize = mDataPos = 0;
  1178. LOGV("continueWrite Setting data size of %p to %d/n", this, mDataSize);
  1179. LOGV("continueWrite Setting data pos of %p to %d/n", this, mDataPos);
  1180. mDataCapacity = desired;
  1181. }
  1182. return NO_ERROR;
  1183. }
  1184. void Parcel::initState()
  1185. {
  1186. mError = NO_ERROR;
  1187. mData = 0;
  1188. mDataSize = 0;
  1189. mDataCapacity = 0;
  1190. mDataPos = 0;
  1191. LOGV("initState Setting data size of %p to %d/n", this, mDataSize);
  1192. LOGV("initState Setting data pos of %p to %d/n", this, mDataPos);
  1193. mObjects = NULL;
  1194. mObjectsSize = 0;
  1195. mObjectsCapacity = 0;
  1196. mNextObjectHint = 0;
  1197. mHasFds = false;
  1198. mFdsKnown = true;
  1199. mOwner = NULL;
  1200. }
  1201. void Parcel::scanForFds() const
  1202. {
  1203. bool hasFds = false;
  1204. for (size_t i=0; i<mObjectsSize; i++) {
  1205. const flat_binder_object* flat
  1206. = reinterpret_cast<const flat_binder_object*>(mData + mObjects[i]);
  1207. if (flat->type == BINDER_TYPE_FD) {
  1208. hasFds = true;
  1209. break;
  1210. }
  1211. }
  1212. mHasFds = hasFds;
  1213. mFdsKnown = true;
  1214. }
  1215. }; // namespace android

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

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

探索Android中的Parcel机制（上） .相关推荐

  1. 探索Android中的Parcel机制（上）

    一．先从Serialize说起 我们都知道JAVA中的Serialize机制,译成串行化.序列化--,其作用是能将数据对象存入字节流其中,在须要时又一次生成对象.主要应用是利用外部存储设备保存对象状态 ...

  2. 探索Android中的Parcel机制（下）

    上一篇中我们透过源码看到了Parcel背后的机制,本质上把它当成一个Serialize就可以了,只是它是在内存中完成的序列化和反序列化,利用的是连续的内存空间,因此会更加高效. 我们接下来要说的是Pa ...

  3. 浅析Android中的消息机制

    在分析Android消息机制之前,我们先来看一段代码: [java] view plaincopy public class MainActivity extends Activity impleme ...

  4. android classloader异常,Android中ClassLoader类加载机制

    Android中apk的构建过程 构建apk 如图 所示,典型 Android 应用模块的构建流程通常依循下列步骤: 编译器将您的源代码转换成 DEX(Dalvik Executable) 文件(其中 ...

  5. Android中Alarm的机制

    本次给大家分析的是Android中Alarm的机制所用源码为最新的Android4.4.4.首先简单介绍如何使用Alarm并给出其工作原理,接着分析Alarm和Timer以及Handler在完成定时任 ...

  6. android系统的alarm机制,Android中Alarm的机制

    本次给大家分析的是Android中Alarm的机制所用源码为最新的Android4.4.4.首先简单介绍如何使用Alarm并给出其工作原理,接着分析Alarm和Timer以及Handler在完成定时任 ...

  7. Android中的消息机制

    Android 中的消息机制其实就是指的是 Handler 消息机制以及附带的 Looper 和 MessageQueue 的工作流程. 1.Android 为什么提供Handler? 解决子线程不能 ...

  8. 重温Android中的消息机制

    引入: 提到Android中的消息机制,大家应该都不陌生,我们在开发中不可避免的要和它打交道.从我们开发的角度来看,Handler是Android消息机制的上层接口.我们在平时的开发中只需要和Hand ...

  9. Android中的IPC机制

    Android IPC简介 IPC是Inter-Process Communication的缩写,含义就是进程间通信或者跨进程通信,是指两个进程之间进行数据交换的过程.那么什么是进程,什么是线程,进程 ...

最新文章

  1. C# 引用类型和值类型
  2. 【廖雪峰python入门笔记】set
  3. QT使用xsl将xml为html,使用xslt 2.0将属性设置为根元素(Puting attributes to the root-element with xslt 2.0)...
  4. 性能优化CPU、内存、磁盘I/O、网络性能相关命令
  5. VC6.0常见英文错误对照表
  6. 一图胜千言，这本交互式线代教科书让你分分钟理解复杂概念，佐治亚理工出品...
  7. delphi switch语句例子_Python系列之常用语句
  8. 常量指针 和 指针常量
  9. 实用的Portraiture滤镜磨皮教程
  10. snakeyaml操作yml文件中注释的处理
  11. codewars----Descending Order
  12. 【数据分析】2022 年将占据主导地位的 3 种数据和分析趋势
  13. memcached php mysql_PHP: memcached
  14. 支付宝PC扫码支付接入流程及代码示例
  15. 渲染吃CPU还是显卡呢？未来是否新睿云的云渲染会大行其道呢？
  16. 视频教程-SQL语句从入门到精通迅速提升篇视频课程(Oracle零基础版)-Oracle
  17. RESTful风格的SSM框架搭建
  18. 安装mplayer后没有声音解决方法
  19. 【热门主题：睡觉win7主题】
  20. Axure RP简单作品

热门文章

  1. 谈谈被大家过于在乎的性能
  2. 有关short与int的重载[jase基础]
  3. Wand mixture在Horseshoe模型中的应用
  4. 傅立叶变换和小波变换入门学习
  5. 图解Oracle 12c 手动建库
  6. 发送请求获取响应内容(c#)
  7. ASP.NET MVC5 Entity Framework CodeFirst（代码优先）
  8. jquery ajax json 数据的遍历
  9. wampserver 绑定域名 外部可以正常访问
  10. 数据库设计中的五个范式