一 AIDL作用
AIDL (Android Interface Definition Language) 是一种IDL 语言，用于生成可以在Android设备上两个进程之间进行进程间通信(interprocess communication, IPC)的代码。如果在一个进程中（例如Activity）要调用另一个进程中（例如Service）对象的操作，就可以使用AIDL生成可序列化的参数,AIDL IPC机制是面向接口的，像COM或Corba一样，但是更加轻量级。它是使用代理类在客户端和实现端传递数据。
二 AIDL的使用场景的选择
只有你允许客户端从不同的应用程序为了进程间的通信而去访问你的service，以及想在你的service处理多线程。如果不需要进行不同应用程序间的并发通信(IPC)，you should create your interface by implementing a Binder；或者你想进行IPC，但不需要处理多线程的，则implement your interface using a Messenger。无论如何，在使用AIDL前，必须要理解如何绑定service——bindService，如何绑定服务。
三 如何使用AIDL工程，下面我们进行列子来详细的说明
1 首先创建一个Android工程来当aidl进程间通信的服务端，创建一个包名来com.android.aidl.keran，在这个包名下存放aidl文件，如果需要访问自定义对象还需要创建自定义对象，在这个我们就来创建一个自定义对象，用来说明问题。
IMyService.aidl代码如下：
package
import
interface
List<Student> getStudent();
void
}
这样服务器端的aidl文件就定义好了，说明：
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.android.aidl.keran.IMyService
可见这个Stub类就是一个普通的Binder，只不过它实现了我们定义的aidl接口。它还有一个静态方法
public static com.android.aidl.keran.IMyService asInterface(android.os.IBinder obj)
这个方法很有用，通过它，我们就可以在客户端中得到IMyService的实例，进而通过实例来调用其方法。
Student.aidl代码如下：
package
parcelable Student;
Student.java代码如下：
1. package
2.
3. import
4.
5. import
6. import
7.
8. public final class Student implements
9.
10. public static final int SEX_MALE = 1;
11. public static final int SEX_FEMALE = 2;
12.
13. public int
14. public
15. public int
16. public int
17.
18. public
19. }
20.
21. public static final Parcelable.Creator<Student> CREATOR = new
22. Parcelable.Creator<Student>() {
23.
24. public
25. return new
26. }
27.
28. public Student[] newArray(int
29. return new
30. }
31.
32. };
33.
34. private
35. readFromParcel(in);
36. }
37.
38. @Override
39. public int
40. return 0;
41. }
42.
43. @Override
44. public void writeToParcel(Parcel dest, int
45. dest.writeInt(sno);
46. dest.writeString(name);
47. dest.writeInt(sex);
48. dest.writeInt(age);
49. }
50.
51. public void
52. sno = in.readInt();
53. name = in.readString();
54. sex = in.readInt();
55. age = in.readInt();
56. }
57.
58. @Override
59. public
60. return String.format(Locale.ENGLISH, "Student[ %d, %s, %d, %d ]", sno, name, sex, age);
61. }
62.
63. }
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<Student> CREATOR：这个照着上面的代码抄就可以
需要注意的是，readFromParcel和writeToParcel操作数据成员的顺序要一致
3.创建服务端service
创建一个service，比如名为MyService.java，代码如下：
1. /**
2. * @author scott
3. */
4. public class MyService extends
5. {
6. private final static String TAG = "MyService";
7. private static final String PACKAGE_SAYHI = "com.example.test";
8.
9. private
10. private boolean mCanRun = true;
11. private List<Student> mStudents = new
12.
13. //这里实现了aidl中的抽象函数
14. private final IMyService.Stub mBinder = new
15.
16. @Override
17. public List<Student> getStudent() throws
18. synchronized
19. return
20. }
21. }
22.
23. @Override
24. public void addStudent(Student student) throws
25. synchronized
26. if
27. mStudents.add(student);
28. }
29. }
30. }
31.
32. //在这里可以做权限认证，return false意味着客户端的调用就会失败，比如下面，只允许包名为com.example.test的客户端通过，
33. //其他apk将无法完成调用过程
34. public boolean onTransact(int code, Parcel data, Parcel reply, int
35. throws
36. null;
37. this.getPackageManager().
38. getPackagesForUid(getCallingUid());
39. if (packages != null && packages.length > 0) {
40. 0];
41. }
42. "onTransact: "
43. if
44. return false;
45. }
46.
47. return super.onTransact(code, data, reply, flags);
48. }
49.
50. };
51.
52. @Override
53. public void
54. {
55. new Thread(null, new ServiceWorker(), "BackgroundService");
56. thr.start();
57.
58. synchronized
59. for (int i = 1; i < 6; i++) {
60. new
61. "student#"
62. 5;
63. mStudents.add(student);
64. }
65. }
66.
67. mNotificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
68. super.onCreate();
69. }
70.
71. @Override
72. public
73. {
74. "on bind,intent = %s", intent.toString()));
75. "服务已启动");
76. return
77. }
78.
79. @Override
80. public int onStartCommand(Intent intent, int flags, int
81. {
82. return super.onStartCommand(intent, flags, startId);
83. }
84.
85. @Override
86. public void
87. {
88. false;
89. super.onDestroy();
90. }
91.
92. private void
93. {
94. new
95. System.currentTimeMillis());
96. notification.flags = Notification.FLAG_AUTO_CANCEL;
97. notification.defaults |= Notification.DEFAULT_ALL;
98. this, 0,
99. new Intent(this, MyActivity.class), 0);
100. this, "我的通知", message,
101. contentIntent);
102. 1, notification);
103. }
104.
105. class ServiceWorker implements
106. {
107. long counter = 0;
108.
109. @Override
110. public void
111. {
112. // do background processing here.....
113. while
114. {
115. "scott", ""
116. counter++;
117. try
118. {
119. 2000);
120. catch
121. {
122. e.printStackTrace();
123. }
124. }
125. }
126. }
127.
128. }
/**
* @author scott
*/
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中的方法，这样就可以解决这个问题了。
4. 在AndroidMenifest中声明service
1. <service
2. android:name="com.ryg.sayhi.MyService"
3. android:process=":remote"
4. android:exported="true" >
5. <intent-filter>
6. <category android:name="android.intent.category.DEFAULT" />
7. <action android:name="com.ryg.sayhi.MyService" />
8. </intent-filter>
9. </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>说明：上述的 <action android:name="com.ryg.sayhi.MyService" />是为了能让其他apk隐式bindService，通过隐式调用的方式来起activity或者service，需要把category设为default，这是因为，隐式调用的时候，intent中的category默认会被设置为default。
5. 新建一个工程，充当客户端
新建一个客户端工程，将服务端工程中的com.ryg.sayhi.aidl包整个拷贝到客户端工程的src下，这个时候，客户端com.ryg.sayhi.aidl包是和服务端工程完全一样的。如果客户端工程中不采用服务端的包名，客户端将无法正常工作，比如你把客户端中com.ryg.sayhi.aidl改一下名字，你运行程序的时候将会crash，也就是说，客户端存放aidl文件的包必须和服务端一样。客户端bindService的代码就比较简单了，如下：
1. import
2. import
3.
4. public class MainActivity extends Activity implements
5.
6. private static final String ACTION_BIND_SERVICE = "com.ryg.sayhi.MyService";
7. private
8.
9. private ServiceConnection mServiceConnection = new
10. {
11. @Override
12. public void
13. {
14. null;
15. }
16.
17. @Override
18. public void
19. {
20. //通过服务端onBind方法返回的binder对象得到IMyService的实例，得到实例就可以调用它的方法了
21. mIMyService = IMyService.Stub.asInterface(service);
22. try
23. 0);
24. showDialog(student.toString());
25. catch
26. e.printStackTrace();
27. }
28.
29. }
30. };
31.
32. @Override
33. protected void
34. super.onCreate(savedInstanceState);
35. setContentView(R.layout.activity_main);
36. Button button1 = (Button) findViewById(R.id.button1);
37. new
38.
39. @Override
40. public void
41. if
42. new
43. intentService.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
44. this.bindService(intentService, mServiceConnection, BIND_AUTO_CREATE);
45. }
46.
47. }
48.
49. public void
50. {
51. new AlertDialog.Builder(MainActivity.this)
52. "scott")
53. .setMessage(message)
54. "确定", null)
55. .show();
56. }
57.
58. @Override
59. protected void
60. if (mIMyService != null) {
61. unbindService(mServiceConnection);
62. }
63. super.onDestroy();
64. }
65. }
