Android Binder 修炼之道(二)Client Server 实例

前面一节,分析了 Binder 系统中的骨架,了解了 Client ServiceManager Server 三者之间的关系,重点针对 ServiceManager 分析了服务的注册过程以及查询过程。本节,将重点放在实现一个简单的 Server 和 Client ,加深对于代码的理解。
首先是 Server:
我们要向 ServiceManager 注册 1 个 calculate 服务,这个服务有两个功能,一个加 1,一个减 1

#ifndef _TEST_SERVER_H
#define _TEST_SERVER_H
#define SVR_CMD_ADD_ONE         0
#define SVR_CMD_REDUCE_ONE      1
#endif // _TEST_SERVER_H
/* Copyright 2008 The Android Open Source Project
 */
#include
#include
#include
#include
#include
#include
#include
#include "binder.h"
#include "test_server.h"
首先来看 main 函数
int main(int argc, char **argv)
{
    int fd;
    struct binder_state *bs;
    uint32_t svcmgr = BINDER_SERVICE_MANAGER;
    uint32_t handle;
    int ret;
    /* 打开 binder 驱动 */
    bs = binder_open(128*1024);
    if (!bs) {
        fprintf(stderr, "failed to open binder driver\n");
        return -1;
    }
    /* 注册服务,最后一个参数不知道干啥用,先随便写 */
    ret = svcmgr_publish(bs, svcmgr, "calculate", (void *)123);
    if (ret) {
        fprintf(stderr, "failed to publish calculate service\n");
        return -1;
    }
    /* 陷入循环,等待 Client 上钩 */
    binder_loop(bs, service_handler);
    return 0;
}
看注册服务函数:
int svcmgr_publish(struct binder_state *bs, uint32_t target, const char *name, void *ptr)
{
    int status;
    unsigned iodata[512/4];
    struct binder_io msg, reply;
    
    /* 构造 binder_io */
    bio_init(&msg, iodata, sizeof(iodata), 4);
    bio_put_uint32(&msg, 0);  // strict mode header
    bio_put_string16_x(&msg, SVC_MGR_NAME);
    bio_put_string16_x(&msg, name);
    
    /* 暂时不知道干啥用的 */
    bio_put_obj(&msg, ptr);
    if (binder_call(bs, &msg, &reply, target, SVC_MGR_ADD_SERVICE))
        return -1;
    status = bio_get_uint32(&reply);
    
    /* 这个也不太清楚 */
    binder_done(bs, &msg, &reply);
    return status;
}
构造 binder_io 的时候先放入了一个 0 ,然后将ServiceManager的名字填充进去,最后把要注册的服务的名字注册进去,然后调用 binder_call 去访问 ServiceManager 的 addService 函数。不搭理那句 bio_put_obj 的话,注册服务的实质就是告诉 ServiceManager 一个服务的名字而已,仅此而已。
注册完两个服务,那么就要等待 Client 上钩,发送数据给我们处理了:
int service_handler(struct binder_state *bs,
                   struct binder_transaction_data *txn,
                   struct binder_io *msg,
                   struct binder_io *reply)
{
    /* 根据txn->code知道要调用哪一个函数
     * 如果需要参数, 可以从msg取出
     * 如果要返回结果, 可以把结果放入reply
     */
    uint32_t n,result;
    char name[512];
    size_t len;
    uint32_t handle;
    uint32_t strict_policy;
    int i;
    // Binder 通信的时候都会先塞个0进去,取数据的一方要先把这个0取出来
    strict_policy = bio_get_uint32(msg);
    switch(txn->code) {
    case SVR_CMD_ADD_ONE:
        /* 从msg里取出要处理的数据,并调用处理函数处理 */
        n = bio_get_uint32(msg);
        result = addone(n);
        /* 把结果放入reply */
        bio_put_uint32(reply, result);
        return 0;
    case SVR_CMD_REDUCE_ONE:
        /* 从msg里取出要处理的数据,并调用处理函数处理 */
        n = bio_get_uint32(msg);
        result = reduceone(n);
        /* 把结果放入reply */
        bio_put_uint32(reply, result);
        return 0;
    default:
        fprintf(stderr, "unknown code %d\n", txn->code);
        return -1;
    }
    return 0;
}
这里会产生一个疑问,回复的数据放入 reply 就可以了吗?不需要发送出去?答案是肯定的,你只需要放入 reply 即可了,bind_loop 中会帮你发送出去,看一眼代码踏实:
res = func(bs, txn, &msg, &reply);
binder_send_reply(bs, &reply, txn->data.ptr.buffer, res);
可以看出,调用我们的处理函数之后,紧接着就是发送回复的数据。
至于这俩函数,不必多说啥
uint32_t addone(uint32_t n)
{
        fprintf(stderr, "i am server,add one %d\n", n);
        return ++n;
}
uint32_t reduceone(uint32_t n)
{
        fprintf(stderr, "i am server,reduce one %d\n", n);
        return --n;
}

下面来看 Client 程序:
明确 Client 要干的事情,我有一个数,我想知道它加1是多少,减1是多少,但是自己不会算,得找个服务商算一算。算之前,得找个中介查查,哪个服务商能提供这个服务。Server 进程相当于服务商,他提供 calculate 服务。
#include
#include
#include
#include
#include
#include
#include
#include "binder.h"
#include "test_server.h"
struct binder_state *g_bs;
uint32_t g_handle;
int main(int argc, char **argv)
{
    int fd;
    struct binder_state *bs;
    uint32_t svcmgr = BINDER_SERVICE_MANAGER;
    uint32_t handle;
    int ret;
    /* 一样的,先打开 Binder 驱动 */
    bs = binder_open(128*1024);
    if (!bs) {
        fprintf(stderr, "failed to open binder driver\n");
        return -1;
    }
    g_bs = bs;
    /* 查询服务,获得服务 handle */
    handle = svcmgr_lookup(bs, svcmgr, "calculate");
    if (!handle) {
        fprintf(stderr, "failed to get addone service\n");
        return -1;
    }
    g_handle = handle;
    /* send data to server */
    if (!strcmp(argv[1], "a")) {
        ret = addone(atoi(argv[2]));
        fprintf(stderr, "get ret of addone= %d\n", ret);
    } else if (!strcmp(argv[1], "r")) {
        ret = reduceone(atoi(argv[2]));
        fprintf(stderr, "get ret of reduceone= %d\n", ret);
    }
    /* Client 使用完就释放服务 */
    binder_release(bs, handle);
    return 0;
}
uint32_t svcmgr_lookup(struct binder_state *bs, uint32_t target, const char *name)
{
    uint32_t handle;
    unsigned iodata[512/4];
    struct binder_io msg, reply;
    /* 构造 binder_io 参数是想要获取 service 的名字 */
    bio_init(&msg, iodata, sizeof(iodata), 4);
    bio_put_uint32(&msg, 0);  // strict mode header
    bio_put_string16_x(&msg, SVC_MGR_NAME);
    bio_put_string16_x(&msg, name);
    
    /* 查询服务是否存在 */
    if (binder_call(bs, &msg, &reply, target, SVC_MGR_CHECK_SERVICE))
        return 0;
    
    /* 得到服务的 handle */
    handle = bio_get_ref(&reply);
    
    /* 申请服务,用完 release */
    if (handle)
        binder_acquire(bs, handle);
    binder_done(bs, &msg, &reply);
    return handle;
}
int addone(int n)
{
    unsigned iodata[512/4];
    struct binder_io msg, reply;
    int ret;
    /* 构造binder_io */
    bio_init(&msg, iodata, sizeof(iodata), 4);
    bio_put_uint32(&msg, 0);  // strict mode header
    /* 放入参数 */
    bio_put_uint32(&msg, n); 
    /* 调用binder_call */
    if (binder_call(g_bs, &msg, &reply, g_handle, SVR_CMD_ADD_ONE))
        return;
    /* 从reply中解析出返回值 */
    ret = bio_get_uint32(&reply);
    binder_done(g_bs, &msg, &reply);
    return ret;
}
int reduceone(int n)
{
    unsigned iodata[512/4];
    struct binder_io msg, reply;
    int ret;
    /* 构造binder_io */
    bio_init(&msg, iodata, sizeof(iodata), 4);
    bio_put_uint32(&msg, 0);  // strict mode header
    /* 放入参数 */
    bio_put_uint32(&msg, n);
    /* 调用binder_call */
    if (binder_call(g_bs, &msg, &reply, g_handle, SVR_CMD_REDUCE_ONE))
        return 0;
    /* 从reply中解析出返回值 */
    ret = bio_get_uint32(&reply);
    binder_done(g_bs, &msg, &reply);
    return ret;
}
编译:
运行:

 

Android Binder 修炼之道(二)Client Server 实例_第1张图片 
不要忘了我们忽略了一个问题,bio_put_obj(&msg, ptr);这个东西是干嘛的?

前面的例子中,我们的 Server 只提供了一个 calculate 服务,如果这个服务商业务比较广,他还能提供查水表服务,那么Server的代码该如何写?
在我们的代码中只有一个服务处理函数,通过binder_loop来处理client的需求,binder_loop(bs, service_handler);
分析 binder_loop 的代码不难发现,这个 Server 进程只要有数据进来,就会调用 service_handler ,至于 client 访问的是哪个服务,该怎样区别对待,就需要用到前面忽略的 ptr 了。
首先,service_handler 作为进程数据的总入口,它有一个参数,binder_transaction_data
struct binder_transaction_data {
        union {
                __u32 handle;        /* target descriptor of command transaction */
                binder_uintptr_t ptr; /* target descriptor of return transaction */
        } target;
        ...
}
我们可以通过 ptr 来区分是哪个服务被调用,从而调用该服务的处理函数,那么ptr是什么东西?是服务处理函数的函数指针。
binder_loop(bs, main_server_handler);
int main_server_handler(struct binder_state *bs,
                   struct binder_transaction_data *txn,
                   struct binder_io *msg,
                   struct binder_io *reply)
{
        int (*handler)(struct binder_state *bs,
                   struct binder_transaction_data *txn,
                   struct binder_io *msg,
                   struct binder_io *reply);
        handler = (int (*)(struct binder_state *bs,
                   struct binder_transaction_data *txn,
                   struct binder_io *msg,
                   struct binder_io *reply))txn->target.ptr;
        return handler(bs, txn, msg, reply);
}
写一个 main_server_handler 作为总入口,然后根据其传入的函数指针调用处理函数,也就是 calculate 或 查水表的服务函数
那么这个函数指针 Binder 系统是如何知道的呢?它怎么能知道一个服务对应处理函数的函数指针是多少?这就需要在注册服务的同时,传入这个函数指针。
ret = svcmgr_publish(bs, svcmgr, "calculate", calculate_service_handler);
ret = svcmgr_publish(bs, svcmgr, "chashuibiao", chashuibiao_service_handler);


你可能感兴趣的:(Android)