Broadcasts

IntentFilter filter = new IntentFilter(Intent.ACTION_AIRPLANE_MODE_CHANGED);
registerReceiver(receiver, filter, Manifest.permission.SEND_SMS, null );

@NonNull
public static LocalBroadcastManager getInstance(@NonNull Context context) {
    synchronized (mLock) {
        if (mInstance == null) {
            mInstance = new LocalBroadcastManager(context.getApplicationContext());
        }
        return mInstance;
    }
}

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);
            }
        }
    };
}

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

// register的两个参数会封装成为该类型
private static final class ReceiverRecord {
    final IntentFilter filter;
    final BroadcastReceiver receiver;
    boolean broadcasting;
    boolean dead;

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

public void registerReceiver(@NonNull BroadcastReceiver receiver,
        @NonNull IntentFilter filter) {
    synchronized (mReceivers) {
        // 将入参包装为ReceiverRecord对象
        ReceiverRecord entry = new ReceiverRecord(filter, receiver);
        // 1. receiver对应的value还没有初始化，则初始化
        // 2. 向receiver对应的value中添加ReceiverRecord对象
        ArrayList<ReceiverRecord> filters = mReceivers.get(receiver);
        if (filters == null) {
            filters = new ArrayList<>(1);
            mReceivers.put(receiver, filters);
        }
        filters.add(entry);
        // 遍历入参filter中的actions，对于每个action
        // 1. action对应的value还没有初始化，则初始化
        // 2. 向action对应的value中添加ReceiverRecord对象
        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 boolean sendBroadcast(@NonNull Intent intent) {
    synchronized (mReceivers) {
        // 获取intent中各个数据，稍后用来与IntentFilter进行匹配
        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();

        // 获取action对应的ArrayList<ReceiverRecord>，准备进行遍历
        ArrayList<ReceiverRecord> entries = mActions.get(intent.getAction());
        if (entries != null) {
            // 匹配成功的结果将会保存到这里
            ArrayList<ReceiverRecord> receivers = null;
            for (int i=0; i<entries.size(); i++) {
                ReceiverRecord receiver = entries.get(i);

                // 防止一个BroadcastReceiver响应多次
                if (receiver.broadcasting) {
                    continue;
                }

                // 如果匹配成功，添加到receivers数组中
                // 且将其broadcasting置为true，防止同一个BroadcastReceiver响应多次
                int match = receiver.filter.match(action, type, scheme, data,
                        categories, "LocalBroadcastManager");
                if (match >= 0) {
                    if (receivers == null) {
                        receivers = new ArrayList<ReceiverRecord>();
                    }
                    receivers.add(receiver);
                    receiver.broadcasting = true;
                }
            }

            // 最后将匹配的结果里面的标志位复位，以待后面发送广播时还能接受
            // 同时将intent-receivers包装成为一个BroadcastRecord对象，这就是一个二元组
            // 最后给mHandler发送一个消息，mHandler收到消息后就会在主线程执行广播的onReceiver方法了
            if (receivers != null) {
                for (int i=0; i<receivers.size(); i++) {
                    receivers.get(i).broadcasting = false;
                }
                // mPendingBroadcasts保存的是每次发送广播后，匹配成功的广播接收者
                mPendingBroadcasts.add(new BroadcastRecord(intent, receivers));
                if (!mHandler.hasMessages(MSG_EXEC_PENDING_BROADCASTS)) {
                    mHandler.sendEmptyMessage(MSG_EXEC_PENDING_BROADCASTS);
                }
                return true;
            }
        }
    }
    return false;
}

private void executePendingBroadcasts() {
    while (true) {
        final BroadcastRecord[] brs;
        // 将mPendingBroadcasts复制到brs数组中
        // 注意这里加了锁，防止在复制的过程中，有新的广播发送，然后丢失新的结果
        synchronized (mReceivers) {
            final int N = mPendingBroadcasts.size();
            if (N <= 0) {
                return;
            }
            brs = new BroadcastRecord[N];
            mPendingBroadcasts.toArray(brs);
            mPendingBroadcasts.clear();
        }
        // 遍历brs，brs中的每一项都是一次广播发送后匹配的结果
        for (int i=0; i<brs.length; i++) {
            final BroadcastRecord br = brs[i];
            // 取出receivers中每一个receiver
            final int nbr = br.receivers.size();
            for (int j=0; j<nbr; j++) {
                final ReceiverRecord rec = br.receivers.get(j);
                // 如果receiver没有退订
                if (!rec.dead) {
                    // 调用其onReceive方法
                    rec.receiver.onReceive(mAppContext, br.intent);
                }
            }
        }
    }
}

/**
  * Like {@link #sendBroadcast(Intent)}, but if there are any receivers for
  * the Intent this function will block and immediately dispatch them before
  * returning.
  */
public void sendBroadcastSync(@NonNull Intent intent) {
    if (sendBroadcast(intent)) {
        executePendingBroadcasts();
    }
}