From 750cd48981d78af5babf479e28c33e3666139b67 Mon Sep 17 00:00:00 2001 From: Jean Chalard Date: Wed, 12 Mar 2014 17:02:13 +0900 Subject: [PATCH] [CB03] Pass whole events to the various input logic handlers. Bug: 13406701 Change-Id: I0a0e4e0b3357f116e1b915c548dee4575e300c92 --- .../com/android/inputmethod/event/Event.java | 6 + .../inputmethod/event/InputTransaction.java | 15 +- .../latin/inputlogic/InputLogic.java | 250 +++++++++--------- 3 files changed, 137 insertions(+), 134 deletions(-) diff --git a/java/src/com/android/inputmethod/event/Event.java b/java/src/com/android/inputmethod/event/Event.java index 31092f176..a4a17e12d 100644 --- a/java/src/com/android/inputmethod/event/Event.java +++ b/java/src/com/android/inputmethod/event/Event.java @@ -130,6 +130,12 @@ public class Event { return 0 != (FLAG_DEAD & mFlags); } + // Returns whether this is a fake key press from the suggestion strip. This happens with + // punctuation signs selected from the suggestion strip. + public boolean isSuggestionStripPress() { + return EVENT_INPUT_KEYPRESS == mType && Constants.SUGGESTION_STRIP_COORDINATE == mX; + } + // TODO: remove this method - we should not have to test this public boolean isCommittable() { return EVENT_INPUT_KEYPRESS == mType || EVENT_MODE_KEY == mType || EVENT_TOGGLE == mType; diff --git a/java/src/com/android/inputmethod/event/InputTransaction.java b/java/src/com/android/inputmethod/event/InputTransaction.java index 3f709a674..2e9014f20 100644 --- a/java/src/com/android/inputmethod/event/InputTransaction.java +++ b/java/src/com/android/inputmethod/event/InputTransaction.java @@ -33,11 +33,7 @@ public class InputTransaction { // Initial conditions public final SettingsValues mSettingsValues; - // If the key inserts a code point, mKeyCode is always equal to the code points. Otherwise, - // it's always a code that may not be a code point, typically a negative number. - public final int mKeyCode; - public final int mX; // Pressed x-coordinate, or one of Constants.*_COORDINATE - public final int mY; // Pressed y-coordinate, or one of Constants.*_COORDINATE + public final Event mEvent; public final long mTimestamp; public final int mSpaceState; public final int mShiftState; @@ -45,13 +41,10 @@ public class InputTransaction { // Outputs private int mRequiredShiftUpdate = SHIFT_NO_UPDATE; - public InputTransaction(final SettingsValues settingsValues, final int keyCode, - final int x, final int y, final long timestamp, final int spaceState, - final int shiftState) { + public InputTransaction(final SettingsValues settingsValues, final Event event, + final long timestamp, final int spaceState, final int shiftState) { mSettingsValues = settingsValues; - mKeyCode = keyCode; - mX = x; - mY = y; + mEvent = event; mTimestamp = timestamp; mSpaceState = spaceState; mShiftState = shiftState; diff --git a/java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java b/java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java index f7e528648..cc5611b0c 100644 --- a/java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java +++ b/java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java @@ -368,16 +368,13 @@ public final class InputLogic { // var because it's confusing. Instead the switch() should handle this in a readable manner. final int code = Event.NOT_A_CODE_POINT == event.mCodePoint ? event.mKeyCode : event.mCodePoint; - final int x = event.mX; - final int y = event.mY; - final InputTransaction inputTransaction = new InputTransaction(settingsValues, code, x, y, + final InputTransaction inputTransaction = new InputTransaction(settingsValues, event, SystemClock.uptimeMillis(), mSpaceState, getActualCapsMode(settingsValues, keyboardShiftMode)); if (ProductionFlag.USES_DEVELOPMENT_ONLY_DIAGNOSTICS) { - ResearchLogger.latinIME_onCodeInput(inputTransaction.mKeyCode, - inputTransaction.mX, inputTransaction.mY); + ResearchLogger.latinIME_onCodeInput(code, event.mX, event.mY); } - if (inputTransaction.mKeyCode != Constants.CODE_DELETE + if (event.mKeyCode != Constants.CODE_DELETE || inputTransaction.mTimestamp > mLastKeyTime + Constants.LONG_PRESS_MILLISECONDS) { mDeleteCount = 0; } @@ -388,97 +385,104 @@ public final class InputLogic { } // TODO: Consolidate the double-space period timer, mLastKeyTime, and the space state. - if (inputTransaction.mKeyCode != Constants.CODE_SPACE) { + if (event.mCodePoint != Constants.CODE_SPACE) { handler.cancelDoubleSpacePeriodTimer(); } boolean didAutoCorrect = false; - switch (inputTransaction.mKeyCode) { - case Constants.CODE_DELETE: - handleBackspace(inputTransaction, handler); - LatinImeLogger.logOnDelete(inputTransaction.mX, inputTransaction.mY); - break; - case Constants.CODE_SHIFT: - performRecapitalization(inputTransaction.mSettingsValues); - inputTransaction.requireShiftUpdate(InputTransaction.SHIFT_UPDATE_NOW); - break; - case Constants.CODE_CAPSLOCK: - // Note: Changing keyboard to shift lock state is handled in - // {@link KeyboardSwitcher#onCodeInput(int)}. - 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#onCodeInput(int,int)}. - break; - 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. - didAutoCorrect = handleNonSpecialCharacter(inputTransaction, handler); + if (Event.NOT_A_KEY_CODE != event.mKeyCode) { + // A special key, like delete, shift, emoji, or the settings key. + switch (event.mKeyCode) { + case Constants.CODE_DELETE: + handleBackspace(inputTransaction, handler); + LatinImeLogger.logOnDelete(event.mX, event.mY); + break; + case Constants.CODE_SHIFT: + performRecapitalization(inputTransaction.mSettingsValues); + inputTransaction.requireShiftUpdate(InputTransaction.SHIFT_UPDATE_NOW); + break; + case Constants.CODE_CAPSLOCK: + // Note: Changing keyboard to shift lock state is handled in + // {@link KeyboardSwitcher#onCodeInput(int)}. + 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#onCodeInput(int,int)}. + break; + case Constants.CODE_ALPHA_FROM_EMOJI: + // Note: Switching back from Emoji keyboard to the main keyboard is being + // handled in {@link KeyboardState#onCodeInput(int,int)}. + break; + case Constants.CODE_SHIFT_ENTER: + // TODO: remove this object + final InputTransaction tmpTransaction = new InputTransaction( + inputTransaction.mSettingsValues, inputTransaction.mEvent, + inputTransaction.mTimestamp, inputTransaction.mSpaceState, + inputTransaction.mShiftState); + didAutoCorrect = handleNonSpecialCharacter(tmpTransaction, handler); + break; + default: + throw new RuntimeException("Unknown key code : " + event.mKeyCode); + } + } else { + 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. + didAutoCorrect = handleNonSpecialCharacter(inputTransaction, handler); + } + break; + default: + didAutoCorrect = handleNonSpecialCharacter(inputTransaction, handler); + break; } - break; - case Constants.CODE_SHIFT_ENTER: - // TODO: remove this object - final InputTransaction tmpTransaction = new InputTransaction( - inputTransaction.mSettingsValues, inputTransaction.mKeyCode, - inputTransaction.mX, inputTransaction.mY, inputTransaction.mTimestamp, - inputTransaction.mSpaceState, inputTransaction.mShiftState); - didAutoCorrect = handleNonSpecialCharacter(tmpTransaction, handler); - break; - case Constants.CODE_ALPHA_FROM_EMOJI: - // Note: Switching back from Emoji keyboard to the main keyboard is being handled in - // {@link KeyboardState#onCodeInput(int,int)}. - break; - default: - didAutoCorrect = handleNonSpecialCharacter(inputTransaction, handler); - break; } - // Reset after any single keystroke, except shift, capslock, and symbol-shift - if (!didAutoCorrect && inputTransaction.mKeyCode != Constants.CODE_SHIFT - && inputTransaction.mKeyCode != Constants.CODE_CAPSLOCK - && inputTransaction.mKeyCode != Constants.CODE_SWITCH_ALPHA_SYMBOL) + if (!didAutoCorrect && event.mKeyCode != Constants.CODE_SHIFT + && event.mKeyCode != Constants.CODE_CAPSLOCK + && event.mKeyCode != Constants.CODE_SWITCH_ALPHA_SYMBOL) mLastComposedWord.deactivate(); - if (Constants.CODE_DELETE != inputTransaction.mKeyCode) { + if (Constants.CODE_DELETE != event.mKeyCode) { mEnteredText = null; } mConnection.endBatchEdit(); @@ -632,15 +636,16 @@ public final class InputLogic { private boolean handleNonSpecialCharacter(final InputTransaction inputTransaction, // TODO: remove this argument final LatinIME.UIHandler handler) { + final int codePoint = inputTransaction.mEvent.mCodePoint; mSpaceState = SpaceState.NONE; final boolean didAutoCorrect; - if (inputTransaction.mSettingsValues.isWordSeparator(inputTransaction.mKeyCode) - || Character.getType(inputTransaction.mKeyCode) == Character.OTHER_SYMBOL) { + if (inputTransaction.mSettingsValues.isWordSeparator(codePoint) + || Character.getType(codePoint) == Character.OTHER_SYMBOL) { didAutoCorrect = handleSeparator(inputTransaction, - Constants.SUGGESTION_STRIP_COORDINATE == inputTransaction.mX, handler); + inputTransaction.mEvent.isSuggestionStripPress(), handler); if (inputTransaction.mSettingsValues.mIsInternal) { - LatinImeLoggerUtils.onSeparator((char)inputTransaction.mKeyCode, - inputTransaction.mX, inputTransaction.mY); + LatinImeLoggerUtils.onSeparator((char)codePoint, + inputTransaction.mEvent.mX, inputTransaction.mEvent.mY); } } else { didAutoCorrect = false; @@ -674,6 +679,7 @@ public final class InputLogic { final InputTransaction inputTransaction, // TODO: Remove this argument final LatinIME.UIHandler handler) { + final int codePoint = inputTransaction.mEvent.mCodePoint; // TODO: refactor this method to stop flipping isComposingWord around all the time, and // make it shorter (possibly cut into several pieces). Also factor handleNonSpecialCharacter // which has the same name as other handle* methods but is not the same. @@ -682,7 +688,7 @@ public final class InputLogic { // TODO: remove isWordConnector() and use isUsuallyFollowedBySpace() instead. // See onStartBatchInput() to see how to do it. if (SpaceState.PHANTOM == inputTransaction.mSpaceState - && !settingsValues.isWordConnector(inputTransaction.mKeyCode)) { + && !settingsValues.isWordConnector(codePoint)) { if (isComposingWord) { // Sanity check throw new RuntimeException("Should not be composing here"); @@ -704,7 +710,7 @@ public final class InputLogic { if (!isComposingWord // We only start composing if this is a word code point. Essentially that means it's a // a letter or a word connector. - && settingsValues.isWordCodePoint(inputTransaction.mKeyCode) + && settingsValues.isWordCodePoint(codePoint) // We never go into composing state if suggestions are not requested. && settingsValues.isSuggestionsRequested() && // In languages with spaces, we only start composing a word when we are not already @@ -715,8 +721,8 @@ public final class InputLogic { // the character is a single quote or a dash. The idea here is, single quote and dash // are not separators and they should be treated as normal characters, except in the // first position where they should not start composing a word. - isComposingWord = (Constants.CODE_SINGLE_QUOTE != inputTransaction.mKeyCode - && Constants.CODE_DASH != inputTransaction.mKeyCode); + isComposingWord = (Constants.CODE_SINGLE_QUOTE != codePoint + && Constants.CODE_DASH != 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 @@ -724,7 +730,8 @@ public final class InputLogic { resetComposingState(false /* alsoResetLastComposedWord */); } if (isComposingWord) { - mWordComposer.add(inputTransaction.mKeyCode, inputTransaction.mX, inputTransaction.mY); + // TODO: pass the entire event to the word composer. + mWordComposer.add(codePoint, inputTransaction.mEvent.mX, inputTransaction.mEvent.mY); // If it's the first letter, make note of auto-caps state if (mWordComposer.size() == 1) { // We pass 1 to getPreviousWordForSuggestion because we were not composing a word @@ -737,9 +744,9 @@ public final class InputLogic { mWordComposer.getTypedWord()), 1); } else { final boolean swapWeakSpace = maybeStripSpace(inputTransaction, - Constants.SUGGESTION_STRIP_COORDINATE == inputTransaction.mX); + inputTransaction.mEvent.isSuggestionStripPress()); - sendKeyCodePoint(settingsValues, inputTransaction.mKeyCode); + sendKeyCodePoint(settingsValues, codePoint); if (swapWeakSpace) { swapSwapperAndSpace(inputTransaction); @@ -750,8 +757,8 @@ public final class InputLogic { } handler.postUpdateSuggestionStrip(); if (settingsValues.mIsInternal) { - LatinImeLoggerUtils.onNonSeparator((char)inputTransaction.mKeyCode, inputTransaction.mX, - inputTransaction.mY); + LatinImeLoggerUtils.onNonSeparator((char)codePoint, inputTransaction.mEvent.mX, + inputTransaction.mEvent.mY); } } @@ -765,9 +772,10 @@ public final class InputLogic { final boolean isFromSuggestionStrip, // TODO: remove this argument final LatinIME.UIHandler handler) { + final int codePoint = inputTransaction.mEvent.mCodePoint; boolean didAutoCorrect = false; // We avoid sending spaces in languages without spaces if we were composing. - final boolean shouldAvoidSendingCode = Constants.CODE_SPACE == inputTransaction.mKeyCode + final boolean shouldAvoidSendingCode = Constants.CODE_SPACE == codePoint && !inputTransaction.mSettingsValues.mSpacingAndPunctuations .mCurrentLanguageHasSpaces && mWordComposer.isComposingWord(); @@ -781,46 +789,44 @@ public final class InputLogic { if (mWordComposer.isComposingWord()) { if (inputTransaction.mSettingsValues.mCorrectionEnabled) { final String separator = shouldAvoidSendingCode ? LastComposedWord.NOT_A_SEPARATOR - : StringUtils.newSingleCodePointString(inputTransaction.mKeyCode); + : StringUtils.newSingleCodePointString(codePoint); commitCurrentAutoCorrection(inputTransaction.mSettingsValues, separator, handler); didAutoCorrect = true; } else { commitTyped(inputTransaction.mSettingsValues, - StringUtils.newSingleCodePointString(inputTransaction.mKeyCode)); + StringUtils.newSingleCodePointString(codePoint)); } } final boolean swapWeakSpace = maybeStripSpace(inputTransaction, isFromSuggestionStrip); - final boolean isInsideDoubleQuoteOrAfterDigit = - Constants.CODE_DOUBLE_QUOTE == inputTransaction.mKeyCode + 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 == inputTransaction.mKeyCode) { + } 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 { needsPrecedingSpace = inputTransaction.mSettingsValues.isUsuallyPrecededBySpace( - inputTransaction.mKeyCode); + codePoint); } if (needsPrecedingSpace) { promotePhantomSpace(inputTransaction.mSettingsValues); } if (ProductionFlag.USES_DEVELOPMENT_ONLY_DIAGNOSTICS) { - ResearchLogger.latinIME_handleSeparator(inputTransaction.mKeyCode, - mWordComposer.isComposingWord()); + ResearchLogger.latinIME_handleSeparator(codePoint, mWordComposer.isComposingWord()); } if (!shouldAvoidSendingCode) { - sendKeyCodePoint(inputTransaction.mSettingsValues, inputTransaction.mKeyCode); + sendKeyCodePoint(inputTransaction.mSettingsValues, codePoint); } - if (Constants.CODE_SPACE == inputTransaction.mKeyCode) { + if (Constants.CODE_SPACE == codePoint) { if (inputTransaction.mSettingsValues.isSuggestionsRequested()) { if (maybeDoubleSpacePeriod(inputTransaction.mSettingsValues, handler)) { inputTransaction.requireShiftUpdate(InputTransaction.SHIFT_UPDATE_NOW); @@ -837,9 +843,8 @@ public final class InputLogic { swapSwapperAndSpace(inputTransaction); mSpaceState = SpaceState.SWAP_PUNCTUATION; } else if ((SpaceState.PHANTOM == inputTransaction.mSpaceState - && inputTransaction.mSettingsValues.isUsuallyFollowedBySpace( - inputTransaction.mKeyCode)) - || (Constants.CODE_DOUBLE_QUOTE == inputTransaction.mKeyCode + && inputTransaction.mSettingsValues.isUsuallyFollowedBySpace(codePoint)) + || (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 @@ -1056,7 +1061,8 @@ public final class InputLogic { */ private boolean maybeStripSpace(final InputTransaction inputTransaction, final boolean isFromSuggestionStrip) { - if (Constants.CODE_ENTER == inputTransaction.mKeyCode && + final int codePoint = inputTransaction.mEvent.mCodePoint; + if (Constants.CODE_ENTER == codePoint && SpaceState.SWAP_PUNCTUATION == inputTransaction.mSpaceState) { mConnection.removeTrailingSpace(); return false; @@ -1064,12 +1070,10 @@ public final class InputLogic { if ((SpaceState.WEAK == inputTransaction.mSpaceState || SpaceState.SWAP_PUNCTUATION == inputTransaction.mSpaceState) && isFromSuggestionStrip) { - if (inputTransaction.mSettingsValues.isUsuallyPrecededBySpace( - inputTransaction.mKeyCode)) { + if (inputTransaction.mSettingsValues.isUsuallyPrecededBySpace(codePoint)) { return false; } - if (inputTransaction.mSettingsValues.isUsuallyFollowedBySpace( - inputTransaction.mKeyCode)) { + if (inputTransaction.mSettingsValues.isUsuallyFollowedBySpace(codePoint)) { return true; } mConnection.removeTrailingSpace();