/**
 * A Handler allows you to send and process {@link Message} and Runnable
 * objects associated with a thread's {@link MessageQueue}.  Each Handler
 * instance is associated with a single thread and that thread's message
 * queue.  When you create a new Handler, it is bound to the thread /
 * message queue of the thread that is creating it -- from that point on,
 * it will deliver messages and runnables to that message queue and execute
 * them as they come out of the message queue.
 * 
 * <p>There are two main uses for a Handler: (1) to schedule messages and
 * runnables to be executed at some point in the future; and (2) to enqueue
 * an action to be performed on a different thread than your own.
 * 
 * <p>Scheduling messages is accomplished with the
 * {@link #post}, {@link #postAtTime(Runnable, long)},
 * {@link #postDelayed}, {@link #sendEmptyMessage},
 * {@link #sendMessage}, {@link #sendMessageAtTime}, and
 * {@link #sendMessageDelayed} methods.  The <em>post</em> versions allow
 * you to enqueue Runnable objects to be called by the message queue when
 * they are received; the <em>sendMessage</em> versions allow you to enqueue
 * a {@link Message} object containing a bundle of data that will be
 * processed by the Handler's {@link #handleMessage} method (requiring that
 * you implement a subclass of Handler).
 * 
 * <p>When posting or sending to a Handler, you can either
 * allow the item to be processed as soon as the message queue is ready
 * to do so, or specify a delay before it gets processed or absolute time for
 * it to be processed.  The latter two allow you to implement timeouts,
 * ticks, and other timing-based behavior.
 * 
 * <p>When a
 * process is created for your application, its main thread is dedicated to
 * running a message queue that takes care of managing the top-level
 * application objects (activities, broadcast receivers, etc) and any windows
 * they create.  You can create your own threads, and communicate back with
 * the main application thread through a Handler.  This is done by calling
 * the same <em>post</em> or <em>sendMessage</em> methods as before, but from
 * your new thread.  The given Runnable or Message will then be scheduled
 * in the Handler's message queue and processed when appropriate.
 */

/**
  * Default constructor associates this handler with the {@link Looper} for the
  * current thread.
  *
  * If this thread does not have a looper, this handler won't be able to receive messages
  * so an exception is thrown.
  */
public Handler() {
    this(null, false);
}

/**
  * Constructor associates this handler with the {@link Looper} for the
  * current thread and takes a callback interface in which you can handle
  * messages.
  *
  * If this thread does not have a looper, this handler won't be able to receive messages
  * so an exception is thrown.
  *
  * @param callback The callback interface in which to handle messages, or null.
  */
public Handler(@Nullable Callback callback) {
    this(callback, false);
}

/**
  * Use the {@link Looper} for the current thread
  * and set whether the handler should be asynchronous.
  *
  * Handlers are synchronous by default unless this constructor is used to make
  * one that is strictly asynchronous.
  *
  * Asynchronous messages represent interrupts or events that do not require global ordering
  * with respect to synchronous messages.  Asynchronous messages are not subject to
  * the synchronization barriers introduced by {@link MessageQueue#enqueueSyncBarrier(long)}.
  *
  * @param async If true, the handler calls {@link Message#setAsynchronous(boolean)} for
  * each {@link Message} that is sent to it or {@link Runnable} that is posted to it.
  *
  * @hide
  */
@UnsupportedAppUsage
public Handler(boolean async) {
    this(null, async);
}

/**
  * Use the {@link Looper} for the current thread with the specified callback interface
  * and set whether the handler should be asynchronous.
  *
  * Handlers are synchronous by default unless this constructor is used to make
  * one that is strictly asynchronous.
  *
  * Asynchronous messages represent interrupts or events that do not require global ordering
  * with respect to synchronous messages.  Asynchronous messages are not subject to
  * the synchronization barriers introduced by {@link MessageQueue#enqueueSyncBarrier(long)}.
  *
  * @param callback The callback interface in which to handle messages, or null.
  * @param async If true, the handler calls {@link Message#setAsynchronous(boolean)} for
  * each {@link Message} that is sent to it or {@link Runnable} that is posted to it.
  *
  * @hide
  */
public Handler(@Nullable Callback callback, boolean async) {
    if (FIND_POTENTIAL_LEAKS) {
        final Class<? extends Handler> klass = getClass();
        if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
                (klass.getModifiers() & Modifier.STATIC) == 0) {
            Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
                klass.getCanonicalName());
        }
    }

    mLooper = Looper.myLooper();
    if (mLooper == null) {
        throw new RuntimeException(
            "Can't create handler inside thread " + Thread.currentThread()
                    + " that has not called Looper.prepare()");
    }
    mQueue = mLooper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
}

/**
  * Use the provided {@link Looper} instead of the default one.
  *
  * @param looper The looper, must not be null.
  */
public Handler(@NonNull Looper looper) {
    this(looper, null, false);
}

Handler handler = new Handler(Looper.getMainLooper());

/**
  * Use the provided {@link Looper} instead of the default one and take a callback
  * interface in which to handle messages.
  *
  * @param looper The looper, must not be null.
  * @param callback The callback interface in which to handle messages, or null.
  */
public Handler(@NonNull Looper looper, @Nullable Callback callback) {
    this(looper, callback, false);
}

/**
  * Use the provided {@link Looper} instead of the default one and take a callback
  * interface in which to handle messages.  Also set whether the handler
  * should be asynchronous.
  *
  * Handlers are synchronous by default unless this constructor is used to make
  * one that is strictly asynchronous.
  *
  * Asynchronous messages represent interrupts or events that do not require global ordering
  * with respect to synchronous messages.  Asynchronous messages are not subject to
  * the synchronization barriers introduced by conditions such as display vsync.
  *
  * @param looper The looper, must not be null.
  * @param callback The callback interface in which to handle messages, or null.
  * @param async If true, the handler calls {@link Message#setAsynchronous(boolean)} for
  * each {@link Message} that is sent to it or {@link Runnable} that is posted to it.
  *
  * @hide
  */
@UnsupportedAppUsage
public Handler(@NonNull Looper looper, @Nullable Callback callback, boolean async) {
    mLooper = looper;
    mQueue = looper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
}

// 默认
public final boolean post(@NonNull Runnable r) {
    return  sendMessageDelayed(getPostMessage(r), 0);
}

// Delayed
public final boolean postDelayed(@NonNull Runnable r, long delayMillis) {
    return sendMessageDelayed(getPostMessage(r), delayMillis);
}
/** @hide */
public final boolean postDelayed(Runnable r, int what, long delayMillis) {
    return sendMessageDelayed(getPostMessage(r).setWhat(what), delayMillis);
}
public final boolean postDelayed(@NonNull Runnable r, @Nullable Object token, long delayMillis) {
    return sendMessageDelayed(getPostMessage(r, token), delayMillis);
}

// AtTime
public final boolean postAtTime(@NonNull Runnable r, long uptimeMillis) {
    return sendMessageAtTime(getPostMessage(r), uptimeMillis);
}
public final boolean postAtTime(@NonNull Runnable r, @Nullable Object token, long uptimeMillis) {
    return sendMessageAtTime(getPostMessage(r, token), uptimeMillis);
}

// AtFrontOfQueue
public final boolean postAtFrontOfQueue(@NonNull Runnable r) {
    return sendMessageAtFrontOfQueue(getPostMessage(r));
}

public final boolean sendMessage(@NonNull Message msg) {
    return sendMessageDelayed(msg, 0);
}

public final boolean sendEmptyMessage(int what) {
    return sendEmptyMessageDelayed(what, 0);
}

public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
    Message msg = Message.obtain();
    msg.what = what;
    return sendMessageDelayed(msg, delayMillis);
}

public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {
    Message msg = Message.obtain();
    msg.what = what;
    return sendMessageAtTime(msg, uptimeMillis);
}

public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis) {
    if (delayMillis < 0) {
        delayMillis = 0;
    }
    return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}

public boolean sendMessageAtTime(@NonNull Message msg, long uptimeMillis) {
    MessageQueue queue = mQueue;
    if (queue == null) {
        RuntimeException e = new RuntimeException(
                this + " sendMessageAtTime() called with no mQueue");
        Log.w("Looper", e.getMessage(), e);
        return false;
    }
    return enqueueMessage(queue, msg, uptimeMillis);
}

public final boolean sendMessageAtFrontOfQueue(@NonNull Message msg) {
    MessageQueue queue = mQueue;
    if (queue == null) {
        RuntimeException e = new RuntimeException(
            this + " sendMessageAtTime() called with no mQueue");
        Log.w("Looper", e.getMessage(), e);
        return false;
    }
    return enqueueMessage(queue, msg, 0);
}

private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg, long uptimeMillis) {
    msg.target = this;
    msg.workSourceUid = ThreadLocalWorkSource.getUid();

    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);
}