android的Parcel那点事

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

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

三．Parcel的使用

Parcel就是一个存放读取数据的容器，  Android系统中的binder进程间通信(IPC)就使用了Parcel类来进行客户端与服务端数据的交互，而且AIDL的数据也是通过Parcel来交互的。在Java空间和C++都实现了Parcel，由于它在C/C++中，直接使用了内存来读取数据，因此，它更有效率。

分析Binder机制中的客户端与服务器端进行实际操作ontransact()函数 ：

[java]

1. //参数说明：   
2. // code ：是请求的ID号    
3. // data ：客户端请求发送的参数   
4. // reply：服务器端返回的结果   
5. // flags：一些额外的标识，如FLAG_ONEWAY等，通常为0.   
6. virtual status_t    onTransact( uint32_t code,  
7.                                 const Parcel& data,  
8.                                 Parcel* reply,  
9.                                 uint32_t flags = 0);  

从中我们可以看到Parcel的重要性以及窥探它的使用情况，接下来，我主要分析它的存储机制。 

     

    常用方法介绍：

            obtain()                          获得一个新的parcel ，相当于new一个对象

            dataSize()                      得到当前parcel对象的实际存储空间

            dataCapacity()               得到当前parcel对象的已分配的存储空间, >=dataSize()值  (以空间换时间)

            dataPostion()                 获得当前parcel对象的偏移量(类似于文件流指针的偏移量)

            setDataPosition()           设置偏移量

            recyle()                           清空、回收parcel对象的内存

            writeInt(int)                     写入一个整数

            writeFloat(float)              写入一个浮点数

            writeDouble(double)       写入一个双精度数

            writeString(string)           写入一个字符串

         当然，还有更多的writeXXX()方法，与之对应的就是readXXX()，具体方法请参阅SDK。

          其中几个值得注意的方法为：

             writeException()        在Parcel队头写入一个异常

             writeException()        Parcel队头写入“无异常“

             readException()        在Parcel队头读取，若读取值为异常，则抛出该异常；否则，程序正常运行。

 

分析

 

       相信看了前面的值，对Parcel的使用该有了初步印象。那么，Parcel的内部存储机制是怎么样的？偏移量又是

  什么情况？让我们回忆一下基本数据类型的取值范围：

                   boolean     1bit          1字节

                   char          16bit         2字节

                   int             32bit        4字节

                   long          64bit        8字节

                   float          32bit        4字节

                  double       64bit         8字节

 

        如果大家对C语言熟悉的话，C语言中结构体的内存对齐和Parcel采用的内存存放机制一样，即读取最小字节

为32bit，也即4个字节。高于4个字节的，以实际数据类型进行存放，但得为4byte的倍数。基本公式如下：

             实际存放字节：

                       判别一：  32bit      (<=32bit)             例如：boolean，char，int

                       判别二：  实际占用字节(>32bit)     例如：long，float，String，数组等

        当我们使用readXXX()方法时，读取方法也如上述：

              实际读取字节：

                        判别一：  32bit      (<=32bit)            例如：boolean，char，int

                        判别二：  实际字节大小(>32bit)     例如：long，float，String，数值等

      由上可以知道，当我们写入/读取一个数据时，偏移量至少为4byte(32bit)，于是，偏移量的公式如下：

                 f(x)= 4x  (x=0,1,…n)

        事实上，我们可以显示的通过setDataPostion(int postion) 来直接操作我们欲读取数据时的偏移量。毫无疑问，

你可以设置任何偏移量，但所读取的值是类型可能有误。因此显示设置偏移量读取值的时候，需要小心。

      

      另外一个注意点就是我们在writeXXX()和readXXX()时，导致的偏移量是共用的，例如，我们在writeInt(23)后，

此时的datapostion=4，如果我们想读取5，简单的通过readInt()是不行的，只能得到0。这时我们只能通过

setDataPosition(0)设置为起始偏移量，从起始位置读取四个字节，即23。因此，在读取某个值时，可能需要使用

setDataPostion(int postion)使偏移量装换到我们的值处。

 

      巧用setDataPosition()方法,当我们的parcel对象中只存在某一类型时，我们就可以通过这个方法来快速的读取

所有值。具体方法如下：

 

[html]

1. /**  
2.      * 前提条件，Parcel存在多个类型相同的对象，本例子以10个float对象说明：  
3.      */  
4.     public void readSameType() {  
5.         Parcel parcel =Parcel.obtain() ;  
6.         for (int i = 0; i < 10; i++) {  
7.             parcel.writeDouble(i);  
8.             Log.i(TAG, "write double ----> " + getParcelInfo());  
9.         }  
10.         //方法一 ，显示设置偏移量   
11.         int i = 0;  
12.         int datasize = parcel.dataSize();  
13.         while (i < datasize) {  
14.             parcel.setDataPosition(i);  
15.             double fvalue = parcel.readDouble();  
16.             Log.i(TAG, " read double is=" + fvalue + ", --->" + getParcelInfo());  
17.             i += 8; // double占用字节为 8byte   
18.         }  
19. //      方法二，由于对象的类型一致，我们可以直接利用readXXX()读取值会产生偏移量  
20. //      parcel.setDataPosition(0)  ;  //  
21. //      while(parcel.dataPosition()<parcel.dataSize()){  
22. //          double fvalue = parcel.readDouble();  
23. //          Log.i(TAG, " read double is=" + fvalue + ", --->" + getParcelInfo());  
24. //      }  
25.     }  

    由于可能存在读取值的偏差，一个默认的取值规范为：

             1、  读取复杂对象时： 对象匹配时，返回当前偏移位置的该对象；

                               对象不匹配时，返回null对象 ；

             2、  读取简单对象时： 对象匹配时，返回当前偏移位置的该对象 ；

                               对象不匹配时，返回0；  

四．Parcel在activity和service之间的相互通信方法使用

在android中Activity负责前台界面展示，service负责后台的需要长期运行的任务。Activity和Service之间的通信主要由IBinder负责。在需要和Service通信的Activity中实现ServiceConnection接口，并且实现其中的onServiceConnected和onServiceDisconnected方法。然后在这个Activity中还要通过如下代码绑定服务:

Java代码 

1. Intent intent = new Intent().setClass( this , IHRService.class );  
2. bindService( intent , this , Context.BIND_AUTO_CREATE );  

  当调用bindService方法后就会回调Activity的onServiceConnected，在这个方法中会向Activity中传递一个IBinder的实例，Acitity需要保存这个实例。代码如下:

Java代码 

1. public void onServiceConnected( ComponentName inName , IBinder serviceBinder) {  
2.     if ( inName.getShortClassName().endsWith( "IHRService" ) ) {  
3.     try {  
4.         this.serviceBinder= serviceBinder;  
5.         mService = ( (IHRService.MyBinder) serviceBinder).getService();  
6.         //mTracker = mService.mConfiguration.mTracker;  
7.         } catch (Exception e) {}  
8.               
9.     }  
10. }  

 

在Service中需要创建一个实现IBinder的内部类(这个内部类不一定在Service中实现，但必须在Service中创建它)。

Java代码 

1. public class MyBinder extends Binder {  
2. //此方法是为了可以在Acitity中获得服务的实例  
3.     public IHRService getService() {  
4.         return IHRService.this;  
5.     }  
6. //这个方法主要是接收Activity发向服务的消息，data为发送消息时向服务传入的对象，replay是由服务返回的对象  
7.     public boolean onTransact( int code , Parcel data , Parcel reply , int flags ) {  
8.         //called when client calls transact on returned Binder  
9.         return handleTransactions( code , data , reply , flags );  
10.     }  
11.   
12. }  

  

然后在Service中创建这个类的实例：

Java代码 

1. public IBinder onBind( Intent intent ) {  
2.     IBinder result = null;  
3.     if ( null == result ) result = new MyBinder() ;  
4.     return result;  
5. }  

  这时候如果Activity向服务发送消息，就可以调用如下代码向服务端发送消息：

Java代码 

1. inSend = Parcel.obtain()；  
2. serviceBinder.transact( inCode , inSend , null , IBinder.FLAG_ONEWAY );  

 

这种方式是只向服务端发送消息,没有返回值的。如果需要从服务端返回某些值则可用如下代码：

Java代码 

1. result = Parcel.obtain();  
2. serviceBinder.transact( inCode , inSend , result , 0 );  
3. return result;  

发送消息后IBinder接口中的onTransact将会被调用。在服务中如果有结果返回(比如下载数据)则将结果写入到result参数中。在Activity中从result中读取服务执行的结果。

五．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); 
   
6. 
   
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); 
    
12. 
    

复制代码

        从中我们看到，从这个源程序文件中我们看不到真正的功能是如何实现的，必须透过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. } 
    
11. 
    
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. } 
    
22. 
    

复制代码