Android AIDL实例解析

落日映苍穹つ 2022-08-11 20:58 155阅读 0赞

原文转自：[http://blog.csdn.net/bboyfeiyu/article/details/39003759][http_blog.csdn.net_bboyfeiyu_article_details_39003759]

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接口源代码分析][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类，内容大致如下：

**\[java\]**  [view plain][] [copy][view plain]

1.  **package** com.example.advanceandroid.aidl;  
2.    
3.  **public** **interface** ILogin **extends** android.os.IInterface  
4.  \{  
5.      /\*\* Local-side IPC implementation stub class. \*/  
6.      **public** **static** **abstract** **class** Stub **extends** android.os.Binder **implements**  
7.              com.example.advanceandroid.aidl.ILogin  
8.      \{  
9.          **private** **static** **final** java.lang.String DESCRIPTOR = "com.example.advanceandroid.aidl.ILogin";  
10.   
11.         /\*\* Construct the stub at attach it to the interface. \*/  
12.         **public** Stub()  
13.         \{  
14.             **this**.attachInterface(**this**, DESCRIPTOR);  
15.         \}  
16.   
17.         /\*\* 
18.          \* Cast an IBinder object into an com.example.advanceandroid.aidl.ILogin 
19.          \* interface, generating a proxy if needed. 
20.          \*/  
21.         **public** **static** com.example.advanceandroid.aidl.ILogin asInterface(android.os.IBinder obj)  
22.         \{  
23.             **if** ((obj == **null**)) \{  
24.                 **return** **null**;  
25.             \}  
26.             android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);  
27.             **if** (((iin != **null**) && (iin **instanceof** com.example.advanceandroid.aidl.ILogin))) \{  
28.                 **return** ((com.example.advanceandroid.aidl.ILogin) iin);  
29.             \}  
30.             **return** **new** com.example.advanceandroid.aidl.ILogin.Stub.Proxy(obj);  
31.         \}  
32.   
33.         @Override  
34.         **public** android.os.IBinder asBinder()  
35.         \{  
36.             **return** **this**;  
37.         \}  
38.   
39.         @Override  
40.         **public** **boolean** onTransact(**int** code, android.os.Parcel data, android.os.Parcel reply,  
41.                 **int** flags) **throws** android.os.RemoteException  
42.         \{  
43.             **switch** (code)  
44.             \{  
45.                 **case** INTERFACE\_TRANSACTION: \{  
46.                     reply.writeString(DESCRIPTOR);  
47.                     **return** **true**;  
48.                 \}  
49.                 **case** TRANSACTION\_login: \{                            // 1、登录请求，执行的是this.login();  
50.                     data.enforceInterface(DESCRIPTOR);  
51.                     java.lang.String \_result = **this**.login();  
52.                     reply.writeNoException();  
53.                     reply.writeString(\_result);  
54.                     **return** **true**;  
55.                 \}  
56.             \}  
57.             **return** **super**.onTransact(code, data, reply, flags);  
58.         \}  
59.   
60.         **private** **static** **class** Proxy **implements** com.example.advanceandroid.aidl.ILogin  
61.         \{  
62.             **private** android.os.IBinder mRemote;  
63.   
64.             Proxy(android.os.IBinder remote)  
65.             \{  
66.                 mRemote = remote;  
67.             \}  
68.   
69.             @Override  
70.             **public** android.os.IBinder asBinder()  
71.             \{  
72.                 **return** mRemote;  
73.             \}  
74.   
75.             **public** java.lang.String getInterfaceDescriptor()  
76.             \{  
77.                 **return** DESCRIPTOR;  
78.             \}  
79.   
80.             @Override  
81.             **public** java.lang.String login() **throws** android.os.RemoteException                // 2、Proxy中的login，通过Binder机制实现IPC  
82.             \{  
83.                 android.os.Parcel \_data = android.os.Parcel.obtain();  
84.                 android.os.Parcel \_reply = android.os.Parcel.obtain();  
85.                 java.lang.String \_result;  
86.                 **try** \{  
87.                     \_data.writeInterfaceToken(DESCRIPTOR);  
88.                     mRemote.transact(Stub.TRANSACTION\_login, \_data, \_reply, 0);  
89.                     \_reply.readException();  
90.                     \_result = \_reply.readString();  
91.                 \} **finally** \{  
92.                     \_reply.recycle();  
93.                     \_data.recycle();  
94.                 \}  
95.                 **return** \_result;  
96.             \}  
97.         \}  
98.   
99.         **static** **final** **int** TRANSACTION\_login = (android.os.IBinder.FIRST\_CALL\_TRANSACTION + 0);  
100.     \}  
101.   
102.     **public** java.lang.String login() **throws** android.os.RemoteException;  
103. \}

可以看到，该类中自动生成了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，内容大致如下 :

**\[java\]**  [view plain][] [copy][view plain]

1.  /\*\* 
2.  \* AIDL服务端接口，LoginStubImpl实现了ILogin接口. 
3.  \*  
4.  \* @author mrsimple 
5.  \*/  
6.  **public** **class** LoginService **extends** Service \{  
7.    
8.      /\*\* 
9.       \*  
10.      \*/  
11.     IBinder mBinder = **new** LoginStubImpl();  
12.   
13.     /\*\* 
14.      \* @author mrsimple 
15.      \*/  
16.     **class** LoginStubImpl **extends** Stub \{  
17.         @Override  
18.         **public** String login() **throws** RemoteException \{  
19.             **return** "这是从 " + **this**.getClass().getName() + " 返回的字符串";  
20.         \}  
21.     \}  
22.   
23.     /\* 
24.      \* 返回Binder实例，即实现了ILogin接口的Stub的子类，这里为LoginStubImpl 
25.      \* \[url=home.php?mod=space&uid=133757\]@see\[/url\] android.app.Service\#onBind(android.content.Intent) 
26.      \*/  
27.     @Override  
28.     **public** IBinder onBind(Intent intent) \{  
29.         **return** mBinder;  
30.     \}  
31. \}

该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，如下 :

**\[html\]**  [view plain][] [copy][view plain]

1.    
2.      **<****service** android:name="com.example.advanceandroid.aidl.LoginService" **>**  
3.          **<****intent-filter****>**  
4.              **<****action** android:name="com.example.advanceandroid.aidl.LoginService" **/>**  
5.          **</****intent-filter****>**  
6.      **</****service****>**

客户端建立连接

在Activity中加入如下代码 :

**\[java\]**  [view plain][] [copy][view plain]

1.  ServiceConnection mLoginConnection = **new** ServiceConnection() \{  
2.    
3.         @Override  
4.         **public** **void** onServiceDisconnected(ComponentName name) \{  
5.             Log.d("", "\#\#\# aidl disconnected.");  
6.         \}  
7.    
8.         @Override  
9.         **public** **void** onServiceConnected(ComponentName name, IBinder service) \{  
10.            Log.d("", "\#\#\# aidl onServiceConnected.     service : " + service.getClass().getName());  
11.   
12.            ILogin login = Stub.asInterface(service);  
13.            Log.d("", "\#\#\# after asInterface : " + login.getClass().getName());  
14.            **try** \{  
15.                Log.d("", "\#\#\# login : " + login.login());  
16.                // Toast.makeText(MainActivity.this, "onServiceConnected : " +  
17.                // login.login(),  
18.                // Toast.LENGTH\_SHORT).show();  
19.            \} **catch** (RemoteException e) \{  
20.                e.printStackTrace();  
21.            \}  
22.        \}  
23.    \};  
24.   
25.    @Override  
26.    **protected** **void** onResume() \{  
27.        **super**.onResume();  
28.   
29.        // 服务端的action  
30.        Intent aidlIntent = **new** Intent("com.example.advanceandroid.aidl.LoginService");  
31.        bindService(aidlIntent, mLoginConnection, Context.BIND\_AUTO\_CREATE);  
32.    \}  
33.   
34.    @Override  
35.    **protected** **void** onStop() \{  
36.        **super**.onStop();  
37.        // unbind  
38.        unbindService(mLoginConnection);  
39.    \}

运行

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

**\[java\]**  [view plain][] [copy][view plain]

1.  09\-02 10:40:54.662: D/(9589): \#\#\# aidl onServiceConnected.     service : android.os.BinderProxy  
2.  09\-02 10:40:54.662: D/(9589): \#\#\# after asInterface : com.example.advanceandroid.aidl.ILogin$Stub$Proxy  
3.  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。

[http_blog.csdn.net_bboyfeiyu_article_details_39003759]: http://blog.csdn.net/bboyfeiyu/article/details/39003759
[Android_Binder_Java]: http://blog.csdn.net/luoshengyang/article/details/6642463
[view plain]: http://blog.csdn.net/bboyfeiyu/article/details/39003759#