示例#1
0
  public void toggleCalendar(boolean shown) {
    if ((mState != PickersState.DATE && mState != PickersState.DATETIME)
        || mScreenWidth < SCREEN_SIZE_THRESHOLD) {
      if (DEBUG) {
        Log.d(
            LOGTAG,
            "Cannot display calendar on this device, in this state"
                + ": screen width :"
                + mScreenWidth);
      }
      return;
    }

    if (shown) {
      mCalendarEnabled = true;
      mCalendar.setVisibility(VISIBLE);
      setYearShown(false);
      setWeekShown(false);
      setMonthShown(false);
      setDayShown(false);
    } else {
      mCalendar.setVisibility(GONE);
      setYearShown(true);
      setMonthShown(true);
      setDayShown(true);
      mPickers.setOrientation(LinearLayout.HORIZONTAL);
      mCalendarEnabled = false;
    }
  }
示例#2
0
  @Override
  public View onCreateView(
      LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    final View rootView = inflater.inflate(R.layout.fragment_scheduler, container, false);

    calendarView = (CalendarView) rootView.findViewById(R.id.calendarView);
    calendarView.setOnDateChangeListener(
        new CalendarView.OnDateChangeListener() {

          @Override
          public void onSelectedDayChange(CalendarView view, int year, int month, int dayOfMonth) {

            String currDate =
                ""
                    + year
                    + "-"
                    + String.format("%02d", month + 1)
                    + "-"
                    + String.format("%02d", dayOfMonth);

            Intent intent = new Intent(rootView.getContext(), SchedulerDailyActivity.class);
            Log.i("currDate", currDate);
            intent.putExtra("currDate", currDate);
            startActivity(intent);
          }
        });

    return rootView;
  }
示例#3
0
  public void open(View view) {

    final Dialog dialog = new Dialog(NewTask.this);
    dialog.setContentView(R.layout.activity_calendar2);
    dialog.setTitle("Select Date");
    calendar = (CalendarView) dialog.findViewById(R.id.calendar);

    calendar.setOnDateChangeListener(
        new CalendarView.OnDateChangeListener() {
          @Override
          public void onSelectedDayChange(CalendarView view, int year, int month, int dayOfMonth) {

            Year = year;
            Month = month;
            Day = dayOfMonth;
            date1 = new Date(Year - 1900, Month, Day);
            DateFormat dateFormat =
                android.text.format.DateFormat.getDateFormat(getApplicationContext());
            DATE.setText(dateFormat.format(date1), TextView.BufferType.EDITABLE);
            Toast.makeText(
                    getApplicationContext(),
                    dayOfMonth + "/" + (Month + 1) + "/" + year,
                    Toast.LENGTH_LONG)
                .show();
            dialog.dismiss();
          }
        });
    dialog.show();
  }
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    CalendarView calendar = (CalendarView) findViewById(R.id.myCalendar);

    calendar.setOnDateChangeListener(
        new OnDateChangeListener() {
          @Override
          public void onSelectedDayChange(CalendarView view, int year, int month, int day) {
            int Day = day;
            int Month = month + 1; // Month starts with 0
            int Year = year;
            selectedDate = Month + "/" + Day + "/" + Year;
          }
        });
  }
示例#5
0
 @Override
 public void setEnabled(boolean enabled) {
   if (mIsEnabled == enabled) {
     return;
   }
   super.setEnabled(enabled);
   mDaySpinner.setEnabled(enabled);
   mMonthSpinner.setEnabled(enabled);
   mYearSpinner.setEnabled(enabled);
   mCalendarView.setEnabled(enabled);
   mIsEnabled = enabled;
 }
示例#6
0
 /**
  * Sets the maximal date supported by this {@link DatePicker} in milliseconds since January 1,
  * 1970 00:00:00 in {@link TimeZone#getDefault()} time zone.
  *
  * @param maxDate The maximal supported date.
  */
 public void setMaxDate(long maxDate) {
   mTempDate.setTimeInMillis(maxDate);
   if (mTempDate.get(Calendar.YEAR) == mMaxDate.get(Calendar.YEAR)
       && mTempDate.get(Calendar.DAY_OF_YEAR) != mMaxDate.get(Calendar.DAY_OF_YEAR)) {
     return;
   }
   mMaxDate.setTimeInMillis(maxDate);
   mCalendarView.setMaxDate(maxDate);
   if (mCurrentDate.after(mMaxDate)) {
     mCurrentDate.setTimeInMillis(mMaxDate.getTimeInMillis());
     updateCalendarView();
   }
   updateSpinners();
 }
 @Override
 protected Dialog onCreateDialog(int id) {
   // 实例化一个view
   view = View.inflate(TestCalendarView.this, R.layout.calendarview, null);
   // 初始化一个calendarView控件
   calendar = (CalendarView) view.findViewById(R.id.calendarview2);
   // 自定义一个类 并实例化一个类的对象;
   Event event = new Event();
   // 设置calendarView的事件监听
   calendar.setOnDateChangeListener((CalendarView.OnDateChangeListener) event);
   if (dialog == null) { // 如果dialog为null时创建dialog,否则直接return一个dialog;
     dialog =
         new AlertDialog.Builder(TestCalendarView.this) // 新建一个AlertDialog
             // .setTitle("选择日期")
             // .setIcon(android.R.drawable.ic_dialog_info)
             .setView(view)
             .setPositiveButton("确定", (DialogInterface.OnClickListener) event)
             .create();
   }
   return dialog;
 }
示例#8
0
 /** Updates the calendar view with the current date. */
 private void updateCalendarView() {
   mCalendarView.setDate(mCurrentDate.getTimeInMillis(), false, false);
 }
示例#9
0
 /**
  * Sets whether the {@link CalendarView} is shown.
  *
  * @param shown True if the calendar view is to be shown.
  */
 public void setCalendarViewShown(boolean shown) {
   mCalendarView.setVisibility(shown ? VISIBLE : GONE);
 }
示例#10
0
 /**
  * Gets whether the {@link CalendarView} is shown.
  *
  * @return True if the calendar view is shown.
  * @see #getCalendarView()
  */
 public boolean getCalendarViewShown() {
   return mCalendarView.isShown();
 }
示例#11
0
 /**
  * Gets the maximal date supported by this {@link DatePicker} in milliseconds since January 1,
  * 1970 00:00:00 in {@link TimeZone#getDefault()} time zone.
  *
  * <p>Note: The default maximal date is 12/31/2100.
  *
  * <p>
  *
  * @return The maximal supported date.
  */
 public long getMaxDate() {
   return mCalendarView.getMaxDate();
 }
示例#12
0
  public LunarDatePicker(Context context, AttributeSet attrs, int defStyle) {
    super(context, attrs, defStyle);

    // initialization based on locale
    setCurrentLocale(Locale.getDefault());

    // /@M:{comment these lines
    //         TypedArray attributesArray = context.obtainStyledAttributes(attrs,
    //         R.styleable.LunarDatePicker,
    //         defStyle, 0);
    //         boolean spinnersShown =
    //         attributesArray.getBoolean(R.styleable.LunarDatePicker_spinnersShown,
    //         DEFAULT_SPINNERS_SHOWN);
    //         boolean calendarViewShown = attributesArray.getBoolean(
    //         R.styleable.LunarDatePicker_calendarViewShown,
    //         DEFAULT_CALENDAR_VIEW_SHOWN);
    //         int startYear =
    //         attributesArray.getInt(R.styleable.LunarDatePicker_startYear,
    //         DEFAULT_START_YEAR);
    //         int endYear = attributesArray.getInt(R.styleable.LunarDatePicker_endYear,
    //         DEFAULT_END_YEAR);
    //         String minDate =
    //         attributesArray.getString(R.styleable.LunarDatePicker_minDate);
    //         String maxDate =
    //         attributesArray.getString(R.styleable.LunarDatePicker_maxDate);
    //         int layoutResourceId =R.layout.date_picker;
    //         attributesArray.getResourceId(R.styleable.LunarDatePicker_layout,
    //         R.layout.date_picker);
    //         attributesArray.recycle();
    // /}

    // /M:add @{
    boolean spinnersShown = DEFAULT_SPINNERS_SHOWN;
    boolean calendarViewShown = DEFAULT_CALENDAR_VIEW_SHOWN;
    int startYear = DEFAULT_START_YEAR;
    int endYear = DEFAULT_END_YEAR;
    int layoutResourceId = R.layout.date_picker;
    // /}

    LayoutInflater inflater =
        (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
    inflater.inflate(layoutResourceId, this, true);

    OnValueChangeListener onChangeListener =
        new OnValueChangeListener() {
          public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
            updateInputState();
            mTempDate.setTimeInMillis(mCurrentDate.getTimeInMillis());
            int gregorianYear = mTempDate.get(Calendar.YEAR);
            int gregorianMonth = mTempDate.get(Calendar.MONTH) + 1;
            int gregorianDay = mTempDate.get(Calendar.DAY_OF_MONTH);
            int lunarDates[] =
                LunarUtil.calculateLunarByGregorian(gregorianYear, gregorianMonth, gregorianDay);

            // take care of wrapping of days and months to update greater
            // fields
            if (picker == mDaySpinner) {
              if (oldVal > 27 && newVal == 1) {
                mTempDate.add(Calendar.DAY_OF_MONTH, 1);
              } else if (oldVal == 1 && newVal > 27) {
                mTempDate.add(Calendar.DAY_OF_MONTH, -1);
              } else {
                mTempDate.add(Calendar.DAY_OF_MONTH, newVal - oldVal);
              }
            } else if (picker == mMonthSpinner) {
              int leapMonth = 0;
              int monthCountDays = 0;
              if (oldVal > 10 && newVal == 0) {
                leapMonth = LunarUtil.leapMonth(lunarDates[0]);
                if (leapMonth == 12) {
                  monthCountDays = LunarUtil.daysOfLeapMonthInLunarYear(lunarDates[0]);
                } else {
                  monthCountDays = LunarUtil.daysOfALunarMonth(lunarDates[0], 12);
                }
                mTempDate.add(Calendar.DAY_OF_MONTH, monthCountDays);

              } else if (oldVal == 0 && newVal > 10) {
                leapMonth = LunarUtil.leapMonth(lunarDates[0] - 1);
                if (leapMonth == 12) {
                  monthCountDays = LunarUtil.daysOfLeapMonthInLunarYear(lunarDates[0]);
                } else {
                  monthCountDays = LunarUtil.daysOfALunarMonth(lunarDates[0] - 1, 12);
                }

                mTempDate.add(Calendar.DAY_OF_MONTH, -monthCountDays);
              } else {
                leapMonth = LunarUtil.leapMonth(lunarDates[0]);
                // move to previous
                if ((newVal - oldVal) < 0) {
                  if (leapMonth == 0) {
                    monthCountDays = LunarUtil.daysOfALunarMonth(lunarDates[0], newVal + 1);
                  } else { // leap year
                    if (newVal < leapMonth) {
                      monthCountDays = LunarUtil.daysOfALunarMonth(lunarDates[0], newVal + 1);
                    } else if (newVal == leapMonth) {
                      monthCountDays = LunarUtil.daysOfLeapMonthInLunarYear(lunarDates[0]);
                    } else {
                      monthCountDays = LunarUtil.daysOfALunarMonth(lunarDates[0], newVal);
                    }
                  }
                  monthCountDays = -monthCountDays;
                } else { // move to next month
                  if (leapMonth == 0) {
                    monthCountDays = LunarUtil.daysOfALunarMonth(lunarDates[0], oldVal + 1);
                  } else { // leap year
                    if (oldVal < leapMonth) {
                      monthCountDays = LunarUtil.daysOfALunarMonth(lunarDates[0], oldVal + 1);
                    } else if (oldVal == leapMonth) {
                      monthCountDays = LunarUtil.daysOfLeapMonthInLunarYear(lunarDates[0]);
                    } else {
                      monthCountDays = LunarUtil.daysOfALunarMonth(lunarDates[0], oldVal);
                    }
                  }
                }
                mTempDate.add(Calendar.DAY_OF_MONTH, monthCountDays);
              }
            } else if (picker == mYearSpinner) {
              int orientation =
                  newVal - oldVal > 0
                      ? LunarUtil.INCREASE_A_LUANR_YEAR
                      : LunarUtil.DECREATE_A_LUANR_YEAR;
              mTempDate =
                  LunarUtil.decreaseOrIncreaseALunarYear(
                      mTempDate, lunarDates[1], lunarDates[2], orientation);
            } else {
              throw new IllegalArgumentException();
            }
            // now set the date to the adjusted one
            setDate(
                mTempDate.get(Calendar.YEAR),
                mTempDate.get(Calendar.MONTH),
                mTempDate.get(Calendar.DAY_OF_MONTH));
            updateSpinners();
            updateCalendarView();
            notifyDateChanged();
          }
        };

    mSpinners = (LinearLayout) findViewById(R.id.pickers);

    // calendar view day-picker
    mCalendarView = (CalendarView) findViewById(R.id.calendar_view);
    mCalendarView.setOnDateChangeListener(
        new CalendarView.OnDateChangeListener() {
          public void onSelectedDayChange(CalendarView view, int year, int month, int monthDay) {
            setDate(year, month, monthDay);
            updateSpinners();
            notifyDateChanged();
          }
        });

    // day
    mDaySpinner = (NumberPicker) findViewById(R.id.day);
    // /M: comment this line @{
    // mDaySpinner.setFormatter(NumberPicker.TWO_DIGIT_FORMATTER);
    // /}
    mDaySpinner.setOnLongPressUpdateInterval(100);
    mDaySpinner.setOnValueChangedListener(onChangeListener);
    // mDaySpinner has 3 child,topButton,editText,bottomButtom
    if (mDaySpinner.getChildCount() == PICKER_CHILD_COUNT) {
      // set the Middle EditText of Numberpicker read only.
      mDaySpinnerInput = (EditText) mDaySpinner.getChildAt(1);
      mDaySpinnerInput.setClickable(false);
      mDaySpinnerInput.setFocusable(false);
    } else {
      // Normally,this will always not happen.
      mDaySpinnerInput = new EditText(context);
      Log.e(TAG, "mDaySpinner.getChildCount() != 3,It isn't init ok.");
    }

    // month
    mMonthSpinner = (NumberPicker) findViewById(R.id.month);
    mMonthSpinner.setMinValue(0);
    mMonthSpinner.setMaxValue(mNumberOfMonths - 1);
    mMonthSpinner.setDisplayedValues(mShortMonths);
    mMonthSpinner.setOnLongPressUpdateInterval(200);
    mMonthSpinner.setOnValueChangedListener(onChangeListener);
    // mDaySpinner has 3 child,topButton,editText,bottomButtom
    if (mMonthSpinner.getChildCount() == PICKER_CHILD_COUNT) {
      // set the Middle EditText of Numberpicker read only.
      mMonthSpinnerInput = (EditText) mMonthSpinner.getChildAt(1);
      mMonthSpinnerInput.setClickable(false);
      mMonthSpinnerInput.setFocusable(false);
    } else {
      // Normally,this will always not happen.
      mMonthSpinnerInput = new EditText(context);
      Log.e(TAG, "mMonthSpinner.getChildCount() != 3,It isn't init ok.");
    }
    // year
    mYearSpinner = (NumberPicker) findViewById(R.id.year);
    mYearSpinner.setOnLongPressUpdateInterval(100);
    mYearSpinner.setOnValueChangedListener(onChangeListener);
    // mDaySpinner has 3 child,topButton,editText,bottomButtom
    if (mYearSpinner.getChildCount() == PICKER_CHILD_COUNT) {
      // set the Middle EditText of Numberpicker read only.
      mYearSpinnerInput = (EditText) mYearSpinner.getChildAt(1);
      mYearSpinnerInput.setClickable(false);
      mYearSpinnerInput.setFocusable(false);
    } else {
      // Normally,this will always not happen.
      mYearSpinnerInput = new EditText(context);
      Log.e(TAG, "mYearSpinner.getChildCount() != 3,It isn't init ok.");
    }

    // show only what the user required but make sure we
    // show something and the spinners have higher priority
    if (!spinnersShown && !calendarViewShown) {
      setSpinnersShown(true);
    } else {
      setSpinnersShown(spinnersShown);
      setCalendarViewShown(calendarViewShown);
    }

    // set the min date giving priority of the minDate over startYear
    mTempDate.clear();
    mTempDate.set(startYear, 0, 1);
    setMinDate(mTempDate.getTimeInMillis());

    // set the max date giving priority of the maxDate over endYear
    mTempDate.clear();
    mTempDate.set(endYear, 11, 31);
    setMaxDate(mTempDate.getTimeInMillis());

    // initialize to current date
    mCurrentDate.setTimeInMillis(System.currentTimeMillis());
    init(
        mCurrentDate.get(Calendar.YEAR),
        mCurrentDate.get(Calendar.MONTH),
        mCurrentDate.get(Calendar.DAY_OF_MONTH),
        null);

    // re-order the number spinners to match the current date format
    reorderSpinners();

    // set content descriptions
    AccessibilityManager accessibilityManager =
        (AccessibilityManager) context.getSystemService(context.ACCESSIBILITY_SERVICE);
    if (accessibilityManager.isEnabled()) {
      setContentDescriptions();
    }
  }
示例#13
0
 void updateCalendar() {
   if (mCalendarEnabled) {
     mCalendar.setDate(mCurrentDate.getTimeInMillis(), false, false);
   }
 }
示例#14
0
  public DateTimePicker(
      Context context,
      String dateFormat,
      String dateTimeValue,
      PickersState state,
      String minDateValue,
      String maxDateValue) {
    super(context);

    setCurrentLocale(Locale.getDefault());

    mState = state;
    LayoutInflater inflater = LayoutInflater.from(context);
    inflater.inflate(R.layout.datetime_picker, this, true);

    mOnChangeListener = new OnValueChangeListener();

    mDateSpinners = (LinearLayout) findViewById(R.id.date_spinners);
    mTimeSpinners = (LinearLayout) findViewById(R.id.time_spinners);
    mPickers = (LinearLayout) findViewById(R.id.datetime_picker);

    // We will display differently according to the screen size width.
    WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
    Display display = wm.getDefaultDisplay();
    DisplayMetrics dm = new DisplayMetrics();
    display.getMetrics(dm);
    mScreenWidth = display.getWidth() / dm.densityDpi;
    mScreenHeight = display.getHeight() / dm.densityDpi;

    if (DEBUG) {
      Log.d(LOGTAG, "screen width: " + mScreenWidth + " screen height: " + mScreenHeight);
    }

    // Set the min / max attribute.
    try {
      if (minDateValue != null && !minDateValue.equals("")) {
        mMinDate.setTime(new SimpleDateFormat(dateFormat).parse(minDateValue));
      } else {
        mMinDate.set(DEFAULT_START_YEAR, Calendar.JANUARY, 1);
      }
    } catch (Exception ex) {
      Log.e(LOGTAG, "Error parsing format sting: " + ex);
      mMinDate.set(DEFAULT_START_YEAR, Calendar.JANUARY, 1);
    }

    try {
      if (maxDateValue != null && !maxDateValue.equals("")) {
        mMaxDate.setTime(new SimpleDateFormat(dateFormat).parse(maxDateValue));
      } else {
        mMaxDate.set(DEFAULT_END_YEAR, Calendar.DECEMBER, 31);
      }
    } catch (Exception ex) {
      Log.e(LOGTAG, "Error parsing format string: " + ex);
      mMaxDate.set(DEFAULT_END_YEAR, Calendar.DECEMBER, 31);
    }

    // Find the initial date from the constructor arguments.
    try {
      if (!dateTimeValue.equals("")) {
        mTempDate.setTime(new SimpleDateFormat(dateFormat).parse(dateTimeValue));
      } else {
        mTempDate.setTimeInMillis(System.currentTimeMillis());
      }
    } catch (Exception ex) {
      Log.e(LOGTAG, "Error parsing format string: " + ex);
      mTempDate.setTimeInMillis(System.currentTimeMillis());
    }

    if (mMaxDate.before(mMinDate)) {
      // If the input date range is illogical/garbage, we should not restrict the input range (i.e.
      // allow the
      // user to select any date). If we try to make any assumptions based on the illogical min/max
      // date we could
      // potentially prevent the user from selecting dates that are in the developers intended
      // range, so it's best
      // to allow anything.
      mMinDate.set(DEFAULT_START_YEAR, Calendar.JANUARY, 1);
      mMaxDate.set(DEFAULT_END_YEAR, Calendar.DECEMBER, 31);
    }

    // mTempDate will either be a site-supplied value, or today's date otherwise. CalendarView
    // implementations can
    // crash if they're supplied an invalid date (i.e. a date not in the specified range), hence we
    // need to set
    // a sensible default date here.
    if (mTempDate.before(mMinDate) || mTempDate.after(mMaxDate)) {
      mTempDate.setTimeInMillis(mMinDate.getTimeInMillis());
    }

    // If we're displaying a date, the screen is wide enough
    // (and if we're using an SDK where the calendar view exists)
    // then display a calendar.
    if (Versions.feature11Plus
        && (mState == PickersState.DATE || mState == PickersState.DATETIME)
        && mScreenWidth >= SCREEN_SIZE_THRESHOLD) {

      if (DEBUG) {
        Log.d(LOGTAG, "SDK > 10 and screen wide enough, displaying calendar");
      }

      mCalendar = new CalendarView(context);
      mCalendar.setVisibility(GONE);

      LayoutParams layoutParams = new LayoutParams(250, 280);
      mCalendar.setLayoutParams(layoutParams);
      mCalendar.setFocusable(true);
      mCalendar.setFocusableInTouchMode(true);
      mCalendar.setMaxDate(mMaxDate.getTimeInMillis());
      mCalendar.setMinDate(mMinDate.getTimeInMillis());
      mCalendar.setDate(mTempDate.getTimeInMillis(), false, false);

      mCalendar.setOnDateChangeListener(
          new CalendarView.OnDateChangeListener() {
            @Override
            public void onSelectedDayChange(CalendarView view, int year, int month, int monthDay) {
              mTempDate.set(year, month, monthDay);
              setDate(mTempDate);
              notifyDateChanged();
            }
          });

      mPickers.addView(mCalendar);
    } else {
      // If the screen is more wide than high, we are displaying day and
      // time spinners, and if there is no calendar displayed, we should
      // display the fields in one row.
      if (mScreenWidth > mScreenHeight && mState == PickersState.DATETIME) {
        mPickers.setOrientation(LinearLayout.HORIZONTAL);
      }
      mCalendar = null;
    }

    // Initialize all spinners.
    mDaySpinner = setupSpinner(R.id.day, 1, mTempDate.get(Calendar.DAY_OF_MONTH));
    mDaySpinner.setFormatter(TWO_DIGIT_FORMATTER);
    mDaySpinnerInput = (EditText) mDaySpinner.getChildAt(1);

    mMonthSpinner =
        setupSpinner(R.id.month, 1, mTempDate.get(Calendar.MONTH) + 1); // Month is 0-based
    mMonthSpinner.setFormatter(TWO_DIGIT_FORMATTER);
    mMonthSpinner.setDisplayedValues(mShortMonths);
    mMonthSpinnerInput = (EditText) mMonthSpinner.getChildAt(1);

    mWeekSpinner = setupSpinner(R.id.week, 1, mTempDate.get(Calendar.WEEK_OF_YEAR));
    mWeekSpinner.setFormatter(TWO_DIGIT_FORMATTER);
    mWeekSpinnerInput = (EditText) mWeekSpinner.getChildAt(1);

    mYearSpinner = setupSpinner(R.id.year, DEFAULT_START_YEAR, DEFAULT_END_YEAR);
    mYearSpinnerInput = (EditText) mYearSpinner.getChildAt(1);

    mAMPMSpinner = setupSpinner(R.id.ampm, 0, 1);
    mAMPMSpinner.setFormatter(TWO_DIGIT_FORMATTER);

    if (mIs12HourMode) {
      mHourSpinner = setupSpinner(R.id.hour, 1, 12);
      mAMPMSpinnerInput = (EditText) mAMPMSpinner.getChildAt(1);
      mAMPMSpinner.setDisplayedValues(mShortAMPMs);
    } else {
      mHourSpinner = setupSpinner(R.id.hour, 0, 23);
      mAMPMSpinnerInput = null;
    }

    mHourSpinner.setFormatter(TWO_DIGIT_FORMATTER);
    mHourSpinnerInput = (EditText) mHourSpinner.getChildAt(1);

    mMinuteSpinner = setupSpinner(R.id.minute, 0, 59);
    mMinuteSpinner.setFormatter(TWO_DIGIT_FORMATTER);
    mMinuteSpinnerInput = (EditText) mMinuteSpinner.getChildAt(1);

    // The order in which the spinners are displayed are locale-dependent
    reorderDateSpinners();

    // Set the date to the initial date. Since this date can come from the user,
    // it can fire an exception (out-of-bound date)
    try {
      updateDate(mTempDate);
    } catch (Exception ex) {
    }

    // Display only the pickers needed for the current state.
    displayPickers();
  }