老罗android binder,Android系统进程间通信（IPC）机制Binder中的Server启动过程源代码分析(1)...

最新推荐文章于 2024-04-12 17:40:32 发布

爱大淼爱大唐

最新推荐文章于 2024-04-12 17:40:32 发布

阅读量240

点赞数

文章标签：老罗android binder

在前面一篇文章

本文通过一个具体的例子来说明Binder机制中Server的启动过程。我们知道，在Android系统中，提供了多媒体播放的功能，这个功能是以服务的形式来提供的。这里，我们就通过分析MediaPlayerService的实现来了解Media Server的启动过程。

首先，看一下MediaPlayerService的类图，以便我们理解下面要描述的内容。

我们将要介绍的主角MediaPlayerService继承于BnMediaPlayerService类，熟悉Binder机制的同学应该知道BnMediaPlayerService是一个Binder Native类，用来处理Client请求的。BnMediaPlayerService继承于BnInterface类，BnInterface是一个模板类，它定义在frameworks/base/include/binder/IInterface.h文件中：

template

class BnInterface :publicINTERFACE,publicBBinder

{

public:

virtual sp queryLocalInterface(const String16& _descriptor);

virtual const String16& getInterfaceDescriptor() const;

protected:

virtual IBinder* onAsBinder();

};

这里可以看出，BnMediaPlayerService实际是继承了IMediaPlayerService和BBinder类。IMediaPlayerService和BBinder类又分别继承了IInterface和IBinder类，IInterface和IBinder类又同时继承了RefBase类。

实际上，BnMediaPlayerService并不是直接接收到Client处发送过来的请求，而是使用了IPCThreadState接收Client处发送过来的请求，而IPCThreadState又借助了ProcessState类来与Binder驱动程序交互。有关IPCThreadState和ProcessState的关系，可以参考上一篇文章浅谈Android系统进程间通信(IPC)机制Binder中的Server和Client获得Service Manager接口之路，接下来也会有相应的描述。IPCThreadState接收到了Client处的请求后，就会调用BBinder类的transact函数，并传入相关参数，BBinder类的transact函数最终调用BnMediaPlayerService类的onTransact函数，于是，就开始真正地处理Client的请求了。

了解了MediaPlayerService类结构之后，就要开始进入到本文的主题了。

首先，看看MediaPlayerService是如何启动的。启动MediaPlayerService的代码位于frameworks/base/media/mediaserver/main_mediaserver.cpp文件中：

intmain(intargc,char** argv)

{

sp proc(ProcessState::self());

sp sm = defaultServiceManager();

LOGI("ServiceManager: %p", sm.get());

AudioFlinger::instantiate();

MediaPlayerService::instantiate();

CameraService::instantiate();

AudioPolicyService::instantiate();

ProcessState::self()->startThreadPool();

IPCThreadState::self()->joinThreadPool();

}

这里我们不关注AudioFlinger和CameraService相关的代码。

先看下面这句代码：

sp proc(ProcessState::self());

这句代码的作用是通过ProcessState::self()调用创建一个ProcessState实例。ProcessState::self()是ProcessState类的一个静态成员变量，定义在frameworks/base/libs/binder/ProcessState.cpp文件中：

sp ProcessState::self()

{

if (gProcess !=NULL)returngProcess;

AutoMutex _l(gProcessMutex);

if (gProcess ==NULL) gProcess = new ProcessState;

returngProcess;

}

这里可以看出，这个函数作用是返回一个全局唯一的ProcessState实例gProcess。全局唯一实例变量gProcess定义在frameworks/base/libs/binder/Static.cpp文件中：

Mutex gProcessMutex;

sp gProcess;

再来看ProcessState的构造函数：

ProcessState::ProcessState()

: mDriverFD(open_driver())

, mVMStart(MAP_FAILED)

, mManagesContexts(false)

, mBinderContextCheckFunc(NULL)

, mBinderContextUserData(NULL)

, mThreadPoolStarted(false)

, mThreadPoolSeq(1)

{

if (mDriverFD >= 0) {

// XXX Ideally, there should be a specific defineforwhether we

// have mmap (orwhether we could possibly have the kernel module

// availabla).

#if !defined(HAVE_WIN32_IPC)

// mmap the binder, providing a chunkofvirtual addressspacetoreceive transactions.

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

if (mVMStart == MAP_FAILED) {

// *sigh*

LOGE("Using /dev/binder failed: unable to mmap transaction memory.\n");

close(mDriverFD);

mDriverFD = -1;

}

#else

mDriverFD = -1;

#endif

}

if (mDriverFD

// Needtorun without the driver, starting our own thread pool.

}

这个函数有两个关键地方，一是通过open_driver函数打开Binder设备文件/dev/binder，并将打开设备文件描述符保存在成员变量mDriverFD中；二是通过mmap来把设备文件/dev/binder映射到内存中。

先看open_driver函数的实现，这个函数同样位于frameworks/base/libs/binder/ProcessState.cpp文件中：

staticintopen_driver()

{

if (gSingleProcess) {

return-1;

}

intfd =open("/dev/binder", O_RDWR);

if (fd >= 0) {

fcntl(fd, F_SETFD, FD_CLOEXEC);

intvers;

#if defined(HAVE_ANDROID_OS)

status_t result = ioctl(fd, BINDER_VERSION, &vers);

#else

status_t result = -1;

errno = EPERM;

#endif

if (result == -1) {

LOGE("Binder ioctl to obtain version failed: %s", strerror(errno));

close(fd);

fd = -1;

}

if (result != 0 || vers != BINDER_CURRENT_PROTOCOL_VERSION) {

LOGE("Binder driver protocol does not match user space protocol!");

close(fd);

fd = -1;

}

#if defined(HAVE_ANDROID_OS)

size_t maxThreads = 15;

result = ioctl(fd, BINDER_SET_MAX_THREADS, &maxThreads);

if (result == -1) {

LOGE("Binder ioctl to set max threads failed: %s", strerror(errno));

}

#endif

}else{

LOGW("Opening '/dev/binder' failed: %s\n", strerror(errno));

}

returnfd;

}

这个函数的作用主要是通过open文件操作函数来打开/dev/binder设备文件，然后再调用ioctl文件控制函数来分别执行BINDER_VERSION和BINDER_SET_MAX_THREADS两个命令来和Binder驱动程序进行交互，前者用于获得当前Binder驱动程序的版本号，后者用于通知Binder驱动程序，MediaPlayerService最多可同时启动15个线程来处理Client端的请求。

open在Binder驱动程序中的具体实现，请参考前面一篇文章浅谈Service Manager成为Android进程间通信(IPC)机制Binder守护进程之路，这里不再重复描述。打开/dev/binder设备文件后，Binder驱动程序就为MediaPlayerService进程创建了一个struct binder_proc结构体实例来维护MediaPlayerService进程上下文相关信息。

我们来看一下ioctl文件操作函数执行BINDER_VERSION命令的过程：

status_t result = ioctl(fd, BINDER_VERSION, &vers);

这个函数调用最终进入到Binder驱动程序的binder_ioctl函数中，我们只关注BINDER_VERSION相关的部分逻辑：

staticlong binder_ioctl(struct file *filp, unsignedintcmd, unsigned long arg)

{

intret;

struct binder_proc *proc = filp->private_data;

struct binder_thread *thread;

unsignedintsize= _IOC_SIZE(cmd);

void __user *ubuf = (void __user *)arg;

/*printk(KERN_INFO"binder_ioctl: %d:%d %x %lx\n", proc->pid,current->pid, cmd, arg);*/

ret = wait_event_interruptible(binder_user_error_wait, binder_stop_on_user_error

if (ret)

returnret;

mutex_lock(&binder_lock);

thread = binder_get_thread(proc);

if (thread ==NULL) {

ret = -ENOMEM;

gotoerr;

}

switch (cmd) {

......

caseBINDER_VERSION:

if (size!= sizeof(struct binder_version)) {

ret = -EINVAL;

gotoerr;

}

if (put_user(BINDER_CURRENT_PROTOCOL_VERSION, &((struct binder_version *)ubuf)->protocol_version)) {

ret = -EINVAL;

gotoerr;

}

break;

......

}

ret = 0;

err:

......

returnret;

}

很简单，只是将BINDER_CURRENT_PROTOCOL_VERSION写入到传入的参数arg指向的用户缓冲区中去就返回了。BINDER_CURRENT_PROTOCOL_VERSION是一个宏，定义在kernel/common/drivers/staging/android/binder.h文件中：

/* Thisisthecurrentprotocol version. */

#define BINDER_CURRENT_PROTOCOL_VERSION 7

这里为什么要把ubuf转换成struct binder_version之后，再通过其protocol_version成员变量再来写入呢，转了一圈，最终内容还是写入到ubuf中。我们看一下struct binder_version的定义就会明白，同样是在kernel/common/drivers/staging/android/binder.h文件中：

/* UsewithBINDER_VERSION, driver fillsinfields. */

struct binder_version {

/* driver protocol version-- increment with incompatible change */

signed long protocol_version;

};

从注释中可以看出来，这里是考虑到兼容性，因为以后很有可能不是用signed long来表示版本号。

这里有一个重要的地方要注意的是，由于这里是打开设备文件/dev/binder之后，第一次进入到binder_ioctl函数，因此，这里调用binder_get_thread的时候，就会为当前线程创建一个struct binder_thread结构体变量来维护线程上下文信息，具体可以参考浅谈Service Manager成为Android进程间通信(IPC)机制Binder守护进程之路一文。

接着我们再来看一下ioctl文件操作函数执行BINDER_SET_MAX_THREADS命令的过程：

result = ioctl(fd, BINDER_SET_MAX_THREADS, &maxThreads);

这个函数调用最终进入到Binder驱动程序的binder_ioctl函数中，我们只关注BINDER_SET_MAX_THREADS相关的部分逻辑：

staticlong binder_ioctl(struct file *filp, unsignedintcmd, unsigned long arg)

{

intret;

struct binder_proc *proc = filp->private_data;

struct binder_thread *thread;

unsignedintsize= _IOC_SIZE(cmd);

void __user *ubuf = (void __user *)arg;

/*printk(KERN_INFO"binder_ioctl: %d:%d %x %lx\n", proc->pid,current->pid, cmd, arg);*/

ret = wait_event_interruptible(binder_user_error_wait, binder_stop_on_user_error

if (ret)

returnret;

mutex_lock(&binder_lock);

thread = binder_get_thread(proc);

if (thread ==NULL) {

ret = -ENOMEM;

gotoerr;

}

switch (cmd) {

......

caseBINDER_SET_MAX_THREADS:

if (copy_from_user(&proc->max_threads, ubuf, sizeof(proc->max_threads))) {

ret = -EINVAL;

gotoerr;

}

break;

......

}

ret = 0;

err:

......

returnret;

}

这里实现也是非常简单，只是简单地把用户传进来的参数保存在proc->max_threads中就完毕了。注意，这里再调用binder_get_thread函数的时候，就可以在proc->threads中找到当前线程对应的struct binder_thread结构了，因为前面已经创建好并保存在proc->threads红黑树中。

回到ProcessState的构造函数中，这里还通过mmap函数来把设备文件/dev/binder映射到内存中，这个函数在浅谈Service Manager成为Android进程间通信(IPC)机制Binder守护进程之路一文也已经有详细介绍，这里不再重复描述。宏BINDER_VM_SIZE就定义在ProcessState.cpp文件中：

#define BINDER_VM_SIZE ((1*1024*1024) - (4096 *2))

mmap函数调用完成之后，Binder驱动程序就为当前进程预留了BINDER_VM_SIZE大小的内存空间了。

这样，ProcessState全局唯一变量gProcess就创建完毕了，回到frameworks/base/media/mediaserver/main_mediaserver.cpp文件中的main函数，下一步是调用defaultServiceManager函数来获得Service Manager的远程接口，这个已经在上一篇文章

再接下来，就进入到MediaPlayerService::instantiate函数把MediaPlayerService添加到Service Manger中去了。这个函数定义在frameworks/base/media/libmediaplayerservice/MediaPlayerService.cpp文件中：

void MediaPlayerService::instantiate() {

defaultServiceManager()->addService(

String16("media.player"), new MediaPlayerService());

}

我们重点看一下IServiceManger::addService的过程，这有助于我们加深对Binder机制的理解。

在上一篇文章浅谈Android系统进程间通信(IPC)机制Binder中的Server和Client获得Service Manager接口之路中说到，defaultServiceManager返回的实际是一个BpServiceManger类实例，因此，我们看一下BpServiceManger::addService的实现，这个函数实现在frameworks/base/libs/binder/IServiceManager.cpp文件中：

class BpServiceManager :publicBpInterface

{

public:

BpServiceManager(const sp& impl)

: BpInterface(impl)

{

}

......

virtual status_t addService(const String16&name, const sp& service)

{

Parcel data, reply;

data.writeInterfaceToken(IServiceManager::getInterfaceDescriptor());

data.writeString16(name);

data.writeStrongBinder(service);

status_t err = remote()->transact(ADD_SERVICE_TRANSACTION, data, &reply);

returnerr == NO_ERROR ? reply.readExceptionCode()

}

......

};

这里的Parcel类是用来于序列化进程间通信数据用的。

先来看这一句的调用：

data.writeInterfaceToken(IServiceManager::getInterfaceDescriptor());

IServiceManager::getInterfaceDescriptor()返回来的是一个字符串，即"android.os.IServiceManager"，具体可以参考IServiceManger的实现。我们看一下Parcel::writeInterfaceToken的实现，位于frameworks/base/libs/binder/Parcel.cpp文件中：

// Write RPC headers. (previously just the interface token)

status_t Parcel::writeInterfaceToken(const String16& interface)

{

writeInt32(IPCThreadState::self()->getStrictModePolicy() |

STRICT_MODE_PENALTY_GATHER);

// currently the interface identification tokenisjust itsnameasa string

returnwriteString16(interface);

}

它的作用是写入一个整数和一个字符串到Parcel中去。

再来看下面的调用：

data.writeString16(name);

这里又是写入一个字符串到Parcel中去，这里的name即是上面传进来的“media.player”字符串。

往下看：

data.writeStrongBinder(service);

这里定入一个Binder对象到Parcel去。我们重点看一下这个函数的实现，因为它涉及到进程间传输Binder实体的问题，比较复杂，需要重点关注，同时，也是理解Binder机制的一个重点所在。注意，这里的service参数是一个MediaPlayerService对象。

status_t Parcel::writeStrongBinder(const sp& val)

{

returnflatten_binder(ProcessState::self(), val, this);

}

看到flatten_binder函数，是不是似曾相识的感觉？我们在前面一篇文章浅谈Service Manager成为Android进程间通信(IPC)机制Binder守护进程之路中，曾经提到在Binder驱动程序中，使用struct flat_binder_object来表示传输中的一个binder对象，它的定义如下所示：

* Thisisthe flattened representationofa Binder objectfortransfer

*betweenprocesses. The'offsets'suppliedaspartofa bindertransaction

*containsoffsetsintothe datawherethese structures occur. The Binder

* driver takes careofre-writing the structure typeanddataasit moves

*betweenprocesses.

struct flat_binder_object {

/* 8 bytesforlarge_flat_header. */

unsigned long type;

unsigned long flags;

/* 8 bytesofdata. */

union{

void *binder; /*localobject */

signed long handle; /* remote object */

};

/* extra data associatedwithlocalobject */

void *cookie;

};

我们进入到flatten_binder函数看看：

status_t flatten_binder(const sp& proc,

const sp& binder, Parcel*out)

{

flat_binder_object obj;

obj.flags = 0x7f | FLAT_BINDER_FLAG_ACCEPTS_FDS;

if (binder !=NULL) {

IBinder *local= binder->localBinder();

if (!local) {

BpBinder *proxy = binder->remoteBinder();

if (proxy ==NULL) {

LOGE("null proxy");

}

const int32_t handle = proxy ? proxy->handle() : 0;

obj.type = BINDER_TYPE_HANDLE;

obj.handle = handle;

obj.cookie =NULL;

}else{

obj.type = BINDER_TYPE_BINDER;

obj.binder =local->getWeakRefs();

obj.cookie =local;

}

}else{

obj.type = BINDER_TYPE_BINDER;

obj.binder =NULL;

obj.cookie =NULL;

}

returnfinish_flatten_binder(binder, obj,out);

}

首先是初始化flat_binder_object的flags域：

obj.flags = 0x7f | FLAT_BINDER_FLAG_ACCEPTS_FDS;

0x7f表示处理本Binder实体请求数据包的线程的最低优先级，FLAT_BINDER_FLAG_ACCEPTS_FDS表示这个Binder实体可以接受文件描述符，Binder实体在收到文件描述符时，就会在本进程中打开这个文件。

传进来的binder即为MediaPlayerService::instantiate函数中new出来的MediaPlayerService实例，因此，不为空。又由于MediaPlayerService继承自BBinder类，它是一个本地Binder实体，因此binder->localBinder返回一个BBinder指针，而且肯定不为空，于是执行下面语句：

obj.type = BINDER_TYPE_BINDER;

obj.binder =local->getWeakRefs();

obj.cookie =local;

设置了flat_binder_obj的其他成员变量，注意，指向这个Binder实体地址的指针local保存在flat_binder_obj的成员变量cookie中。

函数调用finish_flatten_binder来将这个flat_binder_obj写入到Parcel中去：

inlinestaticstatus_t finish_flatten_binder(

const sp& binder, const flat_binder_object& flat, Parcel*out)

{

returnout->writeObject(flat,false);

}

Parcel::writeObject的实现如下：

status_t Parcel::writeObject(const flat_binder_object& val, bool nullMetaData)

{

const bool enoughData = (mDataPos+sizeof(val)) <= mDataCapacity;

const bool enoughObjects = mObjectsSize

if (enoughData && enoughObjects) {

restart_write:

*reinterpret_cast(mData+mDataPos) = val;

// Needtowrite meta-data?

if (nullMetaData || val.binder !=NULL) {

mObjects[mObjectsSize] = mDataPos;

acquire_object(ProcessState::self(), val, this);

mObjectsSize++;

}

// remember if it's a file descriptor

if (val.type == BINDER_TYPE_FD) {

mHasFds = mFdsKnown =true;

}

returnfinishWrite(sizeof(flat_binder_object));

}

if (!enoughData) {

const status_t err = growData(sizeof(val));

if (err != NO_ERROR)returnerr;

}

if (!enoughObjects) {

size_t newSize = ((mObjectsSize+2)*3)/2;

size_t* objects = (size_t*)realloc(mObjects, newSize*sizeof(size_t));

if (objects ==NULL)returnNO_MEMORY;

mObjects = objects;

mObjectsCapacity = newSize;

}

gotorestart_write;

}

这里除了把flat_binder_obj写到Parcel里面之内，还要记录这个flat_binder_obj在Parcel里面的偏移位置：

mObjects[mObjectsSize] = mDataPos;

这里因为，如果进程间传输的数据间带有Binder对象的时候，Binder驱动程序需要作进一步的处理，以维护各个Binder实体的一致性，下面我们将会看到Binder驱动程序是怎么处理这些Binder对象的。

再回到BpServiceManager::addService函数中，调用下面语句：

status_t err = remote()->transact(ADD_SERVICE_TRANSACTION, data, &reply);

回到浅谈Android系统进程间通信(IPC)机制Binder中的Server和Client获得Service Manager接口之路一文中的类图中去看一下，这里的remote成员函数来自于BpRefBase类，它返回一个BpBinder指针。因此，我们继续进入到BpBinder::transact函数中去看看：

status_t BpBinder::transact(

uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)

{

// Once a binder has died, it will never come backtolife.

if (mAlive) {

status_t status = IPCThreadState::self()->transact(

mHandle, code, data, reply, flags);

if (status == DEAD_OBJECT) mAlive = 0;

returnstatus;

}

returnDEAD_OBJECT;

}

这里又调用了IPCThreadState::transact进执行实际的操作。注意，这里的mHandle为0，code为ADD_SERVICE_TRANSACTION。ADD_SERVICE_TRANSACTION是上面以参数形式传进来的，那mHandle为什么是0呢？因为这里表示的是Service Manager远程接口，它的句柄值一定是0，具体请参考浅谈Android系统进程间通信(IPC)机制Binder中的Server和Client获得Service Manager接口之路一文。

再进入到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_LOG_TRANSACTIONS() {

TextOutput::Bundle _b(alog);

alog <

}

if (err == NO_ERROR) {

LOG_ONEWAY(">>>> SEND from pid %d uid %d %s", getpid(), getuid(),

(flags & TF_ONE_WAY) == 0 ?"READ REPLY":"ONE WAY");

err = writeTransactionData(BC_TRANSACTION, flags, handle, code, data,NULL);

}

if (err != NO_ERROR) {

if (reply) reply->setError(err);

return(mLastError = err);

}

if ((flags & TF_ONE_WAY) == 0) {

#if 0

if (code == 4) { // relayout

LOGI(">>>>>> CALLING transaction 4");

}else{

LOGI(">>>>>> CALLING transaction %d", code);

}

#endif

if (reply) {

err = waitForResponse(reply);

}else{

Parcel fakeReply;

err = waitForResponse(&fakeReply);

}

#if 0

if (code == 4) { // relayout

LOGI("<<<<<

}else{

LOGI("<<<<<

}

#endif

IF_LOG_TRANSACTIONS() {

TextOutput::Bundle _b(alog);

alog <

if (reply) alog <

elsealog <

}

}else{

err = waitForResponse(NULL,NULL);

}

returnerr;

}

IPCThreadState::transact函数的参数flags是一个默认值为0的参数，上面没有传相应的实参进来，因此，这里就为0。

函数首先调用writeTransactionData函数准备好一个struct binder_transaction_data结构体变量，这个是等一下要传输给Binder驱动程序的。struct binder_transaction_data的定义我们在浅谈Service Manager成为Android进程间通信(IPC)机制Binder守护进程之路一文中有详细描述，读者不妨回过去读一下。这里为了方便描述，将struct binder_transaction_data的定义再次列出来：

struct binder_transaction_data {

/* Thefirsttwo areonlyusedforbcTRANSACTIONandbrTRANSACTION,

* identifying the targetandcontentsofthetransaction.

union{

size_t handle; /* target descriptorofcommandtransaction*/

void *ptr; /* target descriptorofreturntransaction*/

} target;

void *cookie; /* target object cookie */

unsignedintcode; /*transactioncommand */

/* General information about thetransaction. */

unsignedintflags;

pid_t sender_pid;

uid_t sender_euid;

size_t data_size; /* numberofbytesofdata */

size_t offsets_size; /* numberofbytesofoffsets */

/* If thistransactionisinline, the data immediately

* follows here; otherwise, it endswitha pointerto

* the data buffer.

union{

struct {

/*transactiondata */

const void *buffer;

/* offsetsfrombuffertoflat_binder_object structs */

const void *offsets;

} ptr;

uint8_t buf[8];

} data;

};

writeTransactionData函数的实现如下：

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();

}elseif (statusBuffer) {

tr.flags |= TF_STATUS_CODE;

*statusBuffer = err;

tr.data_size = sizeof(status_t);

tr.data.ptr.buffer = statusBuffer;

tr.offsets_size = 0;

tr.data.ptr.offsets =NULL;

}else{

return(mLastError = err);

}

mOut.writeInt32(cmd);

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

returnNO_ERROR;

}

注意，这里的cmd为BC_TRANSACTION。这个函数很简单，在这个场景下，就是执行下面语句来初始化本地变量tr：

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();

回忆一下上面的内容，写入到tr.data.ptr.buffer的内容相当于下面的内容：

writeInt32(IPCThreadState::self()->getStrictModePolicy() |

STRICT_MODE_PENALTY_GATHER);

writeString16("android.os.IServiceManager");

writeString16("media.player");

writeStrongBinder(new MediaPlayerService());

其中包含了一个Binder实体MediaPlayerService，因此需要设置tr.offsets_size就为1，tr.data.ptr.offsets就指向了这个MediaPlayerService的地址在tr.data.ptr.buffer中的偏移量。最后，将tr的内容保存在IPCThreadState的成员变量mOut中。

回到IPCThreadState::transact函数中，接下去看，(flags & TF_ONE_WAY) == 0为true，并且reply不为空，所以最终进入到waitForResponse(reply)这条路径来。我们看一下waitForResponse函数的实现：

status_t IPCThreadState::waitForResponse(Parcel *reply, status_t *acquireResult)

{

int32_t cmd;

int32_t err;

while (1) {

if ((err=talkWithDriver())

err =mIn.errorCheck();

if (err

if (mIn.dataAvail() == 0)continue;

cmd =mIn.readInt32();

IF_LOG_COMMANDS() {

alog <

}

switch (cmd) {

caseBR_TRANSACTION_COMPLETE:

if (!reply && !acquireResult)gotofinish;

break;

caseBR_DEAD_REPLY:

err = DEAD_OBJECT;

gotofinish;

caseBR_FAILED_REPLY:

err = FAILED_TRANSACTION;

gotofinish;

caseBR_ACQUIRE_RESULT:

{

LOG_ASSERT(acquireResult !=NULL,"Unexpected brACQUIRE_RESULT");

const int32_t result =mIn.readInt32();

if (!acquireResult)continue;

*acquireResult = result ? NO_ERROR : INVALID_OPERATION;

}

gotofinish;

caseBR_REPLY:

{

binder_transaction_data tr;

err =mIn.read(&tr, sizeof(tr));

LOG_ASSERT(err == NO_ERROR,"Not enough command data for brREPLY");

if (err != NO_ERROR)gotofinish;

if (reply) {

if ((tr.flags & TF_STATUS_CODE) == 0) {

reply->ipcSetDataReference(

reinterpret_cast(tr.data.ptr.buffer),

tr.data_size,

reinterpret_cast(tr.data.ptr.offsets),

tr.offsets_size/sizeof(size_t),

freeBuffer, this);

}else{

err = *static_cast(tr.data.ptr.buffer);

freeBuffer(NULL,

reinterpret_cast(tr.data.ptr.buffer),

tr.data_size,

reinterpret_cast(tr.data.ptr.offsets),

tr.offsets_size/sizeof(size_t), this);

}

}else{

freeBuffer(NULL,

reinterpret_cast(tr.data.ptr.buffer),

tr.data_size,

reinterpret_cast(tr.data.ptr.offsets),

tr.offsets_size/sizeof(size_t), this);

continue;

}

gotofinish;

default:

err = executeCommand(cmd);

if (err != NO_ERROR)gotofinish;

break;

}

finish:

if (err != NO_ERROR) {

if (acquireResult) *acquireResult = err;

if (reply) reply->setError(err);

mLastError = err;

}

returnerr;

}

爱大淼爱大唐

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
老罗android binder,Android系统进程间通信（IPC）机制Binder中的Server启动过程源代码分析(1)...

在前面一篇文章本文通过一个具体的例子来说明Binder机制中Server的启动过程。我们知道，在Android系统中，提供了多媒体播放的功能，这个功能是以服务的形式来提供的。这里，我们就通过分析MediaPlayerService的实现来了解Media Server的启动过程。首先，看一下MediaPlayerService的类图，以便我们理解下面要描述的内容。我们将要介绍的主角MediaPlay...
复制链接

扫一扫