core/java/android/os/Looper.java - platform/frameworks/base - Gitiles

 /*
  * 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.Config;
 import android.util.Log;
 import android.util.Printer;
 import android.util.PrefixPrinter;

 /**
   * Class used to run a message loop for a thread.  Threads by default do
   * not have a message loop associated with them; to create one, call
   * {@link #prepare} in the thread that is to run the loop, and then
   * {@link #loop} to have it process messages until the loop is stopped.
   *
   * <p>Most interaction with a message loop is through the
   * {@link Handler} class.
   *
   * <p>This is a typical example of the implementation of a Looper thread,
   * using the separation of {@link #prepare} and {@link #loop} to create an
   * initial Handler to communicate with the Looper.
   *
   * <pre>
   *  class LooperThread extends Thread {
   *      public Handler mHandler;
   *
   *      public void run() {
   *          Looper.prepare();
   *
   *          mHandler = new Handler() {
   *              public void handleMessage(Message msg) {
   *                  // process incoming messages here
   *              }
   *          };
   *
   *          Looper.loop();
   *      }
   *  }</pre>
   */
 public class Looper {
     private static final String TAG = "Looper";
     private static final boolean LOG_V = Log.isLoggable(TAG, Log.VERBOSE);

     // sThreadLocal.get() will return null unless you've called prepare().
     private static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

     final MessageQueue mQueue;
     final Thread mThread;
     volatile boolean mRun;

     private Printer mLogging = null;
     private static Looper mMainLooper = null;  // guarded by Looper.class

      /** Initialize the current thread as a looper.
       * This gives you a chance to create handlers that then reference
       * this looper, before actually starting the loop. Be sure to call
       * {@link #loop()} after calling this method, and end it by calling
       * {@link #quit()}.
       */
     public static final void prepare() {
         if (sThreadLocal.get() != null) {
             throw new RuntimeException("Only one Looper may be created per thread");
         }
         sThreadLocal.set(new Looper());
     }

     /**
      * Initialize the current thread as a looper, marking it as an
      * application's main looper. The main looper for your application
      * is created by the Android environment, so you should never need
      * to call this function yourself.  See also: {@link #prepare()}
      */
     public static final void prepareMainLooper() {
         prepare();
         setMainLooper(myLooper());
         if (Process.supportsProcesses()) {
             myLooper().mQueue.mQuitAllowed = false;
         }
     }

     private synchronized static void setMainLooper(Looper looper) {
         mMainLooper = looper;
     }

     /** Returns the application's main looper, which lives in the main thread of the application.
      */
     public synchronized static final Looper getMainLooper() {
         return mMainLooper;
     }

     /**
      * Run the message queue in this thread. Be sure to call
      * {@link #quit()} to end the loop.
      */
     public static final void loop() {
         Looper me = myLooper();
         if (me == null) {
             throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
         }
         MessageQueue queue = me.mQueue;

         // Make sure the identity of this thread is that of the local process,
         // and keep track of what that identity token actually is.
         Binder.clearCallingIdentity();
         final long ident = Binder.clearCallingIdentity();

         while (true) {
             Message msg = queue.next(); // might block
             if (msg != null) {
                 if (msg.target == null) {
                     // No target is a magic identifier for the quit message.
                     return;
                 }
                 if (me.mLogging != null) me.mLogging.println(
                         ">>>>> Dispatching to " + msg.target + " "
                         + msg.callback + ": " + msg.what
                         );
                 msg.target.dispatchMessage(msg);
                 if (me.mLogging != null) me.mLogging.println(
                         "<<<<< Finished to    " + msg.target + " "
                         + msg.callback);

                 // Make sure that during the course of dispatching the
                 // identity of the thread wasn't corrupted.
                 final long newIdent = Binder.clearCallingIdentity();
                 if (ident != newIdent) {
                     Log.wtf("Looper", "Thread identity changed from 0x"
                             + Long.toHexString(ident) + " to 0x"
                             + Long.toHexString(newIdent) + " while dispatching to "
                             + msg.target.getClass().getName() + " "
                             + msg.callback + " what=" + msg.what);
                 }

                 msg.recycle();
             }
         }
     }

     /**
      * Return the Looper object associated with the current thread.  Returns
      * null if the calling thread is not associated with a Looper.
      */
     public static final Looper myLooper() {
         return sThreadLocal.get();
     }

     /**
      * Control logging of messages as they are processed by this Looper.  If
      * enabled, a log message will be written to <var>printer</var>
      * at the beginning and ending of each message dispatch, identifying the
      * target Handler and message contents.
      *
      * @param printer A Printer object that will receive log messages, or
      * null to disable message logging.
      */
     public void setMessageLogging(Printer printer) {
         mLogging = printer;
     }

     /**
      * Return the {@link MessageQueue} object associated with the current
      * thread.  This must be called from a thread running a Looper, or a
      * NullPointerException will be thrown.
      */
     public static final MessageQueue myQueue() {
         return myLooper().mQueue;
     }

     private Looper() {
         mQueue = new MessageQueue();
         mRun = true;
         mThread = Thread.currentThread();
     }

     public void quit() {
         Message msg = Message.obtain();
         // NOTE: By enqueueing directly into the message queue, the
         // message is left with a null target.  This is how we know it is
         // a quit message.
         mQueue.enqueueMessage(msg, 0);
     }

     /**
      * Return the Thread associated with this Looper.
      */
     public Thread getThread() {
         return mThread;
     }

     /** @hide */
     public MessageQueue getQueue() {
         return mQueue;
     }

     public void dump(Printer pw, String prefix) {
         pw = PrefixPrinter.create(pw, prefix);
         pw.println(this.toString());
         pw.println("mRun=" + mRun);
         pw.println("mThread=" + mThread);
         pw.println("mQueue=" + ((mQueue != null) ? mQueue : "(null"));
         if (mQueue != null) {
             synchronized (mQueue) {
                 long now = SystemClock.uptimeMillis();
                 Message msg = mQueue.mMessages;
                 int n = 0;
                 while (msg != null) {
                     pw.println("  Message " + n + ": " + msg.toString(now));
                     n++;
                     msg = msg.next;
                 }
                 pw.println("(Total messages: " + n + ")");
             }
         }
     }

     public String toString() {
         return "Looper{"
             + Integer.toHexString(System.identityHashCode(this))
             + "}";
     }

     static class HandlerException extends Exception {

         HandlerException(Message message, Throwable cause) {
             super(createMessage(cause), cause);
         }

         static String createMessage(Throwable cause) {
             String causeMsg = cause.getMessage();
             if (causeMsg == null) {
                 causeMsg = cause.toString();
             }
             return causeMsg;
         }
     }
 }
	/*
	* 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.Config;
	import android.util.Log;
	import android.util.Printer;
	import android.util.PrefixPrinter;

	/**
	* Class used to run a message loop for a thread. Threads by default do
	* not have a message loop associated with them; to create one, call
	* {@link #prepare} in the thread that is to run the loop, and then
	* {@link #loop} to have it process messages until the loop is stopped.
	*
	* <p>Most interaction with a message loop is through the
	* {@link Handler} class.
	*
	* <p>This is a typical example of the implementation of a Looper thread,
	* using the separation of {@link #prepare} and {@link #loop} to create an
	* initial Handler to communicate with the Looper.
	*
	* <pre>
	* class LooperThread extends Thread {
	* public Handler mHandler;
	*
	* public void run() {
	* Looper.prepare();
	*
	* mHandler = new Handler() {
	* public void handleMessage(Message msg) {
	* // process incoming messages here
	* }
	* };
	*
	* Looper.loop();
	* }
	* }</pre>
	*/
	public class Looper {
	private static final String TAG = "Looper";
	private static final boolean LOG_V = Log.isLoggable(TAG, Log.VERBOSE);

	// sThreadLocal.get() will return null unless you've called prepare().
	private static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

	final MessageQueue mQueue;
	final Thread mThread;
	volatile boolean mRun;

	private Printer mLogging = null;
	private static Looper mMainLooper = null; // guarded by Looper.class

	/** Initialize the current thread as a looper.
	* This gives you a chance to create handlers that then reference
	* this looper, before actually starting the loop. Be sure to call
	* {@link #loop()} after calling this method, and end it by calling
	* {@link #quit()}.
	*/
	public static final void prepare() {
	if (sThreadLocal.get() != null) {
	throw new RuntimeException("Only one Looper may be created per thread");
	}
	sThreadLocal.set(new Looper());
	}

	/**
	* Initialize the current thread as a looper, marking it as an
	* application's main looper. The main looper for your application
	* is created by the Android environment, so you should never need
	* to call this function yourself. See also: {@link #prepare()}
	*/
	public static final void prepareMainLooper() {
	prepare();
	setMainLooper(myLooper());
	if (Process.supportsProcesses()) {
	myLooper().mQueue.mQuitAllowed = false;
	}
	}

	private synchronized static void setMainLooper(Looper looper) {
	mMainLooper = looper;
	}

	/** Returns the application's main looper, which lives in the main thread of the application.
	*/
	public synchronized static final Looper getMainLooper() {
	return mMainLooper;
	}

	/**
	* Run the message queue in this thread. Be sure to call
	* {@link #quit()} to end the loop.
	*/
	public static final void loop() {
	Looper me = myLooper();
	if (me == null) {
	throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
	}
	MessageQueue queue = me.mQueue;

	// Make sure the identity of this thread is that of the local process,
	// and keep track of what that identity token actually is.
	Binder.clearCallingIdentity();
	final long ident = Binder.clearCallingIdentity();

	while (true) {
	Message msg = queue.next(); // might block
	if (msg != null) {
	if (msg.target == null) {
	// No target is a magic identifier for the quit message.
	return;
	}
	if (me.mLogging != null) me.mLogging.println(
	">>>>> Dispatching to " + msg.target + " "
	+ msg.callback + ": " + msg.what
	);
	msg.target.dispatchMessage(msg);
	if (me.mLogging != null) me.mLogging.println(
	"<<<<< Finished to " + msg.target + " "
	+ msg.callback);

	// Make sure that during the course of dispatching the
	// identity of the thread wasn't corrupted.
	final long newIdent = Binder.clearCallingIdentity();
	if (ident != newIdent) {
	Log.wtf("Looper", "Thread identity changed from 0x"
	+ Long.toHexString(ident) + " to 0x"
	+ Long.toHexString(newIdent) + " while dispatching to "
	+ msg.target.getClass().getName() + " "
	+ msg.callback + " what=" + msg.what);
	}

	msg.recycle();
	}
	}
	}

	/**
	* Return the Looper object associated with the current thread. Returns
	* null if the calling thread is not associated with a Looper.
	*/
	public static final Looper myLooper() {
	return sThreadLocal.get();
	}

	/**
	* Control logging of messages as they are processed by this Looper. If
	* enabled, a log message will be written to <var>printer</var>
	* at the beginning and ending of each message dispatch, identifying the
	* target Handler and message contents.
	*
	* @param printer A Printer object that will receive log messages, or
	* null to disable message logging.
	*/
	public void setMessageLogging(Printer printer) {
	mLogging = printer;
	}

	/**
	* Return the {@link MessageQueue} object associated with the current
	* thread. This must be called from a thread running a Looper, or a
	* NullPointerException will be thrown.
	*/
	public static final MessageQueue myQueue() {
	return myLooper().mQueue;
	}

	private Looper() {
	mQueue = new MessageQueue();
	mRun = true;
	mThread = Thread.currentThread();
	}

	public void quit() {
	Message msg = Message.obtain();
	// NOTE: By enqueueing directly into the message queue, the
	// message is left with a null target. This is how we know it is
	// a quit message.
	mQueue.enqueueMessage(msg, 0);
	}

	/**
	* Return the Thread associated with this Looper.
	*/
	public Thread getThread() {
	return mThread;
	}

	/** @hide */
	public MessageQueue getQueue() {
	return mQueue;
	}

	public void dump(Printer pw, String prefix) {
	pw = PrefixPrinter.create(pw, prefix);
	pw.println(this.toString());
	pw.println("mRun=" + mRun);
	pw.println("mThread=" + mThread);
	pw.println("mQueue=" + ((mQueue != null) ? mQueue : "(null"));
	if (mQueue != null) {
	synchronized (mQueue) {
	long now = SystemClock.uptimeMillis();
	Message msg = mQueue.mMessages;
	int n = 0;
	while (msg != null) {
	pw.println(" Message " + n + ": " + msg.toString(now));
	n++;
	msg = msg.next;
	}
	pw.println("(Total messages: " + n + ")");
	}
	}
	}

	public String toString() {
	return "Looper{"
	+ Integer.toHexString(System.identityHashCode(this))
	+ "}";
	}

	static class HandlerException extends Exception {

	HandlerException(Message message, Throwable cause) {
	super(createMessage(cause), cause);
	}

	static String createMessage(Throwable cause) {
	String causeMsg = cause.getMessage();
	if (causeMsg == null) {
	causeMsg = cause.toString();
	}
	return causeMsg;
	}
	}
	}