Android 中防止屏幕旋转时对话框消失

Question

我试图防止在活动重新启动时关闭使用警报生成器构建的对话框。

如果我重载 onConfigurationChanged 方法，我可以成功执行此操作并将布局重置为正确的方向，但我会丢失 edittext 的粘性文本功能。因此，在解决对话框问题时，我创建了这个编辑文本问题。

如果我保存编辑文本中的字符串并在 onCofiguration 更改中重新分配它们，它们似乎仍然默认为初始值，而不是旋转之前输入的值。即使我强制无效似乎也会更新它们。

我真的需要解决对话框问题或编辑文本问题。

感谢您的帮助。

Answer 1

如今避免此问题的最佳方法是使用 DialogFragment。

创建一个扩展 DialogFragment 的新类。覆盖 onCreateDialog 并返回旧的 Dialog 或 AlertDialog。

然后你可以用 DialogFragment.show(fragmentManager, tag)。

这是一个带有 Listener 的示例

public class MyDialogFragment extends DialogFragment {

    public interface YesNoListener {
        void onYes();

        void onNo();
    }

    @Override
    public void onAttach(Activity activity) {
        super.onAttach(activity);
        if (!(activity instanceof YesNoListener)) {
            throw new ClassCastException(activity.toString() + " must implement YesNoListener");
        }
    }

    @Override
    public Dialog onCreateDialog(Bundle savedInstanceState) {
        return new AlertDialog.Builder(getActivity())
                .setTitle(R.string.dialog_my_title)
                .setMessage(R.string.dialog_my_message)
                .setPositiveButton(android.R.string.yes, new DialogInterface.OnClickListener() {

                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        ((YesNoListener) getActivity()).onYes();
                    }
                })
                .setNegativeButton(android.R.string.no, new DialogInterface.OnClickListener() {

                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        ((YesNoListener) getActivity()).onNo();
                    }
                })
                .create();
    }
}

：在您调用的活动中：

new MyDialogFragment().show(getSupportFragmentManager(), "tag"); // or getFragmentManager() in API 11+

此答案有助于解释其他三个问题（及其答案）：

• Android 避免对话框关闭的最佳方法设备旋转后
• Android DialogFragment 与 Dialog
• 如何使用兼容包显示 DialogFragment？

Answer 2

// Prevent dialog dismiss when orientation changes
private static void doKeepDialog(Dialog dialog){
    WindowManager.LayoutParams lp = new WindowManager.LayoutParams();
    lp.copyFrom(dialog.getWindow().getAttributes());
    lp.width = WindowManager.LayoutParams.WRAP_CONTENT;
    lp.height = WindowManager.LayoutParams.WRAP_CONTENT;
    dialog.getWindow().setAttributes(lp);
}

public static void doLogout(final Context context){     
        final AlertDialog dialog = new AlertDialog.Builder(context)
        .setIcon(android.R.drawable.ic_dialog_alert)
        .setTitle(R.string.titlelogout)
        .setMessage(R.string.logoutconfirm)
        .setPositiveButton("Yes", new DialogInterface.OnClickListener()
        {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                ...   
            }

        })
        .setNegativeButton("No", null)      
        .show();    

        doKeepDialog(dialog);
    }

Answer 3

如果您要更改方向更改时的布局，我不会将 android:configChanges="orientation" 放入您的清单中，因为无论如何您都会重新创建视图。

使用这些方法保存 Activity 的当前状态（例如输入的文本、显示的对话框、显示的数据等）：

@Override
protected void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
}

@Override
protected void onRestoreInstanceState(Bundle savedInstanceState) {
    super.onRestoreInstanceState(savedInstanceState);
}

这样，Activity 会再次执行 onCreate，然后调用 onRestoreInstanceState 方法，您可以在其中再次设置 EditText 值。

如果你想存储更复杂的对象，你可以使用

@Override
public Object onRetainNonConfigurationInstance() {
}

这里你可以存储任何对象，在onCreate中你只需调用getLastNonConfigurationInstance();来获取对象。

Answer 4

只需在您的活动中添加 android:configChanges="orientation"
AndroidManifest.xml 中的元素

示例：

<activity
            android:name=".YourActivity"
            android:configChanges="orientation"
            android:label="@string/app_name"></activity>

Answer 5

一种非常简单的方法是通过 onCreateDialog() 方法创建对话框（请参见下面的注释）。您可以通过 showDialog() 显示它们。这样，Android 就会为您处理旋转，您不必在 onPause() 中调用 dismiss() 来避免 WindowLeak，然后您也不必恢复对话框。来自文档：

显示由该活动管理的对话框。第一次为给定 id 调用 onCreateDialog(int, Bundle) 时，将使用相同的 id 进行调用。此后，对话框将自动保存和恢复。

请参阅 Android 文档 showDialog() 了解更多信息。希望它对某人有帮助！

注意：如果使用AlertDialog.Builder，请勿从onCreateDialog()调用show()，而是调用create() > 相反。如果使用 ProgressDialog，只需创建对象，设置所需的参数并返回它。总之，onCreateDialog() 中的 show() 会导致问题，只需创建 de Dialog 实例并返回它即可。这应该有效！ （我在使用 onCreate() 中的 showDialog() 时遇到了问题 - 实际上没有显示对话框 - 但如果您在 onResume() 或侦听器回调中使用它，它效果很好）。

Answer 6

这个问题很久以前就有答案了。

然而，这是我自己使用的非黑客且简单解决方案。

我为自己做了这个帮助器类，所以你也可以在你的应用程序中使用它。

用法是：

PersistentDialogFragment.newInstance(
        getBaseContext(),
        RC_REQUEST_CODE,
        R.string.message_text,
        R.string.positive_btn_text,
        R.string.negative_btn_text)
        .show(getSupportFragmentManager(), PersistentDialogFragment.TAG);

或者

 PersistentDialogFragment.newInstance(
        getBaseContext(),
        RC_EXPLAIN_LOCATION,
        "Dialog title", 
        "Dialog Message", 
        "Positive Button", 
        "Negative Button", 
        false)
    .show(getSupportFragmentManager(), PersistentDialogFragment.TAG);





public class ExampleActivity extends Activity implements PersistentDialogListener{

        @Override
        void onDialogPositiveClicked(int requestCode) {
                switch(requestCode) {
                  case RC_REQUEST_CODE:
                  break;
                }
        }

        @Override
        void onDialogNegativeClicked(int requestCode) {
                switch(requestCode) {
                  case RC_REQUEST_CODE:
                  break;
                }          
        }
}

Answer 7

当然，最好的方法是使用 DialogFragment。

这是我的包装类解决方案，它有助于防止在一个片段（或经过小重构的活动）内消除不同的对话框。此外，如果由于某些原因有大量 AlertDialogs 分散在代码中，并且它们之间在操作、外观或其他方面存在细微差别，它还有助于避免大规模代码重构。

public class DialogWrapper extends DialogFragment {
    private static final String ARG_DIALOG_ID = "ARG_DIALOG_ID";

    private int mDialogId;

    /**
     * Display dialog fragment.
     * @param invoker  The fragment which will serve as {@link AlertDialog} alert dialog provider
     * @param dialogId The ID of dialog that should be shown
     */
    public static <T extends Fragment & DialogProvider> void show(T invoker, int dialogId) {
        Bundle args = new Bundle();
        args.putInt(ARG_DIALOG_ID, dialogId);
        DialogWrapper dialogWrapper = new DialogWrapper();
        dialogWrapper.setArguments(args);
        dialogWrapper.setTargetFragment(invoker, 0);
        dialogWrapper.show(invoker.getActivity().getSupportFragmentManager(), null);
    }

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mDialogId = getArguments().getInt(ARG_DIALOG_ID);
    }

    @NonNull
    @Override
    public Dialog onCreateDialog(Bundle savedInstanceState) {
        return getDialogProvider().getDialog(mDialogId);
    }

    private DialogProvider getDialogProvider() {
        return (DialogProvider) getTargetFragment();
    }

    public interface DialogProvider {
        Dialog getDialog(int dialogId);
    }
}

当涉及到 Activity 时，您可以在 onCreateDialog() 中调用 getContext()，将其转换为 DialogProvider 接口，并通过 onCreateDialog() 来请求特定对话框代码>mDialogId。所有处理目标片段的逻辑都应该被删除。

片段的用法：

public class MainFragment extends Fragment implements DialogWrapper.DialogProvider {
    private static final int ID_CONFIRMATION_DIALOG = 0;

    @Override
    public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
        Button btnHello = (Button) view.findViewById(R.id.btnConfirm);
        btnHello.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                DialogWrapper.show(MainFragment.this, ID_CONFIRMATION_DIALOG);
            }
        });
    }

    @Override
    public Dialog getDialog(int dialogId) {
        switch (dialogId) {
            case ID_CONFIRMATION_DIALOG:
                return createConfirmationDialog(); //Your AlertDialog
            default:
                throw new IllegalArgumentException("Unknown dialog id: " + dialogId);
        }
    }
}

您可以在我的博客上阅读完整的文章 如何防止 Dialog 被解雇？ 并使用源代码。

Answer 8

看来这仍然是一个问题，即使“一切都正确”并使用 DialogFragment 等。

Google 问题跟踪器 声称这是由于消息队列中遗留有旧的关闭消息所致。提供的解决方法非常简单：

    @Override
    public void onDestroyView() {
        /* Bugfix: https://issuetracker.google.com/issues/36929400 */
        if (getDialog() != null && getRetainInstance())
            getDialog().setDismissMessage(null);

        super.onDestroyView();
    }

令人难以置信的是，在该问题首次报告 7 年后仍然需要这样做。

Answer 9

您可以将Dialog 的 onSave/onRestore 方法与Activity 的 onSave/onRestore 方法结合起来，以保留 Dialog 的状态。

注意：此方法适用于那些“简单”对话框，例如显示警报消息。它不会重现嵌入在对话框中的 WebView 的内容。如果您确实想防止复杂的对话框在旋转过程中消失，请尝试 Chung IW 的方法。

@Override
protected void onRestoreInstanceState(Bundle savedInstanceState) {
     super.onRestoreInstanceState(savedInstanceState);
     myDialog.onRestoreInstanceState(savedInstanceState.getBundle("DIALOG"));
     // Put your codes to retrieve the EditText contents and 
     // assign them to the EditText here.
}

@Override
protected void onSaveInstanceState(Bundle outState) {
     super.onSaveInstanceState(outState);
     // Put your codes to save the EditText contents and put them 
     // to the outState Bundle here.
     outState.putBundle("DIALOG", myDialog.onSaveInstanceState());
}

Answer 10

我遇到了类似的问题：当屏幕方向更改时，即使用户没有关闭对话框，也会调用对话框的 onDismiss 侦听器。我可以通过使用 onCancel 侦听器来解决此问题，该侦听器在用户按下后退按钮和用户触摸对话框外部时都会触发。

Answer 11

如果没有任何帮助，并且您需要一个有效的解决方案，您可以安全起见，每次打开对话框时都将其基本信息保存到活动 ViewModel 中（并在您关闭对话框时将其从该列表中删除）。此基本信息可以是对话框类型和一些 ID（打开此对话框所需的信息）。在 Activity 生命周期发生变化时，此 ViewModel 不会被销毁。假设用户打开一个对话框以留下对餐厅的引用。因此，对话框类型为 LeaveReferenceDialog，id 为餐厅 id。打开此对话框时，您可以将此信息保存在可称为 DialogInfo 的对象中，并将此对象添加到 Activity 的 ViewModel 中。此信息将允许您在调用活动 onResume() 时重新打开对话框：

// On resume in Activity
    override fun onResume() {
            super.onResume()
    
            // Restore dialogs that were open before activity went to background
            restoreDialogs()
        }

哪个调用：

    fun restoreDialogs() {
    mainActivityViewModel.setIsRestoringDialogs(true) // lock list in view model

    for (dialogInfo in mainActivityViewModel.openDialogs)
        openDialog(dialogInfo)

    mainActivityViewModel.setIsRestoringDialogs(false) // open lock
}

当 ViewModel 中的 IsRestoringDialogs 设置为 true 时，对话框信息将不会添加到视图模型中的列表中，这很重要，因为我们'现在正在恢复该列表中已有的对话框。否则，在使用时更改列表将导致异常。所以：

// Create new dialog
        override fun openLeaveReferenceDialog(restaurantId: String) {
            var dialog = LeaveReferenceDialog()
            // Add id to dialog in bundle
            val bundle = Bundle()
            bundle.putString(Constants.RESTAURANT_ID, restaurantId)
            dialog.arguments = bundle
            dialog.show(supportFragmentManager, "")
        
            // Add dialog info to list of open dialogs
            addOpenDialogInfo(DialogInfo(LEAVE_REFERENCE_DIALOG, restaurantId))
    }

然后在关闭时删除对话框信息：

// Dismiss dialog
override fun dismissLeaveReferenceDialog(Dialog dialog, id: String) {
   if (dialog?.isAdded()){
      dialog.dismiss()
      mainActivityViewModel.removeOpenDialog(LEAVE_REFERENCE_DIALOG, id)
   }
}

并且在 Activity 的 ViewModel 中：

fun addOpenDialogInfo(dialogInfo: DialogInfo){
    if (!isRestoringDialogs){
       val dialogWasInList = removeOpenDialog(dialogInfo.type, dialogInfo.id)
       openDialogs.add(dialogInfo)
     }
}


fun removeOpenDialog(type: Int, id: String) {
    if (!isRestoringDialogs)
       for (dialogInfo in openDialogs) 
         if (dialogInfo.type == type && dialogInfo.id == id) 
            openDialogs.remove(dialogInfo)
}

您实际上以相同的顺序重新打开之前打开的所有对话框。但他们如何保留自己的信息呢？每个对话框都有自己的 ViewModel，该 ViewModel 在活动生命周期中也不会被销毁。因此，当您打开对话框时，您将获得 ViewModel 并一如既往地使用对话框的此 ViewModel 初始化 UI。

Answer 12

好的，经过 1 周的努力，我找到了解决方案：

当然，上述问题的正确解决方案是 DialogFragement 我仍然面临一些问题，因为我想让它可重复使用，有时在任何系统更改（如旋转）后它不会消失，将暗模式更改为亮模式（能够继续出现在屏幕中，但禁用被禁用）等。

此问题将解决以下问题：

1. 屏幕旋转/系统更改时对话框消失。
2. 数据将保留在对话框中（对话框标题和其他内容）。
3. 系统更改/轮换后将能够解散。

注意：我已经在 Kotlin 中完成了此操作。但概念是相同的，请阅读评论，它非常重要

---

ConfirmDialogWithYesAndNo.kt

class ConfirmDialogWithYesAndNo(private val confirmDialogTitleText:String="Default Confirm Dialog Title",private val confirmDialogMessageText:String="Default Confirm Dialog Message",private val confirmDialogPositiveButtonText:String="Yes",private val confirmDialogNegativeButtonText:String="No",private val confirmDialogPositiveButtonClickListener:()->Unit= {},private val confirmDialogNegativeButtonClickListener:()->Unit= {}): DialogFragment(){
    //Must keep this global
    private lateinit var alertDialog: AlertDialog

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        //Must use this otherwise after system change it will not dismiss and won't have same text which you passed.
        retainInstance = true
    }

    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
        super.onCreateDialog(savedInstanceState)

        //Normal Dialog creation and return it
        val builder = AlertDialog.Builder(requireActivity())
        builder.setTitle(confirmDialogTitleText)
        builder.setMessage(confirmDialogMessageText)
        builder.setIcon(android.R.drawable.ic_dialog_alert)
        builder.setPositiveButton("Yes") { _, _ ->
            //In case you use custom layout
            alertDialog.dismiss()

            confirmDialogPositiveButtonClickListener()
        }
        builder.setNegativeButton("No") { _, _ ->
            //In case you use custom layout button
            confirmDialogNegativeButtonClickListener()
        }
        val alertDialog: AlertDialog = builder.create()
        alertDialog.setCancelable(false)
        alertDialog.show()

        return alertDialog
    }
}

用法

MainActivity.kt：

class MainActivity : AppCompatActivity() {
    ....
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
.....
        butoon.setOnClickListener {
            val confirmDialogWithYesAndNo= ConfirmDialogWithYesAndNo("Hiii T","Hi Message","Yess B","No B",{
                Toast.makeText(this,"Yesss",Toast.LENGTH_LONG).show()
            },{
                Toast.makeText(this,"Noo",Toast.LENGTH_LONG).show()
            })
            confirmDialogWithYesAndNo.showNow(this.supportFragmentManager,"anyrandomstring")
          ...
        }
       ....

    }
}

要联系或检查此代码示例：vaibhavmojidra.github.io/site/

Answer 13

是的，我同意@Brais Gabin给出的使用DialogFragment的解决方案，只是想建议对他给出的解决方案进行一些更改。

在定义扩展 DialogFragment 的自定义类时，我们需要一些接口来管理调用对话框的活动或片段最终的操作。但在 onAttach(Context context) 方法中设置这些侦听器接口有时可能会导致 ClassCastException ，从而导致应用程序崩溃。

因此，为了避免这种异常，我们可以创建一个方法来设置侦听器接口，并在创建对话框片段的对象后调用它。
这是一个示例代码，可以帮助您了解更多信息 -

AlertRetryDialog.class

    public class AlertRetryDialog extends DialogFragment {

       public interface Listener{
         void onRetry();
         }

    Listener listener;

     public void setListener(Listener listener)
       {
       this.listener=listener;
       }

    @NonNull
    @Override
    public Dialog onCreateDialog(@Nullable Bundle savedInstanceState) {
    AlertDialog.Builder builder=new AlertDialog.Builder(getActivity());
    builder.setMessage("Please Check Your Network Connection").setPositiveButton("Retry", new 
    DialogInterface.OnClickListener() {
        @Override
        public void onClick(DialogInterface dialog, int which) {
             //Screen rotation will cause the listener to be null
            //Always do a null check of your interface listener before calling its method
            if(listener!=null&&listener instanceof HomeFragment)
            listener.onRetry();
        }
       }).setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
        @Override
        public void onClick(DialogInterface dialog, int which) {
            dialog.dismiss();
         }
     });
     return builder.create();
    }

   }

在您调用的 Activity 或 Fragment 中 -

                   AlertRetryDialog alertRetryDialog = new AlertRetryDialog();
                    alertRetryDialog.setListener(HomeFragment.this);
                    alertRetryDialog.show(getFragmentManager(), "tag");

并在您的 Activity 或 Fragment 中实现侦听器接口的方法 -

              public class YourActivity or YourFragment implements AlertRetryDialog.Listener{ 
                
                  //here's my listener interface's method
                    @Override
                    public void onRetry()
                    {
                     //your code for action
                      }
                
                 }

始终确保进行 null 检查在调用其任何方法之前先检查侦听器接口，以防止 NullPointerException（屏幕旋转将导致侦听器接口为空）。

如果您觉得这个答案有帮助，请告诉我。谢谢。

Answer 14

只需使用

ConfigurationChanges = Android.Content.PM.ConfigChanges.Orientation | Android.Content.PM.ConfigChanges.ScreenSize

，应用程序就会知道如何处理旋转和屏幕尺寸。