Android AIDL——實現機制淺析

1.基於前面寫的aidl使用，這段時間準備研究ActivityManager框架，對aidl進行了更深刻的研究，由於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;
}

5.裏面設置本地C代碼的調用，我沒有深刻研究，隨着後面我對android框架的深刻，我會發blog進一步說民底層C代碼是如何實現進程通訊 的，關於AIDL進程通訊，暫時研究到這裏。