1131 lines
41 KiB
Java
1131 lines
41 KiB
Java
/*
|
|
* Copyright (C) 2013 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.content.Context;
|
|
import android.content.res.ColorStateList;
|
|
import android.content.res.Resources;
|
|
import android.content.res.TypedArray;
|
|
import android.icu.text.DecimalFormatSymbols;
|
|
import android.os.Parcelable;
|
|
import android.text.SpannableStringBuilder;
|
|
import android.text.TextUtils;
|
|
import android.text.format.DateFormat;
|
|
import android.text.format.DateUtils;
|
|
import android.text.style.TtsSpan;
|
|
import android.util.AttributeSet;
|
|
import android.util.StateSet;
|
|
import android.view.HapticFeedbackConstants;
|
|
import android.view.LayoutInflater;
|
|
import android.view.MotionEvent;
|
|
import android.view.View;
|
|
import android.view.View.AccessibilityDelegate;
|
|
import android.view.View.MeasureSpec;
|
|
import android.view.ViewGroup;
|
|
import android.view.accessibility.AccessibilityEvent;
|
|
import android.view.accessibility.AccessibilityNodeInfo;
|
|
import android.view.accessibility.AccessibilityNodeInfo.AccessibilityAction;
|
|
import android.view.inputmethod.InputMethodManager;
|
|
import android.widget.RadialTimePickerView.OnValueSelectedListener;
|
|
import android.widget.TextInputTimePickerView.OnValueTypedListener;
|
|
|
|
import com.android.internal.R;
|
|
import com.android.internal.widget.NumericTextView;
|
|
import com.android.internal.widget.NumericTextView.OnValueChangedListener;
|
|
|
|
|
|
import java.lang.annotation.Retention;
|
|
import java.lang.annotation.RetentionPolicy;
|
|
import java.util.Calendar;
|
|
|
|
/**
|
|
* A delegate implementing the radial clock-based TimePicker.
|
|
*/
|
|
class TimePickerClockDelegate extends TimePicker.AbstractTimePickerDelegate {
|
|
/**
|
|
* Delay in milliseconds before valid but potentially incomplete, for
|
|
* example "1" but not "12", keyboard edits are propagated from the
|
|
* hour / minute fields to the radial picker.
|
|
*/
|
|
private static final long DELAY_COMMIT_MILLIS = 2000;
|
|
|
|
@IntDef({FROM_EXTERNAL_API, FROM_RADIAL_PICKER, FROM_INPUT_PICKER})
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
private @interface ChangeSource {}
|
|
private static final int FROM_EXTERNAL_API = 0;
|
|
private static final int FROM_RADIAL_PICKER = 1;
|
|
private static final int FROM_INPUT_PICKER = 2;
|
|
|
|
// Index used by RadialPickerLayout
|
|
private static final int HOUR_INDEX = RadialTimePickerView.HOURS;
|
|
private static final int MINUTE_INDEX = RadialTimePickerView.MINUTES;
|
|
|
|
private static final int[] ATTRS_TEXT_COLOR = new int[] {R.attr.textColor};
|
|
private static final int[] ATTRS_DISABLED_ALPHA = new int[] {R.attr.disabledAlpha};
|
|
|
|
private static final int AM = 0;
|
|
private static final int PM = 1;
|
|
|
|
private static final int HOURS_IN_HALF_DAY = 12;
|
|
|
|
private final NumericTextView mHourView;
|
|
private final NumericTextView mMinuteView;
|
|
private final View mAmPmLayout;
|
|
private final RadioButton mAmLabel;
|
|
private final RadioButton mPmLabel;
|
|
private final RadialTimePickerView mRadialTimePickerView;
|
|
private final TextView mSeparatorView;
|
|
|
|
private boolean mRadialPickerModeEnabled = true;
|
|
private final ImageButton mRadialTimePickerModeButton;
|
|
private final String mRadialTimePickerModeEnabledDescription;
|
|
private final String mTextInputPickerModeEnabledDescription;
|
|
private final View mRadialTimePickerHeader;
|
|
private final View mTextInputPickerHeader;
|
|
|
|
private final TextInputTimePickerView mTextInputPickerView;
|
|
|
|
private final Calendar mTempCalendar;
|
|
|
|
// Accessibility strings.
|
|
private final String mSelectHours;
|
|
private final String mSelectMinutes;
|
|
|
|
private boolean mIsEnabled = true;
|
|
private boolean mAllowAutoAdvance;
|
|
private int mCurrentHour;
|
|
private int mCurrentMinute;
|
|
private boolean mIs24Hour;
|
|
|
|
// The portrait layout puts AM/PM at the right by default.
|
|
private boolean mIsAmPmAtLeft = false;
|
|
// The landscape layouts put AM/PM at the bottom by default.
|
|
private boolean mIsAmPmAtTop = false;
|
|
|
|
// Localization data.
|
|
private boolean mHourFormatShowLeadingZero;
|
|
private boolean mHourFormatStartsAtZero;
|
|
|
|
// Most recent time announcement values for accessibility.
|
|
private CharSequence mLastAnnouncedText;
|
|
private boolean mLastAnnouncedIsHour;
|
|
|
|
public TimePickerClockDelegate(TimePicker delegator, Context context, AttributeSet attrs,
|
|
int defStyleAttr, int defStyleRes) {
|
|
super(delegator, context);
|
|
|
|
// process style attributes
|
|
final TypedArray a = mContext.obtainStyledAttributes(attrs,
|
|
R.styleable.TimePicker, defStyleAttr, defStyleRes);
|
|
final LayoutInflater inflater = (LayoutInflater) mContext.getSystemService(
|
|
Context.LAYOUT_INFLATER_SERVICE);
|
|
final Resources res = mContext.getResources();
|
|
|
|
mSelectHours = res.getString(R.string.select_hours);
|
|
mSelectMinutes = res.getString(R.string.select_minutes);
|
|
|
|
final int layoutResourceId = a.getResourceId(R.styleable.TimePicker_internalLayout,
|
|
R.layout.time_picker_material);
|
|
final View mainView = inflater.inflate(layoutResourceId, delegator);
|
|
mainView.setSaveFromParentEnabled(false);
|
|
mRadialTimePickerHeader = mainView.findViewById(R.id.time_header);
|
|
mRadialTimePickerHeader.setOnTouchListener(new NearestTouchDelegate());
|
|
|
|
// Set up hour/minute labels.
|
|
mHourView = (NumericTextView) mainView.findViewById(R.id.hours);
|
|
mHourView.setOnClickListener(mClickListener);
|
|
mHourView.setOnFocusChangeListener(mFocusListener);
|
|
mHourView.setOnDigitEnteredListener(mDigitEnteredListener);
|
|
mHourView.setAccessibilityDelegate(
|
|
new ClickActionDelegate(context, R.string.select_hours));
|
|
mSeparatorView = (TextView) mainView.findViewById(R.id.separator);
|
|
mMinuteView = (NumericTextView) mainView.findViewById(R.id.minutes);
|
|
mMinuteView.setOnClickListener(mClickListener);
|
|
mMinuteView.setOnFocusChangeListener(mFocusListener);
|
|
mMinuteView.setOnDigitEnteredListener(mDigitEnteredListener);
|
|
mMinuteView.setAccessibilityDelegate(
|
|
new ClickActionDelegate(context, R.string.select_minutes));
|
|
mMinuteView.setRange(0, 59);
|
|
|
|
// Set up AM/PM labels.
|
|
mAmPmLayout = mainView.findViewById(R.id.ampm_layout);
|
|
mAmPmLayout.setOnTouchListener(new NearestTouchDelegate());
|
|
|
|
final String[] amPmStrings = TimePicker.getAmPmStrings(context);
|
|
mAmLabel = (RadioButton) mAmPmLayout.findViewById(R.id.am_label);
|
|
mAmLabel.setText(obtainVerbatim(amPmStrings[0]));
|
|
mAmLabel.setOnClickListener(mClickListener);
|
|
ensureMinimumTextWidth(mAmLabel);
|
|
|
|
mPmLabel = (RadioButton) mAmPmLayout.findViewById(R.id.pm_label);
|
|
mPmLabel.setText(obtainVerbatim(amPmStrings[1]));
|
|
mPmLabel.setOnClickListener(mClickListener);
|
|
ensureMinimumTextWidth(mPmLabel);
|
|
|
|
// For the sake of backwards compatibility, attempt to extract the text
|
|
// color from the header time text appearance. If it's set, we'll let
|
|
// that override the "real" header text color.
|
|
ColorStateList headerTextColor = null;
|
|
|
|
@SuppressWarnings("deprecation")
|
|
final int timeHeaderTextAppearance = a.getResourceId(
|
|
R.styleable.TimePicker_headerTimeTextAppearance, 0);
|
|
if (timeHeaderTextAppearance != 0) {
|
|
final TypedArray textAppearance = mContext.obtainStyledAttributes(null,
|
|
ATTRS_TEXT_COLOR, 0, timeHeaderTextAppearance);
|
|
final ColorStateList legacyHeaderTextColor = textAppearance.getColorStateList(0);
|
|
headerTextColor = applyLegacyColorFixes(legacyHeaderTextColor);
|
|
textAppearance.recycle();
|
|
}
|
|
|
|
if (headerTextColor == null) {
|
|
headerTextColor = a.getColorStateList(R.styleable.TimePicker_headerTextColor);
|
|
}
|
|
|
|
mTextInputPickerHeader = mainView.findViewById(R.id.input_header);
|
|
|
|
if (headerTextColor != null) {
|
|
mHourView.setTextColor(headerTextColor);
|
|
mSeparatorView.setTextColor(headerTextColor);
|
|
mMinuteView.setTextColor(headerTextColor);
|
|
mAmLabel.setTextColor(headerTextColor);
|
|
mPmLabel.setTextColor(headerTextColor);
|
|
}
|
|
|
|
// Set up header background, if available.
|
|
if (a.hasValueOrEmpty(R.styleable.TimePicker_headerBackground)) {
|
|
mRadialTimePickerHeader.setBackground(a.getDrawable(
|
|
R.styleable.TimePicker_headerBackground));
|
|
mTextInputPickerHeader.setBackground(a.getDrawable(
|
|
R.styleable.TimePicker_headerBackground));
|
|
}
|
|
|
|
a.recycle();
|
|
|
|
mRadialTimePickerView = (RadialTimePickerView) mainView.findViewById(R.id.radial_picker);
|
|
mRadialTimePickerView.applyAttributes(attrs, defStyleAttr, defStyleRes);
|
|
mRadialTimePickerView.setOnValueSelectedListener(mOnValueSelectedListener);
|
|
|
|
mTextInputPickerView = (TextInputTimePickerView) mainView.findViewById(R.id.input_mode);
|
|
mTextInputPickerView.setListener(mOnValueTypedListener);
|
|
|
|
mRadialTimePickerModeButton =
|
|
(ImageButton) mainView.findViewById(R.id.toggle_mode);
|
|
mRadialTimePickerModeButton.setOnClickListener(new View.OnClickListener() {
|
|
@Override
|
|
public void onClick(View v) {
|
|
toggleRadialPickerMode();
|
|
}
|
|
});
|
|
mRadialTimePickerModeEnabledDescription = context.getResources().getString(
|
|
R.string.time_picker_radial_mode_description);
|
|
mTextInputPickerModeEnabledDescription = context.getResources().getString(
|
|
R.string.time_picker_text_input_mode_description);
|
|
|
|
mAllowAutoAdvance = true;
|
|
|
|
updateHourFormat();
|
|
|
|
// Initialize with current time.
|
|
mTempCalendar = Calendar.getInstance(mLocale);
|
|
final int currentHour = mTempCalendar.get(Calendar.HOUR_OF_DAY);
|
|
final int currentMinute = mTempCalendar.get(Calendar.MINUTE);
|
|
initialize(currentHour, currentMinute, mIs24Hour, HOUR_INDEX);
|
|
}
|
|
|
|
private void toggleRadialPickerMode() {
|
|
if (mRadialPickerModeEnabled) {
|
|
mRadialTimePickerView.setVisibility(View.GONE);
|
|
mRadialTimePickerHeader.setVisibility(View.GONE);
|
|
mTextInputPickerHeader.setVisibility(View.VISIBLE);
|
|
mTextInputPickerView.setVisibility(View.VISIBLE);
|
|
mRadialTimePickerModeButton.setImageResource(R.drawable.btn_clock_material);
|
|
mRadialTimePickerModeButton.setContentDescription(
|
|
mRadialTimePickerModeEnabledDescription);
|
|
mRadialPickerModeEnabled = false;
|
|
} else {
|
|
mRadialTimePickerView.setVisibility(View.VISIBLE);
|
|
mRadialTimePickerHeader.setVisibility(View.VISIBLE);
|
|
mTextInputPickerHeader.setVisibility(View.GONE);
|
|
mTextInputPickerView.setVisibility(View.GONE);
|
|
mRadialTimePickerModeButton.setImageResource(R.drawable.btn_keyboard_key_material);
|
|
mRadialTimePickerModeButton.setContentDescription(
|
|
mTextInputPickerModeEnabledDescription);
|
|
updateTextInputPicker();
|
|
InputMethodManager imm = mContext.getSystemService(InputMethodManager.class);
|
|
if (imm != null) {
|
|
imm.hideSoftInputFromWindow(mDelegator.getWindowToken(), 0);
|
|
}
|
|
mRadialPickerModeEnabled = true;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean validateInput() {
|
|
return mTextInputPickerView.validateInput();
|
|
}
|
|
|
|
/**
|
|
* Ensures that a TextView is wide enough to contain its text without
|
|
* wrapping or clipping. Measures the specified view and sets the minimum
|
|
* width to the view's desired width.
|
|
*
|
|
* @param v the text view to measure
|
|
*/
|
|
private static void ensureMinimumTextWidth(TextView v) {
|
|
v.measure(MeasureSpec.UNSPECIFIED, MeasureSpec.UNSPECIFIED);
|
|
|
|
// Set both the TextView and the View version of minimum
|
|
// width because they are subtly different.
|
|
final int minWidth = v.getMeasuredWidth();
|
|
v.setMinWidth(minWidth);
|
|
v.setMinimumWidth(minWidth);
|
|
}
|
|
|
|
/**
|
|
* Updates hour formatting based on the current locale and 24-hour mode.
|
|
* <p>
|
|
* Determines how the hour should be formatted, sets member variables for
|
|
* leading zero and starting hour, and sets the hour view's presentation.
|
|
*/
|
|
private void updateHourFormat() {
|
|
final String bestDateTimePattern = DateFormat.getBestDateTimePattern(
|
|
mLocale, mIs24Hour ? "Hm" : "hm");
|
|
final int lengthPattern = bestDateTimePattern.length();
|
|
boolean showLeadingZero = false;
|
|
char hourFormat = '\0';
|
|
|
|
for (int i = 0; i < lengthPattern; i++) {
|
|
final char c = bestDateTimePattern.charAt(i);
|
|
if (c == 'H' || c == 'h' || c == 'K' || c == 'k') {
|
|
hourFormat = c;
|
|
if (i + 1 < lengthPattern && c == bestDateTimePattern.charAt(i + 1)) {
|
|
showLeadingZero = true;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
mHourFormatShowLeadingZero = showLeadingZero;
|
|
mHourFormatStartsAtZero = hourFormat == 'K' || hourFormat == 'H';
|
|
|
|
// Update hour text field.
|
|
final int minHour = mHourFormatStartsAtZero ? 0 : 1;
|
|
final int maxHour = (mIs24Hour ? 23 : 11) + minHour;
|
|
mHourView.setRange(minHour, maxHour);
|
|
mHourView.setShowLeadingZeroes(mHourFormatShowLeadingZero);
|
|
|
|
final String[] digits = DecimalFormatSymbols.getInstance(mLocale).getDigitStrings();
|
|
int maxCharLength = 0;
|
|
for (int i = 0; i < 10; i++) {
|
|
maxCharLength = Math.max(maxCharLength, digits[i].length());
|
|
}
|
|
mTextInputPickerView.setHourFormat(maxCharLength * 2);
|
|
}
|
|
|
|
static final CharSequence obtainVerbatim(String text) {
|
|
return new SpannableStringBuilder().append(text,
|
|
new TtsSpan.VerbatimBuilder(text).build(), 0);
|
|
}
|
|
|
|
/**
|
|
* The legacy text color might have been poorly defined. Ensures that it
|
|
* has an appropriate activated state, using the selected state if one
|
|
* exists or modifying the default text color otherwise.
|
|
*
|
|
* @param color a legacy text color, or {@code null}
|
|
* @return a color state list with an appropriate activated state, or
|
|
* {@code null} if a valid activated state could not be generated
|
|
*/
|
|
@Nullable
|
|
private ColorStateList applyLegacyColorFixes(@Nullable ColorStateList color) {
|
|
if (color == null || color.hasState(R.attr.state_activated)) {
|
|
return color;
|
|
}
|
|
|
|
final int activatedColor;
|
|
final int defaultColor;
|
|
if (color.hasState(R.attr.state_selected)) {
|
|
activatedColor = color.getColorForState(StateSet.get(
|
|
StateSet.VIEW_STATE_ENABLED | StateSet.VIEW_STATE_SELECTED), 0);
|
|
defaultColor = color.getColorForState(StateSet.get(
|
|
StateSet.VIEW_STATE_ENABLED), 0);
|
|
} else {
|
|
activatedColor = color.getDefaultColor();
|
|
|
|
// Generate a non-activated color using the disabled alpha.
|
|
final TypedArray ta = mContext.obtainStyledAttributes(ATTRS_DISABLED_ALPHA);
|
|
final float disabledAlpha = ta.getFloat(0, 0.30f);
|
|
ta.recycle();
|
|
defaultColor = multiplyAlphaComponent(activatedColor, disabledAlpha);
|
|
}
|
|
|
|
if (activatedColor == 0 || defaultColor == 0) {
|
|
// We somehow failed to obtain the colors.
|
|
return null;
|
|
}
|
|
|
|
final int[][] stateSet = new int[][] {{ R.attr.state_activated }, {}};
|
|
final int[] colors = new int[] { activatedColor, defaultColor };
|
|
return new ColorStateList(stateSet, colors);
|
|
}
|
|
|
|
private int multiplyAlphaComponent(int color, float alphaMod) {
|
|
final int srcRgb = color & 0xFFFFFF;
|
|
final int srcAlpha = (color >> 24) & 0xFF;
|
|
final int dstAlpha = (int) (srcAlpha * alphaMod + 0.5f);
|
|
return srcRgb | (dstAlpha << 24);
|
|
}
|
|
|
|
private static class ClickActionDelegate extends AccessibilityDelegate {
|
|
private final AccessibilityAction mClickAction;
|
|
|
|
public ClickActionDelegate(Context context, int resId) {
|
|
mClickAction = new AccessibilityAction(
|
|
AccessibilityNodeInfo.ACTION_CLICK, context.getString(resId));
|
|
}
|
|
|
|
@Override
|
|
public void onInitializeAccessibilityNodeInfo(View host, AccessibilityNodeInfo info) {
|
|
super.onInitializeAccessibilityNodeInfo(host, info);
|
|
|
|
info.addAction(mClickAction);
|
|
}
|
|
}
|
|
|
|
private void initialize(int hourOfDay, int minute, boolean is24HourView, int index) {
|
|
mCurrentHour = hourOfDay;
|
|
mCurrentMinute = minute;
|
|
mIs24Hour = is24HourView;
|
|
updateUI(index);
|
|
}
|
|
|
|
private void updateUI(int index) {
|
|
updateHeaderAmPm();
|
|
updateHeaderHour(mCurrentHour, false);
|
|
updateHeaderSeparator();
|
|
updateHeaderMinute(mCurrentMinute, false);
|
|
updateRadialPicker(index);
|
|
updateTextInputPicker();
|
|
|
|
mDelegator.invalidate();
|
|
}
|
|
|
|
private void updateTextInputPicker() {
|
|
mTextInputPickerView.updateTextInputValues(getLocalizedHour(mCurrentHour), mCurrentMinute,
|
|
mCurrentHour < 12 ? AM : PM, mIs24Hour, mHourFormatStartsAtZero);
|
|
}
|
|
|
|
private void updateRadialPicker(int index) {
|
|
mRadialTimePickerView.initialize(mCurrentHour, mCurrentMinute, mIs24Hour);
|
|
setCurrentItemShowing(index, false, true);
|
|
}
|
|
|
|
private void updateHeaderAmPm() {
|
|
if (mIs24Hour) {
|
|
mAmPmLayout.setVisibility(View.GONE);
|
|
} else {
|
|
// Find the location of AM/PM based on locale information.
|
|
final String dateTimePattern = DateFormat.getBestDateTimePattern(mLocale, "hm");
|
|
final boolean isAmPmAtStart = dateTimePattern.startsWith("a");
|
|
setAmPmStart(isAmPmAtStart);
|
|
updateAmPmLabelStates(mCurrentHour < 12 ? AM : PM);
|
|
}
|
|
}
|
|
|
|
private void setAmPmStart(boolean isAmPmAtStart) {
|
|
final RelativeLayout.LayoutParams params =
|
|
(RelativeLayout.LayoutParams) mAmPmLayout.getLayoutParams();
|
|
if (params.getRule(RelativeLayout.RIGHT_OF) != 0
|
|
|| params.getRule(RelativeLayout.LEFT_OF) != 0) {
|
|
final int margin = (int) (mContext.getResources().getDisplayMetrics().density * 8);
|
|
// Horizontal mode, with AM/PM appearing to left/right of hours and minutes.
|
|
final boolean isAmPmAtLeft;
|
|
if (TextUtils.getLayoutDirectionFromLocale(mLocale) == View.LAYOUT_DIRECTION_LTR) {
|
|
isAmPmAtLeft = isAmPmAtStart;
|
|
} else {
|
|
isAmPmAtLeft = !isAmPmAtStart;
|
|
}
|
|
|
|
if (isAmPmAtLeft) {
|
|
params.removeRule(RelativeLayout.RIGHT_OF);
|
|
params.addRule(RelativeLayout.LEFT_OF, mHourView.getId());
|
|
} else {
|
|
params.removeRule(RelativeLayout.LEFT_OF);
|
|
params.addRule(RelativeLayout.RIGHT_OF, mMinuteView.getId());
|
|
}
|
|
|
|
if (isAmPmAtStart) {
|
|
params.setMarginStart(0);
|
|
params.setMarginEnd(margin);
|
|
} else {
|
|
params.setMarginStart(margin);
|
|
params.setMarginEnd(0);
|
|
}
|
|
mIsAmPmAtLeft = isAmPmAtLeft;
|
|
} else if (params.getRule(RelativeLayout.BELOW) != 0
|
|
|| params.getRule(RelativeLayout.ABOVE) != 0) {
|
|
// Vertical mode, with AM/PM appearing to top/bottom of hours and minutes.
|
|
if (mIsAmPmAtTop == isAmPmAtStart) {
|
|
// AM/PM is already at the correct location. No change needed.
|
|
return;
|
|
}
|
|
|
|
final int otherViewId;
|
|
if (isAmPmAtStart) {
|
|
otherViewId = params.getRule(RelativeLayout.BELOW);
|
|
params.removeRule(RelativeLayout.BELOW);
|
|
params.addRule(RelativeLayout.ABOVE, otherViewId);
|
|
} else {
|
|
otherViewId = params.getRule(RelativeLayout.ABOVE);
|
|
params.removeRule(RelativeLayout.ABOVE);
|
|
params.addRule(RelativeLayout.BELOW, otherViewId);
|
|
}
|
|
|
|
// Switch the top and bottom paddings on the other view.
|
|
final View otherView = mRadialTimePickerHeader.findViewById(otherViewId);
|
|
final int top = otherView.getPaddingTop();
|
|
final int bottom = otherView.getPaddingBottom();
|
|
final int left = otherView.getPaddingLeft();
|
|
final int right = otherView.getPaddingRight();
|
|
otherView.setPadding(left, bottom, right, top);
|
|
|
|
mIsAmPmAtTop = isAmPmAtStart;
|
|
}
|
|
|
|
mAmPmLayout.setLayoutParams(params);
|
|
}
|
|
|
|
@Override
|
|
public void setDate(int hour, int minute) {
|
|
setHourInternal(hour, FROM_EXTERNAL_API, true, false);
|
|
setMinuteInternal(minute, FROM_EXTERNAL_API, false);
|
|
|
|
onTimeChanged();
|
|
}
|
|
|
|
/**
|
|
* Set the current hour.
|
|
*/
|
|
@Override
|
|
public void setHour(int hour) {
|
|
setHourInternal(hour, FROM_EXTERNAL_API, true, true);
|
|
}
|
|
|
|
private void setHourInternal(int hour, @ChangeSource int source, boolean announce,
|
|
boolean notify) {
|
|
if (mCurrentHour == hour) {
|
|
return;
|
|
}
|
|
|
|
resetAutofilledValue();
|
|
mCurrentHour = hour;
|
|
updateHeaderHour(hour, announce);
|
|
updateHeaderAmPm();
|
|
|
|
if (source != FROM_RADIAL_PICKER) {
|
|
mRadialTimePickerView.setCurrentHour(hour);
|
|
mRadialTimePickerView.setAmOrPm(hour < 12 ? AM : PM);
|
|
}
|
|
if (source != FROM_INPUT_PICKER) {
|
|
updateTextInputPicker();
|
|
}
|
|
|
|
mDelegator.invalidate();
|
|
if (notify) {
|
|
onTimeChanged();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return the current hour in the range (0-23)
|
|
*/
|
|
@Override
|
|
public int getHour() {
|
|
final int currentHour = mRadialTimePickerView.getCurrentHour();
|
|
if (mIs24Hour) {
|
|
return currentHour;
|
|
}
|
|
|
|
if (mRadialTimePickerView.getAmOrPm() == PM) {
|
|
return (currentHour % HOURS_IN_HALF_DAY) + HOURS_IN_HALF_DAY;
|
|
} else {
|
|
return currentHour % HOURS_IN_HALF_DAY;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set the current minute (0-59).
|
|
*/
|
|
@Override
|
|
public void setMinute(int minute) {
|
|
setMinuteInternal(minute, FROM_EXTERNAL_API, true);
|
|
}
|
|
|
|
private void setMinuteInternal(int minute, @ChangeSource int source, boolean notify) {
|
|
if (mCurrentMinute == minute) {
|
|
return;
|
|
}
|
|
|
|
resetAutofilledValue();
|
|
mCurrentMinute = minute;
|
|
updateHeaderMinute(minute, true);
|
|
|
|
if (source != FROM_RADIAL_PICKER) {
|
|
mRadialTimePickerView.setCurrentMinute(minute);
|
|
}
|
|
if (source != FROM_INPUT_PICKER) {
|
|
updateTextInputPicker();
|
|
}
|
|
|
|
mDelegator.invalidate();
|
|
if (notify) {
|
|
onTimeChanged();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return The current minute.
|
|
*/
|
|
@Override
|
|
public int getMinute() {
|
|
return mRadialTimePickerView.getCurrentMinute();
|
|
}
|
|
|
|
/**
|
|
* Sets whether time is displayed in 24-hour mode or 12-hour mode with
|
|
* AM/PM indicators.
|
|
*
|
|
* @param is24Hour {@code true} to display time in 24-hour mode or
|
|
* {@code false} for 12-hour mode with AM/PM
|
|
*/
|
|
public void setIs24Hour(boolean is24Hour) {
|
|
if (mIs24Hour != is24Hour) {
|
|
mIs24Hour = is24Hour;
|
|
mCurrentHour = getHour();
|
|
|
|
updateHourFormat();
|
|
updateUI(mRadialTimePickerView.getCurrentItemShowing());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return {@code true} if time is displayed in 24-hour mode, or
|
|
* {@code false} if time is displayed in 12-hour mode with AM/PM
|
|
* indicators
|
|
*/
|
|
@Override
|
|
public boolean is24Hour() {
|
|
return mIs24Hour;
|
|
}
|
|
|
|
@Override
|
|
public void setEnabled(boolean enabled) {
|
|
mHourView.setEnabled(enabled);
|
|
mMinuteView.setEnabled(enabled);
|
|
mAmLabel.setEnabled(enabled);
|
|
mPmLabel.setEnabled(enabled);
|
|
mRadialTimePickerView.setEnabled(enabled);
|
|
mIsEnabled = enabled;
|
|
}
|
|
|
|
@Override
|
|
public boolean isEnabled() {
|
|
return mIsEnabled;
|
|
}
|
|
|
|
@Override
|
|
public int getBaseline() {
|
|
// does not support baseline alignment
|
|
return -1;
|
|
}
|
|
|
|
@Override
|
|
public Parcelable onSaveInstanceState(Parcelable superState) {
|
|
return new SavedState(superState, getHour(), getMinute(),
|
|
is24Hour(), getCurrentItemShowing());
|
|
}
|
|
|
|
@Override
|
|
public void onRestoreInstanceState(Parcelable state) {
|
|
if (state instanceof SavedState) {
|
|
final SavedState ss = (SavedState) state;
|
|
initialize(ss.getHour(), ss.getMinute(), ss.is24HourMode(), ss.getCurrentItemShowing());
|
|
mRadialTimePickerView.invalidate();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
|
|
onPopulateAccessibilityEvent(event);
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public void onPopulateAccessibilityEvent(AccessibilityEvent event) {
|
|
int flags = DateUtils.FORMAT_SHOW_TIME;
|
|
if (mIs24Hour) {
|
|
flags |= DateUtils.FORMAT_24HOUR;
|
|
} else {
|
|
flags |= DateUtils.FORMAT_12HOUR;
|
|
}
|
|
|
|
mTempCalendar.set(Calendar.HOUR_OF_DAY, getHour());
|
|
mTempCalendar.set(Calendar.MINUTE, getMinute());
|
|
|
|
final String selectedTime = DateUtils.formatDateTime(mContext,
|
|
mTempCalendar.getTimeInMillis(), flags);
|
|
final String selectionMode = mRadialTimePickerView.getCurrentItemShowing() == HOUR_INDEX ?
|
|
mSelectHours : mSelectMinutes;
|
|
event.getText().add(selectedTime + " " + selectionMode);
|
|
}
|
|
|
|
/** @hide */
|
|
@Override
|
|
@TestApi
|
|
public View getHourView() {
|
|
return mHourView;
|
|
}
|
|
|
|
/** @hide */
|
|
@Override
|
|
@TestApi
|
|
public View getMinuteView() {
|
|
return mMinuteView;
|
|
}
|
|
|
|
/** @hide */
|
|
@Override
|
|
@TestApi
|
|
public View getAmView() {
|
|
return mAmLabel;
|
|
}
|
|
|
|
/** @hide */
|
|
@Override
|
|
@TestApi
|
|
public View getPmView() {
|
|
return mPmLabel;
|
|
}
|
|
|
|
/**
|
|
* @return the index of the current item showing
|
|
*/
|
|
private int getCurrentItemShowing() {
|
|
return mRadialTimePickerView.getCurrentItemShowing();
|
|
}
|
|
|
|
/**
|
|
* Propagate the time change
|
|
*/
|
|
private void onTimeChanged() {
|
|
mDelegator.sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_SELECTED);
|
|
if (mOnTimeChangedListener != null) {
|
|
mOnTimeChangedListener.onTimeChanged(mDelegator, getHour(), getMinute());
|
|
}
|
|
if (mAutoFillChangeListener != null) {
|
|
mAutoFillChangeListener.onTimeChanged(mDelegator, getHour(), getMinute());
|
|
}
|
|
}
|
|
|
|
private void tryVibrate() {
|
|
mDelegator.performHapticFeedback(HapticFeedbackConstants.CLOCK_TICK);
|
|
}
|
|
|
|
private void updateAmPmLabelStates(int amOrPm) {
|
|
final boolean isAm = amOrPm == AM;
|
|
mAmLabel.setActivated(isAm);
|
|
mAmLabel.setChecked(isAm);
|
|
|
|
final boolean isPm = amOrPm == PM;
|
|
mPmLabel.setActivated(isPm);
|
|
mPmLabel.setChecked(isPm);
|
|
}
|
|
|
|
/**
|
|
* Converts hour-of-day (0-23) time into a localized hour number.
|
|
* <p>
|
|
* The localized value may be in the range (0-23), (1-24), (0-11), or
|
|
* (1-12) depending on the locale. This method does not handle leading
|
|
* zeroes.
|
|
*
|
|
* @param hourOfDay the hour-of-day (0-23)
|
|
* @return a localized hour number
|
|
*/
|
|
private int getLocalizedHour(int hourOfDay) {
|
|
if (!mIs24Hour) {
|
|
// Convert to hour-of-am-pm.
|
|
hourOfDay %= 12;
|
|
}
|
|
|
|
if (!mHourFormatStartsAtZero && hourOfDay == 0) {
|
|
// Convert to clock-hour (either of-day or of-am-pm).
|
|
hourOfDay = mIs24Hour ? 24 : 12;
|
|
}
|
|
|
|
return hourOfDay;
|
|
}
|
|
|
|
private void updateHeaderHour(int hourOfDay, boolean announce) {
|
|
final int localizedHour = getLocalizedHour(hourOfDay);
|
|
mHourView.setValue(localizedHour);
|
|
|
|
if (announce) {
|
|
tryAnnounceForAccessibility(mHourView.getText(), true);
|
|
}
|
|
}
|
|
|
|
private void updateHeaderMinute(int minuteOfHour, boolean announce) {
|
|
mMinuteView.setValue(minuteOfHour);
|
|
|
|
if (announce) {
|
|
tryAnnounceForAccessibility(mMinuteView.getText(), false);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The time separator is defined in the Unicode CLDR and cannot be supposed to be ":".
|
|
*
|
|
* See http://unicode.org/cldr/trac/browser/trunk/common/main
|
|
*
|
|
* We pass the correct "skeleton" depending on 12 or 24 hours view and then extract the
|
|
* separator as the character which is just after the hour marker in the returned pattern.
|
|
*/
|
|
private void updateHeaderSeparator() {
|
|
final String bestDateTimePattern = DateFormat.getBestDateTimePattern(mLocale,
|
|
(mIs24Hour) ? "Hm" : "hm");
|
|
final String separatorText = getHourMinSeparatorFromPattern(bestDateTimePattern);
|
|
mSeparatorView.setText(separatorText);
|
|
mTextInputPickerView.updateSeparator(separatorText);
|
|
}
|
|
|
|
/**
|
|
* This helper method extracts the time separator from the {@code datetimePattern}.
|
|
*
|
|
* The time separator is defined in the Unicode CLDR and cannot be supposed to be ":".
|
|
*
|
|
* See http://unicode.org/cldr/trac/browser/trunk/common/main
|
|
*
|
|
* @return Separator string. This is the character or set of quoted characters just after the
|
|
* hour marker in {@code dateTimePattern}. Returns a colon (:) if it can't locate the
|
|
* separator.
|
|
*
|
|
* @hide
|
|
*/
|
|
private static String getHourMinSeparatorFromPattern(String dateTimePattern) {
|
|
final String defaultSeparator = ":";
|
|
boolean foundHourPattern = false;
|
|
for (int i = 0; i < dateTimePattern.length(); i++) {
|
|
switch (dateTimePattern.charAt(i)) {
|
|
// See http://www.unicode.org/reports/tr35/tr35-dates.html for hour formats.
|
|
case 'H':
|
|
case 'h':
|
|
case 'K':
|
|
case 'k':
|
|
foundHourPattern = true;
|
|
continue;
|
|
case ' ': // skip spaces
|
|
continue;
|
|
case '\'':
|
|
if (!foundHourPattern) {
|
|
continue;
|
|
}
|
|
SpannableStringBuilder quotedSubstring = new SpannableStringBuilder(
|
|
dateTimePattern.substring(i));
|
|
int quotedTextLength = DateFormat.appendQuotedText(quotedSubstring, 0);
|
|
return quotedSubstring.subSequence(0, quotedTextLength).toString();
|
|
default:
|
|
if (!foundHourPattern) {
|
|
continue;
|
|
}
|
|
return Character.toString(dateTimePattern.charAt(i));
|
|
}
|
|
}
|
|
return defaultSeparator;
|
|
}
|
|
|
|
static private int lastIndexOfAny(String str, char[] any) {
|
|
final int lengthAny = any.length;
|
|
if (lengthAny > 0) {
|
|
for (int i = str.length() - 1; i >= 0; i--) {
|
|
char c = str.charAt(i);
|
|
for (int j = 0; j < lengthAny; j++) {
|
|
if (c == any[j]) {
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
private void tryAnnounceForAccessibility(CharSequence text, boolean isHour) {
|
|
if (mLastAnnouncedIsHour != isHour || !text.equals(mLastAnnouncedText)) {
|
|
// TODO: Find a better solution, potentially live regions?
|
|
mDelegator.announceForAccessibility(text);
|
|
mLastAnnouncedText = text;
|
|
mLastAnnouncedIsHour = isHour;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Show either Hours or Minutes.
|
|
*/
|
|
private void setCurrentItemShowing(int index, boolean animateCircle, boolean announce) {
|
|
mRadialTimePickerView.setCurrentItemShowing(index, animateCircle);
|
|
|
|
if (index == HOUR_INDEX) {
|
|
if (announce) {
|
|
mDelegator.announceForAccessibility(mSelectHours);
|
|
}
|
|
} else {
|
|
if (announce) {
|
|
mDelegator.announceForAccessibility(mSelectMinutes);
|
|
}
|
|
}
|
|
|
|
mHourView.setActivated(index == HOUR_INDEX);
|
|
mMinuteView.setActivated(index == MINUTE_INDEX);
|
|
}
|
|
|
|
private void setAmOrPm(int amOrPm) {
|
|
updateAmPmLabelStates(amOrPm);
|
|
|
|
if (mRadialTimePickerView.setAmOrPm(amOrPm)) {
|
|
mCurrentHour = getHour();
|
|
updateTextInputPicker();
|
|
if (mOnTimeChangedListener != null) {
|
|
mOnTimeChangedListener.onTimeChanged(mDelegator, getHour(), getMinute());
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Listener for RadialTimePickerView interaction. */
|
|
private final OnValueSelectedListener mOnValueSelectedListener = new OnValueSelectedListener() {
|
|
@Override
|
|
public void onValueSelected(int pickerType, int newValue, boolean autoAdvance) {
|
|
boolean valueChanged = false;
|
|
switch (pickerType) {
|
|
case RadialTimePickerView.HOURS:
|
|
if (getHour() != newValue) {
|
|
valueChanged = true;
|
|
}
|
|
final boolean isTransition = mAllowAutoAdvance && autoAdvance;
|
|
setHourInternal(newValue, FROM_RADIAL_PICKER, !isTransition, true);
|
|
if (isTransition) {
|
|
setCurrentItemShowing(MINUTE_INDEX, true, false);
|
|
|
|
final int localizedHour = getLocalizedHour(newValue);
|
|
mDelegator.announceForAccessibility(localizedHour + ". " + mSelectMinutes);
|
|
}
|
|
break;
|
|
case RadialTimePickerView.MINUTES:
|
|
if (getMinute() != newValue) {
|
|
valueChanged = true;
|
|
}
|
|
setMinuteInternal(newValue, FROM_RADIAL_PICKER, true);
|
|
break;
|
|
}
|
|
|
|
if (mOnTimeChangedListener != null && valueChanged) {
|
|
mOnTimeChangedListener.onTimeChanged(mDelegator, getHour(), getMinute());
|
|
}
|
|
}
|
|
};
|
|
|
|
private final OnValueTypedListener mOnValueTypedListener = new OnValueTypedListener() {
|
|
@Override
|
|
public void onValueChanged(int pickerType, int newValue) {
|
|
switch (pickerType) {
|
|
case TextInputTimePickerView.HOURS:
|
|
setHourInternal(newValue, FROM_INPUT_PICKER, false, true);
|
|
break;
|
|
case TextInputTimePickerView.MINUTES:
|
|
setMinuteInternal(newValue, FROM_INPUT_PICKER, true);
|
|
break;
|
|
case TextInputTimePickerView.AMPM:
|
|
setAmOrPm(newValue);
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
|
|
/** Listener for keyboard interaction. */
|
|
private final OnValueChangedListener mDigitEnteredListener = new OnValueChangedListener() {
|
|
@Override
|
|
public void onValueChanged(NumericTextView view, int value,
|
|
boolean isValid, boolean isFinished) {
|
|
final Runnable commitCallback;
|
|
final View nextFocusTarget;
|
|
if (view == mHourView) {
|
|
commitCallback = mCommitHour;
|
|
nextFocusTarget = view.isFocused() ? mMinuteView : null;
|
|
} else if (view == mMinuteView) {
|
|
commitCallback = mCommitMinute;
|
|
nextFocusTarget = null;
|
|
} else {
|
|
return;
|
|
}
|
|
|
|
view.removeCallbacks(commitCallback);
|
|
|
|
if (isValid) {
|
|
if (isFinished) {
|
|
// Done with hours entry, make visual updates
|
|
// immediately and move to next focus if needed.
|
|
commitCallback.run();
|
|
|
|
if (nextFocusTarget != null) {
|
|
nextFocusTarget.requestFocus();
|
|
}
|
|
} else {
|
|
// May still be making changes. Postpone visual
|
|
// updates to prevent distracting the user.
|
|
view.postDelayed(commitCallback, DELAY_COMMIT_MILLIS);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
private final Runnable mCommitHour = new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
setHour(mHourView.getValue());
|
|
}
|
|
};
|
|
|
|
private final Runnable mCommitMinute = new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
setMinute(mMinuteView.getValue());
|
|
}
|
|
};
|
|
|
|
private final View.OnFocusChangeListener mFocusListener = new View.OnFocusChangeListener() {
|
|
@Override
|
|
public void onFocusChange(View v, boolean focused) {
|
|
if (focused) {
|
|
switch (v.getId()) {
|
|
case R.id.am_label:
|
|
setAmOrPm(AM);
|
|
break;
|
|
case R.id.pm_label:
|
|
setAmOrPm(PM);
|
|
break;
|
|
case R.id.hours:
|
|
setCurrentItemShowing(HOUR_INDEX, true, true);
|
|
break;
|
|
case R.id.minutes:
|
|
setCurrentItemShowing(MINUTE_INDEX, true, true);
|
|
break;
|
|
default:
|
|
// Failed to handle this click, don't vibrate.
|
|
return;
|
|
}
|
|
|
|
tryVibrate();
|
|
}
|
|
}
|
|
};
|
|
|
|
private final View.OnClickListener mClickListener = new View.OnClickListener() {
|
|
@Override
|
|
public void onClick(View v) {
|
|
|
|
final int amOrPm;
|
|
switch (v.getId()) {
|
|
case R.id.am_label:
|
|
setAmOrPm(AM);
|
|
break;
|
|
case R.id.pm_label:
|
|
setAmOrPm(PM);
|
|
break;
|
|
case R.id.hours:
|
|
setCurrentItemShowing(HOUR_INDEX, true, true);
|
|
break;
|
|
case R.id.minutes:
|
|
setCurrentItemShowing(MINUTE_INDEX, true, true);
|
|
break;
|
|
default:
|
|
// Failed to handle this click, don't vibrate.
|
|
return;
|
|
}
|
|
|
|
tryVibrate();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Delegates unhandled touches in a view group to the nearest child view.
|
|
*/
|
|
private static class NearestTouchDelegate implements View.OnTouchListener {
|
|
private View mInitialTouchTarget;
|
|
|
|
@Override
|
|
public boolean onTouch(View view, MotionEvent motionEvent) {
|
|
final int actionMasked = motionEvent.getActionMasked();
|
|
if (actionMasked == MotionEvent.ACTION_DOWN) {
|
|
if (view instanceof ViewGroup) {
|
|
mInitialTouchTarget = findNearestChild((ViewGroup) view,
|
|
(int) motionEvent.getX(), (int) motionEvent.getY());
|
|
} else {
|
|
mInitialTouchTarget = null;
|
|
}
|
|
}
|
|
|
|
final View child = mInitialTouchTarget;
|
|
if (child == null) {
|
|
return false;
|
|
}
|
|
|
|
final float offsetX = view.getScrollX() - child.getLeft();
|
|
final float offsetY = view.getScrollY() - child.getTop();
|
|
motionEvent.offsetLocation(offsetX, offsetY);
|
|
final boolean handled = child.dispatchTouchEvent(motionEvent);
|
|
motionEvent.offsetLocation(-offsetX, -offsetY);
|
|
|
|
if (actionMasked == MotionEvent.ACTION_UP
|
|
|| actionMasked == MotionEvent.ACTION_CANCEL) {
|
|
mInitialTouchTarget = null;
|
|
}
|
|
|
|
return handled;
|
|
}
|
|
|
|
private View findNearestChild(ViewGroup v, int x, int y) {
|
|
View bestChild = null;
|
|
int bestDist = Integer.MAX_VALUE;
|
|
|
|
for (int i = 0, count = v.getChildCount(); i < count; i++) {
|
|
final View child = v.getChildAt(i);
|
|
final int dX = x - (child.getLeft() + child.getWidth() / 2);
|
|
final int dY = y - (child.getTop() + child.getHeight() / 2);
|
|
final int dist = dX * dX + dY * dY;
|
|
if (bestDist > dist) {
|
|
bestChild = child;
|
|
bestDist = dist;
|
|
}
|
|
}
|
|
|
|
return bestChild;
|
|
}
|
|
}
|
|
}
|