AIDL定义
AIDL(Andrid接口定义语言)通常用于进程间通讯。编译器根据AIDL文件生成一系列对应的Java类，，通过预先定义的接口以及Binder机制达到进程间通讯的目的。说白了，AIDL就是定义一个接口，客户端(调用端)通过bindService来与远程服务端建立一个连接，在建立连接成功后会返回一个IBnder对象，该对象是服务端Binder的BinderProxy，在建立连接时，客户端会通过asInterface函数将BinderProxy对象包装成本地的Proxy,并将远程服务端的BinderProx对象赋值给Proxy类的mRemote字段，就是通过mRemote执行远程函数的调用。
AIDL实现
新建一个AIDL文件，在AS中File-New-AIDL-AIDL file，我们创建一个SsoAuth.aidl文件，里面会默认有一个baseTypes函数。我们在程序后面添加一个ssoAuth函数用于SSO授权。代码如下：
interface SsoAuth {
/**
* Demonstrates some basic types that you can use as
* parameters and return values in AIDL.
*/
void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,double aDouble, String aString);
void ssoAuth(String name,String pwd);
}
因为客户端是调用端，因此，只需要定义AIDL文件，此时重新build一下工程就会生成一个SsoAuth.java类，该类根据SsoAuth.aidl自动生成，包含了我们在AIDL文件成定义的函数。因为AIDL通常用于进程间通讯，因此，我们新建一个被调用的工程，我们命名为aidl_server,然后将客户端的AIDL文件夹复制到aidl_server的app/src/main目录下，如图所示：
此时相当于在客户端和被调用端都有同一份SsoAuth.aidl文件，他们的包名、类型完全一致，生成的SsoAuth.java类也完全一致，这样在远程调用时它们就能够拥有一致的类型。Rebuild被调用工程之后就会生成SsoAuth.java文件，该文件中有一个Stub类实现了SsoAuth接口。我们首先需要定义一个Service子类，然后在定义一个继承Stub的子类，并且在Service的onBind函数中返回这个Stub子类的对象。
public class SsoAuthService extends Service {
private String TAG = "TAG";
SsoAuthImpl mBinder = new SsoAuthImpl();
public SsoAuthService() {
}
@Override
public void onCreate() {
super.onCreate();
Log.i(TAG, "onCreate: ");
}
@Override
public IBinder onBind(Intent intent) {
return mBinder;
}
class SsoAuthImpl extends SsoAuth.Stub {
@Override
public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, String aString) throws RemoteException {
Log.i(TAG, "basicTypes: ");
}
@Override
public void ssoAuth(String name, String pwd) throws RemoteException {
Log.i(TAG, "ssoAuth: >>>"+name+" 密码：>"+pwd);
}
}
}
从上述代码中我们可以看到，实际上完成功能的继承自Stub的SsoAuthImpl类，Service只是提供了一个让SsoAuthImpl依附的外壳。完成SsoAuthService之后我们需要注册到清单文件中，代码如下：
<service
android:name=".SsoAuthService"
android:process=":remote"
android:enabled="true"
android:exported="true">
<intent-filter>
<action android:name="com.shengmingji.aidl_server.SsoAuthService" />
</intent-filter>
</service>
然后先运行服务端应用，并且在客户端中完成调用Server的代码。客户端Activity的代码：
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
public void bindServer(View view) {
if (ssoAuth == null) {
Intent intent = new Intent("com.shengmingji.aidl_server.SsoAuthService");
bindService(intent, connection, BIND_AUTO_CREATE);
} else {
try {
ssoAuth.ssoAuth("hahaha","123456");
} catch (RemoteException e) {
e.printStackTrace();
}
}
}
private SsoAuth ssoAuth;
ServiceConnection connection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
ssoAuth = SsoAuth.Stub.asInterface(service);
}
@Override
public void onServiceDisconnected(ComponentName name) {
ssoAuth = null;
}
};
@Override
protected void onDestroy() {
super.onDestroy();
unbindService(connection);
}
}
上述代码中，运行程序点击登录按钮是会想Server端发起Service请求，在建立连接之后会将Binder对象转换为SsoAuth对象，然后调用SsoAuth对象的SsoAuth函数。此时ssoAuth函数实际上调用的就是Server端SsoAuthImpl类的实现。运行程序点击登录按钮，运行结果
12-14 20:20:59.957 18625-18625/? D/AndroidKeyStoreProvider: not overseas product
12-14 20:20:59.987 18625-18625/com.shengmingji.aidl_server:remote I/TAG: onCreate:
12-14 20:21:10.337 18625-18644/com.shengmingji.aidl_server:remote I/TAG: ssoAuth: >>>hahaha 密码：>123456
12-14 20:21:11.807 18625-18643/com.shengmingji.aidl_server:remote I/TAG: ssoAuth: >>>hahaha 密码：>123456
这一切的核心都是通过AIDL 文件生成的Stub类以及其背后的Binder。首先我们看看生成的SsoAuth.java，Stub类就是该文件中的内部类。代码如下：
public interface SsoAuth extends android.os.IInterface {
/**
* Local-side IPC implementation stub class.
*/
public static abstract class Stub extends android.os.Binder implements com.shengmingji.aidl.SsoAuth {
private static final java.lang.String DESCRIPTOR = "com.shengmingji.aidl.SsoAuth";
/**
* Construct the stub at attach it to the interface.
*/
public Stub() {
this.attachInterface(this, DESCRIPTOR);
}
/**
* Cast an IBinder object into an
* com.shengmingji.aidl.SsoAuth interface,
* generating a proxy if needed.
*/
public static com.shengmingji.aidl.SsoAuth asInterface(android.os.IBinder obj) {
if ((obj == null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin != null) && (iin instanceof com.shengmingji.aidl.SsoAuth))) {
return ((com.shengmingji.aidl.SsoAuth) iin);
}
return new com.shengmingji.aidl.SsoAuth.Stub.Proxy(obj);
}
@Override
public android.os.IBinder asBinder() {
return this;
}
@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_basicTypes: {
data.enforceInterface(DESCRIPTOR);
int _arg0;
_arg0 = data.readInt();
long _arg1;
_arg1 = data.readLong();
boolean _arg2;
_arg2 = (0 != data.readInt());
float _arg3;
_arg3 = data.readFloat();
double _arg4;
_arg4 = data.readDouble();
java.lang.String _arg5;
_arg5 = data.readString();
this.basicTypes(_arg0, _arg1, _arg2, _arg3, _arg4, _arg5);
reply.writeNoException();
return true;
}
case TRANSACTION_ssoAuth: {
data.enforceInterface(DESCRIPTOR);
java.lang.String _arg0;
_arg0 = data.readString();
java.lang.String _arg1;
_arg1 = data.readString();
this.ssoAuth(_arg0, _arg1);
reply.writeNoException();
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
private static class Proxy implements com.shengmingji.aidl.SsoAuth {
private android.os.IBinder mRemote;
Proxy(android.os.IBinder remote) {
mRemote = remote;
}
@Override
public android.os.IBinder asBinder() {
return mRemote;
}
public java.lang.String getInterfaceDescriptor() {
return DESCRIPTOR;
}
/**
* Demonstrates some basic types that you can use as parameters
* and return values in AIDL.
*/
@Override
public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, java.lang.String aString) throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeInt(anInt);
_data.writeLong(aLong);
_data.writeInt(((aBoolean) ? (1) : (0)));
_data.writeFloat(aFloat);
_data.writeDouble(aDouble);
_data.writeString(aString);
mRemote.transact(Stub.TRANSACTION_basicTypes, _data, _reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
@Override
public void ssoAuth(java.lang.String name, java.lang.String pwd) throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(name);
_data.writeString(pwd);
mRemote.transact(Stub.TRANSACTION_ssoAuth, _data, _reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
}
static final int TRANSACTION_basicTypes = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
static final int TRANSACTION_ssoAuth = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
}
/**
* Demonstrates some basic types that you can use as parameters
* and return values in AIDL.
*/
public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, java.lang.String aString) throws android.os.RemoteException;
public void ssoAuth(java.lang.String name, java.lang.String pwd) throws android.os.RemoteException;
}
首先，他声明了两个方法basicTypes()和ssoAuth()。显然这就是我们在SsoAuth.aidl中所声明的方法，同时它还声明了两个整数的id分别用于标识这两个方法，这两个id用于标识在transact过程中客户端所请求的到底哪个方法。接着声明了一个内部类Stub，这个Stub就是一个Binder类，当客户端和服务端都位于同一个进程中时，方法调用不会走跨进程的transact过程，二两者位于同一个进程时，方法调用需要走transac过程。这个逻辑是Stub的内部代理类Proxy来完成。
Stub类说明
在SsoAuth.java中自动生成了SsoAuth接口，该接口中有一个ssoAuth函数，但最重要的是生成了一个Stub类，该类继承自Binder类，并实现了SsoAuth接口。Stub里面最重要的就是asInterface函数，在这个函数总会判断obj参数的类型，如果该obj是本地的接口类型，则认为不是进程间调用，此时将obj转换成SsoAuth类型；否则会通过自动生成的另一个内部类Proxy来包装obj，将其赋值给Proxy中的mRemote字段。Proxy类也实现了SsoAuth接口，不同的是它是通过Binder机制来与远程进程进行交互，例如，在ssoAuth函数中，Proxy将通过Binder机制向服务器传递请求和数据，它请求的类型为TRANSACTION_ssoAuth，参数分别是String类型的name和pwd。
对于服务器来说，它也有一份SsoAuth.aidl以及SsoAuth.java。但不同的是服务端是指令的接收端，客户端的调用会通过Binder机制传递到服务器，最终调用Stub类中的onTransact函数，可以看到在
case TRANSACTION_ssoAuth: {
data.enforceInterface(DESCRIPTOR);
java.lang.String _arg0;
_arg0 = data.readString();
java.lang.String _arg1;
_arg1 = data.readString();
this.ssoAuth(_arg0, _arg1);
reply.writeNoException();
return true;
}
中执行了this.ssoAuth(arg0, arg1) 函数，意思就是当接到客户端的TRANSACTION_ssoAuth请求时，执行this.ssoAuth(_arg0, _arg1)函数，通过客户端分析我们知道，当我们调用ssoAuth函数时实际上就是通过mRemote向服务端提交了一个TRANSACTION_ssoAuth请求，因此，这两端通过Binder机制就对接上了，可以理解为C/S模式。
而在客户端调用bindService之后，如果绑定成功则会调用onServiceConnected，这里的Service对象就是BinderProxy类型，经过asInterface转换后被包装成了Proxy类型，但是调用的时候，执行的是服务端SsoAuthImpl中的ssoAuth函数。因此SsoAuthImpl实例mBinder被服务端包装成了BinderProxy类型，在经过客户端的Proxy进行包装，通过Binder机制进行数据传输，实现进程间调用。
Demo
参考
《Android开发进阶》
