BroadcastReceiver
BroadcastReceiver是Android四大組件之一，我們都比較熟悉，稱它爲“廣播”
Android中的廣播就類似於電臺廣播，一個廣播可以有N個接收者。這是一個典型的發佈——訂閱模式，也可以叫做觀察者模式。
廣播機制最大的特點就是發送發並不關心接收方是否接收到數據，也不關心接收方是如何處理數據的，通過這樣的形式達到接收雙方的完全解耦。
BroadcastReceiver是一個全局的（可跨進程）的廣播，也就是說所有應用都可收到你發送的BroadcastReceiver。這可能會帶來安全隱患，比如其他應用惡意模擬發送廣播、獲取隱私數據等等。
在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.
意思大概是如果你不需要跨進程發送廣播，請考慮使用LocalBroadcastManager替代BroadcastReceiver，這樣我們就可以避免其他應用程序能夠接收或發送你的應用程序的BroadcastReceiver所帶來的安全問題
LocalBroadcastManager的基本使用
- 註冊廣播
LocalBroadcastManager.getInstance(context).registerReceiver(receiver,intentFilter);
- 反註冊廣播
LocalBroadcastManager.getInstance(context).unregisterReceiver(receiver);
- 發送廣播
LocalBroadcastManager.getInstance(context).sendBroadcast(newIntent());
LocalBroadcastManager 源碼解析
代碼量比較少，我先用大白話說一遍，有個印象之後，看代碼就好理解了
大體框架就是兩個內部類、三個集合、一個Handler、註冊廣播的方法、反註冊廣播的方法、發送廣播的方法、通知接收者的方法。
- 兩個內部類用於承載一些廣播數據，如IntentFilter、BroadcastReceiver等
- 三個集合就是將承載着數據的內部類存儲起來，功能：存儲註冊的接收者、方便在需要的時候獲取對象，比如獲取接受者並回調onReceive方法等
- Handler用於在主線程發送並接收消息，調用executePendingBroadcasts()方法爲接受者回調onReceive方法
- 註冊廣播的方法：用內部類封裝數據，並存入集合
- 反註冊廣播的方法：從集合中刪除對應的數據
- 發送廣播的方法：獲取到Intent中攜帶的數據，與集合中保存的數據進行匹配，將匹配的保存到集合中，通過handler發送消息回調executePendingBroadcasts()方法爲接受者回調onReceive方法
- 通知接收者的方法：從集合中獲取註冊的BroadcastReceiver對象，調用其onReceive方法
public class LocalBroadcastManager {
/**
* 內部類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();
}
}
/**
* 內部類BroadcastRecord 承載着ReceiverRecord集合，用於發送廣播時獲取BroadcastReceiver對象
*/
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對象爲key，IntentFilter集合爲value 在註冊廣播接收器時添加 用於以後方便取消註冊廣播接收器
private final HashMap<BroadcastReceiver, ArrayList<IntentFilter>> mReceivers
= new HashMap<BroadcastReceiver, ArrayList<IntentFilter>>();
//以Action字符串爲key,以裝載着IntentFilter和BroadcastReceive的內部類ReceiverRecord爲value，用於發送廣播後得到廣播接收器
private final HashMap<String, ArrayList<ReceiverRecord>> mActions
= new HashMap<String, ArrayList<ReceiverRecord>>();
//存儲裝載着ReceiverRecord集合的內部類BroadcastRecord的集合 用於發送廣播時回調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;
//單例模式創建
public static LocalBroadcastManager getInstance(Context context) {
synchronized (mLock) {
if (mInstance == null) {
mInstance = new LocalBroadcastManager(context.getApplicationContext());
}
return mInstance;
}
}
private LocalBroadcastManager(Context context) {
mAppContext = context;
//核心 使用一個主線程Looper的Handler 用於完成廣播的消息處理
//也就是說 onReceive接收廣播的時候 是處於主線程中
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);
}
}
};
}
/**
* 註冊廣播接收器
*
*/
public void registerReceiver(BroadcastReceiver receiver, IntentFilter filter) {
synchronized (mReceivers) {
//承載IntentFilter和BroadcastReceiver的內部類，會將其存儲於mActions集合，方便根據action查找廣播接收器
ReceiverRecord entry = new ReceiverRecord(filter, receiver);
//將BroadcastReceiver和IntentFilter存入mReceivers集合中，方便取消廣播監聽器
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對象
ArrayList<IntentFilter> filters = mReceivers.remove(receiver);
if (filters == null) {
return;
}
//根據mActions存儲的IntentFilter集合將mActions集合中相關action對應的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);
}
}
}
}
}
}
/**
* 發送廣播
* 1.獲取到要發送的Intent包含的信息
* 2.從註冊的接收器中找到與之匹配的接收器，存儲到集合中
* 3.通過Handler在主線程回調註冊的接收器的onReceive方法
*/
public boolean sendBroadcast(Intent intent) {
synchronized (mReceivers) {
// 獲取Intent中攜帶的相關信息
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);
// 根據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是內部類ReceiverRecord的一個屬性，用於防止重複加入receiver到receivers集合
//被加入receivers集合時賦值爲true,遍歷結束後將改屬性全部賦值爲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) {
//添加結束，將所有receiver對象的broadcasting屬性賦值爲false
for (int i=0; i<receivers.size(); i++) {
receivers.get(i).broadcasting = false;
}
//封裝進BroadcastRecord中，並添加到mPendingBroadcasts集合
mPendingBroadcasts.add(new BroadcastRecord(intent, receivers));
//若主線程隊列中沒有MSG_EXEC_PENDING_BROADCASTS，則發送該消息進行onReceive回調
if (!mHandler.hasMessages(MSG_EXEC_PENDING_BROADCASTS)) {
mHandler.sendEmptyMessage(MSG_EXEC_PENDING_BROADCASTS);
}
return true;
}
}
}
return false;
}
/**
* 發送同步廣播
* 指的是在一次廣播的發送完成之前，不會同時發送其他廣播
*/
public void sendBroadcastSync(Intent intent) {
if (sendBroadcast(intent)) {
executePendingBroadcasts();
}
}
/**
* 回調註冊的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數組中
mPendingBroadcasts.toArray(brs);
//將該集合清除 如果本次循環結束前未添加新的對象到該集合，那麼下次循環將被return
mPendingBroadcasts.clear();
}
//遍歷回調匹配的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);
}
}
}
}
}
看完源碼，我們會發現，BroadcastReceiver的跨進程通信是依賴Binder機制來完成的，而LocalBroadcastManager這個不跨進程的廣播並沒有那麼複雜，說白了就是單例模式的LocalBroadcastManager就是普通觀察這模式，將廣播接收者（即觀察者）存儲到集合中，發送廣播時去集合找到對應的接受者（即當可觀察者發生變更時），配合了Handler的使用回調onReceive對象罷了（即通知觀察者做出相應的處理），此模式可以看看Observable類的源碼，加深理解。
利與弊
它的好處是：
- 僅在本應用內廣播，不用擔心數據泄露與其他應用模擬發送廣播，比BroadcastReceiver更安全
- 效率比使用Binder的BroadcastReceiver高
相對而言，缺點就是：
- 不能跨進程通信。這就是它的雙刃劍啊
- 不能用於系統Action，例如電量、Wifi狀態等
總而言之，就是根據自己的實際情況去選擇適合的工具，這樣才能讓它們都“工作”在自己真正應該在的崗位上，才能發揮出最大的價值！