Handler源码翻译

一直以为Handler类肯定很庞大，结果打开源码一看，，，都是骗人的，庞大的不是代码，是英文注释。。。

好吧，那我们先从这庞大的英文注释开始，用我蹩脚的英文为大家翻译一下。如有不妥之处，欢迎之处，批评，嘲笑，更正o(╯□╰)o

还没翻译完，回头再翻译。

/* * 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 com.example.myapp;import android.os.Binder;import android.os.Looper;import android.os.Message;import android.os.MessageQueue;import android.os.SystemClock;import android.util.Log;import android.util.Printer;import java.lang.reflect.Modifier;/** * 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. * * 翻译： * Handler允许你发送处理消息，以及发送一个与线程的MessageQueue(消息队列)向关联的Runnable接口对象。 * 每个Handler实例与线程和这个线程的消息队列相关联。当你创建一个Handler，它被绑定到创建它的线程的消息队列。 * 从这一点来说，它会传递消息和runnable到消息队列，以及执行这些内容。 * * * <p>There are two main uses for a Handler: (1) to schedule messages and * runnables to be executed as some point in the future; and (2) to enqueue * an action to be performed on a different thread than your own. * * 翻译： * Handler有两个主要用途： * 1.调度消息和在未来某个时刻被执行的Runnable * 2.将和handler所处线程不同的操作入队 * * <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). * * 翻译： * 调度信息通过以下方法实现： * 1、post * 2.postAtTime * 3.postDelayed * 4.sendEmptyMessage * 5.sendMessage * 6.sendMessageAtTime * 7.sendMessageDelay * post允许： * 当接受到runnable对象的时候入队runnable对象到消息队列 * sendMessage允许： * 入队一个被handler的handleMessage方法执行的包含bundle数据的对象 * * <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. * * 翻译: * 当post或者send到一个Handler,你既可以一旦消息队列准备就绪就立即处理，也可以延迟处理。 * * <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. * * 翻译： * 当你的应用程序创建一个进程，它的主线程运行的消息队列专门用于管理应用顶级的对象（活动，广播接收器等），以及他们创建的窗口。 * 你可以创建自己的线程，并且通过Handler回传消息给主线程。和之前一样也是通过post，sendMessage等方法。 * 给定的Runnable或消息随后将在适当的时候在Handler的消息队列被调度和处理。 * */public class Handler {    /*     * Set this flag to true to detect anonymous, local or member classes     * that extend this Handler class and that are not static. These kind     * of classes can potentially create leaks.     *     * 翻译：     * 此标志设置为true，以检测继承Handler的不是静态的匿名，本地或成员类。这些类型的类可能创造潜在的泄漏。     */    private static final boolean FIND_POTENTIAL_LEAKS = false;    private static final String TAG = "Handler";    /**     * Callback interface you can use when instantiating a Handler to avoid     * having to implement your own subclass of Handler.     *     * @param msg A {@link android.os.Message Message} object     * @return True if no further handling is desired     */    public interface Callback {        public boolean handleMessage(Message msg);    }        /**     * Subclasses must implement this to receive messages.     *     * 子类必须实现这个方法来接受消息     */    public void handleMessage(Message msg) {    }        /**     * Handle system messages here.     * 这里处理系统消息     *     */    public void dispatchMessage(Message msg) {        if (msg.callback != null) {            handleCallback(msg);        } else {            if (mCallback != null) {                if (mCallback.handleMessage(msg)) {                    return;                }            }            handleMessage(msg);        }    }    /**     * Default constructor associates this handler with the {@link Looper} for the     * current thread.     *     * 默认的构造函数与当前线程的looper相关联     *     * If this thread does not have a looper, this handler won't be able to receive messages     * so an exception is thrown.     *     * 如果线程没有looper，handler不能接受消息，同时会抛出异常     */    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.     *     * 同上面的构造函数，但是多了callback     *     * 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(Callback callback) {        this(callback, false);    }    /**     * Use the provided {@link Looper} instead of the default one.     *     * 用给的looper代替默认的looper     *     * @param looper The looper, must not be null.     */    public Handler(Looper looper) {        this(looper, null, false);    }    /**     * Use the provided {@link Looper} instead of the default one and take a callback     * interface in which to handle messages.     *     * 同上，用给的looper以及回调     *     * @param looper The looper, must not be null.     * @param callback The callback interface in which to handle messages, or null.     */    public Handler(Looper looper, Callback callback) {        this(looper, callback, false);    }    /**     * Use the {@link Looper} for the current thread     * and set whether the handler should be asynchronous.     *     * 用当前线程的looper，以及设置handler是否应该是异步的     *     * 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.     * true异步。     * @hide     */    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(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 that has not called Looper.prepare()");        }        mQueue = mLooper.mQueue;        mCallback = callback;        mAsynchronous = async;    }    /**     * 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 {@link MessageQueue#enqueueSyncBarrier(long)}.     *     * @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     */    public Handler(Looper looper, Callback callback, boolean async) {        mLooper = looper;        mQueue = looper.mQueue;        mCallback = callback;        mAsynchronous = async;    }    /**     * Returns a string representing the name of the specified message.     * The default implementation will either return the class name of the     * message callback if any, or the hexadecimal representation of the     * message "what" field.     *     *  返回表示指定的消息名称的字符串。默认的实现要么返回消息回调（如有）或消息“是什么”字段的十六进制表示的类名。     *     * @param message The message whose name is being queried      */    public String getMessageName(Message message) {        if (message.callback != null) {            return message.callback.getClass().getName();        }        return "0x" + Integer.toHexString(message.what);    }    /**     * Returns a new {@link android.os.Message Message} from the global message pool. More efficient than     * creating and allocating new instances. The retrieved message has its handler set to this instance (Message.target == this).     *  If you don't want that facility, just call Message.obtain() instead.     *     *  从消息池中拿来一个msg 不需要另开辟空间 ，new需要重新申请，效率低，obtainMessage可以循环利用     */    public final Message obtainMessage()    {        return Message.obtain(this);    }    /**     * Same as {@link #obtainMessage()}, except that it also sets the what member of the returned Message.     *      * @param what Value to assign to the returned Message.what field.     * @return A Message from the global message pool.     */    public final Message obtainMessage(int what)    {        return Message.obtain(this, what);    }        /**     *      * Same as {@link #obtainMessage()}, except that it also sets the what and obj members      * of the returned Message.     *      * @param what Value to assign to the returned Message.what field.     * @param obj Value to assign to the returned Message.obj field.     * @return A Message from the global message pool.     */    public final Message obtainMessage(int what, Object obj)    {        return Message.obtain(this, what, obj);    }    /**     *      * Same as {@link #obtainMessage()}, except that it also sets the what, arg1 and arg2 members of the returned     * Message.     * @param what Value to assign to the returned Message.what field.     * @param arg1 Value to assign to the returned Message.arg1 field.     * @param arg2 Value to assign to the returned Message.arg2 field.     * @return A Message from the global message pool.     */    public final Message obtainMessage(int what, int arg1, int arg2)    {        return Message.obtain(this, what, arg1, arg2);    }        /**     *      * Same as {@link #obtainMessage()}, except that it also sets the what, obj, arg1,and arg2 values on the      * returned Message.     * @param what Value to assign to the returned Message.what field.     * @param arg1 Value to assign to the returned Message.arg1 field.     * @param arg2 Value to assign to the returned Message.arg2 field.     * @param obj Value to assign to the returned Message.obj field.     * @return A Message from the global message pool.     */    public final Message obtainMessage(int what, int arg1, int arg2, Object obj)    {        return Message.obtain(this, what, arg1, arg2, obj);    }    /**     * Causes the Runnable r to be added to the message queue.     * The runnable will be run on the thread to which this handler is      * attached.      *     *  把Runnable添加到消息队列。Runnable将被handler所在的线程run     *     * @param r The Runnable that will be executed.     *      * @return Returns true if the Runnable was successfully placed in to the      *         message queue.  Returns false on failure, usually because the     *         looper processing the message queue is exiting.     */    public final boolean post(Runnable r)    {       return  sendMessageDelayed(getPostMessage(r), 0);    }        /**     * Causes the Runnable r to be added to the message queue, to be run     * at a specific time given by <var>uptimeMillis</var>.     * <b>The time-base is {@link android.os.SystemClock#uptimeMillis}.</b>     * Time spent in deep sleep will add an additional delay to execution.     * The runnable will be run on the thread to which this handler is attached.     *     * 把Runnable添加到消息队列。Runnable将被handler所在的线程在指定的时刻后run     * 注意时间基数是uptimeMillis().     * sleep花费的时间将添加一个额外的延迟     *     * @param r The Runnable that will be executed.     * @param uptimeMillis The absolute time at which the callback should run,     *         using the {@link android.os.SystemClock#uptimeMillis} time-base.     *       * @return Returns true if the Runnable was successfully placed in to the      *         message queue.  Returns false on failure, usually because the     *         looper processing the message queue is exiting.  Note that a     *         result of true does not mean the Runnable will be processed -- if     *         the looper is quit before the delivery time of the message     *         occurs then the message will be dropped.     */    public final boolean postAtTime(Runnable r, long uptimeMillis)    {        return sendMessageAtTime(getPostMessage(r), uptimeMillis);    }        /**     * Causes the Runnable r to be added to the message queue, to be run     * at a specific time given by <var>uptimeMillis</var>.     * <b>The time-base is {@link android.os.SystemClock#uptimeMillis}.</b>     * Time spent in deep sleep will add an additional delay to execution.     * The runnable will be run on the thread to which this handler is attached.     *     * @param r The Runnable that will be executed.     * @param uptimeMillis The absolute time at which the callback should run,     *         using the {@link android.os.SystemClock#uptimeMillis} time-base.     *      * @return Returns true if the Runnable was successfully placed in to the      *         message queue.  Returns false on failure, usually because the     *         looper processing the message queue is exiting.  Note that a     *         result of true does not mean the Runnable will be processed -- if     *         the looper is quit before the delivery time of the message     *         occurs then the message will be dropped.     *              * @see android.os.SystemClock#uptimeMillis     */    public final boolean postAtTime(Runnable r, Object token, long uptimeMillis)    {        return sendMessageAtTime(getPostMessage(r, token), uptimeMillis);    }        /**     * Causes the Runnable r to be added to the message queue, to be run     * after the specified amount of time elapses.     * The runnable will be run on the thread to which this handler     * is attached.     * <b>The time-base is {@link android.os.SystemClock#uptimeMillis}.</b>     * Time spent in deep sleep will add an additional delay to execution.     *       * @param r The Runnable that will be executed.     * @param delayMillis The delay (in milliseconds) until the Runnable     *        will be executed.     *             * @return Returns true if the Runnable was successfully placed in to the      *         message queue.  Returns false on failure, usually because the     *         looper processing the message queue is exiting.  Note that a     *         result of true does not mean the Runnable will be processed --     *         if the looper is quit before the delivery time of the message     *         occurs then the message will be dropped.     */    public final boolean postDelayed(Runnable r, long delayMillis)    {        return sendMessageDelayed(getPostMessage(r), delayMillis);    }        /**     * Posts a message to an object that implements Runnable.     * Causes the Runnable r to executed on the next iteration through the     * message queue. The runnable will be run on the thread to which this     * handler is attached.     * <b>This method is only for use in very special circumstances -- it     * can easily starve the message queue, cause ordering problems, or have     * other unexpected side-effects.</b>     *     * 发布实现了runnable接口的对象。     * 这个runnable会在消息队列的下次迭代执行。这个runnable是在handler在的线程中run     * 这个方法仅适用于非常特殊的情况，因为它很容易造成饿死，顺序以及其他意想不到的副作用。     *       * @param r The Runnable that will be executed.     *      * @return Returns true if the message was successfully placed in to the      *         message queue.  Returns false on failure, usually because the     *         looper processing the message queue is exiting.     */    public final boolean postAtFrontOfQueue(Runnable r)    {        return sendMessageAtFrontOfQueue(getPostMessage(r));    }    /**     * Runs the specified task synchronously.     * <p>     * If the current thread is the same as the handler thread, then the runnable     * runs immediately without being enqueued.  Otherwise, posts the runnable     * to the handler and waits for it to complete before returning.     *     * 如果当前线程和handler所在线程相同，runnable将无需排队立即运行。相反，post方法运行前     * 会等待入队完成     *     * </p><p>     * This method is dangerous!  Improper use can result in deadlocks.     * Never call this method while any locks are held or use it in a     * possibly re-entrant manner.     *     * 这个方法是危险的！！！使用不当可能导致死锁。任何持有锁的或者可能re-entrant都不要调用此方法！！！     *     * </p><p>     * This method is occasionally useful in situations where a background thread     * must synchronously await completion of a task that must run on the     * handler's thread.  However, this problem is often a symptom of bad design.     * Consider improving the design (if possible) before resorting to this method.     * </p><p>     * One example of where you might want to use this method is when you just     * set up a Handler thread and need to perform some initialization steps on     * it before continuing execution.     * </p><p>     * If timeout occurs then this method returns <code>false</code> but the runnable     * will remain posted on the handler and may already be in progress or     * complete at a later time.     * </p><p>     * When using this method, be sure to use {@link Looper#quitSafely} when     * quitting the looper.  Otherwise {@link #runWithScissors} may hang indefinitely.     * (TODO: We should fix this by making MessageQueue aware of blocking runnables.)     * </p>     *     * @param r The Runnable that will be executed synchronously.     * @param timeout The timeout in milliseconds, or 0 to wait indefinitely.     *     * @return Returns true if the Runnable was successfully executed.     *         Returns false on failure, usually because the     *         looper processing the message queue is exiting.     *     * @hide This method is prone to abuse and should probably not be in the API.     * If we ever do make it part of the API, we might want to rename it to something     * less funny like runUnsafe().     */    public final boolean runWithScissors(final Runnable r, long timeout) {        if (r == null) {            throw new IllegalArgumentException("runnable must not be null");        }        if (timeout < 0) {            throw new IllegalArgumentException("timeout must be non-negative");        }        if (Looper.myLooper() == mLooper) {            r.run();            return true;        }        BlockingRunnable br = new BlockingRunnable(r);        return br.postAndWait(this, timeout);    }    /**     * Remove any pending posts of Runnable r that are in the message queue.     */    public final void removeCallbacks(Runnable r)    {        mQueue.removeMessages(this, r, null);    }    /**     * Remove any pending posts of Runnable <var>r</var> with Object     * <var>token</var> that are in the message queue.  If <var>token</var> is null,     * all callbacks will be removed.     */    public final void removeCallbacks(Runnable r, Object token)    {        mQueue.removeMessages(this, r, token);    }    /**     * Pushes a message onto the end of the message queue after all pending messages     * before the current time. It will be received in {@link #handleMessage},     * in the thread attached to this handler.     *       * @return Returns true if the message was successfully placed in to the      *         message queue.  Returns false on failure, usually because the     *         looper processing the message queue is exiting.     */    public final boolean sendMessage(Message msg)    {        return sendMessageDelayed(msg, 0);    }    /**     * Sends a Message containing only the what value.     *       * @return Returns true if the message was successfully placed in to the      *         message queue.  Returns false on failure, usually because the     *         looper processing the message queue is exiting.     */    public final boolean sendEmptyMessage(int what)    {        return sendEmptyMessageDelayed(what, 0);    }    /**     * Sends a Message containing only the what value, to be delivered     * after the specified amount of time elapses.     * @see #sendMessageDelayed(android.os.Message, long)      *      * @return Returns true if the message was successfully placed in to the      *         message queue.  Returns false on failure, usually because the     *         looper processing the message queue is exiting.     */    public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {        Message msg = Message.obtain();        msg.what = what;        return sendMessageDelayed(msg, delayMillis);    }    /**     * Sends a Message containing only the what value, to be delivered      * at a specific time.     * @see #sendMessageAtTime(android.os.Message, long)     *       * @return Returns true if the message was successfully placed in to the      *         message queue.  Returns false on failure, usually because the     *         looper processing the message queue is exiting.     */    public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {        Message msg = Message.obtain();        msg.what = what;        return sendMessageAtTime(msg, uptimeMillis);    }    /**     * Enqueue a message into the message queue after all pending messages     * before (current time + delayMillis). You will receive it in     * {@link #handleMessage}, in the thread attached to this handler.     *       * @return Returns true if the message was successfully placed in to the      *         message queue.  Returns false on failure, usually because the     *         looper processing the message queue is exiting.  Note that a     *         result of true does not mean the message will be processed -- if     *         the looper is quit before the delivery time of the message     *         occurs then the message will be dropped.     */    public final boolean sendMessageDelayed(Message msg, long delayMillis)    {        if (delayMillis < 0) {            delayMillis = 0;        }        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);    }    /**     * Enqueue a message into the message queue after all pending messages     * before the absolute time (in milliseconds) <var>uptimeMillis</var>.     * <b>The time-base is {@link android.os.SystemClock#uptimeMillis}.</b>     * Time spent in deep sleep will add an additional delay to execution.     * You will receive it in {@link #handleMessage}, in the thread attached     * to this handler.     *      * @param uptimeMillis The absolute time at which the message should be     *         delivered, using the     *         {@link android.os.SystemClock#uptimeMillis} time-base.     *              * @return Returns true if the message was successfully placed in to the      *         message queue.  Returns false on failure, usually because the     *         looper processing the message queue is exiting.  Note that a     *         result of true does not mean the message will be processed -- if     *         the looper is quit before the delivery time of the message     *         occurs then the message will be dropped.     */    public boolean sendMessageAtTime(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);    }    /**     * Enqueue a message at the front of the message queue, to be processed on     * the next iteration of the message loop.  You will receive it in     * {@link #handleMessage}, in the thread attached to this handler.     * <b>This method is only for use in very special circumstances -- it     * can easily starve the message queue, cause ordering problems, or have     * other unexpected side-effects.</b>     *       * @return Returns true if the message was successfully placed in to the      *         message queue.  Returns false on failure, usually because the     *         looper processing the message queue is exiting.     */    public final boolean sendMessageAtFrontOfQueue(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(MessageQueue queue, Message msg, long uptimeMillis) {        msg.target = this;        if (mAsynchronous) {            msg.setAsynchronous(true);        }        return queue.enqueueMessage(msg, uptimeMillis);    }    /**     * Remove any pending posts of messages with code 'what' that are in the     * message queue.     */    public final void removeMessages(int what) {        mQueue.removeMessages(this, what, null);    }    /**     * Remove any pending posts of messages with code 'what' and whose obj is     * 'object' that are in the message queue.  If <var>object</var> is null,     * all messages will be removed.     */    public final void removeMessages(int what, Object object) {        mQueue.removeMessages(this, what, object);    }    /**     * Remove any pending posts of callbacks and sent messages whose     * <var>obj</var> is <var>token</var>.  If <var>token</var> is null,     * all callbacks and messages will be removed.     */    public final void removeCallbacksAndMessages(Object token) {        mQueue.removeCallbacksAndMessages(this, token);    }    /**     * Check if there are any pending posts of messages with code 'what' in     * the message queue.     */    public final boolean hasMessages(int what) {        return mQueue.hasMessages(this, what, null);    }    /**     * Check if there are any pending posts of messages with code 'what' and     * whose obj is 'object' in the message queue.     */    public final boolean hasMessages(int what, Object object) {        return mQueue.hasMessages(this, what, object);    }    /**     * Check if there are any pending posts of messages with callback r in     * the message queue.     *      * @hide     */    public final boolean hasCallbacks(Runnable r) {        return mQueue.hasMessages(this, r, null);    }    // if we can get rid of this method, the handler need not remember its loop    // we could instead export a getMessageQueue() method...     public final Looper getLooper() {        return mLooper;    }    public final void dump(Printer pw, String prefix) {        pw.println(prefix + this + " @ " + SystemClock.uptimeMillis());        if (mLooper == null) {            pw.println(prefix + "looper uninitialized");        } else {            mLooper.dump(pw, prefix + "  ");        }    }    @Override    public String toString() {        return "Handler (" + getClass().getName() + ") {"        + Integer.toHexString(System.identityHashCode(this))        + "}";    }    final IMessenger getIMessenger() {        synchronized (mQueue) {            if (mMessenger != null) {                return mMessenger;            }            mMessenger = new MessengerImpl();            return mMessenger;        }    }    private final class MessengerImpl extends IMessenger.Stub {        public void send(Message msg) {            msg.sendingUid = Binder.getCallingUid();            Handler.this.sendMessage(msg);        }    }    private static Message getPostMessage(Runnable r) {        Message m = Message.obtain();        m.callback = r;        return m;    }    private static Message getPostMessage(Runnable r, Object token) {        Message m = Message.obtain();        m.obj = token;        m.callback = r;        return m;    }    private static void handleCallback(Message message) {        message.callback.run();    }    final MessageQueue mQueue;    final Looper mLooper;    final Callback mCallback;    final boolean mAsynchronous;    IMessenger mMessenger;    private static final class BlockingRunnable implements Runnable {        private final Runnable mTask;        private boolean mDone;        public BlockingRunnable(Runnable task) {            mTask = task;        }        @Override        public void run() {            try {                mTask.run();            } finally {                synchronized (this) {                    mDone = true;                    notifyAll();                }            }        }        public boolean postAndWait(Handler handler, long timeout) {            if (!handler.post(this)) {                return false;            }            synchronized (this) {                if (timeout > 0) {                    final long expirationTime = SystemClock.uptimeMillis() + timeout;                    while (!mDone) {                        long delay = expirationTime - SystemClock.uptimeMillis();                        if (delay <= 0) {                            return false; // timeout                        }                        try {                            wait(delay);                        } catch (InterruptedException ex) {                        }                    }                } else {                    while (!mDone) {                        try {                            wait();                        } catch (InterruptedException ex) {                        }                    }                }            }            return true;        }    }}