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

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

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

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

java代码：

1. finishWrite(padded);
   
2. return data;
   
3. }?
   
4. 
   
5. status_t err = growData(padded);
   
6. if (err == NO_ERROR) goto restart_write;
   
7. return NULL;
   
8. }?
   
9. 
   
10. status_t Parcel::writeInt32(int32_t val)
    
11. {
    
12. return writeAligned(val);
    
13. }?
    
14. 
    
15. status_t Parcel::writeInt64(int64_t val)
    
16. {
    
17. return writeAligned(val);
    
18. }?
    
19. 
    
20. status_t Parcel::writeFloat(float val)
    
21. {
    
22. return writeAligned(val);
    
23. }?
    
24. 
    
25. status_t Parcel::writeDouble(double val)
    
26. {
    
27. return writeAligned(val);
    
28. }?
    
29. 
    
30. status_t Parcel::writeIntPtr(intptr_t val)
    
31. {
    
32. return writeAligned(val);
    
33. }?
    
34. 
    
35. status_t Parcel::writeCString(const char* str)
    
36. {
    
37. return write(str, strlen(str)+1);
    
38. }?
    
39. 
    
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. }?
    
48. 
    
49. status_t Parcel::writeString16(const String16& str)
    
50. {
    
51. return writeString16(str.string(), str.size());
    
52. }?
    
53. 
    
54. status_t Parcel::writeString16(const char16_t* str, size_t len)
    
55. {
    
56. if (str == NULL) return writeInt32(-1);?
    
57. 
    
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. }?
    
71. 
    
72. status_t Parcel::writeStrongBinder(const sp& val)
    
73. {
    
74. return flatten_binder(ProcessState::self(), val, this);
    
75. }?
    
76. 
    
77. status_t Parcel::writeWeakBinder(const wp& val)
    
78. {
    
79. return flatten_binder(ProcessState::self(), val, this);
    
80. }?
    
81. 
    
82. status_t Parcel::writeNativeHandle(const native_handle* handle)
    
83. {
    
84. if (!handle || handle->version != sizeof(native_handle))
    
85. return BAD_TYPE;?
    
86. 
    
87. status_t err;
    
88. err = writeInt32(handle->numFds);
    
89. if (err != NO_ERROR) return err;?
    
90. 
    
91. err = writeInt32(handle->numInts);
    
92. if (err != NO_ERROR) return err;?
    
93. 
    
94. for (int i=0 ; err==NO_ERROR && inumFds ; i++)
    
95. err = writeDupFileDescriptor(handle->data[i]);?
    
96. 
    
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. }?
     
104. 
     
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. }?
     
114. 
     
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. }?
     
124. 
     
125. status_t Parcel::write(const Flattenable& val)
     
126. {
     
127. status_t err;?
     
128. 
     
129. // size if needed
     
130. size_t len = val.getFlattenedSize();
     
131. size_t fd_count = val.getFdCount();?
     
132. 
     
133. err = this->writeInt32(len);
     
134. if (err) return err;?
     
135. 
     
136. err = this->writeInt32(fd_count);
     
137. if (err) return err;?
     
138. 
     
139. // payload
     
140. void* buf = this->writeInplace(PAD_SIZE(len));
     
141. if (buf == NULL)
     
142. return BAD_VALUE;?
     
143. 
     
144. int* fds = NULL;
     
145. if (fd_count) {
     
146. fds = new int[fd_count];
     
147. }?
     
148. 
     
149. err = val.flatten(buf, len, fds, fd_count);
     
150. for (size_t i=0 ; i err = this->writeDupFileDescriptor( fds[i] );
     
151. }?
     
152. 
     
153. if (fd_count) {
     
154. delete [] fds;
     
155. }?
     
156. 
     
157. return err;
     
158. }?
     
159. 
     
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;?
     
167. 
     
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. }?
     
174. 
     
175. // remember if it’s a file descriptor
     
176. if (val.type == BINDER_TYPE_FD) {
     
177. mHasFds = mFdsKnown = true;
     
178. }?
     
179. 
     
180. return finishWrite(sizeof(flat_binder_object));
     
181. }?
     
182. 
     
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. }?
     
194.