员工年度工作总结报告(2012年度)--张宝华

移动开发 2018-05-13 19:03:28 阅读次数: 0

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

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

       三．Parcel类的背后
       在Framework中有parcel类，源码路径是：Frameworks/base/core/java/android/os/Parcel.java
       典型的源码片断如下：

java代码：

  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); 

  7. /**
  8. * Write a long integer value into the parcel at the current dataPosition(),
  9. * growing dataCapacity() if needed.
  10. */
  11. public final native void writeLong(long val); 

复制代码

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

java代码：
  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. } 

  12. static void android_os_Parcel_writeLong(JNIEnv* env, jobject clazz, jlong val)
  13. {
  14. Parcel* parcel = parcelForJavaObject(env, clazz);
  15. if (parcel != NULL) {
  16. const status_t err = parcel->writeInt64(val);
  17. if (err != NO_ERROR) {
  18. jniThrowException(env, “java/lang/OutOfMemoryError”, NULL);
  19. }
  20. }
  21. } 

复制代码

       从这里我们可以得到的信息是函数的实现依赖于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一个新对象。

java代码：
  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. */ 

  17. #ifndef ANDROID_PARCEL_H
  18. #define ANDROID_PARCEL_H 

  20. #include 
  21. #include 
  22. #include 
  23. #include 
  24. #include 
  25. // —————————————————————————
  26. namespace android { 

  28. class IBinder;
  29. class ProcessState;
  30. class String8;
  31. class TextOutput;
  32. class Flattenable; 

  34. struct flat_binder_object; // defined in support_p/binder_module.h 

  36. class Parcel
  37. {
  38. public:
  39. Parcel();
  40. ~Parcel(); 

  42. const uint8_t* data() const;
  43. size_t dataSize() const;
  44. size_t dataAvail() const;
  45. size_t dataPosition() const;
  46. size_t dataCapacity() const; 

  48. status_t setDataSize(size_t size);
  49. void setDataPosition(size_t pos) const;
  50. status_t setDataCapacity(size_t size); 

  52. status_t setData(const uint8_t* buffer, size_t len); 

  54. status_t appendFrom(Parcel *parcel, size_t start, size_t len); 

  56. bool hasFileDescriptors() const; 

复制代码

本帖最后由 nuli 于 2011-9-14 15:15 编辑

java代码：
  1. status_t writeInterfaceToken(const String16& interface);
  2. bool enforceInterface(const String16& interface) const;
  3. bool checkInterface(IBinder*) const; 

  5. void freeData(); 

  7. const size_t* objects() const;
  8. size_t objectsCount() const; 

  10. status_t errorCheck() const;
  11. void setError(status_t err); 

  13. status_t write(const void* data, size_t len);
  14. void* writeInplace(size_t len);
  15. status_t writeUnpadded(const void* data, size_t len);
  16. status_t writeInt32(int32_t val);
  17. status_t writeInt64(int64_t val);
  18. status_t writeFloat(float val);
  19. status_t writeDouble(double val);
  20. status_t writeIntPtr(intptr_t val);
  21. status_t writeCString(const char* str);
  22. status_t writeString8(const String8& str);
  23. status_t writeString16(const String16& str);
  24. status_t writeString16(const char16_t* str, size_t len);
  25. status_t writeStrongBinder(const sp& val);
  26. status_t writeWeakBinder(const wp& val);
  27. status_t write(const Flattenable& val); 

  29. // Place a native_handle into the parcel (the native_handle’s file-
  30. // descriptors are dup’ed, so it is safe to delete the native_handle
  31. // when this function returns).
  32. // Doesn’t take ownership of the native_handle.
  33. status_t writeNativeHandle(const native_handle* handle); 

  35. // Place a file descriptor into the parcel. The given fd must remain
  36. // valid for the lifetime of the parcel.
  37. status_t writeFileDescriptor(int fd); 

  39. // Place a file descriptor into the parcel. A dup of the fd is made, which
  40. // will be closed once the parcel is destroyed.
  41. status_t writeDupFileDescriptor(int fd); 

  43. status_t writeObject(const flat_binder_object& val, bool nullMetaData); 

  45. void remove(size_t start, size_t amt); 

  47. status_t read(void* outData, size_t len) const;
  48. const void* readInplace(size_t len) const;
  49. int32_t readInt32() const;
  50. status_t readInt32(int32_t *pArg) const;
  51. int64_t readInt64() const;
  52. status_t readInt64(int64_t *pArg) const;
  53. float readFloat() const;
  54. status_t readFloat(float *pArg) const;
  55. double readDouble() const;
  56. status_t readDouble(double *pArg) const;
  57. intptr_t readIntPtr() const;
  58. status_t readIntPtr(intptr_t *pArg) const; 

  60. const char* readCString() const;
  61. String8 readString8() const;
  62. String16 readString16() const;
  63. const char16_t* readString16Inplace(size_t* outLen) const;
  64. sp readStrongBinder() const;
  65. wp readWeakBinder() const;
  66. status_t read(Flattenable& val) const; 

  68. // Retrieve native_handle from the parcel. This returns a copy of the
  69. // parcel’s native_handle (the caller takes ownership). The caller
  70. // must free the native_handle with native_handle_close() and
  71. // native_handle_delete().
  72. native_handle* readNativeHandle() const; 

  74. // Retrieve a file descriptor from the parcel. This returns the raw fd
  75. // in the parcel, which you do not own — use dup() to get your own copy.
  76. int readFileDescriptor() const; 

  78. const flat_binder_object* readObject(bool nullMetaData) const; 

  80. // Explicitly close all file descriptors in the parcel.
  81. void closeFileDescriptors(); 

  83. typedef void (*release_func)(Parcel* parcel,
  84. const uint8_t* data, size_t dataSize,
  85. const size_t* objects, size_t objectsSize,
  86. void* cookie); 

  88. const uint8_t* ipcData() const;
  89. size_t ipcDataSize() const;
  90. const size_t* ipcObjects() const;
  91. size_t ipcObjectsCount() const;
  92. void ipcSetDataReference(const uint8_t* data, size_t dataSize,
  93. const size_t* objects, size_t objectsCount,
  94. release_func relFunc, void* relCookie); 

  96. void print(TextOutput& to, uint32_t flags = 0) const; 

  98. private:
  99. Parcel(const Parcel& o);
  100. Parcel& operator=(const Parcel& o); 

  102. status_t finishWrite(size_t len);
  103. void releaseObjects();
  104. void acquireObjects();
  105. status_t growData(size_t len);
  106. status_t restartWrite(size_t desired);
  107. status_t continueWrite(size_t desired);
  108. void freeDataNoInit();
  109. void initState();
  110. void scanForFds() const; 

  112. template
  113. status_t readAligned(T *pArg) const; 

  115. template T readAligned() const; 

  117. template
  118. status_t writeAligned(T val); 

  120. status_t mError;
  121. uint8_t* mData;
  122. size_t mDataSize;
  123. size_t mDataCapacity;
  124. mutable size_t mDataPos;
  125. size_t* mObjects;
  126. size_t mObjectsSize;
  127. size_t mObjectsCapacity;
  128. mutable size_t mNextObjectHint; 

  130. mutable bool mFdsKnown;
  131. mutable bool mHasFds; 

  133. release_func mOwner;
  134. void* mOwnerCookie;
  135. }; 

复制代码
本帖最后由 nuli 于 2011-9-14 15:15 编辑

java代码：
  1. // ————————————————————————— 

  3. inline TextOutput& operator<<(TextOutput& to, const Parcel& parcel)
  4. {
  5. parcel.print(to);
  6. return to;
  7. } 

  9. // --------------------------------------------------------------------------- 

  11. // Generic acquire and release of objects.
  12. void acquire_object(const sp& proc,
  13. const flat_binder_object& obj, const void* who);
  14. void release_object(const sp& proc,
  15. const flat_binder_object& obj, const void* who); 

  17. void flatten_binder(const sp& proc,
  18. const sp& binder, flat_binder_object* out);
  19. void flatten_binder(const sp& proc,
  20. const wp& binder, flat_binder_object* out);
  21. status_t unflatten_binder(const sp& proc,
  22. const flat_binder_object& flat, sp* out);
  23. status_t unflatten_binder(const sp& proc,
  24. const flat_binder_object& flat, wp* out); 

  26. }; // namespace android 

  28. // ————————————————————————— 

  30. #endif // ANDROID_PARCEL_H 

  32. view plain
  33. /*
  34. * Copyright (C) 2005 The Android Open Source Project
  35. *
  36. * Licensed under the Apache License, Version 2.0 (the “License”);
  37. * you may not use this file except in compliance with the License.
  38. * You may obtain a copy of the License at
  39. *
  40. * http://www.apache.org/licenses/LICENSE-2.0
  41. *
  42. * Unless required by applicable law or agreed to in writing, software
  43. * distributed under the License is distributed on an “AS IS” BASIS,
  44. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  45. * See the License for the specific language governing permissions and
  46. * limitations under the License.
  47. */ 

  49. #define LOG_TAG “Parcel”
  50. //#define LOG_NDEBUG 0 

  52. #include 
  53. #include 
  54. #include 
  55. #include 
  56. #include 
  57. #include 
  58. #include 
  59. #include 
  60. #include 
  61. #include 
  62. #include 
  63. #include 
  64. #include 
  65. #include 
  66. #include 
  67. #ifndef INT32_MAX
  68. #define INT32_MAX ((int32_t)(2147483647))
  69. #endif 

  71. #define LOG_REFS(…)
  72. //#define LOG_REFS(…) LOG(LOG_DEBUG, “Parcel”, __VA_ARGS__) 

  74. // ————————————————————————— 

  76. #define PAD_SIZE(s) (((s)+3)&~3) 

  78. // XXX This can be made public if we want to provide
  79. // support for typed data.
  80. struct small_flat_data
  81. {
  82. uint32_t type;
  83. uint32_t data;
  84. }; 

  86. namespace android { 

  88. void acquire_object(const sp& proc,
  89. const flat_binder_object& obj, const void* who)
  90. {
  91. switch (obj.type) {
  92. case BINDER_TYPE_BINDER:
  93. if (obj.binder) {
  94. LOG_REFS(“Parcel %p acquiring reference on local %p”, who, obj.cookie);
  95. static_cast(obj.cookie)->incStrong(who);
  96. }
  97. return;
  98. case BINDER_TYPE_WEAK_BINDER:
  99. if (obj.binder)
  100. static_cast(obj.binder)->incWeak(who);
  101. return;
  102. case BINDER_TYPE_HANDLE: {
  103. const sp b = proc->getStrongProxyForHandle(obj.handle);
  104. if (b != NULL) {
  105. LOG_REFS(“Parcel %p acquiring reference on remote %p”, who, b.get());
  106. b->incStrong(who);
  107. }
  108. return;
  109. }
  110. case BINDER_TYPE_WEAK_HANDLE: {
  111. const wp b = proc->getWeakProxyForHandle(obj.handle);
  112. if (b != NULL) b.get_refs()->incWeak(who);
  113. return;
  114. }
  115. case BINDER_TYPE_FD: {
  116. // intentionally blank — nothing to do to acquire this, but we do
  117. // recognize it as a legitimate object type.
  118. return;
  119. }
  120. } 

  122. LOGD(“Invalid object type 0x%08lx”, obj.type);
  123. } 

  125. void release_object(const sp& proc,
  126. const flat_binder_object& obj, const void* who)
  127. {
  128. switch (obj.type) {
  129. case BINDER_TYPE_BINDER:
  130. if (obj.binder) {
  131. LOG_REFS(“Parcel %p releasing reference on local %p”, who, obj.cookie);
  132. static_cast(obj.cookie)->decStrong(who);
  133. }
  134. return;
  135. case BINDER_TYPE_WEAK_BINDER:
  136. if (obj.binder)
  137. static_cast(obj.binder)->decWeak(who);
  138. return;
  139. case BINDER_TYPE_HANDLE: {
  140. const sp b = proc->getStrongProxyForHandle(obj.handle);
  141. if (b != NULL) {
  142. LOG_REFS(“Parcel %p releasing reference on remote %p”, who, b.get());
  143. b->decStrong(who);
  144. }
  145. return;
  146. }
  147. case BINDER_TYPE_WEAK_HANDLE: {
  148. const wp b = proc->getWeakProxyForHandle(obj.handle);
  149. if (b != NULL) b.get_refs()->decWeak(who);
  150. return;
  151. }
  152. case BINDER_TYPE_FD: {
  153. if (obj.cookie != (void*)0) close(obj.handle);
  154. return;
  155. }
  156. } 

  158. LOGE(“Invalid object type 0x%08lx”, obj.type);
  159. } 

  161. inline static status_t finish_flatten_binder(
  162. const sp& binder, const flat_binder_object& flat, Parcel* out)
  163. {
  164. return out->writeObject(flat, false);
  165. } 

  167. status_t flatten_binder(const sp& proc,
  168. const sp& binder, Parcel* out)
  169. {
  170. flat_binder_object obj; 

  172. obj.flags = 0x7f | FLAT_BINDER_FLAG_ACCEPTS_FDS;
  173. if (binder != NULL) {
  174. IBinder *local = binder->localBinder();
  175. if (!local) {
  176. BpBinder *proxy = binder->remoteBinder();
  177. if (proxy == NULL) {
  178. LOGE(“null proxy”);
  179. }
  180. const int32_t handle = proxy ? proxy->handle() : 0;
  181. obj.type = BINDER_TYPE_HANDLE;
  182. obj.handle = handle;
  183. obj.cookie = NULL;
  184. } else {
  185. obj.type = BINDER_TYPE_BINDER;
  186. obj.binder = local->getWeakRefs();
  187. obj.cookie = local;
  188. }
  189. } else {
  190. obj.type = BINDER_TYPE_BINDER;
  191. obj.binder = NULL;
  192. obj.cookie = NULL;
  193. } 

  195. return finish_flatten_binder(binder, obj, out);
  196. } 

  198. status_t flatten_binder(const sp& proc,
  199. const wp& binder, Parcel* out)
  200. {
  201. flat_binder_object obj; 

  203. obj.flags = 0x7f | FLAT_BINDER_FLAG_ACCEPTS_FDS;
  204. if (binder != NULL) {
  205. sp real = binder.promote();
  206. if (real != NULL) {
  207. IBinder *local = real->localBinder();
  208. if (!local) {
  209. BpBinder *proxy = real->remoteBinder();
  210. if (proxy == NULL) {
  211. LOGE(“null proxy”);
  212. }
  213. const int32_t handle = proxy ? proxy->handle() : 0;
  214. obj.type = BINDER_TYPE_WEAK_HANDLE;
  215. obj.handle = handle;
  216. obj.cookie = NULL;
  217. } else {
  218. obj.type = BINDER_TYPE_WEAK_BINDER;
  219. obj.binder = binder.get_refs();
  220. obj.cookie = binder.unsafe_get();
  221. }
  222. return finish_flatten_binder(real, obj, out);
  223. } 

复制代码
java代码：
  1. // XXX How to deal? In order to flatten the given binder,
  2. // we need to probe it for information, which requires a primary
  3. // reference… but we don’t have one.
  4. //
  5. // The OpenBinder implementation uses a dynamic_cast<> here,
  6. // but we can’t do that with the different reference counting
  7. // implementation we are using.
  8. LOGE(“Unable to unflatten Binder weak reference!”);
  9. obj.type = BINDER_TYPE_BINDER;
  10. obj.binder = NULL;
  11. obj.cookie = NULL;
  12. return finish_flatten_binder(NULL, obj, out); 

  14. } else {
  15. obj.type = BINDER_TYPE_BINDER;
  16. obj.binder = NULL;
  17. obj.cookie = NULL;
  18. return finish_flatten_binder(NULL, obj, out);
  19. }
  20. } 

  22. inline static status_t finish_unflatten_binder(
  23. BpBinder* proxy, const flat_binder_object& flat, const Parcel& in)
  24. {
  25. return NO_ERROR;
  26. } 

  28. status_t unflatten_binder(const sp& proc,
  29. const Parcel& in, sp* out)
  30. {
  31. const flat_binder_object* flat = in.readObject(false); 

  33. if (flat) {
  34. switch (flat->type) {
  35. case BINDER_TYPE_BINDER:
  36. *out = static_cast(flat->cookie);
  37. return finish_unflatten_binder(NULL, *flat, in);
  38. case BINDER_TYPE_HANDLE:
  39. *out = proc->getStrongProxyForHandle(flat->handle);
  40. return finish_unflatten_binder(
  41. static_cast(out->get()), *flat, in);
  42. }
  43. }
  44. return BAD_TYPE;
  45. } 

  47. status_t unflatten_binder(const sp& proc,
  48. const Parcel& in, wp* out)
  49. {
  50. const flat_binder_object* flat = in.readObject(false); 

  52. if (flat) {
  53. switch (flat->type) {
  54. case BINDER_TYPE_BINDER:
  55. *out = static_cast(flat->cookie);
  56. return finish_unflatten_binder(NULL, *flat, in);
  57. case BINDER_TYPE_WEAK_BINDER:
  58. if (flat->binder != NULL) {
  59. out->set_object_and_refs(
  60. static_cast(flat->cookie),
  61. static_cast(flat->binder));
  62. } else {
  63. *out = NULL;
  64. }
  65. return finish_unflatten_binder(NULL, *flat, in);
  66. case BINDER_TYPE_HANDLE:
  67. case BINDER_TYPE_WEAK_HANDLE:
  68. *out = proc->getWeakProxyForHandle(flat->handle);
  69. return finish_unflatten_binder(
  70. static_cast(out->unsafe_get()), *flat, in);
  71. }
  72. }
  73. return BAD_TYPE;
  74. } 

  76. // ————————————————————————— 

  78. Parcel::Parcel()
  79. {
  80. initState();
  81. } 

  83. Parcel::~Parcel()
  84. {
  85. freeDataNoInit();
  86. } 

  88. const uint8_t* Parcel::data() const
  89. {
  90. return mData;
  91. } 

  93. size_t Parcel::dataSize() const
  94. {
  95. return (mDataSize > mDataPos ? mDataSize : mDataPos);
  96. } 

  98. size_t Parcel::dataAvail() const
  99. {
  100. // TODO: decide what to do about the possibility that this can
  101. // report an available-data size that exceeds a Java int’s max
  102. // positive value, causing havoc. Fortunately this will only
  103. // happen if someone constructs a Parcel containing more than two
  104. // gigabytes of data, which on typical phone hardware is simply
  105. // not possible.
  106. return dataSize() – dataPosition();
  107. } 

  109. size_t Parcel::dataPosition() const
  110. {
  111. return mDataPos;
  112. } 

  114. size_t Parcel::dataCapacity() const
  115. {
  116. return mDataCapacity;
  117. } 

  119. status_t Parcel::setDataSize(size_t size)
  120. {
  121. status_t err;
  122. err = continueWrite(size);
  123. if (err == NO_ERROR) {
  124. mDataSize = size;
  125. LOGV(“setDataSize Setting data size of %p to %d/n”, this, mDataSize);
  126. }
  127. return err;
  128. } 

  130. void Parcel::setDataPosition(size_t pos) const
  131. {
  132. mDataPos = pos;
  133. mNextObjectHint = 0;
  134. } 

  136. status_t Parcel::setDataCapacity(size_t size)
  137. {
  138. if (size > mDataSize) return continueWrite(size);
  139. return NO_ERROR;
  140. } 

  142. status_t Parcel::setData(const uint8_t* buffer, size_t len)
  143. {
  144. status_t err = restartWrite(len);
  145. if (err == NO_ERROR) {
  146. memcpy(const_cast(data()), buffer, len);
  147. mDataSize = len;
  148. mFdsKnown = false;
  149. }
  150. return err;
  151. } 

  153. status_t Parcel::appendFrom(Parcel *parcel, size_t offset, size_t len)
  154. {
  155. const sp proc(ProcessState::self());
  156. status_t err;
  157. uint8_t *data = parcel->mData;
  158. size_t *objects = parcel->mObjects;
  159. size_t size = parcel->mObjectsSize;
  160. int startPos = mDataPos;
  161. int firstIndex = -1, lastIndex = -2; 

  163. if (len == 0) {
  164. return NO_ERROR;
  165. } 

  167. // range checks against the source parcel size
  168. if ((offset > parcel->mDataSize)
  169. || (len > parcel->mDataSize)
  170. || (offset + len > parcel->mDataSize)) {
  171. return BAD_VALUE;
  172. } 

复制代码
本帖最后由 nuli 于 2011-9-14 15:13 编辑

java代码：
  1. // Count objects in range
  2. for (int i = 0; i < (int) size; i++) {
  3. size_t off = objects[i];
  4. if ((off >= offset) && (off < offset + len)) {
  5. if (firstIndex == -1) {
  6. firstIndex = i;
  7. }
  8. lastIndex = i;
  9. }
  10. }
  11. int numObjects = lastIndex - firstIndex + 1; 

  13. // grow data
  14. err = growData(len);
  15. if (err != NO_ERROR) {
  16. return err;
  17. } 

  19. // append data
  20. memcpy(mData + mDataPos, data + offset, len);
  21. mDataPos += len;
  22. mDataSize += len; 

  24. if (numObjects > 0) {
  25. // grow objects
  26. if (mObjectsCapacity < mObjectsSize + numObjects) {
  27. int newSize = ((mObjectsSize + numObjects)*3)/2;
  28. size_t *objects =
  29. (size_t*)realloc(mObjects, newSize*sizeof(size_t));
  30. if (objects == (size_t*)0) {
  31. return NO_MEMORY;
  32. }
  33. mObjects = objects;
  34. mObjectsCapacity = newSize;
  35. } 

  37. // append and acquire objects
  38. int idx = mObjectsSize;
  39. for (int i = firstIndex; i <= lastIndex; i++) {
  40. size_t off = objects[i] - offset + startPos;
  41. mObjects[idx++] = off;
  42. mObjectsSize++; 

  44. flat_binder_object* flat
  45. = reinterpret_cast(mData + off);
  46. acquire_object(proc, *flat, this); 

  48. if (flat->type == BINDER_TYPE_FD) {
  49. // If this is a file descriptor, we need to dup it so the
  50. // new Parcel now owns its own fd, and can declare that we
  51. // officially know we have fds.
  52. flat->handle = dup(flat->handle);
  53. flat->cookie = (void*)1;
  54. mHasFds = mFdsKnown = true;
  55. }
  56. }
  57. } 

  59. return NO_ERROR;
  60. } 

  62. bool Parcel::hasFileDescriptors() const
  63. {
  64. if (!mFdsKnown) {
  65. scanForFds();
  66. }
  67. return mHasFds;
  68. } 

  70. status_t Parcel::writeInterfaceToken(const String16& interface)
  71. {
  72. // currently the interface identification token is just its name as a string
  73. return writeString16(interface);
  74. } 

  76. bool Parcel::checkInterface(IBinder* binder) const
  77. {
  78. return enforceInterface(binder->getInterfaceDescriptor());
  79. } 

  81. bool Parcel::enforceInterface(const String16& interface) const
  82. {
  83. const String16 str(readString16());
  84. if (str == interface) {
  85. return true;
  86. } else {
  87. LOGW(“**** enforceInterface() expected ‘%s’ but read ‘%s’/n”,
  88. String8(interface).string(), String8(str).string());
  89. return false;
  90. }
  91. } 

  93. const size_t* Parcel::objects() const
  94. {
  95. return mObjects;
  96. } 

  98. size_t Parcel::objectsCount() const
  99. {
  100. return mObjectsSize;
  101. } 

  103. status_t Parcel::errorCheck() const
  104. {
  105. return mError;
  106. } 

  108. void Parcel::setError(status_t err)
  109. {
  110. mError = err;
  111. } 

  113. status_t Parcel::finishWrite(size_t len)
  114. {
  115. //printf(“Finish write of %d/n”, len);
  116. mDataPos += len;
  117. LOGV(“finishWrite Setting data pos of %p to %d/n”, this, mDataPos);
  118. if (mDataPos > mDataSize) {
  119. mDataSize = mDataPos;
  120. LOGV(“finishWrite Setting data size of %p to %d/n”, this, mDataSize);
  121. }
  122. //printf(“New pos=%d, size=%d/n”, mDataPos, mDataSize);
  123. return NO_ERROR;
  124. } 

  126. status_t Parcel::writeUnpadded(const void* data, size_t len)
  127. {
  128. size_t end = mDataPos + len;
  129. if (end < mDataPos) {
  130. // integer overflow
  131. return BAD_VALUE;
  132. } 
  133. if (end <= mDataCapacity) {
  134. restart_write:
  135. memcpy(mData+mDataPos, data, len);
  136. return finishWrite(len);
  137. } 
  138. status_t err = growData(len);
  139. if (err == NO_ERROR) goto restart_write;
  140. return err;
  141. } 
  142. status_t Parcel::write(const void* data, size_t len)
  143. {
  144. void* const d = writeInplace(len);
  145. if (d) {
  146. memcpy(d, data, len);
  147. return NO_ERROR;
  148. }
  149. return mError;
  150. } 
  151. void* Parcel::writeInplace(size_t len)
  152. {
  153. const size_t padded = PAD_SIZE(len); 
  154. // sanity check for integer overflow
  155. if (mDataPos+padded < mDataPos) {
  156. return NULL;
  157. } 
  158. if ((mDataPos+padded) <= mDataCapacity) {
  159. restart_write:
  160. //printf("Writing %ld bytes, padded to %ld/n", len, padded);
  161. uint8_t* const data = mData+mDataPos; 
  162. // Need to pad at end?
  163. if (padded != len) {
  164. #if BYTE_ORDER == BIG_ENDIAN
  165. static const uint32_t mask[4] = {
  166. 0x00000000, 0xffffff00, 0xffff0000, 0xff000000
  167. };
  168. #endif
  169. #if BYTE_ORDER == LITTLE_ENDIAN
  170. static const uint32_t mask[4] = {
  171. 0x00000000, 0x00ffffff, 0x0000ffff, 0x000000ff
  172. };
  173. #endif
  174. //printf("Applying pad mask: %p to %p/n", (void*)mask[padded-len],
  175. // *reinterpret_cast(data+padded-4));
  176. *reinterpret_cast(data+padded-4) &= mask[padded-len];
  177. } 
复制代码
本帖最后由 nuli 于 2011-9-14 15:14 编辑

java代码：
  1. finishWrite(padded);
  2. return data;
  3. } 

  5. status_t err = growData(padded);
  6. if (err == NO_ERROR) goto restart_write;
  7. return NULL;
  8. } 

  10. status_t Parcel::writeInt32(int32_t val)
  11. {
  12. return writeAligned(val);
  13. } 

  15. status_t Parcel::writeInt64(int64_t val)
  16. {
  17. return writeAligned(val);
  18. } 

  20. status_t Parcel::writeFloat(float val)
  21. {
  22. return writeAligned(val);
  23. } 

  25. status_t Parcel::writeDouble(double val)
  26. {
  27. return writeAligned(val);
  28. } 

  30. status_t Parcel::writeIntPtr(intptr_t val)
  31. {
  32. return writeAligned(val);
  33. } 

  35. status_t Parcel::writeCString(const char* str)
  36. {
  37. return write(str, strlen(str)+1);
  38. } 

  40. status_t Parcel::writeString8(const String8& str)
  41. {
  42. status_t err = writeInt32(str.bytes());
  43. if (err == NO_ERROR) {
  44. err = write(str.string(), str.bytes()+1);
  45. }
  46. return err;
  47. } 

  49. status_t Parcel::writeString16(const String16& str)
  50. {
  51. return writeString16(str.string(), str.size());
  52. } 

  54. status_t Parcel::writeString16(const char16_t* str, size_t len)
  55. {
  56. if (str == NULL) return writeInt32(-1); 

  58. status_t err = writeInt32(len);
  59. if (err == NO_ERROR) {
  60. len *= sizeof(char16_t);
  61. uint8_t* data = (uint8_t*)writeInplace(len+sizeof(char16_t));
  62. if (data) {
  63. memcpy(data, str, len);
  64. *reinterpret_cast(data+len) = 0;
  65. return NO_ERROR;
  66. }
  67. err = mError;
  68. }
  69. return err;
  70. } 

  72. status_t Parcel::writeStrongBinder(const sp& val)
  73. {
  74. return flatten_binder(ProcessState::self(), val, this);
  75. } 

  77. status_t Parcel::writeWeakBinder(const wp& val)
  78. {
  79. return flatten_binder(ProcessState::self(), val, this);
  80. } 

  82. status_t Parcel::writeNativeHandle(const native_handle* handle)
  83. {
  84. if (!handle || handle->version != sizeof(native_handle))
  85. return BAD_TYPE; 

  87. status_t err;
  88. err = writeInt32(handle->numFds);
  89. if (err != NO_ERROR) return err; 

  91. err = writeInt32(handle->numInts);
  92. if (err != NO_ERROR) return err; 

  94. for (int i=0 ; err==NO_ERROR && inumFds ; i++)
  95. err = writeDupFileDescriptor(handle->data[i]); 

  97. if (err != NO_ERROR) {
  98. LOGD(“write native handle, write dup fd failed”);
  99. return err;
  100. }
  101. err = write(handle->data + handle->numFds, sizeof(int)*handle->numInts);
  102. return err;
  103. } 

  105. status_t Parcel::writeFileDescriptor(int fd)
  106. {
  107. flat_binder_object obj;
  108. obj.type = BINDER_TYPE_FD;
  109. obj.flags = 0x7f | FLAT_BINDER_FLAG_ACCEPTS_FDS;
  110. obj.handle = fd;
  111. obj.cookie = (void*)0;
  112. return writeObject(obj, true);
  113. } 

  115. status_t Parcel::writeDupFileDescriptor(int fd)
  116. {
  117. flat_binder_object obj;
  118. obj.type = BINDER_TYPE_FD;
  119. obj.flags = 0x7f | FLAT_BINDER_FLAG_ACCEPTS_FDS;
  120. obj.handle = dup(fd);
  121. obj.cookie = (void*)1;
  122. return writeObject(obj, true);
  123. } 

  125. status_t Parcel::write(const Flattenable& val)
  126. {
  127. status_t err; 

  129. // size if needed
  130. size_t len = val.getFlattenedSize();
  131. size_t fd_count = val.getFdCount(); 

  133. err = this->writeInt32(len);
  134. if (err) return err; 

  136. err = this->writeInt32(fd_count);
  137. if (err) return err; 

  139. // payload
  140. void* buf = this->writeInplace(PAD_SIZE(len));
  141. if (buf == NULL)
  142. return BAD_VALUE; 

  144. int* fds = NULL;
  145. if (fd_count) {
  146. fds = new int[fd_count];
  147. } 

  149. err = val.flatten(buf, len, fds, fd_count);
  150. for (size_t i=0 ; i err = this->writeDupFileDescriptor( fds[i] );
  151. } 

  153. if (fd_count) {
  154. delete [] fds;
  155. } 

  157. return err;
  158. } 

  160. status_t Parcel::writeObject(const flat_binder_object& val, bool nullMetaData)
  161. {
  162. const bool enoughData = (mDataPos+sizeof(val)) <= mDataCapacity;
  163. const bool enoughObjects = mObjectsSize < mObjectsCapacity;
  164. if (enoughData && enoughObjects) {
  165. restart_write:
  166. *reinterpret_cast(mData+mDataPos) = val; 

  168. // Need to write meta-data?
  169. if (nullMetaData || val.binder != NULL) {
  170. mObjects[mObjectsSize] = mDataPos;
  171. acquire_object(ProcessState::self(), val, this);
  172. mObjectsSize++;
  173. } 

  175. // remember if it’s a file descriptor
  176. if (val.type == BINDER_TYPE_FD) {
  177. mHasFds = mFdsKnown = true;
  178. } 

  180. return finishWrite(sizeof(flat_binder_object));
  181. } 

  183. if (!enoughData) {
  184. const status_t err = growData(sizeof(val));
  185. if (err != NO_ERROR) return err;
  186. }
  187. if (!enoughObjects) {
  188. size_t newSize = ((mObjectsSize+2)*3)/2;
  189. size_t* objects = (size_t*)realloc(mObjects, newSize*sizeof(size_t));
  190. if (objects == NULL) return NO_MEMORY;
  191. mObjects = objects;
  192. mObjectsCapacity = newSize;
  193. } 

复制代码

猜你喜欢

转载自huaonline.iteye.com/blog/1755011
今日推荐
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
周排行
计算机组成与设计（七）—— 除法器
Integer Approximation(分治+枚举)
大话数据库索引
windows10系统JDK的配置及下载地址
mysql实现秒值转换中原六仔平台搭建
Codeforces Round #556 (Div. 1)
百练1064 网线主管
Codeforces 995F Cowmpany Cowmpensation
子集生成之增量构造法，位向量法，二进制法
ERROR: cmd.exe failed with args /c "/APK\gradle\rungradle.bat...
每日归档
更多
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022