Package icyllis.modernui.core

# Class Looper

java.lang.Object
icyllis.modernui.core.Looper

public final class Looper extends 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 `prepareMainLooper()` in the thread that is to run the loop, and then `loop()` to have it process messages until the loop is stopped.

Most interaction with a message loop is through the `Handler` class.

Modified from Android Open Source Project.

- ## Nested Class Summary

  Nested Classes
  Modifier and Type
  Class
  Description
  `static interface`
  `Looper.Observer`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `static Looper`
  `getMainLooper()`
  Returns the application's main looper, which lives in the main thread of the application.
  `MessageQueue`
  `getQueue()`
  Gets this looper's message queue.
  `Thread`
  `getThread()`
  Gets the Thread associated with this Looper.
  `boolean`
  `isCurrentThread()`
  Returns true if the current thread is this looper's thread.
  `static void`
  `loop()`
  Run the message queue in this thread.
  `static Looper`
  `myLooper()`
  Return the Looper object associated with the current thread.
  `static MessageQueue`
  `myQueue()`
  Return the `MessageQueue` object associated with the current thread.
  `static Looper`
  `prepare()`
  Initialize the current thread as a looper.
  `static void`
  `prepareMainLooper()`
  Prepare the main event loop.
  `void`
  `quit()`
  Quits the looper.
  `void`
  `quitSafely()`
  Quits the looper safely.
  `static void`
  `setObserver(Looper.Observer observer)`
  Set the transaction observer for all Loopers in this process.
  `void`
  `setSlowLogThresholdMs(long slowDispatchThresholdMs, long slowDeliveryThresholdMs)`
  Set a thresholds for slow dispatch/delivery log.
  `String`
  `toString()`

  ### Methods inherited from class java.lang.Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- ## Method Details

  - ### prepare

    @NonNull public static Looper prepare()
    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 `loop()` after calling this method, and end it by calling `quit()`.

    Throws:
      `RuntimeException` - initializes twice

  - ### prepareMainLooper

    @Internal @MainThread public static void prepareMainLooper()
    Prepare the main event loop. This must be called from the entry point of the application.

  - ### getMainLooper

    public static Looper getMainLooper()
    Returns the application's main looper, which lives in the main thread of the application.

  - ### setObserver

    public static void setObserver(@Nullable Looper.Observer observer)
    Set the transaction observer for all Loopers in this process.

  - ### loop

    public static void loop()
    Run the message queue in this thread. Be sure to call `quit()` to end the loop.

  - ### myLooper

    @Nullable public static Looper myLooper()
    Return the Looper object associated with the current thread. Returns null if the calling thread is not associated with a Looper.

  - ### myQueue

    @NonNull public static MessageQueue myQueue()
    Return the `MessageQueue` object associated with the current thread.
    Throws:
      `NullPointerException` - not called from a thread running a Looper

  - ### isCurrentThread

    public boolean isCurrentThread()
    Returns true if the current thread is this looper's thread.

  - ### setSlowLogThresholdMs

    public void setSlowLogThresholdMs(long slowDispatchThresholdMs, long slowDeliveryThresholdMs)
    Set a thresholds for slow dispatch/delivery log.

  - ### quit

    public void quit()
    Quits the looper.

    Causes the `loop()` method to terminate without processing any more messages in the message queue.

    Any attempt to post messages to the queue after the looper is asked to quit will fail. For example, the `Handler.sendMessage(Message)` method will return false.

    Using this method may be unsafe because some messages may not be delivered before the looper terminates. Consider using `quitSafely()` instead to ensure that all pending work is completed in an orderly manner.

    See Also:
      - `quitSafely()`

  - ### quitSafely

    public void quitSafely()
    Quits the looper safely.

    Causes the `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.

    Any attempt to post messages to the queue after the looper is asked to quit will fail. For example, the `Handler.sendMessage(Message)` method will return false.

  - ### getThread

    @NonNull public Thread getThread()
    Gets the Thread associated with this Looper.
    Returns:
      The looper's thread.

  - ### getQueue

    @NonNull public MessageQueue getQueue()
    Gets this looper's message queue.
    Returns:
      The looper's message queue.

  - ### toString

    @NonNull public String toString()
    Overrides:
      `toString` in class `Object`