Use Add-To-Dictionary indicator only
With this CL, the previously used commit indicator was reverted.
Instead we use the add-to-dictionary indicator only at the moment.
This CL also fixes the indicator position in bidi context.
BUG: 17335734
Change-Id: I5f7cf173ddc30876e2b01320acaff8ba4265edf6
diff --git a/java/res/values/donottranslate-text-decorator.xml b/java/res/values/donottranslate-text-decorator.xml
index 832610b..2693645 100644
--- a/java/res/values/donottranslate-text-decorator.xml
+++ b/java/res/values/donottranslate-text-decorator.xml
@@ -19,62 +19,11 @@
-->
<resources>
- <!-- The delay time in milliseconds from to show the commit indicator -->
- <integer name="text_decorator_delay_in_milliseconds_to_show_commit_indicator">
- 500
- </integer>
-
<!-- The extra margin in dp around the hit area of the commit/add-to-dictionary indicator -->
<integer name="text_decorator_hit_area_margin_in_dp">
4
</integer>
- <!-- If true, the commit/add-to-text indicator will be suppressed when the word isn't going to
- trigger auto-correction. -->
- <bool name="text_decorator_only_for_auto_correction">true</bool>
-
- <!-- If true, the commit/add-to-text indicator will be suppressed when the word is already in
- the dictionary. -->
- <bool name="text_decorator_only_for_out_of_vocabulary">false</bool>
-
- <!-- Background color to be used to highlight the target text when the commit indicator is
- visible. -->
- <color name="text_decorator_commit_indicator_text_highlight_color">
- #B6E2DE
- </color>
-
- <!-- Background color of the commit indicator. -->
- <color name="text_decorator_commit_indicator_background_color">
- #48B6AC
- </color>
-
- <!-- Foreground color of the commit indicator. -->
- <color name="text_decorator_commit_indicator_foreground_color">
- #FFFFFF
- </color>
-
- <!-- Viewport size of "text_decorator_commit_indicator_path". -->
- <integer name="text_decorator_commit_indicator_path_size">
- 480
- </integer>
-
- <!-- Coordinates of the closed path to be used to render the commit indicator.
- The format is: X[0], Y[0], X[1], Y[1], ..., X[N-1], Y[N-1] -->
- <integer-array name="text_decorator_commit_indicator_path">
- <item>180</item>
- <item>323</item>
- <item>97</item>
- <item>240</item>
- <item>68</item>
- <item>268</item>
- <item>180</item>
- <item>380</item>
- <item>420</item>
- <item>140</item>
- <item>392</item>
- <item>112</item>
- </integer-array>
-
<!-- Background color to be used to highlight the target text when the add-to-dictionary
indicator is visible. -->
<color name="text_decorator_add_to_dictionary_indicator_text_highlight_color">
diff --git a/java/src/com/android/inputmethod/compat/CursorAnchorInfoCompatWrapper.java b/java/src/com/android/inputmethod/compat/CursorAnchorInfoCompatWrapper.java
index 8a28185..c937eee 100644
--- a/java/src/com/android/inputmethod/compat/CursorAnchorInfoCompatWrapper.java
+++ b/java/src/com/android/inputmethod/compat/CursorAnchorInfoCompatWrapper.java
@@ -41,6 +41,8 @@
// Note that CursorAnchorInfo has been introduced in API level XX (Build.VERSION_CODE.LXX).
private static final CompatUtils.ClassWrapper sCursorAnchorInfoClass;
+ private static final CompatUtils.ToIntMethodWrapper sGetSelectionStartMethod;
+ private static final CompatUtils.ToIntMethodWrapper sGetSelectionEndMethod;
private static final CompatUtils.ToObjectMethodWrapper<RectF> sGetCharacterBoundsMethod;
private static final CompatUtils.ToIntMethodWrapper sGetCharacterBoundsFlagsMethod;
private static final CompatUtils.ToObjectMethodWrapper<CharSequence> sGetComposingTextMethod;
@@ -52,10 +54,14 @@
private static final CompatUtils.ToObjectMethodWrapper<Matrix> sGetMatrixMethod;
private static final CompatUtils.ToIntMethodWrapper sGetInsertionMarkerFlagsMethod;
- private static int COMPOSING_TEXT_START_DEFAULT = -1;
+ private static int INVALID_TEXT_INDEX = -1;
static {
sCursorAnchorInfoClass = CompatUtils.getClassWrapper(
"android.view.inputmethod.CursorAnchorInfo");
+ sGetSelectionStartMethod = sCursorAnchorInfoClass.getPrimitiveMethod(
+ "getSelectionStart", INVALID_TEXT_INDEX);
+ sGetSelectionEndMethod = sCursorAnchorInfoClass.getPrimitiveMethod(
+ "getSelectionEnd", INVALID_TEXT_INDEX);
sGetCharacterBoundsMethod = sCursorAnchorInfoClass.getMethod(
"getCharacterBounds", (RectF)null, int.class);
sGetCharacterBoundsFlagsMethod = sCursorAnchorInfoClass.getPrimitiveMethod(
@@ -63,7 +69,7 @@
sGetComposingTextMethod = sCursorAnchorInfoClass.getMethod(
"getComposingText", (CharSequence)null);
sGetComposingTextStartMethod = sCursorAnchorInfoClass.getPrimitiveMethod(
- "getComposingTextStart", COMPOSING_TEXT_START_DEFAULT);
+ "getComposingTextStart", INVALID_TEXT_INDEX);
sGetInsertionMarkerBaselineMethod = sCursorAnchorInfoClass.getPrimitiveMethod(
"getInsertionMarkerBaseline", 0.0f);
sGetInsertionMarkerBottomMethod = sCursorAnchorInfoClass.getPrimitiveMethod(
@@ -105,6 +111,14 @@
return FakeHolder.sInstance;
}
+ public int getSelectionStart() {
+ return sGetSelectionStartMethod.invoke(mInstance);
+ }
+
+ public int getSelectionEnd() {
+ return sGetSelectionEndMethod.invoke(mInstance);
+ }
+
public CharSequence getComposingText() {
return sGetComposingTextMethod.invoke(mInstance);
}
diff --git a/java/src/com/android/inputmethod/keyboard/TextDecorator.java b/java/src/com/android/inputmethod/keyboard/TextDecorator.java
index f614b22..315d363 100644
--- a/java/src/com/android/inputmethod/keyboard/TextDecorator.java
+++ b/java/src/com/android/inputmethod/keyboard/TextDecorator.java
@@ -17,23 +17,22 @@
package com.android.inputmethod.keyboard;
import android.graphics.Matrix;
-import android.graphics.PointF;
import android.graphics.RectF;
import android.inputmethodservice.InputMethodService;
import android.os.Message;
import android.text.TextUtils;
import android.util.Log;
import android.view.View;
+import android.view.inputmethod.CursorAnchorInfo;
import com.android.inputmethod.annotations.UsedForTesting;
import com.android.inputmethod.compat.CursorAnchorInfoCompatWrapper;
-import com.android.inputmethod.latin.SuggestedWords.SuggestedWordInfo;
import com.android.inputmethod.latin.utils.LeakGuardHandlerWrapper;
import javax.annotation.Nonnull;
/**
- * A controller class of commit/add-to-dictionary indicator (a.k.a. TextDecorator). This class
+ * A controller class of the add-to-dictionary indicator (a.k.a. TextDecorator). This class
* is designed to be independent of UI subsystems such as {@link View}. All the UI related
* operations are delegated to {@link TextDecoratorUi} via {@link TextDecoratorUiOperator}.
*/
@@ -41,18 +40,22 @@
private static final String TAG = TextDecorator.class.getSimpleName();
private static final boolean DEBUG = false;
- private static final int MODE_NONE = 0;
- private static final int MODE_COMMIT = 1;
- private static final int MODE_ADD_TO_DICTIONARY = 2;
+ private static final int INVALID_CURSOR_INDEX = -1;
- private int mMode = MODE_NONE;
+ private static final int MODE_MONITOR = 0;
+ private static final int MODE_WAITING_CURSOR_INDEX = 1;
+ private static final int MODE_SHOWING_INDICATOR = 2;
- private final PointF mLocalOrigin = new PointF();
- private final RectF mRelativeIndicatorBounds = new RectF();
- private final RectF mRelativeComposingTextBounds = new RectF();
+ private int mMode = MODE_MONITOR;
+
+ private String mLastComposingText = null;
+ private RectF mIndicatorBoundsForLastComposingText = new RectF();
+ private RectF mComposingTextBoundsForLastComposingText = new RectF();
private boolean mIsFullScreenMode = false;
- private SuggestedWordInfo mWaitingWord = null;
+ private String mWaitingWord = null;
+ private int mWaitingCursorStart = INVALID_CURSOR_INDEX;
+ private int mWaitingCursorEnd = INVALID_CURSOR_INDEX;
private CursorAnchorInfoCompatWrapper mCursorAnchorInfoWrapper = null;
@Nonnull
@@ -63,16 +66,10 @@
public interface Listener {
/**
- * Called when the user clicks the composing text to commit.
- * @param wordInfo the suggested word which the user clicked on.
+ * Called when the user clicks the indicator to add the word into the dictionary.
+ * @param word the word which the user clicked on.
*/
- void onClickComposingTextToCommit(final SuggestedWordInfo wordInfo);
-
- /**
- * Called when the user clicks the composing text to add the word into the dictionary.
- * @param wordInfo the suggested word which the user clicked on.
- */
- void onClickComposingTextToAddToDictionary(final SuggestedWordInfo wordInfo);
+ void onClickComposingTextToAddToDictionary(final String word);
}
public TextDecorator(final Listener listener) {
@@ -103,46 +100,19 @@
}
/**
- * Shows the "Commit" indicator and associates it with the given suggested word.
+ * Shows the "Add to dictionary" indicator and associates it with associating the given word.
*
- * <p>The effect of {@link #showCommitIndicator(SuggestedWordInfo)} and
- * {@link #showAddToDictionaryIndicator(SuggestedWordInfo)} are exclusive to each other. Call
- * {@link #reset()} to hide the indicator.</p>
- *
- * @param wordInfo the suggested word which should be associated with the indicator. This object
- * will be passed back in {@link Listener#onClickComposingTextToCommit(SuggestedWordInfo)}
+ * @param word the word which should be associated with the indicator. This object will be
+ * passed back in {@link Listener#onClickComposingTextToAddToDictionary(String)}.
+ * @param selectionStart the cursor index (inclusive) when the indicator should be displayed.
+ * @param selectionEnd the cursor index (exclusive) when the indicator should be displayed.
*/
- public void showCommitIndicator(final SuggestedWordInfo wordInfo) {
- if (mMode == MODE_COMMIT && wordInfo != null &&
- TextUtils.equals(mWaitingWord.mWord, wordInfo.mWord)) {
- // Skip layout for better performance.
- return;
- }
- mWaitingWord = wordInfo;
- mMode = MODE_COMMIT;
- layoutLater();
- }
-
- /**
- * Shows the "Add to dictionary" indicator and associates it with associating the given
- * suggested word.
- *
- * <p>The effect of {@link #showCommitIndicator(SuggestedWordInfo)} and
- * {@link #showAddToDictionaryIndicator(SuggestedWordInfo)} are exclusive to each other. Call
- * {@link #reset()} to hide the indicator.</p>
- *
- * @param wordInfo the suggested word which should be associated with the indicator. This object
- * will be passed back in
- * {@link Listener#onClickComposingTextToAddToDictionary(SuggestedWordInfo)}.
- */
- public void showAddToDictionaryIndicator(final SuggestedWordInfo wordInfo) {
- if (mMode == MODE_ADD_TO_DICTIONARY && wordInfo != null &&
- TextUtils.equals(mWaitingWord.mWord, wordInfo.mWord)) {
- // Skip layout for better performance.
- return;
- }
- mWaitingWord = wordInfo;
- mMode = MODE_ADD_TO_DICTIONARY;
+ public void showAddToDictionaryIndicator(final String word, final int selectionStart,
+ final int selectionEnd) {
+ mWaitingWord = word;
+ mWaitingCursorStart = selectionStart;
+ mWaitingCursorEnd = selectionEnd;
+ mMode = MODE_WAITING_CURSOR_INDEX;
layoutLater();
return;
}
@@ -165,18 +135,19 @@
*/
public void reset() {
mWaitingWord = null;
- mMode = MODE_NONE;
- mLocalOrigin.set(0.0f, 0.0f);
- mRelativeIndicatorBounds.set(0.0f, 0.0f, 0.0f, 0.0f);
- mRelativeComposingTextBounds.set(0.0f, 0.0f, 0.0f, 0.0f);
+ mMode = MODE_MONITOR;
+ mWaitingCursorStart = INVALID_CURSOR_INDEX;
+ mWaitingCursorEnd = INVALID_CURSOR_INDEX;
cancelLayoutInternalExpectedly("Resetting internal state.");
}
/**
- * Must be called when the {@link InputMethodService#onUpdateCursorAnchorInfo()} is called.
+ * Must be called when the {@link InputMethodService#onUpdateCursorAnchorInfo(CursorAnchorInfo)}
+ * is called.
*
* <p>CAVEAT: Currently the input method author is responsible for ignoring
- * {@link InputMethodService#onUpdateCursorAnchorInfo()} called in full screen mode.</p>
+ * {@link InputMethodService#onUpdateCursorAnchorInfo(CursorAnchorInfo)} called in full screen
+ * mode.</p>
* @param info the compatibility wrapper object for the received {@link CursorAnchorInfo}.
*/
public void onUpdateCursorAnchorInfo(final CursorAnchorInfoCompatWrapper info) {
@@ -185,29 +156,6 @@
layoutImmediately();
}
- /**
- * Hides indicator if the new composing text doesn't match the expected one.
- *
- * <p>Calling this method is optional but recommended whenever the new composition is passed to
- * the application. The motivation of this method is to reduce the UI latency. With this method,
- * we can hide the indicator without waiting the arrival of the
- * {@link InputMethodService#onUpdateCursorAnchorInfo(CursorAnchorInfo)} callback, assuming that
- * the application accepts the new composing text without any modification. Even if this
- * assumption is false, the indicator will be shown again when
- * {@link InputMethodService#onUpdateCursorAnchorInfo(CursorAnchorInfo)} is actually received.
- * </p>
- *
- * @param newComposingText the new composing text that is being passed to the application.
- */
- public void hideIndicatorIfNecessary(final CharSequence newComposingText) {
- if (mMode != MODE_COMMIT && mMode != MODE_ADD_TO_DICTIONARY) {
- return;
- }
- if (!TextUtils.equals(newComposingText, mWaitingWord.mWord)) {
- mUiOperator.hideUi();
- }
- }
-
private void cancelLayoutInternalUnexpectedly(final String message) {
mUiOperator.hideUi();
Log.d(TAG, message);
@@ -232,15 +180,6 @@
}
private void layoutMain() {
- if (mMode != MODE_COMMIT && mMode != MODE_ADD_TO_DICTIONARY) {
- if (mMode == MODE_NONE) {
- cancelLayoutInternalExpectedly("Not ready for layouting.");
- } else {
- cancelLayoutInternalUnexpectedly("Unknown mMode=" + mMode);
- }
- return;
- }
-
final CursorAnchorInfoCompatWrapper info = mCursorAnchorInfoWrapper;
if (info == null) {
@@ -254,104 +193,117 @@
}
final CharSequence composingText = info.getComposingText();
- if (mMode == MODE_COMMIT) {
- if (composingText == null) {
- cancelLayoutInternalExpectedly("composingText is null.");
- return;
- }
+ if (!TextUtils.isEmpty(composingText)) {
final int composingTextStart = info.getComposingTextStart();
final int lastCharRectIndex = composingTextStart + composingText.length() - 1;
final RectF lastCharRect = info.getCharacterBounds(lastCharRectIndex);
- final int lastCharRectFlag = info.getCharacterBoundsFlags(lastCharRectIndex);
+ final int lastCharRectFlags = info.getCharacterBoundsFlags(lastCharRectIndex);
final boolean hasInvisibleRegionInLastCharRect =
- (lastCharRectFlag & CursorAnchorInfoCompatWrapper.FLAG_HAS_INVISIBLE_REGION)
+ (lastCharRectFlags & CursorAnchorInfoCompatWrapper.FLAG_HAS_INVISIBLE_REGION)
!= 0;
if (lastCharRect == null || matrix == null || hasInvisibleRegionInLastCharRect) {
mUiOperator.hideUi();
return;
}
- final RectF segmentStartCharRect = new RectF(lastCharRect);
- for (int i = composingText.length() - 2; i >= 0; --i) {
- final RectF charRect = info.getCharacterBounds(composingTextStart + i);
- if (charRect == null) {
+
+ // Note that the following layout information is fragile, and must be invalidated
+ // even when surrounding text next to the composing text is changed because it can
+ // affect how the composing text is rendered.
+ // TODO: Investigate if we can change the input logic to make the target text
+ // composing state so that we can retrieve the character bounds reliably.
+ final String composingTextString = composingText.toString();
+ final float top = lastCharRect.top;
+ final float bottom = lastCharRect.bottom;
+ float left = lastCharRect.left;
+ float right = lastCharRect.right;
+ boolean useRtlLayout = false;
+ for (int i = composingText.length() - 1; i >= 0; --i) {
+ final int characterIndex = composingTextStart + i;
+ final RectF characterBounds = info.getCharacterBounds(characterIndex);
+ final int characterBoundsFlags = info.getCharacterBoundsFlags(characterIndex);
+ if (characterBounds == null) {
break;
}
- if (charRect.top != segmentStartCharRect.top) {
+ if (characterBounds.top != top) {
break;
}
- if (charRect.bottom != segmentStartCharRect.bottom) {
+ if (characterBounds.bottom != bottom) {
break;
}
- segmentStartCharRect.set(charRect);
+ if ((characterBoundsFlags & CursorAnchorInfoCompatWrapper.FLAG_IS_RTL) != 0) {
+ // This is for both RTL text and bi-directional text. RTL languages usually mix
+ // RTL characters with LTR characters and in this case we should display the
+ // indicator on the left, while in LTR languages that normally never happens.
+ // TODO: Try to come up with a better algorithm.
+ useRtlLayout = true;
+ }
+ left = Math.min(characterBounds.left, left);
+ right = Math.max(characterBounds.right, right);
}
-
- mLocalOrigin.set(lastCharRect.right, lastCharRect.top);
- mRelativeIndicatorBounds.set(lastCharRect.right, lastCharRect.top,
- lastCharRect.right + lastCharRect.height(), lastCharRect.bottom);
- mRelativeIndicatorBounds.offset(-mLocalOrigin.x, -mLocalOrigin.y);
-
- mRelativeIndicatorBounds.set(lastCharRect.right, lastCharRect.top,
- lastCharRect.right + lastCharRect.height(), lastCharRect.bottom);
- mRelativeIndicatorBounds.offset(-mLocalOrigin.x, -mLocalOrigin.y);
-
- mRelativeComposingTextBounds.set(segmentStartCharRect.left, segmentStartCharRect.top,
- segmentStartCharRect.right, segmentStartCharRect.bottom);
- mRelativeComposingTextBounds.offset(-mLocalOrigin.x, -mLocalOrigin.y);
-
- if (mWaitingWord == null) {
- cancelLayoutInternalExpectedly("mWaitingText is null.");
- return;
+ mLastComposingText = composingTextString;
+ mComposingTextBoundsForLastComposingText.set(left, top, right, bottom);
+ // The height and width of the indicator is the same as the height of the composing
+ // text.
+ final float indicatorSize = bottom - top;
+ mIndicatorBoundsForLastComposingText.set(0.0f, 0.0f, indicatorSize, indicatorSize);
+ // The horizontal position of the indicator depends on the text direction.
+ final float indicatorTop = top;
+ final float indicatorLeft;
+ if (useRtlLayout) {
+ indicatorLeft = left - indicatorSize;
+ } else {
+ indicatorLeft = right;
}
- if (TextUtils.isEmpty(mWaitingWord.mWord)) {
- cancelLayoutInternalExpectedly("mWaitingText.mWord is empty.");
- return;
- }
- if (!TextUtils.equals(composingText, mWaitingWord.mWord)) {
- // This is indeed an expected situation because of the asynchronous nature of
- // input method framework in Android. Note that composingText is notified from the
- // application, while mWaitingWord.mWord is obtained directly from the InputLogic.
- cancelLayoutInternalExpectedly(
- "Composing text doesn't match the one we are waiting for.");
- return;
- }
- } else {
- if (!mIsFullScreenMode && !TextUtils.isEmpty(composingText)) {
- // This is an unexpected case.
- // TODO: Document this.
- mUiOperator.hideUi();
- return;
- }
- // In MODE_ADD_TO_DICTIONARY, we cannot retrieve the character position at all because
- // of the lack of composing text. We will use the insertion marker position instead.
- if ((info.getInsertionMarkerFlags() &
- CursorAnchorInfoCompatWrapper.FLAG_HAS_INVISIBLE_REGION) != 0) {
- mUiOperator.hideUi();
- return;
- }
- final float insertionMarkerHolizontal = info.getInsertionMarkerHorizontal();
- final float insertionMarkerTop = info.getInsertionMarkerTop();
- mLocalOrigin.set(insertionMarkerHolizontal, insertionMarkerTop);
+ mIndicatorBoundsForLastComposingText.offset(indicatorLeft, indicatorTop);
}
- final RectF indicatorBounds = new RectF(mRelativeIndicatorBounds);
- final RectF composingTextBounds = new RectF(mRelativeComposingTextBounds);
- indicatorBounds.offset(mLocalOrigin.x, mLocalOrigin.y);
- composingTextBounds.offset(mLocalOrigin.x, mLocalOrigin.y);
- mUiOperator.layoutUi(mMode == MODE_COMMIT, matrix, indicatorBounds, composingTextBounds);
+ final int selectionStart = info.getSelectionStart();
+ final int selectionEnd = info.getSelectionEnd();
+ switch (mMode) {
+ case MODE_MONITOR:
+ mUiOperator.hideUi();
+ return;
+ case MODE_WAITING_CURSOR_INDEX:
+ if (selectionStart != mWaitingCursorStart || selectionEnd != mWaitingCursorEnd) {
+ mUiOperator.hideUi();
+ return;
+ }
+ mMode = MODE_SHOWING_INDICATOR;
+ break;
+ case MODE_SHOWING_INDICATOR:
+ if (selectionStart != mWaitingCursorStart || selectionEnd != mWaitingCursorEnd) {
+ mUiOperator.hideUi();
+ mMode = MODE_MONITOR;
+ mWaitingCursorStart = INVALID_CURSOR_INDEX;
+ mWaitingCursorEnd = INVALID_CURSOR_INDEX;
+ return;
+ }
+ break;
+ default:
+ cancelLayoutInternalUnexpectedly("Unexpected internal mode=" + mMode);
+ return;
+ }
+
+ if (!TextUtils.equals(mLastComposingText, mWaitingWord)) {
+ cancelLayoutInternalUnexpectedly("mLastComposingText doesn't match mWaitingWord");
+ return;
+ }
+
+ if ((info.getInsertionMarkerFlags() &
+ CursorAnchorInfoCompatWrapper.FLAG_HAS_INVISIBLE_REGION) != 0) {
+ mUiOperator.hideUi();
+ return;
+ }
+
+ mUiOperator.layoutUi(matrix, mIndicatorBoundsForLastComposingText,
+ mComposingTextBoundsForLastComposingText);
}
private void onClickIndicator() {
- if (mWaitingWord == null || TextUtils.isEmpty(mWaitingWord.mWord)) {
+ if (mMode != MODE_SHOWING_INDICATOR) {
return;
}
- switch (mMode) {
- case MODE_COMMIT:
- mListener.onClickComposingTextToCommit(mWaitingWord);
- break;
- case MODE_ADD_TO_DICTIONARY:
- mListener.onClickComposingTextToAddToDictionary(mWaitingWord);
- break;
- }
+ mListener.onClickComposingTextToAddToDictionary(mWaitingWord);
}
private final LayoutInvalidator mLayoutInvalidator = new LayoutInvalidator(this);
@@ -407,10 +359,7 @@
private final static Listener EMPTY_LISTENER = new Listener() {
@Override
- public void onClickComposingTextToCommit(SuggestedWordInfo wordInfo) {
- }
- @Override
- public void onClickComposingTextToAddToDictionary(SuggestedWordInfo wordInfo) {
+ public void onClickComposingTextToAddToDictionary(final String word) {
}
};
@@ -425,8 +374,7 @@
public void setOnClickListener(Runnable listener) {
}
@Override
- public void layoutUi(boolean isCommitMode, Matrix matrix, RectF indicatorBounds,
- RectF composingTextBounds) {
+ public void layoutUi(Matrix matrix, RectF indicatorBounds, RectF composingTextBounds) {
}
};
}
diff --git a/java/src/com/android/inputmethod/keyboard/TextDecoratorUi.java b/java/src/com/android/inputmethod/keyboard/TextDecoratorUi.java
index 6e215a9..b67d177 100644
--- a/java/src/com/android/inputmethod/keyboard/TextDecoratorUi.java
+++ b/java/src/com/android/inputmethod/keyboard/TextDecoratorUi.java
@@ -46,7 +46,6 @@
private static final int VISUAL_DEBUG_HIT_AREA_COLOR = 0x80ff8000;
private final RelativeLayout mLocalRootView;
- private final CommitIndicatorView mCommitIndicatorView;
private final AddToDictionaryIndicatorView mAddToDictionaryIndicatorView;
private final PopupWindow mTouchEventWindow;
private final View mTouchEventWindowClickListenerView;
@@ -73,9 +72,7 @@
mLocalRootView.setBackgroundDrawable(new ColorDrawable(Color.TRANSPARENT));
final ViewGroup contentView = getContentView(inputView);
- mCommitIndicatorView = new CommitIndicatorView(context);
mAddToDictionaryIndicatorView = new AddToDictionaryIndicatorView(context);
- mLocalRootView.addView(mCommitIndicatorView);
mLocalRootView.addView(mAddToDictionaryIndicatorView);
if (contentView != null) {
contentView.addView(mLocalRootView);
@@ -110,17 +107,15 @@
@Override
public void hideUi() {
- mCommitIndicatorView.setVisibility(View.GONE);
mAddToDictionaryIndicatorView.setVisibility(View.GONE);
mTouchEventWindow.dismiss();
}
@Override
- public void layoutUi(final boolean isCommitMode, final Matrix matrix,
- final RectF indicatorBounds, final RectF composingTextBounds) {
+ public void layoutUi(final Matrix matrix, final RectF indicatorBounds,
+ final RectF composingTextBounds) {
final RectF indicatorBoundsInScreenCoordinates = new RectF();
matrix.mapRect(indicatorBoundsInScreenCoordinates, indicatorBounds);
- mCommitIndicatorView.setBounds(indicatorBoundsInScreenCoordinates);
mAddToDictionaryIndicatorView.setBounds(indicatorBoundsInScreenCoordinates);
final RectF hitAreaBounds = new RectF(composingTextBounds);
@@ -133,20 +128,9 @@
mLocalRootView.getLocationOnScreen(originScreen);
final int viewOriginX = originScreen[0];
final int viewOriginY = originScreen[1];
-
- final View toBeShown;
- final View toBeHidden;
- if (isCommitMode) {
- toBeShown = mCommitIndicatorView;
- toBeHidden = mAddToDictionaryIndicatorView;
- } else {
- toBeShown = mAddToDictionaryIndicatorView;
- toBeHidden = mCommitIndicatorView;
- }
- toBeShown.setX(indicatorBoundsInScreenCoordinates.left - viewOriginX);
- toBeShown.setY(indicatorBoundsInScreenCoordinates.top - viewOriginY);
- toBeShown.setVisibility(View.VISIBLE);
- toBeHidden.setVisibility(View.GONE);
+ mAddToDictionaryIndicatorView.setX(indicatorBoundsInScreenCoordinates.left - viewOriginX);
+ mAddToDictionaryIndicatorView.setY(indicatorBoundsInScreenCoordinates.top - viewOriginY);
+ mAddToDictionaryIndicatorView.setVisibility(View.VISIBLE);
if (mTouchEventWindow.isShowing()) {
mTouchEventWindow.update((int)hitAreaBoundsInScreenCoordinates.left - viewOriginX,
@@ -239,15 +223,6 @@
return windowContentView;
}
- private static final class CommitIndicatorView extends TextDecoratorUi.IndicatorView {
- public CommitIndicatorView(final Context context) {
- super(context, R.array.text_decorator_commit_indicator_path,
- R.integer.text_decorator_commit_indicator_path_size,
- R.color.text_decorator_commit_indicator_background_color,
- R.color.text_decorator_commit_indicator_foreground_color);
- }
- }
-
private static final class AddToDictionaryIndicatorView extends TextDecoratorUi.IndicatorView {
public AddToDictionaryIndicatorView(final Context context) {
super(context, R.array.text_decorator_add_to_dictionary_indicator_path,
diff --git a/java/src/com/android/inputmethod/keyboard/TextDecoratorUiOperator.java b/java/src/com/android/inputmethod/keyboard/TextDecoratorUiOperator.java
index f84e12d..9c0b64a 100644
--- a/java/src/com/android/inputmethod/keyboard/TextDecoratorUiOperator.java
+++ b/java/src/com/android/inputmethod/keyboard/TextDecoratorUiOperator.java
@@ -44,12 +44,10 @@
/**
* Called when the layout should be updated.
- * @param isCommitMode {@code true} if the commit indicator should be shown. Show the
- * add-to-dictionary indicator otherwise.
* @param matrix The matrix that transforms the local coordinates into the screen coordinates.
* @param indicatorBounds The bounding box of the indicator, in local coordinates.
* @param composingTextBounds The bounding box of the composing text, in local coordinates.
*/
- void layoutUi(final boolean isCommitMode, final Matrix matrix, final RectF indicatorBounds,
+ void layoutUi(final Matrix matrix, final RectF indicatorBounds,
final RectF composingTextBounds);
}
diff --git a/java/src/com/android/inputmethod/latin/LatinIME.java b/java/src/com/android/inputmethod/latin/LatinIME.java
index 84b2d27..8195322 100644
--- a/java/src/com/android/inputmethod/latin/LatinIME.java
+++ b/java/src/com/android/inputmethod/latin/LatinIME.java
@@ -188,9 +188,8 @@
private static final int MSG_UPDATE_TAIL_BATCH_INPUT_COMPLETED = 6;
private static final int MSG_RESET_CACHES = 7;
private static final int MSG_WAIT_FOR_DICTIONARY_LOAD = 8;
- private static final int MSG_SHOW_COMMIT_INDICATOR = 9;
// Update this when adding new messages
- private static final int MSG_LAST = MSG_SHOW_COMMIT_INDICATOR;
+ private static final int MSG_LAST = MSG_WAIT_FOR_DICTIONARY_LOAD;
private static final int ARG1_NOT_GESTURE_INPUT = 0;
private static final int ARG1_DISMISS_GESTURE_FLOATING_PREVIEW_TEXT = 1;
@@ -201,7 +200,6 @@
private int mDelayInMillisecondsToUpdateSuggestions;
private int mDelayInMillisecondsToUpdateShiftState;
- private int mDelayInMillisecondsToShowCommitIndicator;
public UIHandler(final LatinIME ownerInstance) {
super(ownerInstance);
@@ -217,8 +215,6 @@
R.integer.config_delay_in_milliseconds_to_update_suggestions);
mDelayInMillisecondsToUpdateShiftState = res.getInteger(
R.integer.config_delay_in_milliseconds_to_update_shift_state);
- mDelayInMillisecondsToShowCommitIndicator = res.getInteger(
- R.integer.text_decorator_delay_in_milliseconds_to_show_commit_indicator);
}
@Override
@@ -276,14 +272,6 @@
latinIme.getCurrentRecapitalizeState());
}
break;
- case MSG_SHOW_COMMIT_INDICATOR:
- // Protocol of MSG_SET_COMMIT_INDICATOR_ENABLED:
- // - what: MSG_SHOW_COMMIT_INDICATOR
- // - arg1: not used.
- // - arg2: not used.
- // - obj: the Runnable object to be called back.
- ((Runnable) msg.obj).run();
- break;
case MSG_WAIT_FOR_DICTIONARY_LOAD:
Log.i(TAG, "Timeout waiting for dictionary load");
break;
@@ -384,19 +372,6 @@
obtainMessage(MSG_UPDATE_TAIL_BATCH_INPUT_COMPLETED, suggestedWords).sendToTarget();
}
- /**
- * Posts a delayed task to show the commit indicator.
- *
- * <p>Only one task can exist in the queue. When this method is called, any prior task that
- * has not yet fired will be canceled.</p>
- * @param task the runnable object that will be fired when the delayed task is dispatched.
- */
- public void postShowCommitIndicatorTask(final Runnable task) {
- removeMessages(MSG_SHOW_COMMIT_INDICATOR);
- sendMessageDelayed(obtainMessage(MSG_SHOW_COMMIT_INDICATOR, task),
- mDelayInMillisecondsToShowCommitIndicator);
- }
-
// Working variables for the following methods.
private boolean mIsOrientationChanging;
private boolean mPendingSuccessiveImsCallback;
diff --git a/java/src/com/android/inputmethod/latin/RichInputConnection.java b/java/src/com/android/inputmethod/latin/RichInputConnection.java
index b5d42dd..744b032 100644
--- a/java/src/com/android/inputmethod/latin/RichInputConnection.java
+++ b/java/src/com/android/inputmethod/latin/RichInputConnection.java
@@ -252,7 +252,7 @@
* See {@link InputConnection#commitText(CharSequence, int)}.
*/
public void commitText(final CharSequence text, final int newCursorPosition) {
- commitTextWithBackgroundColor(text, newCursorPosition, Color.TRANSPARENT);
+ commitTextWithBackgroundColor(text, newCursorPosition, Color.TRANSPARENT, text.length());
}
/**
@@ -265,9 +265,11 @@
* the background color. Note that this method specifies {@link BackgroundColorSpan} with
* {@link Spanned#SPAN_COMPOSING} flag, meaning that the background color persists until
* {@link #finishComposingText()} is called.
+ * @param coloredTextLength the length of text, in Java chars, which should be rendered with
+ * the given background color.
*/
public void commitTextWithBackgroundColor(final CharSequence text, final int newCursorPosition,
- final int color) {
+ final int color, final int coloredTextLength) {
if (DEBUG_BATCH_NESTING) checkBatchEdit();
if (DEBUG_PREVIOUS_TEXT) checkConsistencyForDebug();
mCommittedTextBeforeComposingText.append(text);
@@ -285,7 +287,8 @@
mTempObjectForCommitText.clear();
mTempObjectForCommitText.append(text);
final BackgroundColorSpan backgroundColorSpan = new BackgroundColorSpan(color);
- mTempObjectForCommitText.setSpan(backgroundColorSpan, 0, text.length(),
+ final int spanLength = Math.min(coloredTextLength, text.length());
+ mTempObjectForCommitText.setSpan(backgroundColorSpan, 0, spanLength,
Spanned.SPAN_COMPOSING | Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
mIC.commitText(mTempObjectForCommitText, newCursorPosition);
mLastCommittedTextHasBackgroundColor = true;
diff --git a/java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java b/java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java
index 5ab3571..21e2a1c 100644
--- a/java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java
+++ b/java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java
@@ -28,6 +28,7 @@
import android.view.KeyCharacterMap;
import android.view.KeyEvent;
import android.view.inputmethod.CorrectionInfo;
+import android.view.inputmethod.CursorAnchorInfo;
import android.view.inputmethod.EditorInfo;
import com.android.inputmethod.compat.CursorAnchorInfoCompatWrapper;
@@ -90,12 +91,8 @@
private final TextDecorator mTextDecorator = new TextDecorator(new TextDecorator.Listener() {
@Override
- public void onClickComposingTextToCommit(SuggestedWordInfo wordInfo) {
- mLatinIME.pickSuggestionManually(wordInfo);
- }
- @Override
- public void onClickComposingTextToAddToDictionary(SuggestedWordInfo wordInfo) {
- mLatinIME.addWordToUserDictionary(wordInfo.mWord);
+ public void onClickComposingTextToAddToDictionary(final String word) {
+ mLatinIME.addWordToUserDictionary(word);
mLatinIME.dismissAddToDictionaryHint();
}
});
@@ -170,6 +167,7 @@
mConnection.requestCursorUpdates(true /* enableMonitor */,
true /* requestImmediateCallback */);
}
+ mTextDecorator.reset();
}
}
@@ -333,17 +331,8 @@
}
final boolean shouldShowAddToDictionaryHint = shouldShowAddToDictionaryHint(suggestionInfo);
- final boolean shouldShowAddToDictionaryIndicator =
- shouldShowAddToDictionaryHint && settingsValues.mShouldShowUiToAcceptTypedWord;
- final int backgroundColor;
- if (shouldShowAddToDictionaryIndicator) {
- backgroundColor = settingsValues.mTextHighlightColorForAddToDictionaryIndicator;
- } else {
- backgroundColor = Color.TRANSPARENT;
- }
- commitChosenWordWithBackgroundColor(settingsValues, suggestion,
- LastComposedWord.COMMIT_TYPE_MANUAL_PICK, LastComposedWord.NOT_A_SEPARATOR,
- backgroundColor);
+ commitChosenWord(settingsValues, suggestion, LastComposedWord.COMMIT_TYPE_MANUAL_PICK,
+ LastComposedWord.NOT_A_SEPARATOR);
mConnection.endBatchEdit();
// Don't allow cancellation of manual pick
mLastComposedWord.deactivate();
@@ -358,9 +347,6 @@
// That's going to be predictions (or punctuation suggestions), so INPUT_STYLE_NONE.
handler.postUpdateSuggestionStrip(SuggestedWords.INPUT_STYLE_NONE);
}
- if (shouldShowAddToDictionaryIndicator) {
- mTextDecorator.showAddToDictionaryIndicator(suggestionInfo);
- }
return inputTransaction;
}
@@ -430,6 +416,9 @@
mRecapitalizeStatus.enable();
// We moved the cursor and need to invalidate the indicator right now.
mTextDecorator.reset();
+ // Remaining background color that was used for the add-to-dictionary indicator should be
+ // removed.
+ mConnection.removeBackgroundColorFromHighlightedTextIfNecessary();
// We moved the cursor. If we are touching a word, we need to resume suggestion.
mLatinIME.mHandler.postResumeSuggestions(false /* shouldIncludeResumedWordInSuggestions */,
true /* shouldDelay */);
@@ -508,7 +497,9 @@
handler.cancelUpdateSuggestionStrip();
++mAutoCommitSequenceNumber;
mConnection.beginBatchEdit();
- if (mWordComposer.isComposingWord()) {
+ if (!mWordComposer.isComposingWord()) {
+ mConnection.removeBackgroundColorFromHighlightedTextIfNecessary();
+ } else {
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.
@@ -620,42 +611,6 @@
}
mSuggestedWords = suggestedWords;
final boolean newAutoCorrectionIndicator = suggestedWords.mWillAutoCorrect;
- if (shouldShowCommitIndicator(suggestedWords, settingsValues)) {
- // typedWordInfo is never null here.
- final int textBackgroundColor = settingsValues.mTextHighlightColorForCommitIndicator;
- final SuggestedWordInfo typedWordInfo = suggestedWords.getTypedWordInfoOrNull();
- handler.postShowCommitIndicatorTask(new Runnable() {
- @Override
- public void run() {
- // TODO: This needs to be refactored to ensure that mWordComposer is accessed
- // only from the UI thread.
- if (!mWordComposer.isComposingWord()) {
- mTextDecorator.reset();
- return;
- }
- final SuggestedWordInfo currentTypedWordInfo =
- mSuggestedWords.getTypedWordInfoOrNull();
- if (currentTypedWordInfo == null) {
- mTextDecorator.reset();
- return;
- }
- if (!currentTypedWordInfo.equals(typedWordInfo)) {
- // Suggested word has been changed. This task is obsolete.
- mTextDecorator.reset();
- return;
- }
- // TODO: As with the above TODO comment, this operation must be performed only
- // on the UI thread too. Needs to be refactored.
- setComposingTextInternalWithBackgroundColor(typedWordInfo.mWord,
- 1 /* newCursorPosition */, textBackgroundColor);
- mTextDecorator.showCommitIndicator(typedWordInfo);
- }
- });
- } else {
- // Note: It is OK to not cancel previous postShowCommitIndicatorTask() here. Having a
- // cancellation mechanism could improve performance a bit though.
- mTextDecorator.reset();
- }
// Put a blue underline to a word in TextView which will be auto-corrected.
if (mIsAutoCorrectionIndicatorOn != newAutoCorrectionIndicator
@@ -833,13 +788,14 @@
final InputTransaction inputTransaction,
// TODO: remove this argument
final LatinIME.UIHandler handler) {
- // In case the "add to dictionary" hint was still displayed.
- // TODO: Do we really need to check if we have composing text here?
- if (!mWordComposer.isComposingWord() &&
- mSuggestionStripViewAccessor.isShowingAddToDictionaryHint()) {
- mSuggestionStripViewAccessor.dismissAddToDictionaryHint();
+ if (!mWordComposer.isComposingWord()) {
mConnection.removeBackgroundColorFromHighlightedTextIfNecessary();
- mTextDecorator.reset();
+ // In case the "add to dictionary" hint was still displayed.
+ // TODO: Do we really need to check if we have composing text here?
+ if (mSuggestionStripViewAccessor.isShowingAddToDictionaryHint()) {
+ mSuggestionStripViewAccessor.dismissAddToDictionaryHint();
+ mTextDecorator.reset();
+ }
}
final int codePoint = event.mCodePoint;
@@ -1096,7 +1052,7 @@
inputTransaction.setRequiresUpdateSuggestions();
} else {
if (mLastComposedWord.canRevertCommit()) {
- revertCommit(inputTransaction);
+ revertCommit(inputTransaction, inputTransaction.mSettingsValues);
return;
}
if (mEnteredText != null && mConnection.sameAsTextBeforeCursor(mEnteredText)) {
@@ -1582,14 +1538,19 @@
* 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) {
+ 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;
// We want java chars, not codepoints for the following.
- final int separatorLength = mLastComposedWord.mSeparatorString.length();
+ final 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) {
@@ -1608,7 +1569,7 @@
if (!TextUtils.isEmpty(committedWord)) {
mDictionaryFacilitator.removeWordFromPersonalizedDicts(committedWordString);
}
- final String stringToCommit = originallyTypedWord + mLastComposedWord.mSeparatorString;
+ final String stringToCommit = originallyTypedWord + separatorString;
final SpannableString textToCommit = new SpannableString(stringToCommit);
if (committedWord instanceof SpannableString) {
final SpannableString committedWordWithSuggestionSpans = (SpannableString)committedWord;
@@ -1645,23 +1606,53 @@
suggestions.toArray(new String[suggestions.size()]), 0 /* flags */),
0 /* start */, lastCharIndex /* end */, 0 /* flags */);
}
+
+ final boolean shouldShowAddToDictionaryForTypedWord =
+ shouldShowAddToDictionaryForTypedWord(mLastComposedWord, settingsValues);
+
if (inputTransaction.mSettingsValues.mSpacingAndPunctuations.mCurrentLanguageHasSpaces) {
// For languages with spaces, we revert to the typed string, but the cursor is still
// after the separator so we don't resume suggestions. If the user wants to correct
// the word, they have to press backspace again.
- mConnection.commitText(textToCommit, 1);
+ if (shouldShowAddToDictionaryForTypedWord) {
+ mConnection.commitTextWithBackgroundColor(textToCommit, 1,
+ settingsValues.mTextHighlightColorForAddToDictionaryIndicator,
+ originallyTypedWordString.length());
+ } else {
+ mConnection.commitText(textToCommit, 1);
+ }
} 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,
mLatinIME.getCoordinatesForCurrentKeyboard(codePoints));
- setComposingTextInternal(textToCommit, 1);
+ if (shouldShowAddToDictionaryForTypedWord) {
+ setComposingTextInternalWithBackgroundColor(textToCommit, 1,
+ settingsValues.mTextHighlightColorForAddToDictionaryIndicator,
+ originallyTypedWordString.length());
+ } else {
+ 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();
+
+ if (shouldShowAddToDictionaryForTypedWord) {
+ // Due to the API limitation as of L, we cannot reliably retrieve the reverted text
+ // when the separator causes line breaking. Until this API limitation is addressed in
+ // the framework, show the indicator only when the separator doesn't contain
+ // line-breaking characters.
+ if (!StringUtils.hasLineBreakCharacter(separatorString)) {
+ mTextDecorator.showAddToDictionaryIndicator(originallyTypedWordString,
+ mConnection.getExpectedSelectionStart(),
+ mConnection.getExpectedSelectionEnd());
+ }
+ mSuggestionStripViewAccessor.showAddToDictionaryHint(originallyTypedWordString);
+ } else {
+ // We have a separator between the word and the cursor: we should show predictions.
+ inputTransaction.setRequiresUpdateSuggestions();
+ }
}
/**
@@ -2085,9 +2076,7 @@
}
/**
- * Commits the chosen word to the text field and saves it for later retrieval. This is a
- * synonym of {@code commitChosenWordWithBackgroundColor(settingsValues, chosenWord,
- * commitType, separatorString, Color.TRANSPARENT}.
+ * 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.
@@ -2096,23 +2085,6 @@
*/
private void commitChosenWord(final SettingsValues settingsValues, final String chosenWord,
final int commitType, final String separatorString) {
- commitChosenWordWithBackgroundColor(settingsValues, chosenWord, commitType, separatorString,
- Color.TRANSPARENT);
- }
-
- /**
- * 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.
- * @param backgroundColor the background color to be specified with the committed text. Pass
- * {@link Color#TRANSPARENT} to not specify the background color.
- */
- private void commitChosenWordWithBackgroundColor(final SettingsValues settingsValues,
- final String chosenWord, final int commitType, final String separatorString,
- final int backgroundColor) {
final SuggestedWords suggestedWords = mSuggestedWords;
final CharSequence chosenWordWithSuggestions =
SuggestionSpanUtils.getTextWithSuggestionSpan(mLatinIME, chosenWord,
@@ -2122,7 +2094,7 @@
// information from the 1st previous word.
final PrevWordsInfo prevWordsInfo = mConnection.getPrevWordsInfoFromNthPreviousWord(
settingsValues.mSpacingAndPunctuations, mWordComposer.isComposingWord() ? 2 : 1);
- mConnection.commitTextWithBackgroundColor(chosenWordWithSuggestions, 1, backgroundColor);
+ mConnection.commitText(chosenWordWithSuggestions, 1);
// Add the word to the user history dictionary
performAdditionToUserHistoryDictionary(settingsValues, chosenWord, prevWordsInfo);
// TODO: figure out here if this is an auto-correct or if the best word is actually
@@ -2206,7 +2178,7 @@
private void setComposingTextInternal(final CharSequence newComposingText,
final int newCursorPosition) {
setComposingTextInternalWithBackgroundColor(newComposingText, newCursorPosition,
- Color.TRANSPARENT);
+ Color.TRANSPARENT, newComposingText.length());
}
/**
@@ -2222,9 +2194,11 @@
* @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 newCursorPosition, final int backgroundColor, final int coloredTextLength) {
final CharSequence composingTextToBeSet;
if (backgroundColor == Color.TRANSPARENT) {
composingTextToBeSet = newComposingText;
@@ -2232,7 +2206,8 @@
final SpannableString spannable = new SpannableString(newComposingText);
final BackgroundColorSpan backgroundColorSpan =
new BackgroundColorSpan(backgroundColor);
- spannable.setSpan(backgroundColorSpan, 0, spannable.length(),
+ final int spanLength = Math.min(coloredTextLength, spannable.length());
+ spannable.setSpan(backgroundColorSpan, 0, spanLength,
Spanned.SPAN_EXCLUSIVE_EXCLUSIVE | Spanned.SPAN_COMPOSING);
composingTextToBeSet = spannable;
}
@@ -2254,7 +2229,8 @@
}
/**
- * Must be called from {@link InputMethodService#onUpdateCursorAnchorInfo} is called.
+ * Must be called from {@link InputMethodService#onUpdateCursorAnchorInfo(CursorAnchorInfo)} is
+ * called.
* @param info The wrapper object with which we can access cursor/anchor info.
*/
public void onUpdateCursorAnchorInfo(final CursorAnchorInfoCompatWrapper info) {
@@ -2278,12 +2254,12 @@
}
/**
- * Returns whether the commit indicator should be shown or not.
- * @param suggestedWords the suggested word that is being displayed.
+ * Returns whether the add to dictionary indicator should be shown or not.
+ * @param lastComposedWord the last composed word information.
* @param settingsValues the current settings value.
* @return {@code true} if the commit indicator should be shown.
*/
- private boolean shouldShowCommitIndicator(final SuggestedWords suggestedWords,
+ private boolean shouldShowAddToDictionaryForTypedWord(final LastComposedWord lastComposedWord,
final SettingsValues settingsValues) {
if (!mConnection.isCursorAnchorInfoMonitorEnabled()) {
// We cannot help in this case because we are heavily relying on this new API.
@@ -2292,24 +2268,16 @@
if (!settingsValues.mShouldShowUiToAcceptTypedWord) {
return false;
}
- final SuggestedWordInfo typedWordInfo = suggestedWords.getTypedWordInfoOrNull();
- if (typedWordInfo == null) {
+ if (TextUtils.isEmpty(lastComposedWord.mTypedWord)) {
return false;
}
- if (suggestedWords.mInputStyle != SuggestedWords.INPUT_STYLE_TYPING){
+ if (TextUtils.equals(lastComposedWord.mTypedWord, lastComposedWord.mCommittedWord)) {
return false;
}
- if (settingsValues.mShowCommitIndicatorOnlyForAutoCorrection
- && !suggestedWords.mWillAutoCorrect) {
+ if (!mDictionaryFacilitator.isUserDictionaryEnabled()) {
return false;
}
- // TODO: Calling shouldShowAddToDictionaryHint(typedWordInfo) multiple times should be fine
- // in terms of performance, but we can do better. One idea is to make SuggestedWords include
- // a boolean that tells whether the word is a dictionary word or not.
- if (settingsValues.mShowCommitIndicatorOnlyForOutOfVocabulary
- && !shouldShowAddToDictionaryHint(typedWordInfo)) {
- return false;
- }
- return true;
+ return !mDictionaryFacilitator.isValidWord(lastComposedWord.mTypedWord,
+ true /* ignoreCase */);
}
}
diff --git a/java/src/com/android/inputmethod/latin/settings/SettingsValues.java b/java/src/com/android/inputmethod/latin/settings/SettingsValues.java
index 5c742a8..d8c548d 100644
--- a/java/src/com/android/inputmethod/latin/settings/SettingsValues.java
+++ b/java/src/com/android/inputmethod/latin/settings/SettingsValues.java
@@ -97,10 +97,7 @@
new int[AdditionalFeaturesSettingUtils.ADDITIONAL_FEATURES_SETTINGS_SIZE];
// TextDecorator
- public final int mTextHighlightColorForCommitIndicator;
public final int mTextHighlightColorForAddToDictionaryIndicator;
- public final boolean mShowCommitIndicatorOnlyForAutoCorrection;
- public final boolean mShowCommitIndicatorOnlyForOutOfVocabulary;
// Debug settings
public final boolean mIsInternal;
@@ -175,12 +172,6 @@
mSuggestionsEnabledPerUserSettings = readSuggestionsEnabled(prefs);
AdditionalFeaturesSettingUtils.readAdditionalFeaturesPreferencesIntoArray(
prefs, mAdditionalFeaturesSettingValues);
- mShowCommitIndicatorOnlyForAutoCorrection = res.getBoolean(
- R.bool.text_decorator_only_for_auto_correction);
- mShowCommitIndicatorOnlyForOutOfVocabulary = res.getBoolean(
- R.bool.text_decorator_only_for_out_of_vocabulary);
- mTextHighlightColorForCommitIndicator = res.getColor(
- R.color.text_decorator_commit_indicator_text_highlight_color);
mTextHighlightColorForAddToDictionaryIndicator = res.getColor(
R.color.text_decorator_add_to_dictionary_indicator_text_highlight_color);
mIsInternal = Settings.isInternal(prefs);
@@ -426,12 +417,6 @@
sb.append("" + (null == awu ? "null" : awu.toString()));
sb.append("\n mAdditionalFeaturesSettingValues = ");
sb.append("" + Arrays.toString(mAdditionalFeaturesSettingValues));
- sb.append("\n mShowCommitIndicatorOnlyForAutoCorrection = ");
- sb.append("" + mShowCommitIndicatorOnlyForAutoCorrection);
- sb.append("\n mShowCommitIndicatorOnlyForOutOfVocabulary = ");
- sb.append("" + mShowCommitIndicatorOnlyForOutOfVocabulary);
- sb.append("\n mTextHighlightColorForCommitIndicator = ");
- sb.append("" + mTextHighlightColorForCommitIndicator);
sb.append("\n mTextHighlightColorForAddToDictionaryIndicator = ");
sb.append("" + mTextHighlightColorForAddToDictionaryIndicator);
sb.append("\n mIsInternal = ");
diff --git a/java/src/com/android/inputmethod/latin/utils/StringUtils.java b/java/src/com/android/inputmethod/latin/utils/StringUtils.java
index 38f0b3f..1781924 100644
--- a/java/src/com/android/inputmethod/latin/utils/StringUtils.java
+++ b/java/src/com/android/inputmethod/latin/utils/StringUtils.java
@@ -37,6 +37,14 @@
private static final String EMPTY_STRING = "";
+ private static final char CHAR_LINE_FEED = 0X000A;
+ private static final char CHAR_VERTICAL_TAB = 0X000B;
+ private static final char CHAR_FORM_FEED = 0X000C;
+ private static final char CHAR_CARRIAGE_RETURN = 0X000D;
+ private static final char CHAR_NEXT_LINE = 0X0085;
+ private static final char CHAR_LINE_SEPARATOR = 0X2028;
+ private static final char CHAR_PARAGRAPH_SEPARATOR = 0X2029;
+
private StringUtils() {
// This utility class is not publicly instantiable.
}
@@ -594,4 +602,30 @@
return sb + "]";
}
}
+
+ /**
+ * Returns whether the last composed word contains line-breaking character (e.g. CR or LF).
+ * @param text the text to be examined.
+ * @return {@code true} if the last composed word contains line-breaking separator.
+ */
+ @UsedForTesting
+ public static boolean hasLineBreakCharacter(final String text) {
+ if (TextUtils.isEmpty(text)) {
+ return false;
+ }
+ for (int i = text.length() - 1; i >= 0; --i) {
+ final char c = text.charAt(i);
+ switch (c) {
+ case CHAR_LINE_FEED:
+ case CHAR_VERTICAL_TAB:
+ case CHAR_FORM_FEED:
+ case CHAR_CARRIAGE_RETURN:
+ case CHAR_NEXT_LINE:
+ case CHAR_LINE_SEPARATOR:
+ case CHAR_PARAGRAPH_SEPARATOR:
+ return true;
+ }
+ }
+ return false;
+ }
}