LocalBroadcastManager和Activity生命周期

Question

因此，我正在研究从一些长期运行的网络操作中将回调接口更改为本地广播的可行性。 由于Activity生命周期为需要修改UI的异步请求创建了各种复杂性（将Activity与onDestroy()的回调断开连接，不要在onSaveInstanceState()之后修改FragmentTransaction ，等等，我在想使用本地广播更有意义，我们可以在生命周期事件中注册/取消注册接收器。

但是，当在配置更改期间销毁并重新创建活动时，没有注册广播接收器的这个小窗口时间（例如，在onPause()/onResume()之间）。 因此，例如，如果我们在onCreate()启动异步请求，如果savedInstanceState == null （例如，对于活动的第一次启动）， 如果用户更改了它们，则完成时发送的广播是否可能丢失操作完成前的设备方向？ （即接收器在onPause（）上未注册，然后操作完成，然后接收器在onResume（）中重新注册）

如果是这种情况，那么它会增加我们需要添加支持的额外复杂性，而且可能不值得切换。 我已经研究了其他东西，比如Otto EventBus库，但我不确定它是否有同样的问题需要担心。

Answer 1

如Activity的onRetainNonConfigurationInstance()方法中所述，系统在Activity重启的过程中禁用主线程中的消息队列处理。 这可确保发布到主线程的事件始终在Activity生命周期的稳定点传递。

然而，似乎是在一个设计缺陷sendBroadcast()的方法LocalBroadcastManager ，因为它计算注册BroadcastReceiver从投稿线S排队广播之前要在主线程上传递的，而不是在主线程上评价他们，在广播传送时。 虽然这使它能够报告传递的成功或失败，但它没有提供正确的语义来允许从主线程中临时安全地注销BroadcastReceiver ，而不会丢失潜在的广播。

解决方案是使用Handler从主线程发布广播，使用sendBroadcastSync()方法，以便立即传送广播而不是重新发布。 这是一个实现这个的示例实用程序类：

public class LocalBroadcastUtils extends Handler {
    private final LocalBroadcastManager manager;

    private LocalBroadcastUtils(Context context) {
        super(context.getMainLooper());
        manager = LocalBroadcastManager.getInstance(context);
    }

    @Override
    public void handleMessage(Message msg) {
        manager.sendBroadcastSync((Intent) msg.obj);
    }

    private static LocalBroadcastUtils instance;

    public static void sendBroadcast(Context context, Intent intent) {
        if (Looper.myLooper() == context.getMainLooper()) {
            // If this is called from the main thread, we can retain the
            // "optimization" provided by the LocalBroadcastManager semantics.
            // Or we could just revert to evaluating matching BroadcastReceivers
            // at the time of delivery consistently for all cases.
            LocalBroadcastManager.getInstance(context).sendBroadcast(intent);
        } else {
            synchronized (LocalBroadcastUtils.class) {
                if (instance == null) {
                    instance = new LocalBroadcastUtils(context);
                }
            }
            instance.sendMessage(instance.obtainMessage(0, intent));
        }
    }
}

Answer 2

要解决此问题，您需要一个即使在配置更改时重新创建活动时仍保持活动的组件。 您可以使用应用程序单例或保留的片段 。

如果您使用Otto或EventBus ，那么您可以创建一个事件总线实例作为应用程序的字段，它将保持与设备配置更改（如方向更改）分离。 您的活动需要在onStart()注册事件监听器，它将接收最新事件。

如果使用保留的片段，则片段将保持活动状态，直到活动未完成。 配置更改也不会释放保留片段的实例。 将保留的Fragment设为不可见（从onCreateView()方法返回null onCreateView()也是一种很好的做法。 在你的活动的onStart() ，你可以随时从该片段中获取最新状态。

您可以将LocalBroadcastManager与其中一种方法一起使用，但它并未真正解决该问题。 它就像任何其他事件总线一样，但是带有丑陋且不方便的API;）

Answer 3

在这种情况下，我发现android加载器极其有用。

在我的情况下，我需要从另一个应用程序接收广播并管理我的应用程序中的片段转换。

所以我在下面做了。

/**
 * LoaderManager callbacks
 */
private LoaderManager.LoaderCallbacks<Intent> mLoaderCallbacks =
        new LoaderManager.LoaderCallbacks<Intent>() {

            @Override
            public Loader<Intent> onCreateLoader(int id, Bundle args) {
                Logger.v(SUB_TAG + " onCreateLoader");
                return new MyLoader(MyActivity.this);
            }

            @Override
            public void onLoadFinished(Loader<Intent> loader, Intent intent) {
                Logger.i(SUB_TAG + " onLoadFinished");
                // Display our data
                if (intent.getAction().equals(INTENT_CHANGE_SCREEN)) {
                    if (false == isFinishing()) {
                        // handle fragment transaction 
                        handleChangeScreen(intent.getExtras());

                    }
                } else if (intent.getAction().equals(INTENT_CLOSE_SCREEN)) {
                    finishActivity();
                }
            }

            @Override
            public void onLoaderReset(Loader<Intent> loader) {
                Logger.i(SUB_TAG + " onLoaderReset");
            }
};

 /**
 * Listening to change screen commands. We use Loader here because
 * it works well with activity life cycle.
 * eg, like when the activity is paused and we receive command, it
 * will be delivered to activity only after activity comes back.  
 * LoaderManager handles this.
 */
private static class MyLoader extends Loader<Intent> {

    private Intent mIntent;
    BroadcastReceiver mCommadListner;
    public MyLoader(Context context) {
        super(context);
        Logger.i(SUB_TAG + " MyLoader");
    }

    private void registerMyListner() {
        if (mCommadListner !=  null) {
            return;
        }
        Logger.i(SUB_TAG + " registerMyListner");
        mCommadListner = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                String action = intent.getAction();
                if (action == null || action.isEmpty()) {
                    Logger.i(SUB_TAG + " intent action null/empty returning: ");
                    return;
                }
                Logger.i(SUB_TAG + " intent action: " + action);
                mIntent = intent;
                deliverResult(mIntent);
            }
        };
        IntentFilter filter = new IntentFilter();
        filter.addAction(INTENT_CHANGE_SCREEN);
        getContext().registerReceiver(mCommadListner, filter);
    }

    @Override
    protected void onStartLoading() {
        Logger.i(SUB_TAG + " onStartLoading");
        if (mIntent != null) {
            deliverResult(mIntent);
        }
        registerMyListner();
    }

    @Override
    protected void onReset() {
        Logger.i(SUB_TAG + "Loader onReset");
        if (mCommadListner != null) {
            getContext().unregisterReceiver(mCommadListner);
            mCommadListner = null;
        }
    }
}

Activity#onCreate or Fragment@onActivityCreated()
@Override
protected void onCreate(Bundle savedInstanceState) {
    // Listening to change screen commands from broadcast listner. We use Loader here because
    // it works well with activity life cycle.
    // eg, like when the activity is paused and we receive intent from broadcast, it will delivered
    // to activity only after activity comes back. LoaderManager handles this.
    getLoaderManager().initLoader(0, null, mLoaderCallbacks);
}

Answer 4

如果您的活动将暂停或重新创建，则正常广播将会丢失。 您可以使用粘性广播，但它不能与LocalBroadcastManager一起LocalBroadcastManager ，您必须记住通过调用Context.removeStickyBroadcast()手动删除粘性广播。 系统会保留粘性广播（即使您的活动已暂停），直到您决定删除它为止。

EventBus提供postSticky（）方法，类似于粘性广播。