Android Binder的原理與使用

前言

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;
        }
        //獲取本地interface
        IInterface 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);
        }

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

        /**
         * 處理Client調用請求
         */
        @Override
        public 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{

        @Override
        public void testVoidAidl() throws RemoteException {
            Log.d(TAG, "testVoidAidl");
        }

        @Override
        public 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: %s\n", 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的資料請關註WalkonNet其它相關文章!

推薦閱讀:

    None Found