一．先从Serialize说起

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

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

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

三．Parcel类的背后

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

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

典型的源码片断如下：

[java] view plain copy print ?

1. /**
2. *WriteanintegervalueintotheparcelatthecurrentdataPosition(),
3. *growingdataCapacity()ifneeded.
4. */
5. publicfinalnativevoidwriteInt(intval);
7. /**
8. *WritealongintegervalueintotheparcelatthecurrentdataPosition(),
9. *growingdataCapacity()ifneeded.
10. */
11. publicfinalnativevoidwriteLong(longval);

/** * 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 plain copy print ?

1. staticvoidandroid_os_Parcel_writeInt(JNIEnv*env,jobjectclazz,jintval)
2. {
3. Parcel*parcel=parcelForJavaObject(env,clazz);
4. if(parcel!=NULL){
5. conststatus_terr=parcel->writeInt32(val);
6. if(err!=NO_ERROR){
7. jniThrowException(env,"java/lang/OutOfMemoryError",NULL);
8. }
9. }
10. }
12. staticvoidandroid_os_Parcel_writeLong(JNIEnv*env,jobjectclazz,jlongval)
13. {
14. Parcel*parcel=parcelForJavaObject(env,clazz);
15. if(parcel!=NULL){
16. conststatus_terr=parcel->writeInt64(val);
17. if(err!=NO_ERROR){
18. jniThrowException(env,"java/lang/OutOfMemoryError",NULL);
19. }
20. }
21. }

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 plain copy print ?

1. /*
2. *Copyright(C)2005TheAndroidOpenSourceProject
3. *
4. *LicensedundertheApacheLicense,Version2.0(the"License");
5. *youmaynotusethisfileexceptincompliancewiththeLicense.
6. *YoumayobtainacopyoftheLicenseat
7. *
8. *http://www.apache.org/licenses/LICENSE-2.0
9. *
10. *Unlessrequiredbyapplicablelaworagreedtoinwriting,software
11. *distributedundertheLicenseisdistributedonan"ASIS"BASIS,
12. *WITHOUTWARRANTIESORCONDITIONSOFANYKIND,eitherexpressorimplied.
13. *SeetheLicenseforthespecificlanguagegoverningpermissionsand
14. *limitationsundertheLicense.
15. */
17. #ifndefANDROID_PARCEL_H
18. #defineANDROID_PARCEL_H
20. #include<cutils/native_handle.h>
21. #include<utils/Errors.h>
22. #include<utils/RefBase.h>
23. #include<utils/String16.h>
24. #include<utils/Vector.h>
26. //---------------------------------------------------------------------------
27. namespaceandroid{
29. classIBinder;
30. classProcessState;
31. classString8;
32. classTextOutput;
33. classFlattenable;
35. structflat_binder_object;//definedinsupport_p/binder_module.h
37. classParcel
38. {
39. public:
40. Parcel();
41. ~Parcel();
43. constuint8_t*data()const;
44. size_tdataSize()const;
45. size_tdataAvail()const;
46. size_tdataPosition()const;
47. size_tdataCapacity()const;
49. status_tsetDataSize(size_tsize);
50. voidsetDataPosition(size_tpos)const;
51. status_tsetDataCapacity(size_tsize);
53. status_tsetData(constuint8_t*buffer,size_tlen);
55. status_tappendFrom(Parcel*parcel,size_tstart,size_tlen);
57. boolhasFileDescriptors()const;
59. status_twriteInterfaceToken(constString16&interface);
60. boolenforceInterface(constString16&interface)const;
61. boolcheckInterface(IBinder*)const;
63. voidfreeData();
65. constsize_t*objects()const;
66. size_tobjectsCount()const;
68. status_terrorCheck()const;
69. voidsetError(status_terr);
71. status_twrite(constvoid*data,size_tlen);
72. void*writeInplace(size_tlen);
73. status_twriteUnpadded(constvoid*data,size_tlen);
74. status_twriteInt32(int32_tval);
75. status_twriteInt64(int64_tval);
76. status_twriteFloat(floatval);
77. status_twriteDouble(doubleval);
78. status_twriteIntPtr(intptr_tval);
79. status_twriteCString(constchar*str);
80. status_twriteString8(constString8&str);
81. status_twriteString16(constString16&str);
82. status_twriteString16(constchar16_t*str,size_tlen);
83. status_twriteStrongBinder(constsp<IBinder>&val);
84. status_twriteWeakBinder(constwp<IBinder>&val);
85. status_twrite(constFlattenable&val);
87. //Placeanative_handleintotheparcel(thenative_handle'sfile-
88. //descriptorsaredup'ed,soitissafetodeletethenative_handle
89. //whenthisfunctionreturns).
90. //Doesn'ttakeownershipofthenative_handle.
91. status_twriteNativeHandle(constnative_handle*handle);
93. //Placeafiledescriptorintotheparcel.Thegivenfdmustremain
94. //validforthelifetimeoftheparcel.
95. status_twriteFileDescriptor(intfd);
97. //Placeafiledescriptorintotheparcel.Adupofthefdismade,which
98. //willbeclosedoncetheparcelisdestroyed.
99. status_twriteDupFileDescriptor(intfd);
101. status_twriteObject(constflat_binder_object&val,boolnullMetaData);
103. voidremove(size_tstart,size_tamt);
105. status_tread(void*outData,size_tlen)const;
106. constvoid*readInplace(size_tlen)const;
107. int32_treadInt32()const;
108. status_treadInt32(int32_t*pArg)const;
109. int64_treadInt64()const;
110. status_treadInt64(int64_t*pArg)const;
111. floatreadFloat()const;
112. status_treadFloat(float*pArg)const;
113. doublereadDouble()const;
114. status_treadDouble(double*pArg)const;
115. intptr_treadIntPtr()const;
116. status_treadIntPtr(intptr_t*pArg)const;
118. constchar*readCString()const;
119. String8readString8()const;
120. String16readString16()const;
121. constchar16_t*readString16Inplace(size_t*outLen)const;
122. sp<IBinder>readStrongBinder()const;
123. wp<IBinder>readWeakBinder()const;
124. status_tread(Flattenable&val)const;
126. //Retrievenative_handlefromtheparcel.Thisreturnsacopyofthe
127. //parcel'snative_handle(thecallertakesownership).Thecaller
128. //mustfreethenative_handlewithnative_handle_close()and
129. //native_handle_delete().
130. native_handle*readNativeHandle()const;
133. //Retrieveafiledescriptorfromtheparcel.Thisreturnstherawfd
134. //intheparcel,whichyoudonotown--usedup()togetyourowncopy.
135. intreadFileDescriptor()const;
137. constflat_binder_object*readObject(boolnullMetaData)const;
139. //Explicitlycloseallfiledescriptorsintheparcel.
140. voidcloseFileDescriptors();
142. typedefvoid(*release_func)(Parcel*parcel,
143. constuint8_t*data,size_tdataSize,
144. constsize_t*objects,size_tobjectsSize,
145. void*cookie);
147. constuint8_t*ipcData()const;
148. size_tipcDataSize()const;
149. constsize_t*ipcObjects()const;
150. size_tipcObjectsCount()const;
151. voidipcSetDataReference(constuint8_t*data,size_tdataSize,
152. constsize_t*objects,size_tobjectsCount,
153. release_funcrelFunc,void*relCookie);
155. voidprint(TextOutput&to,uint32_tflags=0)const;
157. private:
158. Parcel(constParcel&o);
159. Parcel&operator=(constParcel&o);
161. status_tfinishWrite(size_tlen);
162. voidreleaseObjects();
163. voidacquireObjects();
164. status_tgrowData(size_tlen);
165. status_trestartWrite(size_tdesired);
166. status_tcontinueWrite(size_tdesired);
167. voidfreeDataNoInit();
168. voidinitState();
169. voidscanForFds()const;
171. template<classT>
172. status_treadAligned(T*pArg)const;
174. template<classT>TreadAligned()const;
176. template<classT>
177. status_twriteAligned(Tval);
179. status_tmError;
180. uint8_t*mData;
181. size_tmDataSize;
182. size_tmDataCapacity;
183. mutablesize_tmDataPos;
184. size_t*mObjects;
185. size_tmObjectsSize;
186. size_tmObjectsCapacity;
187. mutablesize_tmNextObjectHint;
189. mutableboolmFdsKnown;
190. mutableboolmHasFds;
192. release_funcmOwner;
193. void*mOwnerCookie;
194. };
196. //---------------------------------------------------------------------------
198. inlineTextOutput&operator<<(TextOutput&to,constParcel&parcel)
199. {
200. parcel.print(to);
201. returnto;
202. }
204. //---------------------------------------------------------------------------
206. //Genericacquireandreleaseofobjects.
207. voidacquire_object(constsp<ProcessState>&proc,
208. constflat_binder_object&obj,constvoid*who);
209. voidrelease_object(constsp<ProcessState>&proc,
210. constflat_binder_object&obj,constvoid*who);
212. voidflatten_binder(constsp<ProcessState>&proc,
213. constsp<IBinder>&binder,flat_binder_object*out);
214. voidflatten_binder(constsp<ProcessState>&proc,
215. constwp<IBinder>&binder,flat_binder_object*out);
216. status_tunflatten_binder(constsp<ProcessState>&proc,
217. constflat_binder_object&flat,sp<IBinder>*out);
218. status_tunflatten_binder(constsp<ProcessState>&proc,
219. constflat_binder_object&flat,wp<IBinder>*out);
221. };//namespaceandroid
223. //---------------------------------------------------------------------------
225. #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 plain copy print ?

1. /*
2. *Copyright(C)2005TheAndroidOpenSourceProject
3. *
4. *LicensedundertheApacheLicense,Version2.0(the"License");
5. *youmaynotusethisfileexceptincompliancewiththeLicense.
6. *YoumayobtainacopyoftheLicenseat
7. *
8. *http://www.apache.org/licenses/LICENSE-2.0
9. *
10. *Unlessrequiredbyapplicablelaworagreedtoinwriting,software
11. *distributedundertheLicenseisdistributedonan"ASIS"BASIS,
12. *WITHOUTWARRANTIESORCONDITIONSOFANYKIND,eitherexpressorimplied.
13. *SeetheLicenseforthespecificlanguagegoverningpermissionsand
14. *limitationsundertheLicense.
15. */
17. #defineLOG_TAG"Parcel"
18. //#defineLOG_NDEBUG0
20. #include<binder/Parcel.h>
22. #include<binder/Binder.h>
23. #include<binder/BpBinder.h>
24. #include<utils/Debug.h>
25. #include<binder/ProcessState.h>
26. #include<utils/Log.h>
27. #include<utils/String8.h>
28. #include<utils/String16.h>
29. #include<utils/TextOutput.h>
30. #include<utils/misc.h>
31. #include<utils/Flattenable.h>
33. #include<private/binder/binder_module.h>
35. #include<stdio.h>
36. #include<stdlib.h>
37. #include<stdint.h>
39. #ifndefINT32_MAX
40. #defineINT32_MAX((int32_t)(2147483647))
41. #endif
43. #defineLOG_REFS(...)
44. //#defineLOG_REFS(...)LOG(LOG_DEBUG,"Parcel",__VA_ARGS__)
46. //---------------------------------------------------------------------------
48. #definePAD_SIZE(s)(((s)+3)&~3)
50. //XXXThiscanbemadepublicifwewanttoprovide
51. //supportfortypeddata.
52. structsmall_flat_data
53. {
54. uint32_ttype;
55. uint32_tdata;
56. };
58. namespaceandroid{
60. voidacquire_object(constsp<ProcessState>&proc,
61. constflat_binder_object&obj,constvoid*who)
62. {
63. switch(obj.type){
64. caseBINDER_TYPE_BINDER:
65. if(obj.binder){
66. LOG_REFS("Parcel%pacquiringreferenceonlocal%p",who,obj.cookie);
67. static_cast<IBinder*>(obj.cookie)->incStrong(who);
68. }
69. return;
70. caseBINDER_TYPE_WEAK_BINDER:
71. if(obj.binder)
72. static_cast<RefBase::weakref_type*>(obj.binder)->incWeak(who);
73. return;
74. caseBINDER_TYPE_HANDLE:{
75. constsp<IBinder>b=proc->getStrongProxyForHandle(obj.handle);
76. if(b!=NULL){
77. LOG_REFS("Parcel%pacquiringreferenceonremote%p",who,b.get());
78. b->incStrong(who);
79. }
80. return;
81. }
82. caseBINDER_TYPE_WEAK_HANDLE:{
83. constwp<IBinder>b=proc->getWeakProxyForHandle(obj.handle);
84. if(b!=NULL)b.get_refs()->incWeak(who);
85. return;
86. }
87. caseBINDER_TYPE_FD:{
88. //intentionallyblank--nothingtodotoacquirethis,butwedo
89. //recognizeitasalegitimateobjecttype.
90. return;
91. }
92. }
94. LOGD("Invalidobjecttype0x%08lx",obj.type);
95. }
97. voidrelease_object(constsp<ProcessState>&proc,
98. constflat_binder_object&obj,constvoid*who)
99. {
100. switch(obj.type){
101. caseBINDER_TYPE_BINDER:
102. if(obj.binder){
103. LOG_REFS("Parcel%preleasingreferenceonlocal%p",who,obj.cookie);
104. static_cast<IBinder*>(obj.cookie)->decStrong(who);
105. }
106. return;
107. caseBINDER_TYPE_WEAK_BINDER:
108. if(obj.binder)
109. static_cast<RefBase::weakref_type*>(obj.binder)->decWeak(who);
110. return;
111. caseBINDER_TYPE_HANDLE:{
112. constsp<IBinder>b=proc->getStrongProxyForHandle(obj.handle);
113. if(b!=NULL){
114. LOG_REFS("Parcel%preleasingreferenceonremote%p",who,b.get());
115. b->decStrong(who);
116. }
117. return;
118. }
119. caseBINDER_TYPE_WEAK_HANDLE:{
120. constwp<IBinder>b=proc->getWeakProxyForHandle(obj.handle);
121. if(b!=NULL)b.get_refs()->decWeak(who);
122. return;
123. }
124. caseBINDER_TYPE_FD:{
125. if(obj.cookie!=(void*)0)close(obj.handle);
126. return;
127. }
128. }
130. LOGE("Invalidobjecttype0x%08lx",obj.type);
131. }
133. inlinestaticstatus_tfinish_flatten_binder(
134. constsp<IBinder>&binder,constflat_binder_object&flat,Parcel*out)
135. {
136. returnout->writeObject(flat,false);
137. }
139. status_tflatten_binder(constsp<ProcessState>&proc,
140. constsp<IBinder>&binder,Parcel*out)
141. {
142. flat_binder_objectobj;
144. obj.flags=0x7f|FLAT_BINDER_FLAG_ACCEPTS_FDS;
145. if(binder!=NULL){
146. IBinder*local=binder->localBinder();
147. if(!local){
148. BpBinder*proxy=binder->remoteBinder();
149. if(proxy==NULL){
150. LOGE("nullproxy");
151. }
152. constint32_thandle=proxy?proxy->handle():0;
153. obj.type=BINDER_TYPE_HANDLE;
154. obj.handle=handle;
155. obj.cookie=NULL;
156. }else{
157. obj.type=BINDER_TYPE_BINDER;
158. obj.binder=local->getWeakRefs();
159. obj.cookie=local;
160. }
161. }else{
162. obj.type=BINDER_TYPE_BINDER;
163. obj.binder=NULL;
164. obj.cookie=NULL;
165. }
167. returnfinish_flatten_binder(binder,obj,out);
168. }
170. status_tflatten_binder(constsp<ProcessState>&proc,
171. constwp<IBinder>&binder,Parcel*out)
172. {
173. flat_binder_objectobj;
175. obj.flags=0x7f|FLAT_BINDER_FLAG_ACCEPTS_FDS;
176. if(binder!=NULL){
177. sp<IBinder>real=binder.promote();
178. if(real!=NULL){
179. IBinder*local=real->localBinder();
180. if(!local){
181. BpBinder*proxy=real->remoteBinder();
182. if(proxy==NULL){
183. LOGE("nullproxy");
184. }
185. constint32_thandle=proxy?proxy->handle():0;
186. obj.type=BINDER_TYPE_WEAK_HANDLE;
187. obj.handle=handle;
188. obj.cookie=NULL;
189. }else{
190. obj.type=BINDER_TYPE_WEAK_BINDER;
191. obj.binder=binder.get_refs();
192. obj.cookie=binder.unsafe_get();
193. }
194. returnfinish_flatten_binder(real,obj,out);
195. }
197. //XXXHowtodeal?Inordertoflattenthegivenbinder,
198. //weneedtoprobeitforinformation,whichrequiresaprimary
199. //reference...butwedon'thaveone.
200. //
201. //TheOpenBinderimplementationusesadynamic_cast<>here,
202. //butwecan'tdothatwiththedifferentreferencecounting
203. //implementationweareusing.
204. LOGE("UnabletounflattenBinderweakreference!");
205. obj.type=BINDER_TYPE_BINDER;
206. obj.binder=NULL;
207. obj.cookie=NULL;
208. returnfinish_flatten_binder(NULL,obj,out);
210. }else{
211. obj.type=BINDER_TYPE_BINDER;
212. obj.binder=NULL;
213. obj.cookie=NULL;
214. returnfinish_flatten_binder(NULL,obj,out);
215. }
216. }
218. inlinestaticstatus_tfinish_unflatten_binder(
219. BpBinder*proxy,constflat_binder_object&flat,constParcel&in)
220. {
221. returnNO_ERROR;
222. }
224. status_tunflatten_binder(constsp<ProcessState>&proc,
225. constParcel&in,sp<IBinder>*out)
226. {
227. constflat_binder_object*flat=in.readObject(false);
229. if(flat){
230. switch(flat->type){
231. caseBINDER_TYPE_BINDER:
232. *out=static_cast<IBinder*>(flat->cookie);
233. returnfinish_unflatten_binder(NULL,*flat,in);
234. caseBINDER_TYPE_HANDLE:
235. *out=proc->getStrongProxyForHandle(flat->handle);
236. returnfinish_unflatten_binder(
237. static_cast<BpBinder*>(out->get()),*flat,in);
238. }
239. }
240. returnBAD_TYPE;
241. }
243. status_tunflatten_binder(constsp<ProcessState>&proc,
244. constParcel&in,wp<IBinder>*out)
245. {
246. constflat_binder_object*flat=in.readObject(false);
248. if(flat){
249. switch(flat->type){
250. caseBINDER_TYPE_BINDER:
251. *out=static_cast<IBinder*>(flat->cookie);
252. returnfinish_unflatten_binder(NULL,*flat,in);
253. caseBINDER_TYPE_WEAK_BINDER:
254. if(flat->binder!=NULL){
255. out->set_object_and_refs(
256. static_cast<IBinder*>(flat->cookie),
257. static_cast<RefBase::weakref_type*>(flat->binder));
258. }else{
259. *out=NULL;
260. }
261. returnfinish_unflatten_binder(NULL,*flat,in);
262. caseBINDER_TYPE_HANDLE:
263. caseBINDER_TYPE_WEAK_HANDLE:
264. *out=proc->getWeakProxyForHandle(flat->handle);
265. returnfinish_unflatten_binder(
266. static_cast<BpBinder*>(out->unsafe_get()),*flat,in);
267. }
268. }
269. returnBAD_TYPE;
270. }
272. //---------------------------------------------------------------------------
274. Parcel::Parcel()
275. {
276. initState();
277. }
279. Parcel::~Parcel()
280. {
281. freeDataNoInit();
282. }
284. constuint8_t*Parcel::data()const
285. {
286. returnmData;
287. }
289. size_tParcel::dataSize()const
290. {
291. return(mDataSize>mDataPos?mDataSize:mDataPos);
292. }
294. size_tParcel::dataAvail()const
295. {
296. //TODO:decidewhattodoaboutthepossibilitythatthiscan
297. //reportanavailable-datasizethatexceedsaJavaint'smax
298. //positivevalue,causinghavoc.Fortunatelythiswillonly
299. //happenifsomeoneconstructsaParcelcontainingmorethantwo
300. //gigabytesofdata,whichontypicalphonehardwareissimply
301. //notpossible.
302. returndataSize()-dataPosition();
303. }
305. size_tParcel::dataPosition()const
306. {
307. returnmDataPos;
308. }
310. size_tParcel::dataCapacity()const
311. {
312. returnmDataCapacity;
313. }
315. status_tParcel::setDataSize(size_tsize)
316. {
317. status_terr;
318. err=continueWrite(size);
319. if(err==NO_ERROR){
320. mDataSize=size;
321. LOGV("setDataSizeSettingdatasizeof%pto%d/n",this,mDataSize);
322. }
323. returnerr;
324. }
326. voidParcel::setDataPosition(size_tpos)const
327. {
328. mDataPos=pos;
329. mNextObjectHint=0;
330. }
332. status_tParcel::setDataCapacity(size_tsize)
333. {
334. if(size>mDataSize)returncontinueWrite(size);
335. returnNO_ERROR;
336. }
338. status_tParcel::setData(constuint8_t*buffer,size_tlen)
339. {
340. status_terr=restartWrite(len);
341. if(err==NO_ERROR){
342. memcpy(const_cast<uint8_t*>(data()),buffer,len);
343. mDataSize=len;
344. mFdsKnown=false;
345. }
346. returnerr;
347. }
349. status_tParcel::appendFrom(Parcel*parcel,size_toffset,size_tlen)
350. {
351. constsp<ProcessState>proc(ProcessState::self());
352. status_terr;
353. uint8_t*data=parcel->mData;
354. size_t*objects=parcel->mObjects;
355. size_tsize=parcel->mObjectsSize;
356. intstartPos=mDataPos;
357. intfirstIndex=-1,lastIndex=-2;
359. if(len==0){
360. returnNO_ERROR;
361. }
363. //rangechecksagainstthesourceparcelsize
364. if((offset>parcel->mDataSize)
365. ||(len>parcel->mDataSize)
366. ||(offset+len>parcel->mDataSize)){
367. returnBAD_VALUE;
368. }
370. //Countobjectsinrange
371. for(inti=0;i<(int)size;i++){
372. size_toff=objects[i];
373. if((off>=offset)&&(off<offset+len)){
374. if(firstIndex==-1){
375. firstIndex=i;
376. }
377. lastIndex=i;
378. }
379. }
380. intnumObjects=lastIndex-firstIndex+1;
382. //growdata
383. err=growData(len);
384. if(err!=NO_ERROR){
385. returnerr;
386. }
388. //appenddata
389. memcpy(mData+mDataPos,data+offset,len);
390. mDataPos+=len;
391. mDataSize+=len;
393. if(numObjects>0){
394. //growobjects
395. if(mObjectsCapacity<mObjectsSize+numObjects){
396. intnewSize=((mObjectsSize+numObjects)*3)/2;
397. size_t*objects=
398. (size_t*)realloc(mObjects,newSize*sizeof(size_t));
399. if(objects==(size_t*)0){
400. returnNO_MEMORY;
401. }
402. mObjects=objects;
403. mObjectsCapacity=newSize;
404. }
406. //appendandacquireobjects
407. intidx=mObjectsSize;
408. for(inti=firstIndex;i<=lastIndex;i++){
409. size_toff=objects[i]-offset+startPos;
410. mObjects[idx++]=off;
411. mObjectsSize++;
413. flat_binder_object*flat
414. =reinterpret_cast<flat_binder_object*>(mData+off);
415. acquire_object(proc,*flat,this);
417. if(flat->type==BINDER_TYPE_FD){
418. //Ifthisisafiledescriptor,weneedtodupitsothe
419. //newParcelnowownsitsownfd,andcandeclarethatwe
420. //officiallyknowwehavefds.
421. flat->handle=dup(flat->handle);
422. flat->cookie=(void*)1;
423. mHasFds=mFdsKnown=true;
424. }
425. }
426. }
428. returnNO_ERROR;
429. }
431. boolParcel::hasFileDescriptors()const
432. {
433. if(!mFdsKnown){
434. scanForFds();
435. }
436. returnmHasFds;
437. }
439. status_tParcel::writeInterfaceToken(constString16&interface)
440. {
441. //currentlytheinterfaceidentificationtokenisjustitsnameasastring
442. returnwriteString16(interface);
443. }
445. boolParcel::checkInterface(IBinder*binder)const
446. {
447. returnenforceInterface(binder->getInterfaceDescriptor());
448. }
450. boolParcel::enforceInterface(constString16&interface)const
451. {
452. constString16str(readString16());
453. if(str==interface){
454. returntrue;
455. }else{
456. LOGW("****enforceInterface()expected'%s'butread'%s'/n",
457. String8(interface).string(),String8(str).string());
458. returnfalse;
459. }
460. }
462. constsize_t*Parcel::objects()const
463. {
464. returnmObjects;
465. }
467. size_tParcel::objectsCount()const
468. {
469. returnmObjectsSize;
470. }
472. status_tParcel::errorCheck()const
473. {
474. returnmError;
475. }
477. voidParcel::setError(status_terr)
478. {
479. mError=err;
480. }
482. status_tParcel::finishWrite(size_tlen)
483. {
484. //printf("Finishwriteof%d/n",len);
485. mDataPos+=len;
486. LOGV("finishWriteSettingdataposof%pto%d/n",this,mDataPos);
487. if(mDataPos>mDataSize){
488. mDataSize=mDataPos;
489. LOGV("finishWriteSettingdatasizeof%pto%d/n",this,mDataSize);
490. }
491. //printf("Newpos=%d,size=%d/n",mDataPos,mDataSize);
492. returnNO_ERROR;
493. }
495. status_tParcel::writeUnpadded(constvoid*data,size_tlen)
496. {
497. size_tend=mDataPos+len;
498. if(end<mDataPos){
499. //integeroverflow
500. returnBAD_VALUE;
501. }
503. if(end<=mDataCapacity){
504. restart_write:
505. memcpy(mData+mDataPos,data,len);
506. returnfinishWrite(len);
507. }
509. status_terr=growData(len);
510. if(err==NO_ERROR)gotorestart_write;
511. returnerr;
512. }
514. status_tParcel::write(constvoid*data,size_tlen)
515. {
516. void*constd=writeInplace(len);
517. if(d){
518. memcpy(d,data,len);
519. returnNO_ERROR;
520. }
521. returnmError;
522. }
524. void*Parcel::writeInplace(size_tlen)
525. {
526. constsize_tpadded=PAD_SIZE(len);
528. //sanitycheckforintegeroverflow
529. if(mDataPos+padded<mDataPos){
530. returnNULL;
531. }
533. if((mDataPos+padded)<=mDataCapacity){
534. restart_write:
535. //printf("Writing%ldbytes,paddedto%ld/n",len,padded);
536. uint8_t*constdata=mData+mDataPos;
538. //Needtopadatend?
539. if(padded!=len){
540. #ifBYTE_ORDER==BIG_ENDIAN
541. staticconstuint32_tmask[4]={
542. 0x00000000,0xffffff00,0xffff0000,0xff000000
543. };
544. #endif
545. #ifBYTE_ORDER==LITTLE_ENDIAN
546. staticconstuint32_tmask[4]={
547. 0x00000000,0x00ffffff,0x0000ffff,0x000000ff
548. };
549. #endif
550. //printf("Applyingpadmask:%pto%p/n",(void*)mask[padded-len],
551. //*reinterpret_cast<void**>(data+padded-4));
552. *reinterpret_cast<uint32_t*>(data+padded-4)&=mask[padded-len];
553. }
555. finishWrite(padded);
556. returndata;
557. }
559. status_terr=growData(padded);
560. if(err==NO_ERROR)gotorestart_write;
561. returnNULL;
562. }
564. status_tParcel::writeInt32(int32_tval)
565. {
566. returnwriteAligned(val);
567. }
569. status_tParcel::writeInt64(int64_tval)
570. {
571. returnwriteAligned(val);
572. }
574. status_tParcel::writeFloat(floatval)
575. {
576. returnwriteAligned(val);
577. }
579. status_tParcel::writeDouble(doubleval)
580. {
581. returnwriteAligned(val);
582. }
584. status_tParcel::writeIntPtr(intptr_tval)
585. {
586. returnwriteAligned(val);
587. }
589. status_tParcel::writeCString(constchar*str)
590. {
591. returnwrite(str,strlen(str)+1);
592. }
594. status_tParcel::writeString8(constString8&str)
595. {
596. status_terr=writeInt32(str.bytes());
597. if(err==NO_ERROR){
598. err=write(str.string(),str.bytes()+1);
599. }
600. returnerr;
601. }
603. status_tParcel::writeString16(constString16&str)
604. {
605. returnwriteString16(str.string(),str.size());
606. }
608. status_tParcel::writeString16(constchar16_t*str,size_tlen)
609. {
610. if(str==NULL)returnwriteInt32(-1);
612. status_terr=writeInt32(len);
613. if(err==NO_ERROR){
614. len*=sizeof(char16_t);
615. uint8_t*data=(uint8_t*)writeInplace(len+sizeof(char16_t));
616. if(data){
617. memcpy(data,str,len);
618. *reinterpret_cast<char16_t*>(data+len)=0;
619. returnNO_ERROR;
620. }
621. err=mError;
622. }
623. returnerr;
624. }
626. status_tParcel::writeStrongBinder(constsp<IBinder>&val)
627. {
628. returnflatten_binder(ProcessState::self(),val,this);
629. }
631. status_tParcel::writeWeakBinder(constwp<IBinder>&val)
632. {
633. returnflatten_binder(ProcessState::self(),val,this);
634. }
636. status_tParcel::writeNativeHandle(constnative_handle*handle)
637. {
638. if(!handle||handle->version!=sizeof(native_handle))
639. returnBAD_TYPE;
641. status_terr;
642. err=writeInt32(handle->numFds);
643. if(err!=NO_ERROR)returnerr;
645. err=writeInt32(handle->numInts);
646. if(err!=NO_ERROR)returnerr;
648. for(inti=0;err==NO_ERROR&&i<handle->numFds;i++)
649. err=writeDupFileDescriptor(handle->data[i]);
651. if(err!=NO_ERROR){
652. LOGD("writenativehandle,writedupfdfailed");
653. returnerr;
654. }
655. err=write(handle->data+handle->numFds,sizeof(int)*handle->numInts);
656. returnerr;
657. }
659. status_tParcel::writeFileDescriptor(intfd)
660. {
661. flat_binder_objectobj;
662. obj.type=BINDER_TYPE_FD;
663. obj.flags=0x7f|FLAT_BINDER_FLAG_ACCEPTS_FDS;
664. obj.handle=fd;
665. obj.cookie=(void*)0;
666. returnwriteObject(obj,true);
667. }
669. status_tParcel::writeDupFileDescriptor(intfd)
670. {
671. flat_binder_objectobj;
672. obj.type=BINDER_TYPE_FD;
673. obj.flags=0x7f|FLAT_BINDER_FLAG_ACCEPTS_FDS;
674. obj.handle=dup(fd);
675. obj.cookie=(void*)1;
676. returnwriteObject(obj,true);
677. }
679. status_tParcel::write(constFlattenable&val)
680. {
681. status_terr;
683. //sizeifneeded
684. size_tlen=val.getFlattenedSize();
685. size_tfd_count=val.getFdCount();
687. err=this->writeInt32(len);
688. if(err)returnerr;
690. err=this->writeInt32(fd_count);
691. if(err)returnerr;
693. //payload
694. void*buf=this->writeInplace(PAD_SIZE(len));
695. if(buf==NULL)
696. returnBAD_VALUE;
698. int*fds=NULL;
699. if(fd_count){
700. fds=newint[fd_count];
701. }
703. err=val.flatten(buf,len,fds,fd_count);
704. for(size_ti=0;i<fd_count&&err==NO_ERROR;i++){
705. err=this->writeDupFileDescriptor(fds[i]);
706. }
708. if(fd_count){
709. delete[]fds;
710. }
712. returnerr;
713. }
715. status_tParcel::writeObject(constflat_binder_object&val,boolnullMetaData)
716. {
717. constboolenoughData=(mDataPos+sizeof(val))<=mDataCapacity;
718. constboolenoughObjects=mObjectsSize<mObjectsCapacity;
719. if(enoughData&&enoughObjects){
720. restart_write:
721. *reinterpret_cast<flat_binder_object*>(mData+mDataPos)=val;
723. //Needtowritemeta-data?
724. if(nullMetaData||val.binder!=NULL){
725. mObjects[mObjectsSize]=mDataPos;
726. acquire_object(ProcessState::self(),val,this);
727. mObjectsSize++;
728. }
730. //rememberifit'safiledescriptor
731. if(val.type==BINDER_TYPE_FD){
732. mHasFds=mFdsKnown=true;
733. }
735. returnfinishWrite(sizeof(flat_binder_object));
736. }
738. if(!enoughData){
739. conststatus_terr=growData(sizeof(val));
740. if(err!=NO_ERROR)returnerr;
741. }
742. if(!enoughObjects){
743. size_tnewSize=((mObjectsSize+2)*3)/2;
744. size_t*objects=(size_t*)realloc(mObjects,newSize*sizeof(size_t));
745. if(objects==NULL)returnNO_MEMORY;
746. mObjects=objects;
747. mObjectsCapacity=newSize;
748. }
750. gotorestart_write;
751. }
753. voidParcel::remove(size_tstart,size_tamt)
754. {
755. LOG_ALWAYS_FATAL("Parcel::remove()notyetimplemented!");
756. }
758. status_tParcel::read(void*outData,size_tlen)const
759. {
760. if((mDataPos+PAD_SIZE(len))>=mDataPos&&(mDataPos+PAD_SIZE(len))<=mDataSize){
761. memcpy(outData,mData+mDataPos,len);
762. mDataPos+=PAD_SIZE(len);
763. LOGV("readSettingdataposof%pto%d/n",this,mDataPos);
764. returnNO_ERROR;
765. }
766. returnNOT_ENOUGH_DATA;
767. }
769. constvoid*Parcel::readInplace(size_tlen)const
770. {
771. if((mDataPos+PAD_SIZE(len))>=mDataPos&&(mDataPos+PAD_SIZE(len))<=mDataSize){
772. constvoid*data=mData+mDataPos;
773. mDataPos+=PAD_SIZE(len);
774. LOGV("readInplaceSettingdataposof%pto%d/n",this,mDataPos);
775. returndata;
776. }
777. returnNULL;
778. }
780. template<classT>
781. status_tParcel::readAligned(T*pArg)const{
782. COMPILE_TIME_ASSERT_FUNCTION_SCOPE(PAD_SIZE(sizeof(T))==sizeof(T));
784. if((mDataPos+sizeof(T))<=mDataSize){
785. constvoid*data=mData+mDataPos;
786. mDataPos+=sizeof(T);
787. *pArg=*reinterpret_cast<constT*>(data);
788. returnNO_ERROR;
789. }else{
790. returnNOT_ENOUGH_DATA;
791. }
792. }
794. template<classT>
795. TParcel::readAligned()const{
796. Tresult;
797. if(readAligned(&result)!=NO_ERROR){
798. result=0;
799. }
801. returnresult;
802. }
804. template<classT>
805. status_tParcel::writeAligned(Tval){
806. COMPILE_TIME_ASSERT_FUNCTION_SCOPE(PAD_SIZE(sizeof(T))==sizeof(T));
808. if((mDataPos+sizeof(val))<=mDataCapacity){
809. restart_write:
810. *reinterpret_cast<T*>(mData+mDataPos)=val;
811. returnfinishWrite(sizeof(val));
812. }
814. status_terr=growData(sizeof(val));
815. if(err==NO_ERROR)gotorestart_write;
816. returnerr;
817. }
819. status_tParcel::readInt32(int32_t*pArg)const
820. {
821. returnreadAligned(pArg);
822. }
824. int32_tParcel::readInt32()const
825. {
826. returnreadAligned<int32_t>();
827. }
830. status_tParcel::readInt64(int64_t*pArg)const
831. {
832. returnreadAligned(pArg);
833. }
836. int64_tParcel::readInt64()const
837. {
838. returnreadAligned<int64_t>();
839. }
841. status_tParcel::readFloat(float*pArg)const
842. {
843. returnreadAligned(pArg);
844. }
847. floatParcel::readFloat()const
848. {
849. returnreadAligned<float>();
850. }
852. status_tParcel::readDouble(double*pArg)const
853. {
854. returnreadAligned(pArg);
855. }
858. doubleParcel::readDouble()const
859. {
860. returnreadAligned<double>();
861. }
863. status_tParcel::readIntPtr(intptr_t*pArg)const
864. {
865. returnreadAligned(pArg);
866. }
869. intptr_tParcel::readIntPtr()const
870. {
871. returnreadAligned<intptr_t>();
872. }
875. constchar*Parcel::readCString()const
876. {
877. constsize_tavail=mDataSize-mDataPos;
878. if(avail>0){
879. constchar*str=reinterpret_cast<constchar*>(mData+mDataPos);
880. //isthestring'strailingNULwithintheparcel'svalidbounds?
881. constchar*eos=reinterpret_cast<constchar*>(memchr(str,0,avail));
882. if(eos){
883. constsize_tlen=eos-str;
884. mDataPos+=PAD_SIZE(len+1);
885. LOGV("readCStringSettingdataposof%pto%d/n",this,mDataPos);
886. returnstr;
887. }
888. }
889. returnNULL;
890. }
892. String8Parcel::readString8()const
893. {
894. int32_tsize=readInt32();
895. //watchforpotentialintoverflowadding1fortrailingNUL
896. if(size>0&&size<INT32_MAX){
897. constchar*str=(constchar*)readInplace(size+1);
898. if(str)returnString8(str,size);
899. }
900. returnString8();
901. }
903. String16Parcel::readString16()const
904. {
905. size_tlen;
906. constchar16_t*str=readString16Inplace(&len);
907. if(str)returnString16(str,len);
908. LOGE("ReadingaNULLstringnotsupportedhere.");
909. returnString16();
910. }
912. constchar16_t*Parcel::readString16Inplace(size_t*outLen)const
913. {
914. int32_tsize=readInt32();
915. //watchforpotentialintoverflowfromsize+1
916. if(size>=0&&size<INT32_MAX){
917. *outLen=size;
918. constchar16_t*str=(constchar16_t*)readInplace((size+1)*sizeof(char16_t));
919. if(str!=NULL){
920. returnstr;
921. }
922. }
923. *outLen=0;
924. returnNULL;
925. }
927. sp<IBinder>Parcel::readStrongBinder()const
928. {
929. sp<IBinder>val;
930. unflatten_binder(ProcessState::self(),*this,&val);
931. returnval;
932. }
934. wp<IBinder>Parcel::readWeakBinder()const
935. {
936. wp<IBinder>val;
937. unflatten_binder(ProcessState::self(),*this,&val);
938. returnval;
939. }
942. native_handle*Parcel::readNativeHandle()const
943. {
944. intnumFds,numInts;
945. status_terr;
946. err=readInt32(&numFds);
947. if(err!=NO_ERROR)return0;
948. err=readInt32(&numInts);
949. if(err!=NO_ERROR)return0;
951. native_handle*h=native_handle_create(numFds,numInts);
952. for(inti=0;err==NO_ERROR&&i<numFds;i++){
953. h->data[i]=dup(readFileDescriptor());
954. if(h->data[i]<0)err=BAD_VALUE;
955. }
956. err=read(h->data+numFds,sizeof(int)*numInts);
957. if(err!=NO_ERROR){
958. native_handle_close(h);
959. native_handle_delete(h);
960. h=0;
961. }
962. returnh;
963. }
966. intParcel::readFileDescriptor()const
967. {
968. constflat_binder_object*flat=readObject(true);
969. if(flat){
970. switch(flat->type){
971. caseBINDER_TYPE_FD:
972. //LOGI("Returningfiledescriptor%ldfromparcel%p/n",flat->handle,this);
973. returnflat->handle;
974. }
975. }
976. returnBAD_TYPE;
977. }
979. status_tParcel::read(Flattenable&val)const
980. {
981. //size
982. constsize_tlen=this->readInt32();
983. constsize_tfd_count=this->readInt32();
985. //payload
986. voidconst*buf=this->readInplace(PAD_SIZE(len));
987. if(buf==NULL)
988. returnBAD_VALUE;
990. int*fds=NULL;
991. if(fd_count){
992. fds=newint[fd_count];
993. }
995. status_terr=NO_ERROR;
996. for(size_ti=0;i<fd_count&&err==NO_ERROR;i++){
997. fds[i]=dup(this->readFileDescriptor());
998. if(fds[i]<0)err=BAD_VALUE;
999. }
1001. if(err==NO_ERROR){
1002. err=val.unflatten(buf,len,fds,fd_count);
1003. }
1005. if(fd_count){
1006. delete[]fds;
1007. }
1009. returnerr;
1010. }
1011. constflat_binder_object*Parcel::readObject(boolnullMetaData)const
1012. {
1013. constsize_tDPOS=mDataPos;
1014. if((DPOS+sizeof(flat_binder_object))<=mDataSize){
1015. constflat_binder_object*obj
1016. =reinterpret_cast<constflat_binder_object*>(mData+DPOS);
1017. mDataPos=DPOS+sizeof(flat_binder_object);
1018. if(!nullMetaData&&(obj->cookie==NULL&&obj->binder==NULL)){
1019. //WhentransferringaNULLobject,wedon'twriteitinto
1020. //theobjectlist,sowedon'twanttocheckforitwhen
1021. //reading.
1022. LOGV("readObjectSettingdataposof%pto%d/n",this,mDataPos);
1023. returnobj;
1024. }
1026. //Ensurethatthisobjectisvalid...
1027. size_t*constOBJS=mObjects;
1028. constsize_tN=mObjectsSize;
1029. size_topos=mNextObjectHint;
1031. if(N>0){
1032. LOGV("Parcel%plookingforobjat%d,hint=%d/n",
1033. this,DPOS,opos);
1035. //Startatthecurrenthintposition,lookingforanobjectat
1036. //thecurrentdataposition.
1037. if(opos<N){
1038. while(opos<(N-1)&&OBJS[opos]<DPOS){
1039. opos++;
1040. }
1041. }else{
1042. opos=N-1;
1043. }
1044. if(OBJS[opos]==DPOS){
1045. //Foundit!
1046. LOGV("Parcelfoundobj%datindex%dwithforwardsearch",
1047. this,DPOS,opos);
1048. mNextObjectHint=opos+1;
1049. LOGV("readObjectSettingdataposof%pto%d/n",this,mDataPos);
1050. returnobj;
1051. }
1053. //Lookbackwardsforit...
1054. while(opos>0&&OBJS[opos]>DPOS){
1055. opos--;
1056. }
1057. if(OBJS[opos]==DPOS){
1058. //Foundit!
1059. LOGV("Parcelfoundobj%datindex%dwithbackwardsearch",
1060. this,DPOS,opos);
1061. mNextObjectHint=opos+1;
1062. LOGV("readObjectSettingdataposof%pto%d/n",this,mDataPos);
1063. returnobj;
1064. }
1065. }
1066. LOGW("AttempttoreadobjectfromParcel%patoffset%dthatisnotintheobjectlist",
1067. this,DPOS);
1068. }
1069. returnNULL;
1070. }
1072. voidParcel::closeFileDescriptors()
1073. {
1074. size_ti=mObjectsSize;
1075. if(i>0){
1076. //LOGI("Closingfiledescriptorsfor%dobjects...",mObjectsSize);
1077. }
1078. while(i>0){
1079. i--;
1080. constflat_binder_object*flat
1081. =reinterpret_cast<flat_binder_object*>(mData+mObjects[i]);
1082. if(flat->type==BINDER_TYPE_FD){
1083. //LOGI("Closingfd:%ld/n",flat->handle);
1084. close(flat->handle);
1085. }
1086. }
1087. }
1089. constuint8_t*Parcel::ipcData()const
1090. {
1091. returnmData;
1092. }
1094. size_tParcel::ipcDataSize()const
1095. {
1096. return(mDataSize>mDataPos?mDataSize:mDataPos);
1097. }
1099. constsize_t*Parcel::ipcObjects()const
1100. {
1101. returnmObjects;
1102. }
1104. size_tParcel::ipcObjectsCount()const
1105. {
1106. returnmObjectsSize;
1107. }
1109. voidParcel::ipcSetDataReference(constuint8_t*data,size_tdataSize,
1110. constsize_t*objects,size_tobjectsCount,release_funcrelFunc,void*relCookie)
1111. {
1112. freeDataNoInit();
1113. mError=NO_ERROR;
1114. mData=const_cast<uint8_t*>(data);
1115. mDataSize=mDataCapacity=dataSize;
1116. //LOGI("setDataReferenceSettingdatasizeof%pto%lu(pid=%d)/n",this,mDataSize,getpid());
1117. mDataPos=0;
1118. LOGV("setDataReferenceSettingdataposof%pto%d/n",this,mDataPos);
1119. mObjects=const_cast<size_t*>(objects);
1120. mObjectsSize=mObjectsCapacity=objectsCount;
1121. mNextObjectHint=0;
1122. mOwner=relFunc;
1123. mOwnerCookie=relCookie;
1124. scanForFds();
1125. }
1127. voidParcel::print(TextOutput&to,uint32_tflags)const
1128. {
1129. to<<"Parcel(";
1131. if(errorCheck()!=NO_ERROR){
1132. conststatus_terr=errorCheck();
1133. to<<"Error:"<<(void*)err<<"/""<<strerror(-err)<<"/"";
1134. }elseif(dataSize()>0){
1135. constuint8_t*DATA=data();
1136. to<<indent<<HexDump(DATA,dataSize())<<dedent;
1137. constsize_t*OBJS=objects();
1138. constsize_tN=objectsCount();
1139. for(size_ti=0;i<N;i++){
1140. constflat_binder_object*flat
1141. =reinterpret_cast<constflat_binder_object*>(DATA+OBJS[i]);
1142. to<<endl<<"Object#"<<i<<"@"<<(void*)OBJS[i]<<":"
1143. <<TypeCode(flat->type&0x7f7f7f00)
1144. <<"="<<flat->binder;
1145. }
1146. }else{
1147. to<<"NULL";
1148. }
1150. to<<")";
1151. }
1153. voidParcel::releaseObjects()
1154. {
1155. constsp<ProcessState>proc(ProcessState::self());
1156. size_ti=mObjectsSize;
1157. uint8_t*constdata=mData;
1158. size_t*constobjects=mObjects;
1159. while(i>0){
1160. i--;
1161. constflat_binder_object*flat
1162. =reinterpret_cast<flat_binder_object*>(data+objects[i]);
1163. release_object(proc,*flat,this);
1164. }
1165. }
1167. voidParcel::acquireObjects()
1168. {
1169. constsp<ProcessState>proc(ProcessState::self());
1170. size_ti=mObjectsSize;
1171. uint8_t*constdata=mData;
1172. size_t*constobjects=mObjects;
1173. while(i>0){
1174. i--;
1175. constflat_binder_object*flat
1176. =reinterpret_cast<flat_binder_object*>(data+objects[i]);
1177. acquire_object(proc,*flat,this);
1178. }
1179. }
1181. voidParcel::freeData()
1182. {
1183. freeDataNoInit();
1184. initState();
1185. }
1187. voidParcel::freeDataNoInit()
1188. {
1189. if(mOwner){
1190. //LOGI("Freeingdatarefof%p(pid=%d)/n",this,getpid());
1191. mOwner(this,mData,mDataSize,mObjects,mObjectsSize,mOwnerCookie);
1192. }else{
1193. releaseObjects();
1194. if(mData)free(mData);
1195. if(mObjects)free(mObjects);
1196. }
1197. }
1199. status_tParcel::growData(size_tlen)
1200. {
1201. size_tnewSize=((mDataSize+len)*3)/2;
1202. return(newSize<=mDataSize)
1203. ?(status_t)NO_MEMORY
1204. :continueWrite(newSize);
1205. }
1207. status_tParcel::restartWrite(size_tdesired)
1208. {
1209. if(mOwner){
1210. freeData();
1211. returncontinueWrite(desired);
1212. }
1214. uint8_t*data=(uint8_t*)realloc(mData,desired);
1215. if(!data&&desired>mDataCapacity){
1216. mError=NO_MEMORY;
1217. returnNO_MEMORY;
1218. }
1220. releaseObjects();
1222. if(data){
1223. mData=data;
1224. mDataCapacity=desired;
1225. }
1227. mDataSize=mDataPos=0;
1228. LOGV("restartWriteSettingdatasizeof%pto%d/n",this,mDataSize);
1229. LOGV("restartWriteSettingdataposof%pto%d/n",this,mDataPos);
1231. free(mObjects);
1232. mObjects=NULL;
1233. mObjectsSize=mObjectsCapacity=0;
1234. mNextObjectHint=0;
1235. mHasFds=false;
1236. mFdsKnown=true;
1238. returnNO_ERROR;
1239. }
1241. status_tParcel::continueWrite(size_tdesired)
1242. {
1243. //Ifshrinking,firstadjustforanyobjectsthatappear
1244. //afterthenewdatasize.
1245. size_tobjectsSize=mObjectsSize;
1246. if(desired<mDataSize){
1247. if(desired==0){
1248. objectsSize=0;
1249. }else{
1250. while(objectsSize>0){
1251. if(mObjects[objectsSize-1]<desired)
1252. break;
1253. objectsSize--;
1254. }
1255. }
1256. }
1258. if(mOwner){
1259. //Ifthesizeisgoingtozero,justreleasetheowner'sdata.
1260. if(desired==0){
1261. freeData();
1262. returnNO_ERROR;
1263. }
1265. //Ifthereisadifferentowner,weneedtotake
1266. //posession.
1267. uint8_t*data=(uint8_t*)malloc(desired);
1268. if(!data){
1269. mError=NO_MEMORY;
1270. returnNO_MEMORY;
1271. }
1272. size_t*objects=NULL;
1274. if(objectsSize){
1275. objects=(size_t*)malloc(objectsSize*sizeof(size_t));
1276. if(!objects){
1277. mError=NO_MEMORY;
1278. returnNO_MEMORY;
1279. }
1281. //Littlehacktoonlyacquirereferencesonobjects
1282. //wewillbekeeping.
1283. size_toldObjectsSize=mObjectsSize;
1284. mObjectsSize=objectsSize;
1285. acquireObjects();
1286. mObjectsSize=oldObjectsSize;
1287. }
1289. if(mData){
1290. memcpy(data,mData,mDataSize<desired?mDataSize:desired);
1291. }
1292. if(objects&&mObjects){
1293. memcpy(objects,mObjects,objectsSize*sizeof(size_t));
1294. }
1295. //LOGI("Freeingdatarefof%p(pid=%d)/n",this,getpid());
1296. mOwner(this,mData,mDataSize,mObjects,mObjectsSize,mOwnerCookie);
1297. mOwner=NULL;
1299. mData=data;
1300. mObjects=objects;
1301. mDataSize=(mDataSize<desired)?mDataSize:desired;
1302. LOGV("continueWriteSettingdatasizeof%pto%d/n",this,mDataSize);
1303. mDataCapacity=desired;
1304. mObjectsSize=mObjectsCapacity=objectsSize;
1305. mNextObjectHint=0;
1307. }elseif(mData){
1308. if(objectsSize<mObjectsSize){
1309. //Needtoreleaserefsonanyobjectswearedropping.
1310. constsp<ProcessState>proc(ProcessState::self());
1311. for(size_ti=objectsSize;i<mObjectsSize;i++){
1312. constflat_binder_object*flat
1313. =reinterpret_cast<flat_binder_object*>(mData+mObjects[i]);
1314. if(flat->type==BINDER_TYPE_FD){
1315. //willneedtorescanbecausewemayhaveloppedofftheonlyFDs
1316. mFdsKnown=false;
1317. }
1318. release_object(proc,*flat,this);
1319. }
1320. size_t*objects=
1321. (size_t*)realloc(mObjects,objectsSize*sizeof(size_t));
1322. if(objects){
1323. mObjects=objects;
1324. }
1325. mObjectsSize=objectsSize;
1326. mNextObjectHint=0;
1327. }
1329. //Weownthedata,sowecanjustdoarealloc().
1330. if(desired>mDataCapacity){
1331. uint8_t*data=(uint8_t*)realloc(mData,desired);
1332. if(data){
1333. mData=data;
1334. mDataCapacity=desired;
1335. }elseif(desired>mDataCapacity){
1336. mError=NO_MEMORY;
1337. returnNO_MEMORY;
1338. }
1339. }else{
1340. mDataSize=desired;
1341. LOGV("continueWriteSettingdatasizeof%pto%d/n",this,mDataSize);
1342. if(mDataPos>desired){
1343. mDataPos=desired;
1344. LOGV("continueWriteSettingdataposof%pto%d/n",this,mDataPos);
1345. }
1346. }
1348. }else{
1349. //Thisisthefirstdata.Easy!
1350. uint8_t*data=(uint8_t*)malloc(desired);
1351. if(!data){
1352. mError=NO_MEMORY;
1353. returnNO_MEMORY;
1354. }
1356. if(!(mDataCapacity==0&&mObjects==NULL
1357. &&mObjectsCapacity==0)){
1358. LOGE("continueWrite:%d/%p/%d/%d",mDataCapacity,mObjects,mObjectsCapacity,desired);
1359. }
1361. mData=data;
1362. mDataSize=mDataPos=0;
1363. LOGV("continueWriteSettingdatasizeof%pto%d/n",this,mDataSize);
1364. LOGV("continueWriteSettingdataposof%pto%d/n",this,mDataPos);
1365. mDataCapacity=desired;
1366. }
1368. returnNO_ERROR;
1369. }
1371. voidParcel::initState()
1372. {
1373. mError=NO_ERROR;
1374. mData=0;
1375. mDataSize=0;
1376. mDataCapacity=0;
1377. mDataPos=0;
1378. LOGV("initStateSettingdatasizeof%pto%d/n",this,mDataSize);
1379. LOGV("initStateSettingdataposof%pto%d/n",this,mDataPos);
1380. mObjects=NULL;
1381. mObjectsSize=0;
1382. mObjectsCapacity=0;
1383. mNextObjectHint=0;
1384. mHasFds=false;
1385. mFdsKnown=true;
1386. mOwner=NULL;
1387. }
1389. voidParcel::scanForFds()const
1390. {
1391. boolhasFds=false;
1392. for(size_ti=0;i<mObjectsSize;i++){
1393. constflat_binder_object*flat
1394. =reinterpret_cast<constflat_binder_object*>(mData+mObjects[i]);
1395. if(flat->type==BINDER_TYPE_FD){
1396. hasFds=true;
1397. break;
1398. }
1399. }
1400. mHasFds=hasFds;
1401. mFdsKnown=true;
1402. }
1404. };//namespaceandroid

/* * 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版本。

更多相关文章

1. 【Android】学习笔记(5)——浅谈Handler
2. Android(安卓)Bitmap图片处理，防止内存溢出
3. GC机制，你真的了解吗？
4. Android的消息机制之ThreadLocal的工作原理
5. Android(安卓)Studio使用profile简单优雅的查看内存变化
6. Android--关于Cursor空指针的问题
7. Android事件分发机制学习笔记
8. 使用Valgrind找出Android中Native程序内存泄露问题
9. android onPause()和onStop()区别

随机推荐

1. android toast使用总结
2. Android(安卓)AsyncTask几个注意事项
3. Android(安卓)Studio 2.2 NDK开发 opencv
4. 高逼格UI-ASD(Android(安卓)Support Desi
5. Android开发：设置圆形Button
6. android的小细节
7. android usb相关知识总结
8. Android数据存储操作
9. 打开Android(安卓)PVLogger的方法
10. android的Spinner控件的自定义样式设置以