AIDL简介

AIDL，Android Interface definition language的缩写,它是一种android内部进程通信接口的描述语言,通过它我们可以定义进程间的通信接口。最近看了下AIDL在Android系统中的用法，在网上看到很多初学的朋友不太明白AIDL的实际作用，android提供了很多进程间通信的组件，像action、broadcast、contentprovide都可以实现进程间的通信，为什么还要用AIDL这个东西呢？我在android源码中实现了一个自己写的AIDL例子，用以简单解释下AIDL的作用。

有开发过蓝牙或者WIFI应用的朋友肯定都知道，要去操作它必须先获得一个管理类，比如WIFI的管理类是WifiManager，通过getSystemService(Context.WIFI_SERVICE)就可以得到wifi的管理权限，这个提供了很多的方法可以让用户去操作它，比如打开wifi可以调用setWifiEnabled(true)方法。那这个Manager到底做了什么工作呢？是怎样实现打开wifi的呢？其实这个Manager只是一个管理类，真正干活的另有其人，是一个叫WifiService的系统服务。在Android系统中有很多的Manager，wifi的管理类叫WifiManager，蓝牙的管理类叫BluetoothManager，但是，只要有xxxManager.java，就会有Ixxx.aidl，并且有xxxService.java。这个aidl类就是实现Manager和Service通信的桥梁。

下面看我加的一个例子：

首先在android源码中的frameworks/base/core/java/android/os/目录下加入一个IMyTestService.aidl，一般系统的AIDL文件都放在这个目录下。

package android.os;

/** {@hide} */
interface IMyTestService
{
    void open();
    void close();
}

关于AIDL的语言规范我就不多说了，其实和Java写接口差不多(它本来就是一种接口语言)。里面只定义两个简单的方法，open和close。

然后在frameworks/base/Android.mk中添加一句：core/java/android/os/IMyTestService.aidl。android系统的编译目标是通过Android.mk来指定的，在这里加上自定义的aidl文件系统才会把这个文件编译进去，最终生成一个叫IMyTestService.java的文件。这一部分用eclipse可以很直观的看到，在项目添加了aidl文件后eclipse会自动编译此aidl，生成的文件存放在gen目录下。

AIDL添加好了后，在frameworks/base/services/java/com/android/server/目录下添加一个MyTestService.java，继承IMytestService这个aidl。

package com.android.server;

import android.net.wifi.WifiManager;
import android.content.Context;
import android.os.IMyTestService;
import android.util.Log;

public class MyTestService extends IMyTestService.Stub {

    private static final String TAG = "MyTestService";
    private Context mContext;
    private WifiManager mWifiManager;

    public MyTestService(Context context/*,WindowManagerService wm*/) {
        super();
        mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
    }

    /* close wifi */
    public void close() {
        mWifiManager.setWifiEnabled(false);
    }

    /* open wifi */
    public void open() {
        mWifiManager.setWifiEnabled(true);
    }
}

实现aidl文件中定义的open和close方法，我这里很简单，open就是去打开wifi，close就去关闭wifi，当然，你也可以实现你自定义的功能，这个没有限制。

然后在frameworks/base/core/java/android/content/Context.java文件中加入一个静态字符串：public static final String MY_TEST_SERVICE ="my_test_service";

最后把这个服务添加到系统服务中去，在frameworks/base/services/java/com/android/server/SystemServer.java中Thread的run方法中添加下面代码：

try {
                 Slog.i(TAG, "My Test Service");
                 myService = new MyTestService(context);
                 ServiceManager.addService(Context.MY_TEST_SERVICE, myService);
             } catch (Throwable e) {
                 reportWtf("starting my test Service", e);
             }

myService需要在前面声明一下。

SystemService是android系统跑起来之后就会调用的，这里的意思是把MyTestService添加到系统服务中去，并取名字叫Context.MY_TEST_SERVICE，也就是my_test_service。这样看起来是不是很熟悉呢？每个开发人员在开发过程中肯定会调用系统服务的，比如电源管理服务：getSystemService(Context.POWER_SERVICE)，这个Service也是在这里添加进去的。android有很多的系统服务，这里就不一一例举了，有兴趣的朋友可以自行看看这个文件。

现在aidl添加了，service也添加了，并且添加进了系统服务，那么还少一个Manager，可以让第三方程序调用的Manager。

在frameworks/base/core/java/android/device/目录下添加MyTestManager.java文件：

package android.device;
import android.util.Log;
import android.content.Context;
import android.os.RemoteException;
import android.os.IMyTestService;
import android.os.ServiceManager;

public class MyTestManager {

private static final String TAG = "MyTestManager";

private IMyTestService mTestService;

    public MyTestManager() {
        IMyTestService mService = IMyTestService.Stub
                .asInterface(ServiceManager.getService(Context.MY_TEST_SERVICE));
        mTestService = mService;
    }
    /**
     * Return true if open succeed
     * @see #open my Function()
     */
    public boolean openScanner() {
        try {
            mTestService.open();
        } catch (android.os.RemoteException e) {
            return false;
        }
        return true;
    }
    /**
     * Return true if close succeed
     * @see #close my Function()
     */
     public boolean closeScanner() {
         try {
              mTestService.close();
         } catch (android.os.RemoteException e) {
              return false;
         }
         return true;
    }
}

这个Manager通过aidl的Stub获取了刚才添加的那个系统级别的service，然后在这里去调用这个service的方法，以操作service，这就是aidl的作用。

然后我们可以写一个第三方程序，获取一个MyTestManager，调用这个管理类的openScanner和closeScanner方法去实现自己在service中定义的功能。

AndroidManifest中必须要添加权限，否则报错，没有研究这个权限起的什么作用，有懂得的朋友分享一下吧。

import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.app.Activity;
import android.device.MyTestManager;

public class MainActivity extends Activity {
    private Button open, close;
    private MyTestManager mTestManager;

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

        mTestManager = new MyTestManager();
        open = (Button) findViewById(R.id.btn1);
        open.setText("打开Wifi");
        close = (Button) findViewById(R.id.btn2);
        close.setText("关闭Wifi");

        open.setOnClickListener(new OnClickListener() {

           @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                mTestManager.openScanner();
            }
       });

        close.setOnClickListener(new OnClickListener() {

           @Override
            public void onClick(View v) {
               // TODO Auto-generated method stub
               mTestManager.closeScanner();
            }
        });
    }
}

这也就实现了Android夸进程通信了。

这里只是一个很简单的例子，以便不理解这一块的朋友管中窥豹，其实AIDL和系统级服务的配合使用远没这么简单，但是大致原理是这样的，比如Android的网络服务，google定义了很多的状态，通过后台的Service不断的监听这些状态的变化去控制网络，又比如电源管理，控制屏幕的亮度等等，复杂的是其中繁多的状态变化。

转载----http://www.2cto.com/kf/201501/370478.html

本文提供了一个关于AIDL使用的简单易懂的例子，分为客户端和服务端两部分，分别为客户端和服务端新建一个eclipse工程，实现了从客户端向服务端发送请求，服务端打印log的功能。

===============================================================

 Android 使用AIDL例子

客户端和服务端的源码结构如下：

注意，由于客户端和服务端的aidl文件所在包名必须一样，而两个包名一样的程序在安装时会产生冲突，所以这里用了一个技巧，在客户端工程的AndroidManifest.xml里把包名指定为com.styleflying，所以大家就会看到gen目录下的R.java所在的包是com.styleflying而不是com.styleflying.AIDL

 

正文

现在客户端和服务端工程分别新建一个aidl接口，所在包和文件名必须一样。两个aidl接口是一样的，内容如下：

 

[java]  view plain copy

1. package com.styleflying.AIDL;  
2. interface mInterface{  
3.     void invokTest();  
4. }  

自动编译生成.java文件如下：

[java]  view plain copy

1. /* 
2.  * This file is auto-generated.  DO NOT MODIFY. 
3.  * Original file: G://workspace//AidlDemo_client//src//com//styleflying//AIDL//mInterface.aidl 
4.  */  
5. package com.styleflying.AIDL;  
6. public interface mInterface extends android.os.IInterface  
7. {  
8.     /** Local-side IPC implementation stub class. */  
9.     public static abstract class Stub extends android.os.Binder implements com.styleflying.AIDL.mInterface  
10.     {  
11.         private static final java.lang.String DESCRIPTOR = "com.styleflying.AIDL.mInterface";  
12.         /** Construct the stub at attach it to the interface. */  
13.         public Stub()  
14.         {  
15.             this.attachInterface(this, DESCRIPTOR);  
16.         }  
17.         /** 
18.          * Cast an IBinder object into an com.styleflying.AIDL.mInterface interface, 
19.          * generating a proxy if needed. 
20.          */  
21.         public static com.styleflying.AIDL.mInterface asInterface(android.os.IBinder obj)  
22.         {  
23.             if ((obj==null)) {  
24.             return null;  
25.             }  
26.             android.os.IInterface iin = (android.os.IInterface)obj.queryLocalInterface(DESCRIPTOR);  
27.             if (((iin!=null)&&(iin instanceof com.styleflying.AIDL.mInterface))) {  
28.                 return ((com.styleflying.AIDL.mInterface)iin);  
29.             }  
30.             return new com.styleflying.AIDL.mInterface.Stub.Proxy(obj);  
31.         }  
32.         public android.os.IBinder asBinder()  
33.         {  
34.             return this;  
35.         }  
36.         @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException  
37.         {  
38.             switch (code)  
39.             {  
40.                 case INTERFACE_TRANSACTION:  
41.                 {  
42.                     reply.writeString(DESCRIPTOR);  
43.                     return true;  
44.                 }  
45.                 case TRANSACTION_invokTest:  
46.                 {  
47.                     data.enforceInterface(DESCRIPTOR);  
48.                     this.invokTest();  
49.                     reply.writeNoException();  
50.                     return true;  
51.                 }  
52.             }  
53.             return super.onTransact(code, data, reply, flags);  
54.         }  
55.         private static class Proxy implements com.styleflying.AIDL.mInterface  
56.         {  
57.             private android.os.IBinder mRemote;  
58.             Proxy(android.os.IBinder remote)  
59.             {  
60.                 mRemote = remote;  
61.             }  
62.             public android.os.IBinder asBinder()  
63.             {  
64.                 return mRemote;  
65.             }  
66.             public java.lang.String getInterfaceDescriptor()  
67.             {  
68.                 return DESCRIPTOR;  
69.             }  
70.             public void invokTest() throws android.os.RemoteException  
71.             {  
72.                 android.os.Parcel _data = android.os.Parcel.obtain();  
73.                 android.os.Parcel _reply = android.os.Parcel.obtain();  
74.                 try {  
75.                     _data.writeInterfaceToken(DESCRIPTOR);  
76.                     mRemote.transact(Stub.TRANSACTION_invokTest, _data, _reply, 0);  
77.                     _reply.readException();  
78.                 }  
79.                 finally {  
80.                     _reply.recycle();  
81.                     _data.recycle();  
82.                 }  
83.             }  
84.         }  
85.         static final int TRANSACTION_invokTest = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);  
86.     }  
87.     public void invokTest() throws android.os.RemoteException;  
88. }  

 

客户端的mAIDLActivity.java如下：

[java]  view plain copy

1. package com.styleflying.AIDL;  
2. import android.app.Activity;  
3. import android.content.ComponentName;  
4. import android.content.Context;  
5. import android.content.Intent;  
6. import android.content.ServiceConnection;  
7. import android.os.Bundle;  
8. import android.os.IBinder;  
9. import android.os.RemoteException;  
10. import android.util.Log;  
11. import android.view.View;  
12. import android.view.View.OnClickListener;  
13. import android.widget.Button;  
14. import android.widget.Toast;  
15. import com.styleflying.R;  
16. public class mAIDLActivity extends Activity {  
17.       
18.     private static final String TAG = "AIDLActivity";  
19.     private Button btnOk;  
20.     private Button btnCancel;  
21.     private Button btnCallBack;  
22.       
23.     private void Log(String str){  
24.         Log.d(TAG,"----------" + str + "----------");  
25.     }  
26.       
27.           
28.     mInterface mService;  
29.     private ServiceConnection mConnection = new ServiceConnection(){  
30.         public void onServiceConnected(ComponentName className,  
31.                 IBinder service){  
32.             Log("connect service");  
33.             mService = mInterface.Stub.asInterface(service);  
34.         }  
35.           
36.         public void onServiceDisconnected(ComponentName className){  
37.             Log("disconnect service");  
38.             mService = null;  
39.         }  
40.     };  
41.       
42.       
43.       
44.     /** Called when the activity is first created. */  
45.     @Override  
46.     public void onCreate(Bundle savedInstanceState) {  
47.             super.onCreate(savedInstanceState);  
48.             setContentView(R.layout.main);  
49.           
50.         btnOk = (Button)findViewById(R.id.btn_ok);  
51.         btnCancel = (Button)findViewById(R.id.btn_cancel);  
52.         btnCallBack = (Button)findViewById(R.id.btn_callback);  
53.           
54.         btnOk.setOnClickListener(new OnClickListener(){  
55.             public void onClick(View v){  
56.                 Bundle args = new Bundle();  
57.                 Intent intent = new Intent("com.styleflying.AIDL.service");  
58.                 intent.putExtras(args);  
59.                 bindService(intent,mConnection,Context.BIND_AUTO_CREATE);  
60.             }  
61.         });  
62.           
63.         btnCancel.setOnClickListener(new OnClickListener(){  
64.             public void onClick(View v){  
65.                 unbindService(mConnection);  
66.             }  
67.         });       
68.         btnCallBack.setOnClickListener(new OnClickListener(){  
69.             public void onClick(View v){  
70.                 try{  
71.                     Log.i(TAG,"current Thread id = " + Thread.currentThread().getId());  
72.                     mService.invokTest();  
73.                 }  
74.                 catch(RemoteException e){  
75.                       
76.                 }  
77.             }  
78.         });  
79.           
80.           
81.     }  
82. }  

 

客户端在执行bindService的时候，成功绑定服务之后，会回调mConnection的onServiceConnected(),并且传回了服务端的通信接口IBinder，此IBinder即服务onBind()时返回的IBinder，详见mAIDLService.java。

在onServiceConnected(),客户端成功获取了服务端通信接口，实际上是本地代理对象，该对象存在于客户端进程空间，客户端只和代理对象交互，真正的IPC通信是本地代理对象和服务端的通信。

 

mAIDLService.java如下：

[c-sharp]  view plain copy

1. package com.styleflying.AIDL;  
2. import android.app.Service;  
3. import android.content.Intent;  
4. import android.os.IBinder;  
5. import android.os.Looper;  
6. import android.os.RemoteException;  
7. import android.util.Log;  
8. import android.widget.Toast;  
9. public class mAIDLService extends Service{  
10.     private static final String TAG = "AIDLService";  
11.       
12.     private void Log(String str){  
13.         Log.i(TAG,"----------" + str + "----------");  
14.     }  
15.       
16.     public void onCreate(){  
17.         Log("service created");  
18.     }  
19.       
20.     public void onStart(Intent intent, int startId){  
21.         Log("service started id = " + startId);  
22.     }  
23.       
24.     public IBinder onBind(Intent t){  
25.         Log("service on bind");  
26.         return mBinder;  
27.     }  
28.       
29.     public void onDestroy(){  
30.         Log("service on destroy");  
31.         super.onDestroy();  
32.     }  
33.       
34.     public boolean onUnbind(Intent intent){  
35.         Log("service on unbind");  
36.         return super.onUnbind(intent);  
37.     }  
38.       
39.     public void onRebind(Intent intent){  
40.         Log("service on rebind");  
41.         super.onRebind(intent);  
42.     }  
43.       
44.       
45.     private final mInterface.Stub mBinder = new mInterface.Stub() {       
46.         public void invokTest() throws RemoteException {  
47.             // TODO Auto-generated method stub  
48.             Log.e(TAG, "remote call from client! current thread id = " + Thread.currentThread().getId());  
49.         }  
50.     };  
51. }  

注意onBind()函数，返回了mBinder，而mBinder实现了mInterface.Stub，实现了mInterface接口，执行了打印log的操作。

 

整个交互流程如下：

1.客户端通过绑定服务，获取了服务的句柄(本地代理对象)；

2.客户端执行onClick()，调用本地代理对象的invokTest()函数，本地代理对象调用mRemote.transact()发出远程调用请求（见   mInterface.java）；

3.服务端响应onTransact()执行this.invokTest()，并将执行结果返回；

 

由于客户端只和本地代理对象即服务句柄通信，由代理对象进行真正的IPC操作，所以对客户端来说，IPC过程是透明的，调用远程操作如同调用本地操作一样。在客户端调用transact()时，会将服务描述DSCRIPTION写入到data里，在客户端onTransact时会验证，如果两个不一样，则不能通信。而DSCRIPTION是根据mInterface包名和接口名自动生成的，这就是为什么两个工程里的mInterface.aidl要在同一个包的原因。

 

在这个过程中，mInterface.aidl起到了桥梁的作用，规定统一了客户端和服务端的通信接口，使得客户端和服务端得以成功的通信。

具体的通信transact和onTransact的过程也就是利用Binder驱动通信的过程，在这里就不多叙述。

最后补上两个工程的AndroidManifest.xml

[xhtml]  view plain copy

1. <?xml version="1.0" encoding="utf-8"?>  
2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"  
3.       package="com.styleflying"  
4.       android:versionCode="1"  
5.       android:versionName="1.0">  
6.     <application android:icon="@drawable/icon" android:label="@string/app_name">  
7.         <activity android:name=".AIDL.mAIDLActivity"  
8.                   android:label="@string/app_name">  
9.             <intent-filter>  
10.                 <action android:name="android.intent.action.MAIN" />  
11.                 <category android:name="android.intent.category.LAUNCHER" />  
12.             </intent-filter>  
13.         </activity>  
14.     </application>  
15.     <uses-sdk android:minSdkVersion="8" />  
16. </manifest>   

[xhtml]  view plain copy

1. <?xml version="1.0" encoding="utf-8"?>  
2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"  
3.       package="com.styleflying.AIDL"  
4.       android:versionCode="1"  
5.       android:versionName="1.0">  
6.     <application android:icon="@drawable/icon" android:label="@string/app_name">  
7.         <service android:name=".mAIDLService">  
8.                 <intent-filter>  
9.                 <action android:name="com.styleflying.AIDL.service" />  
10.                 <category android:name="android.intent.category.DEFAULT" />  
11.             </intent-filter>  
12.         </service>  
13.     </application>  
14.     <uses-sdk android:minSdkVersion="8" />  
15. </manifest>   

--------http://blog.csdn.net/huanxido/article/details/6373181