通常情況下，如果兩個對象能夠直接相互訪問，那么這兩個對象存在于同一個內存空間中。
如果兩個對象分別存在于兩個不同的進程的時候，那么這兩個對象是不能相互訪問的，這個時候就需要使用跨進程通信的技術了。
而Android是基于Linux系統的，Linux傳統的跨進程技術主要是Socket，信號量，管道，消息隊列等，但是這些技術都有不同的缺點，如Socket開銷大效率不高，管道和消息隊列拷貝次數多，而對于Android系統來講，更重要的是安全性要高，而這些技術安全性都不是很高，大部分情況下接收方并不能得到發送發進程的PID/UID，很難識別身份。
所以Android系統就設計出了Binder跨進程通信機制，來保證傳輸性能和安全性。
Binder
Binder主要模塊
-
BinderDriver
存在于內核空間中，以字符設備的misc類型注冊，用戶可以從/dev/binder設備文件節點上，通過open和ioctl文件操作函數與BinderDriver進行通信，主要是負責Binder通信的建立，進程間的傳遞、Binder引用計數管理/數據包的管理。
-
BinderClient
存在于用戶空間中，它和BinderServer的跨進程通信都是通過BinderDriver來處理轉發的。
對于BinderClient只需要知道自己需要使用的Binder的名字和該Binder在ServerManager中的0號引用就可以了。通過0號引用去訪問ServerManager獲取Binder的引用，得到引用后就可以直接調用Binder的方法了。 -
ServerManager
存在于用戶空間中，用來管理BinderServer，BinderClient可以通過它來查詢BinderServer接口，查詢到之后就可以獲取到Binder的映射。
-
BinderServer
BinderServer會生成一個Binder實體，并會給Binder綁定一個名字，最終封裝成一個數據包傳遞給BinderDriver，BinderDriver在獲取到這個數據包之后，如果發現這個數據包是新傳遞過來的，就會給其在內核空間中創建相應的Binder實體節點和對應的實體節點的引用。
BinderDriver會將Binder的引用傳遞給ServerManager，ServerManager收到后就會取出Binder的名字和引用插入一張數據表中，這個就和DNS存儲域名到IP的映射原理一樣。
系統如何使用Binder
在客戶端中ServerManager的接口定義主要是在IServiceManager中：
public interface IServiceManager extends IInterface
{
/**
* Retrieve an existing service called @a name from the
* service manager. Blocks for a few seconds waiting for it to be
* published if it does not already exist.
*/
public IBinder getService(String name) throws RemoteException;
/**
* Retrieve an existing service called @a name from the
* service manager. Non-blocking.
*/
public IBinder checkService(String name) throws RemoteException;
/**
* Place a new @a service called @a name into the service
* manager.
*/
public void addService(String name, IBinder service, boolean allowIsolated)
throws RemoteException;
/**
* Return a list of all currently running services.
*/
public String[] listServices() throws RemoteException;
/**
* Assign a permission controller to the service manager. After set, this
* interface is checked before any services are added.
*/
public void setPermissionController(IPermissionController controller)
throws RemoteException;
static final String descriptor = "android.os.IServiceManager";
int GET_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION;
int CHECK_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+1;
int ADD_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+2;
int LIST_SERVICES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+3;
int CHECK_SERVICES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+4;
int SET_PERMISSION_CONTROLLER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+5;
}
可以看到IServiceManager定義的方法主要是添加，獲取，檢查等關于各種服務。主要作用其實就是像上面所說的簡單的將Binder以字符表示的名字轉換成引用。而對于BinderClient的實現其實就是ServiceManagerNative和ServiceManagerProxy，這兩個類實現了該接口，我們在AIDL的時候在分析。
AIDL
我們以具體的例子來分析，首先我們創建相關aidl文件：
// Book.java
public class Book implements Parcelable {
public int bookId;
public String bookName;
protected Book(Parcel in) {
bookId = in.readInt();
bookName = in.readString();
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeInt(bookId);
dest.writeString(bookName);
}
@Override
public int describeContents() {
return 0;
}
public static final Creator<Book> CREATOR = new Creator<Book>() {
@Override
public Book createFromParcel(Parcel in) {
return new Book(in);
}
@Override
public Book[] newArray(int size) {
return new Book[size];
}
};
}
// Book.aidl
package com.fastaoe.proficient;
parcelable Book;
// IBookManager.aidl
package com.fastaoe.proficient;
import com.fastaoe.proficient.Book;
interface IBookManager {
List<Book> getBookList();
void addBook(in Book book);
}
上面3個文件，Book.java表示圖書信息，實現了Parcelable接口。
Book.aidl是Book.java在AIDL中的聲明。
IBookManager是定義了用來操作Book的方法，getBookList從服務器中獲取圖書列表，addBook向服務器圖書列表中插入一本新書。
當我們聲明好了AIDL之后，IDE編譯好之后，就生成了IBookManager.java這個類。
public interface IBookManager extends android.os.IInterface {
// 代碼省略，下面在分析
}
可以看到這個系統為我們生成的類，實現了IInterface這個接口，自己本身也是一個接口，我們可以實現這個接口來實現相關的方法。我們來具體分析下這個生成的接口：
private static final java.lang.String DESCRIPTOR = "com.fastaoe.proficient.IBookManager";
Binder的唯一標識，一般情況下使用當前的類來表示。
public static com.fastaoe.proficient.IBookManager asInterface(android.os.IBinder obj) {
if ((obj == null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin != null) && (iin instanceof com.fastaoe.proficient.IBookManager))) {
return ((com.fastaoe.proficient.IBookManager) iin);
}
return new com.fastaoe.proficient.IBookManager.Stub.Proxy(obj);
}
用來將服務器中的Binder對象轉換成客戶端中所需要的AIDL接口類型的對象。可以看到當客戶端和服務端在同一個進程的時候，返回的就是服務端的Stub本身，如果不在同一個進程，返回的是系統封裝好的Stub.proxy對象，這表示當不在同一個進程的時候，客戶端拿到的其實不是服務端Binder本身，而是一個副本。
public android.os.IBinder asBinder() {
return this;
}
返回Binder對象本身。
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_getBookList: {
data.enforceInterface(DESCRIPTOR);
java.util.List<com.fastaoe.proficient.Book> _result = this.getBookList();
reply.writeNoException();
reply.writeTypedList(_result);
return true;
}
case TRANSACTION_addBook: {
data.enforceInterface(DESCRIPTOR);
com.fastaoe.proficient.Book _arg0;
if ((0 != data.readInt())) {
_arg0 = com.fastaoe.proficient.Book.CREATOR.createFromParcel(data);
} else {
_arg0 = null;
}
this.addBook(_arg0);
reply.writeNoException();
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
這個方法運行在服務器端的Binder線程池中，當客戶端發起跨進程的請求的時候，請求會通過底層封裝之后交給此方法執行。服務器端通過code來判斷客戶端請求的方法是什么，接著從data中獲取目標方法所需要的數據，并執行目標方法。當方法執行完之后通過reply寫入返回值，最后返回是否成功，如果成功返回true，否則則是false失敗。
private static class Proxy implements com.fastaoe.proficient.IBookManager {
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;
}
@Override
public java.util.List<com.fastaoe.proficient.Book> getBookList() throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
java.util.List<com.fastaoe.proficient.Book> _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
_reply.readException();
_result = _reply.createTypedArrayList(com.fastaoe.proficient.Book.CREATOR);
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
@Override
public void addBook(com.fastaoe.proficient.Book book) throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
if ((book != null)) {
_data.writeInt(1);
book.writeToParcel(_data, 0);
} else {
_data.writeInt(0);
}
mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
}
這個類運行在客戶端中，當客戶端調用此方法之后，首先會創建parcel的類型的輸入對象_data，輸出對象_reply，返回值對象_result（如果有的話），接著通過_data將參數存儲起來，在通過transact方法來發送RPC請求，同時線程會被掛起。接著服務端的onTransact方法會調用，最終RPC過程返回后，當前線程繼續執行，從_reply獲取到返回的結果。
通過AIDL實現跨進程通信（參考《Android開發藝術探索第二章例子》）
我們把AIDL生成的類分析完之后，就來實現一個服務器和客戶端通信的例子吧。
首先定義AIDL文件，就是上面圖書的例子
其中需要注意的是：
AIDL支持的數據類型：
- 基本數據類型
- String和CharSequence
- ArrayList和HashMap
- Parcelable
- AIDL本身
當我們自定義了Parcelable的時候，必須新建一個同名的.aidl文件，并將其聲明為parcelable類型。
AIDL中所有的實現了Parcelabe接口的類都需要聲明相對應的aidl文件，并且需要標識in(輸入)、out(輸出)、inout(輸入輸出)。
服務端的實現
public class ServerService extends Service {
private CopyOnWriteArrayList<Book> list = new CopyOnWriteArrayList<>();
private RemoteCallbackList<IAddBookListener> listeners = new RemoteCallbackList<>();
@Override
public void onCreate() {
super.onCreate();
list.add(new Book(1, "島上書店"));
list.add(new Book(2, "白夜行"));
}
@Nullable
@Override
public IBinder onBind(Intent intent) {
return binder;
}
private IBinder binder = new IBookManager.Stub(){
@Override
public List<Book> getListBook() throws RemoteException {
return list;
}
@Override
public void addBook(Book book) throws RemoteException {
onNewBookAdd(book);
}
@Override
public void registerListener(IAddBookListener listener) throws RemoteException {
listeners.register(listener);
}
@Override
public void unregisterListener(IAddBookListener listener) throws RemoteException {
listeners.unregister(listener);
}
};
private void onNewBookAdd(Book book) throws RemoteException {
list.add(book);
int N = listeners.beginBroadcast();
for (int i = 0; i < N; i++) {
IAddBookListener broadcastItem = listeners.getBroadcastItem(i);
broadcastItem.OnNewBookAddListener(book);
}
listeners.finishBroadcast();
}
}
在服務端中我們首先初始化了圖書列表，并創建了Binder對象并在onBind中返回。
使用了CopyOnWriteArrayList，這個List是支持并發讀寫的，因為當多個客戶端同時連接的時候，會出現多個線程同時訪問的問題，所以需要在AIDL中處理線程問題。
-
使用RemoteCallbackList來管理跨進程的listener接口，因為如果使用List的話，并不能在unregister的時候刪除掉當前listener接口，雖然我們使用的看上去是同一個listener，但是其實并不是同一個對象。
客戶端和服務端在多進程的環境中，而對象是不可能在多進程下傳遞的，所以Binder會將客戶端傳遞過來的對象重新轉化成新的對象，并不是原來的對象，這其實是反序列化的過程，所以AIDL中的自定義對象必須實現Parcelable接口。
那么怎么解除注冊呢？
可以通過RemoteCallbackList，RemoteCallbackList是系統專門提供用來刪除跨進程listener的接口，在它的內部有一個Map用來保存所有的AIDL回調，key是IBinder，value是callback。雖然在跨進程的環境中，生成的對象不是同一個對象，但是它們底層的Binder肯定是同一個，所以可以利用這個來實現解除注冊。當客戶端要解除注冊的時候，服務端通過RemoteCallbackList找到具有相同Binder對象的服務端listener并將其刪除。
客戶端實現
public class MainActivity extends AppCompatActivity {
private List<Book> list = new ArrayList<>();
private int index = 3;
Handler handler = new Handler(){
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 1:
list.add((Book) msg.obj);
tv_book.setText(list.toString());
break;
}
}
};
private ServiceConnection conn = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
iBookManager = IBookManager.Stub.asInterface(service);
try {
iBookManager.registerListener(listener);
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
iBookManager = null;
}
};
private IBookManager iBookManager;
private IAddBookListener listener = new IAddBookListener.Stub() {
@Override
public void OnNewBookAddListener(Book book) throws RemoteException {
handler.obtainMessage(1, book).sendToTarget();
}
};
private Button btn_search;
private Button btn_add;
private TextView tv_book;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
btn_search = (Button) findViewById(R.id.btn_search);
btn_add = (Button) findViewById(R.id.btn_add);
tv_book = (TextView) findViewById(R.id.tv_book);
btn_search.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (iBookManager != null) {
try {
// TODO: 2017/7/9 放在子線程中
list = iBookManager.getListBook();
} catch (RemoteException e) {
e.printStackTrace();
}
tv_book.setText(list.toString());
}
}
});
btn_add.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (iBookManager != null) {
Book book = new Book(index, "圖書"+ index);
index += 1;
try {
// TODO: 2017/7/9 放在子線程中
iBookManager.addBook(book);
} catch (RemoteException e) {
e.printStackTrace();
}
}
}
});
Intent intent = new Intent();
intent.setAction("com.fastaoe.server.ServerService");
intent.setComponent(new ComponentName("com.fastaoe.server", "com.fastaoe.server.ServerService"));
bindService(intent, conn, Context.BIND_AUTO_CREATE);
}
@Override
protected void onDestroy() {
try {
iBookManager.unregisterListener(listener);
} catch (RemoteException e) {
e.printStackTrace();
}
unbindService(conn);
super.onDestroy();
}
}
首先綁定遠程服務，接著將遠程服務返回的Binder對象轉換成AIDL接口，接著就可以調用服務端中的方法了。
需要注意的是如果aidl中的方法在服務端是耗時的操作的時候，需要處理，不然會導致ANR的產生，同樣的當服務端調用客戶端的耗時操作的時候，也需要保證在服務端的方法運行在非UI線程，因為Service本身是運行在UI線程中的。
OnNewBookAddListener運行在Binder線程池中，所以不能在其中訪問UI相關的內容，如果需要訪問的話，則需要通過Handler切換線程。
-
Binder在連接過程中是可能意外死亡的，主要是因為服務端的進程被終止了，所以我們需要重新連接服務。
- 可以通過在onServiceDisconnected中重連。
- 也可以通過DeathRecipient來監聽是否被斷開。
具體的Demo可以查看AIDL的簡單實現
