Android_Binder—分析MediaServer解析服务的初始化和注册

已于 2022-11-11 18:19:58 修改
阅读量713 收藏
点赞数
分类专栏： Android 文章标签： java 前端 服务器
于 2022-07-12 11:03:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41939525/article/details/125620718
版权

\frameworks\av\media\mediaserver\main_mediaserver.cpp：

该文件含有main函数，是可执行的文件。

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

    sp<ProcessState> proc(ProcessState::self());
    sp<IServiceManager> sm(defaultServiceManager());
    ALOGI("ServiceManager: %p", sm.get());
    AIcu_initializeIcuOrDie();
    MediaPlayerService::instantiate();
    ResourceManagerService::instantiate();
    registerExtensions();
    ProcessState::self()->startThreadPool();
    IPCThreadState::self()->joinThreadPool();
}
  1. 初始化一个ProcessState对象
  2. 获取IServiceManager对象
  3. 调用MediaPlayerService和ResourceManagerService的instantiate方法
  4. startThreadPool和joinThreadPool方法

1.ProcessState对象

#ifdef __ANDROID_VNDK__
const char* kDefaultDriver = "/dev/vndbinder";
#else
const char* kDefaultDriver = "/dev/binder";

sp<ProcessState> ProcessState::self()
{
    Mutex::Autolock _l(gProcessMutex);
    if (gProcess != nullptr) {
        return gProcess;
    }
    gProcess = new ProcessState(kDefaultDriver);
    return gProcess;
}
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(nullptr)
    , mBinderContextUserData(nullptr)
    , mThreadPoolStarted(false)
    , mThreadPoolSeq(1)
    , mCallRestriction(CallRestriction::NONE)
{
    if (mDriverFD >= 0) {
        // mmap the binder, providing a chunk of virtual address space to receive transactions.
        mVMStart = mmap(nullptr, BINDER_VM_SIZE, PROT_READ, MAP_PRIVATE | MAP_NORESERVE, mDriverFD, 0);
        if (mVMStart == MAP_FAILED) {
            // *sigh*
            ALOGE("Using %s failed: unable to mmap transaction memory.\n", mDriverName.c_str());
            close(mDriverFD);
            mDriverFD = -1;
            mDriverName.clear();
        }
    }

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

以上我们注意两个重点： 

mDriverFD(open_driver(driver))

 open_driver的作用就是打开/dev/binder这个设备，它是android在内核中专门用于完成进程间通信而设置的一个虚拟设备

static int open_driver()
{
    int fd =open("/dev/binder", O_RDWR);//打开/dev/binder设备
    if (fd>= 0) {
         ......
       size_t maxThreads = 15;
       //通过ioctl方式告诉binder驱动，这个fd支持的最大线程数是15个
       result = ioctl(fd, BINDER_SET_MAX_THREADS, &maxThreads);  
   }
return fd;
......
}

第二个重点是：

mVMStart = mmap(nullptr, BINDER_VM_SIZE, PROT_READ, MAP_PRIVATE | MAP_NORESERVE, mDriverFD, 0);

 mmap是磁盘文件与内存相互映射的方法，这里表示向Binder驱动申请一块(1M-8K)的虚拟地址空间来接收事务。

注意ProcessState对象是个单例。

2.IServiceManager对象

frameworks\native\libs\binder\IServiceManager.cpp:

sp<IServiceManager> defaultServiceManager()
{
    if (gDefaultServiceManager != nullptr) return gDefaultServiceManager;

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

    return gDefaultServiceManager;
}


template<typename INTERFACE>
inline sp<INTERFACE> interface_cast(const sp<IBinder>& obj)
{
    return INTERFACE::asInterface(obj); 
}

interface_cast方法参数是IBinder对象强转后返回了一个IServiceManager对象。

看下getContextObject方法：

frameworks\native\libs\binder\ProcessState.cpp

sp<IBinder> ProcessState::getContextObject(const sp<IBinder>& /*caller*/)
{
    return getStrongProxyForHandle(0);
}

sp<IBinder> ProcessState::getStrongProxyForHandle(int32_t handle)
{
    sp<IBinder> result;

    AutoMutex _l(mLock);

    handle_entry* e = lookupHandleLocked(handle);

    if (e != nullptr) {
        IBinder* b = e->binder;
        if (b == nullptr || !e->refs->attemptIncWeak(this)) {
            if (handle == 0) {
                Parcel data;
                status_t status = IPCThreadState::self()->transact(
                        0, IBinder::PING_TRANSACTION, data, nullptr, 0);
                if (status == DEAD_OBJECT)
                   return nullptr;
            }
            b = BpBinder::create(handle);
            e->binder = b;
            if (b) e->refs = b->getWeakRefs();
            result = b;
        } else {
            result.force_set(b);
            e->refs->decWeak(this);
        }
    }

    return result;
}

这里根据handle创建了BpBinder对象并返回，所以getContextObject方法返回的是一个BpBinder对象，但是经过interface_cast将该对象转成了IServiceManager类型的。

在IServiceManager.cpp里面还有句代码：

IMPLEMENT_META_INTERFACE(ServiceManager, "android.os.IServiceManager");

看样子是使用了某个宏定义，点进去看：

#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 != nullptr) {                                           \
            intr = static_cast<I##INTERFACE*>(                          \
                obj->queryLocalInterface(                               \
                        I##INTERFACE::descriptor).get());               \
            if (intr == nullptr) {                                      \
                intr = new Bp##INTERFACE(obj);                          \
            }                                                           \
        }                                                               \
        return intr;                                                    \
    }                                                                   \
    std::unique_ptr<I##INTERFACE> I##INTERFACE::default_impl;           \
    bool I##INTERFACE::setDefaultImpl(std::unique_ptr<I##INTERFACE> impl)\
    {                                                                   \
        if (!I##INTERFACE::default_impl && impl) {                      \
            I##INTERFACE::default_impl = std::move(impl);               \
            return true;                                                \
        }                                                               \
        return false;                                                   \
    }                                                                   \
    const std::unique_ptr<I##INTERFACE>& I##INTERFACE::getDefaultImpl() \
    {                                                                   \
        return I##INTERFACE::default_impl;                              \
    }                                                                   \
    I##INTERFACE::I##INTERFACE() { }                                    \
    I##INTERFACE::~I##INTERFACE() { }                                   \

 我们把对应的值ServiceManager, "android.os.IServiceManager"代入进去变成：

#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> IServiceManager::asInterface(              
            const ::android::sp<::android::IBinder>& obj)               
    {                                                                   
        ::android::sp<IServiceManager> intr;                               
        if (obj != nullptr) {                                           
            intr = static_cast<IServiceManager*>(                          
                obj->queryLocalInterface(                               
                        IServiceManager::descriptor).get());               
            if (intr == nullptr) {                                      
                intr = new BpServiceManager(obj);                          
            }                                                           
        }                                                               
        return intr;                                                    
    }                                                                   
    std::unique_ptr<IServiceManager> IServiceManager::default_impl;           
    bool IServiceManager::setDefaultImpl(std::unique_ptr<IServiceManager> impl)
    {                                                                   
        if (!IServiceManager::default_impl && impl) {                      
            IServiceManager::default_impl = std::move(impl);               
            return true;                                                
        }                                                               
        return false;                                                   
    }                                                                   
    const std::unique_ptr<IServiceManager>& IServiceManager::getDefaultImpl() 
    {                                                                   
        return IServiceManager::default_impl;                             
    }                                                                   
    IServiceManager::IServiceManager() { }                                   
    IServiceManager::~IServiceManager() { }

所以之前说interface_cast将该对象转成了IServiceManager类型，

    ::android::sp<IServiceManager> IServiceManager::asInterface(              
            const ::android::sp<::android::IBinder>& obj)               
    {                                                                   
        ::android::sp<IServiceManager> intr;                               
        if (obj != nullptr) {                                           
            intr = static_cast<IServiceManager*>(                          
                obj->queryLocalInterface(                               
                        IServiceManager::descriptor).get());               
            if (intr == nullptr) {                                      
                intr = new BpServiceManager(obj);                          
            }                                                           
        }                                                               
        return intr;                                                    
    }

这里的转换不是类型强转，而是用BpBinder对象创建了一个BpServiceManager对象。

注意BpServiceManager是个单例。

我们知道了IServiceManager的defaultServiceManager方法返回了一个BpServiceManager对象，接下来看看哪里用到了他。

3.调用MediaPlayerService和ResourceManagerService的instantiate方法

frameworks\av\media\libmediaplayerservice\MediaPlayerService.cpp：

void MediaPlayerService::instantiate() {
    defaultServiceManager()->addService(
            String16("media.player"), new MediaPlayerService());
}

这里调用了IServiceManager的addService：

    virtual status_t addService(const String16& name, const sp<IBinder>& service,
                                bool allowIsolated, int dumpsysPriority) {
        Parcel data, reply;
        data.writeInterfaceToken(IServiceManager::getInterfaceDescriptor());
        data.writeString16(name);
        data.writeStrongBinder(service);
        data.writeInt32(allowIsolated ? 1 : 0);
        data.writeInt32(dumpsysPriority);
        status_t err = remote()->transact(ADD_SERVICE_TRANSACTION, data, &reply);
        return err == NO_ERROR ? reply.readExceptionCode() : err;
    }

这里调用了remote()的transact方法，至于remote()返回了啥，我们可以看一下BpServiceManager：

frameworks\native\libs\binder\IServiceManager.cpp:BpServiceManager

class BpServiceManager : public BpInterface<IServiceManager>
{
public:
    //explicit关键字：修饰内部类，表示不能发生相应的隐式类型转换
    explicit BpServiceManager(const sp<IBinder>& impl) 
        : BpInterface<IServiceManager>(impl)
    {
    }
.......
}

可以看到BpServiceManager实现了BpInterface，从前面我们知道impl是BpBinder对象。

接下来我们看BpInterface：

frameworks\native\libs\binder\include\binder\IInterface.h:BpInterface

template<typename INTERFACE>
inline BpInterface<INTERFACE>::BpInterface(const sp<IBinder>& remote)
    : BpRefBase(remote)
{
}

frameworks\native\libs\binder\Binder.cpp:BpRefBase

BpRefBase::BpRefBase(const sp<IBinder>& o)
    : mRemote(o.get()), mRefs(nullptr), mState(0)
{
    extendObjectLifetime(OBJECT_LIFETIME_WEAK);

    if (mRemote) {
        mRemote->incStrong(this);           // Removed on first IncStrong().
        mRefs = mRemote->createWeak(this);  // Held for our entire lifetime.
    }
}

这里 mRemote(o.get()) 给mRemote赋值了BpBinder

class BpRefBase : public virtual RefBase
{
protected:
...
    inline  IBinder*        remote()                { return mRemote; }
    inline  IBinder*        remote() const          { return mRemote; }
    IBinder* const          mRemote;
....
}

所以remote()就是返回的BpBinder。

回到之前的remote()->transact(ADD_SERVICE_TRANSACTION, data, &reply);

所以调用的是BpBinder的transact方法：

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) {
        status_t status = IPCThreadState::self()->transact(
            mHandle, code, data, reply, flags);
        if (status == DEAD_OBJECT) mAlive = 0;
        return status;
    }

    return DEAD_OBJECT;
}

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;

    ....
    err = writeTransactionData(BC_TRANSACTION, flags, handle, code, data, nullptr);
    ....
    err = waitForResponse(nullptr, nullptr);

    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.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();
    } else if (statusBuffer) {
        tr.flags |= TF_STATUS_CODE;
        *statusBuffer = err;
        tr.data_size = sizeof(status_t);
        tr.data.ptr.buffer = reinterpret_cast<uintptr_t>(statusBuffer);
        tr.offsets_size = 0;
        tr.data.ptr.offsets = 0;
    } else {
        return (mLastError = err);
    }

    mOut.writeInt32(cmd);
    mOut.write(&tr, sizeof(tr));

    return NO_ERROR;
}

mIn是用来接受来自Binder设备的数据的，mOut是存储发往Binder设备的数据的。

所以addService把信息写到了mOut里面。

status_t IPCThreadState::waitForResponse(Parcel *reply, status_t *acquireResult)
{
    uint32_t cmd;
    int32_t err;

    while (1) {
        if ((err=talkWithDriver()) < NO_ERROR) break;
        err = mIn.errorCheck();
        if (err < NO_ERROR) break;
        if (mIn.dataAvail() == 0) continue;

        cmd = (uint32_t)mIn.readInt32();

        IF_LOG_COMMANDS() {
            alog << "Processing waitForResponse Command: "
                << getReturnString(cmd) << endl;
        }

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

        case BR_DEAD_REPLY:
            err = DEAD_OBJECT;
            goto finish;

        case BR_FAILED_REPLY:
            err = FAILED_TRANSACTION;
            goto finish;

        case BR_ACQUIRE_RESULT:
            {
                ALOG_ASSERT(acquireResult != NULL, "Unexpected brACQUIRE_RESULT");
                const int32_t result = mIn.readInt32();
                if (!acquireResult) continue;
                *acquireResult = result ? NO_ERROR : INVALID_OPERATION;
            }
            goto finish;

        case BR_REPLY:
            {
                binder_transaction_data tr;
                err = mIn.read(&tr, sizeof(tr));
                ALOG_ASSERT(err == NO_ERROR, "Not enough command data for brREPLY");
                if (err != NO_ERROR) goto finish;

                if (reply) {
                    if ((tr.flags & TF_STATUS_CODE) == 0) {
                        reply->ipcSetDataReference(
                            reinterpret_cast<const uint8_t*>(tr.data.ptr.buffer),
                            tr.data_size,
                            reinterpret_cast<const binder_size_t*>(tr.data.ptr.offsets),
                            tr.offsets_size/sizeof(binder_size_t),
                            freeBuffer, this);
                    } else {
                        err = *reinterpret_cast<const status_t*>(tr.data.ptr.buffer);
                        freeBuffer(nullptr,
                            reinterpret_cast<const uint8_t*>(tr.data.ptr.buffer),
                            tr.data_size,
                            reinterpret_cast<const binder_size_t*>(tr.data.ptr.offsets),
                            tr.offsets_size/sizeof(binder_size_t), this);
                    }
                } else {
                    freeBuffer(nullptr,
                        reinterpret_cast<const uint8_t*>(tr.data.ptr.buffer),
                        tr.data_size,
                        reinterpret_cast<const binder_size_t*>(tr.data.ptr.offsets),
                        tr.offsets_size/sizeof(binder_size_t), this);
                    continue;
                }
            }
            goto finish;

        default:
            err = executeCommand(cmd);
            if (err != NO_ERROR) goto finish;
            break;
        }
    }

finish:
    if (err != NO_ERROR) {
        if (acquireResult) *acquireResult = err;
        if (reply) reply->setError(err);
        mLastError = err;
    }

    return err;
}

终于看到我们想要的了，talkWithDriver()方法，在该方法下面就是从mIn里面获取数据，并在switch里面进行处理，mIn的数据是从talkWithDriver方法中填充的。

status_t IPCThreadState::talkWithDriver(bool doReceive)
{
    if (mProcess->mDriverFD <= 0) {
        return -EBADF;
    }

    binder_write_read bwr;

    // Is the read buffer empty?
    const bool needRead = mIn.dataPosition() >= mIn.dataSize();

    // We don't want to write anything if we are still reading
    // from data left in the input buffer and the caller
    // has requested to read the next data.
    const size_t outAvail = (!doReceive || needRead) ? mOut.dataSize() : 0;

    bwr.write_size = outAvail;
    bwr.write_buffer = (uintptr_t)mOut.data();

    // This is what we'll read.
    if (doReceive && needRead) {
        bwr.read_size = mIn.dataCapacity();
        bwr.read_buffer = (uintptr_t)mIn.data();
    } else {
        bwr.read_size = 0;
        bwr.read_buffer = 0;
    }

   ...

    // Return immediately if there is nothing to do.
    if ((bwr.write_size == 0) && (bwr.read_size == 0)) return NO_ERROR;

    bwr.write_consumed = 0;
    bwr.read_consumed = 0;
    status_t err;
    do {
      
#if defined(__ANDROID__)
        if (ioctl(mProcess->mDriverFD, BINDER_WRITE_READ, &bwr) >= 0)
            err = NO_ERROR;
        else
            err = -errno;
#else
        err = INVALID_OPERATION;
#endif
        if (mProcess->mDriverFD <= 0) {
            err = -EBADF;
        }

    } while (err == -EINTR);

    if (err >= NO_ERROR) {
        if (bwr.write_consumed > 0) {
            if (bwr.write_consumed < mOut.dataSize())
                mOut.remove(0, bwr.write_consumed);
            else {
                mOut.setDataSize(0);
                processPostWriteDerefs();
            }
        }
        if (bwr.read_consumed > 0) {
            mIn.setDataSize(bwr.read_consumed);
            mIn.setDataPosition(0);
        }
        return NO_ERROR;
    }

    return err;
}

binder_write_read 是用来与Binder设备交换数据的结构。

填充完bwr的输入和输出的缓冲区后，最重要的方法就是

ioctl(mProcess->mDriverFD, BINDER_WRITE_READ, &bwr)

ioctl是一个专用于设备输入输出操作的系统调用,该调用传入一个跟设备有关的请求码，系统调用的功能完全取决于请求码。

所以addService到头来就是向Binder设备输入输出内容，从Binder设备获取到的内容就这mIn里。

4.startThreadPool和joinThreadPool方法

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);
        t->run(name.string());
    }
}
class PoolThread : public Thread
{
public:
   PoolThread(bool isMain)
        :mIsMain(isMain){}
   protected:
    virtualbool threadLoop()
    {
       //线程函数如此简单，不过是在这个新线程中又创建了一个IPCThreadState。
        IPCThreadState::self()->joinThreadPool(mIsMain);
        return false;
    }
   const boolmIsMain;
};

threadLoop方法在线程run方法调用时会被循环调用的一个方法，返回false时该线程就会退出循环。

还需要看看IPCThreadState的joinThreadPool的实现，因为新创建的线程也会调用这个函数，具体代码如下所示：

void IPCThreadState::joinThreadPool(bool isMain)
{
    mOut.writeInt32(isMain ? BC_ENTER_LOOPER : BC_REGISTER_LOOPER);

    status_t result;
    do {
        processPendingDerefs();
        // now get the next command to be processed, waiting if necessary
        result = getAndExecuteCommand();

        if (result < NO_ERROR && result != TIMED_OUT && result != -ECONNREFUSED && result != -EBADF) {
            ALOGE("getAndExecuteCommand(fd=%d) returned unexpected error %d, aborting",
                  mProcess->mDriverFD, result);
            abort();
        }

        // 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);
}

这里循环运行了 getAndExecuteCommand()方法：

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++;
        if (mProcess->mExecutingThreadsCount >= mProcess->mMaxThreads &&
                mProcess->mStarvationStartTimeMs == 0) {
            mProcess->mStarvationStartTimeMs = uptimeMillis();
        }
        pthread_mutex_unlock(&mProcess->mThreadCountLock);

        result = executeCommand(cmd);

        pthread_mutex_lock(&mProcess->mThreadCountLock);
        mProcess->mExecutingThreadsCount--;
        if (mProcess->mExecutingThreadsCount < mProcess->mMaxThreads &&
                mProcess->mStarvationStartTimeMs != 0) {
            int64_t starvationTimeMs = uptimeMillis() - mProcess->mStarvationStartTimeMs;
            if (starvationTimeMs > 100) {
                ALOGE("binder thread pool (%zu threads) starved for %" PRId64 " ms",
                      mProcess->mMaxThreads, starvationTimeMs);
            }
            mProcess->mStarvationStartTimeMs = 0;
        }
        pthread_cond_broadcast(&mProcess->mThreadCountDecrement);
        pthread_mutex_unlock(&mProcess->mThreadCountLock);
    }

    return result;
}

我们之前得知talkWithDriver()是与Binder设备互动，获取数据到mIn中，getAndExecuteCommand方法就是在读取内容并运行executeCommand进行处理。

所以这里一共两个线程在读取Binder设备，一个是​ProcessState​的startThreadPool内部开启了一个子线程，一个是IPCThreadState的joinThreadPool在主线程。

总结：每个线程都有一个IPCThreadState和ServiceManager。

IPCThreadState：IPCThreadState的主要作用就是跟Binder设备通信，轮询、处理Binder设备cmd的executeCommand，并且提供了transact方法给BpBinder使用。每个IPCThreadState中都有一个mIn、一个mOut，其中mIn是用来接收来自Binder设备的数据的，而mOut则是用来存储发往Binder设备的数据的。

ServiceManager：用来管理服务，本身由BpBinder封装而成，需要注意的是它的handle是0，每个 handle对应一个Binder通信对象(比如另外一个进程中的Service)在 binder 设备中的话柄。而之所以每个进程都可以直接与 ServiceManager通信的原因是，它固定是0，也只能给 ServiceManager使用。而其他大于0的handle，则不确定是对应这个哪个进程的Service。只要是通过 addService添加的Service，在 ServiceManager中都会记录这个 Service的名称以及其在binder driver中对应的 handle，应用进程想要同一个名称为 A的Service通信，可通过 ServiceManager的 getService("A")获取其对应的 handle，这样就可以与之通信了。

通过BpBinder对象管理服务，可以查询、添加等。不过这些行为最终还是调用IPCThreadState提供的transact方法与Binder设备通信。

MediaServer的main函数，简单来说就是向该服务进程把自己包装成BpServiceManager通过IPCThreadState注册该服务即与Binder设备通信，然后在该进程中开启多线程轮询，读取Binder设备信息并处理。

#全家桶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
安卓上两类多媒体服务简要分析
tugouxp的专栏
07-12 1234
安卓系统里面有两类主流的多媒体服务实现， mediaserver和mediacodec server，两套方案作为安卓系统多媒体架构的基础支撑框架，为安卓设备提供视频解码方案. 关于mediacodec和mediaserver是安卓多媒体实现的两种框架，mediaplayer是一个server ,应用是通过binder请求多媒体服务的，这方面，mediacodec也一样，它也是server，应用也是通过binder请求media codec 服务的。mediacodec也有独立的进程，通过bin...
1. Android MultiMedia框架完全解析 - 从开机到MediaServer的注册过程
吾皇的博客
03-31 8629
Android的App一般是用java写的，大致流程如下： MediaPlayer mediaPlayer = new MediaPlayer(); mediaPlayer.setOnCompletionListener(new OnCompletionListener() { @Override public void onCompletion(MediaPlayer mp){ mediaP...
引领直播未来：强大的媒体服务器——media-server
最新发布
gitblog_00078的博客
05-26 331
引领直播未来：强大的媒体服务器——media-server 项目地址:https://gitcode.com/brpc/media-server 在今天的数字时代，实时流媒体已经成为我们生活的一部分，而media-server正是这一领域的杰出代表。基于Baidu Realtime Computing Framework (brpc)，这个开源项目为百度云的直播服务提供了坚实的技术基础。 项目介绍...
Andorid-MediaServer
cheriyou_的博客
07-15 958
前言: MediaServer是整个android中media部分的核心和灵魂。几乎所有与多媒体播放相关的内容都放在这里。 安卓系统有server manager，每个server需要注册到servermanager中，然后client可以根据server name去获取相应的service。servermanager开机自启动，并会向binder申明自己是serverma...
注册服务(addService)
kingmasterlife的博客
04-25 356
过程说明: 1. 获 取 ServiceManager: 讲 解 了 defaultServiceManager() 返回的是BpServiceManager 对象， 用于跟 servicemanager 进程通信;2. 理解 Binder 线程池的管理, 讲解了 startThreadPool 和joinThreadPool 过程.media 服务注册。
Android 系统服务（getSystemService）的常用用法介绍（一）
热门推荐
qaz0699的博客
08-09 1万+
Android 系统服务（getSystemService）的常用用法介绍（一） 0、 什么是系统服务？为什么要使用系统服务 我们在Android开发过程中经常会用到各种各样的系统管理服务，比如对Wifi进行操作时需要使用到WifiManager，对电源进行操作就需要使用到PowerMamager，对于电池得操作就需要使用到BatterManager… 可以说，系统服务时Android对于我们开发...
set_eth.zip_Android ip_android_android 设置mac_binder
09-21
总结来说，"set_eth.zip_Android ip_android_android 设置mac_binder"是一个关于如何在Android系统中通过Binder机制来设置IP和MAC地址的解决方案。这个过程涉及系统权限、服务创建、JNI调用以及安全控制等多方面知识...
Android底层源码分析_Binder
07-17
Android底层源码分析_Binder，Android底层源码分析_Binder
Android系统进程间通信（IPC）机制Binder中的Server启动过程源代码分析
09-01
在启动Server的过程中，关键的步骤在于初始化和注册服务。这个过程通常在main_mediaserver.cpp文件的main函数中完成。代码中的`ProcessState::self()`创建了一个ProcessState对象，它负责管理当前进程中的所有Binder...
Android NDK实现Binder服务和客户端
09-19
需要在系统源码下编译，或者提取出对应的头文件亦可。这里需要注意Android4.x以后系统SeLinux如果打开，系统级需要配置对应的sepolicy才能使用。测试阶段推荐直接setenforce 0关闭鉴权即可
android binder分析
10-25
在 main_mediaserver.cpp 的 main 函数中，我们可以看到 Binder 机制的实现过程。首先，创建了一个 ProcessState 对象，用于管理进程状态。然后，创建了一个 IServiceManager 对象，用于管理服务。接着，启动了...
（2） Android中Binder调用流程 --- Binder环境的初始化
china0851的专栏
02-20 749
       我们知道，在Android里Binder是进程间通信的基础，而且，Android的应用程序天生就支持Binder通信，为什么？没了Binder，Android里的四大组件将没法运转，比如Activity的启动其实是通过AMS来管理的，Activity里的那个token成员变量其实就是Activity在AMS中一条记录的引用，而这些都是跨进程的。        既然Binder是And...
Android Binder机制浅析(一)
一晌贪欢
08-17 330
Binder是Android系统进程间通信（IPC）方式之一。Linux已经拥有的进程间通信IPC手段包括(Internet Process Connection)： 管道（Pipe）、信号（Signal）和跟踪（Trace）、插口（Socket）、报文队列（Message）、共享内存（Share Memory）和信号量（Semaphore）。本文分析的是Binder的实现以及Binder组件Client、Server和Service Manager、Binder驱动的相互关系 本文根据网上现有资源进行整合
Android源码分析--MediaServer源码分析（一）
Joe_c 的专栏
03-27 4907
MediaServer中包括了系统中的许多重要的Server： AudioFlinger：音频系统中的核心服务 AudioPolicyService：音频系统中关于音频策略的重要服务 MediaPlayerService：多媒体系统中的重要服务 CameraService：有关照相和摄像的重要服务 同时，分析MediaServer对于理解Android中的IPC机制能够提供较好的帮助。Android
【安卓源码】Binder机制1-Servicemanager 进程的启动和defaultServiceManager
mike_jun的博客
04-23 1198
对于用户空间，不同进程之间彼此是不能共享的，而内核空间却是可共享的。Client进程向Server进程通信，恰恰是利用进程间可共享的内核内存空间来完成底层通信工作的，Client端与Server端进程往往采用ioctl等方法跟内核空间的驱动进行交互。Binder通信采用C/S架构，从组件视角来说，包含Client、Server、ServiceManager以及binder驱动，其中ServiceManager用于管理系统中的各种服务。
Android系统MediaServer分析
姥姥教我学编程
12-22 4941
1.MediaServer进程 /* ** Copyright 2008, The Android Open Source Project ** ** Licensed under the Apache License, Version 2.0 (the "License"); ** you may not use this file except in compliance with t
Binder通信过程中的用户空间线程池的管理
山庄来客的专栏
05-30 9380
在Binder通信机制里，客户端与服务端之间的通信是在专门的IPC通信线程中进行的。这些线程构成一个线程池。线程的创建和销毁是在用户空间进行的，而对线程的控制是在驱动层进行的，即驱动控制线程池中线程的生命，而线程本身则是运行在用户空间的。驱动层是通过BR_SPAWN_LOOPER向用户空间发送创建新线程的命令。 线程池的大小可以设置。默认情况下，线程池只有一个主线程，它在进程生命周期期间是不会退
Android-深入理解Binder（一）
weixin_43580319的博客
04-21 2992
文章目录深入理解Binder概述解析MediaServerMediaServer的入口函数ProcessStatedefaultServiceManager注册MediaPlayerService 深入理解Binder 概述 Binder是Android系统提供的一种IPC机制（进程间通信），由于Android是基于Linux内核的，因此除了Binder以外，还存在其他的IPC机制，如管道和Socket等。Android系统基本上可以看作是一个基于Binder通信的C/S架构，Binder就像是网络一样，把
startThreadPool调用流程
gaosiniquanjia的博客
03-21 1170
ProcessState::self()->startThreadPool(); 1、startThreadPool()的主要作用是:(ProcessState.cpp) 调用spawnPooledThread( true ) 2、spawnPooledThread这个函数里面主要作用是:(ProcessState.cpp) 启动一个线程sp<Thread> t = new PoolThread(isMain); t->run(buf); //最终就会执行Po...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值