दिलचस्प पोस्ट
जावास्क्रिप्ट / कचरा कलेक्टर में परिपत्र संदर्भ मैं डेटाएंडटेक्स्ट प्रॉपर्टी का उपयोग कर XAML में एक विंडो पर एक व्यू मॉडेल कैसे सेट करूं? एनजी-क्लिक से मूल तत्व प्राप्त करें जावास्क्रिप्ट – "यह" का स्वामी UIGraphicsGetImageFromCurrentImageContext मेमोरी रिसाव पूर्वावलोकन के साथ एआरएम: लिंक रजिस्टर और फ्रेम सूचक लिनक्स में सी के getch () फ़ंक्शन को कैसे कार्यान्वित करें? जावास्क्रिप्ट के साथ वर्तमान यूआरएल प्राप्त करें? केंद्र में <ul> <li> div में जावा में ResultSet द्वारा दिए गए पंक्तियों की संख्या प्राप्त करें क्या मैं mailto के उपयोग के साथ विषय / ईमेल की सामग्री सेट कर सकता हूं? मैं क्यों नहीं कर सकता <img src = "C: /localfile.jpg">? जब वर्तमान चयनित आइटम को फिर से चुना जाता है तो मैं एंड्रॉइड स्पिनर में एक ईवेंट कैसे प्राप्त करूं? आर.सी. 1 में बाइंडिंग सिंटैक्स का उपयोग करके कुछ शैलियों को जोड़ा नहीं जा सकता है हम थ्रेड.स्टार्ट () विधि को कॉल क्यों करते हैं जो कॉल को विधि चलाते हैं?

जेली बीन दिनांक पिक्चर डाइलाग – क्या रद्द करने का कोई तरीका है?

मॉडरेटर के लिए नोट: आज (15 जुलाई), मैंने पाया है कि किसी ने पहले से ही इस समस्या का सामना कर लिया है। लेकिन मुझे यकीन नहीं है कि अगर इसे डुप्लिकेट के रूप में बंद करना उचित है, क्योंकि मुझे लगता है कि मैंने इस मुद्दे के बेहतर विवरण प्रदान किया है। मुझे यकीन नहीं है कि मुझे अन्य प्रश्न को संपादित करना चाहिए और वहां इस सामग्री को पेस्ट करना चाहिए, लेकिन मैं किसी और के प्रश्न को बहुत ज्यादा बदलना सहज नहीं हूं। —

मेरे पास कुछ अजीब है

मुझे नहीं लगता कि समस्या यह निर्भर करती है कि आप किसके खिलाफ एसडीके बनाते हैं उपकरण ओएस संस्करण क्या मायने रखता है

समस्या # 1: डिफ़ॉल्ट रूप से असंगति

जेली बीन में DatePickerDialog (?) बदल गया था और अब केवल एक पूर्ण बटन प्रदान करता है पिछले संस्करणों में एक रद्द करें बटन शामिल था, और इससे उपयोगकर्ता अनुभव (पिछले एंड्रॉइड वर्ज़न से असंगतता, मांसपेशी मेमोरी) को प्रभावित कर सकता है।

प्रतिलिपि बनाएँ : एक बुनियादी परियोजना बनाएं इसे पर रखें onCreate :

 DatePickerDialog picker = new DatePickerDialog( this, new OnDateSetListener() { @Override public void onDateSet(DatePicker v, int y, int m, int d) { Log.d("Picker", "Set!"); } }, 2012, 6, 15); picker.show(); 

अपेक्षित: संवाद में प्रकट होने के लिए एक रद्द करें बटन।

वर्तमान: एक रद्द करें बटन दिखाई नहीं देता।

स्क्रीनशॉट: 4.0.3 (ओके) और 4.1.1 (संभवतः गलत?)।

समस्या # 2: गलत व्यवहार को ख़ारिज करना

डायलॉग कॉल जो भी श्रोता है वह वास्तव में कॉल करना चाहिए, और फिर हमेशा OnDateSetListener श्रोता को कॉल OnDateSetListener है। रद्द करना अभी भी सेट विधि को कॉल करता है, और सेटिंग को दो बार विधि कहता है

प्रतिलिपि: # 1 कोड का उपयोग करें, लेकिन नीचे कोड जोड़ें (आप देखेंगे कि यह # 1 हल करता है, लेकिन केवल नेत्रहीन / UI):

 picker.setButton(DialogInterface.BUTTON_NEGATIVE, "Cancel", new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { Log.d("Picker", "Cancel!"); } }); 

अपेक्षित होना:

  • बैक की दबाए जाने या संवाद के बाहर क्लिक करने से कुछ भी नहीं करना चाहिए
  • दबाने "रद्द करें" का मुद्रण पिकर रद्द करना चाहिए !
  • "सेट" को दबाए जाने वाले पिकर सेट को प्रिंट करना चाहिए !

वर्तमान:

  • बैक कुंजी दबाकर या डायलॉग प्रिंटर्स सेट पर क्लिक करके क्लिक करें!
  • "रद्द करें" प्रिंटिंग पिकर रद्द करने का दबाव ! और फिर पिकर सेट!
  • पिकर सेट "सेट" प्रिंटिंग को दबाए रखें! और फिर पिकर सेट!

व्यवहार दिखा रहा लाइनें लॉग करें:

 07-15 12:00:13.415: D/Picker(21000): Set! 07-15 12:00:24.860: D/Picker(21000): Cancel! 07-15 12:00:24.876: D/Picker(21000): Set! 07-15 12:00:33.696: D/Picker(21000): Set! 07-15 12:00:33.719: D/Picker(21000): Set! 

अन्य नोट्स और टिप्पणियां

  • एक DatePickerFragment चारों ओर लपेटकर कोई फर्क नहीं पड़ता। मैंने आपके लिए इस समस्या को सरल बनाया है, लेकिन मैंने इसका परीक्षण किया है।

वेब के समाधान से एकत्रित समाधान "जेली बीन दिनांक पिक्चर डाइलाग – क्या रद्द करने का कोई तरीका है?"

नोट: यहां लॉलीपॉप के रूप में तय किया गया है । ग्राहकों में उपयोग के लिए स्वचालित कक्षा (सभी एंड्रॉइड वर्ज़न के साथ संगत) के साथ-साथ अपडेट भी किया गया।

टीएल; डीआर: वैश्विक समाधान के लिए 1-2-3 मृत आसान चरणों:

  1. इस वर्ग को डाउनलोड करें
  2. अपनी गतिविधि में OnDateSetListener को लागू करें (या अपनी आवश्यकताओं के अनुसार वर्ग बदलें)।
  3. इस कोड के साथ संवाद ट्रिगर करें (इस नमूने में, मैं इसे एक 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"); 

और यह सब लेता है! इसके कारण मैं अभी भी अपना जवाब "स्वीकार" के रूप में रखता हूं क्योंकि मैं अभी भी अपना समाधान पसंद करता हूं क्योंकि यह क्लाइंट कोड में बहुत छोटा पदचिह्न है, यह मौलिक मुद्दे को संबोधित करता है (श्रोता को ढांचे वर्ग में कहा जाता है), कॉन्फ़िग परिवर्तनों में ठीक काम करता है और यह कोड लॉजिक को पिछले एंड्रॉइड संस्करणों में डिफ़ॉल्ट कार्यान्वयन के लिए रूट करता है जो इस बग से ग्रस्त नहीं है (क्लास स्रोत देखें)।

मूल उत्तर (ऐतिहासिक और उपचारात्मक कारणों के लिए रखा गया है):

बग स्रोत

ठीक है, ऐसा लगता है कि यह वास्तव में एक बग है और कोई अन्य व्यक्ति पहले से ही इसे भर चुका है अंक 34833

मैंने पाया है कि समस्या संभवतः DatePickerDialog.java कहां पढ़ता है:

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

मुझे लगता था कि यह हो सकता था:

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

अब अगर कोई मुझे बता सकता है कि मैं एंड्रॉइड को पैच / बग रिपोर्ट कैसे पेश कर सकता हूं, तो मुझे खुशी होगी इस बीच, मैंने वहां समस्या में DatePickerDialog.java एक संलग्न संस्करण के रूप में संभव सुधार (सरल) सुझाया था।

बग से बचने के लिए संकल्पना

श्रोता को कन्स्ट्रक्टर में null करने के लिए सेट करें और बाद में अपना स्वयं का BUTTON_POSITIVE बटन बनाएं । यही है, नीचे विवरण।

समस्या होती है क्योंकि DatePickerDialog.java , जैसा कि आप स्रोत में देख सकते हैं, एक वैश्विक चर ( mCallBack ) को कॉल करता है जो कन्स्ट्रक्टर में दिए गए श्रोता को संग्रहीत करता है:

  /** * @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. } 

इसलिए, चाल को श्रोता के रूप में संग्रहीत करने के लिए एक null श्रोता प्रदान करना है, और उसके बाद अपने खुद के बटन सेट करें (नीचे मूल कोड # 1 से अपडेट किया गया है):

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

अब यह संभव सुधार की वजह से काम करेगा जो मैंने ऊपर पोस्ट किया था।

और जब से DatePickerDialog.java एक null लिए चेक करता है जब भी वह mCallback पढ़ता है ( चूंकि एपीआई 3 / 1.5 के दिन ऐसा लगता है कि — हनीकॉम्ब की जांच नहीं हो सकती), यह अपवाद को ट्रिगर नहीं करेगा। लॉलीपॉप को ध्यान में रखते हुए इस मुद्दे को तय किया गया, मैं इसे देख नहीं रहा हूं: बस डिफ़ॉल्ट कार्यान्वयन का उपयोग करें (जो मैंने प्रदान किया है कक्षा में)।

सबसे पहले मैं clearFocus() फोन करने से नहीं डरता था, लेकिन मैंने यहां परीक्षण किया है और लॉग लाइनें साफ थीं। इसलिए उस प्रस्ताव के अनुसार मैंने जो भी प्रस्ताव किया हो, उसके बाद भी जरूरी नहीं हो सकता, लेकिन मुझे नहीं पता।

पिछले API स्तर (संपादित) के साथ संगतता

जैसा कि मैंने नीचे दी गई टिप्पणी में बताया, यह एक अवधारणा थी, और आप अपने Google ड्राइव खाते से उपयोग कर रहे वर्ग को डाउनलोड कर सकते हैं । जिस तरीके से मैंने इस्तेमाल किया था, डिफ़ॉल्ट सिस्टम कार्यान्वयन का उपयोग बग से प्रभावित संस्करणों पर नहीं किया जाता है।

मैंने कुछ मान्यताओं (बटन नामों आदि) को अपनी आवश्यकताओं के लिए उपयुक्त बनाया है क्योंकि मैं कम से कम क्लाइंट कक्षाओं में बॉयलरप्लेट कोड को कम करना चाहता था पूर्ण उपयोग उदाहरण:

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

अगर आप टुकड़ों का उपयोग नहीं कर रहे हैं, तो मैं दाऊद कैसेरीनो के समाधान पर अपना खुद का रिफ जोड़ूंगा, और सभी संस्करणों (2.1 से 4.1) में इसे ठीक करने का एक आसान तरीका चाहते हैं:

 public class FixedDatePickerDialog extends DatePickerDialog { //I use a Calendar object to initialize it, but you can revert to Y,M,D easily public FixedDatePickerDialog(Calendar dateToShow, Context context, OnDateSetListener callBack) { super(context, null, dateToShow.get(YEAR), dateToShow.get(MONTH), dateToShow.get(DAY_OF_MONTH)); initializePicker(callBack); } public FixedDatePickerDialog(Calendar dateToShow, Context context, int theme, OnDateSetListener callBack) { super(context, theme, null, dateToShow.get(YEAR), dateToShow.get(MONTH), dateToShow.get(DAY_OF_MONTH)); initializePicker(callBack); } private void initializePicker(final OnDateSetListener callback) { try { //If you're only using Honeycomb+ then you can just call getDatePicker() instead of using reflection Field pickerField = DatePickerDialog.class.getDeclaredField("mDatePicker"); pickerField.setAccessible(true); final DatePicker picker = (DatePicker) pickerField.get(this); this.setCancelable(true); this.setButton(DialogInterface.BUTTON_NEGATIVE, getContext().getText(android.R.string.cancel), (OnClickListener) null); this.setButton(DialogInterface.BUTTON_POSITIVE, getContext().getText(android.R.string.ok), new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { picker.clearFocus(); //Focus must be cleared so the value change listener is called callback.onDateSet(picker, picker.getYear(), picker.getMonth(), picker.getDayOfMonth()); } }); } catch (Exception e) { /* Reflection probably failed*/ } } } 

जब तक कि बग को ठीक नहीं किया जायेगा, तब तक मैं DatePickerDialog या TimePickerDialog का उपयोग नहीं करने का सुझाव देता हूं। टाइम पिक्चर / डेट पिक्चर विजेट के साथ कस्टम बनाया अलर्ट डाइलॉग का प्रयोग करें;

TimePickerDialog को बदलें;

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

बदलें DatePickerDialog के साथ;

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

डेविड कैसेरीनो के समाधान के आधार पर टाइमपीकर के लिए एक , "टीएल; डीआर: वैश्विक समाधान के लिए 1-2-3 मृत आसान चरणों"

TimePickerDialog DatePickerDialog.getDatePicker जैसी कार्यक्षमता प्रदान नहीं करता है इसलिए, ऑनटाइमसेटलाइनर श्रोता को उपलब्ध कराया जाना है। बस DatePicker समाधान समाधान के साथ समानता रखने के लिए, मैंने पुरानी एमएलिसर अवधारणा को बनाए रखा है। यदि आप की आवश्यकता है तो आप इसे बदल सकते हैं

कॉलिंग और श्रोता मूल समाधान के समान है। बस में शामिल हैं

 import android.app.TimePickerDialog; import android.app.TimePickerDialog.OnTimeSetListener; 

पैरेंट क्लास का विस्तार करें,

 ... implements OnDateSetListener, OnTimeSetListener 

लागू

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

उदाहरण कॉल करना

  Calendar cal = Calendar.getInstance(); int hour = cal.get(Calendar.HOUR_OF_DAY); int minute = cal.get(Calendar.MINUTE); Bundle b = new Bundle(); b.putInt(TimePickerDialogFragment.HOUR, hour); b.putInt(TimePickerDialogFragment.MINUTE, minute); DialogFragment picker = new TimePickerDialogFragment(); picker.setArguments(b); picker.show(getSupportFragmentManager(), "frag_time_picker"); 

(रद्द करने के लिए अपडेट किया गया है)

 public class TimePickerDialogFragment extends DialogFragment { public static final String HOUR = "Hour"; public static final String MINUTE = "Minute"; private boolean isCancelled = false; //Added to handle cancel private TimePickerDialog.OnTimeSetListener mListener; //Added to handle parent listener private TimePickerDialog.OnTimeSetListener mTimeSetListener = new TimePickerDialog.OnTimeSetListener() { public void onTimeSet(TimePicker view, int hourOfDay, int minute) { if (!isCancelled) { mListener.onTimeSet(view,hourOfDay,minute); } } }; // @Override public void onAttach(Activity activity) { super.onAttach(activity); this.mListener = (TimePickerDialog.OnTimeSetListener) activity; } @Override public void onDetach() { this.mListener = null; super.onDetach(); } @TargetApi(11) @Override public Dialog onCreateDialog(Bundle savedInstanceState) { Bundle b = getArguments(); int h = b.getInt(HOUR); int m = b.getInt(MINUTE); final TimePickerDialog picker = new TimePickerDialog(getActivity(), getConstructorListener(), h, m,DateFormat.is24HourFormat(getActivity())); //final TimePicker timePicker = new TimePicker(getBaseContext()); if (hasJellyBeanAndAbove()) { picker.setButton(DialogInterface.BUTTON_POSITIVE, getActivity().getString(android.R.string.ok), new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { isCancelled = false; //Cancel flag, used in mTimeSetListener } }); picker.setButton(DialogInterface.BUTTON_NEGATIVE, getActivity().getString(android.R.string.cancel), new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { isCancelled = true; //Cancel flag, used in mTimeSetListener } }); } return picker; } private boolean hasJellyBeanAndAbove() { return Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN; } private TimePickerDialog.OnTimeSetListener getConstructorListener() { return hasJellyBeanAndAbove() ? mTimeSetListener : mListener; //instead of null, mTimeSetListener is returned. } } 

अगर कोई भी त्वरित उपाय चाहता है, तो यहां मैंने उपयोग किया हुआ कोड है:

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

}

Where layout.date_picker_view एक DatePicker के साथ एक सरल लेआउट संसाधन है क्योंकि यह केवल तत्व है:

 <!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"/> 

यदि आप रुचि रखते हैं तो यहां पूरी ट्यूटोरियल है।

मेरा सरल समाधान जब आप इसे फिर से फायरिंग करना चाहते हैं तो बस "रीसेटफाईड" चलाएं (जब संवाद फिर से खोलते हैं)।

 private class FixedDatePickerDialogListener implements DatePickerDialog.OnDateSetListener{ private boolean fired; public void resetFired(){ fired = false; } public void onDateSet(DatePicker view, int year, int monthOfYear, int dayOfMonth) { if (fired) { Log.i("DatePicker", "Double fire occurred."); return;//ignore and return. } //put your code here to handle onDateSet fired = true;//first time fired } } 

जिस स्थिति से मैंने इस स्थिति का प्रबंधन किया था, वह एक झंडा का प्रयोग कर रहा था और उसमें सेन्केल और ऑन डिसिसिस तरीकों को ओवरराइड कर रहा था।

ऑन-कनेल को केवल तभी कहा जाता है जब उपयोगकर्ता संवाद के बाहर या पीछे के बटन को छूता है। onDismiss हमेशा कहा जाता है

ऑन-कनेल विधि में कोई फ़्लैग सेट करना उपयोगकर्ता के इरादे पर onDismiss विधि में फ़िल्टर करने में मदद कर सकता है: कार्रवाई रद्द या क्रिया पूर्ण करें कुछ कोड के नीचे जो विचार दिखाता है

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

अंकुर चौधरी के समान TimePickerDialog मुद्दे पर शानदार जवाब के अनुसार, अगर हम onDateSet अंदर की जाँच onDateSet तो दिए गए दृश्य isShown() या नहीं, यह न्यूनतम समस्या के साथ पूरी समस्या को हल करेगा, isShown() किसी isShown() जांच करने या कुछ घृणित जांच करने के लिए झंडे कोड के चारों ओर जा रहे हैं या यहां तक ​​कि ओएस संस्करण की जांच भी करते हैं, बस निम्नलिखित करें:

 public void onDateSet(DatePicker view, int year, int month, int day) { if (view.isShown()) { // read the date here :) } } 

और निश्चित रूप से अंकुर के उत्तर के अनुसार onTimeSet लिए भी किया जा सकता है

एक बहुत ही सरल समाधान है, यदि आपका एप्लिकेशन क्रिया बार का उपयोग नहीं करता है जिस तरह से ध्यान दें, कुछ ऐप्स काम करने के लिए इस कार्यक्षमता पर भरोसा करते हैं, क्योंकि डेट पिकर का रद्द करना एक विशेष अर्थ है (जैसे यह दिनांक फ़ील्ड को रिक्त स्ट्रिंग में साफ़ करता है, जो कुछ ऐप्स के लिए एक मान्य और सार्थक इनपुट होता है ) और बूलीयन झंडे का उपयोग करने से तारीख को ठीक से दो बार सेट होने से रोकने के लिए इस मामले में आपकी मदद नहीं करेगा।

पुन। वास्तविक फिक्स, आपको नए बटन या अपने स्वयं के संवाद बनाने की आवश्यकता नहीं है यह मुद्दा दोनों के साथ संगत होना है, एंड्रॉइड के पुराने संस्करण, छोटी गाड़ी (4 ) और भविष्य में किसी भी अन्य, हालांकि बाद के बारे में सुनिश्चित होना असंभव है, बिल्कुल। ध्यान दें कि एंड्रॉइड 2. में , एंड्रॉइड के लिए ऑनस्टॉप () एंड्रॉइड। एप। डायलॉग बिल्कुल कुछ भी नहीं है, और 4 में है। * यह एमएपीएआरबीएससेटशोहाइडएनिमेशन सक्षम (झूठी) है जो कि केवल महत्वपूर्ण है यदि आपके ऐप में एक्शन बार है DatePickerDialog में, onStop (), जो कि डायलॉग से प्राप्त होता है, केवल mDatePicker.clearFocus () (जैसा कि एंड्रॉइड स्रोत 4.3 के लिए नवीनतम फिक्स के रूप में) योगदान करता है, जो जरूरी नहीं लगता है।

इसलिए किसी विधि के साथ एसओएसटी () को बदलने से कई मामलों में आपके ऐप को ठीक करना चाहिए और यह सुनिश्चित करना चाहिए कि यह निकट भविष्य के लिए ऐसा ही रहेगा। इस प्रकार केवल DatePickerDialog वर्ग को अपने स्वयं के साथ बढ़ाएं और ontop () एक डमी विधि को कथित करें। आपको अपनी आवश्यकताओं के अनुसार एक या दो कन्स्ट्रक्टर भी प्रदान करना होगा। यह भी ध्यान रखें कि गतिविधि फिक्स के साथ कुछ करने का प्रयास करके इस फिक्स को ज़्यादा प्रयास करने का प्रयास करने के लिए किसी को झुका नहीं जाना चाहिए, क्योंकि यह आपकी संगतता को केवल एंड्रॉइड के नवीनतम संस्करणों तक ही सीमित कर देगा। यह भी ध्यान रखें कि DatePicker के onStop () के लिए सुपर कॉल करने में सक्षम होना अच्छा होगा क्योंकि बग केवल DatePickerDialog में ही है, लेकिन DatePickerDialog के सुपर वर्ग में नहीं। हालांकि, यह आपको अपने कस्टम क्लास से सुपर। सुपर.ऑनस्टॉप () को कॉल करने की आवश्यकता होगी, जो जावा आपको ऐसा नहीं करने देगा, क्योंकि यह एनकॉप्सिलेशन फ़ॉर्निसी के विरुद्ध होता है 🙂 नीचे मेरा छोटा सा वर्ग है, जिसे मैं डेटपेकर डिलीओग को विराम देता था। मुझे उम्मीद है कि यह टिप्पणी किसी के लिए उपयोगी होगी। वोज्टेक जारोस

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

}

नीचे की अवधारणाओं को आज़माएं

 DatePickerDialog picker = new DatePickerDialog( this, new OnDateSetListener() { @Override public void onDateSet(DatePicker v, int y, int m, int d) { Log.d("Picker", "Set!"); } }, 2012, 6, 15); picker.show(); 

onDateSet () विधि दो बार कॉल करता है (यदि आप एमुलेटर में जांच कर रहे हैं.यह दो बार कॉल करता है। यदि वास्तविक डिवाइस का उपयोग कर रहे हैं तो यह सही समय पर कॉल करेगा। यदि आप इम्यूलेटर का उपयोग कर रहे हैं तो काउंटर का उपयोग करें। यदि आप वास्तविक उपकरण में काम कर रहे हैं तो काउंटर चर को अनदेखा करें। वास्तविक उपकरण के लिए यह मेरे लिए काम करती है।)
जब उपयोगकर्ता DatePickerDialog में बटन क्लिक करता है
इसके लिए आपको काउंटर वैल्यू को बनाए रखना चाहिए और कुछ भी नहीं करना चाहिए जब मोथोड पहली बार कॉल करता है और विधि को दूसरी बार कॉल करता है।
नीचे कोडिंग स्निपेट्स देखें

  static int counter=0; //Counter will be declared globally. DatePickerDialog picker = new DatePickerDialog( this, new OnDateSetListener() { @Override public void onDateSet(DatePicker v, int y, int m, int d) { counter++; if(counter==1) return; counter=0; //Do the operations here } }, 2012, 6, 15); picker.show(); 

रद्द करने के लिए datepicker मेरे लिए काम कर रहा है dilod.Emulator इसके wokring नहीं के लिए

 DialogInterface.OnClickListener dialogOnClickListener=new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { // TODO Auto-generated method stub if(which==Dialog.BUTTON_NEGATIVE) { Log.i(tagName, "dialog negative button clicked"); dialog.dismiss(); } } }; mDatePickerDialog.setButton(Dialog.BUTTON_NEGATIVE, "Cancel", dialogOnClickListener); 

यह मेरे लिए एक असली डिवाइस के लिए काम कर रहा है.लेकिन एमुलेटर के लिए यह सही ढंग से काम नहीं कर रहा है। मुझे लगता है कि यह एक एंड्रॉइड इम्यूलेटर बग है।

एक साधारण समाधान दूसरे रन को छोड़ने के लिए एक बूलीयन का उपयोग करेगा

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

आप रद्द कर सकते हैं पर रद्द () और setOnDismissListener () का उपयोग करने के लिए नकारात्मक उपयोगकर्ता कार्रवाई का पता लगाने और एक DatePickerDialog.BUTTON_POSITIVE के साथ आप जानते हैं कि उपयोगकर्ता एक नई तारीख सेट करना चाहता है।

  DatePickerDialog mDPD = new DatePickerDialog( getActivity(), mOnDateSetListener, mYear, mMonth, mDay); mDPD.setOnCancelListener(new OnCancelListener() { @Override public void onCancel(DialogInterface dialog) { // do something onCancek setDate = false; } }); mDPD.setOnDismissListener(new OnDismissListener() { @Override public void onDismiss(DialogInterface arg0) { // do something onDismiss setDate = false; } }); mDPD.setButton(DatePickerDialog.BUTTON_POSITIVE, "Finish", new DatePickerDialog.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { // user set new date setDate = true; } }); 

तो सेट डेट के लिए चेक करें:

 public void onDateSet(DatePicker view, int year, int month, int day) { if(setDate){ //do something with new date } } 

यहां रद्द करें बटन पर DatePickerDialog के लिए मेरा वर्कअराउंड क्लास है और साथ ही इसे वापस बटन द्वारा छोड़ दिया गया है। DatePickerDialog की शैली में प्रतिलिपि करें और उपयोग करें (क्योंकि श्रोता अवधारणापूर्ण है, हमें उपयोग करते समय नया उदाहरण बनाना होगा, अन्यथा इसे बनाने के लिए अधिक कोड आवश्यक है)

उपयोग:

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

वर्ग:

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

}

मैं दिनांक पिकर, समय बीनने और नंबर पिकर का उपयोग कर रहा हूं। जब भी उपयोगकर्ता एक नंबर का चयन करता है, तो पिकर को खारिज करने से पहले संख्या में कॉलर्स कॉल करते हैं, इसलिए पहले से ही इस तरह की संरचना के साथ कुछ करना है, जब पिकर को खारिज किया जाता है:

 public int interimValue; public int finalValue; public void onValueChange(NumberPicker picker, int oldVal, int newVal) { this.interimValue = newVal; } public void onDismiss(DialogInterface dialog) { super.onDismiss(dialog); this.finalValue = this.interimValue; } 

मैंने इसे बटन पर क्लिक करने के लिए एक तर्क के साथ कस्टम बटन पर क्लिक करने के लिए इसे बढ़ा दिया है। मेरे अंतिम मूल्य को सेट करने से पहले अब मैं यह जांच सकता हूं कि कौन से बटन टैप किया गया था:

 public int interimValue; public int finalValue; public boolean saveButtonClicked; public void setup() { picker.setButton(DialogInterface.BUTTON_POSITIVE, getString(R.string.BUTTON_SAVE), new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int which) { picker.onClick(dialog, which); // added for Android 5.0 onButtonClicked(true); } }); picker.setButton(DialogInterface.BUTTON_NEGATIVE, getString(R.string.BUTTON_CANCEL), new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int which) { picker.onClick(dialog, which); // added for Android 5.0 onButtonClicked(false); } }); } public void onValueChange(NumberPicker picker, int oldVal, int newVal) { this.interimValue = newVal; } public void onButtonClicked(boolean save) { this.saveButtonClicked = save; } public void onDismiss(DialogInterface dialog) { super.onDismiss(dialog); if (this.saveButtonClicked) { // save this.finalValue = this.interimValue; } else { // cancel } } 

And then I extended that to work with the date and time types for date and time pickers as well as the int type for number pickers.

I posted this because I thought it was simpler than some of the solutions above, but now that I've included all the code, I guess it's not much simpler! But it fit nicely into the structure I already had.

Update for Lollipop: Apparently this bug doesn't happen on all Android 4.1-4.4 devices, because I received a few reports from users whose date and time pickers weren't calling the onDateSet and onTimeSet callbacks. And the bug was officially fixed in Android 5.0. My approach only worked on devices where the bug is present, because my custom buttons didn't call the dialog's onClick handler, which is the only place that onDateSet and onTimeSet are called when the bug is not present. I updated my code above to call the dialog's onClick, so now it works whether or not the bug is present.

I liked David Cesarino's answer above, but wanted something that was a drop in replacement for the broken dialog and would work on any dialog that might be missing cancel / have incorrect cancel behavior. Here are derived classes for DatePickerDialog / TimePickerDialog that should work as drop in replacements. These are not custom views. It uses the system dialog, but just changes the cancel / back button behavior to work as expected.

This should work on API level 3 and higher. So, basically any version of Android (I tested it on jellybean and lollipop specifically).

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

My working version with ClearButton using Lambda Expressions:

 public class DatePickerFragment extends DialogFragment { private OnDateSelectListener dateSelectListener; private OnDateClearListener dateClearListener; public void setDateSelectListener(OnDateSelectListener dateSelectListener) { this.dateSelectListener = dateSelectListener; } public void setDateClearListener(OnDateClearListener dateClearListener) { this.dateClearListener = dateClearListener; } @Override public Dialog onCreateDialog(Bundle savedInstanceState) { // Use the current date as the default date in 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); // Create a new instance of DatePickerDialog and return it DatePickerDialog dialog = new DatePickerDialog(getActivity(), null, year, month, day); dialog.setCancelable(true); dialog.setCanceledOnTouchOutside(true); dialog.setTitle("Select Date"); dialog.setButton(BUTTON_POSITIVE, ("Done"), (dialog1, which) -> { DatePicker dp = dialog.getDatePicker(); dialog.dismiss(); dateSelectListener.onDateSelect(dp.getYear(), dp.getMonth(), dp.getDayOfMonth()); }); dialog.setButton(BUTTON_NEUTRAL, ("Clear"), (dialog1, which) -> { dialog.dismiss(); dateClearListener.onDateClear(); }); dialog.setButton(BUTTON_NEGATIVE, ("Cancel"), (dialog1, which) -> { if (which == DialogInterface.BUTTON_NEGATIVE) { dialog.cancel(); } }); dialog.getDatePicker().setCalendarViewShown(false); return dialog; } public interface OnDateClearListener { void onDateClear(); } public interface OnDateSelectListener { void onDateSelect(int year, int monthOfYear, int dayOfMonth); } } 

For TimePickerDialog the workaround can be as follows:

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

I delegate all events to wrapper KitKatSetTimeListener, and only fire back to original OnTimeSetListener in case BUTTON_POSITIVE is clicked.

After testing some of the sugestions posted here, I personally think this solution is the most simple. I pass "null" as my listener in the DatePickerDialog constructor, and then when I click the "OK" button I call my onDateSearchSetListener:

 datePickerDialog = new DatePickerDialog(getContext(), null, dateSearch.get(Calendar.YEAR), dateSearch.get(Calendar.MONTH), dateSearch.get(Calendar.DAY_OF_MONTH)); datePickerDialog.setCancelable(false); datePickerDialog.setButton(DialogInterface.BUTTON_POSITIVE, getString(R.string.dialog_ok), new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { Log.d("Debug", "Correct"); onDateSearchSetListener.onDateSet(datePickerDialog.getDatePicker(), datePickerDialog.getDatePicker().getYear(), datePickerDialog.getDatePicker().getMonth(), datePickerDialog.getDatePicker().getDayOfMonth()); } }); datePickerDialog.setButton(DialogInterface.BUTTON_NEGATIVE, getString(R.string.dialog_cancel), new DialogInterface.OnClickListener() { @Override public void onClick(DialogInterface dialog, int which) { Log.d("Debug", "Cancel"); dialog.dismiss(); } }); 

I know this post has been here for almost a year but I thought I should post my findings. You could still keep the listener(instead of setting it to mull) and still have this work as expected. The key is to implicitly set the "OK" or(and) the "cancel" buttons. I tested it and it works gratefully for me. The listener does not get fired twice.

Look at this example,

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