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

Question

我目前在叠加层中有一个片段。这是用于登录服务的。在手机应用程序中，我想在叠加层中显示的每个步骤都是它们自己的屏幕和活动。登录过程分为 3 个部分，每个部分都有自己的活动，通过 startActivityForResult() 调用。

现在我想使用片段和覆盖层来做同样的事情。叠加层将显示与每个活动相对应的片段。问题是这些片段托管在 Honeycomb API 的活动中。我可以让第一个片段工作，但随后我需要 startActivityForResult()，这是不可能的。是否有类似于 startFragmentForResult() 的东西，我可以在其中启动一个新片段，并在完成后将结果返回到前一个片段？

Answer 1

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

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

Answer 2

如果您愿意，有一些片段之间通信的方法，

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

您可以使用这些方法进行回调。

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

Answer 3

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

您可以查看我制作的博客文章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

Answer 4

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

SharedViewModel

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"
    }

}

Answer 5

我的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;
    }
}

Answer 6

这是一个老问题，但我会尝试更新此处给出的答案。

您可以按照此处使用 FragmentResultListener api。

这样，如果您有两个片段，FragmentOne 导航到 FragmentTwo，您可以将数据从 FragmentTwo 向后传递到 FragmentOne 使用此代码：

class FragmentOne: Fragment() {
    ...
    override fun onCreate(savedInstanceState: Bundle?) {
        ...
        setFragmentResultListener("myRequestKey") { _, result ->
            val myString = result.getString("myString", "")
            doSomethingWithMyString(myString)
        }
    }
    ...
}

使用从 androidx.fragment.app.setFragmentResultListener 导入的 setFragmentResultListener。
再次

class FragmentTwo: Fragment() {
    ...
    private fun returnToFragmentOne() {
        val bundle = bundleOf(
            "myString" to "My Awesome String Data"
        )
        setFragmentResult("myRequestKey", bundle)
        findNavController().navigateUp()
    }
    ...
}

，从 androidx.fragment.app.setFragmentResult 静态导入 setFragmentResult。

这样，第二个片段将调用第一个片段的 onCreate 方法中定义的回调，并使用导航组件返回到它（您可以自由选择其他导航方法）。

Answer 7

有一个 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));

Answer 8

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

在fragment1中

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

Answer 9

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

首先，创建一个接口 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)
            }
        }
    }

Answer 10

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