Android消息机制-Handler（二）

一.Handler的两类使用方法

Handler里面有两类方法，一类是sendxxxx()，另一类是postxxxxx()

A. sendxxxx方法

1.sendEmptyMessage(int what):只发送了一个what值，也就是handleMessage收到的msg里面what的值

2.sendEmptyMessageDelayed(int what,long delayMillis):  指定延时多少毫秒后发送what

3.sendMessage(Message msg):立即发送信息，需要传入一个Message对象作为参数

4.sendMessageDelayed(Message msg, long delayMillis):延迟一定时间发送message对象

5.sendEmptyMessageAtTime(int what, long uptimeMillis)：在一具体时间发送空消息

6.sendMessageAtTime(Message msg, long uptimeMillis)：不说也知道了，在一具体时间发送message对象

7.sendMessageAtFrontOfQueue(Message msg)：插入消息队列的头部，然后next就是它执行了

注：以上在handler源码里除了7 sendMessageAtFrontOfQueue 最终没有调用 sendMessageAtTime 方法外，其他方法最终都指向了    sendMessageAtTime方法

B.postXXX方法

1.post(Runnable r)：Runable对象作为参数，post完之后，直接可以执行，Runable对象里面的run方法

2.postDelayed(Runnable r, long delayMillis)：延迟一定时间执行runable对象

3.postAtTime(Runnable r, long uptimeMillis)在一具体时间执行runable对象

4.postAtFrontOfQueue(Runnable r):在消息队列头部插入runable对象执行

post方法执行举例

package practise.heima.com.customview;

import android.app.Activity;
import android.os.Handler;
import android.os.Bundle;
import android.widget.TextView;

public class HandlerActivity extends Activity {

    private TextView tv;
    Handler handler=new Handler();
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_mhandler);
        tv= (TextView) findViewById(R.id.tv);
        handler.postDelayed(new Runnable() {
            @Override
            public void run() {
                tv.setText("Runable 对象执行");
            }
        },2000);//利用post方法，延迟两秒执行Runbale
    }
}

二 send 和post方式有什么区别吗？

其实只是实现形式的不同，区别不大。不管是send或者post 最终的执行都是在 dispatchMessage(Message msg) 里面，源码如下：

 public void dispatchMessage(Message msg) {
        if (msg.callback != null) {  //如果message对象里面的callback不为空执行handleCallback(msg)
            handleCallback(msg);
        } else {//否则的话
		//如果handler对象里的 mCallback不为空的话，就执行mCallback的handleMessage(msg)方法
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
		//mCallback为空的话,就执行Handler的handleMessage(msg)方法
            handleMessage(msg);
        }
    }

可以发现，dispatchMessage做了两个if判断，也就是有三种执行方法。

    A.post方法的执行

post方法对应的是msg.callback != null 的判断，这个是Message对象里面定义的callback属性，是个Runable对象，

Runnable callback;

其实去看Handler类里post方法源码可以发现post方法的Runnable对象参数，通过getPostMessage(Runnable r)生成了一个有Runnable类型属性的Message对象，并调用sendMessageDelayed 把这个包含Runnable对象的Message发出去了。

 public final boolean post(Runnable r)
    {
       return  sendMessageDelayed(getPostMessage(r), 0);
    }

 private static Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r;
        return m;
    }

当dispatchMessage收到消息的时候判断message的callback是否为空，不为空，就用handleCallback(msg)，执行了最开始传递进来的Runnable对象

 private static void handleCallback(Message message) {
        message.callback.run();
    }

Ｂ.send方法的执行

send方法对应的是最后的Handler的handleMessage(msg) 的执行，这个执行的一般都是我们在定义handler时，重写的handleMessage(msg) 方法。

Message的target属性是Handler类型，在让消息排队的时候执行enqueueMessage方法，在里面，handler对象本身让message对象给打包排队去了，并最终执行

 private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

C.mCallback  的执行

Handler定义了一个 Callback接口。通过看源码发现，dispatchMessage 里面的 mCallback 属性，都是通过构造函数赋值的，也就是说，在new handler对象的时候，就可以传递一个实现了Callback接口的对象进来，最终可以在dispatchMessage 里面执行这个实现Callback接口的对象的参数的handleMessage(msg)方法。

所以，使得Handler能够处理Message，我们有两种办法： 
1. 向Hanlder的构造函数传入一个Handler.Callback对象，并实现Handler.Callback的handleMessage方法 
2. 无需向Hanlder的构造函数传入Handler.Callback对象，但是需要重写Handler本身的handleMessage方法 

也就是说无论哪种方式，我们都得通过某种方式实现handleMessage方法

还有一点，这种方法是可以带有返回值的，如果返回false，可以既执行mCallback的handleMessage(msg)方法，又可以执行重写的handler的handleMessage(msg)方法

使用Callback形式的handler

Handler handler=new Handler(new Handler.Callback() {
        @Override
        public boolean handleMessage(Message msg) {
            return false;
        }
    }){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
        }
    };

 Handler handler=new Handler(new Handler.Callback() {
        @Override
        public boolean handleMessage(Message msg) {
            Log.e("HandlerActivity","handler执行Callback()");
            return false;//false 则handler本身重写的handleMessage会执行，true不会
        }
    }){
        @Override
        public void handleMessage(Message msg) {
            Log.e("HandlerActivity","handler执行handleMessage()");
        }
    };

源码里有关mCallback的地方。
final Callback mCallback;

    public interface Callback {
        public boolean handleMessage(Message msg);
    }

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

   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;
    }