binder机制

接上一篇文章binder机制一

一、BpServiceManager是什么：

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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)
    {
       待会再说..
}
基类BpInterface的构造函数（经过兑现后）
//这里的参数又叫remote，唉，真是害人不浅啊。
inline BpInterface< IServiceManager >::BpInterface(const sp<IBinder>& remote)
    : BpRefBase(remote)
{
}
BpRefBase::BpRefBase(const sp<IBinder>& o)
    : mRemote(o.get()), mRefs(NULL), mState(0)
//o.get()，这个是sp类的获取实际数据指针的一个方法，你只要知道
//它返回的是sp<xxxx>中xxx* 指针就行
{
//mRemote就是刚才的BpBinder(0)
   ...
}

好了，到这里，我们知道了：
sp sm = defaultServiceManager(); 返回的实际是BpServiceManager，它的remote对象是BpBinder，传入的那个handle参数是0。
回到上一篇文章的起点：

1
2
3
4
5
6
7
8
9
10
11
int main(int argc, char** argv)
{
    sp<ProcessState> proc(ProcessState::self());
    sp<IServiceManager> sm = defaultServiceManager();
    //上面的讲解已经完了
    MediaPlayerService::instantiate();//实例化MediaPlayerservice
    //看来这里有名堂！
 
    ProcessState::self()->startThreadPool();
    IPCThreadState::self()->joinThreadPool();
}

二、MediaPlayerService

那下面我们看看后续又干了什么？以MediaPlayerService为例。
它位于/frameworks/av/media/libmediaplayerservice/MediaPlayerService.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
266 void MediaPlayerService::instantiate() {
267    defaultServiceManager()->addService(    //传进来服务的名字，穿件去new出来的对象
268            String16("media.player"), new MediaPlayerService());
269}
270
271MediaPlayerService::MediaPlayerService()
272{
273    ALOGV("MediaPlayerService created");
274    mNextConnId = 1;
275
276    mBatteryAudio.refCount = 0;
277    for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
278        mBatteryAudio.deviceOn[i] = 0;
279        mBatteryAudio.lastTime[i] = 0;
280        mBatteryAudio.totalTime[i] = 0;
281    }
282    // speaker is on by default
283    mBatteryAudio.deviceOn[SPEAKER] = 1;
284    // defaultServiceManager返回的是刚才创建的BpServiceManager调用它的addService函数。
285    // reset battery stats
286    // if the mediaserver has crashed, battery stats could be left
287    // in bad state, reset the state upon service start.
288    BatteryNotifier::getInstance().noteResetVideo();
290    MediaPlayerFactory::registerBuiltinFactories();
291}

MediaPlayerService从BnMediaPlayerService派生
class MediaPlayerService : public BnMediaPlayerService

FT，MediaPlayerService从BnMediaPlayerService派生。
Bn 是Binder Native的含义，是和Bp相对的，Bp的p是proxy代理的意思，那么另一端一定有一个和代理打交道的东西，这个就是Bn。
讲到这里会有点乱喔。先分析下，到目前为止都构造出来了什么。
lBpServiceManager
lBnMediaPlayerService
这两个东西不是相对的两端，从BnXXX就可以判断，BpServiceManager对应的应该是BnServiceManager，BnMediaPlayerService对应的应该是BpMediaPlayerService。
我们现在在哪里?对了，我们现在是创建了BnMediaPlayerService，想把它加入到系统的中去。
我创建一个新的Service—BnMediaPlayerService，想把它告诉ServiceManager。
那我怎么和ServiceManager通讯呢？恩，利用BpServiceManager。所以嘛，我调用了BpServiceManager的addService函数！
为什么要搞个ServiceManager来呢？这个和Android机制有关系。所有Service都需要加入到ServiceManager来管理。同时也方便了Client来查询系统存在哪些Service，没看见我们传入了字符串吗？这样就可以通过Human Readable的字符串来查找Service了。

三、addService

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
virtual status_t addService(const String16& name, const sp<IBinder>& service)
    {
        Parcel data, reply;
        //data是发送到BnServiceManager的命令包
        //看见没？先把Interface名字写进去，也就是什么android.os.IServiceManager
        data.writeInterfaceToken(IServiceManager::getInterfaceDescriptor());
        //再把新service的名字写进去 叫media.player
        data.writeString16(name);
        //把新服务service—>就是MediaPlayerService写到命令中
        data.writeStrongBinder(service);
        //调用remote的transact函数
        status_t err = remote()->transact(ADD_SERVICE_TRANSACTION, data, &reply);
        return err == NO_ERROR ? reply.readInt32() : err;
}

我的天，remote()返回的是什么？
remote(){ return mRemote; }–>啊？找不到对应的实际对象了？？？
还记得我们刚才初始化时候说的：
“这里的参数又叫remote，唉，真是害人不浅啊“
原来，这里的mRemote就是最初创建的BpBinder..
好吧，到那里去看看：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
BpBinder的位置在framework\native\libs\binder\BpBinder.cpp
status_t BpBinder::transact(
    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
//又绕回去了，调用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;
    }
...
}
再看看IPCThreadState的transact函数把
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 ((flags & TF_ONE_WAY) == 0) {
        if (reply) {
            err = waitForResponse(reply);
        } else {
            Parcel fakeReply;
            err = waitForResponse(&fakeReply);
        }
      ....等回复
        err = waitForResponse(NULL, NULL);
   ....   
    return err;
}
再进一步，瞧瞧这个...
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.handle = handle;
    tr.code = code;
    tr.flags = binderFlags;
   
    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(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)
{
    int32_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 = 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;
  } while (err == -EINTR);
//到这里，回复数据就在bwr中了，bmr接收回复数据的buffer就是mIn提供的
        if (bwr.read_consumed > 0) {
            mIn.setDataSize(bwr.read_consumed);
            mIn.setDataPosition(0);
        }
return NO_ERROR;
}

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

1
2
3
4
5
6
7
8
9
int main(int argc, char** argv)
{
    sp<ProcessState> proc(ProcessState::self());
    sp<IServiceManager> sm = defaultServiceManager();   
MediaPlayerService::instantiate();
---》该函数内部调用addService，把MediaPlayerService信息 add到ServiceManager中
    ProcessState::self()->startThreadPool();
    IPCThreadState::self()->joinThreadPool();
}

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

四、BnServiceManager

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
int main(int argc, char **argv)
{
    struct binder_state *bs;
    void *svcmgr = BINDER_SERVICE_MANAGER;
    bs = binder_open(128*1024);//应该是打开binder设备吧？
    binder_become_context_manager(bs) //成为manager
    svcmgr_handle = svcmgr;
    binder_loop(bs, svcmgr_handler);//处理BpServiceManager发过来的命令
}
看看binder_open是不是和我们猜得一样？
struct binder_state *binder_open(unsigned mapsize)
{
    struct binder_state *bs;
    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);
  }
再看看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;
    readbuf[0] = BC_ENTER_LOOPER;
    binder_write(bs, readbuf, sizeof(unsigned));
    for (;;) {//果然是循环
        bwr.read_size = sizeof(readbuf);
        bwr.read_consumed = 0;
        bwr.read_buffer = (unsigned) readbuf;
 
        res = ioctl(bs->fd, BINDER_WRITE_READ, &bwr);
      //哈哈，收到请求了，解析命令
        res = binder_parse(bs, 0, readbuf, bwr.read_consumed, func);
  }
这个...后面还要说吗？？
恩，最后有一个类似handleMessage的地方处理各种各样的命令。这个就是
svcmgr_handler,就在ServiceManager.c中
int svcmgr_handler(struct binder_state *bs,
                   struct binder_txn *txn,
                   struct binder_io *msg,
                   struct binder_io *reply)
{
    struct svcinfo *si;
    uint16_t *s;
    unsigned len;
    void *ptr;
 
    s = bio_get_string16(msg, &len);
    switch(txn->code) {
    case SVC_MGR_ADD_SERVICE:
        s = bio_get_string16(msg, &len);
        ptr = bio_get_ref(msg);
        if (do_add_service(bs, s, len, ptr, txn->sender_euid))
            return -1;
        break;
...
其中，do_add_service真正添加BnMediaService信息
int do_add_service(struct binder_state *bs,
                   uint16_t *s, unsigned len,
                   void *ptr, unsigned uid)
{
    struct svcinfo *si;
    si = find_svc(s, len);s是一个list
     si = malloc(sizeof(*si) + (len + 1) * sizeof(uint16_t));
       si->ptr = ptr;
        si->len = len;
        memcpy(si->name, s, (len + 1) * sizeof(uint16_t));
        si->name[len] = '\0';
        si->death.func = svcinfo_death;
        si->death.ptr = si;
        si->next = svclist;
        svclist = si; //看见没，这个svclist是一个列表，保存了当前注册到ServiceManager
中的信息
    }
   binder_acquire(bs, ptr);//这个吗。当这个Service退出后，我希望系统通知我一下，好释放上面malloc出来的资源。大概就是干这个事情的。
    binder_link_to_death(bs, ptr, &si->death);
    return 0;
}

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

五ServiceManager存在的意义

为何需要一个这样的东西呢？
原来，Android系统中Service信息都是先add到ServiceManager中，由ServiceManager来集中管理，这样就可以查询当前系统有哪些服务。而且,Android系统中某个服务例如MediaPlayerService的客户端想要和MediaPlayerService通讯的话，必须先向ServiceManager查询MediaPlayerService的信息，然后通过ServiceManager返回的东西再来和MediaPlayerService交互。
毕竟，要是MediaPlayerService身体不好，老是挂掉的话，客户的代码就麻烦了，就不知道后续新生的MediaPlayerService的信息了，所以只能这样：

  1. MediaPlayerService向SM注册
    l. MediaPlayerClient查询当前注册在SM中的MediaPlayerService的信息
    l. 根据这个信息，MediaPlayerClient和MediaPlayerService交互
    另外，ServiceManager的handle标示是0，所以只要往handle是0的服务发送消息了，最终都会被传递到ServiceManager中去。
    MediaService的运行：
    ldefaultServiceManager得到了BpServiceManager，然后MediaPlayerService 实例化后，调用BpServiceManager的addService函数
    l. 这个过程中，是service_manager收到addService的请求，然后把对应信息放到自己保存的一个服务list中
    到这儿，我们可看到，service_manager有一个binder_looper函数，专门等着从binder中接收请求。虽然service_manager没有从BnServiceManager中派生，但是它肯定完成了BnServiceManager的功能。
    同样，我们创建了MediaPlayerService即BnMediaPlayerService，那它也应该：
    l. 打开binder设备
    l. 也搞一个looper循环，然后坐等请求
    service，service，这个和网络编程中的监听socket的工作很像嘛！
    好吧，既然MediaPlayerService的构造函数没有看到显示的打开binder设备，那么我们看看它的父类即BnXXX又到底干了些什么呢？

六 MediaPlayerService打开binder

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class MediaPlayerService : public BnMediaPlayerService
// MediaPlayerService从BnMediaPlayerService派生
//而BnMediaPlayerService从BnInterface和IMediaPlayerService同时派生
class BnMediaPlayerService: public BnInterface<IMediaPlayerService>
{
public:
    virtual status_t    onTransact( uint32_t code,
                                    const Parcel& data,
                                    Parcel* reply,
                                    uint32_t flags = 0);
};
看起来，BnInterface似乎更加和打开设备相关啊。
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吗？

1
2
3
4
5
6
7
8
int main(int argc, char** argv)
{
//对啊，我在ProcessState中不是打开过binder了吗？
 
    sp<ProcessState> proc(ProcessState::self());
    sp<IServiceManager> sm = defaultServiceManager();
MediaPlayerService::instantiate();   
  ......

七、looper

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
...
//难道是下面两个？
ProcessState::self()->startThreadPool();
IPCThreadState::self()->joinThreadPool();
看看startThreadPool吧
void ProcessState::startThreadPool()
{
  ...
    spawnPooledThread(true);
}
void ProcessState::spawnPooledThread(bool isMain)
{
    sp<Thread> t = new PoolThread(isMain);isMain是TRUE
//创建线程池，然后run起来，和java的Thread何其像也。
    t->run(buf);
 }
PoolThread从Thread类中派生，那么此时会产生一个线程吗？看看PoolThread和Thread的构造吧
PoolThread::PoolThread(bool isMain)
        : mIsMain(isMain)
    {
    }
Thread::Thread(bool canCallJava)//canCallJava默认值是true
    :   mCanCallJava(canCallJava),
        mThread(thread_id_t(-1)),
        mLock("Thread::mLock"),
        mStatus(NO_ERROR),
        mExitPending(false), mRunning(false)
{
}
喔，这个时候还没有创建线程呢。然后调用PoolThread::run，实际调用了基类的run。
status_t Thread::run(const char* name, int32_t priority, size_t stack)
{
  bool res;
    if (mCanCallJava) {
        res = createThreadEtc(_threadLoop,//线程函数是_threadLoop
                this, name, priority, stack, &mThread);
    }
//终于，在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 {
 ...
        if (result && !self->mExitPending) {
                result = self->threadLoop();哇塞，调用自己的threadLoop
            }
        }
我们是PoolThread对象，所以调用PoolThread的threadLoop函数
virtual bool PoolThread ::threadLoop()
    {
//mIsMain为true。
//而且注意，这是一个新的线程，所以必然会创建一个
新的IPCThreadState对象（记得线程本地存储吗？TLS），然后      
IPCThreadState::self()->joinThreadPool(mIsMain);
        return false;
    }
主线程和工作线程都调用了joinThreadPool，看看这个干嘛了！
void IPCThreadState::joinThreadPool(bool isMain)
{
     mOut.writeInt32(isMain ? BC_ENTER_LOOPER : BC_REGISTER_LOOPER);
     status_t result;
    do {
        int32_t cmd;
         result = talkWithDriver();
         result = executeCommand(cmd);
        }
       } while (result != -ECONNREFUSED && result != -EBADF);
 
    mOut.writeInt32(BC_EXIT_LOOPER);
    talkWithDriver(false);
}
看到没？有loop了，但是好像是有两个线程都执行了这个啊！这里有两个消息循环？
下面看看executeCommand
status_t IPCThreadState::executeCommand(int32_t cmd)
{
BBinder* obj;
    RefBase::weakref_type* refs;
    status_t result = NO_ERROR;
case BR_TRANSACTION:
        {
            binder_transaction_data tr;
            result = mIn.read(&tr, sizeof(tr));
//来了一个命令，解析成BR_TRANSACTION,然后读取后续的信息
       Parcel reply;
             if (tr.target.ptr) {
//这里用的是BBinder。
                sp<BBinder> b((BBinder*)tr.cookie);
                const status_t error = b->transact(tr.code, buffer, &reply, 0);
}
让我们看看BBinder的transact函数干嘛了
status_t BBinder::transact(
    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
就是调用自己的onTransact函数嘛      
err = onTransact(code, data, reply, flags);
    return err;
}

BnMediaPlayerService从BBinder派生，所以会调用到它的onTransact函数
终于水落石出了，让我们看看BnMediaPlayerServcice的onTransact函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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_URL: {
            CHECK_INTERFACE(IMediaPlayerService, data, reply);
            // create是一个虚函数，由MediaPlayerService来实现！！
            sp<IMediaPlayer> player = create(
                    pid, client, url, numHeaders > 0 ? &headers : NULL);
 
            reply->writeStrongBinder(player->asBinder());
            return NO_ERROR;
        } break;

其实，到这里，我们就明白了。BnXXX的onTransact函数收取命令，然后派发到派生类的函数，由他们完成实际的工作。
说明：
这里有点特殊，startThreadPool和joinThreadPool完后确实有两个线程，主线程和工作线程，而且都在做消息循环。为什么要这么做呢？他们参数isMain都是true。不知道google搞什么。难道是怕一个线程工作量太多，所以搞两个线程来工作？这种解释应该也是合理的。
网上有人测试过把最后一句屏蔽掉，也能正常工作。但是难道主线程提出了，程序还能不退出吗？这个…管它的，反正知道有两个线程在那处理就行了。

四 MediaPlayerClient
这节讲讲MediaPlayerClient怎么和MediaPlayerService交互。
使用MediaPlayerService的时候，先要创建它的BpMediaPlayerService。我们看看一个例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
IMediaDeathNotifier::getMediaPlayerService()
{
        sp<IServiceManager> sm = defaultServiceManager();
        sp<IBinder> binder;
        do {
//向SM查询对应服务的信息，返回binder           
binder = sm->getService(String16("media.player"));
            if (binder != 0) {
                break;
             }
             usleep(500000); // 0.5 s
        } while(true);
 
//通过interface_cast，将这个binder转化成BpMediaPlayerService
//注意，这个binder只是用来和binder设备通讯用的，实际
//上和IMediaPlayerService的功能一点关系都没有。
//还记得我说的Bridge模式吗?BpMediaPlayerService用这个binder和BnMediaPlayerService
//通讯。
    sMediaPlayerService = interface_cast<IMediaPlayerService>(binder);
    }
    return sMediaPlayerService;
}

为什么反复强调这个Bridge？其实也不一定是Bridge模式，但是我真正想说明的是：
Binder其实就是一个和binder设备打交道的接口，而上层IMediaPlayerService只不过把它当做一个类似socket使用罢了。我以前经常把binder和上层类IMediaPlayerService的功能混到一起去。
当然，你们不一定会犯这个错误。但是有一点请注意：
下班》