Android Binder 修煉之道（三）Binder 系統C++實現 BpXXX代理類分析

    在 Binder 系統中，分爲 Client ServiceManager Server 三部分，C++是面向對象的語言，因此，這三者對應三個類的實例。ServiceManager 由 Android系統實現，我們只需要實現我們自己的　client 和 Server 類即可。

    在 Binder 系統 C 的實現中，我們的 Client 和 Server 都實現了 sddone 和 reduceone 函數，名稱一樣，內容不一樣，因此在 C++ 中，將這些函數統一封裝成一個接口類 ICalculateService ，放在 ICalculateService.h 中。

/* 參考: frameworks\av\include\media\IMediaPlayerService.h */
#ifndef ANDROID_ICALCULATESRVICE_H
#define ANDROID_ICALCULATESRVICE_H
#include <utils/Errors.h>  // for status_t
#include <utils/KeyedVector.h>
#include <utils/RefBase.h>
#include <utils/String8.h>
#include <binder/IInterface.h>
#include <binder/Parcel.h>
#define SVR_CMD_ADD_ONE     0
#define SVR_CMD_REDUCE_ONE  1
namespace android {
class ICalculateService: public IInterface
{
public:
    DECLARE_META_INTERFACE(CalculcateService);
    virtual void addone(int n) = 0;
    virtual int reduceone(int n) = 0;
};
class BnCalculateService: public BnInterface<ICalculateService>
{
public:
    virtual status_t    onTransact( uint32_t code,
                                    const Parcel& data,
                                    Parcel* reply,
                                    uint32_t flags = 0);
    virtual void addone(int n);
    virtual int reduceone(int n);
};
}
#endif



template<typename INTERFACE>
class BnInterface : public INTERFACE, public BBinder
{
public:
    virtual sp<IInterface>      queryLocalInterface(const String16& _descriptor);
    virtual const String16&     getInterfaceDescriptor() const;
protected:
    virtual IBinder*            onAsBinder();
};

    可以看到，這個ICalculateService接口非常簡單，定義了兩個純虛函數，所謂的純虛函數就是作爲標準接口，在子類中實現。

同時可以看到，這裏還定義了一個 BnCalculateService ，它就是我們的 Server ，這個 BnCalculateService 繼承自 BnInterface
模板類ICalculateService 類 和 BBinder 類，BBinder 繼承自 IBindre，他們都是抽象類，其中 onTransact 就是在 BBinder 類中定義的。

    BnCalculateService 的意思是 Binder native Calculate Service ，函數實現放在：BnCalculateService.cpp 中

/* 參考: frameworks\av\media\libmedia\IMediaPlayerService.cpp */
#define LOG_TAG "CalculateService"
#include "ICalculateService.h"
namespace android {
status_t BnCalculateService::onTransact( uint32_t code,
                                const Parcel& data,
                                Parcel* reply,
                                uint32_t flags)
{
    /* 解析數據,調用addone/reduceone */
    switch (code) {
        case SVR_CMD_ADD_ONE: {
            int32_t policy =  data.readInt32();
            int32_t n = data.readInt32();
            /* 把返回值寫入reply傳回去 */
            reply->writeInt32(result);
            
            return NO_ERROR;
        } break;
        
        case SVR_CMD_REDUCE_ONE: {
            /* 從data中取出參數 */
            int32_t policy =  data.readInt32();
            int32_t n = data.readInt32();
            /* 把返回值寫入reply傳回去 */
            reply->writeInt32(result);
            
            return NO_ERROR;
        } break;
        default:
            return BBinder::onTransact(code, data, reply, flags);
    }
}
int32_t BnCalculateService::addone(int32_t n)
{
    ALOGI("server add one : %d\n", cnt++);
    return ++n;
int32_t BnCalculateService::sayhello_to(int32_t n)
{
    ALOGI("server reduce one : %d\n", n);
    return --n;
}
}
定義好了這個 Server 類如何使用？



/* 參考: frameworks\av\media\mediaserver\Main_mediaserver.cpp */
#define LOG_TAG "HelloService"
//#define LOG_NDEBUG 0
#include <fcntl.h>
#include <sys/prctl.h>
#include <sys/wait.h>
#include <binder/IPCThreadState.h>
#include <binder/ProcessState.h>
#include <binder/IServiceManager.h>
#include <cutils/properties.h>
#include <utils/Log.h>
#include "ICalculateService.h"
using namespace android;
int main(void)
{
    /* addService */
    /* while(1){ read data, 解析數據, 調用服務函數 } */
    /* 打開驅動, mmap */
    sp<ProcessState> proc(ProcessState::self());
    /* 獲得BpServiceManager */
    sp<IServiceManager> sm = defaultServiceManager();
    sm->addService(String16("calculate"), new BnCalculateService());
    /* 循環體 */
    ProcessState::self()->startThreadPool();
    IPCThreadState::self()->joinThreadPool();
    return 0;
}



下面來看 Client

/* 參考: frameworks\av\media\libmedia\IMediaPlayerService.cpp */
#include "ICalculateService.h"
namespace android {
class BpCalculateService: public BpInterface<ICalculateService>
{
public:
    BpCalculateService(const sp<IBinder>& impl)
        : BpInterface<ICalculateService>(impl)
    {
    }
    int addone(int n)
    {
        Parcel data, reply;
        data.writeInt32(0);
        data.writeInt32(n);
        remote()->transact(SVR_CMD_REDUCE_ONE, data, &reply);
        return reply.readInt32();
    }
    
    int reduceone(int n)
    {
        /* 構造/發送數據 */
        Parcel data, reply;
        data.writeInt32(0);
        data.writeInt32(n);
        remote()->transact(SVR_CMD_REDUCE_ONE, data, &reply);
        return reply.readInt32();
    }
};
IMPLEMENT_META_INTERFACE(CalculateService, "android.media.ICalculateService");
}








#define LOG_TAG "CalculateService"
//#define LOG_NDEBUG 0
#include <fcntl.h>
#include <sys/prctl.h>
#include <sys/wait.h>
#include <binder/IPCThreadState.h>
#include <binder/ProcessState.h>
#include <binder/IServiceManager.h>
#include <cutils/properties.h>
#include <utils/Log.h>
#include "ICalculateService.h"
using namespace android;
/* ./test_client hello
 * ./test_client hello <name>
 */
int main(int argc, char **argv)
{
    int cnt;
    
    if (argc < 2){
        ALOGI("Usage:\n");
        ALOGI("%s <hello|goodbye>\n", argv[0]);
        ALOGI("%s <hello|goodbye> <name>\n", argv[0]);
        return -1;
    }
    /* getService */
    /* 打開驅動, mmap */
    sp<ProcessState> proc(ProcessState::self());
    /* 獲得BpServiceManager */
    sp<IServiceManager> sm = defaultServiceManager();
    sp<IBinder> binder =
        sm->getService(String16("calculate"));
    if (binder == 0)
    {
        ALOGI("can't get calculate service\n");
        return -1;
    }
    /* service肯定是BpCalculateServie指針 */
    sp<ICalculateService> service =
        interface_cast<ICalculateService>(binder);
    /* 多態,調用Service的函數 */
    cnt = service->reduceone(argv[2]);
    ALOGI("client call reduceone, result = %d", cnt);
    
    return 0;
}

IBinder 如何轉換成 ICalculateService ?

template<typename INTERFACE>
inline sp<INTERFACE> interface_cast(const sp<IBinder>& obj)
{
    return INTERFACE::asInterface(obj);
}
可以看出，interface_cast 是個模板函數，在這，它將調用 ICalculateService::asInterface(binder)
asInterface 從哪來的？



class ICalculateService: public IInterface
{
public:
    DECLARE_META_INTERFACE(CalculcateService);
    virtual void addone(int n) = 0;
    virtual int reduceone(int n) = 0;
};


#define DECLARE_META_INTERFACE(INTERFACE)                               \
    static const android::String16 descriptor;                          \
    static android::sp<I##INTERFACE> asInterface(                       \
            const android::sp<android::IBinder>& obj);                  \
    virtual const android::String16& getInterfaceDescriptor() const;    \
    I##INTERFACE();                                                     \
    virtual ~I##INTERFACE(); 
實際是：



#define DECLARE_META_INTERFACE(INTERFACE)                               \
    static const android::String16 descriptor;                          \
    static android::sp<ICalculcateService> asInterface(                       \
            const android::sp<android::IBinder>& obj);                  \
    virtual const android::String16& getInterfaceDescriptor() const;    \
    ICalculcateService();                                                     \
    virtual ~ICalculcateService(); 

那個這個 asInterface 函數的實現在哪？

class BpCalculateService: public BpInterface<ICalculateService>
{
public:
    BpCalculateService(const sp<IBinder>& impl)
        : BpInterface<ICalculateService>(impl)
    {
    }
    int addone(int n)
    {
         ...
    }
    
    int reduceone(int n)
    {
         ...
    }
};
IMPLEMENT_META_INTERFACE(CalculateService, "android.media.ICalculateService");
}



#define IMPLEMENT_META_INTERFACE(INTERFACE, NAME)                       \
    const android::String16 I##INTERFACE::descriptor(NAME);             \
    const android::String16&                                            \
            I##INTERFACE::getInterfaceDescriptor() const {              \
        return I##INTERFACE::descriptor;                                \
    }                                                                   \
    android::sp<I##INTERFACE> I##INTERFACE::asInterface(                \
            const android::sp<android::IBinder>& obj)                   \
    {                                                                   \
        android::sp<I##INTERFACE> intr;                                 \
        if (obj != NULL) {                                              \
            intr = static_cast<I##INTERFACE*>(                          \
                obj->queryLocalInterface(                               \
                        I##INTERFACE::descriptor).get());               \
            if (intr == NULL) {                                         \
                intr = new Bp##INTERFACE(obj);                          \
            }                                                           \
        }                                                               \
        return intr;                                                    \
    }                                                                   \
    I##INTERFACE::I##INTERFACE() { }                                    \
    I##INTERFACE::~I##INTERFACE() { }    

替換完之後就是這個樣子：

#define IMPLEMENT_META_INTERFACE(INTERFACE, NAME)                       \
    const android::String16 ICalculcateService::descriptor(NAME);             \
    const android::String16&                                            \
            ICalculcateService::getInterfaceDescriptor() const {              \
        return ICalculcateService::descriptor;                                \
    }                                                                   \
    android::sp<ICalculcateService> ICalculcateService::asInterface(                \
            const android::sp<android::IBinder>& obj)                   \
    {                                                                   \
        android::sp<ICalculcateService> intr;                                 \
        if (obj != NULL) {                                              \
            intr = static_cast<ICalculcateService*>(                          \
                obj->queryLocalInterface(                               \
                        ICalculcateService::descriptor).get());               \
            if (intr == NULL) {                                         \
                intr = new BpCalculcateService(obj);                          \
            }                                                           \
        }                                                               \
        return intr;                                                    \
    }                                                                   \
    ICalculcateService::ICalculcateService() { }                                    \
    ICalculcateService::~ICalculcateService() { }    




sp<IInterface>  IBinder::queryLocalInterface(const String16& /*descriptor*/)
{
    return NULL;
}

因此，這裏直接返回的是，new BpCalculateService(binder)
也就是說 interface_cast<ICalculateService>(binder) 的最終結果 new BpCalculateService(binder)
binder 是通過 getService 構造的 BpBinder 對象的指針（BpBinder繼承自IBinder）
先不關心 binder 怎麼來的，先來看看如何用 binder(BpBinder)來構造BpXXXService
BpXXXService 繼承自 BpInterface<IXXXService> 繼承自 BpRefBase

BpRefBase::BpRefBase(const sp<IBinder>& o)
    : mRemote(o.get()), mRefs(NULL), mState(0)
{
    extendObjectLifetime(OBJECT_LIFETIME_WEAK);
    if (mRemote) {
        mRemote->incStrong(this);           // Removed on first IncStrong().
        mRefs = mRemote->createWeak(this);  // Held for our entire lifetime.
    }
}
o 是 binder ，o 是個智能指針，o.get() 返回這個指針所指向的對象的指針，也就是 mRemote 指向了 binder
也就是說 interface_cast<ICalculateService>(binder) 的最終結果,構造了一個 BpCalculateService 它裏邊的 mRemote 指向一個 BpBinder
binder 獲取的過程：





sp<IServiceManager> sm = defaultServiceManager();
    sp<IBinder> binder =
        sm->getService(String16("calculate"));

defaultServiceManager IServiceManager 類的接口，它的 getService 函數在 BpServiceManager 類中實現， 


    virtual sp<IBinder> getService(const String16& name) const
    {
        unsigned n;
        for (n = 0; n < 5; n++){
            sp<IBinder> svc = checkService(name);
            if (svc != NULL) return svc;
            ALOGI("Waiting for service %s...\n", String8(name).string());
            sleep(1);
        }
        return NULL;
    }
    virtual sp<IBinder> checkService( const String16& name) const
    {
        Parcel data, reply;
        data.writeInterfaceToken(IServiceManager::getInterfaceDescriptor());
        data.writeString16(name);
        remote()->transact(CHECK_SERVICE_TRANSACTION, data, &reply);
        return reply.readStrongBinder();
    }





sp<IBinder> Parcel::readStrongBinder() const
{
    sp<IBinder> val;
    unflatten_binder(ProcessState::self(), *this, &val);
    return val;
}


status_t unflatten_binder(const sp<ProcessState>& proc,
    const Parcel& in, sp<IBinder>* out)
{
    const flat_binder_object* flat = in.readObject(false);
    if (flat) {
        switch (flat->type) {
            case BINDER_TYPE_BINDER:
                *out = reinterpret_cast<IBinder*>(flat->cookie);
                return finish_unflatten_binder(NULL, *flat, in);
            case BINDER_TYPE_HANDLE:
                *out = proc->getStrongProxyForHandle(flat->handle);
                return finish_unflatten_binder(
                    static_cast<BpBinder*>(out->get()), *flat, in);
        }
    }
    return BAD_TYPE;
}




sp<IBinder> ProcessState::getStrongProxyForHandle(int32_t handle)
{
    sp<IBinder> result;
    AutoMutex _l(mLock);
    handle_entry* e = lookupHandleLocked(handle);
    IBinder* b = e->binder;
    if (b == NULL || !e->refs->attemptIncWeak(this)) {
        b = new BpBinder(handle); 
        e->binder = b;
        if (b) e->refs = b->getWeakRefs();
         result = b;
    } 

    
    return result;
}

getService 的過程：
構造數據發送數據，在 reply 中取出 handle，通過 handle 構造一個 BpBinder 對象，mHandle = handle
也就是說我們獲取服務的時候是得到了一個服務的 handle ，然後用這個 handle 構造對應的代理類，BpXXXService，在通過BpXXXService代理類的函數來訪問具體的服務。
前面說到，getService 函數也是在一個代理類中實現的，BpServiceManager 中，看看它是怎麼來的：

sp<IServiceManager> sm = defaultServiceManager();







sp<IServiceManager> defaultServiceManager()
{
    if (gDefaultServiceManager != NULL) return gDefaultServiceManager;
    
    {
        AutoMutex _l(gDefaultServiceManagerLock);
        while (gDefaultServiceManager == NULL) {
            gDefaultServiceManager = interface_cast<IServiceManager>(
                ProcessState::self()->getContextObject(NULL));
            if (gDefaultServiceManager == NULL)
                sleep(1);
        }
    }
    
    return gDefaultServiceManager;
}

剛開始的時候，gDefaultServiceManager 爲 NULL：
gDefaultServiceManager = interface_cast<IServiceManager>(ProcessState::self()->getContextObject(NULL));






sp<IBinder> ProcessState::getContextObject(const sp<IBinder>& /*caller*/)
{
    return getStrongProxyForHandle(0);//new BpBinder(0); 
}

也就是 interface_cast<IServiceManager>（new BpBinder(0)）
和前面分析的一樣，這裏應該是用 BpBinder（0）構造一個 BpServiceManager對象，BpServiceManager 中的 mRemote 指向 BpBinder(0)，mHandle = 0
 
總結：

訪問服務先需要構造代理類，通過 handle 構造 BpBinder，BpBinder 中的 mHandle = handle

通過 BpBinder 構造 BpXXX 代理類對象(代理類對象中的 mRemote 指向 BpBinder)然後付給一個接口類的指針，比如 IServiceManager 或者 IHelloService 

利用多態的特性，用父類指針比如 IServiceManager 或者 IHelloService，直接調用 BpXXX 中的函數訪問服務。




後面需要分析： 

    如何訪問服務的？

    BnXXXService 如何註冊服務的，收到消息如何處理的