Android Binder Mechanism (2) -- 如何获得ServiceManager的代理对象的引用

来源：互联网发布：python 测试框架编辑：程序博客网时间：2024/06/05 17:13

http://blog.csdn.net/baiyanning/article/details/6191931

在这篇文章中，我们将深入剖析一下Android系统的服务管理员ServiceManager。

ServiceManager是Android系统服务的管理者。所有需要通过Binder机制进行进程间通信的进程都要首先获得Service Manager的代理对象才能进行Binder通讯。比如系统中有用于音频混音的AudioFlingerService，用于照相的CameraService，用于媒体文件播放的MediaPlayerService。所有这些服务都会向ServiceManager注册，因此ServiceManager就维护了系统中所有服务的一个列表。任何应用程序要想使用这些服务，首先要向ServiceManager请求获得这些服务的引用，从而建立起和这些服务的联系。

在本系列的第一篇文章中，ExampleService通过如下语句向系统注册服务。

[cpp] view plaincopy

// File: ExampleService.cpp
int r = defaultServiceManager()->addService(String16("byn.example"), new ExampleService());

这里有两个问题：

1. defaultServiceManager()都完成了哪些工作，它返回的结果是什么？

2. 为什么调用上一步返回对象的addService方法，就可以向系统注册服务？这一注册过程都完成了哪些工作？

这篇文章先回答问题1。

ServiceManager也是系统中的一个服务，那么应用程序如何和它取得联系呢？答案就是通过defaultServiceManager()函数。defaultServiceManager()是系统在Android命名空间中定义的一个全局函数，用来获得ServiceManager的代理对象的引用。我们看一下该函数的源代码。

[cpp] view plaincopy

// File: framework/base/libs/binder/IServiceManager.cpp
sp<IServiceManager> defaultServiceManager()
{
if (gDefaultServiceManager != NULL) return gDefaultServiceManager; // 如果该代理对象已经存在，直接返回该对象
{
AutoMutex _l(gDefaultServiceManagerLock);
if (gDefaultServiceManager == NULL) {
gDefaultServiceManager = interface_cast<IServiceManager>(
ProcessState::self()->getContextObject(NULL));
}
}
return gDefaultServiceManager;
}

gDefaultServiceManager在libutil中定义，因此任何程序或库使用了libutil库都会有该变量，它在一个进程中是唯一的。gDefaultServiceManager的初始值为NULL，所以先调用ProcessState::self()方法获取一个ProcessState实例。这里用到了Singleton的设计模式，从而可知一个进程只有一个ProcessState实例。

[cpp] view plaincopy

// File: Frameworks/base/libs/binder/ProcessState.cpp
sp<ProcessState> ProcessState::self()
{
if (gProcess != NULL) return gProcess;
AutoMutex _l(gProcessMutex);
if (gProcess == NULL) gProcess = new ProcessState;
return gProcess;
}

该ProcessState会打开/dev/binder设备供IPCThreadState使用。查看其构造函数便知。

[cpp] view plaincopy

// File: frameworks/base/libs/binder/ProcessState.cpp
ProcessState::ProcessState()
: mDriverFD(open_driver())
, mVMStart(MAP_FAILED)
, mManagesContexts(false)
, mBinderContextCheckFunc(NULL)
, mBinderContextUserData(NULL)
, mThreadPoolStarted(false)
, mThreadPoolSeq(1)
{
if (mDriverFD >= 0) {
// XXX Ideally, there should be a specific define for whether we
// have mmap (or whether we could possibly have the kernel module
// availabla).
#if !defined(HAVE_WIN32_IPC)
// mmap the binder, providing a chunk of virtual address space to receive transactions.
mVMStart = mmap(0, BINDER_VM_SIZE, PROT_READ, MAP_PRIVATE | MAP_NORESERVE, mDriverFD, 0);
if (mVMStart == MAP_FAILED) {
// *sigh*
LOGE("Using /dev/binder failed: unable to mmap transaction memory./n");
close(mDriverFD);
mDriverFD = -1;
}
#else
mDriverFD = -1;
#endif
}
if (mDriverFD < 0) {
// Need to run without the driver, starting our own thread pool.
}
}

再看一下open_driver()方法的源代码。

[cpp] view plaincopy

// File: frameworks/base/libs/binder/ProcessState.cpp
static int open_driver()
{
if (gSingleProcess) {
return -1;
}
int fd = open("/dev/binder", O_RDWR);
if (fd >= 0) {
fcntl(fd, F_SETFD, FD_CLOEXEC);
int vers;
#if defined(HAVE_ANDROID_OS)
status_t result = ioctl(fd, BINDER_VERSION, &vers);
#else
status_t result = -1;
errno = EPERM;
#endif
if (result == -1) {
LOGE("Binder ioctl to obtain version failed: %s", strerror(errno));
close(fd);
fd = -1;
}
if (result != 0 || vers != BINDER_CURRENT_PROTOCOL_VERSION) {
LOGE("Binder driver protocol does not match user space protocol!");
close(fd);
fd = -1;
}
#if defined(HAVE_ANDROID_OS)
size_t maxThreads = 15;
result = ioctl(fd, BINDER_SET_MAX_THREADS, &maxThreads);
if (result == -1) {
LOGE("Binder ioctl to set max threads failed: %s", strerror(errno));
}
#endif
} else {
LOGW("Opening '/dev/binder' failed: %s/n", strerror(errno));
}
return fd;
}

open_driver()方法打开binder设备(/dev/binder)，获取binder版本号，设定最大线程个数，并返回binder设备的文件描述符。内核空间中分配约1M的连续空间(BINDER_VM_SIZE)给进程，并用mmap函数映射到进程的用户空间。该空间用于transaction交互数据用。

回到defaultServiceManager()方法。我们可以看到defaultServiceManager()是调用ProcessState对象的getContextObject方法获得ServiceManager的代理对象。我们再看一下getContextObject函数的源代码：

[cpp] view plaincopy

// File: frameworks/base/libs/binder/ProcessState.cpp
sp<IBinder> ProcessState::getContextObject(const sp<IBinder>& caller)
{
if (supportsProcesses()) {
return getStrongProxyForHandle(0);
} else {
return getContextObject(String16("default"), caller);
}
}

因为支持binder驱动(supportsProcesses()函数会判断binder驱动是否打开，以此来检验是否支持binder)，这里是以0为参数调用getStrongProxyForHandle()方法获得ServiceManager的代理对象。我们再看一下getStrongProxyForHandle()方法的源代码：

[cpp] view plaincopy

// File: frameworks/base/libs/binder/ProcessState.cpp
sp<IBinder> ProcessState::getStrongProxyForHandle(int32_t handle)
{
sp<IBinder> result;
AutoMutex _l(mLock);
handle_entry* e = lookupHandleLocked(handle);
if (e != NULL) {
// We need to create a new BpBinder if there isn't currently one, OR we
// are unable to acquire a weak reference on this current one. See comment
// in getWeakProxyForHandle() for more info about this.
IBinder* b = e->binder;
if (b == NULL || !e->refs->attemptIncWeak(this)) {
b = new BpBinder(handle);
e->binder = b;
if (b) e->refs = b->getWeakRefs();
result = b;
} else {
// This little bit of nastyness is to allow us to add a primary
// reference to the remote proxy when this team doesn't have one
// but another team is sending the handle to us.
result.force_set(b);
e->refs->decWeak(this);
}
}
return result;
}

getStrongProxyForHandle()首先调用lookupHandleLocked()方法查找当前进程是否维护的Service代理对象的列表。我们再看一下lookupHandleLocked()方法的源代码。

[cpp] view plaincopy

// File: ProcessState.cpp
ProcessState::handle_entry* ProcessState::lookupHandleLocked(int32_t handle)
{
const size_t N=mHandleToObject.size();
if (N <= (size_t)handle) {
handle_entry e;
e.binder = NULL;
e.refs = NULL;
status_t err = mHandleToObject.insertAt(e, N, handle+1-N);
if (err < NO_ERROR) return NULL;
}
return &mHandleToObject.editItemAt(handle);
}

mHHandleToObject是一个以handle_entry类型为元素的Vector，维护当前进程的代理对象列表。其索引就是每个代理对象句柄的值。比如ServiceManager对应的句柄肯定是0，那么它就是这个列表的第1项。如果待查询的的句柄的值大于等于当前列表的大小，说明待创建的Service代理对象条目尚未在当前进程中创建，那么就需要插入新项。当前的列表大小是N，索引从0至N-1，如果待查询的索引是handle，那么就要插入handle-(N-1)项。如果该代理对象条目已经创建过了，那么直接返回其引用就可以了。

注：这里的“创建”只是在列表中创建相应的条目(e.binder = NULL;e.refs = NULL;)，真正的代理对象要在稍后才创建。

现在回到getStrongProxyForHandle()方法。如果该代理对象尚未创建(e->binder==NULL)，那么就创建一个，并更新代理对象列表中的相应记录。

我们再来看一下BpBinder类的构造函数做了什么。

[cpp] view plaincopy

// File: frameworks/base/libs/binder/BpBinder.cpp
BpBinder::BpBinder(int32_t handle)
: mHandle(handle)
, mAlive(1)
, mObitsSent(0)
, mObituaries(NULL)
{
LOGV("Creating BpBinder %p handle %d/n", this, mHandle);
extendObjectLifetime(OBJECT_LIFETIME_WEAK);
IPCThreadState::self()->incWeakHandle(handle);
}

这里调用了IPCThreadState类的incWeakHandle()方法来增加引用计数。我们再看看incWeakHandle()方法的源代码。

[cpp] view plaincopy

// File: frameworks/base/libs/binder/IPCThreadState.cpp
void IPCThreadState::incWeakHandle(int32_t handle)
{
LOG_REMOTEREFS("IPCThreadState::incWeakHandle(%d)/n", handle);
mOut.writeInt32(BC_INCREFS);
mOut.writeInt32(handle);
}

这里incWeakHandle()在输出缓冲区增加了一条BC_INCREFS命令。

如果该handle对应的代理对象已经创建过了，那么就增加它的引用计数。result是一个指向IBinder类型的强指针。Android系统中定义了sp(strong pointer)和wp(weak pointer)两种智能指针。注意这里的操作符"="已经被重载了。force_set是RefBase类专门为ProcessState类优化的一个方法，让我们看一下它的源代码。

[cpp] view plaincopy

// File: frameworks/base/include/utils/RefBase.h
template<typename T>
void sp<T>::force_set(T* other)
{
other->forceIncStrong(this);
m_ptr = other;
}

设定好引用计数之后，getStrongProxyForHandle()方法返回代理对象的句柄。接下来会通过interface_cast将其转换为IserviceManager类型。我们来看看这个转换是怎么实现的。

[cpp] view plaincopy

gDefaultServiceManager = interface_cast<IServiceManager>(
ProcessState::self()->getContextObject(NULL));

interface_cast<IServiceManager>，其实调用的是IServiceManager.asInterface方法：

[cpp] view plaincopy

// File: frameworks/base/include/binder/IInterface.h
template<typename INTERFACE>
inline sp<INTERFACE> interface_cast(const sp<IBinder>& obj)
{
return INTERFACE::asInterface(obj);
}

查看IServiceManager的源文件，好像并没有定义asInterface方法。不要急，我们先看一下IServiceManager的定义：

[cpp] view plaincopy

// File: frameworks/base/include/binder/IServiceManager.h
class IServiceManager : public IInterface
{
public:
DECLARE_META_INTERFACE(ServiceManager);
/**
* Retrieve an existing service, blocking for a few seconds
* if it doesn't yet exist.
*/
virtual sp<IBinder> getService( const String16& name) const = 0;
/**
* Retrieve an existing service, non-blocking.
*/
virtual sp<IBinder> checkService( const String16& name) const = 0;
/**
* Register a service.
*/
virtual status_t addService( const String16& name,
const sp<IBinder>& service) = 0;
/**
* Return list of all existing services.
*/
virtual Vector<String16> listServices() = 0;
enum {
GET_SERVICE_TRANSACTION = IBinder::FIRST_CALL_TRANSACTION,
CHECK_SERVICE_TRANSACTION,
ADD_SERVICE_TRANSACTION,
LIST_SERVICES_TRANSACTION,
};
};

这里的宏DECLARE_META_INTERFACE在IInterface.h头文件中定义如下：

[cpp] view plaincopy

// File: frameworks/base/include/binder/IInterface.h
#define DECLARE_META_INTERFACE(INTERFACE) /
static const String16 descriptor; /
static sp<I##INTERFACE> asInterface(const sp<IBinder>& obj); /
virtual const String16& getInterfaceDescriptor() const; /
I##INTERFACE(); /
virtual ~I##INTERFACE(); /

这里，我们终于找到了asInterface方法的声明。该方法是通过在IServiceManager.cpp文件中的IMPLEMENT_META_INTERFACE宏来实现的。

[cpp] view plaincopy

// File: frameworks/base/include/binder/IServiceManager.cpp
IMPLEMENT_META_INTERFACE(ServiceManager, "android.os.IServiceManager");

IMPLEMENT_META_INTERFACE宏定义如下：

[cpp] view plaincopy

// File: frameworks/base/include/binder/IInterface.h
#define IMPLEMENT_META_INTERFACE(INTERFACE, NAME) /
const String16 I##INTERFACE::descriptor(NAME); /
const String16& I##INTERFACE::getInterfaceDescriptor() const { /
return I##INTERFACE::descriptor; /
} /
sp<I##INTERFACE> I##INTERFACE::asInterface(const sp<IBinder>& obj) /
{ /
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() { } /

将上面这些宏展开后的最终结果就是，

[cpp] view plaincopy

sp<IServiceManager> IServiceManager::asInterface(const sp<IBinder>& obj)
{
sp<IServiceManager> intr;
if (obj != NULL) {
intr = static_cast<IServiceManager*>(obj->queryLocalInterface(
IServiceManager::descriptor).get());
if (intr == NULL) {
intr = new BpServiceManager(obj);
}
}
return intr;
}

可见，IServiceManager::asInterface()函数最终会用一个IBinder对象创建一个BpServiceManager对象，并将它返回。

好了，现在我们总结一下获取ServiceManager代理对象的全部过程：

defaultServiceManager(); // 获取ServiceManager代理对象

{

interface_cast<IServiceManager>(ProcessState::self()->getContextObject(NULL)); // 将返回的BpBinder类型的代理对象转换成ServiceManager类型的代理对象

{

getStrongProxyForHandle(0); // 以0为参数即可获得ServiceManager的代理对象

{

lookupHandleLocked(0);

b = new BpBinder(0); // 新建一个代理对象

返回根据handle生成的代理对象

}

返回根据handle生成的代理对象

}

返回转换成ServiceManager类型的代理对象

}

最后，我们可以回答问题1了：

问题： defaultServiceManager()都完成了哪些工作，它返回的结果是什么？

答：如果当前进程已经生成了ServiceManager的代理对象，那么该函数返回它的一个引用；如果当前进程还没有生成过ServiceManager的代理对象，那么创建它，并返回它的一个引用。

我们将在下篇文章中深入剖析为什么调用该引用指向的getService方法就可以获得ExampleService的代理对象的引用。