AIDL用法及代码分析

AIDL为安卓接口定义语言的简称，作用是利用binder机制，实现IPC。

1、AIDL用法

服务端

新建项目，名字定义为server，顾名思义当做服务端，然后创建aidl文件，项目结构如下图：

image.png

看一下两个aidl文件中的内容：

// IWsyAidl.aidl
package com.wsy.service;
import com.wsy.service.Person;

interface IWsyAidl {
    void addPersonIn(in Person person);
    void addPersonInOut(inout Person person);
    void addPersonOut(out Person person);
    List<Person> getPersons();
}

这个aidl文件定义了四个方法，即服务端提供四个方法供客户端调用，概括一下就是客户端可以以三种方式向服务端添加Person对象，也可以获取服务端已经存储的Person的数量
参数说明：

in 客户端向服务端传递参数，服务端对参数修改后不会同步到客户端
inout 客户端向服务端传递参数，服务端对参数修改后会同步到客户端
out 客户端向服务端传递一个所有属性为空的对象(比如Person类中有name属性，即使给Person对象设置了name，传递到服务端的时候name依然为null),服务端对参数修改后会同步到客户端
具体的现象后面会结合日志说明。
```
  // Person.aidl
  package com.wsy.service;
  parcelable Person;
```

aidl中需要将自定义对象序列化之后进行数据传输，即上面的关键字parcelable修饰Person

在对应的目录下创建Person类实现Parcelable接口：

image.png

public class Person implements Parcelable {
private String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    protected Person(Parcel in) {
        name = in.readString();
    }

    public static final Creator<Person> CREATOR = new Creator<Person>() {
        @Override
        public Person createFromParcel(Parcel in) {
            return new Person(in);
        }

        @Override
        public Person[] newArray(int size) {
            return new Person[size];
        }
    };

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(name);
    }

    public void readFromParcel(Parcel dest){
        name = dest.readString();
    }
}

build项目，项目会在build目录下自动生成aidl对应的文件：

image.png

IWsyAidl结构如下：

image.png

创建Service类，里面重写onBind方法，返回IWsyAidl.Stub的实例

public class PersonService extends Service {
private String TAG = "aidlServer";
private List<Person> personList = new ArrayList<>();

@Nullable
@Override
public IBinder onBind(Intent intent) {
    return new PersonStub();
}

@Override
public void onCreate() {
    super.onCreate();
    Log.e("PersonService", "服务已启动");
}

class PersonStub extends IWsyAidl.Stub{

    @Override
    public void addPersonIn(Person person) throws RemoteException {
        if (person != null) {
            Log.e(TAG, "客户端传来的人的名字：" + person.getName());
            person.setName("服务器改了人的名字 In");
            personList.add(person);
        } else {
            Log.e(TAG, "接收到了一个空对象 In");
        }
    }

    @Override
    public void addPersonInOut(Person person) throws RemoteException {
        if (person != null) {
            Log.e(TAG, "客户端传来的人的名字：" + person.getName());
            person.setName("服务器改了人的名字 InOut");
            personList.add(person);
        } else {
            Log.e(TAG, "接收到了一个空对象 InOut");
        }
    }

    @Override
    public void addPersonOut(Person person) throws RemoteException {
        if (person != null) {
            Log.e(TAG, "客户端传来的人的名字：" + person.getName());
            person.setName("服务器改了人的名字 Out");
            personList.add(person);
        } else {
            Log.e(TAG, "接收到了一个空对象 Out");
        }
    }

    @Override
    public List<Person> getPersons() throws RemoteException {
        return personList;
    }
}

}

在清单文件配置Service

<service
    android:name=".PersonService"
    android:enabled="true"
    android:exported="true">
    <intent-filter>
        <action android:name="com.wsy.service.PersonService" />
        <category android:name="android.intent.category.DEFAULT"/>
    </intent-filter>
</service>

启动服务

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        startService(new Intent(this, PersonService.class));
    }
}

客户端

新建项目，名字为client，作为客户端

拷贝server中的aidl目录及Person类到对应目录，这里要保证client端和server端的aidl和Person的目录要完全一致，否则会报类找不到的错误，build项目：

image.png

绑定服务

public class MainActivity extends AppCompatActivity {
    private String TAG = "aidlClient";
    private Button addIn, addInOut, addOut, get;
    private IWsyAidl iWsyAidl;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        bindAidlService();
        addIn = findViewById(R.id.btn_add_in);
        addInOut = findViewById(R.id.btn_add_in_out);
        addOut = findViewById(R.id.btn_add_out);
        get = findViewById(R.id.btn_get);
        addIn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                try {
                    Person person = new Person("客户端In");
                    iWsyAidl.addPersonIn(person);
                    Log.e(TAG, person.getName());
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        });
        addInOut.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                try {
                    Person person = new Person("客户端InOut");
                    iWsyAidl.addPersonInOut(person);
                    Log.e(TAG, person.getName());
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        });
        addOut.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                try {
                    Person person = new Person("客户端out");
                    iWsyAidl.addPersonOut(person);
                    Log.e(TAG, person.getName());
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        });
        get.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                try {
                    List<Person> persons = iWsyAidl.getPersons();
                    Log.e(TAG, "persons.size = " + persons.size());
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        });
    }

    ServiceConnection conn = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            iWsyAidl = IWsyAidl.Stub.asInterface(service);
            Log.e(TAG, "服务已绑定");
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };

    void bindAidlService() {
        Intent service = new Intent();
        service.setPackage("com.wsy.service");
        service.setAction("com.wsy.service.PersonService");
        bindService(service, conn, Context.BIND_AUTO_CREATE);

    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        unbindService(conn);
    }
}

运行server，启动服务；运行client，绑定服务：

image.png

分别点击添加IN、添加INOUT、添加OUT

image.png

由上图验证了文章开头提到的in/out/inout起到的作用

为in时，客户端执行new Person("客户端In")，name为“客户端In”;服务端首先打印了客户端传来的名字是“客户端In”，然后执行setName("服务器改了人的名字 In")，返回客户端，客户端打印的名字仍为“客户端In”，所以说明了in关键字可以让客户端传递完整的对象到服务端，服务端修改后不会同步到客户端；
为inout时，客户端执行new Person("客户端InOut")，name为“客户端InOut”;服务端首先打印了客户端传来的名字是“客户端InOut”，然后执行setName("服务器改了人的名字 InOut")，返回客户端，客户端打印的名字为“服务器改了人的名字 InOut”，所以说明了inout关键字可以让客户端传递完整的对象到服务端，服务端修改后会同步到客户端；
为out时，客户端执行new Person("客户端out")，name为“客户端InOut”;服务端首先打印了客户端传来的名字是“null”，然后执行setName("服务器改了人的名字 Out")，返回客户端，客户端打印的名字为“服务器改了人的名字 Out”，所以说明了out关键字可以让客户端传递对象到服务端,但是对象的属性为null，服务端修改后会同步到客户端；

2、AIDL详解

首先还是先看一下根据aidl文件生成的代码的结构：

image.png

用aidl实现线程间通信，生成的代码主要分两方面分析，Stub接收端和Proxy发送端，先看一下类的继承关系：

public static abstract class Stub extends android.os.Binder implements com.wsy.service.IWsyAidl

private static class Proxy implements com.wsy.service.IWsyAidl

由此可见Stub和Proxy都实现了IWsyAidl接口，Stub还继承了Binder抽象类。先分析下Stub中的方法：

Stub():

public Stub() {
    this.attachInterface(this, DESCRIPTOR);
}

Binder:
public void attachInterface(@Nullable IInterface owner, @Nullable String descriptor) {
    mOwner = owner;
    mDescriptor = descriptor;
}

Stub方法调用的其实是父类Binder的attachInterface方法，其实就是用Stub自己及Stub中的DESCRIPTOR做了初始化的操作：

asInterface(IBinder):

public static com.wsy.service.IWsyAidl asInterface(android.os.IBinder obj) {
    if ((obj == null)) {
        return null;
    }
    android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
    if (((iin != null) && (iin instanceof com.wsy.service.IWsyAidl))) {
        return ((com.wsy.service.IWsyAidl) iin);
    }
    return new com.wsy.service.IWsyAidl.Stub.Proxy(obj);
}

public @Nullable IInterface queryLocalInterface(@NonNull String descriptor) {
    if (mDescriptor != null && mDescriptor.equals(descriptor)) {
        return mOwner;
    }
    return null;
}

在Binder中queryLocalInterface中，mDescriptor就是Stub方法中传入的DESCRIPTOR，符合条件的话返回mOwer，即Stub的实例。
asInterface作用就是判断返回一个Stub实例，如果属于同一进城则直接返回Stub，否则返回一个Stub的代理。(因为返回类型是IWsyAidl,而Stub和Proxy都实现了IWsyAidl接口，所以返回Stub和Proxy都没问题)

asBinder(),返回一个Binder对象:

public android.os.IBinder asBinder() {
    return this;
}

onTransact()就是Stub作为接收端的处理方法，先不讲，接下来看Proxy结构，Proxy是Stub的内部类

image.png

Proxy():

Proxy(android.os.IBinder remote) {
    mRemote = remote;
}

构造方法，mRemote保存了一个Binder实例。在Stub的分析中当不属于统一进程时会调用new com.wsy.service.IWsyAidl.Stub.Proxy(obj)，所以这里其实存的是服务端Stub的实例；
asBinder()，返回Stub实例：

public android.os.IBinder asBinder() {
    return mRemote;
}

getInterfaceDescriptor(),返回描述符即Stub.DESCRIPTOR：

public java.lang.String getInterfaceDescriptor() {
    return DESCRIPTOR;
}

Proxy实现IWsyAidl接口，所以必须实现接口中的四个方法

image.png

以addPersonIn为例：

public void addPersonIn(com.wsy.service.Person person) 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 ((person != null)) {
            _data.writeInt(1);
            person.writeToParcel(_data, 0);
        } else {
            _data.writeInt(0);
        }
        boolean _status = mRemote.transact(Stub.TRANSACTION_addPersonIn, _data, _reply, 0);
        if (!_status && getDefaultImpl() != null) {
            getDefaultImpl().addPersonIn(person);
            return;
        }
        _reply.readException();
    } finally {
        _reply.recycle();
        _data.recycle();
    }
}

_data和_reply都是通过池获取到的序列化实例，_data其实是客户端发送给服务端的数据，_reply是服务端返回给客户端的数据。_data.writeInterfaceToken(DESCRIPTOR)，向要发送的数据中写入描述符，
如果person不为空，执行person.writeToParcel(_data, 0)，即：

public void writeToParcel(Parcel dest, int flags) {
    dest.writeString(name);
}

所以，_data中其实包含两个数据，一个是int类型的1，一个是String类型的name；然后调用mRemote.transact(Stub.TRANSACTION_addPersonIn, _data, _reply, 0);上面提到了，mRemote其实就是服务端的Stub实例，所以这里从客户端回到了服务端，transact是IBinder接口中的方法，所以看下Binder类：

public final boolean transact(int code, @NonNull Parcel data, @Nullable Parcel reply,
        int flags) throws RemoteException {
    if (false) Log.v("Binder", "Transact: " + code + " to " + this);

    if (data != null) {
        data.setDataPosition(0);
    }
    boolean r = onTransact(code, data, reply, flags);
    if (reply != null) {
        reply.setDataPosition(0);
    }
    return r;
}

里面找到了，onTransact方法，上面提到过Stub继承了Binder类，所以回到Stub中：

public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException {
        java.lang.String descriptor = DESCRIPTOR;
        switch (code) {
            case INTERFACE_TRANSACTION: {
                reply.writeString(descriptor);
                return true;
            }
            case TRANSACTION_addPersonIn: {
                data.enforceInterface(descriptor);
                com.wsy.service.Person _arg0;
                if ((0 != data.readInt())) {
                    _arg0 = com.wsy.service.Person.CREATOR.createFromParcel(data);
                } else {
                    _arg0 = null;
                }
                this.addPersonIn(_arg0);
                reply.writeNoException();
                return true;
            }
            case TRANSACTION_addPersonInOut: {
                data.enforceInterface(descriptor);
                com.wsy.service.Person _arg0;
                if ((0 != data.readInt())) {
                    _arg0 = com.wsy.service.Person.CREATOR.createFromParcel(data);
                } else {
                    _arg0 = null;
                }
                this.addPersonInOut(_arg0);
                reply.writeNoException();
                if ((_arg0 != null)) {
                    reply.writeInt(1);
                    _arg0.writeToParcel(reply, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
                } else {
                    reply.writeInt(0);
                }
                return true;
            }
            case TRANSACTION_addPersonOut: {
                data.enforceInterface(descriptor);
                com.wsy.service.Person _arg0;
                _arg0 = new com.wsy.service.Person();
                this.addPersonOut(_arg0);
                reply.writeNoException();
                if ((_arg0 != null)) {
                    reply.writeInt(1);
                    _arg0.writeToParcel(reply, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
                } else {
                    reply.writeInt(0);
                }
                return true;
            }
            case TRANSACTION_getPersons: {
                data.enforceInterface(descriptor);
                java.util.List<com.wsy.service.Person> _result = this.getPersons();
                reply.writeNoException();
                reply.writeTypedList(_result);
                return true;
            }
            default: {
                return super.onTransact(code, data, reply, flags);
            }
        }
    }

code即为客户调用mRemote.transact(Stub.TRANSACTION_addPersonIn, _data, _reply, 0)对应的参数Stub.TRANSACTION_addPersonIn，

static final int TRANSACTION_addPersonIn = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
static final int TRANSACTION_addPersonInOut = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
static final int TRANSACTION_addPersonOut = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2);
static final int TRANSACTION_getPersons = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3);

这些值其实就是1、2、3、4，这里是个小技巧，因为服务端可客户端的代码完全一致，所以用数字代表定义的方法，这样相对于通过方法名找到对应的方法更高效。
code的作用就是为了让到服务端要执行哪个方法，这里以addPersonIn为例，所以看这里：

case TRANSACTION_addPersonIn: {
    data.enforceInterface(descriptor);
    com.wsy.service.Person _arg0;
    if ((0 != data.readInt())) {
        _arg0 = com.wsy.service.Person.CREATOR.createFromParcel(data);
    } else {
        _arg0 = null;
    }
    this.addPersonIn(_arg0);
    reply.writeNoException();
    return true;
}

data是客户端传来的序列化对象，在Proxy的分析中，如果person不为空，data中包含int类型的1和String类型的name。所以这里会走_arg0 = com.wsy.service.Person.CREATOR.createFromParcel(data)，即

public static final Creator<Person> CREATOR = new Creator<Person>() {
    @Override
    public Person createFromParcel(Parcel in) {
        return new Person(in);
    }

    @Override
    public Person[] newArray(int size) {
        return new Person[size];
    }
};
    
protected Person(Parcel in) {
    name = in.readString();
}

这里其实是创建了一个新的Person对象，然后用客户端传来的数据给Person的属性赋了值，然后调用this.addPersonIn(_arg0)即Stub的实现类的addPersonIn方法，上面在server中的PersonService类中定义了Stub的实现类：

image.png

reply是返回给客户端的对象，因为addPersonIn没有返回值，所以返回客户端直接reply.writeNoException()就可以了。如果客户端需要返回值，如getPersons方法，则

reply.writeNoException(); 
reply.writeTypedList(_result);

当客户端调用服务端借口时，客户端的进城处于挂起状态，会一直等待服务端处理数据后返回。

至于客户端是怎么获取到的服务端的Stub对象，如何绑定成功的可以参考bindService源码解析

IPC之AIDL分析

IPC之AIDL分析

AIDL用法及代码分析

1、AIDL用法

服务端

新建项目，名字定义为server，顾名思义当做服务端，然后创建aidl文件，项目结构如下图：

在对应的目录下创建Person类实现Parcelable接口：

build项目，项目会在build目录下自动生成aidl对应的文件：

创建Service类，里面重写onBind方法，返回IWsyAidl.Stub的实例

在清单文件配置Service

启动服务

客户端

新建项目，名字为client，作为客户端

绑定服务

运行server，启动服务；运行client，绑定服务：

分别点击添加IN、添加INOUT、添加OUT

2、AIDL详解