/**@class android.os.Looper
@extends java.lang.Object

 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 android.os.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>
*/
var Looper = {

/**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}().
*/
prepare : function(  ) {},

/**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}()
*/
prepareMainLooper : function(  ) {},

/**Returns the application's main looper, which lives in the main thread of the application.
*/
getMainLooper : function(  ) {},

/**Set the transaction observer for all Loopers in this process.
@hide 
*/
setObserver : function(  ) {},

/**Run the message queue in this thread. Be sure to call
 {@link #quit}() to end the loop.
*/
loop : function(  ) {},

/**Return the Looper object associated with the current thread.  Returns
 null if the calling thread is not associated with a Looper.
*/
myLooper : function(  ) {},

/**Return the {@link android.os.MessageQueue} object associated with the current
 thread.  This must be called from a thread running a Looper, or a
 NullPointerException will be thrown.
*/
myQueue : function(  ) {},

/**Returns true if the current thread is this looper's thread.
*/
isCurrentThread : function(  ) {},

/**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 {Object {Printer}} printer A Printer object that will receive log messages, or
 null to disable message logging.
*/
setMessageLogging : function(  ) {},

/**{@hide}
*/
setTraceTag : function(  ) {},

/**Set a thresholds for slow dispatch/delivery log.
 {@hide}
*/
setSlowLogThresholdMs : function(  ) {},

/**Quits the looper.
 <p>
 Causes the {@link #loop} method to terminate without processing any
 more messages in the message queue.
 </p><p>
 Any attempt to post messages to the queue after the looper is asked to quit will fail.
 For example, the {@link android.os.Handler#sendMessage(Message)} method will return false.
 </p><p class="note">
 Using this method may be unsafe because some messages may not be delivered
 before the looper terminates.  Consider using {@link #quitSafely} instead to ensure
 that all pending work is completed in an orderly manner.
 </p>
@see #quitSafely
*/
quit : function(  ) {},

/**Quits the looper safely.
 <p>
 Causes the {@link #loop} method to terminate as soon as all remaining messages
 in the message queue that are already due to be delivered have been handled.
 However pending delayed messages with due times in the future will not be
 delivered before the loop terminates.
 </p><p>
 Any attempt to post messages to the queue after the looper is asked to quit will fail.
 For example, the {@link android.os.Handler#sendMessage(Message)} method will return false.
 </p>
*/
quitSafely : function(  ) {},

/**Gets the Thread associated with this Looper.
@return {Object {java.lang.Thread}} The looper's thread.
*/
getThread : function(  ) {},

/**Gets this looper's message queue.
@return {Object {android.os.MessageQueue}} The looper's message queue.
*/
getQueue : function(  ) {},

/**Dumps the state of the looper for debugging purposes.
@param {Object {Printer}} pw A printer to receive the contents of the dump.
@param {String} prefix A prefix to prepend to each line which is printed.
*/
dump : function(  ) {},

/**Dumps the state of the looper for debugging purposes.
@param {Object {Printer}} pw A printer to receive the contents of the dump.
@param {String} prefix A prefix to prepend to each line which is printed.
@param {Object {Handler}} handler Only dump messages for this Handler.
@hide 
*/
dump : function(  ) {},

/**
@hide 
*/
writeToProto : function(  ) {},

/**
*/
toString : function(  ) {},


};