| /* |
| * Copyright (C) 2006 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package android.os; |
| |
| import android.util.AndroidRuntimeException; |
| import android.util.Log; |
| |
| import java.util.ArrayList; |
| |
| /** |
| * Low-level class holding the list of messages to be dispatched by a |
| * {@link Looper}. Messages are not added directly to a MessageQueue, |
| * but rather through {@link Handler} objects associated with the Looper. |
| * |
| * <p>You can retrieve the MessageQueue for the current thread with |
| * {@link Looper#myQueue() Looper.myQueue()}. |
| */ |
| public class MessageQueue { |
| Message mMessages; |
| private final ArrayList<IdleHandler> mIdleHandlers = new ArrayList<IdleHandler>(); |
| private IdleHandler[] mPendingIdleHandlers; |
| private boolean mQuiting; |
| boolean mQuitAllowed = true; |
| |
| // Indicates whether next() is blocked waiting in pollOnce() with a non-zero timeout. |
| private boolean mBlocked; |
| |
| @SuppressWarnings("unused") |
| private int mPtr; // used by native code |
| |
| private native void nativeInit(); |
| private native void nativeDestroy(); |
| private native void nativePollOnce(int ptr, int timeoutMillis); |
| private native void nativeWake(int ptr); |
| |
| /** |
| * 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(); |
| } |
| |
| /** |
| * Add a new {@link IdleHandler} to this message queue. This may be |
| * removed automatically for you by returning false from |
| * {@link IdleHandler#queueIdle IdleHandler.queueIdle()} when it is |
| * invoked, or explicitly removing it with {@link #removeIdleHandler}. |
| * |
| * <p>This method is safe to call from any thread. |
| * |
| * @param handler The IdleHandler to be added. |
| */ |
| public final void addIdleHandler(IdleHandler handler) { |
| if (handler == null) { |
| throw new NullPointerException("Can't add a null IdleHandler"); |
| } |
| synchronized (this) { |
| mIdleHandlers.add(handler); |
| } |
| } |
| |
| /** |
| * Remove an {@link IdleHandler} from the queue that was previously added |
| * with {@link #addIdleHandler}. If the given object is not currently |
| * in the idle list, nothing is done. |
| * |
| * @param handler The IdleHandler to be removed. |
| */ |
| public final void removeIdleHandler(IdleHandler handler) { |
| synchronized (this) { |
| mIdleHandlers.remove(handler); |
| } |
| } |
| |
| MessageQueue() { |
| nativeInit(); |
| } |
| |
| @Override |
| protected void finalize() throws Throwable { |
| try { |
| nativeDestroy(); |
| } finally { |
| super.finalize(); |
| } |
| } |
| |
| final Message next() { |
| int pendingIdleHandlerCount = -1; // -1 only during first iteration |
| int nextPollTimeoutMillis = 0; |
| |
| for (;;) { |
| if (nextPollTimeoutMillis != 0) { |
| Binder.flushPendingCommands(); |
| } |
| nativePollOnce(mPtr, nextPollTimeoutMillis); |
| |
| synchronized (this) { |
| // Try to retrieve the next message. Return if found. |
| final long now = SystemClock.uptimeMillis(); |
| final Message msg = mMessages; |
| if (msg != null) { |
| final long when = msg.when; |
| if (now >= when) { |
| mBlocked = false; |
| mMessages = msg.next; |
| msg.next = null; |
| if (false) Log.v("MessageQueue", "Returning message: " + msg); |
| msg.markInUse(); |
| return msg; |
| } else { |
| nextPollTimeoutMillis = (int) Math.min(when - now, Integer.MAX_VALUE); |
| } |
| } else { |
| nextPollTimeoutMillis = -1; |
| } |
| |
| // 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); |
| } |
| |
| // 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); |
| } |
| |
| 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; |
| } |
| } |
| |
| final boolean enqueueMessage(Message msg, long when) { |
| if (msg.isInUse()) { |
| throw new AndroidRuntimeException(msg |
| + " This message is already in use."); |
| } |
| if (msg.target == null && !mQuitAllowed) { |
| throw new RuntimeException("Main thread not allowed to quit"); |
| } |
| final boolean needWake; |
| synchronized (this) { |
| if (mQuiting) { |
| RuntimeException e = new RuntimeException( |
| msg.target + " sending message to a Handler on a dead thread"); |
| Log.w("MessageQueue", e.getMessage(), e); |
| return false; |
| } else if (msg.target == null) { |
| mQuiting = true; |
| } |
| |
| msg.when = when; |
| //Log.d("MessageQueue", "Enqueing: " + msg); |
| Message p = mMessages; |
| if (p == null || when == 0 || when < p.when) { |
| msg.next = p; |
| mMessages = msg; |
| needWake = mBlocked; // new head, might need to wake up |
| } else { |
| Message prev = null; |
| while (p != null && p.when <= when) { |
| prev = p; |
| p = p.next; |
| } |
| msg.next = prev.next; |
| prev.next = msg; |
| needWake = false; // still waiting on head, no need to wake up |
| } |
| } |
| if (needWake) { |
| nativeWake(mPtr); |
| } |
| return true; |
| } |
| |
| final boolean removeMessages(Handler h, int what, Object object, |
| boolean doRemove) { |
| synchronized (this) { |
| Message p = mMessages; |
| boolean found = false; |
| |
| // Remove all messages at front. |
| while (p != null && p.target == h && p.what == what |
| && (object == null || p.obj == object)) { |
| if (!doRemove) return true; |
| found = true; |
| Message n = p.next; |
| mMessages = n; |
| p.recycle(); |
| p = n; |
| } |
| |
| // Remove all messages after front. |
| while (p != null) { |
| Message n = p.next; |
| if (n != null) { |
| if (n.target == h && n.what == what |
| && (object == null || n.obj == object)) { |
| if (!doRemove) return true; |
| found = true; |
| Message nn = n.next; |
| n.recycle(); |
| p.next = nn; |
| continue; |
| } |
| } |
| p = n; |
| } |
| |
| return found; |
| } |
| } |
| |
| final void removeMessages(Handler h, Runnable r, Object object) { |
| if (r == null) { |
| return; |
| } |
| |
| synchronized (this) { |
| Message p = mMessages; |
| |
| // Remove all messages at front. |
| while (p != null && p.target == h && p.callback == r |
| && (object == null || p.obj == object)) { |
| Message n = p.next; |
| mMessages = n; |
| p.recycle(); |
| p = n; |
| } |
| |
| // Remove all messages after front. |
| while (p != null) { |
| Message n = p.next; |
| if (n != null) { |
| if (n.target == h && n.callback == r |
| && (object == null || n.obj == object)) { |
| Message nn = n.next; |
| n.recycle(); |
| p.next = nn; |
| continue; |
| } |
| } |
| p = n; |
| } |
| } |
| } |
| |
| final void removeCallbacksAndMessages(Handler h, Object object) { |
| synchronized (this) { |
| Message p = mMessages; |
| |
| // Remove all messages at front. |
| while (p != null && p.target == h |
| && (object == null || p.obj == object)) { |
| Message n = p.next; |
| mMessages = n; |
| p.recycle(); |
| p = n; |
| } |
| |
| // Remove all messages after front. |
| while (p != null) { |
| Message n = p.next; |
| if (n != null) { |
| if (n.target == h && (object == null || n.obj == object)) { |
| Message nn = n.next; |
| n.recycle(); |
| p.next = nn; |
| continue; |
| } |
| } |
| p = n; |
| } |
| } |
| } |
| |
| /* |
| private void dumpQueue_l() |
| { |
| Message p = mMessages; |
| System.out.println(this + " queue is:"); |
| while (p != null) { |
| System.out.println(" " + p); |
| p = p.next; |
| } |
| } |
| */ |
| } |