使用 LocalBroadcastManager 从 Fragment 到 Activity 进行通信 [英] Using LocalBroadcastManager to communicate from Fragment to Activity

问题描述

当我刚开始进行 Android 应用程序开发时，这个问题是作为我的第一个 Android 项目之一创建的.由于历史原因，我保留它，但您应该考虑改用 EventBus 或 RxJava.这是一个巨大的混乱.

This question was created as part of one of my first Android projects when I was just starting out with Android application development. I'm keeping this for historical reasons, but you should consider using EventBus or RxJava instead. This is a gigantic mess.

请不要考虑使用它.谢谢.

Please DO NOT CONSIDER using this. Thank you.

事实上，如果你想要一些很酷的东西来解决使用具有多个片段"的单个活动的问题，那么使用 流畅自定义视图组.

In fact, if you want something cool that solves the problem of using a single activity with multiple "fragments", then use flowless with custom viewgroups.

我已经实现了一种启动 Fragment 创建的方法，从 Fragments 使用广播意图通过 LocalBroadcastManager 告诉 Activity 要实例化的 Fragment.

I have implemented a way to initiate the creation of Fragments, from Fragments using a broadcast intent through the LocalBroadcastManager to tell the Activity what Fragment to instantiate.

我知道这是一段非常长的代码，但我不是要求调试，它按我的预期完美运行 - 接收到数据，创建可以由 Bundles 参数化，并且 Fragment 不直接实例化其他片段.

I know this is a terribly long amount of code, but I'm not asking for debugging, it works perfectly as I intended - the data is received, the creation can be parametrized by Bundles, and Fragments don't directly instantiate other Fragments.

public abstract class FragmentCreator implements Parcelable
{
public static String fragmentCreatorKey = "fragmentCreator";
public static String fragmentCreationBroadcastMessage = "fragment-creation";
public static String fragmentDialogCreationBroadcastMessage = "fragment-dialog-creation";

protected Bundle arguments;
protected Boolean hasBundle;

public FragmentCreator(Bundle arguments, boolean hasBundle)
{
    this.arguments = arguments;
    this.hasBundle = hasBundle;
}

protected FragmentCreator(Parcel in)
{
    hasBundle = (Boolean) in.readSerializable();
    if (hasBundle == true && arguments == null)
    {
        arguments = in.readBundle();
    }
}

public Fragment createFragment()
{
    Fragment fragment = instantiateFragment();
    if (arguments != null)
    {
        fragment.setArguments(arguments);
    }
    return fragment;
}

protected abstract Fragment instantiateFragment();

@Override
public int describeContents()
{
    return 0;
}

@Override
public void writeToParcel(Parcel dest, int flags)
{
    dest.writeSerializable(hasBundle);
    if (arguments != null)
    {
        arguments.writeToParcel(dest, 0);
    }
}

public void sendFragmentCreationMessage(Context context)
{
    Intent intent = new Intent(FragmentCreator.fragmentCreationBroadcastMessage);
    intent.putExtra(FragmentCreator.fragmentCreatorKey, this);
    LocalBroadcastManager.getInstance(context).sendBroadcast(intent);
}

public void sendDialogFragmentCreationMessage(Context context)
{
    Intent intent = new Intent(FragmentCreator.fragmentDialogCreationBroadcastMessage);
    intent.putExtra(FragmentCreator.fragmentCreatorKey, this);
    LocalBroadcastManager.getInstance(context).sendBroadcast(intent);
}
}

这样，创建的 Fragment 如下所示:

This way, a Fragment that is created looks like this:

public class TemplateFragment extends Fragment implements GetActionBarTitle, View.OnClickListener
{
 private int titleId;

public TemplateFragment()
{
    titleId = R.string.app_name;
}

@Override
public int getActionBarTitleId()
{
    return titleId;
}

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState)
{
    View rootView = inflater.inflate(R.layout.fragment_template, container, false);
    return rootView;
}

@Override
public void onViewCreated(View view, Bundle savedInstanceState)
{
    super.onViewCreated(view, savedInstanceState);
}

@Override
public void onClick(View v)
{
}

public static class Creator extends FragmentCreator
{
    public Creator()
    {
        super(null, false);
    }

    public Creator(Bundle bundle)
    {
        super(bundle, true);
    }

    protected Creator(Parcel in)
    {
        super(in);
    }

    @Override
    protected Fragment instantiateFragment()
    {
        return new TemplateFragment();
    }

    @SuppressWarnings("unused")
    public static final Parcelable.Creator<TemplateFragment.Creator> CREATOR = new Parcelable.Creator<TemplateFragment.Creator>()
    {
        @Override
        public TemplateFragment.Creator createFromParcel(Parcel in)
        {
            return new TemplateFragment.Creator(in);
        }

        @Override
        public TemplateFragment.Creator[] newArray(int size)
        {
            return new TemplateFragment.Creator[size];
        }
    };
}
}

可以处理消息的初始容器活动如下所示:

The initial container activity that can process the messages looks like this:

        Intent intent = new Intent();
        intent.setClass(this.getActivity(), ContainerActivity.class);
        intent.putExtra(FragmentCreator.fragmentCreatorKey,
                new TemplateFragment.Creator());
        startActivity(intent);

片段像这样实例化其他片段":

And the Fragments "instantiate other Fragments" like this:

  Bundle bundle = new Bundle();
  bundle.putParcelable("argument", data);
  TemplateFragment.Creator creator = new TemplateFragment.Creator(bundle);
  creator.sendFragmentCreationMessage(getActivity());

并且容器Activity接收到实例化请求:

And the Container Activity receives the instantiation request:

public class ContainerActivity extends ActionBarActivity implements SetFragment, ShowDialog
{
private BroadcastReceiver mFragmentCreationMessageReceiver = new BroadcastReceiver()
{
    @Override
    public void onReceive(Context context, Intent intent)
    {
        setFragment((FragmentCreator) intent.getParcelableExtra(FragmentCreator.fragmentCreatorKey));
    }
};

private BroadcastReceiver mFragmentDialogCreationMessageReceiver = new BroadcastReceiver()
{
    @Override
    public void onReceive(Context context, Intent intent)
    {
        showDialog((FragmentCreator) intent.getParcelableExtra(FragmentCreator.fragmentCreatorKey));
    }
};

@Override
public void onCreate(Bundle saveInstanceState)
{
    super.onCreate(saveInstanceState);
    this.setContentView(R.layout.activity_container);
    getActionBar().setDisplayHomeAsUpEnabled(true);
    if (saveInstanceState == null)
    {
        Fragment fragment = ((FragmentCreator) getIntent().getParcelableExtra(
                FragmentCreator.fragmentCreatorKey)).createFragment();
        if (fragment != null)
        {
            replaceFragment(fragment);
        }
    }
    else
    {
        this.getActionBar()
                .setTitle(
                        ((GetActionBarTitle) (this.getSupportFragmentManager()
                                .findFragmentById(R.id.activity_container_container)))
                                .getActionBarTitleId());
    }
    getSupportFragmentManager().addOnBackStackChangedListener(new OnBackStackChangedListener()
    {
        public void onBackStackChanged()
        {
            int backCount = getSupportFragmentManager().getBackStackEntryCount();
            if (backCount == 0)
            {
                finish();
            }
        }
    });
}

@Override
protected void onResume()
{
    LocalBroadcastManager.getInstance(this).registerReceiver(mFragmentCreationMessageReceiver,
            new IntentFilter(FragmentCreator.fragmentCreationBroadcastMessage));
    LocalBroadcastManager.getInstance(this).registerReceiver(mFragmentDialogCreationMessageReceiver,
            new IntentFilter(FragmentCreator.fragmentDialogCreationBroadcastMessage));
    super.onResume();
}

@Override
protected void onPause()
{
    super.onPause();
    LocalBroadcastManager.getInstance(this).unregisterReceiver(mFragmentCreationMessageReceiver);
    LocalBroadcastManager.getInstance(this).unregisterReceiver(
            mFragmentDialogCreationMessageReceiver);
}

@Override
public void setFragment(FragmentCreator fragmentCreator)
{
    Fragment fragment = fragmentCreator.createFragment();
    replaceFragment(fragment);
}

public void replaceFragment(Fragment fragment)
{
    if (fragment != null)
    {
        this.setTitle(((GetActionBarTitle) fragment).getActionBarTitleId());
        getSupportFragmentManager().beginTransaction()
                .replace(R.id.activity_container_container, fragment).addToBackStack(null).commit();
    }
}

@Override
public void showDialog(FragmentCreator fragmentCreator)
{
    FragmentManager fm = getSupportFragmentManager();
    Fragment fragment = fragmentCreator.createFragment();
    if (fragment instanceof DialogFragment)
    {
        DialogFragment df = (DialogFragment) fragment;
        df.show(fm, "dialog");
    }
    else
    {
        Log.e(this.getClass().getSimpleName(), "showDialog() called with non-dialog parameter!");
    }
}

@Override
public boolean onOptionsItemSelected(MenuItem item)
{
    if (item.getItemId() == android.R.id.home)
    {
        this.onBackPressed();
    }
    return super.onOptionsItemSelected(item);
}
}

我的问题是，这实际上是一个好主意，还是过度设计"的可怕案例(为每个 Fragment 创建一个 Factory 并以本地广播的形式将其发送到 Activity，而不仅仅是投射最可能的持有者活动界面的活动并像那样调用函数)?

My question is, is this actually a good idea, or is this a terrible case of "over-engineering" (creating a Factory for each Fragment and sending it to the Activity in the form of a local broadcast, rather than just casting the Activity of the most possible holder activity's interface and calling the function like that)?

我的目标是这样，我可以使用相同的 Activity 来保存分支"片段，这样我就不需要为每个菜单点制作一个.而不是仅仅重复使用相同的活动，并将所有逻辑分成片段.(目前它不支持基于方向的布局组织，我看到了这个缺点——而且这样每个 Fragment 都需要持有一个静态创建者，这是额外的样板代码".

My goal was that this way, I can use the same Activity for holding "branch" fragments, so that I don't need to make one for each menu point. Rather than just re-use the same activity, and divide all logic into fragments. (Currently it doesn't support orientation-based layout organization, I see that downside - and also that this way each Fragment needs to hold a static creator, which is extra 'boilerplate code').

如果您知道为什么我不应该为此使用本地广播管理器的答案，我会很高兴听到回复.我认为它很简洁，但有可能它只是将简单的事情复杂化了.

If you know the answer why I shouldn't be using the local broadcast manager for this, I'll be happy to hear the response. I think it's pretty neat, but there's a chance it's just overcomplicating something simple.

推荐答案

您可以使用 Interface 来维护 Fragment 可重用性的主要目标.您可以通过以下方式实现 Activity-Fragment 或 Fragment-Fragment 之间的通信:

You can use Interface for it so main objective of Fragment re-usability is maintained. You can implement communication between Activity-Fragment OR Fragment-Fragment via using following :

这篇关于使用 LocalBroadcastManager 从 Fragment 到 Activity 进行通信的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！