am fe5364c8: Cleanup : remove old recorrection code

* commit 'fe5364c825058f6c34c0f42135a5520b77525a28':
  Cleanup : remove old recorrection code

java/src/com/android/inputmethod/deprecated/recorrection/Recorrection.java

@@ -1,287 +0,0 @@
-/*
- * Copyright (C) 2011 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 com.android.inputmethod.deprecated.recorrection;
-
-import android.content.SharedPreferences;
-import android.content.res.Resources;
-import android.text.TextUtils;
-import android.view.inputmethod.ExtractedText;
-import android.view.inputmethod.ExtractedTextRequest;
-import android.view.inputmethod.InputConnection;
-
-import com.android.inputmethod.compat.InputConnectionCompatUtils;
-import com.android.inputmethod.compat.SuggestionSpanUtils;
-import com.android.inputmethod.deprecated.VoiceProxy;
-import com.android.inputmethod.keyboard.KeyboardSwitcher;
-import com.android.inputmethod.latin.AutoCorrection;
-import com.android.inputmethod.latin.EditingUtils;
-import com.android.inputmethod.latin.LatinIME;
-import com.android.inputmethod.latin.R;
-import com.android.inputmethod.latin.Settings;
-import com.android.inputmethod.latin.Suggest;
-import com.android.inputmethod.latin.SuggestedWords;
-import com.android.inputmethod.latin.SuggestionsView;
-import com.android.inputmethod.latin.TextEntryState;
-import com.android.inputmethod.latin.WordComposer;
-
-import java.util.ArrayList;
-
-/**
- * Manager of re-correction functionalities
- */
-public class Recorrection implements SharedPreferences.OnSharedPreferenceChangeListener {
-    private static final Recorrection sInstance = new Recorrection();
-
-    private LatinIME mService;
-    private boolean mRecorrectionEnabled = false;
-    private final ArrayList<RecorrectionSuggestionEntries> mRecorrectionSuggestionsList =
-            new ArrayList<RecorrectionSuggestionEntries>();
-
-    public static Recorrection getInstance() {
-        return sInstance;
-    }
-
-    public static void init(LatinIME context, SharedPreferences prefs) {
-        if (context == null || prefs == null) {
-            return;
-        }
-        sInstance.initInternal(context, prefs);
-    }
-
-    private Recorrection() {
-    }
-
-    public boolean isRecorrectionEnabled() {
-        return mRecorrectionEnabled;
-    }
-
-    private void initInternal(LatinIME context, SharedPreferences prefs) {
-        if (SuggestionSpanUtils.SUGGESTION_SPAN_IS_SUPPORTED) {
-            mRecorrectionEnabled = false;
-            return;
-        }
-        updateRecorrectionEnabled(context.getResources(), prefs);
-        mService = context;
-        prefs.registerOnSharedPreferenceChangeListener(this);
-    }
-
-    public void checkRecorrectionOnStart() {
-        if (SuggestionSpanUtils.SUGGESTION_SPAN_IS_SUPPORTED || !mRecorrectionEnabled) return;
-
-        final InputConnection ic = mService.getCurrentInputConnection();
-        if (ic == null) return;
-        // There could be a pending composing span.  Clean it up first.
-        ic.finishComposingText();
-
-        if (mService.isShowingSuggestionsStrip() && mService.isSuggestionsRequested()) {
-            // First get the cursor position. This is required by setOldSuggestions(), so that
-            // it can pass the correct range to setComposingRegion(). At this point, we don't
-            // have valid values for mLastSelectionStart/End because onUpdateSelection() has
-            // not been called yet.
-            ExtractedTextRequest etr = new ExtractedTextRequest();
-            etr.token = 0; // anything is fine here
-            ExtractedText et = ic.getExtractedText(etr, 0);
-            if (et == null) return;
-            mService.setLastSelection(
-                    et.startOffset + et.selectionStart, et.startOffset + et.selectionEnd);
-
-            // Then look for possible corrections in a delayed fashion
-            if (!TextUtils.isEmpty(et.text) && mService.isCursorTouchingWord()) {
-                mService.mHandler.postUpdateOldSuggestions();
-            }
-        }
-    }
-
-    public void updateRecorrectionSelection(KeyboardSwitcher keyboardSwitcher,
-            SuggestionsView suggestionsView, int candidatesStart, int candidatesEnd,
-            int newSelStart, int newSelEnd, int oldSelStart, int lastSelectionStart,
-            int lastSelectionEnd, boolean hasUncommittedTypedChars) {
-        if (SuggestionSpanUtils.SUGGESTION_SPAN_IS_SUPPORTED || !mRecorrectionEnabled) return;
-        if (!mService.isShowingSuggestionsStrip()) return;
-        if (!keyboardSwitcher.isInputViewShown()) return;
-        if (!mService.isSuggestionsRequested()) return;
-        // Don't look for corrections if the keyboard is not visible
-        // Check if we should go in or out of correction mode.
-        if ((candidatesStart == candidatesEnd || newSelStart != oldSelStart || TextEntryState
-                .isRecorrecting())
-                && (newSelStart < newSelEnd - 1 || !hasUncommittedTypedChars)) {
-            if (mService.isCursorTouchingWord() || lastSelectionStart < lastSelectionEnd) {
-                mService.mHandler.cancelUpdateBigramPredictions();
-                mService.mHandler.postUpdateOldSuggestions();
-            } else {
-                abortRecorrection(false);
-                // If showing the "touch again to save" hint, do not replace it. Else,
-                // show the bigrams if we are at the end of the text, punctuation
-                // otherwise.
-                if (suggestionsView != null && !suggestionsView.isShowingAddToDictionaryHint()) {
-                    InputConnection ic = mService.getCurrentInputConnection();
-                    if (null == ic || !TextUtils.isEmpty(ic.getTextAfterCursor(1, 0))) {
-                        if (!mService.isShowingPunctuationList()) {
-                            mService.setPunctuationSuggestions();
-                        }
-                    } else {
-                        mService.mHandler.postUpdateBigramPredictions();
-                    }
-                }
-            }
-        }
-    }
-
-    public void saveRecorrectionSuggestion(WordComposer word, CharSequence result) {
-        if (SuggestionSpanUtils.SUGGESTION_SPAN_IS_SUPPORTED || !mRecorrectionEnabled) return;
-        if (word.size() <= 1) {
-            return;
-        }
-        // Skip if result is null. It happens in some edge case.
-        if (TextUtils.isEmpty(result)) {
-            return;
-        }
-
-        // Make a copy of the CharSequence, since it is/could be a mutable CharSequence
-        final String resultCopy = result.toString();
-        RecorrectionSuggestionEntries entry = new RecorrectionSuggestionEntries(
-                resultCopy, new WordComposer(word));
-        mRecorrectionSuggestionsList.add(entry);
-    }
-
-    public void clearWordsInHistory() {
-        mRecorrectionSuggestionsList.clear();
-    }
-
-    /**
-     * Tries to apply any typed alternatives for the word if we have any cached alternatives,
-     * otherwise tries to find new corrections and completions for the word.
-     * @param touching The word that the cursor is touching, with position information
-     * @return true if an alternative was found, false otherwise.
-     */
-    public boolean applyTypedAlternatives(WordComposer word, Suggest suggest,
-            KeyboardSwitcher keyboardSwitcher, EditingUtils.SelectedWord touching) {
-        if (SuggestionSpanUtils.SUGGESTION_SPAN_IS_SUPPORTED || !mRecorrectionEnabled) return false;
-        // If we didn't find a match, search for result in typed word history
-        WordComposer foundWord = null;
-        RecorrectionSuggestionEntries alternatives = null;
-        // Search old suggestions to suggest re-corrected suggestions.
-        for (RecorrectionSuggestionEntries entry : mRecorrectionSuggestionsList) {
-            if (TextUtils.equals(entry.getChosenWord(), touching.mWord)) {
-                foundWord = entry.mWordComposer;
-                alternatives = entry;
-                break;
-            }
-        }
-        // If we didn't find a match, at least suggest corrections as re-corrected suggestions.
-        if (foundWord == null
-                && (AutoCorrection.isValidWord(suggest.getUnigramDictionaries(),
-                        touching.mWord, true))) {
-            foundWord = new WordComposer();
-            for (int i = 0; i < touching.mWord.length(); i++) {
-                foundWord.add(touching.mWord.charAt(i),
-                        new int[] { touching.mWord.charAt(i) }, WordComposer.NOT_A_COORDINATE,
-                        WordComposer.NOT_A_COORDINATE);
-            }
-        }
-        // Found a match, show suggestions
-        if (foundWord != null || alternatives != null) {
-            if (alternatives == null) {
-                alternatives = new RecorrectionSuggestionEntries(touching.mWord, foundWord);
-            }
-            showRecorrections(suggest, keyboardSwitcher, alternatives);
-            if (foundWord != null) {
-                word.init(foundWord);
-            } else {
-                word.reset();
-            }
-            return true;
-        }
-        return false;
-    }
-
-
-    private void showRecorrections(Suggest suggest, KeyboardSwitcher keyboardSwitcher,
-            RecorrectionSuggestionEntries entries) {
-        SuggestedWords.Builder builder = entries.getAlternatives(suggest, keyboardSwitcher);
-        builder.setTypedWordValid(false).setHasMinimalSuggestion(false);
-        mService.showSuggestions(builder.build(), entries.getOriginalWord());
-    }
-
-    public void fetchAndDisplayRecorrectionSuggestions(VoiceProxy voiceProxy,
-            SuggestionsView suggestionsView, Suggest suggest, KeyboardSwitcher keyboardSwitcher,
-            WordComposer word, boolean hasUncommittedTypedChars, int lastSelectionStart,
-            int lastSelectionEnd, String wordSeparators) {
-        if (!InputConnectionCompatUtils.RECORRECTION_SUPPORTED) return;
-        if (SuggestionSpanUtils.SUGGESTION_SPAN_IS_SUPPORTED || !mRecorrectionEnabled) return;
-        voiceProxy.setShowingVoiceSuggestions(false);
-        if (suggestionsView != null && suggestionsView.isShowingAddToDictionaryHint()) {
-            return;
-        }
-        InputConnection ic = mService.getCurrentInputConnection();
-        if (ic == null) return;
-        if (!hasUncommittedTypedChars) {
-            // Extract the selected or touching text
-            EditingUtils.SelectedWord touching = EditingUtils.getWordAtCursorOrSelection(ic,
-                    lastSelectionStart, lastSelectionEnd, wordSeparators);
-
-            if (touching != null && touching.mWord.length() > 1) {
-                ic.beginBatchEdit();
-
-                if (applyTypedAlternatives(word, suggest, keyboardSwitcher, touching)
-                        || voiceProxy.applyVoiceAlternatives(touching)) {
-                    TextEntryState.selectedForRecorrection();
-                    InputConnectionCompatUtils.underlineWord(ic, touching);
-                } else {
-                    abortRecorrection(true);
-                }
-
-                ic.endBatchEdit();
-            } else {
-                abortRecorrection(true);
-                mService.updateBigramPredictions();
-            }
-        } else {
-            abortRecorrection(true);
-        }
-    }
-
-    public void abortRecorrection(boolean force) {
-        if (SuggestionSpanUtils.SUGGESTION_SPAN_IS_SUPPORTED) return;
-        if (force || TextEntryState.isRecorrecting()) {
-            TextEntryState.onAbortRecorrection();
-            mService.setCandidatesViewShown(mService.isSuggestionsStripVisible());
-            mService.getCurrentInputConnection().finishComposingText();
-            mService.clearSuggestions();
-        }
-    }
-
-    public void updateRecorrectionEnabled(Resources res, SharedPreferences prefs) {
-        // If the option should not be shown, do not read the re-correction preference
-        // but always use the default setting defined in the resources.
-        if (res.getBoolean(R.bool.config_enable_show_recorrection_option)) {
-            mRecorrectionEnabled = prefs.getBoolean(Settings.PREF_RECORRECTION_ENABLED,
-                    res.getBoolean(R.bool.config_default_compat_recorrection_enabled));
-        } else {
-            mRecorrectionEnabled =
-                    res.getBoolean(R.bool.config_default_compat_recorrection_enabled);
-        }
-    }
-
-    @Override
-    public void onSharedPreferenceChanged(SharedPreferences prefs, String key) {
-        if (SuggestionSpanUtils.SUGGESTION_SPAN_IS_SUPPORTED) return;
-        if (key.equals(Settings.PREF_RECORRECTION_ENABLED)) {
-            updateRecorrectionEnabled(mService.getResources(), prefs);
-        }
-    }
-}

java/src/com/android/inputmethod/deprecated/recorrection/RecorrectionSuggestionEntries.java

@@ -1,63 +0,0 @@
-/*
- * Copyright (C) 2011 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 com.android.inputmethod.deprecated.recorrection;
-
-import com.android.inputmethod.keyboard.KeyboardSwitcher;
-import com.android.inputmethod.latin.Suggest;
-import com.android.inputmethod.latin.SuggestedWords;
-import com.android.inputmethod.latin.WordComposer;
-
-import android.text.TextUtils;
-
-public class RecorrectionSuggestionEntries {
-    public final CharSequence mChosenWord;
-    public final WordComposer mWordComposer;
-
-    public RecorrectionSuggestionEntries(CharSequence chosenWord, WordComposer wordComposer) {
-        mChosenWord = chosenWord;
-        mWordComposer = wordComposer;
-    }
-
-    public CharSequence getChosenWord() {
-        return mChosenWord;
-    }
-
-    public CharSequence getOriginalWord() {
-        return mWordComposer.getTypedWord();
-    }
-
-    public SuggestedWords.Builder getAlternatives(
-            Suggest suggest, KeyboardSwitcher keyboardSwitcher) {
-        return getTypedSuggestions(suggest, keyboardSwitcher, mWordComposer);
-    }
-
-    @Override
-    public int hashCode() {
-        return mChosenWord.hashCode();
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        return o instanceof CharSequence && TextUtils.equals(mChosenWord, (CharSequence)o);
-    }
-
-    private static SuggestedWords.Builder getTypedSuggestions(
-            Suggest suggest, KeyboardSwitcher keyboardSwitcher, WordComposer word) {
-        return suggest.getSuggestedWordBuilder(word, null,
-                keyboardSwitcher.getLatinKeyboard().getProximityInfo());
-    }
-}

java/src/com/android/inputmethod/latin/LatinIME.java

@@ -60,7 +60,6 @@ import com.android.inputmethod.compat.SuggestionSpanUtils;
 import com.android.inputmethod.compat.VibratorCompatWrapper;
 import com.android.inputmethod.deprecated.LanguageSwitcherProxy;
 import com.android.inputmethod.deprecated.VoiceProxy;
-import com.android.inputmethod.deprecated.recorrection.Recorrection;
 import com.android.inputmethod.keyboard.Key;
 import com.android.inputmethod.keyboard.Keyboard;
 import com.android.inputmethod.keyboard.KeyboardActionListener;
@@ -168,7 +167,6 @@ public class LatinIME extends InputMethodServiceCompatWrapper implements Keyboar
     private KeyboardSwitcher mKeyboardSwitcher;
     private SubtypeSwitcher mSubtypeSwitcher;
     private VoiceProxy mVoiceProxy;
-    private Recorrection mRecorrection;
 
     private UserDictionary mUserDictionary;
     private UserBigramDictionary mUserBigramDictionary;
@@ -252,11 +250,7 @@ public class LatinIME extends InputMethodServiceCompatWrapper implements Keyboar
                 latinIme.updateSuggestions();
                 break;
             case MSG_UPDATE_OLD_SUGGESTIONS:
-                latinIme.mRecorrection.fetchAndDisplayRecorrectionSuggestions(
+                // TODO: remove MSG_UPDATE_OLD_SUGGESTIONS message
-                        latinIme.mVoiceProxy, latinIme.mSuggestionsView,
-                        latinIme.mSuggest, latinIme.mKeyboardSwitcher, latinIme.mWordComposer,
-                        latinIme.mHasUncommittedTypedChars, latinIme.mLastSelectionStart,
-                        latinIme.mLastSelectionEnd, latinIme.mSettingsValues.mWordSeparators);
                 break;
             case MSG_UPDATE_SHIFT_STATE:
                 switcher.updateShiftState();
@@ -470,7 +464,6 @@ public class LatinIME extends InputMethodServiceCompatWrapper implements Keyboar
         InputMethodManagerCompatWrapper.init(this);
         SubtypeSwitcher.init(this);
         KeyboardSwitcher.init(this, prefs);
-        Recorrection.init(this, prefs);
         AccessibilityUtils.init(this, prefs);
 
         super.onCreate();
@@ -479,7 +472,6 @@ public class LatinIME extends InputMethodServiceCompatWrapper implements Keyboar
         mInputMethodId = Utils.getInputMethodId(mImm, getPackageName());
         mSubtypeSwitcher = SubtypeSwitcher.getInstance();
         mKeyboardSwitcher = KeyboardSwitcher.getInstance();
-        mRecorrection = Recorrection.getInstance();
         mVibrator = VibratorCompatWrapper.getInstance(this);
         DEBUG = LatinImeLogger.sDBG;
 
@@ -758,8 +750,6 @@ public class LatinIME extends InputMethodServiceCompatWrapper implements Keyboar
         inputView.setKeyPreviewPopupEnabled(mSettingsValues.mKeyPreviewPopupOn,
                 mSettingsValues.mKeyPreviewPopupDismissDelay);
         inputView.setProximityCorrectionEnabled(true);
-        // If we just entered a text field, maybe it has some old text that requires correction
-        mRecorrection.checkRecorrectionOnStart();
 
         voiceIme.onStartInputView(inputView.getWindowToken());
 
@@ -886,13 +876,6 @@ public class LatinIME extends InputMethodServiceCompatWrapper implements Keyboar
             if (((mComposingStringBuilder.length() > 0 && mHasUncommittedTypedChars)
                     || mVoiceProxy.isVoiceInputHighlighted())
                     && (selectionChanged || candidatesCleared)) {
-                if (candidatesCleared) {
-                    // If the composing span has been cleared, save the typed word in the history
-                    // for recorrection before we reset the suggestions strip.  Then, we'll be able
-                    // to show suggestions for recorrection right away.
-                    mRecorrection.saveRecorrectionSuggestion(mWordComposer,
-                            mComposingStringBuilder);
-                }
                 mComposingStringBuilder.setLength(0);
                 mHasUncommittedTypedChars = false;
                 TextEntryState.reset();
@@ -915,11 +898,6 @@ public class LatinIME extends InputMethodServiceCompatWrapper implements Keyboar
         // Make a note of the cursor position
         mLastSelectionStart = newSelStart;
         mLastSelectionEnd = newSelEnd;
-
-        mRecorrection.updateRecorrectionSelection(mKeyboardSwitcher,
-                mSuggestionsView, candidatesStart, candidatesEnd, newSelStart,
-                newSelEnd, oldSelStart, mLastSelectionStart,
-                mLastSelectionEnd, mHasUncommittedTypedChars);
     }
 
     public void setLastSelection(int start, int end) {
@@ -937,7 +915,7 @@ public class LatinIME extends InputMethodServiceCompatWrapper implements Keyboar
      */
     @Override
     public void onExtractedTextClicked() {
-        if (mRecorrection.isRecorrectionEnabled() && isSuggestionsRequested()) return;
+        if (isSuggestionsRequested()) return;
 
         super.onExtractedTextClicked();
     }
@@ -953,7 +931,7 @@ public class LatinIME extends InputMethodServiceCompatWrapper implements Keyboar
      */
     @Override
     public void onExtractedCursorMovement(int dx, int dy) {
-        if (mRecorrection.isRecorrectionEnabled() && isSuggestionsRequested()) return;
+        if (isSuggestionsRequested()) return;
 
         super.onExtractedCursorMovement(dx, dy);
     }
@@ -969,7 +947,6 @@ public class LatinIME extends InputMethodServiceCompatWrapper implements Keyboar
             mOptionsDialog = null;
         }
         mVoiceProxy.hideVoiceWindow(mConfigurationChanging);
-        mRecorrection.clearWordsInHistory();
         super.hideWindow();
     }
 
@@ -1325,7 +1302,6 @@ public class LatinIME extends InputMethodServiceCompatWrapper implements Keyboar
         mVoiceProxy.commitVoiceInput();
         final InputConnection ic = getCurrentInputConnection();
         if (ic == null) return;
-        mRecorrection.abortRecorrection(false);
         ic.beginBatchEdit();
         commitTyped(ic);
         maybeRemovePreviousPeriod(ic, text);
@@ -1441,17 +1417,12 @@ public class LatinIME extends InputMethodServiceCompatWrapper implements Keyboar
             removeTrailingSpace();
         }
 
-        if (mLastSelectionStart == mLastSelectionEnd) {
-            mRecorrection.abortRecorrection(false);
-        }
-
         int code = primaryCode;
         if ((isAlphabet(code) || mSettingsValues.isSymbolExcludedFromWordSeparators(code))
                 && isSuggestionsRequested() && !isCursorTouchingWord()) {
             if (!mHasUncommittedTypedChars) {
                 mHasUncommittedTypedChars = true;
                 mComposingStringBuilder.setLength(0);
-                mRecorrection.saveRecorrectionSuggestion(mWordComposer, mBestWord);
                 mWordComposer.reset();
                 clearSuggestions();
             }
@@ -1517,7 +1488,6 @@ public class LatinIME extends InputMethodServiceCompatWrapper implements Keyboar
         final InputConnection ic = getCurrentInputConnection();
         if (ic != null) {
             ic.beginBatchEdit();
-            mRecorrection.abortRecorrection(false);
         }
         if (mHasUncommittedTypedChars) {
             // In certain languages where single quote is a separator, it's better
@@ -1886,7 +1856,6 @@ public class LatinIME extends InputMethodServiceCompatWrapper implements Keyboar
                 ic.commitText(bestWord, 1);
             }
         }
-        mRecorrection.saveRecorrectionSuggestion(mWordComposer, bestWord);
         mHasUncommittedTypedChars = false;
         mCommittedLength = bestWord.length();
     }