乐趣区

关于android:浅析AIDL

作者：

jiezi

在

浅析AIDL

前言

AIDL(Android Interface Define Language) 是IPC过程间通信形式的一种.用于生成能够在Android设施上两个过程之间进行过程间通信(interprocess communication, IPC)的代码.通过简要剖析AIDL的应用，还能够让咱们进一步了解Binder的通信机制。

1 实例阐明

假如一个情景咱们须要计算a+b，咱们须要在客户端传递两个参数a和b，而后将参数传递给服务端（另一个过程）来进行计算，计算结果传递给客户端。

1.1 在我的项目中创立AIDL文件

命名为INumManager.aidl

interface INumManager {
    int add(int num1,int num2);
}

编译实现为后生成如下一个文件

public interface INumManager extends android.os.IInterface
{
  /** Default implementation for INumManager. */
  // 默认实现
  ...
  /** Local-side IPC implementation stub class. */
  // Stub类
  public static abstract class Stub extends android.os.Binder implements com.jathow.listviewtest.INumManager
  {
    private static final java.lang.String DESCRIPTOR = "com.jathow.listviewtest.INumManager";
    /** Construct the stub at attach it to the interface. */
    public Stub()
    {
      this.attachInterface(this, DESCRIPTOR);
    }
    /**
     * Cast an IBinder object into an com.jathow.listviewtest.INumManager interface,
     * generating a proxy if needed.
     */
    //将服务端的Binder对象转换成客户须要的AIDL对象，转换辨别过程，客户端服务端位于同一过程，返回服务端的
    //Stub对象自身；否则返回的是零碎的封装后的Stub.proxy对象。
    public static com.jathow.listviewtest.INumManager asInterface(android.os.IBinder obj)
    {
      if ((obj==null)) {
        return null;
      }
      android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
      if (((iin!=null)&&(iin instanceof com.jathow.listviewtest.INumManager))) {
        return ((com.jathow.listviewtest.INumManager)iin);
      }
      return new com.jathow.listviewtest.INumManager.Stub.Proxy(obj);
    }
    @Override public android.os.IBinder asBinder()
    {
      return this;
    }
    
    //运行在服务端的Binder线程池中
    @Override 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_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;
        }
        default:
        {
          return super.onTransact(code, data, reply, flags);
        }
      }
    }
    
    //代理类，运行在客户端
    private static class Proxy implements com.jathow.listviewtest.INumManager
    {
      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;
      }
      
      //客户端调用此办法，传递进来num1和num2两个参数
      @Override public int add(int num1, int num2) throws android.os.RemoteException
      {
        android.os.Parcel _data = android.os.Parcel.obtain();
        android.os.Parcel _reply = android.os.Parcel.obtain();
        int _result;
        try {
          //向_data中写入参数
          _data.writeInterfaceToken(DESCRIPTOR);
          _data.writeInt(num1);
          _data.writeInt(num2);
          //通过transact办法向服务端传递参数，并调用了办法，返回的后果写入_reply中
          boolean _status = mRemote.transact(Stub.TRANSACTION_add, _data, _reply, 0);
          if (!_status && getDefaultImpl() != null) {
            return getDefaultImpl().add(num1, num2);
          }
          _reply.readException();
          _result = _reply.readInt();
        }
        finally {
          _reply.recycle();
          _data.recycle();
        }
        return _result;
      }
      public static com.jathow.listviewtest.INumManager sDefaultImpl;
    }
    //标识位
    static final int TRANSACTION_add = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
    ... 获取默认实现
  }
  public int add(int num1, int num2) throws android.os.RemoteException;
}

在这个编译文件中，次要蕴含了三个货色，别离是INumManager接口，接口的动态抽象类Stub，和Stub的动态外部类。
咱们一个个来剖析：

  • INumManager接口
    该接口继承了IInterface类，所有的AIDL接口都须要继承IInterface类，其次要的性能就是标记Server过程对象能提供哪里办法（AIDL文件中定义的接口）

  • Stub类（该类继承了Binder类，实现了INumManager接口）

    • Binder类实现了IBinder接口，IBinder接口代表了一种跨过程通信的能力，实现该接口的类都能够跨过程传输。阐明Stub是一个Binder的本地对象，其能够进行跨过程通信。
    • 实现INumManager接口，即表明具备 Server 承诺给 Client 的能力
    • asInterface办法，其常见应用是在ServiceConnection中，其会调用Stub.asInterface（Binder binder）拿到跨过程通信对象。从源码中咱们能够发现，该类会先进行一步查找obj.queryLocalInterface(DESCRIPTOR)，判断Binder是不是本地对象（Client和Server在同一过程之中），如果是则间接应用会，如果不是则会调用Stub.Proxy(obj)生成一个代理对象。
    • onTransact办法，此办法运行在服务端中的Binder线程池中，当客户端发动跨过程申请时，近程申请会通过零碎底层封装后交由此办法解决。

  • Proxy类（实现了INumManager接口）

    • 在Stub类中，int add(int num1, int num2)是一个形象办法，Client端须要继承并实现它。

      • 如果Client和Server都在一个过程则间接实现即可
      • 如果是近程调用，Client调用Server的办法就须要通过Binder代理来实现，也就是下面的Proxy。
    • Proxy的办法中，先通过Parcel将数据序列化，向data中写入参数，而后通过transact办法向服务端传递参数，此时调用此办法的线程会挂起，而后服务端的onTransact办法被调用，依据相干的编号，调动相应的函数，之后将返回的后果写入_reply中，而后返回，唤醒挂起线程，取出数据。

1.2 创立一个Service来监听客户端连贯申请

public class IRemoteService extends Service {

    //客户端绑定service时会执行
    @Override
    public IBinder onBind(Intent intent) {
        return iBinder;
    }

    private IBinder iBinder = new IImoocAIDL.Stub(){

        @Override
        public int add(int num1, int num2) throws RemoteException {
            Log.e("TAG","收到了来自客户端的申请" + num1 + "+" + num2 );
            return num1 + num2;
        }
    };
}

1.3 客户端绑定服务并调用服务端办法

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private EditText num1;
    private EditText num2;
    private Button button;
    private TextView text;

    private IImoocAIDL iImoocAIDL;

    private ServiceConnection conn = new ServiceConnection() {

        //绑定服务，回调onBind()办法
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            iImoocAIDL = IImoocAIDL.Stub.asInterface(service);
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            iImoocAIDL = null;
        }
    };

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

        bindService();
        initView();

    }

    private void initView() {
        num1 = (EditText) findViewById(R.id.num1);
        num2 = (EditText) findViewById(R.id.num2);
        button = (Button) findViewById(R.id.button);
        text = (TextView) findViewById(R.id.text);

        button.setOnClickListener(this);
    }


    @Override
    public void onClick(View v) {
        int num11 = Integer.parseInt(num1.getText().toString());
        int num22 = Integer.parseInt(num2.getText().toString());

        try {
            int res = iImoocAIDL.add(num11,num22);
            text.setText(num11 +"+"+ num22 +"="+ res);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }

    private void bindService() {

        Intent intent = new Intent();
        //绑定服务端的service
        intent.setAction("com.mecury.aidltest.IRomoteService");
        //新版本（5.0后）必须显式intent启动 绑定服务
        intent.setComponent(new ComponentName("com.mecury.aidltest","com.mecury.aidltest.IRemoteService"));
        //绑定的时候服务端主动创立
        bindService(intent,conn, Context.BIND_AUTO_CREATE);
    }

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

如此，就能够进行一次AIDL的调用。

2 AIDL调用流程

咱们当初来略微梳理一下整个IPC的流程

  • 首先，咱们在服务端，建设了一个AIDL的接口，该接口外部有Stub类（Binder对象）须要咱们后续去实现。

  • 而后，咱们在客户端利用这个Stub类去获取Binderd对象

    • 如果是同一个过程，则间接操作Binder类
    • 如果不是同一个过程，则取得代理对象Proxy
  • Proxy对象调用某个办法，会将参数存入Parcel，并调用transact办法（此时阻塞线程），Binder驱动承受到这个拜访之后，就会去查问本人的表单，寻找与代理对象绝对应的Binder对象，而后调用告诉服务器端调用Ontransact对象，并把返回后果发给驱动，之后再将这个后果放回给Proxy对象（此时唤醒线程）。这样就实现了一次过程间的通信。

评论

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

这个站点使用 Akismet 来减少垃圾评论。了解你的评论数据如何被处理。

更多文章