/*
* 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);
}
}