diff options
Diffstat (limited to 'java/src/com/android/inputmethod/latin')
6 files changed, 82 insertions, 31 deletions
diff --git a/java/src/com/android/inputmethod/latin/AutoCorrection.java b/java/src/com/android/inputmethod/latin/AutoCorrection.java index fc9771065..485ec511f 100644 --- a/java/src/com/android/inputmethod/latin/AutoCorrection.java +++ b/java/src/com/android/inputmethod/latin/AutoCorrection.java @@ -82,14 +82,16 @@ public class AutoCorrection { return false; } - public static boolean isValidWordForAutoCorrection( + public static boolean allowsToBeAutoCorrected( Map<String, Dictionary> dictionaries, CharSequence word, boolean ignoreCase) { - final Dictionary whiteList = dictionaries.get(Suggest.DICT_KEY_WHITELIST); + final WhitelistDictionary whitelistDictionary = + (WhitelistDictionary)dictionaries.get(Suggest.DICT_KEY_WHITELIST); // If "word" is in the whitelist dictionary, it should not be auto corrected. - if (whiteList != null && whiteList.isValidWord(word)) { - return false; + if (whitelistDictionary != null + && whitelistDictionary.shouldForciblyAutoCorrectFrom(word)) { + return true; } - return isValidWord(dictionaries, word, ignoreCase); + return !isValidWord(dictionaries, word, ignoreCase); } private static boolean hasAutoCorrectionForWhitelistedWord(CharSequence whiteListedWord) { @@ -100,8 +102,8 @@ public class AutoCorrection { WordComposer wordComposer, ArrayList<CharSequence> suggestions, CharSequence typedWord, int correctionMode) { if (TextUtils.isEmpty(typedWord)) return false; - boolean isValidWord = isValidWordForAutoCorrection(dictionaries, typedWord, false); - return wordComposer.size() > 1 && suggestions.size() > 0 && isValidWord + boolean allowsAutoCorrect = allowsToBeAutoCorrected(dictionaries, typedWord, false); + return wordComposer.size() > 1 && suggestions.size() > 0 && !allowsAutoCorrect && (correctionMode == Suggest.CORRECTION_FULL || correctionMode == Suggest.CORRECTION_FULL_BIGRAM); } diff --git a/java/src/com/android/inputmethod/latin/LatinIME.java b/java/src/com/android/inputmethod/latin/LatinIME.java index c5f336b3f..958092bc7 100644 --- a/java/src/com/android/inputmethod/latin/LatinIME.java +++ b/java/src/com/android/inputmethod/latin/LatinIME.java @@ -693,6 +693,12 @@ public class LatinIME extends InputMethodServiceCompatWrapper implements Keyboar return; } + // Forward this event to the accessibility utilities, if enabled. + final AccessibilityUtils accessUtils = AccessibilityUtils.getInstance(); + if (accessUtils.isTouchExplorationEnabled()) { + accessUtils.onStartInputViewInternal(attribute, restarting); + } + mSubtypeSwitcher.updateParametersOnStartInputView(); TextEntryState.reset(); @@ -1259,6 +1265,7 @@ public class LatinIME extends InputMethodServiceCompatWrapper implements Keyboar break; case Keyboard.CODE_CAPSLOCK: switcher.toggleCapsLock(); + vibrate(); break; case Keyboard.CODE_SHORTCUT: mSubtypeSwitcher.switchToShortcutIME(); @@ -1645,11 +1652,16 @@ public class LatinIME extends InputMethodServiceCompatWrapper implements Keyboar boolean autoCorrectionAvailable = !mInputTypeNoAutoCorrect && mSuggest.hasAutoCorrection(); final CharSequence typedWord = wordComposer.getTypedWord(); // Here, we want to promote a whitelisted word if exists. - final boolean typedWordValid = AutoCorrection.isValidWordForAutoCorrection( + // TODO: Change this scheme - a boolean is not enough. A whitelisted word may be "valid" + // but still autocorrected from - in the case the whitelist only capitalizes the word. + // The whitelist should be case-insensitive, so it's not possible to be consistent with + // a boolean flag. Right now this is handled with a slight hack in + // WhitelistDictionary#shouldForciblyAutoCorrectFrom. + final boolean allowsToBeAutoCorrected = AutoCorrection.allowsToBeAutoCorrected( mSuggest.getUnigramDictionaries(), typedWord, preferCapitalization()); if (mCorrectionMode == Suggest.CORRECTION_FULL || mCorrectionMode == Suggest.CORRECTION_FULL_BIGRAM) { - autoCorrectionAvailable |= typedWordValid; + autoCorrectionAvailable |= (!allowsToBeAutoCorrected); } // Don't auto-correct words with multiple capital letter autoCorrectionAvailable &= !wordComposer.isMostlyCaps(); @@ -1662,9 +1674,9 @@ public class LatinIME extends InputMethodServiceCompatWrapper implements Keyboar // need to clear the previous state when the user starts typing a word (i.e. typed word's // length == 1). if (typedWord != null) { - if (builder.size() > 1 || typedWord.length() == 1 || typedWordValid + if (builder.size() > 1 || typedWord.length() == 1 || (!allowsToBeAutoCorrected) || mSuggestionsView.isShowingAddToDictionaryHint()) { - builder.setTypedWordValid(typedWordValid).setHasMinimalSuggestion( + builder.setTypedWordValid(!allowsToBeAutoCorrected).setHasMinimalSuggestion( autoCorrectionAvailable); } else { SuggestedWords previousSuggestions = mSuggestionsView.getSuggestions(); diff --git a/java/src/com/android/inputmethod/latin/Suggest.java b/java/src/com/android/inputmethod/latin/Suggest.java index f6f55819d..caa5aac51 100644 --- a/java/src/com/android/inputmethod/latin/Suggest.java +++ b/java/src/com/android/inputmethod/latin/Suggest.java @@ -67,10 +67,10 @@ public class Suggest implements Dictionary.WordCallback { public static final int DIC_USER_UNIGRAM = 3; public static final int DIC_CONTACTS = 4; public static final int DIC_USER_BIGRAM = 5; + public static final int DIC_WHITELIST = 6; // If you add a type of dictionary, increment DIC_TYPE_LAST_ID // TODO: this value seems unused. Remove it? - public static final int DIC_TYPE_LAST_ID = 5; - + public static final int DIC_TYPE_LAST_ID = 6; public static final String DICT_KEY_MAIN = "main"; public static final String DICT_KEY_CONTACTS = "contacts"; // User dictionary, the system-managed one. @@ -360,7 +360,7 @@ public class Suggest implements Dictionary.WordCallback { final String typedWordString = typedWord == null ? null : typedWord.toString(); CharSequence whitelistedWord = capitalizeWord(mIsAllUpperCase, mIsFirstCharCapitalized, - mWhiteListDictionary.getWhiteListedWord(typedWordString)); + mWhiteListDictionary.getWhitelistedWord(typedWordString)); mAutoCorrection.updateAutoCorrectionStatus(mUnigramDictionaries, wordComposer, mSuggestions, mScores, typedWord, mAutoCorrectionThreshold, mCorrectionMode, diff --git a/java/src/com/android/inputmethod/latin/SuggestedWords.java b/java/src/com/android/inputmethod/latin/SuggestedWords.java index b177d144a..005db36bd 100644 --- a/java/src/com/android/inputmethod/latin/SuggestedWords.java +++ b/java/src/com/android/inputmethod/latin/SuggestedWords.java @@ -175,6 +175,19 @@ public class SuggestedWords { public CharSequence getWord(int pos) { return mWords.get(pos); } + + public String toString() { + // Pretty-print method to help debug + final StringBuilder sb = new StringBuilder("StringBuilder: mTypedWordValid = " + + mTypedWordValid + " ; mHasMinimalSuggestion = " + mHasMinimalSuggestion + + " ; mIsPunctuationSuggestions = " + mIsPunctuationSuggestions + + " --- "); + for (CharSequence s : mWords) { + sb.append(s); + sb.append(" ; "); + } + return sb.toString(); + } } public static class SuggestedWordInfo { diff --git a/java/src/com/android/inputmethod/latin/WhitelistDictionary.java b/java/src/com/android/inputmethod/latin/WhitelistDictionary.java index 93474b654..8f349ce6f 100644 --- a/java/src/com/android/inputmethod/latin/WhitelistDictionary.java +++ b/java/src/com/android/inputmethod/latin/WhitelistDictionary.java @@ -27,7 +27,7 @@ import com.android.inputmethod.keyboard.ProximityInfo; import java.util.HashMap; import java.util.Locale; -public class WhitelistDictionary extends Dictionary { +public class WhitelistDictionary extends ExpandableDictionary { private static final boolean DBG = LatinImeLogger.sDBG; private static final String TAG = WhitelistDictionary.class.getSimpleName(); @@ -35,7 +35,9 @@ public class WhitelistDictionary extends Dictionary { private final HashMap<String, Pair<Integer, String>> mWhitelistWords = new HashMap<String, Pair<Integer, String>>(); + // TODO: Conform to the async load contact of ExpandableDictionary public WhitelistDictionary(final Context context, final Locale locale) { + super(context, Suggest.DIC_WHITELIST); final Resources res = context.getResources(); final Locale previousLocale = LocaleUtils.setSystemLocale(res, locale); if (context != null) { @@ -61,6 +63,7 @@ public class WhitelistDictionary extends Dictionary { if (before != null && after != null) { mWhitelistWords.put( before.toLowerCase(), new Pair<Integer, String>(score, after)); + addWord(after, score); } } } catch (NumberFormatException e) { @@ -70,27 +73,34 @@ public class WhitelistDictionary extends Dictionary { } } - public String getWhiteListedWord(String before) { + public String getWhitelistedWord(String before) { if (before == null) return null; final String lowerCaseBefore = before.toLowerCase(); if(mWhitelistWords.containsKey(lowerCaseBefore)) { if (DBG) { - Log.d(TAG, "--- found whiteListedWord: " + lowerCaseBefore); + Log.d(TAG, "--- found whitelistedWord: " + lowerCaseBefore); } return mWhitelistWords.get(lowerCaseBefore).second; } return null; } - // Not used for WhitelistDictionary. We use getWhitelistedWord() in Suggest.java instead - @Override - public void getWords(final WordComposer composer, final WordCallback callback, - final ProximityInfo proximityInfo) { - } - - @Override - public boolean isValidWord(CharSequence word) { + // See LatinIME#updateSuggestions. This breaks in the (queer) case that the whitelist + // lists that word a should autocorrect to word b, and word c would autocorrect to + // an upper-cased version of a. In this case, the way this return value is used would + // remove the first candidate when the user typed the upper-cased version of A. + // Example : abc -> def and xyz -> Abc + // A user typing Abc would experience it being autocorrected to something else (not + // necessarily def). + // There is no such combination in the whitelist at the time and there probably won't + // ever be - it doesn't make sense. But still. + public boolean shouldForciblyAutoCorrectFrom(CharSequence word) { if (TextUtils.isEmpty(word)) return false; - return !TextUtils.isEmpty(getWhiteListedWord(word.toString())); + final String correction = getWhitelistedWord(word.toString()); + if (TextUtils.isEmpty(correction)) return false; + return !correction.equals(word); } + + // Leave implementation of getWords and isValidWord to the superclass. + // The words have been added to the ExpandableDictionary with addWord() inside initWordlist. } diff --git a/java/src/com/android/inputmethod/latin/spellcheck/AndroidSpellCheckerService.java b/java/src/com/android/inputmethod/latin/spellcheck/AndroidSpellCheckerService.java index 4d569b808..f9e6a5e68 100644 --- a/java/src/com/android/inputmethod/latin/spellcheck/AndroidSpellCheckerService.java +++ b/java/src/com/android/inputmethod/latin/spellcheck/AndroidSpellCheckerService.java @@ -37,6 +37,7 @@ import com.android.inputmethod.latin.LocaleUtils; import com.android.inputmethod.latin.R; import com.android.inputmethod.latin.SynchronouslyLoadedUserDictionary; import com.android.inputmethod.latin.Utils; +import com.android.inputmethod.latin.WhitelistDictionary; import com.android.inputmethod.latin.WordComposer; import java.util.ArrayList; @@ -79,6 +80,8 @@ public class AndroidSpellCheckerService extends SpellCheckerService { Collections.synchronizedMap(new TreeMap<String, DictionaryPool>()); private Map<String, Dictionary> mUserDictionaries = Collections.synchronizedMap(new TreeMap<String, Dictionary>()); + private Map<String, Dictionary> mWhitelistDictionaries = + Collections.synchronizedMap(new TreeMap<String, Dictionary>()); // The threshold for a candidate to be offered as a suggestion. private double mSuggestionThreshold; @@ -253,12 +256,17 @@ public class AndroidSpellCheckerService extends SpellCheckerService { mDictionaryPools = Collections.synchronizedMap(new TreeMap<String, DictionaryPool>()); final Map<String, Dictionary> oldUserDictionaries = mUserDictionaries; mUserDictionaries = Collections.synchronizedMap(new TreeMap<String, Dictionary>()); + final Map<String, Dictionary> oldWhitelistDictionaries = mWhitelistDictionaries; + mWhitelistDictionaries = Collections.synchronizedMap(new TreeMap<String, Dictionary>()); for (DictionaryPool pool : oldPools.values()) { pool.close(); } for (Dictionary dict : oldUserDictionaries.values()) { dict.close(); } + for (Dictionary dict : oldWhitelistDictionaries.values()) { + dict.close(); + } return false; } @@ -280,12 +288,18 @@ public class AndroidSpellCheckerService extends SpellCheckerService { DictionaryFactory.createDictionaryFromManager(this, locale, fallbackResourceId, USE_FULL_EDIT_DISTANCE_FLAG_ARRAY); final String localeStr = locale.toString(); - Dictionary userDict = mUserDictionaries.get(localeStr); - if (null == userDict) { - userDict = new SynchronouslyLoadedUserDictionary(this, localeStr, true); - mUserDictionaries.put(localeStr, userDict); + Dictionary userDictionary = mUserDictionaries.get(localeStr); + if (null == userDictionary) { + userDictionary = new SynchronouslyLoadedUserDictionary(this, localeStr, true); + mUserDictionaries.put(localeStr, userDictionary); + } + dictionaryCollection.addDictionary(userDictionary); + Dictionary whitelistDictionary = mWhitelistDictionaries.get(localeStr); + if (null == whitelistDictionary) { + whitelistDictionary = new WhitelistDictionary(this, locale); + mWhitelistDictionaries.put(localeStr, whitelistDictionary); } - dictionaryCollection.addDictionary(userDict); + dictionaryCollection.addDictionary(whitelistDictionary); return new DictAndProximity(dictionaryCollection, proximityInfo); } |