core/java/android/text/method/DigitsKeyListener.java - platform/frameworks/base - Git at Google

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