/*
* Copyright (C) 2017 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.support.v17.leanback.widget.picker;
import android.content.Context;
import android.content.res.TypedArray;
import android.support.v17.leanback.R;
import android.text.TextUtils;
import android.util.AttributeSet;
import android.view.View;
import android.view.ViewGroup;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Locale;
/**
* {@link TimePicker} is a direct subclass of {@link Picker}.
* <p>
* This class is a widget for selecting time and displays it according to the formatting for the
* current system locale. The time can be selected by hour, minute, and AM/PM picker columns.
* The AM/PM mode is activated only when the 12 hour format is desired by setting
* {@code is24HourFormat} attribute to false. Otherwise, TimePicker displays only two columns for a
* 24 hour time format.
* <p>
* This widget can show the current time as the initial value if {@code useCurrentTime} is set to
* true. Each individual time picker field can be set set at any time by calling
* {@link #setHour(int)}, {@link #setMinute(int)} using 24-hour time format. The time format can
* also be changed at any time by calling {@link #setIs24Hour(boolean)}, and the AM/PM picker column
* will be activated or deactivated according to the given format.
*
* @attr ref R.styleable#lbTimePicker_is24HourFormat
* @attr ref R.styleable#lbTimePicker_useCurrentTime
*/
public class TimePicker extends Picker {
static final String TAG = "TimePicker";
private static final int AM_INDEX = 0;
private static final int PM_INDEX = 1;
private static final int HOURS_IN_HALF_DAY = 12;
PickerColumn mHourColumn;
PickerColumn mMinuteColumn;
PickerColumn mAmPmColumn;
private ViewGroup mPickerView;
private View mAmPmSeparatorView;
int mColHourIndex;
int mColMinuteIndex;
int mColAmPmIndex;
private final PickerUtility.TimeConstant mConstant;
private boolean mIs24hFormat;
private int mCurrentHour;
private int mCurrentMinute;
private int mCurrentAmPmIndex;
/**
* Constructor called when inflating a TimePicker widget. This version uses a default style of
* 0, so the only attribute values applied are those in the Context's Theme and the given
* AttributeSet.
*
* @param context the context this TimePicker widget is associated with through which we can
* access the current theme attributes and resources
* @param attrs the attributes of the XML tag that is inflating the TimePicker widget
*/
public TimePicker(Context context, AttributeSet attrs) {
this(context, attrs, 0);
}
/**
* Constructor called when inflating a TimePicker widget.
*
* @param context the context this TimePicker widget is associated with through which we can
* access the current theme attributes and resources
* @param attrs the attributes of the XML tag that is inflating the TimePicker widget
* @param defStyleAttr An attribute in the current theme that contains a reference to a style
* resource that supplies default values for the widget. Can be 0 to not
* look for defaults.
*/
public TimePicker(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
mConstant = PickerUtility.getTimeConstantInstance(Locale.getDefault(),
context.getResources());
setSeparator(mConstant.timeSeparator);
mPickerView = (ViewGroup) findViewById(R.id.picker);
final TypedArray attributesArray = context.obtainStyledAttributes(attrs,
R.styleable.lbTimePicker);
mIs24hFormat = attributesArray.getBoolean(R.styleable.lbTimePicker_is24HourFormat, false);
boolean useCurrentTime = attributesArray.getBoolean(R.styleable.lbTimePicker_useCurrentTime,
true);
updateColumns(getTimePickerFormat());
// The column range for the minute and AM/PM column is static and does not change, whereas
// the hour column range can change depending on whether 12 or 24 hour format is set at
// any given time.
updateHourColumn(false);
updateMin(mMinuteColumn, 0);
updateMax(mMinuteColumn, 59);
updateMin(mAmPmColumn, 0);
updateMax(mAmPmColumn, 1);
updateAmPmColumn();
if (useCurrentTime) {
Calendar currentDate = PickerUtility.getCalendarForLocale(null,
mConstant.locale);
setHour(currentDate.get(Calendar.HOUR_OF_DAY));
setMinute(currentDate.get(Calendar.MINUTE));
}
}
private static boolean updateMin(PickerColumn column, int value) {
if (value != column.getMinValue()) {
column.setMinValue(value);
return true;
}
return false;
}
private static boolean updateMax(PickerColumn column, int value) {
if (value != column.getMaxValue()) {
column.setMaxValue(value);
return true;
}
return false;
}
/**
*
* @return the time picker format string based on the current system locale and the layout
* direction
*/
private String getTimePickerFormat() {
// Obtain the time format string per the current locale (e.g. h:mm a)
String hmaPattern = ((SimpleDateFormat) DateFormat
.getTimeInstance(DateFormat.SHORT, mConstant.locale)).toPattern();
boolean isRTL = TextUtils.getLayoutDirectionFromLocale(mConstant.locale) == View
.LAYOUT_DIRECTION_RTL;
boolean isAmPmAtEnd = hmaPattern.indexOf("a") > hmaPattern.indexOf("m");
// Hour will always appear to the left of minutes regardless of layout direction.
String timePickerFormat = isRTL ? "mh" : "hm";
return isAmPmAtEnd ? (timePickerFormat + "a") : ("a" + timePickerFormat);
}
private void updateColumns(String timePickerFormat) {
if (TextUtils.isEmpty(timePickerFormat)) {
timePickerFormat = "hma";
}
timePickerFormat = timePickerFormat.toUpperCase();
mHourColumn = mMinuteColumn = mAmPmColumn = null;
mColHourIndex = mColMinuteIndex = mColAmPmIndex = -1;
ArrayList<PickerColumn> columns = new ArrayList<>(3);
for (int i = 0; i < timePickerFormat.length(); i++) {
switch (timePickerFormat.charAt(i)) {
case 'H':
columns.add(mHourColumn = new PickerColumn());
mHourColumn.setStaticLabels(mConstant.hours24);
mColHourIndex = i;
break;
case 'M':
columns.add(mMinuteColumn = new PickerColumn());
mMinuteColumn.setStaticLabels(mConstant.minutes);
mColMinuteIndex = i;
break;
case 'A':
columns.add(mAmPmColumn = new PickerColumn());
mAmPmColumn.setStaticLabels(mConstant.ampm);
mColAmPmIndex = i;
updateMin(mAmPmColumn, 0);
updateMax(mAmPmColumn, 1);
break;
default:
throw new IllegalArgumentException("Invalid time picker format.");
}
}
setColumns(columns);
mAmPmSeparatorView = mPickerView.getChildAt(mColAmPmIndex == 0 ? 1 :
(2 * mColAmPmIndex - 1));
}
/**
* Updates the range in the hour column and notifies column changed if notifyChanged is true.
* Hour column can have either [0-23] or [1-12] depending on whether the 24 hour format is set
* or not.
*
* @param notifyChanged {code true} if we should notify data set changed on the hour column,
* {@code false} otherwise.
*/
private void updateHourColumn(boolean notifyChanged) {
updateMin(mHourColumn, mIs24hFormat ? 0 : 1);
updateMax(mHourColumn, mIs24hFormat ? 23 : 12);
if (notifyChanged) {
setColumnAt(mColHourIndex, mHourColumn);
}
}
/**
* Updates AM/PM column depending on whether the 24 hour format is set or not. The visibility of
* this column is set to {@code GONE} for a 24 hour format, and {@code VISIBLE} in 12 hour
* format. This method also updates the value of this column for a 12 hour format.
*/
private void updateAmPmColumn() {
if (mIs24hFormat) {
mColumnViews.get(mColAmPmIndex).setVisibility(GONE);
mAmPmSeparatorView.setVisibility(GONE);
} else {
mColumnViews.get(mColAmPmIndex).setVisibility(VISIBLE);
mAmPmSeparatorView.setVisibility(VISIBLE);
setColumnValue(mColAmPmIndex, mCurrentAmPmIndex, false);
}
}
/**
* Sets the currently selected hour using a 24-hour time.
*
* @param hour the hour to set, in the range (0-23)
* @see #getHour()
*/
public void setHour(int hour) {
if (hour < 0 || hour > 23) {
throw new IllegalArgumentException("hour: " + hour + " is not in [0-23] range in");
}
mCurrentHour = hour;
if (!mIs24hFormat) {
if (mCurrentHour >= HOURS_IN_HALF_DAY) {
mCurrentAmPmIndex = PM_INDEX;
if (mCurrentHour > HOURS_IN_HALF_DAY) {
mCurrentHour -= HOURS_IN_HALF_DAY;
}
} else {
mCurrentAmPmIndex = AM_INDEX;
if (mCurrentHour == 0) {
mCurrentHour = HOURS_IN_HALF_DAY;
}
}
updateAmPmColumn();
}
setColumnValue(mColHourIndex, mCurrentHour, false);
}
/**
* Returns the currently selected hour using 24-hour time.
*
* @return the currently selected hour in the range (0-23)
* @see #setHour(int)
*/
public int getHour() {
if (mIs24hFormat) {
return mCurrentHour;
}
if (mCurrentAmPmIndex == AM_INDEX) {
return mCurrentHour % HOURS_IN_HALF_DAY;
}
return (mCurrentHour % HOURS_IN_HALF_DAY) + HOURS_IN_HALF_DAY;
}
/**
* Sets the currently selected minute.
*
* @param minute the minute to set, in the range (0-59)
* @see #getMinute()
*/
public void setMinute(int minute) {
if (mCurrentMinute == minute) {
return;
}
if (minute < 0 || minute > 59) {
throw new IllegalArgumentException("minute: " + minute + " is not in [0-59] range.");
}
mCurrentMinute = minute;
setColumnValue(mColMinuteIndex, mCurrentMinute, false);
}
/**
* Returns the currently selected minute.
*
* @return the currently selected minute, in the range (0-59)
* @see #setMinute(int)
*/
public int getMinute() {
return mCurrentMinute;
}
/**
* Sets whether this widget displays a 24-hour mode or a 12-hour mode with an AM/PM picker.
*
* @param is24Hour {@code true} to display in 24-hour mode,
* {@code false} ti display in 12-hour mode with AM/PM.
* @see #is24Hour()
*/
public void setIs24Hour(boolean is24Hour) {
if (mIs24hFormat == is24Hour) {
return;
}
// the ordering of these statements is important
int currentHour = getHour();
mIs24hFormat = is24Hour;
updateHourColumn(true);
setHour(currentHour);
updateAmPmColumn();
}
/**
* @return {@code true} if this widget displays time in 24-hour mode,
* {@code false} otherwise.
*
* @see #setIs24Hour(boolean)
*/
public boolean is24Hour() {
return mIs24hFormat;
}
/**
* Only meaningful for a 12-hour time.
*
* @return {@code true} if the currently selected time is in PM,
* {@code false} if the currently selected time in in AM.
*/
public boolean isPm() {
return (mCurrentAmPmIndex == PM_INDEX);
}
@Override
public void onColumnValueChanged(int columnIndex, int newValue) {
if (columnIndex == mColHourIndex) {
mCurrentHour = newValue;
} else if (columnIndex == mColMinuteIndex) {
mCurrentMinute = newValue;
} else if (columnIndex == mColAmPmIndex) {
mCurrentAmPmIndex = newValue;
} else {
throw new IllegalArgumentException("Invalid column index.");
}
}
}