Android Binder机制理解

Android Binder机制理解

一、说明
Android系统中应用很广泛的但也是最难理解的就是Binder机制了，从APP组被调到系统平台组后感觉需要学的东西更多了，思考的方式也有所改变，从是什么转变到为什么(背后的设计思想和实现细节)，初次接触Framework感觉就是在于各种服务打交道，例如ActivityManagerService、WindowManagerService、PowerManagerService等等。要想短时间内就把这些都屡清楚是挺困难的一件事。但是万变不离其宗，它们背后的设计思想应该差异不大，所以由简入繁，先攻克其中较为简单的一点，其他的就可以迎刃而解了。下面就以MediaService为例展开源码（基于Android M 6.0版本）的分析，理解了Binder就能够在很大程度上理解程序的运行流程。先简单理解一下Binder通信模型，Binder框架定义了四个角色：Server，Client，ServiceManager（简称SMgr）以及Binder驱动。其中Server，Client，SMgr运行于用户空间，驱动运行于内核空间。这四个角色的关系和互联网类似：Server是服务器，Client是客户终端，SMgr是域名服务器（DNS），驱动是路由器。

二、MediaService探究
MediaService是一个应用程序，其中我们只分析MediaPlayerService。
MediaService的源码文件在：frameworks/av/media/mediaserver/main_mediaserver.cpp

int main(int argc __unused, char** argv)
{
    ......
    sp<ProcessState> proc(ProcessState::self());//获得一个ProcessState实例
    sp<IServiceManager> sm = defaultServiceManager();//得到一个ServiceManager对象
    ALOGI("ServiceManager: %p", sm.get());
    AudioFlinger::instantiate();
    MediaPlayerService::instantiate();//初始化MediaPlayerService服务
    ResourceManagerService::instantiate();
    ......
    ProcessState::self()->startThreadPool();//像是启动Process的线程池？
    IPCThreadState::self()->joinThreadPool();//然后将自己加入到刚才的线程池？
}

sp，究竟是smart pointer还是strong pointer呢？就把它当做一个普通的指针看待，即sp<IServiceManager> –>IServiceManager*。sp是google为了方便C/C++程序员管理指针的分配和释放的一套方法，类似JAVA的什么WeakReference之类的。以后的分析中，sp就看成是XXX*就可以了。

2.1 ProcessState
第一个调用的函数是ProcessState::self()，然后赋值给了proc变量，程序运行完，proc会自动delete内部的内容，所以就自动释放了先前分配的资源。

ProcessState位置在frameworks/native/libs/binder/ProcessState.cpp

sp<ProcessState> ProcessState::self()
{
    Mutex::Autolock _l(gProcessMutex);//锁保护
    if (gProcess != NULL) {
        return gProcess;//第一次进来肯定不走这儿
    }
    gProcess = new ProcessState;//创建一个ProcessState对象
    return gProcess;//这里返回的是指针，但是函数返回的是sp<xxx>，所以把sp<xxx>看成是XXX*是可以的
}

//再来看ProcessState构造函数,这个构造函数看来很重要
ProcessState::ProcessState()
    : mDriverFD(open_driver())//Android很多代码都是这么写的,函数很重要，在下面分析。
    , mVMStart(MAP_FAILED)//映射内存的起始地址
    , mThreadCountLock(PTHREAD_MUTEX_INITIALIZER)
    , mThreadCountDecrement(PTHREAD_COND_INITIALIZER)
    , mExecutingThreadsCount(0)
    , mMaxThreads(DEFAULT_MAX_BINDER_THREADS)
    , 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)
        // 为这个Binder提供一个虚拟地址空间块来接收处理
        //BINDER_VM_SIZE 定义为((2*1024*1024) - (4096 *2)) 2M-8K
        //将fd映射为内存，这样内存的memcpy等操作就相当于write/read(fd)了
        mVMStart = mmap(0, BINDER_VM_SIZE, PROT_READ, MAP_PRIVATE | MAP_NORESERVE, mDriverFD, 0);
        if (mVMStart == MAP_FAILED) {
            // *sigh*
            ALOGE("Using /dev/binder failed: unable to mmap transaction memory.\n");
            close(mDriverFD);
            mDriverFD = -1;
        }
#else
        mDriverFD = -1;
#endif
    }

    LOG_ALWAYS_FATAL_IF(mDriverFD < 0, "Binder driver could not be opened.  Terminating.");
}

//open_driver，就是打开/dev/binder这个设备，这个是android在内核中搞的一个专门用于完成
//进程间通讯而设置的一个虚拟的设备。BTW，说白了就是内核的提供的一个机制，这个和我们用socket加NET_LINK方式和内核通讯是一个道理。
static int open_driver()
{
    int fd = open("/dev/binder", O_RDWR);
    if (fd >= 0) {
        fcntl(fd, F_SETFD, FD_CLOEXEC);
        int vers = 0;
        status_t result = ioctl(fd, BINDER_VERSION, &vers);
        if (result == -1) {
            ALOGE("Binder ioctl to obtain version failed: %s", strerror(errno));
            close(fd);
            fd = -1;
        }
        if (result != 0 || vers != BINDER_CURRENT_PROTOCOL_VERSION) {
            ALOGE("Binder driver protocol does not match user space protocol!");
            close(fd);
            fd = -1;
        }
        //#define DEFAULT_MAX_BINDER_THREADS 15
        size_t maxThreads = DEFAULT_MAX_BINDER_THREADS;
        //通过ioctl方式告诉内核，这个fd支持最大线程数是15个。
        result = ioctl(fd, BINDER_SET_MAX_THREADS, &maxThreads);
        if (result == -1) {
            ALOGE("Binder ioctl to set max threads failed: %s", strerror(errno));
        }
    } else {
        ALOGW("Opening '/dev/binder' failed: %s\n", strerror(errno));
    }
    return fd;
}

到这里Process::self就分析完了，这里主要做了两件事情：
（1）、打开/dev/binder设备，这样的话就相当于和内核binder机制有了交互的通道
（2）、映射fd到内存，设备的fd传进去后，估计这块内存是和binder设备共享的

接下来，就到调用defaultServiceManager()地方了。
2.2 defaultServiceManager
defaultServiceManager位置在frameworks/native/libs/binder/IServiceManager.cpp中

sp<IServiceManager> defaultServiceManager()
{
    if (gDefaultServiceManager != NULL) return gDefaultServiceManager;
    //又是一个单例，设计模式中叫singleton。
    {
        AutoMutex _l(gDefaultServiceManagerLock);
        while (gDefaultServiceManager == NULL) {
            //真正的gDefaultServiceManager是在这里创建的
            gDefaultServiceManager = interface_cast<IServiceManager>(
                ProcessState::self()->getContextObject(NULL));
            if (gDefaultServiceManager == NULL)
                sleep(1);
        }
    }

    return gDefaultServiceManager;
}
//注：
/*gDefaultServiceManager = interface_cast<IServiceManager>(

                ProcessState::self()->getContextObject(NULL));

ProcessState::self，肯定返回的是刚才创建的gProcess，然后调用它的getContextObject，注意传进去的是NULL，即0*/

//回到ProcessState类，

sp<IBinder> ProcessState::getContextObject(const sp<IBinder>& /*caller*/)
{
    return getStrongProxyForHandle(0);
}
//进入到getStrongProxyForHandle
//注意这个参数的命名，handle。搞过windows的应该比较熟悉这个名字，
//这是对资源的一种标示，其实说白了就是某个数据结构，保存在数组中，然后handle是它在这个数组中的索引。
sp<IBinder> ProcessState::getStrongProxyForHandle(int32_t handle)
{
    sp<IBinder> result;

    AutoMutex _l(mLock);
    //确实，从数组中查找对应索引的资源，lookupHandleLocked这个就不说了，内部会返回一个handle_entry
    handle_entry* e = lookupHandleLocked(handle);

    //下面是 handle_entry 的结构
    /*
    struct handle_entry {
         IBinder* binder;
         RefBase::weakref_type* refs;//这个不知道是什么
                };
     */
    if (e != NULL) {
        //如果目前没有我们所查找的，就创建一个新的bpbinder，
        //或者我们无法获得这个当前的弱引用。可以在getweakproxyforhandle()中查看更多关于这个的信息。
        IBinder* b = e->binder;//第一次进来，肯定为空
        if (b == NULL || !e->refs->attemptIncWeak(this)) {
            if (handle == 0) {
                //上下文管理器的特殊情况
                //上下文管理器是我们创建一个BpBinder proxy代理在没有持有一个引用的情况下的唯一对象。
                //进行一次虚拟处理来确保上下文管理器在我们创建第一个本地引用之前已经被注册。
                //如果上下文管理器不是当前这个就已经为BpBinder创建了一个本地引用，
                //那么这个驱动将不会提供该引用给这个上下文管理器，并且这个驱动API不会返回任何状态
                // Note that this is not race-free if the context manager
                // dies while this code runs.
                //
                // TODO: add a driver API to wait for context manager, or
                // stop special casing handle 0 for context manager and add
                // a driver API to get a handle to the context manager with
                // proper reference counting.

                Parcel data;
                status_t status = IPCThreadState::self()->transact(
                        0, IBinder::PING_TRANSACTION, data, NULL, 0);
                if (status == DEAD_OBJECT)
                   return NULL;
            }

            b = new BpBinder(handle); //在这里创建了一个新的BpBinder
            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;//返回刚才创建的BpBinder。
}

//到这里，是不是有点迷糊了？函数调用太深的时候，就容易忘记。

/*我们是从gDefaultServiceManager = interface_cast<IServiceManager>(
                ProcessState::self()->getContextObject(NULL));
开始搞的，现在，这个函数调用将变成
gDefaultServiceManager = interface_cast<IServiceManager>(new BpBinder(0));*/

BpBinder又是个什么东东？Android名字起得太眼花缭乱了。
还是继续把层层深入的函数调用栈化繁为简。先看看BpBinder的构造函数。

2.3 BpBinder
BpBinder位置在frameworks/native/libs/binder/BpBinder.cpp中。

BpBinder::BpBinder(int32_t handle)
    : mHandle(handle)//注意，接上述内容，这里调用的时候传入的是0, 
/*SMgr提供的Binder比较特殊，它没有名字也不需要注册，
其次这个Binder的引用在所有Client中都固定为0而无须通过其它手段获得。
也就是说，一个Server若要向SMgr注册自己Binder就必需通过0这个引用号和SMgr的Binder通信。
类比网络通信，0号引用就好比域名服务器的地址，你必须预先手工或动态配置好。
要注意这里说的Client是相对SMgr而言的，一个应用程序可能是个提供服务的Server，但对SMgr来说它仍然是个Client。*/
    , mAlive(1)
    , mObitsSent(0)
    , mObituaries(NULL)
{
    ALOGV("Creating BpBinder %p handle %d\n", this, mHandle);

    extendObjectLifetime(OBJECT_LIFETIME_WEAK);
    IPCThreadState::self()->incWeakHandle(handle);//竟然到IPCThreadState::self()
}

//这里一块说说，IPCThreadState::self估计应该又是一个singleton吧？
//该文件位置在frameworks/native/libs/binder/IPCThreadState.cpp

IPCThreadState* IPCThreadState::self()
{
    if (gHaveTLS) {//第一次进来为false
restart:
        const pthread_key_t k = gTLS;
        //TLS是Thread Local Storage的意思，不懂得自己去google下它的作用吧。这里只需要
        //知道这种空间每个线程有一个，而且线程间不共享这些空间，好处是？
        //就可以免去同步了。在这个线程，我就用这个线程的东西，反正别的线程获取不到其他线程TLS中的数据。
        //从线程本地存储空间中获得保存在其中的IPCThreadState对象
        //这段代码写法很晦涩，只有pthread_getspecific,那么肯定有地方调用pthread_setspecific。
        IPCThreadState* st = (IPCThreadState*)pthread_getspecific(k);
        if (st) return st;
        return new IPCThreadState;
    }

#ifdef _MTK_ENG_BUILD_
    if (gShutdown) {
        IPCThreadState* st = (IPCThreadState*)pthread_getspecific(gTLS);
        ALOGD("IPCThreadState 0x%p, gTLS:%d gHaveTLS:%d\n", &st, gTLS, gHaveTLS);
        return NULL;
    }
#else
    if (gShutdown) return NULL;
#endif

    pthread_mutex_lock(&gTLSMutex);
    if (!gHaveTLS) {
        if (pthread_key_create(&gTLS, threadDestructor) != 0) {
            pthread_mutex_unlock(&gTLSMutex);
            return NULL;
        }
        gHaveTLS = true;
    }
    pthread_mutex_unlock(&gTLSMutex);
    goto restart;//少见的goto语句，直接跳转到restart 去创建IPCThreadState
}

//这里是构造函数，在构造函数里边pthread_setspecific
IPCThreadState::IPCThreadState()
    : mProcess(ProcessState::self()),
      mMyThreadId(gettid()),
      mStrictModePolicy(0),
      mLastTransactionBinderFlags(0)
{
    pthread_setspecific(gTLS, this);
    clearCaller();
    mIn.setDataCapacity(256);
    //mIn,mOut是两个Parcel，干嘛用的啊？把它看成是命令的buffer吧。
    mOut.setDataCapacity(256);
}

new BpBinder就算完了。到这里，我们创建了些什么呢？
（1）ProcessState有了。
（2）IPCThreadState有了，而且是主线程的。
（3）BpBinder有了，内部handle值为0
gDefaultServiceManager = interface_cast<IServiceManager>(new BpBinder(0));
终于回到原点了！

interface_cast，我第一次接触的时候，把它看做类似的static_cast一样的东西，然后死活也搞不明白 BpBinder*指针怎么能强转为IServiceManager*，跟踪进入interface_cast

IInterface.h位于frameworks/native/include/binder/IInterface.h

template<typename INTERFACE>
inline sp<INTERFACE> interface_cast(const sp<IBinder>& obj)
{
    return INTERFACE::asInterface(obj);
}
所以，上面等价于：
inline sp<IServiceManager> interface_cast(const sp<IBinder>& obj)
{
    return IServiceManager::asInterface(obj);
}

看来，只能跟到IServiceManager了。
IServiceManager.h位于frameworks/native/include/binder/IServiceManager.h

看看它是如何定义的:

2.4 IServiceManager

class IServiceManager : public IInterface
{
//ServiceManager,字面上理解就是Service管理类，管理什么？增加服务，查询服务等
//这里仅列出增加服务addService函数
public:
    DECLARE_META_INTERFACE(ServiceManager);

    virtual status_t            addService( const String16& name,
                                            const sp<IBinder>& service,
                                            bool allowIsolated = false) = 0;

/*DECLARE_META_INTERFACE(ServiceManager)？？
和MFC类似,有DELCARE肯定有IMPLEMENT,
这两个宏DECLARE_META_INTERFACE和IMPLEMENT_META_INTERFACE(INTERFACE, NAME)都在刚才的IInterface.h中定义。
我们先看看DECLARE_META_INTERFACE这个宏往IServiceManager加了什么？*/

//下面是DECLARE宏
#define DECLARE_META_INTERFACE(INTERFACE)                               \
    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();  

//我们把它兑现到IServiceManager就是：
static const android::String16 descriptor;//增加一个描述字符串
static android::sp< IServiceManager > asInterface(const android::sp<android::IBinder>&
obj) //增加一个asInterface函数
virtual const android::String16& getInterfaceDescriptor() const;//增加一个get函数估计其返回值就是descriptor这个字符串
IServiceManager ();                                                     \
virtual ~IServiceManager();//增加构造和虚析购函数...

//下面是IMPLEMENT宏的定义
#define IMPLEMENT_META_INTERFACE(INTERFACE, NAME)                       \
    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() { }   

//IMPLEMENT宏兑现到IServiceManager
见IServiceManager.cpp。位于frameworks/native/libs/binder/IServiceManager.cpp

//下面是这个宏的定义的使用
IMPLEMENT_META_INTERFACE(ServiceManager, "android.os.IServiceManager");
//赶紧兑现一下IMPLEMENT宏吧
const
android::String16 IServiceManager::descriptor(“android.os.IServiceManager”);
const android::String16& IServiceManager::getInterfaceDescriptor() const
{  
    return IServiceManager::descriptor;//返回上面那个android.os.IServiceManager
   }                                                                      
   android::sp<IServiceManager> IServiceManager::asInterface(
            const android::sp<android::IBinder>& obj)
    {
        android::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::IServiceManager () { }                                   
    IServiceManager::~ IServiceManager() { }

    /*asInterface是这么搞的，赶紧分析下吧，还是不知道interface_cast怎么把BpBinder*转成了IServiceManager
我们刚才解析过的interface_cast<IServiceManager>(new BpBinder(0)),
原来就是调用asInterface(new BpBinder(0))*/
android::sp<IServiceManager> IServiceManager::asInterface(
            const android::sp<android::IBinder>& obj)
    {
        android::sp<IServiceManager> intr;
        if (obj != NULL) {                                             
            ....                                      
                intr = new BpServiceManager(obj);
            //终于看到和IServiceManager相关的东西了，看来实际返回的是BpServiceManager(new BpBinder(0))；                         
            }                                                          
        }                                                              
        return intr;                                                   
}                     

BpServiceManager是个什么东东？p是什么个意思？

2.5 BpServiceManager
p是proxy即代理的意思，Bp就是BinderProxy，BpServiceManager，就是SM的Binder代理。既然是代理，那肯定希望对用户是透明的，那就是说头文件里边不会有这个Bp的定义，接下来看。
BpServiceManager就在刚才的IServiceManager.cpp中定义。

class BpServiceManager : public BpInterface<IServiceManager>
{
//这种继承方式，表示同时继承BpInterface和IServiceManager，
//这样IServiceManger的addService必然在这个类中实现
public:
//注意构造函数参数的命名 impl，难道这里使用了Bridge模式？真正完成操作的是impl对象？
//这里传入的impl就是new BpBinder(0)
    BpServiceManager(const sp<IBinder>& impl)
        : BpInterface<IServiceManager>(impl)
    {
    }
    ......
    virtual status_t addService(const String16& name, const sp<IBinder>& service,
            bool allowIsolated)
    {
        //下面再讲
        Parcel data, reply;
        data.writeInterfaceToken(IServiceManager::getInterfaceDescriptor());
        data.writeString16(name);
        data.writeStrongBinder(service);
        data.writeInt32(allowIsolated ? 1 : 0);
        status_t err = remote()->transact(ADD_SERVICE_TRANSACTION, data, &reply);
        return err == NO_ERROR ? reply.readExceptionCode() : err;
    }
    ......
    //基类BpInterface的构造函数见frameworks/native/include/binder/IInterface.h
    //（经过兑现后）这里的参数又叫remote，真是害人不浅。
inline BpInterface<IServiceManager>::BpInterface(const sp<IBinder>& remote)
    : BpRefBase(remote)
{
}

};

Binder.cpp位于frameworks/native/libs/binder/Binder.cpp

BpRefBase::BpRefBase(const sp<IBinder>& o)
    : mRemote(o.get()), mRefs(NULL), mState(0)
//o.get()，这个是sp类的获取实际数据指针的一个方法，你只要知道
//它返回的是sp<xxxx>中xxx* 指针就行
{
    extendObjectLifetime(OBJECT_LIFETIME_WEAK);
    //mRemote就是刚才的BpBinder(0)
    if (mRemote) {
        mRemote->incStrong(this);           // Removed on first IncStrong().
        mRefs = mRemote->createWeak(this);  // Held for our entire lifetime.
    }
}

好了，到这里，我们知道了：
sp<IServiceManager> sm = defaultServiceManager(); 返回的实际是BpServiceManager，它的remote对象是BpBinder，传入的那个handle参数是0。

现在重新回到MediaService。

int main(int argc __unused, char** argv)
{
    ......
    sp<ProcessState> proc(ProcessState::self());//获得一个ProcessState实例
    sp<IServiceManager> sm = defaultServiceManager();//得到一个ServiceManager对象
    //上面的讲解已经完了
    MediaPlayerService::instantiate();//初始化MediaPlayerService服务
    //这里值得推敲！
    ......
    ProcessState::self()->startThreadPool();
    IPCThreadState::self()->joinThreadPool();
}

到这里，我们把binder设备打开了，得到一个BpServiceManager对象，这表明我们可以和SM打交道了。

2.6 MediaPlayerService
那下面我们看看后续又干了什么？以MediaPlayerService为例。

它位于frameworks/av/media/libmediaplayerservice/MediaPlayerService.cpp

void MediaPlayerService::instantiate() {
    defaultServiceManager()->addService(
            String16("media.player"), new MediaPlayerService());
                /*传进去服务的名字，传进去new出来的对象*/
}
//defaultServiceManager返回的是刚才创建的BpServiceManager调用它的addService函数。

MediaPlayerService::MediaPlayerService()
{
    ALOGV("MediaPlayerService created");
    MM_LOGI("created");

    mNextConnId = 1;

    mBatteryAudio.refCount = 0;
    for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
        mBatteryAudio.deviceOn[i] = 0;
        mBatteryAudio.lastTime[i] = 0;
        mBatteryAudio.totalTime[i] = 0;
    }
    // speaker is on by default
    mBatteryAudio.deviceOn[SPEAKER] = 1;

    // reset battery stats
    // if the mediaserver has crashed, battery stats could be left
    // in bad state, reset the state upon service start.
    BatteryNotifier& notifier(BatteryNotifier::getInstance());
    notifier.noteResetVideo();
    notifier.noteResetAudio();

    MediaPlayerFactory::registerBuiltinFactories();
}

MediaPlayerService从BnMediaPlayerService派生
见frameworks/av/media/libmediaplayerservice/MediaPlayerService.h

class MediaPlayerService : public BnMediaPlayerService

MediaPlayerService从BnMediaPlayerService派生，BnXXX,BpXXX，快晕了。

Bn 是Binder Native的含义，是和Bp相对的，Bp的p是proxy代理的意思，那么另一端一定有一个和代理打交道的东西，这个就是Bn。
讲到这里会有点乱喔。先分析下，到目前为止都构造出来了什么。

BpServiceManager
BnMediaPlayerService

这两个东西不是相对的两端，从BnXXX就可以判断，BpServiceManager对应的应该是BnServiceManager，BnMediaPlayerService对应的应该是BpMediaPlayerService。
我们现在是创建了BnMediaPlayerService，想把它加入到系统的中去。

我们创建一个新的Service—BnMediaPlayerService，想把它告诉ServiceManager。
那我怎么和ServiceManager通讯呢？利用BpServiceManager。所以嘛，我们调用了BpServiceManager的addService函数！

为什么要搞个ServiceManager来呢？这个和Android机制有关系。所有Service都需要加入到ServiceManager来管理。同时也方便了Client来查询系统存在哪些Service，ServiceManager就相当于我们的DNS域名服务器。没看见我们传入了字符串吗？”media.player”就相当于我们的网络域名，这样就可以通过Human Readable的字符串来查找Service了。

2.7 addService
addService是调用的BpServiceManager的函数。前面略去没讲，现在我们看看。

virtual status_t addService(const String16& name, const sp<IBinder>& service,
            bool allowIsolated)
    {
        Parcel data, reply;
        //data是发送到BnServiceManager的命令包
        //先把Interface名字写进去，也就是什么android.os.IServiceManager
        data.writeInterfaceToken(IServiceManager::getInterfaceDescriptor());

        //再把新service的名字写进去 叫media.player
        data.writeString16(name);

        //把新服务service—>就是MediaPlayerService写到命令中
        data.writeStrongBinder(service);
        data.writeInt32(allowIsolated ? 1 : 0);

        //调用remote的transact函数
        status_t err = remote()->transact(ADD_SERVICE_TRANSACTION, data, &reply);
        return err == NO_ERROR ? reply.readExceptionCode() : err;
    }

remote(){ return mRemote; }
见frameworks/native/include/binder/Binder.h

class BpRefBase : public virtual RefBase
{
protected:
                            BpRefBase(const sp<IBinder>& o);
    virtual                 ~BpRefBase();
    virtual void            onFirstRef();
    virtual void            onLastStrongRef(const void* id);
    virtual bool            onIncStrongAttempted(uint32_t flags, const void* id);

    inline  IBinder*        remote()                { return mRemote; }
    inline  IBinder*        remote() const          { return mRemote; }

private:
                            BpRefBase(const BpRefBase& o);
    BpRefBase&              operator=(const BpRefBase& o);

    IBinder* const          mRemote;
    RefBase::weakref_type*  mRefs;
    volatile int32_t        mState;
};

}; 

这里的mRemote就是最初创建的BpBinder..
到那里去看看：

//BpBinder的位置在frameworks/native/libs/binder/BpBinder.cpp
status_t BpBinder::transact(
    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
    // Once a binder has died, it will never come back to life.
    if (mAlive) {
    //又绕回去了，调用IPCThreadState的transact。
    //注意：这里的mHandle为0,code是ADD_SERVICE_TRANSACTION,data是命令包
    //reply是回复包，flags=0
        status_t status = IPCThreadState::self()->transact(
            mHandle, code, data, reply, flags);
        if (status == DEAD_OBJECT) mAlive = 0;
        return status;
    }

    return DEAD_OBJECT;
}

//再看看IPCThreadState的transact函数吧
//见frameworks/native/libs/binder/IPCThreadState.cpp
status_t IPCThreadState::transact(int32_t handle,
                                  uint32_t code, const Parcel& data,
                                  Parcel* reply, uint32_t flags)
{
    status_t err = data.errorCheck();

    flags |= TF_ACCEPT_FDS;

    //......

    if (err == NO_ERROR) {
        //调用writeTransactionData 发送数据
        err = writeTransactionData(BC_TRANSACTION, flags, handle, code, data, NULL);
    }

    if (err != NO_ERROR) {
        if (reply) reply->setError(err);

        return (mLastError = err);
    }

    if ((flags & TF_ONE_WAY) == 0) {

        if (reply) {
            err = waitForResponse(reply);
        } else {
            Parcel fakeReply;
            err = waitForResponse(&fakeReply);
        }


    } else {
        //......等回复
        err = waitForResponse(NULL, NULL);
    }

    ......
    return err;
}

//再进一步，瞧瞧writeTransactionData 
status_t IPCThreadState::writeTransactionData(int32_t cmd, uint32_t binderFlags,
    int32_t handle, uint32_t code, const Parcel& data, status_t* statusBuffer)
{
    binder_transaction_data tr;

    tr.target.ptr = 0; /* Don't pass uninitialized stack data to a remote process */
    tr.target.handle = handle;
    tr.code = code;
    tr.flags = binderFlags;
    tr.cookie = 0;
    tr.sender_pid = 0;
    tr.sender_euid = 0;

    const status_t err = data.errorCheck();
    if (err == NO_ERROR) {
        tr.data_size = data.ipcDataSize();
        tr.data.ptr.buffer = data.ipcData();
        tr.offsets_size = data.ipcObjectsCount()*sizeof(binder_size_t);
        tr.data.ptr.offsets = data.ipcObjects();
    } 
    ....

    //上面把命令数据封装成binder_transaction_data，然后

    //写到mOut中，mOut是命令的缓冲区，也是一个Parcel
    mOut.writeInt32(cmd);
    mOut.write(&tr, sizeof(tr));
    //仅仅写到了Parcel中，Parcel好像没和/dev/binder设备有什么关联啊？
    //那只能在另外一个地方写到binder设备中去了。
    return NO_ERROR;
}

//就是在waitForResponse中
status_t IPCThreadState::waitForResponse(Parcel *reply, status_t *acquireResult)
{
    uint32_t cmd;
    int32_t err;

    while (1) {
        //talkWithDriver，应该是这里了
        if ((err=talkWithDriver()) < NO_ERROR) break;
        err = mIn.errorCheck();
        if (err < NO_ERROR) break;
        if (mIn.dataAvail() == 0) continue;
            //这里开始操作mIn了，看来talkWithDriver中
            //把mOut发出去，然后从driver中读到数据放到mIn中了。
        cmd = (uint32_t)mIn.readInt32();

        }

        switch (cmd) {
        case BR_TRANSACTION_COMPLETE:
            if (!reply && !acquireResult) goto finish;
            break;

       ......

    return err;
}

status_t IPCThreadState::talkWithDriver(bool doReceive)
{
    binder_write_read bwr;
    ......

    //中间东西太复杂了，不就是把mOut数据和mIn接收数据的处理后赋值给bwr吗？
    status_t err;
    do {
        ......
        //用ioctl来读写
        if (ioctl(mProcess->mDriverFD, BINDER_WRITE_READ, &bwr) >= 0)
            err = NO_ERROR;
        else {
            err = -errno;
        }

        if (mProcess->mDriverFD <= 0) {
            err = -EBADF;
        }
    } while (err == -EINTR);

    if (err >= NO_ERROR) {
        ......
        //到这里，回复数据就在bwr中了，bwr接收回复数据的buffer就是mIn提供的
        if (bwr.read_consumed > 0) {
            mIn.setDataSize(bwr.read_consumed);
            mIn.setDataPosition(0);
        }
        return NO_ERROR;
    }

    return err;
}

好了，到这里，我们发送addService的流程就彻底走完了。
BpServiceManager发送了一个addService命令到BnServiceManager，然后收到回复。
先继续我们的main函数。

int main(int argc __unused, char** argv)
{
    ......
    sp<ProcessState> proc(ProcessState::self());//获得一个ProcessState实例
    sp<IServiceManager> sm = defaultServiceManager();//得到一个ServiceManager对象

    //该函数内部调用addService，把MediaPlayerService信息 add到ServiceManager中
    MediaPlayerService::instantiate();//初始化MediaPlayerService服务
    ......
    ProcessState::self()->startThreadPool();
    IPCThreadState::self()->joinThreadPool();
}

这里有个容易搞晕的地方：
MediaPlayerService是一个BnMediaPlayerService,那么它是不是应该等着
BpMediaPlayerService来和他交互呢?但是我们没看见MediaPlayerService有打开binder设备的操作啊！
这个嘛，到底是继续addService操作的另一端BnServiceManager还是先说
BnMediaPlayerService呢？
还是先说BnServiceManager吧。顺便把系统的Binder架构说说。

2.8 BnServiceManager
上面说了，defaultServiceManager返回的是一个BpServiceManager，通过它可以把命令请求发送到binder设备，而且handle的值为0。那么，系统的另外一端肯定有个接收命令的，那又是谁呢？
很可惜啊，BnServiceManager不存在，但确实有一个程序完成了BnServiceManager的工作，那就是service.exe(如果在windows上一定有exe后缀，叫service的名字太多了，这里加exe就表明它是一个程序)

位置在frameworks/native/cmds/servicemanager/service_manager.c中。

int main(int argc, char **argv)
{
    struct binder_state *bs;
    //应该是打开binder设备吧？
    bs = binder_open(128*1024);
    if (!bs) {
        ALOGE("failed to open binder driver\n");
        return -1;
    }
    //成为manager
    if (binder_become_context_manager(bs)) {
        ALOGE("cannot become context manager (%s)\n", strerror(errno));
        return -1;
    }
    ......

    //处理BpServiceManager发过来的命令
    binder_loop(bs, svcmgr_handler);

    return 0;
}
//看看binder_open是不是和我们猜得一样？
//见frameworks/native/cmds/servicemanager/binder.c
struct binder_state *binder_open(size_t mapsize)
{
    struct binder_state *bs;
    struct binder_version vers;

    bs = malloc(sizeof(*bs));
    ......
    bs->fd = open("/dev/binder", O_RDWR);//确实如此
    ......

    bs->mapsize = mapsize;
    bs->mapped = mmap(NULL, mapsize, PROT_READ, MAP_PRIVATE, bs->fd, 0);
    ......
    return bs;
fail_map:
    close(bs->fd);
fail_open:
    free(bs);
    return NULL;
}

//再看看binder_become_context_manager
int binder_become_context_manager(struct binder_state *bs)
{
    return ioctl(bs->fd, BINDER_SET_CONTEXT_MGR, 0);//把自己设为MANAGER
}

//binder_loop 肯定是从binder设备中读请求，写回复的这么一个循环吧？
void binder_loop(struct binder_state *bs, binder_handler func)
{
    int res;
    struct binder_write_read bwr;
    uint32_t readbuf[32];

    bwr.write_size = 0;
    bwr.write_consumed = 0;
    bwr.write_buffer = 0;

    readbuf[0] = BC_ENTER_LOOPER;
    binder_write(bs, readbuf, sizeof(uint32_t));

    for (;;) {//果然是循环
        bwr.read_size = sizeof(readbuf);
        bwr.read_consumed = 0;
        bwr.read_buffer = (uintptr_t) readbuf;

        res = ioctl(bs->fd, BINDER_WRITE_READ, &bwr);

        if (res < 0) {
            ALOGE("binder_loop: ioctl failed (%s)\n", strerror(errno));
            break;
        }
        //收到请求了，解析命令
        res = binder_parse(bs, 0, (uintptr_t) readbuf, bwr.read_consumed, func);
        ......
    }
}
//这个...后面还要说吗？？
//恩，最后有一个类似handleMessage的地方处理各种各样的命令。这个就是
//svcmgr_handler,就在在frameworks/native/cmds/servicemanager/service_manager.c中
int svcmgr_handler(struct binder_state *bs,
                   struct binder_transaction_data *txn,
                   struct binder_io *msg,
                   struct binder_io *reply)
{
    struct svcinfo *si;
    uint16_t *s;
    size_t len;
    uint32_t handle;
    uint32_t strict_policy;
    int allow_isolated;

    ......
    s = bio_get_string16(msg, &len);
    ......
    switch(txn->code) {
    ......
    case SVC_MGR_ADD_SERVICE:
        s = bio_get_string16(msg, &len);
        if (s == NULL) {
            return -1;
        }
        handle = bio_get_ref(msg);
        allow_isolated = bio_get_uint32(msg) ? 1 : 0;
        if (do_add_service(bs, s, len, handle, txn->sender_euid,
            allow_isolated, txn->sender_pid))
            return -1;
        break;
    ......    
}
//其中，do_add_service真正添加BnMediaService信息
int do_add_service(struct binder_state *bs,
                   const uint16_t *s, size_t len,
                   uint32_t handle, uid_t uid, int allow_isolated,
                   pid_t spid)
{
    struct svcinfo *si;
    ......
    si = find_svc(s, len);//s是一个list
    if (si) {
        if (si->handle) {
            ALOGE("add_service('%s',%x) uid=%d - ALREADY REGISTERED, OVERRIDE\n",
                 str8(s, len), handle, uid);
            svcinfo_death(bs, si);
        }
        si->handle = handle;
    } else {
        si = malloc(sizeof(*si) + (len + 1) * sizeof(uint16_t));
        if (!si) {
            ALOGE("add_service('%s',%x) uid=%d - OUT OF MEMORY\n",
                 str8(s, len), handle, uid);
            return -1;
        }
        si->handle = handle;
        si->len = len;
        memcpy(si->name, s, (len + 1) * sizeof(uint16_t));
        si->name[len] = '\0';
        si->death.func = (void*) svcinfo_death;
        si->death.ptr = si;
        si->allow_isolated = allow_isolated;
        si->next = svclist;
        svclist = si; //这个svclist是一个列表，保存了当前注册到ServiceManager中的信息
    }

    binder_acquire(bs, handle);
    //这个吗。当这个Service退出后，我希望系统通知我一下，好释放上面malloc出来的资源。大概就是干这个事情的。
    binder_link_to_death(bs, handle, &si->death);
    return 0;
}

对于addService来说，看来ServiceManager把信息加入到自己维护的一个服务列表中了。

2.9 ServiceManager存在的意义
为何需要一个这样的东西呢？

原来，Android系统中Service信息都是先add到ServiceManager中，由ServiceManager来集中管理，这样就可以查询当前系统有哪些服务。而且,Android系统中某个服务例如MediaPlayerService的客户端想要和MediaPlayerService通讯的话，必须先向ServiceManager查询MediaPlayerService的信息，然后通过ServiceManager返回的东西再来和MediaPlayerService交互。

毕竟，要是MediaPlayerService身体不好，老是挂掉的话，客户的代码就麻烦了，就不知道后续新生的MediaPlayerService的信息了，所以只能这样：

• MediaPlayerService向SM注册

• MediaPlayerClient查询当前注册在SM中的MediaPlayerService的信息

• 根据这个信息，MediaPlayerClient和MediaPlayerService交互

另外，ServiceManager的handle标示是0，所以只要往handle是0的服务发送消息了，最终都会被传递到ServiceManager中去。

三、 MediaService的运行

上一节的知识，我们知道了：

• defaultServiceManager得到了BpServiceManager，然后MediaPlayerService 实例化后，调用BpServiceManager的addService函数

• 这个过程中，是service_manager收到addService的请求，然后把对应信息放到自己保存的一个服务list中

到这儿，我们可看到，service_manager有一个binder_looper函数，专门等着从binder中接收请求。虽然service_manager没有从BnServiceManager中派生，但是它肯定完成了BnServiceManager的功能。

同样，我们创建了MediaPlayerService即BnMediaPlayerService，那它也应该：

• 打开binder设备

• 也搞一个looper循环，然后坐等请求service

service，这个和网络编程中的监听socket的工作很像嘛！
好吧，既然MediaPlayerService的构造函数没有看到显示的打开binder设备，那么我们看看它的父类即BnXXX又到底干了些什么呢？

3.1 MediaPlayerService打开binder
见frameworks/av/media/libmediaplayerservice/MediaPlayerService.h

class MediaPlayerService : public BnMediaPlayerService
{
    // MediaPlayerService从BnMediaPlayerService派生

    ......
}
//而BnMediaPlayerService从BnInterface和IMediaPlayerService同时派生

见frameworks/av/include/media/IMediaPlayerService.h

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

//看起来，BnInterface似乎更加和打开设备相关。
//见frameworks/native/include/binder/IInterface.h
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 BnInterface : public IMediaPlayerService, public BBinder

BBinder?BpBinder？是不是和BnXXX以及BpXXX对应的呢？如果是，为什么又叫BBinder呢？

BBinder::BBinder()

    : mExtras(NULL)

{

//没有打开设备的地方啊？

}

回想下，我们的Main_MediaService程序，有哪里打开过binder吗？

int main(int argc __unused, char** argv)
{
    ......
    //对啊，我在ProcessState中不是打开过binder了吗？
    sp<ProcessState> proc(ProcessState::self());
    sp<IServiceManager> sm = defaultServiceManager();

    MediaPlayerService::instantiate();

    ......
}

3.2 looper
原来打开binder设备的地方是和进程相关的，一个进程打开一个就可以了。那么，我在哪里进行类似的消息循环looper操作呢？

......
//难道是下面两个？
ProcessState::self()->startThreadPool();//像是启动Process的线程池？
IPCThreadState::self()->joinThreadPool();//然后将自己加入到刚才的线程池？
//看看startThreadPool吧
void ProcessState::startThreadPool()
{
    AutoMutex _l(mLock);
    if (!mThreadPoolStarted) {
        mThreadPoolStarted = true;
        spawnPooledThread(true);
    }
}

void ProcessState::spawnPooledThread(bool isMain)
{
    if (mThreadPoolStarted) {
        String8 name = makeBinderThreadName();
        ALOGV("Spawning new pooled thread, name=%s\n", name.string());
        sp<Thread> t = new PoolThread(isMain);//isMain是TRUE
        //创建线程池，然后run起来，和java的Thread何其像也。
        t->run(name.string());
    }
}
//PoolThread从Thread类中派生，那么此时会产生一个线程吗？看看PoolThread和Thread的构造吧
class PoolThread : public Thread
{
public:
    PoolThread(bool isMain)
        : mIsMain(isMain)
    {
    }
    ......
};

//Thread的构造见system/core/libutils/Threads.cpp
Thread::Thread(bool canCallJava)//canCallJava默认值是true
    :   mCanCallJava(canCallJava),
        mThread(thread_id_t(-1)),
        mLock("Thread::mLock"),
        mStatus(NO_ERROR),
        mExitPending(false), mRunning(false)
#ifdef HAVE_ANDROID_OS
        , mTid(-1)
#endif
{
}
//这个时候还没有创建线程呢。然后调用PoolThread::run，实际调用了基类的run。
status_t Thread::run(const char* name, int32_t priority, size_t stack)
{
    ......

    bool res;
    if (mCanCallJava) {
        res = createThreadEtc(_threadLoop,
                this, name, priority, stack, &mThread);
    } else {
        res = androidCreateRawThreadEtc(_threadLoop,
                this, name, priority, stack, &mThread);
    }
    ......

    return NO_ERROR;
}

//createThreadEtc见system/core/include/utils/AndroidThreads.h
inline bool createThreadEtc(thread_func_t entryFunction,
                            void *userData,
                            const char* threadName = "android:unnamed_thread",
                            int32_t threadPriority = PRIORITY_DEFAULT,
                            size_t threadStackSize = 0,
                            thread_id_t *threadId = 0)
{
    return androidCreateThreadEtc(entryFunction, userData, threadName,
        threadPriority, threadStackSize, threadId) ? true : false;
}

//终于，在run函数中，创建线程了。从此主线程执行
IPCThreadState::self()->joinThreadPool();

//新开的线程执行_threadLoop
//我们先看看_threadLoop
int Thread::_threadLoop(void* user)
{
    Thread* const self = static_cast<Thread*>(user);

    sp<Thread> strong(self->mHoldSelf);
    wp<Thread> weak(strong);
    self->mHoldSelf.clear();
    ......
    do {
        bool result;
        ......

            if (result && !self->exitPending()) {

                result = self->threadLoop();//调用自己的threadLoop
            }
        } else {
            result = self->threadLoop();
        }
    ......      
    return 0;
}
//我们是PoolThread对象，所以调用PoolThread的threadLoop函数
virtual bool threadLoop()
{
    IPCThreadState* ipc = IPCThreadState::self();
//mIsMain为true。
//而且注意，这是一个新的线程，所以必然会创建一个
//新的IPCThreadState对象（记得线程本地存储吗？TLS），然后      
    if(ipc)
        ipc->joinThreadPool(mIsMain);
    //IPCThreadState::self()->joinThreadPool(mIsMain);
    return false;
}

//主线程和工作线程都调用了joinThreadPool，看看这个干嘛了！
void IPCThreadState::joinThreadPool(bool isMain)
{
    mOut.writeInt32(isMain ? BC_ENTER_LOOPER : BC_REGISTER_LOOPER);

    set_sched_policy(mMyThreadId, SP_FOREGROUND);   
    status_t result;
    do {
        processPendingDerefs();
        // now get the next command to be processed, waiting if necessary
        result = getAndExecuteCommand();
        ......
        // Let this thread exit the thread pool if it is no longer
        // needed and it is not the main process thread.
        if(result == TIMED_OUT && !isMain) {
            break;
        }
    } while (result != -ECONNREFUSED && result != -EBADF);

    mOut.writeInt32(BC_EXIT_LOOPER);
    talkWithDriver(false);
}
//看到没？有loop了，但是好像是有两个线程都执行了这个！这里有两个消息循环？
//getAndExecuteCommand中调用了executeCommand
status_t IPCThreadState::getAndExecuteCommand()
{
    status_t result;
    int32_t cmd;

    result = talkWithDriver();
    if (result >= NO_ERROR) {
        size_t IN = mIn.dataAvail();
        if (IN < sizeof(int32_t)) return result;
        cmd = mIn.readInt32();

        pthread_mutex_lock(&mProcess->mThreadCountLock);
        mProcess->mExecutingThreadsCount++;
        pthread_mutex_unlock(&mProcess->mThreadCountLock);

        result = executeCommand(cmd);

        pthread_mutex_lock(&mProcess->mThreadCountLock);
        mProcess->mExecutingThreadsCount--;
        pthread_cond_broadcast(&mProcess->mThreadCountDecrement);
        pthread_mutex_unlock(&mProcess->mThreadCountLock);

        set_sched_policy(mMyThreadId, SP_FOREGROUND);
    }

    return result;
}
//下面看看executeCommand
status_t IPCThreadState::executeCommand(int32_t cmd)
{
    BBinder* obj;
    RefBase::weakref_type* refs;
    status_t result = NO_ERROR;

    switch ((uint32_t)cmd) {
    case BR_TRANSACTION:
        {
            binder_transaction_data tr;
            result = mIn.read(&tr, sizeof(tr));
            //来了一个命令，解析成BR_TRANSACTION,然后读取后续的信息
            Parcel reply;
            status_t error;

            if (tr.target.ptr) {
                //这里用的是BBinder。
                if (reinterpret_cast<RefBase::weakref_type*>(
                        tr.target.ptr)->attemptIncStrong(this)) {
                    error = reinterpret_cast<BBinder*>(tr.cookie)->transact(tr.code, buffer,
                            &reply, tr.flags);
                    reinterpret_cast<BBinder*>(tr.cookie)->decStrong(this);
                } else {
                    error = UNKNOWN_TRANSACTION;
                }

            }
}
//让我们看看BBinder的transact函数干嘛了
//见frameworks/native/libs/binder/Binder.cpp
status_t BBinder::transact(
    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
    data.setDataPosition(0);

    status_t err = NO_ERROR;
    switch (code) {
        case PING_TRANSACTION:
            reply->writeInt32(pingBinder());
            break;
        default:
            //就是调用自己的onTransact函数嘛
            err = onTransact(code, data, reply, flags);
            break;
    }

    if (reply != NULL) {
        reply->setDataPosition(0);
    }

    return err;
}
//BnMediaPlayerService从BnInterface派生，BnInterface从BBinder派生，所以会调用到它的onTransact函数 
//终于水落石出了，让我们看看BnMediaPlayerServcice的onTransact函数。
status_t BnMediaPlayerService::onTransact(
    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
    // BnMediaPlayerService从BBinder和IMediaPlayerService派生，所有IMediaPlayerService
    //看到下面的switch没？所有IMediaPlayerService提供的函数都通过命令类型来区分
    switch (code) {
        case CREATE: {
                CHECK_INTERFACE(IMediaPlayerService, data, reply);
                //create是一个虚函数，由MediaPlayerService来实现！！
                //见frameworks/av/media/libmediaplayerservice/MediaPlayerService.h
                //MediaPlayerService从BnMediaPlayerService派生
                sp<IMediaPlayerClient> client =
                    interface_cast<IMediaPlayerClient>(data.readStrongBinder());
                int audioSessionId = data.readInt32();
                sp<IMediaPlayer> player = create(client, audioSessionId);
                reply->writeStrongBinder(IInterface::asBinder(player));
                return NO_ERROR;
            } break;
            ......
        }
}

其实，到这里，我们就明白了。BnXXX的onTransact函数收取命令，然后派发到派生类的函数，由他们完成实际的工作。

说明：

这里有点特殊，startThreadPool和joinThreadPool完后确实有两个线程，主线程和工作线程，而且都在做消息循环。为什么要这么做呢？他们参数isMain都是true。不知道google搞什么。难道是怕一个线程工作量太多，所以搞两个线程来工作？这种解释应该也是合理的。

网上有人测试过把最后一句屏蔽掉，也能正常工作。但是难道主线程退出了，程序还能不退出吗？这个…管它的，反正知道有两个线程在那处理就行了。

四、 MediaPlayerClient

这节讲讲MediaPlayerClient怎么和MediaPlayerService交互。
使用MediaPlayerService的时候，先要创建它的BpMediaPlayerService。我们看看一个例子
见frameworks/av/media/libmedia/IMediaDeathNotifier.cpp

// establish binder interface to MediaPlayerService
/*static*/const sp<IMediaPlayerService>
IMediaDeathNotifier::getMediaPlayerService()
{
    ALOGV("getMediaPlayerService");
    Mutex::Autolock _l(sServiceLock);
    if (sMediaPlayerService == 0) {
        sp<IServiceManager> sm = defaultServiceManager();
        sp<IBinder> binder;
        do {
            //向SM查询对应服务的信息，返回binder 
            binder = sm->getService(String16("media.player"));
            if (binder != 0) {
                break;
            }
            ALOGW("Media player service not published, waiting...");
            usleep(500000); // 0.5 s
        } while (true);

        if (sDeathNotifier == NULL) {
            sDeathNotifier = new DeathNotifier();
        }
        binder->linkToDeath(sDeathNotifier);
        //通过interface_cast，将这个binder转化成BpMediaPlayerService
        //注意，这个binder只是用来和binder设备通讯用的， 
        //实际上和IMediaPlayerService的功能一点关系都没有。        
        //还记得我说的Bridge模式吗?
        //BpMediaPlayerService用这个binder和BnMediaPlayerService通讯。
        sMediaPlayerService = interface_cast<IMediaPlayerService>(binder);
    }
    ALOGE_IF(sMediaPlayerService == 0, "no media player service!?");
    return sMediaPlayerService;
}

为什么反复强调这个Bridge？其实也不一定是Bridge模式，但是我真正想说明的是：

Binder其实就是一个和binder设备打交道的接口，而上层IMediaPlayerService只不过把它当做一个类似socket使用罢了。我以前经常把binder和上层类IMediaPlayerService的功能混到一起去。所以有一点请注意：

4.1 Native层
刚才那个getMediaPlayerService代码是C++层的，但是整个使用的例子确实JAVA->JNI层的调用。如果我要写一个纯C++的程序该怎么办？

int main()
{
  getMediaPlayerService();//直接调用这个函数能获得BpMediaPlayerService吗？
//不能，为什么？因为我还没打开binder驱动呐！但是你在JAVA应用程序里边却有google已经替你封装好了。
//所以，纯native层的代码，必须也得像下面这样处理：

sp<ProcessState> proc(ProcessState::self());//这个其实不是必须的，因为

//好多地方都需要这个，所以自动也会创建.

getMediaPlayerService();

//还得起消息循环呐，否则如果Bn那边有消息通知你，你怎么接受得到呢？

ProcessState::self()->startThreadPool();

//至于主线程是否也需要调用消息循环，就看个人而定了。不过一般是等着接收其他来源的消息，例如socket发来的命令，然后控制MediaPlayerService就可以了。

}

五、实现自己的Service
好了，我们学习了这么多Binder的东西，那么想要实现一个自己的Service该咋办呢？
如果是纯C++程序的话，肯定得类似main_MediaService那样干了。

int main()
{
    sp<ProcessState> proc(ProcessState::self());
    sp<IServiceManager> sm = defaultServiceManager();   
    sm->addService(“service.name”,new XXXService());    
    ProcessState::self()->startThreadPool();    
    IPCThreadState::self()->joinThreadPool();

}

//看看XXXService怎么定义呢？
//我们需要一个Bn，需要一个Bp，而且Bp不用暴露出来。那么就在BnXXX.cpp中一起实现好了。
//另外，XXXService提供自己的功能，例如getXXX调用

5.1 定义XXX接口
XXX接口是和XXX服务相关的，例如提供getXXX，setXXX函数，和应用逻辑相关。
需要从IInterface派生

class IXXX: public IInterface
{
public:

DECLARE_META_INTERFACE(XXX);//申明宏

virtual getXXX() = 0;

virtual setXXX() = 0;

}//这是一个接口。

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

其中BnXXX是需要有头文件的。BnXXX只不过是把IXXX接口加入到Binder架构中来，而不参与实际的getXXX和setXXX应用层逻辑。
这个BnXXX定义可以和上面的IXXX定义放在一块。分开也行。

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依然是一个纯虚类

};

有了DECLARE，那我们在某个CPP中IMPLEMNT它吧。那就在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; //SET_XXX类似

BpXXX也在这里实现吧。

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;
    }
    //setXXX类似
}

至此，Binder就算分析完了，大家看完后，应该能做到以下几点：

• 如果需要写自己的Service的话，总得知道系统是怎么个调用你的函数。有2个线程在那不停得从binder设备中收取命令，然后调用你的函数。这是个多线程问题。

• 如果需要跟踪bug的话，得知道从Client端调用的函数，是怎么最终传到到远端的Service。这样，对于一些函数调用，Client端跟踪完了，我就知道转到Service去看对应函数调用了。反正是同步方式。也就是Client一个函数调用会一直等待到Service返回为止。