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