diff options
Diffstat (limited to 'java/src')
16 files changed, 318 insertions, 156 deletions
diff --git a/java/src/com/android/inputmethod/keyboard/MainKeyboardView.java b/java/src/com/android/inputmethod/keyboard/MainKeyboardView.java index e1c841de7..810bd9150 100644 --- a/java/src/com/android/inputmethod/keyboard/MainKeyboardView.java +++ b/java/src/com/android/inputmethod/keyboard/MainKeyboardView.java @@ -424,8 +424,8 @@ public final class MainKeyboardView extends KeyboardView implements PointerTrack */ @Override public void setKeyboard(final Keyboard keyboard) { - // Remove any pending messages. - mKeyTimerHandler.cancelAllKeyTimers(); + // Remove any pending messages, except dismissing preview and key repeat. + mKeyTimerHandler.cancelLongPressTimers(); super.setKeyboard(keyboard); mKeyDetector.setKeyboard( keyboard, -getPaddingLeft(), -getPaddingTop() + getVerticalCorrection()); diff --git a/java/src/com/android/inputmethod/keyboard/internal/GestureStrokeDrawingPoints.java b/java/src/com/android/inputmethod/keyboard/internal/GestureStrokeDrawingPoints.java index 7618682da..7d09e9d2f 100644 --- a/java/src/com/android/inputmethod/keyboard/internal/GestureStrokeDrawingPoints.java +++ b/java/src/com/android/inputmethod/keyboard/internal/GestureStrokeDrawingPoints.java @@ -157,19 +157,19 @@ public final class GestureStrokeDrawingPoints { for (int i = 1; i < segments; i++) { final float t = i / (float)segments; mInterpolator.interpolate(t); - eventTimes.add(d1, (int)(dt * t) + t1); - xCoords.add(d1, (int)mInterpolator.mInterpolatedX); - yCoords.add(d1, (int)mInterpolator.mInterpolatedY); + eventTimes.addAt(d1, (int)(dt * t) + t1); + xCoords.addAt(d1, (int)mInterpolator.mInterpolatedX); + yCoords.addAt(d1, (int)mInterpolator.mInterpolatedY); if (GestureTrailDrawingPoints.DEBUG_SHOW_POINTS) { - types.add(d1, GestureTrailDrawingPoints.POINT_TYPE_INTERPOLATED); + types.addAt(d1, GestureTrailDrawingPoints.POINT_TYPE_INTERPOLATED); } d1++; } - eventTimes.add(d1, pt[p2]); - xCoords.add(d1, px[p2]); - yCoords.add(d1, py[p2]); + eventTimes.addAt(d1, pt[p2]); + xCoords.addAt(d1, px[p2]); + yCoords.addAt(d1, py[p2]); if (GestureTrailDrawingPoints.DEBUG_SHOW_POINTS) { - types.add(d1, GestureTrailDrawingPoints.POINT_TYPE_SAMPLED); + types.addAt(d1, GestureTrailDrawingPoints.POINT_TYPE_SAMPLED); } } return lastInterpolatedDrawIndex; diff --git a/java/src/com/android/inputmethod/keyboard/internal/TimerHandler.java b/java/src/com/android/inputmethod/keyboard/internal/TimerHandler.java index 3298a3f24..ec7b9b024 100644 --- a/java/src/com/android/inputmethod/keyboard/internal/TimerHandler.java +++ b/java/src/com/android/inputmethod/keyboard/internal/TimerHandler.java @@ -126,7 +126,7 @@ public final class TimerHandler extends LeakGuardHandlerWrapper<Callbacks> imple removeMessages(MSG_LONGPRESS_SHIFT_KEY); } - private void cancelLongPressTimers() { + public void cancelLongPressTimers() { removeMessages(MSG_LONGPRESS_KEY); removeMessages(MSG_LONGPRESS_SHIFT_KEY); } diff --git a/java/src/com/android/inputmethod/latin/DictionaryFacilitatorForSuggest.java b/java/src/com/android/inputmethod/latin/DictionaryFacilitatorForSuggest.java index c9bcfe369..aa8bb2ccb 100644 --- a/java/src/com/android/inputmethod/latin/DictionaryFacilitatorForSuggest.java +++ b/java/src/com/android/inputmethod/latin/DictionaryFacilitatorForSuggest.java @@ -36,6 +36,7 @@ import java.util.HashSet; import java.util.Locale; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; // TODO: Consolidate dictionaries in native code. @@ -55,8 +56,7 @@ public class DictionaryFacilitatorForSuggest { private UserHistoryDictionary mUserHistoryDictionary; private PersonalizationDictionary mPersonalizationDictionary; - @UsedForTesting - private boolean mIsCurrentlyWaitingForMainDictionary = false; + private final CountDownLatch mLatchForWaitingLoadingMainDictionary; public interface DictionaryInitializationListener { public void onUpdateMainDictionaryAvailability(boolean isMainDictionaryAvailable); @@ -77,13 +77,41 @@ public class DictionaryFacilitatorForSuggest { final DictionaryFacilitatorForSuggest oldDictionaryFacilitator) { mContext = context; mLocale = locale; + mLatchForWaitingLoadingMainDictionary = new CountDownLatch(1); initForDebug(settingsValues); - reloadMainDict(context, locale, listener); + loadMainDict(context, locale, listener); setUserDictionary(new UserBinaryDictionary(context, locale)); resetAdditionalDictionaries(oldDictionaryFacilitator, settingsValues); } /** + * Creates instance for reloading the main dict. + * + * @param listener the listener + * @param oldDictionaryFacilitator the instance having old dictionaries. This must not be null. + */ + public DictionaryFacilitatorForSuggest(final DictionaryInitializationListener listener, + final DictionaryFacilitatorForSuggest oldDictionaryFacilitator) { + mContext = oldDictionaryFacilitator.mContext; + mLocale = oldDictionaryFacilitator.mLocale; + mDictionarySubsetForDebug = oldDictionaryFacilitator.mDictionarySubsetForDebug; + mLatchForWaitingLoadingMainDictionary = new CountDownLatch(1); + loadMainDict(mContext, mLocale, listener); + // Transfer user dictionary. + setUserDictionary(oldDictionaryFacilitator.mUserDictionary); + oldDictionaryFacilitator.removeDictionary(Dictionary.TYPE_USER); + // Transfer contacts dictionary. + setContactsDictionary(oldDictionaryFacilitator.mContactsDictionary); + oldDictionaryFacilitator.removeDictionary(Dictionary.TYPE_CONTACTS); + // Transfer user history dictionary. + setUserHistoryDictionary(oldDictionaryFacilitator.mUserHistoryDictionary); + oldDictionaryFacilitator.removeDictionary(Dictionary.TYPE_USER_HISTORY); + // Transfer personalization dictionary. + setPersonalizationDictionary(oldDictionaryFacilitator.mPersonalizationDictionary); + oldDictionaryFacilitator.removeDictionary(Dictionary.TYPE_PERSONALIZATION); + } + + /** * Creates instance for when the settings values have been changed. * * @param settingsValues the new settings values @@ -94,6 +122,7 @@ public class DictionaryFacilitatorForSuggest { final DictionaryFacilitatorForSuggest oldDictionaryFacilitator) { mContext = oldDictionaryFacilitator.mContext; mLocale = oldDictionaryFacilitator.mLocale; + mLatchForWaitingLoadingMainDictionary = new CountDownLatch(0); initForDebug(settingsValues); // Transfer main dictionary. setMainDictionary(oldDictionaryFacilitator.mMainDictionary); @@ -110,6 +139,7 @@ public class DictionaryFacilitatorForSuggest { final ArrayList<String> dictionaryTypes, final HashMap<String, File> dictionaryFiles) { mContext = context; mLocale = locale; + mLatchForWaitingLoadingMainDictionary = new CountDownLatch(0); for (final String dictType : dictionaryTypes) { if (dictType.equals(Dictionary.TYPE_MAIN)) { final DictionaryCollection mainDictionary = @@ -167,9 +197,8 @@ public class DictionaryFacilitatorForSuggest { } } - public void reloadMainDict(final Context context, final Locale locale, + private void loadMainDict(final Context context, final Locale locale, final DictionaryInitializationListener listener) { - mIsCurrentlyWaitingForMainDictionary = true; mMainDictionary = null; if (listener != null) { listener.onUpdateMainDictionaryAvailability(hasMainDictionary()); @@ -183,7 +212,7 @@ public class DictionaryFacilitatorForSuggest { if (listener != null) { listener.onUpdateMainDictionaryAvailability(hasMainDictionary()); } - mIsCurrentlyWaitingForMainDictionary = false; + mLatchForWaitingLoadingMainDictionary.countDown(); } }.start(); } @@ -194,9 +223,9 @@ public class DictionaryFacilitatorForSuggest { return null != mMainDictionary && mMainDictionary.isInitialized(); } - @UsedForTesting - public boolean isCurrentlyWaitingForMainDictionary() { - return mIsCurrentlyWaitingForMainDictionary; + public void waitForLoadingMainDictionary(final long timeout, final TimeUnit unit) + throws InterruptedException { + mLatchForWaitingLoadingMainDictionary.await(timeout, unit); } private void setMainDictionary(final Dictionary mainDictionary) { diff --git a/java/src/com/android/inputmethod/latin/InputPointers.java b/java/src/com/android/inputmethod/latin/InputPointers.java index 2e638aaf3..c3bcf3785 100644 --- a/java/src/com/android/inputmethod/latin/InputPointers.java +++ b/java/src/com/android/inputmethod/latin/InputPointers.java @@ -16,14 +16,16 @@ package com.android.inputmethod.latin; +import android.util.Log; + import com.android.inputmethod.annotations.UsedForTesting; import com.android.inputmethod.latin.utils.ResizableIntArray; -import android.util.Log; - // TODO: This class is not thread-safe. public final class InputPointers { private static final String TAG = InputPointers.class.getSimpleName(); + private static final boolean DEBUG_TIME = false; + private final int mDefaultCapacity; private final ResizableIntArray mXCoordinates; private final ResizableIntArray mYCoordinates; @@ -38,11 +40,29 @@ public final class InputPointers { mTimes = new ResizableIntArray(defaultCapacity); } - public void addPointer(int index, int x, int y, int pointerId, int time) { - mXCoordinates.add(index, x); - mYCoordinates.add(index, y); - mPointerIds.add(index, pointerId); - mTimes.add(index, time); + private void fillWithLastTimeUntil(final int index) { + final int fromIndex = mTimes.getLength(); + // Fill the gap with the latest time. + // See {@link #getTime(int)} and {@link #isValidTimeStamps()}. + if (fromIndex <= 0) { + return; + } + final int fillLength = index - fromIndex + 1; + if (fillLength <= 0) { + return; + } + final int lastTime = mTimes.get(fromIndex - 1); + mTimes.fill(lastTime, fromIndex, fillLength); + } + + public void addPointerAt(int index, int x, int y, int pointerId, int time) { + mXCoordinates.addAt(index, x); + mYCoordinates.addAt(index, y); + mPointerIds.addAt(index, pointerId); + if (LatinImeLogger.sDBG || DEBUG_TIME) { + fillWithLastTimeUntil(index); + } + mTimes.addAt(index, time); } @UsedForTesting @@ -68,23 +88,6 @@ public final class InputPointers { } /** - * Append the pointers in the specified {@link InputPointers} to the end of this. - * @param src the source {@link InputPointers} to read the data from. - * @param startPos the starting index of the pointers in {@code src}. - * @param length the number of pointers to be appended. - */ - @UsedForTesting - void append(InputPointers src, int startPos, int length) { - if (length == 0) { - return; - } - mXCoordinates.append(src.mXCoordinates, startPos, length); - mYCoordinates.append(src.mYCoordinates, startPos, length); - mPointerIds.append(src.mPointerIds, startPos, length); - mTimes.append(src.mTimes, startPos, length); - } - - /** * Append the times, x-coordinates and y-coordinates in the specified {@link ResizableIntArray} * to the end of this. * @param pointerId the pointer id of the source. @@ -141,7 +144,7 @@ public final class InputPointers { } public int[] getTimes() { - if (LatinImeLogger.sDBG) { + if (LatinImeLogger.sDBG || DEBUG_TIME) { if (!isValidTimeStamps()) { throw new RuntimeException("Time stamps are invalid."); } @@ -157,10 +160,11 @@ public final class InputPointers { private boolean isValidTimeStamps() { final int[] times = mTimes.getPrimitiveArray(); - for (int i = 1; i < getPointerSize(); ++i) { + final int size = getPointerSize(); + for (int i = 1; i < size; ++i) { if (times[i] < times[i - 1]) { // dump - for (int j = 0; j < times.length; ++j) { + for (int j = 0; j < size; ++j) { Log.d(TAG, "--- (" + j + ") " + times[j]); } return false; diff --git a/java/src/com/android/inputmethod/latin/LatinIME.java b/java/src/com/android/inputmethod/latin/LatinIME.java index 5a5674f8f..aadb65192 100644 --- a/java/src/com/android/inputmethod/latin/LatinIME.java +++ b/java/src/com/android/inputmethod/latin/LatinIME.java @@ -89,6 +89,7 @@ import java.io.FileDescriptor; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Locale; +import java.util.concurrent.TimeUnit; /** * Input method implementation for Qwerty'ish keyboard. @@ -519,11 +520,22 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen new DictionaryFacilitatorForSuggest(currentSettingsValues, oldDictionaryFacilitator); // Create Suggest instance with the new dictionary facilitator. - mInputLogic.mSuggest = new Suggest(suggest /* oldSuggest */, dictionaryFacilitator); - suggest.close(); + resetSuggest(new Suggest(suggest /* oldSuggest */, dictionaryFacilitator)); + } else if (suggest == null) { + initSuggestForLocale(locale); } - if (currentSettingsValues.mUsePersonalizedDicts) { - PersonalizationDictionarySessionRegistrar.init(this); + } + + private void refreshPersonalizationDictionarySession() { + if (mSettings.getCurrent().mUsePersonalizedDicts) { + if (mSubtypeSwitcher.isSystemLocaleSameAsLocaleOfAllEnabledSubtypes()) { + final DictionaryFacilitatorForSuggest dictionaryFacilitator = + (mInputLogic.mSuggest == null) ? + null : mInputLogic.mSuggest.mDictionaryFacilitator; + PersonalizationDictionarySessionRegistrar.init(this, dictionaryFacilitator); + } else { + PersonalizationDictionarySessionRegistrar.close(this); + } } else { PersonalizationHelper.removeAllPersonalizedDictionaries(this); PersonalizationDictionarySessionRegistrar.resetAll(this); @@ -555,31 +567,41 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen } else { subtypeLocale = switcherSubtypeLocale; } + initSuggestForLocale(subtypeLocale); + } + private void initSuggestForLocale(final Locale locale) { final SettingsValues settingsValues = mSettings.getCurrent(); final DictionaryFacilitatorForSuggest oldDictionaryFacilitator = (mInputLogic.mSuggest == null) ? null : mInputLogic.mSuggest.mDictionaryFacilitator; // Creates new dictionary facilitator for the new locale. final DictionaryFacilitatorForSuggest dictionaryFacilitator = - new DictionaryFacilitatorForSuggest(this /* context */, subtypeLocale, + new DictionaryFacilitatorForSuggest(this /* context */, locale, settingsValues, this /* DictionaryInitializationListener */, oldDictionaryFacilitator); - final Suggest newSuggest = new Suggest(subtypeLocale, dictionaryFacilitator); + final Suggest newSuggest = new Suggest(locale, dictionaryFacilitator); if (settingsValues.mCorrectionEnabled) { newSuggest.setAutoCorrectionThreshold(settingsValues.mAutoCorrectionThreshold); } + resetSuggest(newSuggest); + } + + /* package private */ void resetSuggestMainDict() { + final DictionaryFacilitatorForSuggest oldDictionaryFacilitator = + mInputLogic.mSuggest.mDictionaryFacilitator; + final DictionaryFacilitatorForSuggest dictionaryFacilitator = + new DictionaryFacilitatorForSuggest(this /* listener */, oldDictionaryFacilitator); + resetSuggest(new Suggest(mInputLogic.mSuggest /* oldSuggest */, dictionaryFacilitator)); + } + + private void resetSuggest(final Suggest newSuggest) { if (ProductionFlag.USES_DEVELOPMENT_ONLY_DIAGNOSTICS) { ResearchLogger.getInstance().initDictionary(newSuggest.mDictionaryFacilitator); } final Suggest oldSuggest = mInputLogic.mSuggest; mInputLogic.mSuggest = newSuggest; if (oldSuggest != null) oldSuggest.close(); - } - - /* package private */ void resetSuggestMainDict() { - final Locale subtypeLocale = mSubtypeSwitcher.getCurrentSubtypeLocale(); - mInputLogic.mSuggest.mDictionaryFacilitator.reloadMainDict(this, subtypeLocale, - this /* SuggestInitializationListener */); + refreshPersonalizationDictionarySession(); } @Override @@ -595,7 +617,7 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen ResearchLogger.getInstance().onDestroy(); } unregisterReceiver(mDictionaryPackInstallReceiver); - PersonalizationDictionarySessionRegistrar.onDestroy(this); + PersonalizationDictionarySessionRegistrar.close(this); LatinImeLogger.commit(); LatinImeLogger.onDestroy(); super.onDestroy(); @@ -615,7 +637,8 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen mOptionsDialog.dismiss(); } } - PersonalizationDictionarySessionRegistrar.onConfigurationChanged(this, conf); + PersonalizationDictionarySessionRegistrar.onConfigurationChanged(this, conf, + mInputLogic.mSuggest.mDictionaryFacilitator); super.onConfigurationChanged(conf); } @@ -1291,7 +1314,8 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen @UsedForTesting public boolean isShowingPunctuationList() { if (mInputLogic.mSuggestedWords == null) return false; - return mSettings.getCurrent().mSuggestPuncList == mInputLogic.mSuggestedWords; + return mSettings.getCurrent().mSpacingAndPunctuations.mSuggestPuncList + == mInputLogic.mSuggestedWords; } // TODO[IL]: Define a clear interface for this @@ -1407,7 +1431,8 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen private SuggestedWords getOlderSuggestions(final String typedWord) { SuggestedWords previousSuggestedWords = mInputLogic.mSuggestedWords; - if (previousSuggestedWords == mSettings.getCurrent().mSuggestPuncList) { + if (previousSuggestedWords + == mSettings.getCurrent().mSpacingAndPunctuations.mSuggestPuncList) { previousSuggestedWords = SuggestedWords.EMPTY; } if (typedWord == null) { @@ -1560,7 +1585,7 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen if (currentSettings.mBigramPredictionEnabled) { clearSuggestionStrip(); } else { - setSuggestedWords(currentSettings.mSuggestPuncList); + setSuggestedWords(currentSettings.mSpacingAndPunctuations.mSuggestPuncList); } setAutoCorrectionIndicator(false); setSuggestionStripShown(isSuggestionsStripVisible()); @@ -1777,14 +1802,20 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen // DO NOT USE THIS for any other purpose than testing. This is information private to LatinIME. @UsedForTesting - /* package for test */ boolean isCurrentlyWaitingForMainDictionary() { - return mInputLogic.mSuggest.mDictionaryFacilitator.isCurrentlyWaitingForMainDictionary(); + /* package for test */ void waitForMainDictionary(final long timeout, final TimeUnit unit) + throws InterruptedException { + mInputLogic.mSuggest.mDictionaryFacilitator.waitForLoadingMainDictionary(timeout, unit); } // DO NOT USE THIS for any other purpose than testing. This can break the keyboard badly. @UsedForTesting - /* package for test */ void replaceMainDictionaryForTest(final Locale locale) { - mInputLogic.mSuggest.mDictionaryFacilitator.reloadMainDict(this, locale, null); + /* package for test */ void replaceDictionariesForTest(final Locale locale) { + final DictionaryFacilitatorForSuggest oldDictionaryFacilitator = + mInputLogic.mSuggest.mDictionaryFacilitator; + final DictionaryFacilitatorForSuggest dictionaryFacilitator = + new DictionaryFacilitatorForSuggest(this, locale, mSettings.getCurrent(), + this /* listener */, oldDictionaryFacilitator); + resetSuggest(new Suggest(locale, dictionaryFacilitator)); } public void debugDumpStateAndCrashWithException(final String context) { diff --git a/java/src/com/android/inputmethod/latin/RichInputConnection.java b/java/src/com/android/inputmethod/latin/RichInputConnection.java index 4d174ddb8..7cf64a3bc 100644 --- a/java/src/com/android/inputmethod/latin/RichInputConnection.java +++ b/java/src/com/android/inputmethod/latin/RichInputConnection.java @@ -685,6 +685,10 @@ public final class RichInputConnection { && !settingsValues.isWordConnector(codePointBeforeCursor)) { return true; } + return isCursorFollowedByWordCharacter(settingsValues); + } + + public boolean isCursorFollowedByWordCharacter(final SettingsValues settingsValues) { final CharSequence after = getTextAfterCursor(1, 0); if (!TextUtils.isEmpty(after) && !settingsValues.isWordSeparator(after.charAt(0)) && !settingsValues.isWordConnector(after.charAt(0))) { diff --git a/java/src/com/android/inputmethod/latin/SubtypeSwitcher.java b/java/src/com/android/inputmethod/latin/SubtypeSwitcher.java index b0ab60357..860575a1f 100644 --- a/java/src/com/android/inputmethod/latin/SubtypeSwitcher.java +++ b/java/src/com/android/inputmethod/latin/SubtypeSwitcher.java @@ -273,6 +273,18 @@ public final class SubtypeSwitcher { return mNeedsToDisplayLanguage.getValue(); } + public boolean isSystemLocaleSameAsLocaleOfAllEnabledSubtypes() { + final Locale systemLocale = mResources.getConfiguration().locale; + final List<InputMethodSubtype> enabledSubtypesOfThisIme = + mRichImm.getMyEnabledInputMethodSubtypeList(true); + for (final InputMethodSubtype subtype : enabledSubtypesOfThisIme) { + if (!systemLocale.equals(SubtypeLocaleUtils.getSubtypeLocale(subtype))) { + return false; + } + } + return true; + } + private static InputMethodSubtype sForcedSubtypeForTesting = null; @UsedForTesting void forceSubtype(final InputMethodSubtype subtype) { diff --git a/java/src/com/android/inputmethod/latin/WordComposer.java b/java/src/com/android/inputmethod/latin/WordComposer.java index f078c7346..b4f2d1a58 100644 --- a/java/src/com/android/inputmethod/latin/WordComposer.java +++ b/java/src/com/android/inputmethod/latin/WordComposer.java @@ -186,7 +186,7 @@ public final class WordComposer { // (See {@link #setBatchInputWord}). if (!mIsBatchMode) { // TODO: Set correct pointer id and time - mInputPointers.addPointer(newIndex, keyX, keyY, 0, 0); + mInputPointers.addPointerAt(newIndex, keyX, keyY, 0, 0); } } mIsFirstCharCapitalized = isFirstCharCapitalized( diff --git a/java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java b/java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java index b365003a5..968129a96 100644 --- a/java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java +++ b/java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java @@ -529,7 +529,7 @@ public final class InputLogic { // In languages with spaces, we only start composing a word when we are not already // touching a word. In languages without spaces, the above conditions are sufficient. (!mConnection.isCursorTouchingWord(settingsValues) - || !settingsValues.mCurrentLanguageHasSpaces)) { + || !settingsValues.mSpacingAndPunctuations.mCurrentLanguageHasSpaces)) { // Reset entirely the composing state anyway, then start composing a new word unless // the character is a single quote or a dash. The idea here is, single quote and dash // are not separators and they should be treated as normal characters, except in the @@ -594,7 +594,7 @@ public final class InputLogic { boolean didAutoCorrect = false; // We avoid sending spaces in languages without spaces if we were composing. final boolean shouldAvoidSendingCode = Constants.CODE_SPACE == codePoint - && !settingsValues.mCurrentLanguageHasSpaces + && !settingsValues.mSpacingAndPunctuations.mCurrentLanguageHasSpaces && mWordComposer.isComposingWord(); if (mWordComposer.isCursorFrontOrMiddleOfComposingWord()) { // If we are in the middle of a recorrection, we need to commit the recorrection @@ -813,7 +813,8 @@ public final class InputLogic { } } if (settingsValues.isSuggestionStripVisible() - && settingsValues.mCurrentLanguageHasSpaces) { + && settingsValues.mSpacingAndPunctuations.mCurrentLanguageHasSpaces + && !mConnection.isCursorFollowedByWordCharacter(settingsValues)) { restartSuggestionsOnWordTouchedByCursor(settingsValues, deleteCountAtStart - mDeleteCount /* offset */, true /* includeResumedWordInSuggestions */, keyboardSwitcher); @@ -911,8 +912,8 @@ public final class InputLogic { if (canBeFollowedByDoubleSpacePeriod(firstCodePoint)) { handler.cancelDoubleSpacePeriodTimer(); mConnection.deleteSurroundingText(2, 0); - final String textToInsert = new String( - new int[] { settingsValues.mSentenceSeparator, Constants.CODE_SPACE }, 0, 2); + final String textToInsert = + settingsValues.mSpacingAndPunctuations.mSentenceSeparatorAndSpace; mConnection.commitText(textToInsert, 1); if (ProductionFlag.USES_DEVELOPMENT_ONLY_DIAGNOSTICS) { ResearchLogger.latinIME_maybeDoubleSpacePeriod(textToInsert, @@ -966,7 +967,7 @@ public final class InputLogic { if (TextUtils.isEmpty(selectedText)) return; // Race condition with the input connection mRecapitalizeStatus.initialize(mLastSelectionStart, mLastSelectionEnd, selectedText.toString(), - settingsValues.mLocale, settingsValues.mWordSeparators); + settingsValues.mLocale, settingsValues.mSpacingAndPunctuations.mWordSeparators); // We trim leading and trailing whitespace. mRecapitalizeStatus.trim(); // Trimming the object may have changed the length of the string, and we need to @@ -1065,7 +1066,7 @@ public final class InputLogic { if (!mLatinIME.isSuggestionsStripVisible()) return; // Recorrection is not supported in languages without spaces because we don't know // how to segment them yet. - if (!settingsValues.mCurrentLanguageHasSpaces) return; + if (!settingsValues.mSpacingAndPunctuations.mCurrentLanguageHasSpaces) return; // If the cursor is not touching a word, or if there is a selection, return right away. if (mLastSelectionStart != mLastSelectionEnd) return; // If we don't know the cursor location, return. @@ -1073,7 +1074,8 @@ public final class InputLogic { final int expectedCursorPosition = mLastSelectionStart + offset; // We know Start == End if (!mConnection.isCursorTouchingWord(settingsValues)) return; final TextRange range = mConnection.getWordRangeAtCursor( - settingsValues.mWordSeparators, 0 /* additionalPrecedingWordsCount */); + settingsValues.mSpacingAndPunctuations.mWordSeparators, + 0 /* additionalPrecedingWordsCount */); if (null == range) return; // Happens if we don't have an input connection at all if (range.length() <= 0) return; // Race condition. No text to resume on, so bail out. // If for some strange reason (editor bug or so) we measure the text before the cursor as @@ -1113,8 +1115,19 @@ public final class InputLogic { keyboardSwitcher.getKeyboard()); mWordComposer.setCursorPositionWithinWord( typedWord.codePointCount(0, numberOfCharsInWordBeforeCursor)); - mConnection.setComposingRegion(expectedCursorPosition - numberOfCharsInWordBeforeCursor, + // TODO: Change these lines to setComposingRegion(cursorPosition, + // cursorPosition + range.getNumberOfCharsInWordAfterCursor()); + if (0 != offset) { + // Backspace was pressed. We are at the end of a word, and we don't know the cursor + // position for sure, so use relative methods. + mConnection.deleteSurroundingText(numberOfCharsInWordBeforeCursor, 0); + mConnection.setComposingText(typedWord, 1); + } else { + // This is recorrection. The cursor position is reasonably reliable, and the cursor + // may be in the middle of a word so use setComposingRegion. + mConnection.setComposingRegion(expectedCursorPosition - numberOfCharsInWordBeforeCursor, expectedCursorPosition + range.getNumberOfCharsInWordAfterCursor()); + } if (suggestions.isEmpty()) { // We come here if there weren't any suggestion spans on this word. We will try to // compute suggestions for it instead. @@ -1195,7 +1208,7 @@ public final class InputLogic { } } final String stringToCommit = originallyTypedWord + mLastComposedWord.mSeparatorString; - if (settingsValues.mCurrentLanguageHasSpaces) { + if (settingsValues.mSpacingAndPunctuations.mCurrentLanguageHasSpaces) { // For languages with spaces, we revert to the typed string, but the cursor is still // after the separator so we don't resume suggestions. If the user wants to correct // the word, they have to press backspace again. @@ -1295,7 +1308,7 @@ public final class InputLogic { // TODO: Make this private public String getNthPreviousWordForSuggestion(final SettingsValues currentSettings, final int nthPreviousWord) { - if (currentSettings.mCurrentLanguageHasSpaces) { + if (currentSettings.mSpacingAndPunctuations.mCurrentLanguageHasSpaces) { // If we are typing in a language with spaces we can just look up the previous // word from textview. return mConnection.getNthPreviousWord(currentSettings, nthPreviousWord); @@ -1386,7 +1399,7 @@ public final class InputLogic { if (settingsValues.mBigramPredictionEnabled) { mLatinIME.clearSuggestionStrip(); } else { - mLatinIME.setSuggestedWords(settingsValues.mSuggestPuncList); + mLatinIME.setSuggestedWords(settingsValues.mSpacingAndPunctuations.mSuggestPuncList); } mConnection.resetCachesUponCursorMoveAndReturnSuccess(newSelStart, newSelEnd, shouldFinishComposition); @@ -1495,7 +1508,7 @@ public final class InputLogic { // TODO: Make this private. public void promotePhantomSpace(final SettingsValues settingsValues) { if (settingsValues.shouldInsertSpacesAutomatically() - && settingsValues.mCurrentLanguageHasSpaces + && settingsValues.mSpacingAndPunctuations.mCurrentLanguageHasSpaces && !mConnection.textBeforeCursorLooksLikeURL()) { if (ProductionFlag.USES_DEVELOPMENT_ONLY_DIAGNOSTICS) { ResearchLogger.latinIME_promotePhantomSpace(); diff --git a/java/src/com/android/inputmethod/latin/personalization/PersonalizationDictionarySessionRegistrar.java b/java/src/com/android/inputmethod/latin/personalization/PersonalizationDictionarySessionRegistrar.java index 76965112f..d6c0dc0dc 100644 --- a/java/src/com/android/inputmethod/latin/personalization/PersonalizationDictionarySessionRegistrar.java +++ b/java/src/com/android/inputmethod/latin/personalization/PersonalizationDictionarySessionRegistrar.java @@ -19,11 +19,15 @@ package com.android.inputmethod.latin.personalization; import android.content.Context; import android.content.res.Configuration; +import com.android.inputmethod.latin.DictionaryFacilitatorForSuggest; + public class PersonalizationDictionarySessionRegistrar { - public static void init(final Context context) { + public static void init(final Context context, + final DictionaryFacilitatorForSuggest dictionaryFacilitator) { } - public static void onConfigurationChanged(final Context context, final Configuration conf) { + public static void onConfigurationChanged(final Context context, final Configuration conf, + final DictionaryFacilitatorForSuggest dictionaryFacilitator) { } public static void onUpdateData(final Context context, final String type) { @@ -35,6 +39,6 @@ public class PersonalizationDictionarySessionRegistrar { public static void resetAll(final Context context) { } - public static void onDestroy(final Context context) { + public static void close(final Context context) { } } diff --git a/java/src/com/android/inputmethod/latin/settings/Settings.java b/java/src/com/android/inputmethod/latin/settings/Settings.java index 75c7258ae..84ba7223a 100644 --- a/java/src/com/android/inputmethod/latin/settings/Settings.java +++ b/java/src/com/android/inputmethod/latin/settings/Settings.java @@ -176,7 +176,7 @@ public final class Settings implements SharedPreferences.OnSharedPreferenceChang } public String getWordSeparators() { - return mSettingsValues.mWordSeparators; + return mSettingsValues.mSpacingAndPunctuations.mWordSeparators; } public boolean isWordSeparator(final int code) { diff --git a/java/src/com/android/inputmethod/latin/settings/SettingsValues.java b/java/src/com/android/inputmethod/latin/settings/SettingsValues.java index a07a0cecf..3fa686ba7 100644 --- a/java/src/com/android/inputmethod/latin/settings/SettingsValues.java +++ b/java/src/com/android/inputmethod/latin/settings/SettingsValues.java @@ -26,20 +26,12 @@ import android.view.inputmethod.EditorInfo; import com.android.inputmethod.annotations.UsedForTesting; import com.android.inputmethod.compat.AppWorkaroundsUtils; -import com.android.inputmethod.keyboard.internal.KeySpecParser; -import com.android.inputmethod.latin.Constants; -import com.android.inputmethod.latin.Dictionary; import com.android.inputmethod.latin.InputAttributes; import com.android.inputmethod.latin.R; import com.android.inputmethod.latin.RichInputMethodManager; -import com.android.inputmethod.latin.SuggestedWords; -import com.android.inputmethod.latin.SuggestedWords.SuggestedWordInfo; import com.android.inputmethod.latin.utils.AsyncResultHolder; -import com.android.inputmethod.latin.utils.CollectionUtils; -import com.android.inputmethod.latin.utils.StringUtils; import com.android.inputmethod.latin.utils.TargetPackageInfoGetterTask; -import java.util.ArrayList; import java.util.Arrays; import java.util.Locale; @@ -56,15 +48,9 @@ public final class SettingsValues { private static final int TIMEOUT_TO_GET_TARGET_PACKAGE = 5; // seconds // From resources: + public final SpacingAndPunctuations mSpacingAndPunctuations; public final int mDelayUpdateOldSuggestions; - public final int[] mSymbolsPrecededBySpace; - public final int[] mSymbolsFollowedBySpace; - public final int[] mWordConnectors; - public final SuggestedWords mSuggestPuncList; - public final String mWordSeparators; - public final int mSentenceSeparator; public final CharSequence mHintToSaveText; - public final boolean mCurrentLanguageHasSpaces; // From preferences, in the same order as xml/prefs.xml: public final boolean mAutoCap; @@ -115,22 +101,8 @@ public final class SettingsValues { mLocale = locale; // Get the resources mDelayUpdateOldSuggestions = res.getInteger(R.integer.config_delay_update_old_suggestions); - mSymbolsPrecededBySpace = - StringUtils.toCodePointArray(res.getString(R.string.symbols_preceded_by_space)); - Arrays.sort(mSymbolsPrecededBySpace); - mSymbolsFollowedBySpace = - StringUtils.toCodePointArray(res.getString(R.string.symbols_followed_by_space)); - Arrays.sort(mSymbolsFollowedBySpace); - mWordConnectors = - StringUtils.toCodePointArray(res.getString(R.string.symbols_word_connectors)); - Arrays.sort(mWordConnectors); - final String[] suggestPuncsSpec = KeySpecParser.splitKeySpecs(res.getString( - R.string.suggested_punctuations)); - mSuggestPuncList = createSuggestPuncList(suggestPuncsSpec); - mWordSeparators = res.getString(R.string.symbols_word_separators); - mSentenceSeparator = res.getInteger(R.integer.sentence_separator); + mSpacingAndPunctuations = new SpacingAndPunctuations(res); mHintToSaveText = res.getText(R.string.hint_add_to_dictionary); - mCurrentLanguageHasSpaces = res.getBoolean(R.bool.current_language_has_spaces); // Store the input attributes if (null == inputAttributes) { @@ -199,18 +171,8 @@ public final class SettingsValues { // TODO: locale is saved, but not used yet. May have to change this if tests require. mLocale = locale; mDelayUpdateOldSuggestions = 0; - mSymbolsPrecededBySpace = new int[] { '(', '[', '{', '&' }; - Arrays.sort(mSymbolsPrecededBySpace); - mSymbolsFollowedBySpace = new int[] { '.', ',', ';', ':', '!', '?', ')', ']', '}', '&' }; - Arrays.sort(mSymbolsFollowedBySpace); - mWordConnectors = new int[] { '\'', '-' }; - Arrays.sort(mWordConnectors); - mSentenceSeparator = Constants.CODE_PERIOD; - final String[] suggestPuncsSpec = new String[] { "!", "?", ",", ":", ";" }; - mSuggestPuncList = createSuggestPuncList(suggestPuncsSpec); - mWordSeparators = "&\t \n()[]{}*&<>+=|.,;:!?/_\""; + mSpacingAndPunctuations = SpacingAndPunctuations.DEFAULT; mHintToSaveText = "Touch again to save"; - mCurrentLanguageHasSpaces = true; mInputAttributes = new InputAttributes(null, false /* isFullscreenMode */); mAutoCap = true; mVibrateOn = true; @@ -265,11 +227,11 @@ public final class SettingsValues { } public boolean isWordSeparator(final int code) { - return mWordSeparators.contains(String.valueOf((char)code)); + return mSpacingAndPunctuations.isWordSeparator(code); } public boolean isWordConnector(final int code) { - return Arrays.binarySearch(mWordConnectors, code) >= 0; + return mSpacingAndPunctuations.isWordConnector(code); } public boolean isWordCodePoint(final int code) { @@ -277,11 +239,11 @@ public final class SettingsValues { } public boolean isUsuallyPrecededBySpace(final int code) { - return Arrays.binarySearch(mSymbolsPrecededBySpace, code) >= 0; + return mSpacingAndPunctuations.isUsuallyPrecededBySpace(code); } public boolean isUsuallyFollowedBySpace(final int code) { - return Arrays.binarySearch(mSymbolsFollowedBySpace, code) >= 0; + return mSpacingAndPunctuations.isUsuallyFollowedBySpace(code); } public boolean shouldInsertSpacesAutomatically() { @@ -320,27 +282,6 @@ public final class SettingsValues { return null == appWorkaroundUtils ? false : appWorkaroundUtils.isBrokenByRecorrection(); } - // Helper functions to create member values. - private static SuggestedWords createSuggestPuncList(final String[] puncs) { - final ArrayList<SuggestedWordInfo> puncList = CollectionUtils.newArrayList(); - if (puncs != null) { - for (final String puncSpec : puncs) { - // TODO: Stop using KeySpceParser.getLabel(). - puncList.add(new SuggestedWordInfo(KeySpecParser.getLabel(puncSpec), - SuggestedWordInfo.MAX_SCORE, SuggestedWordInfo.KIND_HARDCODED, - Dictionary.DICTIONARY_HARDCODED, - SuggestedWordInfo.NOT_AN_INDEX /* indexOfTouchPointOfSecondWord */, - SuggestedWordInfo.NOT_A_CONFIDENCE /* autoCommitFirstWordConfidence */)); - } - } - return new SuggestedWords(puncList, - false /* typedWordValid */, - false /* hasAutoCorrectionCandidate */, - true /* isPunctuationSuggestions */, - false /* isObsoleteSuggestions */, - false /* isPrediction */); - } - private static final int SUGGESTION_VISIBILITY_SHOW_VALUE = R.string.prefs_suggestion_visibility_show_value; private static final int SUGGESTION_VISIBILITY_SHOW_ONLY_PORTRAIT_VALUE = diff --git a/java/src/com/android/inputmethod/latin/settings/SpacingAndPunctuations.java b/java/src/com/android/inputmethod/latin/settings/SpacingAndPunctuations.java new file mode 100644 index 000000000..0500f4ad4 --- /dev/null +++ b/java/src/com/android/inputmethod/latin/settings/SpacingAndPunctuations.java @@ -0,0 +1,124 @@ +/* + * Copyright (C) 2014 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.settings; + +import android.content.res.Resources; + +import com.android.inputmethod.keyboard.internal.KeySpecParser; +import com.android.inputmethod.latin.Constants; +import com.android.inputmethod.latin.Dictionary; +import com.android.inputmethod.latin.R; +import com.android.inputmethod.latin.SuggestedWords; +import com.android.inputmethod.latin.SuggestedWords.SuggestedWordInfo; +import com.android.inputmethod.latin.utils.CollectionUtils; +import com.android.inputmethod.latin.utils.StringUtils; + +import java.util.ArrayList; +import java.util.Arrays; + +public final class SpacingAndPunctuations { + private final int[] mSymbolsPrecededBySpace; + private final int[] mSymbolsFollowedBySpace; + private final int[] mWordConnectors; + public final SuggestedWords mSuggestPuncList; + public final String mWordSeparators; + private final int mSentenceSeparator; + public final String mSentenceSeparatorAndSpace; + public final boolean mCurrentLanguageHasSpaces; + + public static final SpacingAndPunctuations DEFAULT = new SpacingAndPunctuations(); + + private SpacingAndPunctuations() { + mSymbolsPrecededBySpace = new int[] { '(', '[', '{', '&' }; + Arrays.sort(mSymbolsPrecededBySpace); + mSymbolsFollowedBySpace = new int[] { '.', ',', ';', ':', '!', '?', ')', ']', '}', '&' }; + Arrays.sort(mSymbolsFollowedBySpace); + mWordConnectors = new int[] { '\'', '-' }; + Arrays.sort(mWordConnectors); + mSentenceSeparator = Constants.CODE_PERIOD; + mSentenceSeparatorAndSpace = ". "; + final String[] suggestPuncsSpec = new String[] { "!", "?", ",", ":", ";" }; + mSuggestPuncList = createSuggestPuncList(suggestPuncsSpec); + mWordSeparators = "&\t \n()[]{}*&<>+=|.,;:!?/_\""; + mCurrentLanguageHasSpaces = true; + } + + public SpacingAndPunctuations(final Resources res) { + mSymbolsPrecededBySpace = + StringUtils.toCodePointArray(res.getString(R.string.symbols_preceded_by_space)); + Arrays.sort(mSymbolsPrecededBySpace); + mSymbolsFollowedBySpace = + StringUtils.toCodePointArray(res.getString(R.string.symbols_followed_by_space)); + Arrays.sort(mSymbolsFollowedBySpace); + mWordConnectors = + StringUtils.toCodePointArray(res.getString(R.string.symbols_word_connectors)); + Arrays.sort(mWordConnectors); + final String[] suggestPuncsSpec = KeySpecParser.splitKeySpecs(res.getString( + R.string.suggested_punctuations)); + mSuggestPuncList = createSuggestPuncList(suggestPuncsSpec); + mWordSeparators = res.getString(R.string.symbols_word_separators); + mSentenceSeparator = res.getInteger(R.integer.sentence_separator); + mSentenceSeparatorAndSpace = new String(new int[] { + mSentenceSeparator, Constants.CODE_SPACE }, 0, 2); + mCurrentLanguageHasSpaces = res.getBoolean(R.bool.current_language_has_spaces); + } + + // Helper functions to create member values. + private static SuggestedWords createSuggestPuncList(final String[] puncs) { + final ArrayList<SuggestedWordInfo> puncList = CollectionUtils.newArrayList(); + if (puncs != null) { + for (final String puncSpec : puncs) { + // TODO: Stop using KeySpceParser.getLabel(). + puncList.add(new SuggestedWordInfo(KeySpecParser.getLabel(puncSpec), + SuggestedWordInfo.MAX_SCORE, SuggestedWordInfo.KIND_HARDCODED, + Dictionary.DICTIONARY_HARDCODED, + SuggestedWordInfo.NOT_AN_INDEX /* indexOfTouchPointOfSecondWord */, + SuggestedWordInfo.NOT_A_CONFIDENCE /* autoCommitFirstWordConfidence */)); + } + } + return new SuggestedWords(puncList, + false /* typedWordValid */, + false /* hasAutoCorrectionCandidate */, + true /* isPunctuationSuggestions */, + false /* isObsoleteSuggestions */, + false /* isPrediction */); + } + + public boolean isWordSeparator(final int code) { + return mWordSeparators.contains(String.valueOf((char)code)); + } + + public boolean isWordConnector(final int code) { + return Arrays.binarySearch(mWordConnectors, code) >= 0; + } + + public boolean isWordCodePoint(final int code) { + return Character.isLetter(code) || isWordConnector(code); + } + + public boolean isUsuallyPrecededBySpace(final int code) { + return Arrays.binarySearch(mSymbolsPrecededBySpace, code) >= 0; + } + + public boolean isUsuallyFollowedBySpace(final int code) { + return Arrays.binarySearch(mSymbolsFollowedBySpace, code) >= 0; + } + + public boolean isSentenceSeparator(final int code) { + return code == mSentenceSeparator; + } +} diff --git a/java/src/com/android/inputmethod/latin/utils/CapsModeUtils.java b/java/src/com/android/inputmethod/latin/utils/CapsModeUtils.java index 3d4404a98..6ad5c77d5 100644 --- a/java/src/com/android/inputmethod/latin/utils/CapsModeUtils.java +++ b/java/src/com/android/inputmethod/latin/utils/CapsModeUtils.java @@ -191,7 +191,7 @@ public final class CapsModeUtils { if (c == Constants.CODE_QUESTION_MARK || c == Constants.CODE_EXCLAMATION_MARK) { return (TextUtils.CAP_MODE_CHARACTERS | TextUtils.CAP_MODE_SENTENCES) & reqModes; } - if (settingsValues.mSentenceSeparator != c || j <= 0) { + if (!settingsValues.mSpacingAndPunctuations.isSentenceSeparator(c) || j <= 0) { return (TextUtils.CAP_MODE_CHARACTERS | TextUtils.CAP_MODE_WORDS) & reqModes; } @@ -241,7 +241,7 @@ public final class CapsModeUtils { case WORD: if (Character.isLetter(c)) { state = WORD; - } else if (settingsValues.mSentenceSeparator == c) { + } else if (settingsValues.mSpacingAndPunctuations.isSentenceSeparator(c)) { state = PERIOD; } else { return caps; @@ -257,7 +257,7 @@ public final class CapsModeUtils { case LETTER: if (Character.isLetter(c)) { state = LETTER; - } else if (settingsValues.mSentenceSeparator == c) { + } else if (settingsValues.mSpacingAndPunctuations.isSentenceSeparator(c)) { state = PERIOD; } else { return noCaps; diff --git a/java/src/com/android/inputmethod/latin/utils/ResizableIntArray.java b/java/src/com/android/inputmethod/latin/utils/ResizableIntArray.java index 7c6fe93ac..64c9e2cff 100644 --- a/java/src/com/android/inputmethod/latin/utils/ResizableIntArray.java +++ b/java/src/com/android/inputmethod/latin/utils/ResizableIntArray.java @@ -34,7 +34,7 @@ public final class ResizableIntArray { throw new ArrayIndexOutOfBoundsException("length=" + mLength + "; index=" + index); } - public void add(final int index, final int val) { + public void addAt(final int index, final int val) { if (index < mLength) { mArray[index] = val; } else { |