Android Binder详解

virtual status_t transact( uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags = 0);

virtual BBinder* localBinder();
virtual BpBinder* remoteBinder();

BBinder* BBinder::localBinder()
{
    return this;
}

BpBinder* BpBinder::remoteBinder()
{
    return this;
}

virtual status_t linkToDeath(const sp<DeathRecipient>& recipient, void* cookie = NULL, uint32_t flags = 0) = 0;

class DeathRecipient : public virtual RefBase {
public:
    virtual void binderDied(const wp<IBinder>& who) = 0;
};

class IInterface : public virtual RefBase{
public:
    IInterface();
    sp<IBinder> asBinder();
    sp<const IBinder> asBinder() const;

protected:
    virtual ~IInterface();
    virtual IBinder* onAsBinder() = 0;
};

template<typename INTERFACE>
IBinder* BnInterface<INTERFACE>::onAsBinder()
{
    return this;
}

template<typename INTERFACE>
inline IBinder* BpInterface<INTERFACE>::onAsBinder()
{
    return remote();
}

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

#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() { }                                   \

android::sp<IMediaPlayerService> IMediaPlayerService::asInterface(const android::sp<android::IBinder>& obj)
{
    android::sp<IMediaPlayerService> intr;
    if (obj != NULL) {
        intr = static_cast<IMediaPlayerService>(
            obj->queryLocalInterface(IMediaPlayerService::descriptor).get());

        if (intr == NULL) {
            intr = new BpMediaPlayerService(obj);
        }
    }

    return intr;
}

sp<IInterface>  IBinder::queryLocalInterface(const String16& descriptor)
{
    return NULL;
}

template<typename INTERFACE>
inline sp<IInterface> BnInterface<INTERFACE>::queryLocalInterface(
        const String16& _descriptor)
{
    if (_descriptor == INTERFACE::descriptor) return this;
    return NULL;
}

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

Parcel是Android提供的一个容器类，通过binder传输的数据都可以写进Parcel中。但是因为Parcel中的数据最终都会copy到驱动空间，而驱动空间为每一个进程分配的内存是有效的，如果Parcel中的数据量太大就会造成数据传输失败。所以，binder通信中不适宜用Parcel传输诸如图片这样的数据，如果有需求传输大容量数据，可以使用共享内存IMemory。这个我们会在本文的最后讲解。

Parcel中不仅可以装载int，float，string这样的基础数据类型，还可以装载IBinder对象，文件句柄等特俗对象。现在我们就来看看Parcel是如何装载IBinder对象。首先看一张图： 

对图中几个数据结构做下解释：

• binder_write_read:用户层传递数据给binder驱动使用的是ioctl的方式（ioctl（fd，cmd，arg）），当cmd为BINDER_WRITE_READ的时候，arg对应的就是binder_write_read结构体。除了binder_write_read以外还有几个其他的命令，但是用的最频繁的就是binder_write_read。

• binder_transaction_data:BINDER_WRITE_READ命令的数据也是以：命令+数据的格式存放。当cmd为BC_TRANSACTION的时候，对应的数据结构是binder_transaction_data。

• flat_binder_object：Parcel中存放的binder对象，以此数据结构来表征。

每一个Parcel都对应一块内存buffer，Parcel内部有三个重要的变量：mData,mObjects,mObjectsSize。

• mData:指向数据buffer，调用write接口写入的数据都依次存放在这块buffer中。

• mObjects:指向一个动态分配的一维数组，这个数组的大小可以动态的扩展。里面存放的是mData的下标值。当数据buffer中写入了binder对象，就会在mObjects中存放一条下标记录，表示在数据buffer的某个地方存放的是一个binder对象。

• mObjectsSize：mObjects数组的大小。

上图中的Parcel buffer中写入了一个IXXXService的描述符，接着是正常的参数参数，比如int之类的数据，紧接着写入了三个binder对象。第一个是BBinder，第二个是BpBinder，第三个是一个文件句柄。他们共同以flat_binder_object数据结构来表示，只是数据结构中的值不一样。当我们要传递一个IBinder到另外一个进程的时候，先要调用Parcel的writeStrongBinder函数将此IBinder对象写入到Parcel中：

因为IBinder的引用可能是指向BpBinder，也可能指向BBinder，所以在上述的代码中首先是通过IBinder的localBinder试图获取一个本地binder对象，如果不为空，则表示传递的是一个BBinder对象。如果为空则表示传递的是一个BpBinder。如果传递的是一个BBinder，则需要在驱动层生成binder_ref数据结构，同时把BBinder在用户空间所对应的地址保存在驱动层中。

在通过BpXXXService调用函数接口的时候，实际上是把参数写入到Parcel中，然后由Parcel构造一个bidner_transaction_data数据结构。然后将BC_TRANSACTION命令和binder_transaction_data写入Parcel，在由此Parcel构造最终的binder_write_read数据结构，通过ioctl将此数据结构传递给驱动。

从上小节的图中可以得知，IBinder对象是以flat_binder_object结构体在binder驱动中传递。binder驱动通过将用户空间的Parcel所对应的buffer和mObjects所对应的buffer拷贝到目标进程的驱动内存空间，然后通过mObjects数组的偏移量在数据buffer中找到对应的flat_binder_object对象，根据type的不同创建binder_noede或者是binder_ref数据结构予以描述binder对象。

对于BBinder来说，驱动会为之创建一个binder_node数据结构，同时创建的还有binder_ref数据结构。当传递BBinder的时候，flat_binder_object的type初始值是BINDER_TYPD_BINDER,当binder驱动将此数据结构拷贝到目标进程的内存空间的时候，将type替换为binder_type_handle，并且把handle赋值为binder_ref的int描述符。

用户空间通过从Parcel中读取出对应的flat_binder_object数据结构，然后创建一个BpBinder对象。

• 驱动通过将数据buffer 拷贝到目标进程的内存空间，用户空间以此buffer构造一个Parcel对象。所以才可以通过readStrongBinder来获取其他进程写入的binder对象。

• unflatten_binder：当type是BINDER_TYPE_HANDLE的时候，以handle为参数调用ProcessState::getStrongProxyForHandle苟赞一个BpBinder。

• ProcessState::getStrongProxyForHandle函数首先会检查此handle所对应的BpBinder是否已经创建过，如果已经创建，则返回保存的BpBinder指针；如果没有创建就重新构造一份BpBinder，并且保存在Vector中。因为在进程内ProcessState是单例的，所以对于同一个handle，整个系统只会存在一个BpBinder。

由此就完成了BBinder的传输：发送进程的BBinder，到了目标进程之后，将会得到一个BpBinder。同时驱动也会创建对应的数据结构：binder_node和binder_ref。

Android对于c++ 对象的生命周期的管理是通过sp指针来管理的。一般对象的生命周期只受此对象的强引用计数的影响。当对象的强引用计数为0的时候，就会调用对象的析构函数释放对象的内存。

当我们通过要将一个BBinder传递到驱动的时候，首先要把这个BBinder对象写入到Parcel。Parcel提供了两个函数才管理BBinder对象的引用计数：

当写入BBinder到一个Parcel的时候，会调用acquire_object来增加BBinder的强引用计数，这样确保在写入驱动的过程中，用户空间的BBinder不会被析构。

当用户层和驱动的一次会话结束的时候，Parcel容器会被析构，在Parcel的析构函数中会调用release_object将对象强引用计数减1，然后释放掉自己所分配的buffer。

在驱动层检测到用户传输下来的数据中有BBinder对象，会使用命令BR_INCREFS和BR_ACQUIRE通知用户空间增加BBinder对象的弱引用计数和强引用计数。在驱动层binder_node保存着BBinder对象在用户空间的地址以及管理其在驱动层的计数关系。binder_ref相当于对binder_node引用，每增加一个binder_ref，binder_node的internal_strong_refs变量都会加1.每减少一个binder_ref的时候，binder_node的internal_strong_refs都会减1.当此变量为0的时候，就会以BR_RELEASE和BR_DECREFS通知BBinder对象，减少在用户空间的计数，如果BBinder的强引用计数减少为0就会导致BBinder的析构函数的执行。binder_ref的存在受BpBinder的影响，一个BpBinder对应着唯一的一个binder_ref，当BpBinder在用户空间的强引用计数变为0 的时候，binder_ref的引用计数也会变为0，导致binder_ref被删除。

关于binder_node和binder_ref的引用计数关系是可以从sys系统中查看：

这里以一张传递BBinder过程中，binder_node，binder_ref计数变化的时序图结束本章的讲解： 

sp<ProcessState> proc(ProcessState::self());

#define BINDER_WRITE_READ             _IOWR(‘b‘, 1, struct binder_write_read)
#define BINDER_SET_IDLE_TIMEOUT       _IOW(‘b‘, 3, int64_t)
#define BINDER_SET_MAX_THREADS        _IOW(‘b‘, 5, size_t)
#define BINDER_SET_IDLE_PRIORITY      _IOW(‘b‘, 6, int)
#define BINDER_SET_CONTEXT_MGR        _IOW(‘b‘, 7, int)
#define BINDER_THREAD_EXIT            _IOW(‘b‘, 8, int)
#define BINDER_VERSION                _IOWR(‘b‘, 9, struct binder_version)

sp<IServiceManager> defaultServiceManager()
{
    if (gDefaultServiceManager != NULL) return gDefaultServiceManager;
    {
        AutoMutex _l(gDefaultServiceManagerLock);
        if (gDefaultServiceManager == NULL) {
            gDefaultServiceManager = interface_cast<IServiceManager>(
                ProcessState::self()->getContextObject(NULL));
        }
    }

    return gDefaultServiceManager;
}

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

static struct {
    unsigned uid;
    const char *name;
} allowed[] = {
    { AID_MEDIA, "media.audio_flingIMemoryer" },
    { AID_MEDIA, "media.player" },
    { AID_MEDIA, "media.camera" },
    { AID_MEDIA, "media.audio_policy" },
    { AID_DRM,   "drm.drmManager" },
    { AID_NFC,   "nfc" },
    { AID_BLUETOOTH, "bluetooth" },
    { AID_RADIO, "radio.phone" },
    { AID_RADIO, "radio.sms" },
    { AID_RADIO, "radio.phonesubinfo" },
    { AID_RADIO, "radio.simphonebook" },
    { AID_RADIO, "phone" },
    { AID_RADIO, "sip" },
    { AID_RADIO, "isms" },
    { AID_RADIO, "iphonesubinfo" },
    { AID_RADIO, "simphonebook" },
    { AID_MEDIA, "common_time.clock" },
    { AID_MEDIA, "common_time.config" },
};

int svc_can_register(unsigned uid, uint16_t *name)
{
    unsigned n;

    if ((uid == 0) || (uid == AID_SYSTEM))
        return 1;

    for (n = 0; n < sizeof(allowed) / sizeof(allowed[0]); n++)
        if ((uid == allowed[n].uid) && str16eq(name, allowed[n].name))
            return 1;

    return 0;
}

sp<MemoryHeapBase> heap = new MemoryHeapBase(size, 0, "MetadataRetrieverClient");
sp<IMemory> mAlbumArt = new MemoryBase(heap, 0, size);
memcpy(mAlbumArt->pointer(), albumArtata, albumArtmSize);

sp<IMemory> artWorkMemory = interface_cast<IMemory>（ibinder）;

void *data = http://www.mamicode.com/artWorkMemory->pointer();"hljs-keyword" style="">int size = artWorkMemory->size();

sp<MemoryDealer> memoryDealer = new MemoryDealer(length1+length2, "ArtWork");
sp<IMemory> artwokMemory = memoryDealer->allocate(length1);
sp<IMemory> artwokMemory = memoryDealer->allocate(length2);

MemoryDealer::MemoryDealer(size_t size, const char* name)
    : mHeap(new MemoryHeapBase(size, 0, name)),
    mAllocator(new SimpleBestFitAllocator(size))
{
}

MemoryHeapBase::MemoryHeapBase(size_t size, uint32_t flags, char const * name)
    : mFD(-1), mSize(0), mBase(MAP_FAILED), mFlags(flags),
      mDevice(0), mNeedUnmap(false), mOffset(0)
{
    const size_t pagesize = getpagesize();
    size = ((size + pagesize-1) & ~(pagesize-1));
    int fd = ashmem_create_region(name == NULL ? "MemoryHeapBase" : name, size);
    ALOGE_IF(fd<0, "error creating ashmem region: %s", strerror(errno));
    if (fd >= 0) {
        if (mapfd(fd, size) == NO_ERROR) {
            if (flags & READ_ONLY) {
                ashmem_set_prot_region(fd, PROT_READ);
            }
        }
    }
}
status_t MemoryHeapBase::mapfd(int fd, size_t size, uint32_t offset)
{
    if (size == 0) {
        // try to figure out the size automatically
#ifdef HAVE_ANDROID_OS
        // first try the PMEM ioctl
        pmem_region reg;
        int err = ioctl(fd, PMEM_GET_TOTAL_SIZE, &reg);
        if (err == 0)
            size = reg.len;
#endif
        if (size == 0) { // try fstat
            struct stat sb;
            if (fstat(fd, &sb) == 0)
                size = sb.st_size;
        }
        // if it didn‘t work, let mmap() fail.
    }

    if ((mFlags & DONT_MAP_LOCALLY) == 0) {
        void* base = (uint8_t*)mmap(0, size,
                PROT_READ|PROT_WRITE, MAP_SHARED, fd, offset);
        if (base == MAP_FAILED) {
            ALOGE("mmap(fd=%d, size=%u) failed (%s)",
                    fd, uint32_t(size), strerror(errno));
            close(fd);
            return -errno;
        }
        //ALOGD("mmap(fd=%d, base=%p, size=%lu)", fd, base, size);
        mBase = base;
        mNeedUnmap = true;
    } else  {
        mBase = 0; // not MAP_FAILED
        mNeedUnmap = false;
    }
    mFD = fd;
    mSize = size;
    mOffset = offset;
    return NO_ERROR;
}

void* IMemory::pointer() const {
    ssize_t offset;
    sp<IMemoryHeap> heap = getMemory(&offset);
    void* const base = heap!=0 ? heap->base() : MAP_FAILED;
    if (base == MAP_FAILED)
        return 0;
    return static_cast<char*>(base) + offset;
}

void*   base() const  { return getBase(); }

void* BpMemoryHeap::getBase() const {
    assertMapped();
    return mBase;
}
void BpMemoryHeap::assertMapped() const
{
    if (mHeapId == -1) {
        sp<IBinder> binder(const_cast<BpMemoryHeap*>(this)->asBinder());
        sp<BpMemoryHeap> heap(static_cast<BpMemoryHeap*>(find_heap(binder).get()));
        heap->assertReallyMapped();
        if (heap->mBase != MAP_FAILED) {
            Mutex::Autolock _l(mLock);
            if (mHeapId == -1) {
                mBase   = heap->mBase;
                mSize   = heap->mSize;
                mOffset = heap->mOffset;
                android_atomic_write( dup( heap->mHeapId ), &mHeapId );
            }
        } else {
            // something went wrong
            free_heap(binder);
        }
    }
}

void BpMemoryHeap::assertReallyMapped() const
{
    if (mHeapId == -1) {

        // remote call without mLock held, worse case scenario, we end up
        // calling transact() from multiple threads, but that‘s not a problem,
        // only mmap below must be in the critical section.

        Parcel data, reply;
        data.writeInterfaceToken(IMemoryHeap::getInterfaceDescriptor());
        status_t err = remote()->transact(HEAP_ID, data, &reply);
        int parcel_fd = reply.readFileDescriptor();
        ssize_t size = reply.readInt32();
        uint32_t flags = reply.readInt32();
        uint32_t offset = reply.readInt32();

        ALOGE_IF(err, "binder=%p transaction failed fd=%d, size=%ld, err=%d (%s)",
                asBinder().get(), parcel_fd, size, err, strerror(-err));

        int fd = dup( parcel_fd );
        ALOGE_IF(fd==-1, "cannot dup fd=%d, size=%ld, err=%d (%s)",
                parcel_fd, size, err, strerror(errno));

        int access = PROT_READ;
        if (!(flags & READ_ONLY)) {
            access |= PROT_WRITE;
        }

        Mutex::Autolock _l(mLock);
        if (mHeapId == -1) {
            mRealHeap = true;
            mBase = mmap(0, size, access, MAP_SHARED, fd, offset);
            if (mBase == MAP_FAILED) {
                ALOGE("cannot map BpMemoryHeap (binder=%p), size=%ld, fd=%d (%s)",
                        asBinder().get(), size, fd, strerror(errno));
                close(fd);
            } else {
                mSize = size;
                mFlags = flags;
                mOffset = offset;
                android_atomic_write(fd, &mHeapId);
            }
        }
    }
}