Android 为'使用LocalBroadcastManager；粘性'；广播

我认为我不能使用发送“粘性”广播是正确的吗？ 如果是这样的话，这似乎是非常短视的，尤其是如果应用程序使用了在应用程序生命周期中可以交换的片段，并且依赖于广播数据

我认为不能使用LocalBroadcastManager发送“粘性”广播，对吗

是的，你说得对

如果是这样的话，这似乎是非常短视的，尤其是如果应用程序使用了在应用程序生命周期中可以交换的片段，并且依赖于广播数据

---

如果您愿意，欢迎您将源代码带到

LocalBroadcastManager

，并为其创建自己的粘性扩展。就我个人而言，我会使用其他存储此类数据的方法（模型片段、单例或持久数据存储，具体取决于场景）。

正如@commonware所说，我尝试使用LocalBroadcastManager源代码实现sticky。选中此项：

不确定这是否是最好的方法。到目前为止，它运行良好。就我个人而言，我更喜欢使用奥托

public class StickyLocalBroadcastManager {

private static class ReceiverRecord {
    final IntentFilter filter;
    final BroadcastReceiver receiver;
    boolean broadcasting;

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

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder(128);
        builder.append("Receiver{");
        builder.append(receiver);
        builder.append(" filter=");
        builder.append(filter);
        builder.append("}");
        return builder.toString();
    }
}

private static class BroadcastRecord {
    final Intent intent;
    final ArrayList<ReceiverRecord> receivers;

    BroadcastRecord(Intent _intent, ArrayList<ReceiverRecord> _receivers) {
        intent = _intent;
        receivers = _receivers;
    }
}

private static final String TAG = "LocalBroadcastManager";
private static final boolean DEBUG = false;

private final Context mAppContext;

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

private final ArrayList<BroadcastRecord> mPendingBroadcasts
        = new ArrayList<BroadcastRecord>();

private final ArrayList<Intent> mStickyBroadcasts
        = new ArrayList<Intent>();

static final int MSG_EXEC_PENDING_BROADCASTS = 1;

private final Handler mHandler;

private static final Object mLock = new Object();
private static StickyLocalBroadcastManager mInstance;

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

private StickyLocalBroadcastManager(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);
            }
        }
    };
}

/**
 * Register a receive for any local broadcasts that match the given IntentFilter.
 *
 * @param receiver The BroadcastReceiver to handle the broadcast.
 * @param filter   Selects the Intent broadcasts to be received.
 * @see #unregisterReceiver
 */
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);
        }
        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);
            }
            entries.add(entry);
        }
        //check sticky broadcasts
        for (Intent intent : mStickyBroadcasts) {
            if (mActions.containsKey(intent.getAction())) {
                sendBroadcast(intent, false);
            }
        }
    }
}

/**
 * Unregister a previously registered BroadcastReceiver.  <em>All</em>
 * filters that have been registered for this BroadcastReceiver will be
 * removed.
 *
 * @param receiver The BroadcastReceiver to unregister.
 * @see #registerReceiver
 */
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);
                    }
                }
            }
        }
    }
}

/**
 * remove the sticky broadcasts .
 * @param action is the action need to be removed.
 */
public void removeStickyBroadcast(String action) {
    if (action == null || action.length() <= 0) {
        return;
    }
    synchronized (mStickyBroadcasts) {
        Iterator<Intent> intentIterator = mStickyBroadcasts.iterator();
        while (intentIterator.hasNext()) {
            Intent intent = intentIterator.next();
            if (action.equalsIgnoreCase(intent.getAction())) {
                intentIterator.remove();
            }
        }
    }
}

/**
 * remove all the sticky broadcasts.
 */
public void removeAllStickyBroadcasts(){
    synchronized (mStickyBroadcasts){
        mStickyBroadcasts.clear();
    }
}

/**
 * send broadcast with specified action.
 * @param action is the action .
 * @return
 */
public boolean sendBroadcast(String action){
    Intent intent = new Intent(action);
    return sendBroadcast(intent);
}

/**
 * send broadcast with specified action.
 * @param action is the action .
 * @return
 */
public boolean sendBroadcast(String action, boolean isSticky){
    Intent intent = new Intent(action);
    return sendBroadcast(intent, isSticky);
}

/**
 * Broadcast the given intent to all interested BroadcastReceivers.  This
 * call is asynchronous; it returns immediately, and you will continue
 * executing while the receivers are run.
 *
 * @param intent The Intent to broadcast; all receivers matching this
 *               Intent will receive the broadcast.
 * @see #registerReceiver
 */
public boolean sendBroadcast(Intent intent) {
    return sendBroadcast(intent, false);
}

/**
 * Broadcast the given intent to all interested BroadcastReceivers.  This
 * call is asynchronous; it returns immediately, and you will continue
 * executing while the receivers are run.
 *
 * @param intent   The Intent to broadcast; all receivers matching this
 *                 Intent will receive the broadcast.
 * @param isSticky The flag of this intent is need to be sticky or not.
 * @see #registerReceiver
 */
public boolean sendBroadcast(Intent intent, boolean isSticky) {
    if (isSticky) {
        mStickyBroadcasts.add(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;
}

/**
 * Like {@link #sendBroadcast(Intent, boolean)}, but if there are any receivers for
 * the Intent this function will block and immediately dispatch them before
 * returning.
 */
public void sendBroadcastSync(Intent intent) {
    if (sendBroadcast(intent, false)) {
        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();
        }
        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);
            }
        }
    }
}
}

公共类StickyLocalBroadcastManager{
私有静态类接收记录{
最终目的过滤器；
最终广播接收机；
布尔广播；
接收方记录（IntentFilter\u filter，BroadcastReceiver\u receiver）{
过滤器=_过滤器；
接收器=_接收器；
}
@凌驾
公共字符串toString（）{
StringBuilder=新的StringBuilder（128）；
附加（“接收方{”）；
生成器.附加（接收方）；
builder.append（“filter=”）；
builder.append（过滤器）；
builder.append（“}”）；
返回builder.toString（）；
}
}
私有静态类广播记录{
最终意图；
最终阵列列表接收器；
广播记录（意图、阵列列表、接收器）{
意向=_意向；
接收者=_接收者；
}
}
私有静态最终字符串TAG=“LocalBroadcastManager”；
私有静态最终布尔调试=false；
私有最终上下文mAppContext；
私有最终哈希映射mreceiver
=新HashMap（）；
私有最终哈希映射
=新HashMap（）；
私人最终阵列列表mPendingBroadcasts
=新的ArrayList（）；
私人最终ArrayList mStickyBroadcasts
=新的ArrayList（）；
静态最终int MSG_EXEC_PENDING_BROADCASTS=1；
私人最终处理人；
私有静态最终对象mLock=新对象（）；
私有静态粘滞度；
公共静态StickyLocalBroadcastManager getInstance（上下文）{
已同步（mLock）{
if（minInstance==null）{
MinInstance=new StickyLocalBroadcastManager（context.getApplicationContext（））；
}
回报率；
}
}
专用StickyLocalBroadcastManager（上下文）{
mAppContext=上下文；
mHandler=新处理程序（context.getMainLooper（））{
@凌驾
公共无效handleMessage（消息消息消息）{
开关（msg.what）{
案例MSG_EXEC_未决_广播：
executePendingBroadcasts（）；
打破
违约：
超级handleMessage（msg）；
}
}
};
}
/**
*注册与给定IntentFilter匹配的任何本地广播的接收。
*
*@param receiver用于处理广播的BroadcastReceiver。
*@param filter选择要接收的意图广播。
*@see#取消注册接收者
*/
公共无效注册表接收器（广播接收器、意图过滤器过滤器）{
已同步（mreceiver）{
ReceiverRecord条目=新的ReceiverRecord（过滤器，接收器）；
ArrayList过滤器=mReceivers.get（接收器）；
if（过滤器==null）{
过滤器=新阵列列表（1）；
mreceiver.put（接收器、过滤器）；
}
过滤器。添加（过滤器）；
对于（int i=0；iif（receivers.size（）虽然此链接可以回答问题，但最好在此处包含答案的基本部分，并提供链接供参考。如果链接页面发生更改，则只有链接的答案可能会无效。@Markus感谢您的建议。第一次在Stackoverflow上发布答案。粘性广播现在已被弃用。我在e屏幕，我希望根据加载的“主”片段，在bo上加载一个小片段