Android native异步消息机制

谷歌在Android native层实现的一个异步消息机制，在这个机制中几乎不存在同步锁，所有的处理都是异步的，将变量封装到一个消息AMessage结构体中，然后放到队列中去，后台专门有一个线程会从这个队列中取出消息然后执行，执行函数就是onMessageReceived

AMessage类

struct AMessage : public RefBase {
    //构造函数，包括两个参数，第一个参数指明这是个什么消息，用于在onMessageReceived处理分支中进行匹配，第二个参数target用于后台线程在处理这个消息的时候知道发给哪个类处理
    AMessage(uint32_t what = 0, ALooper::handler_id target = 0);
    void setWhat(uint32_t what);
    uint32_t what() const;
    void setTarget(ALooper::handler_id target);
    ALooper::handler_id target() const;

    void clear();
    //这个消息类中定义了一堆set和find方法，用于在在传递消息过程中携带各种信息
    void setObject(const char *name, const sp &obj);
    void setBuffer(const char *name, const sp &buffer);
    void setMessage(const char *name, const sp &obj);
    bool findBuffer(const char *name, sp *buffer) const;
    bool findMessage(const char *name, sp *obj) const;
    void post(int64_t delayUs = 0);
protected:
    virtual ~AMessage();  析构函数
private:
    uint32_t mWhat;
    ALooper::handler_id mTarget;
    两个重要的私有成员变量
};

使用方法
正如开头部分看的那样，构造一个消息的过程如下：

void NuPlayer::start() {
    (new AMessage(kWhatStart, id()))->post();
}
void AMessage::post(int64_t delayUs) {
    gLooperRoster.postMessage(this, delayUs);
}

AHandler类分析----消息处理类的父类

struct AHandler : public RefBase {
    AHandler()
        : mID(0) {  // mID的初始值为0
    }
    ALooper::handler_id id() const {
        return mID;   //id()这个函数用于返回内部变量mID的值，其初始值为0，但是会通过setID函数设置
    }
    sp<ALooper> looper();
protected:
    virtual void onMessageReceived(const sp &msg) = 0;
private:
    friend struct ALooperRoster;
    ALooper::handler_id mID;
    //下面这个函数正式在其友元类ALooperRoster的registerHandler中调用的
    void setID(ALooper::handler_id id) {
        mID = id;
    }
};

ALooper::handler_id ALooperRoster::registerHandler(
        const sp looper, const sp &handler) {
    Mutex::Autolock autoLock(mLock);

    if (handler->id() != 0) {
        CHECK(!"A handler must only be registered once.");
        return INVALID_OPERATION;
    }
    HandlerInfo info;
    info.mLooper = looper;
    info.mHandler = handler;
    ALooper::handler_id handlerID = mNextHandlerID++;
    mHandlers.add(handlerID, info);
    handler->setID(handlerID);
    //针对每个handler调用registerHandler的时候都会设置一个独一无二的handler_id，最后发送消息进行处理的时候就是通过这个独一无二的handler_id这个变量找到处理handler类的。
    return handlerID;
}    

在这个函数中针对这个looper和handler会构造一个HandlerInfo结构体，然后放到pair容器中。一个looper可以有多个handler，但是一一个handler只能跟一个looper。

ALooper类

struct ALooper : public RefBase {
    typedef int32_t event_id;
    typedef int32_t handler_id;
    ALooper();
    // Takes effect in a subsequent call to start().
    void setName(const char *name);
    handler_id registerHandler(const sp &handler);
    void unregisterHandler(handler_id handlerID);
    status_t start(
            bool runOnCallingThread = false,
            bool canCallJava = false,
            int32_t priority = PRIORITY_DEFAULT
            );
private:
    friend struct ALooperRoster; 
    struct Event {
        int64_t mWhenUs;
        sp mMessage;
    };
   //后台存放事件的链表
    List<Event> mEventQueue;
    struct LooperThread;
    //后台处理线程
    sp<LooperThread> mThread;
    void post(const sp &msg, int64_t delayUs);
    bool loop();
};

ALooper 里面用Condition 做消息通知， List存储消息

能作为handler进行注册的类都必须是继承自AHandler这个类，注册的过程也是交给
gLooperRoster处理。

AMessage类：

消息类，用于构造消息，并通过post方法投递出去由ALooperRoster 类中转给ALooper

ALooperRoster类：中转类

将消息中转给ALooper 或者 AHandleReflector

ALooper

负责存储和转发AHandle的消息

LooperThread：

此线程循环调用ALooper的loop方法来转发消息

AHandleReflector类

消息处理类

使用方法
1.开始会创建一个ALooper对象， mLooper->start(…)

2.然后会实现一个AHandler的子类，
mLooper->registerhandler(objectXX)

子类实现一个onMessageReceived(XXXX),做收到消息的处理。

3.最后创建消息进行投递进入Message Queue。
创建AMessage里面，需要指定handleid,才能知道目标是发给谁。

mLooper(new ALooper)
mLooper->setName(name);  

mLooper->start(  
         false, // runOnCallingThread  
         false, // canCallJava  
         ANDROID_PRIORITY_FOREGROUND); 

mPlayer = new NUPlayer;
mLooper->registerHandler(mPlayer);  
//mPlayer是一个AHandler

mReflector =new AhandlerReflector<RTSPSource.(this);
mLooper->registerHandler(mReflector); 

(new AMessage(kWhatStart,id()))->post()