FragmentManager.setFragmentResultListener(
    requestKey,
    lifecycleOwner,
    FragmentResultListener { requestKey: String, result: Bundle ->
        在這里可以通過requestKey的判斷，來區(qū)別處理
    })
 

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

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 的實(shí)例，用來存儲(chǔ)數(shù)據(jù)傳輸?shù)?Bundle
        // 如果傳遞的參數(shù) result 為空，移除 requestKey 對應(yīng)的 Bundle
        mResults.remove(requestKey);
        return;
    }
    // Check if there is a listener waiting for a result with this key
    // mResultListeners 是 ConcurrentHashMap 的實(shí)例，用來儲(chǔ)存注冊的 listener
    // 獲取 requestKey 對應(yīng)的 listener
    LifecycleAwareResultListener resultListener = mResultListeners.get(requestKey);
    if (resultListener != null && resultListener.isAtLeast(Lifecycle.State.STARTED)) {
        // 如果 resultListener 不為空，并且生命周期處于 STARTED 狀態(tài)時(shí)，調(diào)用回調(diào)
        resultListener.onFragmentResult(requestKey, result);
    } else {
        // 否則保存當(dāng)前傳輸?shù)臄?shù)據(jù)
        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>());

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 的實(shí)例，用來儲(chǔ)存注冊的 listener
    // 如果傳遞的參數(shù) listener 為空時(shí)，移除 requestKey 對應(yīng)的 listener
    if (listener == null) {
        mResultListeners.remove(requestKey);
        return;
    }
    // Lifecycle是一個(gè)生命周期感知組件，一般用來響應(yīng)Activity、Fragment等組件的生命周期變化
    final Lifecycle lifecycle = lifecycleOwner.getLifecycle();
    // 當(dāng)生命周期處于 DESTROYED 時(shí)，直接返回
    // 避免當(dāng) Fragment 處于不可預(yù)知狀態(tài)的時(shí)，可能發(fā)生未知的問題
    if (lifecycle.getCurrentState() == Lifecycle.State.DESTROYED) {
        return;
    }
    // 開始監(jiān)聽生命周期
    LifecycleEventObserver observer = new LifecycleEventObserver() {
        @Override
        public void onStateChanged(@NonNull LifecycleOwner source,
                                   @NonNull Lifecycle.Event event) {
            // 當(dāng)生命周期處于 ON_START 時(shí)開始處理數(shù)據(jù)
            if (event == Lifecycle.Event.ON_START) {
                // 開始檢查受到的數(shù)據(jù)
                Bundle storedResult = mResults.get(requestKey);
                if (storedResult != null) {
                    // 如果結(jié)果不為空，調(diào)用回調(diào)方法
                    listener.onFragmentResult(requestKey, storedResult);
                    // 清除數(shù)據(jù)
                    setFragmentResult(requestKey, null);
                }
            }
            // 當(dāng)生命周期處于 ON_DESTROY 時(shí)，移除監(jiān)聽
            if (event == Lifecycle.Event.ON_DESTROY) {
                lifecycle.removeObserver(this);
                mResultListeners.remove(requestKey);
            }
        }
    };
    lifecycle.addObserver(observer);
    mResultListeners.put(requestKey, new FragmentManager.LifecycleAwareResultListener(lifecycle, listener));
}