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