am 3508eb14: Merge "Remove changing a word when added to the dictionary"
* commit '3508eb14c083a2d3e0f1671b926ebb4ec9302130': Remove changing a word when added to the dictionarymain
commit
a1efc18927
|
@ -95,7 +95,6 @@ import com.android.inputmethod.latin.utils.InputTypeUtils;
|
|||
import com.android.inputmethod.latin.utils.IntentUtils;
|
||||
import com.android.inputmethod.latin.utils.JniUtils;
|
||||
import com.android.inputmethod.latin.utils.LatinImeLoggerUtils;
|
||||
import com.android.inputmethod.latin.utils.PositionalInfoForUserDictPendingAddition;
|
||||
import com.android.inputmethod.latin.utils.RecapitalizeStatus;
|
||||
import com.android.inputmethod.latin.utils.StaticInnerHandlerWrapper;
|
||||
import com.android.inputmethod.latin.utils.TargetPackageInfoGetterTask;
|
||||
|
@ -185,8 +184,6 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
|
|||
private boolean mIsUserDictionaryAvailable;
|
||||
|
||||
private LastComposedWord mLastComposedWord = LastComposedWord.NOT_A_COMPOSED_WORD;
|
||||
private PositionalInfoForUserDictPendingAddition
|
||||
mPositionalInfoForUserDictPendingAddition = null;
|
||||
private final WordComposer mWordComposer = new WordComposer();
|
||||
private final RichInputConnection mConnection = new RichInputConnection(this);
|
||||
private final RecapitalizeStatus mRecapitalizeStatus = new RecapitalizeStatus();
|
||||
|
@ -898,19 +895,6 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
|
|||
currentSettingsValues.mGestureTrailEnabled,
|
||||
currentSettingsValues.mGestureFloatingPreviewTextEnabled);
|
||||
|
||||
// If we have a user dictionary addition in progress, we should check now if we should
|
||||
// replace the previously committed string with the word that has actually been added
|
||||
// to the user dictionary.
|
||||
if (null != mPositionalInfoForUserDictPendingAddition
|
||||
&& mPositionalInfoForUserDictPendingAddition.tryReplaceWithActualWord(
|
||||
mConnection, editorInfo, mLastSelectionEnd, currentLocale)) {
|
||||
mPositionalInfoForUserDictPendingAddition = null;
|
||||
}
|
||||
// If tryReplaceWithActualWord returns false, we don't know what word was
|
||||
// added to the user dictionary yet, so we keep the data and defer processing. The word will
|
||||
// be replaced when the user dictionary reports back with the actual word, which ends
|
||||
// up calling #onWordAddedToUserDictionary() in this class.
|
||||
|
||||
initPersonalizationDebugSettings(currentSettingsValues);
|
||||
|
||||
if (TRACE) Debug.startMethodTracing("/data/trace/latinime");
|
||||
|
@ -1416,7 +1400,6 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
|
|||
public void addWordToUserDictionary(final String word) {
|
||||
if (TextUtils.isEmpty(word)) {
|
||||
// Probably never supposed to happen, but just in case.
|
||||
mPositionalInfoForUserDictPendingAddition = null;
|
||||
return;
|
||||
}
|
||||
final String wordToEdit;
|
||||
|
@ -1428,22 +1411,6 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
|
|||
mUserDictionary.addWordToUserDictionary(wordToEdit);
|
||||
}
|
||||
|
||||
public void onWordAddedToUserDictionary(final String newSpelling) {
|
||||
// If word was added but not by us, bail out
|
||||
if (null == mPositionalInfoForUserDictPendingAddition) return;
|
||||
if (mWordComposer.isComposingWord()) {
|
||||
// We are late... give up and return
|
||||
mPositionalInfoForUserDictPendingAddition = null;
|
||||
return;
|
||||
}
|
||||
mPositionalInfoForUserDictPendingAddition.setActualWordBeingAdded(newSpelling);
|
||||
if (mPositionalInfoForUserDictPendingAddition.tryReplaceWithActualWord(
|
||||
mConnection, getCurrentInputEditorInfo(), mLastSelectionEnd,
|
||||
mSubtypeSwitcher.getCurrentSubtypeLocale())) {
|
||||
mPositionalInfoForUserDictPendingAddition = null;
|
||||
}
|
||||
}
|
||||
|
||||
private void onSettingsKeyPressed() {
|
||||
if (isShowingOptionDialog()) return;
|
||||
showSubtypeSelectorAndSettings();
|
||||
|
|
|
@ -103,14 +103,6 @@ public class UserBinaryDictionary extends ExpandableBinaryDictionary {
|
|||
@Override
|
||||
public void onChange(final boolean self, final Uri uri) {
|
||||
setRequiresReload(true);
|
||||
// We want to report back to Latin IME in case the user just entered the word.
|
||||
// If the user changed the word in the dialog box, then we want to replace
|
||||
// what was entered in the text field.
|
||||
if (null == uri || !(context instanceof LatinIME)) return;
|
||||
final long changedRowId = ContentUris.parseId(uri);
|
||||
if (-1 == changedRowId) return; // Unknown content... Not sure why we're here
|
||||
final String changedWord = getChangedWordForUri(uri);
|
||||
((LatinIME)context).onWordAddedToUserDictionary(changedWord);
|
||||
}
|
||||
};
|
||||
cres.registerContentObserver(Words.CONTENT_URI, true, mObserver);
|
||||
|
@ -118,19 +110,6 @@ public class UserBinaryDictionary extends ExpandableBinaryDictionary {
|
|||
loadDictionary();
|
||||
}
|
||||
|
||||
private String getChangedWordForUri(final Uri uri) {
|
||||
final Cursor cursor = mContext.getContentResolver().query(uri,
|
||||
PROJECTION_QUERY, null, null, null);
|
||||
if (cursor == null) return null;
|
||||
try {
|
||||
if (!cursor.moveToFirst()) return null;
|
||||
final int indexWord = cursor.getColumnIndex(Words.WORD);
|
||||
return cursor.getString(indexWord);
|
||||
} finally {
|
||||
cursor.close();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public synchronized void close() {
|
||||
if (mObserver != null) {
|
||||
|
|
|
@ -1,108 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 2012 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.latin.utils;
|
||||
|
||||
import android.view.inputmethod.EditorInfo;
|
||||
|
||||
import com.android.inputmethod.latin.RichInputConnection;
|
||||
|
||||
import java.util.Locale;
|
||||
|
||||
/**
|
||||
* Holder class for data about a word already committed but that may still be edited.
|
||||
*
|
||||
* When the user chooses to add a word to the user dictionary by pressing the appropriate
|
||||
* suggestion, a dialog is presented to give a chance to edit the word before it is actually
|
||||
* registered as a user dictionary word. If the word is actually modified, the IME needs to
|
||||
* go back and replace the word that was committed with the amended version.
|
||||
* The word we need to replace with will only be known after it's actually committed, so
|
||||
* the IME needs to take a note of what it has to replace and where it is.
|
||||
* This class encapsulates this data.
|
||||
*/
|
||||
public final class PositionalInfoForUserDictPendingAddition {
|
||||
final private String mOriginalWord;
|
||||
final private int mCursorPos; // Position of the cursor after the word
|
||||
final private EditorInfo mEditorInfo; // On what binding this has been added
|
||||
final private int mCapitalizedMode;
|
||||
private String mActualWordBeingAdded;
|
||||
|
||||
public PositionalInfoForUserDictPendingAddition(final String word, final int cursorPos,
|
||||
final EditorInfo editorInfo, final int capitalizedMode) {
|
||||
mOriginalWord = word;
|
||||
mCursorPos = cursorPos;
|
||||
mEditorInfo = editorInfo;
|
||||
mCapitalizedMode = capitalizedMode;
|
||||
}
|
||||
|
||||
public void setActualWordBeingAdded(final String actualWordBeingAdded) {
|
||||
mActualWordBeingAdded = actualWordBeingAdded;
|
||||
}
|
||||
|
||||
/**
|
||||
* Try to replace the string at the remembered position with the actual word being added.
|
||||
*
|
||||
* After the user validated the word being added, the IME has to replace the old version
|
||||
* (which has been committed in the text view) with the amended version if it's different.
|
||||
* This method tries to do that, but may fail because the IME is not yet ready to do so -
|
||||
* for example, it is still waiting for the new string, or it is waiting to return to the text
|
||||
* view in which the amendment should be made. In these cases, we should keep the data
|
||||
* and wait until all conditions are met.
|
||||
* This method returns true if the replacement has been successfully made and this data
|
||||
* can be forgotten; it returns false if the replacement can't be made yet and we need to
|
||||
* keep this until a later time.
|
||||
* The IME knows about the actual word being added through a callback called by the
|
||||
* user dictionary facility of the device. When this callback comes, the keyboard may still
|
||||
* be connected to the edition dialog, or it may have already returned to the original text
|
||||
* field. Replacement has to work in both cases.
|
||||
* Accordingly, this method is called at two different points in time : upon getting the
|
||||
* event that a new word was added to the user dictionary, and upon starting up in a
|
||||
* new text field.
|
||||
* @param connection The RichInputConnection through which to contact the editor.
|
||||
* @param editorInfo Information pertaining to the editor we are currently in.
|
||||
* @param currentCursorPosition The current cursor position, for checking purposes.
|
||||
* @param locale The locale for changing case, if necessary
|
||||
* @return true if the edit has been successfully made, false if we need to try again later
|
||||
*/
|
||||
public boolean tryReplaceWithActualWord(final RichInputConnection connection,
|
||||
final EditorInfo editorInfo, final int currentCursorPosition, final Locale locale) {
|
||||
// If we still don't know the actual word being added, we need to try again later.
|
||||
if (null == mActualWordBeingAdded) return false;
|
||||
// The entered text and the registered text were the same anyway : we can
|
||||
// return success right away even if focus has not returned yet to the text field we
|
||||
// want to amend.
|
||||
if (mActualWordBeingAdded.equals(mOriginalWord)) return true;
|
||||
// Not the same text field : we need to try again later. This happens when the addition
|
||||
// is reported by the user dictionary provider before the focus has moved back to the
|
||||
// original text view, so the IME is still in the text view of the dialog and has no way to
|
||||
// edit the original text view at this time.
|
||||
if (!mEditorInfo.packageName.equals(editorInfo.packageName)
|
||||
|| mEditorInfo.fieldId != editorInfo.fieldId) {
|
||||
return false;
|
||||
}
|
||||
// Same text field, but not the same cursor position : we give up, so we return success
|
||||
// so that it won't be tried again
|
||||
if (currentCursorPosition != mCursorPos) return true;
|
||||
// We have made all the checks : do the replacement and report success
|
||||
// If this was auto-capitalized, we need to restore the case before committing
|
||||
final String wordWithCaseFixed = CapsModeUtils.applyAutoCapsMode(mActualWordBeingAdded,
|
||||
mCapitalizedMode, locale);
|
||||
connection.setComposingRegion(currentCursorPosition - mOriginalWord.length(),
|
||||
currentCursorPosition);
|
||||
connection.commitText(wordWithCaseFixed, wordWithCaseFixed.length());
|
||||
return true;
|
||||
}
|
||||
}
|
Loading…
Reference in New Issue