Android binder 原理及实现机制<一>

​0，从android native service 说起
我们先来看一个简单的 native service 例子:

// 定义能力接口
class IBuddy: public IInterface {
public:
    enum {
        BUDDY_GET_PID = IBinder::FIRST_CALL_TRANSACTION,
    };
    virtual int getPid(void ) = 0;
    DECLARE_META_INTERFACE(Buddy);
};
IMPLEMENT_META_INTERFACE(Buddy, "Buddy");

// 定义接口proxy ，用于应用调用接口
class BpBuddy : public BpInterface<IBuddy> {
public:
   // 定义构造函数，注意参数 类型
   BpBuddy(const sp<IBinder>& impl) : BpInterface<IBuddy>(impl) { }
   
    virtual void getPid(int32_t push_data) {
       Parcel data, reply;
        // Write RPC headers.  (previously just the interface token)
       data.writeInterfaceToken(IBuddy::getInterfaceDescriptor());
       data.writeInt32(push_data);
       remote()->transact(BUDDY_GET_PID, data, &reply);
       int32_t res;
       status_t status = reply.readInt32(&res);
       return res;
    }
}

// 接口的实现类
class BnBuddy : public BnInterface<IBuddy> {
    virtual status_t onTransact(uint32_t code,const Parcel& data,
                                Parcel* reply,uint32_t flags = 0);
};


status_t BnBuddy::onTransact(uint32_t code, const Parcel &data,
                            Parcel* reply,uint32_t flags) {
   // 检测 discriptor 是否相同
   CHECK_INTERFACE(IBuddy, data, reply);
    switch(code) {
        case BUDDY_GET_PID: {
            int32_t pid = getPid();  // 调用getPid() 函数
            reply->writeInt32(pid);
            return NO_ERROR;
        }
            break;           
        default:
            return BBinder::onTransact(code, data, reply, flags);
    }
}

class BuddyService : public BnBuddy {
    virtual int32_t getPid() {// impl:   system call, get process ID
       return getpid();
    }
};

int main(int argc, char **argv)
{
        //regester service to service manager
        defaultServiceManager()->addService(String16("BuddyService"), new BuddyService());
        ProcessState::self()->startThreadPool();
        IPCThreadState::self()->joinThreadPool();
        return 0;
}


sp<IServiceManager> sm =defaultServiceManager();
// find buddy service , and call function
sp<IBinder> binder =sm->getService(String16("Buddy"));
sp<IBuddy> mBuddy =interface_cast<IBuddy>(binder);

0.1 一个完整native service 所需要的组件（class）

0.2 注册service 到系统
再来回顾一下 前面添加service 代码：

int main(int argc, char **argv)
{
        //regester service to service manager
        defaultServiceManager()->addService(String16("BuddyService"), new BuddyService());
        //开启监听
        ProcessState::self()->startThreadPool();
        IPCThreadState::self()->joinThreadPool();
        return 0;
}

RTFSC ， 源代码我们逐步分析：

第一步，首先调用 defaultServiceManager()，此函数调用返回了一个 IServiceManager 指针，

sp<IServiceManager> defaultServiceManager(){
    //  gDefaultServiceManager  在文件 /android/frameworks/native/libs/binder/Static.cpp  中定义
    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;
}

// 这里是一个singleton， gProcess 也是在   /android/frameworks/native/libs/binder/Static.cpp  中定义的
sp<ProcessState> ProcessState::self()
{
    Mutex::Autolock _l(gProcessMutex);
    if (gProcess != NULL) {
        return gProcess;
    }
    gProcess = new ProcessState;
    return gProcess;
}

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
    handle_entry* e = lookupHandleLocked(handle);
    if (e != NULL) {
        IBinder* b = e->binder;
        if (b == NULL || !e->refs->attemptIncWeak(this)) {
            if (handle == 0) {         
                Parcel data;
                status_t status = IPCThreadState::self()->transact(
                        0, IBinder::PING_TRANSACTION, data, NULL, 0);
                if (status == DEAD_OBJECT)
                   return NULL;
            }
            // 这里我们返回的是一个 handle  == 0 的BpBinder
            b = new BpBinder(handle);
            e->binder = b;
            if (b) e->refs = b->getWeakRefs();  
            result = b;
        } else {
            result.force_set(b);
            e->refs->decWeak(this);
        }
    }
    return result;
}

interface_cast<IServiceManager> 这个函数的作用是什么呢？

template<typename INTERFACE>
inline sp<INTERFACE> interface_cast(const sp<IBinder>& obj)
{
    return INTERFACE::asInterface(obj);
}
显然，这里直接调用的 IServiceManager::asInterface 那么函数asInterface 是在哪里声明和定义的呢，下面我们看看 IServiceManager 这个类的定义
// IServiceManager 声明
class IServiceManager : public IInterface
{
public:
    DECLARE_META_INTERFACE(ServiceManager);
    //。。。 省略不相关代码
};
// 定义
IMPLEMENT_META_INTERFACE(ServiceManager, "android.os.IServiceManager");

0.2.0 关于 IInterface 所提供的两个宏

// 定义了一个 静态变量
// 声明了一个 asInterface 静态函数
// 声明了一个获取接口描述符的成员函数
#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;                                \
    }                                                                   \
    // asInterface 函数的实现 ， 在IServiceManager 中这里的参数是一个 BpBinder
    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*>(                          \