nyancrimew/LatinIME
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

am d04271e7: am fa63d910: Merge "Use Add-To-Dictionary indicator only" into lmp-dev

Browse source 
* commit 'd04271e7fc783c8f514b506aa78522dc40cb69e6':
  Use Add-To-Dictionary indicator only
This commit is contained in:
Yohei Yukawa 2014-09-18 07:34:24 +00:00 committed by Android Git Automerger
commit b477d6886d
10 changed files with 267 additions and 418 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

51
java/res/values/donottranslate-text-decorator.xml
View file

@ -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">

18
java/src/com/android/inputmethod/compat/CursorAnchorInfoCompatWrapper.java
View file

@ -41,6 +41,8 @@ public final class CursorAnchorInfoCompatWrapper {
// 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 @@ public final class CursorAnchorInfoCompatWrapper {
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 @@ public final class CursorAnchorInfoCompatWrapper {
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 @@ public final class CursorAnchorInfoCompatWrapper {
return FakeHolder.sInstance;
}
public int getSelectionStart() {
return sGetSelectionStartMethod.invoke(mInstance);
}
public int getSelectionEnd() {
return sGetSelectionEndMethod.invoke(mInstance);
}
public CharSequence getComposingText() {
return sGetComposingTextMethod.invoke(mInstance);
}

282
java/src/com/android/inputmethod/keyboard/TextDecorator.java
View file

@ -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 @@ public class TextDecorator {
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 class TextDecorator {
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 @@ public class TextDecorator {
}
/**
* 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 class TextDecorator {
*/
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 @@ public class TextDecorator {
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 @@ public class TextDecorator {
}
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 @@ public class TextDecorator {
}
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;
}
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;
}
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;
left = Math.min(characterBounds.left, left);
right = Math.max(characterBounds.right, right);
}
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 {
if (!mIsFullScreenMode && !TextUtils.isEmpty(composingText)) {
// This is an unexpected case.
// TODO: Document this.
indicatorLeft = right;
}
mIndicatorBoundsForLastComposingText.offset(indicatorLeft, indicatorTop);
}
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;
}
// 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.
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;
}
final float insertionMarkerHolizontal = info.getInsertionMarkerHorizontal();
final float insertionMarkerTop = info.getInsertionMarkerTop();
mLocalOrigin.set(insertionMarkerHolizontal, insertionMarkerTop);
}
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);
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;
}
}
private final LayoutInvalidator mLayoutInvalidator = new LayoutInvalidator(this);
@ -407,10 +359,7 @@ public class TextDecorator {
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 class TextDecorator {
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) {
}
};
}

35
java/src/com/android/inputmethod/keyboard/TextDecoratorUi.java
View file

@ -46,7 +46,6 @@ public final class TextDecoratorUi implements TextDecoratorUiOperator {
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 @@ public final class TextDecoratorUi implements TextDecoratorUiOperator {
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 @@ public final class TextDecoratorUi implements TextDecoratorUiOperator {
@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 @@ public final class TextDecoratorUi implements TextDecoratorUiOperator {
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 @@ public final class TextDecoratorUi implements TextDecoratorUiOperator {
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,

4
java/src/com/android/inputmethod/keyboard/TextDecoratorUiOperator.java
View file

@ -44,12 +44,10 @@ public interface TextDecoratorUiOperator {
/**
* 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);
}

27
java/src/com/android/inputmethod/latin/LatinIME.java
View file

@ -188,9 +188,8 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
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 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
private int mDelayInMillisecondsToUpdateSuggestions;
private int mDelayInMillisecondsToUpdateShiftState;
private int mDelayInMillisecondsToShowCommitIndicator;
public UIHandler(final LatinIME ownerInstance) {
super(ownerInstance);
@ -217,8 +215,6 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
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 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
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 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
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;

9
java/src/com/android/inputmethod/latin/RichInputConnection.java
View file

@ -252,7 +252,7 @@ public final class RichInputConnection {
* 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 @@ public final class RichInputConnection {
* 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 @@ public final class RichInputConnection {
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;

178
java/src/com/android/inputmethod/latin/inputlogic/InputLogic.java
View file

@ -28,6 +28,7 @@ import android.util.Log;
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 @@ public final class InputLogic {
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 @@ public final class InputLogic {
mConnection.requestCursorUpdates(true /* enableMonitor */,
true /* requestImmediateCallback */);
}
mTextDecorator.reset();
}
}
@ -333,17 +331,8 @@ public final class InputLogic {
}
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 @@ public final class InputLogic {
// 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 @@ public final class InputLogic {
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 @@ public final class InputLogic {
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 @@ public final class InputLogic {
}
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,14 +788,15 @@ public final class InputLogic {
final InputTransaction inputTransaction,
// TODO: remove this argument
final LatinIME.UIHandler handler) {
if (!mWordComposer.isComposingWord()) {
mConnection.removeBackgroundColorFromHighlightedTextIfNecessary();
// 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()) {
if (mSuggestionStripViewAccessor.isShowingAddToDictionaryHint()) {
mSuggestionStripViewAccessor.dismissAddToDictionaryHint();
mConnection.removeBackgroundColorFromHighlightedTextIfNecessary();
mTextDecorator.reset();
}
}
final int codePoint = event.mCodePoint;
mSpaceState = SpaceState.NONE;
@ -1096,7 +1052,7 @@ public final class InputLogic {
inputTransaction.setRequiresUpdateSuggestions();
} else {
if (mLastComposedWord.canRevertCommit()) {
revertCommit(inputTransaction);
revertCommit(inputTransaction, inputTransaction.mSettingsValues);
return;
}
if (mEnteredText != null && mConnection.sameAsTextBeforeCursor(mEnteredText)) {
@ -1582,14 +1538,19 @@ public final class InputLogic {
* 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 @@ public final class InputLogic {
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,24 +1606,54 @@ public final class InputLogic {
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.
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));
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;
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();
}
}
/**
* Factor in auto-caps and manual caps and compute the current caps mode.
@ -2085,9 +2076,7 @@ public final class InputLogic {
}
/**
* 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 @@ public final class InputLogic {
*/
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 @@ public final class InputLogic {
// 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 @@ public final class InputLogic {
private void setComposingTextInternal(final CharSequence newComposingText,
final int newCursorPosition) {
setComposingTextInternalWithBackgroundColor(newComposingText, newCursorPosition,
Color.TRANSPARENT);
Color.TRANSPARENT, newComposingText.length());
}
/**
@ -2222,9 +2194,11 @@ public final class InputLogic {
* @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 @@ public final class InputLogic {
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 @@ public final class InputLogic {
}
/**
* 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 @@ public final class InputLogic {
}
/**
* 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 @@ public final class InputLogic {
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 */);
}
}

15
java/src/com/android/inputmethod/latin/settings/SettingsValues.java
View file

@ -97,10 +97,7 @@ public final class SettingsValues {
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 @@ public final class SettingsValues {
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 @@ public final class SettingsValues {
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 = ");

34
java/src/com/android/inputmethod/latin/utils/StringUtils.java
View file

@ -37,6 +37,14 @@ public final class StringUtils {
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 @@ public final class StringUtils {
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;
}
}