Fragment通过FragmentManager实现通信功能详细讲解

目录

• 一、自己的理解
• 二、使用
• 1.接收数据
• 2.发送数据
• 三、源码分析
• 1.发送数据
• 2.接收数据
• 四、小结

一、自己的理解

本质就是Fragment经由同一个FragmentManager以观察者模式的方式通信。

首先多个Fragment通过同一个实例做到观察者模式的通信。

其次Fragment都是由FragmentManage开发者_Python培训r来管理的，Fragemnt的重建数据的保存等，各种机制都由FragmentManager控制，所以选择FragmentManager来当这个同一个实例是最合适不过。

所以一个经由同一个FragmentManager以观察者模式的方式通信就出现了。

二、使用

1.接收数据

FragmentManager.setFragmentResultListener(
    requestKey,
    lifecycleOwner,
    FragmentResultListener { requestKey: String, result: Bundle ->
        在这里可以通过requestKey的判断，来区别处理
    })
 

如果想在 Fragment 中接受数据，可以在 FragmentManager 中注册一个 FragmentResultListener，通过对requestKey 的判断，区别处理 FragmentManager 发送的数据

setFragmentResultListener方法的参数中，携带着lifecycleOwner，它对生命周期进行了监听，只有在Started状态之后才能接收信息，并且对Started状态之前最后一次发送的数据有黏性，即Started之前发的最后一条消息，在Started状态之后会收到，当lifecycleOwner生命周期到销毁的时候会移除这个FragmentResultListener。

2.发送数据

FragmentManager.setFragmentResult(
    requestKey, 
    bundleOf(key to value) 
)
 

注意事项：

通信的Fragment要使用同一个FragmentManager来接收和发送信息。

举例：

(1).如果在 FragmentA 中接收FragmentB 发送的数据，FragmentA 和 FragmentB 处于相同的层级，它们的共同点是被上一层级的FragmentManager所控制，parentFragmentManager就是他俩的同一个实例的FragmentManager，所以他们都通过parentFragmentManager来通信。

(2).如果在 FragmentA 中接受 FragmentB 发送的数据，FragmentA 是 FragmentB 的父容器，那对于FragemntA来说它和FragemntB的共同的FragmentManager是A的childFragmentManager，对于FragmentB来说它和A的共同的FragmentManager是B的parentFragmentManager，所以A接收B的消息用childFragmentManager，B发送A的消息用parentFragmentManager

三、源码分析

1.发送数据

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);
    }
}

我们看到这两个集合：

private final Map<String, Bundle> mResults =
        Collections.synchronizedMap(new HashMap<String, Bundle>());
private final Map<String, LifecycleAwareResultListener> mResultListeners =
        Collections.synchronizedMap(new HashMap<String, LifecycleAwareResultListener>());

就明白，这就是观察者模式保存观察者的地方，再看发送数据的方法， 果然就是通过requestKey来找到对应的观察者，然后调用onFragmentResult方法通知观察者。

注意当resultListener生命周期状态不到Started的时候，会先把数据保存mResults.put(requestKey, result);，在监听到生命周期状态到Started时，会取一次数据，然后这个mResults是一个map，所以只会保存最后一次put的数据，所以在Started生命周期前发送的最后一次数据，有黏性。

2.接收数据

private final ConcurrentHashMap<String, Lifecyclehttp://www.devze.comAwareResultListener> mResultListeners =
        new ConcurrentHashMap<>();
@Override
public final void setFragwww.devze.commentResultListener(@NonNull final String requestKey,
                                            @NonNull final LifecycleOwner lifecycleOwner,
      TeaeclZi                                      @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) {
                    // 如果结果不为空，调用回调方法
   android                 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 时，移除监听

如果大家看过我的Lifecycle源码分析的文章，就会很简单的看出来这就是一个简单的观察者模式。

四、小结

这种方式只能传递简单数据类型、Serializable 和 Parcelable 数据，Fragment result APIs 允许程序从崩溃中恢复数据，而且不会持有对方的引用，避免当 Fragment 处于不可预知状态的时，可能发生未知的问题。

优点：

在 Fragment 之间传递数据，不会持有对方的引用

当生命周期处于 ON_START 时开始处理数据，避免当 Fragment 处于不可预知状态的时，可能发生未知的问题

当生命周期处于 ON_DESTROY 时，移除监听

到此这篇关于Fragment通过FragmentManager实现通信功能详细讲解的文章就介绍到这了,更多相关Fragment FragmentManager通信内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！