Jelly Bean DatePickerDialog - Gibt es eine Möglichkeit, abzubrechen?

Hinweis: Feste wie der LutscherQuelle hier. Automatisierte Klasse für den Einsatz in clients (kompatibel mit allen Android-Versionen) aktualisiert.

TL;DR: 1-2-3 Toten einfache Schritte für eine Globale Lösung:

1. Download diese Klasse.
2. Implementieren OnDateSetListener in Ihrer Aktivität (oder ändern Sie die Klasse, um Ihre Bedürfnisse anzupassen).

3. Trigger-Dialogfeld mit diesem code (in diesem Beispiel, benutze ich es in einem Fragment):

   Bundle b = new Bundle();
   b.putInt(DatePickerDialogFragment.YEAR, 2012);
   b.putInt(DatePickerDialogFragment.MONTH, 6);
   b.putInt(DatePickerDialogFragment.DATE, 17);
   DialogFragment picker = new DatePickerDialogFragment();
   picker.setArguments(b);
   picker.show(getActivity().getSupportFragmentManager(), "frag_date_picker");

Und das ist alles was es braucht! Der Grund, warum ich immer noch meine Antwort als "akzeptiert" ist, weil ich immer noch lieber meine Lösung, da es eine sehr kleine Stellfläche im client-code, befasst sich mit dem grundlegenden Problem (der listener aufgerufen wird, in der framework-Klasse), funktioniert über config-änderungen und-Routen der code-Logik, um die default-Implementierung in den vorherigen Android-Versionen nicht geplagt von diesem Fehler (siehe Klasse Quelle).

Ursprüngliche Antwort (behalten aus historischen und didaktischen Gründen):

Fehler Quelle

OK, sieht aus wie es ist in der Tat ein bug und schon jemand anderes gefüllt. Problem 34833.

Habe ich gefunden, dass das problem möglicherweise in DatePickerDialog.java. Wo es heißt:

private void tryNotifyDateSet() {
    if (mCallBack != null) {
        mDatePicker.clearFocus();
        mCallBack.onDateSet(mDatePicker, mDatePicker.getYear(),
                mDatePicker.getMonth(), mDatePicker.getDayOfMonth());
    }
}

@Override
protected void onStop() {
    tryNotifyDateSet();
    super.onStop();
}

Ich denke, es hätte sein können:

@Override
protected void onStop() {
    //instead of the full tryNotifyDateSet() call:
    if (mCallBack != null) mDatePicker.clearFocus();
    super.onStop();
}

Nun, wenn jemand kann mir sagen, wie kann ich vorschlagen, einen patch/bug-report zu Android, ich würde mich freuen. Mittlerweile habe ich vorgeschlagen, eine mögliche Lösung (einfach) als angehängte version von DatePickerDialog.java in der Ausgabe.

Konzept zu vermeiden, die Fehler

Legen Sie den Hörer auf null im Konstruktor, und erstellen Sie Ihre eigenen BUTTON_POSITIVE Schaltfläche später. Das ist es, details siehe unten.

Das problem tritt auf, weil DatePickerDialog.javawie Sie sehen können, in der Quelle fordert eine Globale variable (mCallBack) , speichert der listener, die übergeben wurde, im Konstruktor:

    /**
 * @param context The context the dialog is to run in.
 * @param callBack How the parent is notified that the date is set.
 * @param year The initial year of the dialog.
 * @param monthOfYear The initial month of the dialog.
 * @param dayOfMonth The initial day of the dialog.
 */
public DatePickerDialog(Context context,
        OnDateSetListener callBack,
        int year,
        int monthOfYear,
        int dayOfMonth) {
    this(context, 0, callBack, year, monthOfYear, dayOfMonth);
}

    /**
 * @param context The context the dialog is to run in.
 * @param theme the theme to apply to this dialog
 * @param callBack How the parent is notified that the date is set.
 * @param year The initial year of the dialog.
 * @param monthOfYear The initial month of the dialog.
 * @param dayOfMonth The initial day of the dialog.
 */
public DatePickerDialog(Context context,
        int theme,
        OnDateSetListener callBack,
        int year,
        int monthOfYear,
        int dayOfMonth) {
    super(context, theme);

    mCallBack = callBack;
    //... rest of the constructor.
}

So, der trick ist, um eine null listener gespeichert werden, wie der Hörer, und dann Rollen Sie Ihre eigenen Satz von Tasten (unten ist der original code aus #1, aktualisiert):

    DatePickerDialog picker = new DatePickerDialog(
        this,
        null, //instead of a listener
        2012, 6, 15);
    picker.setCancelable(true);
    picker.setCanceledOnTouchOutside(true);
    picker.setButton(DialogInterface.BUTTON_POSITIVE, "OK",
        new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                Log.d("Picker", "Correct behavior!");
            }
        });
    picker.setButton(DialogInterface.BUTTON_NEGATIVE, "Cancel", 
        new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                Log.d("Picker", "Cancel!");
            }
        });
picker.show();

Ist es jetzt funktionieren wird, da die Möglichkeit der Korrektur, die ich oben geschrieben.

Und da DatePickerDialog.java prüft, ob ein null Wann immer es liest mCallback (seit den Tagen des API 3/1.5 es scheint --- kann nicht überprüfen, Honeycomb natürlich), es wird nicht die Ausnahme auslöst. Angesichts Lollipop das Problem behoben wurde, werde ich nicht zu schauen es: nutzen Sie einfach die default-Implementierung (in der Klasse, die ich zur Verfügung gestellt).

Zuerst hatte ich Angst, nicht den Aufruf der clearFocus()aber ich habe hier getestet und die Log-Linien waren sauber. So, die Zeile habe ich vorgeschlagen, vielleicht sogar nicht notwendig, nachdem alle, aber ich weiß es nicht.

Kompatibilität mit früheren API-Ebenen (bearbeitet)

Als ich, wies in den Kommentar unten, das war ein Konzept, und Sie können laden Sie die Klasse ich bin mit meinem Google Drive-Konto. Die Art, wie ich verwendet, die Standard-system-Implementierung verwendet wird, auf Versionen nicht betroffen von dem bug.

Nahm ich ein paar Annahmen (die Namen von Schaltflächen, etc.) geeignet sind für meine Bedürfnisse, weil ich wollte, zu verringern, boilerplate code in der client-Klassen auf ein minimum. Volle Nutzung Beispiel:

class YourActivity extends SherlockFragmentActivity implements OnDateSetListener

//...

Bundle b = new Bundle();
b.putInt(DatePickerDialogFragment.YEAR, 2012);
b.putInt(DatePickerDialogFragment.MONTH, 6);
b.putInt(DatePickerDialogFragment.DATE, 17);
DialogFragment picker = new DatePickerDialogFragment();
picker.setArguments(b);
picker.show(getActivity().getSupportFragmentManager(), "fragment_date_picker");

InformationsquelleAutor der Antwort

Bis der Fehler behoben wird schlage ich vor, Sie nicht zu verwenden, DatePickerDialog oder TimePickerDialog. Verwenden Sie benutzerdefinierte gemacht AlertDialog mit TimePicker/DatePicker-widget;

Ändern TimePickerDialog mit;

    final TimePicker timePicker = new TimePicker(this);
    timePicker.setIs24HourView(true);
    timePicker.setCurrentHour(20);
    timePicker.setCurrentMinute(15);

    new AlertDialog.Builder(this)
            .setTitle("Test")
            .setPositiveButton(android.R.string.ok, new OnClickListener() {

                @Override
                public void onClick(DialogInterface dialog, int which) {
                    Log.d("Picker", timePicker.getCurrentHour() + ":"
                            + timePicker.getCurrentMinute());
                }
            })
            .setNegativeButton(android.R.string.cancel,
                    new OnClickListener() {

                        @Override
                        public void onClick(DialogInterface dialog,
                                int which) {
                            Log.d("Picker", "Cancelled!");
                        }
                    }).setView(timePicker).show();

Ändern DatePickerDialog mit;

    final DatePicker datePicker = new DatePicker(this);
    datePicker.init(2012, 10, 5, null);
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
        datePicker.setCalendarViewShown(false);
    }

    new AlertDialog.Builder(this)
            .setTitle("Test")
            .setPositiveButton(android.R.string.ok, new OnClickListener() {

                @Override
                public void onClick(DialogInterface dialog, int which) {
                    Log.d("Picker", datePicker.getYear() + " "
                            + (datePicker.getMonth() + 1) + " "
                            + datePicker.getDayOfMonth());
                }
            })
            .setNegativeButton(android.R.string.cancel,
                    new OnClickListener() {

                        @Override
                        public void onClick(DialogInterface dialog,
                                int which) {
                            Log.d("Picker", "Cancelled!");
                        }
                    }).setView(datePicker).show();

InformationsquelleAutor der Antwort cirit

In den Fall, jemand will eine schnelle Abhilfe, hier ist der code, den ich verwendet:

public void showCustomDatePicker () {

final DatePicker mDatePicker = (DatePicker) getLayoutInflater().
        inflate(R.layout.date_picker_view, null);
//Set an initial date for the picker
final Calendar c = Calendar.getInstance();
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH);
int day = c.get(Calendar.DAY_OF_MONTH);
//Set the date now
mDatePicker.updateDate(year, month, day);

//create the dialog
AlertDialog.Builder mBuilder = new Builder(this);
//set the title
mBuilder.setTitle(getString(R.string.date_picker_title))
    //set our date picker
    .setView(mDatePicker)
    //set the buttons 
.setPositiveButton(android.R.string.ok, new OnClickListener() {

    @Override
    public void onClick(DialogInterface dialog, int which) {
        //whatever method you choose to handle the date changes
            //the important thing to know is how to retrieve the data from the picker
        handleOnDateSet(mDatePicker.getYear(), 
                mDatePicker.getMonth(), 
                mDatePicker.getDayOfMonth());
    }
})
.setNegativeButton(android.R.string.cancel, new OnClickListener() {

    @Override
    public void onClick(DialogInterface dialog, int which) {
        dialog.dismiss();
    }
})
//create the dialog and show it.
.create().show();

}

Wo layout.date_picker_view ist ein einfaches layout-Ressource mit einem DatePicker, da es nur ein element:

<!xml version="1.0" encoding="utf-8">
<DatePicker xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/date_picker"
android:layout_width="fill_parent"   
android:spinnersShown="true" 
android:calendarViewShown="false"
android:layout_height="fill_parent"/>

Hier ist die vollständige tutorial in Fall, dass Sie interessiert sind.

InformationsquelleAutor der Antwort daniel_c05

Die Art und Weise habe ich es geschafft diese situation wurde mit einem flag und überschreiben der onCancel und onDismiss Methoden.

onCancel wird nur aufgerufen, wenn der Benutzer berührt außerhalb des Dialogfensters oder die zurück-Taste.
onDismiss immer aufgerufen wird,

Einstellung eine fahne in die onCancel-Methode kann helfen, die filter in der onDismiss Methode die Absicht des Benutzers: Abbruch der Aktion oder Aktion durchgeführt. Nachfolgend einige code, der zeigt die Idee.

public class DatePickerDialogFragment extends DialogFragment implements DatePickerDialog.OnDateSetListener {

    private boolean cancelDialog = false;
    private int year;
    private int month;
    private int day;

    @Override
    public Dialog onCreateDialog(Bundle savedInstanceState) {
        DatePickerDialog dpd = new DatePickerDialog(getActivity(), this, year, month, day);
        return dpd;
    }

    public void setDatePickerDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    @Override
    public void onCancel(DialogInterface dialog) {
        super.onCancel(dialog);
        cancelDialog = true;
    }

    @Override
    public void onDismiss(DialogInterface dialog) {
        super.onDismiss(dialog);
        if (!cancelDialog) {
          #put the code you want to execute if the user clicks the done button
        }
    }

    @Override
    public void onDateSet(DatePicker view, int year, int monthOfYear, int dayOfMonth) {
        setDatePickerDate(year, monthOfYear, dayOfMonth);
    }
}

InformationsquelleAutor der Antwort Alvaro

Gibt es eine sehr einfache Lösung, wenn Ihre Anwendung nicht mit der Aktion bar. Beachten Sie übrigens, dass einige Anwendungen verlassen sich auf diese Funktionalität zu arbeiten, weil die Aufhebung der date picker hat eine Besondere Bedeutung (z.B. löscht er das date-Feld mit einer leeren Zeichenfolge, die für manche apps ist eine gültige und sinnvolle Art der Eingabe) und die Verwendung von boolean-flags zu verhindern, dass das Datum festgelegt wird zweimal auf OK, wird dir nicht helfen in diesem Fall.

Re. die eigentliche Korrektur, Sie haben keinen um erstellen Sie neue Schaltflächen oder Ihren eigenen dialog. Der Punkt ist, um kompatibel zu sein mit den beiden, die ältere Versionen von Android, die buggy sind (4.) und jede Zukunft, wenn die letztere ist unmöglich, sicher, natürlich.
Beachten Sie, dass in Android 2., der onStop() für android.app.Dialog tut überhaupt nichts, und in der 4.* es tut mActionBar.setShowHideAnimationEnabled(false) ist nur wichtig, wenn Ihre app über eine action bar. Der onStop() in DatePickerDialog, die erbt von Dialog, trägt nur mDatePicker.clearFocus() (wie Sie das neueste Update für Android Quellen 4.3), die nicht wichtig erscheinen.

Ersetzt also onStop (), eine Methode, die nichts tut, sollte in vielen Fällen beheben Sie Ihre app und sicherzustellen, dass es so bleiben für die absehbare Zukunft. So erweitern Sie ganz einfach DatePickerDialog Klasse mit Ihren eigenen und überschreiben onStop() mit einer dummy-Methode. Sie müssen auch ein oder zwei Konstruktoren, wie pro Ihre Anforderungen.
Beachten Sie auch, dass man nicht versucht sein, zu übertreiben, diese zu beheben, indem Sie z.B. versuchen, etwas zu tun mit der Tätigkeit bar direkt, als würde beschränken Sie Ihre Kompatibilität zu den neuesten Versionen von Android nur. Beachten Sie auch, dass es schön wäre, um der Lage sein, die super für den DatePicker-der onStop (), da der Fehler nur in der onStop() in DatePickerDialog selbst, aber nicht in DatePickerDialog ist super Klasse. Dies würde jedoch erfordern, die Sie anrufen, super.super.onStop() aus der custom-Klasse, die Java-lassen Sie nicht zu tun, da geht es gegen die Verkapselung Philosophie 🙂
Unten ist meine kleine Klasse, die ich verwendet, um verride DatePickerDialog.
Ich hoffe, dieser Kommentar wäre nützlich für jemanden.
Wojtek Jarosz

public class myDatePickerDialog extends DatePickerDialog {

public myDatePickerDialog(Context context, OnDateSetListener callBack, int year, int monthOfYear, int dayOfMonth) {
    super(context, callBack, year, monthOfYear, dayOfMonth);
}

@Override
protected void onStop() {
    //Replacing tryNotifyDateSet() with nothing - this is a workaround for Android bug https://android-review.googlesource.com/#/c/61270/A

    //Would also like to clear focus, but we cannot get at the private members, so we do nothing.  It seems to do no harm...
    //mDatePicker.clearFocus();

    //Now we would like to call super on onStop(), but actually what we would mean is super.super, because
    //it is super.onStop() that we are trying NOT to run, because it is buggy.  However, doing such a thing
    //in Java is not allowed, as it goes against the philosophy of encapsulation (the Creators never thought
    //that we might have to patch parent classes from the bottom up :)
    //However, we do not lose much by doing nothing at all, because in Android 2.* onStop() in androd.app.Dialog //actually
    //does nothing and in 4.* it does:
    //     if (mActionBar != null) mActionBar.setShowHideAnimationEnabled(false); 
    //which is not essential for us here because we use no action bar... QED
    //So we do nothing and we intend to keep this workaround forever because of users with older devices, who might
    //run Android 4.1 - 4.3 for some time to come, even if the bug is fixed in later versions of Android.
}   

}

InformationsquelleAutor der Antwort Wojtek Jarosz

Eine einfache Lösung wäre die Verwendung einer booleschen überspringen zweiten Lauf

boolean isShow = false; //define global variable


//when showing time picker
TimePickerDialog timeDlg = new TimePickerDialog( this, new OnTimeSetListener()
            {

                @Override
                public void onTimeSet( TimePicker view, int hourOfDay, int minute )
                {
                    if ( isShow )
                    {
                        isShow = false;
                        //your code
                    }

                }
            }, 8, 30, false );

timeDlg.setButton( TimePickerDialog.BUTTON_NEGATIVE, "Cancel", new DialogInterface.OnClickListener()
            {
                @Override
                public void onClick( DialogInterface dialog, int which )
                {
                    isShow = false;
                }
            } );
timeDlg.setButton( TimePickerDialog.BUTTON_POSITIVE, "Set", new DialogInterface.OnClickListener()
            {
                @Override
                public void onClick( DialogInterface dialog, int which )
                {
                    isShow = true;
                }
            } );

timeDlg.show();

InformationsquelleAutor der Antwort chamikaw

Hier ist mein workaround Klasse für DatePickerDialog auf "Abbrechen" button verwerfen, indem Sie zurück-Taste. Copy&verwenden, in der Art von DatePickerDialog (Weil der Hörer ist stateful, müssen wir neue Instanz, wenn verwenden, ansonsten mehr code erforderlich ist, zu machen es funktioniert)

Verwenden:

new FixedDatePickerDialog(this,
            new FixedOnDateSetListener() {

                @Override
                public void onDateSet(DatePicker view, int year,
                        int monthOfYear, int dayOfMonth) {
                    if (isOkSelected()) {
                        //when DONE button is clicked
                    }
                }

            }, year, month, day).show();

Klasse:

public class FixedDatePickerDialog extends DatePickerDialog {
private final FixedOnDateSetListener fixedCallback;
public FixedDatePickerDialog(Context context,
        FixedOnDateSetListener callBack, int year, int monthOfYear,
        int dayOfMonth) {
    super(context, callBack, year, monthOfYear, dayOfMonth);
    fixedCallback = callBack;
    this.setButton(DialogInterface.BUTTON_NEGATIVE,
            context.getString(R.string.cancel), this);
    this.setButton(DialogInterface.BUTTON_POSITIVE,
            context.getString(R.string.done), this);
}

@Override
public void onClick(DialogInterface dialog, int which) {
    if (which == BUTTON_POSITIVE) {
        fixedCallback.setOkSelected(true);
    } else {
        fixedCallback.setOkSelected(false);
    }
    super.onClick(dialog, which);
}

public abstract static class FixedOnDateSetListener implements
        OnDateSetListener {
    private boolean okSelected = false;

    @Override
    abstract public void onDateSet(DatePicker view, int year,
            int monthOfYear, int dayOfMonth);

    public void setOkSelected(boolean okSelected) {
        this.okSelected = okSelected;
    }

    public boolean isOkSelected() {
        return okSelected;
    }
}

}

InformationsquelleAutor der Antwort The Sea

Ich mochte David Cesarino ' s Antwort oben, aber wollte etwas, das war ein drop-in-Ersatz für den gebrochenen dialog und arbeiten würde, auf jeder dialog, vielleicht fehlt kündigen /falsche Abbrechen Verhalten. Hier sind abgeleitete Klassen für DatePickerDialog /TimePickerDialog funktionieren sollte, das als drop-in Ersatz. Diese sind nicht benutzerdefinierte Ansichten. Es verwendet die system-dialog, sondern ändert nur den Abbrechen - /zurück-button Verhalten wie erwartet funktioniert.

Diese Arbeit sollte auf API-Ebene 3 und höher. Also, im Grunde jede Android-version (getestet habe ich es auf jellybean und lollipop speziell).

DatePickerDialog:

package snappy_company_name_here;

import android.content.Context;
import android.content.DialogInterface;
import android.widget.DatePicker;

/**
 * This is a modified version of DatePickerDialog that correctly handles cancellation behavior since it's broken on jellybean and
 * kitkat date pickers.
 *
 * Here is the bug: http://code.google.com/p/android/issues/detail?id=34833
 * Here is an SO post with a bunch of details: http://stackoverflow.com/questions/11444238/jelly-bean-datepickerdialog-is-there-a-way-to-cancel
 *
 * @author stuckj, created on 5/5/15.
 */
public class DatePickerDialog extends android.app.DatePickerDialog implements DialogInterface.OnClickListener
{
    final CallbackHelper callbackHelper;

    //NOTE: Must be static since we're using it in a super constructor call. Which is annoying, but necessary
    private static class CallbackHelper implements OnDateSetListener
    {
        private final OnDateSetListener callBack;
        private boolean dialogButtonPressHandled = false; //To prevent setting the date when the dialog is dismissed...

        //NOTE: Must be static since we're using it in a super constructor call. Which is annoying, but necessary
        public CallbackHelper(final OnDateSetListener callBack)
        {
            this.callBack = callBack;
        }

        @Override
        public void onDateSet(final DatePicker view, final int year, final int monthOfYear, final int dayOfMonth)
        {
            if (!dialogButtonPressHandled && (callBack != null))
            {
                callBack.onDateSet(view, year, monthOfYear, dayOfMonth);
            }
        }
    }

    /**
     * Sets the positive and negative buttons to use the dialog callbacks we define.
     */
    private void setButtons(final Context context)
    {
        setButton(DialogInterface.BUTTON_NEGATIVE, context.getString(android.R.string.cancel), this);
        setButton(DialogInterface.BUTTON_POSITIVE, context.getString(android.R.string.ok), this);
    }

    @Override
    public void onClick(final DialogInterface dialog, final int which)
    {
        //ONLY call the super method in the positive case...
        if (which == DialogInterface.BUTTON_POSITIVE)
        {
            super.onClick(dialog, which);
        }

        callbackHelper.dialogButtonPressHandled = true;
    }

    @Override
    public void onBackPressed()
    {
        getButton(DialogInterface.BUTTON_NEGATIVE).performClick();
    }

    //Need this so we can both pass callbackHelper to the super class and save it off as a variable.
    private DatePickerDialog(final Context context,
                             final OnDateSetListener callBack,
                             final int year,
                             final int monthOfYear,
                             final int dayOfMonth,
                             final CallbackHelper callbackHelper)
    {
        super(context, callbackHelper, year, monthOfYear, dayOfMonth);
        this.callbackHelper = callbackHelper;
        setButtons(context);
    }

    /**
     * @param context The context the dialog is to run in.
     * @param callBack How the parent is notified that the date is set.
     * @param year The initial year of the dialog.
     * @param monthOfYear The initial month of the dialog.
     * @param dayOfMonth The initial day of the dialog.
     */
    public DatePickerDialog(final Context context,
                            final OnDateSetListener callBack,
                            final int year,
                            final int monthOfYear,
                            final int dayOfMonth)
    {
        this(context, callBack, year, monthOfYear, dayOfMonth, new CallbackHelper(callBack));
    }

    //Need this so we can both pass callbackHelper to the super class and save it off as a variable.
    private DatePickerDialog(final Context context, final int theme, final OnDateSetListener listener, final int year,
                             final int monthOfYear, final int dayOfMonth, final CallbackHelper callbackHelper)
    {
        super(context, theme, callbackHelper, year, monthOfYear, dayOfMonth);
        this.callbackHelper = callbackHelper;
        setButtons(context);
    }

    /**
     * @param context The context the dialog is to run in.
     * @param theme the theme to apply to this dialog
     * @param listener How the parent is notified that the date is set.
     * @param year The initial year of the dialog.
     * @param monthOfYear The initial month of the dialog.
     * @param dayOfMonth The initial day of the dialog.
     */
    public DatePickerDialog(final Context context, final int theme, final OnDateSetListener listener, final int year,
                            final int monthOfYear, final int dayOfMonth)
    {
        this(context, theme, listener, year, monthOfYear, dayOfMonth, new CallbackHelper(listener));
    }
}

TimePickerDialog:

package snappy_company_name_here;

import android.content.Context;
import android.content.DialogInterface;
import android.widget.TimePicker;

/**
 * This is a modified version of TimePickerDialog that correctly handles cancellation behavior since it's broken on jellybean and
 * kitkat date pickers.
 *
 * Here is the bug: http://code.google.com/p/android/issues/detail?id=34833
 * Here is an SO post with a bunch of details: http://stackoverflow.com/questions/11444238/jelly-bean-datepickerdialog-is-there-a-way-to-cancel
 *
 * @author stuckj, created on 5/5/15.
 */
public class TimePickerDialog extends android.app.TimePickerDialog implements DialogInterface.OnClickListener
{
    final CallbackHelper callbackHelper;

    //NOTE: Must be static since we're using it in a super constructor call. Which is annoying, but necessary
    private static class CallbackHelper implements OnTimeSetListener
    {
        private final OnTimeSetListener callBack;
        private boolean dialogButtonPressHandled = false; //To prevent setting the date when the dialog is dismissed...

        //NOTE: Must be static since we're using it in a super constructor call. Which is annoying, but necessary
        public CallbackHelper(final OnTimeSetListener callBack)
        {
            this.callBack = callBack;
        }

        @Override
        public void onTimeSet(final TimePicker view, final int hourOfDay, final int minute)
        {
            if (!dialogButtonPressHandled && (callBack != null))
            {
                callBack.onTimeSet(view, hourOfDay, minute);
            }
        }
    }

    /**
     * Sets the positive and negative buttons to use the dialog callbacks we define.
     */
    private void setButtons(final Context context)
    {
        setButton(DialogInterface.BUTTON_NEGATIVE, context.getString(android.R.string.cancel), this);
        setButton(DialogInterface.BUTTON_POSITIVE, context.getString(android.R.string.ok), this);
    }

    @Override
    public void onClick(final DialogInterface dialog, final int which)
    {
        //ONLY call the super method in the positive case...
        if (which == DialogInterface.BUTTON_POSITIVE)
        {
            super.onClick(dialog, which);
        }

        callbackHelper.dialogButtonPressHandled = true;
    }

    @Override
    public void onBackPressed()
    {
        getButton(DialogInterface.BUTTON_NEGATIVE).performClick();
    }

    //Need this so we can both pass callbackHelper to the super class and save it off as a variable.
    private  TimePickerDialog(final Context context,
                              final OnTimeSetListener callBack,
                              final int hourOfDay, final int minute, final boolean is24HourView, final CallbackHelper callbackHelper)
    {
        super(context, callbackHelper, hourOfDay, minute, is24HourView);
        this.callbackHelper = callbackHelper;
        setButtons(context);
    }

    /**
     * @param context Parent.
     * @param callBack How parent is notified.
     * @param hourOfDay The initial hour.
     * @param minute The initial minute.
     * @param is24HourView Whether this is a 24 hour view, or AM/PM.
     */
    public TimePickerDialog(final Context context,
                            final OnTimeSetListener callBack,
                            final int hourOfDay, final int minute, final boolean is24HourView)
    {
        this(context, callBack, hourOfDay, minute, is24HourView, new CallbackHelper(callBack));
    }

    //Need this so we can both pass callbackHelper to the super class and save it off as a variable.
    private TimePickerDialog(final Context context, final int theme, final OnTimeSetListener callBack, final int hourOfDay,
                            final int minute, final boolean is24HourView, final CallbackHelper callbackHelper)
    {
        super(context, theme, callbackHelper, hourOfDay, minute, is24HourView);
        this.callbackHelper = callbackHelper;
        setButtons(context);
    }

    /**
     * @param context Parent.
     * @param theme the theme to apply to this dialog
     * @param callBack How parent is notified.
     * @param hourOfDay The initial hour.
     * @param minute The initial minute.
     * @param is24HourView Whether this is a 24 hour view, or AM/PM.
     */
    public TimePickerDialog(final Context context, final int theme, final OnTimeSetListener callBack, final int hourOfDay,
                            final int minute, final boolean is24HourView)
    {
        this(context, theme, callBack, hourOfDay, minute, is24HourView, new CallbackHelper(callBack));
    }
}

InformationsquelleAutor der Antwort stuckj

Für TimePickerDialog die Abhilfe kann wie folgt sein:

TimePickerDialog createTimePickerDialog(Context context, int themeResId, TimePickerDialog.OnTimeSetListener orignalListener,
                                                         int hourOfDay, int minute, boolean is24HourView) {
        class KitKatTimeSetListener implements TimePickerDialog.OnTimeSetListener {
            private int hour;
            private int minute;

            private KitKatTimeSetListener() {
            }

            @Override
            public void onTimeSet(TimePicker view, int hourOfDay, int minute) {
                this.hour = hourOfDay;
                this.minute = minute;
            }

            private int getHour() { return hour; }
            private int getMinute() {return minute; }
        };

        KitKatTimeSetListener kitkatTimeSetListener = new KitKatTimeSetListener();
        TimePickerDialog timePickerDialog = new TimePickerDialog(context, themeResId, kitkatTimeSetListener, hourOfDay, minute, is24HourView);

        timePickerDialog.setButton(DialogInterface.BUTTON_POSITIVE, context.getString(android.R.string.ok), (dialog, which) -> {
            timePickerDialog.onClick(timePickerDialog, DialogInterface.BUTTON_POSITIVE);
            orignalListener.onTimeSet(new TimePicker(context), kitkatTimeSetListener.getHour(), kitkatTimeSetListener.getMinute());
            dialog.cancel();
        });
        timePickerDialog.setButton(DialogInterface.BUTTON_NEGATIVE, context.getString(android.R.string.cancel), (dialog, which) -> {
            dialog.cancel();
        });

        return timePickerDialog;
    }

Ich delegieren alle Ereignisse wrapper KitKatSetTimeListener, und nur Feuer, zurück zum ursprünglichen OnTimeSetListener im Falle BUTTON_POSITIVE geklickt wird.

InformationsquelleAutor der Antwort southerton

Ich weiß, dieser Beitrag ist hier schon seit fast einem Jahr, aber ich dachte, ich sollte post meine Erkenntnisse.
Sie konnte noch immer die Zuhörer(anstatt es zu mull) und trotzdem haben diese Arbeit, wie erwartet. Der Schlüssel ist, um implizit die "OK" - oder(und) die "Abbrechen" - buttons. Habe es getestet und es funktioniert dankbar für mich. Der Zuhörer muß nicht gefeuert zweimal.

Blick auf dieses Beispiel,

private void setTime(){
final Calendar c = Calendar.getInstance();
int hour = c.get(Calendar.HOUR_OF_DAY);
int minute = c.get(Calendar.MINUTE);

final TimePickerDialog timepicker = new TimePickerDialog(this.getActivity(),
        timePickerListener,
        hour, 
        minute, 
        DateFormat.is24HourFormat(getActivity()));

timepicker.setButton(DialogInterface.BUTTON_POSITIVE, "Print", new    
    android.content.DialogInterface.OnClickListener(){
        @Override
        public void onClick(DialogInterface dialog,int which) {
            print = true;
            timepicker.dismiss();           
        }
});

timepicker.setButton(DialogInterface.BUTTON_NEGATIVE, "Cancel", new 
    android.content.DialogInterface.OnClickListener(){
        @Override
        public void onClick(DialogInterface dialog,int which){
            print = false;
            timepicker.dismiss();       
        }
});

timepicker.setCancelable(false);
timepicker.show();
}

InformationsquelleAutor der Antwort Crocodile