Android AIDL——实现机制
1.android框架大量使用了进程通信机制，所以，在研究android framework前认真研究一下AIDL的实现机制十分有必要的
2.aidl是 Android Interface definition language的缩写，它是一种进程通信接口的描述，通过sdk解释器对器进行编译，会把它编译成java代码在gen目录下，类路径与aidl文件的类路径相同。
3.aidl接口
package com.cao.android.demos.binder.aidl;
import com.cao.android.demos.binder.aidl.AIDLActivity;
interface AIDLService {
void registerTestCall(AIDLActivity cb);
void invokCallBack();
}
它编译后生成的java文件如下
AIDLService.java详细描述了aidl接口的实现，看上面图示，AIDLActivity.aidl编译成了一个接口AIDLActivity，一个存根类Stub,一个代理类Proxy
public interface AIDLService extends android.os.IInterface//与AIDLActivity.aidl中定义的接口对应的java接口实现
public static abstract class Stub extends android.os.Binder implements com.cao.android.demos.binder.aidl.AIDLService
//继承android.os.Binder，在onTransact完成对通信数据的接收，通过不同通信参数code调用AIDLService接口方法，并回写调用返回结果AIDLService接口方法需要在
//服务端实现
private static class Proxy implements com.cao.android.demos.binder.aidl.AIDLService
//实现AIDLService接口方法，但是方法只是执行代理远程调用操作，具体方法操作在远端的Stub存根类中实现
总的来说，AIDLActivity.aidl编译会生成一个AIDLActivity接口，一个stub存根抽像类，一个proxy代理类，这个实现其实根axis的wsdl文件编译生成思路是一致的，
stub存根抽像类需要在服务端实现，proxy代理类被客户端使用，通过stub,proxy的封装，屏蔽了进程通信的细节，对使用者来说就只是一个AIDLActivity接口的调用
4.根据以上思路使用aidl再看一下AIDLService调用实现代码
--1.在服务端实现AIDLService.Stub抽象类，在服务端onBind方法中返回该实现类
--2.客户端绑定service时在ServiceConnection.onServiceConnected获取onBind返回的IBinder对象
private ServiceConnection mConnection = new ServiceConnection() {
public void onServiceConnected(ComponentName className, IBinder service) {
Log("connect service");
mService = AIDLService.Stub.asInterface(service);
try {
mService.registerTestCall(mCallback);
} catch (RemoteException e) {
}
}
注意mConnection在bindservice作为调用参数：bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
--3.AIDLService.Stub.asInterface(service);
public static com.cao.android.demos.binder.aidl.AIDLService asInterface(android.os.IBinder obj)
{
if ((obj==null)) {
return null;
}
android.os.IInterface iin = (android.os.IInterface)obj.queryLocalInterface(DESCRIPTOR);
//如果bindService绑定的是同一进程的service,返回的是服务端Stub对象本省，那么在客户端是直接操作Stub对象，并不进行进程通信了
if (((iin!=null)&&(iin instanceof com.cao.android.demos.binder.aidl.AIDLService))) {
return ((com.cao.android.demos.binder.aidl.AIDLService)iin);
}
//bindService绑定的不是同一进程的service，返回的是代理对象，obj==android.os.BinderProxy对象，被包装成一个AIDLService.Stub.Proxy代理对象
//不过AIDLService.Stub.Proxy进程间通信通过android.os.BinderProxy实现
return new com.cao.android.demos.binder.aidl.AIDLService.Stub.Proxy(obj);
}
--4.调用AIDLService接口方法，如果是同一进程，AIDLService就是service的Stub对象，等同直接调用Stub对象实现的AIDLService接口方法
如果是一个proxy对象，那就是在进程间调用了，我们看一个客户端调用的例子：
public void onClick(View v) {
Log("AIDLTestActivity.btnCallBack");
try {
mService.invokCallBack();
} catch (RemoteException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
--mService.invokCallBack()等同调用Proxy.invokCallBack,这个时候是进程间调用，我们看代理方法的实现
public void invokCallBack() throws android.os.RemoteException
{
//构造一个Parcel对象，该对象可在进程间传输
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
try {
//DESCRIPTOR = "com.cao.android.demos.binder.aidl.AIDLService",描述了调用哪个Stub对象
_data.writeInterfaceToken(DESCRIPTOR);
//Stub.TRANSACTION_invokCallBack标识调用Stub中哪个接口方法，mRemote在是构造Proxy对象的参数obj,也就是public void onServiceConnected(ComponentName className, IBinder service)
//中的service参数，它是一个BinderProxy对象,负责传输进程间数据。
mRemote.transact(Stub.TRANSACTION_invokCallBack, _data, _reply, 0);
_reply.readException();
}
finally {
_reply.recycle();
_data.recycle();
}
}
--5.BinderProxy.transact 该方法本地化实现
public native boolean transact(int code, Parcel data, Parcel reply,
int flags) throws RemoteException;
//对应实现的本地化代码 /frameworks/base/core/jni/android_util_Binder.cpp->static jboolean android_os_BinderProxy_transact(JNIEnv* env, jobject obj,
jint code, jobject dataObj,
jobject replyObj, jint flags)
//具体进程通信在c代码中如何实现，以后再深入研究。
--6.服务端进程数据接收
--调用堆栈
##AIDLService.Stub.onTransact
##AIDLService.Stub(Binder).execTransact
##NativeStart.run
--AIDLService.Stub.onTransact
public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException
{
switch (code)
{
case INTERFACE_TRANSACTION:
{
reply.writeString(DESCRIPTOR);
return true;
}
case TRANSACTION_registerTestCall:
{
data.enforceInterface(DESCRIPTOR);
com.cao.android.demos.binder.aidl.AIDLActivity _arg0;
_arg0 = com.cao.android.demos.binder.aidl.AIDLActivity.Stub.asInterface(data.readStrongBinder());
this.registerTestCall(_arg0);
reply.writeNoException();
return true;
}
//TRANSACTION_invokCallBack由前面客户端调用的时候transact方法参数决定，code==TRANSACTION_invokCallBack，执行
//invokCallBack方法，方法由继承Stud的服务端存根类实现。
case TRANSACTION_invokCallBack:
{
data.enforceInterface(DESCRIPTOR);
this.invokCallBack();
reply.writeNoException();
return true;
}
通过代码来实现这个数据传输过程是冗长乏味的，Android提供了AIDL工具来处理这项工作。
AIDL IPC机制是面向接口的，像COM或Corba一样，但是更加轻量级。它是使用代理类在客户端和实现端传递数据。
- Calls made from the local process are executed in the same thread that is making the call. If this is your main UI thread, that thread continues to execute in the AIDL interface. If it is another thread, that is the one that executes your code in the service. Thus, if only local threads are accessing the service, you can completely control which threads are executing in it (but if that is the case, then you shouldn't be using AIDL at all, but should instead create the interface by implementing a Binder).
- Calls from a remote process are dispatched from a thread pool the platform maintains inside of your own process. You must be prepared for incoming calls from unknown threads, with multiple calls happening at the same time. In other words, an implementation of an AIDL interface must be completely thread-safe.
- The
onewaykeyword modifies the behavior of remote calls. When used, a remote call does not block; it simply sends the transaction data and immediately returns. The implementation of the interface eventually receives this as a regular call from theBinderthread pool as a normal remote call. Ifonewayis used with a local call, there is no impact and the call is still synchronous.
AIDL使用简单的语法来声明接口，描述其方法以及方法的参数和返回值。这些参数和返回值可以是任何类型，甚至是其他AIDL生成的接口。
需要特别注意的是， 对于非基本数据类型，也不是String和CharSequence类型的，需要有方向指示，包括in、out和inout，in表示由客户端设置，out表示由服务端设置，inout是两者均可设置。
import com.demo.Person;
interface IMyService {
void savePersonInfo(in Person person);
List<Person> getAllPerson();
}
private LinkedList<Person> personList = new LinkedList<Person>();
@Override
public IBinder onBind(Intent intent) {
return mBinder;
}
private final IMyService.Stub mBinder = new IMyService.Stub(){
@Override
public void savePersonInfo(Person person) throws RemoteException {
if (person != null){
personList.add(person);
}
}
@Override
public List<Person> getAllPerson() throws RemoteException {
return personList;
}
};
}
public static abstract class Stub extends android.os.Binder implements com.demo.IMyService
1) void writeToParcel(Parcel dest, int flags) 将需要序列化存储的数据写入外部提供的Parcel对象dest。而看了网上的代码例子，个人猜测，读取Parcel数据的次序要和这里的write次序一致，否则可能会读错数据。具体情况我没试验过！
2) describeContents() 没搞懂有什么用，反正直接返回0也可以
3) static final Parcelable.Creator对象CREATOR 这个CREATOR命名是固定的，而它对应的接口有两个方法：
createFromParcel(Parcel source) 实现从source创建出JavaBean实例的功能
newArray(int size) 创建一个类型为T，长度为size的数组，仅一句话（return new T[size])即可。估计本方法是供外部类反序列化本类数组使用。
private String name;
private String telNumber;
private int age;
public Person() {}
public Person(Parcel pl){
name = pl.readString();
telNumber = pl.readString();
age = pl.readInt();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getTelNumber() {
return telNumber;
}
public void setTelNumber(String telNumber) {
this.telNumber = telNumber;
}
public int getAge() {
return age;
}
public void setAge( int age) {
this.age = age;
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeString(name);
dest.writeString(telNumber);
dest.writeInt(age);
}
public static final Parcelable.Creator<Person> CREATOR = new Parcelable.Creator<Person>() {
@Override
public Person createFromParcel(Parcel source) {
return new Person(source);
}
@Override
public Person[] newArray( int size) {
return new Person[size];
}
};
}
然后创建Person.aidl文件，注意这里的parcelable和原来实现的Parcelable 接口，开头的字母p一个小写一个大写：
parcelable Person;
3. 抛出的异常是不能返回给调用者（跨进程抛异常处理是不可取的）。
3. 客户端获取接口
private ServiceConnection mRemoteConnection = new ServiceConnection() {
public void onServiceConnected(ComponentName className, IBinder service) {
mRemoteService = IMyService.Stub.asInterface(service);
}
public void onServiceDisconnected(ComponentName className) {
mRemoteService = null;
}
};
* Cast an IBinder object into an com.demo.IMyService interface,
* generating a proxy if needed.
*/
public static com.demo.IMyService asInterface(android.os.IBinder obj) {...}
unbindService(mRemoteConnection);
} else{
bindService( new Intent( "com.demo.IMyService"),
mRemoteConnection, Context.BIND_AUTO_CREATE);
}
mIsRemoteBound = !mIsRemoteBound;
new View.OnClickListener(){
private int index = 0;
@Override
public void onClick(View view) {
Person person = new Person();
index = index + 1;
person.setName( "Person" + index);
person.setAge(20);
person.setTelNumber( "123456");
try {
mRemoteService.savePersonInfo(person);
} catch (RemoteException e) {
e.printStackTrace();
}
}
});
listPersonButton.setOnClickListener(
new View.OnClickListener(){
@Override
public void onClick(View view) {
List<Person> list = null;
try {
list = mRemoteService.getAllPerson();
} catch (RemoteException e) {
e.printStackTrace();
}
if (list != null){
StringBuilder text = new StringBuilder();
for(Person person : list){
text.append( "\nPerson name:");
text.append(person.getName());
text.append( "\n age :");
text.append(person.getAge());
text.append( "\n tel number:");
text.append(person.getTelNumber());
}
inputPersonEdit.setText(text);
} else {
Toast.makeText(ServiceActivity. this, "get data error",
Toast.LENGTH_SHORT).show();
}
}
});
Permission权限
如果Service在AndroidManifest.xml中声明了全局的强制的访问权限，其他引用必须声明权限才能来start，stop或bind这个service.
另外，service可以通过权限来保护她的IPC方法调用，通过调用checkCallingPermission(String)方法来确保可以执行这个操作。
AndroidManifest.xml的Service元素
< intent-filter >
< action android:name ="com.demo.IMyService" />
</ intent-filter >
</ service >
这里的android:process=":remote"，一开始我没有添加的，在同一个程序里使用IPC，即同一个程序作为客户端/服务器端，结果运行mRemoteService = IMyService.Stub.asInterface(service);时提示空指针异常。观察了人家的在不同程序里进行IPC的代码，也是没有这个android:process=":remote"的。后来在官方文档http://androidappdocs.appspot.com/guide/topics/manifest/service-element.html里了解到（留意第二段文字）：
The name of the process where the service is to run. Normally, all components of an application run in the default process created for the application. It has the same name as the application package. The <application> element's process attribute can set a different default for all components. But component can override the default with its own process attribute, allowing you to spread your application across multiple processes.