AHandler and AMessages

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

Ahandler机制包括以下几个类

AMessage
消息类，用于构造消息，通过post方法投递出去给ALooper

status_t AMessage::post(int64_t delayUs) {    sp<ALooper> looper = mLooper.promote();    if (looper == NULL) {        ALOGW("failed to post message as target looper for handler %d is gone.", mTarget);        return -ENOENT;    }    looper->post(this, delayUs);    return OK;}void AMessage::deliver() {    sp<AHandler> handler = mHandler.promote();    if (handler == NULL) {        ALOGW("failed to deliver message as target handler %d is gone.", mTarget);        return;    }    handler->deliverMessage(this); //see AHandler@deliverMessage，前面通过looper post最后就是调用这里的deliever送到handler手里}

AHandler
消息处理类，一般当做父类，继承该类的子类需要实现onMessageReceived方法

void AHandler::deliverMessage(const sp<AMessage> &msg) {    onMessageReceived(msg);    mMessageCounter++;….}

ALooper
与Ahander一一对应，负责存储消息并分发Ahandler的消息，与AMessage一对多关系

// posts a message on this looper with the given timeoutvoid ALooper::post(const sp<AMessage> &msg, int64_t delayUs) {    Mutex::Autolock autoLock(mLock);    int64_t whenUs;    if (delayUs > 0) {        whenUs = GetNowUs() + delayUs;    } else {        whenUs = GetNowUs();    }    List<Event>::iterator it = mEventQueue.begin();    while (it != mEventQueue.end() && (*it).mWhenUs <= whenUs) {        ++it;    }    Event event;    event.mWhenUs = whenUs;    event.mMessage = msg;    if (it == mEventQueue.begin()) {        mQueueChangedCondition.signal();    }    mEventQueue.insert(it, event);}----------------------------------------------------------status_t ALooper::start(        bool runOnCallingThread, bool canCallJava, int32_t priority) {    if (runOnCallingThread) {        {            Mutex::Autolock autoLock(mLock);            if (mThread != NULL || mRunningLocally) {                return INVALID_OPERATION;            }            mRunningLocally = true;        }        do {        } while (loop());        return OK;    }    Mutex::Autolock autoLock(mLock);    if (mThread != NULL || mRunningLocally) {        return INVALID_OPERATION;    }    mThread = new LooperThread(this, canCallJava);    status_t err = mThread->run(            mName.empty() ? "ALooper" : mName.c_str(), priority);    if (err != OK) {        mThread.clear();    }    return err;}bool ALooper::loop() {    Event event;    {        Mutex::Autolock autoLock(mLock);        if (mThread == NULL && !mRunningLocally) {            return false;        }        if (mEventQueue.empty()) {            mQueueChangedCondition.wait(mLock);            return true;        }        int64_t whenUs = (*mEventQueue.begin()).mWhenUs;        int64_t nowUs = GetNowUs();        if (whenUs > nowUs) {            int64_t delayUs = whenUs - nowUs;            mQueueChangedCondition.waitRelative(mLock, delayUs * 1000ll);            return true;        }        event = *mEventQueue.begin();        mEventQueue.erase(mEventQueue.begin());    }    event.mMessage->deliver();　//see AHandler.deliverMessage…..    return true;}

LooperThread
此线程调用ALooper的loop方法来分发消息

 virtual status_t readyToRun() {        mThreadId = androidGetThreadId();        return Thread::readyToRun();    }    virtual bool threadLoop() {        return mLooper->loop();    }

ALooperRoaster
与Handler是一对多的关系， 管理Looper和Handler一一对应关系，负责释放stale handler

ALooper::handler_id ALooperRoster::registerHandler(        const sp<ALooper> looper, const sp<AHandler> &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, looper);    return handlerID;}

void ALooperRoster::unregisterHandler(ALooper::handler_id handlerID) {    Mutex::Autolock autoLock(mLock);    ssize_t index = mHandlers.indexOfKey(handlerID);    if (index < 0) {        return;    }    const HandlerInfo &info = mHandlers.valueAt(index);    sp<AHandler> handler = info.mHandler.promote();    if (handler != NULL) {        handler->setID(0, NULL);    }    mHandlers.removeItemsAt(index);}

void ALooperRoster::unregisterStaleHandlers() {    Vector<sp<ALooper> > activeLoopers;    {        Mutex::Autolock autoLock(mLock);        for (size_t i = mHandlers.size(); i > 0;) {            i--;            const HandlerInfo &info = mHandlers.valueAt(i);            sp<ALooper> looper = info.mLooper.promote();            if (looper == NULL) {                ALOGV("Unregistering stale handler %d", mHandlers.keyAt(i));                mHandlers.removeItemsAt(i);            } else {                // At this point ‘looper‘ might be the only sp<> keeping                // the object alive. To prevent it from going out of scope                // and having ~ALooper call this method again recursively                // and then deadlocking because of the Autolock above, add                // it to a Vector which will go out of scope after the lock                // has been released.                activeLoopers.add(looper);            }        }    }}

异步消息机制的创建

sp<ALooper> mLooper = new ALooper; //创建一个Alooper实例sp<AHandlerReflector> mHandler = new AHandlerReflector //创建一个Ahandler实例mLooper->setName(“xxxxx”); //设置looper名字mLooper->start(false, true, PRIORITY_XXX); //根据参数创建并启动 looper threadmLooper->regiserHandler(mHandler); //register handler 会调用AHandler的setID方法将looper设置到Handler里去

Post消息

sp<AMessage> msg = new AMessage(kWhatSayGoodbye, mHandler); //在AMessage的构造方法里获取Ahandler对应的Looper并保存msg->post(); // 调用looper的post方法

Message Post的调用过程

Message::post

↓

ALooper::postmEventQueue.insertmQueueChangedCondition.signal() //如果之前没有event，通知looper thread

↓

ALooper::loop()if (mEventQueue.empty()) { //如果消息队列为空，则等待mQueueChangedCondition.wait(mLock);return true;}event = *mEventQueue.begin();event.mMessage->deliver();

↓

AHandler::deliverMessage

↓

AHandlerReflector:: onMessageReceived

↓
具体的实现