core/java/android/os/MessageQueue.java - platform/frameworks/base - Git at Google

 /*
  * 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.Config;
 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 (Config.LOGV) 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;
         }
     }
     */
 }
	/*
	* 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.Config;
	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 (Config.LOGV) 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;
	}
	}
	*/
	}