Merge "Implement new keyboard interaction model in TimePicker" (cbe45082) · Commits · e / os / android_frameworks_base

core/java/android/widget/TimePicker.java

+12 −0

Original line number	Diff line number	Diff line
		@@ -29,6 +29,8 @@ import com.android.internal.R;

		import java.util.Locale;

		import libcore.icu.LocaleData;

		/**
		* A widget for selecting the time of day, in either 24-hour or AM/PM mode.
		* <p>
		@@ -303,6 +305,16 @@ public class TimePicker extends FrameLayout {
		void onValidationChanged(boolean valid);
		}

		static String[] getAmPmStrings(Context context) {
		final Locale locale = context.getResources().getConfiguration().locale;
		final LocaleData d = LocaleData.get(locale);

		final String[] result = new String[2];
		result[0] = d.amPm[0].length() > 4 ? d.narrowAm : d.amPm[0];
		result[1] = d.amPm[1].length() > 4 ? d.narrowPm : d.amPm[1];
		return result;
		}

		/**
		* An abstract class which can be used as a start for TimePicker implementations
		*/

core/java/android/widget/TimePickerClockDelegate.java

+245 −681

File changed.

Preview size limit exceeded, changes collapsed.

core/java/com/android/internal/widget/NumericTextView.java

0 → 100644

+328 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2015 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 com.android.internal.widget;

		import android.content.Context;
		import android.graphics.Rect;
		import android.util.AttributeSet;
		import android.util.StateSet;
		import android.view.KeyEvent;
		import android.widget.TextView;

		/**
		* Extension of TextView that can handle displaying and inputting a range of
		* numbers.
		* <p>
		* Clients of this view should never call {@link #setText(CharSequence)} or
		* {@link #setHint(CharSequence)} directly. Instead, they should call
		* {@link #setValue(int)} to modify the currently displayed value.
		*/
		public class NumericTextView extends TextView {
		private static final int RADIX = 10;
		private static final double LOG_RADIX = Math.log(RADIX);

		private int mMinValue = 0;
		private int mMaxValue = 99;

		/** Number of digits in the maximum value. */
		private int mMaxCount = 2;

		private boolean mShowLeadingZeroes = true;

		private int mValue;

		/** Number of digits entered during editing mode. */
		private int mCount;

		/** Used to restore the value after an aborted edit. */
		private int mPreviousValue;

		private OnValueChangedListener mListener;

		public NumericTextView(Context context, AttributeSet attrs) {
		super(context, attrs);

		// Generate the hint text color based on disabled state.
		final int textColorDisabled = getTextColors().getColorForState(StateSet.get(0), 0);
		setHintTextColor(textColorDisabled);

		setFocusable(true);
		}

		@Override
		protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
		super.onFocusChanged(focused, direction, previouslyFocusedRect);

		if (focused) {
		mPreviousValue = mValue;
		mValue = 0;
		mCount = 0;

		// Transfer current text to hint.
		setHint(getText());
		setText("");
		} else {
		if (mCount == 0) {
		// No digits were entered, revert to previous value.
		mValue = mPreviousValue;

		setText(getHint());
		setHint("");
		}

		// Ensure the committed value is within range.
		if (mValue < mMinValue) {
		mValue = mMinValue;
		}

		setValue(mValue);

		if (mListener != null) {
		mListener.onValueChanged(this, mValue, true, true);
		}
		}
		}

		/**
		* Sets the currently displayed value.
		* <p>
		* The specified {@code value} must be within the range specified by
		* {@link #setRange(int, int)} (e.g. between {@link #getRangeMinimum()}
		* and {@link #getRangeMaximum()}).
		*
		* @param value the value to display
		*/
		public final void setValue(int value) {
		if (mValue != value) {
		mValue = value;

		updateDisplayedValue();
		}
		}

		/**
		* Returns the currently displayed value.
		* <p>
		* If the value is currently being edited, returns the live value which may
		* not be within the range specified by {@link #setRange(int, int)}.
		*
		* @return the currently displayed value
		*/
		public final int getValue() {
		return mValue;
		}

		/**
		* Sets the valid range (inclusive).
		*
		* @param minValue the minimum valid value (inclusive)
		* @param maxValue the maximum valid value (inclusive)
		*/
		public final void setRange(int minValue, int maxValue) {
		if (mMinValue != minValue) {
		mMinValue = minValue;
		}

		if (mMaxValue != maxValue) {
		mMaxValue = maxValue;
		mMaxCount = 1 + (int) (Math.log(maxValue) / LOG_RADIX);

		updateMinimumWidth();
		updateDisplayedValue();
		}
		}

		/**
		* @return the minimum value value (inclusive)
		*/
		public final int getRangeMinimum() {
		return mMinValue;
		}

		/**
		* @return the maximum value value (inclusive)
		*/
		public final int getRangeMaximum() {
		return mMaxValue;
		}

		/**
		* Sets whether this view shows leading zeroes.
		* <p>
		* When leading zeroes are shown, the displayed value will be padded
		* with zeroes to the width of the maximum value as specified by
		* {@link #setRange(int, int)} (see also {@link #getRangeMaximum()}.
		* <p>
		* For example, with leading zeroes shown, a maximum of 99 and value of
		* 9 would display "09". A maximum of 100 and a value of 9 would display
		* "009". With leading zeroes hidden, both cases would show "9".
		*
		* @param showLeadingZeroes {@code true} to show leading zeroes,
		* {@code false} to hide them
		*/
		public final void setShowLeadingZeroes(boolean showLeadingZeroes) {
		if (mShowLeadingZeroes != showLeadingZeroes) {
		mShowLeadingZeroes = showLeadingZeroes;

		updateDisplayedValue();
		}
		}

		public final boolean getShowLeadingZeroes() {
		return mShowLeadingZeroes;
		}

		/**
		* Computes the display value and updates the text of the view.
		* <p>
		* This method should be called whenever the current value or display
		* properties (leading zeroes, max digits) change.
		*/
		private void updateDisplayedValue() {
		final String format;
		if (mShowLeadingZeroes) {
		format = "%0" + mMaxCount + "d";
		} else {
		format = "%d";
		}

		// Always use String.format() rather than Integer.toString()
		// to obtain correctly localized values.
		setText(String.format(format, mValue));
		}

		/**
		* Computes the minimum width in pixels required to display all possible
		* values and updates the minimum width of the view.
		* <p>
		* This method should be called whenever the maximum value changes.
		*/
		private void updateMinimumWidth() {
		final CharSequence previousText = getText();
		int maxWidth = 0;

		for (int i = 0; i < mMaxValue; i++) {
		setText(String.format("%0" + mMaxCount + "d", i));
		measure(MeasureSpec.UNSPECIFIED, MeasureSpec.UNSPECIFIED);

		final int width = getMeasuredWidth();
		if (width > maxWidth) {
		maxWidth = width;
		}
		}

		setText(previousText);
		setMinWidth(maxWidth);
		setMinimumWidth(maxWidth);
		}

		public final void setOnDigitEnteredListener(OnValueChangedListener listener) {
		mListener = listener;
		}

		public final OnValueChangedListener getOnDigitEnteredListener() {
		return mListener;
		}

		@Override
		public boolean onKeyDown(int keyCode, KeyEvent event) {
		return isKeyCodeNumeric(keyCode)
		\|\| (keyCode == KeyEvent.KEYCODE_DEL)
		\|\| super.onKeyDown(keyCode, event);
		}

		@Override
		public boolean onKeyMultiple(int keyCode, int repeatCount, KeyEvent event) {
		return isKeyCodeNumeric(keyCode)
		\|\| (keyCode == KeyEvent.KEYCODE_DEL)
		\|\| super.onKeyMultiple(keyCode, repeatCount, event);
		}

		@Override
		public boolean onKeyUp(int keyCode, KeyEvent event) {
		return handleKeyUp(keyCode)
		\|\| super.onKeyUp(keyCode, event);
		}

		private boolean handleKeyUp(int keyCode) {
		if (keyCode == KeyEvent.KEYCODE_DEL) {
		// Backspace removes the least-significant digit, if available.
		if (mCount > 0) {
		mValue /= RADIX;
		mCount--;
		}
		} else if (isKeyCodeNumeric(keyCode)) {
		if (mCount < mMaxCount) {
		final int keyValue = numericKeyCodeToInt(keyCode);
		final int newValue = mValue * RADIX + keyValue;
		if (newValue <= mMaxValue) {
		mValue = newValue;
		mCount++;
		}
		}
		} else {
		return false;
		}

		final String formattedValue;
		if (mCount > 0) {
		// If the user types 01, we should always show the leading 0 even if
		// getShowLeadingZeroes() is false. Preserve typed leading zeroes by
		// using the number of digits entered as the format width.
		formattedValue = String.format("%0" + mCount + "d", mValue);
		} else {
		formattedValue = "";
		}

		setText(formattedValue);

		if (mListener != null) {
		final boolean isValid = mValue >= mMinValue;
		final boolean isFinished = mCount >= mMaxCount \|\| mValue * RADIX > mMaxValue;
		mListener.onValueChanged(this, mValue, isValid, isFinished);
		}

		return true;
		}

		private static boolean isKeyCodeNumeric(int keyCode) {
		return keyCode == KeyEvent.KEYCODE_0 \|\| keyCode == KeyEvent.KEYCODE_1
		\|\| keyCode == KeyEvent.KEYCODE_2 \|\| keyCode == KeyEvent.KEYCODE_3
		\|\| keyCode == KeyEvent.KEYCODE_4 \|\| keyCode == KeyEvent.KEYCODE_5
		\|\| keyCode == KeyEvent.KEYCODE_6 \|\| keyCode == KeyEvent.KEYCODE_7
		\|\| keyCode == KeyEvent.KEYCODE_8 \|\| keyCode == KeyEvent.KEYCODE_9;
		}

		private static int numericKeyCodeToInt(int keyCode) {
		return keyCode - KeyEvent.KEYCODE_0;
		}

		public interface OnValueChangedListener {
		/**
		* Called when the value displayed by {@code view} changes.
		*
		* @param view the view whose value changed
		* @param value the new value
		* @param isValid {@code true} if the value is valid (e.g. within the
		* range specified by {@link #setRange(int, int)}),
		* {@code false} otherwise
		* @param isFinished {@code true} if the no more digits may be entered,
		* {@code false} if more digits may be entered
		*/
		void onValueChanged(NumericTextView view, int value, boolean isValid, boolean isFinished);
		}
		}

core/res/res/color/primary_text_secondary_when_activated_material_inverse.xml

+21 −1

Original line number	Diff line number	Diff line
		<?xml version="1.0" encoding="utf-8"?>
		<!--
		~ Copyright (C) 2015 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
		-->

		<selector xmlns:android="http://schemas.android.com/apk/res/android">
		<item
		android:state_enabled="false"
		android:color="?attr/textColorSecondaryInverse"
		android:alpha="?attr/disabledAlpha" />
		<item
		android:state_activated="true"
		android:color="?attr/textColorPrimaryInverse" />

core/res/res/drawable/time_picker_editable_background.xml

0 → 100644

+32 −0

Original line number	Diff line number	Diff line
		<?xml version="1.0" encoding="utf-8"?>
		<!--
		~ Copyright (C) 2015 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
		-->

		<selector xmlns:android="http://schemas.android.com/apk/res/android">
		<item android:state_focused="true">
		<layer-list>
		<item android:gravity="bottom"
		android:height="10dp">
		<shape android:shape="line"
		android:tint="?attr/textColorPrimaryInverse">
		<stroke android:color="@color/white"
		android:width="2dp" />
		</shape>
		</item>
		</layer-list>
		</item>
		<item android:drawable="@color/transparent" />
		</selector>