一、 前言：
Android媒体通路中，大量充斥着AHandler、ALooper和AMessage的消息机制，之前简单分析了一下java层的消息机制，而native层的消息机制同java层原理类似，但又有一些区别，所以单独拿来分析一下，在nuplayer和mediacodec中随处可见这种异步机制。
三者的简单概括：
AMessage：我们要发送的消息，类似于一个“包裹”，“邮件”；
AHandler：消息处理者，与java层消息机制不同的是，这里的hanlder不会有发送message的功能，每个handler都有一个唯一的标识符ID；
ALooper：消息分发的控制者，实际上通过一个“小弟”ALooperRoster来协调控制message与handler；
下面我们将以mediacodec中一条消息的发送为例，来看下一条message是如何被打包、发送再到处理的，进而结合源码，对整个native层的AHandler、ALooper和AMessage有一个全面的了解。
相关代码路径（Android5.1）：
AHandler、ALooper和AMessage相关源码路径：
frameworks\av\media\libstagefright\foundation
mediacodec代码路径：
frameworks\av\media\libstagefright
二、示例分析：
- 消息机制的建立：
消息机制的建立首先是ALooper的实例化：
mediacodec的java接口通过JNI会调入到android_media_MediaCodec.cpp文件中，在native层，会先去实例化一个JMediaCodec：
JMediaCodec::JMediaCodec(
JNIEnv *env, jobject thiz,
const char *name, bool nameIsType, bool encoder)
: mClass(NULL),
mObject(NULL) {
...
/* 1.实例化一个Alooper */
mLooper = new ALooper;
mLooper->setName("MediaCodec_looper");
/* 2.开启looper的start */
mLooper->start(
false, // runOnCallingThread
true, // canCallJava
PRIORITY_FOREGROUND);
if (nameIsType) {
if (mDebug) {
ALOGI("CreateByType(%s, encoder:%s)", name, encoder?"true":"false");
mIsVideo = !strncasecmp(name, "video/", 6);
}
/* 3.实例化mediacodec */
mCodec = MediaCodec::CreateByType(mLooper, name, encoder, &mInitStatus);
} else {
if (mDebug) {
ALOGI("CreateByComponentName(%s)", name);
AString nameString = AString(name);
nameString.trim();
if (nameString.find("video", 0) >= 0) {
mIsVideo = true;
}
}
mCodec = MediaCodec::CreateByComponentName(mLooper, name, &mInitStatus);
}
...
}
截取了该函数中关键部分代码，首先是实例化ALooper，然后是设置当前线程中looper的名字，注意，native层代码中将不再限制一个线程只有一个looper：
ALooper::ALooper()
: mRunningLocally(false) {
/* 每个looper会维护一个全局变量ALooperRoster，也就是前文说的“小弟” */
gLooperRoster.unregisterStaleHandlers();
}
void ALooper::setName(const char *name) {
mName = name;
}
从构造函数可以看出来，ALooper是单例设计模式，每个ALooper只有一个ALooperRoster，ALooper很多重要的工作都是交由ALooperRoster来完成的。
回到JMediaCodec看第二步，start函数：
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;
}
/* 创建了一个thread给looper处理 */
mThread = new LooperThread(this, canCallJava);
/* 调用run方法让thread转起来 */
status_t err = mThread->run(
mName.empty() ? "ALooper" : mName.c_str(), priority);
if (err != OK) {
mThread.clear();
}
return err;
}
实际上，我们可以把looper看成是一个thread来操作；
JMediaCodec的第三步就是去实例化mediacodec了：
sp<MediaCodec> MediaCodec::CreateByType(
const sp<ALooper> &looper, const char *mime, bool encoder, status_t *err) {
/* 实例化mediacodec */
sp<MediaCodec> codec = new MediaCodec(looper);
/* 执行init操作 */
const status_t ret = codec->init(mime, true /* nameIsType */, encoder);
if (err != NULL) {
*err = ret;
}
return ret == OK ? codec : NULL; // NULL deallocates codec.
}
MediaCodec::MediaCodec(const sp<ALooper> &looper)
: mState(UNINITIALIZED),
mLooper(looper),
mCodec(NULL),
mReplyID(0),
mFlags(0),
mStickyError(OK),
mSoftRenderer(NULL),
mBatteryStatNotified(false),
mIsVideo(false),
mDequeueInputTimeoutGeneration(0),
mDequeueInputReplyID(0),
mDequeueOutputTimeoutGeneration(0),
mDequeueOutputReplyID(0),
mHaveInputSurface(false) {
mStats = false;
mBufferCounter = 0;
char value[PROPERTY_VALUE_MAX];
if (property_get("service.media.codec.stats", value, NULL)
&& (!strcasecmp("true", value))) {
mStats = true;
}
}
mediacodec构造中关键的一点就是把JMediaCodec实例化的looper给传过来了；
再看一下init函数，有点长，我们也只截取部分：
status_t MediaCodec::init(const AString &name, bool nameIsType, bool encoder) {
...
/* 1.实例化ACodec */
mCodec = new ACodec;
bool needDedicatedLooper = false;
if (nameIsType && !strncasecmp(name.c_str(), "video/", 6)) {
needDedicatedLooper = true;
} else {
AString tmp = name;
if (tmp.endsWith(".secure")) {
tmp.erase(tmp.size() - 7, 7);
}
const sp<IMediaCodecList> mcl = MediaCodecList::getInstance();
ssize_t codecIdx = mcl->findCodecByName(tmp.c_str());
if (codecIdx >= 0) {
const sp<MediaCodecInfo> info = mcl->getCodecInfo(codecIdx);
Vector<AString> mimes;
info->getSupportedMimes(&mimes);
for (size_t i = 0; i < mimes.size(); i++) {
if (mimes[i].startsWith("video/")) {
needDedicatedLooper = true;
break;
}
}
}
}
if (needDedicatedLooper) {
if (mCodecLooper == NULL) {
/* 2.mediacodec再创建一个looper */
mCodecLooper = new ALooper;
mCodecLooper->setName("CodecLooper");
mCodecLooper->start(false, false, ANDROID_PRIORITY_AUDIO);
}
/* 3.将ACodec注册到mediacodec的looper中 */
mCodecLooper->registerHandler(mCodec);
} else {
mLooper->registerHandler(mCodec);
}
/* 4.将mediacodec注册到JMediaCodec的looper中 */
mLooper->registerHandler(this);
...
}
init函数会去实例化ACodec,它与OMX进行交互，并且，在mediacodec中又创建了一个looper，然后就是调用registerHandler来将handler注册到looper中，这里需要点一下，mediacodec和acodec都是继承自handler，每个looper可以有多个handler，但是，每个handler只能被注册到一个looper中，看一下注册函数：
ALooper::handler_id ALooper::registerHandler(const sp<AHandler> &handler) {
return gLooperRoster.registerHandler(this, handler);
}
转交ALooperRoster来处理：
ALooper::handler_id ALooperRoster::registerHandler(
const sp<ALooper> looper, const sp<AHandler> &handler) {
Mutex::Autolock autoLock(mLock);
/* handler构造时默认id为0，如果不为0，说明该handler已经被注册 */
if (handler->id() != 0) {
CHECK(!"A handler must only be registered once.");
return INVALID_OPERATION;
}
HandlerInfo info; //打包handler
info.mLooper = looper; //记录当前looper
info.mHandler = handler; //记录注册handler
/* 分配一个id */
ALooper::handler_id handlerID = mNextHandlerID++;
/* 这是一个KeyedVector，记录每个handlerinfo与id */
mHandlers.add(handlerID, info);
/* 将分配的id设置到handler中 */
handler->setID(handlerID);
return handlerID;
}
registerHandler完成的事就是将该handler注册到对应的looper中.
到目前为止，我们必须明白以下几点：
①JMediaCodec和mediacodec各自创建了一个looper；
②JMediaCodec的looper中注册了两个handler，分别是JMediaCodec和mediacodec；
③mediacodec的looper中目前只注册了ACodec这一个handler；
2. start指令中的消息传递：
这里选用mediacodec的start指令来看下消息收发，经过java层，jni，最终调用到mediacodec的start函数中：
status_t MediaCodec::start() {
/* 实例化一个Amessage */
sp<AMessage> msg = new AMessage(kWhatStart, id());
/* 投递出去并获取响应 */
sp<AMessage> response;
return PostAndAwaitResponse(msg, &response);
}
AMessage的实例化很简单：
AMessage::AMessage(uint32_t what, ALooper::handler_id target)
: mWhat(what),
mTarget(target),
mNumItems(0) {
}
看一下下面的PostAndAwaitResponse函数：
status_t MediaCodec::PostAndAwaitResponse(
const sp<AMessage> &msg, sp<AMessage> *response) {
/* 调用AMessage的postAndAwaitResponse函数 */
status_t err = msg->postAndAwaitResponse(response);
if (err != OK) {
return err;
}
if (!(*response)->findInt32("err", &err)) {
err = OK;
}
return err;
}
还是得去看AMessage中的函数实现：
status_t AMessage::postAndAwaitResponse(sp<AMessage> *response) {
return gLooperRoster.postAndAwaitResponse(this, response);
}
这个gLooperRoster很眼熟，没错，就是ALooper中的ALooperRoster，可以看下AMessage.h：
AMessage.cpp:
extern ALooperRoster gLooperRoster;
AMessage是通过外部引用的ALooper中的“小弟”ALooperRoster，所以，AMessage的操作最终还是让ALooperRoster来接管了：
status_t ALooperRoster::postAndAwaitResponse(
const sp<AMessage> &msg, sp<AMessage> *response) {
/* 1.通过handler id 来找到注册的looper */
sp<ALooper> looper = findLooper(msg->target());
if (looper == NULL) {
ALOGW("failed to post message. "
"Target handler %d still registered, but object gone.",
msg->target());
response->clear();
return -ENOENT;
}
Mutex::Autolock autoLock(mLock);
uint32_t replyID = mNextReplyID++;
msg->setInt32("replyID", replyID);
/* 2.调用Alooper将消息投递出去 */
looper->post(msg, 0 /* delayUs */);
ssize_t index;
while ((index = mReplies.indexOfKey(replyID)) < 0) {
mRepliesCondition.wait(mLock);
}
*response = mReplies.valueAt(index);
mReplies.removeItemsAt(index);
return OK;
}
这个函数着重分析两点，首先是通过handler找到对应的looper，因为前面我们说过了，每个handler只能被注册到一个looper中，所以，在前面的KeyedVector中通过搜寻键值对的方式可以找到looper，接下来，就是调用looper的post函数将消息投递到对应的looper中了，注意区别，java层中的消息投递，是由hanlder.sendMessage来完成的。
我们具体看下post函数：
void ALooper::post(const sp<AMessage> &msg, int64_t delayUs) {
Mutex::Autolock autoLock(mLock);
/* 1.计算投递时间 */
int64_t whenUs;
if (delayUs > 0) {
whenUs = GetNowUs() + delayUs;
} else {
whenUs = GetNowUs();
}
/* 2.遍历链表，找到一个系统时间大于该事件的时间 */
List<Event>::iterator it = mEventQueue.begin();
while (it != mEventQueue.end() && (*it).mWhenUs <= whenUs) {
++it;
}
/* 3.将消息打包成event */
Event event;
event.mWhenUs = whenUs;
event.mMessage = msg;
if (it == mEventQueue.begin()) {
mQueueChangedCondition.signal();
}
/* 4.插入到事件队列中 */
mEventQueue.insert(it, event);
}
post实现的逻辑很简单，就是将事件打包成event之后找一个合适的位置插入到事件链表中；
消息发送端的操作就分析完了，通过创建message所在的hanlder id，找到对应的looper，调用looper的post将消息投递出去；
来看下接收端是何时建立并且如何处理消息的，还记得looper实例化之后调用的start函数吗？里面会去实例化一个thread：
...
mThread = new LooperThread(this, canCallJava);
status_t err = mThread->run(
mName.empty() ? "ALooper" : mName.c_str(), priority);
if (err != OK) {
mThread.clear();
}
...
LooperThread继承的是Android的thread基类，其构造函数中传入了looper对象：
LooperThread(ALooper *looper, bool canCallJava)
: Thread(canCallJava),
mLooper(looper),
mThreadId(NULL) {
}
既然是继承自thread基类，那么必然覆写threadLoop方法，因为thread类中，threadLoop是一个纯虚函数，这里需要注意，threadLoop如果返回值为true，则会一直循环，具体的代码就不去分析了，扯了这么多，我们看一下LooperThread中threadLoop干的啥：
virtual bool threadLoop() {
return mLooper->loop();
}
很简单，就去调用了ALooper中的loop函数，也就是说，如果mLooper->loop()返回值为true，那么该函数一直循环，因此，消息的取出就是在这里面做的了，看一下loop函数：
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;
}
果然代码中充斥着true，还是需要用到熟悉的ALooper“小弟”ALooperRoster，直接看关键函数deliverMessage：
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;
}
}
/* 调用对应的handle处理消息 */
handler->onMessageReceived(msg);
}
终于看到关键点了，onMessageReceived，这下你知道为什么每一个继承自AHandler的类中都要有onMessageReceived函数了吧，总算把消息投递到了“收件人”那里，至于start的消息具体干了啥，我们就不分析了，主要分析消息收发的过程。
三、总结：
给一张图总结一下JMediaCodec中三者间的关系：
①AMessage被封装成Event进行收发；
②每个AHandler只能被注册到一个ALooper中；
③Event投递最终是通过ALooper来的；
④ALooper实际是看成了一个线程来运行的，AHandler与Event的协调工作是通过ALooperRoster来完成的；
⑤JMediaCodec和MediaCodec这两个AHandler是注册在JMediaCodec实例化的ALooper中，而ACodec这个AHandler是注册在Mediacodec实例化多的ALooper中；
211
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
