Android 的 LocalBroadcastManager 源码分析

1、简述

在安卓中广播通常分为普通广播、有序广播、粘性广播和本地广播，其中本地广播相比而言具有以下特点

• 安全：本地广播只能在其APP中发送和接收，其他应用无法获取和接收；
• 高效：本地广播发送和接收效率较高；
• 简单：无静态注册方式，使用其封装后的注册、发送和解除方法。

2、简单使用

• 获取对象：通过LocalBroadcastManager获取LocalBroadcast对象；

mLocalBroadcastManager = LocalBroadcastManager.getInstance(this);

• 注册广播:自定义Action添加至IntentFilter中；

IntentFilter intentFilter = new IntentFilter();
intentFilter.addAction("com.xiaohan.LocalBroadcast");
mLocalBroadcastManager.registerReceiver(mLocalBroadcastReceiver,intentFilter);

• 发送广播：调用LocalBroadcastManager中封装后的sendBroadcast发送广播信息；

Intent intent = new Intent();
intent.setAction("com.xiaohan.LocalBroadcast");
intent.putExtra("test",10);
mLocalBroadcastManager.sendBroadcast(intent);

• 广播接收者：自定义广播接收者与普通的广播一样，只需要继承BroadcastReceiver并重写onReceive即可；

private class LocalBroadcastReceiver extends BroadcastReceiver{

        @Override
        public void onReceive(Context context, Intent intent) {
            Log.i(TAG, "onReceive: "+intent.getAction());
            Log.i(TAG, "onReceive: "+intent.getIntExtra("test",1));
        }
    }

• 解除注册：调用LocalBroadcastManager中封装后的unregisterReceiver解除注册

mLocalBroadcastManager.unregisterReceiver(mLocalBroadcastReceiver);

3、源码分析

对于源码分析的思路可以基于第一部分中提到的安全、高效、简单的特点，对源码进行分析，对LocalBroadcastManager类中的构造方法、关键集合、注册广播、发送广播、接收处理和解除注册。
构造方法
查看源码的构造方法可以看出，其为private修饰，说明其采用的是单例模式，其内部通过一个Handler维护，在创建Handler时，添加的是context.getMainLooper()，因此本地广播中运行在主线程中。

private LocalBroadcastManager(Context context) {
        this.mAppContext = context;
        this.mHandler = new Handler(context.getMainLooper()) {
            public void handleMessage(Message msg) {
                switch(msg.what) {
                case 1:
                    LocalBroadcastManager.this.executePendingBroadcasts();
                    break;
                default:
                    super.handleMessage(msg);
                }

            }
        };
    }

关键集合

private final HashMap<BroadcastReceiver, ArrayList<LocalBroadcastManager.ReceiverRecord>> mReceivers = new HashMap();
private final HashMap<String, ArrayList<LocalBroadcastManager.ReceiverRecord>> mActions = new HashMap();
private final ArrayList<LocalBroadcastManager.BroadcastRecord> mPendingBroadcasts = new ArrayList();

LocalBroadcastManager中通过以上三个关键的集合进行维护，其含义如下：

• mReceivers ：其key为BroadcastReceiver，value为ArrayList<LocalBroadcastManager.ReceiverRecord>集合，其中ReceiverRecord的构造参数为IntentFilter和BroadcastReceiver，这是由于同一个BroadcastReceiver中可以包含多个IntentFilter对象，接收多个Action；
• mActions ：其key为action，value为ArrayList<LocalBroadcastManager.ReceiverRecord>，其包含了所有的本地广播的Action集合信息，在注册时添加，发送时遍历，解除时删除；
• mPendingBroadcasts ：其包含了所有的本地广播的BroadcastReceiver和Action的集合信息

注冊广播

 public void registerReceiver(@NonNull BroadcastReceiver receiver, @NonNull IntentFilter filter) {
        HashMap var3 = this.mReceivers;
        synchronized(this.mReceivers) {
        //1、广播添加：检测集合中是否包含注册的广播信息，如未包含添加至mReceivers中
            LocalBroadcastManager.ReceiverRecord entry = new LocalBroadcastManager.ReceiverRecord(filter, receiver);
            ArrayList<LocalBroadcastManager.ReceiverRecord> filters = (ArrayList)this.mReceivers.get(receiver);
            if (filters == null) {
                filters = new ArrayList(1);
                this.mReceivers.put(receiver, filters);
            }
            filters.add(entry);
	//2、Action添加：查找集合中是否包含添加的action，未包含添加至mActions中
            for(int i = 0; i < filter.countActions(); ++i) {
                String action = filter.getAction(i);
                ArrayList<LocalBroadcastManager.ReceiverRecord> entries = (ArrayList)this.mActions.get(action);
                if (entries == null) {
                    entries = new ArrayList(1);
                    this.mActions.put(action, entries);
                }

                entries.add(entry);
            }
        }
    }

发送广播

 public boolean sendBroadcast(@NonNull Intent intent) {
        HashMap var2 = this.mReceivers;
        synchronized(this.mReceivers) {
        String action = intent.getAction()
        ...
        //1、根据action查找到广播信息
        ArrayList<LocalBroadcastManager.ReceiverRecord> entries = (ArrayList)this.mActions.get(intent.getAction());
        //2、遍历所有的mActions 集合，获取其对应的广播
        for(i = 0; i < entries.size(); ++i) {
				LocalBroadcastManager.ReceiverRecord receiver = (LocalBroadcastManager.ReceiverRecord)entries.get(i);
		//3、查看该广播是否已经解除注册，否则添加至需要发送的广播接收者中
				 if (receiver.broadcasting) {
                        if (debug) {
                            Log.v("LocalBroadcastManager", "  Filter's target already added");
                        }
                    } else {
					int match = receiver.filter.match(action, type, scheme, data, categories, "LocalBroadcastManager");
						if (match >= 0) {
						if (receivers == null) {
                                receivers = new ArrayList();
                            }

                            receivers.add(receiver);
                            receiver.broadcasting = true;
						}
						...
				//4、更改广播的状态
					 if (receivers != null) {
                    for(i = 0; i < receivers.size(); ++i) {
                        ((LocalBroadcastManager.ReceiverRecord)receivers.get(i)).broadcasting = false;
                    }
			//	5、通过Handler发送至executePendingBroadcasts()中进行处理
                    this.mPendingBroadcasts.add(new LocalBroadcastManager.BroadcastRecord(intent, receivers));
                    if (!this.mHandler.hasMessages(1)) {
                        this.mHandler.sendEmptyMessage(1);
                    }
					...
                }
					}
		}
}

void executePendingBroadcasts() {
//1、一直不断的查看是否有广播发送需要处理
 while(true) {
synchronized(this.mReceivers) {
				//2、获取所有的广播对象
                int N = this.mPendingBroadcasts.size();
                if (N <= 0) {
                    return;
                }

                brs = new LocalBroadcastManager.BroadcastRecord[N];
                this.mPendingBroadcasts.toArray(brs);
                this.mPendingBroadcasts.clear();
            }
		//3、遍历所有的广播对象，查看该广播状态的.dead是否为true，否则就将该广播信息发送至所有的广播接收者中，在其重写的onReceive获取到发送的广播信息。
            for(int i = 0; i < brs.length; ++i) {
                LocalBroadcastManager.BroadcastRecord br = brs[i];
                int nbr = br.receivers.size();

                for(int j = 0; j < nbr; ++j) {
                    LocalBroadcastManager.ReceiverRecord rec = (LocalBroadcastManager.ReceiverRecord)br.receivers.get(j);
                    if (!rec.dead) {
                        rec.receiver.onReceive(this.mAppContext, br.intent);
                    }
                }
            }
	}

}

解除注册

public void unregisterReceiver(@NonNull BroadcastReceiver receiver) {
        HashMap var2 = this.mReceivers;
        synchronized(this.mReceivers) {
        //1、移除广播信息
            ArrayList<LocalBroadcastManager.ReceiverRecord> filters = (ArrayList)this.mReceivers.remove(receiver);
          //2、如果IntentFilter不为空，则移除该广播对应的Action信息，并对其dead属性修改为true
            if (filters != null) {
                for(int i = filters.size() - 1; i >= 0; --i) {
                    LocalBroadcastManager.ReceiverRecord filter = (LocalBroadcastManager.ReceiverRecord)filters.get(i);
                    filter.dead = true;

                    for(int j = 0; j < filter.filter.countActions(); ++j) {
                        String action = filter.filter.getAction(j);
                        ArrayList<LocalBroadcastManager.ReceiverRecord> receivers = (ArrayList)this.mActions.get(action);
                        if (receivers != null) {
                            for(int k = receivers.size() - 1; k >= 0; --k) {
                                LocalBroadcastManager.ReceiverRecord rec = (LocalBroadcastManager.ReceiverRecord)receivers.get(k);
                                if (rec.receiver == receiver) {
                                    rec.dead = true;
                                    receivers.remove(k);
                                }
                            }

                            if (receivers.size() <= 0) {
                                this.mActions.remove(action);
                            }
                 ...
    }

至此我们对于源码就分析结束，针对安全、高效和简单分析如下：
安全：其采用自定义的广播机制，通过集合进行维护，因此该广播只能运行在其应用中；
高效：常见的广播通过Binder和AMS（Activity Manager Service）进行维护，而本地广播通过Handler进行维护，其效率较高；
简单：常见的广播包括静态和动态方式，本地广播通过LocalBroadcastManager维护，其注册、发送和解除都在该类中，便于调用和源码查看。