/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.widget;
import android.annotation.IntDef;
import android.annotation.Nullable;
import android.annotation.TestApi;
import android.annotation.UnsupportedAppUsage;
import android.annotation.Widget;
import android.content.Context;
import android.content.res.Configuration;
import android.content.res.TypedArray;
import android.icu.util.Calendar;
import android.icu.util.TimeZone;
import android.os.Parcel;
import android.os.Parcelable;
import android.text.format.DateUtils;
import android.util.AttributeSet;
import android.util.Log;
import android.util.SparseArray;
import android.view.View;
import android.view.ViewStructure;
import android.view.accessibility.AccessibilityEvent;
import android.view.autofill.AutofillManager;
import android.view.autofill.AutofillValue;
import android.view.inspector.InspectableProperty;
import com.android.internal.R;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.Locale;
/**
* Provides a widget for selecting a date.
* <p>
* When the {@link android.R.styleable#DatePicker_datePickerMode} attribute is
* set to {@code spinner}, the date can be selected using year, month, and day
* spinners or a {@link CalendarView}. The set of spinners and the calendar
* view are automatically synchronized. The client can customize whether only
* the spinners, or only the calendar view, or both to be displayed.
* </p>
* <p>
* When the {@link android.R.styleable#DatePicker_datePickerMode} attribute is
* set to {@code calendar}, the month and day can be selected using a
* calendar-style view while the year can be selected separately using a list.
* </p>
* <p>
* See the <a href="{@docRoot}guide/topics/ui/controls/pickers.html">Pickers</a>
* guide.
* </p>
* <p>
* For a dialog using this view, see {@link android.app.DatePickerDialog}.
* </p>
*
* @attr ref android.R.styleable#DatePicker_startYear
* @attr ref android.R.styleable#DatePicker_endYear
* @attr ref android.R.styleable#DatePicker_maxDate
* @attr ref android.R.styleable#DatePicker_minDate
* @attr ref android.R.styleable#DatePicker_spinnersShown
* @attr ref android.R.styleable#DatePicker_calendarViewShown
* @attr ref android.R.styleable#DatePicker_dayOfWeekBackground
* @attr ref android.R.styleable#DatePicker_dayOfWeekTextAppearance
* @attr ref android.R.styleable#DatePicker_headerBackground
* @attr ref android.R.styleable#DatePicker_headerMonthTextAppearance
* @attr ref android.R.styleable#DatePicker_headerDayOfMonthTextAppearance
* @attr ref android.R.styleable#DatePicker_headerYearTextAppearance
* @attr ref android.R.styleable#DatePicker_yearListItemTextAppearance
* @attr ref android.R.styleable#DatePicker_yearListSelectorColor
* @attr ref android.R.styleable#DatePicker_calendarTextColor
* @attr ref android.R.styleable#DatePicker_datePickerMode
*/
@Widget
public class DatePicker extends FrameLayout {
private static final String LOG_TAG = DatePicker.class.getSimpleName();
/**
* Presentation mode for the Holo-style date picker that uses a set of
* {@link android.widget.NumberPicker}s.
*
* @see #getMode()
* @hide Visible for testing only.
*/
@TestApi
public static final int MODE_SPINNER = 1;
/**
* Presentation mode for the Material-style date picker that uses a
* calendar.
*
* @see #getMode()
* @hide Visible for testing only.
*/
@TestApi
public static final int MODE_CALENDAR = 2;
/** @hide */
@IntDef(prefix = { "MODE_" }, value = {
MODE_SPINNER,
MODE_CALENDAR
})
@Retention(RetentionPolicy.SOURCE)
public @interface DatePickerMode {}
@UnsupportedAppUsage
private final DatePickerDelegate mDelegate;
@DatePickerMode
private final int mMode;
/**
* The callback used to indicate the user changed the date.
*/
public interface OnDateChangedListener {
/**
* Called upon a date change.
*
* @param view The view associated with this listener.
* @param year The year that was set.
* @param monthOfYear The month that was set (0-11) for compatibility
* with {@link java.util.Calendar}.
* @param dayOfMonth The day of the month that was set.
*/
void onDateChanged(DatePicker view, int year, int monthOfYear, int dayOfMonth);
}
public DatePicker(Context context) {
this(context, null);
}
public DatePicker(Context context, AttributeSet attrs) {
this(context, attrs, R.attr.datePickerStyle);
}
public DatePicker(Context context, AttributeSet attrs, int defStyleAttr) {
this(context, attrs, defStyleAttr, 0);
}
public DatePicker(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
super(context, attrs, defStyleAttr, defStyleRes);
// DatePicker is important by default, unless app developer overrode attribute.
if (getImportantForAutofill() == IMPORTANT_FOR_AUTOFILL_AUTO) {
setImportantForAutofill(IMPORTANT_FOR_AUTOFILL_YES);
}
final TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.DatePicker,
defStyleAttr, defStyleRes);
saveAttributeDataForStyleable(context, R.styleable.DatePicker,
attrs, a, defStyleAttr, defStyleRes);
final boolean isDialogMode = a.getBoolean(R.styleable.DatePicker_dialogMode, false);
final int requestedMode = a.getInt(R.styleable.DatePicker_datePickerMode, MODE_SPINNER);
final int firstDayOfWeek = a.getInt(R.styleable.DatePicker_firstDayOfWeek, 0);
a.recycle();
if (requestedMode == MODE_CALENDAR && isDialogMode) {
// You want MODE_CALENDAR? YOU CAN'T HANDLE MODE_CALENDAR! Well,
// maybe you can depending on your screen size. Let's check...
mMode = context.getResources().getInteger(R.integer.date_picker_mode);
} else {
mMode = requestedMode;
}
switch (mMode) {
case MODE_CALENDAR:
mDelegate = createCalendarUIDelegate(context, attrs, defStyleAttr, defStyleRes);
break;
case MODE_SPINNER:
default:
mDelegate = createSpinnerUIDelegate(context, attrs, defStyleAttr, defStyleRes);
break;
}
if (firstDayOfWeek != 0) {
setFirstDayOfWeek(firstDayOfWeek);
}
mDelegate.setAutoFillChangeListener((v, y, m, d) -> {
final AutofillManager afm = context.getSystemService(AutofillManager.class);
if (afm != null) {
afm.notifyValueChanged(this);
}
});
}
private DatePickerDelegate createSpinnerUIDelegate(Context context, AttributeSet attrs,
int defStyleAttr, int defStyleRes) {
return new DatePickerSpinnerDelegate(this, context, attrs, defStyleAttr, defStyleRes);
}
private DatePickerDelegate createCalendarUIDelegate(Context context, AttributeSet attrs,
int defStyleAttr, int defStyleRes) {
return new DatePickerCalendarDelegate(this, context, attrs, defStyleAttr,
defStyleRes);
}
/**
* @return the picker's presentation mode, one of {@link #MODE_CALENDAR} or
* {@link #MODE_SPINNER}
* @attr ref android.R.styleable#DatePicker_datePickerMode
* @hide Visible for testing only.
*/
@InspectableProperty(name = "datePickerMode", enumMapping = {
@InspectableProperty.EnumEntry(value = MODE_SPINNER, name = "spinner"),
@InspectableProperty.EnumEntry(value = MODE_CALENDAR, name = "calendar")
})
@DatePickerMode
@TestApi
public int getMode() {
return mMode;
}
/**
* Initialize the state. If the provided values designate an inconsistent
* date the values are normalized before updating the spinners.
*
* @param year The initial year.
* @param monthOfYear The initial month <strong>starting from zero</strong>.
* @param dayOfMonth The initial day of the month.
* @param onDateChangedListener How user is notified date is changed by
* user, can be null.
*/
public void init(int year, int monthOfYear, int dayOfMonth,
OnDateChangedListener onDateChangedListener) {
mDelegate.init(year, monthOfYear, dayOfMonth, onDateChangedListener);
}
/**
* Set the callback that indicates the date has been adjusted by the user.
*
* @param onDateChangedListener How user is notified date is changed by
* user, can be null.
*/
public void setOnDateChangedListener(OnDateChangedListener onDateChangedListener) {
mDelegate.setOnDateChangedListener(onDateChangedListener);
}
/**
* Update the current date.
*
* @param year The year.
* @param month The month which is <strong>starting from zero</strong>.
* @param dayOfMonth The day of the month.
*/
public void updateDate(int year, int month, int dayOfMonth) {
mDelegate.updateDate(year, month, dayOfMonth);
}
/**
* @return The selected year.
*/
@InspectableProperty(hasAttributeId = false)
public int getYear() {
return mDelegate.getYear();
}
/**
* @return The selected month.
*/
@InspectableProperty(hasAttributeId = false)
public int getMonth() {
return mDelegate.getMonth();
}
/**
* @return The selected day of month.
*/
@InspectableProperty(hasAttributeId = false)
public int getDayOfMonth() {
return mDelegate.getDayOfMonth();
}
/**
* Gets the minimal 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 minimal date is 01/01/1900.
* <p>
*
* @return The minimal supported date.
*/
@InspectableProperty
public long getMinDate() {
return mDelegate.getMinDate().getTimeInMillis();
}
/**
* Sets the minimal date supported by this {@link NumberPicker} in
* milliseconds since January 1, 1970 00:00:00 in
* {@link TimeZone#getDefault()} time zone.
*
* @param minDate The minimal supported date.
*/
public void setMinDate(long minDate) {
mDelegate.setMinDate(minDate);
}
/**
* 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.
*/
@InspectableProperty
public long getMaxDate() {
return mDelegate.getMaxDate().getTimeInMillis();
}
/**
* 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) {
mDelegate.setMaxDate(maxDate);
}
/**
* Sets the callback that indicates the current date is valid.
*
* @param callback the callback, may be null
* @hide
*/
@UnsupportedAppUsage
public void setValidationCallback(@Nullable ValidationCallback callback) {
mDelegate.setValidationCallback(callback);
}
@Override
public void setEnabled(boolean enabled) {
if (mDelegate.isEnabled() == enabled) {
return;
}
super.setEnabled(enabled);
mDelegate.setEnabled(enabled);
}
@Override
public boolean isEnabled() {
return mDelegate.isEnabled();
}
/** @hide */
@Override
public boolean dispatchPopulateAccessibilityEventInternal(AccessibilityEvent event) {
return mDelegate.dispatchPopulateAccessibilityEvent(event);
}
/** @hide */
@Override
public void onPopulateAccessibilityEventInternal(AccessibilityEvent event) {
super.onPopulateAccessibilityEventInternal(event);
mDelegate.onPopulateAccessibilityEvent(event);
}
@Override
public CharSequence getAccessibilityClassName() {
return DatePicker.class.getName();
}
@Override
protected void onConfigurationChanged(Configuration newConfig) {
super.onConfigurationChanged(newConfig);
mDelegate.onConfigurationChanged(newConfig);
}
/**
* Sets the first day of week.
*
* @param firstDayOfWeek The first day of the week conforming to the
* {@link CalendarView} APIs.
* @see Calendar#SUNDAY
* @see Calendar#MONDAY
* @see Calendar#TUESDAY
* @see Calendar#WEDNESDAY
* @see Calendar#THURSDAY
* @see Calendar#FRIDAY
* @see Calendar#SATURDAY
*
* @attr ref android.R.styleable#DatePicker_firstDayOfWeek
*/
public void setFirstDayOfWeek(int firstDayOfWeek) {
if (firstDayOfWeek < Calendar.SUNDAY || firstDayOfWeek > Calendar.SATURDAY) {
throw new IllegalArgumentException("firstDayOfWeek must be between 1 and 7");
}
mDelegate.setFirstDayOfWeek(firstDayOfWeek);
}
/**
* Gets the first day of week.
*
* @return The first day of the week conforming to the {@link CalendarView}
* APIs.
* @see Calendar#SUNDAY
* @see Calendar#MONDAY
* @see Calendar#TUESDAY
* @see Calendar#WEDNESDAY
* @see Calendar#THURSDAY
* @see Calendar#FRIDAY
* @see Calendar#SATURDAY
*
* @attr ref android.R.styleable#DatePicker_firstDayOfWeek
*/
@InspectableProperty
public int getFirstDayOfWeek() {
return mDelegate.getFirstDayOfWeek();
}
/**
* Returns whether the {@link CalendarView} is shown.
* <p>
* <strong>Note:</strong> This method returns {@code false} when the
* {@link android.R.styleable#DatePicker_datePickerMode} attribute is set
* to {@code calendar}.
*
* @return {@code true} if the calendar view is shown
* @see #getCalendarView()
* @deprecated Not supported by Material-style {@code calendar} mode
*/
@InspectableProperty
@Deprecated
public boolean getCalendarViewShown() {
return mDelegate.getCalendarViewShown();
}
/**
* Returns the {@link CalendarView} used by this picker.
* <p>
* <strong>Note:</strong> This method throws an
* {@link UnsupportedOperationException} when the
* {@link android.R.styleable#DatePicker_datePickerMode} attribute is set
* to {@code calendar}.
*
* @return the calendar view
* @see #getCalendarViewShown()
* @deprecated Not supported by Material-style {@code calendar} mode
* @throws UnsupportedOperationException if called when the picker is
* displayed in {@code calendar} mode
*/
@Deprecated
public CalendarView getCalendarView() {
return mDelegate.getCalendarView();
}
/**
* Sets whether the {@link CalendarView} is shown.
* <p>
* <strong>Note:</strong> Calling this method has no effect when the
* {@link android.R.styleable#DatePicker_datePickerMode} attribute is set
* to {@code calendar}.
*
* @param shown {@code true} to show the calendar view, {@code false} to
* hide it
* @deprecated Not supported by Material-style {@code calendar} mode
*/
@Deprecated
public void setCalendarViewShown(boolean shown) {
mDelegate.setCalendarViewShown(shown);
}
/**
* Returns whether the spinners are shown.
* <p>
* <strong>Note:</strong> his method returns {@code false} when the
* {@link android.R.styleable#DatePicker_datePickerMode} attribute is set
* to {@code calendar}.
*
* @return {@code true} if the spinners are shown
* @deprecated Not supported by Material-style {@code calendar} mode
*/
@InspectableProperty
@Deprecated
public boolean getSpinnersShown() {
return mDelegate.getSpinnersShown();
}
/**
* Sets whether the spinners are shown.
* <p>
* Calling this method has no effect when the
* {@link android.R.styleable#DatePicker_datePickerMode} attribute is set
* to {@code calendar}.
*
* @param shown {@code true} to show the spinners, {@code false} to hide
* them
* @deprecated Not supported by Material-style {@code calendar} mode
*/
@Deprecated
public void setSpinnersShown(boolean shown) {
mDelegate.setSpinnersShown(shown);
}
@Override
protected void dispatchRestoreInstanceState(SparseArray<Parcelable> container) {
dispatchThawSelfOnly(container);
}
@Override
protected Parcelable onSaveInstanceState() {
Parcelable superState = super.onSaveInstanceState();
return mDelegate.onSaveInstanceState(superState);
}
@Override
protected void onRestoreInstanceState(Parcelable state) {
BaseSavedState ss = (BaseSavedState) state;
super.onRestoreInstanceState(ss.getSuperState());
mDelegate.onRestoreInstanceState(ss);
}
/**
* A delegate interface that defined the public API of the DatePicker. Allows different
* DatePicker implementations. This would need to be implemented by the DatePicker delegates
* for the real behavior.
*
* @hide
*/
interface DatePickerDelegate {
void init(int year, int monthOfYear, int dayOfMonth,
OnDateChangedListener onDateChangedListener);
void setOnDateChangedListener(OnDateChangedListener onDateChangedListener);
void setAutoFillChangeListener(OnDateChangedListener onDateChangedListener);
void updateDate(int year, int month, int dayOfMonth);
int getYear();
int getMonth();
int getDayOfMonth();
void autofill(AutofillValue value);
AutofillValue getAutofillValue();
void setFirstDayOfWeek(int firstDayOfWeek);
int getFirstDayOfWeek();
void setMinDate(long minDate);
Calendar getMinDate();
void setMaxDate(long maxDate);
Calendar getMaxDate();
void setEnabled(boolean enabled);
boolean isEnabled();
CalendarView getCalendarView();
void setCalendarViewShown(boolean shown);
boolean getCalendarViewShown();
void setSpinnersShown(boolean shown);
boolean getSpinnersShown();
void setValidationCallback(ValidationCallback callback);
void onConfigurationChanged(Configuration newConfig);
Parcelable onSaveInstanceState(Parcelable superState);
void onRestoreInstanceState(Parcelable state);
boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event);
void onPopulateAccessibilityEvent(AccessibilityEvent event);
}
/**
* An abstract class which can be used as a start for DatePicker implementations
*/
abstract static class AbstractDatePickerDelegate implements DatePickerDelegate {
// The delegator
protected DatePicker mDelegator;
// The context
protected Context mContext;
// NOTE: when subclasses change this variable, they must call resetAutofilledValue().
protected Calendar mCurrentDate;
// The current locale
protected Locale mCurrentLocale;
// Callbacks
protected OnDateChangedListener mOnDateChangedListener;
protected OnDateChangedListener mAutoFillChangeListener;
protected ValidationCallback mValidationCallback;
// The value that was passed to autofill() - it must be stored because it getAutofillValue()
// must return the exact same value that was autofilled, otherwise the widget will not be
// properly highlighted after autofill().
private long mAutofilledValue;
public AbstractDatePickerDelegate(DatePicker delegator, Context context) {
mDelegator = delegator;
mContext = context;
setCurrentLocale(Locale.getDefault());
}
protected void setCurrentLocale(Locale locale) {
if (!locale.equals(mCurrentLocale)) {
mCurrentLocale = locale;
onLocaleChanged(locale);
}
}
@Override
public void setOnDateChangedListener(OnDateChangedListener callback) {
mOnDateChangedListener = callback;
}
@Override
public void setAutoFillChangeListener(OnDateChangedListener callback) {
mAutoFillChangeListener = callback;
}
@Override
public void setValidationCallback(ValidationCallback callback) {
mValidationCallback = callback;
}
@Override
public final void autofill(AutofillValue value) {
if (value == null || !value.isDate()) {
Log.w(LOG_TAG, value + " could not be autofilled into " + this);
return;
}
final long time = value.getDateValue();
final Calendar cal = Calendar.getInstance(mCurrentLocale);
cal.setTimeInMillis(time);
updateDate(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH),
cal.get(Calendar.DAY_OF_MONTH));
// Must set mAutofilledValue *after* calling subclass method to make sure the value
// returned by getAutofillValue() matches it.
mAutofilledValue = time;
}
@Override
public final AutofillValue getAutofillValue() {
final long time = mAutofilledValue != 0
? mAutofilledValue
: mCurrentDate.getTimeInMillis();
return AutofillValue.forDate(time);
}
/**
* This method must be called every time the value of the year, month, and/or day is
* changed by a subclass method.
*/
protected void resetAutofilledValue() {
mAutofilledValue = 0;
}
protected void onValidationChanged(boolean valid) {
if (mValidationCallback != null) {
mValidationCallback.onValidationChanged(valid);
}
}
protected void onLocaleChanged(Locale locale) {
// Stub.
}
@Override
public void onPopulateAccessibilityEvent(AccessibilityEvent event) {
event.getText().add(getFormattedCurrentDate());
}
protected String getFormattedCurrentDate() {
return DateUtils.formatDateTime(mContext, mCurrentDate.getTimeInMillis(),
DateUtils.FORMAT_SHOW_DATE | DateUtils.FORMAT_SHOW_YEAR
| DateUtils.FORMAT_SHOW_WEEKDAY);
}
/**
* Class for managing state storing/restoring.
*/
static class SavedState extends View.BaseSavedState {
private final int mSelectedYear;
private final int mSelectedMonth;
private final int mSelectedDay;
private final long mMinDate;
private final long mMaxDate;
private final int mCurrentView;
private final int mListPosition;
private final int mListPositionOffset;
public SavedState(Parcelable superState, int year, int month, int day, long minDate,
long maxDate) {
this(superState, year, month, day, minDate, maxDate, 0, 0, 0);
}
/**
* Constructor called from {@link DatePicker#onSaveInstanceState()}
*/
public SavedState(Parcelable superState, int year, int month, int day, long minDate,
long maxDate, int currentView, int listPosition, int listPositionOffset) {
super(superState);
mSelectedYear = year;
mSelectedMonth = month;
mSelectedDay = day;
mMinDate = minDate;
mMaxDate = maxDate;
mCurrentView = currentView;
mListPosition = listPosition;
mListPositionOffset = listPositionOffset;
}
/**
* Constructor called from {@link #CREATOR}
*/
private SavedState(Parcel in) {
super(in);
mSelectedYear = in.readInt();
mSelectedMonth = in.readInt();
mSelectedDay = in.readInt();
mMinDate = in.readLong();
mMaxDate = in.readLong();
mCurrentView = in.readInt();
mListPosition = in.readInt();
mListPositionOffset = in.readInt();
}
@Override
public void writeToParcel(Parcel dest, int flags) {
super.writeToParcel(dest, flags);
dest.writeInt(mSelectedYear);
dest.writeInt(mSelectedMonth);
dest.writeInt(mSelectedDay);
dest.writeLong(mMinDate);
dest.writeLong(mMaxDate);
dest.writeInt(mCurrentView);
dest.writeInt(mListPosition);
dest.writeInt(mListPositionOffset);
}
public int getSelectedDay() {
return mSelectedDay;
}
public int getSelectedMonth() {
return mSelectedMonth;
}
public int getSelectedYear() {
return mSelectedYear;
}
public long getMinDate() {
return mMinDate;
}
public long getMaxDate() {
return mMaxDate;
}
public int getCurrentView() {
return mCurrentView;
}
public int getListPosition() {
return mListPosition;
}
public int getListPositionOffset() {
return mListPositionOffset;
}
@SuppressWarnings("all")
// suppress unused and hiding
public static final @android.annotation.NonNull Parcelable.Creator<SavedState> CREATOR = new Creator<SavedState>() {
public SavedState createFromParcel(Parcel in) {
return new SavedState(in);
}
public SavedState[] newArray(int size) {
return new SavedState[size];
}
};
}
}
/**
* A callback interface for updating input validity when the date picker
* when included into a dialog.
*
* @hide
*/
public interface ValidationCallback {
void onValidationChanged(boolean valid);
}
@Override
public void dispatchProvideAutofillStructure(ViewStructure structure, int flags) {
// This view is self-sufficient for autofill, so it needs to call
// onProvideAutoFillStructure() to fill itself, but it does not need to call
// dispatchProvideAutoFillStructure() to fill its children.
structure.setAutofillId(getAutofillId());
onProvideAutofillStructure(structure, flags);
}
@Override
public void autofill(AutofillValue value) {
if (!isEnabled()) return;
mDelegate.autofill(value);
}
@Override
public @AutofillType int getAutofillType() {
return isEnabled() ? AUTOFILL_TYPE_DATE : AUTOFILL_TYPE_NONE;
}
@Override
public AutofillValue getAutofillValue() {
return isEnabled() ? mDelegate.getAutofillValue() : null;
}
}