學(xué)習(xí)IPC機制離不開對IBinder的了解，好久沒有用過AIDL了，本篇是記錄一下，免得自己忘記。

場景

1.aidl_service 提供簡單計算服務(wù)
2.aidl_client 請求計算服務(wù)，并顯示結(jié)果

AIDL文檔

Google文檔如下:

Paste_Image.png

1.新建aidl文件
2.實現(xiàn)aidl定義的接口
3.將定義好的接口文件給客戶端

新建AIDL文件

aidl文件格式最基本的定義接口，寫法和java基本一樣，如下:

// Query.aidl
package my.service.calc;

// Declare any non-default types here with import statements

interface Query {
    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
            double aDouble, String aString);
}

aidl語言支持的數(shù)據(jù)類型，Google文檔如下:

Paste_Image.png

支持：
1.基本java的數(shù)據(jù)類型
2.String, Charsequence, List, Map
3.支持實現(xiàn)了Parcelable接口的對象，必須添加對象的aidl定義, 如下:

// Expression.aidl
package my.service.calc;

parcelable Expression;

在相應(yīng)的包下定義正確的Java類，如下:

package my.service.calc;
/**
 * 代表要計算的表達(dá)式
 */
public class Expression implements Parcelable {
    ...
}

使用android studio2.2開發(fā)的，新建工程MyAidl_server
然后新建AIDL文件,如下:

Paste_Image.png

寫上ICalcService,然后就會新建出AIDL文件，修改接口定義，提供一個設(shè)置表達(dá)式Expression的方法，一個計算并且返回結(jié)果的方法，這里有個知識點, 如下:

AIDL所有的非基本參數(shù)都需要一個定向tag來指出數(shù)據(jù)流通的方式，否則編譯不過
in 代表這個參數(shù)的數(shù)據(jù)是由客戶端流向給服務(wù)端
out 代表這個參數(shù)的數(shù)據(jù)是由服務(wù)端流向給客戶端
inout 代表雙向

后面會結(jié)合AIDL生成的Java代表分析，in,out,inout到底具體怎樣體現(xiàn)的

我們生成基本的文件,ICalcService.aidl，如下:

// ICalcService.aidl
package my.service.calc;

// Declare any non-default types here with import statements
import my.service.calc.Expression;
import my.service.calc.Result;

interface ICalcService {

    void set(in Expression exp);//輸入表達(dá)式

    void calc(out Result result);//輸出計算結(jié)果

    void test(inout Result result);//測試inout的空方法

}

// Expression.aidl
package my.service.calc;
// 代表表達(dá)式，包含計算符號，左右2邊int數(shù)據(jù)
parcelable Expression;

// Result.aidl
package my.service.calc;

// 代表最近一次表達(dá)式的計算結(jié)果
parcelable Result;

然后實現(xiàn)對應(yīng)的Java類：
表達(dá)式類

public class Expression implements Parcelable {
    public static final int TYPE_ADD = 1;
    public static final int TYPE_SUB = 2;

    public int left;
    public int right;
    public int opt;

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeInt(this.left);
        dest.writeInt(this.right);
        dest.writeInt(this.opt);
    }

    public Expression() {
    }

    protected Expression(Parcel in) {
        this.left = in.readInt();
        this.right = in.readInt();
        this.opt = in.readInt();
    }

    public static final Parcelable.Creator<Expression> CREATOR = new Parcelable.Creator<Expression>() {
        @Override
        public Expression createFromParcel(Parcel source) {
            return new Expression(source);
        }

        @Override
        public Expression[] newArray(int size) {
            return new Expression[size];
        }
    };
}

計算結(jié)果類

public class Result implements Parcelable {

    private boolean vaild;
    private int result;

    public void set(int result) {
        this.result = result;
        this.vaild = true;
    }

    @Override
    public String toString() {
        return String.format("%d [%s]", result, vaild ? "有效" : "無效");
    }

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeByte(this.vaild ? (byte) 1 : (byte) 0);
        dest.writeInt(this.result);
    }

    public void readFromParcel(Parcel dest) {
        this.vaild = dest.readByte() != 0;
        this.result = dest.readInt();
    }

    public Result() {
    }

    protected Result(Parcel in) {
        this.vaild = in.readByte() != 0;
        this.result = in.readInt();
    }

    public static final Parcelable.Creator<Result> CREATOR = new Parcelable.Creator<Result>() {
        @Override
        public Result createFromParcel(Parcel source) {
            return new Result(source);
        }

        @Override
        public Result[] newArray(int size) {
            return new Result[size];
        }
    };
}

IDE幫我們通過AIDL文件，生成了 ICalcService.java文件，格式化后如下:

package my.service.calc;

public interface ICalcService extends android.os.IInterface {
    /**
     * Local-side IPC implementation stub class.
       我們自己的服務(wù)必須實現(xiàn)這個Stub class類以提供服務(wù)，它是繼承的Binder
     */
    public static abstract class Stub extends android.os.Binder implements ICalcService {
        private static final String DESCRIPTOR = "my.service.calc.ICalcService";

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

        /**
         * 這里轉(zhuǎn)換為正真的ICalcService接口
         */
        public static ICalcService asInterface(android.os.IBinder obj) {
            if ((obj == null)) {
                return null;
            }
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            //如果是進(jìn)程內(nèi)通信的話，我們應(yīng)該是直接擁有這個服務(wù)對象的，可以直接返回使用
            if (((iin != null) && (iin instanceof ICalcService))) {
                return ((ICalcService) iin);
            }
            //如果是2個進(jìn)程之間相互通信，我們只能擁有remote對象的IBinder句柄，然后通過IBinder機制去交互
            return new Proxy(obj);
        }

        @Override
        public android.os.IBinder asBinder() {
            return this;
        }
        
        /*
        * 這里是真正交互的地方，code代表需要調(diào)用那個方法，在文件最后定義了代表相關(guān)方法的int值，data是輸入?yún)?shù)，reply是輸出參數(shù)，flags代表的是0代表一次普通的RPC，1代表one_way RPC        */
        @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;
                }
                //第1個方法是in
                case TRANSACTION_set: {
                    data.enforceInterface(DESCRIPTOR);
                    Expression _arg0;
                    //檢查參數(shù)，如果有將會從客戶端來的數(shù)據(jù)中讀取一個輸入?yún)?shù)對象
                    if ((0 != data.readInt())) {
                        _arg0 = Expression.CREATOR.createFromParcel(data);
                    } else {
                        _arg0 = null;
                    }
                    //服務(wù)調(diào)用處理
                    this.set(_arg0);
                    reply.writeNoException();
                    //服務(wù)端不會有任何回寫操作
                    return true;
                }
                //第2個方法是out
                case TRANSACTION_calc: {
                    data.enforceInterface(DESCRIPTOR);
                    //這里明顯區(qū)別，不從客戶端讀取參數(shù)，直接new一個新的參數(shù)對象
                    Result _arg0;
                    _arg0 = new Result();
                    //服務(wù)調(diào)用處理
                    this.calc(_arg0);
                    reply.writeNoException();
                    //將結(jié)果回寫給客戶端，數(shù)據(jù)流向了客戶端
                    if ((_arg0 != null)) {
                        reply.writeInt(1);
                        _arg0.writeToParcel(reply, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
                    } else {
                        reply.writeInt(0);
                    }
                    return true;
                }
                //第3個方法inout，按照上面分析應(yīng)該是 1,2情況的合并
                case TRANSACTION_test: {
                    data.enforceInterface(DESCRIPTOR);
                    ///檢查參數(shù)，如果有將會從客戶端來的數(shù)據(jù)中讀取一個輸入?yún)?shù)對象
                    Result _arg0;
                    if ((0 != data.readInt())) {
                        _arg0 = Result.CREATOR.createFromParcel(data);
                    } else {
                        _arg0 = null;
                    }
                    //服務(wù)調(diào)用處理
                    this.test(_arg0);
                    reply.writeNoException();
                    //將結(jié)果回寫給客戶端，數(shù)據(jù)流向了客戶端
                    if ((_arg0 != null)) {
                        reply.writeInt(1);
                        _arg0.writeToParcel(reply, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
                    } else {
                        reply.writeInt(0);
                    }
                    return true;
                }
            }
            return super.onTransact(code, data, reply, flags);
        }

        //代理實現(xiàn)，主要還是調(diào)用遠(yuǎn)程的remote對象，代碼自己查看本地的
        private static class Proxy implements ICalcService {
           ...
        }

        static final int TRANSACTION_set = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
        static final int TRANSACTION_calc = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
        static final int TRANSACTION_test = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2);
    }

    public void set(Expression exp) throws android.os.RemoteException;

    public void calc(Result result) throws android.os.RemoteException;

    public void test(Result result) throws android.os.RemoteException;
}

我在代碼注釋了一些，包括in out inout不同，體現(xiàn)在onTransact函數(shù)中對參數(shù)的不同處理方式，以及結(jié)果的處理。
我們只要服務(wù)端繼承ICalcService.Stub進(jìn)行抽血方法實現(xiàn)，然后通過service的onBind接口返回，就完成了服務(wù)端的編寫，如下:

@Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return new CalcBinder();
    }

    private class CalcBinder extends ICalcService.Stub {

        private Expression mExp;


        @Override
        public void set(Expression exp) throws RemoteException {
            mExp = exp;
        }

        @Override
        public void calc(Result result) throws RemoteException {
            //計算結(jié)果設(shè)置給result對象
            if (mExp != null) {
                result.set(ExpressionFactory.create(mExp).getValue());
            }
        }

        @Override
        public void test(Result result) throws RemoteException {
            //empty
        }
    }

這里有個坑，如果有out標(biāo)記的參數(shù)對象，編譯時候會報錯，必須給參數(shù)對象類添加readFromParcel(Parcel dest)以讀取來自服務(wù)端的結(jié)果，如下:

    public void readFromParcel(Parcel dest) {
        this.vaild = dest.readByte() != 0;
        this.result = dest.readInt();
    }

以上服務(wù)端就完成了。
客戶端工程只要將服務(wù)端的AIDL文件，Expression.java, Result.java拷貝過去，就可以了，生成同樣的文件，然后bindService即可鏈接計算服務(wù)，如下:

Paste_Image.png

綁定服務(wù)->請求求和->請求計算結(jié)果，完成上面set calc方法的調(diào)用。

小記:  onServiceDisconnected只會在服務(wù)進(jìn)程被意外殺死才會調(diào)用，unbindservice并不會回調(diào)這個方法

對于進(jìn)程間通信來說，具體的流程就分為如下幾步：

1.Client 發(fā)起遠(yuǎn)程調(diào)用請求 也就是RPC 到Binder。同時將自己掛起，掛起的原因是要等待RPC調(diào)用結(jié)束以后返回的結(jié)果

2.Binder 收到RPC請求以后 把參數(shù)收集一下，調(diào)用transact方法，把RPC請求轉(zhuǎn)發(fā)給service端。

3.service端 收到rpc請求以后 就去線程池里 找一個空閑的線程去走service端的 onTransact方法 ，實際上也就是真正在運行service端的 方法了，等方法運行結(jié)束 就把結(jié)果 寫回到binder中。

4.Binder 收到返回數(shù)據(jù)以后 就喚醒原來的Client 線程，返回結(jié)果。至此，一次進(jìn)程間通信 的過程就結(jié)束了

關(guān)于IBinder線程問題:

1.客戶端請求的時候，會被掛起，等待直到結(jié)果返回，所以耗時的請求通信過程不能放在主線程里面
2.經(jīng)測試服務(wù)端方法是binder開啟的線程調(diào)用的，每次調(diào)用線程不一樣，所以服務(wù)端多個客戶端的情況下，要考慮并發(fā)

參考大神們博客:
Android 手寫B(tài)inder 教你理解android中的進(jìn)程間通信
你真的理解Android AIDL中的in，out，inout么
Android aidl Binder框架淺析