码迷，mamicode.com
首页 > 系统相关 > 详细

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

时间：2015-08-31 23:33:49      阅读：304      评论：0      收藏：0      [点我收藏+]

标签：

 

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

首先要了解一下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 plaincopy
 
  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. }  

 

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

 

[java] view plaincopy
 
  1. package com.scott.aidl;  
  2. parcelable Person;  

 

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

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

 

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

 

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

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

 

[java] view plaincopy
 
  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. }  

 

该文件的大纲视图如下：

技术分享

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

 

[java] view plaincopy
 
  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. }  

 

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

 

[java] view plaincopy
 
  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代码：

 

[java] view plaincopy
 
  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. }  

 

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

当点击greetBtn时，截图如下：

技术分享

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

技术分享

版权声明：本文为博主原创文章，未经博主允许不得转载。

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

标签：

原文地址：http://www.cnblogs.com/syjhsgcc/p/4774260.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！