LocalBroadcastManager源碼分析

時間 2019-11-21

標籤 localbroadcastmanager 源碼分析简体版

原文原文鏈接

1、LocalBroadcastManager是什麼

LocalBroadcastManager是Android Support包提供了一個工具，用於在同一個應用內的不一樣組件間發送Broadcast。LocalBroadcastManager也稱爲局部通知管理器，這種通知的好處是安全性高，效率也高，適合局部通訊，能夠用來代替Handler更新UI。android

2、LocalBroadcastManager的優勢

因廣播數據在本應用範圍內傳播，你不用擔憂隱私數據泄露的問題。因此LocalBroadcastManager比BroadcastReceiver更安全。
不用擔憂別的應用僞造廣播，形成安全隱患。
相比在系統內發送全局廣播，它更高效。

3、LocalBroadcastManager使用

獲取LocalBroadcastManager實例

LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(ctx);

註冊，須要傳入BroadcastReceiver和IntentFilter對象

localBroadcastManager.registerReceiver(receiver, filter);

發送，需傳入一個Intenet對象

localBroadcastManager.sendBroadcast(intent);

註銷，須要經過建立的BroadcastReceiver對象來實現註銷

localBroadcastManager.unregisterReceiver(receiver);

4、LocalBroadcastManager使用小例子

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <TextView
        android:id="@+id/local_textview"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:gravity="center"
        android:text="LocalBroadcastReciver"
        android:textColor="@android:color/holo_orange_light"
        android:textSize="20sp" />
</LinearLayout>

public class LocalBroadcastReciverAct extends AppCompatActivity {

    private LocalBroadcastManager localBroadcastManager = null;
    private BroadcastReceiver broadcastReceiver = null;
    private IntentFilter intentFilter = null;

    private static final String ACTION = "LOCAL_BROADCAST_RECIVER_ACTION";
    private TextView localTextview = null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_local_broadcast_reciver);
        localTextview = findViewById(R.id.local_textview);
        localTextview.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                localBroadcastManager.sendBroadcast(new Intent(ACTION));
            }
        });
        localBroadcastManager = LocalBroadcastManager.getInstance(this);
    }

    @Override
    protected void onStart() {
        super.onStart();
        initReciverFilter();
        localBroadcastManager.registerReceiver(broadcastReceiver, intentFilter);
    }

    private void initReciverFilter() {
        broadcastReceiver = new MyBroadcastReciver();
        intentFilter = new IntentFilter(ACTION);
    }

    @Override
    protected void onStop() {
        super.onStop();
        localBroadcastManager.unregisterReceiver(broadcastReceiver);
    }

    private class MyBroadcastReciver extends BroadcastReceiver {

        @Override
        public void onReceive(Context context, Intent intent) {
            localTextview.setText("已接受到LocalBroadcastReciver");
        }
    }

}

效果圖數組

5、源碼分析

LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(ctx);安全

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 = new Handler(context.getMainLooper()) {

            @Override
            public void handleMessage(Message msg) {
                switch (msg.what) {
                    case MSG_EXEC_PENDING_BROADCASTS:
                        executePendingBroadcasts();
                        break;
                    default:
                        super.handleMessage(msg);
                }
            }
        };
    }

從構造方法私有化，很明顯這是一個單利模式，而且進行了加鎖操做因此是一個線程安全的單利模式；而且在LocalBroadcastManager的構造方法中咱們看見了mHandler = new Handler(context.getMainLooper())，因此能夠初步判定LocalBroadcastManager是經過handler+message實現的消息廣播，context.getMainLooper()是主線程的Looper，因此這個handler是運行在主線程的，不能進行耗時操做！
ide

localBroadcastManager.registerReceiver(broadcastReceiver, intentFilter);工具

// 廣播接收器做爲key，接收器記錄集合做爲value
private final HashMap<BroadcastReceiver, ArrayList<ReceiverRecord>> mReceivers = new HashMap<>();
// 篩選動做(類型)做爲key，接收器記錄集合做爲value
private final HashMap<String, ArrayList<ReceiverRecord>> mActions = new HashMap<>();

public void registerReceiver(BroadcastReceiver receiver, IntentFilter filter) {
        synchronized (mReceivers) {
            ReceiverRecord entry = new ReceiverRecord(filter, receiver);
            ArrayList<ReceiverRecord> filters = mReceivers.get(receiver);
            if (filters == null) {
                filters = new ArrayList<>(1);
                mReceivers.put(receiver, filters);
            }
            filters.add(entry);
            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);
            }
        }
    }

registerReceiver只是作了一些數據的分類保存操做。ReceiverRecord是一個內部類，主要是存儲廣播接收器BroadcastReceiver，篩選器IntentFilter，及廣播運行狀態。oop

private static final class ReceiverRecord {
        final IntentFilter filter; // 篩選器
        final BroadcastReceiver receiver; // 廣播接收器
        boolean broadcasting; // 是否處於激活狀態
        boolean dead; // 廣播是否已經銷燬
        ............
    }

private static final String ACTION = "LOCAL_BROADCAST_RECIVER_ACTION";
localBroadcastManager.sendBroadcast(new Intent(ACTION));源碼分析

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;
                // 遍歷集合，找到符合條件的ReceiverRecord
                for (int i=0; i<entries.size(); i++) {
                    ReceiverRecord receiver = entries.get(i); 
                    if (debug) Log.v(TAG, "Matching against filter " + receiver.filter);
                    
                    // 已經處於激活狀態的ReceiverRecord過濾掉（主要避免重複加入）
                    if (receiver.broadcasting) {
                        if (debug) {
                            Log.v(TAG, "  Filter's target already added");
                        }
                        continue;
                    }

                    // 判斷本次循環取出的ReceiverRecord，在動做、數據，分類是否匹配
                    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); // 符合條件的加入到receivers中
                        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;  // 篩選完後，將狀態重置
                    }
                    // 從新構造一個BroadcastRecord對象，並添加到待發送狀態下的廣播列表
                    mPendingBroadcasts.add(new BroadcastRecord(intent, receivers));
                    // 查看handler在排隊執行的消息中是否有MSG_EXEC_PENDING_BROADCASTS類型，
                    // 沒有，添加一個MSG_EXEC_PENDING_BROADCASTS類型的消息
                    if (!mHandler.hasMessages(MSG_EXEC_PENDING_BROADCASTS)) {
                        mHandler.sendEmptyMessage(MSG_EXEC_PENDING_BROADCASTS);
                    }
                    return true;
                }
            }
        }
        return false;
    }

sendBroadcast()中主要進行的是廣播接受器的篩選操做，而後通知handler準備調用篩選出來的廣播接收器。this

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 void executePendingBroadcasts() {
        while (true) {
            final BroadcastRecord[] brs; // 使用數組存放，廣播接受記錄
            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++) {
                final BroadcastRecord br = brs[i];
                final int nbr = br.receivers.size();
                // 遍歷調用接收器方法
                for (int j=0; j<nbr; j++) {
                    final ReceiverRecord rec = br.receivers.get(j);
                    // 不在銷燬狀態下，調用接收器的onReceive()方法執行
                    if (!rec.dead) {
                        rec.receiver.onReceive(mAppContext, br.intent);
                    }
                }
            }
        }
    }

executePendingBroadcasts()執行接收器的onReceive()方法。
spa

localBroadcastManager.unregisterReceiver(broadcastReceiver);線程

public void unregisterReceiver(BroadcastReceiver receiver) {
        synchronized (mReceivers) {
            // 從mReceivers中移除，並返回對應的記錄集合
            final ArrayList<ReceiverRecord> filters = mReceivers.remove(receiver);
            if (filters == null) {
                return;
            }
            // 遍歷接收器記錄集合，並設置dead = true; 避免正在運行的executePendingBroadcasts()執行此接收器的回調
            for (int i=filters.size()-1; i>=0; i--) {
                final ReceiverRecord filter = filters.get(i);
                filter.dead = true;
                for (int j=0; j<filter.filter.countActions(); j++) {
                    final String action = filter.filter.getAction(j);
                    final ArrayList<ReceiverRecord> receivers = mActions.get(action);
                    if (receivers != null) {
                        for (int k=receivers.size()-1; k>=0; k--) {
                            final ReceiverRecord rec = receivers.get(k);
                            if (rec.receiver == receiver) {
                                rec.dead = true;
                                receivers.remove(k);
                            }
                        }
                        if (receivers.size() <= 0) {
                            mActions.remove(action);
                        }
                    }
                }
            }
        }
    }

unregisterReceiver()中主要是資源的釋放，並將註冊的BroadcastReceiver相關信息，從集合中刪除，並設置BroadcastReceiver對應的ReceiverRecord的dead狀態標記爲true，避免被執行。