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