From 75715f7d9fb0b19c2ddaf73bf62148c7d19f0a99 Mon Sep 17 00:00:00 2001 From: Jean Chalard Date: Thu, 27 Mar 2014 09:43:45 +0000 Subject: [PATCH] Revert "[CB15] Remove a redundant variable." This reverts commit 0de7a6d1a272d52a9544df1c693ae199ab5abc52. Change-Id: I327679b76a14cf9c3aec4b00b013b921408c32f9 --- .../inputmethod/latin/BinaryDictionary.java | 14 ++------ .../inputmethod/latin/LastComposedWord.java | 8 +++-- .../inputmethod/latin/WordComposer.java | 32 +++++++++++++++++-- 3 files changed, 37 insertions(+), 17 deletions(-) diff --git a/java/src/com/android/inputmethod/latin/BinaryDictionary.java b/java/src/com/android/inputmethod/latin/BinaryDictionary.java index 323d0c8a3..0aa34e82e 100644 --- a/java/src/com/android/inputmethod/latin/BinaryDictionary.java +++ b/java/src/com/android/inputmethod/latin/BinaryDictionary.java @@ -249,18 +249,8 @@ public final class BinaryDictionary extends Dictionary { final boolean isGesture = composer.isBatchMode(); if (composerSize <= 1 || !isGesture) { if (composerSize > MAX_WORD_LENGTH - 1) return null; - final CharSequence typedWord = composer.getTypedWord(); - final int charCount = typedWord.length(); - int typedWordCharIndex = 0; - int inputCodePointIndex = 0; - while (typedWordCharIndex < charCount) { - final int codePoint = Character.codePointAt(typedWord, typedWordCharIndex); - mInputCodePoints[inputCodePointIndex] = codePoint; - typedWordCharIndex += Character.charCount(codePoint); - inputCodePointIndex += 1; - if (inputCodePointIndex >= MAX_WORD_LENGTH) { - break; - } + for (int i = 0; i < composerSize; i++) { + mInputCodePoints[i] = composer.getCodeAt(i); } } diff --git a/java/src/com/android/inputmethod/latin/LastComposedWord.java b/java/src/com/android/inputmethod/latin/LastComposedWord.java index a3b030626..2a16ab5ab 100644 --- a/java/src/com/android/inputmethod/latin/LastComposedWord.java +++ b/java/src/com/android/inputmethod/latin/LastComposedWord.java @@ -44,6 +44,7 @@ public final class LastComposedWord { public static final String NOT_A_SEPARATOR = ""; + public final int[] mPrimaryKeyCodes; public final ArrayList mEvents; public final String mTypedWord; public final CharSequence mCommittedWord; @@ -56,15 +57,16 @@ public final class LastComposedWord { private boolean mActive; public static final LastComposedWord NOT_A_COMPOSED_WORD = - new LastComposedWord(new ArrayList(), null, "", "", - NOT_A_SEPARATOR, null, WordComposer.CAPS_MODE_OFF); + new LastComposedWord(null, new ArrayList(), null, "", "", + NOT_A_SEPARATOR, null, WordComposer.CAPS_MODE_OFF); // Warning: this is using the passed objects as is and fully expects them to be // immutable. Do not fiddle with their contents after you passed them to this constructor. - public LastComposedWord(final ArrayList events, + public LastComposedWord(final int[] primaryKeyCodes, final ArrayList events, final InputPointers inputPointers, final String typedWord, final CharSequence committedWord, final String separatorString, final String prevWord, final int capitalizedMode) { + mPrimaryKeyCodes = primaryKeyCodes; if (inputPointers != null) { mInputPointers.copy(inputPointers); } diff --git a/java/src/com/android/inputmethod/latin/WordComposer.java b/java/src/com/android/inputmethod/latin/WordComposer.java index 4638c8a8b..a955f375b 100644 --- a/java/src/com/android/inputmethod/latin/WordComposer.java +++ b/java/src/com/android/inputmethod/latin/WordComposer.java @@ -43,6 +43,11 @@ public final class WordComposer { private CombinerChain mCombinerChain; + // An array of code points representing the characters typed so far. + // The array is limited to MAX_WORD_LENGTH code points, but mTypedWord extends past that + // and mCodePointSize can go past that. If mCodePointSize is greater than MAX_WORD_LENGTH, + // this just does not contain the associated code points past MAX_WORD_LENGTH. + private int[] mPrimaryKeyCodes; // The list of events that served to compose this string. private final ArrayList mEvents; private final InputPointers mInputPointers = new InputPointers(MAX_WORD_LENGTH); @@ -86,6 +91,7 @@ public final class WordComposer { public WordComposer() { mCombinerChain = new CombinerChain(); + mPrimaryKeyCodes = new int[MAX_WORD_LENGTH]; mEvents = CollectionUtils.newArrayList(); mTypedWord = new StringBuilder(MAX_WORD_LENGTH); mAutoCorrection = null; @@ -100,6 +106,7 @@ public final class WordComposer { public WordComposer(final WordComposer source) { mCombinerChain = source.mCombinerChain; + mPrimaryKeyCodes = Arrays.copyOf(source.mPrimaryKeyCodes, source.mPrimaryKeyCodes.length); mEvents = new ArrayList(source.mEvents); mTypedWord = new StringBuilder(source.mTypedWord); mInputPointers.copy(source.mInputPointers); @@ -152,6 +159,14 @@ public final class WordComposer { return size() > 0; } + // TODO: make sure that the index should not exceed MAX_WORD_LENGTH + public int getCodeAt(int index) { + if (index >= MAX_WORD_LENGTH) { + return -1; + } + return mPrimaryKeyCodes[index]; + } + public InputPointers getInputPointers() { return mInputPointers; } @@ -180,6 +195,8 @@ public final class WordComposer { refreshSize(); mCursorPositionWithinWord = mCodePointSize; if (newIndex < MAX_WORD_LENGTH) { + mPrimaryKeyCodes[newIndex] = primaryCode >= Constants.CODE_SPACE + ? Character.toLowerCase(primaryCode) : primaryCode; // In the batch input mode, the {@code mInputPointers} holds batch input points and // shouldn't be overridden by the "typed key" coordinates // (See {@link #setBatchInputWord}). @@ -227,7 +244,15 @@ public final class WordComposer { mCombinerChain.reset(); int actualMoveAmountWithinWord = 0; int cursorPos = mCursorPositionWithinWord; - final int[] codePoints = StringUtils.toCodePointArray(mTypedWord.toString()); + final int[] codePoints; + if (mCodePointSize >= MAX_WORD_LENGTH) { + // If we have more than MAX_WORD_LENGTH characters, we don't have everything inside + // mPrimaryKeyCodes. This should be rare enough that we can afford to just compute + // the array on the fly when this happens. + codePoints = StringUtils.toCodePointArray(mTypedWord.toString()); + } else { + codePoints = mPrimaryKeyCodes; + } if (expectedMoveAmount >= 0) { // Moving the cursor forward for the expected amount or until the end of the word has // been reached, whichever comes first. @@ -426,7 +451,9 @@ public final class WordComposer { // Note: currently, we come here whenever we commit a word. If it's a MANUAL_PICK // or a DECIDED_WORD we may cancel the commit later; otherwise, we should deactivate // the last composed word to ensure this does not happen. - final LastComposedWord lastComposedWord = new LastComposedWord(mEvents, + final int[] primaryKeyCodes = mPrimaryKeyCodes; + mPrimaryKeyCodes = new int[MAX_WORD_LENGTH]; + final LastComposedWord lastComposedWord = new LastComposedWord(primaryKeyCodes, mEvents, mInputPointers, mTypedWord.toString(), committedWord, separatorString, prevWord, mCapitalizedMode); mInputPointers.reset(); @@ -462,6 +489,7 @@ public final class WordComposer { public void resumeSuggestionOnLastComposedWord(final LastComposedWord lastComposedWord, final String previousWord) { + mPrimaryKeyCodes = lastComposedWord.mPrimaryKeyCodes; mEvents.clear(); Collections.copy(mEvents, lastComposedWord.mEvents); mInputPointers.set(lastComposedWord.mInputPointers);