基础总结篇之四：Service完全解析--使用AIDL实现进程间的通信之复杂类型传递



上次讲到简单的AIDL进程间通信的操作，客户端向服务端发送一个String类型的参数，服务端也返回一个String类型的结果，看似已经可以完成基本的需要了。不过在有的时候，简单的数据类型并不能满足我们的需求，我们就需要考虑怎样向服务端传递复杂的数据类型。今天就来讲一下如何向服务端传递复杂类型的问题。

首先要了解一下AIDL对Java类型的支持。

1.AIDL支持Java原始数据类型。

2.AIDL支持String和CharSequence。

3.AIDL支持传递其他AIDL接口，但你引用的每个AIDL接口都需要一个import语句，即使位于同一个包中。

4.AIDL支持传递实现了android.os.Parcelable接口的复杂类型，同样在引用这些类型时也需要import语句。(Parcelable接口告诉Android运行时在封送(marshalling)和解封送(unmarshalling)过程中实现如何序列化和反序列化对象，你可以很容易联想到java.io.Serializable接口。有些朋友可能会有疑问，两种接口功能确实类似，但为什么Android不用内置的Java序列化机制，而偏偏要搞一套新东西呢？这是因为Android团队认为Java中的序列化太慢，难以满足Android的进程间通信需求，所以他们构建了Parcelable解决方案。Parcelable要求显示序列化类的成员，但最终序列化对象的速度将快很多。另外要注意的是，Android提供了两种机制来将数据传递给另一个进程，第一种是使用Intent将数据束(Bundle)传递给活动，第二种也就是Parcelable传递给服务。这两种机制不可互换，不要混淆。也就是说，Parcelable无法传递给活动，只能用作AIDL定义的一部分)。

5.AIDL支持java.util.List和java.util.Map，但是有一些限制。集合中项的允许数据类型包括Java原始类型、String、CharSequence或是android.os.Parcelable。无需为List和Map提供import语句，但需要为Parcelable提供import语句。

6.非原始类型中，除了String和CharSequence以外，其余均需要一个方向指示符。方向指示符包括in、out、和inout。in表示由客户端设置，out表示由服务端设置，inout表示客户端和服务端都设置了该值。

接下来就演示一下具体的流程：

我们先看一下服务端的结构：

其中，Person类是我们要在服务端和客户端中间进行传递的类型，代码如下：

[java] view plain copy print ?

1. package com.scott.aidl;  
2.   
3. import android.os.Parcel;  
4. import android.os.Parcelable;  
5.   
6. public class Person implements Parcelable {  
7.   
8.     private String name;  
9.     private int sex;  
10.       
11.     //必须提供一个名为CREATOR的static final属性 该属性需要实现android.os.Parcelable.Creator<T>接口  
12.     public static final Parcelable.Creator<Person> CREATOR = new Parcelable.Creator<Person>() {  
13.   
14.         @Override  
15.         public Person createFromParcel(Parcel source) {  
16.             return new Person(source);  
17.         }  
18.   
19.         @Override  
20.         public Person[] newArray(int size) {  
21.             return new Person[size];  
22.         }  
23.     };  
24.       
25.     public Person() {  
26.           
27.     }  
28.       
29.     private Person(Parcel source) {  
30.         readFromParcel(source);  
31.     }  
32.       
33.     @Override  
34.     public int describeContents() {  
35.         return 0;  
36.     }  
37.   
38.     //注意写入变量和读取变量的顺序应该一致 不然得不到正确的结果  
39.     @Override  
40.     public void writeToParcel(Parcel dest, int flags) {  
41.         dest.writeString(name);  
42.         dest.writeInt(sex);  
43.     }  
44.       
45.     //注意读取变量和写入变量的顺序应该一致 不然得不到正确的结果  
46.     public void readFromParcel(Parcel source) {  
47.         name = source.readString();  
48.         sex = source.readInt();  
49.     }  
50.   
51.     public String getName() {  
52.         return name;  
53.     }  
54.   
55.     public void setName(String name) {  
56.         this.name = name;  
57.     }  
58.   
59.     public int getSex() {  
60.         return sex;  
61.     }  
62.   
63.     public void setSex(int sex) {  
64.         this.sex = sex;  
65.     }  
66.       
67. }  

package com.scott.aidl; import android.os.Parcel; import android.os.Parcelable; public class Person implements Parcelable { private String name; private int sex; //必须提供一个名为CREATOR的static final属性 该属性需要实现android.os.Parcelable.Creator<T>接口 public static final Parcelable.Creator<Person> CREATOR = new Parcelable.Creator<Person>() { @Override public Person createFromParcel(Parcel source) { return new Person(source); } @Override public Person[] newArray(int size) { return new Person[size]; } }; public Person() { } private Person(Parcel source) { readFromParcel(source); } @Override public int describeContents() { return 0; } //注意写入变量和读取变量的顺序应该一致 不然得不到正确的结果 @Override public void writeToParcel(Parcel dest, int flags) { dest.writeString(name); dest.writeInt(sex); } //注意读取变量和写入变量的顺序应该一致 不然得不到正确的结果 public void readFromParcel(Parcel source) { name = source.readString(); sex = source.readInt(); } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getSex() { return sex; } public void setSex(int sex) { this.sex = sex; } }

然后我们需要在同一包下建立一个与包含复杂类型的Person.java文件匹配的Person.aidl文件，代码如下：

[java] view plain copy print ?

1. package com.scott.aidl;  
2. parcelable Person;  

package com.scott.aidl; parcelable Person;

这个Person.aidl文件很简单，就是定义了一个Parcelable类，告诉系统我们需要序列化和反序列化的类型。每一个实现了Parcelable的类型都需要对应的.aidl文件。AIDL编译器在编译AIDL文件时会自动查找此类文件。

接下来，我们需要创建一个IGreetService.aidl文件，以接收类型为Person的输入参数，以便客户端可以将Person传递给服务。

[java] view plain copy print ?

1. package com.scott.aidl;  
2. import com.scott.aidl.Person;  
3.   
4. interface IGreetService {  
5.     String greet(in Person person);  
6. }   

package com.scott.aidl; import com.scott.aidl.Person; interface IGreetService { String greet(in Person person); }

注意，我们需要在参数上加入方向指示符in，代表参数由客户端设置，我们还需要为Person提供一个import语句(虽然说在同一个包下)。

此时，在eclipse插件的帮助下，AIDL编译器会自动编译生成一个IGreetService.java文件，格式化后的代码如下：

[java] view plain copy print ?

1. package com.scott.aidl;  
2.   
3. public interface IGreetService extends android.os.IInterface {  
4.     /** Local-side IPC implementation stub class. */  
5.     public static abstract class Stub extends android.os.Binder implements com.scott.aidl.IGreetService {  
6.         private static final java.lang.String DESCRIPTOR = "com.scott.aidl.IGreetService";  
7.   
8.         /** Construct the stub at attach it to the interface. */  
9.         public Stub() {  
10.             this.attachInterface(this, DESCRIPTOR);  
11.         }  
12.   
13.         /** 
14.          * Cast an IBinder object into an com.scott.aidl.IGreetService 
15.          * interface, generating a proxy if needed. 
16.          */  
17.         public static com.scott.aidl.IGreetService asInterface(android.os.IBinder obj) {  
18.             if ((obj == null)) {  
19.                 return null;  
20.             }  
21.             android.os.IInterface iin = (android.os.IInterface) obj.queryLocalInterface(DESCRIPTOR);  
22.             if (((iin != null) && (iin instanceof com.scott.aidl.IGreetService))) {  
23.                 return ((com.scott.aidl.IGreetService) iin);  
24.             }  
25.             return new com.scott.aidl.IGreetService.Stub.Proxy(obj);  
26.         }  
27.   
28.         public android.os.IBinder asBinder() {  
29.             return this;  
30.         }  
31.   
32.         @Override  
33.         public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags)  
34.                 throws android.os.RemoteException {  
35.             switch (code) {  
36.             case INTERFACE_TRANSACTION: {  
37.                 reply.writeString(DESCRIPTOR);  
38.                 return true;  
39.             }  
40.             case TRANSACTION_greet: {  
41.                 data.enforceInterface(DESCRIPTOR);  
42.                 com.scott.aidl.Person _arg0;  
43.                 if ((0 != data.readInt())) {  
44.                     _arg0 = com.scott.aidl.Person.CREATOR.createFromParcel(data);  
45.                 } else {  
46.                     _arg0 = null;  
47.                 }  
48.                 java.lang.String _result = this.greet(_arg0);  
49.                 reply.writeNoException();  
50.                 reply.writeString(_result);  
51.                 return true;  
52.             }  
53.             }  
54.             return super.onTransact(code, data, reply, flags);  
55.         }  
56.   
57.         private static class Proxy implements com.scott.aidl.IGreetService {  
58.             private android.os.IBinder mRemote;  
59.   
60.             Proxy(android.os.IBinder remote) {  
61.                 mRemote = remote;  
62.             }  
63.   
64.             public android.os.IBinder asBinder() {  
65.                 return mRemote;  
66.             }  
67.   
68.             public java.lang.String getInterfaceDescriptor() {  
69.                 return DESCRIPTOR;  
70.             }  
71.   
72.             public java.lang.String greet(com.scott.aidl.Person person) throws android.os.RemoteException {  
73.                 android.os.Parcel _data = android.os.Parcel.obtain();  
74.                 android.os.Parcel _reply = android.os.Parcel.obtain();  
75.                 java.lang.String _result;  
76.                 try {  
77.                     _data.writeInterfaceToken(DESCRIPTOR);  
78.                     if ((person != null)) {  
79.                         _data.writeInt(1);  
80.                         person.writeToParcel(_data, 0);  
81.                     } else {  
82.                         _data.writeInt(0);  
83.                     }  
84.                     mRemote.transact(Stub.TRANSACTION_greet, _data, _reply, 0);  
85.                     _reply.readException();  
86.                     _result = _reply.readString();  
87.                 } finally {  
88.                     _reply.recycle();  
89.                     _data.recycle();  
90.                 }  
91.                 return _result;  
92.             }  
93.         }  
94.   
95.         static final int TRANSACTION_greet = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);  
96.     }  
97.   
98.     public java.lang.String greet(com.scott.aidl.Person person) throws android.os.RemoteException;  
99. }  

package com.scott.aidl; public interface IGreetService extends android.os.IInterface { /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements com.scott.aidl.IGreetService { private static final java.lang.String DESCRIPTOR = "com.scott.aidl.IGreetService"; /** Construct the stub at attach it to the interface. */ public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an com.scott.aidl.IGreetService * interface, generating a proxy if needed. */ public static com.scott.aidl.IGreetService asInterface(android.os.IBinder obj) { if ((obj == null)) { return null; } android.os.IInterface iin = (android.os.IInterface) obj.queryLocalInterface(DESCRIPTOR); if (((iin != null) && (iin instanceof com.scott.aidl.IGreetService))) { return ((com.scott.aidl.IGreetService) iin); } return new com.scott.aidl.IGreetService.Stub.Proxy(obj); } public android.os.IBinder asBinder() { return this; } @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { switch (code) { case INTERFACE_TRANSACTION: { reply.writeString(DESCRIPTOR); return true; } case TRANSACTION_greet: { data.enforceInterface(DESCRIPTOR); com.scott.aidl.Person _arg0; if ((0 != data.readInt())) { _arg0 = com.scott.aidl.Person.CREATOR.createFromParcel(data); } else { _arg0 = null; } java.lang.String _result = this.greet(_arg0); reply.writeNoException(); reply.writeString(_result); return true; } } return super.onTransact(code, data, reply, flags); } private static class Proxy implements com.scott.aidl.IGreetService { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } public android.os.IBinder asBinder() { return mRemote; } public java.lang.String getInterfaceDescriptor() { return DESCRIPTOR; } public java.lang.String greet(com.scott.aidl.Person person) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(); android.os.Parcel _reply = android.os.Parcel.obtain(); java.lang.String _result; try { _data.writeInterfaceToken(DESCRIPTOR); if ((person != null)) { _data.writeInt(1); person.writeToParcel(_data, 0); } else { _data.writeInt(0); } mRemote.transact(Stub.TRANSACTION_greet, _data, _reply, 0); _reply.readException(); _result = _reply.readString(); } finally { _reply.recycle(); _data.recycle(); } return _result; } } static final int TRANSACTION_greet = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); } public java.lang.String greet(com.scott.aidl.Person person) throws android.os.RemoteException; }

该文件的大纲视图如下：

接下来，就该完成我们的AIDLService逻辑部分了，AIDLService.java代码如下：

[java] view plain copy print ?

1. package com.scott.server;  
2.   
3. import android.app.Service;  
4. import android.content.Intent;  
5. import android.os.IBinder;  
6. import android.os.RemoteException;  
7. import android.util.Log;  
8.   
9. import com.scott.aidl.IGreetService;  
10. import com.scott.aidl.Person;  
11.   
12. public class AIDLService extends Service {  
13.   
14.     private static final String TAG = "AIDLService";  
15.       
16.     IGreetService.Stub stub = new IGreetService.Stub() {  
17.         @Override  
18.         public String greet(Person person) throws RemoteException {  
19.             Log.i(TAG, "greet(Person person) called");  
20.               
21.             String greeting = "hello, " + person.getName();  
22.             switch (person.getSex()) {  
23.             case 0:  
24.                 greeting = greeting + ", you're handsome.";  
25.                 break;  
26.             case 1:  
27.                 greeting = greeting + ", you're beautiful.";  
28.                 break;  
29.             }  
30.             return greeting;  
31.         }  
32.     };  
33.       
34.     @Override  
35.     public IBinder onBind(Intent intent) {  
36.         Log.i(TAG, "onBind() called");  
37.         return stub;  
38.     }  
39.       
40.     @Override  
41.     public boolean onUnbind(Intent intent) {  
42.         Log.i(TAG, "onUnbind() called");  
43.         return true;  
44.     }  
45.       
46.     @Override  
47.     public void onDestroy() {  
48.         super.onDestroy();  
49.         Log.i(TAG, "onDestroy() called");  
50.     }  
51. }  

package com.scott.server; import android.app.Service; import android.content.Intent; import android.os.IBinder; import android.os.RemoteException; import android.util.Log; import com.scott.aidl.IGreetService; import com.scott.aidl.Person; public class AIDLService extends Service { private static final String TAG = "AIDLService"; IGreetService.Stub stub = new IGreetService.Stub() { @Override public String greet(Person person) throws RemoteException { Log.i(TAG, "greet(Person person) called"); String greeting = "hello, " + person.getName(); switch (person.getSex()) { case 0: greeting = greeting + ", you're handsome."; break; case 1: greeting = greeting + ", you're beautiful."; break; } return greeting; } }; @Override public IBinder onBind(Intent intent) { Log.i(TAG, "onBind() called"); return stub; } @Override public boolean onUnbind(Intent intent) { Log.i(TAG, "onUnbind() called"); return true; } @Override public void onDestroy() { super.onDestroy(); Log.i(TAG, "onDestroy() called"); } }

最后，在AndroidManifest.xml中配置该服务：

[java] view plain copy print ?

1. <service android:name=".AIDLService">  
2.         <intent-filter>  
3.            <action android:name="android.intent.action.AIDLService" />  
4.                  <category android:name="android.intent.category.DEFAULT" />  
5.     </intent-filter>  
6. </service>  

<service android:name=".AIDLService"> <intent-filter> <action android:name="android.intent.action.AIDLService" /> <category android:name="android.intent.category.DEFAULT" /> </intent-filter> </service>

服务端就已经完成了。接下来我们来看一下客户端的结构：

我们需要把服务端的Person.java、Person.aidl和IGreetService.aidl拷到对应的包下。我们主要来看看MainActivity.java代码：

[java] view plain copy print ?

1. package com.scott.client;  
2.   
3. import android.app.Activity;  
4. import android.content.ComponentName;  
5. import android.content.Context;  
6. import android.content.Intent;  
7. import android.content.ServiceConnection;  
8. import android.os.Bundle;  
9. import android.os.IBinder;  
10. import android.os.RemoteException;  
11. import android.util.Log;  
12. import android.view.View;  
13. import android.widget.Button;  
14. import android.widget.Toast;  
15.   
16. import com.scott.aidl.IGreetService;  
17. import com.scott.aidl.Person;  
18.   
19. public class MainActivity extends Activity {  
20.   
21.     private Button bindBtn;  
22.     private Button greetBtn;  
23.     private Button unbindBtn;  
24.   
25.     private IGreetService greetService;  
26.     private ServiceConnection conn = new ServiceConnection() {  
27.   
28.         @Override  
29.         public void onServiceConnected(ComponentName name, IBinder service) {  
30.             Log.i("ServiceConnection", "onServiceConnected() called");  
31.             greetService = IGreetService.Stub.asInterface(service);  
32.         }  
33.   
34.         @Override  
35.         public void onServiceDisconnected(ComponentName name) {  
36.             //This is called when the connection with the service has been unexpectedly disconnected,  
37.             //that is, its process crashed. Because it is running in our same process, we should never see this happen.  
38.             Log.i("ServiceConnection", "onServiceDisconnected() called");  
39.         }  
40.     };  
41.   
42.     @Override  
43.     public void onCreate(Bundle savedInstanceState) {  
44.         super.onCreate(savedInstanceState);  
45.         setContentView(R.layout.main);  
46.   
47.         bindBtn = (Button) findViewById(R.id.bindBtn);  
48.         bindBtn.setOnClickListener(new View.OnClickListener() {  
49.             @Override  
50.             public void onClick(View v) {  
51.                 Intent intent = new Intent("android.intent.action.AIDLService");  
52.                 bindService(intent, conn, Context.BIND_AUTO_CREATE);  
53.                   
54.                 bindBtn.setEnabled(false);  
55.                 greetBtn.setEnabled(true);  
56.                 unbindBtn.setEnabled(true);  
57.             }  
58.         });  
59.   
60.         greetBtn = (Button) findViewById(R.id.greetBtn);  
61.         greetBtn.setOnClickListener(new View.OnClickListener() {  
62.             @Override  
63.             public void onClick(View v) {  
64.                 try {  
65.                     Person person = new Person();  
66.                     person.setName("scott");  
67.                     person.setSex(0);  
68.                     String retVal = greetService.greet(person);  
69.                     Toast.makeText(MainActivity.this, retVal, Toast.LENGTH_SHORT).show();  
70.                 } catch (RemoteException e) {  
71.                     Toast.makeText(MainActivity.this, "error", Toast.LENGTH_SHORT).show();  
72.                 }  
73.             }  
74.         });  
75.   
76.         unbindBtn = (Button) findViewById(R.id.unbindBtn);  
77.         unbindBtn.setOnClickListener(new View.OnClickListener() {  
78.             @Override  
79.             public void onClick(View v) {  
80.                 unbindService(conn);  
81.                   
82.                 bindBtn.setEnabled(true);  
83.                 greetBtn.setEnabled(false);  
84.                 unbindBtn.setEnabled(false);  
85.             }  
86.         });  
87.     }  
88. }  

package com.scott.client; import android.app.Activity; import android.content.ComponentName; import android.content.Context; import android.content.Intent; import android.content.ServiceConnection; import android.os.Bundle; import android.os.IBinder; import android.os.RemoteException; import android.util.Log; import android.view.View; import android.widget.Button; import android.widget.Toast; import com.scott.aidl.IGreetService; import com.scott.aidl.Person; public class MainActivity extends Activity { private Button bindBtn; private Button greetBtn; private Button unbindBtn; private IGreetService greetService; private ServiceConnection conn = new ServiceConnection() { @Override public void onServiceConnected(ComponentName name, IBinder service) { Log.i("ServiceConnection", "onServiceConnected() called"); greetService = IGreetService.Stub.asInterface(service); } @Override public void onServiceDisconnected(ComponentName name) { //This is called when the connection with the service has been unexpectedly disconnected, //that is, its process crashed. Because it is running in our same process, we should never see this happen. Log.i("ServiceConnection", "onServiceDisconnected() called"); } }; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); bindBtn = (Button) findViewById(R.id.bindBtn); bindBtn.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { Intent intent = new Intent("android.intent.action.AIDLService"); bindService(intent, conn, Context.BIND_AUTO_CREATE); bindBtn.setEnabled(false); greetBtn.setEnabled(true); unbindBtn.setEnabled(true); } }); greetBtn = (Button) findViewById(R.id.greetBtn); greetBtn.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { try { Person person = new Person(); person.setName("scott"); person.setSex(0); String retVal = greetService.greet(person); Toast.makeText(MainActivity.this, retVal, Toast.LENGTH_SHORT).show(); } catch (RemoteException e) { Toast.makeText(MainActivity.this, "error", Toast.LENGTH_SHORT).show(); } } }); unbindBtn = (Button) findViewById(R.id.unbindBtn); unbindBtn.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { unbindService(conn); bindBtn.setEnabled(true); greetBtn.setEnabled(false); unbindBtn.setEnabled(false); } }); } }

通过这种方式，就可以将Person类型的对象传递到服务端，实现复杂类型的通信传递。

当点击greetBtn时，截图如下：

然后看一下整个过程的日志信息。点击bindBtn、greetBtn、unbindBtn的整个过程日志如下：