終於建了一個自己個人小站：https://huangtianyu.gitee.io，以後優先更新小站博客，歡迎進站，O(∩_∩)O~~
1. 簡介
通常我們在使用Android廣播的時候都會直接將廣播註冊到系統的AMS當中，由於AMS任務繁忙，一般可能不會立即能處理到我們發出的廣播，如果我們使用廣播是在應用內的單個進程中使用，則完全可以採用LocalBroadcastManager來處理。LocalBroadcastManager採用的是Handler的消息機制來處理的廣播，而註冊到系統中的是通過Binder機制實現的，速度是應用內廣播要快很多。不過由於Handler的消息機制是爲了同一個進程的多線程間進行通信的，因而跨進程時無法使用應用內廣播。
1.1 使用
在使用上和普通的Broadcast類似，主要分5步。具體如下：
//1. 自定義廣播接收者
public class LocalReceiver extends BroadcastReceiver {
public void onReceive(Context context, Intent intent) {
...
}
}
LocalReceiver localReceiver = new LocalReceiver();
//2. 註冊廣播
LocalBroadcastManager.getInstance(context)
.registerReceiver(localReceiver, new IntentFilter(“test”));
//4. 發送廣播
LocalBroadcastManager.getInstance(context).sendBroadcast(new Intent("test"));
//5. 取消註冊廣播
LocalBroadcastManager.getInstance(context).unregisterReceiver(localReceiver);自定義廣播和普通的廣播一樣，在註冊廣播的時候將該廣播接受者註冊到LocalBroadcatManager中。當發生時也是調用LocalBroadcastManager的sendBroadcast進行發生。同樣在不使用時記得取消廣播註冊。
2. LocalBroadcastManager
2.1 初始化
LocalBroadcastManager採用的是單例模式，其構造函數是私有的，獲取該類實例的方法是getInstance，具體代碼如下：
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;
//mHandler是主線程的
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);
}
}
};
}在構造函數中創建了一個mHandler，該mHandler關聯的是主線程的Looper。即消息處理時都在主線程中處理。
2.2 registerReceiver
public void registerReceiver(BroadcastReceiver receiver, IntentFilter filter) {
//在註冊，取消註冊，發送廣播的時候都需要先獲取mReceivers的鎖
synchronized (mReceivers) {
//新建一個ReceiverRecord實體表示該receiver及對應的filter
ReceiverRecord entry = new ReceiverRecord(filter, receiver);
//獲取receiver對應的filters
ArrayList<IntentFilter> filters = mReceivers.get(receiver);
if (filters == null) {
//如果該receiver沒有對應的filters則，新建一個。
filters = new ArrayList<IntentFilter>(1);
mReceivers.put(receiver, filters);
}
//將filter放入該receiver對應的filters中
filters.add(filter);
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);
//將action放入mActions中
mActions.put(action, entries);
}
entries.add(entry);
}
}
}註冊的時候也就是將receiver自己和對應的filter及action放入到mReceivers和mActions當中。代碼比較簡單。
2.3 發送廣播sendBroadcast
public boolean sendBroadcast(Intent intent) {
synchronized (mReceivers) {
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);
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);
if (receiver.broadcasting) {
if (debug) {
Log.v(TAG, " Filter's target already added");
}
continue;
}
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>();
}
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) {
for (int i=0; i<receivers.size(); i++) {
receivers.get(i).broadcasting = false;
}
mPendingBroadcasts.add(new BroadcastRecord(intent, receivers));
if (!mHandler.hasMessages(MSG_EXEC_PENDING_BROADCASTS)) {
mHandler.sendEmptyMessage(MSG_EXEC_PENDING_BROADCASTS);
}
return true;
}
}
}
return false;
}主要步驟：1.根據Intent的action來查詢相應的廣播接收者列表；
2.創建相應廣播，添加到mPendingBroadcasts隊列；
3.發送MSG_EXEC_PENDING_BROADCASTS消息。將消息傳給主線程進行處理。
4.主線程mHandler接受到後就由該類的handlerMessage進行處理。在該方法中調用executePendingBroadcasts()進行處理
private void executePendingBroadcasts() {
while (true) {
BroadcastRecord[] brs = null;
synchronized (mReceivers) {//注意多線程下的同步
final int N = mPendingBroadcasts.size();
if (N <= 0) {
return;
}
brs = new BroadcastRecord[N];
mPendingBroadcasts.toArray(brs);//把待處理的廣播轉成數組形式
mPendingBroadcasts.clear();//然後就可以把mPendingBroadcasts清空
}
//for循環變量每個接受者，然後調用對應的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);
}
}
}
}處理也很簡單，查詢相應的變量，找到有多少個接受者，然後調用接受者的onReceive，該調用在主線程中，因而不要做耗時操作。在LocalBroadcastManager中還提供了同步發送廣播處理的方法：
//使用該方法會立即去讓接受者處理廣播。
public void sendBroadcastSync(Intent intent) {
if (sendBroadcast(intent)) {
executePendingBroadcasts();
}
}2.4 廣播的註銷
public void unregisterReceiver(BroadcastReceiver receiver) {
synchronized (mReceivers) {
ArrayList<IntentFilter> filters = mReceivers.remove(receiver);
if (filters == null) {
return;
}
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);
}
}
}
}
}
}註銷廣播也很簡單，找到註冊時候添加到List中的變量，然後remove掉。注意要講mReceivers,mActions裏面保存的都remove了。
3.總結
普通廣播採用Binder和系統通信，由AMS進行管理，而應用內廣播是通過Handler的消息機制來進行通信，僅在一個進程中使用。和普通廣播比，應用內廣播安全，速度快。缺點是只能在應用的一個進程中使用，不能跨進程使用。