前言

就在前段时间，Google 推出了 Fragment Result API 和 Activity Results API，用来取代之前的 Activity 和 Fragment 之间通信形式的有余，大家能够返回看看都有那些更新：
https://medium.com/androiddev…

通过 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…

接口回调的形式进行 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…

通过 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 之间通信最好的形式是什么？

❤️/ 感激反对 /

以上便是本次分享的全部内容，心愿对你有所帮忙 ^_^

喜爱的话别忘了 分享、点赞、珍藏 三连哦~

欢送关注公众号 程序员巴士，来自字节、虾皮、招银的三端兄弟，分享编程教训、技术干货与职业规划，助你少走弯路进大厂。