/*
* Copyright (C) 2013 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 org.futo.inputmethod.latin.inputlogic;
import android.graphics.Color;
import android.os.SystemClock;
import android.text.SpannableString;
import android.text.Spanned;
import android.text.TextUtils;
import android.text.style.BackgroundColorSpan;
import android.text.style.SuggestionSpan;
import android.util.Log;
import android.view.KeyCharacterMap;
import android.view.KeyEvent;
import android.view.inputmethod.CorrectionInfo;
import android.view.inputmethod.EditorInfo;
import org.futo.inputmethod.accessibility.AccessibilityUtils;
import org.futo.inputmethod.compat.SuggestionSpanUtils;
import org.futo.inputmethod.event.Event;
import org.futo.inputmethod.event.InputTransaction;
import org.futo.inputmethod.keyboard.KeyDetector;
import org.futo.inputmethod.keyboard.Keyboard;
import org.futo.inputmethod.keyboard.KeyboardSwitcher;
import org.futo.inputmethod.latin.Dictionary;
import org.futo.inputmethod.latin.DictionaryFacilitator;
import org.futo.inputmethod.latin.LastComposedWord;
import org.futo.inputmethod.latin.LatinIMELegacy;
import org.futo.inputmethod.latin.NgramContext;
import org.futo.inputmethod.latin.RichInputConnection;
import org.futo.inputmethod.latin.Suggest;
import org.futo.inputmethod.latin.Suggest.OnGetSuggestedWordsCallback;
import org.futo.inputmethod.latin.SuggestedWords;
import org.futo.inputmethod.latin.SuggestedWords.SuggestedWordInfo;
import org.futo.inputmethod.latin.WordComposer;
import org.futo.inputmethod.latin.common.Constants;
import org.futo.inputmethod.latin.common.InputPointers;
import org.futo.inputmethod.latin.common.StringUtils;
import org.futo.inputmethod.latin.define.DebugFlags;
import org.futo.inputmethod.latin.settings.Settings;
import org.futo.inputmethod.latin.settings.SettingsValues;
import org.futo.inputmethod.latin.settings.SettingsValuesForSuggestion;
import org.futo.inputmethod.latin.settings.SpacingAndPunctuations;
import org.futo.inputmethod.latin.suggestions.SuggestionStripViewAccessor;
import org.futo.inputmethod.latin.utils.AsyncResultHolder;
import org.futo.inputmethod.latin.utils.InputTypeUtils;
import org.futo.inputmethod.latin.utils.RecapitalizeStatus;
import org.futo.inputmethod.latin.utils.StatsUtils;
import org.futo.inputmethod.latin.utils.TextRange;
import org.futo.inputmethod.latin.xlm.LanguageModelFacilitator;
import java.text.BreakIterator;
import java.util.ArrayList;
import java.util.Locale;
import java.util.TreeSet;
import java.util.concurrent.TimeUnit;
import javax.annotation.Nonnull;
/**
* This class manages the input logic.
*/
public final class InputLogic {
private static final String TAG = InputLogic.class.getSimpleName();
// TODO : Remove this member when we can.
final LatinIMELegacy mLatinIMELegacy;
public final SuggestionStripViewAccessor mSuggestionStripViewAccessor;
// Never null.
private InputLogicHandler mInputLogicHandler = InputLogicHandler.NULL_HANDLER;
// TODO : make all these fields private as soon as possible.
// Current space state of the input method. This can be any of the above constants.
private int mSpaceState;
// Never null
public SuggestedWords mSuggestedWords = SuggestedWords.getEmptyInstance();
public final Suggest mSuggest;
private final DictionaryFacilitator mDictionaryFacilitator;
public LastComposedWord mLastComposedWord = LastComposedWord.NOT_A_COMPOSED_WORD;
public final WordComposer mWordComposer;
public final RichInputConnection mConnection;
private final RecapitalizeStatus mRecapitalizeStatus = new RecapitalizeStatus();
private int mDeleteCount;
private long mLastKeyTime;
public final TreeSet<Long> mCurrentlyPressedHardwareKeys = new TreeSet<>();
// Keeps track of most recently inserted text (multi-character key) for reverting
private String mEnteredText;
// TODO: This boolean is persistent state and causes large side effects at unexpected times.
// Find a way to remove it for readability.
private boolean mIsAutoCorrectionIndicatorOn;
private long mDoubleSpacePeriodCountdownStart;
// The word being corrected while the cursor is in the middle of the word.
// Note: This does not have a composing span, so it must be handled separately.
private String mWordBeingCorrectedByCursor = null;
private boolean isLogicSuppressedByExternalLogic = false;
public void startSuppressingLogic() {
isLogicSuppressedByExternalLogic = true;
}
public void endSuppressingLogic() {
isLogicSuppressedByExternalLogic = false;
}
/**
* Create a new instance of the input logic.
* @param latinIMELegacy the instance of the parent LatinIME. We should remove this when we can.
* @param suggestionStripViewAccessor an object to access the suggestion strip view.
* @param dictionaryFacilitator facilitator for getting suggestions and updating user history
* dictionary.
*/
public InputLogic(final LatinIMELegacy latinIMELegacy,
final SuggestionStripViewAccessor suggestionStripViewAccessor,
final DictionaryFacilitator dictionaryFacilitator) {
mLatinIMELegacy = latinIMELegacy;
mSuggestionStripViewAccessor = suggestionStripViewAccessor;
mWordComposer = new WordComposer();
mConnection = new RichInputConnection(latinIMELegacy.getInputMethodService());
mInputLogicHandler = InputLogicHandler.NULL_HANDLER;
mSuggest = new Suggest(dictionaryFacilitator);
mDictionaryFacilitator = dictionaryFacilitator;
}
/**
* Initializes the input logic for input in an editor.
*
* Call this when input starts or restarts in some editor (typically, in onStartInputView).
*
* @param combiningSpec the combining spec string for this subtype
* @param settingsValues the current settings values
*/
public void startInput(final String combiningSpec, final SettingsValues settingsValues) {
mEnteredText = null;
mWordBeingCorrectedByCursor = null;
mConnection.onStartInput();
if (!mWordComposer.getTypedWord().isEmpty()) {
// For messaging apps that offer send button, the IME does not get the opportunity
// to capture the last word. This block should capture those uncommitted words.
// The timestamp at which it is captured is not accurate but close enough.
StatsUtils.onWordCommitUserTyped(
mWordComposer.getTypedWord(), mWordComposer.isBatchMode());
}
mWordComposer.restartCombining(combiningSpec);
resetComposingState(true /* alsoResetLastComposedWord */);
mDeleteCount = 0;
mSpaceState = SpaceState.NONE;
mRecapitalizeStatus.disable(); // Do not perform recapitalize until the cursor is moved once
mCurrentlyPressedHardwareKeys.clear();
mSuggestedWords = SuggestedWords.getEmptyInstance();
// In some cases (namely, after rotation of the device) editorInfo.initialSelStart is lying
// so we try using some heuristics to find out about these and fix them.
mConnection.tryFixLyingCursorPosition();
cancelDoubleSpacePeriodCountdown();
if (InputLogicHandler.NULL_HANDLER == mInputLogicHandler) {
mInputLogicHandler = new InputLogicHandler(mLatinIMELegacy, this);
} else {
mInputLogicHandler.reset();
}
if (settingsValues.mShouldShowLxxSuggestionUi) {
mConnection.requestCursorUpdates(true /* enableMonitor */,
true /* requestImmediateCallback */);
}
}
/**
* Call this when the subtype changes.
* @param combiningSpec the spec string for the combining rules
* @param settingsValues the current settings values
*/
public void onSubtypeChanged(final String combiningSpec, final SettingsValues settingsValues) {
finishInput();
startInput(combiningSpec, settingsValues);
}
/**
* Call this when the orientation changes.
* @param settingsValues the current values of the settings.
*/
public void onOrientationChange(final SettingsValues settingsValues) {
// If !isComposingWord, #commitTyped() is a no-op, but still, it's better to avoid
// the useless IPC of {begin,end}BatchEdit.
if (mWordComposer.isComposingWord()) {
mConnection.beginBatchEdit();
// If we had a composition in progress, we need to commit the word so that the
// suggestionsSpan will be added. This will allow resuming on the same suggestions
// after rotation is finished.
commitTyped(settingsValues, LastComposedWord.NOT_A_SEPARATOR);
mConnection.endBatchEdit();
}
}
/**
* Clean up the input logic after input is finished.
*/
public void finishInput() {
if (mWordComposer.isComposingWord()) {
mConnection.finishComposingText();
StatsUtils.onWordCommitUserTyped(
mWordComposer.getTypedWord(), mWordComposer.isBatchMode());
}
mIsAutoCorrectionIndicatorOn = false;
resetComposingState(true /* alsoResetLastComposedWord */);
mInputLogicHandler.reset();
}
// Normally this class just gets out of scope after the process ends, but in unit tests, we
// create several instances of LatinIME in the same process, which results in several
// instances of InputLogic. This cleans up the associated handler so that tests don't leak
// handlers.
public void recycle() {
final InputLogicHandler inputLogicHandler = mInputLogicHandler;
mInputLogicHandler = InputLogicHandler.NULL_HANDLER;
inputLogicHandler.destroy();
mDictionaryFacilitator.closeDictionaries();
}
/**
* React to a string input.
*
* This is triggered by keys that input many characters at once, like the ".com" key or
* some additional keys for example.
*
* @param settingsValues the current values of the settings.
* @param event the input event containing the data.
* @return the complete transaction object
*/
public InputTransaction onTextInput(final SettingsValues settingsValues, final Event event,
final int keyboardShiftMode, final LatinIMELegacy.UIHandler handler) {
final String rawText = event.getTextToCommit().toString();
final InputTransaction inputTransaction = new InputTransaction(settingsValues, event,
SystemClock.uptimeMillis(), mSpaceState,
getActualCapsMode(settingsValues, keyboardShiftMode));
mConnection.beginBatchEdit();
if (mWordComposer.isComposingWord()) {
commitCurrentAutoCorrection(settingsValues, rawText, handler);
} else {
resetComposingState(true /* alsoResetLastComposedWord */);
}
handler.postUpdateSuggestionStrip(SuggestedWords.INPUT_STYLE_TYPING);
final String text = performSpecificTldProcessingOnTextInput(rawText);
if (SpaceState.PHANTOM == mSpaceState) {
insertAutomaticSpaceIfOptionsAndTextAllow(settingsValues);
}
mConnection.commitText(text, 1);
StatsUtils.onWordCommitUserTyped(mEnteredText, mWordComposer.isBatchMode());
mConnection.endBatchEdit();
// Space state must be updated before calling updateShiftState
mSpaceState = SpaceState.NONE;
mEnteredText = text;
mWordBeingCorrectedByCursor = null;
inputTransaction.setDidAffectContents();
inputTransaction.requireShiftUpdate(InputTransaction.SHIFT_UPDATE_NOW);
return inputTransaction;
}
/**
* A suggestion was picked from the suggestion strip.
* @param settingsValues the current values of the settings.
* @param suggestionInfo the suggestion info.
* @param keyboardShiftState the shift state of the keyboard, as returned by
* {@link org.futo.inputmethod.keyboard.KeyboardSwitcher#getKeyboardShiftMode()}
* @return the complete transaction object
*/
// Called from {@link SuggestionStripView} through the {@link SuggestionStripView#Listener}
// interface
public InputTransaction onPickSuggestionManually(final SettingsValues settingsValues,
final SuggestedWordInfo suggestionInfo, final int keyboardShiftState,
final int currentKeyboardScriptId, final LatinIMELegacy.UIHandler handler) {
final SuggestedWords suggestedWords = mSuggestedWords;
final String suggestion = suggestionInfo.mWord;
// If this is a punctuation picked from the suggestion strip, pass it to onCodeInput
if (suggestion.length() == 1 && suggestedWords.isPunctuationSuggestions()) {
// We still want to log a suggestion click.
StatsUtils.onPickSuggestionManually(
mSuggestedWords, suggestionInfo, mDictionaryFacilitator);
// Word separators are suggested before the user inputs something.
// Rely on onCodeInput to do the complicated swapping/stripping logic consistently.
final Event event = Event.createPunctuationSuggestionPickedEvent(suggestionInfo);
return onCodeInput(settingsValues, event, keyboardShiftState,
currentKeyboardScriptId, handler);
}
final Event event = Event.createSuggestionPickedEvent(suggestionInfo);
final InputTransaction inputTransaction = new InputTransaction(settingsValues,
event, SystemClock.uptimeMillis(), mSpaceState, keyboardShiftState);
// Manual pick affects the contents of the editor, so we take note of this. It's important
// for the sequence of language switching.
inputTransaction.setDidAffectContents();
if(suggestionInfo.mKindAndFlags == SuggestedWordInfo.KIND_UNDO) {
inputTransaction.setRequiresUpdateSuggestions();
mConnection.finishComposingText();
mWordComposer.reset();
mConnection.commitText(suggestionInfo.mWord, 1);
return inputTransaction;
}
mConnection.beginBatchEdit();
if (SpaceState.PHANTOM == mSpaceState && suggestion.length() > 0
// In the batch input mode, a manually picked suggested word should just replace
// the current batch input text and there is no need for a phantom space.
&& !mWordComposer.isBatchMode()) {
final int firstChar = Character.codePointAt(suggestion, 0);
if (!settingsValues.isWordSeparator(firstChar)
|| settingsValues.isUsuallyPrecededBySpace(firstChar)) {
if(!mConnection.spacePrecedesComposingText())
insertAutomaticSpaceIfOptionsAndTextAllow(settingsValues);
}
}
// TODO: We should not need the following branch. We should be able to take the same
// code path as for other kinds, use commitChosenWord, and do everything normally. We will
// however need to reset the suggestion strip right away, because we know we can't take
// the risk of calling commitCompletion twice because we don't know how the app will react.
if (suggestionInfo.isKindOf(SuggestedWordInfo.KIND_APP_DEFINED)) {
mSuggestedWords = SuggestedWords.getEmptyInstance();
mSuggestionStripViewAccessor.setNeutralSuggestionStrip();
inputTransaction.requireShiftUpdate(InputTransaction.SHIFT_UPDATE_NOW);
resetComposingState(true /* alsoResetLastComposedWord */);
mConnection.commitCompletion(suggestionInfo.mApplicationSpecifiedCompletionInfo);
mConnection.endBatchEdit();
return inputTransaction;
}
commitChosenWord(settingsValues, suggestion, LastComposedWord.COMMIT_TYPE_MANUAL_PICK,
LastComposedWord.NOT_A_SEPARATOR, suggestionInfo.isKindOf(SuggestedWordInfo.KIND_TYPED) ? 3 : 1);
mConnection.endBatchEdit();
// Don't allow cancellation of manual pick
mLastComposedWord.deactivate();
// Space state must be updated before calling updateShiftState
insertOrSetPhantomSpace(settingsValues);
inputTransaction.requireShiftUpdate(InputTransaction.SHIFT_UPDATE_NOW);
// If we're not showing the "Touch again to save", then update the suggestion strip.
// That's going to be predictions (or punctuation suggestions), so INPUT_STYLE_NONE.
handler.postUpdateSuggestionStrip(SuggestedWords.INPUT_STYLE_NONE);
StatsUtils.onPickSuggestionManually(
mSuggestedWords, suggestionInfo, mDictionaryFacilitator);
StatsUtils.onWordCommitSuggestionPickedManually(
suggestionInfo.mWord, mWordComposer.isBatchMode());
return inputTransaction;
}
/**
* Consider an update to the cursor position. Evaluate whether this update has happened as
* part of normal typing or whether it was an explicit cursor move by the user. In any case,
* do the necessary adjustments.
* @param oldSelStart old selection start
* @param oldSelEnd old selection end
* @param newSelStart new selection start
* @param newSelEnd new selection end
* @param settingsValues the current values of the settings.
* @return whether the cursor has moved as a result of user interaction.
*/
public boolean onUpdateSelection(final int oldSelStart, final int oldSelEnd,
final int newSelStart, final int newSelEnd, final SettingsValues settingsValues) {
if(isLogicSuppressedByExternalLogic) return false;
if (mConnection.isBelatedExpectedUpdate(oldSelStart, newSelStart, oldSelEnd, newSelEnd)) {
return false;
}
// TODO: the following is probably better done in resetEntireInputState().
// it should only happen when the cursor moved, and the very purpose of the
// test below is to narrow down whether this happened or not. Likewise with
// the call to updateShiftState.
// We set this to NONE because after a cursor move, we don't want the space
// state-related special processing to kick in.
mSpaceState = SpaceState.NONE;
final boolean selectionChangedOrSafeToReset =
oldSelStart != newSelStart || oldSelEnd != newSelEnd // selection changed
|| !mWordComposer.isComposingWord(); // safe to reset
final boolean hasOrHadSelection = (oldSelStart != oldSelEnd || newSelStart != newSelEnd);
final int moveAmount = newSelStart - oldSelStart;
// As an added small gift from the framework, it happens upon rotation when there
// is a selection that we get a wrong cursor position delivered to startInput() that
// does not get reflected in the oldSel{Start,End} parameters to the next call to
// onUpdateSelection. In this case, we may have set a composition, and when we're here
// we realize we shouldn't have. In theory, in this case, selectionChangedOrSafeToReset
// should be true, but that is if the framework had taken that wrong cursor position
// into account, which means we have to reset the entire composing state whenever there
// is or was a selection regardless of whether it changed or not.
if (hasOrHadSelection || !settingsValues.needsToLookupSuggestions()
|| (selectionChangedOrSafeToReset
&& !mWordComposer.moveCursorByAndReturnIfInsideComposingWord(moveAmount))) {
// If we are composing a word and moving the cursor, we would want to set a
// suggestion span for recorrection to work correctly. Unfortunately, that
// would involve the keyboard committing some new text, which would move the
// cursor back to where it was. Latin IME could then fix the position of the cursor
// again, but the asynchronous nature of the calls results in this wreaking havoc
// with selection on double tap and the like.
// Another option would be to send suggestions each time we set the composing
// text, but that is probably too expensive to do, so we decided to leave things
// as is.
// Also, we're posting a resume suggestions message, and this will update the
// suggestions strip in a few milliseconds, so if we cleared the suggestion strip here
// we'd have the suggestion strip noticeably janky. To avoid that, we don't clear
// it here, which means we'll keep outdated suggestions for a split second but the
// visual result is better.
resetEntireInputState(newSelStart, newSelEnd, false /* clearSuggestionStrip */);
// If the user is in the middle of correcting a word, we should learn it before moving
// the cursor away.
if (!TextUtils.isEmpty(mWordBeingCorrectedByCursor)) {
final int timeStampInSeconds = (int)TimeUnit.MILLISECONDS.toSeconds(
System.currentTimeMillis());
performAdditionToUserHistoryDictionary(settingsValues, mWordBeingCorrectedByCursor,
NgramContext.EMPTY_PREV_WORDS_INFO, -1);
}
} else {
// resetEntireInputState calls resetCachesUponCursorMove, but forcing the
// composition to end. But in all cases where we don't reset the entire input
// state, we still want to tell the rich input connection about the new cursor
// position so that it can update its caches.
mConnection.resetCachesUponCursorMoveAndReturnSuccess(
newSelStart, newSelEnd, false /* shouldFinishComposition */);
}
// The cursor has been moved : we now accept to perform recapitalization
mRecapitalizeStatus.enable();
// We moved the cursor. If we are touching a word, we need to resume suggestion.
mIsAutoCorrectionIndicatorOn = false;
mLatinIMELegacy.mHandler.postResumeSuggestions(true /* shouldDelay */);
// Stop the last recapitalization, if started.
mRecapitalizeStatus.stop();
mWordBeingCorrectedByCursor = null;
return true;
}
/**
* React to a code input. It may be a code point to insert, or a symbolic value that influences
* the keyboard behavior.
*
* 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 event the event to handle.
* @param keyboardShiftMode the current shift mode of the keyboard, as returned by
* {@link org.futo.inputmethod.keyboard.KeyboardSwitcher#getKeyboardShiftMode()}
* @return the complete transaction object
*/
public InputTransaction onCodeInput(final SettingsValues settingsValues,
@Nonnull final Event event, final int keyboardShiftMode,
final int currentKeyboardScriptId, final LatinIMELegacy.UIHandler handler) {
mWordBeingCorrectedByCursor = null;
final Event processedEvent = mWordComposer.processEvent(event);
final InputTransaction inputTransaction = new InputTransaction(settingsValues,
processedEvent, SystemClock.uptimeMillis(), mSpaceState,
getActualCapsMode(settingsValues, keyboardShiftMode));
if (processedEvent.mKeyCode != Constants.CODE_DELETE
|| inputTransaction.mTimestamp > mLastKeyTime + Constants.LONG_PRESS_MILLISECONDS) {
mDeleteCount = 0;
}
mLastKeyTime = inputTransaction.mTimestamp;
mConnection.beginBatchEdit();
if (!mWordComposer.isComposingWord()) {
// TODO: is this useful? It doesn't look like it should be done here, but rather after
// a word is committed.
mIsAutoCorrectionIndicatorOn = false;
}
// TODO: Consolidate the double-space period timer, mLastKeyTime, and the space state.
if (processedEvent.mCodePoint != Constants.CODE_SPACE) {
cancelDoubleSpacePeriodCountdown();
}
Event currentEvent = processedEvent;
while (null != currentEvent) {
if (currentEvent.isConsumed()) {
handleConsumedEvent(currentEvent, inputTransaction);
} else if (currentEvent.isFunctionalKeyEvent()) {
handleFunctionalEvent(currentEvent, inputTransaction, currentKeyboardScriptId,
handler);
} else {
handleNonFunctionalEvent(currentEvent, inputTransaction, handler);
}
currentEvent = currentEvent.mNextEvent;
}
// Try to record the word being corrected when the user enters a word character or
// the backspace key.
if (!mConnection.hasSlowInputConnection() && !mWordComposer.isComposingWord()
&& (settingsValues.isWordCodePoint(processedEvent.mCodePoint) ||
processedEvent.mKeyCode == Constants.CODE_DELETE)) {
mWordBeingCorrectedByCursor = getWordAtCursor(
settingsValues, currentKeyboardScriptId);
}
if (!inputTransaction.didAutoCorrect() && processedEvent.mKeyCode != Constants.CODE_SHIFT
&& processedEvent.mKeyCode != Constants.CODE_CAPSLOCK
&& processedEvent.mKeyCode != Constants.CODE_SWITCH_ALPHA_SYMBOL)
mLastComposedWord.deactivate();
if (Constants.CODE_DELETE != processedEvent.mKeyCode) {
mEnteredText = null;
}
mConnection.endBatchEdit();
updateBoostedCodePoints(
settingsValues,
settingsValues.isWordCodePoint(processedEvent.mCodePoint)
);
return inputTransaction;
}
/**
* Updates keys whose hitboxes are boosted. This works by looking at the word being composed,
* and checking for next letters that would still produce a valid word within the dictionary
*/
private void updateBoostedCodePoints(
final SettingsValues settingsValues,
final boolean wasWordCodePoint
) {
final KeyDetector keyDetector = mLatinIMELegacy.mKeyboardSwitcher.getMainKeyboardView().mKeyDetector;
// Require key boosting setting to be enabled
if(settingsValues.mUseDictionaryKeyBoosting
// text field must allow autocorrection
&& settingsValues.mAutoCorrectionEnabledPerUserSettings
// previous codepoint must have been a word codepoint (i.e. exclude boosting after backspace or symbols)
&& wasWordCodePoint
// accessibility must not be enabled
&& !AccessibilityUtils.getInstance().isAccessibilityEnabled()
) {
keyDetector.updateBoostedCodePoints(mSuggest.getValidNextCodePoints(mWordComposer));
} else {
keyDetector.updateBoostedCodePoints(null);
}
}
public void showBatchSuggestions(final SuggestedWords suggestedWordsForBatchInput,
final boolean isTailBatchInput) {
mInputLogicHandler.showGestureSuggestionsWithPreviewVisuals(suggestedWordsForBatchInput, isTailBatchInput);
}
public void onStartBatchInput(final SettingsValues settingsValues,
final KeyboardSwitcher keyboardSwitcher, final LatinIMELegacy.UIHandler handler) {
mWordBeingCorrectedByCursor = null;
mInputLogicHandler.onStartBatchInput();
handler.showGesturePreviewAndSuggestionStrip(
SuggestedWords.getEmptyInstance(), false /* dismissGestureFloatingPreviewText */);
handler.cancelUpdateSuggestionStrip();
++mAutoCommitSequenceNumber;
mConnection.beginBatchEdit();
if (mWordComposer.isComposingWord()) {
if (mWordComposer.isCursorFrontOrMiddleOfComposingWord()) {
// If we are in the middle of a recorrection, we need to commit the recorrection
// first so that we can insert the batch input at the current cursor position.
// We also need to unlearn the original word that is now being corrected.
unlearnWord(mWordComposer.getTypedWord(), settingsValues,
Constants.EVENT_BACKSPACE);
resetEntireInputState(mConnection.getExpectedSelectionStart(),
mConnection.getExpectedSelectionEnd(), true /* clearSuggestionStrip */);
} else if (mWordComposer.isSingleLetter()) {
// We auto-correct the previous (typed, not gestured) string iff it's one character
// long. The reason for this is, even in the middle of gesture typing, you'll still
// tap one-letter words and you want them auto-corrected (typically, "i" in English
// should become "I"). However for any longer word, we assume that the reason for
// tapping probably is that the word you intend to type is not in the dictionary,
// so we do not attempt to correct, on the assumption that if that was a dictionary
// word, the user would probably have gestured instead.
commitCurrentAutoCorrection(settingsValues, LastComposedWord.NOT_A_SEPARATOR,
handler);
} else {
commitTyped(settingsValues, LastComposedWord.NOT_A_SEPARATOR);
}
}
final int codePointBeforeCursor = mConnection.getCodePointBeforeCursor();
if (Character.isLetterOrDigit(codePointBeforeCursor)
|| settingsValues.isUsuallyFollowedBySpace(codePointBeforeCursor)) {
final boolean autoShiftHasBeenOverriden = keyboardSwitcher.getKeyboardShiftMode() !=
getCurrentAutoCapsState(settingsValues);
mSpaceState = SpaceState.PHANTOM;
if (!autoShiftHasBeenOverriden) {
// When we change the space state, we need to update the shift state of the
// keyboard unless it has been overridden manually. This is happening for example
// after typing some letters and a period, then gesturing; the keyboard is not in
// caps mode yet, but since a gesture is starting, it should go in caps mode,
// unless the user explictly said it should not.
keyboardSwitcher.requestUpdatingShiftState(getCurrentAutoCapsState(settingsValues),
getCurrentRecapitalizeState());
}
}
mConnection.endBatchEdit();
mWordComposer.setCapitalizedModeAtStartComposingTime(
getActualCapsMode(settingsValues, keyboardSwitcher.getKeyboardShiftMode()));
}
/* The sequence number member is only used in onUpdateBatchInput. It is increased each time
* auto-commit happens. The reason we need this is, when auto-commit happens we trim the
* input pointers that are held in a singleton, and to know how much to trim we rely on the
* results of the suggestion process that is held in mSuggestedWords.
* However, the suggestion process is asynchronous, and sometimes we may enter the
* onUpdateBatchInput method twice without having recomputed suggestions yet, or having
* received new suggestions generated from not-yet-trimmed input pointers. In this case, the
* mIndexOfTouchPointOfSecondWords member will be out of date, and we must not use it lest we
* remove an unrelated number of pointers (possibly even more than are left in the input
* pointers, leading to a crash).
* To avoid that, we increase the sequence number each time we auto-commit and trim the
* input pointers, and we do not use any suggested words that have been generated with an
* earlier sequence number.
*/
private int mAutoCommitSequenceNumber = 1;
public void onUpdateBatchInput(final InputPointers batchPointers) {
mInputLogicHandler.onUpdateBatchInput(batchPointers, mAutoCommitSequenceNumber);
}
public void onEndBatchInput(final InputPointers batchPointers) {
mInputLogicHandler.updateTailBatchInput(batchPointers, mAutoCommitSequenceNumber);
++mAutoCommitSequenceNumber;
}
public void onCancelBatchInput(final LatinIMELegacy.UIHandler handler) {
mInputLogicHandler.onCancelBatchInput();
handler.showGesturePreviewAndSuggestionStrip(
SuggestedWords.getEmptyInstance(), true /* dismissGestureFloatingPreviewText */);
}
// TODO: on the long term, this method should become private, but it will be difficult.
// Especially, how do we deal with InputMethodService.onDisplayCompletions?
public void setSuggestedWords(final SuggestedWords suggestedWords) {
if (!suggestedWords.isEmpty()) {
suggestedWords.mWillAutoCorrect = suggestedWords.mWillAutoCorrect
&& !mConnection.textBeforeCursorLooksLikeURL();
final SuggestedWordInfo suggestedWordInfo;
if (suggestedWords.mWillAutoCorrect) {
suggestedWordInfo = suggestedWords.getInfo(SuggestedWords.INDEX_OF_AUTO_CORRECTION);
} else {
// We can't use suggestedWords.getWord(SuggestedWords.INDEX_OF_TYPED_WORD)
// because it may differ from mWordComposer.mTypedWord.
suggestedWordInfo = suggestedWords.mTypedWordInfo;
}
mWordComposer.setAutoCorrection(suggestedWordInfo);
}
mSuggestedWords = suggestedWords;
final boolean newAutoCorrectionIndicator = suggestedWords.mWillAutoCorrect;
// Put a blue underline to a word in TextView which will be auto-corrected.
if (mIsAutoCorrectionIndicatorOn != newAutoCorrectionIndicator
&& mWordComposer.isComposingWord()) {
mIsAutoCorrectionIndicatorOn = newAutoCorrectionIndicator;
final CharSequence textWithUnderline =
getTextWithUnderline(mWordComposer.getTypedWord());
// TODO: when called from an updateSuggestionStrip() call that results from a posted
// message, this is called outside any batch edit. Potentially, this may result in some
// janky flickering of the screen, although the display speed makes it unlikely in
// the practice.
setComposingTextInternal(textWithUnderline, 1);
}
}
/**
* Handle a consumed event.
*
* Consumed events represent events that have already been consumed, typically by the
* combining chain.
*
* @param event The event to handle.
* @param inputTransaction The transaction in progress.
*/
private void handleConsumedEvent(final Event event, final InputTransaction inputTransaction) {
// A consumed event may have text to commit and an update to the composing state, so
// we evaluate both. With some combiners, it's possible than an event contains both
// and we enter both of the following if clauses.
final CharSequence textToCommit = event.getTextToCommit();
if (!TextUtils.isEmpty(textToCommit)) {
mConnection.commitText(textToCommit, 1);
inputTransaction.setDidAffectContents();
}
if (mWordComposer.isComposingWord()) {
setComposingTextInternal(mWordComposer.getTypedWord(), 1);
inputTransaction.setDidAffectContents();
inputTransaction.setRequiresUpdateSuggestions();
}
}
/**
* Handle a functional key event.
*
* A functional event is a special key, like delete, shift, emoji, or the settings key.
* Non-special keys are those that generate a single code point.
* This includes all letters, digits, punctuation, separators, emoji. It excludes keys that
* 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 event The event to handle.
* @param inputTransaction The transaction in progress.
*/
private void handleFunctionalEvent(final Event event, final InputTransaction inputTransaction,
final int currentKeyboardScriptId, final LatinIMELegacy.UIHandler handler) {
if(event.mKeyCode <= Constants.CODE_ACTION_MAX && event.mKeyCode >= Constants.CODE_ACTION_0) {
final int actionId = event.mKeyCode - Constants.CODE_ACTION_0;
handler.triggerAction(actionId);
return;
}
if(event.mKeyCode <= Constants.CODE_ALT_ACTION_MAX && event.mKeyCode >= Constants.CODE_ALT_ACTION_0) {
final int actionId = event.mKeyCode - Constants.CODE_ALT_ACTION_0;
handler.triggerActionAlt(actionId);
return;
}
switch (event.mKeyCode) {
case Constants.CODE_DELETE:
handleBackspaceEvent(event, inputTransaction, currentKeyboardScriptId);
// Backspace is a functional key, but it affects the contents of the editor.
inputTransaction.setDidAffectContents();
break;
case Constants.CODE_SHIFT:
performRecapitalization(inputTransaction.mSettingsValues);
inputTransaction.requireShiftUpdate(InputTransaction.SHIFT_UPDATE_NOW);
if (mSuggestedWords.isPrediction()) {
inputTransaction.setRequiresUpdateSuggestions();
}
break;
case Constants.CODE_CAPSLOCK:
// Note: Changing keyboard to shift lock state is handled in
// {@link KeyboardSwitcher#onEvent(Event)}.
break;
case Constants.CODE_SYMBOL_SHIFT:
// Note: Calling back to the keyboard on the symbol Shift key is handled in
// {@link #onPressKey(int,int,boolean)} and {@link #onReleaseKey(int,boolean)}.
break;
case Constants.CODE_SWITCH_ALPHA_SYMBOL:
// Note: Calling back to the keyboard on symbol key is handled in
// {@link #onPressKey(int,int,boolean)} and {@link #onReleaseKey(int,boolean)}.
break;
case Constants.CODE_SETTINGS:
onSettingsKeyPressed();
break;
case Constants.CODE_SHORTCUT:
// We need to switch to the shortcut IME. This is handled by LatinIME since the
// input logic has no business with IME switching.
break;
case Constants.CODE_ACTION_NEXT:
performEditorAction(EditorInfo.IME_ACTION_NEXT);
break;
case Constants.CODE_ACTION_PREVIOUS:
performEditorAction(EditorInfo.IME_ACTION_PREVIOUS);
break;
case Constants.CODE_LANGUAGE_SWITCH:
handleLanguageSwitchKey();
break;
case Constants.CODE_EMOJI:
// Note: Switching emoji keyboard is being handled in
// {@link KeyboardState#onEvent(Event,int)}.
break;
case Constants.CODE_ALPHA_FROM_EMOJI:
// Note: Switching back from Emoji keyboard to the main keyboard is being
// handled in {@link KeyboardState#onEvent(Event,int)}.
break;
case Constants.CODE_SHIFT_ENTER:
final Event tmpEvent = Event.createSoftwareKeypressEvent(Constants.CODE_ENTER,
event.mKeyCode, event.mX, event.mY, event.isKeyRepeat());
handleNonSpecialCharacterEvent(tmpEvent, inputTransaction, handler);
// Shift + Enter is treated as a functional key but it results in adding a new
// line, so that does affect the contents of the editor.
inputTransaction.setDidAffectContents();
break;
case Constants.CODE_TO_NUMBER_LAYOUT:
case Constants.CODE_TO_ALT_0_LAYOUT:
case Constants.CODE_TO_ALT_1_LAYOUT:
case Constants.CODE_TO_ALT_2_LAYOUT:
// Handled in KeyboardState
break;
default:
throw new RuntimeException("Unknown key code : " + event.mKeyCode);
}
}
/**
* Handle an event that is not a functional event.
*
* These events are generally events that cause input, but in some cases they may do other
* things like trigger an editor action.
*
* @param event The event to handle.
* @param inputTransaction The transaction in progress.
*/
private void handleNonFunctionalEvent(final Event event,
final InputTransaction inputTransaction,
final LatinIMELegacy.UIHandler handler) {
inputTransaction.setDidAffectContents();
switch (event.mCodePoint) {
case Constants.CODE_ENTER:
final EditorInfo editorInfo = getCurrentInputEditorInfo();
final int imeOptionsActionId =
InputTypeUtils.getImeOptionsActionIdFromEditorInfo(editorInfo);
if (InputTypeUtils.IME_ACTION_CUSTOM_LABEL == imeOptionsActionId) {
// Either we have an actionLabel and we should performEditorAction with
// actionId regardless of its value.
performEditorAction(editorInfo.actionId);
} else if (EditorInfo.IME_ACTION_NONE != imeOptionsActionId) {
// We didn't have an actionLabel, but we had another action to execute.
// EditorInfo.IME_ACTION_NONE explicitly means no action. In contrast,
// EditorInfo.IME_ACTION_UNSPECIFIED is the default value for an action, so it
// means there should be an action and the app didn't bother to set a specific
// code for it - presumably it only handles one. It does not have to be treated
// in any specific way: anything that is not IME_ACTION_NONE should be sent to
// performEditorAction.
performEditorAction(imeOptionsActionId);
} else {
// No action label, and the action from imeOptions is NONE: this is a regular
// enter key that should input a carriage return.
handleNonSpecialCharacterEvent(event, inputTransaction, handler);
}
break;
default:
handleNonSpecialCharacterEvent(event, inputTransaction, handler);
break;
}
}
/**
* Handle inputting a code point to the editor.
*
* Non-special keys are those that generate a single code point.
* This includes all letters, digits, punctuation, separators, emoji. It excludes keys that
* 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 event The event to handle.
* @param inputTransaction The transaction in progress.
*/
private void handleNonSpecialCharacterEvent(final Event event,
final InputTransaction inputTransaction,
final LatinIMELegacy.UIHandler handler) {
final int codePoint = event.mCodePoint;
mSpaceState = SpaceState.NONE;
if(codePoint == Constants.CODE_SPACE
&& inputTransaction.mSpaceState == SpaceState.ANTIPHANTOM) {
return;
}
if (inputTransaction.mSettingsValues.isWordSeparator(codePoint)
|| Character.getType(codePoint) == Character.OTHER_SYMBOL) {
handleSeparatorEvent(event, inputTransaction, handler);
} else {
if (SpaceState.PHANTOM == inputTransaction.mSpaceState) {
if (mWordComposer.isCursorFrontOrMiddleOfComposingWord()) {
// If we are in the middle of a recorrection, we need to commit the recorrection
// first so that we can insert the character at the current cursor position.
// We also need to unlearn the original word that is now being corrected.
unlearnWord(mWordComposer.getTypedWord(), inputTransaction.mSettingsValues,
Constants.EVENT_BACKSPACE);
resetEntireInputState(mConnection.getExpectedSelectionStart(),
mConnection.getExpectedSelectionEnd(), true /* clearSuggestionStrip */);
} else {
commitTyped(inputTransaction.mSettingsValues, LastComposedWord.NOT_A_SEPARATOR);
}
}
handleNonSeparatorEvent(event, inputTransaction.mSettingsValues, inputTransaction);
}
}
/**
* Handle a non-separator.
* @param event The event to handle.
* @param settingsValues The current settings values.
* @param inputTransaction The transaction in progress.
*/
private void handleNonSeparatorEvent(final Event event, final SettingsValues settingsValues,
final InputTransaction inputTransaction) {
final int codePoint = event.mCodePoint;
// TODO: refactor this method to stop flipping isComposingWord around all the time, and
// make it shorter (possibly cut into several pieces). Also factor
// handleNonSpecialCharacterEvent which has the same name as other handle* methods but is
// not the same.
boolean isComposingWord = mWordComposer.isComposingWord();
// TODO: remove isWordConnector() and use isUsuallyFollowedBySpace() instead.
// See onStartBatchInput() to see how to do it.
if (SpaceState.PHANTOM == inputTransaction.mSpaceState
&& !settingsValues.isWordConnector(codePoint)) {
if (isComposingWord) {
// Validity check
throw new RuntimeException("Should not be composing here");
}
insertAutomaticSpaceIfOptionsAndTextAllow(settingsValues);
}
if (mWordComposer.isCursorFrontOrMiddleOfComposingWord()) {
// If we are in the middle of a recorrection, we need to commit the recorrection
// first so that we can insert the character at the current cursor position.
// We also need to unlearn the original word that is now being corrected.
unlearnWord(mWordComposer.getTypedWord(), inputTransaction.mSettingsValues,
Constants.EVENT_BACKSPACE);
resetEntireInputState(mConnection.getExpectedSelectionStart(),
mConnection.getExpectedSelectionEnd(), true /* clearSuggestionStrip */);
isComposingWord = false;
}
// We want to find out whether to start composing a new word with this character. If so,
// we need to reset the composing state and switch isComposingWord. The order of the
// tests is important for good performance.
// We only start composing if we're not already composing.
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)
// We never go into composing state if suggestions are not requested.
&& settingsValues.needsToLookupSuggestions() &&
// 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.
// NOTE: If the InputConnection is slow, we skip the text-after-cursor check since it
// can incur a very expensive getTextAfterCursor() lookup, potentially making the
// keyboard UI slow and non-responsive.
// TODO: Cache the text after the cursor so we don't need to go to the InputConnection
// each time. We are already doing this for getTextBeforeCursor().
(!settingsValues.mSpacingAndPunctuations.mCurrentLanguageHasSpaces
|| !mConnection.isCursorTouchingWord(settingsValues.mSpacingAndPunctuations,
!mConnection.hasSlowInputConnection() /* checkTextAfter */))) {
// Reset entirely the composing state anyway, then start composing a new word unless
// the character is a word connector. The idea here is, word connectors 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 = !settingsValues.mSpacingAndPunctuations.isWordConnector(codePoint);
// 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
// have touch coordinates for it.
resetComposingState(false /* alsoResetLastComposedWord */);
}
if (isComposingWord) {
mWordComposer.applyProcessedEvent(event);
// If it's the first letter, make note of auto-caps state
if (mWordComposer.isSingleLetter()) {
mWordComposer.setCapitalizedModeAtStartComposingTime(inputTransaction.mShiftState);
}
setComposingTextInternal(getTextWithUnderline(mWordComposer.getTypedWord()), 1);
} else {
final boolean swapWeakSpace = tryStripSpaceAndReturnWhetherShouldSwapInstead(event,
inputTransaction);
if (swapWeakSpace && trySwapSwapperAndSpace(event, inputTransaction)) {
mSpaceState = SpaceState.WEAK;
} else {
boolean autoInsertSpaces = canInsertAutoSpace(settingsValues)
&& (settingsValues.mAltSpacesMode >= Settings.SPACES_MODE_ALL)
&& !mConnection.digitPrecedesCursor();
boolean spacePrecedesCursor = mConnection.spacePrecedesCursor();
sendKeyCodePoint(settingsValues, codePoint);
if(autoInsertSpaces
&& spacePrecedesCursor
&& settingsValues.isUsuallyFollowedBySpaceIffPrecededBySpace(codePoint)) {
insertOrSetPhantomSpace(settingsValues);
}
}
}
inputTransaction.setRequiresUpdateSuggestions();
}
/**
* Handle input of a separator code point.
* @param event The event to handle.
* @param inputTransaction The transaction in progress.
*/
private void handleSeparatorEvent(final Event event, final InputTransaction inputTransaction,
final LatinIMELegacy.UIHandler handler) {
final int codePoint = event.mCodePoint;
final SettingsValues settingsValues = inputTransaction.mSettingsValues;
final boolean wasComposingWord = mWordComposer.isComposingWord();
// We avoid sending spaces in languages without spaces if we were composing.
final boolean shouldAvoidSendingCode = Constants.CODE_SPACE == codePoint
&& !settingsValues.mSpacingAndPunctuations.mCurrentLanguageHasSpaces
&& wasComposingWord;
if (mWordComposer.isCursorFrontOrMiddleOfComposingWord()) {
// If we are in the middle of a recorrection, we need to commit the recorrection
// first so that we can insert the separator at the current cursor position.
// We also need to unlearn the original word that is now being corrected.
unlearnWord(mWordComposer.getTypedWord(), inputTransaction.mSettingsValues,
Constants.EVENT_BACKSPACE);
resetEntireInputState(mConnection.getExpectedSelectionStart(),
mConnection.getExpectedSelectionEnd(), true /* clearSuggestionStrip */);
}
// isComposingWord() may have changed since we stored wasComposing
if (mWordComposer.isComposingWord()) {
if (settingsValues.mAutoCorrectionEnabledPerUserSettings) {
final String separator = shouldAvoidSendingCode ? LastComposedWord.NOT_A_SEPARATOR
: StringUtils.newSingleCodePointString(codePoint);
commitCurrentAutoCorrection(settingsValues, separator, handler);
inputTransaction.setDidAutoCorrect();
} else {
commitTyped(settingsValues,
StringUtils.newSingleCodePointString(codePoint));
}
}
final boolean swapWeakSpace = tryStripSpaceAndReturnWhetherShouldSwapInstead(event,
inputTransaction);
final boolean isInsideDoubleQuoteOrAfterDigit = Constants.CODE_DOUBLE_QUOTE == codePoint
&& mConnection.isInsideDoubleQuoteOrAfterDigit();
final boolean needsPrecedingSpace;
if (SpaceState.PHANTOM != inputTransaction.mSpaceState) {
needsPrecedingSpace = false;
} else if (Constants.CODE_DOUBLE_QUOTE == codePoint) {
// 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 if (settingsValues.mSpacingAndPunctuations.isClusteringSymbol(codePoint)
&& settingsValues.mSpacingAndPunctuations.isClusteringSymbol(
mConnection.getCodePointBeforeCursor())) {
needsPrecedingSpace = false;
} else {
needsPrecedingSpace = settingsValues.isUsuallyPrecededBySpace(codePoint);
}
if (needsPrecedingSpace) {
insertAutomaticSpaceIfOptionsAndTextAllow(settingsValues);
}
if (tryPerformDoubleSpacePeriod(event, inputTransaction)) {
mSpaceState = SpaceState.DOUBLE;
inputTransaction.setRequiresUpdateSuggestions();
StatsUtils.onDoubleSpacePeriod();
} else if (swapWeakSpace && trySwapSwapperAndSpace(event, inputTransaction)) {
if(inputTransaction.mSpaceState == SpaceState.ANTIPHANTOM) {
mSpaceState = SpaceState.ANTIPHANTOM;
} else {
mSpaceState = SpaceState.SWAP_PUNCTUATION;
}
inputTransaction.setRequiresUpdateSuggestions();
} else if (Constants.CODE_SPACE == codePoint) {
if (!mSuggestedWords.isPunctuationSuggestions()) {
mSpaceState = SpaceState.WEAK;
}
startDoubleSpacePeriodCountdown(inputTransaction);
if (wasComposingWord || mSuggestedWords.isEmpty()) {
inputTransaction.setRequiresUpdateSuggestions();
}
if (!shouldAvoidSendingCode) {
sendKeyCodePoint(settingsValues, codePoint);
}
} else {
if ((SpaceState.PHANTOM == inputTransaction.mSpaceState
&& settingsValues.isUsuallyFollowedBySpace(codePoint)
&& !settingsValues.mInputAttributes.mIsUriField)
|| (Constants.CODE_DOUBLE_QUOTE == codePoint
&& 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
// space. For example, if I type "Good dat", pick "day" from the suggestion strip
// then insert a comma and go on to typing the next word, I want the space to be
// inserted automatically before the next word, the same way it is when I don't
// input the comma. A double quote behaves like it's usually followed by space if
// we're inside a double quote.
// The case is a little different if the separator is a space stripper. Such a
// separator does not normally need a space on the right (that's the difference
// between swappers and strippers), so we should not stay in phantom space state if
// the separator is a stripper. Hence the additional test above.
mSpaceState = SpaceState.PHANTOM;
}
boolean autoInsertSpaces = canInsertAutoSpace(settingsValues)
&& (settingsValues.mAltSpacesMode >= Settings.SPACES_MODE_ALL)
&& !mConnection.digitPrecedesCursor();
boolean spacePrecedesCursor = mConnection.spacePrecedesCursor();
boolean codeShouldBePrecededBySpace = settingsValues.isUsuallyPrecededBySpace(codePoint);
// Disabled: this behavior is annoying in some circumstances (e.g. coding) and other
// keyboards seem to not do it
//|| (codePoint == Constants.CODE_DOUBLE_QUOTE && !isInsideDoubleQuoteOrAfterDigit);
codeShouldBePrecededBySpace = codeShouldBePrecededBySpace
&& !symbolRequiringPrecedingSpaceShouldSkipPrecedingSpace(
codePoint, mConnection.getCodePointBeforeCursor(), inputTransaction);
if(autoInsertSpaces
&& codeShouldBePrecededBySpace
&& !spacePrecedesCursor
) {
sendKeyCodePoint(settingsValues, Constants.CODE_SPACE);
mSpaceState = SpaceState.SYMBOL_PREFIX;
if(inputTransaction.didAutoCorrect()) {
mLastComposedWord.mSeparatorString = " " + mLastComposedWord.mSeparatorString;
}
}
final boolean fieldEmptyBeforeText =
(mConnection.getCodePointBeforeCursor() == Constants.NOT_A_CODE);
sendKeyCodePoint(settingsValues, codePoint);
boolean codeShouldBeFollowedBySpace = false;
if(settingsValues.isUsuallyFollowedBySpace(codePoint)) {
if(settingsValues.isOptionallyPrecededBySpace(codePoint)) {
// If it's optionally preceded by space, only auto-insert space if there is no space before cursor
// i.e. typing "hello :" will not auto insert space
// but typing "hello: " will auto insert space
codeShouldBeFollowedBySpace = !spacePrecedesCursor;
} else {
// otherwise it's safe to follow with space
codeShouldBeFollowedBySpace = true;
}
} else if(settingsValues.isUsuallyFollowedBySpaceIffPrecededBySpace(codePoint)) {
// For some symbols like - and & we only insert if its preceded by a space
codeShouldBeFollowedBySpace = spacePrecedesCursor;
} else if(codePoint == Constants.CODE_DOUBLE_QUOTE) {
codeShouldBeFollowedBySpace = isInsideDoubleQuoteOrAfterDigit;
}
// Do not automatically insert a space if there is no text preceding the cursor
// (e.g. if we are typing "!g", do not insert space after exclamation mark,
// and if we are typing ":)", do not insert space after colon)
codeShouldBeFollowedBySpace = codeShouldBeFollowedBySpace && !fieldEmptyBeforeText;
if(autoInsertSpaces && codeShouldBeFollowedBySpace) {
insertOrSetPhantomSpace(settingsValues);
if(inputTransaction.didAutoCorrect()) {
mLastComposedWord.mSeparatorString = mLastComposedWord.mSeparatorString + " ";
}
}
inputTransaction.setRequiresUpdateSuggestions();
}
inputTransaction.requireShiftUpdate(InputTransaction.SHIFT_UPDATE_NOW);
}
/**
* Handle a press on the backspace key.
* @param event The event to handle.
* @param inputTransaction The transaction in progress.
*/
private void handleBackspaceEvent(final Event event, final InputTransaction inputTransaction,
final int currentKeyboardScriptId) {
mSpaceState = SpaceState.NONE;
mDeleteCount++;
// In many cases after backspace, we need to update the shift state. Normally we need
// to do this right away to avoid the shift state being out of date in case the user types
// backspace then some other character very fast. However, in the case of backspace key
// repeat, this can lead to flashiness when the cursor flies over positions where the
// shift state should be updated, so if this is a key repeat, we update after a small delay.
// Then again, even in the case of a key repeat, if the cursor is at start of text, it
// can't go any further back, so we can update right away even if it's a key repeat.
final int shiftUpdateKind =
event.isKeyRepeat() && mConnection.getExpectedSelectionStart() > 0
? InputTransaction.SHIFT_UPDATE_LATER : InputTransaction.SHIFT_UPDATE_NOW;
inputTransaction.requireShiftUpdate(shiftUpdateKind);
if (mWordComposer.isCursorFrontOrMiddleOfComposingWord()) {
// If we are in the middle of a recorrection, we need to commit the recorrection
// first so that we can remove the character at the current cursor position.
// We also need to unlearn the original word that is now being corrected.
unlearnWord(mWordComposer.getTypedWord(), inputTransaction.mSettingsValues,
Constants.EVENT_BACKSPACE);
resetEntireInputState(mConnection.getExpectedSelectionStart(),
mConnection.getExpectedSelectionEnd(), true /* clearSuggestionStrip */);
// When we exit this if-clause, mWordComposer.isComposingWord() will return false.
}
final boolean deleteWholeWords = event.isKeyRepeat()
&& Settings.getInstance().getCurrent().mBackspaceMode == Settings.BACKSPACE_MODE_WORDS;
if (mWordComposer.isComposingWord()) {
if (mWordComposer.isBatchMode()) {
final String rejectedSuggestion = mWordComposer.getTypedWord();
mWordComposer.reset();
mWordComposer.setRejectedBatchModeSuggestion(rejectedSuggestion);
if (!TextUtils.isEmpty(rejectedSuggestion)) {
unlearnWord(rejectedSuggestion, inputTransaction.mSettingsValues,
Constants.EVENT_REJECTION);
}
StatsUtils.onBackspaceWordDelete(rejectedSuggestion.length());
} else if(deleteWholeWords) {
final String removedWord = mWordComposer.getTypedWord();
mWordComposer.reset();
if (!TextUtils.isEmpty(removedWord)) {
unlearnWord(removedWord, inputTransaction.mSettingsValues,
Constants.EVENT_BACKSPACE);
}
} else {
mWordComposer.applyProcessedEvent(event);
StatsUtils.onBackspacePressed(1);
}
if (mWordComposer.isComposingWord()) {
setComposingTextInternal(getTextWithUnderline(mWordComposer.getTypedWord()), 1);
} else {
mConnection.commitText("", 1);
}
inputTransaction.setRequiresUpdateSuggestions();
} else {
if (mLastComposedWord.canRevertCommit()) {
final String lastComposedWord = mLastComposedWord.mTypedWord;
revertCommit(inputTransaction, inputTransaction.mSettingsValues);
StatsUtils.onRevertAutoCorrect();
StatsUtils.onWordCommitUserTyped(lastComposedWord, mWordComposer.isBatchMode());
// Restart suggestions when backspacing into a reverted word. This is required for
// the final corrected word to be learned, as learning only occurs when suggestions
// are active.
//
// Note: restartSuggestionsOnWordTouchedByCursor is already called for normal
// (non-revert) backspace handling.
if (inputTransaction.mSettingsValues.isSuggestionsEnabledPerUserSettings()
&& inputTransaction.mSettingsValues.mSpacingAndPunctuations
.mCurrentLanguageHasSpaces
&& !mConnection.isCursorFollowedByWordCharacter(
inputTransaction.mSettingsValues.mSpacingAndPunctuations)) {
final int spaceState = mSpaceState; // Need to preserve space state, which restart resets
restartSuggestionsOnWordTouchedByCursor(inputTransaction.mSettingsValues,
false /* forStartInput */, currentKeyboardScriptId);
mSpaceState = spaceState;
}
return;
}
if (mEnteredText != null && mConnection.sameAsTextBeforeCursor(mEnteredText)) {
// Cancel multi-character input: remove the text we just entered.
// This is triggered on backspace after a key that inputs multiple characters,
// like the smiley key or the .com key.
mConnection.deleteTextBeforeCursor(mEnteredText.length());
StatsUtils.onDeleteMultiCharInput(mEnteredText.length());
mLatinIMELegacy.onCodePointDeleted(mEnteredText);
mEnteredText = null;
// If we have mEnteredText, then we know that mHasUncommittedTypedChars == false.
// In addition we know that spaceState is false, and that we should not be
// reverting any autocorrect at this point. So we can safely return.
return;
}
if (SpaceState.DOUBLE == inputTransaction.mSpaceState) {
cancelDoubleSpacePeriodCountdown();
if (mConnection.revertDoubleSpacePeriod(
inputTransaction.mSettingsValues.mSpacingAndPunctuations)) {
// No need to reset mSpaceState, it has already be done (that's why we
// receive it as a parameter)
inputTransaction.setRequiresUpdateSuggestions();
mWordComposer.setCapitalizedModeAtStartComposingTime(
WordComposer.CAPS_MODE_OFF);
StatsUtils.onRevertDoubleSpacePeriod();
return;
}
} else if (SpaceState.SWAP_PUNCTUATION == inputTransaction.mSpaceState) {
if (mConnection.revertSwapPunctuation()) {
StatsUtils.onRevertSwapPunctuation();
// Likewise
return;
}
} else if (SpaceState.SYMBOL_PREFIX == inputTransaction.mSpaceState) {
if (mConnection.revertPrefixSpace()) {
return;
}
}
boolean hasUnlearnedWordBeingDeleted = false;
// No cancelling of commit/double space/swap: we have a regular backspace.
// We should backspace one char and restart suggestion if at the end of a word.
if (mConnection.hasSelection()) {
// If there is a selection, remove it.
// We also need to unlearn the selected text.
final CharSequence selection = mConnection.getSelectedText(0 /* 0 for no styles */);
if (!TextUtils.isEmpty(selection)) {
unlearnWord(selection.toString(), inputTransaction.mSettingsValues,
Constants.EVENT_BACKSPACE);
hasUnlearnedWordBeingDeleted = true;
}
final int numCharsDeleted = mConnection.getExpectedSelectionEnd()
- mConnection.getExpectedSelectionStart();
mConnection.setSelection(mConnection.getExpectedSelectionEnd(),
mConnection.getExpectedSelectionEnd());
mConnection.deleteTextBeforeCursor(numCharsDeleted);
StatsUtils.onBackspaceSelectedText(numCharsDeleted);
} else {
// There is no selection, just delete one character.
if (inputTransaction.mSettingsValues.isBeforeJellyBean()
|| inputTransaction.mSettingsValues.mInputAttributes.isTypeNull()
|| Constants.NOT_A_CURSOR_POSITION
== mConnection.getExpectedSelectionEnd()) {
// There are three 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, or we don't know the cursor position.
// Before Jelly bean, the keyboard would simulate a hardware keyboard event on
// pressing enter or delete. This is bad for many reasons (there are race
// conditions with commits) but some applications are relying on this behavior
// so we continue to support it for older apps, so we retain this behavior if
// the app has target SDK < JellyBean.
// As for the case where we don't know the cursor position, it can happen
// because of bugs in the framework. But the framework should know, so the next
// best thing is to leave it to whatever it thinks is best.
sendDownUpKeyEvent(KeyEvent.KEYCODE_DEL, 0);
int totalDeletedLength = 1;
if (mDeleteCount > Constants.DELETE_ACCELERATE_AT) {
// If this is an accelerated (i.e., double) deletion, then we need to
// consider unlearning here because we may have already reached
// the previous word, and will lose it after next deletion.
hasUnlearnedWordBeingDeleted |= unlearnWordBeingDeleted(
inputTransaction.mSettingsValues, currentKeyboardScriptId);
sendDownUpKeyEvent(KeyEvent.KEYCODE_DEL, 0);
totalDeletedLength++;
}
StatsUtils.onBackspacePressed(totalDeletedLength);
} else {
final int codePointBeforeCursor = mConnection.getCodePointBeforeCursor();
if (codePointBeforeCursor == Constants.NOT_A_CODE) {
// HACK for backward compatibility with broken apps that haven't realized
// yet that hardware keyboards are not the only way of inputting text.
// Nothing to delete before the cursor. We should not do anything, but many
// broken apps expect something to happen in this case so that they can
// catch it and have their broken interface react. If you need the keyboard
// to do this, you're doing it wrong -- please fix your app.
//mConnection.deleteTextBeforeCursor(1);
sendDownUpKeyEvent(KeyEvent.KEYCODE_DEL, 0);
// TODO: Add a new StatsUtils method onBackspaceWhenNoText()
return;
}
String textDeleted = new String(Character.toChars(codePointBeforeCursor));
int lengthToDelete =
Character.isSupplementaryCodePoint(codePointBeforeCursor) ? 2 : 1;
// Handle emoji sequences (flags, etc)
CharSequence textBeforeCursor = mConnection.getTextBeforeCursor(deleteWholeWords ? 48 : 8, 0);
if (textBeforeCursor != null && textBeforeCursor.length() > 0) {
BreakIterator breakIterator;
if(deleteWholeWords) {
breakIterator = BreakIterator.getWordInstance();
} else {
breakIterator = BreakIterator.getCharacterInstance();
}
breakIterator.setText(textBeforeCursor.toString());
int end = breakIterator.last();
int start = breakIterator.previous();
if(deleteWholeWords && textBeforeCursor.subSequence(start, end).toString().equals(" ")) {
start = breakIterator.previous();
}
if (start != BreakIterator.DONE) {
lengthToDelete = end - start;
textDeleted = textBeforeCursor.subSequence(start, end).toString();
}
}
Log.d(TAG, "lengthToDelete=" + lengthToDelete + ", textDeleted=" + textDeleted);
mConnection.deleteTextBeforeCursor(lengthToDelete);
int totalDeletedLength = lengthToDelete;
if (mDeleteCount > Constants.DELETE_ACCELERATE_AT) {
// If this is an accelerated (i.e., double) deletion, then we need to
// consider unlearning here because we may have already reached
// the previous word, and will lose it after next deletion.
hasUnlearnedWordBeingDeleted |= unlearnWordBeingDeleted(
inputTransaction.mSettingsValues, currentKeyboardScriptId);
final int codePointBeforeCursorToDeleteAgain =
mConnection.getCodePointBeforeCursor();
if (codePointBeforeCursorToDeleteAgain != Constants.NOT_A_CODE) {
final int lengthToDeleteAgain = Character.isSupplementaryCodePoint(
codePointBeforeCursorToDeleteAgain) ? 2 : 1;
mConnection.deleteTextBeforeCursor(lengthToDeleteAgain);
totalDeletedLength += lengthToDeleteAgain;
}
}
StatsUtils.onBackspacePressed(totalDeletedLength);
if(codePointBeforeCursor >= 0x1F600)
mLatinIMELegacy.onCodePointDeleted(textDeleted);
}
}
if (!hasUnlearnedWordBeingDeleted) {
// Consider unlearning the word being deleted (if we have not done so already).
unlearnWordBeingDeleted(
inputTransaction.mSettingsValues, currentKeyboardScriptId);
}
if (mConnection.hasSlowInputConnection()) {
mSuggestionStripViewAccessor.setNeutralSuggestionStrip();
} else if (inputTransaction.mSettingsValues.isSuggestionsEnabledPerUserSettings()
&& inputTransaction.mSettingsValues.mSpacingAndPunctuations
.mCurrentLanguageHasSpaces
&& !mConnection.isCursorFollowedByWordCharacter(
inputTransaction.mSettingsValues.mSpacingAndPunctuations)) {
restartSuggestionsOnWordTouchedByCursor(inputTransaction.mSettingsValues,
false /* forStartInput */, currentKeyboardScriptId);
}
}
}
String getWordAtCursor(final SettingsValues settingsValues, final int currentKeyboardScriptId) {
if (!mConnection.hasSelection()
&& settingsValues.isSuggestionsEnabledPerUserSettings()
&& settingsValues.mSpacingAndPunctuations.mCurrentLanguageHasSpaces) {
final TextRange range = mConnection.getWordRangeAtCursor(
settingsValues.mSpacingAndPunctuations,
currentKeyboardScriptId);
if (range != null) {
return range.mWord.toString();
}
}
return "";
}
boolean unlearnWordBeingDeleted(
final SettingsValues settingsValues, final int currentKeyboardScriptId) {
if (mConnection.hasSlowInputConnection()) {
// TODO: Refactor unlearning so that it does not incur any extra calls
// to the InputConnection. That way it can still be performed on a slow
// InputConnection.
Log.w(TAG, "Skipping unlearning due to slow InputConnection.");
return false;
}
// If we just started backspacing to delete a previous word (but have not
// entered the composing state yet), unlearn the word.
// TODO: Consider tracking whether or not this word was typed by the user.
if (!mConnection.isCursorFollowedByWordCharacter(settingsValues.mSpacingAndPunctuations)) {
final String wordBeingDeleted = getWordAtCursor(
settingsValues, currentKeyboardScriptId);
if (!TextUtils.isEmpty(wordBeingDeleted)) {
unlearnWord(wordBeingDeleted, settingsValues, Constants.EVENT_BACKSPACE);
return true;
}
}
return false;
}
void unlearnWord(final String word, final SettingsValues settingsValues, final int eventType) {
final NgramContext ngramContext = mConnection.getNgramContextFromNthPreviousWord(
settingsValues.mSpacingAndPunctuations, 2);
final long timeStampInSeconds = TimeUnit.MILLISECONDS.toSeconds(
System.currentTimeMillis());
mDictionaryFacilitator.unlearnFromUserHistory(
word, ngramContext, timeStampInSeconds, eventType);
// FIXME: For some reason, 2 is the right value some times and 1 is the right value at other times.
// To make sure it's deleted from history, we just call it with both and one of them should work
if(settingsValues.mTransformerPredictionEnabled) {
final NgramContext ngramContext1 = mConnection.getNgramContextFromNthPreviousWord(
settingsValues.mSpacingAndPunctuations, 1);
mLatinIMELegacy.getLanguageModelFacilitator().unlearnFromHistory(
word, ngramContext, timeStampInSeconds, eventType);
mLatinIMELegacy.getLanguageModelFacilitator().unlearnFromHistory(
word, ngramContext1, timeStampInSeconds, eventType);
}
}
/**
* Handle a press on the language switch key (the "globe key")
*/
private void handleLanguageSwitchKey() {
mLatinIMELegacy.switchToNextSubtype();
}
/**
* Swap a space with a space-swapping punctuation sign.
*
* This method will check that there are two characters before the cursor and that the first
* one is a space before it does the actual swapping.
* @param event The event to handle.
* @param inputTransaction The transaction in progress.
* @return true if the swap has been performed, false if it was prevented by preliminary checks.
*/
private boolean trySwapSwapperAndSpace(final Event event,
final InputTransaction inputTransaction) {
final int codePointBeforeCursor = mConnection.getCodePointBeforeCursor();
if (Constants.CODE_SPACE != codePointBeforeCursor) {
return false;
}
final boolean isWritingSchema = event.mCodePoint == '/'
&& mConnection.isPotentiallyWritingSchema();
mConnection.deleteTextBeforeCursor(1);
boolean stripSpace = inputTransaction.mSettingsValues.mInputAttributes.mIsUriField || isWritingSchema;
final String text = event.getTextToCommit() +
(stripSpace ? "" : " ");
mConnection.commitText(text, 1);
inputTransaction.requireShiftUpdate(InputTransaction.SHIFT_UPDATE_NOW);
return true;
}
/*
* Special case for symbols that are usually preceded by space.
* Given the codepoint and the prior codepoint (skipping over a space if one is there),
* it will return true if the preceding space should be skipped.
*
* This is mainly applicable for French question marks, so that typing ...??!? would not result
* in ... ? ? ! ?
*/
private boolean symbolRequiringPrecedingSpaceShouldSkipPrecedingSpace(final int codePoint,
final int priorCodePoint, final InputTransaction inputTransaction) {
if(!inputTransaction.mSettingsValues.isUsuallyPrecededBySpace(codePoint)) return false;
if(!inputTransaction.mSettingsValues.isUsuallyFollowedBySpace(priorCodePoint)) return false;
return (codePoint == priorCodePoint)
|| inputTransaction.mSettingsValues.mSpacingAndPunctuations.isSentenceTerminator(priorCodePoint);
}
/*
* Strip a trailing space if necessary and returns whether it's a swap weak space situation.
* @param event The event to handle.
* @param inputTransaction The transaction in progress.
* @return whether we should swap the space instead of removing it.
*/
private boolean tryStripSpaceAndReturnWhetherShouldSwapInstead(final Event event,
final InputTransaction inputTransaction) {
final int codePoint = event.mCodePoint;
final boolean isFromSuggestionStrip = event.isSuggestionStripPress();
if (Constants.CODE_ENTER == codePoint && (
(SpaceState.SWAP_PUNCTUATION == inputTransaction.mSpaceState) ||
(SpaceState.ANTIPHANTOM == inputTransaction.mSpaceState)
)) {
mConnection.removeTrailingSpace();
return false;
}
if ((SpaceState.WEAK == inputTransaction.mSpaceState
|| SpaceState.SWAP_PUNCTUATION == inputTransaction.mSpaceState)
&& isFromSuggestionStrip) {
if (inputTransaction.mSettingsValues.isUsuallyPrecededBySpace(codePoint)) {
return false;
}
if (inputTransaction.mSettingsValues.isUsuallyFollowedBySpace(codePoint)) {
return true;
}
mConnection.removeTrailingSpace();
}
final boolean isInsideDoubleQuoteOrAfterDigit = Constants.CODE_DOUBLE_QUOTE == codePoint
&& mConnection.isInsideDoubleQuoteOrAfterDigit();
final boolean isPotentiallyWritingSchema = codePoint == '/'
&& mConnection.isPotentiallyWritingSchema();
final boolean settingsPermitSwapping =
inputTransaction.mSettingsValues.mAltSpacesMode >= Settings.SPACES_MODE_ALL;
// If we are typing a bunch of dashes, strip the space instead of padding them with spaces
if(inputTransaction.mSpaceState == SpaceState.ANTIPHANTOM
&& inputTransaction.mSettingsValues.isUsuallyFollowedBySpaceIffPrecededBySpace(codePoint)
&& codePoint == mConnection.getNthCodePointBeforeCursor(1)
) {
mConnection.removeTrailingSpace();
return false;
}
// Text field either needs to be fit for automatic spaces, or be a uri field
// (in the case of uri field, we will strip trailing space without adding it back
// in trySwapSwapperAndSpace)
// TODO: Maybe just do mConnection.removeTrailingSpace() here in case of uri field
final boolean textFieldFitForSwapping =
inputTransaction.mSettingsValues.shouldInsertSpacesAutomatically()
|| inputTransaction.mSettingsValues.mInputAttributes.mIsUriField;
// Character needs to be usually followed by space (eg . , ? !)
// or be an ending quotation mark, or be a schema to strip the space in case of https: //
// TODO: Maybe just do mConnection.removeTrailingSpace() here in case of schema
boolean characterFitForSwapping = (
inputTransaction.mSettingsValues.isUsuallyFollowedBySpace(codePoint)
|| isInsideDoubleQuoteOrAfterDigit
|| isPotentiallyWritingSchema
);
// If this codepoint is preceded by a space, we swap it only if the preceding space is
// skippable, and if we are in antiphantom state.
//
// French example: if I type "je..", a space is automatically inserted, and I type a
// question mark, the space will be swapped to produce "je..? "
// If I type "je..", the space is automatically inserted, I tap space manually which unsets
// antiphantom state, the space will NOT be swapped and will instead get "je.. ? "
if(characterFitForSwapping
&& inputTransaction.mSettingsValues.isUsuallyPrecededBySpace(codePoint)) {
characterFitForSwapping = symbolRequiringPrecedingSpaceShouldSkipPrecedingSpace(
codePoint,
mConnection.getNthCodePointBeforeCursor(1),
inputTransaction
) && inputTransaction.mSpaceState == SpaceState.ANTIPHANTOM;
}
// If this codepoint can be preceded by space optionally, only perform the swap if the
// preceding space was automatically added. If I type "hello", space, and ":)", it should
// type "hello :)"
if(characterFitForSwapping
&& inputTransaction.mSettingsValues.isOptionallyPrecededBySpace(codePoint)) {
characterFitForSwapping = inputTransaction.mSpaceState == SpaceState.ANTIPHANTOM;
}
return settingsPermitSwapping && textFieldFitForSwapping && characterFitForSwapping;
}
public void startDoubleSpacePeriodCountdown(final InputTransaction inputTransaction) {
mDoubleSpacePeriodCountdownStart = inputTransaction.mTimestamp;
}
public void cancelDoubleSpacePeriodCountdown() {
mDoubleSpacePeriodCountdownStart = 0;
}
public boolean isDoubleSpacePeriodCountdownActive(final InputTransaction inputTransaction) {
return inputTransaction.mTimestamp - mDoubleSpacePeriodCountdownStart
< inputTransaction.mSettingsValues.mDoubleSpacePeriodTimeout;
}
/**
* Apply the double-space-to-period transformation if applicable.
*
* The double-space-to-period transformation means that we replace two spaces with a
* period-space sequence of characters. This typically happens when the user presses space
* twice in a row quickly.
* This method will check that the double-space-to-period is active in settings, that the
* two spaces have been input close enough together, that the typed character is a space
* and that the previous character allows for the transformation to take place. If all of
* these conditions are fulfilled, this method applies the transformation and returns true.
* Otherwise, it does nothing and returns false.
*
* @param event The event to handle.
* @param inputTransaction The transaction in progress.
* @return true if we applied the double-space-to-period transformation, false otherwise.
*/
private boolean tryPerformDoubleSpacePeriod(final Event event,
final InputTransaction inputTransaction) {
// Check the setting, the typed character and the countdown. If any of the conditions is
// not fulfilled, return false.
if (!inputTransaction.mSettingsValues.mUseDoubleSpacePeriod
|| Constants.CODE_SPACE != event.mCodePoint
|| !isDoubleSpacePeriodCountdownActive(inputTransaction)) {
return false;
}
// We only do this when we see one space and an accepted code point before the cursor.
// The code point may be a surrogate pair but the space may not, so we need 3 chars.
final CharSequence lastTwo = mConnection.getTextBeforeCursor(3, 0);
if (null == lastTwo) return false;
final int length = lastTwo.length();
if (length < 2) return false;
if (lastTwo.charAt(length - 1) != Constants.CODE_SPACE) {
return false;
}
// We know there is a space in pos -1, and we have at least two chars. If we have only two
// chars, isSurrogatePairs can't return true as charAt(1) is a space, so this is fine.
final int firstCodePoint =
Character.isSurrogatePair(lastTwo.charAt(0), lastTwo.charAt(1)) ?
Character.codePointAt(lastTwo, length - 3) : lastTwo.charAt(length - 2);
if (canBeFollowedByDoubleSpacePeriod(firstCodePoint)) {
cancelDoubleSpacePeriodCountdown();
mConnection.deleteTextBeforeCursor(1);
final String textToInsert = inputTransaction.mSettingsValues.mSpacingAndPunctuations
.mSentenceSeparatorAndSpace;
mConnection.commitText(textToInsert, 1);
inputTransaction.requireShiftUpdate(InputTransaction.SHIFT_UPDATE_NOW);
inputTransaction.setRequiresUpdateSuggestions();
return true;
}
return false;
}
/**
* Returns whether this code point can be followed by the double-space-to-period transformation.
*
* See #maybeDoubleSpaceToPeriod for details.
* Generally, most word characters can be followed by the double-space-to-period transformation,
* while most punctuation can't. Some punctuation however does allow for this to take place
* after them, like the closing parenthesis for example.
*
* @param codePoint the code point after which we may want to apply the transformation
* @return whether it's fine to apply the transformation after this code point.
*/
private static boolean canBeFollowedByDoubleSpacePeriod(final int codePoint) {
// TODO: This should probably be a denylist rather than a allowlist.
// TODO: This should probably be language-dependant...
return Character.isLetterOrDigit(codePoint)
|| codePoint == Constants.CODE_SINGLE_QUOTE
|| codePoint == Constants.CODE_DOUBLE_QUOTE
|| codePoint == Constants.CODE_CLOSING_PARENTHESIS
|| codePoint == Constants.CODE_CLOSING_SQUARE_BRACKET
|| codePoint == Constants.CODE_CLOSING_CURLY_BRACKET
|| codePoint == Constants.CODE_CLOSING_ANGLE_BRACKET
|| codePoint == Constants.CODE_PLUS
|| codePoint == Constants.CODE_PERCENT
|| Character.getType(codePoint) == Character.OTHER_SYMBOL;
}
/**
* Performs a recapitalization event.
* @param settingsValues The current settings values.
*/
private void performRecapitalization(final SettingsValues settingsValues) {
if (!mConnection.hasSelection() || !mRecapitalizeStatus.mIsEnabled()) {
return; // No selection or recapitalize is disabled for now
}
final int selectionStart = mConnection.getExpectedSelectionStart();
final int selectionEnd = mConnection.getExpectedSelectionEnd();
final int numCharsSelected = selectionEnd - selectionStart;
if (numCharsSelected > Constants.MAX_CHARACTERS_FOR_RECAPITALIZATION) {
// We bail out if we have too many characters for performance reasons. We don't want
// to suck possibly multiple-megabyte data.
return;
}
// If we have a recapitalize in progress, use it; otherwise, start a new one.
if (!mRecapitalizeStatus.isStarted()
|| !mRecapitalizeStatus.isSetAt(selectionStart, selectionEnd)) {
final CharSequence selectedText =
mConnection.getSelectedText(0 /* flags, 0 for no styles */);
if (TextUtils.isEmpty(selectedText)) return; // Race condition with the input connection
mRecapitalizeStatus.start(selectionStart, selectionEnd, selectedText.toString(),
settingsValues.mLocale,
settingsValues.mSpacingAndPunctuations.mSortedWordSeparators);
// We trim leading and trailing whitespace.
mRecapitalizeStatus.trim();
}
mConnection.finishComposingText();
mRecapitalizeStatus.rotate();
mConnection.setSelection(selectionEnd, selectionEnd);
mConnection.deleteTextBeforeCursor(numCharsSelected);
mConnection.commitText(mRecapitalizeStatus.getRecapitalizedString(), 0);
mConnection.setSelection(mRecapitalizeStatus.getNewCursorStart(),
mRecapitalizeStatus.getNewCursorEnd());
}
private void performAdditionToUserHistoryDictionary(final SettingsValues settingsValues,
final String suggestion, @Nonnull final NgramContext ngramContext, final int importance) {
// If correction is not enabled, we don't add words to the user history dictionary.
// That's to avoid unintended additions in some sensitive fields, or fields that
// expect to receive non-words.
if (!settingsValues.mAutoCorrectionEnabledPerUserSettings) return;
if (settingsValues.mInputAttributes.mNoLearning) return;
if (mConnection.hasSlowInputConnection()) {
// Since we don't unlearn when the user backspaces on a slow InputConnection,
// turn off learning to guard against adding typos that the user later deletes.
Log.w(TAG, "Skipping learning due to slow InputConnection.");
return;
}
if (TextUtils.isEmpty(suggestion)) return;
final boolean wasAutoCapitalized =
mWordComposer.wasAutoCapitalized() && !mWordComposer.isMostlyCaps();
final int timeStampInSeconds = (int)TimeUnit.MILLISECONDS.toSeconds(
System.currentTimeMillis());
mDictionaryFacilitator.addToUserHistory(suggestion, wasAutoCapitalized,
ngramContext, timeStampInSeconds, settingsValues.mBlockPotentiallyOffensive);
if(settingsValues.mTransformerPredictionEnabled) {
mLatinIMELegacy.getLanguageModelFacilitator().addToHistory(suggestion, wasAutoCapitalized,
ngramContext, timeStampInSeconds, settingsValues.mBlockPotentiallyOffensive, importance);
}
}
private boolean ensureSuggestionStripCompleted(final SettingsValues settingsValues,
final String separator, final LatinIMELegacy.UIHandler handler) {
LanguageModelFacilitator facilitator = handler.getLanguageModelFacilitator();
if(!facilitator.shouldPassThroughToLegacy()) {
if(facilitator.hasPendingUpdate()) {
return facilitator.blockUntilComplete();
}
} else {
if (handler.hasPendingUpdateSuggestions()) {
handler.cancelUpdateSuggestionStrip();
// To know the input style here, we should retrieve the in-flight "update suggestions"
// message and read its arg1 member here. However, the Handler class does not let
// us retrieve this message, so we can't do that. But in fact, we notice that
// we only ever come here when the input style was typing. In the case of batch
// input, we update the suggestions synchronously when the tail batch comes. Likewise
// for application-specified completions. As for recorrections, we never auto-correct,
// so we don't come here either. Hence, the input style is necessarily
// INPUT_STYLE_TYPING.
performUpdateSuggestionStripSync(settingsValues, SuggestedWords.INPUT_STYLE_TYPING);
}
}
return true;
}
public void performUpdateSuggestionStripSync(final SettingsValues settingsValues,
final int inputStyle) {
long startTimeMillis = 0;
if (DebugFlags.DEBUG_ENABLED) {
startTimeMillis = System.currentTimeMillis();
Log.d(TAG, "performUpdateSuggestionStripSync()");
}
// Check if we have a suggestion engine attached.
if (!settingsValues.needsToLookupSuggestions()) {
if (mWordComposer.isComposingWord()) {
Log.w(TAG, "Called updateSuggestionsOrPredictions but suggestions were not "
+ "requested!");
}
// Clear the suggestions strip.
mSuggestionStripViewAccessor.showSuggestionStrip(SuggestedWords.getEmptyInstance());
return;
}
if (!mWordComposer.isComposingWord() && !settingsValues.mBigramPredictionEnabled) {
mSuggestionStripViewAccessor.setNeutralSuggestionStrip();
return;
}
mSuggestionStripViewAccessor.setNeutralSuggestionStrip();
final AsyncResultHolder<SuggestedWords> holder = new AsyncResultHolder<>("Suggest");
mInputLogicHandler.getSuggestedWords(inputStyle, SuggestedWords.NOT_A_SEQUENCE_NUMBER,
new OnGetSuggestedWordsCallback() {
@Override
public void onGetSuggestedWords(final SuggestedWords suggestedWords) {
final String typedWordString = mWordComposer.getTypedWord();
final SuggestedWordInfo typedWordInfo = new SuggestedWordInfo(
typedWordString, "" /* prevWordsContext */,
SuggestedWordInfo.MAX_SCORE,
SuggestedWordInfo.KIND_TYPED, Dictionary.DICTIONARY_USER_TYPED,
SuggestedWordInfo.NOT_AN_INDEX /* indexOfTouchPointOfSecondWord */,
SuggestedWordInfo.NOT_A_CONFIDENCE);
// Show new suggestions if we have at least one. Otherwise keep the old
// suggestions with the new typed word. Exception: if the length of the
// typed word is <= 1 (after a deletion typically) we clear old suggestions.
if (suggestedWords.size() > 1 || typedWordString.length() <= 1) {
holder.set(suggestedWords);
} else {
holder.set(retrieveOlderSuggestions(typedWordInfo, mSuggestedWords));
}
}
}
);
// This line may cause the current thread to wait.
final SuggestedWords suggestedWords = holder.get(null,
Constants.GET_SUGGESTED_WORDS_TIMEOUT);
if (suggestedWords != null) {
mSuggestionStripViewAccessor.showSuggestionStrip(suggestedWords);
}
if (DebugFlags.DEBUG_ENABLED) {
long runTimeMillis = System.currentTimeMillis() - startTimeMillis;
Log.d(TAG, "performUpdateSuggestionStripSync() : " + runTimeMillis + " ms to finish");
}
}
/**
* Check if the cursor is touching a word. If so, restart suggestions on this word, else
* do nothing.
*
* @param settingsValues the current values of the settings.
* @param forStartInput whether we're doing this in answer to starting the input (as opposed
* to a cursor move, for example). In ICS, there is a platform bug that we need to work
* around only when we come here at input start time.
*/
public void restartSuggestionsOnWordTouchedByCursor(final SettingsValues settingsValues,
final boolean forStartInput,
// TODO: remove this argument, put it into settingsValues
final int currentKeyboardScriptId) {
mSpaceState = SpaceState.NONE;
// HACK: We may want to special-case some apps that exhibit bad behavior in case of
// recorrection. This is a temporary, stopgap measure that will be removed later.
// TODO: remove this.
if (settingsValues.isBrokenByRecorrection()
// Recorrection is not supported in languages without spaces because we don't know
// how to segment them yet.
|| !settingsValues.mSpacingAndPunctuations.mCurrentLanguageHasSpaces
// If no suggestions are requested, don't try restarting suggestions.
|| !settingsValues.needsToLookupSuggestions()
// If we are currently in a batch input, we must not resume suggestions, or the result
// of the batch input will replace the new composition. This may happen in the corner case
// that the app moves the cursor on its own accord during a batch input.
|| mInputLogicHandler.isInBatchInput()
// If the cursor is not touching a word, or if there is a selection, return right away.
|| mConnection.hasSelection()
// If we don't know the cursor location, return.
|| mConnection.getExpectedSelectionStart() < 0) {
mSuggestionStripViewAccessor.setNeutralSuggestionStrip();
return;
}
final int expectedCursorPosition = mConnection.getExpectedSelectionStart();
if (!mConnection.isCursorTouchingWord(settingsValues.mSpacingAndPunctuations,
true /* checkTextAfter */)) {
//Log.d(TAG, "Reset input state");
resetEntireInputState(
mConnection.getExpectedSelectionStart(),
mConnection.getExpectedSelectionEnd(),
true
);
//Log.d(TAG, "ComposingText1 [" + mConnection.getComposingTextForDebug() + "] , TypedWord [" + mWordComposer.getTypedWord() + "]");
// Show predictions.
mWordComposer.setCapitalizedModeAtStartComposingTime(WordComposer.CAPS_MODE_OFF);
mLatinIMELegacy.mHandler.postUpdateSuggestionStrip(SuggestedWords.INPUT_STYLE_RECORRECTION);
return;
}
final TextRange range = mConnection.getWordRangeAtCursor(
settingsValues.mSpacingAndPunctuations, currentKeyboardScriptId);
if (null == range) return; // Happens if we don't have an input connection at all
if (range.length() <= 0) {
// Race condition, or touching a word in a non-supported script.
mLatinIMELegacy.setNeutralSuggestionStrip();
return;
}
// If for some strange reason (editor bug or so) we measure the text before the cursor as
// longer than what the entire text is supposed to be, the safe thing to do is bail out.
if (range.mHasUrlSpans) return; // If there are links, we don't resume suggestions. Making
// edits to a linkified text through batch commands would ruin the URL spans, and unless
// we take very complicated steps to preserve the whole link, we can't do things right so
// we just do not resume because it's safer.
final int numberOfCharsInWordBeforeCursor = range.getNumberOfCharsInWordBeforeCursor();
if (numberOfCharsInWordBeforeCursor > expectedCursorPosition) return;
final ArrayList<SuggestedWordInfo> suggestions = new ArrayList<>();
final String typedWordString = range.mWord.toString();
final SuggestedWordInfo typedWordInfo = new SuggestedWordInfo(typedWordString,
"" /* prevWordsContext */, SuggestedWords.MAX_SUGGESTIONS + 1,
SuggestedWordInfo.KIND_TYPED, Dictionary.DICTIONARY_USER_TYPED,
SuggestedWordInfo.NOT_AN_INDEX /* indexOfTouchPointOfSecondWord */,
SuggestedWordInfo.NOT_A_CONFIDENCE /* autoCommitFirstWordConfidence */);
suggestions.add(typedWordInfo);
if (!isResumableWord(settingsValues, typedWordString)) {
mSuggestionStripViewAccessor.setNeutralSuggestionStrip();
return;
}
int i = 0;
for (final SuggestionSpan span : range.getSuggestionSpansAtWord()) {
for (final String s : span.getSuggestions()) {
++i;
if (!TextUtils.equals(s, typedWordString)) {
suggestions.add(new SuggestedWordInfo(s,
"" /* prevWordsContext */, SuggestedWords.MAX_SUGGESTIONS - i,
SuggestedWordInfo.KIND_RESUMED, Dictionary.DICTIONARY_RESUMED,
SuggestedWordInfo.NOT_AN_INDEX /* indexOfTouchPointOfSecondWord */,
SuggestedWordInfo.NOT_A_CONFIDENCE
/* autoCommitFirstWordConfidence */));
}
}
}
final int[] codePoints = StringUtils.toCodePointArray(typedWordString);
mWordComposer.setComposingWord(codePoints,
mLatinIMELegacy.getCoordinatesForCurrentKeyboard(codePoints));
mWordComposer.setCursorPositionWithinWord(
typedWordString.codePointCount(0, numberOfCharsInWordBeforeCursor));
if (forStartInput) {
mConnection.maybeMoveTheCursorAroundAndRestoreToWorkaroundABug();
}
mConnection.setComposingRegion(expectedCursorPosition - numberOfCharsInWordBeforeCursor,
expectedCursorPosition + range.getNumberOfCharsInWordAfterCursor());
if (suggestions.size() <= 1) {
// If there weren't any suggestion spans on this word, suggestions#size() will be 1
// if shouldIncludeResumedWordInSuggestions is true, 0 otherwise. In this case, we
// have no useful suggestions, so we will try to compute some for it instead.
mInputLogicHandler.getSuggestedWords(Suggest.SESSION_ID_TYPING,
SuggestedWords.NOT_A_SEQUENCE_NUMBER, new OnGetSuggestedWordsCallback() {
@Override
public void onGetSuggestedWords(final SuggestedWords suggestedWords) {
doShowSuggestionsAndClearAutoCorrectionIndicator(suggestedWords);
}});
} else {
// We found suggestion spans in the word. We'll create the SuggestedWords out of
// them, and make willAutoCorrect false. We make typedWordValid false, because the
// color of the word in the suggestion strip changes according to this parameter,
// and false gives the correct color.
final SuggestedWords suggestedWords = new SuggestedWords(suggestions,
null /* rawSuggestions */, typedWordInfo, false /* typedWordValid */,
false /* willAutoCorrect */, false /* isObsoleteSuggestions */,
SuggestedWords.INPUT_STYLE_RECORRECTION, SuggestedWords.NOT_A_SEQUENCE_NUMBER);
doShowSuggestionsAndClearAutoCorrectionIndicator(suggestedWords);
}
}
void doShowSuggestionsAndClearAutoCorrectionIndicator(final SuggestedWords suggestedWords) {
mIsAutoCorrectionIndicatorOn = false;
mLatinIMELegacy.mHandler.showSuggestionStrip(suggestedWords);
}
/**
* Reverts a previous commit with auto-correction.
*
* This is triggered upon pressing backspace just after a commit with auto-correction.
*
* @param inputTransaction The transaction in progress.
* @param settingsValues the current values of the settings.
*/
private void revertCommit(final InputTransaction inputTransaction,
final SettingsValues settingsValues) {
final CharSequence originallyTypedWord = mLastComposedWord.mTypedWord;
final String originallyTypedWordString =
originallyTypedWord != null ? originallyTypedWord.toString() : "";
final CharSequence committedWord = mLastComposedWord.mCommittedWord;
final String committedWordString = committedWord.toString();
final int cancelLength = committedWord.length();
final String separatorString = mLastComposedWord.mSeparatorString;
// If our separator is a space, we won't actually commit it,
// but set the space state to PHANTOM so that a space will be inserted
// on the next keypress
final boolean usePhantomSpace = separatorString.equals(Constants.STRING_SPACE);
// We want java chars, not codepoints for the following.
int separatorLength = separatorString.length();
// TODO: should we check our saved separator against the actual contents of the text view?
final int deleteLength = cancelLength + separatorLength;
if (DebugFlags.DEBUG_ENABLED) {
if (mWordComposer.isComposingWord()) {
throw new RuntimeException("revertCommit, but we are composing a word");
}
final CharSequence wordBeforeCursor =
mConnection.getTextBeforeCursor(deleteLength, 0).subSequence(0, cancelLength);
if (!TextUtils.equals(committedWord, wordBeforeCursor)) {
throw new RuntimeException("revertCommit check failed: we thought we were "
+ "reverting \"" + committedWord
+ "\", but before the cursor we found \"" + wordBeforeCursor + "\"");
}
}
mConnection.deleteTextBeforeCursor(deleteLength);
if (!TextUtils.isEmpty(committedWord)) {
unlearnWord(committedWordString, inputTransaction.mSettingsValues,
Constants.EVENT_REVERT);
}
final String stringToCommit = originallyTypedWord +
(usePhantomSpace ? "" : separatorString);
final SpannableString textToCommit = new SpannableString(stringToCommit);
if (committedWord instanceof SpannableString) {
final SpannableString committedWordWithSuggestionSpans = (SpannableString)committedWord;
final Object[] spans = committedWordWithSuggestionSpans.getSpans(0,
committedWord.length(), Object.class);
final int lastCharIndex = textToCommit.length() - 1;
// We will collect all suggestions in the following array.
final ArrayList<String> suggestions = new ArrayList<>();
// First, add the committed word to the list of suggestions.
suggestions.add(committedWordString);
for (final Object span : spans) {
// If this is a suggestion span, we check that the word is not the committed word.
// That should mostly be the case.
// Given this, we add it to the list of suggestions, otherwise we discard it.
if (span instanceof SuggestionSpan) {
final SuggestionSpan suggestionSpan = (SuggestionSpan)span;
for (final String suggestion : suggestionSpan.getSuggestions()) {
if (!suggestion.equals(committedWordString)) {
suggestions.add(suggestion);
}
}
} else {
// If this is not a suggestion span, we just add it as is.
textToCommit.setSpan(span, 0 /* start */, lastCharIndex /* end */,
committedWordWithSuggestionSpans.getSpanFlags(span));
}
}
// Add the suggestion list to the list of suggestions.
textToCommit.setSpan(new SuggestionSpan(mLatinIMELegacy.getInputMethodService(),
inputTransaction.mSettingsValues.mLocale,
suggestions.toArray(new String[suggestions.size()]), 0 /* flags */,
null /* notificationTargetClass */),
0 /* start */, lastCharIndex /* end */, 0 /* flags */);
}
if (inputTransaction.mSettingsValues.mSpacingAndPunctuations.mCurrentLanguageHasSpaces) {
mConnection.commitText(textToCommit, 1);
if (usePhantomSpace) {
mSpaceState = SpaceState.PHANTOM;
}
} else {
// For languages without spaces, we revert the typed string but the cursor is flush
// with the typed word, so we need to resume suggestions right away.
final int[] codePoints = StringUtils.toCodePointArray(stringToCommit);
mWordComposer.setComposingWord(codePoints,
mLatinIMELegacy.getCoordinatesForCurrentKeyboard(codePoints));
setComposingTextInternal(textToCommit, 1);
}
// Don't restart suggestion yet. We'll restart if the user deletes the separator.
mLastComposedWord = LastComposedWord.NOT_A_COMPOSED_WORD;
// We have a separator between the word and the cursor: we should show predictions.
inputTransaction.setRequiresUpdateSuggestions();
}
/**
* Factor in auto-caps and manual caps and compute the current caps mode.
* @param settingsValues the current settings values.
* @param keyboardShiftMode the current shift mode of the keyboard. See
* KeyboardSwitcher#getKeyboardShiftMode() for possible values.
* @return the actual caps mode the keyboard is in right now.
*/
private int getActualCapsMode(final SettingsValues settingsValues,
final int keyboardShiftMode) {
if (keyboardShiftMode != WordComposer.CAPS_MODE_AUTO_SHIFTED) {
return keyboardShiftMode;
}
final int auto = getCurrentAutoCapsState(settingsValues);
if (0 != (auto & TextUtils.CAP_MODE_CHARACTERS)) {
return WordComposer.CAPS_MODE_AUTO_SHIFT_LOCKED;
}
if (0 != auto) {
return WordComposer.CAPS_MODE_AUTO_SHIFTED;
}
return WordComposer.CAPS_MODE_OFF;
}
/**
* Gets the current auto-caps state, factoring in the space state.
*
* This method tries its best to do this in the most efficient possible manner. It avoids
* getting text from the editor if possible at all.
* This is called from the KeyboardSwitcher (through a trampoline in LatinIME) because it
* needs to know auto caps state to display the right layout.
*
* @param settingsValues the relevant settings values
* @return a caps mode from TextUtils.CAP_MODE_* or Constants.TextUtils.CAP_MODE_OFF.
*/
public int getCurrentAutoCapsState(final SettingsValues settingsValues) {
if (!settingsValues.mAutoCap) return Constants.TextUtils.CAP_MODE_OFF;
final EditorInfo ei = getCurrentInputEditorInfo();
if (ei == null) return Constants.TextUtils.CAP_MODE_OFF;
final int inputType = ei.inputType;
// Warning: this depends on mSpaceState, which may not be the most current value. If
// mSpaceState gets updated later, whoever called this may need to be told about it.
return mConnection.getCursorCapsMode(inputType, settingsValues.mSpacingAndPunctuations,
SpaceState.PHANTOM == mSpaceState);
}
public int getCurrentRecapitalizeState() {
if (!mRecapitalizeStatus.isStarted()
|| !mRecapitalizeStatus.isSetAt(mConnection.getExpectedSelectionStart(),
mConnection.getExpectedSelectionEnd())) {
// Not recapitalizing at the moment
return RecapitalizeStatus.NOT_A_RECAPITALIZE_MODE;
}
return mRecapitalizeStatus.getCurrentMode();
}
/**
* @return the editor info for the current editor
*/
private EditorInfo getCurrentInputEditorInfo() {
return mLatinIMELegacy.getInputMethodService().getCurrentInputEditorInfo();
}
/**
* Get n-gram context from the nth previous word before the cursor as context
* for the suggestion process.
* @param spacingAndPunctuations the current spacing and punctuations settings.
* @param nthPreviousWord reverse index of the word to get (1-indexed)
* @return the information of previous words
*/
public NgramContext getNgramContextFromNthPreviousWordForSuggestion(
final SpacingAndPunctuations spacingAndPunctuations, final int nthPreviousWord) {
if (spacingAndPunctuations.mCurrentLanguageHasSpaces) {
// If we are typing in a language with spaces we can just look up the previous
// word information from textview.
return mConnection.getNgramContextFromNthPreviousWord(
spacingAndPunctuations, nthPreviousWord);
}
if (LastComposedWord.NOT_A_COMPOSED_WORD == mLastComposedWord) {
return NgramContext.BEGINNING_OF_SENTENCE;
}
return new NgramContext(new NgramContext.WordInfo(
mLastComposedWord.mCommittedWord.toString()));
}
/**
* Tests the passed word for resumability.
*
* We can resume suggestions on words whose first code point is a word code point (with some
* nuances: check the code for details).
*
* @param settings the current values of the settings.
* @param word the word to evaluate.
* @return whether it's fine to resume suggestions on this word.
*/
private static boolean isResumableWord(final SettingsValues settings, final String word) {
final int firstCodePoint = word.codePointAt(0);
return settings.isWordCodePoint(firstCodePoint)
&& Constants.CODE_SINGLE_QUOTE != firstCodePoint
&& Constants.CODE_DASH != firstCodePoint;
}
/**
* @param actionId the action to perform
*/
private void performEditorAction(final int actionId) {
mConnection.performEditorAction(actionId);
}
/**
* Perform the processing specific to inputting TLDs.
*
* Some keys input a TLD (specifically, the ".com" key) and this warrants some specific
* processing. First, if this is a TLD, we ignore PHANTOM spaces -- this is done by type
* of character in onCodeInput, but since this gets inputted as a whole string we need to
* do it here specifically. Then, if the last character before the cursor is a period, then
* we cut the dot at the start of ".com". This is because humans tend to type "www.google."
* and then press the ".com" key and instinctively don't expect to get "www.google..com".
*
* @param text the raw text supplied to onTextInput
* @return the text to actually send to the editor
*/
private String performSpecificTldProcessingOnTextInput(final String text) {
if (text.length() <= 1 || text.charAt(0) != Constants.CODE_PERIOD
|| !Character.isLetter(text.charAt(1))) {
// Not a tld: do nothing.
return text;
}
// We have a TLD (or something that looks like this): make sure we don't add
// a space even if currently in phantom mode.
mSpaceState = SpaceState.NONE;
final int codePointBeforeCursor = mConnection.getCodePointBeforeCursor();
// If no code point, #getCodePointBeforeCursor returns NOT_A_CODE_POINT.
if (Constants.CODE_PERIOD == codePointBeforeCursor) {
return text.substring(1);
}
return text;
}
/**
* Handle a press on the settings key.
*/
private void onSettingsKeyPressed() {
mLatinIMELegacy.displaySettingsDialog();
}
/**
* Resets the whole input state to the starting state.
*
* This will clear the composing word, reset the last composed word, clear the suggestion
* strip and tell the input connection about it so that it can refresh its caches.
*
* @param newSelStart the new selection start, in java characters.
* @param newSelEnd the new selection end, in java characters.
* @param clearSuggestionStrip whether this method should clear the suggestion strip.
*/
// TODO: how is this different from startInput ?!
private void resetEntireInputState(final int newSelStart, final int newSelEnd,
final boolean clearSuggestionStrip) {
final boolean shouldFinishComposition = mWordComposer.isComposingWord();
resetComposingState(true /* alsoResetLastComposedWord */);
if (clearSuggestionStrip) {
mSuggestionStripViewAccessor.setNeutralSuggestionStrip();
}
mConnection.resetCachesUponCursorMoveAndReturnSuccess(newSelStart, newSelEnd,
shouldFinishComposition);
}
/**
* Resets only the composing state.
*
* Compare #resetEntireInputState, which also clears the suggestion strip and resets the
* input connection caches. This only deals with the composing state.
*
* @param alsoResetLastComposedWord whether to also reset the last composed word.
*/
private void resetComposingState(final boolean alsoResetLastComposedWord) {
mWordComposer.reset();
if (alsoResetLastComposedWord) {
mLastComposedWord = LastComposedWord.NOT_A_COMPOSED_WORD;
}
}
/**
* Make a {@link org.futo.inputmethod.latin.SuggestedWords} object containing a typed word
* and obsolete suggestions.
* See {@link org.futo.inputmethod.latin.SuggestedWords#getTypedWordAndPreviousSuggestions(
* SuggestedWordInfo, org.futo.inputmethod.latin.SuggestedWords)}.
* @param typedWordInfo The typed word as a SuggestedWordInfo.
* @param previousSuggestedWords The previously suggested words.
* @return Obsolete suggestions with the newly typed word.
*/
static SuggestedWords retrieveOlderSuggestions(final SuggestedWordInfo typedWordInfo,
final SuggestedWords previousSuggestedWords) {
final SuggestedWords oldSuggestedWords = previousSuggestedWords.isPunctuationSuggestions()
? SuggestedWords.getEmptyInstance() : previousSuggestedWords;
final ArrayList<SuggestedWords.SuggestedWordInfo> typedWordAndPreviousSuggestions =
SuggestedWords.getTypedWordAndPreviousSuggestions(typedWordInfo, oldSuggestedWords);
return new SuggestedWords(typedWordAndPreviousSuggestions, null /* rawSuggestions */,
typedWordInfo, false /* typedWordValid */, false /* hasAutoCorrectionCandidate */,
true /* isObsoleteSuggestions */, oldSuggestedWords.mInputStyle,
SuggestedWords.NOT_A_SEQUENCE_NUMBER);
}
/**
* @return the {@link Locale} of the {@link #mDictionaryFacilitator} if available. Otherwise
* {@link Locale#ROOT}.
*/
@Nonnull
private Locale getDictionaryFacilitatorLocale() {
return mDictionaryFacilitator != null ? mDictionaryFacilitator.getLocale() : Locale.ROOT;
}
/**
* Gets a chunk of text with or the auto-correction indicator underline span as appropriate.
*
* This method looks at the old state of the auto-correction indicator to put or not put
* the underline span as appropriate. It is important to note that this does not correspond
* exactly to whether this word will be auto-corrected to or not: what's important here is
* to keep the same indication as before.
* When we add a new code point to a composing word, we don't know yet if we are going to
* auto-correct it until the suggestions are computed. But in the mean time, we still need
* to display the character and to extend the previous underline. To avoid any flickering,
* the underline should keep the same color it used to have, even if that's not ultimately
* the correct color for this new word. When the suggestions are finished evaluating, we
* will call this method again to fix the color of the underline.
*
* @param text the text on which to maybe apply the span.
* @return the same text, with the auto-correction underline span if that's appropriate.
*/
// TODO: Shouldn't this go in some *Utils class instead?
private CharSequence getTextWithUnderline(final String text) {
// TODO: Locale should be determined based on context and the text given.
return mIsAutoCorrectionIndicatorOn
? SuggestionSpanUtils.getTextWithAutoCorrectionIndicatorUnderline(
mLatinIMELegacy.getInputMethodService(), text, getDictionaryFacilitatorLocale())
: text;
}
/**
* Sends a DOWN key event followed by an UP key event to the editor.
*
* If possible at all, avoid using this method. It causes all sorts of race conditions with
* the text view because it goes through a different, asynchronous binder. Also, batch edits
* are ignored for key events. Use the normal software input methods instead.
*
* @param keyCode the key code to send inside the key event.
*/
public void sendDownUpKeyEvent(final int keyCode, final int metaState) {
final long eventTime = SystemClock.uptimeMillis();
mConnection.sendKeyEvent(new KeyEvent(eventTime, eventTime,
KeyEvent.ACTION_DOWN, keyCode, 0, metaState, KeyCharacterMap.VIRTUAL_KEYBOARD, 0,
KeyEvent.FLAG_SOFT_KEYBOARD | KeyEvent.FLAG_KEEP_TOUCH_MODE));
mConnection.sendKeyEvent(new KeyEvent(SystemClock.uptimeMillis(), eventTime,
KeyEvent.ACTION_UP, keyCode, 0, metaState, KeyCharacterMap.VIRTUAL_KEYBOARD, 0,
KeyEvent.FLAG_SOFT_KEYBOARD | KeyEvent.FLAG_KEEP_TOUCH_MODE));
}
/**
* Sends a code point to the editor, using the most appropriate method.
*
* Normally we send code points with commitText, but there are some cases (where backward
* compatibility is a concern for example) where we want to use deprecated methods.
*
* @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) {
// TODO: Remove this special handling of digit letters.
// For backward compatibility. See {@link InputMethodService#sendKeyChar(char)}.
if (codePoint >= '0' && codePoint <= '9') {
sendDownUpKeyEvent(codePoint - '0' + KeyEvent.KEYCODE_0, 0);
return;
}
// TODO: we should do this also when the editor has TYPE_NULL
if (Constants.CODE_ENTER == codePoint && settingsValues.isBeforeJellyBean()) {
// Backward compatibility mode. Before Jelly bean, the keyboard would simulate
// a hardware keyboard event on pressing enter or delete. This is bad for many
// reasons (there are race conditions with commits) but some applications are
// relying on this behavior so we continue to support it for older apps.
sendDownUpKeyEvent(KeyEvent.KEYCODE_ENTER, 0);
} else {
mConnection.commitText(StringUtils.newSingleCodePointString(codePoint), 1);
}
}
/**
* Insert an automatic space, if the options allow it.
*
* This checks the options and the text before the cursor are appropriate before inserting
* an automatic space.
*
* @param settingsValues the current values of the settings.
*/
private void insertAutomaticSpaceIfOptionsAndTextAllow(final SettingsValues settingsValues) {
if (settingsValues.shouldInsertSpacesAutomatically()
&& settingsValues.mSpacingAndPunctuations.mCurrentLanguageHasSpaces
&& !mConnection.textBeforeCursorLooksLikeURL()) {
sendKeyCodePoint(settingsValues, Constants.CODE_SPACE);
}
}
private boolean canInsertAutoSpace(final SettingsValues settingsValues) {
return (settingsValues.mAltSpacesMode >= Settings.SPACES_MODE_SUGGESTIONS)
&& settingsValues.shouldInsertSpacesAutomatically()
&& settingsValues.mSpacingAndPunctuations.mCurrentLanguageHasSpaces
&& !settingsValues.mInputAttributes.mIsUriField
&& !mConnection.textBeforeCursorLooksLikeURL();
}
private void insertOrSetPhantomSpace(final SettingsValues settingsValues) {
if(canInsertAutoSpace(settingsValues)
// If the next character is usually followed by space, it likely doesn't make sense
// to put a space immediately (e.g. cursor at "example sentence|.")
&& !settingsValues.isUsuallyFollowedBySpace(mConnection.getCodePointAfterCursor())){
// If a space already follows the cursor it should be removed then re-inserted, so that
// the cursor is after the space.
if(mConnection.spaceFollowsCursor()) mConnection.removeLeadingSpace();
mSpaceState = SpaceState.ANTIPHANTOM;
sendKeyCodePoint(settingsValues, Constants.CODE_SPACE);
} else {
mSpaceState = SpaceState.PHANTOM;
}
}
/**
* Do the final processing after a batch input has ended. This commits the word to the editor.
* @param settingsValues the current values of the settings.
* @param suggestedWords suggestedWords to use.
*/
public void onUpdateTailBatchInputCompleted(final SettingsValues settingsValues,
final SuggestedWords suggestedWords, final KeyboardSwitcher keyboardSwitcher) {
final String batchInputText = suggestedWords.isEmpty() ? null : suggestedWords.getWord(0);
if (TextUtils.isEmpty(batchInputText)) {
return;
}
mConnection.beginBatchEdit();
if (SpaceState.PHANTOM == mSpaceState) {
insertAutomaticSpaceIfOptionsAndTextAllow(settingsValues);
}
mWordComposer.setBatchInputWord(batchInputText);
setComposingTextInternal(batchInputText, 1);
mConnection.endBatchEdit();
// Space state must be updated before calling updateShiftState
mSpaceState = SpaceState.PHANTOM;
keyboardSwitcher.requestUpdatingShiftState(getCurrentAutoCapsState(settingsValues),
getCurrentRecapitalizeState());
}
/**
* Commit the typed string to the editor.
*
* This is typically called when we should commit the currently composing word without applying
* auto-correction to it. Typically, we come here upon pressing a separator when the keyboard
* is configured to not do auto-correction at all (because of the settings or the properties of
* the editor). In this case, `separatorString' is set to the separator that was pressed.
* We also come here in a variety of cases with external user action. For example, when the
* cursor is moved while there is a composition, or when the keyboard is closed, or when the
* user presses the Send button for an SMS, we don't auto-correct as that would be unexpected.
* In this case, `separatorString' is set to NOT_A_SEPARATOR.
*
* @param settingsValues the current values of the settings.
* @param separatorString the separator that's causing the commit, or NOT_A_SEPARATOR if none.
*/
public void commitTyped(final SettingsValues settingsValues, final String separatorString) {
if (!mWordComposer.isComposingWord()) return;
final String typedWord = mWordComposer.getTypedWord();
if (typedWord.length() > 0) {
final boolean isBatchMode = mWordComposer.isBatchMode();
commitChosenWord(settingsValues, typedWord,
LastComposedWord.COMMIT_TYPE_USER_TYPED_WORD, separatorString, -1);
StatsUtils.onWordCommitUserTyped(typedWord, isBatchMode);
}
}
/**
* Commit the current auto-correction.
*
* This will commit the best guess of the keyboard regarding what the user meant by typing
* the currently composing word. The IME computes suggestions and assigns a confidence score
* to each of them; when it's confident enough in one suggestion, it replaces the typed string
* by this suggestion at commit time. When it's not confident enough, or when it has no
* suggestions, or when the settings or environment does not allow for auto-correction, then
* this method just commits the typed string.
* Note that if suggestions are currently being computed in the background, this method will
* block until the computation returns. This is necessary for consistency (it would be very
* strange if pressing space would commit a different word depending on how fast you press).
*
* @param settingsValues the current value of the settings.
* @param separator the separator that's causing the commit to happen.
*/
private void commitCurrentAutoCorrection(final SettingsValues settingsValues,
final String separator, final LatinIMELegacy.UIHandler handler) {
// Complete any pending suggestions query first
if(!ensureSuggestionStripCompleted(settingsValues, separator, handler)) return;
final SuggestedWordInfo autoCorrectionOrNull = mWordComposer.getAutoCorrectionOrNull();
final String typedWord = mWordComposer.getTypedWord();
final String stringToCommit = (autoCorrectionOrNull != null)
? autoCorrectionOrNull.mWord : typedWord;
if (stringToCommit != null) {
if (TextUtils.isEmpty(typedWord)) {
throw new RuntimeException("We have an auto-correction but the typed word "
+ "is empty? Impossible! I must commit suicide.");
}
final boolean isBatchMode = mWordComposer.isBatchMode();
commitChosenWord(settingsValues, stringToCommit,
LastComposedWord.COMMIT_TYPE_DECIDED_WORD, separator, 0);
if (!typedWord.equals(stringToCommit)) {
// This will make the correction flash for a short while as a visual clue
// to the user that auto-correction happened. It has no other effect; in particular
// note that this won't affect the text inside the text field AT ALL: it only makes
// the segment of text starting at the supplied index and running for the length
// of the auto-correction flash. At this moment, the "typedWord" argument is
// ignored by TextView.
mConnection.commitCorrection(new CorrectionInfo(
mConnection.getExpectedSelectionEnd() - stringToCommit.length(),
typedWord, stringToCommit));
String prevWordsContext = (autoCorrectionOrNull != null)
? autoCorrectionOrNull.mPrevWordsContext
: "";
StatsUtils.onAutoCorrection(typedWord, stringToCommit, isBatchMode,
mDictionaryFacilitator, prevWordsContext);
StatsUtils.onWordCommitAutoCorrect(stringToCommit, isBatchMode);
} else {
StatsUtils.onWordCommitUserTyped(stringToCommit, isBatchMode);
}
}
}
/**
* Commits the chosen word to the text field and saves it for later retrieval.
*
* @param settingsValues the current values of the settings.
* @param chosenWord the word we want to commit.
* @param commitType the type of the commit, as one of LastComposedWord.COMMIT_TYPE_*
* @param separatorString the separator that's causing the commit, or NOT_A_SEPARATOR if none.
*/
private void commitChosenWord(final SettingsValues settingsValues, final String chosenWord,
final int commitType, final String separatorString, final int importance) {
long startTimeMillis = 0;
if (DebugFlags.DEBUG_ENABLED) {
startTimeMillis = System.currentTimeMillis();
Log.d(TAG, "commitChosenWord() : [" + chosenWord + "]");
}
final SuggestedWords suggestedWords = mSuggestedWords;
// TODO: Locale should be determined based on context and the text given.
final Locale locale = getDictionaryFacilitatorLocale();
final CharSequence chosenWordWithSuggestions = chosenWord;
// b/21926256
// SuggestionSpanUtils.getTextWithSuggestionSpan(mLatinIME, chosenWord,
// suggestedWords, locale);
if (DebugFlags.DEBUG_ENABLED) {
long runTimeMillis = System.currentTimeMillis() - startTimeMillis;
Log.d(TAG, "commitChosenWord() : " + runTimeMillis + " ms to run "
+ "SuggestionSpanUtils.getTextWithSuggestionSpan()");
startTimeMillis = System.currentTimeMillis();
}
// When we are composing word, get n-gram context from the 2nd previous word because the
// 1st previous word is the word to be committed. Otherwise get n-gram context from the 1st
// previous word.
final NgramContext ngramContext = mConnection.getNgramContextFromNthPreviousWord(
settingsValues.mSpacingAndPunctuations, mWordComposer.isComposingWord() ? 2 : 1);
if (DebugFlags.DEBUG_ENABLED) {
long runTimeMillis = System.currentTimeMillis() - startTimeMillis;
Log.d(TAG, "commitChosenWord() : " + runTimeMillis + " ms to run "
+ "Connection.getNgramContextFromNthPreviousWord()");
Log.d(TAG, "commitChosenWord() : NgramContext = " + ngramContext);
startTimeMillis = System.currentTimeMillis();
}
mConnection.commitText(chosenWordWithSuggestions, 1);
if (DebugFlags.DEBUG_ENABLED) {
long runTimeMillis = System.currentTimeMillis() - startTimeMillis;
Log.d(TAG, "commitChosenWord() : " + runTimeMillis + " ms to run "
+ "Connection.commitText");
startTimeMillis = System.currentTimeMillis();
}
// Add the word to the user history dictionary
performAdditionToUserHistoryDictionary(settingsValues, chosenWord, ngramContext, importance);
if (DebugFlags.DEBUG_ENABLED) {
long runTimeMillis = System.currentTimeMillis() - startTimeMillis;
Log.d(TAG, "commitChosenWord() : " + runTimeMillis + " ms to run "
+ "performAdditionToUserHistoryDictionary()");
startTimeMillis = System.currentTimeMillis();
}
// TODO: figure out here if this is an auto-correct or if the best word is actually
// what user typed. Note: currently this is done much later in
// LastComposedWord#didCommitTypedWord by string equality of the remembered
// strings.
mLastComposedWord = mWordComposer.commitWord(commitType,
chosenWordWithSuggestions, separatorString, ngramContext);
if (DebugFlags.DEBUG_ENABLED) {
long runTimeMillis = System.currentTimeMillis() - startTimeMillis;
Log.d(TAG, "commitChosenWord() : " + runTimeMillis + " ms to run "
+ "WordComposer.commitWord()");
startTimeMillis = System.currentTimeMillis();
}
}
/**
* Retry resetting caches in the rich input connection.
*
* When the editor can't be accessed we can't reset the caches, so we schedule a retry.
* This method handles the retry, and re-schedules a new retry if we still can't access.
* We only retry up to 5 times before giving up.
*
* @param tryResumeSuggestions Whether we should resume suggestions or not.
* @param remainingTries How many times we may try again before giving up.
* @return whether true if the caches were successfully reset, false otherwise.
*/
public boolean retryResetCachesAndReturnSuccess(final boolean tryResumeSuggestions,
final int remainingTries, final LatinIMELegacy.UIHandler handler) {
final boolean shouldFinishComposition = mConnection.hasSelection()
|| !mConnection.isCursorPositionKnown();
if (!mConnection.resetCachesUponCursorMoveAndReturnSuccess(
mConnection.getExpectedSelectionStart(), mConnection.getExpectedSelectionEnd(),
shouldFinishComposition)) {
if (0 < remainingTries) {
handler.postResetCaches(tryResumeSuggestions, remainingTries - 1);
return false;
}
// If remainingTries is 0, we should stop waiting for new tries, however we'll still
// return true as we need to perform other tasks (for example, loading the keyboard).
}
mConnection.tryFixLyingCursorPosition();
if (tryResumeSuggestions) {
handler.postResumeSuggestions(true /* shouldDelay */);
}
return true;
}
public void getSuggestedWords(final SettingsValues settingsValues,
final Keyboard keyboard, final int keyboardShiftMode, final int inputStyle,
final int sequenceNumber, final OnGetSuggestedWordsCallback callback) {
mWordComposer.adviseCapitalizedModeBeforeFetchingSuggestions(
getActualCapsMode(settingsValues, keyboardShiftMode));
mSuggest.getSuggestedWords(mWordComposer,
getNgramContextFromNthPreviousWordForSuggestion(
settingsValues.mSpacingAndPunctuations,
// Get the word on which we should search the bigrams. If we are composing
// a word, it's whatever is *before* the half-committed word in the buffer,
// hence 2; if we aren't, we should just skip whitespace if any, so 1.
mWordComposer.isComposingWord() ? 2 : 1),
keyboard,
new SettingsValuesForSuggestion(
settingsValues.mBlockPotentiallyOffensive,
settingsValues.mTransformerPredictionEnabled
),
settingsValues.mAutoCorrectionEnabledPerUserSettings,
inputStyle, sequenceNumber, callback);
}
/**
* Used as an injection point for each call of
* {@link RichInputConnection#setComposingText(CharSequence, int)}.
*
* <p>Currently using this method is optional and you can still directly call
* {@link RichInputConnection#setComposingText(CharSequence, int)}, but it is recommended to
* use this method whenever possible.<p>
* <p>TODO: Should we move this mechanism to {@link RichInputConnection}?</p>
*
* @param newComposingText the composing text to be set
* @param newCursorPosition the new cursor position
*/
private void setComposingTextInternal(final CharSequence newComposingText,
final int newCursorPosition) {
setComposingTextInternalWithBackgroundColor(newComposingText, newCursorPosition,
Color.TRANSPARENT, newComposingText.length());
}
/**
* Equivalent to {@link #setComposingTextInternal(CharSequence, int)} except that this method
* allows to set {@link BackgroundColorSpan} to the composing text with the given color.
*
* <p>TODO: Currently the background color is exclusive with the black underline, which is
* automatically added by the framework. We need to change the framework if we need to have both
* of them at the same time.</p>
* <p>TODO: Should we move this method to {@link RichInputConnection}?</p>
*
* @param newComposingText the composing text to be set
* @param newCursorPosition the new cursor position
* @param backgroundColor the background color to be set to the composing text. Set
* {@link Color#TRANSPARENT} to disable the background color.
* @param coloredTextLength the length of text, in Java chars, which should be rendered with
* the given background color.
*/
private void setComposingTextInternalWithBackgroundColor(final CharSequence newComposingText,
final int newCursorPosition, final int backgroundColor, final int coloredTextLength) {
final CharSequence composingTextToBeSet;
if (backgroundColor == Color.TRANSPARENT) {
composingTextToBeSet = newComposingText;
} else {
final SpannableString spannable = new SpannableString(newComposingText);
final BackgroundColorSpan backgroundColorSpan =
new BackgroundColorSpan(backgroundColor);
final int spanLength = Math.min(coloredTextLength, spannable.length());
spannable.setSpan(backgroundColorSpan, 0, spanLength,
Spanned.SPAN_EXCLUSIVE_EXCLUSIVE | Spanned.SPAN_COMPOSING);
composingTextToBeSet = spannable;
}
mConnection.setComposingText(composingTextToBeSet, newCursorPosition);
}
/**
* Gets an object allowing private IME commands to be sent to the
* underlying editor.
* @return An object for sending private commands to the underlying editor.
*/
public PrivateCommandPerformer getPrivateCommandPerformer() {
return mConnection;
}
/**
* Gets the expected index of the first char of the composing span within the editor's text.
* Returns a negative value in case there appears to be no valid composing span.
*
* @see #getComposingLength()
* @see RichInputConnection#hasSelection()
* @see RichInputConnection#isCursorPositionKnown()
* @see RichInputConnection#getExpectedSelectionStart()
* @see RichInputConnection#getExpectedSelectionEnd()
* @return The expected index in Java chars of the first char of the composing span.
*/
// TODO: try and see if we can get rid of this method. Ideally the users of this class should
// never need to know this.
public int getComposingStart() {
if (!mConnection.isCursorPositionKnown() || mConnection.hasSelection()) {
return -1;
}
return mConnection.getExpectedSelectionStart() - mWordComposer.size();
}
/**
* Gets the expected length in Java chars of the composing span.
* May be 0 if there is no valid composing span.
* @see #getComposingStart()
* @return The expected length of the composing span.
*/
// TODO: try and see if we can get rid of this method. Ideally the users of this class should
// never need to know this.
public int getComposingLength() {
return mWordComposer.size();
}
/**
* Which direction the selection should be expanded/contracted in via cursorLeft/Right methods
* If true, the right side of the selection (the end) is fixed and the left side (start) gets
* moved around, and vice versa.
*/
private boolean isRightSidePointer = true;
/**
* Shifts the cursor/selection based on isRightSidePointer and the parameters
* @param steps How many characters to step over, or the direction if stepOverWords
* @param stepOverWords Whether to ignore the magnitude of steps and step over full words
* @param select Whether or not to start/continue selection
*/
private void cursorStep(int steps, boolean stepOverWords, boolean select) {
if(stepOverWords) {
steps = mConnection.getWordBoundarySteps(steps, isRightSidePointer);
} else {
steps = mConnection.getUnicodeSteps(steps, isRightSidePointer);
}
int cursor = isRightSidePointer ? mConnection.getExpectedSelectionStart() : mConnection.getExpectedSelectionEnd();
int start = mConnection.getExpectedSelectionStart();
int end = mConnection.getExpectedSelectionEnd();
if(isRightSidePointer) {
start += steps;
cursor += steps;
} else {
end += steps;
cursor += steps;
}
if (!select) {
start = cursor;
end = cursor;
}
start = Math.max(0, start);
end = Math.max(0, end);
mConnection.setSelection(start, end);
}
/**
* Disables recapitalization
*/
public void disableRecapitalization() {
mRecapitalizeStatus.disable();
}
private void cursorLeftInternal(int steps, boolean stepOverWords, boolean select) {
finishInput();
if(!mConnection.hasSelection()) isRightSidePointer = true;
cursorStep(-steps, stepOverWords, select);
}
private void cursorRightInternal(int steps, boolean stepOverWords, boolean select) {
finishInput();
if(!mConnection.hasSelection()) isRightSidePointer = false;
cursorStep(steps, stepOverWords, select);
}
/**
* Shifts the cursor left by a number of characters
* @param steps How many characters to step over, or the direction if stepOverWords
* @param stepOverWords Whether to ignore the magnitude of steps and step over full words
* @param select Whether or not to start/continue selection
*/
public void cursorLeft(int steps, boolean stepOverWords, boolean select) {
final SettingsValues settingsValues = Settings.getInstance().getCurrent();
steps = Math.abs(steps);
if(!mConnection.hasCursorPosition() || settingsValues.mInputAttributes.mIsCodeField) {
mConnection.finishComposingText();
int meta = 0;
if(stepOverWords) meta = meta | KeyEvent.META_CTRL_ON;
if(select) meta = meta | KeyEvent.META_SHIFT_ON;
mConnection.beginBatchEdit();
for(int i=0; i<steps; i++)
sendDownUpKeyEvent(KeyEvent.KEYCODE_DPAD_LEFT, meta);
mConnection.endBatchEdit();
} else {
if(settingsValues.mIsRTL) {
cursorRightInternal(steps, stepOverWords, select);
} else {
cursorLeftInternal(steps, stepOverWords, select);
}
}
}
/**
* Shifts the cursor right by a number of characters
* @param steps How many characters to step over, or the direction if stepOverWords
* @param stepOverWords Whether to ignore the magnitude of steps and step over full words
* @param select Whether or not to start/continue selection
*/
public void cursorRight(int steps, boolean stepOverWords, boolean select) {
final SettingsValues settingsValues = Settings.getInstance().getCurrent();
steps = Math.abs(steps);
if(!mConnection.hasCursorPosition() || settingsValues.mInputAttributes.mIsCodeField) {
mConnection.finishComposingText();
int meta = 0;
if(stepOverWords) meta = meta | KeyEvent.META_CTRL_ON;
if(select) meta = meta | KeyEvent.META_SHIFT_ON;
mConnection.beginBatchEdit();
for(int i=0; i<steps; i++)
sendDownUpKeyEvent(KeyEvent.KEYCODE_DPAD_RIGHT, meta);
mConnection.endBatchEdit();
} else {
if(settingsValues.mIsRTL) {
cursorLeftInternal(steps, stepOverWords, select);
} else {
cursorRightInternal(steps, stepOverWords, select);
}
}
}
}