Binder学习(三)经过AIDL分析Binder通讯流程

时间 2019-12-01

标签 binder 学习经过 aidl 分析通讯流程繁體版

原文原文链接

概述

AIDL (Android Interface Definition Language) 是一种接口定义语言，用于生成能够在Android设备上两个进程之间进行PC的代码。若是在一个进程中（例如Activity）要调用另外一个进程中（例如Service）对象的操做，就可使用AIDL生成可序列化的参数，来完成进程间通讯，也就是说，为了简化应用层进行IPC操做，Android提供了AIDL这门语言，在学习AIDL这门语言以前，咱们来看一下Android中IPC的具体流程。java

Client发起一个请求，阻塞
Client拿到服务端的Proxy，调用Proxy的相应方法
Proxy去跟Server进行交互，请求相应的结果
Proxy拿到结果返回给客户端

Client跟Proxy进行交互的数据不须要进行序列化，可是Proxy跟Server进行交互的时候必须进行序列化跟反序列化android

其实咱们在实际进行IPC的时候并不须要关注Proxy以及Binder Driver，上述模型能够再次进行抽象bash

client端：BpBinder.transact()来发送事务请求；
server端：BBinder.onTransact()会接收到相应事务。app

正文

数据类型

AIDL默认支持以下数据类型：ide

基本数据类型
List集合
Map集合
String类型
CharSequence类型

若是定义的类型不是AIDL默认支持的类型，则须要使用Parcelable进行序列化。一类是用来定义parcelable对象，以供其余AIDL文件使用AIDL中非默认支持的数据类型的。学习

文件类型

AIDL的文件后缀名为.aidl，并非以前的.java,不过在使用AIDL进行通讯的过程当中，
aidl文件只是用来定义数据类型跟接口。ui

使用方法

建立一个Parcelable 对象

public class People implements Parcelable {
    private int age;
    private String gender;
    private String hobby;
    //此处省略若干行代码
}复制代码

建立一个AIDL的类

package com.wustor.aidl;
// Declare any non-default types here with import statements
parcelable People;复制代码

建立一个AIDL的接口

package com.wustor.aidl;
// Declare any non-default types here with import statements
import com.wustor.aidl.People;
interface PeopleManager {
   List<People> getPeople();
  void addPeople(in People people);
}复制代码

查看PeopleManager.java

Android系统会在".\app\build\generated\source\aidl\debug\com\wustor\aidl"的目录下生成一个PeopleManager.java文件，这个类就是AIDL的核心，这个类是一个接口，下面先看一下这个接口的结构图：this

PeopleManager内部实现了PeopleManager.aidl的两个方法，而且在内部建立了一个叫Stub的内部类，同时Stub也本身维护了一个叫作Proxy的内部类，经过前面对Binder机制的原理分析，咱们其实能够很明确的知道，Proxy就是服务端的代理类，他做为一个中间代理，承载了Client与Server之间的转化，而Stub类的onTransact方法就是用来接收Proxy的输入而且把请求结果返回，从而达到代理的做用，因此分析AIDL实际上只须要注重分析一下asInterface，onTransact这两个方法以及Proxy代理类便可。 spa

asBinder

@Override
        public android.os.IBinder asBinder() {
            return this;
        }复制代码

返回当前Binder对象线程

asInterface

此方法位于Client端

/** * Cast an IBinder object into an com.wustor.aidl.PeopleManager interface, * generating a proxy if needed. */
        public static com.wustor.aidl.PeopleManager asInterface(android.os.IBinder obj) {
            if ((obj == null)) {
                return null;
            }
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            //查看本地是否存在这个类，不存在的话就从新建立
            if (((iin != null) && (iin instanceof com.wustor.aidl.PeopleManager))) {
                return ((com.wustor.aidl.PeopleManager) iin);
            }
            return new com.wustor.aidl.PeopleManager.Stub.Proxy(obj);
        }复制代码

queryLocalInterface

public IInterface queryLocalInterface(String descriptor) {
        if (mDescriptor.equals(descriptor)) {
            return mOwner;
        }
        return null;
    }

    public void attachInterface(IInterface owner, String descriptor) {
        mOwner = owner;
        mDescriptor = descriptor;
    }复制代码

首先会调用queryLocalInterface来判断descriptor跟mDescriptor是否相等，咱们经过查看Binder的源码能够看到descriptor就是当前PeopleManager的类名，那么经过传递过来的Binder对象查询这个类名，实际上就是判断Server端的BookManager跟Client是否是相同，若是相同就说明Client跟Server是在同一个进程，若是在同一个进程，那么就直接返回当前的IInterface ，不然返回null，那么Client端就会本身建立一个Proxy的代理类。

Proxy

getPeople()

static final int TRANSACTION_getPeople = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
    static final int TRANSACTION_addPeople = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
 @Override
  public java.util.List<com.wustor.aidl.People> getPeople() throws android.os.RemoteException {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                java.util.List<com.wustor.aidl.People> _result;
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    //调用transact方法，传递参数
                    mRemote.transact(Stub.TRANSACTION_getPeople, _data, _reply, 0);
                    _reply.readException();
                    //拿到返回结果
                    _result = _reply.createTypedArrayList(com.wustor.aidl.People.CREATOR);
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
                //返回参数给Client
                return _result;
            }复制代码

在Client调用，执行Transact方法，当前线程阻塞，服务端的onTransact方法会被调用，从reply中拿到返回值后，线程继续执行。

addPeoplet

@Override
            public void addPeople(com.wustor.aidl.People people) throws android.os.RemoteException {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    if ((people != null)) {
                        _data.writeInt(1);
                        people.writeToParcel(_data, 0);
                    } else {
                        _data.writeInt(0);
                    }
                    mRemote.transact(Stub.TRANSACTION_addPeople, _data, _reply, 0);
                    _reply.readException();
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
            }复制代码

在Client执行，跟getPeople()方法基本一致，惟一的区别是此方法没有返回值，因此不须要回写Client

onTransact

@Override
        public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException {
            switch (code) {
                case INTERFACE_TRANSACTION: {
                    reply.writeString(DESCRIPTOR);
                    return true;
                }
                case TRANSACTION_getPeople: {
                    data.enforceInterface(DESCRIPTOR);
                    java.util.List<com.wustor.aidl.People> _result = this.getPeople();
                    reply.writeNoException();
                    reply.writeTypedList(_result);
                    return true;
                }
                case TRANSACTION_addPeople: {
                    data.enforceInterface(DESCRIPTOR);
                    com.wustor.aidl.People _arg0;
                    if ((0 != data.readInt())) {
                        _arg0 = com.wustor.aidl.People.CREATOR.createFromParcel(data);
                    } else {
                        _arg0 = null;
                    }
                    this.addPeople(_arg0);
                    reply.writeNoException();
                    return true;
                }
            }
            return super.onTransact(code, data, reply, flags);
        }复制代码

运行在Server端，当Client端发起跨进程请求的时候，系统底层会返回Proxy代理，而后经过代理执行Client的方法，就会调用此方法。注意这个方法会从data取传递过来的参数，而后经过code判断须要执行哪个方法，执行完毕后，就返回值写入reply中，此方法的返回值代表IPC请求是否成功。

总结

经过分析AIDL的原理，从而能够进一步理解Binder机制，总结一下，Android中利用Binder机制。

经过观察这张图，咱们能够AIDL底层对Binder机制进行了封装，让Android中的IPC通讯机制更加简单方便，固然，咱们也能够本身动手写，固然Android中还有别的不少IPC通讯方式，例如Messenger等，。若是想实现Binder机制进行通讯，只须要Server(在Android里面大多数使用Service来建立一个Server)端返回一个Binder对象，而后将调用asInterface将Binder对象传递过来便可。

参考资料

Android开发艺术探索