有没有一种方法可以像结果的开始片段一样工作？

所有的片段都存在于活动中。为结果启动 Fragment 没有多大意义，因为容纳它的 Activity 始终可以访问它，反之亦然。如果 Fragment 需要传递结果，它可以访问其 Activity 并设置其结果并完成它。在单个 Activity 中交换 Fragment 的情况下，两个 Fragment 仍然可以访问 Activity，并且您传递的所有消息都可以简单地通过 Activity。

请记住，Fragment 和它的 Activity 之间总是有通信。以结果开始和结束是活动之间的通信机制 - 然后活动可以将任何必要的信息委托给它们的片段。

---

如果你愿意，Fragment 之间有一些通信方法，

setTargetFragment(Fragment fragment, int requestCode)
getTargetFragment()
getTargetRequestCode()

您可以使用这些回调。

Fragment invoker = getTargetFragment();
if(invoker != null) {
    invoker.callPublicMethod();
}

---

最近，Google 刚刚向 FragmentManager 添加了一项新功能，使 FragmentManager 能够充当片段结果的中央存储。我们可以轻松地在 Fragment 之间来回传递数据。

您可以查看我制作的博文https://oozou.com/blog/starting-a-fragment-for-results-in-android-46

起始片段。

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    // Use the Kotlin extension in the fragment-ktx artifact
    setResultListener("requestKey") { key, bundle ->
        // We use a String here, but any type that can be put in a Bundle is supported
        val result = bundle.getString("bundleKey")
        // Do something with the result...
    }
}

我们想要返回结果的片段。

button.setOnClickListener {
    val result = "result"
    // Use the Kotlin extension in the fragment-ktx artifact
    setResult("requestKey", bundleOf("bundleKey" to result))
}

该片段摘自谷歌的官方文档。 https://developer.android.com/training/basics/fragments/pass-data-between#kotlin

在撰写此答案之日，此功能仍处于 alpha 状态。您可以使用此依赖项进行尝试。

androidx.fragment:fragment:1.3.0-alpha05

---

我们可以简单地在片段之间共享相同的 ViewModel

共享视图模型

import android.arch.lifecycle.MutableLiveData
import android.arch.lifecycle.ViewModel

class SharedViewModel : ViewModel() {

    val stringData: MutableLiveData<String> by lazy {
        MutableLiveData<String>()
    }

}

第一个片段

import android.arch.lifecycle.Observer
import android.os.Bundle
import android.arch.lifecycle.ViewModelProviders
import android.support.v4.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup

class FirstFragment : Fragment() {

    private lateinit var sharedViewModel: SharedViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        activity?.run {
            sharedViewModel = ViewModelProviders.of(activity).get(SharedViewModel::class.java)
        }
    }

    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?,
                              savedInstanceState: Bundle?): View? {
        return inflater.inflate(R.layout.fragment_first, container, false)
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        sharedViewModel.stringData.observe(this, Observer { dateString ->
            // get the changed String
        })

    }

}

第二片段

import android.arch.lifecycle.ViewModelProviders
import android.os.Bundle
import android.support.v4.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGrou

class SecondFragment : Fragment() {

    private lateinit var sharedViewModel: SharedViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        activity?.run {
            sharedViewModel = ViewModelProviders.of(activity).get(SharedViewModel::class.java)
        }
    }

    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?,
                              savedInstanceState: Bundle?): View? {
        return inflater.inflate(R.layout.fragment_first, container, false)
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        changeString()
    }

    private fun changeString() {
        sharedViewModel.stringData.value = "Test"
    }

}

---

我的 2 美分。

我通过使用隐藏和显示/添加（现有/新）将旧片段与新片段交换来切换片段。所以这个答案适用于像我一样使用片段的开发人员。

然后我使用 onHiddenChanged 方法知道旧片段已从新片段切换回。请参阅下面的代码。

在离开新片段之前，我在全局参数中设置了一个结果，以供旧片段查询。这是一个非常幼稚的解决方案。

@Override
public void onHiddenChanged(boolean hidden) {
    super.onHiddenChanged(hidden);
    if (hidden) return;
    Result result = Result.getAndReset();
    if (result == Result.Refresh) {
        refresh();
    }
}

public enum Result {
    Refresh;

    private static Result RESULT;

    public static void set(Result result) {
        if (RESULT == Refresh) {
            // Refresh already requested - no point in setting anything else;
            return;
        }
        RESULT = result;
    }

    public static Result getAndReset() {
        Result result = RESULT;
        RESULT = null;
        return result;
    }
}

---

在您的片段中，您可以调用 getActivity()。这将使您能够访问创建片段的活动。从那里您可以调用您的自定义方法来设置值或传递值。

---

有一个 Android 库 - FlowR 允许您启动片段以获得结果。

为结果开始一个片段。

Flowr.open(RequestFragment.class)
    .displayFragmentForResults(getFragmentId(), REQUEST_CODE);

在调用片段中处理结果。

@Override
protected void onFragmentResults(int requestCode, int resultCode, Bundle data) {
    super.onFragmentResults(requestCode, resultCode, data);

    if (requestCode == REQUEST_CODE) {
        if (resultCode == Activity.RESULT_OK) {
            demoTextView.setText("Result OK");
        } else {
            demoTextView.setText("Result CANCELED");
        }
    }
}

在 Fragment 中设置结果。

Flowr.closeWithResults(getResultsResponse(resultCode, resultData));

---

传回数据的最简单方法是通过 setArgument()。例如，您有 fragment1 调用 fragment2 调用 fragment3，fragment1 -> framgnet2 -> fargment3

在片段1

public void navigateToFragment2() {
    if (fragmentManager == null) return;

    Fragment2 fragment = Fragment2.newInstance();
    String tag = "Fragment 2 here";
    fragmentManager.beginTransaction()
            .setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE)
            .add(R.id.flContent, fragment, tag)
            .addToBackStack(null)
            .commitAllowingStateLoss();
}

在fragment2中，我们照常调用fragment3

private void navigateToFragment3() {
    if (fragmentManager == null) return;
    Fragment3 fragment = new Fragment3();
    fragmentManager.beginTransaction()
            .setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE)
            .replace(R.id.flContent, fragment, tag)
            .addToBackStack(null)
            .commit();
}

当我们在 fragment3 中完成任务时，我们现在这样调用：

FragmentManager fragmentManager = getActivity().getSupportFragmentManager();
if (fragmentManager == null) return;
fragmentManager.popBackStack();
Bundle bundle = new Bundle();
bundle.putString("bundle_filter", "data");
fragmentManager.findFragmentByTag("Fragment 2 here").setArguments(bundle);

现在在 fragment2 我们可以很容易地调用参数

@Override
public void onResume() {
    super.onResume();
    Bundle rgs = getArguments();
    if (args != null) 
        String data = rgs.getString("bundle_filter");
}

---

使用接口（和 Kotlin）的解决方案。核心思想是定义一个回调接口，在你的activity中实现它，然后从你的fragment中调用它。

首先，创建一个接口 ActionHandler：

interface ActionHandler {
    fun handleAction(actionCode: String, result: Int)
}

接下来，从您的孩子（在本例中为您的片段）调用它：

companion object {
    const val FRAGMENT_A_CLOSED = "com.example.fragment_a_closed"
}

fun closeFragment() {
    try {
        (activity as ActionHandler).handleAction(FRAGMENT_A_CLOSED, 1234)
    } catch (e: ClassCastException) {
        Timber.e("Calling activity can't get callback!")
    }
    dismiss()
}

最后，在您的父级中实现此功能以接收回调（在本例中为您的 Activity）：

class MainActivity: ActionHandler { 
    override fun handleAction(actionCode: String, result: Int) {
        when {
            actionCode == FragmentA.FRAGMENT_A_CLOSED -> {
                doSomething(result)
            }
            actionCode == FragmentB.FRAGMENT_B_CLOSED -> {
                doSomethingElse(result)
            }
            actionCode == FragmentC.FRAGMENT_C_CLOSED -> {
                doAnotherThing(result)
            }
        }
    }

---

根据您的架构，您可以做的另一件事是在片段之间使用共享的 ViewModel。所以在我的例子中，FragmentA 是一个表单，而 FragmentB 是一个项目选择视图，用户可以在其中搜索和选择一个项目，并将其存储在 ViewModel 中。然后当我回到 FragmentA 时，信息已经存储了！

---