| /* |
| * 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.text.DecimalFormatSymbols; |
| import android.text.Editable; |
| import android.text.InputFilter; |
| import android.text.Selection; |
| import android.text.Spannable; |
| import android.text.SpannableStringBuilder; |
| import android.text.Spanned; |
| import android.text.format.DateFormat; |
| import android.view.KeyEvent; |
| import android.view.View; |
| |
| import libcore.icu.LocaleData; |
| |
| import java.util.Collection; |
| import java.util.Locale; |
| |
| /** |
| * For numeric 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 abstract class NumberKeyListener extends BaseKeyListener |
| implements InputFilter |
| { |
| /** |
| * You can say which characters you can accept. |
| */ |
| @NonNull |
| protected abstract char[] getAcceptedChars(); |
| |
| protected int lookup(KeyEvent event, Spannable content) { |
| return event.getMatch(getAcceptedChars(), getMetaState(content, event)); |
| } |
| |
| public CharSequence filter(CharSequence source, int start, int end, |
| Spanned dest, int dstart, int dend) { |
| char[] accept = getAcceptedChars(); |
| boolean filter = false; |
| |
| int i; |
| for (i = start; i < end; i++) { |
| if (!ok(accept, source.charAt(i))) { |
| break; |
| } |
| } |
| |
| if (i == end) { |
| // It was all OK. |
| return null; |
| } |
| |
| if (end - start == 1) { |
| // It was not OK, and there is only one char, so nothing remains. |
| return ""; |
| } |
| |
| SpannableStringBuilder filtered = |
| new SpannableStringBuilder(source, start, end); |
| i -= start; |
| end -= start; |
| |
| int len = end - start; |
| // Only count down to i because the chars before that were all OK. |
| for (int j = end - 1; j >= i; j--) { |
| if (!ok(accept, source.charAt(j))) { |
| filtered.delete(j, j + 1); |
| } |
| } |
| |
| return filtered; |
| } |
| |
| protected static boolean ok(char[] accept, char c) { |
| for (int i = accept.length - 1; i >= 0; i--) { |
| if (accept[i] == c) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| @Override |
| public boolean onKeyDown(View view, Editable content, |
| int keyCode, KeyEvent event) { |
| int selStart, selEnd; |
| |
| { |
| int a = Selection.getSelectionStart(content); |
| int b = Selection.getSelectionEnd(content); |
| |
| selStart = Math.min(a, b); |
| selEnd = Math.max(a, b); |
| } |
| |
| if (selStart < 0 || selEnd < 0) { |
| selStart = selEnd = 0; |
| Selection.setSelection(content, 0); |
| } |
| |
| int i = event != null ? lookup(event, content) : 0; |
| int repeatCount = event != null ? event.getRepeatCount() : 0; |
| if (repeatCount == 0) { |
| if (i != 0) { |
| if (selStart != selEnd) { |
| Selection.setSelection(content, selEnd); |
| } |
| |
| content.replace(selStart, selEnd, String.valueOf((char) i)); |
| |
| adjustMetaAfterKeypress(content); |
| return true; |
| } |
| } else if (i == '0' && repeatCount == 1) { |
| // Pretty hackish, it replaces the 0 with the + |
| |
| if (selStart == selEnd && selEnd > 0 && |
| content.charAt(selStart - 1) == '0') { |
| content.replace(selStart - 1, selEnd, String.valueOf('+')); |
| adjustMetaAfterKeypress(content); |
| return true; |
| } |
| } |
| |
| adjustMetaAfterKeypress(content); |
| return super.onKeyDown(view, content, keyCode, event); |
| } |
| |
| /* package */ |
| @Nullable |
| static boolean addDigits(@NonNull Collection<Character> collection, @Nullable Locale locale) { |
| if (locale == null) { |
| return false; |
| } |
| final String[] digits = DecimalFormatSymbols.getInstance(locale).getDigitStrings(); |
| for (int i = 0; i < 10; i++) { |
| if (digits[i].length() > 1) { // multi-codeunit digits. Not supported. |
| return false; |
| } |
| collection.add(Character.valueOf(digits[i].charAt(0))); |
| } |
| return true; |
| } |
| |
| // From http://unicode.org/reports/tr35/tr35-dates.html#Date_Format_Patterns |
| private static final String DATE_TIME_FORMAT_SYMBOLS = |
| "GyYuUrQqMLlwWdDFgEecabBhHKkjJCmsSAzZOvVXx"; |
| private static final char SINGLE_QUOTE = '\''; |
| |
| /* package */ |
| static boolean addFormatCharsFromSkeleton( |
| @NonNull Collection<Character> collection, @Nullable Locale locale, |
| @NonNull String skeleton, @NonNull String symbolsToIgnore) { |
| if (locale == null) { |
| return false; |
| } |
| final String pattern = DateFormat.getBestDateTimePattern(locale, skeleton); |
| boolean outsideQuotes = true; |
| for (int i = 0; i < pattern.length(); i++) { |
| final char ch = pattern.charAt(i); |
| if (Character.isSurrogate(ch)) { // characters outside BMP are not supported. |
| return false; |
| } else if (ch == SINGLE_QUOTE) { |
| outsideQuotes = !outsideQuotes; |
| // Single quote characters should be considered if and only if they follow |
| // another single quote. |
| if (i == 0 || pattern.charAt(i - 1) != SINGLE_QUOTE) { |
| continue; |
| } |
| } |
| |
| if (outsideQuotes) { |
| if (symbolsToIgnore.indexOf(ch) != -1) { |
| // Skip expected pattern characters. |
| continue; |
| } else if (DATE_TIME_FORMAT_SYMBOLS.indexOf(ch) != -1) { |
| // An unexpected symbols is seen. We've failed. |
| return false; |
| } |
| } |
| // If we are here, we are either inside quotes, or we have seen a non-pattern |
| // character outside quotes. So ch is a valid character in a date. |
| collection.add(Character.valueOf(ch)); |
| } |
| return true; |
| } |
| |
| /* package */ |
| static boolean addFormatCharsFromSkeletons( |
| @NonNull Collection<Character> collection, @Nullable Locale locale, |
| @NonNull String[] skeletons, @NonNull String symbolsToIgnore) { |
| for (int i = 0; i < skeletons.length; i++) { |
| final boolean success = addFormatCharsFromSkeleton( |
| collection, locale, skeletons[i], symbolsToIgnore); |
| if (!success) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| |
| /* package */ |
| static boolean addAmPmChars(@NonNull Collection<Character> collection, |
| @Nullable Locale locale) { |
| if (locale == null) { |
| return false; |
| } |
| final String[] amPm = LocaleData.get(locale).amPm; |
| for (int i = 0; i < amPm.length; i++) { |
| for (int j = 0; j < amPm[i].length(); j++) { |
| final char ch = amPm[i].charAt(j); |
| if (Character.isBmpCodePoint(ch)) { |
| collection.add(Character.valueOf(ch)); |
| } else { // We don't support non-BMP characters. |
| return false; |
| } |
| } |
| } |
| return true; |
| } |
| |
| /* package */ |
| @NonNull |
| static char[] collectionToArray(@NonNull Collection<Character> chars) { |
| final char[] result = new char[chars.size()]; |
| int i = 0; |
| for (Character ch : chars) { |
| result[i++] = ch; |
| } |
| return result; |
| } |
| } |