Android应用程序消息处理机制(Looper、Handler)分析(7)-android 消息处理机制

如果消息队列中有消息，并且当前时候大于等于消息中的执行时间，那么就直接返回这个消息给Looper.loop消息处理，否则的话就要等待到消息的执行时间：

[java] view plaincopynextPollTimeoutMillis = (int) Math.min(when - now, Integer.MAX_VALUE);

如果消息队列中没有消息，那就要进入无穷等待状态直到有新消息了：

[java] view plaincopynextPollTimeoutMillis = -1;

-1表示下次调用nativePollOnce时，如果消息中没有消息，就进入无限等待状态中去。

当前nativePollOnce返回后，就去看看消息队列中有没有消息：

[java] view plaincopyfinal Message msg = mMessages; 
if (msg != null) { 
final long when = msg.when; 
if (now >= when) { 
mBlocked = false; 
mMessages = msg.next; 
msg.next = null; 
if (Config.LOGV) Log.v("MessageQueue", "Returning message: " + msg); 
return msg; 
} else { 
nextPollTimeoutMillis = (int) Math.min(when - now, Integer.MAX_VALUE); 
} 
} else { 
nextPollTimeoutMillis = -1; 
} 

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

这里计算出来的等待时间都是在下次调用nativePollOnce时使用的。

这里说的等待，是空闲等待，而不是忙等待，因此，在进入空闲等待状态前，如果应用程序注册了IdleHandler接口来处理一些事情，那么就会先执行这里IdleHandler，然后再进入等待状态。IdlerHandler是定义在MessageQueue的一个内部类：

[java] view plaincopypublic class MessageQueue { 
...... 
/** 
* Callback interface for discovering when a thread is going to block 
* waiting for more messages. 
*/ 
public static interface IdleHandler { 
/** 
* Called when the message queue has run out of messages and will now 
* wait for more. Return true to keep your idle handler active, false 
* to have it removed. This may be called if there are still messages 
* pending in the queue, but they are all scheduled to be dispatched 
* after the current time. 
*/ 
boolean queueIdle(); 
} 
...... 
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.

它只有一个成员函数queueIdle，执行这个函数时，如果返回值为false，那么就会从应用程序中移除这个IdleHandler，否则的话就会在应用程序中继续维护着这个IdleHandler，下次空闲时仍会再执会这个IdleHandler。MessageQueue提供了 addIdleHandler和removeIdleHandler两注册和删除IdleHandler。

回到MessageQueue函数中，它接下来就是在进入等待状态前，看看有没有IdleHandler是需要执行的：

　　[java] view plaincopy// If first time, then get the number of idlers to 
run. 
　　if (pendingIdleHandlerCount < 0) { 
　　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); 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

如果没有，即pendingIdleHandlerCount等于0，那下面的逻辑就不执行了，通过continue语句直接进入下一次循环，否则就要把注册在mIdleHandlers中的IdleHandler取出来，放在mPendingIdleHandlers数组中去。

接下来就是执行这些注册了的IdleHanlder了：

[java] view plaincopy// 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 handler 
boolean keep = false; 
try { 
keep = idler.queueIdle(); 
} catch (Throwable t) { 
Log.wtf("MessageQueue", "IdleHandler threw exception", t); 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.