基本使用
LocalBroadcastManager是Android Support包提供了一个工具，用于在同一个应用内的不同组件间发送BroadcastReceiver。
android.support.v4.content.LocalBroadcastManager工具类，可以实现在自己的进程内进行局部广播发送与注册，使用它比直接通过sendBroadcast(Intent)发送系统全局广播有以下几个好处：
- 因广播数据在本应用范围内传播，不用担心隐私数据泄露的问题
- 不用担心别的应用伪造广播，造成安全隐患
- 相比在系统内发送全局广播，它更高效
广播的注册
var mLocalBroadcastManager: LocalBroadcastManager? = null
var mReceiver: BroadcastReceiver? = null
val filter = IntentFilter()
filter.addAction("action")
mReceiver = object : BroadcastReceiver() {
override fun onReceive(context: Context?, intent: Intent?) {
}
}
mLocalBroadcastManager = LocalBroadcastManager.getInstance(this)
mLocalBroadcastManager?.registerReceiver(mReceiver!!, filter)
反注册
mLocalBroadcastManager.unregisterReceiver(mReceiver!!)
广播的发送
LocalBroadcastManager.getInstance(context).sendBroadcast(new Intent("action"));
源码解析
注册广播时，会将BroadcastReceiver和IntentFilter保存到HashMap中。发送广播时，则根据IntentFilter的Action值从已保存的HashMap找到对应接受者，并发送Handler消息去执行receiver的onReceive方法。同步方法则直接调用receiver的onReceive方法。
成员变量
private final HashMap<BroadcastReceiver, ArrayList<IntentFilter>> mReceivers
= new HashMap<BroadcastReceiver, ArrayList<IntentFilter>>();//用于保存注册的BroadcastReceiver和IntentFilter
private final HashMap<String, ArrayList<ReceiverRecord>> mActions
= new HashMap<String, ArrayList<ReceiverRecord>>();//用于保存action和ReceiverRecord集合
private final ArrayList<BroadcastRecord> mPendingBroadcasts
= new ArrayList<BroadcastRecord>();//用于保存待分发的广播
BroadcastRecord
主要是对Intent和ReceiverRecord的封装
private static class BroadcastRecord {
final Intent intent;
final ArrayList<ReceiverRecord> receivers;
BroadcastRecord(Intent _intent, ArrayList<ReceiverRecord> _receivers) {
intent = _intent;
receivers = _receivers;
}
}
ReceiverRecord
主要是对IntentFilter和BroadcastReceiver的封装
private static class ReceiverRecord {
final IntentFilter filter;
final BroadcastReceiver receiver;
boolean broadcasting;
ReceiverRecord(IntentFilter _filter, BroadcastReceiver _receiver) {
filter = _filter;
receiver = _receiver;
}
}
registerReceiver
注册广播
public void registerReceiver(BroadcastReceiver receiver, IntentFilter filter) {
synchronized (mReceivers) {
ReceiverRecord entry = new ReceiverRecord(filter, receiver);
ArrayList<IntentFilter> filters = mReceivers.get(receiver);
if (filters == null) {
filters = new ArrayList<IntentFilter>(1);
mReceivers.put(receiver, filters);//添加receiver和IntentFilter
}
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);
mActions.put(action, entries);//添加action和ReceiverRecord
}
entries.add(entry);
}
}
}
- 首先通过查找mReceivers中找到已经注册的IntentFilter，并添加进ArrayList<IntentFilter>中
- 遍历IntentFilter的action，将action对应的ReceiverRecord添加进ArrayList<ReceiverRecord>中
其实注册动作就是向HashMap中添加元素，进行保存
unregisterReceiver
反注册广播
public void unregisterReceiver(BroadcastReceiver receiver) {
synchronized (mReceivers) {
ArrayList<IntentFilter> filters = mReceivers.remove(receiver);//根据receiver得到ArrayList<IntentFilter>并从mReceivers中移除
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);//获取ReceiverRecord的集合
if (receivers != null) {
for (int k=0; k<receivers.size(); k++) {
if (receivers.get(k).receiver == receiver) {
receivers.remove(k);//移除ReceiverRecord
k--;
}
}
if (receivers.size() <= 0) {
mActions.remove(action);//如果action对应的ArrayList<ReceiverRecord>为空代表这个action没有注册的广播了，进行移除
}
}
}
}
}
}
反注册的过程与注册的过程相反，主要是从两个HashMap移除数据
sendBroadcast
广播的发送，代码比较长，我把无关紧要的debug代码和log删除了
public boolean sendBroadcast(Intent intent) {
synchronized (mReceivers) {
//得到Intent中的action、type、data、scheme和categories
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();
ArrayList<ReceiverRecord> entries = mActions.get(intent.getAction());//从mActions得到ReceiverRecord的集合，也就是我们需要广播的对象
if (entries != null) {
ArrayList<ReceiverRecord> receivers = null;
for (int i=0; i<entries.size(); i++) {
ReceiverRecord receiver = entries.get(i);
if (receiver.broadcasting) {
continue;//正在广播则不处理
}
int match = receiver.filter.match(action, type, scheme, data,
categories, "LocalBroadcastManager");//根据action、type、scheme、data和categories判断是否 匹配
if (match >= 0) {
if (receivers == null) {
receivers = new ArrayList<ReceiverRecord>();
}
receivers.add(receiver);//添加进待广播ReceiverRecord的集合中
receiver.broadcasting = true;//广播标志位设置为true
} else {
//省略部分代码
}
}
if (receivers != null) {
for (int i=0; i<receivers.size(); i++) {
receivers.get(i).broadcasting = false;//广播标志位设置为false
}
mPendingBroadcasts.add(new BroadcastRecord(intent, receivers));//封装intent和receivers并添加到待处理的广播集合中
if (!mHandler.hasMessages(MSG_EXEC_PENDING_BROADCASTS)) {
mHandler.sendEmptyMessage(MSG_EXEC_PENDING_BROADCASTS);//发送消息进行广播分发
}
return true;
}
}
}
return false;
}
LocalBroadcastManager#Handler
收到消息之后进行消息分发，Handler创建的之后传入的Looper是主线程的，那么我们的回调也就切换到主线程中了
private LocalBroadcastManager(Context context) {
mAppContext = context;
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);
}
}
};
}
executePendingBroadcasts
广播的分发，遍历待处理的集合，并调用onReceive进行分发
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();
}
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的onReceive
}
}
}
}
这里面将mPendingBroadcasts可能发生改变看，所以需要同步代码块，集合转换数组，为了提高效率，同步代码块中只对原集合操作保证其安全，并不需要包括广播分发。
sendBroadcastSync
同步分发广播，并不会切换线程，回调的线程是在调用者的线程
public void sendBroadcastSync(Intent intent) {
if (sendBroadcast(intent)) {
executePendingBroadcasts();
}
}
