AIDL的作用
android提供了很多进程间通信的组件，像action、broadcast、contentprovide都可以实现进程间的通信，为什么还要用AIDL这个东西呢？
AIDL (Android Interface Definition Language) 是一种IDL 语言，用于生成可以在Android设备上两个进程之间进行进程间通信(interprocess communication, IPC)的代码。如果在一个进程中（例如Activity）要调用另一个进程中（例如Service）对象的操作，就可以使用AIDL生成可序列化的参数。
AIDL IPC机制是面向接口的，像COM或Corba一样，但是更加轻量级。它是使用代理类在客户端和实现端传递数据。
上面的听起来很迷糊？
上面的听起来很迷糊？
上面的听起来很迷糊？
看下简单版介绍：
- 多个应用程序之间建立共同的服务机制；
- 通过AIDL在不同应用程序之间达到数据的共享和数据相互操作；
- 一句话，主要是用于多应用之间的数据交互（而 在单个应用内或者说该应用如果不需要和其它第三方应用进行交互则不需要实现aidl接口）；
有没觉得有点熟悉的样子？
给你 举个
例子
用过百度的全家桶app吧？
用过某家电商公司的 某猫和某宝之类的吧？
他们实现了一些数据共享，例如你在其中一个app登录了，那么你在他家的别的系列的app下载后，可以直接打开就自动登录了，用你前面的那个账号！
你打开某个app，其余的全家桶成员也被叫醒了。
感觉到了嘛？
选择AIDL的使用场合
官方文档特别提醒我们何时使用AIDL是必要的：只有你允许客户端从不同的应用程序为了进程间的通信而去访问你的service，以及想在你的service处理多线程。如果不需要进行不同应用程序间的并发通信(IPC)，you should create your interface by implementing a Binder；或者你想进行IPC，但不需要处理多线程的，则implement your interface using a Messenger。无论如何，在使用AIDL前，必须要理解如何绑定service——bindService。如何绑定服务，请参考我的另一篇文章：http://blog.csdn.net/singwhatiwanna/article/details/9058143。这里先假设你已经了解如何使用bindService。
案例一
下面有两个案例用来帮助你理解这个一般没用到的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不断的监听这些状态的变化去控制网络，又比如电源管理，控制屏幕的亮度等等，复杂的是其中繁多的状态变化。
案例二
如何使用AIDL
- 先建立一个android工程，用作服务端
创建一个android工程，用来充当跨进程通信的服务端。 - 创建一个包名用来存放aidl文件
创建一个包名用来存放aidl文件,比如com.ryg.sayhi.aidl，在里面新建IMyService.aidl文件，如果需要访问自定义对象，还需要建立对象的aidl文件，这里我们由于使用了自定义对象Student，所以，还需要创建Student.aidl和Student.java。
注意，这三个文件，需要都放在com.ryg.sayhi.aidl包里。下面描述如何写这三个文件。
IMyService.aidl代码如
下：
package com.ryg.sayhi.aidl;
import com.ryg.sayhi.aidl.Student;
interface IMyService {
List<Student> getStudent();
void addStudent(in Student student);
}
说明：
aidl中支持的参数类型为：基本类型（int,long,char,boolean等）,String,CharSequence,List,Map，其他类型必须使用import导入，即使它们可能在同一个包里，比如上面的Student，尽管它和IMyService在同一个包中，但是还是需要显示的import进来。
另外，接口中的参数除了aidl支持的类型，其他类型必须标识其方向：到底是输入还是输出抑或两者兼之，用in，out或者inout来表示，上面的代码我们用in标记，因为它是输入型参数。
在gen下面可以看到，eclipse为我们自动生成了一个代理类
public static abstract class Stub extends android.os.Binder
implements com.ryg.sayhi.aidl.IMyService
可见这个Stub类就是一个普通的Binder，只不过它实现了我们定义的aidl接口。它还有一个静态方法
public static com.ryg.sayhi.aidl.IMyService asInterface(android.os.IBinder obj)这个方法很有用，通过它，我们就可以在客户端中得到IMyService的实例，进而通过实例来调用其方法。
Student.aidl代码如下：
package com.ryg.sayhi.aidl;
parcelable Student;
说明：这里parcelable是个类型，首字母是小写的，和Parcelable接口不是一个东西，要注意。
Student.java代码如下：
package com.ryg.sayhi.aidl;
import java.util.Locale;
import android.os.Parcel;
import android.os.Parcelable;
public final class Student implements Parcelable {
public static final int SEX_MALE = 1;
public static final int SEX_FEMALE = 2;
public int sno;
public String name;
public int sex;
public int age;
public Student() {
}
public static final Parcelable.Creator<Student> CREATOR = new
Parcelable.Creator<Student>() {
public Student createFromParcel(Parcel in) {
return new Student(in);
}
public Student[] newArray(int size) {
return new Student[size];
}
};
private Student(Parcel in) {
readFromParcel(in);
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeInt(sno);
dest.writeString(name);
dest.writeInt(sex);
dest.writeInt(age);
}
public void readFromParcel(Parcel in) {
sno = in.readInt();
name = in.readString();
sex = in.readInt();
age = in.readInt();
}
@Override
public String toString() {
return String.format(Locale.ENGLISH, "Student[ %d, %s, %d, %d ]", sno, name, sex, age);
}
}
说明：通过AIDL传输非基本类型的对象，被传输的对象需要序列化，序列化功能java有提供，但是android sdk提供了更轻量级更方便的方法，即实现Parcelable接口，关于android的序列化，我会在以后写文章介绍。这里只要简单理解一下就行，大意是要实现如下函数
readFromParcel : 从parcel中读取对象
writeToParcel ：将对象写入parcel
describeContents：返回0即可
Parcelable.Creator CREATOR：这个照着上面的代码抄就可以
需要注意的是，readFromParcel和writeToParcel操作数据成员的顺序要一致
创建服务端service
创建一个service，比如名为MyService.java，代码如下：public class MyService extends Service { private final static String TAG = "MyService"; private static final String PACKAGE_SAYHI = "com.example.test"; private NotificationManager mNotificationManager; private boolean mCanRun = true; private List<Student> mStudents = new ArrayList<Student>(); //这里实现了aidl中的抽象函数 private final IMyService.Stub mBinder = new IMyService.Stub() { @Override public List<Student> getStudent() throws RemoteException { synchronized (mStudents) { return mStudents; } } @Override public void addStudent(Student student) throws RemoteException { synchronized (mStudents) { if (!mStudents.contains(student)) { mStudents.add(student); } } } //在这里可以做权限认证，return false意味着客户端的调用就会失败，比如下面，只允许包名为com.example.test的客户端通过， //其他apk将无法完成调用过程 public boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException { String packageName = null; String[] packages = MyService.this.getPackageManager(). getPackagesForUid(getCallingUid()); if (packages != null && packages.length > 0) { packageName = packages[0]; } Log.d(TAG, "onTransact: " + packageName); if (!PACKAGE_SAYHI.equals(packageName)) { return false; } return super.onTransact(code, data, reply, flags); } }; @Override public void onCreate() { Thread thr = new Thread(null, new ServiceWorker(), "BackgroundService"); thr.start(); synchronized (mStudents) { for (int i = 1; i < 6; i++) { Student student = new Student(); student.name = "student#" + i; student.age = i * 5; mStudents.add(student); } } mNotificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE); super.onCreate(); } @Override public IBinder onBind(Intent intent) { Log.d(TAG, String.format("on bind,intent = %s", intent.toString())); displayNotificationMessage("服务已启动"); return mBinder; } @Override public int onStartCommand(Intent intent, int flags, int startId) { return super.onStartCommand(intent, flags, startId); } @Override public void onDestroy() { mCanRun = false; super.onDestroy(); } private void displayNotificationMessage(String message) { Notification notification = new Notification(R.drawable.icon, message, System.currentTimeMillis()); notification.flags = Notification.FLAG_AUTO_CANCEL; notification.defaults |= Notification.DEFAULT_ALL; PendingIntent contentIntent = PendingIntent.getActivity(this, 0, new Intent(this, MyActivity.class), 0); notification.setLatestEventInfo(this, "我的通知", message, contentIntent); mNotificationManager.notify(R.id.app_notification_id + 1, notification); } class ServiceWorker implements Runnable { long counter = 0; @Override public void run() { // do background processing here..... while (mCanRun) { Log.d("scott", "" + counter); counter++; try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } } } } }说明：为了表示service的确在活着，我通过打log的方式，每2s打印一次计数。上述代码的关键在于onBind函数，当客户端bind上来的时候，将IMyService.Stub mBinder返回给客户端，这个mBinder是aidl的存根，其实现了之前定义的aidl接口中的抽象函数。
问题：问题来了，有可能你的service只想让某个特定的apk使用，而不是所有apk都能使用，这个时候，你需要重写Stub中的onTransact方法，根据调用者的uid来获得其信息，然后做权限认证，如果返回true，则调用成功，否则调用会失败。对于其他apk，你只要在onTransact中返回false就可以让其无法调用IMyService中的方法，这样就可以解决这个问题了。在AndroidMenifest中声明service
<service android:name="com.ryg.sayhi.MyService" android:process=":remote" android:exported="true" > <intent-filter> <category android:name="android.intent.category.DEFAULT" /> <action android:name="com.ryg.sayhi.MyService" /> </intent-filter> </service>说明：上述的是为了能让其他apk隐式bindService，通过隐式调用的方式来起activity或者service，需要把category设为default，这是因为，隐式调用的时候，intent中的category默认会被设置为default。
新建一个工程，充当客户端
新建一个客户端工程，将服务端工程中的com.ryg.sayhi.aidl包整个拷贝到客户端工程的src下，这个时候，客户端com.ryg.sayhi.aidl包是和服务端工程完全一样的。如果客户端工程中不采用服务端的包名，客户端将无法正常工作，比如你把客户端中com.ryg.sayhi.aidl改一下名字，你运行程序的时候将会crash，也就是说，客户端存放aidl文件的包必须和服务端一样。
客户端bindService的代码就比较简单了，如下：import com.ryg.sayhi.aidl.IMyService; import com.ryg.sayhi.aidl.Student; public class MainActivity extends Activity implements OnClickListener { private static final String ACTION_BIND_SERVICE = "com.ryg.sayhi.MyService"; private IMyService mIMyService; private ServiceConnection mServiceConnection = new ServiceConnection() { @Override public void onServiceDisconnected(ComponentName name) { mIMyService = null; } @Override public void onServiceConnected(ComponentName name, IBinder service) { //通过服务端onBind方法返回的binder对象得到IMyService的实例，得到实例就可以调用它的方法了 mIMyService = IMyService.Stub.asInterface(service); try { Student student = mIMyService.getStudent().get(0); showDialog(student.toString()); } catch (RemoteException e) { e.printStackTrace(); } } }; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); Button button1 = (Button) findViewById(R.id.button1); button1.setOnClickListener(new OnClickListener() { @Override public void onClick(View view) { if (view.getId() == R.id.button1) { Intent intentService = new Intent(ACTION_BIND_SERVICE); intentService.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); MainActivity.this.bindService(intentService, mServiceConnection, BIND_AUTO_CREATE); } } public void showDialog(String message) { new AlertDialog.Builder(MainActivity.this) .setTitle("scott") .setMessage(message) .setPositiveButton("确定", null) .show(); } @Override protected void onDestroy() { if (mIMyService != null) { unbindService(mServiceConnection); } super.onDestroy(); } }
运行效果
可以看到，当点击按钮1的时候，客户端bindService到服务端apk，并且调用服务端的接口mIMyService.getStudent()来获取学生列表，并且把返回列表中第一个学生的信息显示出来，这就是整个ipc过程，需要注意的是：学生列表是另一个apk中的数据，通过aidl，我们才得到的。另外，如果你在onTransact中返回false，将会发现，获取的学生列表是空的，这意味着方法调用失败了，也就是实现了权限认证。
src:
http://blog.csdn.net/singwhatiwanna/article/details/17041691
android中aidl接口的作用
AIDL在android系统中的作用
1931
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
