nyancrimew/LatinIME
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Cleanup : remove old recorrection code

Browse source 
This removes the calls, but another change will be needed to remove
the messages LatinIME used to send itself to update the suggestion
strip.

Bug: 5402537
Change-Id: I5d1aa63a892516f339f3ceac21f43771b5ffda34
This commit is contained in:
Jean Chalard 2011-10-03 17:45:45 +09:00
parent 6b64a0fedc
commit fe5364c825
3 changed files with 3 additions and 384 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

287
java/src/com/android/inputmethod/deprecated/recorrection/Recorrection.java
View file

@ -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);
}
}
}

63
java/src/com/android/inputmethod/deprecated/recorrection/RecorrectionSuggestionEntries.java
View file

@ -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());
}
}

37
java/src/com/android/inputmethod/latin/LatinIME.java
View file

@ -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(
latinIme.mVoiceProxy, latinIme.mSuggestionsView,
latinIme.mSuggest, latinIme.mKeyboardSwitcher, latinIme.mWordComposer,
latinIme.mHasUncommittedTypedChars, latinIme.mLastSelectionStart,
latinIme.mLastSelectionEnd, latinIme.mSettingsValues.mWordSeparators);
// TODO: remove MSG_UPDATE_OLD_SUGGESTIONS message
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();
}