core/java/android/widget/DatePickerCalendarDelegate.java

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