https://source.android.com/ 
/*
 * 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.

 Clients of this view should never call TextView.setText(CharSequence) or TextView.setHint(CharSequence) directly. Instead, they should call setValue(int) to modify the currently displayed value. 
/**
 * 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. 
/** 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. 
/** Number of digits entered during editing mode. */
    private int mCount;

    
Used to restore the value after an aborted edit. 
/** 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.

 The specified value must be within the range specified by setRange(int, int) (e.g. between getRangeMinimum() and getRangeMaximum()). 
Params:
  • value – the value to display
/**
     * 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.

 If the value is currently being edited, returns the live value which may not be within the range specified by setRange(int, int). 
Returns:the currently displayed value
/**
     * 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).

Params:
  • minValue – the minimum valid value (inclusive)
  • maxValue – the maximum valid value (inclusive)
/**
     * 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();
        }
    }

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

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

    
Sets whether this view shows leading zeroes.

 When leading zeroes are shown, the displayed value will be padded with zeroes to the width of the maximum value as specified by setRange(int, int) (see also getRangeMaximum(). 

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".

Params:
  • showLeadingZeroes – true to show leading zeroes, false to hide them
/**
     * 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.


This method should be called whenever the current value or display
properties (leading zeroes, max digits) change.

/**
     * 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.


This method should be called whenever the maximum value changes.

/**
     * 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 view changes. 
Params:
  • view – the view whose value changed
  • value – the new value
  • isValid – true if the value is valid (e.g. within the range specified by NumericTextView.setRange(int, int)), false otherwise
  • isFinished – true if the no more digits may be entered, false if more digits may be entered
/**
         * 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);
    }
}