AIDL是什么
Android 接口定义语言 (AIDL) 与您可能使用过的其他接口语言 (IDL) 类似。您可以利用它定义客户端与服务均认可的编程接口，以便二者使用进程间通信 (IPC) 进行相互通信。在 Android 中，一个进程通常无法访问另一个进程的内存。因此，为进行通信，进程需将其对象分解成可供操作系统理解的原语，并将其编组为可供您操作的对象。编写执行该编组操作的代码较为繁琐，因此 Android 会使用 AIDL 为您处理此问题。
AIDL的用处
Android 接口定义语言 (AIDL) 会将对象分解成原语，操作系统可通过识别这些原语并将其编组到各进程中来执行 IPC。对于之前采用 Messenger 的方法而言，其实际上是以 AIDL 作为其底层结构。如上所述，Messenger 会在单个线程中创建包含所有客户端请求的队列，以便服务一次接收一个请求。不过，如果您想让服务同时处理多个请求，则可直接使用 AIDL。在此情况下，您的服务必须达到线程安全的要求，并且能够进行多线程处理。
手写AIDL
1.定义binder服务端所提供的功能接口。定义服务端的功能为提供人员的增加与删除，并提供所有人员列表（）。
/**
* 这个类用来定义服务端具有什么样的能力，继承自IInterface才就有跨进程传输的基础能力
/**
* Base class for Binder interfaces. When defining a new interface,
* you must derive it from IInterface. Iinterface的说明
*/
*/
public interface PersonManager extends IInterface {
/**
* 添加人数
*
* @throws RemoteException
*/
void addPerson(PersonBean personBean) throws RemoteException;
/**
* 删除人数
*
* @throws RemoteException
*/
void deletePerson(PersonBean personBean) throws RemoteException;
/**
* 获取人数
*
* @throws RemoteException
*/
List<PersonBean> getPersons() throws RemoteException;
}
PersonBean 是人员信息的model，我只写了一个name属性，跨进程传输则必须实现Parcelable相关接口。为了后面的删除功能还需要重写equle和hashcode方法。
/**
* 实现了parcelable接口的实体类，可用于跨进程传输
*/
class PersonBean() : Parcelable {
var name: String? = null;
constructor(parcel: Parcel) : this() {
name = parcel.readString()
}
override fun writeToParcel(parcel: Parcel, flags: Int) {
parcel.writeString(name)
}
override fun describeContents(): Int {
return 0
}
override fun toString(): String {
return "PersonBean(name=$name)"
}
override fun equals(other: Any?): Boolean {
if (this === other) return true
if (javaClass != other?.javaClass) return false
other as PersonBean
if (name != other.name) return false
return true
}
override fun hashCode(): Int {
return name?.hashCode() ?: 0
}
companion object CREATOR : Parcelable.Creator<PersonBean> {
override fun createFromParcel(parcel: Parcel): PersonBean {
return PersonBean(parcel)
}
override fun newArray(size: Int): Array<PersonBean?> {
return arrayOfNulls(size)
}
}
}
2.添加proxy代理类。我的理解是模拟服务端的所有功能，让客户端感受不到调用的是远程还是本地的服务功能。可以看见PersonManagerProxy实现了PersonManager
接口，所以就实现了相应的方法，而在构造方法中传入了IBinder，实际上的跨进程传输的实体。addPerson，deletePerson，getPersons，三个方法中可以看见实际调用的方法是IBinder的transact方法。PersonManagerProxy只是进行了一些参数方法的封装。
/**
* personmanager/binder在本地的远程代理类。
*/
public class PersonManagerProxy implements PersonManager {
/**
* 远程binder对象
*/
IBinder remote;
private static final String DESCRIPTOR = "com.study.stydyfirst.server.PersonManager";
/**
* 构造方法传入ibinder
*
* @param remote
*/
public PersonManagerProxy(IBinder remote) {
this.remote = remote;
}
public String getInterfaceDescriptor() {
return DESCRIPTOR;
}
@Override
public void addPerson(PersonBean personBean) throws RemoteException {
Parcel data = Parcel.obtain();
Parcel replay = Parcel.obtain();
try {
data.writeInterfaceToken(DESCRIPTOR);
if (personBean != null) {
data.writeInt(1);
personBean.writeToParcel(data, 0);
} else {
data.writeInt(0);
}
remote.transact(PersonManagerStub.TRANSAVTION_addperson, data, replay, 0);
replay.readException();
} finally {
replay.recycle();
data.recycle();
}
}
@Override
public void deletePerson(PersonBean personBean) throws RemoteException {
Parcel data = Parcel.obtain();
Parcel replay = Parcel.obtain();
try {
data.writeInterfaceToken(DESCRIPTOR);
if (personBean != null) {
data.writeInt(1);
personBean.writeToParcel(data, 0);
} else {
data.writeInt(0);
}
remote.transact(PersonManagerStub.TRANSAVTION_deleteperson, data, replay, 0);
replay.readException();
} finally {
replay.recycle();
data.recycle();
}
}
@Override
public List<PersonBean> getPersons() throws RemoteException {
Parcel data = Parcel.obtain();
Parcel replay = Parcel.obtain();
List<PersonBean> result;
try {
data.writeInterfaceToken(DESCRIPTOR);
remote.transact(PersonManagerStub.TRANSAVTION_getpersons, data, replay, 0);
replay.readException();
result = replay.createTypedArrayList(PersonBean.CREATOR);
} finally {
replay.recycle();
data.recycle();
}
return result;
}
@Override
public IBinder asBinder() {
return remote;
}
}
3.添加PersonManagerStub类。跨进程传输的Binder对象。从代码中可以看见PersonManagerStub 继承自Binder，实现了PersonManager 接口的方法。说明：
- 说明他就是一个binder类，具有跨进程传输的能力
- 他的实现类必须实现我们定义的远程服务端具备的添加，删除，列表获取等能力
继续分析下PersonManagerStub 的其他代码， - 构造方法中 this.attachInterface(this, DESCRIPTOR);的作用就是向BinderService注册Binder服务。只有注册了binder，客户端才能查询到有这个binder对象，并使用它。
- asInterface方法，将一个binder对象转换为PersonManager 这个我们定义的接口。通过binder.queryLocalInterface(DESCRIPTOR);方法，判断是否返回代理对象。
- onTransact方法。就是在刚才PersonManagerProxy类中调用的方法就到这了。将客户端传输的数据在这里进行实际处理并通过跨进程传输到远程service那里
/**
* 继承自binder实现了personmanager的方法，说明它可以跨进程传输，并可进行服务端相关的数据操作
*/
public abstract class PersonManagerStub extends Binder implements PersonManager {
private static final String DESCRIPTOR = "com.study.stydyfirst.server.PersonManager";
public PersonManagerStub() {
this.attachInterface(this, DESCRIPTOR);
}
public static PersonManager asInterface(IBinder binder) {
if (binder == null)
return null;
IInterface iin = binder.queryLocalInterface(DESCRIPTOR);//通过DESCRIPTOR查询本地binder，如果存在则说明调用方和service在同一进程间，直接本地调用
if (iin != null && iin instanceof PersonManager)
return (PersonManager) iin;
return new PersonManagerProxy(binder);//本地没有，返回一个远程代理对象
}
@Override
public IBinder asBinder() {
return this;
}
@Override
protected boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
switch (code) {
case INTERFACE_TRANSACTION:
reply.writeString(DESCRIPTOR);
return true;
case TRANSAVTION_getpersons:
data.enforceInterface(DESCRIPTOR);
List<PersonBean> result = this.getPersons();
reply.writeNoException();
reply.writeTypedList(result);
return true;
case TRANSAVTION_addperson:
data.enforceInterface(DESCRIPTOR);
PersonBean arg0 = null;
if (data.readInt() != 0) {
arg0 = PersonBean.CREATOR.createFromParcel(data);
}
this.addPerson(arg0);
reply.writeNoException();
return true;
case TRANSAVTION_deleteperson:
data.enforceInterface(DESCRIPTOR);
PersonBean personBean = null;
if (data.readInt() != 0) {
personBean = PersonBean.CREATOR.createFromParcel(data);
}
this.deletePerson(personBean);
reply.writeNoException();
return true;
}
return super.onTransact(code, data, reply, flags);
}
public static final int TRANSAVTION_getpersons = IBinder.FIRST_CALL_TRANSACTION;
public static final int TRANSAVTION_addperson = IBinder.FIRST_CALL_TRANSACTION + 1;
public static final int TRANSAVTION_deleteperson = IBinder.FIRST_CALL_TRANSACTION + 2;
}
AIDL的相关类已经编写完毕，下面只需要远程service实现相应方法，客户端调用，就能测试该手写AIDL的跨进程传输能力了
远程进程service类，这里使用前台服务通知来显示人员信息，便于直观查看跨进程传输结果，可以看见我们在service中实例化了一个PersonManagerStub对象，并实现了相关方法。并通过notification显示personss的数据信息，并通过service的onBind方法将binder对象传输给客户端
/**
* 远程service
*/
class PersonManagerService : Service() {
/**
* 创建一个数组用于管理人员 var 声明可变变量，val声明不可变变量 相当于final
*/
private var personss: ArrayList<PersonBean> = ArrayList();
val CHANNEL_ID = "personmanager";
val notificationId = 1;
override fun onCreate() {
super.onCreate()
createNotificationChannel()
//初始化通知栏，
showNotification()
}
/**
* 将当前人数显示通过通知栏显示出来
*/
fun showNotification() {
var builder = NotificationCompat.Builder(this, CHANNEL_ID)
.setContentTitle("0fdg")
.setStyle(
NotificationCompat.BigTextStyle()
.bigText("当前的人数是：" + personss.size + "人员信息：" + personss.toString())
)
.setSmallIcon(R.mipmap.ic_launcher)//不设置smallicon，文字信息不生效，我服了
.setPriority(NotificationCompat.PRIORITY_DEFAULT)
with(NotificationManagerCompat.from(this)) {
// notificationId is a unique int for each notification that you must define
//notify(notificationId, builder.build())
startForeground(notificationId, builder.build())
}
}
/**
* 首先创建通知渠道，再进行通知显示
*/
private fun createNotificationChannel() {
// Create the NotificationChannel, but only on API 26+ because
// the NotificationChannel class is new and not in the support library
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
val name = getString(R.string.channel_name)
val descriptionText = getString(R.string.channel_description)
val importance = NotificationManager.IMPORTANCE_DEFAULT
val channel = NotificationChannel(CHANNEL_ID, name, importance).apply {
description = descriptionText
}
// Register the channel with the system
val notificationManager: NotificationManager =
getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
notificationManager.createNotificationChannel(channel)
}
}
override fun onBind(intent: Intent): IBinder {
// TODO("Return the communication channel to the service.")
return binder
}
private val binder = object : PersonManagerStub() {
override fun addPerson(personBean: PersonBean?) {
if (personBean != null) {
personss.add(personBean)
Log.d("Server", "添加" + personBean.name)
showNotification()
};
}
override fun deletePerson(personBean: PersonBean?) {
personss.remove(personBean)
Log.d("Server", "删除");
showNotification()
}
override fun getPersons(): List<PersonBean> {
Log.d("Server", "删除")
return persons;
}
}
}
本地clientActivity,简单service启动与远程建立链接，并传输数据，本地通过PersonManagerStub.asInterface(service)方法直接将binder对象转换为PersonManager即可直接调用远程方法进行数据传输
/**
* 本地client
*/
class ClientActivity : AppCompatActivity() {
/** The primary interface we will be calling on the service. */
private var mService: PersonManager? = null
/**
* 是否绑定的标志
*/
private var isBound = false
/**
* Class for interacting with the main interface of the service.
*/
private val mConnection = object : ServiceConnection {
override fun onServiceConnected(className: ComponentName, service: IBinder) {
// This is called when the connection with the service has been
// established, giving us the service object we can use to
// interact with the service. We are communicating with our
// service through an IDL interface, so get a client-side
// representation of that from the raw service object.
Log.d("client", "链接成功====");
mService = PersonManagerStub.asInterface(service)//将service转成远程服务代理对象，并调用他的方法
isBound = true
}
override fun onServiceDisconnected(className: ComponentName) {
// This is called when the connection with the service has been
// unexpectedly disconnected -- that is, its process crashed.
mService = null
isBound = false
}
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_client)
// Bind to LocalService
addListener()
}
override fun onDestroy() {
super.onDestroy()
if (isBound) {
unbindService(mConnection)
}
}
private fun addListener() {
btn_add.setOnClickListener {
var person = PersonBean()
person.name = "刘德华"
mService?.addPerson(person)
}
btn_delete.setOnClickListener {
var person = PersonBean()
person.name = "刘德华"
mService?.deletePerson(person)
}
btn_bind.setOnClickListener {
Toast.makeText(baseContext, "绑定服务", Toast.LENGTH_SHORT).show();
Intent(this, PersonManagerService::class.java).also { intent ->
bindService(intent, mConnection, Context.BIND_AUTO_CREATE)
//startService(intent)
}
}
}
}
以上就是java层面的client-binder-servi，跨进程的一个传输流程。并通过手写方式实现了AIDL的所有功能。 项目demo地址https://github.com/92123748/AIDLTest
网友评论