學習IPC機制離不開對IBinder的了解，好久沒有用過AIDL了，本篇是記錄一下，免得自己忘記。
場景
1.aidl_service 提供簡單計算服務
2.aidl_client 請求計算服務，并顯示結果
AIDL文檔
Google文檔如下:
Paste_Image.png
1.新建aidl文件
2.實現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語言支持的數據類型，Google文檔如下:
Paste_Image.png
支持：
1.基本java的數據類型
2.String, Charsequence, List, Map
3.支持實現了Parcelable接口的對象，必須添加對象的aidl定義, 如下:
// Expression.aidl
package my.service.calc;
parcelable Expression;
在相應的包下定義正確的Java類，如下:
package my.service.calc;
/**
* 代表要計算的表達式
*/
public class Expression implements Parcelable {
...
}
使用android studio2.2開發的，新建工程MyAidl_server
然后新建AIDL文件,如下:
Paste_Image.png
寫上ICalcService,然后就會新建出AIDL文件，修改接口定義，提供一個設置表達式Expression的方法，一個計算并且返回結果的方法，這里有個知識點, 如下:
AIDL所有的非基本參數都需要一個定向tag來指出數據流通的方式，否則編譯不過
in 代表這個參數的數據是由客戶端流向給服務端
out 代表這個參數的數據是由服務端流向給客戶端
inout 代表雙向
后面會結合AIDL生成的Java代表分析，in,out,inout到底具體怎樣體現的
我們生成基本的文件,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);//輸入表達式
void calc(out Result result);//輸出計算結果
void test(inout Result result);//測試inout的空方法
}
// Expression.aidl
package my.service.calc;
// 代表表達式，包含計算符號，左右2邊int數據
parcelable Expression;
// Result.aidl
package my.service.calc;
// 代表最近一次表達式的計算結果
parcelable Result;
然后實現對應的Java類：
表達式類
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];
}
};
}
計算結果類
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.
我們自己的服務必須實現這個Stub class類以提供服務，它是繼承的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);
}
/**
* 這里轉換為正真的ICalcService接口
*/
public static ICalcService asInterface(android.os.IBinder obj) {
if ((obj == null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
//如果是進程內通信的話，我們應該是直接擁有這個服務對象的，可以直接返回使用
if (((iin != null) && (iin instanceof ICalcService))) {
return ((ICalcService) iin);
}
//如果是2個進程之間相互通信，我們只能擁有remote對象的IBinder句柄，然后通過IBinder機制去交互
return new Proxy(obj);
}
@Override
public android.os.IBinder asBinder() {
return this;
}
/*
* 這里是真正交互的地方，code代表需要調用那個方法，在文件最后定義了代表相關方法的int值，data是輸入參數，reply是輸出參數，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;
//檢查參數，如果有將會從客戶端來的數據中讀取一個輸入參數對象
if ((0 != data.readInt())) {
_arg0 = Expression.CREATOR.createFromParcel(data);
} else {
_arg0 = null;
}
//服務調用處理
this.set(_arg0);
reply.writeNoException();
//服務端不會有任何回寫操作
return true;
}
//第2個方法是out
case TRANSACTION_calc: {
data.enforceInterface(DESCRIPTOR);
//這里明顯區別，不從客戶端讀取參數，直接new一個新的參數對象
Result _arg0;
_arg0 = new Result();
//服務調用處理
this.calc(_arg0);
reply.writeNoException();
//將結果回寫給客戶端，數據流向了客戶端
if ((_arg0 != null)) {
reply.writeInt(1);
_arg0.writeToParcel(reply, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
} else {
reply.writeInt(0);
}
return true;
}
//第3個方法inout，按照上面分析應該是 1,2情況的合并
case TRANSACTION_test: {
data.enforceInterface(DESCRIPTOR);
///檢查參數，如果有將會從客戶端來的數據中讀取一個輸入參數對象
Result _arg0;
if ((0 != data.readInt())) {
_arg0 = Result.CREATOR.createFromParcel(data);
} else {
_arg0 = null;
}
//服務調用處理
this.test(_arg0);
reply.writeNoException();
//將結果回寫給客戶端，數據流向了客戶端
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);
}
//代理實現，主要還是調用遠程的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不同，體現在onTransact函數中對參數的不同處理方式，以及結果的處理。
我們只要服務端繼承ICalcService.Stub進行抽血方法實現，然后通過service的onBind接口返回，就完成了服務端的編寫，如下:
@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 {
//計算結果設置給result對象
if (mExp != null) {
result.set(ExpressionFactory.create(mExp).getValue());
}
}
@Override
public void test(Result result) throws RemoteException {
//empty
}
}
這里有個坑，如果有out標記的參數對象，編譯時候會報錯，必須給參數對象類添加readFromParcel(Parcel dest)以讀取來自服務端的結果，如下:
public void readFromParcel(Parcel dest) {
this.vaild = dest.readByte() != 0;
this.result = dest.readInt();
}
以上服務端就完成了。
客戶端工程只要將服務端的AIDL文件，Expression.java, Result.java拷貝過去，就可以了，生成同樣的文件，然后bindService即可鏈接計算服務，如下:
Paste_Image.png
綁定服務->請求求和->請求計算結果，完成上面set calc方法的調用。
小記: onServiceDisconnected只會在服務進程被意外殺死才會調用，unbindservice并不會回調這個方法
對于進程間通信來說，具體的流程就分為如下幾步：
1.Client 發起遠程調用請求 也就是RPC 到Binder。同時將自己掛起，掛起的原因是要等待RPC調用結束以后返回的結果
2.Binder 收到RPC請求以后 把參數收集一下，調用transact方法，把RPC請求轉發給service端。
3.service端 收到rpc請求以后 就去線程池里 找一個空閑的線程去走service端的 onTransact方法 ，實際上也就是真正在運行service端的 方法了，等方法運行結束 就把結果 寫回到binder中。
4.Binder 收到返回數據以后 就喚醒原來的Client 線程，返回結果。至此，一次進程間通信 的過程就結束了
關于IBinder線程問題:
1.客戶端請求的時候，會被掛起，等待直到結果返回，所以耗時的請求通信過程不能放在主線程里面
2.經測試服務端方法是binder開啟的線程調用的，每次調用線程不一樣，所以服務端多個客戶端的情況下，要考慮并發
參考大神們博客:
Android 手寫Binder 教你理解android中的進程間通信
你真的理解Android AIDL中的in，out，inout么
Android aidl Binder框架淺析
