BroadcastReceiver

BroadcastReceiver是Android四大組件之一，我們都比較熟悉，稱它為“廣播”
Android中的廣播就類似于電臺(tái)廣播，一個(gè)廣播可以有N個(gè)接收者。這是一個(gè)典型的發(fā)布——訂閱模式，也可以叫做觀察者模式。
廣播機(jī)制最大的特點(diǎn)就是發(fā)送發(fā)并不關(guān)心接收方是否接收到數(shù)據(jù)，也不關(guān)心接收方是如何處理數(shù)據(jù)的，通過(guò)這樣的形式達(dá)到接收雙方的完全解耦。

BroadcastReceiver是一個(gè)全局的（可跨進(jìn)程）的廣播，也就是說(shuō)所有應(yīng)用都可收到你發(fā)送的BroadcastReceiver。這可能會(huì)帶來(lái)安全隱患，比如其他應(yīng)用惡意模擬發(fā)送廣播、獲取隱私數(shù)據(jù)等等。

在BroadcastReceiver源碼類注釋中有如下文字：

If you don't need to send broadcasts across applications, consider using
this class with LocalBroadcastManager instead of the more general facilities described below. This will give you a much more efficient implementation (no cross-process communication needed) and allow you to avoid thinking about any security issues related to other applications being able to receive or send your broadcasts.

意思大概是如果你不需要跨進(jìn)程發(fā)送廣播，請(qǐng)考慮使用LocalBroadcastManager替代BroadcastReceiver，這樣我們就可以避免其他應(yīng)用程序能夠接收或發(fā)送你的應(yīng)用程序的BroadcastReceiver所帶來(lái)的安全問(wèn)題

LocalBroadcastManager的基本使用

• 注冊(cè)廣播

 LocalBroadcastManager.getInstance(context).registerReceiver(receiver,intentFilter);

• 反注冊(cè)廣播

 LocalBroadcastManager.getInstance(context).unregisterReceiver(receiver);

• 發(fā)送廣播

 LocalBroadcastManager.getInstance(context).sendBroadcast(newIntent());

LocalBroadcastManager 源碼解析

代碼量比較少，我先用大白話說(shuō)一遍，有個(gè)印象之后，看代碼就好理解了

大體框架就是兩個(gè)內(nèi)部類、三個(gè)集合、一個(gè)Handler、注冊(cè)廣播的方法、反注冊(cè)廣播的方法、發(fā)送廣播的方法、通知接收者的方法。

• 兩個(gè)內(nèi)部類用于承載一些廣播數(shù)據(jù)，如IntentFilter、BroadcastReceiver等
• 三個(gè)集合就是將承載著數(shù)據(jù)的內(nèi)部類存儲(chǔ)起來(lái)，功能：存儲(chǔ)注冊(cè)的接收者、方便在需要的時(shí)候獲取對(duì)象，比如獲取接受者并回調(diào)onReceive方法等
• Handler用于在主線程發(fā)送并接收消息，調(diào)用executePendingBroadcasts()方法為接受者回調(diào)onReceive方法
• 注冊(cè)廣播的方法：用內(nèi)部類封裝數(shù)據(jù)，并存入集合
• 反注冊(cè)廣播的方法：從集合中刪除對(duì)應(yīng)的數(shù)據(jù)
• 發(fā)送廣播的方法：獲取到Intent中攜帶的數(shù)據(jù)，與集合中保存的數(shù)據(jù)進(jìn)行匹配，將匹配的保存到集合中，通過(guò)handler發(fā)送消息回調(diào)executePendingBroadcasts()方法為接受者回調(diào)onReceive方法
• 通知接收者的方法：從集合中獲取注冊(cè)的BroadcastReceiver對(duì)象，調(diào)用其onReceive方法

public class LocalBroadcastManager {

    /**
     * 內(nèi)部類ReceiverRecord 用于保存IntentFilter和BroadcastReceive
     */
    private static class ReceiverRecord {
        final IntentFilter filter;
        final BroadcastReceiver receiver;
        boolean broadcasting;

        ReceiverRecord(IntentFilter _filter, BroadcastReceiver _receiver) {
            filter = _filter;
            receiver = _receiver;
        }

        @Override
        public String toString() {
            StringBuilder builder = new StringBuilder(128);
            builder.append("Receiver{");
            builder.append(receiver);
            builder.append(" filter=");
            builder.append(filter);
            builder.append("}");
            return builder.toString();
        }
    }

    /**
     * 內(nèi)部類BroadcastRecord 承載著ReceiverRecord集合，用于發(fā)送廣播時(shí)獲取BroadcastReceiver對(duì)象
     */
    private static class BroadcastRecord {
        final Intent intent;
        final ArrayList<ReceiverRecord> receivers;

        BroadcastRecord(Intent _intent, ArrayList<ReceiverRecord> _receivers) {
            intent = _intent;
            receivers = _receivers;
        }
    }

    private static final String TAG = "LocalBroadcastManager";
    private static final boolean DEBUG = false;

    private final Context mAppContext;

    //以BroadcastReceiver對(duì)象為key，IntentFilter集合為value 在注冊(cè)廣播接收器時(shí)添加 用于以后方便取消注冊(cè)廣播接收器
    private final HashMap<BroadcastReceiver, ArrayList<IntentFilter>> mReceivers
            = new HashMap<BroadcastReceiver, ArrayList<IntentFilter>>();
    //以Action字符串為key,以裝載著IntentFilter和BroadcastReceive的內(nèi)部類ReceiverRecord為value，用于發(fā)送廣播后得到廣播接收器
    private final HashMap<String, ArrayList<ReceiverRecord>> mActions
            = new HashMap<String, ArrayList<ReceiverRecord>>();
    //存儲(chǔ)裝載著ReceiverRecord集合的內(nèi)部類BroadcastRecord的集合 用于發(fā)送廣播時(shí)回調(diào)BroadcastReceiver的onReceive方法
    private final ArrayList<BroadcastRecord> mPendingBroadcasts
            = new ArrayList<BroadcastRecord>();

    static final int MSG_EXEC_PENDING_BROADCASTS = 1;

    private final Handler mHandler;

    private static final Object mLock = new Object();
    private static LocalBroadcastManager mInstance;

    //單例模式創(chuàng)建
    public static LocalBroadcastManager getInstance(Context context) {
        synchronized (mLock) {
            if (mInstance == null) {
                mInstance = new LocalBroadcastManager(context.getApplicationContext());
            }
            return mInstance;
        }
    }

    private LocalBroadcastManager(Context context) {
        mAppContext = context;
        //核心  使用一個(gè)主線程Looper的Handler 用于完成廣播的消息處理
        //也就是說(shuō) onReceive接收廣播的時(shí)候 是處于主線程中
        mHandler = new Handler(context.getMainLooper()) {

            @Override
            public void handleMessage(Message msg) {
                switch (msg.what) {
                    case MSG_EXEC_PENDING_BROADCASTS:
                        executePendingBroadcasts();
                        break;
                    default:
                        super.handleMessage(msg);
                }
            }
        };
    }

    /**
     * 注冊(cè)廣播接收器
     * 
     */
    public void registerReceiver(BroadcastReceiver receiver, IntentFilter filter) {
        synchronized (mReceivers) {
            //承載IntentFilter和BroadcastReceiver的內(nèi)部類，會(huì)將其存儲(chǔ)于mActions集合，方便根據(jù)action查找廣播接收器
            ReceiverRecord entry = new ReceiverRecord(filter, receiver);

            //將BroadcastReceiver和IntentFilter存入mReceivers集合中，方便取消廣播監(jiān)聽(tīng)器
            ArrayList<IntentFilter> filters = mReceivers.get(receiver);
            if (filters == null) {
                filters = new ArrayList<IntentFilter>(1);
                mReceivers.put(receiver, filters);
            }
            filters.add(filter);

            //將action和ReceiverRecord存入mActions集合
            for (int i=0; i<filter.countActions(); i++) {
                String action = filter.getAction(i);
                ArrayList<ReceiverRecord> entries = mActions.get(action);
                if (entries == null) {
                    entries = new ArrayList<ReceiverRecord>(1);
                    mActions.put(action, entries);
                }
                entries.add(entry);
            }
        }
    }

    /**
     * 取消廣播接收器
     */
    public void unregisterReceiver(BroadcastReceiver receiver) {
        synchronized (mReceivers) {
            //移除掉mActions集合中的該BroadcastReceiver對(duì)象
            ArrayList<IntentFilter> filters = mReceivers.remove(receiver);
            if (filters == null) {
                return;
            }

            //根據(jù)mActions存儲(chǔ)的IntentFilter集合將mActions集合中相關(guān)action對(duì)應(yīng)的ReceiverRecord也刪掉
            for (int i=0; i<filters.size(); i++) {
                IntentFilter filter = filters.get(i);
                for (int j=0; j<filter.countActions(); j++) {
                    String action = filter.getAction(j);
                    ArrayList<ReceiverRecord> receivers = mActions.get(action);
                    if (receivers != null) {
                        for (int k=0; k<receivers.size(); k++) {
                            if (receivers.get(k).receiver == receiver) {
                                receivers.remove(k);
                                k--;
                            }
                        }
                        if (receivers.size() <= 0) {
                            mActions.remove(action);
                        }
                    }
                }
            }
        }
    }

    /**
     * 發(fā)送廣播
     *     1.獲取到要發(fā)送的Intent包含的信息
     *     2.從注冊(cè)的接收器中找到與之匹配的接收器，存儲(chǔ)到集合中
     *     3.通過(guò)Handler在主線程回調(diào)注冊(cè)的接收器的onReceive方法
     */
    public boolean sendBroadcast(Intent intent) {
        synchronized (mReceivers) {
            // 獲取Intent中攜帶的相關(guān)信息
            final String action = intent.getAction();
            final String type = intent.resolveTypeIfNeeded(
                    mAppContext.getContentResolver());
            final Uri data = intent.getData();
            final String scheme = intent.getScheme();
            final Set<String> categories = intent.getCategories();

            final boolean debug = DEBUG ||
                    ((intent.getFlags() & Intent.FLAG_DEBUG_LOG_RESOLUTION) != 0);
            if (debug) Log.v(
                    TAG, "Resolving type " + type + " scheme " + scheme
                    + " of intent " + intent);

            // 根據(jù)action從mActions集合中獲取到ReceiverRecord集合
            ArrayList<ReceiverRecord> entries = mActions.get(intent.getAction());
            if (entries != null) {
                if (debug) Log.v(TAG, "Action list: " + entries);

                ArrayList<ReceiverRecord> receivers = null;
                for (int i=0; i<entries.size(); i++) {
                    ReceiverRecord receiver = entries.get(i);
                    if (debug) Log.v(TAG, "Matching against filter " + receiver.filter);

                    //broadcasting是內(nèi)部類ReceiverRecord的一個(gè)屬性，用于防止重復(fù)加入receiver到receivers集合
                    //被加入receivers集合時(shí)賦值為true,遍歷結(jié)束后將改屬性全部賦值為false
                    if (receiver.broadcasting) {
                        if (debug) {
                            Log.v(TAG, "  Filter's target already added");
                        }
                        continue;
                    }

                    //用斷定filter是否匹配
                    int match = receiver.filter.match(action, type, scheme, data,
                            categories, "LocalBroadcastManager");
                    if (match >= 0) {   //匹配
                        if (debug) Log.v(TAG, "  Filter matched!  match=0x" +
                                Integer.toHexString(match));
                        if (receivers == null) {
                            receivers = new ArrayList<ReceiverRecord>();
                        }
                        //將匹配的receiver加入receivers集合
                        receivers.add(receiver);
                        receiver.broadcasting = true;
                    } else {     //不匹配
                        if (debug) {
                            String reason;
                            switch (match) {
                                case IntentFilter.NO_MATCH_ACTION: reason = "action"; break;
                                case IntentFilter.NO_MATCH_CATEGORY: reason = "category"; break;
                                case IntentFilter.NO_MATCH_DATA: reason = "data"; break;
                                case IntentFilter.NO_MATCH_TYPE: reason = "type"; break;
                                default: reason = "unknown reason"; break;
                            }
                            Log.v(TAG, "  Filter did not match: " + reason);
                        }
                    }
                }

                if (receivers != null) {
                    //添加結(jié)束，將所有receiver對(duì)象的broadcasting屬性賦值為false
                    for (int i=0; i<receivers.size(); i++) {
                        receivers.get(i).broadcasting = false;
                    }
                    //封裝進(jìn)BroadcastRecord中，并添加到mPendingBroadcasts集合
                    mPendingBroadcasts.add(new BroadcastRecord(intent, receivers));
                    //若主線程隊(duì)列中沒(méi)有MSG_EXEC_PENDING_BROADCASTS，則發(fā)送該消息進(jìn)行onReceive回調(diào)
                    if (!mHandler.hasMessages(MSG_EXEC_PENDING_BROADCASTS)) {
                        mHandler.sendEmptyMessage(MSG_EXEC_PENDING_BROADCASTS);
                    }
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 發(fā)送同步廣播 
     * 指的是在一次廣播的發(fā)送完成之前，不會(huì)同時(shí)發(fā)送其他廣播
     */
    public void sendBroadcastSync(Intent intent) {
        if (sendBroadcast(intent)) {
            executePendingBroadcasts();
        }
    }


    /**
     * 回調(diào)注冊(cè)的BroadcastReceiver的onReceive方法
     */
    private void executePendingBroadcasts() {
        while (true) {
            BroadcastRecord[] brs = null;
            synchronized (mReceivers) {
                final int N = mPendingBroadcasts.size();
                if (N <= 0) {
                    return;
                }
                brs = new BroadcastRecord[N];
                //將所有匹配的集合這保存到BroadcastRecord數(shù)組中
                mPendingBroadcasts.toArray(brs);
                //將該集合清除 如果本次循環(huán)結(jié)束前未添加新的對(duì)象到該集合，那么下次循環(huán)將被return
                mPendingBroadcasts.clear();
            }

            //遍歷回調(diào)匹配的BroadcastReceiver的onReceive方法
            for (int i=0; i<brs.length; i++) {
                BroadcastRecord br = brs[i];
                for (int j=0; j<br.receivers.size(); j++) {
                    br.receivers.get(j).receiver.onReceive(mAppContext, br.intent);
                }
            }
        }
    }
}

看完源碼，我們會(huì)發(fā)現(xiàn)，BroadcastReceiver的跨進(jìn)程通信是依賴Binder機(jī)制來(lái)完成的，而LocalBroadcastManager這個(gè)不跨進(jìn)程的廣播并沒(méi)有那么復(fù)雜，說(shuō)白了就是單例模式的LocalBroadcastManager就是普通觀察這模式，將廣播接收者（即觀察者）存儲(chǔ)到集合中，發(fā)送廣播時(shí)去集合找到對(duì)應(yīng)的接受者（即當(dāng)可觀察者發(fā)生變更時(shí)），配合了Handler的使用回調(diào)onReceive對(duì)象罷了（即通知觀察者做出相應(yīng)的處理），此模式可以看看Observable類的源碼，加深理解。

利與弊

它的好處是：

• 僅在本應(yīng)用內(nèi)廣播，不用擔(dān)心數(shù)據(jù)泄露與其他應(yīng)用模擬發(fā)送廣播，比BroadcastReceiver更安全
• 效率比使用Binder的BroadcastReceiver高

相對(duì)而言，缺點(diǎn)就是：

• 不能跨進(jìn)程通信。這就是它的雙刃劍啊
• 不能用于系統(tǒng)Action，例如電量、Wifi狀態(tài)等

總而言之，就是根據(jù)自己的實(shí)際情況去選擇適合的工具，這樣才能讓它們都“工作”在自己真正應(yīng)該在的崗位上，才能發(fā)揮出最大的價(jià)值！