如何使用Binder实现分析

看了老罗的Binder源码分析实在是有点难懂，驱动的分析因为没有基础所以看起来很吃力，但android在native层给我们封装了快速实现Binder应用的库，在此记录，以作查用。

分析媒体框架发现，我们要实现一个IPC服务，大体可以总结为以下几步。

1、获得ServiceManager。

2、实现Service并把自己加入ServiceManager中。

3、进入等待，并接受Client的请求。

其中大多的方法和实现Android都有现成的可以调用，我们只要实现第2步，即实现自己Service。

下面我们就具体实践：

首先肯定会有一个C++程序，类似于main_MediaService的入口

int main(int argc, char** argv)
{
sp<ProcessState> proc(ProcessState::self());
sp<IServiceManager> sm = defaultServiceManager();
MediaPlayerService::instantiate();
ProcessState::self()->startThreadPool();
IPCThreadState::self()->joinThreadPool();
}

定义XXX接口

XXX接口是和XXX服务相关，例如提供getXXX , setXXX函数，和应用逻辑相关。

需要从IInterface派生

class IXXX: public IInterface
{
public:
DECLARE_META_INTERFACE(XXX);申明宏
virtual getXXX() = 0;
virtual setXXX() = 0;
}这是一个接口。

我们声明了一个 DECLARE_META_INTERFACE(XXX) 的宏，他的定义在IInterface.h中，展开看看

class IXXX: public IInterface
{
public:
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();

virtual getXXX() = 0;
virtual setXXX() = 0;
}

这样我们有多了几个方法....继续

为了把IXXX加入到Binder结构中去，需要定义BnXXX和对客户端透明的BpXXX。

既然要透明我们就要把BpXXX放在cpp中实现。

BnXXX是需要头文件的，可以把它和IXXX定义放在一块，分开也行,我们把他放入一个文件IXXX.h
文件中。

class BnXXX: public BnInterface<IXXX>
{
public:
virtual status_t    onTransact( uint32_t code,
const Parcel& data,
Parcel* reply,
uint32_t flags = 0);

//由于IXXX是个纯虚类，而BnXXX只实现了onTransact函数，所以BnXXX依然是一个纯虚类
};

继承BnInterface<IXXX>是继承什么，他的定义同样在IInterface中。

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

兑现后为

class BnXXX: public IXXX, public BBinder
{
public:
virtual status_t    onTransact( uint32_t code,
const Parcel& data, Parcel* reply, uint32_t flags = 0);//这样BnXXX就拥有了IXXX以下的方法：
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();
virtual getXXX() = 0;
virtual setXXX() = 0;
};

接着我们在某个CPP中实现他们，IXXX.cpp :

IMPLEMENT_META_INTERFACE(XXX, "android.xxx.IXXX");//IMPLEMENT宏

status_t BnXXX::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case GET_XXX: {
CHECK_INTERFACE(IXXX, data, reply);
//读请求参数
//调用虚函数getXXX()
return NO_ERROR;

} break;
case SET_XXX: {
CHECK_INTERFACE(IXXX, data, reply);
//读请求参数
//调用虚函数getXXX()
return NO_ERROR;
}
}

IMPLEMENT_META_INTERFACE(XXX,"");定义在IInterface中。

展开并兑现了看看...

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

status_t BnXXX::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code)
{
...
}
}

这样已兑现，该实现的都实现了，就只剩getXXX(), setXXX()应用逻辑需要我们实现。一个宏声明，一个宏实现，我们就把Binder接入自己的程序了，省去了很多步啊， 继续啊...

我们在asInterfance中看到，new Bp##INTERFACE(obj), 这个就是Client的获得proxy对象了，用来封装参数IPC到我们的进程中，它也实现在IXXX.cpp 文件中。

class BpXXX: public BpInterface<IXXX>
{
public:
BpXXX (const sp<IBinder>& impl): BpInterface< IXXX >(impl)  //定义调用父类的构造
{
}

vitural getXXX()
{
Parcel data, reply;
data.writeInterfaceToken(IXXX::getInterfaceDescriptor());
data.writeInt32(pid); remote()->transact(GET_XXX, data, &reply);
return;
}

vitural setXXX()
{
Parcel data, reply;
data.writeInterfaceToken(IXXX::getInterfaceDescriptor());
data.writeInt32(pid);
remote()->transact(SET_XXX, data, &reply);
return;
}
}

BpInterface<IXXX>的继承关系定义在IInterface中

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

protected:
virtual IBinder* onAsBinder();
};

兑现为：

class BpXXX: public IXXX, BpRefBase
{
public:
BpXXX (const sp<IBinder>& impl): BpInterface<IXXX>(impl)
{	//调用父类BpInterface构造，BpInterface又调用父类BpRefBase的构造(这层实现是通过IInterface 的内联函数重载了的), BpRefBase只是简单的把 imp 保存在自己的成员变量中mRemote, 子类可以调用他的remote()函数把他返回出来，另作他用
}

vitural getXXX()	//继承自 IXXX方法
{
...
remote()->transact(GET_XXX, data, &reply);
...
}

vitural setXXX()	//继承自 IXXX方法
{
...
remote()->transact(SET_XXX, data, &reply);
...
}

protected:
virtual IBinder* onAsBinder();		//实现与IInterface 内联函数，只是调用父类BpRefBase.remote()返回 impl对象
}

到此为止我们就已经实现了自己定义的Service.

Client通过ServiceManager查询出我们的就可以调用我们提供的服务了

XXXClient::getService()
{
sp<IServiceManager> sm = defaultServiceManager();
sp<IBinder> binder = sm->getService(String16("android.xxx.IXXX"));
sp<IXXX> service = interface_cast<IXXX>(binder);  //interface_cast<IXXX>(binder) 等于 IXXX.asInterface(binder) , 定义在IInterface
return service;
}

to be continued..