am bea17c49: Introduce commit/add-to-dictionary indicators
* commit 'bea17c49ec23bf0f646cb548445c7756aa50d233': Introduce commit/add-to-dictionary indicatorsmain
Yohei Yukawa
Android Git Automerger
commit
0268f7368f
|
|
@ -0,0 +1,127 @@
|
|||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<!--
|
||||
/*
|
||||
**
|
||||
** Copyright 2014, The Android Open Source Project
|
||||
**
|
||||
** Licensed under the Apache License, Version 2.0 (the "License");
|
||||
** you may not use this file except in compliance with the License.
|
||||
** You may obtain a copy of the License at
|
||||
**
|
||||
** http://www.apache.org/licenses/LICENSE-2.0
|
||||
**
|
||||
** Unless required by applicable law or agreed to in writing, software
|
||||
** distributed under the License is distributed on an "AS IS" BASIS,
|
||||
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
** See the License for the specific language governing permissions and
|
||||
** limitations under the License.
|
||||
*/
|
||||
-->
|
||||
|
||||
<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">false</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">
|
||||
#D1E7B7
|
||||
</color>
|
||||
|
||||
<!-- Foreground color of the commit indicator. -->
|
||||
<color name="text_decorator_add_to_dictionary_indicator_background_color">
|
||||
#4EB848
|
||||
</color>
|
||||
|
||||
<!-- Foreground color of the add-to-dictionary indicator. -->
|
||||
<color name="text_decorator_add_to_dictionary_indicator_foreground_color">
|
||||
#FFFFFF
|
||||
</color>
|
||||
|
||||
<!-- Viewport size of "text_decorator_add_to_dictionary_indicator_path". -->
|
||||
<integer name="text_decorator_add_to_dictionary_indicator_path_size">
|
||||
480
|
||||
</integer>
|
||||
|
||||
<!-- Coordinates of the closed path to be used to render the add-to-dictionary indicator.
|
||||
The format is: X[0], Y[0], X[1], Y[1], ..., X[N-1], Y[N-1] -->
|
||||
<integer-array name="text_decorator_add_to_dictionary_indicator_path">
|
||||
<item>380</item>
|
||||
<item>260</item>
|
||||
<item>260</item>
|
||||
<item>260</item>
|
||||
<item>260</item>
|
||||
<item>380</item>
|
||||
<item>220</item>
|
||||
<item>380</item>
|
||||
<item>220</item>
|
||||
<item>260</item>
|
||||
<item>100</item>
|
||||
<item>260</item>
|
||||
<item>100</item>
|
||||
<item>220</item>
|
||||
<item>220</item>
|
||||
<item>220</item>
|
||||
<item>220</item>
|
||||
<item>100</item>
|
||||
<item>260</item>
|
||||
<item>100</item>
|
||||
<item>260</item>
|
||||
<item>220</item>
|
||||
<item>380</item>
|
||||
<item>220</item>
|
||||
</integer-array>
|
||||
</resources>
|
||||
|
|
@ -0,0 +1,425 @@
|
|||
/*
|
||||
* Copyright (C) 2014 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package 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
|
||||
* 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}.
|
||||
*/
|
||||
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 int mMode = MODE_NONE;
|
||||
|
||||
private final PointF mLocalOrigin = new PointF();
|
||||
private final RectF mRelativeIndicatorBounds = new RectF();
|
||||
private final RectF mRelativeComposingTextBounds = new RectF();
|
||||
|
||||
private boolean mIsFullScreenMode = false;
|
||||
private SuggestedWordInfo mWaitingWord = null;
|
||||
private CursorAnchorInfoCompatWrapper mCursorAnchorInfoWrapper = null;
|
||||
|
||||
@Nonnull
|
||||
private final Listener mListener;
|
||||
|
||||
@Nonnull
|
||||
private TextDecoratorUiOperator mUiOperator = EMPTY_UI_OPERATOR;
|
||||
|
||||
public interface Listener {
|
||||
/**
|
||||
* Called when the user clicks the composing text to commit.
|
||||
* @param wordInfo the suggested 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);
|
||||
}
|
||||
|
||||
public TextDecorator(final Listener listener) {
|
||||
mListener = (listener != null) ? listener : EMPTY_LISTENER;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the UI operator for {@link TextDecorator}. Any user visible operations will be
|
||||
* delegated to the associated UI operator.
|
||||
* @param uiOperator the UI operator to be associated.
|
||||
*/
|
||||
public void setUiOperator(final TextDecoratorUiOperator uiOperator) {
|
||||
mUiOperator.disposeUi();
|
||||
mUiOperator = uiOperator;
|
||||
mUiOperator.setOnClickListener(getOnClickHandler());
|
||||
}
|
||||
|
||||
private final Runnable mDefaultOnClickHandler = new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
onClickIndicator();
|
||||
}
|
||||
};
|
||||
|
||||
@UsedForTesting
|
||||
final Runnable getOnClickHandler() {
|
||||
return mDefaultOnClickHandler;
|
||||
}
|
||||
|
||||
/**
|
||||
* Shows the "Commit" indicator and associates it with 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#onClickComposingTextToCommit(SuggestedWordInfo)}
|
||||
*/
|
||||
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;
|
||||
layoutLater();
|
||||
return;
|
||||
}
|
||||
|
||||
/**
|
||||
* Must be called when the input method is about changing to for from the full screen mode.
|
||||
* @param fullScreenMode {@code true} if the input method is entering the full screen mode.
|
||||
* {@code false} is the input method is finishing the full screen mode.
|
||||
*/
|
||||
public void notifyFullScreenMode(final boolean fullScreenMode) {
|
||||
final boolean currentFullScreenMode = mIsFullScreenMode;
|
||||
if (!currentFullScreenMode && fullScreenMode) {
|
||||
// Currently full screen mode is not supported.
|
||||
// TODO: Support full screen mode.
|
||||
hideIndicator();
|
||||
}
|
||||
mIsFullScreenMode = fullScreenMode;
|
||||
}
|
||||
|
||||
/**
|
||||
* Resets previous requests and makes indicator invisible.
|
||||
*/
|
||||
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);
|
||||
cancelLayoutInternalExpectedly("Resetting internal state.");
|
||||
}
|
||||
|
||||
/**
|
||||
* Must be called when the {@link InputMethodService#onUpdateCursorAnchorInfo()} is called.
|
||||
*
|
||||
* <p>CAVEAT: Currently the input method author is responsible for ignoring
|
||||
* {@link InputMethodService#onUpdateCursorAnchorInfo()} called in full screen mode.</p>
|
||||
* @param info the compatibility wrapper object for the received {@link CursorAnchorInfo}.
|
||||
*/
|
||||
public void onUpdateCursorAnchorInfo(final CursorAnchorInfoCompatWrapper info) {
|
||||
if (mIsFullScreenMode) {
|
||||
// TODO: Consider to call InputConnection#requestCursorAnchorInfo to disable the
|
||||
// event callback to suppress unnecessary event callbacks.
|
||||
return;
|
||||
}
|
||||
mCursorAnchorInfoWrapper = info;
|
||||
// Do not use layoutLater() to minimize the latency.
|
||||
layoutImmediately();
|
||||
}
|
||||
|
||||
private void hideIndicator() {
|
||||
mUiOperator.hideUi();
|
||||
}
|
||||
|
||||
private void cancelLayoutInternalUnexpectedly(final String message) {
|
||||
hideIndicator();
|
||||
Log.d(TAG, message);
|
||||
}
|
||||
|
||||
private void cancelLayoutInternalExpectedly(final String message) {
|
||||
hideIndicator();
|
||||
if (DEBUG) {
|
||||
Log.d(TAG, message);
|
||||
}
|
||||
}
|
||||
|
||||
private void layoutLater() {
|
||||
mLayoutInvalidator.invalidateLayout();
|
||||
}
|
||||
|
||||
|
||||
private void layoutImmediately() {
|
||||
// Clear pending layout requests.
|
||||
mLayoutInvalidator.cancelInvalidateLayout();
|
||||
layoutMain();
|
||||
}
|
||||
|
||||
private void layoutMain() {
|
||||
if (mIsFullScreenMode) {
|
||||
cancelLayoutInternalUnexpectedly("Full screen mode isn't yet supported.");
|
||||
return;
|
||||
}
|
||||
|
||||
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) {
|
||||
cancelLayoutInternalExpectedly("CursorAnchorInfo isn't available.");
|
||||
return;
|
||||
}
|
||||
|
||||
final Matrix matrix = info.getMatrix();
|
||||
if (matrix == null) {
|
||||
cancelLayoutInternalUnexpectedly("Matrix is null");
|
||||
}
|
||||
|
||||
final CharSequence composingText = info.getComposingText();
|
||||
if (mMode == MODE_COMMIT) {
|
||||
if (composingText == null) {
|
||||
cancelLayoutInternalExpectedly("composingText is null.");
|
||||
return;
|
||||
}
|
||||
final int composingTextStart = info.getComposingTextStart();
|
||||
final int lastCharRectIndex = composingTextStart + composingText.length() - 1;
|
||||
final RectF lastCharRect = info.getCharacterRect(lastCharRectIndex);
|
||||
final int lastCharRectFlag = info.getCharacterRectFlags(lastCharRectIndex);
|
||||
final int lastCharRectType =
|
||||
lastCharRectFlag & CursorAnchorInfoCompatWrapper.CHARACTER_RECT_TYPE_MASK;
|
||||
if (lastCharRect == null || matrix == null || lastCharRectType !=
|
||||
CursorAnchorInfoCompatWrapper.CHARACTER_RECT_TYPE_FULLY_VISIBLE) {
|
||||
hideIndicator();
|
||||
return;
|
||||
}
|
||||
final RectF segmentStartCharRect = new RectF(lastCharRect);
|
||||
for (int i = composingText.length() - 2; i >= 0; --i) {
|
||||
final RectF charRect = info.getCharacterRect(composingTextStart + i);
|
||||
if (charRect == null) {
|
||||
break;
|
||||
}
|
||||
if (charRect.top != segmentStartCharRect.top) {
|
||||
break;
|
||||
}
|
||||
if (charRect.bottom != segmentStartCharRect.bottom) {
|
||||
break;
|
||||
}
|
||||
segmentStartCharRect.set(charRect);
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
} else {
|
||||
if (!TextUtils.isEmpty(composingText)) {
|
||||
// This is an unexpected case.
|
||||
// TODO: Document this.
|
||||
hideIndicator();
|
||||
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.isInsertionMarkerClipped()) {
|
||||
hideIndicator();
|
||||
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);
|
||||
}
|
||||
|
||||
private void onClickIndicator() {
|
||||
if (mWaitingWord == null || TextUtils.isEmpty(mWaitingWord.mWord)) {
|
||||
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);
|
||||
|
||||
/**
|
||||
* Used for managing pending layout tasks for {@link TextDecorator#layoutLater()}.
|
||||
*/
|
||||
private static final class LayoutInvalidator {
|
||||
private final HandlerImpl mHandler;
|
||||
public LayoutInvalidator(final TextDecorator ownerInstance) {
|
||||
mHandler = new HandlerImpl(ownerInstance);
|
||||
}
|
||||
|
||||
private static final int MSG_LAYOUT = 0;
|
||||
|
||||
private static final class HandlerImpl
|
||||
extends LeakGuardHandlerWrapper<TextDecorator> {
|
||||
public HandlerImpl(final TextDecorator ownerInstance) {
|
||||
super(ownerInstance);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void handleMessage(final Message msg) {
|
||||
final TextDecorator owner = getOwnerInstance();
|
||||
if (owner == null) {
|
||||
return;
|
||||
}
|
||||
switch (msg.what) {
|
||||
case MSG_LAYOUT:
|
||||
owner.layoutMain();
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Puts a layout task into the scheduler. Does nothing if one or more layout tasks are
|
||||
* already scheduled.
|
||||
*/
|
||||
public void invalidateLayout() {
|
||||
if (!mHandler.hasMessages(MSG_LAYOUT)) {
|
||||
mHandler.obtainMessage(MSG_LAYOUT).sendToTarget();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Clears the pending layout tasks.
|
||||
*/
|
||||
public void cancelInvalidateLayout() {
|
||||
mHandler.removeMessages(MSG_LAYOUT);
|
||||
}
|
||||
}
|
||||
|
||||
private final static Listener EMPTY_LISTENER = new Listener() {
|
||||
@Override
|
||||
public void onClickComposingTextToCommit(SuggestedWordInfo wordInfo) {
|
||||
}
|
||||
@Override
|
||||
public void onClickComposingTextToAddToDictionary(SuggestedWordInfo wordInfo) {
|
||||
}
|
||||
};
|
||||
|
||||
private final static TextDecoratorUiOperator EMPTY_UI_OPERATOR = new TextDecoratorUiOperator() {
|
||||
@Override
|
||||
public void disposeUi() {
|
||||
}
|
||||
@Override
|
||||
public void hideUi() {
|
||||
}
|
||||
@Override
|
||||
public void setOnClickListener(Runnable listener) {
|
||||
}
|
||||
@Override
|
||||
public void layoutUi(boolean isCommitMode, Matrix matrix, RectF indicatorBounds,
|
||||
RectF composingTextBounds) {
|
||||
}
|
||||
};
|
||||
}
|
||||
|
|
@ -0,0 +1,259 @@
|
|||
/*
|
||||
* Copyright (C) 2014 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package com.android.inputmethod.keyboard;
|
||||
|
||||
import android.content.Context;
|
||||
import android.content.res.Resources;
|
||||
import android.graphics.Canvas;
|
||||
import android.graphics.Color;
|
||||
import android.graphics.Matrix;
|
||||
import android.graphics.Paint;
|
||||
import android.graphics.Path;
|
||||
import android.graphics.RectF;
|
||||
import android.graphics.drawable.ColorDrawable;
|
||||
import android.inputmethodservice.InputMethodService;
|
||||
import android.util.TypedValue;
|
||||
import android.view.Gravity;
|
||||
import android.view.View;
|
||||
import android.view.View.OnClickListener;
|
||||
import android.view.ViewGroup;
|
||||
import android.view.ViewGroup.LayoutParams;
|
||||
import android.view.ViewParent;
|
||||
import android.widget.PopupWindow;
|
||||
import android.widget.RelativeLayout;
|
||||
|
||||
import com.android.inputmethod.latin.R;
|
||||
|
||||
/**
|
||||
* Used as the UI component of {@link TextDecorator}.
|
||||
*/
|
||||
public final class TextDecoratorUi implements TextDecoratorUiOperator {
|
||||
private static final boolean VISUAL_DEBUG = false;
|
||||
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;
|
||||
private final float mHitAreaMarginInPixels;
|
||||
|
||||
/**
|
||||
* This constructor is designed to be called from {@link InputMethodService#setInputView(View)}.
|
||||
* Other usages are not supported.
|
||||
*
|
||||
* @param context the context of the input method.
|
||||
* @param inputView the view that is passed to {@link InputMethodService#setInputView(View)}.
|
||||
*/
|
||||
public TextDecoratorUi(final Context context, final View inputView) {
|
||||
final Resources resources = context.getResources();
|
||||
final int hitAreaMarginInDP = resources.getInteger(
|
||||
R.integer.text_decorator_hit_area_margin_in_dp);
|
||||
mHitAreaMarginInPixels = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
|
||||
hitAreaMarginInDP, resources.getDisplayMetrics());
|
||||
|
||||
mLocalRootView = new RelativeLayout(context);
|
||||
mLocalRootView.setLayoutParams(new LayoutParams(LayoutParams.MATCH_PARENT,
|
||||
LayoutParams.MATCH_PARENT));
|
||||
// TODO: Use #setBackground(null) for API Level >= 16.
|
||||
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);
|
||||
}
|
||||
|
||||
// This popup window is used to avoid the limitation that the input method is not able to
|
||||
// observe the touch events happening outside of InputMethodService.Insets#touchableRegion.
|
||||
// We don't use this popup window for rendering the UI for performance reasons though.
|
||||
mTouchEventWindow = new PopupWindow(context);
|
||||
if (VISUAL_DEBUG) {
|
||||
mTouchEventWindow.setBackgroundDrawable(new ColorDrawable(VISUAL_DEBUG_HIT_AREA_COLOR));
|
||||
} else {
|
||||
mTouchEventWindow.setBackgroundDrawable(null);
|
||||
}
|
||||
mTouchEventWindowClickListenerView = new View(context);
|
||||
mTouchEventWindow.setContentView(mTouchEventWindowClickListenerView);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void disposeUi() {
|
||||
if (mLocalRootView != null) {
|
||||
final ViewParent parent = mLocalRootView.getParent();
|
||||
if (parent != null && parent instanceof ViewGroup) {
|
||||
((ViewGroup) parent).removeView(mLocalRootView);
|
||||
}
|
||||
mLocalRootView.removeAllViews();
|
||||
}
|
||||
if (mTouchEventWindow != null) {
|
||||
mTouchEventWindow.dismiss();
|
||||
}
|
||||
}
|
||||
|
||||
@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) {
|
||||
final RectF indicatorBoundsInScreenCoordinates = new RectF();
|
||||
matrix.mapRect(indicatorBoundsInScreenCoordinates, indicatorBounds);
|
||||
mCommitIndicatorView.setBounds(indicatorBoundsInScreenCoordinates);
|
||||
mAddToDictionaryIndicatorView.setBounds(indicatorBoundsInScreenCoordinates);
|
||||
|
||||
final RectF hitAreaBounds = new RectF(composingTextBounds);
|
||||
hitAreaBounds.union(indicatorBounds);
|
||||
final RectF hitAreaBoundsInScreenCoordinates = new RectF();
|
||||
matrix.mapRect(hitAreaBoundsInScreenCoordinates, hitAreaBounds);
|
||||
hitAreaBoundsInScreenCoordinates.inset(-mHitAreaMarginInPixels, -mHitAreaMarginInPixels);
|
||||
|
||||
final int[] originScreen = new int[2];
|
||||
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);
|
||||
|
||||
if (mTouchEventWindow.isShowing()) {
|
||||
mTouchEventWindow.update((int)hitAreaBoundsInScreenCoordinates.left - viewOriginX,
|
||||
(int)hitAreaBoundsInScreenCoordinates.top - viewOriginY,
|
||||
(int)hitAreaBoundsInScreenCoordinates.width(),
|
||||
(int)hitAreaBoundsInScreenCoordinates.height());
|
||||
} else {
|
||||
mTouchEventWindow.setWidth((int)hitAreaBoundsInScreenCoordinates.width());
|
||||
mTouchEventWindow.setHeight((int)hitAreaBoundsInScreenCoordinates.height());
|
||||
mTouchEventWindow.showAtLocation(mLocalRootView, Gravity.NO_GRAVITY,
|
||||
(int)hitAreaBoundsInScreenCoordinates.left - viewOriginX,
|
||||
(int)hitAreaBoundsInScreenCoordinates.top - viewOriginY);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setOnClickListener(final Runnable listener) {
|
||||
mTouchEventWindowClickListenerView.setOnClickListener(new OnClickListener() {
|
||||
@Override
|
||||
public void onClick(final View arg0) {
|
||||
listener.run();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
private static class IndicatorView extends View {
|
||||
private final Path mPath;
|
||||
private final Path mTmpPath = new Path();
|
||||
private final Paint mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
|
||||
private final Matrix mMatrix = new Matrix();
|
||||
private final int mBackgroundColor;
|
||||
private final int mForegroundColor;
|
||||
private final RectF mBounds = new RectF();
|
||||
public IndicatorView(Context context, final int pathResourceId,
|
||||
final int sizeResourceId, final int backgroundColorResourceId,
|
||||
final int foregroundColroResourceId) {
|
||||
super(context);
|
||||
final Resources resources = context.getResources();
|
||||
mPath = createPath(resources, pathResourceId, sizeResourceId);
|
||||
mBackgroundColor = resources.getColor(backgroundColorResourceId);
|
||||
mForegroundColor = resources.getColor(foregroundColroResourceId);
|
||||
}
|
||||
|
||||
public void setBounds(final RectF rect) {
|
||||
mBounds.set(rect);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void onDraw(Canvas canvas) {
|
||||
mPaint.setColor(mBackgroundColor);
|
||||
mPaint.setStyle(Paint.Style.FILL);
|
||||
canvas.drawRect(0.0f, 0.0f, mBounds.width(), mBounds.height(), mPaint);
|
||||
|
||||
mMatrix.reset();
|
||||
mMatrix.postScale(mBounds.width(), mBounds.height());
|
||||
mPath.transform(mMatrix, mTmpPath);
|
||||
mPaint.setColor(mForegroundColor);
|
||||
canvas.drawPath(mTmpPath, mPaint);
|
||||
}
|
||||
|
||||
private static Path createPath(final Resources resources, final int pathResourceId,
|
||||
final int sizeResourceId) {
|
||||
final int size = resources.getInteger(sizeResourceId);
|
||||
final float normalizationFactor = 1.0f / size;
|
||||
final int[] array = resources.getIntArray(pathResourceId);
|
||||
|
||||
final Path path = new Path();
|
||||
for (int i = 0; i < array.length; i += 2) {
|
||||
if (i == 0) {
|
||||
path.moveTo(array[i] * normalizationFactor, array[i + 1] * normalizationFactor);
|
||||
} else {
|
||||
path.lineTo(array[i] * normalizationFactor, array[i + 1] * normalizationFactor);
|
||||
}
|
||||
}
|
||||
path.close();
|
||||
return path;
|
||||
}
|
||||
}
|
||||
|
||||
private static ViewGroup getContentView(final View view) {
|
||||
final View rootView = view.getRootView();
|
||||
if (rootView == null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
final ViewGroup windowContentView = (ViewGroup)rootView.findViewById(android.R.id.content);
|
||||
if (windowContentView == null) {
|
||||
return null;
|
||||
}
|
||||
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,
|
||||
R.integer.text_decorator_add_to_dictionary_indicator_path_size,
|
||||
R.color.text_decorator_add_to_dictionary_indicator_background_color,
|
||||
R.color.text_decorator_add_to_dictionary_indicator_foreground_color);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
/*
|
||||
* Copyright (C) 2014 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package com.android.inputmethod.keyboard;
|
||||
|
||||
import android.graphics.Matrix;
|
||||
import android.graphics.PointF;
|
||||
import android.graphics.RectF;
|
||||
|
||||
/**
|
||||
* This interface defines how UI operations required for {@link TextDecorator} are delegated to
|
||||
* the actual UI implementation class.
|
||||
*/
|
||||
public interface TextDecoratorUiOperator {
|
||||
/**
|
||||
* Called to notify that the UI is ready to be disposed.
|
||||
*/
|
||||
void disposeUi();
|
||||
|
||||
/**
|
||||
* Called when the UI should become invisible.
|
||||
*/
|
||||
void hideUi();
|
||||
|
||||
/**
|
||||
* Called to set the new click handler.
|
||||
* @param onClickListener the callback object whose {@link Runnable#run()} should be called when
|
||||
* the indicator is clicked.
|
||||
*/
|
||||
void setOnClickListener(final Runnable onClickListener);
|
||||
|
||||
/**
|
||||
* 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,
|
||||
final RectF composingTextBounds);
|
||||
}
|
||||
|
|
@ -69,6 +69,7 @@ import com.android.inputmethod.keyboard.KeyboardActionListener;
|
|||
import com.android.inputmethod.keyboard.KeyboardId;
|
||||
import com.android.inputmethod.keyboard.KeyboardSwitcher;
|
||||
import com.android.inputmethod.keyboard.MainKeyboardView;
|
||||
import com.android.inputmethod.keyboard.TextDecoratorUi;
|
||||
import com.android.inputmethod.latin.Suggest.OnGetSuggestedWordsCallback;
|
||||
import com.android.inputmethod.latin.SuggestedWords.SuggestedWordInfo;
|
||||
import com.android.inputmethod.latin.define.DebugFlags;
|
||||
|
|
@ -183,8 +184,9 @@ 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_WAIT_FOR_DICTIONARY_LOAD;
|
||||
private static final int MSG_LAST = MSG_SHOW_COMMIT_INDICATOR;
|
||||
|
||||
private static final int ARG1_NOT_GESTURE_INPUT = 0;
|
||||
private static final int ARG1_DISMISS_GESTURE_FLOATING_PREVIEW_TEXT = 1;
|
||||
|
|
@ -195,6 +197,7 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
|
|||
|
||||
private int mDelayInMillisecondsToUpdateSuggestions;
|
||||
private int mDelayInMillisecondsToUpdateShiftState;
|
||||
private int mDelayInMillisecondsToShowCommitIndicator;
|
||||
|
||||
public UIHandler(final LatinIME ownerInstance) {
|
||||
super(ownerInstance);
|
||||
|
|
@ -206,10 +209,12 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
|
|||
return;
|
||||
}
|
||||
final Resources res = latinIme.getResources();
|
||||
mDelayInMillisecondsToUpdateSuggestions =
|
||||
res.getInteger(R.integer.config_delay_in_milliseconds_to_update_suggestions);
|
||||
mDelayInMillisecondsToUpdateShiftState =
|
||||
res.getInteger(R.integer.config_delay_in_milliseconds_to_update_shift_state);
|
||||
mDelayInMillisecondsToUpdateSuggestions = res.getInteger(
|
||||
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
|
||||
|
|
@ -258,7 +263,7 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
|
|||
case MSG_RESET_CACHES:
|
||||
final SettingsValues settingsValues = latinIme.mSettings.getCurrent();
|
||||
if (latinIme.mInputLogic.retryResetCachesAndReturnSuccess(
|
||||
msg.arg1 == 1 /* tryResumeSuggestions */,
|
||||
msg.arg1 == ARG1_TRUE /* tryResumeSuggestions */,
|
||||
msg.arg2 /* remainingTries */, this /* handler */)) {
|
||||
// If we were able to reset the caches, then we can reload the keyboard.
|
||||
// Otherwise, we'll do it when we can.
|
||||
|
|
@ -267,6 +272,14 @@ 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;
|
||||
|
|
@ -367,6 +380,19 @@ 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;
|
||||
|
|
@ -717,6 +743,7 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
|
|||
if (hasSuggestionStripView()) {
|
||||
mSuggestionStripView.setListener(this, view);
|
||||
}
|
||||
mInputLogic.setTextDecoratorUi(new TextDecoratorUi(this, view));
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
@ -972,9 +999,7 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
|
|||
// @Override
|
||||
public void onUpdateCursorAnchorInfo(final CursorAnchorInfo info) {
|
||||
if (ProductionFlags.ENABLE_CURSOR_ANCHOR_INFO_CALLBACK) {
|
||||
final CursorAnchorInfoCompatWrapper wrapper =
|
||||
CursorAnchorInfoCompatWrapper.fromObject(info);
|
||||
// TODO: Implement here
|
||||
mInputLogic.onUpdateCursorAnchorInfo(CursorAnchorInfoCompatWrapper.fromObject(info));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1178,6 +1203,7 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
|
|||
// In fullscreen mode, no need to have extra space to show the key preview.
|
||||
// If not, we should have extra space above the keyboard to show the key preview.
|
||||
mKeyPreviewBackingView.setVisibility(isFullscreenMode() ? View.GONE : View.VISIBLE);
|
||||
mInputLogic.onUpdateFullscreenMode(isFullscreenMode());
|
||||
}
|
||||
|
||||
private int getCurrentAutoCapsState() {
|
||||
|
|
@ -1221,6 +1247,7 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
|
|||
wordToEdit = word;
|
||||
}
|
||||
mDictionaryFacilitator.addWordToUserDictionary(this /* context */, wordToEdit);
|
||||
mInputLogic.onAddWordToUserDictionary();
|
||||
}
|
||||
|
||||
// Callback for the {@link SuggestionStripView}, to call when the important notice strip is
|
||||
|
|
@ -1409,7 +1436,8 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
|
|||
}
|
||||
|
||||
private void setSuggestedWords(final SuggestedWords suggestedWords) {
|
||||
mInputLogic.setSuggestedWords(suggestedWords);
|
||||
final SettingsValues currentSettingsValues = mSettings.getCurrent();
|
||||
mInputLogic.setSuggestedWords(suggestedWords, currentSettingsValues, mHandler);
|
||||
// TODO: Modify this when we support suggestions with hard keyboard
|
||||
if (!hasSuggestionStripView()) {
|
||||
return;
|
||||
|
|
@ -1418,7 +1446,6 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
|
|||
return;
|
||||
}
|
||||
|
||||
final SettingsValues currentSettingsValues = mSettings.getCurrent();
|
||||
final boolean shouldShowImportantNotice =
|
||||
ImportantNoticeUtils.shouldShowImportantNotice(this);
|
||||
final boolean shouldShowSuggestionCandidates =
|
||||
|
|
|
|||
|
|
@ -17,6 +17,7 @@
|
|||
package com.android.inputmethod.latin.inputlogic;
|
||||
|
||||
import android.graphics.Color;
|
||||
import android.inputmethodservice.InputMethodService;
|
||||
import android.os.SystemClock;
|
||||
import android.text.SpannableString;
|
||||
import android.text.TextUtils;
|
||||
|
|
@ -27,11 +28,14 @@ import android.view.KeyEvent;
|
|||
import android.view.inputmethod.CorrectionInfo;
|
||||
import android.view.inputmethod.EditorInfo;
|
||||
|
||||
import com.android.inputmethod.compat.CursorAnchorInfoCompatWrapper;
|
||||
import com.android.inputmethod.compat.SuggestionSpanUtils;
|
||||
import com.android.inputmethod.event.Event;
|
||||
import com.android.inputmethod.event.InputTransaction;
|
||||
import com.android.inputmethod.keyboard.KeyboardSwitcher;
|
||||
import com.android.inputmethod.keyboard.ProximityInfo;
|
||||
import com.android.inputmethod.keyboard.TextDecorator;
|
||||
import com.android.inputmethod.keyboard.TextDecoratorUiOperator;
|
||||
import com.android.inputmethod.latin.Constants;
|
||||
import com.android.inputmethod.latin.Dictionary;
|
||||
import com.android.inputmethod.latin.DictionaryFacilitator;
|
||||
|
|
@ -81,6 +85,18 @@ public final class InputLogic {
|
|||
public final Suggest mSuggest;
|
||||
private final DictionaryFacilitator mDictionaryFacilitator;
|
||||
|
||||
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);
|
||||
mLatinIME.dismissAddToDictionaryHint();
|
||||
}
|
||||
});
|
||||
|
||||
public LastComposedWord mLastComposedWord = LastComposedWord.NOT_A_COMPOSED_WORD;
|
||||
// This has package visibility so it can be accessed from InputLogicHandler.
|
||||
/* package */ final WordComposer mWordComposer;
|
||||
|
|
@ -303,8 +319,18 @@ public final class InputLogic {
|
|||
return inputTransaction;
|
||||
}
|
||||
|
||||
commitChosenWord(settingsValues, suggestion,
|
||||
LastComposedWord.COMMIT_TYPE_MANUAL_PICK, LastComposedWord.NOT_A_SEPARATOR);
|
||||
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);
|
||||
mConnection.endBatchEdit();
|
||||
// Don't allow cancellation of manual pick
|
||||
mLastComposedWord.deactivate();
|
||||
|
|
@ -312,13 +338,16 @@ public final class InputLogic {
|
|||
mSpaceState = SpaceState.PHANTOM;
|
||||
inputTransaction.requireShiftUpdate(InputTransaction.SHIFT_UPDATE_NOW);
|
||||
|
||||
if (shouldShowAddToDictionaryHint(suggestionInfo)) {
|
||||
if (shouldShowAddToDictionaryHint) {
|
||||
mSuggestionStripViewAccessor.showAddToDictionaryHint(suggestion);
|
||||
} else {
|
||||
// If we're not showing the "Touch again to save", then update the suggestion strip.
|
||||
// That's going to be predictions (or punctuation suggestions), so INPUT_STYLE_NONE.
|
||||
handler.postUpdateSuggestionStrip(SuggestedWords.INPUT_STYLE_NONE);
|
||||
}
|
||||
if (shouldShowAddToDictionaryIndicator) {
|
||||
mTextDecorator.showAddToDictionaryIndicator(suggestionInfo);
|
||||
}
|
||||
return inputTransaction;
|
||||
}
|
||||
|
||||
|
|
@ -386,6 +415,8 @@ public final class InputLogic {
|
|||
|
||||
// The cursor has been moved : we now accept to perform recapitalization
|
||||
mRecapitalizeStatus.enable();
|
||||
// We moved the cursor and need to invalidate the indicator right now.
|
||||
mTextDecorator.reset();
|
||||
// We moved the cursor. If we are touching a word, we need to resume suggestion.
|
||||
mLatinIME.mHandler.postResumeSuggestions(false /* shouldIncludeResumedWordInSuggestions */,
|
||||
true /* shouldDelay */);
|
||||
|
|
@ -561,7 +592,8 @@ public final class InputLogic {
|
|||
|
||||
// TODO: on the long term, this method should become private, but it will be difficult.
|
||||
// Especially, how do we deal with InputMethodService.onDisplayCompletions?
|
||||
public void setSuggestedWords(final SuggestedWords suggestedWords) {
|
||||
public void setSuggestedWords(final SuggestedWords suggestedWords,
|
||||
final SettingsValues settingsValues, final LatinIME.UIHandler handler) {
|
||||
if (SuggestedWords.EMPTY != suggestedWords) {
|
||||
final String autoCorrection;
|
||||
if (suggestedWords.mWillAutoCorrect) {
|
||||
|
|
@ -575,6 +607,38 @@ public final class InputLogic {
|
|||
}
|
||||
mSuggestedWords = suggestedWords;
|
||||
final boolean newAutoCorrectionIndicator = suggestedWords.mWillAutoCorrect;
|
||||
if (shouldShowCommitIndicator(suggestedWords, settingsValues)) {
|
||||
// typedWordInfo is never null here.
|
||||
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;
|
||||
}
|
||||
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
|
||||
&& mWordComposer.isComposingWord()) {
|
||||
|
|
@ -756,6 +820,8 @@ public final class InputLogic {
|
|||
if (!mWordComposer.isComposingWord() &&
|
||||
mSuggestionStripViewAccessor.isShowingAddToDictionaryHint()) {
|
||||
mSuggestionStripViewAccessor.dismissAddToDictionaryHint();
|
||||
mConnection.removeBackgroundColorFromHighlightedTextIfNecessary();
|
||||
mTextDecorator.reset();
|
||||
}
|
||||
|
||||
final int codePoint = event.mCodePoint;
|
||||
|
|
@ -2108,4 +2174,74 @@ public final class InputLogic {
|
|||
settingsValues.mAutoCorrectionEnabledPerUserSettings,
|
||||
inputStyle, sequenceNumber, callback);
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Following methods are tentatively placed in this class for the integration with
|
||||
// TextDecorator.
|
||||
// TODO: Decouple things that are not related to the input logic.
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/**
|
||||
* Sets the UI operator for {@link TextDecorator}.
|
||||
* @param uiOperator the UI operator which should be associated with {@link TextDecorator}.
|
||||
*/
|
||||
public void setTextDecoratorUi(final TextDecoratorUiOperator uiOperator) {
|
||||
mTextDecorator.setUiOperator(uiOperator);
|
||||
}
|
||||
|
||||
/**
|
||||
* Must be called from {@link InputMethodService#onUpdateCursorAnchorInfo} is called.
|
||||
* @param info The wrapper object with which we can access cursor/anchor info.
|
||||
*/
|
||||
public void onUpdateCursorAnchorInfo(final CursorAnchorInfoCompatWrapper info) {
|
||||
mTextDecorator.onUpdateCursorAnchorInfo(info);
|
||||
}
|
||||
|
||||
/**
|
||||
* Must be called when {@link InputMethodService#updateFullscreenMode} is called.
|
||||
* @param isFullscreen {@code true} if the input method is in full-screen mode.
|
||||
*/
|
||||
public void onUpdateFullscreenMode(final boolean isFullscreen) {
|
||||
mTextDecorator.notifyFullScreenMode(isFullscreen);
|
||||
}
|
||||
|
||||
/**
|
||||
* Must be called from {@link LatinIME#addWordToUserDictionary(String)}.
|
||||
*/
|
||||
public void onAddWordToUserDictionary() {
|
||||
mConnection.removeBackgroundColorFromHighlightedTextIfNecessary();
|
||||
mTextDecorator.reset();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns whether the commit indicator should be shown or not.
|
||||
* @param suggestedWords the suggested word that is being displayed.
|
||||
* @param settingsValues the current settings value.
|
||||
* @return {@code true} if the commit indicator should be shown.
|
||||
*/
|
||||
private boolean shouldShowCommitIndicator(final SuggestedWords suggestedWords,
|
||||
final SettingsValues settingsValues) {
|
||||
if (!settingsValues.mShouldShowUiToAcceptTypedWord) {
|
||||
return false;
|
||||
}
|
||||
final SuggestedWordInfo typedWordInfo = suggestedWords.getTypedWordInfoOrNull();
|
||||
if (typedWordInfo == null) {
|
||||
return false;
|
||||
}
|
||||
if (suggestedWords.mInputStyle != SuggestedWords.INPUT_STYLE_TYPING){
|
||||
return false;
|
||||
}
|
||||
if (settingsValues.mShowCommitIndicatorOnlyForAutoCorrection
|
||||
&& !suggestedWords.mWillAutoCorrect) {
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -95,6 +95,12 @@ public final class SettingsValues {
|
|||
public final int[] mAdditionalFeaturesSettingValues =
|
||||
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;
|
||||
public final int mKeyPreviewShowUpDuration;
|
||||
|
|
@ -163,6 +169,14 @@ 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);
|
||||
mKeyPreviewShowUpDuration = Settings.readKeyPreviewAnimationDuration(
|
||||
prefs, DebugSettings.PREF_KEY_PREVIEW_SHOW_UP_DURATION,
|
||||
|
|
@ -396,6 +410,14 @@ 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 = ");
|
||||
sb.append("" + mIsInternal);
|
||||
sb.append("\n mKeyPreviewShowUpDuration = ");
|
||||
|
|
|
|||
Loading…
Reference in New Issue