/*
|
* Copyright (C) 2006 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.text.method;
|
|
import android.annotation.NonNull;
|
import android.annotation.Nullable;
|
import android.icu.lang.UCharacter;
|
import android.icu.lang.UProperty;
|
import android.icu.text.DecimalFormatSymbols;
|
import android.text.InputType;
|
import android.text.SpannableStringBuilder;
|
import android.text.Spanned;
|
import android.view.KeyEvent;
|
|
import com.android.internal.annotations.GuardedBy;
|
import com.android.internal.util.ArrayUtils;
|
|
import java.util.HashMap;
|
import java.util.LinkedHashSet;
|
import java.util.Locale;
|
|
/**
|
* For digits-only text entry
|
* <p></p>
|
* As for all implementations of {@link KeyListener}, this class is only concerned
|
* with hardware keyboards. Software input methods have no obligation to trigger
|
* the methods in this class.
|
*/
|
public class DigitsKeyListener extends NumberKeyListener
|
{
|
private char[] mAccepted;
|
private boolean mNeedsAdvancedInput;
|
private final boolean mSign;
|
private final boolean mDecimal;
|
private final boolean mStringMode;
|
@Nullable
|
private final Locale mLocale;
|
|
private static final String DEFAULT_DECIMAL_POINT_CHARS = ".";
|
private static final String DEFAULT_SIGN_CHARS = "-+";
|
|
private static final char HYPHEN_MINUS = '-';
|
// Various locales use this as minus sign
|
private static final char MINUS_SIGN = '\u2212';
|
// Slovenian uses this as minus sign (a bug?): http://unicode.org/cldr/trac/ticket/10050
|
private static final char EN_DASH = '\u2013';
|
|
private String mDecimalPointChars = DEFAULT_DECIMAL_POINT_CHARS;
|
private String mSignChars = DEFAULT_SIGN_CHARS;
|
|
private static final int SIGN = 1;
|
private static final int DECIMAL = 2;
|
|
@Override
|
protected char[] getAcceptedChars() {
|
return mAccepted;
|
}
|
|
/**
|
* The characters that are used in compatibility mode.
|
*
|
* @see KeyEvent#getMatch
|
* @see #getAcceptedChars
|
*/
|
private static final char[][] COMPATIBILITY_CHARACTERS = {
|
{ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' },
|
{ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '+' },
|
{ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.' },
|
{ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '+', '.' },
|
};
|
|
private boolean isSignChar(final char c) {
|
return mSignChars.indexOf(c) != -1;
|
}
|
|
private boolean isDecimalPointChar(final char c) {
|
return mDecimalPointChars.indexOf(c) != -1;
|
}
|
|
/**
|
* Allocates a DigitsKeyListener that accepts the ASCII digits 0 through 9.
|
*
|
* @deprecated Use {@link #DigitsKeyListener(Locale)} instead.
|
*/
|
@Deprecated
|
public DigitsKeyListener() {
|
this(null, false, false);
|
}
|
|
/**
|
* Allocates a DigitsKeyListener that accepts the ASCII digits 0 through 9, plus the ASCII plus
|
* or minus sign (only at the beginning) and/or the ASCII period ('.') as the decimal point
|
* (only one per field) if specified.
|
*
|
* @deprecated Use {@link #DigitsKeyListener(Locale, boolean, boolean)} instead.
|
*/
|
@Deprecated
|
public DigitsKeyListener(boolean sign, boolean decimal) {
|
this(null, sign, decimal);
|
}
|
|
public DigitsKeyListener(@Nullable Locale locale) {
|
this(locale, false, false);
|
}
|
|
private void setToCompat() {
|
mDecimalPointChars = DEFAULT_DECIMAL_POINT_CHARS;
|
mSignChars = DEFAULT_SIGN_CHARS;
|
final int kind = (mSign ? SIGN : 0) | (mDecimal ? DECIMAL : 0);
|
mAccepted = COMPATIBILITY_CHARACTERS[kind];
|
mNeedsAdvancedInput = false;
|
}
|
|
private void calculateNeedForAdvancedInput() {
|
final int kind = (mSign ? SIGN : 0) | (mDecimal ? DECIMAL : 0);
|
mNeedsAdvancedInput = !ArrayUtils.containsAll(COMPATIBILITY_CHARACTERS[kind], mAccepted);
|
}
|
|
// Takes a sign string and strips off its bidi controls, if any.
|
@NonNull
|
private static String stripBidiControls(@NonNull String sign) {
|
// For the sake of simplicity, we operate on code units, since all bidi controls are
|
// in the BMP. We also expect the string to be very short (almost always 1 character), so we
|
// don't need to use StringBuilder.
|
String result = "";
|
for (int i = 0; i < sign.length(); i++) {
|
final char c = sign.charAt(i);
|
if (!UCharacter.hasBinaryProperty(c, UProperty.BIDI_CONTROL)) {
|
if (result.isEmpty()) {
|
result = String.valueOf(c);
|
} else {
|
// This should happen very rarely, only if we have a multi-character sign,
|
// or a sign outside BMP.
|
result += c;
|
}
|
}
|
}
|
return result;
|
}
|
|
public DigitsKeyListener(@Nullable Locale locale, boolean sign, boolean decimal) {
|
mSign = sign;
|
mDecimal = decimal;
|
mStringMode = false;
|
mLocale = locale;
|
if (locale == null) {
|
setToCompat();
|
return;
|
}
|
LinkedHashSet<Character> chars = new LinkedHashSet<>();
|
final boolean success = NumberKeyListener.addDigits(chars, locale);
|
if (!success) {
|
setToCompat();
|
return;
|
}
|
if (sign || decimal) {
|
final DecimalFormatSymbols symbols = DecimalFormatSymbols.getInstance(locale);
|
if (sign) {
|
final String minusString = stripBidiControls(symbols.getMinusSignString());
|
final String plusString = stripBidiControls(symbols.getPlusSignString());
|
if (minusString.length() > 1 || plusString.length() > 1) {
|
// non-BMP and multi-character signs are not supported.
|
setToCompat();
|
return;
|
}
|
final char minus = minusString.charAt(0);
|
final char plus = plusString.charAt(0);
|
chars.add(Character.valueOf(minus));
|
chars.add(Character.valueOf(plus));
|
mSignChars = "" + minus + plus;
|
|
if (minus == MINUS_SIGN || minus == EN_DASH) {
|
// If the minus sign is U+2212 MINUS SIGN or U+2013 EN DASH, we also need to
|
// accept the ASCII hyphen-minus.
|
chars.add(HYPHEN_MINUS);
|
mSignChars += HYPHEN_MINUS;
|
}
|
}
|
if (decimal) {
|
final String separatorString = symbols.getDecimalSeparatorString();
|
if (separatorString.length() > 1) {
|
// non-BMP and multi-character decimal separators are not supported.
|
setToCompat();
|
return;
|
}
|
final Character separatorChar = Character.valueOf(separatorString.charAt(0));
|
chars.add(separatorChar);
|
mDecimalPointChars = separatorChar.toString();
|
}
|
}
|
mAccepted = NumberKeyListener.collectionToArray(chars);
|
calculateNeedForAdvancedInput();
|
}
|
|
private DigitsKeyListener(@NonNull final String accepted) {
|
mSign = false;
|
mDecimal = false;
|
mStringMode = true;
|
mLocale = null;
|
mAccepted = new char[accepted.length()];
|
accepted.getChars(0, accepted.length(), mAccepted, 0);
|
// Theoretically we may need advanced input, but for backward compatibility, we don't change
|
// the input type.
|
mNeedsAdvancedInput = false;
|
}
|
|
/**
|
* Returns a DigitsKeyListener that accepts the ASCII digits 0 through 9.
|
*
|
* @deprecated Use {@link #getInstance(Locale)} instead.
|
*/
|
@Deprecated
|
@NonNull
|
public static DigitsKeyListener getInstance() {
|
return getInstance(false, false);
|
}
|
|
/**
|
* Returns a DigitsKeyListener that accepts the ASCII digits 0 through 9, plus the ASCII plus
|
* or minus sign (only at the beginning) and/or the ASCII period ('.') as the decimal point
|
* (only one per field) if specified.
|
*
|
* @deprecated Use {@link #getInstance(Locale, boolean, boolean)} instead.
|
*/
|
@Deprecated
|
@NonNull
|
public static DigitsKeyListener getInstance(boolean sign, boolean decimal) {
|
return getInstance(null, sign, decimal);
|
}
|
|
/**
|
* Returns a DigitsKeyListener that accepts the locale-appropriate digits.
|
*/
|
@NonNull
|
public static DigitsKeyListener getInstance(@Nullable Locale locale) {
|
return getInstance(locale, false, false);
|
}
|
|
private static final Object sLocaleCacheLock = new Object();
|
@GuardedBy("sLocaleCacheLock")
|
private static final HashMap<Locale, DigitsKeyListener[]> sLocaleInstanceCache =
|
new HashMap<>();
|
|
/**
|
* Returns a DigitsKeyListener that accepts the locale-appropriate digits, plus the
|
* locale-appropriate plus or minus sign (only at the beginning) and/or the locale-appropriate
|
* decimal separator (only one per field) if specified.
|
*/
|
@NonNull
|
public static DigitsKeyListener getInstance(
|
@Nullable Locale locale, boolean sign, boolean decimal) {
|
final int kind = (sign ? SIGN : 0) | (decimal ? DECIMAL : 0);
|
synchronized (sLocaleCacheLock) {
|
DigitsKeyListener[] cachedValue = sLocaleInstanceCache.get(locale);
|
if (cachedValue != null && cachedValue[kind] != null) {
|
return cachedValue[kind];
|
}
|
if (cachedValue == null) {
|
cachedValue = new DigitsKeyListener[4];
|
sLocaleInstanceCache.put(locale, cachedValue);
|
}
|
return cachedValue[kind] = new DigitsKeyListener(locale, sign, decimal);
|
}
|
}
|
|
private static final Object sStringCacheLock = new Object();
|
@GuardedBy("sStringCacheLock")
|
private static final HashMap<String, DigitsKeyListener> sStringInstanceCache = new HashMap<>();
|
|
/**
|
* Returns a DigitsKeyListener that accepts only the characters
|
* that appear in the specified String. Note that not all characters
|
* may be available on every keyboard.
|
*/
|
@NonNull
|
public static DigitsKeyListener getInstance(@NonNull String accepted) {
|
DigitsKeyListener result;
|
synchronized (sStringCacheLock) {
|
result = sStringInstanceCache.get(accepted);
|
if (result == null) {
|
result = new DigitsKeyListener(accepted);
|
sStringInstanceCache.put(accepted, result);
|
}
|
}
|
return result;
|
}
|
|
/**
|
* Returns a DigitsKeyListener based on an the settings of a existing DigitsKeyListener, with
|
* the locale modified.
|
*
|
* @hide
|
*/
|
@NonNull
|
public static DigitsKeyListener getInstance(
|
@Nullable Locale locale,
|
@NonNull DigitsKeyListener listener) {
|
if (listener.mStringMode) {
|
return listener; // string-mode DigitsKeyListeners have no locale.
|
} else {
|
return getInstance(locale, listener.mSign, listener.mDecimal);
|
}
|
}
|
|
/**
|
* Returns the input type for the listener.
|
*/
|
public int getInputType() {
|
int contentType;
|
if (mNeedsAdvancedInput) {
|
contentType = InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_NORMAL;
|
} else {
|
contentType = InputType.TYPE_CLASS_NUMBER;
|
if (mSign) {
|
contentType |= InputType.TYPE_NUMBER_FLAG_SIGNED;
|
}
|
if (mDecimal) {
|
contentType |= InputType.TYPE_NUMBER_FLAG_DECIMAL;
|
}
|
}
|
return contentType;
|
}
|
|
@Override
|
public CharSequence filter(CharSequence source, int start, int end,
|
Spanned dest, int dstart, int dend) {
|
CharSequence out = super.filter(source, start, end, dest, dstart, dend);
|
|
if (mSign == false && mDecimal == false) {
|
return out;
|
}
|
|
if (out != null) {
|
source = out;
|
start = 0;
|
end = out.length();
|
}
|
|
int sign = -1;
|
int decimal = -1;
|
int dlen = dest.length();
|
|
/*
|
* Find out if the existing text has a sign or decimal point characters.
|
*/
|
|
for (int i = 0; i < dstart; i++) {
|
char c = dest.charAt(i);
|
|
if (isSignChar(c)) {
|
sign = i;
|
} else if (isDecimalPointChar(c)) {
|
decimal = i;
|
}
|
}
|
for (int i = dend; i < dlen; i++) {
|
char c = dest.charAt(i);
|
|
if (isSignChar(c)) {
|
return ""; // Nothing can be inserted in front of a sign character.
|
} else if (isDecimalPointChar(c)) {
|
decimal = i;
|
}
|
}
|
|
/*
|
* If it does, we must strip them out from the source.
|
* In addition, a sign character must be the very first character,
|
* and nothing can be inserted before an existing sign character.
|
* Go in reverse order so the offsets are stable.
|
*/
|
|
SpannableStringBuilder stripped = null;
|
|
for (int i = end - 1; i >= start; i--) {
|
char c = source.charAt(i);
|
boolean strip = false;
|
|
if (isSignChar(c)) {
|
if (i != start || dstart != 0) {
|
strip = true;
|
} else if (sign >= 0) {
|
strip = true;
|
} else {
|
sign = i;
|
}
|
} else if (isDecimalPointChar(c)) {
|
if (decimal >= 0) {
|
strip = true;
|
} else {
|
decimal = i;
|
}
|
}
|
|
if (strip) {
|
if (end == start + 1) {
|
return ""; // Only one character, and it was stripped.
|
}
|
|
if (stripped == null) {
|
stripped = new SpannableStringBuilder(source, start, end);
|
}
|
|
stripped.delete(i - start, i + 1 - start);
|
}
|
}
|
|
if (stripped != null) {
|
return stripped;
|
} else if (out != null) {
|
return out;
|
} else {
|
return null;
|
}
|
}
|
}
|
