Binder c++代码

最新推荐文章于 2022-03-20 01:40:28 发布

kc专栏

最新推荐文章于 2022-03-20 01:40:28 发布

阅读量1.7k

点赞数 2

分类专栏： android Binder机制文章标签： Binder

本文链接：https://blog.csdn.net/kc58236582/article/details/45919201

版权

android Binder机制专栏收录该内容

7 篇文章 1 订阅

订阅专栏

这篇博客主要看一下binder的一些实现，以及自己写一个实例：

Binder中service组件和client组件分别使用模板类BnInterface和BpInterface来描述，前者为Binder的本地对象，后者为代理对象。

// ----------------------------------------------------------------------

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();
};

// ----------------------------------------------------------------------

template<typename INTERFACE>
class BpInterface : public INTERFACE, public BpRefBase
{
public:
                                BpInterface(const sp<IBinder>& remote);

protected:
    virtual IBinder*            onAsBinder();
};

模板参数INTERFACE是一个由进程自定义的的接口，Bninterface和BpInterface都需要实现该接口，自己必须实现Bninterface和BpInterface这两个类

下面是自己实现的一个.h文件

class IExampleService : public IInterface
{
    public:
    DECLARE_META_INTERFACE(ExampleSercie);
    virtual int get () = 0;
    virtual void set (int value) = 0;
}
class BnExampleService : public BnInterface<IExampleService>//这边的模板其实对应上面的定义，就是继承这个接口类而已
{
        virtual status_t    onTransact( uint32_t code,
                                    const Parcel& data,
                                    Parcel* reply,
                                    uint32_t flags = 0);
}

对应实现一个.cpp文件，Bp和Bn的实现在一个文件中，但是实际上是在两个进程中，两个类都要实现IExampleService中的方法

enum {
    EXAMPLE_GET = IBinder::FIRST_CALL_TRANSACTION,
    EXAMPLE_SET,
};
class BpExampleService : public BpInterface<IExampleService>
{
public:
    virtual int get()
    {
        Parcel data, reply;
        data.writeInterfaceToken(IExampleService::getInterfaceDescriptor());
        remote()->transact(EXAMPLE_GET, data, &reply);
        return reply.readInt();
    }
    virtual void set(int value)
    {
        Parcel data, reply;
        data.writeInterfaceToken(IExampleService::getInterfaceDescriptor());
        data.writeInt(value);
        remote()->transact(EXAMPLE_SET, data, &reply);
        return;
    }
};
IMPLEMENT_META_INTERFACE(ExampleService, "ExampleDescriptor");

status_t BnExampleService::onTransact(uint32_t code,
                                    const Parcel& data,
                                    Parcel* reply,
                                    uint32_t flags)
{
    switch(code) {
        case EXAMPLE_GET:
            CHECK_INTERFACE(IExampleService, data, &reply);
            reply->writeInt(get());
            break;
        case EXAMPLE_SET:
            CHECK_INTERFACE(IExampleService, data, &reply);
            set(data->readInt());
            break;
        default:
            return BBinder::onTransact(code,data,reply,flags);
    }
    return NO_ERROR;
}

最后实现service，ExampleService需要继承BnExampleService，并实现虚函数，添加一个instantiate函数将当前service加入到servicemanager中。

class ExampleService : pulic BnExampleService
{
public:
    ExampleService ():mValue(0);
    public int get() {return mValue};
    public void set (int value) { mValue = value;}
    public static void instantiate() {
        defaultServiceManager()->addService(String16("example"), new ExampleService());
    }
private:
    int mValue;
    
}

Bninterface类继承了BBinder，定义如下：

class BBinder : public IBinder
{
public:
    .....

    virtual status_t    transact(   uint32_t code,
                                    const Parcel& data,
                                    Parcel* reply,
                                    uint32_t flags = 0);

protected:
    ......

    virtual status_t    onTransact( uint32_t code,
                                    const Parcel& data,
                                    Parcel* reply,
                                    uint32_t flags = 0);
    ......
};

当有一个Binder代理对象(客户端）通过binder驱动程序向一个binder本地对象（server端）发出一个进程间通信请求时，Binder驱动程序就会调用该Binder本地对象的成员函数tracsact来处理该请求。onTransact由子类实现，负责分发与业务相关的进程间通信请求，我们的例子中在BnExampleService实现了该函数，负责处理进程间发送过来的请求。

class BpRefBase : public virtual RefBase
{
protected:
                            BpRefBase(const sp<IBinder>& o);
    virtual                 ~BpRefBase();
........

    inline  IBinder*        remote()                { return mRemote; }
    inline  IBinder*        remote() const          { return mRemote; }

private:
........

    IBinder* const          mRemote;
......
};

mRemote指向一个BpBinder对象，可以通过remote函数来获取

class BpBinder : public IBinder
{
public:
                        BpBinder(int32_t handle);

    inline  int32_t     handle() const { return mHandle; }
......

    virtual status_t    transact(   uint32_t code,
                                    const Parcel& data,
                                    Parcel* reply,
                                    uint32_t flags = 0);
......
private:
    const   int32_t             mHandle;
....
};

BpBinder类的成员变量mHandle表示一个client组件的句柄，可以通过handle函数获取，它是binder驱动程序中一个client的binder引用对象，client组件通过这个句柄和binder对象引用对象建立对应关系。

BpBinder类的transact用来向运行在server进程中的service组件发送进程间通信请求，通过binder驱动实现。transact会把mHandle，以及通信数据发送给binder驱动，这样驱动可以根据这个句柄值找到对应的binder引用对象，然后找到binder实体对象，最后把通信数据发给对应的service组件。

无论是BBinder，BpBinder同事通过IPCThreadState类和binder驱动交互的。

class IPCThreadState
{
public:
    static  IPCThreadState*     self();
.......
            status_t            transact(int32_t handle,
                                         uint32_t code, const Parcel& data,
                                         Parcel* reply, uint32_t flags);
    
private:
.....
            status_t            talkWithDriver(bool doReceive=true);
....
    const   sp<ProcessState>    mProcess;
....
};

每一个使用binder的进程都有一个binder线程池，用来处理进程通信请求。每个binder线程，内部都有一个IPCThreaState对象，可以通过self获取，transact函数和binder驱动交互，在transact函数内部调用talkwithDriver来实现，它一方面负责向binder驱动发送通信请求，一方面接受binder驱动通信请求。

IPCThreadState类有一个mProcess，指向ProcessState对象。对于每个使用binder的进程，内部都有一个ProcessState对象，负责初始化Binder设备，即打开设备文件/dev/binder，以及将设备文件/dev/binder映射到进程的地址空间。由于ProcessState对象在进程唯一，binder线程池中每一线程都可以通过它与驱动程序连接。

class ProcessState : public virtual RefBase
{
public:
    static  sp<ProcessState>    self();
....

private:

            int                 mDriverFD;
            void*               mVMStart;
....
};

进程中可以通过self函数获取ProcessState 对象，第一次调用创建一个对象，并且打开设备文件/dev/binder，然后调用函数mmap将它映射到进程的地址空间，即请求binder驱动为进程分配内核缓冲区。得到的内核缓冲区的用户地址保存在mVMStart中。

前面实例中有两个宏还没有分析

#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 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() { }

其中就是实现自己的IExample一些固定接口，这边主要看下asInterface这个函数，IBinder中有两个接口，localBinder，remoteBinder，localBinder指的是Binder实体对象，remoteBInder指的是引用对象。

对于服务进程，localBinder有意义，remoteBinder没有意义。在客户端就相反，remoteBinder有意义。因此在asInterface中，querLocalInterface返回为空代表是在客户端，因此需要new Bp##INTERFACE对象。即BpBinder没有重载querLocalInterface这函数，返回为null

下面我们实现service进程的主函数。

int main()
{
    ExampleService::instantiate();//将service加入到serviceManager中
    
    processState::self()->startThreadPool();//开启了一个线程读取binder请求
    IPCThreadState::self()->joinThreadPool();//主线程joinThreadPool读取binder请求，因此有两个binder线程。
    return 0;
}

最后我们看看客户端如何通过binder跨进程通信，调用接口。

int main()
{
    sp<IBinder> binder = defaultServiceManager()->getService(string16("example"));
    if (binder == null)
    {
        LOGE("failed");
        return -1;
    }
    
    sp<IExampleService> service = IExampleService::asInterface(binder);//将IBinder转换成
    int value = service->get();
    printf("%d", value);
}

binder c++的分析完了，后面分析下java的binder原理。

kc专栏

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Binder c++代码

这篇博客主要看一下binder的一些实现，以及自己写一个实例：Binder中service组件和client组件分别使用模板类BnInterface和BpInterface来描述，前者为Binder的本地对象，后者为代理对象。// ----------------------------------------------------------------------templat
复制链接

扫一扫