Handler的使用和理解

• 开发过程中很多情况下需要用到 handler，这里进行一个简单的封装，方便使用，希望对你有所帮助。
• 机制：Handler 机制其实就是线程之间的通信，当我们在子线程需要更新 UI 的时候，可以把需要更新的 UI 信息传递给主线程，进而可以在进行UI刷新。

1、首先创建统一的 Handler 继承类，需要用  Hanlder 的时候直接继承这个类即可

public abstract class MsgBaseHandler extends Handler {

    /**
     * 存放监听的消息类型
     */
    private ArrayList<Integer> mInterests = new ArrayList<>();

    public abstract void careAbout();

    public MsgBaseHandler(Looper looper) {
        super(looper);
        careAbout();
    }

    public MsgBaseHandler() {
        this(null == Looper.myLooper() ? Looper.getMainLooper() : Looper.myLooper());
    }

    /**
     * 添加监听的消息类型
     */
    public void addMsg(int msgID) {
        for (Integer i : mInterests) {
            if (i == msgID) {
                return;
            }
        }

        mInterests.add(msgID);
    }

    /**
     * 取消对某类消息的监听
     */
    public void removeMsg(int msgID) {
        for (Iterator<Integer> it = mInterests.iterator(); it.hasNext(); ) {
            Integer i = it.next();
            if (i == msgID) {
                it.remove();
            }
        }
    }

    /**
     * 是否监听了某个类型
     */
    public boolean isAdded(int msgID) {
        if (mInterests == null) {
            return false;
        }

        return mInterests.contains(msgID);
    }

}

2、创建一个 Handler 管理类，用于管理 Handler 的注册、注销、分发消息

public class MsgHandlerCenter {

    private static final ArrayList<MsgBaseHandler> HANDLER_LIST = new ArrayList<>();

    public MsgHandlerCenter() {

    }

    /**
     * register Message Handler
     * @param msgBaseHandler
     */
    public static void registerMessageHandler(MsgBaseHandler msgBaseHandler) {

    }

    /**
     * unregister Message Handler
     * @param msgBaseHandler
     */
    public static void unRegisterMessageHandler(MsgBaseHandler msgBaseHandler) {

    }

    /**
     * unregister Message Handler
     */
    public static void unRegisterAllMessageHandler() {

    }

    /**
     * deliver message to all registered handlers
     * @param what {@link Message#what}
     * @param arg1 {@link Message#arg1}
     * @param arg2 {@link Message#arg2}
     * @param b {@link Message#obj}
     * @param delay after delay time to dispatch the message, in milliseconds
     */
    public static void dispatchMessageDelay(int what, int arg1, int arg2, Object b, int delay) {
        if (HANDLER_LIST != null && !HANDLER_LIST.isEmpty()) {
            for (int i = 0; i < HANDLER_LIST.size(); i++) {
                MsgBaseHandler h = HANDLER_LIST.get(i);
                if (h != null && h.isAdded(what)) {
                    Message msg = Message.obtain(h, what, arg1, arg2, b);
                    h.sendMessageDelayed(msg, delay);
                }
            }
        }
    }

    public static void dispatchMessageDelay(int what, int delay) {
        dispatchMessageDelay(what, -1, -1, null, delay);
    }

    public static void dispatchMessage(int what, int arg1, int arg2, Object b) {
        dispatchMessageDelay(what, arg1, arg2, b, 0);
    }

    public static void dispatchMessage(int what) {
        dispatchMessage(what, -1, -1, null);
    }

    public static void dispatchMessage(int what, Object b) {
        dispatchMessage(what, -1, -1, b);
    }

    /**
     * remove all messages unhandled
     * @param what {@link Message#what}
     */
    public static void removeMessages(int what) {
        if (HANDLER_LIST != null && !HANDLER_LIST.isEmpty()) {
            for (int i = 0; i < HANDLER_LIST.size(); i++) {
                MsgBaseHandler h = HANDLER_LIST.get(i);
                if (h != null && h.isAdded(what)) {
                    h.removeMessages(what);
                }
            }
        }
    }

}

3、奉上一个使用案例

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mainHandler = new MainHandler(getMainLooper());
        MsgHandlerCenter.registerMessageHandler(mainHandler);

    }

    private class MainHandler extends MsgBaseHandler {

        public MainHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
        }

        @Override
        public void careAbout() {
            addMsg(0);
            addMsg(1);
            addMsg(2);
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        MsgHandlerCenter.unRegisterMessageHandler(mainHandler);
    }