jianjin33

binder机制

分析一下如何创建：

//获得一个ProcessState实例
sp<ProcessState> proc(ProcessState::self());
//得到一个ServiceManager对象
sp<IServiceManager> sm = defaultServiceManager();
MediaPlayerService::instantiate();//初始化MediaPlayerService服务
ProcessState::self()->startThreadPool();//看名字，启动Process的线程池？
IPCThreadState::self()->joinThreadPool();//将自己加入到刚才的线程池？

一、ProcessState::self()；

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

sp<ProcessState> ProcessState::self()
{
    if (gProcess != NULL) return gProcess;---->第一次进来肯定不走这儿
    AutoMutex _l(gProcessMutex);--->锁保护
    if (gProcess == NULL) gProcess = new ProcessState;--->创建一个ProcessState对象
    return gProcess;--->看见没，这里返回的是指针，但是函数返回的是sp<xxx>，所以
    //把sp<xxx>看成是XXX*是可以的
}

再来看看ProcessState构造函数:

//这个构造函数看来很重要
ProcessState::ProcessState()
    : mDriverFD(open_driver())----->Android很多代码都是这么写的,稍不留神就没看见这里调用了一个很重要的函数
    , mVMStart(MAP_FAILED)//映射内存的起始地址
    , mManagesContexts(false)
    , mBinderContextCheckFunc(NULL)
    , mBinderContextUserData(NULL)
    , mThreadPoolStarted(false)
    , mThreadPoolSeq(1)
{
if (mDriverFD >= 0) {
//BIDNER_VM_SIZE定义为(1*1024*1024) - (4096 *2) 1M-8K
        mVMStart = mmap(0, BINDER_VM_SIZE, PROT_READ, MAP_PRIVATE | MAP_NORESERVE,
 mDriverFD, 0);//这个需要你自己去man mmap的用法了，不过大概意思就是
//将fd映射为内存，这样内存的memcpy等操作就相当于write/read(fd)了
    }
    ...
}

open_driver，就是打开/dev/binder这个设备，这个是android在内核中搞的一个专门用于完成
进程间通讯而设置的一个虚拟的设备。BTW，说白了就是内核的提供的一个机制，这个和我们用socket加NET_LINK方式和内核通讯是一个道理.

static int open_driver()
313{
314    int fd = open("/dev/binder", O_RDWR | O_CLOEXEC);
315    if (fd >= 0) {
316        int vers = 0;
317        status_t result = ioctl(fd, BINDER_VERSION, &vers);
318        if (result == -1) {
319            ALOGE("Binder ioctl to obtain version failed: %s", strerror(errno));
320            close(fd);
321            fd = -1;
322        }
323        if (result != 0 || vers != BINDER_CURRENT_PROTOCOL_VERSION) {
324            ALOGE("Binder driver protocol does not match user space protocol!");
325            close(fd);
326            fd = -1;
327        }
328        size_t maxThreads = DEFAULT_MAX_BINDER_THREADS;
             //通过ioctl方式告诉内核，这个fd支持最大线程数是15个。
329        result = ioctl(fd, BINDER_SET_MAX_THREADS, &maxThreads);
330        if (result == -1) {
331            ALOGE("Binder ioctl to set max threads failed: %s", strerror(errno));
332        }
333    } else {
334        ALOGW("Opening '/dev/binder' failed: %s\n", strerror(errno));
335    }
336    return fd;
337}

好了，到这里Process::self就分析完了，到底干什么了呢？

打开/dev/binder设备，这样的话就相当于和内核binder机制有了交互的通道
映射fd到内存，设备的fd传进去后，估计这块内存是和binder设备共享的

接下来，就到调用defaultServiceManager()地方了。

二、defaultServiceManager

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

33sp<IServiceManager> defaultServiceManager()
34{    // 单例设计模式
35    if (gDefaultServiceManager != NULL) return gDefaultServiceManager;
36
37    {
38        AutoMutex _l(gDefaultServiceManagerLock);
39        while (gDefaultServiceManager == NULL) {
              //真正的gDefaultServiceManager是在这里创建的喔
40            gDefaultServiceManager = interface_cast<IServiceManager>(
41                ProcessState::self()->getContextObject(NULL));
42            if (gDefaultServiceManager == NULL)
43                sleep(1);
44        }
45    }
46
47    return gDefaultServiceManager;
48}
gDefaultServiceManager = interface_cast<IServiceManager>(
 
                ProcessState::self()->getContextObject(NULL));
 
ProcessState::self，肯定返回的是刚才创建的gProcess，然后调用它的getContextObject，注意，传进去的是NULL，即0

gDefaultServiceManager = interface_cast(ProcessState::self()->getContextObject(NULL));

ProcessState::self，肯定返回的是刚才创建的gProcess，然后调用它的getContextObject，注意，传进去的是NULL，即0

//回到ProcessState类，
sp<IBinder> ProcessState::getContextObject(const sp<IBinder>& caller)
{
if (supportsProcesses()) {//该函数根据打开设备是否成功来判断是否支持process，
        //在真机上肯定走这个
        return getStrongProxyForHandle(0);//注意，这里传入0
    }
}

sp<IBinder> ProcessState::getStrongProxyForHandle(int32_t handle)
{
    sp<IBinder> result;
    AutoMutex _l(mLock);
handle_entry* e = lookupHandleLocked(handle);--》哈哈，果然，从数组中查找对应
索引的资源，lookupHandleLocked这个就不说了，内部会返回一个handle_entry
 下面是 handle_entry 的结构
/*
struct handle_entry {
                IBinder* binder;--->Binder
                RefBase::weakref_type* refs;-->不知道是什么，不影响.
            };
*/
    if (e != NULL) {
        IBinder* b = e->binder; -->第一次进来，肯定为空
        if (b == NULL || !e->refs->attemptIncWeak(this)) {
            b = new BpBinder(handle); --->看见了吧，创建了一个新的BpBinder
            e->binder = b;
            result = b;
        }....
    }
    return result; 返回刚才创建的BpBinder。
}
//到这里，是不是有点乱了？对，当人脑分析的函数调用太深的时候，就容易忘记。
我们是从gDefaultServiceManager = interface_cast<IServiceManager>(ProcessState::self()->getContextObject(NULL));
开始搞的，现在，这个函数调用将变成 gDefaultServiceManager = interface_cast<IServiceManager>(new BpBinder(0));

BpBinder又是个什么玩意儿？Android名字起得太眼花缭乱了。
因为还没介绍Binder机制的大架构，所以这里介绍BpBinder不合适，但是又讲到BpBinder了，不介绍Binder架构似乎又说不清楚….，sigh！
恩，还是继续把层层深入的函数调用栈化繁为简吧，至少大脑还可以工作。先看看BpBinder的构造函数把。

三、BpBinder：

frameworks/native/libs/binder/BpBinder.cpp

BpBinder::BpBinder(int32_t handle)
    : mHandle(handle) //注意，接上述内容，这里调用的时候传入的是0
    , mAlive(1)
    , mObitsSent(0)
    , mObituaries(NULL)
{
   IPCThreadState::self()->incWeakHandle(handle);//FT，竟然到IPCThreadState::self()
}
这里一块说说吧，IPCThreadState::self估计怎么着又是一个singleton吧？

同级目录下找到：IPCThreadState.cpp

IPCThreadState* IPCThreadState::self()
{
    if (gHaveTLS) {//第一次进来为false
restart:
        const pthread_key_t k = gTLS;
//TLS是Thread Local Storage的意思，不懂得自己去google下它的作用吧。这里只需要
//知道这种空间每个线程有一个，而且线程间不共享这些空间，好处是？我就不用去搞什么
//同步了。在这个线程，我就用这个线程的东西，反正别的线程获取不到其他线程TLS中的数据。===》这句话有漏洞
//从线程本地存储空间中获得保存在其中的IPCThreadState对象
//这段代码写法很晦涩，看见没，只有pthread_getspecific,那么肯定有地方调用
// pthread_setspecific。
        IPCThreadState* st = (IPCThreadState*)pthread_getspecific(k);
        if (st) return st;
        return new IPCThreadState;//new一个对象，
    }
    if (gShutdown) return NULL;
    pthread_mutex_lock(&gTLSMutex);
    if (!gHaveTLS) {
        if (pthread_key_create(&gTLS, threadDestructor) != 0) {
            pthread_mutex_unlock(&gTLSMutex);
            return NULL;
        }
        gHaveTLS = true;
    }
    pthread_mutex_unlock(&gTLSMutex);
goto restart; //我FT，其实goto没有我们说得那样卑鄙，汇编代码很多跳转语句的。
//关键是要用好。
}
//这里是构造函数，在构造函数里边pthread_setspecific
IPCThreadState::IPCThreadState()
    : mProcess(ProcessState::self()), mMyThreadId(androidGetTid())
{
    pthread_setspecific(gTLS, this);
    clearCaller();
mIn.setDataCapacity(256);
//mIn,mOut是两个Parcel，干嘛用的啊？把它看成是命令的buffer吧。再深入解释，又会大脑停摆的。
    mOut.setDataCapacity(256);
}

new BpBinder就算完了。到这里，我们创建了些什么呢？

ProcessState有了。
IPCThreadState有了，而且是主线程的。
BpBinder有了，内部handle值为0

gDefaultServiceManager = interface_cast(new BpBinder(0));
终于回到原点了
interface_cast，我第一次接触的时候，把它看做类似的static_cast一样的东西，然后死活也搞不明白 BpBinder指针怎么能强转为IServiceManager，花了n多时间查看BpBinder是否和IServiceManager继承还是咋的….。
终于，跟踪进入了interface_cast
IInterface.h位于/frameworks/native/include/binder/IInterface.h

template<typename INTERFACE>
inline sp<INTERFACE> interface_cast(const sp<IBinder>& obj)
{
    return INTERFACE::asInterface(obj);
}
所以，上面等价于：
inline sp<IServiceManager> interface_cast(const sp<IBinder>& obj)
{
    return IServiceManager::asInterface(obj);
}
看来，只能跟到IServiceManager了。
IServiceManager.h---》framework/native/include/binder/IServiceManager.h
看看它是如何定义的:

四、IServiceManager

class IServiceManager : public IInterface
{
//ServiceManager,字面上理解就是Service管理类，管理什么？增加服务，查询服务等
//这里仅列出增加服务addService函数
public:
    DECLARE_META_INTERFACE(ServiceManager);
     virtual status_t   addService( const String16& name,
                                            const sp<IBinder>& service) = 0;
};
DECLARE_META_INTERFACE(ServiceManager)？？
怎么和MFC这么类似？微软的影响很大啊！知道MFC的，有DELCARE肯定有IMPLEMENT
果然，这两个宏DECLARE_META_INTERFACE和IMPLEMENT_META_INTERFACE(INTERFACE, NAME)都在
刚才的IInterface.h中定义。我们先看看DECLARE_META_INTERFACE这个宏往IServiceManager加了什么？
下面是DECLARE宏
#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();    
我们把它兑现到IServiceManager就是：
static const android::String16 descriptor;  -->喔，增加一个描述字符串
static android::sp< IServiceManager > asInterface(const android::sp<android::IBinder>&
obj) ---》增加一个asInterface函数
virtual const android::String16& getInterfaceDescriptor() const; ---》增加一个get函数
估计其返回值就是descriptor这个字符串
IServiceManager ();                                                     \
virtual ~IServiceManager();增加构造和虚析购函数...

那IMPLEMENT宏在哪定义的呢？
见IServiceManager.cpp。
/frameworks/native/libs/binder/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 != 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() { }                                   \
很麻烦吧？尤其是宏看着头疼。赶紧兑现下吧。
const
android::String16 IServiceManager::descriptor(“android.os.IServiceManager”);
const android::String16& IServiceManager::getInterfaceDescriptor() const
 {  return IServiceManager::descriptor;//返回上面那个android.os.IServiceManager
   }        android::sp<IServiceManager> IServiceManager::asInterface(
            const android::sp<android::IBinder>& obj)
    {
        android::sp<IServiceManager> intr;
        if (obj != NULL) {                                             
            intr = static_cast<IServiceManager *>(                         
                obj->queryLocalInterface(IServiceManager::descriptor).get());              
            if (intr == NULL) {                                         
                intr = new BpServiceManager(obj);                         
            }                                                          
        }                                                               
        return intr;                                                   
    }                                                                 
    IServiceManager::IServiceManager () { }                                   
    IServiceManager::~ IServiceManager() { }
asInterface是这么搞的啊，赶紧分析下吧，还是不知道interface_cast怎么把BpBinder*转成了IServiceManager
我们刚才解析过的interface_cast<IServiceManager>(new BpBinder(0)),
原来就是调用asInterface(new BpBinder(0))
android::sp<IServiceManager> IServiceManager::asInterface(
            const android::sp<android::IBinder>& obj)
    {
        android::sp<IServiceManager> intr;
        if (obj != NULL) {                                             
            ....                                      
                intr = new BpServiceManager(obj);
//神呐，终于看到和IServiceManager相关的东西了，看来
//实际返回的是BpServiceManager(new BpBinder(0))；                         
            }                                                          
        }                                                              
        return intr;                                                   
}

BpServiceManager是个什么玩意儿？p是什么个意思？proxy代理的意思。