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;
class TimePickerClockDelegate extends TimePicker.AbstractTimePickerDelegate {
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;
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;
private final String mSelectHours;
private final String mSelectMinutes;
private boolean mIsEnabled = true;
private boolean mAllowAutoAdvance;
private int mCurrentHour;
private int mCurrentMinute;
private boolean mIs24Hour;
private boolean mIsAmPmAtLeft = false;
private boolean mIsAmPmAtTop = false;
private boolean mHourFormatShowLeadingZero;
private boolean mHourFormatStartsAtZero;
private CharSequence mLastAnnouncedText;
private boolean mLastAnnouncedIsHour;
public TimePickerClockDelegate(TimePicker delegator, Context context, AttributeSet attrs,
int defStyleAttr, int defStyleRes) {
super(delegator, context);
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());
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);
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);
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);
}
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();
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 = InputMethodManager.peekInstance();
if (imm != null) {
imm.hideSoftInputFromWindow(mDelegator.getWindowToken(), 0);
}
mRadialPickerModeEnabled = true;
}
}
@Override
public boolean validateInput() {
return mTextInputPickerView.validateInput();
}
private static void ensureMinimumTextWidth(TextView v) {
v.measure(MeasureSpec.UNSPECIFIED, MeasureSpec.UNSPECIFIED);
final int minWidth = v.getMeasuredWidth();
v.setMinWidth(minWidth);
v.setMinimumWidth(minWidth);
}
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';
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);
}
@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();
final TypedArray ta = mContext.obtainStyledAttributes(ATTRS_DISABLED_ALPHA);
final float disabledAlpha = ta.getFloat(0, 0.30f);
defaultColor = multiplyAlphaComponent(activatedColor, disabledAlpha);
}
if (activatedColor == 0 || defaultColor == 0) {
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 {
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 boolean isAmPmAtLeft;
if (TextUtils.getLayoutDirectionFromLocale(mLocale) == View.LAYOUT_DIRECTION_LTR) {
isAmPmAtLeft = isAmPmAtStart;
} else {
isAmPmAtLeft = !isAmPmAtStart;
}
if (mIsAmPmAtLeft == isAmPmAtLeft) {
return;
}
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());
}
mIsAmPmAtLeft = isAmPmAtLeft;
} else if (params.getRule(RelativeLayout.BELOW) != 0
|| params.getRule(RelativeLayout.ABOVE) != 0) {
if (mIsAmPmAtTop == isAmPmAtStart) {
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);
}
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();
}
@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();
}
}
@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;
}
}
@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();
}
}
@Override
public int getMinute() {
return mRadialTimePickerView.getCurrentMinute();
}
public void setIs24Hour(boolean is24Hour) {
if (mIs24Hour != is24Hour) {
mIs24Hour = is24Hour;
mCurrentHour = getHour();
updateHourFormat();
updateUI(mRadialTimePickerView.getCurrentItemShowing());
}
}
@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() {
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);
}
@Override
@TestApi
public View getHourView() {
return mHourView;
}
@Override
@TestApi
public View getMinuteView() {
return mMinuteView;
}
@Override
@TestApi
public View getAmView() {
return mAmLabel;
}
@Override
@TestApi
public View getPmView() {
return mPmLabel;
}
private int getCurrentItemShowing() {
return mRadialTimePickerView.getCurrentItemShowing();
}
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);
}
private int getLocalizedHour(int hourOfDay) {
if (!mIs24Hour) {
hourOfDay %= 12;
}
if (!mHourFormatStartsAtZero && hourOfDay == 0) {
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);
}
}
private void updateHeaderSeparator() {
final String bestDateTimePattern = DateFormat.getBestDateTimePattern(mLocale,
(mIs24Hour) ? "Hm" : "hm");
final String separatorText = getHourMinSeparatorFromPattern(bestDateTimePattern);
mSeparatorView.setText(separatorText);
mTextInputPickerView.updateSeparator(separatorText);
}
private static String getHourMinSeparatorFromPattern(String dateTimePattern) {
final String defaultSeparator = ":";
boolean foundHourPattern = false;
for (int i = 0; i < dateTimePattern.length(); i++) {
switch (dateTimePattern.charAt(i)) {
case 'H':
case 'h':
case 'K':
case 'k':
foundHourPattern = true;
continue;
case ' ':
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)) {
mDelegator.announceForAccessibility(text);
mLastAnnouncedText = text;
mLastAnnouncedIsHour = isHour;
}
}
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());
}
}
}
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;
}
}
};
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) {
commitCallback.run();
if (nextFocusTarget != null) {
nextFocusTarget.requestFocus();
}
} else {
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:
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:
return;
}
tryVibrate();
}
};
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;
}
}
}