[译][Google工程师] 刚刚发布了 Fragment 的新特性 “Fragment 间传递数据的新方式” 以及源码分析

• 原标题: Android Fragments: Fragment Result
• 原文地址: proandroiddev.com/android-fra…
• 原文做者: Husayn Hakeem

就在 2020/05/07 号 Now in Android #17 更新了，发布 Android 的新特性，其中就包括 Fragment 间通讯的新方式，你们能够点击这里前往，看看都有那些更新

经过这篇文章你将学习到如下内容，将在译者思考部分会给出相应的答案

• 新 Fragment 间通讯的方式的使用？
• 新 Fragment 间通讯的源码分析？
• 汇总 Fragment 之间的通讯的方式？

译文

Frrgament 间传递数据能够经过多种方式，包括使用 target Fragment APIs (Fragment.setTargetFragment() 和 Fragment.getTargetFragment())，ViewModel 或者 使用 Fragments’ 父容器 Activity，target Fragment APIs 已通过时了，如今鼓励使用新的 Fragment result APIs 完成 Frrgament 之间传递数据，其中传递数据由 FragmentManager 处理，而且在 Fragments 设置发送数据和接受数据

在 Frrgament 之间传递数据

使用新的 Fragment APIs 在 两个 Frrgament 之间的传递，没有任何引用，能够使用它们公共的 FragmentManager，它充当 Frrgament 之间传递数据的中心存储。

接受数据

若是想在 Fragment 中接受数据，能够在 FragmentManager 中注册一个 FragmentResultListener，参数 requestKey 能够过滤掉 FragmentManager 发送的数据

FragmentManager.setFragmentResultListener(
    requestKey,
    lifecycleOwner,
    FragmentResultListener { requestKey: String, result: Bundle ->
        // Handle result
    })
复制代码

参数 lifecycleOwner 能够观察生命周期，当 Fragment 的生命周期处于 STARTED 时接受数据。若是监听 Fragment 的生命周期，您能够在接收到新数据时安全地更新 UI，由于 view 的建立(onViewCreated() 方法在 onStart() 以前被调用)。

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

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

在 FragmentManager 中注册 listener，依赖于 Fragment 发送返回的数据

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

parentFragmentManager.setFragmentResultListener(...)
复制代码

• 若是在 FragmentA 中接受 FragmentB 发送的数据，FragmentA 是 FragmentB 的父容器， 他们经过 child FragmentManager 进行通讯

childFragmentManager.setFragmentResultListener(...)
复制代码

listener 必须设置的Fragment 相同的 FragmentManager

发送数据

若是 FragmentB 发送数据给 FragmentA，须要在 FragmentA 中注册 listener，经过 parent FragmentManager 发送数据

parentFragmentManager.setFragmentResult(
    requestKey, // Same request key FragmentA used to register its listener
    bundleOf(key to value) // The data to be passed to FragmentA
)
复制代码

测试 Fragment Results

测试 Fragment 是否成功接收或发送数据，能够使用 FragmentScenario API

接受数据

若是在 FragmentA 中注册 FragmentResultListener 接受数据，你能够模拟 parent FragmentManager 发送数据，若是在 FragmentA 中正确注册了 listener，能够用来验证 FragmentA 是否能收到数据，例如，若是在 FragmentA 中接受数据并更新 UI, 能够使用 Espresso APIs 来验证是否指望的数据

@Test
fun shouldReceiveData() {
    val scenario = FragmentScenario.launchInContainer(FragmentA::class.java)

    // Pass data using the parent fragment manager
    scenario.onFragment { fragment ->
        val data = bundleOf(KEY_DATA to "value")
        fragment.parentFragmentManager.setFragmentResult("aKey", data)
    }

    // Verify data is received, for example, by verifying it's been displayed on the UI onView(withId(R.id.textView)).check(matches(withText("value"))) } 复制代码

发送数据

能够在 FragmentB 的 parent FragmentManager 上注册一个 FragmentResultListener 来测试 FragmentB 是否成功发送数据，当发送数据结束时，能够来验证这个 listener 是否能收到数据

@Test
fun shouldSendData() {
    val scenario = FragmentScenario.launchInContainer(FragmentB::class.java)

    // Register result listener
    var receivedData = ""
    scenario.onFragment { fragment ->
        fragment.parentFragmentManager.setFragmentResultListener(
            KEY,
            fragment,
            FragmentResultListener { key, result ->
                receivedData = result.getString(KEY_DATA)
            })
    }

    // Send data
    onView(withId(R.id.send_data)).perform(click())

    // Verify data was successfully sent
    assertThat(receivedData).isEqualTo("value")
}
复制代码

示例项目

下面的示例项目，展现了如何使用 Fragment 新的 API

android-playground: https://github.com/husaynhakeem/android-playground...

总结

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

译者的思考

这是译者的一些思考，总结一下 Fragment 1.3.0-alpha04 新增长的 Fragment 间通讯的 API

数据接受

FragmentManager.setFragmentResultListener(
    requestKey,
    lifecycleOwner,
    FragmentResultListener { requestKey: String, result: Bundle ->
        // Handle result
    })
复制代码

数据发送

parentFragmentManager.setFragmentResult(
    requestKey, // Same request key FragmentA used to register its listener
    bundleOf(key to value) // The data to be passed to FragmentA
)
复制代码

那么 Fragment 间通讯的新 API 给咱们带来哪些好处呢：

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

咱们一块儿来从源码的角度分析一下 Google 是如何作的

源码分析

按照惯例从调用的方法来分析，数据接受时，调用了 FragmentManager 的 setFragmentResultListener 方法
androidx.fragment/fragment/1.3.0-alpha04......androidx/fragment/app/FragmentManager.java

private final ConcurrentHashMap<String, LifecycleAwareResultListener> mResultListeners =
        new ConcurrentHashMap<>();

@Override
public final void setFragmentResultListener(@NonNull final String requestKey,
                                            @NonNull final LifecycleOwner lifecycleOwner,
                                            @Nullable final FragmentResultListener listener) {
    // mResultListeners 是 ConcurrentHashMap 的实例，用来储存注册的 listener
    // 若是传递的参数 listener 为空时，移除 requestKey 对应的 listener
    if (listener == null) {
        mResultListeners.remove(requestKey);
        return;
    }

    // Lifecycle是一个生命周期感知组件，通常用来响应Activity、Fragment等组件的生命周期变化
    final Lifecycle lifecycle = lifecycleOwner.getLifecycle();
    // 当生命周期处于 DESTROYED 时，直接返回
    // 避免当 Fragment 处于不可预知状态的时，可能发生未知的问题
    if (lifecycle.getCurrentState() == Lifecycle.State.DESTROYED) {
        return;
    }

    // 开始监听生命周期
    LifecycleEventObserver observer = new LifecycleEventObserver() {
        @Override
        public void onStateChanged(@NonNull LifecycleOwner source,
                                   @NonNull Lifecycle.Event event) {
            // 当生命周期处于 ON_START 时开始处理数据
            if (event == Lifecycle.Event.ON_START) {
                // 开始检查受到的数据
                Bundle storedResult = mResults.get(requestKey);
                if (storedResult != null) {
                    // 若是结果不为空，调用回调方法
                    listener.onFragmentResult(requestKey, storedResult);
                    // 清除数据
                    setFragmentResult(requestKey, null);
                }
            }

            // 当生命周期处于 ON_DESTROY 时，移除监听
            if (event == Lifecycle.Event.ON_DESTROY) {
                lifecycle.removeObserver(this);
                mResultListeners.remove(requestKey);
            }
        }
    };
    lifecycle.addObserver(observer);
    mResultListeners.put(requestKey, new FragmentManager.LifecycleAwareResultListener(lifecycle, listener));
}
复制代码

• Lifecycle是一个生命周期感知组件，通常用来响应Activity、Fragment等组件的生命周期变化
• 获取 Lifecycle 去监听 Fragment 的生命周期的变化
• 当生命周期处于 ON_START 时开始处理数据，避免当 Fragment 处于不可预知状态的时，可能发生未知的问题
• 当生命周期处于 ON_DESTROY 时，移除监听

接下来一块儿来看一下数据发送的方法，调用了 FragmentManager 的 setFragmentResult 方法
androidx.fragment/fragment/1.3.0-alpha04......androidx/fragment/app/FragmentManager.java

private final ConcurrentHashMap<String, Bundle> mResults = new ConcurrentHashMap<>();
private final ConcurrentHashMap<String, LifecycleAwareResultListener> mResultListeners =
        new ConcurrentHashMap<>();
    
@Override
public final void setFragmentResult(@NonNull String requestKey, @Nullable Bundle result) {
    if (result == null) {
        // mResults 是 ConcurrentHashMap 的实例，用来存储数据传输的 Bundle
        // 若是传递的参数 result 为空，移除 requestKey 对应的 Bundle
        mResults.remove(requestKey);
        return;
    }

    // Check if there is a listener waiting for a result with this key
    // mResultListeners 是 ConcurrentHashMap 的实例，用来储存注册的 listener
    // 获取 requestKey 对应的 listener
    LifecycleAwareResultListener resultListener = mResultListeners.get(requestKey);
    if (resultListener != null && resultListener.isAtLeast(Lifecycle.State.STARTED)) {
        // 若是 resultListener 不为空，而且生命周期处于 STARTED 状态时，调用回调
        resultListener.onFragmentResult(requestKey, result);
    } else {
        // 不然保存当前传输的数据
        mResults.put(requestKey, result);
    }
}
复制代码

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

源码分析到这里结束了，咱们一块儿来思考一下，在以前咱们的都有那些数据传方式

汇总 Fragment 之间的通讯的方式

• 经过共享 ViewModel 或者关联 Activity来完成，Fragment 之间不该该直接通讯 参考 Google: ViewModel#sharing
• 经过接口，能够在 Fragment 定义接口，并在 Activity 实现它 参考 Google: 与其余 Fragment 通讯
• 经过使用 findFragmentById 方法，获取 Fragment 的实例，而后调用 Fragment 的公共方法 参考 Google: 与其余 Fragment 通讯
• 调用 Fragment.setTargetFragment() 和 Fragment.getTargetFragment() 方法，可是注意 target fragment 须要直接访问另外一个 fragment 的实例，这是十分危险的，由于你不知道目标 fragment 处于什么状态
• Fragment 新的 API, setFragmentResult() 和 setFragmentResultListener()

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

参考文献

• Now in Android #17: https://medium.com/androiddeve......
• Pass data between fragments: https://developer.android.com/training/basi......
• ViewModel#sharing: https://developer.android.com/topic/librari......
• 与其余 Fragment 通讯: https://developer.android.com/training/basic......

结语

致力于分享一系列 Android 系统源码、逆向分析、算法、翻译相关的文章，目前正在翻译一系列欧美精选文章，不单单是翻译，还有翻译背后对每篇文章思考，若是你喜欢这片文章，请帮我点个赞，感谢，期待与你一块儿成长

文章列表

Android 10 源码系列

• 0xA01 Android 10 源码分析：APK 是如何生成的
• 0xA02 Android 10 源码分析：APK 的安装流程
• 0xA03 Android 10 源码分析：APK 加载流程之资源加载
• 0xA04 Android 10 源码分析：APK 加载流程之资源加载（二）
• 0xA05 Android 10 源码分析：Dialog 加载绘制流程以及在 Kotlin、DataBinding 中的使用
• 0xA06 Android 10 源码分析：WindowManager 视图绑定以及体系结构

工具系列

• 为数很少的人知道的 AndroidStudio 快捷键(一)
• 为数很少的人知道的 AndroidStudio 快捷键(二)
• 关于 adb 命令你所须要知道的
• 如何高效获取视频截图
• 10分钟入门 Shell 脚本编程
• 如何在项目中封装 Kotlin + Android Databinding

逆向系列

• 基于 Smali 文件 Android Studio 动态调试 APP
• 解决在 Android Studio 3.2 找不到 Android Device Monitor 工具