Home | History | Annotate | Download | only in widget 
      1 /*
      2  * Copyright (C) 2014 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package android.widget;
     18 
     19 import android.content.Context;
     20 import android.content.res.ColorStateList;
     21 import android.content.res.Configuration;
     22 import android.content.res.Resources;
     23 import android.content.res.TypedArray;
     24 import android.os.Parcel;
     25 import android.os.Parcelable;
     26 import android.text.format.DateFormat;
     27 import android.text.format.DateUtils;
     28 import android.util.AttributeSet;
     29 import android.view.HapticFeedbackConstants;
     30 import android.view.LayoutInflater;
     31 import android.view.View;
     32 import android.view.accessibility.AccessibilityEvent;
     33 import android.view.accessibility.AccessibilityNodeInfo;
     34 import android.view.animation.AlphaAnimation;
     35 import android.view.animation.Animation;
     36 
     37 import com.android.internal.R;
     38 import com.android.internal.widget.AccessibleDateAnimator;
     39 
     40 import java.text.SimpleDateFormat;
     41 import java.util.Calendar;
     42 import java.util.HashSet;
     43 import java.util.Locale;
     44 
     45 /**
     46  * A delegate for picking up a date (day / month / year).
     47  */
     48 class DatePickerCalendarDelegate extends DatePicker.AbstractDatePickerDelegate implements
     49         View.OnClickListener, DatePickerController {
     50     private static final int USE_LOCALE = 0;
     51 
     52     private static final int UNINITIALIZED = -1;
     53     private static final int MONTH_AND_DAY_VIEW = 0;
     54     private static final int YEAR_VIEW = 1;
     55 
     56     private static final int DEFAULT_START_YEAR = 1900;
     57     private static final int DEFAULT_END_YEAR = 2100;
     58 
     59     private static final int ANIMATION_DURATION = 300;
     60 
     61     private static final int MONTH_INDEX = 0;
     62     private static final int DAY_INDEX = 1;
     63     private static final int YEAR_INDEX = 2;
     64 
     65     private SimpleDateFormat mYearFormat = new SimpleDateFormat("y", Locale.getDefault());
     66     private SimpleDateFormat mDayFormat = new SimpleDateFormat("d", Locale.getDefault());
     67 
     68     private TextView mDayOfWeekView;
     69 
     70     /** Layout that contains the current month, day, and year. */
     71     private LinearLayout mMonthDayYearLayout;
     72 
     73     /** Clickable layout that contains the current day and year. */
     74     private LinearLayout mMonthAndDayLayout;
     75 
     76     private TextView mHeaderMonthTextView;
     77     private TextView mHeaderDayOfMonthTextView;
     78     private TextView mHeaderYearTextView;
     79     private DayPickerView mDayPickerView;
     80     private YearPickerView mYearPickerView;
     81 
     82     private boolean mIsEnabled = true;
     83 
     84     // Accessibility strings.
     85     private String mDayPickerDescription;
     86     private String mSelectDay;
     87     private String mYearPickerDescription;
     88     private String mSelectYear;
     89 
     90     private AccessibleDateAnimator mAnimator;
     91 
     92     private DatePicker.OnDateChangedListener mDateChangedListener;
     93 
     94     private int mCurrentView = UNINITIALIZED;
     95 
     96     private Calendar mCurrentDate;
     97     private Calendar mTempDate;
     98     private Calendar mMinDate;
     99     private Calendar mMaxDate;
    100 
    101     private int mFirstDayOfWeek = USE_LOCALE;
    102 
    103     private HashSet<OnDateChangedListener> mListeners = new HashSet<OnDateChangedListener>();
    104 
    105     public DatePickerCalendarDelegate(DatePicker delegator, Context context, AttributeSet attrs,
    106             int defStyleAttr, int defStyleRes) {
    107         super(delegator, context);
    108 
    109         final Locale locale = Locale.getDefault();
    110         mMinDate = getCalendarForLocale(mMinDate, locale);
    111         mMaxDate = getCalendarForLocale(mMaxDate, locale);
    112         mTempDate = getCalendarForLocale(mMaxDate, locale);
    113         mCurrentDate = getCalendarForLocale(mCurrentDate, locale);
    114 
    115         mMinDate.set(DEFAULT_START_YEAR, 1, 1);
    116         mMaxDate.set(DEFAULT_END_YEAR, 12, 31);
    117 
    118         final Resources res = mDelegator.getResources();
    119         final TypedArray a = mContext.obtainStyledAttributes(attrs,
    120                 R.styleable.DatePicker, defStyleAttr, defStyleRes);
    121         final LayoutInflater inflater = (LayoutInflater) mContext.getSystemService(
    122                 Context.LAYOUT_INFLATER_SERVICE);
    123         final int layoutResourceId = a.getResourceId(
    124                 R.styleable.DatePicker_internalLayout, R.layout.date_picker_holo);
    125         final View mainView = inflater.inflate(layoutResourceId, null);
    126         mDelegator.addView(mainView);
    127 
    128         mDayOfWeekView = (TextView) mainView.findViewById(R.id.date_picker_header);
    129 
    130         // Layout that contains the current date and day name header.
    131         final LinearLayout dateLayout = (LinearLayout) mainView.findViewById(
    132                 R.id.day_picker_selector_layout);
    133         mMonthDayYearLayout = (LinearLayout) mainView.findViewById(
    134                 R.id.date_picker_month_day_year_layout);
    135         mMonthAndDayLayout = (LinearLayout) mainView.findViewById(
    136                 R.id.date_picker_month_and_day_layout);
    137         mMonthAndDayLayout.setOnClickListener(this);
    138         mHeaderMonthTextView = (TextView) mainView.findViewById(R.id.date_picker_month);
    139         mHeaderDayOfMonthTextView = (TextView) mainView.findViewById(R.id.date_picker_day);
    140         mHeaderYearTextView = (TextView) mainView.findViewById(R.id.date_picker_year);
    141         mHeaderYearTextView.setOnClickListener(this);
    142 
    143         // Obtain default highlight color from the theme.
    144         final int defaultHighlightColor = mHeaderYearTextView.getHighlightColor();
    145 
    146         // Use Theme attributes if possible
    147         final int dayOfWeekTextAppearanceResId = a.getResourceId(
    148                 R.styleable.DatePicker_dayOfWeekTextAppearance, -1);
    149         if (dayOfWeekTextAppearanceResId != -1) {
    150             mDayOfWeekView.setTextAppearance(context, dayOfWeekTextAppearanceResId);
    151         }
    152 
    153         mDayOfWeekView.setBackground(a.getDrawable(R.styleable.DatePicker_dayOfWeekBackground));
    154 
    155         dateLayout.setBackground(a.getDrawable(R.styleable.DatePicker_headerBackground));
    156 
    157         final int headerSelectedTextColor = a.getColor(
    158                 R.styleable.DatePicker_headerSelectedTextColor, defaultHighlightColor);
    159         final int monthTextAppearanceResId = a.getResourceId(
    160                 R.styleable.DatePicker_headerMonthTextAppearance, -1);
    161         if (monthTextAppearanceResId != -1) {
    162             mHeaderMonthTextView.setTextAppearance(context, monthTextAppearanceResId);
    163         }
    164         mHeaderMonthTextView.setTextColor(ColorStateList.addFirstIfMissing(
    165                 mHeaderMonthTextView.getTextColors(), R.attr.state_selected,
    166                 headerSelectedTextColor));
    167 
    168         final int dayOfMonthTextAppearanceResId = a.getResourceId(
    169                 R.styleable.DatePicker_headerDayOfMonthTextAppearance, -1);
    170         if (dayOfMonthTextAppearanceResId != -1) {
    171             mHeaderDayOfMonthTextView.setTextAppearance(context, dayOfMonthTextAppearanceResId);
    172         }
    173         mHeaderDayOfMonthTextView.setTextColor(ColorStateList.addFirstIfMissing(
    174                 mHeaderDayOfMonthTextView.getTextColors(), R.attr.state_selected,
    175                 headerSelectedTextColor));
    176 
    177         final int yearTextAppearanceResId = a.getResourceId(
    178                 R.styleable.DatePicker_headerYearTextAppearance, -1);
    179         if (yearTextAppearanceResId != -1) {
    180             mHeaderYearTextView.setTextAppearance(context, yearTextAppearanceResId);
    181         }
    182         mHeaderYearTextView.setTextColor(ColorStateList.addFirstIfMissing(
    183                 mHeaderYearTextView.getTextColors(), R.attr.state_selected,
    184                 headerSelectedTextColor));
    185 
    186         mDayPickerView = new DayPickerView(mContext);
    187         mDayPickerView.setFirstDayOfWeek(mFirstDayOfWeek);
    188         mDayPickerView.setMinDate(mMinDate.getTimeInMillis());
    189         mDayPickerView.setMaxDate(mMaxDate.getTimeInMillis());
    190         mDayPickerView.setDate(mCurrentDate.getTimeInMillis());
    191         mDayPickerView.setOnDaySelectedListener(mOnDaySelectedListener);
    192 
    193         mYearPickerView = new YearPickerView(mContext);
    194         mYearPickerView.init(this);
    195         mYearPickerView.setRange(mMinDate, mMaxDate);
    196 
    197         final int yearSelectedCircleColor = a.getColor(R.styleable.DatePicker_yearListSelectorColor,
    198                 defaultHighlightColor);
    199         mYearPickerView.setYearSelectedCircleColor(yearSelectedCircleColor);
    200 
    201         final ColorStateList calendarTextColor = a.getColorStateList(
    202                 R.styleable.DatePicker_calendarTextColor);
    203         final int calendarSelectedTextColor = a.getColor(
    204                 R.styleable.DatePicker_calendarSelectedTextColor, defaultHighlightColor);
    205         mDayPickerView.setCalendarTextColor(ColorStateList.addFirstIfMissing(
    206                 calendarTextColor, R.attr.state_selected, calendarSelectedTextColor));
    207 
    208         mDayPickerDescription = res.getString(R.string.day_picker_description);
    209         mSelectDay = res.getString(R.string.select_day);
    210         mYearPickerDescription = res.getString(R.string.year_picker_description);
    211         mSelectYear = res.getString(R.string.select_year);
    212 
    213         mAnimator = (AccessibleDateAnimator) mainView.findViewById(R.id.animator);
    214         mAnimator.addView(mDayPickerView);
    215         mAnimator.addView(mYearPickerView);
    216         mAnimator.setDateMillis(mCurrentDate.getTimeInMillis());
    217 
    218         final Animation animation = new AlphaAnimation(0.0f, 1.0f);
    219         animation.setDuration(ANIMATION_DURATION);
    220         mAnimator.setInAnimation(animation);
    221 
    222         final Animation animation2 = new AlphaAnimation(1.0f, 0.0f);
    223         animation2.setDuration(ANIMATION_DURATION);
    224         mAnimator.setOutAnimation(animation2);
    225 
    226         updateDisplay(false);
    227         setCurrentView(MONTH_AND_DAY_VIEW);
    228     }
    229 
    230     /**
    231      * Gets a calendar for locale bootstrapped with the value of a given calendar.
    232      *
    233      * @param oldCalendar The old calendar.
    234      * @param locale The locale.
    235      */
    236     private Calendar getCalendarForLocale(Calendar oldCalendar, Locale locale) {
    237         if (oldCalendar == null) {
    238             return Calendar.getInstance(locale);
    239         } else {
    240             final long currentTimeMillis = oldCalendar.getTimeInMillis();
    241             Calendar newCalendar = Calendar.getInstance(locale);
    242             newCalendar.setTimeInMillis(currentTimeMillis);
    243             return newCalendar;
    244         }
    245     }
    246 
    247     /**
    248      * Compute the array representing the order of Month / Day / Year views in their layout.
    249      * Will be used for I18N purpose as the order of them depends on the Locale.
    250      */
    251     private int[] getMonthDayYearIndexes(String pattern) {
    252         int[] result = new int[3];
    253 
    254         final String filteredPattern = pattern.replaceAll("'.*?'", "");
    255 
    256         final int dayIndex = filteredPattern.indexOf('d');
    257         final int monthMIndex = filteredPattern.indexOf("M");
    258         final int monthIndex = (monthMIndex != -1) ? monthMIndex : filteredPattern.indexOf("L");
    259         final int yearIndex = filteredPattern.indexOf("y");
    260 
    261         if (yearIndex < monthIndex) {
    262             result[YEAR_INDEX] = 0;
    263 
    264             if (monthIndex < dayIndex) {
    265                 result[MONTH_INDEX] = 1;
    266                 result[DAY_INDEX] = 2;
    267             } else {
    268                 result[MONTH_INDEX] = 2;
    269                 result[DAY_INDEX] = 1;
    270             }
    271         } else {
    272             result[YEAR_INDEX] = 2;
    273 
    274             if (monthIndex < dayIndex) {
    275                 result[MONTH_INDEX] = 0;
    276                 result[DAY_INDEX] = 1;
    277             } else {
    278                 result[MONTH_INDEX] = 1;
    279                 result[DAY_INDEX] = 0;
    280             }
    281         }
    282         return result;
    283     }
    284 
    285     private void updateDisplay(boolean announce) {
    286         if (mDayOfWeekView != null) {
    287             mDayOfWeekView.setText(mCurrentDate.getDisplayName(Calendar.DAY_OF_WEEK, Calendar.LONG,
    288                     Locale.getDefault()));
    289         }
    290 
    291         // Compute indices of Month, Day and Year views
    292         final String bestDateTimePattern =
    293                 DateFormat.getBestDateTimePattern(mCurrentLocale, "yMMMd");
    294         final int[] viewIndices = getMonthDayYearIndexes(bestDateTimePattern);
    295 
    296         // Position the Year and MonthAndDay views within the header.
    297         mMonthDayYearLayout.removeAllViews();
    298         if (viewIndices[YEAR_INDEX] == 0) {
    299             mMonthDayYearLayout.addView(mHeaderYearTextView);
    300             mMonthDayYearLayout.addView(mMonthAndDayLayout);
    301         } else {
    302             mMonthDayYearLayout.addView(mMonthAndDayLayout);
    303             mMonthDayYearLayout.addView(mHeaderYearTextView);
    304         }
    305 
    306         // Position Day and Month views within the MonthAndDay view.
    307         mMonthAndDayLayout.removeAllViews();
    308         if (viewIndices[MONTH_INDEX] > viewIndices[DAY_INDEX]) {
    309             mMonthAndDayLayout.addView(mHeaderDayOfMonthTextView);
    310             mMonthAndDayLayout.addView(mHeaderMonthTextView);
    311         } else {
    312             mMonthAndDayLayout.addView(mHeaderMonthTextView);
    313             mMonthAndDayLayout.addView(mHeaderDayOfMonthTextView);
    314         }
    315 
    316         mHeaderMonthTextView.setText(mCurrentDate.getDisplayName(Calendar.MONTH, Calendar.SHORT,
    317                 Locale.getDefault()).toUpperCase(Locale.getDefault()));
    318         mHeaderDayOfMonthTextView.setText(mDayFormat.format(mCurrentDate.getTime()));
    319         mHeaderYearTextView.setText(mYearFormat.format(mCurrentDate.getTime()));
    320 
    321         // Accessibility.
    322         long millis = mCurrentDate.getTimeInMillis();
    323         mAnimator.setDateMillis(millis);
    324         int flags = DateUtils.FORMAT_SHOW_DATE | DateUtils.FORMAT_NO_YEAR;
    325         String monthAndDayText = DateUtils.formatDateTime(mContext, millis, flags);
    326         mMonthAndDayLayout.setContentDescription(monthAndDayText);
    327 
    328         if (announce) {
    329             flags = DateUtils.FORMAT_SHOW_DATE | DateUtils.FORMAT_SHOW_YEAR;
    330             String fullDateText = DateUtils.formatDateTime(mContext, millis, flags);
    331             mAnimator.announceForAccessibility(fullDateText);
    332         }
    333     }
    334 
    335     private void setCurrentView(final int viewIndex) {
    336         long millis = mCurrentDate.getTimeInMillis();
    337 
    338         switch (viewIndex) {
    339             case MONTH_AND_DAY_VIEW:
    340                 mDayPickerView.setDate(getSelectedDay().getTimeInMillis());
    341                 if (mCurrentView != viewIndex) {
    342                     mMonthAndDayLayout.setSelected(true);
    343                     mHeaderYearTextView.setSelected(false);
    344                     mAnimator.setDisplayedChild(MONTH_AND_DAY_VIEW);
    345                     mCurrentView = viewIndex;
    346                 }
    347 
    348                 final int flags = DateUtils.FORMAT_SHOW_DATE;
    349                 final String dayString = DateUtils.formatDateTime(mContext, millis, flags);
    350                 mAnimator.setContentDescription(mDayPickerDescription + ": " + dayString);
    351                 mAnimator.announceForAccessibility(mSelectDay);
    352                 break;
    353             case YEAR_VIEW:
    354                 mYearPickerView.onDateChanged();
    355                 if (mCurrentView != viewIndex) {
    356                     mMonthAndDayLayout.setSelected(false);
    357                     mHeaderYearTextView.setSelected(true);
    358                     mAnimator.setDisplayedChild(YEAR_VIEW);
    359                     mCurrentView = viewIndex;
    360                 }
    361 
    362                 final CharSequence yearString = mYearFormat.format(millis);
    363                 mAnimator.setContentDescription(mYearPickerDescription + ": " + yearString);
    364                 mAnimator.announceForAccessibility(mSelectYear);
    365                 break;
    366         }
    367     }
    368 
    369     @Override
    370     public void init(int year, int monthOfYear, int dayOfMonth,
    371             DatePicker.OnDateChangedListener callBack) {
    372         mCurrentDate.set(Calendar.YEAR, year);
    373         mCurrentDate.set(Calendar.MONTH, monthOfYear);
    374         mCurrentDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);
    375 
    376         mDateChangedListener = callBack;
    377 
    378         onDateChanged(false, false);
    379     }
    380 
    381     @Override
    382     public void updateDate(int year, int month, int dayOfMonth) {
    383         mCurrentDate.set(Calendar.YEAR, year);
    384         mCurrentDate.set(Calendar.MONTH, month);
    385         mCurrentDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);
    386 
    387         onDateChanged(false, true);
    388     }
    389 
    390     private void onDateChanged(boolean fromUser, boolean callbackToClient) {
    391         if (callbackToClient && mDateChangedListener != null) {
    392             final int year = mCurrentDate.get(Calendar.YEAR);
    393             final int monthOfYear = mCurrentDate.get(Calendar.MONTH);
    394             final int dayOfMonth = mCurrentDate.get(Calendar.DAY_OF_MONTH);
    395             mDateChangedListener.onDateChanged(mDelegator, year, monthOfYear, dayOfMonth);
    396         }
    397 
    398         for (OnDateChangedListener listener : mListeners) {
    399             listener.onDateChanged();
    400         }
    401 
    402         mDayPickerView.setDate(getSelectedDay().getTimeInMillis());
    403 
    404         updateDisplay(fromUser);
    405 
    406         if (fromUser) {
    407             tryVibrate();
    408         }
    409     }
    410 
    411     @Override
    412     public int getYear() {
    413         return mCurrentDate.get(Calendar.YEAR);
    414     }
    415 
    416     @Override
    417     public int getMonth() {
    418         return mCurrentDate.get(Calendar.MONTH);
    419     }
    420 
    421     @Override
    422     public int getDayOfMonth() {
    423         return mCurrentDate.get(Calendar.DAY_OF_MONTH);
    424     }
    425 
    426     @Override
    427     public void setMinDate(long minDate) {
    428         mTempDate.setTimeInMillis(minDate);
    429         if (mTempDate.get(Calendar.YEAR) == mMinDate.get(Calendar.YEAR)
    430                 && mTempDate.get(Calendar.DAY_OF_YEAR) != mMinDate.get(Calendar.DAY_OF_YEAR)) {
    431             return;
    432         }
    433         if (mCurrentDate.before(mTempDate)) {
    434             mCurrentDate.setTimeInMillis(minDate);
    435             onDateChanged(false, true);
    436         }
    437         mMinDate.setTimeInMillis(minDate);
    438         mDayPickerView.setMinDate(minDate);
    439         mYearPickerView.setRange(mMinDate, mMaxDate);
    440     }
    441 
    442     @Override
    443     public Calendar getMinDate() {
    444         return mMinDate;
    445     }
    446 
    447     @Override
    448     public void setMaxDate(long maxDate) {
    449         mTempDate.setTimeInMillis(maxDate);
    450         if (mTempDate.get(Calendar.YEAR) == mMaxDate.get(Calendar.YEAR)
    451                 && mTempDate.get(Calendar.DAY_OF_YEAR) != mMaxDate.get(Calendar.DAY_OF_YEAR)) {
    452             return;
    453         }
    454         if (mCurrentDate.after(mTempDate)) {
    455             mCurrentDate.setTimeInMillis(maxDate);
    456             onDateChanged(false, true);
    457         }
    458         mMaxDate.setTimeInMillis(maxDate);
    459         mDayPickerView.setMaxDate(maxDate);
    460         mYearPickerView.setRange(mMinDate, mMaxDate);
    461     }
    462 
    463     @Override
    464     public Calendar getMaxDate() {
    465         return mMaxDate;
    466     }
    467 
    468     @Override
    469     public void setFirstDayOfWeek(int firstDayOfWeek) {
    470         mFirstDayOfWeek = firstDayOfWeek;
    471 
    472         mDayPickerView.setFirstDayOfWeek(firstDayOfWeek);
    473     }
    474 
    475     @Override
    476     public int getFirstDayOfWeek() {
    477         if (mFirstDayOfWeek != USE_LOCALE) {
    478             return mFirstDayOfWeek;
    479         }
    480         return mCurrentDate.getFirstDayOfWeek();
    481     }
    482 
    483     @Override
    484     public void setEnabled(boolean enabled) {
    485         mMonthAndDayLayout.setEnabled(enabled);
    486         mHeaderYearTextView.setEnabled(enabled);
    487         mAnimator.setEnabled(enabled);
    488         mIsEnabled = enabled;
    489     }
    490 
    491     @Override
    492     public boolean isEnabled() {
    493         return mIsEnabled;
    494     }
    495 
    496     @Override
    497     public CalendarView getCalendarView() {
    498         throw new UnsupportedOperationException(
    499                 "CalendarView does not exists for the new DatePicker");
    500     }
    501 
    502     @Override
    503     public void setCalendarViewShown(boolean shown) {
    504         // No-op for compatibility with the old DatePicker.
    505     }
    506 
    507     @Override
    508     public boolean getCalendarViewShown() {
    509         return false;
    510     }
    511 
    512     @Override
    513     public void setSpinnersShown(boolean shown) {
    514         // No-op for compatibility with the old DatePicker.
    515     }
    516 
    517     @Override
    518     public boolean getSpinnersShown() {
    519         return false;
    520     }
    521 
    522     @Override
    523     public void onConfigurationChanged(Configuration newConfig) {
    524         mYearFormat = new SimpleDateFormat("y", newConfig.locale);
    525         mDayFormat = new SimpleDateFormat("d", newConfig.locale);
    526     }
    527 
    528     @Override
    529     public Parcelable onSaveInstanceState(Parcelable superState) {
    530         final int year = mCurrentDate.get(Calendar.YEAR);
    531         final int month = mCurrentDate.get(Calendar.MONTH);
    532         final int day = mCurrentDate.get(Calendar.DAY_OF_MONTH);
    533 
    534         int listPosition = -1;
    535         int listPositionOffset = -1;
    536 
    537         if (mCurrentView == MONTH_AND_DAY_VIEW) {
    538             listPosition = mDayPickerView.getMostVisiblePosition();
    539         } else if (mCurrentView == YEAR_VIEW) {
    540             listPosition = mYearPickerView.getFirstVisiblePosition();
    541             listPositionOffset = mYearPickerView.getFirstPositionOffset();
    542         }
    543 
    544         return new SavedState(superState, year, month, day, mMinDate.getTimeInMillis(),
    545                 mMaxDate.getTimeInMillis(), mCurrentView, listPosition, listPositionOffset);
    546     }
    547 
    548     @Override
    549     public void onRestoreInstanceState(Parcelable state) {
    550         SavedState ss = (SavedState) state;
    551 
    552         mCurrentDate.set(ss.getSelectedYear(), ss.getSelectedMonth(), ss.getSelectedDay());
    553         mCurrentView = ss.getCurrentView();
    554         mMinDate.setTimeInMillis(ss.getMinDate());
    555         mMaxDate.setTimeInMillis(ss.getMaxDate());
    556 
    557         updateDisplay(false);
    558         setCurrentView(mCurrentView);
    559 
    560         final int listPosition = ss.getListPosition();
    561         if (listPosition != -1) {
    562             if (mCurrentView == MONTH_AND_DAY_VIEW) {
    563                 mDayPickerView.postSetSelection(listPosition);
    564             } else if (mCurrentView == YEAR_VIEW) {
    565                 mYearPickerView.postSetSelectionFromTop(listPosition, ss.getListPositionOffset());
    566             }
    567         }
    568     }
    569 
    570     @Override
    571     public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
    572         onPopulateAccessibilityEvent(event);
    573         return true;
    574     }
    575 
    576     @Override
    577     public void onPopulateAccessibilityEvent(AccessibilityEvent event) {
    578         event.getText().add(mCurrentDate.getTime().toString());
    579     }
    580 
    581     @Override
    582     public void onInitializeAccessibilityEvent(AccessibilityEvent event) {
    583         event.setClassName(DatePicker.class.getName());
    584     }
    585 
    586     @Override
    587     public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo info) {
    588         info.setClassName(DatePicker.class.getName());
    589     }
    590 
    591     @Override
    592     public void onYearSelected(int year) {
    593         adjustDayInMonthIfNeeded(mCurrentDate.get(Calendar.MONTH), year);
    594         mCurrentDate.set(Calendar.YEAR, year);
    595         onDateChanged(true, true);
    596 
    597         // Auto-advance to month and day view.
    598         setCurrentView(MONTH_AND_DAY_VIEW);
    599     }
    600 
    601     // If the newly selected month / year does not contain the currently selected day number,
    602     // change the selected day number to the last day of the selected month or year.
    603     //      e.g. Switching from Mar to Apr when Mar 31 is selected -> Apr 30
    604     //      e.g. Switching from 2012 to 2013 when Feb 29, 2012 is selected -> Feb 28, 2013
    605     private void adjustDayInMonthIfNeeded(int month, int year) {
    606         int day = mCurrentDate.get(Calendar.DAY_OF_MONTH);
    607         int daysInMonth = getDaysInMonth(month, year);
    608         if (day > daysInMonth) {
    609             mCurrentDate.set(Calendar.DAY_OF_MONTH, daysInMonth);
    610         }
    611     }
    612 
    613     public static int getDaysInMonth(int month, int year) {
    614         switch (month) {
    615             case Calendar.JANUARY:
    616             case Calendar.MARCH:
    617             case Calendar.MAY:
    618             case Calendar.JULY:
    619             case Calendar.AUGUST:
    620             case Calendar.OCTOBER:
    621             case Calendar.DECEMBER:
    622                 return 31;
    623             case Calendar.APRIL:
    624             case Calendar.JUNE:
    625             case Calendar.SEPTEMBER:
    626             case Calendar.NOVEMBER:
    627                 return 30;
    628             case Calendar.FEBRUARY:
    629                 return (year % 4 == 0) ? 29 : 28;
    630             default:
    631                 throw new IllegalArgumentException("Invalid Month");
    632         }
    633     }
    634 
    635     @Override
    636     public void registerOnDateChangedListener(OnDateChangedListener listener) {
    637         mListeners.add(listener);
    638     }
    639 
    640     @Override
    641     public Calendar getSelectedDay() {
    642         return mCurrentDate;
    643     }
    644 
    645     @Override
    646     public void tryVibrate() {
    647         mDelegator.performHapticFeedback(HapticFeedbackConstants.CALENDAR_DATE);
    648     }
    649 
    650     @Override
    651     public void onClick(View v) {
    652         tryVibrate();
    653         if (v.getId() == R.id.date_picker_year) {
    654             setCurrentView(YEAR_VIEW);
    655         } else if (v.getId() == R.id.date_picker_month_and_day_layout) {
    656             setCurrentView(MONTH_AND_DAY_VIEW);
    657         }
    658     }
    659 
    660     /**
    661      * Listener called when the user selects a day in the day picker view.
    662      */
    663     private final DayPickerView.OnDaySelectedListener
    664             mOnDaySelectedListener = new DayPickerView.OnDaySelectedListener() {
    665         @Override
    666         public void onDaySelected(DayPickerView view, Calendar day) {
    667             mCurrentDate.setTimeInMillis(day.getTimeInMillis());
    668             onDateChanged(true, true);
    669         }
    670     };
    671 
    672     /**
    673      * Class for managing state storing/restoring.
    674      */
    675     private static class SavedState extends View.BaseSavedState {
    676 
    677         private final int mSelectedYear;
    678         private final int mSelectedMonth;
    679         private final int mSelectedDay;
    680         private final long mMinDate;
    681         private final long mMaxDate;
    682         private final int mCurrentView;
    683         private final int mListPosition;
    684         private final int mListPositionOffset;
    685 
    686         /**
    687          * Constructor called from {@link DatePicker#onSaveInstanceState()}
    688          */
    689         private SavedState(Parcelable superState, int year, int month, int day,
    690                 long minDate, long maxDate, int currentView, int listPosition,
    691                 int listPositionOffset) {
    692             super(superState);
    693             mSelectedYear = year;
    694             mSelectedMonth = month;
    695             mSelectedDay = day;
    696             mMinDate = minDate;
    697             mMaxDate = maxDate;
    698             mCurrentView = currentView;
    699             mListPosition = listPosition;
    700             mListPositionOffset = listPositionOffset;
    701         }
    702 
    703         /**
    704          * Constructor called from {@link #CREATOR}
    705          */
    706         private SavedState(Parcel in) {
    707             super(in);
    708             mSelectedYear = in.readInt();
    709             mSelectedMonth = in.readInt();
    710             mSelectedDay = in.readInt();
    711             mMinDate = in.readLong();
    712             mMaxDate = in.readLong();
    713             mCurrentView = in.readInt();
    714             mListPosition = in.readInt();
    715             mListPositionOffset = in.readInt();
    716         }
    717 
    718         @Override
    719         public void writeToParcel(Parcel dest, int flags) {
    720             super.writeToParcel(dest, flags);
    721             dest.writeInt(mSelectedYear);
    722             dest.writeInt(mSelectedMonth);
    723             dest.writeInt(mSelectedDay);
    724             dest.writeLong(mMinDate);
    725             dest.writeLong(mMaxDate);
    726             dest.writeInt(mCurrentView);
    727             dest.writeInt(mListPosition);
    728             dest.writeInt(mListPositionOffset);
    729         }
    730 
    731         public int getSelectedDay() {
    732             return mSelectedDay;
    733         }
    734 
    735         public int getSelectedMonth() {
    736             return mSelectedMonth;
    737         }
    738 
    739         public int getSelectedYear() {
    740             return mSelectedYear;
    741         }
    742 
    743         public long getMinDate() {
    744             return mMinDate;
    745         }
    746 
    747         public long getMaxDate() {
    748             return mMaxDate;
    749         }
    750 
    751         public int getCurrentView() {
    752             return mCurrentView;
    753         }
    754 
    755         public int getListPosition() {
    756             return mListPosition;
    757         }
    758 
    759         public int getListPositionOffset() {
    760             return mListPositionOffset;
    761         }
    762 
    763         @SuppressWarnings("all")
    764         // suppress unused and hiding
    765         public static final Parcelable.Creator<SavedState> CREATOR = new Creator<SavedState>() {
    766 
    767             public SavedState createFromParcel(Parcel in) {
    768                 return new SavedState(in);
    769             }
    770 
    771             public SavedState[] newArray(int size) {
    772                 return new SavedState[size];
    773             }
    774         };
    775     }
    776 }
    777