Binder机制分析（2）——从MediaService中看Binder的实现和使用（1）

最新推荐文章于 2023-02-10 22:06:44 发布
最新推荐文章于 2023-02-10 22:06:44 发布
阅读量656 收藏
点赞数
文章标签： binder

转载于：http://blog.csdn.net/ljsbuct/article/details/7106855

本文是对《Android技术内幕-系统卷》第三章的摘抄和整理。


1. MediaService入口， 获取ServiceManager

下面我们就从MediaService的源码入手进行分析，首先，MediaService的入口函数的实现位于 Main_mediaserver.cpp (av\media\mediaserver) 
    int main(int argc, char* argv)  
    {  
        //获得ProcessState实例  
        sp<ProcessState> proc(ProcessState::self());  
        //得到一个ServiceManager对象  
        sp<IServiceManager> sm = defaultServiceManager();  
        LOGI("ServiceManager: %p", sm.get());  
        //初始化MediaService服务  
        AudioFlinger::instantiate();  
        MediaPlayerService::instantiate();  
        CameraService::instantiate();  
        AudioPolicyService::instantiate();  
        //启动进程的线程池  
        ProcessState::self()->startThreadPool();  
       //将自己加入到线程池  
        IPCThreadState::self()->joinThreadPool();  
    }    
1.1 defaultServiceManager()的实现 
    sp<IServiceManager> defaultServiceManager()  
    {  
        if (gDefaultServiceManager != NULL) return gDefaultServiceManager;  
        {  
            AutoMutex _l(gDefaultServiceManagerLock);  
            if (gDefaultServiceManager == NULL) {  
                //创建gDefaultServiceManager  
                gDefaultServiceManager = interface_cast<IServiceManager>( //强制类型转换为IServiceManager类型 
                    ProcessState::self()->getContextObject(NULL));  
            }  
        }  
        return gDefaultServiceManager;  
    }
这里采用了singleton模式，如果全局的gDefaultServiceManager不为NULL，则直接返回；否则，创建一个gDefaultServiceManager。
    
1.2 getContextObject()的实现 
sp<IBinder> ProcessState::getContextObject(const sp<IBinder>& caller)
{
    return getStrongProxyForHandle(0);
}
1.3 getStrongProxyForHandle的实现 
    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;
    }
将创建过程交给ProcessState::getStrongProxyForHandle()函数来实现，第一次进入该函数则会创建一个BpBinder对象并返回。
1.4 interface_cast的实现
大家可能会疑惑，明明创建的是一个BpBinder对象，为什么最后却通过interface_cast函数强制转换为IServiceManager。
  
   template<typename INTERFACE>
    inline sp<INTERFACE> interface_cast(const sp<IBinder>& obj)  
    {  
        return INTERFACE::asInterface(obj);  
    }
替换INTERFACE： 
    inline sp<IServiceManager> interface_cast(const sp<IBinder>& obj)  
    {  
        return IServiceManager::asInterface(obj);  
    } 
其中，INTERFACE对应于IServiceManager，因此我们需要继续找到IServiceManager::asInterface(...)的实现。在IServiceManager中我们可以看到一个如下所示的宏： 
DECLARE_META_INTERFACE(ServiceManager);

1.5 DECLARE_META_INTERFACE分析

#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();
 替换INTERFACE：

  
     #define DECLARE_META_INTERFACE(INTERFACE)  
        static const Android::String16 descriptor;  
        static android::sp<IServiceManager> asInterface(  
                const Android::sp<android::IBinder>& obj);  
        virtual const android::String16& getInterfaceDescriptor() const;  
        IServiceManager();  
        virtual ~IServiceManager();
1.6 IMPLEMENT_META_INTERFACE分析
 IMPLEMENT_META_INTERFACE(ServiceManager, "Android.os.IServiceManager"); //IServiceManager.cpp 
#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() { }
 替换INTERFACE： 
        #define IMPLEMENT_META_INTERFACE(INTERFACE, NAME)      
            const Android::String16 IServiceManager::descriptor("Android.os.IServiceManager");  
            const android::String16&  
                    IServiceManager::getInterfaceDescriptor() const {  
                return IServiceManager::descriptor;  
            }  
            Android::sp<IServiceManager> ServiceManager::asInterface(  
                    const Android::sp<android::IBinder>& obj)  //实际上obj = BpBinder(0);
            {  
                Android::sp<IServiceManager> intr;  
                if (obj != NULL) {  
                    intr = static_cast<IServiceManager*>(  
                        obj->queryLocalInterface(  
                                IServiceManager::descriptor).get());  
                    if (intr == NULL) {  
                        intr = new BpServiceManager(obj);  //实际上obj = BpBinder(0);
                    }  
                }  
                return intr;  
            }  
            IServiceManager::IServiceManager() { }  
            IServiceManager::~IServiceManager() { }
1.7 asInterface的实现
    该函数首先会根据描述符去查找本地的Interface，如果没有查找到，则会执行“new Bp##INTERFACE(obj);”，实际上就是创建了一个BpServiceManager实例。
    因为这个命名也以Bp开头，也许它与上一节介绍的Binder机制的服务器代理对象有关，其实BpServiceManager就是ServiceManager的Binder代理对象。

1.8 BpServiceManager实现

在IServiceManager.cpp中可以找到BpServiceManager的实现： 
 BpServiceManager(const sp<IBinder>& impl)  //实际上impl = BpBinder(0);
        : BpInterface<IServiceManager>(impl)  
    {  
    }
这里的impl就是之前通过ProcessState::getContextObject创建的BpBinder对象。接着进入BpInterface的构造函数，它位于IInterface.h中：   
inline BpInterface<IServiceManager>::BpInterface(const sp<IBinder>& remote)  //实际上remote = BpBinder(0);
        : BpRefBase(remote)  
    {  
    }
最终会进入BpRefBase的构造函数，它位于Binder.cpp中： 
BpRefBase::BpRefBase(const sp<IBinder>& o)  //实际上o = BpBinder(0);
        : mRemote(o.get()), mRefs(NULL), mState(0)   //实际上mRemote = BpBinder(0);
    {  
        extendObjectLifetime(OBJECT_LIFETIME_WEAK);  
        if (mRemote) {  
            mRemote->incStrong(this);               //Removed on first  
            mRefs = mRemote->createWeak(this);      //Held for our entire  
        }  
    }
    o.get()实际上就是之前通过ProcessState::getContextObject创建的BpBinder对象，即mRemote指向BpBinder对象。也就是说，“sp<IServiceManager> sm = defaultServiceManager();”语句返回的实际上是BpServiceManager，它的remote对象是BpBinder，传入的handle参数是0。
    得到了BpServiceManager对象后，我们就可以通过Binder与ServiceManager进行交互了。


2. 添加Service到ServiceManager：   

2.1 MediaPlayerService::instantiate()分析 
void MediaPlayerService::instantiate() {
    defaultServiceManager()->addService(
            String16("media.player"), new MediaPlayerService());
}
 MediaPlayerService构造函数：   
MediaPlayerService::MediaPlayerService()
{
    ALOGV("MediaPlayerService 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;

    MediaPlayerFactory::registerBuiltinFactories();
}

初始化过程为：

首先，构造一个MediaPlayerService。

然后，通过defaultServiceManager()获得之前创建的BpServiceManager，并调用其addService函数。而MediaPlayerService又继承自BnMediaPlayerService，实际上就是MediaPlayerService服务，对应于Binder机制中的服务端。

2.2 BpServiceManager::addService的实现

virtual status_t addService(const String16& name, const sp<IBinder>& service)  //service就是BnMediaPlayerService
    {  
        Parcel data, reply;  
        data.writeInterfaceToken(IServiceManager::getInterfaceDescriptor());  //通过宏DECLARE_META_INTERFACE所定义的描述符"Android.os.Iservice Manager"。
        data.writeString16(name);  //name就是"media.player"
        data.writeStrongBinder(service);  //service就是BnMediaPlayerService
        status_t err = remote()->transact(ADD_SERVICE_TRANSACTION, data, &reply);  //remote()返回mRemout，也就是BpBinder(0)
        return err == NO_ERROR ? reply.readInt32() : err;  
    }
    首先调用writeInterfaceToken写入Interface的名称IServiceManager::getInterfaceDescriptor()，写入的名称实际上就是前面在IServiceManager中，
    然后，通过writeString16写入服务的名称，根据参数可以知道该服务的名称为 media.player；
    最后，通过writeStrongBinder写入服务，也就是上面所说的MediaPlayerService，即 BnMediaPlayerService。
    准备好要发送的命令包后，通过remote()获得其mRemote对象（前面分析过，该对象实际上就是在defaultServiceManager()中创建的BpBinder对象，也就是BpBinder(0)）；

    调用transact函数来发送命令包，发送的命令为添加服务ADD_SERVICE_TRANSACTION。

2.3 IPCThreadState::self()->transact

    BpBinder::transact最终会调用 IPCThreadState::self()->transact来发送数据。
    而在IPCThreadState中，最终还是通过writeTransactionData函数来完成数据的发送的。
    发送之后，waitForResponse函数会等待反馈的结果，在writeTransactionData中会将要发送的数据整理为一个binder_transaction_data结构体（请参见Binder驱动的部分）。
    直到进入talkWithDriver函数中才会真正开始利用Binder驱动来进行通信。对于驱动的操作，当然就是ioctl了。talkWithDriver函数中的发送片段如代码清单3-60所示。
    talkWithDriver的实现片段
        if (ioctl(mProcess->mDriverFD, BINDER_WRITE_READ, &bwr) >= 0)  
            err = NO_ERROR;  
        else  
            err = -errno;  
    BpServiceManager发送的信息应该由BnServiceManager来接收，但是Android中并没有BnServiceManager。
    因此，具体的接收操作会由Service Manager来完成。具体操作流程请参考上一篇关于Service Manager的实现，也就是其中的svcmgr_handler函数。
    
3. 总结
    1）通过ProcessState::self()函数获得ProcessState对象，并打开Binder设备。
    2）通过defaultServiceManager得到BpServiceManager实例。
    3）通过MediaPlayerService::instantiate()得到MediaPlayerService服务BnMediaPlayer Service，并通过BpServiceManager::addService将MediaPlayerService服务加入到Service Manager的list中。
longshan_2009
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Binder通信二（MediaService理解Binder机制）
ABang的博客
07-24 578
一 说明  Android系统最常见也是初学者最难搞明白的就是Binder了，很多很多的Service就是通过Binder机制来和客户端通讯交互的。所以搞明白Binder的话，在很大程度上就能理解程序运行的流程。 我们这里将以MediaService的例子来分析Binder的使用： l         ServiceManager，这是Android OS的整个服务的管理程序
通过MediaPlayer理解Binder的使用
编程菜鸟---正在努力进阶
07-07 4132
理解Binder的使用是一件不容易的事，尤其由浅入深，本文参考Android深入浅出之Binder机制和Android Binder设计与实现这两文章为基础，从Java层的MediaPlayer开始分析Client, Server 和ServiceManager！至于Binder的实现可以搜索CSDN老罗的文章，涉及到kernel这里不讨论，本文只作为分析android代码记忆用   首先，先
Binder native层源码分析（一）：media_service的启动
ctoast的博客
02-02 405
Binder是Android系统下的IPC通信机制，进程间的通信，包括系统服务的调用，都需要通过Binder来进行。看了很多讲解Binder native层运行原理的书和博客，我大概对native层的Binder运行过程有了一个认识。但总觉得自己对Binder的理解不够深入，无法理解其中很多的实现细节，想要更加深入地理解Binder，还是得自己亲自过一遍源码，做一个总结。 很多书和博客都以系统服务...
Android MediaPlayer 分析- MediaPlayerService.cpp
热门推荐
kickxxx的专栏
11-18 1万+
frameworks/base/libmediaplayerservice/MediaPlayerService.cpp 因为工作的平台是mx51，所以分析的是mx51 10.3的代码，本文主要分析视频播放部分的代码，对于recorder和audio部分忽略掉。 Mediaplayer service是一个系统服务，Android 视频播放，录音录像，元数据获取等客户端应用与Mediapl
Android系统进程间通讯之Binder机制（二）
☃Clay's♂Blogs
05-16 2852
Android系统进程间通讯之Binder机制（二） ----实践篇 首先我们来看一张图，binder机制的层次模型： 如果想要实现Binder机制实现进程间的通讯，从理论篇中总结下来需要有一下几步： （1）第一步，需要为这个接口定义一个继承自I
Android系统的Binder机制之一——Service_Manager
08-24
Android系统基于Linux内核，但在进程间通信（IPC）方面并没有采用传统的Linux IPC机制，而是设计并实现了自己的一套轻量级IPC解决方案——Binder机制。该机制不仅提供了高效的进程间通信能力，还为Android框架层提供...
Android系统的Binder机制之二——服务代理对象（1）.docx
07-06
在Android系统中，Binder机制是实现跨进程通信的关键组件，它允许不同进程间的服务共享和交互。本篇文章主要探讨的是Binder机制中的服务代理对象（Service Proxy Object），特别是BpBinder的核心概念。 首先，服务...
Android系统的Binder机制之三——服务代理对象（2）.docx
07-06
总之，Android系统的Binder机制使得Java层面上的服务代理对象能够高效地创建和使用，实现了进程间的通信和交互。Java层的ServiceManager作为中介，帮助客户端找到并建立与服务的连接，而服务代理对象则作为客户端与...
binder机制的原理说明和使用说明，适合新手了解
04-13
### Binder机制的原理说明和使用说明 #### 一、Binder机制概述 Binder作为一种核心的跨进程通信（Inter-Process Communication, IPC）机制，在Android系统中扮演着至关重要的角色。它不仅实现了不同进程间的通信，...
Binder机制原理解析
最新发布
08-17
Binder机制是Android系统的核心组成部分，它是实现Android应用跨进程通信（IPC）的关键技术。相比于其他IPC方式，如Socket、Shared Memory、...理解Binder的工作原理有助于开发者更好地设计和实现多进程协作的应用。
Android Binder通信机制学习（二）
李清的博客
05-28 1122
新人阿彡的Android多媒体学习之路 🚄🚄🚄 第一章 Android Binder通信机制学习之Binder基本原理 🚄🚄🚄 第二章 Android Binder通信机制学习之Binder基本架构 本章目录新人阿彡的Android多媒体学习之路0、前言1、Binder整体架构2、Binder相关类继承关系3、IBinder类4、IInterface类 0、前言 主要参考：https://paul.pub/android-binder-driver/ 作为一名新步入Android领域的职场老鸟，奈何最近环境
Android 进阶——Framework核心 之Binder Native成员类详解（二）
最美不过，心中有梦，身旁有你！
02-10 969
Framework核心 之Binder Native成员类详解。
DECLARE_META_INTERFACE(INTERFACE)和IMPLEMENT_META_INTERFACE(INTERFACE, NAME)宏定义分析
Android系统攻城狮
05-10 5604
这里讲的两个宏定义是IPC中鼎鼎大名的 DECLARE_META_INTERFACE(INTERFACE) IMPLEMENT_META_INTERFACE(INTERFACE, NAME) 定义 frameworks\base\include\utils\IInterface.h #define DECLARE_META_INTERFACE(
interface宏：DECLARE_META_INTERFACE/IMPLEMENT_META_INTERFACE
CCJHDOPC的专栏:
11-11 2381
frameworks/native/include/binder #define DECLARE_META_INTERFACE(INTERFACE) \ static const android::String16 descriptor; \ static andro
android下Binder机制
pikaxuji的专栏
03-22 1128
以MediaService为例，这个是个后台服务，用来播放多媒体的。 int main(int argc, char** argv) { //FT，就这么简单？？ //获得一个ProcessState实例 sp proc(ProcessState::self()); //得到一个ServiceManager对象     sp sm = defaultServiceManager(
红茶一杯话Binder（初始篇）
weixin_34261415的博客
08-02 360
2019独角兽企业重金招聘Python工程师标准>>> ...
解析Android Binder机制：从MediaService入手
这篇文章将带你逐步揭开Binder的神秘面纱，帮助你从基础到深入理解Android的Service架构，尤其是如何通过MediaService来设计和实现高效的跨进程通信。这对于任何希望成为Android开发者的人员来说，都是一份宝贵的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值