Fragment通过FragmentManager通信

一、自己的理解

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

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

其次Fragment都是由FragmentManager来管理的，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, 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 时，移除监听

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

四、小结

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

优点：

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

Fragment通过FragmentManager通信

猜你喜欢