AIDL過程分析

現(xiàn)在我們通過一個AIDL的使用，分析一下整個通信過程中，各個角色到底做了什么，AIDL到底是如何完成通信的。（如果你連AIDL都不熟悉，請先查閱官方文檔）

首先定一個一個簡單的aidl接口：

// ICompute.aidl
package com.example.test.app;
interface ICompute {
     int add(int a, int b);
}

然后用編譯工具編譯之后，可以得到對應的ICompute.java類，看看系統(tǒng)給我們生成的代碼：

package com.example.test.app;

public interface ICompute extends android.os.IInterface {
    /**
     * Local-side IPC implementation stub class.
     */
    public static abstract class Stub extends android.os.Binder implements com.example.test.app.ICompute {
        private static final java.lang.String DESCRIPTOR = "com.example.test.app.ICompute";

        /**
         * Construct the stub at attach it to the interface.
         */
        public Stub() {
            this.attachInterface(this, DESCRIPTOR);
        }

        /**
         * Cast an IBinder object into an com.example.test.app.ICompute interface,
         * generating a proxy if needed.
         */
        public static com.example.test.app.ICompute asInterface(android.os.IBinder obj) {
            if ((obj == null)) {
                return null;
            }
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (((iin != null) && (iin instanceof com.example.test.app.ICompute))) {
                return ((com.example.test.app.ICompute) iin);
            }
            return new com.example.test.app.ICompute.Stub.Proxy(obj);
        }

        @Override
        public android.os.IBinder asBinder() {
            return this;
        }

        @Override
        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_add: {
                    data.enforceInterface(DESCRIPTOR);
                    int _arg0;
                    _arg0 = data.readInt();
                    int _arg1;
                    _arg1 = data.readInt();
                    int _result = this.add(_arg0, _arg1);
                    reply.writeNoException();
                    reply.writeInt(_result);
                    return true;
                }
            }
            return super.onTransact(code, data, reply, flags);
        }

        private static class Proxy implements com.example.test.app.ICompute {
            private android.os.IBinder mRemote;

            Proxy(android.os.IBinder remote) {
                mRemote = remote;
            }

            @Override
            public android.os.IBinder asBinder() {
                return mRemote;
            }

            public java.lang.String getInterfaceDescriptor() {
                return DESCRIPTOR;
            }

            /**
             * Demonstrates some basic types that you can use as parameters
             * and return values in AIDL.
             */
            @Override
            public int add(int a, int b) throws android.os.RemoteException {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                int _result;
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    _data.writeInt(a);
                    _data.writeInt(b);
                    mRemote.transact(Stub.TRANSACTION_add, _data, _reply, 0);
                    _reply.readException();
                    _result = _reply.readInt();
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
                return _result;
            }
        }

        static final int TRANSACTION_add = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
    }

    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    public int add(int a, int b) throws android.os.RemoteException;
}

系統(tǒng)幫我們生成了這個文件之后，我們只需要繼承ICompute.Stub這個抽象類，實現(xiàn)它的方法，然后在Service 的onBind方法里面返回就實現(xiàn)了AIDL。這個Stub類非常重要，具體看看它做了什么。

Stub類繼承自Binder，意味著這個Stub其實自己是一個Binder本地對象，然后實現(xiàn)了ICompute接口，ICompute本身是一個IInterface，因此他攜帶某種客戶端需要的能力（這里是方法add)。此類有一個內(nèi)部類Proxy，也就是Binder代理對象；

然后看看asInterface方法，我們在bind一個Service之后，在onServiceConnecttion的回調(diào)里面，就是通過這個方法拿到一個遠程的service的，這個方法做了什么呢？

/**
         * Cast an IBinder object into an com.example.test.app.ICompute interface,
         * generating a proxy if needed.
         */
        public static com.example.test.app.ICompute asInterface(android.os.IBinder obj) {
            if ((obj == null)) {
                return null;
            }
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (((iin != null) && (iin instanceof com.example.test.app.ICompute))) {
                return ((com.example.test.app.ICompute) iin);
            }
            return new com.example.test.app.ICompute.Stub.Proxy(obj);
        }

首先看函數(shù)的參數(shù)IBinder類型的obj，這個對象是驅(qū)動給我們的，如果是Binder本地對象，那么它就是Binder類型，如果是Binder代理對象，那就是BinderProxy類型；然后，正如上面自動生成的文檔所說，它會試著查找Binder本地對象，如果找到，說明Client和Server都在同一個進程，這個參數(shù)直接就是本地對象，直接強制類型轉(zhuǎn)換然后返回，如果找不到，說明是遠程對象（處于另外一個進程）那么就需要創(chuàng)建一個Binde代理對象，讓這個Binder代理實現(xiàn)對于遠程對象的訪問。一般來說，如果是與一個遠程Service對象進行通信，那么這里返回的一定是一個Binder代理對象，這個IBinder參數(shù)的實際上是BinderProxy;

再看看我們對于aidl的add 方法的實現(xiàn)；在Stub類里面，add是一個抽象方法，我們需要繼承這個類并實現(xiàn)它；如果Client和Server在同一個進程，那么直接就是調(diào)用這個方法；那么，如果是遠程調(diào)用，這中間發(fā)生了什么呢？Client是如何調(diào)用到Server的方法的？

我們知道，對于遠程方法的調(diào)用，是通過Binder代理完成的，在這個例子里面就是Proxy類；Proxy對于add方法的實現(xiàn)如下：

Override
            public int add(int a, int b) throws android.os.RemoteException {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                int _result;
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    _data.writeInt(a);
                    _data.writeInt(b);
                    mRemote.transact(Stub.TRANSACTION_add, _data, _reply, 0);
                    _reply.readException();
                    _result = _reply.readInt();
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
                return _result;
            }

它首先用Parcel把數(shù)據(jù)序列化了，然后調(diào)用了transact方法；這個transact到底做了什么呢？這個Proxy類在asInterface方法里面被創(chuàng)建，前面提到過，如果是Binder代理那么說明驅(qū)動返回的IBinder實際是BinderProxy, 因此我們的Proxy類里面的mRemote實際類型應該是BinderProxy；我們看看BinderProxy的transact方法：(Binder.java的內(nèi)部類)

public native boolean transact(int code, Parcel data, Parcel reply,
            int flags) throws RemoteException;

這是一個本地方法；它的實現(xiàn)在native層，具體來說在frameworks/base/core/jni/android_util_Binder.cpp文件，里面進行了一系列的函數(shù)調(diào)用，調(diào)用鏈實在太長這里就不給出了；要知道的是它最終調(diào)用到了talkWithDriver函數(shù)；看這個函數(shù)的名字就知道，通信過程要交給驅(qū)動完成了；這個函數(shù)最后通過ioctl系統(tǒng)調(diào)用，Client進程陷入內(nèi)核態(tài)，Client調(diào)用add方法的線程掛起等待返回；驅(qū)動完成一系列的操作之后喚醒Server進程，調(diào)用了Server進程本地對象的onTransact函數(shù)（實際上由Server端線程池完成）。我們再看Binder本地對象的onTransact方法（這里就是Stub類里面的此方法）：

@Override
        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_add: {
                    data.enforceInterface(DESCRIPTOR);
                    int _arg0;
                    _arg0 = data.readInt();
                    int _arg1;
                    _arg1 = data.readInt();
                    int _result = this.add(_arg0, _arg1);
                    reply.writeNoException();
                    reply.writeInt(_result);
                    return true;
                }
            }
            return super.onTransact(code, data, reply, flags);
        }

在Server進程里面，onTransact根據(jù)調(diào)用號（每個AIDL函數(shù)都有一個編號，在跨進程的時候，不會傳遞函數(shù)，而是傳遞編號指明調(diào)用哪個函數(shù)）調(diào)用相關函數(shù)；在這個例子里面，調(diào)用了Binder本地對象的add方法；這個方法將結(jié)果返回給驅(qū)動，驅(qū)動喚醒掛起的Client進程里面的線程并將結(jié)果返回。于是一次跨進程調(diào)用就完成了。

至此，你應該對AIDL這種通信方式里面的各個類以及各個角色有了一定的了解；它總是那么一種固定的模式：一個需要跨進程傳遞的對象一定繼承自IBinder，如果是Binder本地對象，那么一定繼承Binder實現(xiàn)IInterface，如果是代理對象，那么就實現(xiàn)了IInterface并持有了IBinder引用；

Proxy與Stub不一樣，雖然他們都既是Binder又是IInterface，不同的是Stub采用的是繼承（is 關系），Proxy采用的是組合（has 關系）。他們均實現(xiàn)了所有的IInterface函數(shù)，不同的是，Stub又使用策略模式調(diào)用的是虛函數(shù)（待子類實現(xiàn)），而Proxy則使用組合模式。為什么Stub采用繼承而Proxy采用組合？事實上，Stub本身is一個IBinder（Binder），它本身就是一個能跨越進程邊界傳輸?shù)膶ο螅运美^承IBinder實現(xiàn)transact這個函數(shù)從而得到跨越進程的能力（這個能力由驅(qū)動賦予）。Proxy類使用組合，是因為他不關心自己是什么，它也不需要跨越進程傳輸，它只需要擁有這個能力即可，要擁有這個能力，只需要保留一個對IBinder的引用。如果把這個過程做一個類比，在封建社會，Stub好比皇帝，可以號令天下，他生而具有這個權(quán)利（不要說宣揚封建迷信。。）如果一個人也想號令天下，可以，“挾天子以令諸侯”。為什么不自己去當皇帝，其一，一般情況沒必要，當了皇帝其實限制也蠻多的是不是？我現(xiàn)在既能掌管天下，又能不受約束（Java單繼承）；其二，名不正言不順啊，我本來特么就不是（Binder），你非要我是說不過去，搞不好還會造反。最后呢，如果想當皇帝也可以，那就是asBinder了。在Stub類里面，asBinder返回this，在Proxy里面返回的是持有的組合類IBinder的引用。

再去翻閱系統(tǒng)的ActivityManagerServer的源碼，就知道哪一個類是什么角色了：IActivityManager是一個IInterface，它代表遠程Service具有什么能力，ActivityManagerNative指的是Binder本地對象（類似AIDL工具生成的Stub類），這個類是抽象類，它的實現(xiàn)是ActivityManagerService；因此對于AMS的最終操作都會進入ActivityManagerService這個真正實現(xiàn)；同時如果仔細觀察，ActivityManagerNative.java里面有一個非公開類ActivityManagerProxy, 它代表的就是Binder代理對象；是不是跟AIDL模型一模一樣呢？那么ActivityManager是什么？他不過是一個管理類而已，可以看到真正的操作都是轉(zhuǎn)發(fā)給ActivityManagerNative進而交給他的實現(xiàn)ActivityManagerService 完成的。

OK，本文就講到這里了，要深入理解Binder，需要自己下功夫；那些native層以及驅(qū)動里面的調(diào)用過程，用文章寫出來根本沒有意義，需要自己去跟蹤；接下來你可以：

1. 看Android文檔，Parcel, IBinder, Binder等涉及到跨進程通信的類；
2. 不依賴AIDL工具，手寫遠程Service完成跨進程通信
3. 看《Binder設計與實現(xiàn)》
4. 看老羅的博客或者書（書結(jié)構(gòu)更清晰）
5. 再看《Binder設計與實現(xiàn)》
6. 學習Linux系統(tǒng)相關知識；自己看源碼。