Chinaunix首页 | 论坛 | 博客
  • 博客访问: 742865
  • 博文数量: 225
  • 博客积分: 0
  • 博客等级: 民兵
  • 技术积分: 2722
  • 用 户 组: 普通用户
  • 注册时间: 2013-02-03 17:32
文章分类

全部博文(225)

文章存档

2019年(7)

2018年(16)

2017年(1)

2016年(26)

2015年(41)

2014年(15)

2013年(119)

我的朋友

分类: Android平台

2015-09-15 17:35:10

客户端向服务端发送一个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 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的整个过程日志如下:

阅读(1293) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~