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

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

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

 

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

 

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

 

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

 

    这里有两个问题：

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

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

 

    这篇文章先回答问题1。

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

// 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实例。

// 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使用。查看其构造函数便知。

// 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()方法的源代码。

// 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函数的源代码：

// 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()方法的源代码：

// 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()方法的源代码。

// 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类的构造函数做了什么。

// 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()方法的源代码。

// 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类优化的一个方法，让我们看一下它的源代码。

// 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类型。我们来看看这个转换是怎么实现的。

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

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

// 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的定义：

// 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头文件中定义如下：

// 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宏来实现的。

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

    IMPLEMENT_META_INTERFACE宏定义如下：

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

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

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的代理对象的引用。