解析Android AIDL的实例与原理
目录
- 一、概述
- 二、创建 .aidl 文件
- 三、生成 .java 文件
- 四、传输复杂数据
- 五、建立 service
- 六、获取服务
- 七、分析调用过程
一、概述
简单来说,AIDL 就是定义一个接口,客户端(调用端)通过 bindService 来与远程服务端建立一个连接,在该连接建立时会将返回一个 IBinder 对象,该对象是服务端 Binder 的 BinderProxy。在建立连接时,客户端通过 asInterface 函数将该 BinderProxy 对象包装成本地的 Proxy,并赋值给Proxy类的 mRemote 字段,本地通过 mRemote 即可调用远程方法。
二、创建 .aidl 文件
首先打开 Android Studio,new 一个 AIDL file。具体代码如下 :
interface IMyAidlInterface { /** * 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); }
basicTypes 方法事接口自带的,不过可以知道,在 aidl 中只能使用这些基本类型参数:int, long, boolean, float,double, String ;
除了basicTypes 方法之外,我们也可以添加自己的方法。因此,可以删除basicTypes 方法,添加自己的方法。
三、生成 .java 文件
添加完方法之后,选中 .aidl 文件,在弹出的菜单中选择 Synchronize LocalAIDLS... Service.java,就会会自动帮你生成对应的 java 代码。
格式化代码之后,如下所示:
package com.example.databasetest; public interface IMyAidlInterface extends android.os.IInterface { /** * Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements com.example.databasetest.IMyAidlInterface { private static final java.lang.String DESCRIPTOR = "com.example.databasetest.IMyAidlInterface"; /** * Construct the stub at attach it to the interface. */ public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an com.example.databasetest.IMyAidlInterface interface, * generating a proxy if needed. */ public static com.example.databasetest.IMyAidlInterface asInterface(android.os.IBinder obj) { if ((obj == null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin != null) && (iin instanceof com.example.databasetest.IMyAidlInterface))) { return ((com.example.databasetest.IMyAidlInterface) iin); } return new com.example.databasetest.IMyAidlInterface.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; } } return super.onTransact(code, data, reply, flags); } private static class Proxy implements com.example.databasetest.IMyAidlInterface { 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); // 这里是重点,proxy 持有引用,这样就可以进行数据交换,也不会暴露这个对象 mRemote.transact(Stub.TRANSACTION_basicTypes, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } } static final int TRANSACTION_basicTypes = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); } /** * 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; }
如果,你需要修改 .aidl 文件,那么修改之后,选择 build -> make project 即可,会重新生成对应的java文件。
对于生成的这个java 类,很多刚接触的人会不理解,这里需要解释下:
- IMyAidlInterface :这个是我们自己定义的一个 servier 接口,也就是将你想要有的功能定义在接口中;
- IBinder:定义了与远程对象的交互协议,代表一种跨进程传输的能力,实现这个接口,就能将这个对象进行跨进程传递,但是如果要使用的话,推荐继承其子类 Binder;
- Binder:实现了 IBinder 接口,代表的其实就是Binder 本地对象。BinderProxy 类是 Binder 类的一个内部类,它代表远程进程的 Binder 对象的本地代理;这两个类都继承自IBinder, 因而都具有跨进程传输的能力;实际上,在跨越进程的时候,Binder 驱动会自动完成这两个对象的转换。
- Stub: AIDL 的时候,编译工具会给我们生成一个名为 Stub 的静态内部抽象类;这个类继承了 Binder, 说明它是一个 Binder 本地对象,它实现了 IInterface 接口,表明它具有 Server 承诺给 Client 的能力;Stub 是一个抽象类,具体的 IInterface 的相关实现需要开发者自己实现。
- IInterface:IInterface 代表的就是 Server 进程对象具备什么样的能力(能提供哪些方法,其实对应的就是 AIDL 文件中定义的接口)
- proxy:Stub 的静态内部类,是一个实现了IMyAidlInterface接口,所以他是一个远程代理对象,可以用于返回给客户端用。当 client 调用 proxy的某个方法的时候,会将参数传到 proxy 中,在通过其持有的远程实际对象,将方法名和参数等都传给远程实际对象,然后就会回调onTransact,对应的方法就会被调用,以此来实现跨进程调用。
四、传输复杂数据
如果,需要传递复杂数据,那么就需要实现Parcelable 接口,可序列化:
public class Info implements Parcelable { private String content; public String getContent() { return content; } public void setContent(String content) { this.content = content; } public Info() { } public Info(Parcel in) { content = in.readString(); } public static final Creator<Info> CREATOR = new Creator<Info>() { @Override public Info createFromParcel(Parcel in) { return new Info(in); } @Override public Info[] newArray(int size) { return new Info[size]; } }; @Override public int describeContents() { return 0; } @Override public void writeToParcel(Parcel dest, int flags) { dest.writeString(content); } /** * 参数是一个Parcel,用它来存储与传输数据 * * @param dest */ public void readFromParcel(Parcel dest) { //注意,此处的读值顺序应当是和writeToParcel()方法中一致的 content = dest.readString(); } //方便打印数据 @Override public String toString() { return "content : " + content; } }
与此同时,也要建一个 info.aidl 文件,表明数据也是可以传递的。
package com.viii.aidlclient; //注意:Info.Info.java的包名应当是一样的 //这个文件的作用是引入了一个序列化对象 Info 供其他的AIDL文件使用 //注意parcelable是小写 parcelable Info;
这样就可以使用 info 对象了。 不用在受前面的基本类型变量所控制。
五、建立 service
接下去,新建一个Service负责接收消息,并在AndroidManifest.xml里面注册 Service:
public class MyService extends Service { private static final String TAG = "MyService"; // private MyBinder mMyBinder = new MyBinder(); @Nullable @Override public IBinder onBind(Intent intent) { Log.d(TAG, "onBind: "); // 应该返回 mBinder return null; } @Override public void onCreate() { Log.d(TAG, "onCreate: "); super.onCreate(); } @Override public int onStartCommand(Intent intent, int flags, int startId) { Log.d(TAG, "onStartCommand: "); return super.onStartCommand(intent, flags, startId); } // 这里就是服务端的实现,继承了 stub,想要怎么样的能力,自己去实现 private final IMyAidlInterface.Stub mBinder = new IMyAidlInterface.Stub() { @Override public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, String aString) throws RemoteException { // 具体实现过程 } }; }
这时候,可以basicTypes 方法添加具体函数代码,实现你想要的功能。
当我们在本地获取到代理后之后,调用basicTypes 就会触发服务端的调用。
六、获取服务
接下去在 mainactivity 中进行绑定。
public class MainActivity extends AppCompatActivity { private static final String TAG = "MainActivity"; private IMyAidlInterface mService; private boolean mIsBound; private AdditionServiceConnection mServiceConnection; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); doBindService() ; }/** * bind service */ private void doBindService() { mServiceConnection = new AdditionServiceConnection(); Intent intent = new Intent(this, MyService.class); bindService(intent, mServiceConnection, BIND_AUTO_CREATE); } /** * unbind service */ private void doUnbindService() { if (mIsBound) { unbindService(mServiceConnection); mServiceConnection = null; mIsBound = false; } } /** * ServiceConection */ class AdditionServiceConnection implements ServiceConnection { @Override public void onServiceConnected(ComponentName name, IBinder service) { // 连接的时候获取本地代理,这样我们就可以调用 service 中的方法了。 mService = IMyAidlInterface.Stub.asInterface((IBinder) service); mIsBound = true; try { //设置死亡代理 service.linkToDeath(mDeathRecipient, 0); } catch (RemoteException e) { e.printStackTrace(); } Log.d(TAG, "onServiceConnected: "); } @Override public void onServiceDisconnected(ComponentName name) { mService = null; mIsBound = false; Log.d(TAG, "onServiceDisconnected: "); } } /** * 监听Binder是否死亡 */ private IBinder.DeathRecipient mDeathRecipient = new IBinder.DeathRecipient() { @Override public void binderDied() { if (mService == null) { return; } mService.asBinder().unlinkToDeath(mDeathRecipient, 0); mService = null; //重新绑定 doBindService(); } }; @Override protected void onStop() { super.onStop(); doUnbindService(); } }
将远程服务的 binder 拿到之后,我们就可以调用相关方法实现自己的功能呢。
到这里,一个 AIDL 就被我们实现了。
七、分析调用过程
看看 asInterface 方法,我们在 bind 一个 Service 之后,在 onServiceConnecttion 的回调里面,就是通过这个方法拿到一个远程的 service 的,这个方法做了什么呢?
/** * Cast an IBinder object into an com.example.databasetest.IMyAidlInterface interface, * generating a proxy if needed. */ public static com.example.databasetest.IMyAidlInterface asInterface(android.os.IBinder obj) { if ((obj == null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin != null) && (iin instanceof com.example.databasetest.IMyAidlInterface))) { return ((com.example.databasetest.IMyAidlInterface) iin); } // 实际上,代理对象持有真实对象,同时代理对象会对数据进行处理后,再调用实体对象的方法 return new com.example.databasetest.IMyAidlInterface.Stub.Proxy(obj); }
首先看函数的参数IBinder
类型的 obj,这个对象是驱动给我们的,如果是 Binder 本地对象,那么它就是 Binder 类型,如果是 Binder 代理对象,那就是BinderProxy
类型;它会试着查找 Binder 本地对象,如果找到,说明 Client 和 Server 都在同一个进程,这个参数直接就是本地对象,直接强制类型转换然后返回。
如果找不到,说明是远程对象(处于另外一个进程)那么就需要创建一个 Binder 代理对象,让这个 Binder 代理实现对于远程对象的访问。一般来说,如果是与一个远程 Service 对象进行通信,那么这里返回的一定是一个 Binder 代理对象,这个 IBinder 参数的实际上是 BinderProxy;
再看看我们对于 aidl 的basicTypes方法的实现;在 Stub 类里面,basicTypes是一个抽象方法,我们需要继承这个类并实现它;如果 Client 和 Server 在同一个进程,那么直接就是调用这个方法;那么,如果是远程调用,这中间发生了什么呢?Client 是如何调用到 Server 的方法的?
对于远程方法的调用,是通过 Binder 代理完成的,在这个例子里面就是Proxy
类;Proxy
对于basicTypes方法的实现如下:
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(); } }
它首先用 Parcel 把数据序列化了,然后调用了 transact 方法;这个 transact 到底做了什么呢?这个 Proxy 类在 asInterface 方法里面被创建,前面提到过,如果是 Binder 代理那么说明驱动返回的 IBinder 实际是 BinderProxy,因此我们的 Proxy 类里面的 mRemote 实际类型应该是BinderProxy;我们看看 BinderProxy 的 transact 方法:( Binder.java 的内部类)
public native boolean transact(int code, Parcel data, Parcel reply, int flags) throws RemoteException;
这是一个本地方法;它的实现在 native 层,具体来说在 frameworks/base/core/jni/android_util_Binder.cpp 文件,里面进行了一系列的函数调用,调用链实在太长这里就不给出了;要知道的是它最终调用到了talkWithDriver函数;看这个函数的名字就知道,通信过程要交给驱动完成了;这个函数最后通过 ioctl 系统调用,Client 进程陷入内核态,Client 调用 basicTypes 方法的线程挂起等待返回;驱动完成一系列的操作之后唤醒 Server 进程,调用了Server进程本地对象的 onTransact 函数(实际上由 Server 端线程池完成)。我们再看 Binder 本地对象的 onTransact 方法(这里就是 Stub 类里面的此方法):
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; } } return super.onTransact(code, data, reply, flags); }
在 Server 进程里面,onTransact 根据调用号(每个 AIDL 函数都有一个编号,在跨进程的时候,不会传递函数,而是传递编号指明调用哪个函数)调用相关函数。
在这个例子里面,调用了 Binder 本地对象的 basicTypes 方法;这个方法将结果返回给驱动,驱动唤醒挂起的 Client 进程里面的线程并将结果返回。于是一次跨进程调用就完成了。
至此,你应该对 AIDL 这种通信方式里面的各个类以及各个角色有了一定的了解;它总是那么一种固定的模式:一个需要跨进程传递的对象一定继承自 IBinder,如果是 Binder 本地对象,那么一定继承 Binder 实现 IInterface,如果是代理对象,那么就实现了 IInterface 并持有了 IBinder 引用;
Proxy 与 Stub 不一样,虽然他们都既是 Binder 又是 IInterface,不同的是 Stub 采用的是继承(is 关系),Proxy采用的是组合(has 关系)。他们均实现了所有的 IInterface 函数。
不同的是,Stub又使用策略模式调用的是虚函数(待子类实现),而 Proxy 则使用组合模式。为什么Stub采用继承而 Proxy 采用组合?事实上,Stub 本身 is 一个 IBinder(Binder),它本身就是一个能跨越进程边界传输的对象,所以它得继承 IBinder 实现 transact 这个函数从而得到跨越进程的能力(这个能力由驱动赋予)。
Proxy 类使用组合,是因为他不关心自己是什么,它也不需要跨越进程传输,它只需要拥有这个能力即可,要拥有这个能力,只需要保留一个对 IBinder 的引用。
以上就是解析Android AIDL的实例与原理的详细内容,更多关于Android AIDL的资料请关注我们其它相关文章!