注意,这里的status参数为0。从这里可以看出,binder_send_reply告诉Binder驱动程序执行BC_FREE_BUFFER和BC_REPLY命令,前者释放之前在binder_transaction分配的空间,地址为buffer_to_free,buffer_to_free这个地址是Binder驱动程序把自己在内核空间用的地址转换成用户空间地址再传给Service Manager的,所以Binder驱动程序拿到这个地址后,知道怎么样释放这个空间;后者告诉Binder驱动程序,它的SVC_MGR_CHECK_SERVICE操作已经完成了,要查询的服务的句柄值也是保存在data.txn.data,操作结果码是0,也是保存在data.txn.data中。
        再来看binder_write函数:


 

  1. int binder_write(struct binder_state *bs, void *data, unsigned len)  
  2. {  
  3.     struct binder_write_read bwr;  
  4.     int res;  
  5.     bwr.write_size = len;  
  6.     bwr.write_consumed = 0;  
  7.     bwr.write_buffer = (unsigned) data;  
  8.     bwr.read_size = 0;  
  9.     bwr.read_consumed = 0;  
  10.     bwr.read_buffer = 0;  
  11.     res = ioctl(bs->fd, BINDER_WRITE_READ, &bwr);  
  12.     if (res < 0) {  
  13.         fprintf(stderr,"binder_write: ioctl failed (%s)\n",  
  14.                 strerror(errno));  
  15.     }  
  16.     return res;  

    这里可以看出,只有写操作,没有读操作,即read_size为0。
        这里又是一个ioctl的BINDER_WRITE_READ操作。直入到驱动程序的binder_ioctl函数后,执行BINDER_WRITE_READ命令,这里就不累述了。
        最后,从binder_ioctl执行到binder_thread_write函数,首先是执行BC_FREE_BUFFER命令,这个命令的执行在前面一篇文章Android系统进程间通信(IPC)机制Binder中的Server启动过程源代码分析已经介绍过了,这里就不再累述了。

        我们重点关注BC_REPLY命令的执行:


 

  1. int    
  2. binder_thread_write(struct binder_proc *proc, struct binder_thread *thread,    
  3.                     void __user *buffer, int size, signed long *consumed)    
  4. {    
  5.     uint32_t cmd;    
  6.     void __user *ptr = buffer + *consumed;    
  7.     void __user *end = buffer + size;    
  8.     
  9.     while (ptr < end && thread->return_error == BR_OK) {    
  10.         if (get_user(cmd, (uint32_t __user *)ptr))    
  11.             return -EFAULT;    
  12.         ptr += sizeof(uint32_t);    
  13.         if (_IOC_NR(cmd) < ARRAY_SIZE(binder_stats.bc)) {    
  14.             binder_stats.bc[_IOC_NR(cmd)]++;    
  15.             proc->stats.bc[_IOC_NR(cmd)]++;    
  16.             thread->stats.bc[_IOC_NR(cmd)]++;    
  17.         }    
  18.         switch (cmd) {    
  19.         ......    
  20.         case BC_TRANSACTION:    
  21.         case BC_REPLY: {    
  22.             struct binder_transaction_data tr;    
  23.     
  24.             if (copy_from_user(&tr, ptr, sizeof(tr)))    
  25.                 return -EFAULT;    
  26.             ptr += sizeof(tr);    
  27.             binder_transaction(proc, thread, &tr, cmd == BC_REPLY);    
  28.             break;    
  29.                        }    
  30.     
  31.         ......    
  32.         *consumed = ptr - buffer;    
  33.     }    
  34.     return 0;    
  35. }  

   又再次进入到binder_transaction函数:


 

  1. static void  
  2. binder_transaction(struct binder_proc *proc, struct binder_thread *thread,  
  3. struct binder_transaction_data *tr, int reply)  
  4. {  
  5.     struct binder_transaction *t;  
  6.     struct binder_work *tcomplete;  
  7.     size_t *offp, *off_end;  
  8.     struct binder_proc *target_proc;  
  9.     struct binder_thread *target_thread = NULL;  
  10.     struct binder_node *target_node = NULL;  
  11.     struct list_head *target_list;  
  12.     wait_queue_head_t *target_wait;  
  13.     struct binder_transaction *in_reply_to = NULL;  
  14.     struct binder_transaction_log_entry *e;  
  15.     uint32_t return_error;  
  16.  
  17.     ......  
  18.  
  19.     if (reply) {  
  20.         in_reply_to = thread->transaction_stack;  
  21.         if (in_reply_to == NULL) {  
  22.             ......  
  23.             return_error = BR_FAILED_REPLY;  
  24.             goto err_empty_call_stack;  
  25.         }  
  26.         ......  
  27.         thread->transaction_stack = in_reply_to->to_parent;  
  28.         target_thread = in_reply_to->from;  
  29.         ......  
  30.         target_proc = target_thread->proc;  
  31.     } else {  
  32.         ......  
  33.     }  
  34.     if (target_thread) {  
  35.         e->to_thread = target_thread->pid;  
  36.         target_list = &target_thread->todo;  
  37.         target_wait = &target_thread->wait;  
  38.     } else {  
  39.         ......  
  40.     }  
  41.       
  42.  
  43.     /* TODO: reuse incoming transaction for reply */  
  44.     t = kzalloc(sizeof(*t), GFP_KERNEL);  
  45.     if (t == NULL) {  
  46.         return_error = BR_FAILED_REPLY;  
  47.         goto err_alloc_t_failed;  
  48.     }  
  49.     binder_stats.obj_created[BINDER_STAT_TRANSACTION]++;  
  50.  
  51.     tcomplete = kzalloc(sizeof(*tcomplete), GFP_KERNEL);  
  52.     if (tcomplete == NULL) {  
  53.         return_error = BR_FAILED_REPLY;  
  54.         goto err_alloc_tcomplete_failed;  
  55.     }  
  56.     ......  
  57.  
  58.     if (!reply && !(tr->flags & TF_ONE_WAY))  
  59.         t->from = thread;  
  60.     else 
  61.         t->from = NULL;  
  62.     t->sender_euid = proc->tsk->cred->euid;  
  63.     t->to_proc = target_proc;  
  64.     t->to_thread = target_thread;  
  65.     t->code = tr->code;  
  66.     t->flags = tr->flags;  
  67.     t->priority = task_nice(current);  
  68.     t->buffer = binder_alloc_buf(target_proc, tr->data_size,  
  69.         tr->offsets_size, !reply && (t->flags & TF_ONE_WAY));  
  70.     if (t->buffer == NULL) {  
  71.         return_error = BR_FAILED_REPLY;  
  72.         goto err_binder_alloc_buf_failed;  
  73.     }  
  74.     t->buffer->allow_user_free = 0;  
  75.     t->buffer->debug_id = t->debug_id;  
  76.     t->buffer->transaction = t;  
  77.     t->buffer->target_node = target_node;  
  78.     if (target_node)  
  79.         binder_inc_node(target_node, 1, 0, NULL);  
  80.  
  81.     offp = (size_t *)(t->buffer->data + ALIGN(tr->data_size, sizeof(void *)));  
  82.  
  83.     if (copy_from_user(t->buffer->data, tr->data.ptr.buffer, tr->data_size)) {  
  84.         binder_user_error("binder: %d:%d got transaction with invalid " 
  85.             "data ptr\n", proc->pid, thread->pid);  
  86.         return_error = BR_FAILED_REPLY;  
  87.         goto err_copy_data_failed;  
  88.     }  
  89.     if (copy_from_user(offp, tr->data.ptr.offsets, tr->offsets_size)) {  
  90.         binder_user_error("binder: %d:%d got transaction with invalid " 
  91.             "offsets ptr\n", proc->pid, thread->pid);  
  92.         return_error = BR_FAILED_REPLY;  
  93.         goto err_copy_data_failed;  
  94.     }  
  95.     ......  
  96.  
  97.     off_end = (void *)offp + tr->offsets_size;  
  98.     for (; offp < off_end; offp++) {  
  99.         struct flat_binder_object *fp;  
  100.         ......  
  101.         fp = (struct flat_binder_object *)(t->buffer->data + *offp);  
  102.         switch (fp->type) {  
  103.         ......  
  104.         case BINDER_TYPE_HANDLE:  
  105.         case BINDER_TYPE_WEAK_HANDLE: {  
  106.             struct binder_ref *ref = binder_get_ref(proc, fp->handle);  
  107.             if (ref == NULL) {  
  108.                 ......  
  109.                 return_error = BR_FAILED_REPLY;  
  110.                 goto err_binder_get_ref_failed;  
  111.             }  
  112.             if (ref->node->proc == target_proc) {  
  113.                 ......  
  114.             } else {  
  115.                 struct binder_ref *new_ref;  
  116.                 new_ref = binder_get_ref_for_node(target_proc, ref->node);  
  117.                 if (new_ref == NULL) {  
  118.                     return_error = BR_FAILED_REPLY;  
  119.                     goto err_binder_get_ref_for_node_failed;  
  120.                 }  
  121.                 fp->handle = new_ref->desc;  
  122.                 binder_inc_ref(new_ref, fp->type == BINDER_TYPE_HANDLE, NULL);  
  123.                 ......  
  124.             }  
  125.         } break;  
  126.  
  127.         ......  
  128.         }  
  129.     }  
  130.  
  131.     if (reply) {  
  132.         BUG_ON(t->buffer->async_transaction != 0);  
  133.         binder_pop_transaction(target_thread, in_reply_to);  
  134.     } else if (!(t->flags & TF_ONE_WAY)) {  
  135.         ......  
  136.     } else {  
  137.         ......  
  138.     }  
  139.  
  140.     t->work.type = BINDER_WORK_TRANSACTION;  
  141.     list_add_tail(&t->work.entry, target_list);  
  142.     tcomplete->type = BINDER_WORK_TRANSACTION_COMPLETE;  
  143.     list_add_tail(&tcomplete->entry, &thread->todo);  
  144.     if (target_wait)  
  145.         wake_up_interruptible(target_wait);  
  146.     return;  
  147.  
  148.     ......  

   这次进入binder_transaction函数的情形和上面介绍的binder_transaction函数的情形基本一致,只是这里的proc、thread和target_proc、target_thread调换了角色,这里的proc和thread指的是Service Manager进程,而target_proc和target_thread指的是刚才请求SVC_MGR_CHECK_SERVICE的进程。

        那么,这次是如何找到target_proc和target_thread呢。首先,我们注意到,这里的reply等于1,其次,上面我们提到,Binder驱动程序在唤醒Service Manager,告诉它有一个事务t要处理时,事务t虽然从Service Manager的todo队列中删除了,但是仍然保留在transaction_stack中。因此,这里可以从thread->transaction_stack找回这个等待回复的事务t,然后通过它找回target_proc和target_thread:


 

  1. in_reply_to = thread->transaction_stack;  
  2. target_thread = in_reply_to->from;  
  3. target_list = &target_thread->todo;  
  4. target_wait = &target_thread->wait; 

   再接着往下看,由于Service Manager返回来了一个Binder引用,所以这里要处理一下,就是中间的for循环了。这是一个BINDER_TYPE_HANDLE类型的Binder引用,这是前面设置的。先把t->buffer->data的内容转换为一个struct flat_binder_object对象fp,这里的fp->handle值就是这个Service在Service Manager进程里面的引用值了。接通过调用binder_get_ref函数得到Binder引用对象struct binder_ref类型的对象ref:


 

  1. struct binder_ref *ref = binder_get_ref(proc, fp->handle); 

   这里一定能找到,因为前面MediaPlayerService执行IServiceManager::addService的时候把自己添加到Service Manager的时候,会在Service Manager进程中创建这个Binder引用,然后把这个Binder引用的句柄值返回给Service Manager用户空间。

       这里面的ref->node->proc不等于target_proc,因为这个Binder实体是属于创建MediaPlayerService的进程的,而不是请求这个服务的远程接口的进程的,因此,这里调用binder_get_ref_for_node函数为这个Binder实体在target_proc创建一个引用:

  1. struct binder_ref *new_ref;  
  2. new_ref = binder_get_ref_for_node(target_proc, ref->node); 

   然后增加引用计数:


 

  1. binder_inc_ref(new_ref, fp->type == BINDER_TYPE_HANDLE, NULL); 

  这样,返回数据中的Binder对象就处理完成了。注意,这里会把fp->handle的值改为在target_proc中的引用值:

 

  1. fp->handle = new_ref->desc

  这里就相当于是把t->buffer->data里面的Binder对象的句柄值改写了。因为这是在另外一个不同的进程里面的Binder引用,所以句柄值当然要用新的了。这个值最终是要拷贝回target_proc进程的用户空间去的。


      再往下看:

  1. if (reply) {  
  2.      BUG_ON(t->buffer->async_transaction != 0);  
  3.      binder_pop_transaction(target_thread, in_reply_to);  
  4. else if (!(t->flags & TF_ONE_WAY)) {  
  5.      ......  
  6. else {  
  7.      ......  


  这里reply等于1,执行binder_pop_transaction函数把当前事务in_reply_to从target_thread->transaction_stack队列中删掉,这是上次调用binder_transaction函数的时候设置的,现在不需要了,所以把它删掉。

       再往后的逻辑就跟前面执行binder_transaction函数时候一样了,这里不再介绍。最后的结果就是唤醒请求SVC_MGR_CHECK_SERVICE操作的线程:


 

  1. if (target_wait)  
  2.      wake_up_interruptible(target_wait); 

   这样,Service Manger回复调用SVC_MGR_CHECK_SERVICE请求就算完成了,重新回到frameworks/base/cmds/servicemanager/binder.c文件中的binder_loop函数等待下一个Client请求的到来。事实上,Service Manger回到binder_loop函数再次执行ioctl函数时候,又会再次进入到binder_thread_read函数。这时个会发现thread->todo不为空,这是因为刚才我们调用了:

  1. list_add_tail(&tcomplete->entry, &thread->todo); 

  把一个工作项tcompelete放在了在thread->todo中,这个tcompelete的type为BINDER_WORK_TRANSACTION_COMPLETE,因此,Binder驱动程序会执行下面操作:


 

  1. switch (w->type) {    
  2. case BINDER_WORK_TRANSACTION_COMPLETE: {    
  3.     cmd = BR_TRANSACTION_COMPLETE;    
  4.     if (put_user(cmd, (uint32_t __user *)ptr))    
  5.         return -EFAULT;    
  6.     ptr += sizeof(uint32_t);    
  7.     
  8.     list_del(&w->entry);    
  9.     kfree(w);    
  10.         
  11.     } break;    
  12.     ......    
  13. }   

     binder_loop函数执行完这个ioctl调用后,才会在下一次调用ioctl进入到Binder驱动程序进入休眠状态,等待下一次Client的请求。
      上面讲到调用请求SVC_MGR_CHECK_SERVICE操作的线程被唤醒了,于是,重新执行binder_thread_read函数:

  1. static int    
  2. binder_thread_read(struct binder_proc *proc, struct binder_thread *thread,    
  3.                    void  __user *buffer, int size, signed long *consumed, int non_block)    
  4. {    
  5.     void __user *ptr = buffer + *consumed;    
  6.     void __user *end = buffer + size;    
  7.     
  8.     int ret = 0;    
  9.     int wait_for_proc_work;    
  10.     
  11.     if (*consumed == 0) {    
  12.         if (put_user(BR_NOOP, (uint32_t __user *)ptr))    
  13.             return -EFAULT;    
  14.         ptr += sizeof(uint32_t);    
  15.     }    
  16.     
  17. retry:    
  18.     wait_for_proc_work = thread->transaction_stack == NULL && list_empty(&thread->todo);    
  19.     
  20.     ......    
  21.     
  22.     if (wait_for_proc_work) {    
  23.         ......    
  24.     } else {    
  25.         if (non_block) {    
  26.             if (!binder_has_thread_work(thread))    
  27.                 ret = -EAGAIN;    
  28.         } else    
  29.             ret = wait_event_interruptible(thread->wait, binder_has_thread_work(thread));    
  30.     }    
  31.         
  32.     ......    
  33.     
  34.     while (1) {    
  35.         uint32_t cmd;    
  36.         struct binder_transaction_data tr;    
  37.         struct binder_work *w;    
  38.         struct binder_transaction *t = NULL;    
  39.     
  40.         if (!list_empty(&thread->todo))    
  41.             w = list_first_entry(&thread->todo, struct binder_work, entry);    
  42.         else if (!list_empty(&proc->todo) && wait_for_proc_work)    
  43.             w = list_first_entry(&proc->todo, struct binder_work, entry);    
  44.         else {    
  45.             if (ptr - buffer == 4 && !(thread->looper & BINDER_LOOPER_STATE_NEED_RETURN)) /* no data added */    
  46.                 goto retry;    
  47.             break;    
  48.         }    
  49.     
  50.         ......    
  51.     
  52.         switch (w->type) {    
  53.         case BINDER_WORK_TRANSACTION: {    
  54.             t = container_of(w, struct binder_transaction, work);    
  55.                                       } break;    
  56.         ......    
  57.         }    
  58.     
  59.         if (!t)    
  60.             continue;    
  61.     
  62.         BUG_ON(t->buffer == NULL);    
  63.         if (t->buffer->target_node) {    
  64.             ......    
  65.         } else {    
  66.             tr.target.ptr = NULL;    
  67.             tr.cookie = NULL;    
  68.             cmd = BR_REPLY;    
  69.         }    
  70.         tr.code = t->code;    
  71.         tr.flags = t->flags;    
  72.         tr.sender_euid = t->sender_euid;    
  73.     
  74.         if (t->from) {    
  75.             ......    
  76.         } else {    
  77.             tr.sender_pid = 0;    
  78.         }    
  79.     
  80.         tr.data_size = t->buffer->data_size;    
  81.         tr.offsets_size = t->buffer->offsets_size;    
  82.         tr.data.ptr.buffer = (void *)t->buffer->data + proc->user_buffer_offset;    
  83.         tr.data.ptr.offsets = tr.data.ptr.buffer + ALIGN(t->buffer->data_size, sizeof(void *));    
  84.     
  85.         if (put_user(cmd, (uint32_t __user *)ptr))    
  86.             return -EFAULT;    
  87.         ptr += sizeof(uint32_t);    
  88.         if (copy_to_user(ptr, &tr, sizeof(tr)))    
  89.             return -EFAULT;    
  90.         ptr += sizeof(tr);    
  91.     
  92.         ......    
  93.     
  94.         list_del(&t->work.entry);    
  95.         t->buffer->allow_user_free = 1;    
  96.         if (cmd == BR_TRANSACTION && !(t->flags & TF_ONE_WAY)) {    
  97.             ......    
  98.         } else {    
  99.             t->buffer->transaction = NULL;    
  100.             kfree(t);    
  101.             binder_stats.obj_deleted[BINDER_STAT_TRANSACTION]++;    
  102.         }    
  103.         break;    
  104.     }    
  105.     
  106. done:    
  107.     ......    
  108.     return 0;    
  109. }   

  就是从下面这个调用:


 

  1. ret = wait_event_interruptible(thread->wait, binder_has_thread_work(thread)); 

    被唤醒过来了。在while循环中,从thread->todo得到w,w->type为BINDER_WORK_TRANSACTION,于是,得到t。从上面可以知道,Service Manager返回来了一个Binder引用和一个结果码0回来,写在t->buffer->data里面,现在把t->buffer->data加上proc->user_buffer_offset,得到用户空间地址,保存在tr.data.ptr.buffer里面,这样用户空间就可以访问这个数据了。由于cmd不等于BR_TRANSACTION,这时就可以把t删除掉了,因为以后都不需要用了。
       执行完这个函数后,就返回到binder_ioctl函数,执行下面语句,把数据返回给用户空间:


 

  1. if (copy_to_user(ubuf, &bwr, sizeof(bwr))) {    
  2.     ret = -EFAULT;    
  3.     goto err;    
  4. }   

接着返回到用户空间IPCThreadState::talkWithDriver函数,最后返回到IPCThreadState::waitForResponse函数,最终执行到下面语句:


 

  1. status_t IPCThreadState::waitForResponse(Parcel *reply, status_t *acquireResult)    
  2. {    
  3.     int32_t cmd;    
  4.     int32_t err;    
  5.     
  6.     while (1) {    
  7.         if ((err=talkWithDriver()) < NO_ERROR) break;    
  8.             
  9.         ......    
  10.     
  11.         cmd = mIn.readInt32();    
  12.     
  13.         ......    
  14.     
  15.         switch (cmd) {    
  16.         ......    
  17.         case BR_REPLY:    
  18.             {    
  19.                 binder_transaction_data tr;    
  20.                 err = mIn.read(&tr, sizeof(tr));    
  21.                 LOG_ASSERT(err == NO_ERROR, "Not enough command data for brREPLY");    
  22.                 if (err != NO_ERROR) goto finish;    
  23.     
  24.                 if (reply) {    
  25.                     if ((tr.flags & TF_STATUS_CODE) == 0) {    
  26.                         reply->ipcSetDataReference(    
  27.                             reinterpret_cast<const uint8_t*>(tr.data.ptr.buffer),    
  28.                             tr.data_size,    
  29.                             reinterpret_cast<const size_t*>(tr.data.ptr.offsets),    
  30.                             tr.offsets_size/sizeof(size_t),    
  31.                             freeBuffer, this);    
  32.                     } else {    
  33.                         ......  
  34.                     }    
  35.                 } else {    
  36.                     ......   
  37.                 }    
  38.             }    
  39.             goto finish;    
  40.     
  41.         ......    
  42.         }    
  43.     }    
  44.     
  45. finish:    
  46.     ......    
  47.     return err;    
  48. }   

     注意,这里的tr.flags等于0,这个是在上面的binder_send_reply函数里设置的。接着就把结果保存在reply了:


 

  1. reply->ipcSetDataReference(    
  2.        reinterpret_cast<const uint8_t*>(tr.data.ptr.buffer),    
  3.        tr.data_size,    
  4.        reinterpret_cast<const size_t*>(tr.data.ptr.offsets),    
  5.        tr.offsets_size/sizeof(size_t),    
  6.        freeBuffer, this);   

  我们简单看一下Parcel::ipcSetDataReference函数的实现:


 

  1. void Parcel::ipcSetDataReference(const uint8_t* data, size_t dataSize,  
  2.     const size_t* objects, size_t objectsCount, release_func relFunc, void* relCookie)  
  3. {  
  4.     freeDataNoInit();  
  5.     mError = NO_ERROR;  
  6.     mData = const_cast<uint8_t*>(data);  
  7.     mDataSize = mDataCapacity = dataSize;  
  8.     //LOGI("setDataReference Setting data size of %p to %lu (pid=%d)\n", this, mDataSize, getpid());  
  9.     mDataPos = 0;  
  10.     LOGV("setDataReference Setting data pos of %p to %d\n", this, mDataPos);  
  11.     mObjects = const_cast<size_t*>(objects);  
  12.     mObjectsSize = mObjectsCapacity = objectsCount;  
  13.     mNextObjectHint = 0;  
  14.     mOwner = relFunc;  
  15.     mOwnerCookie = relCookie;  
  16.     scanForFds();  

  上面提到,返回来的数据中有一个Binder引用,因此,这里的mObjectSize等于1,这个Binder引用对应的位置记录在mObjects成员变量中。

        从这里层层返回,最后回到BpServiceManager::checkService函数中:


 

  1. virtual sp<IBinder> BpServiceManager::checkService( const String16& name) const  
  2. {  
  3.     Parcel data, reply;  
  4.     data.writeInterfaceToken(IServiceManager::getInterfaceDescriptor());  
  5.     data.writeString16(name);  
  6.     remote()->transact(CHECK_SERVICE_TRANSACTION, data, &reply);  
  7.     return reply.readStrongBinder();  

     这里就是从:


 

  1. remote()->transact(CHECK_SERVICE_TRANSACTION, data, &reply); 

返回来了。我们接着看一下reply.readStrongBinder函数的实现:


 

  1. sp<IBinder> Parcel::readStrongBinder() const  
  2. {  
  3.     sp<IBinder> val;  
  4.     unflatten_binder(ProcessState::self(), *this, &val);  
  5.     return val;  

    这里调用了unflatten_binder函数来构造一个Binder对象:


 

  1. status_t unflatten_binder(const sp<ProcessState>& proc,  
  2.     const Parcel& in, sp<IBinder>* out)  
  3. {  
  4.     const flat_binder_object* flat = in.readObject(false);  
  5.       
  6.     if (flat) {  
  7.         switch (flat->type) {  
  8.             case BINDER_TYPE_BINDER:  
  9.                 *out = static_cast<IBinder*>(flat->cookie);  
  10.                 return finish_unflatten_binder(NULL, *flat, in);  
  11.             case BINDER_TYPE_HANDLE:  
  12.                 *out = proc->getStrongProxyForHandle(flat->handle);  
  13.                 return finish_unflatten_binder(  
  14.                     static_cast<BpBinder*>(out->get()), *flat, in);  
  15.         }          
  16.     }  
  17.     return BAD_TYPE;  

    这里的flat->type是BINDER_TYPE_HANDLE,因此调用ProcessState::getStrongProxyForHandle函数:


 

  1. sp<IBinder> ProcessState::getStrongProxyForHandle(int32_t handle)  
  2. {  
  3.     sp<IBinder> result;  
  4.  
  5.     AutoMutex _l(mLock);  
  6.  
  7.     handle_entry* e = lookupHandleLocked(handle);  
  8.  
  9.     if (e != NULL) {  
  10.         // We need to create a new BpBinder if there isn't currently one, OR we  
  11.         // are unable to acquire a weak reference on this current one.  See comment  
  12.         // in getWeakProxyForHandle() for more info about this.  
  13.         IBinder* b = e->binder;  
  14.         if (b == NULL || !e->refs->attemptIncWeak(this)) {  
  15.             b = new BpBinder(handle);   
  16.             e->binder = b;  
  17.             if (b) e->refs = b->getWeakRefs();  
  18.             result = b;  
  19.         } else {  
  20.             // This little bit of nastyness is to allow us to add a primary 
  21.             // reference to the remote proxy when this team doesn't have one  
  22.             // but another team is sending the handle to us.  
  23.             result.force_set(b);  
  24.             e->refs->decWeak(this);  
  25.         }  
  26.     }  
  27.  
  28.     return result;  

      这里我们可以看到,ProcessState会把使用过的Binder远程接口(BpBinder)缓存起来,这样下次从Service Manager那里请求得到相同的句柄(Handle)时就可以直接返回这个Binder远程接口了,不用再创建一个出来。这里是第一次使用,因此,e->binder为空,于是创建了一个BpBinder对象:

  1. b = new BpBinder(handle);   
  2. e->binder = b;  
  3. if (b) e->refs = b->getWeakRefs();  
  4. result = b; 

   最后,函数返回到IMediaDeathNotifier::getMediaPlayerService这里,从这个语句返回:

 

  1. binder = sm->getService(String16("media.player")); 

    这里,就相当于是:

  1. binder = new BpBinder(handle); 

     最后,函数调用:


 

  1. sMediaPlayerService = interface_cast<IMediaPlayerService>(binder); 

    到了这里,我们可以参考一下前面一篇文章浅谈Android系统进程间通信(IPC)机制Binder中的Server和Client获得Service Manager,就会知道,这里的interface_cast实际上最终调用了IMediaPlayerService::asInterface函数:


 

  1. android::sp<IMediaPlayerService> IMediaPlayerService::asInterface(const android::sp<android::IBinder>& obj)  
  2. {  
  3.     android::sp<IServiceManager> intr;  
  4.     if (obj != NULL) {               
  5.         intr = static_cast<IMediaPlayerService*>(   
  6.             obj->queryLocalInterface(IMediaPlayerService::descriptor).get());  
  7.         if (intr == NULL) {  
  8.             intr = new BpMediaPlayerService(obj);  
  9.         }  
  10.     }  
  11.     return intr;   

    这里的obj就是BpBinder,而BpBinder::queryLocalInterface返回NULL,因此就创建了一个BpMediaPlayerService对象:


 

  1. intr = new BpMediaPlayerService(new BpBinder(handle)); 

因此,我们最终就得到了一个BpMediaPlayerService对象,达到我们最初的目标。

        有了这个BpMediaPlayerService这个远程接口之后,MediaPlayer就可以调用MediaPlayerService的服务了。

        至此,Android系统进程间通信(IPC)机制Binder中的Client如何通过Service Manager的getService函数获得Server远程接口的过程就分析完了,Binder机制的学习就暂告一段落了。

        不过,细心的读者可能会发现,我们这里介绍的Binder机制都是基于C/C++语言实现的,但是我们在编写应用程序都是基于Java语言的,那么,我们如何使用Java语言来使用系统的Binder机制来进行进程间通信呢?这就是下一篇文章要介绍的内容了,敬请关注。