Android的IPC机制(二)——AIDL实现原理简析
2016-02-20 20:10
465 查看
综述
上篇说到AIDL的使用方法,我们不能仅仅只是满足对AIDL的使用,那么对于AIDL到底是如何实现的呢?为什么我们只是创建一个AIDL文件,系统就会为我们自动生成一个Java文件,那么这个Java文件里面到底包含了哪些内容呢?我们今天就来研究一下。AIDL实现原理
在这里我们首先看一下AIDL是怎么实现的。当我们创建一个Service和一个AIDL接口的时候,然后创建一个Binder对象并在Service中的onBind方法中去返回这个Binder对象到客户端,客户端得到这个对象后就可以绑定服务端的Service,并且与服务端建立连接后就可以访问服务端的方法了。所以在整个AIDL的实现过程中这个Binder是关键。那么这个Binder究竟是什么呢?在这里简要说明一下。Binder是一种进程间的通信方式。Binder在Linux 内核中是一个驱动程序(/dev/binder),ServiceManager通过这个Binder驱动连接各种Manager(AvtivityManager,WindowManager等)。在Android的应用层中通过Binder实现Android的RPC(Remote Procedure Call 远程进程调用)过程。
以上篇文章中的加法运算为例分析来一下Binder在应用层的实现机制,我们可以看到在服务端通过new ICalculate.Stub()来创建一个Binder对象,那么我们找到ICalculate的Java代码。 也就是系统根据我们的AIDL接口自动生成Java文件。
/* * This file is auto-generated. DO NOT MODIFY. * Original file: G:\\Android\\androidstudioProject\\aidl\\AIDLClient\\app\\src\\main\\aidl\\com\\ljd\\aidl\\ICalculate.aidl */ package com.ljd.aidl; // Declare any non-default types here with import statements public interface ICalculate extends android.os.IInterface { /** Local-side IPC implementation stub class. */ public static abstract class Stub extends android.os.Binder implements com.ljd.aidl.ICalculate { private static final java.lang.String DESCRIPTOR = "com.ljd.aidl.ICalculate"; /** Construct the stub at attach it to the interface. */ public Stub() { this.attachInterface(this, DESCRIPTOR); } /** * Cast an IBinder object into an com.ljd.aidl.ICalculate interface, * generating a proxy if needed. */ public static com.ljd.aidl.ICalculate asInterface(android.os.IBinder obj) { if ((obj==null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin!=null)&&(iin instanceof com.ljd.aidl.ICalculate))) { return ((com.ljd.aidl.ICalculate)iin); } return new com.ljd.aidl.ICalculate.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_add: { data.enforceInterface(DESCRIPTOR); int _arg0; _arg0 = data.readInt(); int _arg1; _arg1 = data.readInt(); int _result = this.add(_arg0, _arg1); reply.writeNoException(); reply.writeInt(_result); return true; } } return super.onTransact(code, data, reply, flags); } private static class Proxy implements com.ljd.aidl.ICalculate { 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 int add(int first, int second) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(); android.os.Parcel _reply = android.os.Parcel.obtain(); int _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeInt(first); _data.writeInt(second); mRemote.transact(Stub.TRANSACTION_add, _data, _reply, 0); _reply.readException(); _result = _reply.readInt(); } finally { _reply.recycle(); _data.recycle(); } return _result; } } static final int TRANSACTION_add = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); } /** * Demonstrates some basic types that you can use as parameters * and return values in AIDL. */ public int add(int first, int second) throws android.os.RemoteException; }
其实这段代码很有规律可寻的。能够看出ICalculate 是一个继承IInterface的接口,IInterface中只声明了一个asBinder接口,用于返回Binder对象。所有在Binder传输的接口都必须继承这个IInterface接口。在ICalculate的java接口中再次声明了AIDL中的方法并且创建了一个继承Binder的内部抽象类Stub。也就是说这个Stub也就是一个Binder。
在服务端我们通过new ICalculate.Stub()来创建一个Binder对象,我们来看一下这个Stub里面的内容。Stub内定义了一个DESCRIPTOR作为Binder的唯一标识,定义了一个TRANSACTION_add 作为接口方法的id。下面看一下asInterface()方法。
public static com.ljd.binder.ICalculate asInterface(android.os.IBinder obj) { if ((obj == null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin != null) && (iin instanceof com.ljd.binder.ICalculate))) { return ((com.ljd.binder.ICalculate) iin); } return new com.ljd.binder.ICalculate.Stub.Proxy(obj); }
这个方法是在客户端被调用,运行在主线程当中,是将服务端返回来的Binder对象转为客户端所需要的接口对象。通过Binder对象的queryLocalInterface方法去查找客户端进程中是否存在所需要的接口对象。存在的话就直接返回这个接口对象。也就是说这时候客户端和服务端在同一个进程内。若是不存在,就创建一个Proxy对象。Proxy是Stub的一个内部代理类。我们看一下Proxy里面到底做了什么。
private static class Proxy implements com.ljd.aidl.ICalculate { 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 int add(int first, int second) throws android.os.RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(); android.os.Parcel _reply = android.os.Parcel.obtain(); int _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeInt(first); _data.writeInt(second); mRemote.transact(Stub.TRANSACTION_add, _data, _reply, 0); _reply.readException(); _result = _reply.readInt(); } finally { _reply.recycle(); _data.recycle(); } return _result; } }
在跨进程通信中,由于是在asInterface方法中创建了一个Proxy对象,所以,Proxy也是运行在客户端的主线程中。在Proxy类中实现了ICalculate接口,定义了IBinder接口对象。通过实现asBinder接口返回这个IBinder接口对象。而对于我们自己定义的add接口方法中创建两个Parcel对象_data和_reply (Parcel可以说是一个存放读取数据的容器,在Parcel内部包装了可序列化的数据,并且可以在Binder中自由的传输)。我们可以很清晰看出_data对象写入了我们传入的参数,而_reply 则是用来存放方法的返回值。紧接着调用了Binder的transact方法。在transact方法方法中将方法id,_data,_reply作为参数传入进去。下面看一下Binder的transact方法。
public final boolean transact(int code, Parcel data, 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; }
我们可以很明显的看到在transact方法中调用了onTransact方法并返回了一个boolean类型。当返回false的时候客户端请求就会失败。在Stub中我们重写onTransact方法。下面我们看一下onTransact方法。
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_add: { data.enforceInterface(DESCRIPTOR); int _arg0; _arg0 = data.readInt(); int _arg1; _arg1 = data.readInt(); int _result = this.add(_arg0, _arg1); reply.writeNoException(); reply.writeInt(_result); return true; } } return super.onTransact(code, data, reply, flags); }
在onTransact方法中我们会根据code来判断所需要执行的方法,通过data取出所需要的参数,然后执行该方法,若是有返回值则将将返回值写入reply中。在这里Parcel对象data和reply读写顺序要严格保持一致。
可以看出Binder运行的整个流程也就是:当客户端绑定服务端发起远程请求,客户端进程处于休眠,当前线程处于挂起状态。然后服务端开始执行,执行完毕后将结果返回给客户端。然后客户端继续执行。
这也说明了当远程方法是一个很耗时的操作时,我们不应该在主线程中发起请求。而服务端的Binder方法在Binder线程池中运行,所以Binder不论是否耗时都不应该重新为他在开启一个线程。
到这里AIDL中Binder的工作机制已经分析完了。现在我们可以发现完全不用AIDL文件也能够实现跨进程的方法调用。那么我们自己来写一个Binder去实现服务端与客户端的跨进程的方法调用。
自定义Binder的实现
实现过程
在这里我们创建一个继承IInterfaceJava接口,在接口里面我们去声明算术的加减法运算。package com.ljd.binder.custombinder; import android.os.IInterface; public interface ICalculate extends IInterface { static final int TRANSACTION_add = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); static final int TRANSACTION_sub = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); public int add(int first, int second) throws android.os.RemoteException; public int sub(int first, int second) throws android.os.RemoteException; }
然后我们再去实现这个接口。
package com.ljd.binder.custombinder; import android.os.Binder; import android.os.IBinder; import android.os.IInterface; import android.os.Parcel; import android.os.RemoteException; import android.util.Log; /** * Created by ljd-PC on 2016/2/21. */ public class Calculate extends Binder implements ICalculate{ private final String TAG = "Calculate"; private static final String DESCRIPTOR = "com.ljd.binder.ICalculate"; @Override public void attachInterface(IInterface owner, String descriptor) { this.attachInterface(this, DESCRIPTOR); } public static ICalculate asInterface(IBinder obj) { if ((obj == null)) { return null; } IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin != null) && (iin instanceof ICalculate))) { return (ICalculate) iin; } return new Proxy(obj); } @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 TRANSACTION_add: { data.enforceInterface(DESCRIPTOR); int _arg0; _arg0 = data.readInt(); int _arg1; _arg1 = data.readInt(); int _result = this.add(_arg0, _arg1); reply.writeNoException(); reply.writeInt(_result); return true; } case TRANSACTION_sub: { data.enforceInterface(DESCRIPTOR); int _arg0; _arg0 = data.readInt(); int _arg1; _arg1 = data.readInt(); int _result = this.sub(_arg0, _arg1); reply.writeNoException(); reply.writeInt(_result); return true; } } return super.onTransact(code, data, reply, flags); } @Override public int add(int first, int second) throws RemoteException { Log.e(TAG,String.valueOf(first+second)); return first + second; } @Override public int sub(int first, int second) throws RemoteException { return first - second; } @Override public IBinder asBinder() { return null; } private static class Proxy implements ICalculate { private IBinder mRemote; Proxy(IBinder remote) { mRemote = remote; } @Override public IBinder asBinder() { return mRemote; } public String getInterfaceDescriptor() { return DESCRIPTOR; } @Override public int add(int first, int second) throws RemoteException { Parcel _data = Parcel.obtain(); Parcel _reply = Parcel.obtain(); int _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeInt(first); _data.writeInt(second); mRemote.transact(TRANSACTION_add, _data, _reply, 0); _reply.readException(); _result = _reply.readInt(); } finally { _reply.recycle(); _data.recycle(); } return _result; } @Override public int sub(int first, int second) throws RemoteException { android.os.Parcel _data = android.os.Parcel.obtain(); android.os.Parcel _reply = android.os.Parcel.obtain(); int _result; try { _data.writeInterfaceToken(DESCRIPTOR); _data.writeInt(first); _data.writeInt(second); mRemote.transact(TRANSACTION_sub, _data, _reply, 0); _reply.readException(); _result = _reply.readInt(); } finally { _reply.recycle(); _data.recycle(); } return _result; } } }
在这里创建一个Service。
package com.ljd.binder.custombinder; import android.app.Service; import android.content.Intent; import android.os.IBinder; public class CalculateService extends Service { private Calculate mCalculate; public CalculateService() { mCalculate = new Calculate(); } @Override public IBinder onBind(Intent intent) { return mCalculate; } }
在上篇文章中说过我们可以通过android:process 属性为服务端开启一个进程。
<service android:name=".custombinder.CalculateService" android:process=":remote"> <intent-filter> <action android:name="com.ljd.binder.CUSTOM_BINDER"></action> <category android:name="android.intent.category.DEFAULT"></category> </intent-filter> </service>
其中:remote是一种简写法,全称为com.ljd.binder.custombinder:remote。以:开头的进程是属于当前应用的私有进程,其他应用的组件不能和他运行在同一个进程中。
下面是客户端代码。
package com.ljd.binder.custombinder; import android.content.ComponentName; import android.content.Context; import android.content.Intent; import android.content.ServiceConnection; import android.os.IBinder; import android.os.RemoteException; import android.support.v7.app.AppCompatActivity; import android.os.Bundle; import android.util.Log; import android.view.View; import android.widget.Toast; import com.ljd.binder.*; import butterknife.ButterKnife; import butterknife.OnClick; public class CustomBinderActivity extends AppCompatActivity { private final String TAG = "CustomBinderActivity"; private ICalculate mCalculate; private IBinder.DeathRecipient mDeathRecipient = new IBinder.DeathRecipient() { @Override public void binderDied() { if(mCalculate != null){ mCalculate.asBinder().unlinkToDeath(mDeathRecipient,0); mCalculate = null; bindService(); } } }; private ServiceConnection mConnection = new ServiceConnection() { @Override public void onServiceConnected(ComponentName name, IBinder service) { Log.e(TAG,"Bind Success"); mCalculate = Calculate.asInterface(service); try { mCalculate.asBinder().linkToDeath(mDeathRecipient,0); } catch (RemoteException e) { e.printStackTrace(); } } @Override public void onServiceDisconnected(ComponentName name) { mCalculate = null; } }; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_custom_binder); ButterKnife.bind(this); bindService(); } @Override protected void onDestroy() { super.onDestroy(); ButterKnife.unbind(this); unbindService(mConnection); } @OnClick({R.id.custom_add_btn,R.id.custom_sub_btn}) public void onClickButton(View v){ if (mCalculate == null){ return; } switch (v.getId()){ case R.id.custom_add_btn: try { Toast.makeText(this,String.valueOf(mCalculate.add(6,2)),Toast.LENGTH_SHORT).show(); } catch (RemoteException e) { e.printStackTrace(); } break; case R.id.custom_sub_btn: try { Toast.makeText(this,String.valueOf(mCalculate.sub(6,2)),Toast.LENGTH_SHORT).show(); } catch (RemoteException e) { e.printStackTrace(); } break; default: break; } } private void bindService(){ Intent intent = new Intent("com.ljd.binder.CUSTOM_BINDER"); bindService(intent,mConnection, Context.BIND_AUTO_CREATE); } }
效果演示
总结
我们现在自己已经实现了跨进程间的调用。而且我们构建的这个Binder几乎和系统生成的一模一样。所以AIDL就是对Binder进行了一次封装,并且能够支持多线程并发访问。通过AIDL的使用能够大大简化了我们开发过程,节约了我们的开发时间。源码下载
相关文章推荐
- android audio buffer 分析
- 解决Android Studio Fetching Android SDK component information失败问题
- android audio分析
- android audio 音量设置分析
- android 三级菜单 BaseExpandableListAdapter
- Android Support V4, V7, V13的作用与用法
- Ubuntu的Android开发环境配置
- {Android} 测试Google Play In-App-Billing支付
- Android Studio快捷键指南(本文持续更新)
- Android Studio快捷键指南(本文持续更新)
- Android Studio快捷键指南(本文持续更新)
- Android Studio快捷键指南(本文持续更新)
- android xmpp
- Android通过JNI操作串口
- Android 性能测试_Monkey 实践【转】
- Android Monkey 测试策略【转】
- Android&java的成长之路之四(自定义字母索引)
- Android项目使用support v7时遇到的各种问题
- Android Widget学习笔记
- android 5.1预置apk