Evitar el cierre del cuadro de diálogo en la rotación de la pantalla en Android

Estoy tratando de evitar que los cuadros de diálogo creados con el generador de alertas se descarten cuando se reinicia la actividad.

Si sobrecargo el método onConfigurationChanged, puedo hacer esto con éxito y restablecer el diseño a la orientación correcta, pero pierdo la función de texto adhesivo de edittext. Entonces, al resolver el problema del diálogo, he creado este problema de edición de texto.

Si guardo las cadenas del texto de edición y las reasigno en el cambio onCofiguration, todavía parecen tener el valor inicial predeterminado, no el que se ingresó antes de la rotación. Incluso si fuerzo una invalidación, parece actualizarlos.

Realmente necesito resolver el problema del diálogo o el problema de editar texto.

Gracias por la ayuda.

La mejor manera de evitar este problema hoy en día es utilizando un archivo DialogFragment.

Cree una nueva clase que se extienda DialogFragment. Anula onCreateDialogy devuelve tu antiguo Dialogo un AlertDialog.

Entonces puedes mostrarlo con DialogFragment.show(fragmentManager, tag).

Aquí tienes un ejemplo con 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();
    }
}

Y en la Actividad llamas:

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

Esta respuesta ayuda a explicar estas otras tres preguntas (y sus respuestas):

• Android La mejor forma de evitar que los diálogos se descarten después de una rotación de dispositivo
• Android DialogFragment vs Dialog
• ¿Cómo puedo mostrar un DialogFragment usando un paquete de compatibilidad?

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

Si está cambiando el diseño en el cambio de orientación, no lo pondría android:configChanges="orientation"en su manifiesto porque está recreando las vistas de todos modos.

Guarde el estado actual de su actividad (como el texto ingresado, el diálogo mostrado, los datos mostrados, etc.) utilizando estos métodos:

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

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

De esa manera, la actividad pasa por onCreate nuevamente y luego llama al método onRestoreInstanceState donde puede establecer su valor EditText nuevamente.

Si desea almacenar objetos más complejos, puede usar

@Override
public Object onRetainNonConfigurationInstance() {
}

Aquí puede almacenar cualquier objeto y en onCreate solo tiene que llamar getLastNonConfigurationInstance();para obtener el objeto.

Simplemente agregue android: configChanges = "Orientación" con su elemento de actividad en AndroidManifest.xml

Ejemplo:

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

Un enfoque muy sencillo es crear los diálogos a partir del método onCreateDialog()(consulte la nota a continuación). Les muestras a través showDialog(). De esta manera, Android se encarga de la rotación para usted y usted no tiene que llamar dismiss()en onPause()evitar una WindowLeak y luego no tener que restaurar el diálogo. De los documentos:

Muestra un cuadro de diálogo gestionado por esta actividad. Se realizará una llamada a onCreateDialog (int, Bundle) con el mismo ID la primera vez que se llame para un ID determinado. A partir de entonces, el cuadro de diálogo se guardará y restaurará automáticamente.

Consulte los documentos de Android showDialog () para obtener más información. ¡Espero que ayude a alguien!

Nota: Si usa AlertDialog.Builder, no llame show()desde onCreateDialog(), llame en su create()lugar. Si usa ProgressDialog, simplemente cree el objeto, establezca los parámetros que necesita y devuélvalo. En conclusión, show()inside onCreateDialog()causa problemas, simplemente cree la instancia de Dialog y devuélvala. ¡Esto debería funcionar! (He tenido problemas al usar showDialog () desde onCreate () -en realidad no muestra el diálogo-, pero si lo usa en onResume () o en una devolución de llamada de oyente, funciona bien).

Esta pregunta fue respondida hace mucho tiempo.

Sin embargo, esta es una solución simple y no pirateada que uso para mí.

Hice esta clase de ayuda por mí mismo, por lo que también puede usarla en su aplicación.

El uso es:

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

O

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

Puede combinar los métodos onSave / onRestore de Dialog con los métodos onSave / onRestore de Activity para mantener el estado del Dialog.

Nota: este método funciona para esos cuadros de diálogo "simples", como mostrar un mensaje de alerta. No reproducirá el contenido de un WebView incrustado en un diálogo. Si realmente desea evitar que se elimine un diálogo complejo durante la rotación, pruebe el método de 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());
}

Definitivamente, el mejor enfoque es usar DialogFragment.

Aquí está la solución mía de la clase contenedora que ayuda a evitar que se descarten diferentes diálogos dentro de un Fragmento (o Actividad con pequeña refactorización). Además, ayuda a evitar la refactorización masiva de código si, por alguna razón, hay muchos AlertDialogscódigos dispersos con ligeras diferencias entre ellos en términos de acciones, apariencia o algo más.

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

Cuando se trata de Actividad, puede invocarlo getContext()dentro onCreateDialog(), enviarlo a la DialogProviderinterfaz y solicitar un diálogo específico por mDialogId. Se debe eliminar toda la lógica para tratar con un fragmento de destino.

Uso del fragmento:

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

Puedes leer el artículo completo en mi blog ¿Cómo evitar que se cierre el diálogo? y juega con el código fuente .

Parece que esto sigue siendo un problema, incluso cuando se "hace todo bien" y se usa, DialogFragmentetc.

Hay un hilo en Google Issue Tracker que afirma que se debe a que se ha dejado un mensaje de descarte antiguo en la cola de mensajes. La solución alternativa proporcionada es bastante simple:

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

        super.onDestroyView();
    }

Es increíble que esto siga siendo necesario 7 años después de que se informó por primera vez de ese problema.

Tuve un problema similar: cuando cambió la orientación de la pantalla, onDismissse llamó al oyente del cuadro de diálogo aunque el usuario no descartó el cuadro de diálogo. Pude solucionar esto utilizando en su lugar el onCanceloyente, que se activaba tanto cuando el usuario presionaba el botón Atrás como cuando el usuario tocaba fuera del cuadro de diálogo.

Solo usa

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

y la aplicación sabrá cómo manejar la rotación y el tamaño de la pantalla.