前言

Binder是安卓中實現IPC（進程間通信的）常用手段，四大組件之間的跨進程通信也是利用Binder實現的，Binder是學習四大組件工作原理的的一個重要基礎。 好多文章都會深入C代碼去介紹Binder的工作流程，沒點水平真的難以理解，本文不會太深入底層去剖析原理，盡可能較為簡單的讓大家了解Binder是怎么工作的。

Binder的使用

在介紹Binder原理之前，我們先來看看在安卓中怎么使用Binder來進程間通信。 在使用之前我們先來介紹Binder的幾個方法：

public final boolean transact(int code, Parcel data, Parcel reply, int flags)

protected boolean onTransact(int code, Parcel data, Parcel reply, int flags)

這兩個方法分別代表了客戶端和服務端，transact用來發送消息，onTransact負責接收transact傳過來的消息，這一點很容易理解。

code 方法標識符，在相同進程中，我們很容易的通過方法調用來執行我們的目標方法，但是在不同的進程間，方法調用的方式就不能再用了，所以我們使用code來表示遠程調用函數的標識。這個標識必須介于FIRST_CALL_TRANSACTION（0x00000001）和LAST_CALL_TRANSACTION（0x00ffffff）之間。 data Parcel類型的數據包，要傳給客戶端的請求參數。 reply 如果客戶端需要返回值，則reply就是服務端返回的數據。 flags 用來區分這個調用是普通調用還是單程調用，普通調用時，Client端線程會阻塞，直到從Server端接收到返回值，若flag==IBinder.FLAG_ONEWAY，則這次調用是單程調用，Client在傳出數據后會立即執行下一段代碼，此時兩端異步執行，單程調用時函數返回值必須為void （也就是單程調用必須舍棄返回值，要返回值就必須阻塞等待）

利用這兩個方法我們就可以實現Client和Server端的通信，接下來我們看看具體該怎么使用。 在Server接收到Client傳來的消息（data）時，會對data進行驗證data.enforceInterface(DESCRIPTOR)，DESCRIPTOR是一個字符串類型的描述符，當data的描述符跟DESCRIPTOR相同時才能通過驗證。

public class Stub extends Binder { //描述符 public static final java.lang.String DESCRIPTOR = 'MyTestBinder'; //code 方法描述符 public static final int TRANSACTION_test0 = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); public static final int TRANSACTION_test1 = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); @Override protected boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {switch (code) { case TRANSACTION_test0://驗證描述符data.enforceInterface(DESCRIPTOR);//執行方法test0();return true; case TRANSACTION_test1://驗證描述符data.enforceInterface(DESCRIPTOR);//執行方法test1(data, reply);return true;}return super.onTransact(code, data, reply, flags); } //無返回值 private void test0() {Log.d('MyBinderServer', 'test0'); } //有返回值 private void test1(Parcel data, Parcel reply) {Log.d('MyBinderServer', 'test1');reply.writeInt(data.readInt() + 1); }}

我們知道，要想實現Client和Server端的通信連接，就必須讓client知道server端的地址，就跟Http請求，我們要知道服務端的ip和端口。Binder通信其實也是一樣的，那么我們怎么讓Client拿到Server的地址呢？ 一種是跟Http請求一樣，我們知道Http請求要把域名轉換成ip和端口，這就是DNS，我們也需要一個Binder的DNS。安卓中也為我們提供了Binder的“DNS”那就是ServiceManager，ServiceManager中注冊了所有系統服務（如MediaServer等），我們可以使用ServiceManager拿到遠程的Binder地址，這種方式叫做有名Binder查找（有名Binder，如MediaServer等這些系統服務被注冊的時候都是有名字的，比如，我們通過WINDOW_SERVICE這個名字就能拿到WindowManager）。但是問題是向ServiceManager注冊服務的過程是系統進程實現的，我們的應用進程不能注冊自己的Binder。 另一種就是利用有名的Binder來輔助傳遞匿名的Binder，也就是說如果有某個有名Binder服務它提供了傳遞Binder的方法，那么我們就可以通過這個Binder服務來傳遞我們的匿名Binder，我們查找到這個有名的Binder是不是就能拿到我們的匿名Binder。正好AMS其實提供了這樣的功能，它通過Service.onBind把匿名的Binder封裝在了Service里面供我們調用。

public class MyService extends Service {@Override public IBinder onBind(Intent intent) {return new Stub(); }}

我們使用binderService()來獲取遠程的Binder。

Intent serviceIntent = new Intent(this, MyService.class);bindService(serviceIntent, new ServiceConnection() { @Override public void onServiceConnected(ComponentName name, IBinder service) {//service可以理解為是遠程Binder的地址，我們利用他跟遠程通信，C++層會轉換這個IBinder跟Binder進行通信 } @Override public void onServiceDisconnected(ComponentName name) { }}, BIND_AUTO_CREATE);

獲取到Binder之后我們補充好通信的代碼：

bindService(serviceIntent, new ServiceConnection() { @Override public void onServiceConnected(ComponentName name, IBinder service) {Parcel data0 = Parcel.obtain();//請求參數Parcel reply0 = Parcel.obtain();//響應參數Parcel data1 = Parcel.obtain();Parcel reply1 = Parcel.obtain();//調用第一個方法try { //添加描述符 data0.writeInterfaceToken(Stub.DESCRIPTOR); /* * 寫入參數，要想傳遞多個int參數，順序調用writeInt * data0.writeInt(10); * data0.writeInt(20); * 獲取 * int num10 = data0.readInt(); * int num20 = data0.readInt(); */ data0.writeInt(10); //發起遠程調用 service.transact(Stub.TRANSACTION_test0, data0, reply0, 0); reply0.readException();} catch (RemoteException e) { e.printStackTrace();} finally { data0.recycle(); reply0.recycle();}//調用第二個方法try { //添加描述符 data1.writeInterfaceToken(Stub.DESCRIPTOR); data1.writeInt(10); //發起遠程調用 service.transact(Stub.TRANSACTION_test1, data1, reply1, 0); reply1.readException(); //讀取返回值 int num = reply1.readInt(); Log.d(TAG, 'reply value: ' + num);} catch (RemoteException e) { e.printStackTrace();} finally { data1.recycle(); reply1.recycle();} } @Override public void onServiceDisconnected(ComponentName name) { }}, BIND_AUTO_CREATE);

為了方便調用，我們寫一個代理類來封裝通信過程

public class Proxy { //描述符 public static final java.lang.String DESCRIPTOR = 'MyTestBinder'; //code 方法描述符 public static final int TRANSACTION_test0 = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0); public static final int TRANSACTION_test1 = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); private IBinder mRemote; public Proxy(IBinder remote) {this.mRemote = remote; } public void test1() {Parcel data0 = Parcel.obtain();//請求參數Parcel reply0 = Parcel.obtain();//響應參數//調用第一個方法try { //添加描述符 data0.writeInterfaceToken(DESCRIPTOR); /* * 寫入參數，要想傳遞多個int參數，順序調用writeInt * data0.writeInt(10); * data0.writeInt(20); * 獲取 * int num10 = data0.readInt(); * int num20 = data0.readInt(); */ data0.writeInt(10); //發起遠程調用 mRemote.transact(TRANSACTION_test0, data0, reply0, 0); reply0.readException();} catch (RemoteException e) { e.printStackTrace();} finally { data0.recycle(); reply0.recycle();} } public int test2() {Parcel data1 = Parcel.obtain();Parcel reply1 = Parcel.obtain();//調用第二個方法int num = 0;try { //添加描述符 data1.writeInterfaceToken(DESCRIPTOR); data1.writeInt(10); //發起遠程調用 mRemote.transact(TRANSACTION_test1, data1, reply1, 0); reply1.readException(); //讀取返回值 num = reply1.readInt();} catch (RemoteException e) { e.printStackTrace();} finally { data1.recycle(); reply1.recycle();}return num; }}

bindService(serviceIntent, new ServiceConnection() { @Override public void onServiceConnected(ComponentName name, IBinder service) {Proxy proxy = new Proxy(service);proxy.test1();int i = proxy.test2(); } @Override public void onServiceDisconnected(ComponentName name) { }}, BIND_AUTO_CREATE);模糊進程間調用

前邊就是Binder的使用方式，但是至此還遺留了一個問題，我們的Service只有指定了新的進程名之后才會是遠程調用，如果通過bindService 傳遞過來的IBinder對象是同進程的，那我們就不需要使用IBinder.transact進行內核通信了。我們知道同進程之間利用方法調用方式就可以做到通信。 我們在onServiceConnected打印IBinder類型，如果發現是遠程調用，傳給我們的 iBinder 是 BinderProxy 類型，BinderProxy是Binder的內部類一樣實現了IBinder接口，他在native層會對應一個C++的BpBinder，BpBinder 最終會通過Binder驅動跟Server端通信。如果是本地調用，打印出的類型為Stub，說明本地調用時，onServiceConnected傳過來的就是我們在Service的onBinde方法返回的Stub對象本身。基于這個原理，我們可以設計一個轉換方法。

首先我們要怎么判斷當前是遠程調用還是同進程調用呢？ 我們使用queryLocalInterface(DESCRIPTOR)方法，Binder中queryLocalInterface不會返回空，而在BinderProxy的實現中，queryLocalInterface返回為null。 Binder：

public IInterface queryLocalInterface(String descriptor) {if (mDescriptor != null && mDescriptor.equals(descriptor)) { return mOwner;}return null; }

mOwner是attachInterface方法傳進來的接口本身，后面還會出現這個方法。 BinderProxy：

public IInterface queryLocalInterface(String descriptor) {return null; }

當發現是遠程調用時我們創建上邊的Proxy來代理跨進程通信過程。要是本地調用我們直接返回本地Stub對象。

public static IMyInterface asInterface(IBinder iBinder){if ((iBinder == null)) { return null;}//獲取本地interfaceIInterface iin = iBinder.queryLocalInterface(DESCRIPTOR);if (((iin != null) && (iin instanceof IMyInterface))) { //不為空，說明是本地調用，直接強轉后返回。 //IMyInterface封裝了test0()、test1()兩個方法，本地對象和Proxy都繼承自接口 return ((IMyInterface)iin );}//為null，遠程調用，新建代理return new Proxy(iBinder); }

把上面相關代碼完善之后

public interface IBinderTest extends android.os.IInterface { /** * 本地Stub對象 */ public static abstract class Stub extends android.os.Binder implements IBinderTest {private static final java.lang.String DESCRIPTOR = 'com.XXX.XXXX.IBinderTest';public Stub() { //綁定DESCRIPTOR，并設置queryLocalInterface方法返回的mOwner this.attachInterface(this, DESCRIPTOR);}/** * 本地遠程轉換 */public static IBinderTest asInterface(android.os.IBinder obj) { if ((obj == null)) {return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin != null) && (iin instanceof IBinderTest))) {return ((IBinderTest) iin); } return new IBinderTest.Stub.Proxy(obj);}@Overridepublic android.os.IBinder asBinder() { return this;}/** * 處理Client調用請求 */@Overridepublic boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException { java.lang.String descriptor = DESCRIPTOR; switch (code) {case INTERFACE_TRANSACTION: { reply.writeString(descriptor); return true;}case TRANSACTION_testVoidAidl: { data.enforceInterface(descriptor); this.testVoidAidl(); reply.writeNoException(); return true;}case TRANSACTION_testStringAidl: { data.enforceInterface(descriptor); java.lang.String _result = this.testStringAidl(); reply.writeNoException(); reply.writeString(_result); return true;}default: { return super.onTransact(code, data, reply, flags);} }}/** * 遠程調用代理類 */private static class Proxy implements IBinderTest { 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 void testVoidAidl() throws android.os.RemoteException {android.os.Parcel _data = android.os.Parcel.obtain();android.os.Parcel _reply = android.os.Parcel.obtain();try { _data.writeInterfaceToken(DESCRIPTOR); mRemote.transact(Stub.TRANSACTION_testVoidAidl, _data, _reply, 0); _reply.readException();} finally { _reply.recycle(); _data.recycle();} } @Override public java.lang.String testStringAidl() throws android.os.RemoteException {android.os.Parcel _data = android.os.Parcel.obtain();android.os.Parcel _reply = android.os.Parcel.obtain();java.lang.String _result;try { _data.writeInterfaceToken(DESCRIPTOR); mRemote.transact(Stub.TRANSACTION_testStringAidl, _data, _reply, 0); _reply.readException(); _result = _reply.readString();} finally { _reply.recycle(); _data.recycle();}return _result; }}/** * 調用函數code */static final int TRANSACTION_testVoidAidl = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);static final int TRANSACTION_testStringAidl = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1); } public void testVoidAidl() throws android.os.RemoteException; public java.lang.String testStringAidl() throws android.os.RemoteException;}

如果你用過AIDL并且看過AIDL生成的代碼，你就會發現上面代碼就是AIDL生成的。 換掉Service的調用

public class MyService extends Service { private String TAG = 'MyService'; @Override public IBinder onBind(Intent intent) {return new MyBinder(); } class MyBinder extends IBinderTest.Stub{@Overridepublic void testVoidAidl() throws RemoteException { Log.d(TAG, 'testVoidAidl');}@Overridepublic String testStringAidl() throws RemoteException { Log.d(TAG, 'testStringAidl'); return 'hello';} }}

以上就是Binder的使用方法以及原理的簡單介紹。

Binder原理

之前介紹了Binder的基本使用，接下來我們來看下Binder的底層原理。

（圖片來源gityuan.com/2015/10/31/…），安卓的應用內存是隔離的，但是內核空間是共享的，我們要實現IPC就要靠共享的內核空間來交換數據。

Binder通信模型：

ioctl

Binder的通信原理：

由于用戶空間的隔離機制（沙盒模式），所以我們要利用內核空間進行IPC操作，用戶空間與內核空間的交互使用的是linux內核的ioctl函數，接下來簡單了解一下ioctl的使用。 ioctl可以控制I/O設備 （驅動設備），提供了一種獲得設備信息和向設備發送控制參數的手段。簡單來說就是使用ioctl可以對驅動設備進行操作。由于我們IPC的過程中內核空間使用虛擬驅動設備/dev/binder控制通信過程，我們要跟這個Binder驅動設備交互就要使用ioctl命令。 簡單介紹下，Linux要實現驅動設備的使用需要三個角色

應用程序（調用方），使用ioctl來發送操作指令。 驅動程序，用來處理ioctl傳來的指令，并完成對驅動設備的操作。驅動程序被注冊進內核之后，就會等待應用程序的調用。 驅動設備，在Binder機制中，驅動設備是/dev/binder，這個文件被映射到每個系統Service的虛擬內存中（后邊會講到），驅動程序可以操作這個文件進行進程間數據交互。

下圖是Linux中應用程序是怎么通過驅動來操作硬件設備的：

來個圖來說一下應用層與驅動程序函數的ioctl之間的聯系：

簡單介紹一下函數：

int (*ioctl) (struct inode * node, struct file *filp, unsigned int cmd, unsigned long arg);

參數：

inode和file：ioctl的操作有可能是要修改文件的屬性，或者訪問硬件。要修改文件屬性的話，就要用到這兩個結構體了，所以這里傳來了它們的指針。 cmd：命令，接下來會講 arg：參數，接下來會講

返回值： 如果傳入的非法命令，ioctl返回錯誤號-EINVAL。 內核中的驅動函數返回值都有一個默認的方法，只要是正數，內核就會傻乎乎的認為這是正確的返回，并把它傳給應用層，如果是負值，內核就會認為它是錯誤了。

ioctl的cmd cmd就是一個數，如果應用層傳來的數值在驅動中有對應的操作，那么就執行，就跟IBinder的transact方法中函數標識是一個道理. 要先定義個命令，就用一個簡單的0，來個命令的頭文件，驅動和應用函數都要包含這個頭文件：

/*test_cmd.h*/#ifndef _TEST_CMD_H#define _TEST_CMD_H#define TEST_CLEAR 0/*定義的cmd*/#endif /*_TEST_CMD_H*/

驅動實現ioctl： 命令TEST_CLEAR的操作就是清空驅動中的kbuf。

int test_ioctl (struct inode *node, struct file *filp, unsigned int cmd, uns igned long arg){ int ret = 0; struct _test_t *dev = filp->private_data; switch(cmd){case TEST_CLEAR:memset(dev->kbuf, 0, DEV_SIZE);dev->cur_size = 0;filp->f_pos = 0;ret = 0;break;default: /*命令錯誤時的處理*/P_DEBUG('error cmd!n');ret = - EINVAL;break; } return ret;}

然后在應用程序中調用ioctl(fd, TEST_CLEAR);就可以執行驅動程序中的清除kbuf的方法。

ioctl的arg ioctl命令還可以傳遞參數，應用層的ioctl(fd,cmd,...)后面的“...”是指可以傳任意類型的一個參數，注意是一個不是任意多個，只是不檢查類型。

binder初始化

我們了解ioctl之后就來看看Binder設備是怎么初始化的，這里介紹的是Binder設備，并不是Binder設備驅動程序，Binder驅動程序是misc設備驅動，要想了解Binder驅動程序的內容，請點擊下面鏈接。

gityuan.com/2015/11/01/…

我們的系統服務創建的過程中，要創建打開Binder設備，下面是具體過程。 我們先來介紹下frameworks/native/libs/binder/ProcessState.cpp，ProcessState用來儲存當前進程的各種信息，系統服務啟動時會創建當前進程的ProcessState單例對象。

ProcessState::ProcessState() //打開binder : mDriverFD(open_driver()) // //映射內存的起始地址 , mVMStart(MAP_FAILED) , mThreadCountLock(PTHREAD_MUTEX_INITIALIZER) , mThreadCountDecrement(PTHREAD_COND_INITIALIZER) , mExecutingThreadsCount(0) , mMaxThreads(DEFAULT_MAX_BINDER_THREADS) , mStarvationStartTimeMs(0) , mManagesContexts(false) , mBinderContextCheckFunc(NULL) , mBinderContextUserData(NULL) , mThreadPoolStarted(false) , mThreadPoolSeq(1){ if (mDriverFD >= 0) {//分配虛擬地址空間，完成數據wirte/read，內存的memcpy等操作就相當于write/read(mDriverFD)mVMStart = mmap(0, BINDER_VM_SIZE, PROT_READ, MAP_PRIVATE | MAP_NORESERVE, mDriverFD, 0);if (mVMStart == MAP_FAILED) { close(mDriverFD); mDriverFD = -1;} }}

對于一個不懂C++的我，看起來其實挺難受的，但是這段代碼很重要，還是要看懂的。 其實我們只需要關注這幾行重要代碼 open_driver() 下面會講 mVMStart = mmap(0, BINDER_VM_SIZE, PROT_READ, MAP_PRIVATE | MAP_NORESERVE, mDriverFD, 0) 分配虛擬內存映射 我們先來看open_driver函數

static int open_driver(){ int fd = open('/dev/binder', O_RDWR | O_CLOEXEC); //打開 /dev/binder if (fd >= 0) {int vers = 0;//通過ioctl通知binder驅動binder版本status_t result = ioctl(fd, BINDER_VERSION, &vers);if (result == -1) { ALOGE('Binder ioctl to obtain version failed: %s', strerror(errno)); close(fd); fd = -1;}if (result != 0 || vers != BINDER_CURRENT_PROTOCOL_VERSION) { ALOGE('Binder driver protocol does not match user space protocol!'); close(fd); fd = -1;}//設置當前fd最多支持DEFAULT_MAX_BINDER_THREADS線程數量size_t maxThreads = DEFAULT_MAX_BINDER_THREADS;result = ioctl(fd, BINDER_SET_MAX_THREADS, &maxThreads);if (result == -1) { ALOGE('Binder ioctl to set max threads failed: %s', strerror(errno));} } else {ALOGW('Opening ’/dev/binder’ failed: %sn', strerror(errno)); } return fd;}

首先執行int fd = open('/dev/binder', O_RDWR | O_CLOEXEC); 獲取到了驅動文件的文件描述符。 文件打開成功之后，使用ioctl查詢了版本號，并設置了最大的連接線程數。 然后調用mVMStart = mmap(0, BINDER_VM_SIZE, PROT_READ, MAP_PRIVATE | MAP_NORESERVE, mDriverFD, 0)把/dev/binder文件映射到了進程虛擬內存空間，這里我們還要了解下linux的mmap函數。

mmap參考自：blog.itpub.net/7728585/vie…

在LINUX中我們可以使用mmap用來在進程虛擬地址空間中分配創建一片虛擬內存地址映射

我們可以在當前進程的虛擬內存中獲得一塊映射區域，我們直接操作映射區域就可以間接操作內核中的文件。 我們使用mmap的目的是創建共享文件映射

進程都有一份文件映射，并且都指向同一個文件，這樣就實現了共享內存，Binder就是利用這種共享內存方式去進行數據的交互。每個進程都會保留一份dev/binder設備的映射區域，這樣我們利用Binder，數據經過一次拷貝就可以實現跨進程，Linux的管道機制則需要四次拷貝

總結

1、介紹了Binder在Android中的使用方式 2、Binder機制原理，用戶進程隔離，借助內核空間進行IPC 3、使用ioctl系統調用函數，調用Binder設備驅動程序，完成IPC調用 4、dev/binder是Binder機制中的虛擬設備，利用Binder驅動可以操作該設備（數據交互） 5、mmap指令可以創建進程虛擬內存映射空間，映射dev/binder文件，實現共享內存，Binder一次拷貝原理

以上就是Android Binder的原理與使用的詳細內容，更多關于Android Binder的資料請關注好吧啦網其它相關文章！