Android程序设计之AIDL实例详解

通常来说，aidl这项技术在我们的应用开发过程中并不是很常用，虽然新浪微博提供了sso登录，但是其原理就是使用aidl。本文就以完整的实例形式讲述了aidl的原理及实现方法。

aidl(android接口描述语言)是一种借口描述语言; 编译器可以通过aidl文件生成一段代码，通过预先定义的接口达到两个进程内部通信进程的目的. 如果需要在一个activity中, 访问另一个service中的某个对象, 需要先将对象转化成 aidl可识别的参数(可能是多个参数), 然后使用aidl来传递这些参数, 在消息的接收端, 使用这些参数组装成自己需要的对象.

说白了，aidl就是定义一个接口，客户端(调用端)通过bindservice来与远程服务端简历一个连接,在该连接建立时会将返回一个ibinder对象，该对象是服务端binder的binderproxy，在建立连接时，客户端通过asinterface函数将该binderproxy对象包装成本地的proxy，并将远程服务端的binderproxy对象赋值给proxy类的mremote字段，就是通过mremote执行远程方法调用。需要对binder机制有更深的理解，请参考老罗的android系统进程间通信binder机制在应用程序框架层的java接口源代码分析。下面我们看一个aidl实例。

aidl接口声明

在src目录下创建一个com.example.advanceandroid.aidl包，然后在该包下创建一个ilogin.aidl文件，注意是创建文件而不是类或者接口类型。在ilogin.aidl中声明接口，实例如下 :

package com.example.advanceandroid.aidl;
interface ilogin {
    string login();
}

注意看，接口和方法声明都不用public，方法加入public会提示错误。编写完后如果eclipse开启了自动编译则会在gen/com.example.advanceandroid.aidl下生成一个ilogin.java类，内容大致如下：

package com.example.advanceandroid.aidl; 
public interface ilogin extends android.os.iinterface 
{ 
  /** local-side ipc implementation stub class. */ 
  public static abstract class stub extends android.os.binder implements 
      com.example.advanceandroid.aidl.ilogin 
  { 
    private static final java.lang.string descriptor = "com.example.advanceandroid.aidl.ilogin"; 
 
    /** construct the stub at attach it to the interface. */ 
    public stub() 
    { 
      this.attachinterface(this, descriptor); 
    } 
 
    /** 
     * cast an ibinder object into an com.example.advanceandroid.aidl.ilogin 
     * interface, generating a proxy if needed. 
     */ 
    public static com.example.advanceandroid.aidl.ilogin asinterface(android.os.ibinder obj) 
    { 
      if ((obj == null)) { 
        return null; 
      } 
      android.os.iinterface iin = obj.querylocalinterface(descriptor); 
      if (((iin != null) && (iin instanceof com.example.advanceandroid.aidl.ilogin))) { 
        return ((com.example.advanceandroid.aidl.ilogin) iin); 
      } 
      return new com.example.advanceandroid.aidl.ilogin.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_login: {              // 1、登录请求，执行的是this.login(); 
          data.enforceinterface(descriptor); 
          java.lang.string _result = this.login(); 
          reply.writenoexception(); 
          reply.writestring(_result); 
          return true; 
        } 
      } 
      return super.ontransact(code, data, reply, flags); 
    } 
 
    private static class proxy implements com.example.advanceandroid.aidl.ilogin 
    { 
      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; 
      } 
 
      @override 
      public java.lang.string login() throws android.os.remoteexception        // 2、proxy中的login，通过binder机制实现ipc 
      { 
        android.os.parcel _data = android.os.parcel.obtain(); 
        android.os.parcel _reply = android.os.parcel.obtain(); 
        java.lang.string _result; 
        try { 
          _data.writeinterfacetoken(descriptor); 
          mremote.transact(stub.transaction_login, _data, _reply, 0); 
          _reply.readexception(); 
          _result = _reply.readstring(); 
        } finally { 
          _reply.recycle(); 
          _data.recycle(); 
        } 
        return _result; 
      } 
    } 
 
    static final int transaction_login = (android.os.ibinder.first_call_transaction + 0); 
  } 
  public java.lang.string login() throws android.os.remoteexception; 
} 

可以看到，该类中自动生成了ilogin接口，该接口中又一个login()函数。但最重要的是里面生成了一个stub类，该类集成子binder类，并且实现了ilogin接口。stub里面最重要的就是asinterface()这个函数，在这个函数中会判断obj参数的类型，如果是该obj是本地的接口类似，则认为不是ipc，会将该obj转换成ilogin类型；否则会通过自动生成的另一个内部类proxy来包装obj，将其赋值给proxy中的mremote属性。proxy类也实现了ilogin接口，在login()函数中，proxy将通过binder机制向服务端传递请求和数据，如上面代码中的注释2。这是客户端的工作算是完成了。

服务端aidl接口

服务端也需要在相同的包下创建同名的aidl文件，我们直接将客户端的com.example.advanceandroid.aidl包下的ilogin.aidl拷贝到服务端即可，如果用到了自定义的类型，那么该自定义类型也需要在客户端、服务端都有。拷贝完aidl后，在服务端程序中也会在gen中生成对应的ilogin.java文件，内容同客户端一样。这里的重点我们要看ontransact函数，即上述代码中的注释1处，可以看到，在case transaction_login处执行了this.login()函数，意思是当接收到客户端的transaction_login请求时，执行this.login()函数，通过客户端的分析我们知道，当我们调用login()时实际上就是通过mremote向服务端提交了一个transaction_login请求，因此就两端通过binder机制就对接上了，我们可以简单的理解为c/s模式。

服务端还没有完，最重要的一步时建立一个service，内容大致如下 :

/** 
* aidl服务端接口，loginstubimpl实现了ilogin接口. 
* 
* @author mrsimple 
*/ 
public class loginservice extends service { 
 
  /** 
   * 
   */ 
  ibinder mbinder = new loginstubimpl(); 
 
  /** 
   * @author mrsimple 
   */ 
  class loginstubimpl extends stub { 
    @override 
    public string login() throws remoteexception { 
      return "这是从 " + this.getclass().getname() + " 返回的字符串"; 
    } 
  } 
 
  /* 
   * 返回binder实例，即实现了ilogin接口的stub的子类，这里为loginstubimpl 
   * [url=home.php?mod=space&uid=133757]@see[/url] android.app.service#onbind(android.content.intent) 
   */ 
  @override 
  public ibinder onbind(intent intent) { 
    return mbinder; 
  } 
} 

该service我们这里命名为loginservice，继承自service，然后建一个名为loginserviceimpl的内部类，该类继承自自动生成的stub，然后实现login()方法。在loginservice中声明一个ibinder字段mbinder :

ibinder mbinder = new loginstubimpl();

并且在loginservice的onbind函数中将mbinder对象返回。即在客户端建立与服务端的连接时，会调用onbind方法将mbinder对象返回，在客户端的serviceconnection类的onserviceconnected函数中得到的对象ibinder就是经过binderproxy包装的loginservice中的mbinder对象。因此在服务端中的ontransact中调用的this.login()函数实际上就是调用的loginstubimpl中的login()函数。

在服务端程序的androidmanifest.xml中注册loginservice，如下 :

<!-- aidl server service --> 
<service android:name="com.example.advanceandroid.aidl.loginservice" > 
    <intent-filter> 
      <action android:name="com.example.advanceandroid.aidl.loginservice" /> 
    </intent-filter> 
</service> 

客户端建立连接

在activity中加入如下代码 :

serviceconnection mloginconnection = new serviceconnection() { 
 
    @override 
    public void onservicedisconnected(componentname name) { 
      log.d("", "### aidl disconnected."); 
    } 
 
    @override 
    public void onserviceconnected(componentname name, ibinder service) { 
      log.d("", "### aidl onserviceconnected.   service : " + service.getclass().getname()); 
 
      ilogin login = stub.asinterface(service); 
      log.d("", "### after asinterface : " + login.getclass().getname()); 
      try { 
        log.d("", "### login : " + login.login()); 
        // toast.maketext(mainactivity.this, "onserviceconnected : " + 
        // login.login(), 
        // toast.length_short).show(); 
      } catch (remoteexception e) { 
        e.printstacktrace(); 
      } 
    } 
  }; 
 
  @override 
  protected void onresume() { 
    super.onresume(); 
 
    // 服务端的action 
    intent aidlintent = new intent("com.example.advanceandroid.aidl.loginservice"); 
    bindservice(aidlintent, mloginconnection, context.bind_auto_create); 
  } 
 
  @override 
  protected void onstop() { 
    super.onstop(); 
    // unbind 
    unbindservice(mloginconnection); 
  } 

运行

先运行服务端程序，然后在启动客户端程序，可以看到客户端输出如下log:

09-02 10:40:54.662: d/(9589): ### aidl onserviceconnected.   service : android.os.binderproxy 
09-02 10:40:54.662: d/(9589): ### after asinterface : com.example.advanceandroid.aidl.ilogin$stub$proxy 
09-02 10:40:54.662: d/(9589): ### login : 这是从 com.example.advanceandroid.aidl.loginservice$loginstubimpl 返回的字符串 

可以看淡onserviceconnected(componentname name, ibinder service)中的service对象是binderproxy类型，经过asinterface转换后被包装成了proxy类型，但是调用的时候，执行的是服务端loginstubimpl中的login()函数。因此,loginstubimpl实例mbinder被服务端包装成binderproxy类型，再经过客户端的proxy进行包装，通过binder机制进行数据传输，实现ipc。

希望本文所述对大家进一步深入掌握android程序设计有所帮助。