Android : 跟我学Binder --- (5) C++实现
目录：
Android : 跟我学Binder --- (1) 什么是Binder IPC？为何要使用Binder机制？
Android : 跟我学Binder --- (2) AIDL分析及手动实现
Android : 跟我学Binder --- (3) C程序示例
Android : 跟我学Binder --- (4) 驱动情景分析
Android : 跟我学Binder --- (5) C++实现
Android : 跟我学Binder --- (6) JAVA实现
一、程序实现
参考文件:
frameworks\av\include\media\IMediaPlayerService.h (IMediaPlayerService,BnMediaPlayerService)
frameworks\av\media\libmedia\IMediaPlayerService.cpp (BpMediaPlayerService)
frameworks\av\media\libmediaplayerservice\MediaPlayerService.h
frameworks\av\media\libmediaplayerservice\MediaPlayerService.cpp
frameworks\av\media\mediaserver\Main_mediaserver.cpp (server, addService)
之前的代码结构是 test_server 向 service_manager 注册服务，test_client 通过 service_manager 获取服务并使用，服务的实现和数据解析都是在单一的.c文件中实现，接下来对程序框架进行改进，将服务具体函数抽离出来模块化实现，统一由头文件分别定义服务的接口： IHelloService.h 和 IGoodbyeService.h，然后cpp文件实现具体功能：server端为 BnHelloService.cpp 和 BnGoodbyeService.cpp，client端为 BpHelloService.cpp 和 BpGoodbyeService.cpp。
（1）接口定义：（I代表interface）
①IHelloService.h
/* 参考: frameworks\av\include\media\IMediaPlayerService.h */
#ifndef ANDROID_IHELLOERVICE_H
#define ANDROID_IHELLOERVICE_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 HELLO_SVR_CMD_SAYHELLO 1
#define HELLO_SVR_CMD_SAYHELLO_TO 2
#define HELLO_SVR_CMD_GET_FD 3 namespace android { class IHelloService: public IInterface
{
public:
DECLARE_META_INTERFACE(HelloService); //宏自动声明必须的接口
virtual void sayhello(void) = ;
virtual int sayhello_to(const char *name) = ;
virtual int get_fd(void) = ;
}; class BnHelloService: public BnInterface<IHelloService>
{
private:
int fd;
public:
virtual status_t onTransact( uint32_t code,
const Parcel& data,
Parcel* reply,
uint32_t flags = ); virtual void sayhello(void);
virtual int sayhello_to(const char *name);
virtual int get_fd(void); BnHelloService();
BnHelloService(int fd); };
} #endif
②IGoodbyeService.h
/* 参考: frameworks\av\include\media\IMediaPlayerService.h */ #ifndef ANDROID_IGOODBYEERVICE_H
#define ANDROID_IGOODBYEERVICE_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 GOODBYE_SVR_CMD_SAYGOODBYE 1
#define GOODBYE_SVR_CMD_SAYGOODBYE_TO 2 namespace android { class IGoodbyeService: public IInterface
{
public:
DECLARE_META_INTERFACE(GoodbyeService);
virtual void saygoodbye(void) = ;
virtual int saygoodbye_to(const char *name) = ;
}; class BnGoodbyeService: public BnInterface<IGoodbyeService>
{
public:
virtual status_t onTransact( uint32_t code,
const Parcel& data,
Parcel* reply,
uint32_t flags = ); virtual void saygoodbye(void);
virtual int saygoodbye_to(const char *name); };
} #endif
（2）功能实现：（B代表binder，n代表native-本地实现，p代表proxy-代理）
①BnHelloService.cpp
/* 参考: frameworks\av\media\libmedia\IMediaPlayerService.cpp */
#define LOG_TAG "HelloService"
#include "IHelloService.h"
namespace android {
BnHelloService::BnHelloService()
{
}
BnHelloService::BnHelloService(int fd)
{
this->fd = fd;
}
status_t BnHelloService::onTransact( uint32_t code,
const Parcel& data,
Parcel* reply,
uint32_t flags)
{
/* 解析数据,调用sayhello/sayhello_to */
switch (code) {
case HELLO_SVR_CMD_SAYHELLO: {
sayhello();
reply->writeInt32(); /* no exception */
return NO_ERROR;
} break;
case HELLO_SVR_CMD_SAYHELLO_TO: {
/* 从data中取出参数 */
int32_t policy = data.readInt32();
String16 name16_tmp = data.readString16(); /* IHelloService */
String16 name16 = data.readString16();
String8 name8(name16);
int cnt = sayhello_to(name8.string());
/* 把返回值写入reply传回去 */
reply->writeInt32(); /* no exception */
reply->writeInt32(cnt);
return NO_ERROR;
} break;
case HELLO_SVR_CMD_GET_FD: {
int fd = this->get_fd();
reply->writeInt32(); /* no exception */
/* 参考:
* frameworks\base\core\jni\android_view_InputChannel.cpp
* android_view_InputChannel_nativeWriteToParcel
*/
reply->writeDupFileDescriptor(fd);
return NO_ERROR;
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
void BnHelloService::sayhello(void)
{
static int cnt = ;
ALOGI("say hello : %d\n", ++cnt);
}
int BnHelloService::sayhello_to(const char *name)
{
static int cnt = ;
ALOGI("say hello to %s : %d\n", name, ++cnt);
return cnt;
}
int BnHelloService::get_fd(void)
{
return fd;
}
}
②BnGoodbyeService.cpp
/* 参考: frameworks\av\media\libmedia\IMediaPlayerService.cpp */
#define LOG_TAG "GoodbyeService"
#include "IGoodbyeService.h"
namespace android {
status_t BnGoodbyeService::onTransact( uint32_t code,
const Parcel& data,
Parcel* reply,
uint32_t flags)
{
/* 解析数据,调用saygoodbye/saygoodbye_to */
switch (code) {
case GOODBYE_SVR_CMD_SAYGOODBYE: {
saygoodbye();
reply->writeInt32(); /* no exception */
return NO_ERROR;
} break;
case GOODBYE_SVR_CMD_SAYGOODBYE_TO: {
/* 从data中取出参数 */
int32_t policy = data.readInt32();
String16 name16_tmp = data.readString16(); /* IGoodbyeService */
String16 name16 = data.readString16();
String8 name8(name16);
int cnt = saygoodbye_to(name8.string());
/* 把返回值写入reply传回去 */
reply->writeInt32(); /* no exception */
reply->writeInt32(cnt);
return NO_ERROR;
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
void BnGoodbyeService::saygoodbye(void)
{
static int cnt = ;
ALOGI("say goodbye : %d\n", ++cnt);
}
int BnGoodbyeService::saygoodbye_to(const char *name)
{
static int cnt = ;
ALOGI("say goodbye to %s : %d\n", name, ++cnt);
return cnt;
}
}
③BpHelloService.cpp
/* 参考: frameworks\av\media\libmedia\IMediaPlayerService.cpp */
#include "IHelloService.h"
namespace android {
class BpHelloService: public BpInterface<IHelloService>
{
public:
BpHelloService(const sp<IBinder>& impl)
: BpInterface<IHelloService>(impl)
{
}
void sayhello(void)
{
/* 构造/发送数据 */
Parcel data, reply;
data.writeInt32();
data.writeString16(String16("IHelloService"));
remote()->transact(HELLO_SVR_CMD_SAYHELLO, data, &reply);
}
int sayhello_to(const char *name)
{
/* 构造/发送数据 */
Parcel data, reply;
int exception;
data.writeInt32();
data.writeString16(String16("IHelloService"));
data.writeString16(String16(name));
remote()->transact(HELLO_SVR_CMD_SAYHELLO_TO, data, &reply);
exception = reply.readInt32();
if (exception)
return -;
else
return reply.readInt32();
}
int get_fd(void)
{
/* 构造/发送数据 */
Parcel data, reply;
int exception;
data.writeInt32();
data.writeString16(String16("IHelloService"));
remote()->transact(HELLO_SVR_CMD_GET_FD, data, &reply);
exception = reply.readInt32();
if (exception)
return -;
else
{
/* 参考:
* frameworks\base\core\jni\android_view_InputChannel.cpp
* android_view_InputChannel_nativeReadFromParcel
*/
int rawFd = reply.readFileDescriptor();
return dup(rawFd);
}
}
};
IMPLEMENT_META_INTERFACE(HelloService, "android.media.IHelloService");
}
④BpGoodbyeService.cpp
/* 参考: frameworks\av\media\libmedia\IMediaPlayerService.cpp */
#include "IGoodbyeService.h"
namespace android {
class BpGoodbyeService: public BpInterface<IGoodbyeService>
{
public:
BpGoodbyeService(const sp<IBinder>& impl)
: BpInterface<IGoodbyeService>(impl)
{
}
void saygoodbye(void)
{
/* 构造/发送数据 */
Parcel data, reply;
data.writeInt32();
data.writeString16(String16("IGoodbyeService"));
remote()->transact(GOODBYE_SVR_CMD_SAYGOODBYE, data, &reply);
}
int saygoodbye_to(const char *name)
{
/* 构造/发送数据 */
Parcel data, reply;
int exception;
data.writeInt32();
data.writeString16(String16("IGoodbyeService"));
data.writeString16(String16(name));
remote()->transact(GOODBYE_SVR_CMD_SAYGOODBYE_TO, data, &reply);
exception = reply.readInt32();
if (exception)
return -;
else
return reply.readInt32();
}
};
IMPLEMENT_META_INTERFACE(GoodbyeService, "android.media.IGoodbyeService");
}
（3）测试代码：
①test_server.cpp
/* 参考: frameworks\av\media\mediaserver\Main_mediaserver.cpp */ //#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 <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/socket.h> #include "IHelloService.h"
#include "IGoodbyeService.h" #define SOCKET_BUFFER_SIZE (32768U) using namespace android; /* 参考:
* http://blog.csdn.net/linan_nwu/article/details/8222349
*/
class MyThread: public Thread {
private:
int fd;
public:
MyThread() {}
MyThread(int fd) { this->fd = fd; } //如果返回true,循环调用此函数,返回false下一次不会再调用此函数
bool threadLoop()
{
char buf[];
int len;
int cnt = ; while()
{
/* 读数据: test_client发出的数据 */
len = read(fd, buf, );
buf[len] = '\0';
ALOGI("%s\n", buf); /* 向 test_client 发出: Hello, test_client */
len = sprintf(buf, "Hello, test_client, cnt = %d", cnt++);
write(fd, buf, len);
} return true;
} }; /* usage : test_server */
int main(void)
{ int sockets[]; socketpair(AF_UNIX, SOCK_SEQPACKET, , sockets); int bufferSize = SOCKET_BUFFER_SIZE;
setsockopt(sockets[], SOL_SOCKET, SO_SNDBUF, &bufferSize, sizeof(bufferSize));
setsockopt(sockets[], SOL_SOCKET, SO_RCVBUF, &bufferSize, sizeof(bufferSize));
setsockopt(sockets[], SOL_SOCKET, SO_SNDBUF, &bufferSize, sizeof(bufferSize));
setsockopt(sockets[], SOL_SOCKET, SO_RCVBUF, &bufferSize, sizeof(bufferSize)); /* 创建一个线程, 用于跟test_client使用socketpiar通信 */
sp<MyThread> th = new MyThread(sockets[]);
th->run(); /* addService */ /* while(1){ read data, 解析数据, 调用服务函数 } */ /* 打开驱动, mmap */
sp<ProcessState> proc(ProcessState::self()); /* 获得BpServiceManager */
sp<IServiceManager> sm = defaultServiceManager(); sm->addService(String16("hello"), new BnHelloService(sockets[]));
sm->addService(String16("goodbye"), new BnGoodbyeService()); /* 循环体 */
ProcessState::self()->startThreadPool();
IPCThreadState::self()->joinThreadPool(); return ;
}
②test_client.cpp
//#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 <unistd.h> #include "IHelloService.h"
#include "IGoodbyeService.h" using namespace android; /* ./test_client <hello|goodbye>
* ./test_client <readfile>
* ./test_client <hello|goodbye> <name>
*/
int main(int argc, char **argv)
{
int cnt; if (argc < ){
ALOGI("Usage:\n");
ALOGI("%s <readfile>\n", argv[]);
ALOGI("%s <hello|goodbye>\n", argv[]);
ALOGI("%s <hello|goodbye> <name>\n", argv[]);
return -;
} /* getService */
/* 打开驱动, mmap */
sp<ProcessState> proc(ProcessState::self()); /* 获得BpServiceManager */
sp<IServiceManager> sm = defaultServiceManager(); if (strcmp(argv[], "hello") == )
{ sp<IBinder> binder =
sm->getService(String16("hello")); if (binder == )
{
ALOGI("can't get hello service\n");
return -;
} /* service肯定是BpHelloServie指针 */
sp<IHelloService> service =
interface_cast<IHelloService>(binder); /* 调用Service的函数 */
if (argc < ) {
service->sayhello();
ALOGI("client call sayhello");
}
else {
cnt = service->sayhello_to(argv[]);
ALOGI("client call sayhello_to, cnt = %d", cnt);
}
}
else if (strcmp(argv[], "readfile") == )
{ sp<IBinder> binder =
sm->getService(String16("hello")); if (binder == )
{
ALOGI("can't get hello service\n");
return -;
} /* service肯定是BpHelloServie指针 */
sp<IHelloService> service =
interface_cast<IHelloService>(binder); /* 调用Service的函数 */
int fd = service->get_fd(); ALOGI("client call get_fd = %d", fd); char buf[];
int len;
int cnt = ; while ()
{
/* 向 test_server 进程发出: Hello, test_server */
len = sprintf(buf, "Hello, test_server, cnt = %d", cnt++);
write(fd, buf, len); /* 读取数据(test_server进程发回的数据) */
len = read(fd, buf, );
buf[len] = '\0';
ALOGI("%s\n", buf); sleep();
}
}
else
{ sp<IBinder> binder =
sm->getService(String16("goodbye")); if (binder == )
{
ALOGI("can't get goodbye service\n");
return -;
} /* service肯定是BpGoodbyeServie指针 */
sp<IGoodbyeService> service =
interface_cast<IGoodbyeService>(binder); /* 调用Service的函数 */
if (argc < ) {
service->saygoodbye();
ALOGI("client call saygoodbye");
}
else {
cnt = service->saygoodbye_to(argv[]);
ALOGI("client call saygoodbye_to, cnt = %d", cnt);
}
} return ;
}
（4）Android.mk：
LOCAL_PATH:= $(call my-dir) include $(CLEAR_VARS) LOCAL_SRC_FILES:= \
BnHelloService.cpp \
BpHelloService.cpp \
BnGoodbyeService.cpp \
BpGoodbyeService.cpp \
test_server.cpp LOCAL_SHARED_LIBRARIES := \
libcutils \
libutils \
liblog \
libbinder LOCAL_MODULE:= test_server
LOCAL_32_BIT_ONLY := true include $(BUILD_EXECUTABLE) include $(CLEAR_VARS) LOCAL_SRC_FILES:= \
BpHelloService.cpp \
BpGoodbyeService.cpp \
test_client.cpp LOCAL_SHARED_LIBRARIES := \
libcutils \
libutils \
liblog \
libbinder LOCAL_MODULE:= test_client
LOCAL_32_BIT_ONLY := true include $(BUILD_EXECUTABLE)
二、内部机制
1.回顾binder框架关键点
test_server向service_manager添加服务，test_client通过service_manager获取服务，具体流程如下：
①add_service:
a.test_server为每个服务构造 struct flat_binder_object 结构体，其中void *binder 或 void* cookie 对应不同服务；
b.调用ioctl发送数据：
b1. 数据：flat_binder_object + 服务名称;
b2.数据中含有"目的地"：handle=0,则代表 service_manager;
c.驱动程序对每一个flat_binder_object构造一个binder_node结构体，其中 void __user *ptr 和 void __user *cookie即来自flat_binder_object；
d.驱动程序根据handle=0找到service_manager，把数据发送给service_manager并且创建一个 struct binder_ref结构体到链表，其中node指针指向binder_node结构体；
e.service_manager中记录服务名（“hello”、“goodbye”）称和desc值(binder_ref结构体中的desc值)；
②get_service:
a.test_client构造数据：名称 + "目的"(handle=0)；
b.调ioctl发送数据；
c.驱动程序根据handle=0找到service_manager把数据给service_manager；
d.service_manager从service list中找到对应项，比如根据服务名"hello"找到第一项，handle=1；
e.service_manager调用ioctl返回数据(flat_binder_object)；
f.驱动发现数据中含有flat_binder_object，且type为引用，从service_manager的binder_ref表中找到对应项（传入的handle=binder_ref.desc）再找到binder_node,最后为test_client建立binder_ref,即对应service_manager里构造的binder_ref链表；
③test_client使用服务: hello->sayhello(code=1), hello->sayhello_to(code=2)
a.构造数据，code定义要执行的函数、参数、目的(handle=1)；
b.使用ioctl发送数据；
c.驱动从数据中取出handle=1，根据handle找到binder_ref，根据binder_ref找到binder_node,再根据binder_node找到目的进程(.proc->test_server)，最后把数据传给test_server，并且在数据中设置.ptr/.cookie 等于binder_node的.ptr/.cookie；
d.test_server根据.ptr/.cookie获知test_client想调用的服务，再根据code等参数调用具体的函数操作；
小结：
server注册服务时, 对每个服务都提供不同的ptr/cookie,在驱动程序里对每个服务都构造一个binder_node, 它也含有ptr/cookie，client使用服务前要先getService，在驱动程序里对该服务构造一个binder_ref,binder_ref含有desc, node成员, desc是整数, node指向对应服务的binder_node，使用服务时, client调用ioctl发送构造数据，数据里含有handle，驱动程序根据handle找到binder_ref(desc==handle), 再通过binder_ref找到binder_node, 再根据binder_node找到对应server,最后从binder_node取出ptr/cookie连同那些数据发给server，server根据数据中的ptr/cookie信息调用对应服务，再根据code调用对应函数。
Binder系统最核心的函数： ioclt;
client最核心的数据：handle;
server最核心的数据：.ptr/.cookie
2.代理类BpXXX分析
test_server向service_manager添加服务时，首先获得BpServiceManager（handle=0）成为一个client与之通信，test_client同样获得BpServiceManager和service_manager通信，然后test_client再获得BpHelloService（handle=BpServiceManager->getService("Hello")==1）和test_server通信。
UML展示BpServiceManager的继承关系：
（1）
（2）
（3）
2.1 获得BpServiceManager对象的过程:
defaultServiceManager构造了一个BpServiceManager对象（派生自BpRefBase,含有IBinder *mRemote, mRemote指向BpBinder对象，它含有mHandle），
其中它的mRemote = new BpBinder(0); // mRemote->mHandle=0
defaultServiceManager // IServiceManager.cpp
// 把BpBinder(mHandle=0)对象转换为IServiceManager接口(BpServiceManager)
gDefaultServiceManager = interface_cast<IServiceManager>(
ProcessState::self()->getContextObject(NULL));
分析:
ProcessState::self()->getContextObject(NULL)
getStrongProxyForHandle(0);
b = new BpBinder(handle); // mHandle=handle=0
interface_cast<IServiceManager>(new BpBinder(0)) // IInterface.h
IServiceManager::asInterface(obj);
return new BpServiceManager(obj); // mRemote=obj=new BpBinder(0);
2.2 获得BpHelloService对象的过程:
调用BpServiceManager的getService函数获得一个flat_binder_object，
从中取出handle, 创建一个BpBinder(handle),
然后使用interface_cast使用这个BpBinder创建一个BpHelloService对象
// binder是BpBinder对象, 里面含有HelloService的handle
sp<IBinder> binder =
sm->getService(String16("hello")); // IServiceManager.cpp
// 构造数据: 数据中肯定含有"hello"
// 发送数据: 给handle 0, 即 service_manager进程
// 从收到的回复中取出HelloService的handle
return reply.readStrongBinder();
unflatten_binder(ProcessState::self(), *this, &val);
*out = proc->getStrongProxyForHandle(flat->handle);
new BpBinder(handle); //handle来自service_manager进程的回复
// 把binder转换为IHelloService接口(BpHelloService对象)
// binder是BpBinder对象, 里面含有HelloService的handle
sp<IHelloService> service = interface_cast<IHelloService>(binder);
2.3 代理类如何发送数据: ioctl, 数据里含有handle, 含有其他构造的参数
构造好数据之后，调用：
remote()->transact(...) //addService、checkService、getService 以及sayhello/sayhello_to等函数最终都会调用这里，remote()返回一个BpBinder对象，其中实现了transact；
IPCThreadState::self()->transact(mHandle, code, data, reply, flags); //该线程中实现了waitForResponse()、talkWithDriver(其中通过mDriverFD句柄进行ioctl操作) 等函数。
3.数据传输：ProcessState 和 IPCThreadState 类 (单例模式)
ProcessState::self()->startThreadPool(); //创建子线程，最终执行：IPCThreadState ::self()->joinThreadPool();
IPCThreadState ::self()->joinThreadPool(); //循环，读取数据、解析、处理、回复。
3.1 addService
前面介绍过，对于不同服务构造的flat_binder_object结构体，里面的.binder/.cookie对于不同的服务它的值不一样
sm->addService(String16("hello"), new BnHelloService());
data.writeStrongBinder(service); // service = new BnHelloService();
flatten_binder(ProcessState::self(), val, this); // val = service = new BnHelloService();
flat_binder_object obj; // 参数 binder = val = service = new BnHelloService();
IBinder *local = binder->localBinder(); // =this = new BnHelloService();
obj.type = BINDER_TYPE_BINDER;
obj.binder = reinterpret_cast<uintptr_t>(local->getWeakRefs());
obj.cookie = reinterpret_cast<uintptr_t>(local); // new BnHelloService();
3.2 server如何分辨client想使用哪一个服务？
server收到数据里含有flat_binder_object结构体,
它可以根据.binder/.cookie分析client想使用哪一个服务
把.cookie转换为BnXXXX对象，然后调用它的函数:
// 根据cookie构造了一个BBinder指针, 实际上是指向某个BnXXX对象
sp<BBinder> b((BBinder*)tr.cookie);
// 然后调用它的transact函数
error = b->transact(tr.code, buffer, &reply, tr.flags);
err = onTransact(code, data, reply, flags); // 就会调用到BnXXX里实现的onTransact
// 它就会根据code值来调用不同的函数
-end-
最新文章
- JavaBean用JSP调用和使用JSP动作标签的区别
- C# Enum Type
- locals()函数访问当前还在作用范围内的局部变量
- 用dedecms自定义表单创建简易自助预约系统
- 短信发送AZDG加密算法
- Linux Shell 数字计算与比较
- nyoj 10 skiing（记忆化搜索）
- vJine.Core 0.3.0.49 正式发布
- Table嵌套去掉子table的外边框
- 运行phpize时出现：Cannot find autoconf. Please check your autoconf installation
- Java开发环境安装
- awk实践积累
- SQLSERVER执行时间统计工具SQLQueryStress
- ural 1353. Milliard Vasya's Function（背包/递归深搜）
- React Native 之 数据持久化
- Hihocoder 1325 平衡树·Treap（平衡树，Treap）
- （PAT）L2-006 树的遍历 （二叉树构建）
- centos django Failed to load resource: net::ERR_INCOMPLETE_CHUNKED_ENCODING
- OpenStack-Neutron-Fwaas-代码【一】
- Linux ugo 权限