RPC原理图
Binder C语言层的Demo演示
新建目录
把两个文件拷贝到我们的Demo下面
1.binder_server.c
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <linux/types.h>
#include <stdbool.h>
#include <string.h>
#include "binder.h"
#define LOG_TAG "BinderServer"
#include <log/log.h>
#define HELLO_BINDER 1
#define HELLO_BINDER_TO 2
//服务就是被调用的函数
void hellobinder(void)
{
static int cnt = 0;
ALOGW("hello : %d\n", ++cnt);
}
int hellobinder_to(char *name)
{
static int cnt = 0;
ALOGW("hello to %s : %d\n", name, ++cnt);
return cnt;
}
//回调函数
int hellobinder_service_handler(struct binder_state *bs,
struct binder_transaction_data_secctx *txn_secctx,
struct binder_io *msg,
struct binder_io *reply)
{
struct binder_transaction_data *txn = &txn_secctx->transaction_data;
/* 根据txn->code知道要调用哪一个函数
* 参数, 从msg取出
* 返回结果, 把结果放入reply
*/
/* sayhello
* sayhello_to
*/
uint16_t *s;
char name[512];
size_t len;
//uint32_t handle;
uint32_t strict_policy;
int i;
// Equivalent to Parcel::enforceInterface(), reading the RPC
// header with the strict mode policy mask and the interface name.
// Note that we ignore the strict_policy and don't propagate it
// further (since we do no outbound RPCs anyway).
strict_policy = bio_get_uint32(msg);
//code 用于判断我们需要调用哪一个函数，客户端远程调用哪个服务端函数
switch(txn->code) {
case HELLO_BINDER:
hellobinder();
//给reply写一个值为0
bio_put_uint32(reply, 0); /* no exception */
return 0;
case HELLO_BINDER_TO:
/* 从msg里取出字符串 */
s = bio_get_string16(msg, &len); //"IHelloService"
s = bio_get_string16(msg, &len); // name
if (s == NULL) {
return -1;
}
for (i = 0; i < len; i++)
name[i] = s[i];
name[i] = '\0';
/* 处理 */
i = hellobinder_to(name);
/* 把结果放入reply 给回客户端*/
bio_put_uint32(reply, 0); /* no exception */
bio_put_uint32(reply, i);
break;
default:
fprintf(stderr, "unknown code %d\n", txn->code);
return -1;
}
return 0;
}
// 进程的 Binder 回调函数
//binder_transaction_data_secctx主要的数据，msg客户端传递过来的函数的参数，reply返回给客户端的数据
int test_server_handler(struct binder_state *bs,
struct binder_transaction_data_secctx *txn_secctx,
struct binder_io *msg,
struct binder_io *reply)
{
//取出数据，
struct binder_transaction_data *txn = &txn_secctx->transaction_data;
//函数指针，
int (*handler)(struct binder_state *bs,
struct binder_transaction_data *txn,
struct binder_io *msg,
struct binder_io *reply);
// txn->target.ptr 是 svcmgr_publish 传入的第二个参数
handler = (int (*)(struct binder_state *bs,
struct binder_transaction_data *txn,
struct binder_io *msg,
struct binder_io *reply))txn->target.ptr;
//调用函数指针，那么就会调用txn->target.ptr;这个指针，那么就是hellobinder_service_handler
return handler(bs, txn, msg, ，reply);
}
int main(int argc, char **argv)
{
struct binder_state *bs;
//值为 0
uint32_t svcmgr = BINDER_SERVICE_MANAGER;
uint32_t handle;
int ret;
//初始化驱动
bs = binder_open("/dev/binder", 128*1024);
if (!bs) {
fprintf(stderr, "failed to open binder driver\n");
return -1;
}
//添加服务hellobinder_service_handler 是 hello 服务对应的回调函数
//bs打开启动返回的一个int值，句柄，svcmgr表示把数据发到这个进程中，是ServiceManager，hello是注册的服务的名字
//当我们注册的时候把这个hellobinder_service_handler指针传给驱动，驱动就记住hello服务回调是它，客户端需要调用hello服务的时候
ret = svcmgr_publish(bs, svcmgr, "hello", hellobinder_service_handler);
if (ret) {
fprintf(stderr, "failed to publish hello service\n");
return -1;
}
//test_server_handler 进程的 Binder 回调函数，进入循环服务端就不会挂掉，一直执行
//binder收到数据，就解析，解析好就传给test_server_handler
binder_loop(bs, test_server_handler);
return 0;
}
binder_transaction_data_secctx
主要的数据结构是在这里
2.binder_client.c
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <linux/types.h>
#include <stdbool.h>
#include <string.h>
#include "binder.h"
#define HELLO_BINDER 1
#define HELLO_BINDER_TO 2
int g_handle = 0;
struct binder_state *g_bs;
void sayhello(void)
{
unsigned iodata[512/4];
struct binder_io msg, reply;
/* 构造binder_io */
//初始化msg数据，表示的是所调用的服务端函数所需的参数
bio_init(&msg, iodata, sizeof(iodata), 4);
/* 放入参数 */
//把数据写入msg中
bio_put_uint32(&msg, 0); // strict mode header
bio_put_string16_x(&msg, "IHelloService");
/* 调用binder_call */
//发起远程调用，g_bs是binder_open返回的一个句柄，msg函数的参数，reply服务端返回值，g_handle是hello服务在客户端的一个句柄索引，通过它才能找到对应的服务端，HELLO_BINDER是code，表示要调用服务端的哪个函数
if (binder_call(g_bs, &msg, &reply, g_handle, HELLO_BINDER))
return ;
/* 从reply中解析出返回值 */
//解析服务端返回的数据
binder_done(g_bs, &msg, &reply);
}
int main(int argc, char **argv)
{
int fd;
struct binder_state *bs;
uint32_t svcmgr = BINDER_SERVICE_MANAGER;
int ret;
bs = binder_open("/dev/binder", 128*1024);
if (!bs) {
fprintf(stderr, "failed to open binder driver\n");
return -1;
}
g_bs = bs;
/* get service 查找服务，bs是binder_open的返回值，svcmgr是servicemanager表示数据要发送给它，hello是查找服务的名字*/
//g_handle句柄，索引
g_handle = svcmgr_lookup(bs, svcmgr, "hello");
if (!g_handle) {
return -1;
}
//调用服务，发起远程调用
sayhello();
}
编写bp文件
cc_defaults {
name: "bindertestflags",
cflags: [
"-Wall",
"-Wextra",
"-Werror",
"-Wno-unused-parameter",
"-Wno-missing-field-initializers",
"-Wno-unused-parameter",
"-Wno-unused-variable",
"-Wno-incompatible-pointer-types",
"-Wno-sign-compare",
],
product_variables: {
binder32bit: {
cflags: ["-DBINDER_IPC_32BIT=1"],
},
},
shared_libs: ["liblog"],
}
//c的可执行程序
cc_binary {
name: "binderclient",
defaults: ["bindertestflags"],
vendor: true,
srcs: [
"binder_client.c",
"binder.c",
],
}
cc_binary {
name: "binderserver",
defaults: ["bindertestflags"],
vendor: true,
srcs: [
"binder_server.c",
"binder.c",
],
}
// cc_binary {
// name: "myservicemanager",
// defaults: ["mybindertest_flags"],
// srcs: [
// "service_manager.c",
// "binder.c",
// ],
// shared_libs: ["libcutils", "libselinux"],
// }
把编译出来的两个二进制文件push到设备中测试
看到hello已经被调用了说明跨进程通信成功了