默认情况下，AIDL只支持下列数据类型：
Java八种基础数据类型（如 int、long、char、boolean 等）; String字符串； CharSequence字符序列； List列表，List中的所有元素须是前面提到的数据类型，或者是Parcelable类型（这也是本文准备讲解的）； Map，Map 中的所有元素必须是以上列表中支持的数据类型，或者您所声明的由 AIDL 生成的其他接口或Parcelable 类型；如果想在进程间传递以上数据类型之外的对象该怎么办？这就需用到Parcelable接口，Parcelable意思是“可包裹的”，是Android系统可用的序列化接口的一种，另外一种是来自java的Serialable，和Parcelable相比，Serialable的使用较为简单，如果只是保存数据到本地这类应用，使用Serialable即可，但在进程间通讯，则建议使用Parcelable。
2.序列化和反序列化Parcelable是序列化接口，那么什么是序列化，为什么进程间传输自定义对象需要使用序列化？百度百科对序列化的定义如下：
序列化是将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。之后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象。
数据在内存中是字节形态，数据分解到最后都是0和1字节流，这就像万物分解到最后都是原子一样，进程A要传递数据给进程B，同样是以字节形式传递，对于基本数据类型，例如进程A传递int类型数据给进程B，因为进程A和进程B都知道int类型，因此进程B可以直接从内存中还原出数据，而对于自定义数据类型，例如进程A自定义了一个Student对象，进程B并不知道，如果直接传递字节流给进程B，面对一堆字节流，进程B不知道怎么重构还原，需要进程A告诉重构方法，这便是序列化和反序列化的过程，这也是传递自定义对象需使用序列化的原因。
3.使用示例 服务端创建自定义类型,这包括创建Student.java和Student.aidl，两个文件分别在aidl目录下和java目录下，但两个文件所在的包名必须相同，否则编译不通。
java代码里实现
ParcelablewriteToParcel public void writeToParcel(Parcel dest, int flags) {
dest.writeInt(id);//写一个int类型的值
dest.writeString(name);//写一个String类型的值
dest.writeString(gender);//写一个String类型的值
dest.writeInt(age);//写一个int类型的值
}
则对应的
readFromParcel public void readFromParcel(Parcel source) {
id = source.readInt();
name = source.readString();
gender = source.readString();
age = source.readInt();
}
另外，自定义类型中必须含有一个名称为
CREATOR public static final Creator CREATOR = new Creator() {
@Override
public Student createFromParcel(Parcel in) {
return new Student(in);
}
@Override
public Student[] newArray(int size) {
return new Student[size];
}
};
完整的自定义类型java代码如下：
package com.pm.service;
import android.os.Parcel;
import android.os.Parcelable;
public class Student implements Parcelable {
private int id;
private String name;
private String gender;
private int age;
protected Student(Parcel in) {
id = in.readInt();
name = in.readString();
gender = in.readString();
age = in.readInt();
}
public Student(int id, String name, String gender, int age) {
this.id = id;
this.name = name;
this.gender = gender;
this.age = age;
}
public Student(){}
public static final Creator CREATOR = new Creator() {
@Override
public Student createFromParcel(Parcel in) {
return new Student(in);
}
@Override
public Student[] newArray(int size) {
return new Student[size];
}
};
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeInt(id);
dest.writeString(name);
dest.writeString(gender);
dest.writeInt(age);
}
public void readFromParcel(Parcel source) {
id = source.readInt();
name = source.readString();
gender = source.readString();
age = source.readInt();
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
java文件创建好了之后，则可以开始创建同名的Parcelable类的aidl文件，代码如下，代码较简单，只是声明Student是parcelable
// Student.aidl
package com.pm.service;
// Declare any non-default types here with import statements
import com.pm.service.Student;
parcelable Student;
import// ServiceAidlInterface.aidl
package com.pm.service;
// Declare any non-default types here with import statements
import com.pm.service.Student;
interface ServiceAidlInterface {
String ServiceGreet();
List getStudentList();
}
aidl代码编写好了之后，记得同步一下工程，然后在Service里实现新增的方法，完整的代码如下：
package com.pm.service;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.RemoteException;
import java.util.LinkedList;
import java.util.List;
public class MyService extends Service {
private ServiceAidlInterface.Stub serviceAidlInterface= new ServiceAidlInterface.Stub() {
@Override
public String ServiceGreet() throws RemoteException {
return "Hello Client!";
}
@Override
public List getStudentList() throws RemoteException {
List list = new LinkedList();
for (int i = 0; i < 10; i++) {
list.add(new Student(i,"s1"+i,"man",i+10));
}
return list;
}
};
@Override
public IBinder onBind(Intent intent) {
return serviceAidlInterface.asBinder();
}
}
这样一来，服务端要做的事都已完成，接下来是客户端的内容。
从服务端拷贝aidl目录下的文件和Student.java文件到客户端，存放的目录见图，需要注意的是，客户端的Student的aidl文件和java文件也要在相同的包名下,因客户端也是在上篇博客的demo的基础上编写，只需增加一个按钮做事件点击之用，把服务端传递过来的Student对象的实例打印出来，完整的代码见下：
package com.pm.myaidldemo;
import androidx.appcompat.app.AppCompatActivity;
import android.content.ComponentName;
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.TextView;
import com.pm.service.ServiceAidlInterface;
import com.pm.service.Student;
import java.util.ArrayList;
import java.util.List;
public class MainActivity extends AppCompatActivity {
String TAG="AIDLDemo";
private Button bServiceGreet;
private Button bGetStu;
private TextView tvInfo;
private ServiceAidlInterface serviceAidlInterface;
private ServiceConnection connection=new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
serviceAidlInterface = ServiceAidlInterface.Stub.asInterface(service);
}
@Override
public void onServiceDisconnected(ComponentName name) {
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
bindService();
bServiceGreet=findViewById(R.id.btnServiceGreet);
bGetStu=findViewById(R.id.btnGetStudent);
tvInfo=findViewById(R.id.tvInfo);
bServiceGreet.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
String greet= null;
try {
greet = serviceAidlInterface.ServiceGreet();
tvInfo.setText(greet);
} catch (RemoteException e) {
e.printStackTrace();
}
}
});
bGetStu.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
try {
StringBuilder sb=new StringBuilder();
List stulist= serviceAidlInterface.getStudentList();
for(int i=0;i<stulist.size()-5;i++)
{
sb.append("ID:"+stulist.get(i).getId()+"\n");
sb.append("Name:"+stulist.get(i).getName()+"\n");
sb.append("Gender:"+stulist.get(i).getGender()+"\n");
sb.append("Age:"+stulist.get(i).getAge()+"\n");
tvInfo.setText(sb.toString());
}
} catch (RemoteException e) {
e.printStackTrace();
}
}
});
}
private void bindService() {
Intent intent = new Intent();
intent.setAction("com.pm.service.MyService");
intent.setPackage("com.pm.service");
this.bindService(intent, connection, BIND_AUTO_CREATE);
Log.e(TAG, "bindService: finish!");
}
}
客户端编写好了之后，运行的效果如下：
进程间传递自定义对象需要实现Parcelable接口，通过序列化和反序列化实现，相比java原生的Serialization各有特色，如果是数据存储到磁盘上，建议使用java Serialization，如果是进程间通讯，则使用Parcelable。另外自定义类型的java和aidl文档要在相同的包名下，否则会提示找不到类的错误，自定义类型创建好了之后，便可以像aidl基本数据类型一样使用。
作者：风行南方
