diff options
Diffstat (limited to 'java/src/com/android/inputmethod/latin/inputlogic')
| -rw-r--r-- | java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java | 249 |
1 files changed, 120 insertions, 129 deletions
diff --git a/java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java b/java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java index daaac5913..dd9d6e8a9 100644 --- a/java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java +++ b/java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java @@ -205,9 +205,9 @@ public final class InputLogic { LatinImeLogger.logOnManualSuggestion("", suggestion, index, suggestedWords); // Rely on onCodeInput to do the complicated swapping/stripping logic consistently. final int primaryCode = suggestion.charAt(0); - onCodeInput(primaryCode, + onCodeInput(settingsValues, primaryCode, Constants.SUGGESTION_STRIP_COORDINATE, Constants.SUGGESTION_STRIP_COORDINATE, - settingsValues, handler, keyboardSwitcher); + keyboardSwitcher.getKeyboardShiftMode(), handler); if (ProductionFlag.USES_DEVELOPMENT_ONLY_DIAGNOSTICS) { ResearchLogger.latinIME_punctuationSuggestion(index, suggestion, false /* isBatchMode */, suggestedWords.mIsPrediction); @@ -353,49 +353,48 @@ public final class InputLogic { * Typically, this is called whenever a key is pressed on the software keyboard. This is not * the entry point for gesture input; see the onBatchInput* family of functions for this. * + * @param settingsValues the current settings values. * @param code the code to handle. It may be a code point, or an internal key code. * @param x the x-coordinate where the user pressed the key, or NOT_A_COORDINATE. * @param y the y-coordinate where the user pressed the key, or NOT_A_COORDINATE. + * @param keyboardShiftMode the current shift mode of the keyboard, as returned by + * {@link com.android.inputmethod.keyboard.KeyboardSwitcher#getKeyboardShiftMode()} + * @return the complete transaction object */ - public void onCodeInput(final int code, final int x, final int y, - final SettingsValues settingsValues, - // TODO: remove these two arguments - final LatinIME.UIHandler handler, final KeyboardSwitcher keyboardSwitcher) { + public InputTransaction onCodeInput(final SettingsValues settingsValues, final int code, + final int x, final int y, final int keyboardShiftMode, + // TODO: remove this argument + final LatinIME.UIHandler handler) { + final InputTransaction inputTransaction = new InputTransaction(settingsValues, code, x, y, + SystemClock.uptimeMillis(), mSpaceState, + getActualCapsMode(settingsValues, keyboardShiftMode)); if (ProductionFlag.USES_DEVELOPMENT_ONLY_DIAGNOSTICS) { - ResearchLogger.latinIME_onCodeInput(code, x, y); + ResearchLogger.latinIME_onCodeInput(inputTransaction.mKeyCode, + inputTransaction.mX, inputTransaction.mY); } - final long when = SystemClock.uptimeMillis(); - final InputTransaction inputTransaction = new InputTransaction( - getActualCapsMode(settingsValues, keyboardSwitcher.getKeyboardShiftMode())); - if (code != Constants.CODE_DELETE - || when > mLastKeyTime + Constants.LONG_PRESS_MILLISECONDS) { + if (inputTransaction.mKeyCode != Constants.CODE_DELETE + || inputTransaction.mTimestamp > mLastKeyTime + Constants.LONG_PRESS_MILLISECONDS) { mDeleteCount = 0; } - mLastKeyTime = when; + mLastKeyTime = inputTransaction.mTimestamp; mConnection.beginBatchEdit(); - // The space state depends only on the last character pressed and its own previous - // state. Here, we revert the space state to neutral if the key is actually modifying - // the input contents (any non-shift key), which is what we should do for - // all inputs that do not result in a special state. Each character handling is then - // free to override the state as they see fit. - final int spaceState = mSpaceState; if (!mWordComposer.isComposingWord()) { mIsAutoCorrectionIndicatorOn = false; } // TODO: Consolidate the double-space period timer, mLastKeyTime, and the space state. - if (code != Constants.CODE_SPACE) { + if (inputTransaction.mKeyCode != Constants.CODE_SPACE) { handler.cancelDoubleSpacePeriodTimer(); } boolean didAutoCorrect = false; - switch (code) { + switch (inputTransaction.mKeyCode) { case Constants.CODE_DELETE: - handleBackspace(settingsValues, spaceState, inputTransaction, handler); - LatinImeLogger.logOnDelete(x, y); + handleBackspace(inputTransaction, handler); + LatinImeLogger.logOnDelete(inputTransaction.mX, inputTransaction.mY); break; case Constants.CODE_SHIFT: - performRecapitalization(settingsValues); + performRecapitalization(inputTransaction.mSettingsValues); inputTransaction.requireShiftUpdate(InputTransaction.SHIFT_UPDATE_NOW); break; case Constants.CODE_CAPSLOCK: @@ -450,41 +449,35 @@ public final class InputLogic { } else { // No action label, and the action from imeOptions is NONE: this is a regular // enter key that should input a carriage return. - didAutoCorrect = handleNonSpecialCharacter(settingsValues, Constants.CODE_ENTER, - x, y, spaceState, inputTransaction, handler); + didAutoCorrect = handleNonSpecialCharacter(inputTransaction, handler); } break; case Constants.CODE_SHIFT_ENTER: - didAutoCorrect = handleNonSpecialCharacter(settingsValues, Constants.CODE_ENTER, - x, y, spaceState, inputTransaction, handler); + // TODO: remove this object + final InputTransaction tmpTransaction = new InputTransaction( + inputTransaction.mSettingsValues, inputTransaction.mKeyCode, + inputTransaction.mX, inputTransaction.mY, inputTransaction.mTimestamp, + inputTransaction.mSpaceState, inputTransaction.mShiftState); + didAutoCorrect = handleNonSpecialCharacter(tmpTransaction, handler); break; case Constants.CODE_ALPHA_FROM_EMOJI: // Note: Switching back from Emoji keyboard to the main keyboard is being handled in // {@link KeyboardState#onCodeInput(int,int)}. break; default: - didAutoCorrect = handleNonSpecialCharacter(settingsValues, - code, x, y, spaceState, inputTransaction, handler); + didAutoCorrect = handleNonSpecialCharacter(inputTransaction, handler); break; } // Reset after any single keystroke, except shift, capslock, and symbol-shift - if (!didAutoCorrect && code != Constants.CODE_SHIFT - && code != Constants.CODE_CAPSLOCK - && code != Constants.CODE_SWITCH_ALPHA_SYMBOL) + if (!didAutoCorrect && inputTransaction.mKeyCode != Constants.CODE_SHIFT + && inputTransaction.mKeyCode != Constants.CODE_CAPSLOCK + && inputTransaction.mKeyCode != Constants.CODE_SWITCH_ALPHA_SYMBOL) mLastComposedWord.deactivate(); - if (Constants.CODE_DELETE != code) { + if (Constants.CODE_DELETE != inputTransaction.mKeyCode) { mEnteredText = null; } mConnection.endBatchEdit(); - switch (inputTransaction.getRequiredShiftUpdate()) { - case InputTransaction.SHIFT_UPDATE_LATER: - mLatinIME.mHandler.postUpdateShiftState(); - break; - case InputTransaction.SHIFT_UPDATE_NOW: - keyboardSwitcher.updateShiftState(); - break; - default: // SHIFT_NO_UPDATE - } + return inputTransaction; } public void onStartBatchInput(final SettingsValues settingsValues, @@ -628,33 +621,26 @@ public final class InputLogic { * manage keyboard-related stuff like shift, language switch, settings, layout switch, or * any key that results in multiple code points like the ".com" key. * - * @param settingsValues The current settings values. - * @param codePoint the code point associated with the key. - * @param x the x-coordinate of the key press, or Contants.NOT_A_COORDINATE if not applicable. - * @param y the y-coordinate of the key press, or Contants.NOT_A_COORDINATE if not applicable. - * @param spaceState the space state at start of the batch input. * @param inputTransaction The transaction in progress. * @return whether this caused an auto-correction to happen. */ - private boolean handleNonSpecialCharacter(final SettingsValues settingsValues, - final int codePoint, final int x, final int y, final int spaceState, - final InputTransaction inputTransaction, + private boolean handleNonSpecialCharacter(final InputTransaction inputTransaction, // TODO: remove this argument final LatinIME.UIHandler handler) { mSpaceState = SpaceState.NONE; final boolean didAutoCorrect; - if (settingsValues.isWordSeparator(codePoint) - || Character.getType(codePoint) == Character.OTHER_SYMBOL) { - didAutoCorrect = handleSeparator(settingsValues, codePoint, - Constants.SUGGESTION_STRIP_COORDINATE == x, spaceState, inputTransaction, - handler); - if (settingsValues.mIsInternal) { - LatinImeLoggerUtils.onSeparator((char)codePoint, x, y); + if (inputTransaction.mSettingsValues.isWordSeparator(inputTransaction.mKeyCode) + || Character.getType(inputTransaction.mKeyCode) == Character.OTHER_SYMBOL) { + didAutoCorrect = handleSeparator(inputTransaction, + Constants.SUGGESTION_STRIP_COORDINATE == inputTransaction.mX, handler); + if (inputTransaction.mSettingsValues.mIsInternal) { + LatinImeLoggerUtils.onSeparator((char)inputTransaction.mKeyCode, + inputTransaction.mX, inputTransaction.mY); } } else { didAutoCorrect = false; - if (SpaceState.PHANTOM == spaceState) { - if (settingsValues.mIsInternal) { + if (SpaceState.PHANTOM == inputTransaction.mSpaceState) { + if (inputTransaction.mSettingsValues.mIsInternal) { if (mWordComposer.isComposingWord() && mWordComposer.isBatchMode()) { LatinImeLoggerUtils.onAutoCorrection("", mWordComposer.getTypedWord(), " ", mWordComposer); @@ -666,11 +652,10 @@ public final class InputLogic { resetEntireInputState(mConnection.getExpectedSelectionStart(), mConnection.getExpectedSelectionEnd(), true /* clearSuggestionStrip */); } else { - commitTyped(settingsValues, LastComposedWord.NOT_A_SEPARATOR); + commitTyped(inputTransaction.mSettingsValues, LastComposedWord.NOT_A_SEPARATOR); } } - handleNonSeparator(settingsValues, codePoint, x, y, spaceState, - inputTransaction, handler); + handleNonSeparator(inputTransaction.mSettingsValues, inputTransaction, handler); } return didAutoCorrect; } @@ -678,14 +663,9 @@ public final class InputLogic { /** * Handle a non-separator. * @param settingsValues The current settings values. - * @param codePoint the code point associated with the key. - * @param x the x-coordinate of the key press, or Contants.NOT_A_COORDINATE if not applicable. - * @param y the y-coordinate of the key press, or Contants.NOT_A_COORDINATE if not applicable. - * @param spaceState the space state at start of the batch input. * @param inputTransaction The transaction in progress. */ private void handleNonSeparator(final SettingsValues settingsValues, - final int codePoint, final int x, final int y, final int spaceState, final InputTransaction inputTransaction, // TODO: Remove this argument final LatinIME.UIHandler handler) { @@ -696,7 +676,8 @@ public final class InputLogic { // TODO: remove isWordConnector() and use isUsuallyFollowedBySpace() instead. // See onStartBatchInput() to see how to do it. - if (SpaceState.PHANTOM == spaceState && !settingsValues.isWordConnector(codePoint)) { + if (SpaceState.PHANTOM == inputTransaction.mSpaceState + && !settingsValues.isWordConnector(inputTransaction.mKeyCode)) { if (isComposingWord) { // Sanity check throw new RuntimeException("Should not be composing here"); @@ -718,7 +699,7 @@ public final class InputLogic { if (!isComposingWord // We only start composing if this is a word code point. Essentially that means it's a // a letter or a word connector. - && settingsValues.isWordCodePoint(codePoint) + && settingsValues.isWordCodePoint(inputTransaction.mKeyCode) // We never go into composing state if suggestions are not requested. && settingsValues.isSuggestionsRequested() && // In languages with spaces, we only start composing a word when we are not already @@ -729,8 +710,8 @@ public final class InputLogic { // 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 // first position where they should not start composing a word. - isComposingWord = (Constants.CODE_SINGLE_QUOTE != codePoint - && Constants.CODE_DASH != codePoint); + isComposingWord = (Constants.CODE_SINGLE_QUOTE != inputTransaction.mKeyCode + && Constants.CODE_DASH != inputTransaction.mKeyCode); // Here we don't need to reset the last composed word. It will be reset // when we commit this one, if we ever do; if on the other hand we backspace // it entirely and resume suggestions on the previous word, we'd like to still @@ -738,7 +719,7 @@ public final class InputLogic { resetComposingState(false /* alsoResetLastComposedWord */); } if (isComposingWord) { - mWordComposer.add(codePoint, x, y); + mWordComposer.add(inputTransaction.mKeyCode, inputTransaction.mX, inputTransaction.mY); // If it's the first letter, make note of auto-caps state if (mWordComposer.size() == 1) { // We pass 1 to getPreviousWordForSuggestion because we were not composing a word @@ -750,10 +731,10 @@ public final class InputLogic { mConnection.setComposingText(getTextWithUnderline( mWordComposer.getTypedWord()), 1); } else { - final boolean swapWeakSpace = maybeStripSpace(settingsValues, - codePoint, spaceState, Constants.SUGGESTION_STRIP_COORDINATE == x); + final boolean swapWeakSpace = maybeStripSpace(inputTransaction, + Constants.SUGGESTION_STRIP_COORDINATE == inputTransaction.mX); - sendKeyCodePoint(settingsValues, codePoint); + sendKeyCodePoint(settingsValues, inputTransaction.mKeyCode); if (swapWeakSpace) { swapSwapperAndSpace(inputTransaction); @@ -764,28 +745,26 @@ public final class InputLogic { } handler.postUpdateSuggestionStrip(); if (settingsValues.mIsInternal) { - LatinImeLoggerUtils.onNonSeparator((char)codePoint, x, y); + LatinImeLoggerUtils.onNonSeparator((char)inputTransaction.mKeyCode, inputTransaction.mX, + inputTransaction.mY); } } /** * Handle input of a separator code point. - * @param settingsValues The current settings values. - * @param codePoint the code point associated with the key. - * @param isFromSuggestionStrip whether this code point comes from the suggestion strip. - * @param spaceState the space state at start of the batch input. * @param inputTransaction The transaction in progress. + * @param isFromSuggestionStrip whether this code point comes from the suggestion strip. * @return whether this caused an auto-correction to happen. */ - private boolean handleSeparator(final SettingsValues settingsValues, - final int codePoint, final boolean isFromSuggestionStrip, final int spaceState, - final InputTransaction inputTransaction, + private boolean handleSeparator(final InputTransaction inputTransaction, + final boolean isFromSuggestionStrip, // TODO: remove this argument final LatinIME.UIHandler handler) { boolean didAutoCorrect = false; // We avoid sending spaces in languages without spaces if we were composing. - final boolean shouldAvoidSendingCode = Constants.CODE_SPACE == codePoint - && !settingsValues.mSpacingAndPunctuations.mCurrentLanguageHasSpaces + final boolean shouldAvoidSendingCode = Constants.CODE_SPACE == inputTransaction.mKeyCode + && !inputTransaction.mSettingsValues.mSpacingAndPunctuations + .mCurrentLanguageHasSpaces && mWordComposer.isComposingWord(); if (mWordComposer.isCursorFrontOrMiddleOfComposingWord()) { // If we are in the middle of a recorrection, we need to commit the recorrection @@ -795,47 +774,50 @@ public final class InputLogic { } // isComposingWord() may have changed since we stored wasComposing if (mWordComposer.isComposingWord()) { - if (settingsValues.mCorrectionEnabled) { + if (inputTransaction.mSettingsValues.mCorrectionEnabled) { final String separator = shouldAvoidSendingCode ? LastComposedWord.NOT_A_SEPARATOR - : StringUtils.newSingleCodePointString(codePoint); - commitCurrentAutoCorrection(settingsValues, separator, handler); + : StringUtils.newSingleCodePointString(inputTransaction.mKeyCode); + commitCurrentAutoCorrection(inputTransaction.mSettingsValues, separator, handler); didAutoCorrect = true; } else { - commitTyped(settingsValues, StringUtils.newSingleCodePointString(codePoint)); + commitTyped(inputTransaction.mSettingsValues, + StringUtils.newSingleCodePointString(inputTransaction.mKeyCode)); } } - final boolean swapWeakSpace = maybeStripSpace(settingsValues, codePoint, spaceState, - isFromSuggestionStrip); + final boolean swapWeakSpace = maybeStripSpace(inputTransaction, isFromSuggestionStrip); - final boolean isInsideDoubleQuoteOrAfterDigit = Constants.CODE_DOUBLE_QUOTE == codePoint + final boolean isInsideDoubleQuoteOrAfterDigit = + Constants.CODE_DOUBLE_QUOTE == inputTransaction.mKeyCode && mConnection.isInsideDoubleQuoteOrAfterDigit(); final boolean needsPrecedingSpace; - if (SpaceState.PHANTOM != spaceState) { + if (SpaceState.PHANTOM != inputTransaction.mSpaceState) { needsPrecedingSpace = false; - } else if (Constants.CODE_DOUBLE_QUOTE == codePoint) { + } else if (Constants.CODE_DOUBLE_QUOTE == inputTransaction.mKeyCode) { // Double quotes behave like they are usually preceded by space iff we are // not inside a double quote or after a digit. needsPrecedingSpace = !isInsideDoubleQuoteOrAfterDigit; } else { - needsPrecedingSpace = settingsValues.isUsuallyPrecededBySpace(codePoint); + needsPrecedingSpace = inputTransaction.mSettingsValues.isUsuallyPrecededBySpace( + inputTransaction.mKeyCode); } if (needsPrecedingSpace) { - promotePhantomSpace(settingsValues); + promotePhantomSpace(inputTransaction.mSettingsValues); } if (ProductionFlag.USES_DEVELOPMENT_ONLY_DIAGNOSTICS) { - ResearchLogger.latinIME_handleSeparator(codePoint, mWordComposer.isComposingWord()); + ResearchLogger.latinIME_handleSeparator(inputTransaction.mKeyCode, + mWordComposer.isComposingWord()); } if (!shouldAvoidSendingCode) { - sendKeyCodePoint(settingsValues, codePoint); + sendKeyCodePoint(inputTransaction.mSettingsValues, inputTransaction.mKeyCode); } - if (Constants.CODE_SPACE == codePoint) { - if (settingsValues.isSuggestionsRequested()) { - if (maybeDoubleSpacePeriod(settingsValues, handler)) { + if (Constants.CODE_SPACE == inputTransaction.mKeyCode) { + if (inputTransaction.mSettingsValues.isSuggestionsRequested()) { + if (maybeDoubleSpacePeriod(inputTransaction.mSettingsValues, handler)) { inputTransaction.requireShiftUpdate(InputTransaction.SHIFT_UPDATE_NOW); mSpaceState = SpaceState.DOUBLE; } else if (!mSuggestedWords.isPunctuationSuggestions()) { @@ -849,9 +831,10 @@ public final class InputLogic { if (swapWeakSpace) { swapSwapperAndSpace(inputTransaction); mSpaceState = SpaceState.SWAP_PUNCTUATION; - } else if ((SpaceState.PHANTOM == spaceState - && settingsValues.isUsuallyFollowedBySpace(codePoint)) - || (Constants.CODE_DOUBLE_QUOTE == codePoint + } else if ((SpaceState.PHANTOM == inputTransaction.mSpaceState + && inputTransaction.mSettingsValues.isUsuallyFollowedBySpace( + inputTransaction.mKeyCode)) + || (Constants.CODE_DOUBLE_QUOTE == inputTransaction.mKeyCode && isInsideDoubleQuoteOrAfterDigit)) { // If we are in phantom space state, and the user presses a separator, we want to // stay in phantom space state so that the next keypress has a chance to add the @@ -878,12 +861,9 @@ public final class InputLogic { /** * Handle a press on the backspace key. - * @param settingsValues The current settings values. - * @param spaceState The space state at start of this batch edit. * @param inputTransaction The transaction in progress. */ - private void handleBackspace(final SettingsValues settingsValues, final int spaceState, - final InputTransaction inputTransaction, + private void handleBackspace(final InputTransaction inputTransaction, // TODO: remove this argument final LatinIME.UIHandler handler) { mSpaceState = SpaceState.NONE; @@ -922,10 +902,10 @@ public final class InputLogic { } } else { if (mLastComposedWord.canRevertCommit()) { - if (settingsValues.mIsInternal) { + if (inputTransaction.mSettingsValues.mIsInternal) { LatinImeLoggerUtils.onAutoCorrectionCancellation(); } - revertCommit(settingsValues, handler); + revertCommit(inputTransaction.mSettingsValues, handler); return; } if (mEnteredText != null && mConnection.sameAsTextBeforeCursor(mEnteredText)) { @@ -942,14 +922,14 @@ public final class InputLogic { // reverting any autocorrect at this point. So we can safely return. return; } - if (SpaceState.DOUBLE == spaceState) { + if (SpaceState.DOUBLE == inputTransaction.mSpaceState) { handler.cancelDoubleSpacePeriodTimer(); if (mConnection.revertDoubleSpacePeriod()) { // No need to reset mSpaceState, it has already be done (that's why we // receive it as a parameter) return; } - } else if (SpaceState.SWAP_PUNCTUATION == spaceState) { + } else if (SpaceState.SWAP_PUNCTUATION == inputTransaction.mSpaceState) { if (mConnection.revertSwapPunctuation()) { // Likewise return; @@ -975,8 +955,8 @@ public final class InputLogic { // This should never happen. Log.e(TAG, "Backspace when we don't know the selection position"); } - if (settingsValues.isBeforeJellyBean() || - settingsValues.mInputAttributes.isTypeNull()) { + if (inputTransaction.mSettingsValues.isBeforeJellyBean() || + inputTransaction.mSettingsValues.mInputAttributes.isTypeNull()) { // There are two possible reasons to send a key event: either the field has // type TYPE_NULL, in which case the keyboard should send events, or we are // running in backward compatibility mode. Before Jelly bean, the keyboard @@ -1022,11 +1002,12 @@ public final class InputLogic { } } } - if (settingsValues.isSuggestionStripVisible() - && settingsValues.mSpacingAndPunctuations.mCurrentLanguageHasSpaces + if (inputTransaction.mSettingsValues.isSuggestionStripVisible() + && inputTransaction.mSettingsValues.mSpacingAndPunctuations + .mCurrentLanguageHasSpaces && !mConnection.isCursorFollowedByWordCharacter( - settingsValues.mSpacingAndPunctuations)) { - restartSuggestionsOnWordTouchedByCursor(settingsValues, + inputTransaction.mSettingsValues.mSpacingAndPunctuations)) { + restartSuggestionsOnWordTouchedByCursor(inputTransaction.mSettingsValues, true /* includeResumedWordInSuggestions */); } // We just removed at least one character. We need to update the auto-caps state. @@ -1064,22 +1045,28 @@ public final class InputLogic { /* * Strip a trailing space if necessary and returns whether it's a swap weak space situation. - * @param settingsValues The current settings values. - * @param codePoint The code point that is about to be inserted. - * @param spaceState The space state at start of this batch edit. + * @param inputTransaction The transaction in progress. * @param isFromSuggestionStrip Whether this code point is coming from the suggestion strip. * @return whether we should swap the space instead of removing it. */ - private boolean maybeStripSpace(final SettingsValues settingsValues, - final int code, final int spaceState, final boolean isFromSuggestionStrip) { - if (Constants.CODE_ENTER == code && SpaceState.SWAP_PUNCTUATION == spaceState) { + private boolean maybeStripSpace(final InputTransaction inputTransaction, + final boolean isFromSuggestionStrip) { + if (Constants.CODE_ENTER == inputTransaction.mKeyCode && + SpaceState.SWAP_PUNCTUATION == inputTransaction.mSpaceState) { mConnection.removeTrailingSpace(); return false; } - if ((SpaceState.WEAK == spaceState || SpaceState.SWAP_PUNCTUATION == spaceState) + if ((SpaceState.WEAK == inputTransaction.mSpaceState + || SpaceState.SWAP_PUNCTUATION == inputTransaction.mSpaceState) && isFromSuggestionStrip) { - if (settingsValues.isUsuallyPrecededBySpace(code)) return false; - if (settingsValues.isUsuallyFollowedBySpace(code)) return true; + if (inputTransaction.mSettingsValues.isUsuallyPrecededBySpace( + inputTransaction.mKeyCode)) { + return false; + } + if (inputTransaction.mSettingsValues.isUsuallyFollowedBySpace( + inputTransaction.mKeyCode)) { + return true; + } mConnection.removeTrailingSpace(); } return false; @@ -1313,7 +1300,10 @@ public final class InputLogic { SuggestedWordInfo.NOT_AN_INDEX /* indexOfTouchPointOfSecondWord */, SuggestedWordInfo.NOT_A_CONFIDENCE /* autoCommitFirstWordConfidence */)); } - if (!isResumableWord(settingsValues, typedWord)) return; + if (!isResumableWord(settingsValues, typedWord)) { + mSuggestionStripViewAccessor.setNeutralSuggestionStrip(); + return; + } int i = 0; for (final SuggestionSpan span : range.getSuggestionSpansAtWord()) { for (final String s : span.getSuggestions()) { @@ -1738,6 +1728,7 @@ public final class InputLogic { * @param settingsValues the current values of the settings. * @param codePoint the code point to send. */ + // TODO: replace these two parameters with an InputTransaction private void sendKeyCodePoint(final SettingsValues settingsValues, final int codePoint) { if (ProductionFlag.USES_DEVELOPMENT_ONLY_DIAGNOSTICS) { ResearchLogger.latinIME_sendKeyCodePoint(codePoint); |