Android多媒体之binder机制

本文是基于Android O，以Android多媒体模块为例简单剖析学习下Binder机制。

Binder 回顾

Android系统下Binder是由server、client、ServiceManger和Binder驱动组成，Binder驱动运行在内核空间，而server、client以及ServiceManger运行在用户空间。

核心组件便是Binder驱动程序了，Service Manager提供了辅助管理的功能，Client和Server正是在Binder驱动和Service Manager提供的基础设施上，进行Client-Server之间的通信。

下面以MediaPlayerService来阐述下Binder机制

MediaPlayerService的初始化

Android 7.0以后从MediaServer中分离出AudioServer，将AudioFlinger、AudioPolicyService等放到AudioServer中，而原来的MediaPlayerService仍旧保留在MediaServer中创建初始化。

代码位置：
android_o/frameworks/av/media/mediaserver/main_mediaserver.cpp

  int main(int argc __unused, char **argv __unused)
  {
      signal(SIGPIPE, SIG_IGN);

      //在mediaserver启动时通过ProcessState::self()创建ProcessState对象实例赋值  
      //给指针变量proc
      sp<ProcessState> proc(ProcessState::self());
      //获得 ServiceManager的实例赋值给指针变量sm
      sp<IServiceManager> sm(defaultServiceManager());
      ALOGI("ServiceManager: %p", sm.get());
      InitializeIcuOrDie();
      //初始化MediaPlayerService
      MediaPlayerService::instantiate();
      ResourceManagerService::instantiate();
      registerExtensions();
      ProcessState::self()->startThreadPool();
      IPCThreadState::self()->joinThreadPool();
  }

在mediaserver启动时先通过ProcessState::self()创建ProcessState对象实例赋值给指针变量proc，然后获得ServiceManager的实例，接着初始化 MediaPlayerService 。

下面先看一下ProcessState::self()

ProcessState

/android_o/frameworks/native/libs/binder/ProcessState.cpp

  sp<ProcessState> ProcessState::self()
  {
      Mutex::Autolock _l(gProcessMutex);
       //gProcess 是一个单例，singleton。
      if (gProcess != NULL) {
          return gProcess;
      }
      //创建ProcessState
      //参数dev/binder传进去供open_driver使用
      gProcess = new ProcessState("/dev/binder");
      return gProcess;
  }

通过new ProcessState(“/dev/binder”)创建ProcessState，在它的构造函数中有一个重要的初始化操作是 mDriverFD(open_driver(driver))

 ProcessState::ProcessState(const char *driver)
      : mDriverName(String8(driver))
      , mDriverFD(open_driver(driver))
      , mVMStart(MAP_FAILED)//映射内存的起始地址
      , mThreadCountLock(PTHREAD_MUTEX_INITIALIZER)
      , mThreadCountDecrement(PTHREAD_COND_INITIALIZER)
      , mExecutingThreadsCount(0)
      , mMaxThreads(DEFAULT_MAX_BINDER_THREADS)
      , mStarvationStartTimeMs(0)
      , mManagesContexts(false)
      , mBinderContextCheckFunc(NULL)
      , mBinderContextUserData(NULL)
      , mThreadPoolStarted(false)
      , mThreadPoolSeq(1)
 {
     if (mDriverFD >= 0) {
         // mmap the binder, providing a chunk of virtual address space to receive transactions.
         mVMStart = mmap(0, BINDER_VM_SIZE, PROT_READ, MAP_PRIVATE | MAP_NORESERVE, mDriverFD, 0);
         if (mVMStart == MAP_FAILED) {
             // *sigh*
             ALOGE("Using /dev/binder failed: unable to mmap transaction memory.\n");
             close(mDriverFD);
             mDriverFD = -1;
             mDriverName.clear();
         }
     }

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

再来看 open_driver(driver))，参数driver就是/dev/binder，打开/dev/binder这个设备，这个是android在内核中用于完成进程间通讯而设置的一个虚拟的设备，这也是内核中Binder驱动不与真实的设备有关，但是被称为驱动的原因吧。

static int open_driver(const char *driver)
{
    int fd = open(driver, O_RDWR | O_CLOEXEC);
    if (fd >= 0) {
        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(%d) does not match user space protocol(%d)! ioctl() return value: %d",vers,BINDER_CURRENT_PROTOCOL_VERSION, result);
            close(fd);
            fd = -1;
        }
        //DEFAULT_MAX_BINDER_THREADS 最大binder线程数量
        //通过ioctl的方式告诉binder驱动，这个fd支持的最大线程数是15
        size_t maxThreads = DEFAULT_MAX_BINDER_THREADS;
        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 '%s' failed: %s\n", driver, strerror(errno));
    }
    return fd;
}

ProcessState创建的结果：

1 打开/dev/binder设备，这就相当于与内核的Binder驱动有了交互的通道。
2 对返回的fd使用mmap，这样Binder驱动就会分配一块内存来接收数据。
由于ProcessState的惟一性，因此一个进程只打开设备一次。

ServiceManager

创建完ProcessState后接着便是获得ServiceManager的实例

sp<IServiceManager> sm(defaultServiceManager());

android_o/frameworks/native/libs/binder/IServiceManager.cpp

  sp<IServiceManager> defaultServiceManager()
  {
      //又是一个单例
      if (gDefaultServiceManager != NULL) return gDefaultServiceManager;

      {
          AutoMutex _l(gDefaultServiceManagerLock);
          while (gDefaultServiceManager == NULL) {
              gDefaultServiceManager = interface_cast<IServiceManager>(
                  ProcessState::self()->getContextObject(NULL));
              if (gDefaultServiceManager == NULL)
                  sleep(1);
          }
      }

      return gDefaultServiceManager;
  }

sp sm = defaultServiceManager(); 返回的实际是BpServiceManager，它的remote对象是BpBinder。

MediaPlayerService

MediaPlayerService::instantiate();

android_o/frameworks/av/media/libmediaplayerservice/MediaPlayerService.cpp

  void MediaPlayerService::instantiate() {
      //defaultServiceManager返回的是刚才创建的BpServiceManager调用它的addService函数
      defaultServiceManager()->addService(
              String16("media.player"), new MediaPlayerService());
  }

  MediaPlayerService::MediaPlayerService()
  {
      ALOGV("MediaPlayerService created");
      mNextConnId = 1;

      MediaPlayerFactory::registerBuiltinFactories();
  }

android_o/frameworks/av/media/libmediaplayerservice/MediaPlayerService.h

class MediaPlayerService : public BnMediaPlayerService

MediaPlayerService从BnMediaPlayerService派生

Bn 是Binder Native的含义，是和Bp相对的，Bp的p是proxy代理的意思，那么另一端一定有一个和代理打交道的东西，这个就是Bn。

到目前为止都构造出来:

• BpServiceManager

• BnMediaPlayerService

这两个东西不是相对的两端，从BnXXX就可以判断，BpServiceManager对应的应该是BnServiceManager，BnMediaPlayerService对应的应该是BpMediaPlayerService。

创建一个新的Service—BnMediaPlayerService，想把它告诉ServiceManager。

那我怎么和ServiceManager通讯呢？恩，利用BpServiceManager。所以调用了BpServiceManager的addService函数

为什么要搞个ServiceManager来呢？这个和Android机制有关系。所有Service都需要加入到ServiceManager来管理。同时也方便了Client来查询系统存在哪些Service，没看见我们传入了字符串吗？这样就可以通过Human Readable的字符串来查找Service了。
。。。。。。
待续