AIDL 原理分析

1.AIDL定义

Android Interface Define Language Android 接口定义语言。用于服务器与客户端通信接口的一种描述语言。可以生成用于IPC的代码模块。

1.1AIDL支持数据类型：

  1.Java中的八种基本数据类型，包括 byte、short、int、long、float、double、boolean、char。
  2.String 类型。
  3.CharSequence类型。
  4.List类型：List中的所有元素必须是AIDL支持的类型之一
  5.Map类型：Map中的所有元素必须是AIDL支持的类型之一

2.AIDL通信原理说明

AIDL文件自动生成接口类，继承IInterface，主要包含两部分Stub和Proxy。Stub继承IBinder，Proxy实现接口类，同时持有Stub(IBinder引用)。

2.1实现流程

Stub类中有一个对于当前aidl接口的描述，这个描述信息同时是唯一的，通过描述信息会将当前接口注册到Binder驱动的内存中

    private static final String DESCRIPTOR = "com.xue.data.xipcutils.aidl.IXIPCAidlInterface";

客户端连接服务器，在serviceConnected中我们获取到AIDL的接口类，我们调用到Stub中asInterface(IBinder)接口，同时将IBinder传入。

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            IXIPCAidlInterface ixipcAidlInterface = IXIPCAidlInterface.Stub.asInterface(service);
            xIpcServiceMap.put(clazz, ixipcAidlInterface);
        }

    public static IXIPCAidlInterface asInterface(android.os.IBinder obj)
    {
      if ((obj==null)) {
        return null;
      }
      android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
      if (((iin!=null)&&(iin instanceof IXIPCAidlInterface))) {
        return ((IXIPCAidlInterface)iin);
      }
     //将IBinder对象作为参数传入到Proxy中
      return new Proxy(obj);
    }

在Proxy类中将IBinder对象保存，名为mRemote

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

客户端调用aidle接口中send(String msg)方法，实则是在调用Proxy中的send方法

 Response response =  iXIPCAidlInterface .send(request);

在Proxy的send方法中，会调用到IBinder 的transact() ，Binder是IBinder的实现类，所以会调用到Binder中的transact方法

  @Override public Response send(Request request) throws android.os.RemoteException
      {
        android.os.Parcel _data = android.os.Parcel.obtain(); //参数
        android.os.Parcel _reply = android.os.Parcel.obtain();//接受者
        Response _result;
        try {
          _data.writeInterfaceToken(DESCRIPTOR);
          if ((request!=null)) {
            _data.writeInt(1);
            request.writeToParcel(_data, 0);//参数序列化 写入到_data中
          }
          else {
            _data.writeInt(0);
          }
        //调用IBinder的transact方法
          boolean _status = mRemote.transact(Stub.TRANSACTION_send, _data, _reply, 0);
          if (!_status && getDefaultImpl() != null) {
            return getDefaultImpl().send(request);
          }
          _reply.readException();
          if ((0!=_reply.readInt())) {
            _result = Response.CREATOR.createFromParcel(_reply);
          }
          else {
            _result = null;
          }
        }
        finally {
          _reply.recycle();
          _data.recycle();
        }
        return _result;
      }

Binder中transact方法 又调用了onTransact方法，前文讲到Stub继承了IBinder,所以调用到了Stub的onTransact方法

    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;
    }

Stub类的onTransact方法,源码中可以看到在onTransct中直接调用到了 this.send(_arg0)方法，实则就是我们服务器端的方法。

    @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException
    {
      String descriptor = DESCRIPTOR;
      switch (code)
        ............
        case TRANSACTION_send:
        {
          data.enforceInterface(descriptor);
          Request _arg0;
          ............
          //反序列化获取到request参数
            _arg0 = Request.CREATOR.createFromParcel(data);
          
        //将客户端的请求信息带入到服务端， 然后由服务端调用方法并返回数据
          Response _result = this.send(_arg0);
          reply.writeNoException();
          if ((_result!=null)) {
            reply.writeInt(1);
            _result.writeToParcel(reply, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
          }
       ...........
    }

再来看下我们服务端的send方法

public class XIPCService extends Service {
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return binder;
    }
    /**
     *注册binder
     */
    private IXIPCAidlInterface.Stub binder = new IXIPCAidlInterface.Stub() {
        @Override
        public Response send(Request request) throws RemoteException {
             Response  response = new Response();
            response.setData("主线程返回数据给你");
            return response;
        }
    };
}

总结下

1.进程A访问进程B，进程A通过bindService启动进程B。
2.进程B在创建的时候就创建了自己的IBinder引用，是Stub类型的AIDL对象。
3.当我们进程A去访问进程的B的时候，在建立连接后，会拿到这个IBinder引用，通过asInterface产生这个进程的Proxy对象。
4.拿到IBinder引用后， 进程A可以通过这个引用去访问对应的进程B，通过调用transcat方法。而transcat方法调用其实就是去连接Binder驱动，写入数据。
5.调用transcat方法会调用同进程Stub的onTransact方法
6.最终服务端进程方法被调用

基于使用aidl进程间通信，鄙人手写了一下进程间通信框架，感兴趣的童鞋可以看下，顺手点个赞哟~
XIPCUtils