Android Handler消息机制源码分析——第二部分：Message与Handler

Android Handler消息机制源码分析——第二部分：Message与Handler

Message

/**
 * Message代表了一个消息，消息中包含了描述信息与若干数据，
 * Message主要通过Handler对象进行发送。
 * Message中有两个int字段arg1和arg2以及Object类型的obj字段供你使用
 * 你可以在这里设置一些额外的信息。
 * 如果要进行其他的数据传出可以使用setData()方法，
 * data是Bundle类型的字段，你可以在这个字段中设置你想要传输的数据
 *
 * 注意：虽然Message的构造方法是共有的，
 * 但是最好还是使用Message.obtain()方法来获取Message对象
 * 因为使用该方法可以复用Message回收池中的Message对象
 */
public final class Message implements Parcelable {
    /**
     * 用户自定义消息码，用来标识每个信息。
     * 一个消息队列可能处理多个Handler发出的消息，
     * 如果每个Handler对自己的消息都有自己的命名规则，
     * 就可以很好的避免与其他Handler发送的消息标识产生冲突
     */
    public int what;

    /**
     * arg1和arg2这两个字段能够用来保存一些简单的信息
     * 如果你想要传递更多的数据最好使用setData(Bundle)方法，
     * 如果是简单的数据使用arg1和arg2就足够了，可以避免创建对象(Bundle还是蛮耗资源的)
     */
    public int arg1;

    public int arg2;

    /**
     * 你想发送给接受者的任意对象，
     * 当使用Messenger发送跨进程的消息时，
     * 那这个对象还需要实现Parcelable接口了
     * 对于其他更复杂的数据最好还是使用setData(Bundle)进行传递
     *
     * <p>注意：在Android 2.2之前还不支持Parcelable接口
     */
    public Object obj;

    /**
     * Messenger涉及跨进程通信，这里不做深入研究
     * Optional Messenger where replies to this message can be sent.  The
     * semantics of exactly how this is used are up to the sender and
     * receiver.
     */
    public Messenger replyTo;

    /**
     * 这是一个可选字段，也是用来标识发送的信息。
     * 这个字段只在使用Messenger跨进程通信才会使用，其他情况下它都是-1
     */
    public int sendingUid = -1;

    /** If set message is in use.
     * This flag is set when the message is enqueued and remains set while it
     * is delivered and afterwards when it is recycled.  The flag is only cleared
     * when a new message is created or obtained since that is the only time that
     * applications are allowed to modify the contents of the message.
     *
     * It is an error to attempt to enqueue or recycle a message that is already in use.
     */
    /*package*/ static final int FLAG_IN_USE = 1 << 0;       //标志位：标识消息正在使用中

    /** If set message is asynchronous */
    /*package*/ static final int FLAG_ASYNCHRONOUS = 1 << 1; //标志位：标识该消息是异步消息

    /** Flags to clear in the copyFrom method */
    /*package*/ static final int FLAGS_TO_CLEAR_ON_COPY_FROM = FLAG_IN_USE;

    /*package*/ int flags;	//存储上面的几个标志位

    /*package*/ long when;  //消息需要在何时处理

    /*package*/ Bundle data;  //消息所携带的数据，更直接的说这应该是个数据包(小数据没必要存在这里)

    /*package*/ Handler target; //消息的处理者

    /*package*/ Runnable callback; //消息的回调(有这个字段通常就不会去执行target的handleMessage方法)

    // 存储下一个消息(这就是MessageQueue的消息队列的存储机制，实际上就是个单链表)
    /*package*/ Message next;

    // 这几个字段是Message的回收池，
    // 或者叫做缓冲池(这就是建议使用Message.obtain方法获取Message的原因)
    private static final Object sPoolSync = new Object();
    private static Message sPool;          //缓冲池事实上也是使用链表实现的
    private static int sPoolSize = 0;

    private static final int MAX_POOL_SIZE = 50;

    private static boolean gCheckRecycle = true;

    //////////////////////////////////////////////////////////////////////////////////////////////
    /**
     * 从全局的缓冲池中创建一个Message对象，
     * 使用该方法避免了重复创建Message对象
     * 使用全局缓冲池达到对象复用的目的
     */
    public static Message obtain() {
        synchronized (sPoolSync) {
            if (sPool != null) {    //取出缓冲池链表中的第一个Message对象
                Message m = sPool;
                sPool = m.next;
                m.next = null;
                m.flags = 0; // clear in-use flag
                sPoolSize--;
                return m;
            }
        }
        return new Message();
    }

    /**
     * 将传入的Message对象信息拷贝到缓冲池中的一个对象中
     */
    public static Message obtain(Message orig) {
        Message m = obtain();
        m.what = orig.what;
        m.arg1 = orig.arg1;
        m.arg2 = orig.arg2;
        m.obj = orig.obj;
        m.replyTo = orig.replyTo;
        m.sendingUid = orig.sendingUid;
        if (orig.data != null) {
            m.data = new Bundle(orig.data);
        }
        m.target = orig.target;
        m.callback = orig.callback;

        return m;
    }
    /**
     * 下面的obtain功能类似
     */
    public static Message obtain(Handler h) {
        Message m = obtain();
        m.target = h;

        return m;
    }
    public static Message obtain(Handler h, Runnable callback) {
        Message m = obtain();
        m.target = h;
        m.callback = callback;

        return m;
    }
    public static Message obtain(Handler h, int what) {
        Message m = obtain();
        m.target = h;
        m.what = what;

        return m;
    }
    public static Message obtain(Handler h, int what, Object obj) {
        Message m = obtain();
        m.target = h;
        m.what = what;
        m.obj = obj;

        return m;
    }

    public static Message obtain(Handler h, int what, int arg1, int arg2) {
        Message m = obtain();
        m.target = h;
        m.what = what;
        m.arg1 = arg1;
        m.arg2 = arg2;

        return m;
    }
    public static Message obtain(Handler h, int what,
            int arg1, int arg2, Object obj) {
        Message m = obtain();
        m.target = h;
        m.what = what;
        m.arg1 = arg1;
        m.arg2 = arg2;
        m.obj = obj;

        return m;
    }
    //////////////////////////////////////////////////////////////////////////////////////////////

    /** @hide */
    public static void updateCheckRecycle(int targetSdkVersion) {
        if (targetSdkVersion < Build.VERSION_CODES.LOLLIPOP) {
            gCheckRecycle = false;
        }
    }

    /**
     * 将消息回收进缓冲池中
     * 正在使用的Message无法回收(也就是已经入队的消息或正在处理的消息)
     */
    public void recycle() {
        if (isInUse()) {   //正在使用无法回收
            if (gCheckRecycle) {
                throw new IllegalStateException("This message cannot be recycled because it "
                        + "is still in use.");
            }
            return;
        }
        recycleUnchecked();
    }

    /**
     * 不检查是否正在使用，直接回收该消息
     * 这个是包内函数主要供MessageQueue和Looper在处理完消息后使用
     */
    void recycleUnchecked() {
        // 数据归零
        flags = FLAG_IN_USE;
        what = 0;
        arg1 = 0;
        arg2 = 0;
        obj = null;
        replyTo = null;
        sendingUid = -1;
        when = 0;
        target = null;
        callback = null;
        data = null;

        synchronized (sPoolSync) {
            if (sPoolSize < MAX_POOL_SIZE) {
                next = sPool;
                sPool = this;
                sPoolSize++;
            }
        }
    }

    /**
     * 从指定的Message中拷贝到该Message，对于Bundle类型的data字段执行的是浅拷贝
     * 没有拷贝o对象的when时间戳和target、callback字段
     */
    public void copyFrom(Message o) {
        this.flags = o.flags & ~FLAGS_TO_CLEAR_ON_COPY_FROM;
        this.what = o.what;
        this.arg1 = o.arg1;
        this.arg2 = o.arg2;
        this.obj = o.obj;
        this.replyTo = o.replyTo;
        this.sendingUid = o.sendingUid;

        if (o.data != null) {
            this.data = (Bundle) o.data.clone();
        } else {
            this.data = null;
        }
    }

    /**
     * 返回该消息的处理时间，毫秒为单位的时间戳
     */
    public long getWhen() {
        return when;
    }

    public void setTarget(Handler target) {
        this.target = target;
    }

    /**
     * 获取这个消息的处理对象也就是Handler的实现类
     * 对象必须要实现handleMessage(Message)方法.
     */
    public Handler getTarget() {
        return target;
    }

    /**
     * 获取回调接口，当该消息被处理的时候该回调接口会被调用
     */
    public Runnable getCallback() {
        return callback;
    }

    /**
     * 获取存储数据的Bundle对象，这个对象是通过setData方法设置的。
     * 注意：当通过Messenger进行跨进程数据传输时，
     * 你还需要通过调用setClassLoader(ClassLoader)方法为你的Bundle设置类加载器
     * 类加载器主要是用来在其他进程来实例化Bundle中的对象
     * @see #peekData()
     * @see #setData(Bundle)
     */
    public Bundle getData() {
        if (data == null) {
            data = new Bundle();
        }

        return data;
    }

    /**
     * 与getData()不同，这个可能返回null
     * @see #getData()
     * @see #setData(Bundle)
     */
    public Bundle peekData() {
        return data;
    }

    /**
     * Sets a Bundle of arbitrary data values. Use arg1 and arg2 members
     * as a lower cost way to send a few simple integer values, if you can.
     * @see #getData()
     * @see #peekData()
     */
    public void setData(Bundle data) {
        this.data = data;
    }

    /**
     * 可以通过该方法来指定Message的处理者
     */
    public void sendToTarget() {
        target.sendMessage(this);
    }

    /**
     * 判断该消息是否为异步消息，这里涉及到上一篇MessageQueue中讲到的同步消息拦截器(SyncBarrier)。
     * SyncBarrier可以拦截同步消息，所以可以通过setAsynchronous方法将消息设置为异步的。
     *
     *这个方法是用来查看消息是否为异步的。
     * @hide
     */
    public boolean isAsynchronous() {
        return (flags & FLAG_ASYNCHRONOUS) != 0;
    }

    /**
     * 是否将将消息设置为异步的
     * 对于为什么要异步消息，可以查看上篇MessageQueue.enqueueSyncBarrier方法与next方法
     * @hide
     */
    public void setAsynchronous(boolean async) {
        if (async) {
            flags |= FLAG_ASYNCHRONOUS;
        } else {
            flags &= ~FLAG_ASYNCHRONOUS;
        }
    }

    //消息是否正在使用中(消息已在消息队列中或消息正在处理)
    /*package*/ boolean isInUse() {
        return ((flags & FLAG_IN_USE) == FLAG_IN_USE);
    }

    /*package*/ void markInUse() {
        flags |= FLAG_IN_USE;
    }

    /** Message构造方法(但是还是建议使用Message.obtain()方法来获取Message对象)
    */
    public Message() {
    }

    @Override
    public String toString() {
        return toString(SystemClock.uptimeMillis());
    }

    String toString(long now) {
        StringBuilder b = new StringBuilder();
        b.append("{ when=");
        TimeUtils.formatDuration(when - now, b);

        if (target != null) {
            if (callback != null) {
                b.append(" callback=");
                b.append(callback.getClass().getName());
            } else {
                b.append(" what=");
                b.append(what);
            }

            if (arg1 != 0) {
                b.append(" arg1=");
                b.append(arg1);
            }

            if (arg2 != 0) {
                b.append(" arg2=");
                b.append(arg2);
            }

            if (obj != null) {
                b.append(" obj=");
                b.append(obj);
            }

            b.append(" target=");
            b.append(target.getClass().getName());
        } else {
            b.append(" barrier=");
            b.append(arg1);
        }

        b.append(" }");
        return b.toString();
    }

    // 下面都是Parcelable接口的实现，这里就不再往下解释了
    public static final Parcelable.Creator<Message> CREATOR
            = new Parcelable.Creator<Message>() {
        public Message createFromParcel(Parcel source) {
            Message msg = Message.obtain();
            msg.readFromParcel(source);
            return msg;
        }

        public Message[] newArray(int size) {
            return new Message[size];
        }
    };

    public int describeContents() {
        return 0;
    }

    public void writeToParcel(Parcel dest, int flags) {
        if (callback != null) {
            throw new RuntimeException(
                "Can't marshal callbacks across processes.");
        }
        dest.writeInt(what);
        dest.writeInt(arg1);
        dest.writeInt(arg2);
        if (obj != null) {
            try {
                Parcelable p = (Parcelable)obj;
                dest.writeInt(1);
                dest.writeParcelable(p, flags);
            } catch (ClassCastException e) {
                throw new RuntimeException(
                    "Can't marshal non-Parcelable objects across processes.");
            }
        } else {
            dest.writeInt(0);
        }
        dest.writeLong(when);
        dest.writeBundle(data);
        Messenger.writeMessengerOrNullToParcel(replyTo, dest);
        dest.writeInt(sendingUid);
    }

    private void readFromParcel(Parcel source) {
        what = source.readInt();
        arg1 = source.readInt();
        arg2 = source.readInt();
        if (source.readInt() != 0) {
            obj = source.readParcelable(getClass().getClassLoader());
        }
        when = source.readLong();
        data = source.readBundle();
        replyTo = Messenger.readMessengerOrNullFromParcel(source);
        sendingUid = source.readInt();
    }
}

Handler

/**
 * Handler是发送和处理消息的地方，也就是整个Handler框架的头跟尾。
 * 在一个线程中你可以创建多个Handler对象，
 * 每个Handler示例对象都关联了该线程的Looper和MessageQueue。
 * Handler在创建的时候就绑定了它所在的线程的MessageQueue(不需要开发者绑定)
 *
 * <p>发送消息主要一下两类：
 * (1) 发送一个Runnable在指定的时间执行
 * (该方法事实上是通过调研那个getPostMessage方法将Runnable封装到Message对象中)
 * boolean post(Runnable r)
 * boolean postAtTime(Runnable r, long uptimeMillis)
 * boolean postDelayed(Runnable r, long delayMillis)
 * boolean postAtFrontOfQueue(Runnable r)
 * (2) 发送一个消息在指定的时候分发到Handler.handleMessage(Message)方法中
 * boolean sendMessage(Message msg)
 * boolean sendEmptyMessage(int what)
 * boolean sendEmptyMessageDelayed(int what, long delayMillis)
 * boolean sendEmptyMessageAtTime(int what, long uptimeMillis)
 * boolean sendMessageDelayed(Message msg, long delayMillis)
 * boolean sendMessageAtTime(Message msg, long uptimeMillis)
 *
 * 以上两中类型的方法最终都会辗转调用最后那个方法sendMessageAtTime
 * 不同的是前者回调的是Message.callable.run方法(也就是指定的Runnable对象的run方法)
 * 后者回调的是Message.target.handleMessage方法(也就是开发者继承Handler后重载的handleMessage)
 */
public class Handler {
    /*
     */
    private static final boolean FIND_POTENTIAL_LEAKS = false;
    private static final String TAG = "Handler";

    /**
     * 类似于代理模式
     * Handler与Callback的关系类似于Thread与Runnable的关系
     */
    public interface Callback {
        public boolean handleMessage(Message msg);
    }

    /**
     * 处理消息的方法
     * 该方法就是子类需要实现的方法
     */
    public void handleMessage(Message msg) {
    }

    /**
     * 消息分发
     */
    public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            //调用Message.callback.run方法(这就是post类型的方法处理入口)
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    // 这里mCallback就是前面的Callback接口
                    return;
                }
            }
            handleMessage(msg); //最后调用Handler.handleMessage方法
        }
    }

    /**
     * 默认构造函数
     */
    public Handler() {
        this(null, false);
    }

    /**
     * 看了dispatchMessage方法，这个构造就很容易理解
     */
    public Handler(Callback callback) {
        this(callback, false);
    }

    /**
     * 开发者提供一个Looper从而替换默认的Looper
     */
    public Handler(Looper looper) {
        this(looper, null, false);
    }
    public Handler(Looper looper, Callback callback) {
        this(looper, callback, false);
    }

    /**
     * Handler默认是同步的，可以通过该构造修改默认是否默认异步。
     * 异步的Handler发送每个消息时会调用Message.setAsynchronous(boolean)设置消息为异步
     * 异步消息的作用主要是不受SyncBarrier同步拦截器的影响
     *
     * @hide
     */
    public Handler(boolean async) {
        this(null, async);
    }

    /**
     * @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();  //获取当前线程的Looper(默认Looper)
        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;
    }

    /**
     * @hide
     */
    public Handler(Looper looper, Callback callback, boolean async) {
        mLooper = looper;
        mQueue = looper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

    public String getMessageName(Message message) {
        if (message.callback != null) {
            return message.callback.getClass().getName();
        }
        return "0x" + Integer.toHexString(message.what);
    }
    //////////////////////////////////////////////////////////////////////////////////////////////
    //obtainMessage都是间接调用Message.obtain(对象复用的功能前面也说过了)
    public final Message obtainMessage()
    {
        return Message.obtain(this);
    }

    public final Message obtainMessage(int what)
    {
        return Message.obtain(this, what);
    }

    public final Message obtainMessage(int what, Object obj)
    {
        return Message.obtain(this, what, obj);
    }

    public final Message obtainMessage(int what, int arg1, int arg2)
    {
        return Message.obtain(this, what, arg1, arg2);
    }

    public final Message obtainMessage(int what, int arg1, int arg2, Object obj)
    {
        return Message.obtain(this, what, arg1, arg2, obj);
    }
    //////////////////////////////////////////////////////////////////////////////////////////////

    //////////////////////////////////////////////////////////////////////////////////////////////
    // post类型-->Runnable填充Message.callback字段
    // post方法最终会辗转调用 sendMessageAtTime(Message msg, long uptimeMillis) 方法
    // post类型与send类型的区别可以参考dispatchMessage方法
    public final boolean post(Runnable r)
    {
       return  sendMessageDelayed(getPostMessage(r), 0);
    }

    public final boolean postAtTime(Runnable r, long uptimeMillis)
    {
        return sendMessageAtTime(getPostMessage(r), uptimeMillis);
    }

    public final boolean postAtTime(Runnable r, Object token, long uptimeMillis)
    {
        // getPostMessage来填充Message.callback字段
        return sendMessageAtTime(getPostMessage(r, token), uptimeMillis);
    }

    public final boolean postDelayed(Runnable r, long delayMillis)
    {
        return sendMessageDelayed(getPostMessage(r), delayMillis);
    }

    public final boolean postAtFrontOfQueue(Runnable r)
    {
        return sendMessageAtFrontOfQueue(getPostMessage(r));
    }
    //////////////////////////////////////////////////////////////////////////////////////////////
    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);
    }

    public final void removeCallbacks(Runnable r)
    {
        mQueue.removeMessages(this, r, null);
    }

    public final void removeCallbacks(Runnable r, Object token)
    {
        mQueue.removeMessages(this, r, token);
    }
    //////////////////////////////////////////////////////////////////////////////////////////////
    // send方式的方法最终都辗转调用sendMessageAtTime(Message msg, long uptimeMillis)方法
    public final boolean sendMessage(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(Message msg, long delayMillis)
    {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }

    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); //消息入队
    }

    //将消息做为消息队列的头结点
    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); //调用MessageQueue.enqueueMessage
    }
    //////////////////////////////////////////////////////////////////////////////////////////////
    public final void removeMessages(int what) {
        mQueue.removeMessages(this, what, null);
    }

    public final void removeMessages(int what, Object object) {
        mQueue.removeMessages(this, what, object);
    }

    public final void removeCallbacksAndMessages(Object token) {
        mQueue.removeCallbacksAndMessages(this, token);
    }

    public final boolean hasMessages(int what) {
        return mQueue.hasMessages(this, what, null);
    }

    public final boolean hasMessages(int what, Object object) {
        return mQueue.hasMessages(this, what, object);
    }

    public final boolean hasCallbacks(Runnable r) {
        return mQueue.hasMessages(this, r, null);
    }

    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))
        + "}";
    }

    // 下面与Messnger相关的都属于跨进程通信
    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;
    }

    //处理msg.callback情况
    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;
        }
    }
}