我使用DialogFragments的一些事情:从列表中选择项目,输入文本。
将值(即字符串或列表中的项)返回给调用活动/片段的最佳方法是什么?
目前,我正在使调用活动实现驳回监听器,并给予DialogFragment对活动的引用。然后Dialog在activity中调用ondismiss方法,activity从DialogFragment对象中抓取结果。非常混乱,它不能在配置更改(方向更改),因为DialogFragment失去了对活动的引用。
谢谢你的帮助。
我使用DialogFragments的一些事情:从列表中选择项目,输入文本。
将值(即字符串或列表中的项)返回给调用活动/片段的最佳方法是什么?
目前,我正在使调用活动实现驳回监听器,并给予DialogFragment对活动的引用。然后Dialog在activity中调用ondismiss方法,activity从DialogFragment对象中抓取结果。非常混乱,它不能在配置更改(方向更改),因为DialogFragment失去了对活动的引用。
谢谢你的帮助。
当前回答
我很惊讶地看到,没有人建议使用本地广播进行DialogFragment到Activity的通信!我发现它比其他建议更简单、更清晰。本质上,您为您的Activity注册侦听广播,并从您的DialogFragment实例发送本地广播。简单。有关如何设置它的一步一步的指南,请参见这里。
其他回答
有一种更简单的方法来接收来自DialogFragment的结果。
首先,在你的Activity、Fragment或FragmentActivity中,你需要添加以下信息:
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
// Stuff to do, dependent on requestCode and resultCode
if(requestCode == 1) { // 1 is an arbitrary number, can be any int
// This is the return result of your DialogFragment
if(resultCode == 1) { // 1 is an arbitrary number, can be any int
// Now do what you need to do after the dialog dismisses.
}
}
}
requestCode基本上是你调用的DialogFragment的int标签,我马上会展示它是如何工作的。resultCode是你从DialogFragment发送回来的代码,告诉你当前正在等待的Activity、Fragment或FragmentActivity发生了什么。
下一段代码是对DialogFragment的调用。这里有一个例子:
DialogFragment dialogFrag = new MyDialogFragment();
// This is the requestCode that you are sending.
dialogFrag.setTargetFragment(this, 1);
// This is the tag, "dialog" being sent.
dialogFrag.show(getFragmentManager(), "dialog");
用这三行你声明了你的DialogFragment,设置了一个requestCode(它将调用onActivityResult(…)一旦对话框被驳回,然后你就会显示对话框。就是这么简单。
现在,在你的DialogFragment中,你只需要在dismiss()之前直接添加一行,这样你就可以将resultCode发送回onActivityResult()。
getTargetFragment().onActivityResult(getTargetRequestCode(), resultCode, getActivity().getIntent());
dismiss();
就是这样。注意,resultCode被定义为int resultCode,我已经设置为resultCode = 1;在这种情况下。
就是这样,你现在可以把你的DialogFragment的结果发送回你调用的Activity, Fragment,或者FragmentActivity。
另外,看起来这些信息之前已经发布了,但是没有给出足够的例子,所以我想我应该提供更多的细节。
编辑06.24.2016 我为上面的误导性代码道歉。但是你肯定不能接收回活动的结果,就像这行:
dialogFrag.setTargetFragment(this, 1);
设置目标片段而不是活动。为了做到这一点,你需要实现一个interfacecommunator。
在你的DialogFragment中设置一个全局变量
public InterfaceCommunicator interfaceCommunicator;
创建一个公共函数来处理它
public interface InterfaceCommunicator {
void sendRequestCode(int code);
}
然后,当你准备好在DialogFragment完成运行时将代码发送回Activity时,你只需在你dismiss()之前添加一行;你的DialogFragment:
interfaceCommunicator.sendRequestCode(1); // the parameter is any int code you choose.
现在在你的活动中你必须做两件事,第一件事是删除那一行不再适用的代码:
dialogFrag.setTargetFragment(this, 1);
然后实现接口,一切都完成了。你可以通过在类顶部的implements子句中添加以下一行来做到这一点:
public class MyClass Activity implements MyDialogFragment.InterfaceCommunicator
然后@Override activity中的函数,
@Override
public void sendRequestCode(int code) {
// your code here
}
使用这个接口方法就像使用onActivityResult()方法一样。除了接口方法是针对DialogFragments,另一个是针对Fragments。
使用这个AppDialog类既可以将数据传递到DialogFragment,也可以从中获取结果。
详细解释:
Premise - Fragments get destroyed and recreated on config changes. View models hang around. When using a Dialog, it is recommended to wrap it in DialogFragment so that when the user rotates device and changes orientation the Dialog will not unexpectedly disappear (the DialogFragment will re-create it and re-display it). Limitation (hence this question) - The way the DialogFragment works is it takes a class that it will need to re-instantiate on configuration changes - that means one can't have constructor parameters to the subclass to pass parameters, and typically one needs to make custom callbacks through a view model to pass back result of dialog. That typically means a new subclass for every dialog. The solution - To help with all this, this custom AppDialog fragment comes to the rescue - the parameters are stored in-memory (similar to view model, you can think of it as a tiny custom view model that holds T in memory and uses it to re-create the dialog on config changes) until the dialog fragment is dismissed. The proper way to call back would be through a view model. If the fragment that shows the AppDialog, then you probably already have a view model and you can reference it from the lambda used to create the dialog - that means additional strong reference to the view model until the dialog fragment is dismissed. Example - see the examples where a simple Dialog is refactored to use this AppDialog utility class to both receive a parameter and do a callback to viewModel to notify of result.
helper类:
class AppDialog<T>: DialogFragment() {
companion object {
fun<T> buildDialog(params: T? = null, builder: AppDialogLambda<T>): AppDialog<T> {
// Setup arguments
val args = Bundle()
args.putInt("key", pushDialogArgs(params, builder))
// Instantiate
val fragment = AppDialog<T>()
fragment.arguments = args
return fragment
}
// --------------------
// Dialog Arguments
private var lastKey: Int = 0
private val dialogArgs = mutableMapOf<Int, Pair<Any?, AppDialogLambda<*>>>()
private fun pushDialogArgs(params: Any?, builder: AppDialogLambda<*>): Int {
dialogArgs[lastKey] = params to builder
return lastKey++
}
private fun getDialogArgs(key: Int): Pair<Any?, AppDialogLambda<*>> {
return dialogArgs[key]!!
}
private fun deleteDialogArgs(key: Int) {
dialogArgs.remove(key)
}
}
override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
// Get arguments
val argKey = requireArguments().getInt("key")
val (params, builder) = getDialogArgs(argKey)
// We are getting back our arguments we passed AppDialog.buildDialog and
// the type is guaranteed to be the same. Silence this warning
@Suppress("UNCHECKED_CAST")
return (builder as AppDialogLambda<T>)(this, params as T?)
}
override fun onDismiss(dialog: DialogInterface) {
super.onDismiss(dialog)
val argKey = requireArguments().getInt("key")
deleteDialogArgs(argKey)
}
}
示例用法(之后):
val info = mapOf("message" to "${error.description}\n\nPlease check your Internet connection and try again.")
AppDialog.buildDialog(info) { fragment, params ->
fragment.isCancelable = false // since we are in a DialogFragment
AlertDialog.Builder(fragment.context)
.setTitle("Terms Of Service Failed To Load")
.setMessage(params!!["message"])
.setPositiveButton("Retry") { _, _ ->
// Update the view model instead of calling UserTOSFragment directly
// as the fragment may be destroyed and recreated
// on configuration changes. The viewModel will stay alive.
viewModel.onTermsOfServiceReload()
}
.setNegativeButton("Cancel") { _, _ ->
viewModel.onTermsOfServiceDeclined()
fragment.findNavController().popBackStack()
}.create()
}.show(parentFragmentManager, "TOS Failed Dialog")
用法示例(前): 如果不使用DialogFragment(为了说明目的,不要这样做,这是不好的做法,因为对话框将在配置更改时被销毁),则UserTOSFragment中的代码。kt -用于在重试时直接调用UserTOSFragment.loadContent()的注释代码。在上面的例子中,这必须重写为调用viewModel.onTermsOfServiceDeclined():
AlertDialog.Builder(context)
.setTitle("Terms Of Service Failed To Load")
.setMessage("${error.description}\n\nPlease check your Internet connection and try again.")
.setPositiveButton("Retry") { _, _ ->
loadContent()
}
.setCancelable(false)
.setNegativeButton("Cancel") { _, _ ->
viewModel.onTermsOfServiceDeclined()
findNavController().popBackStack()
}
.show()
或者像下面这样共享ViewModel:
public class SharedViewModel extends ViewModel {
private final MutableLiveData<Item> selected = new MutableLiveData<Item>();
public void select(Item item) {
selected.setValue(item);
}
public LiveData<Item> getSelected() {
return selected;
}
}
public class MasterFragment extends Fragment {
private SharedViewModel model;
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
model = ViewModelProviders.of(getActivity()).get(SharedViewModel.class);
itemSelector.setOnClickListener(item -> {
model.select(item);
});
}
}
public class DetailFragment extends Fragment {
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
SharedViewModel model = ViewModelProviders.of(getActivity()).get(SharedViewModel.class);
model.getSelected().observe(this, { item ->
// Update the UI.
});
}
}
https://developer.android.com/topic/libraries/architecture/viewmodel#sharing_data_between_fragments
如果你想发送参数并从第二个片段接收结果,你可以使用fragment。setargarguments来完成这个任务
static class FirstFragment extends Fragment {
final Handler mUIHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 101: // receive the result from SecondFragment
Object result = msg.obj;
// do something according to the result
break;
}
};
};
void onStartSecondFragments() {
Message msg = Message.obtain(mUIHandler, 101, 102, 103, new Object()); // replace Object with a Parcelable if you want to across Save/Restore
// instance
putParcelable(new SecondFragment(), msg).show(getFragmentManager().beginTransaction(), null);
}
}
static class SecondFragment extends DialogFragment {
Message mMsg; // arguments from the caller/FirstFragment
@Override
public void onViewCreated(View view, Bundle savedInstanceState) {
// TODO Auto-generated method stub
super.onViewCreated(view, savedInstanceState);
mMsg = getParcelable(this);
}
void onClickOK() {
mMsg.obj = new Object(); // send the result to the caller/FirstFragment
mMsg.sendToTarget();
}
}
static <T extends Fragment> T putParcelable(T f, Parcelable arg) {
if (f.getArguments() == null) {
f.setArguments(new Bundle());
}
f.getArguments().putParcelable("extra_args", arg);
return f;
}
static <T extends Parcelable> T getParcelable(Fragment f) {
return f.getArguments().getParcelable("extra_args");
}
正如你在这里看到的,有一个非常简单的方法来做到这一点。
在你的DialogFragment中添加一个接口监听器:
public interface EditNameDialogListener {
void onFinishEditDialog(String inputText);
}
然后,添加对该监听器的引用:
private EditNameDialogListener listener;
这将被用来“激活”监听器方法,也用来检查父Activity/Fragment是否实现了这个接口(见下文)。
在“调用”DialogFragment的Activity/FragmentActivity/Fragment中简单地实现了这个接口。
在你的DialogFragment中,你需要在你想要解散DialogFragment并返回结果的地方添加以下内容:
listener.onFinishEditDialog(mEditText.getText().toString());
this.dismiss();
mEditText.getText(). tostring()将被传递回调用Activity。
注意,如果您想返回其他内容,只需更改侦听器所接受的参数。
最后,你应该检查接口是否由父活动/片段实际实现:
@Override
public void onAttach(Context context) {
super.onAttach(context);
// Verify that the host activity implements the callback interface
try {
// Instantiate the EditNameDialogListener so we can send events to the host
listener = (EditNameDialogListener) context;
} catch (ClassCastException e) {
// The activity doesn't implement the interface, throw exception
throw new ClassCastException(context.toString()
+ " must implement EditNameDialogListener");
}
}
这种技术非常灵活,即使你还不想结束对话框,也可以回调结果。