Empêcher le rejet de la boîte de dialogue lors de la rotation de l'écran dans Android

J'essaie d'empêcher les boîtes de dialogue créées avec Alert Builder d'être fermées lorsque l'activité est redémarrée.

Si je surcharge la méthode onConfigurationChanged, je peux le faire avec succès et réinitialiser la mise en page pour une orientation correcte, mais je perds la fonction de texte collant d'edittext. Donc, en résolvant le problème de dialogue, j'ai créé ce problème edittext.

Si j'enregistre les chaînes de l'edittext et que je les réaffecte dans le changement onCofiguration, elles semblent toujours avoir par défaut la valeur initiale et non ce qui a été entré avant la rotation. Même si je force une invalidation semble les mettre à jour.

J'ai vraiment besoin de résoudre soit le problème de dialogue, soit le problème edittext.

Merci pour l'aide.

La meilleure façon d'éviter ce problème de nos jours est d'utiliser un fichier DialogFragment.

Créez une nouvelle classe qui s'étend DialogFragment. Remplacez onCreateDialoget renvoyez votre ancien Dialogou un fichier AlertDialog.

Ensuite, vous pouvez le montrer avec DialogFragment.show(fragmentManager, tag).

Voici un exemple avec un 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();
    }
}

Et dans l'activité que vous appelez:

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

Cette réponse aide à expliquer ces trois autres questions (et leurs réponses):

• Android Meilleur moyen d'éviter que les dialogues ne soient supprimés après une rotation de périphérique
• Android DialogFragment vs Dialog
• Comment puis-je afficher un DialogFragment à l'aide du package de compatibilité?

// 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 vous modifiez la mise en page lors du changement d'orientation, je ne mettrais pas android:configChanges="orientation"dans votre manifeste parce que vous recréez les vues de toute façon.

Enregistrez l'état actuel de votre activité (comme le texte saisi, la boîte de dialogue affichée, les données affichées, etc.) en utilisant ces méthodes:

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

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

De cette façon, l'activité passe à nouveau par onCreate et appelle ensuite la méthode onRestoreInstanceState dans laquelle vous pouvez redéfinir votre valeur EditText.

Si vous souhaitez stocker des objets plus complexes, vous pouvez utiliser

@Override
public Object onRetainNonConfigurationInstance() {
}

Ici, vous pouvez stocker n'importe quel objet et dans onCreate, il vous suffit d'appeler getLastNonConfigurationInstance();pour obtenir l'objet.

Ajoutez simplement android: configChanges = "orientation" avec votre élément d'activité dans AndroidManifest.xml

Exemple:

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

Une approche très simple consiste à créer les boîtes de dialogue à partir de la méthode onCreateDialog()(voir la remarque ci-dessous). Vous leur montrez à travers showDialog(). De cette façon, Android gère la rotation pour vous et vous ne devez pas appeler dismiss()à onPause()éviter une WindowLeak et vous ne devez restaurer la boîte de dialogue. À partir de la documentation:

Afficher une boîte de dialogue gérée par cette activité. Un appel à onCreateDialog (int, Bundle) sera effectué avec le même identifiant la première fois qu'il est appelé pour un identifiant donné. À partir de là, la boîte de dialogue sera automatiquement enregistrée et restaurée.

Voir la documentation Android showDialog () pour plus d'informations. J'espère que cela aide quelqu'un!

Remarque: si vous utilisez AlertDialog.Builder, n'appelez pas show()depuis onCreateDialog(), appelez à la create()place. Si vous utilisez ProgressDialog, créez simplement l'objet, définissez les paramètres dont vous avez besoin et renvoyez-le. En conclusion, à l' show()intérieur onCreateDialog()cause des problèmes, créez simplement une instance de Dialog et renvoyez-la. Cela devrait fonctionner! (J'ai rencontré des problèmes lors de l'utilisation de showDialog () de onCreate () - qui n'affiche pas la boîte de dialogue -, mais si vous l'utilisez dans onResume () ou dans un rappel d'auditeur, cela fonctionne bien).

Cette question a reçu une réponse il y a longtemps.

Pourtant, c'est une solution simple et non piratée que j'utilise pour moi-même.

J'ai fait cette classe d'aide pour moi-même, vous pouvez donc l'utiliser également dans votre application.

L'utilisation est:

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

Ou

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

Vous pouvez combiner les méthodes onSave / onRestore de Dialog avec les méthodes onSave / onRestore de Activity pour conserver l'état du Dialog.

Remarque: Cette méthode fonctionne pour ces boîtes de dialogue "simples", telles que l'affichage d'un message d'alerte. Il ne reproduira pas le contenu d'une WebView intégrée dans une boîte de dialogue. Si vous voulez vraiment empêcher une boîte de dialogue complexe d'être rejetée pendant la rotation, essayez la méthode 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());
}

Certainement, la meilleure approche consiste à utiliser DialogFragment.

Voici ma solution de classe wrapper qui aide à empêcher que différentes boîtes de dialogue soient rejetées dans un fragment (ou une activité avec une petite refactorisation). En outre, cela permet d'éviter une refactorisation massive du code si, pour certaines raisons, il y en a beaucoup AlertDialogsdispersés dans le code avec de légères différences entre eux en termes d'actions, d'apparence ou autre.

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

En ce qui concerne l'activité, vous pouvez l'invoquer à l' getContext()intérieur onCreateDialog(), la lancer dans l' DialogProviderinterface et demander une boîte de dialogue spécifique par mDialogId. Toute logique de traitement d'un fragment cible doit être supprimée.

Utilisation à partir du fragment:

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

Vous pouvez lire l'article complet sur mon blog Comment éviter que Dialog ne soit rejeté? et jouez avec le code source .

Il semble que ce soit toujours un problème, même lorsque "tout faire correctement" et utiliser DialogFragmentetc.

Il existe un fil de discussion sur Google Issue Tracker qui prétend que cela est dû à un ancien message de rejet laissé dans la file d'attente des messages. La solution de contournement fournie est assez simple:

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

        super.onDestroyView();
    }

Incroyable que cela soit encore nécessaire 7 ans après le premier signalement de ce problème.

J'ai eu un problème similaire: lorsque l'orientation de l'écran a changé, l' onDismissécouteur de la boîte de dialogue a été appelé même si l'utilisateur n'a pas fermé la boîte de dialogue. J'ai pu contourner ce problème en utilisant plutôt l' onCancelauditeur, qui s'est déclenché à la fois lorsque l'utilisateur a appuyé sur le bouton de retour et lorsque l'utilisateur a touché en dehors de la boîte de dialogue.

Juste utiliser

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

et l'application saura comment gérer la rotation et la taille de l'écran.