Wie kann man verhindern, dass ein Dialog geschlossen wird, wenn eine Schaltfläche angeklickt wird?

Question

Ich habe einen Dialog mit EditText für die Eingabe. Wenn ich im Dialogfeld auf die Schaltfläche "Ja" klicke, wird die Eingabe bestätigt und das Dialogfeld anschließend geschlossen. Wenn die Eingabe jedoch falsch ist, möchte ich in demselben Dialogfeld bleiben. Unabhängig von der Art der Eingabe soll das Dialogfeld automatisch geschlossen werden, wenn ich auf die Schaltfläche "Nein" klicke. Wie kann ich dies deaktivieren? Übrigens habe ich PositiveButton und NegativeButton für die Schaltfläche im Dialog verwendet.

Answer 1

Angeregt durch Toms Antwort, glaube ich, dass die Idee hier ist:

• Stellen Sie die onClickListener während der Erstellung des Dialogs zu null
• Dann setzen Sie eine onClickListener nachdem der Dialog angezeigt wurde.

Sie können die onShowListener wie Tom. Alternativ dazu können Sie

1. die Schaltfläche nach dem Aufruf der AlertDialog-Funktion show()
2. die Buttons einstellen". onClickListener wie folgt (etwas besser lesbar, denke ich).

Código:

AlertDialog.Builder builder = new AlertDialog.Builder(context);
// ...
final AlertDialog dialog = builder.create();
dialog.show();
// now you can override the default onClickListener
Button b = dialog.getButton(AlertDialog.BUTTON_POSITIVE);
b.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View view) {
        Log.i(TAG, "ok button is clicked");
        handleClick(dialog);
    }
});

Answer 2

Super einfacher Kotlin-Ansatz

 with(AlertDialog.Builder(this)) {
        setTitle("Title")
        setView(R.layout.dialog_name)
        setPositiveButton("Ok", null)
        setNegativeButton("Cancel") { _, _ -> }
        create().apply {
            setOnShowListener {
                getButton(AlertDialog.BUTTON_POSITIVE).setOnClickListener {
                    //Validate and dismiss
                    dismiss()
                }
            }
        }
    }.show()

Answer 3

Für pre API 8 habe ich das Problem mit einem booleschen Flag, einem dismiss listener und dem erneuten Aufruf von dialog.show gelöst, falls der Inhalt des editTextes nicht korrekt war. Etwa so:

case ADD_CLIENT:
        LayoutInflater factoryClient = LayoutInflater.from(this);
        final View EntryViewClient = factoryClient.inflate(
                R.layout.alert_dialog_add_client, null);

        EditText ClientText = (EditText) EntryViewClient
                .findViewById(R.id.client_edit);

        AlertDialog.Builder builderClient = new AlertDialog.Builder(this);
        builderClient
                .setTitle(R.string.alert_dialog_client)
                .setCancelable(false)
                .setView(EntryViewClient)
                .setPositiveButton("Save",
                        new DialogInterface.OnClickListener() {
                            public void onClick(DialogInterface dialog,
                                    int whichButton) {
                                EditText newClient = (EditText) EntryViewClient
                                        .findViewById(R.id.client_edit);
                                String newClientString = newClient
                                        .getText().toString();
                                if (checkForEmptyFields(newClientString)) {
                                    //If field is empty show toast and set error flag to true;
                                    Toast.makeText(getApplicationContext(),
                                            "Fields cant be empty",
                                            Toast.LENGTH_SHORT).show();
                                    add_client_error = true;
                                } else {
                                    //Here save the info and set the error flag to false
                                    add_client_error = false;
                                }
                            }
                        })
                .setNegativeButton("Cancel",
                        new DialogInterface.OnClickListener() {
                            public void onClick(DialogInterface dialog,
                                    int id) {
                                add_client_error = false;
                                dialog.cancel();
                            }
                        });
        final AlertDialog alertClient = builderClient.create();
        alertClient.show();

        alertClient
                .setOnDismissListener(new DialogInterface.OnDismissListener() {

                    @Override
                    public void onDismiss(DialogInterface dialog) {
                        //If the error flag was set to true then show the dialog again
                        if (add_client_error == true) {
                            alertClient.show();
                        } else {
                            return;
                        }

                    }
                });
        return true;

Answer 4

Die Antwort unter dieser Link ist eine einfache Lösung, die bis zu API 3 zurück kompatibel ist und der Lösung von Tom Bollwitt sehr ähnlich ist, aber ohne den weniger kompatiblen OnShowListener.

Ja, das können Sie. Im Grunde müssen Sie das:

1. Erstellen Sie den Dialog mit DialogBuilder
2. show() den Dialog
3. Suchen Sie die Schaltflächen im angezeigten Dialog und überschreiben Sie deren onClickListener

Ich habe kleinere Anpassungen an Kamen's Code vorgenommen, da ich eine EditTextPreference erweitert habe.

@Override
protected void showDialog(Bundle state) {
  super.showDialog(state);

  class mocl implements OnClickListener{
    private final AlertDialog dialog;
    public mocl(AlertDialog dialog) {
          this.dialog = dialog;
      }
    @Override
    public void onClick(View v) {

        //checks if EditText is empty, and if so tells the user via Toast
        //otherwise it closes dialog and calls the EditTextPreference's onClick
        //method to let it know that the button has been pressed

        if (!IntPreference.this.getEditText().getText().toString().equals("")){
        dialog.dismiss();
        IntPreference.this.onClick(dialog,DialogInterface.BUTTON_POSITIVE);
        }
        else {
            Toast t = Toast.makeText(getContext(), "Enter a number!", Toast.LENGTH_SHORT);
            t.show();
        }

    }
  }

  AlertDialog d = (AlertDialog) getDialog();
  Button b = d.getButton(DialogInterface.BUTTON_POSITIVE);
  b.setOnClickListener(new mocl((d)));
}

Was für ein Spaß!

Answer 5

Mit diesem Code können Sie verhindern, dass der Dialog geschlossen wird, wenn eine positive Schaltfläche angeklickt wird. Sie können dasselbe auch mit der negativen Schaltfläche implementieren.

    final AlertDialog alertDialog = alertDialogBuilder
            .setCancelable(false)
            .setTitle("TITLE");
            .setPositiveButton("OK", null)
            .setNegativeButton("CANCEL",
                    (dialog, id) -> {
                        dialog.cancel();
                    })
            .show();
    Button positiveButton = alertDialog.getButton(AlertDialog.BUTTON_POSITIVE);
    positiveButton.setOnClickListener(v -> {
         // check whatever you want
         if(checkMyCondition())
             dialog.cancel();
    })