logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

使用AIDL实现进程间的通信之复杂类型传递

 w_hf的图书馆 2011-07-27

 2011-05-10 17:24 

上次讲到简单的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类是我们要在服务端和客户端中间进行传递的类型，代码如下：

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

 

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

view plaincopy to clipboardprint?
  1. package com.scott.aidl;
  2. parcelable Person;

 

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

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

view plaincopy to clipboardprint?
  1. package com.scott.aidl;
  2. import com.scott.aidl.Person;
  4. interface IGreetService {
  5. String greet(in Person person);
  6. }

 

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

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

view plaincopy to clipboardprint?
  1. package com.scott.aidl;
  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";
  8. /** Construct the stub at attach it to the interface. */
  9. public Stub() {
  10. this.attachInterface(this, DESCRIPTOR);
  11. }
  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. }
  28. public android.os.IBinder asBinder() {
  29. return this;
  30. }
  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. }
  57. private static class Proxy implements com.scott.aidl.IGreetService {
  58. private android.os.IBinder mRemote;
  60. Proxy(android.os.IBinder remote) {
  61. mRemote = remote;
  62. }
  64. public android.os.IBinder asBinder() {
  65. return mRemote;
  66. }
  68. public java.lang.String getInterfaceDescriptor() {
  69. return DESCRIPTOR;
  70. }
  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. }
  95. static final int TRANSACTION_greet = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
  96. }
  98. public java.lang.String greet(com.scott.aidl.Person person) throws android.os.RemoteException;
  99. }

 

该文件的大纲视图如下：

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

view plaincopy to clipboardprint?
  1. package com.scott.server;
  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;
  9. import com.scott.aidl.IGreetService;
  10. import com.scott.aidl.Person;
  12. public class AIDLService extends Service {
  14. private static final String TAG = "AIDLService";
  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");
  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. };
  34. @Override
  35. public IBinder onBind(Intent intent) {
  36. Log.i(TAG, "onBind() called");
  37. return stub;
  38. }
  40. @Override
  41. public boolean onUnbind(Intent intent) {
  42. Log.i(TAG, "onUnbind() called");
  43. return true;
  44. }
  46. @Override
  47. public void onDestroy() {
  48. super.onDestroy();
  49. Log.i(TAG, "onDestroy() called");
  50. }
  51. }

 

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

view plaincopy to clipboardprint?
  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>

 

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

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

view plaincopy to clipboardprint?
  1. package com.scott.client;
  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;
  16. import com.scott.aidl.IGreetService;
  17. import com.scott.aidl.Person;
  19. public class MainActivity extends Activity {
  21. private Button bindBtn;
  22. private Button greetBtn;
  23. private Button unbindBtn;
  25. private IGreetService greetService;
  26. private ServiceConnection conn = new ServiceConnection() {
  28. @Override
  29. public void onServiceConnected(ComponentName name, IBinder service) {
  30. Log.i("ServiceConnection", "onServiceConnected() called");
  31. greetService = IGreetService.Stub.asInterface(service);
  32. }
  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. };
  42. @Override
  43. public void onCreate(Bundle savedInstanceState) {
  44. super.onCreate(savedInstanceState);
  45. setContentView(R.layout.main);
  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);
  54. bindBtn.setEnabled(false);
  55. greetBtn.setEnabled(true);
  56. unbindBtn.setEnabled(true);
  57. }
  58. });
  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. });
  76. unbindBtn = (Button) findViewById(R.id.unbindBtn);
  77. unbindBtn.setOnClickListener(new View.OnClickListener() {
  78. @Override
  79. public void onClick(View v) {
  80. unbindService(conn);
  82. bindBtn.setEnabled(true);
  83. greetBtn.setEnabled(false);
  84. unbindBtn.setEnabled(false);
  85. }
  86. });
  87. }
  88. }

 

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

当点击greetBtn时，截图如下：

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

    本站是提供个人知识管理的网络存储空间，所有内容均由用户发布，不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息，谨防诈骗。如发现有害或侵权内容，请点击一键举报。
    转藏 分享 献花（0）

    来自： w_hf的图书馆 > 《Android》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多