上文从源码分析Handler机制中从java层分析了消息机制，接下来本文从native层去分析Android中的消息机制。
在一个消息驱动的系统中，最重要的就是消息队列和消息获取和处理，从上一篇文章可以看出handler的消息机制主要是靠MessageQueue进行消息列队，靠Looper进行消息循环，Looper的loop方法中进行轮询消息的实际操作还是依靠MessageQueue的next方法来获取消息，也就是说在这个消息驱动机制中最重要的就是MessageQueue这个类了。在Android 2.3之前，只有java层中可以往MessageQueue中添加消息使得消息驱动正常的运作，在2.3之后，MessageQueue的核心部分移到了native层，MessageQueue兼顾了两个世界的来保证消息的运作。 在MessageQueue的构造方法中：
MessageQueue(boolean quitAllowed) {mQuitAllowed = quitAllowed;mPtr = nativeInit();}
构造函数调用nativeInit，该函数由Native层实现，native层的真正实现为android_os_MessageQueue.cpp中的android_os_MessageQueue_nativeInit方法。
static void android_os_MessageQueue_nativeInit(JNIEnv* env,jobject obj) {NativeMessageQueue* nativeMessageQueue = new NativeMessageQueue();if (! nativeMessageQueue) {jniThrowRuntimeException(env, “Unable to allocate native queue”);return;}android_os_MessageQueue_setNativeMessageQueue(env, obj, nativeMessageQueue);}NativeMessageQueue::NativeMessageQueue() {mLooper = Looper::getForThread();if (mLooper == NULL) {mLooper = new Looper(false);Looper::setForThread(mLooper);}}
android_os_MessageQueue_nativeInit函数中创建以一个与java层MessageQueue对应点nativeMessageQueue消息队列，NativeMessageQueue构造中从当前线程中获取一个looper，如果当前线程没有到话，就实例化一个并且绑定到当前线程。
前一篇文章提到，当与消息机制相关的几个对象初始化完毕后，就要开始loop操作，而loop其实也就是循环的执行MessageQueue的next方法。
Message next() {int pendingIdleHandlerCount = -1; // -1 only during first iterationint nextPollTimeoutMillis = 0;for (;;) {if (nextPollTimeoutMillis != 0) {Binder.flushPendingCommands();}// We can assume mPtr != 0 because the loop is obviously still running.// The looper will not call this method after the loop quits.nativePollOnce(mPtr, nextPollTimeoutMillis);synchronized (this) {// Try to retrieve the next message. Return if found.final long now = SystemClock.uptimeMillis();Message prevMsg = null;Message msg = mMessages;if (msg != null && msg.target == null) {// Stalled by a barrier. Find the next asynchronous message in the queue.do {prevMsg = msg;msg = msg.next;} while (msg != null && !msg.isAsynchronous());}if (msg != null) {if (now < msg.when) {// Next message is not ready. Set a timeout to wake up when it is ready.nextPollTimeoutMillis = (int) Math.min(msg.when – now, Integer.MAX_VALUE);} else {// Got a message.mBlocked = false;if (prevMsg != null) {prevMsg.next = msg.next;} else {mMessages = msg.next;}msg.next = null;if (false) Log.v(“MessageQueue”, “Returning message: ” + msg);msg.markInUse();return msg;}} else {// No more messages.nextPollTimeoutMillis = -1;}// Process the quit message now that all pending messages have been handled.if (mQuitting) {dispose();return null;}// If first time idle, then get the number of idlers to run.// Idle handles only run if the queue is empty or if the first message// in the queue (possibly a barrier) is due to be handled in the future.if (pendingIdleHandlerCount < 0&& (mMessages == null || now < mMessages.when)) {pendingIdleHandlerCount = mIdleHandlers.size();}if (pendingIdleHandlerCount <= 0) {// No idle handlers to run. Loop and wait some more.mBlocked = true;continue;}if (mPendingIdleHandlers == null) {mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];}mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);}// Run the idle handlers.// We only ever reach this code block during the first iteration.for (int i = 0; i < pendingIdleHandlerCount; i++) {final IdleHandler idler = mPendingIdleHandlers[i];mPendingIdleHandlers[i] = null; // release the reference to the handlerboolean keep = false;try {keep = idler.queueIdle();} catch (Throwable t) {Log.wtf(“MessageQueue”, “IdleHandler threw exception”, t);}if (!keep) {synchronized (this) {mIdleHandlers.remove(idler);}}}// Reset the idle handler count to 0 so we do not run them again.pendingIdleHandlerCount = 0;// While calling an idle handler, a new message could have been delivered// so go back and look again for a pending message without waiting.nextPollTimeoutMillis = 0;}}
nativePollOnce方法返回后，就代表next方法就可以从mMessages中获取一个消息，也就是说如果消息队列中没有消息存在nativePollOnce就不会返回。 在MessageQueue的enqueueMessage方法中
boolean enqueueMessage(Message msg, long when) {if (msg.isInUse()) {throw new AndroidRuntimeException(msg + ” This message is already in use.”);}if (msg.target == null) {throw new AndroidRuntimeException(“Message must have a target.”);}synchronized (this) {if (mQuitting) {RuntimeException e = new RuntimeException(msg.target + ” sending message to a Handler on a dead thread”);Log.w(“MessageQueue”, e.getMessage(), e);return false;}msg.when = when;Message p = mMessages;boolean needWake;if (p == null || when == 0 || when < p.when) {// New head, wake up the event queue if blocked.msg.next = p;mMessages = msg;needWake = mBlocked;} else {// Inserted within the middle of the queue. Usually we don’t have to wake// up the event queue unless there is a barrier at the head of the queue// and the message is the earliest asynchronous message in the queue.needWake = mBlocked && p.target == null && msg.isAsynchronous();Message prev;for (;;) {prev = p;p = p.next;if (p == null || when < p.when) {break;}if (needWake && p.isAsynchronous()) {needWake = false;}}msg.next = p; // invariant: p == prev.nextprev.next = msg;}// We can assume mPtr != 0 because mQuitting is false.if (needWake) {nativeWake(mPtr);}}return true;}
添加完message后，调用了native层的nativeWake方法，这个应该是触发上面提到的nativePollOnce方法返回，好让加入的message得到分发处理。
害怕攀登高峰的人，永远在山下徘徊。
