3 Alooper分析

概述

这里介绍下Android中利用ALooper进行消息传递和处理的用法及工作原理。

利用ALooper进行消息传递即处理涉及到的类关系图如下：

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

ALooperRoster类：中转类，将消息中转给ALooper 或者 AHandleReflector

ALooper：与AHandle一一对应，负责存储和转发AHandle的消息

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

AHandleReflector类：消息处理类

 

下面依据图并结合具体代码介绍下消息传递及处理流程

 

流程代码分析

图中的箭头部分代表了调用顺序：

1 注册handle： 语句mLooper->registerHandler(mHandler);  这样就建立了ALooper与AHandle的一一对应关系，要发送给AHandle处理的消息，都会经过ALooper存储和转发

mLooper(new ALooper),

  mHandler(new AHandlerReflector<SimpleSoftOMXComponent>(this)),
mLooper->setName(name);
mLooper->registerHandler(mHandler);
mLooper->start(
         false, // runOnCallingThread
         false, // canCallJava
         ANDROID_PRIORITY_FOREGROUND);

看下registerHandler实现

ALooper::handler_id ALooper::registerHandler(const sp<AHandler> &handler) {
    return gLooperRoster.registerHandler(this, handler);
}

主要是将ALooper和AHandle注册到ALooperRoster中，继续跟进

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);
  
    return handlerID;
}

将ALooper与AHandle 信息存储在mHandles 列表中， 可以存储多个<ALooper，AHandle >

注册完成后调用start启动ALooper开始工作

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;
}

这里主要是构造了一个LooperThread线程，此线程会循环调用其threadLoop

virtual bool threadLoop() {
    return mLooper->loop();
}

来处理消息，loop代码后面来看

这里看下threadLoop 在基类Thread中的介绍

    // Derived class must implement threadLoop(). The thread starts its life
    // here. There are two ways of using the Thread object:
    // 1) loop: if threadLoop() returns true, it will be called again if
    //          requestExit() wasn't called.
    // 2) once: if threadLoop() returns false, the thread will exit upon return.
    virtual bool        threadLoop() = 0;

这里的意思是 当threadLoop返回true时，会循环调用此方法，否则就终止线程

因此当threadLoop一直返回true，则可以看成是一个循环。

 

2 发送消息：通过构造AMessage对象，初始化参数后调用post方法发送

sp<AMessage> msg = new AMessage(kWhatSendCommand, mHandler->id());
msg->setInt32("cmd", cmd);
msg->setInt32("param", param);
msg->post();

void AMessage::post(int64_t delayUs) {
    gLooperRoster.postMessage(this, delayUs);
}

3 中转：消息通过ALooperRoster来转发给ALooper

status_t ALooperRoster::postMessage(
        const sp<AMessage> &msg, int64_t delayUs) {
    Mutex::Autolock autoLock(mLock);
    return postMessage_l(msg, delayUs);
}

status_t ALooperRoster::postMessage_l(
        const sp<AMessage> &msg, int64_t delayUs) {
    ssize_t index = mHandlers.indexOfKey(msg->target());
  
    if (index < 0) {
        ALOGW("failed to post message. Target handler not registered.");
        return -ENOENT;
    }
  
    const HandlerInfo &info = mHandlers.valueAt(index);
  
    sp<ALooper> looper = info.mLooper.promote();
  
    if (looper == NULL) {
        ALOGW("failed to post message. "
             "Target handler %d still registered, but object gone.",
             msg->target());
  
        mHandlers.removeItemsAt(index);
        return -ENOENT;
    }
  
    looper->post(msg, delayUs);
  
    return OK;
}

从mHandlers中找到已经注册过的对应的ALooper对象，并调用post方法

4 ALooper存储消息

void 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);
}

从代码里可以看到，消息存储在了mEventQueue中，mEventQueue 是封装了AMessage的结构体

 

5 ALooperRoster 中转

前面说了，LooperThread会调用threadLoop方法

virtual bool threadLoop() {
    return mLooper->loop();
}

实际调用的是ALooper的loop方法，而且如果loop返回true，则会循环调用

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());
    }
  
    gLooperRoster.deliverMessage(event.mMessage);
  
    // NOTE: It's important to note that at this point our "ALooper" object
    // may no longer exist (its final reference may have gone away while
    // delivering the message). We have made sure, however, that loop()
    // won't be called again.
  
    return true;
}

代码主要是做如下工作：查看mEventQueue是否有message，如果有，且时间正确，则调用gLooperRoster.deliverMessage中转出去

而ALooperRoster实际代码为

void ALooperRoster::deliverMessage(const sp<AMessage> &msg) {
    sp<AHandler> handler;
  
    {
        Mutex::Autolock autoLock(mLock);
  
        ssize_t index = mHandlers.indexOfKey(msg->target());
  
        if (index < 0) {
            ALOGW("failed to deliver message. Target handler not registered.");
            return;
        }
  
        const HandlerInfo &info = mHandlers.valueAt(index);
        handler = info.mHandler.promote();
  
        if (handler == NULL) {
            ALOGW("failed to deliver message. "
                 "Target handler %d registered, but object gone.",
                 msg->target());
  
            mHandlers.removeItemsAt(index);
            return;
        }
    }
  
    handler->onMessageReceived(msg);
}

主要就是调用AHandle的onMessageReceived进行处理

 

6 AHandle处理函数执行 

 

这样一个消息从给投递到处理流程就结束了。 理清调用关系：主要是到ALooper中暂存，并借由全局变量gLooperRoster中转，完成了消息的传递。

【结束】