Android AIDL（安卓接口定义语言）基本使用方法

跨进程间通信，分别有 Client 端和 Service 端不同进程

1.定义AIDL文件，此文件现代当于一个协议，定义服务端要实现的方法。

如：

1. package com.example.aidl;  
2. interface IMyService {  
3.     void play();  
4.     void pause();  
5. }  

2.实现服务端Service：

如：

public   class  AIDLService  extends  Service {  

1.     private MyBinder mBinder;  
2.     @Override  
3.     public IBinder onBind(Intent intent) { 
4. mBinder = new MyBinder();
5.         return mBinder;  //返回binder对象
6.     }  
7.      /*  
8.      * 该类继承了IMyService.Stub类而不是extends Binder类。 
9.      * IMyService.Stub是Binder的子类。 
10.      * 进程内的Service定义MyBinder内部类是继承Binder类。 
11.      */  
12.     public class MyBinder extends IMyService.Stub {  
13.         @Override  
14.         public void play() throws RemoteException {  
15.            Log.i(tag, "service 自定义 play()...");   
16.         }  
17.         @Override  
18.         public void pause() throws RemoteException {  
19.             Log.i(tag, "service 自定义 pause()..."); 
20.         }  
21.     }  

3.把 AIDL文件接口复制到Client项目

4.在Client项目中调用Service项目的服务。

如：

1. public class MainActivity extends Activity implements OnClickListener {  
2.     Button btnBind, btnPlay, btnPause;  
3.     IMyService mBinder; // 接口的一个引用  
4.     boolean mIsBind = false; // 绑定值为true,未绑定制为false;  
5.     private ServiceConnection mConn = new ServiceConnection() {  
6.         @Override  
7.         public void onServiceDisconnected(ComponentName name) {  
8.         }  
9.         @Override  
10.         public void onServiceConnected(ComponentName name, IBinder service) {  
11.             /* 
12.              * 获得另一个进程中的Service传递过来的IBinder对象-service， 
13.              * 用IMyService.Stub.asInterface方法转换该对象，这点与进程内的通信不同 
14.              */  
15.             mBinder = IMyService.Stub.asInterface(service);  
16.             mIsBind = true;  
17.             Log.i("MainActivity", "onServiceConnected....");  
18.         }  
19.     };   
20.     @Override  
21.     protected void onCreate(Bundle savedInstanceState) {  
22.         super.onCreate(savedInstanceState);  
23.         setContentView(R.layout.activity_main);  
24.         btnBind = (Button) findViewById(R.id.btn_bind);  
25.         btnPlay = (Button) findViewById(R.id.btn_play);  
26.         btnPause = (Button) findViewById(R.id.btn_pause);  
27.         btnBind.setOnClickListener(this);  
28.         btnPlay.setOnClickListener(this);  
29.         btnPause.setOnClickListener(this);  
30.     }   
31.     @Override  
32.     public void onClick(View v) {  
33.         Intent intent = new Intent();  
34.         int btn = v.getId();  
35.         switch (btn) {  
36.         case R.id.btn_bind:  
37.             intent.setAction(Constant.ACTION_AIDL);  
38.             bindService(intent, mConn, BIND_AUTO_CREATE); //绑定服务
39.             break;  
40.         case R.id.btn_play:  
41.             if (mIsBind){  
42.                 try {  
43.                     mBinder.play(); //调用IMyService接口的方法，服务端的逻辑就可以使用
44.                 } catch (RemoteException e) {  
45.                     e.printStackTrace();  
46.                 }//调用service中的play()  
47.             }  
48.                 break;  
49.         case R.id.btn_pause:  
50.             if(mIsBind){  
51.                 try {  
52.                     mBinder.pause(); //调用IMyService接口的方法
53.                 } catch (Exception e) {  
54.                     e.printStackTrace();  
55.                 }  
56.             }  
57.             break;  
58.         }  
59.     }  
60. }  

以上可以看到，Stub是 IMyService 中的一个静态抽象类，继承了Binder，并且实现了 IMyService 接口。这也就解释了我们定义IMyInterface.Stub的时候为什么需要实现 IMyService 中的方法了，也说明了为什么我们可以把 IMyService .Stub向上转型成IBinder了。

总结: 

AIDL的最终效果就是让 IPC的通讯就像调用函数那样简单。自动的帮你完成了参数序列化发送以及解析返回数据的那一系列麻烦。而你所需要做的就是写上一个接口文件，然后利用aidl工具转化一下得到另一个java文件，这个文件在服务和客户端程序各放一份。服务程序继承IxxxxService.Stub 然后将函数接口里面的逻辑代码实现一下。