全新的Fragment通信方式

发表于 3年以前 | 总阅读数：357 次

前言

就在前段时间，Google 推出了 Fragment Result API 和 Activity Results API，用来取代之前的 Activity 和 Fragment 之间通信方式的不足，大家可以前往看看都有哪些更新：

https://medium.com/androiddevelopers/now-in-android-17-9d73f7bed7f

通过Fragment Result API进行Fragment间数据传递:

发送数据

@Override
@NonNull
public final @Override void setFragmentResult(@NonNull String requestKey, @NonNull Bundle result)

如果 FragmentB 发送数据给 FragmentA，需要在 FragmentA 中注册 listener，通过 parent FragmentManager 发送数据

数据接收:

@Override
@NonNull
public final @Override void setFragmentResultListener(
    @NonNull String requestKey,
    @NonNull LifecycleOwner lifecycleOwner,
    @NonNull FragmentResultListener listener
)

如果想在 Fragment 中接受数据，可以在 FragmentManager 中注册一个 FragmentResultListener，参数 requestKey 可以过滤掉 FragmentManager 发送的数据

setFragmentResultListener为给定的requestKey设置了ResultListener。一旦给定的 LifecycleOwner 至少处于 STARTED 状态， setFragmentResult 使用相同的 requestKey 设置的任何结果都将传递给回调。回调将保持活动状态，直到 LifecycleOwner 达到 DESTROYED 状态或使用相同的 requestKey 调用 clearFragmentResultListener。

时序图分析:

可以通过简化后的时序图来分析lifecycle状态和fragment设置监听的顺序:

如果监听 Fragment 的生命周期，您可以在接收到新数据时安全地更新 UI，因为 view 的创建(onViewCreated() 方法在 onStart() 之前被调用)。

当生命周期处于 LifecycleOwner STARTED 的状态之前，如果有多个数据传递，只会接收到最新的值:

当生命周期处于 LifecycleOwner DESTROYED 时，它将自动移除 listener，如果想手动移除 listener，需要调用 FragmentManager.setFragmentResultListener() 方法，传递空的 FragmentResultListener

从时序图很明显可以总体分析出流程来，大致是在FragmentManager中注册listener，依赖于Fragment发送返回的数据。

不同层级关系的Fragment数据传递

一般fragment数据传递涉及到不同层级间的传递，主要分为下面两种:

父子层级的两个Fragment数据传递

如果在 FragmentA 中接受 FragmentB 发送的数据，FragmentA 是 FragmentB 的父容器，他们通过 child FragmentManager 进行通信

childFragmentManager.setFragmentResultListener(...)

注意 listener必须设置的Fragment需要用到相同的FragmentManager。

相同层级的两个Fragment数据传递

如果在 FragmentA 中接受 FragmentB 发送的数据，FragmentA 和 FragmentB 处于相同的层级，通过 parent FragmentManager 进行通信，FragmentA 必须使用 parent FragmentManager 注册 listener

parentFragmentManager.setFragmentResultListener(...)

源码解析

不同于之前旧的Target Fragment Api，可以看到这里将监听器和fragment的lifecycle进行绑定，这样将带来以下优点:

在 Fragment 之间传递数据，不会持有对方的引用
当生命周期处于 ON_START 时开始处理数据，避免当 Fragment 处于不可预知状态的时，可能发生未知的问题
当生命周期处于 ON_DESTROY 时，移除监听

那让我们更进一步看下，fragment和它的lifecycle是如何进行数据监听的绑定和解绑的呢:

   @Override
    public final void setFragmentResultListener(@NonNull final String requestKey,
                                                @NonNull final LifecycleOwner lifecycleOwner,
                                                @NonNull final FragmentResultListener listener) {
        final Lifecycle lifecycle = lifecycleOwner.getLifecycle();
        //destroyed则直接返回
        if (lifecycle.getCurrentState() == Lifecycle.State.DESTROYED) {
            return;
        }

        LifecycleEventObserver observer = new LifecycleEventObserver() {
            @Override
            public void onStateChanged(@NonNull LifecycleOwner source,
                                       @NonNull Lifecycle.Event event) {
                //在start的时候进行方法调用
                if (event == Lifecycle.Event.ON_START) {
                    // 一旦出于start状态，检查存储结果
                    Bundle storedResult = mResults.get(requestKey);
                    if (storedResult != null) {
                        // 如果查询的结果不为空，则触发回调
                        listener.onFragmentResult(requestKey, storedResult);
                        // 清除结果
                        clearFragmentResult(requestKey);
                    }
                }

                //destroy则移除监听
                if (event == Lifecycle.Event.ON_DESTROY) {
                    lifecycle.removeObserver(this);
                    mResultListeners.remove(requestKey);
                }
            }
        };

可以看到上面代码做了:

获取 Lifecycle 去监听 Fragment 的生命周期的变化
当生命周期处于 ON_START 时开始处理数据，避免当 Fragment 处于不可预知状态的时，可能发生未知的问题
当生命周期处于 ON_DESTROY 时，移除监听
当生命周期处于 DESTROYED 则直接返回不作处理

看过接受数据如何做的，下面再看下如何发送数据的:

    @Override
    public final void setFragmentResult(@NonNull String requestKey, @NonNull Bundle result) {
        // 检查是否有监听器去监听requestkey结果
        FragmentManager.LifecycleAwareResultListener resultListener = mResultListeners.get(requestKey);
        // 如果生命周期started，则触发回调
        if (resultListener != null && resultListener.isAtLeast(Lifecycle.State.STARTED)) {
            resultListener.onFragmentResult(requestKey, result);
        } else {
            //否则 保存当前传输数据result
            mResults.put(requestKey, result);
        }
    }

获取 requestKey 注册的 listener
当生命周期处于 STARTED 状态时，开始发送数据
否则保存当前传输的数据

看完源码简单分享，那么再来看下fragment间通信还有哪些其他方法?

Fragment中的通信方式还有哪些

通过使用findFragmentById或关联Activity获取Fragment的实例，然后调用Fragment的公共方法：

第一步在被调用的MainFragment注册公共方法

    //MainFragment.java文件中
    public void setData(List<String> dataList) {
        adapter.set(dataList);
    }

第二步在主动调用的Fragment中关联activity并获取到MainFragment后，调用公共方法

    //MenuFragment.java文件中
    lv.setOnItemClickListener(new AdapterView.OnItemClickListener() {
        @Override
        public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
            MainFragment mainFragment =
                    (MainFragment) getActivity()
                            .getSupportFragmentManager()
                            .findFragmentByTag("mainFragment");
            mainFragment.setData(mDataList.get(position));
        }
    });

缺点: Fragment 之间不应该直接通信参考 https://developer.android.com/topic/libraries/architecture/viewmodel#sharing

接口回调的方式进行fragment间数据传递:

step1: 在Menuragment中创建一个接口以及接口对应的set方法：

    //MainFragment.java文件中
    public interface OnDataTransferListener {
        public void dataTransfer(List<String> dataList);
    }
    public void setOnDataTransferListener(OnDataTransferListener mListener) {
        this.mListener = mListener;
    }

step2: 在MenuFragment中的ListView条目点击事件中进行接口进行接口回调

    //MenuFragment.java文件中
    lv.setOnItemClickListener(new AdapterView.OnItemClickListener() {
        @Override
        public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
            if (mListener != null) {
                mListener.dataTransfer(mDataList.get(position));
            }
        }
    });

step3: 在MainActivity中根据menuFragment获取到接口的set方法，在这个方法中进行进行数据传递，具体如下：

    //在MainActivity中
menuFragment.setOnDataTransferListener(new MenuFragment.OnDataTransferListener() {
        @Override
        public void dataTransfer(List<String> data) {
            mainFragment.setData(data);
        }
    });

缺点: 相对Result API更复杂，具体可以参考官方文档 https://developer.android.com/training/basics/fragments/communicating

通过Target Fragment APIs (Fragment.setTargetFragment() & Fragment.getTargetFragment())方法进行Fragment间数据传递:

援引Google官方的说明:

Fragment.setTargetFragment()

Use case = 2 fragments hosted by the same activity.

Where startActivityForResult() establishes a relationship between 2 activities, setTargetFragment() defines the caller/called relationship between 2 fragments.

setTargetFragment(target) lets the "called" fragment know where to send the result. onActivityResult() is called manually in this case.

通过下面的伪代码可以表示出调用关系:

public class Caller extends Fragment

     Fragment called = Called.newInstance()

     called.setTargetFragment(this)

public class Called extends DialogFragment

   intent = amazingData

   getTargetFragment().onActivityResult(  getTargetRequestCode(),,intent  )

简而言之，假设Fragment A 跳转B 在B中做一些操作之后，想把这些操作回传给A Fragment中存在startActivityForResult()以及onActivityResult（）方法，但没有setResult（）方法，用于设置返回的intent，这样我们就需要通过调用getActivity().setResult(ListTitleFragment.REQUEST_DETAIL, intent);

这种方法无形当中增加了两个Fragment 与 Activity的耦合度所以，就有了setTargetFragment()方法在启动B的时候，可以调用 B.setTargetFragment(A,int t) 将AB关联起来，然后在B的代码中调用 getTargetFragment().onActivityResult()将数据回传给 A

缺点: 该方法目前已经被谷歌官方所废弃，Target fragment 需要直接访问另一个fragment 的实例，这是十分危险的，因为不知道目标fragment处于什么状态；

通过ViewModel容器进行Fragment间数据传递:

Activity 中的两个或更多 Fragment 需要相互通信是一种很常见的现象。想象一下拆分视图 (list-detail) Fragment 的常见情况，假设您有一个 Fragment，在该 Fragment 中，用户从列表中选择一项，还有另一个 Fragment，用于显示选定项的内容。这种情况不太容易处理，因为这两个 Fragment 都需要定义某种接口描述，并且所有者 Activity 必须将两者绑定在一起。此外，这两个 Fragment 都必须处理另一个 Fragment 尚未创建或不可见的情况。

可以使用 ViewModel 对象解决这一常见的难点。这两个 fragment 可以使用其 activity 范围共享 ViewModel 来处理此类通信，如以下示例代码所示：

public class SharedViewModel extends ViewModel {
    private final MutableLiveData<Item> selected = new MutableLiveData<Item>();

    public void select(Item item) {
        selected.setValue(item);
    }

    public LiveData<Item> getSelected() {
        return selected;
    }
}

public class ListFragment extends Fragment {
    private SharedViewModel model;

    public void onViewCreated(@NonNull View view, Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        model = new ViewModelProvider(requireActivity()).get(SharedViewModel.class);
        itemSelector.setOnClickListener(item -> {
            model.select(item);
        });
    }
}

public class DetailFragment extends Fragment {

    public void onViewCreated(@NonNull View view, Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        SharedViewModel model = new ViewModelProvider(requireActivity()).get(SharedViewModel.class);
        model.getSelected().observe(getViewLifecycleOwner(), item -> {
           // Update the UI.
        });
    }
}

请注意，这两个 Fragment 都会检索包含它们的 Activity。这样，当这两个 Fragment 各自获取 ViewModelProvider 时，它们会收到相同的 SharedViewModel 实例（其范围限定为该 Activity）。

此方法具有以下优势：Activity 不需要执行任何操作，也不需要对此通信有任何了解。除了 SharedViewModel 约定之外，Fragment 不需要相互了解。如果其中一个 Fragment 消失，另一个 Fragment 将继续照常工作。每个 Fragment 都有自己的生命周期，而不受另一个 Fragment 的生命周期的影响。如果一个 Fragment 替换另一个 Fragment，界面将继续工作而没有任何问题。

总结

虽然使用了 Fragment result APIs，替换了过时的 Fragment target APIs，但是新的 APIs 在Bundle 作为数据传传递方面有一些限制，只能传递简单数据类型、Serializable 和 Parcelable 数据，Fragment result APIs 允许程序从崩溃中恢复数据，而且不会持有对方的引用，避免当 Fragment 处于不可预知状态的时，可能发生未知的问题。

综合以上通信方式，那么你认为 Fragment 之间通信最好的方式是什么？

- END -