Put SuggestionSpan at commitText (1fef530e) · Commits · e / os / android_packages_inputmethods_LatinIME

java/src/com/android/inputmethod/compat/CompatUtils.java

+22 −26

Original line number	Diff line number	Diff line
		@@ -22,7 +22,6 @@ import android.util.Log;

		import java.lang.reflect.Constructor;
		import java.lang.reflect.Field;
		import java.lang.reflect.InvocationTargetException;
		import java.lang.reflect.Method;
		import java.util.ArrayList;
		import java.util.List;
		@@ -74,23 +73,22 @@ public class CompatUtils {
		return targetClass.getMethod(name, parameterTypes);
		} catch (SecurityException e) {
		// ignore
		return null;
		} catch (NoSuchMethodException e) {
		// ignore
		return null;
		}
		return null;
		}

		public static Field getField(Class<?> targetClass, String name) {
		if (targetClass == null \|\| TextUtils.isEmpty(name)) return null;
		try {
		return targetClass.getField(name);
		} catch (SecurityException e) {
		// ignore
		return null;
		} catch (NoSuchFieldException e) {
		// ignore
		return null;
		}
		return null;
		}

		public static Constructor<?> getConstructor(Class<?> targetClass, Class<?>[] types) {
		@@ -99,11 +97,20 @@ public class CompatUtils {
		return targetClass.getConstructor(types);
		} catch (SecurityException e) {
		// ignore
		return null;
		} catch (NoSuchMethodException e) {
		// ignore
		}
		return null;
		}

		public static Object newInstance(Constructor<?> constructor, Object[] args) {
		if (constructor == null) return null;
		try {
		return constructor.newInstance(args);
		} catch (Exception e) {
		Log.e(TAG, "Exception in newInstance: " + e.getClass().getSimpleName());
		}
		return null;
		}

		public static Object invoke(
		@@ -111,39 +118,28 @@ public class CompatUtils {
		if (method == null) return defaultValue;
		try {
		return method.invoke(receiver, args);
		} catch (IllegalArgumentException e) {
		Log.e(TAG, "Exception in invoke: IllegalArgumentException");
		return defaultValue;
		} catch (IllegalAccessException e) {
		Log.e(TAG, "Exception in invoke: IllegalAccessException");
		return defaultValue;
		} catch (InvocationTargetException e) {
		Log.e(TAG, "Exception in invoke: IllegalTargetException");
		return defaultValue;
		} catch (Exception e) {
		Log.e(TAG, "Exception in invoke: " + e.getClass().getSimpleName());
		}
		return defaultValue;
		}

		public static Object getFieldValue(Object receiver, Object defaultValue, Field field) {
		if (field == null) return defaultValue;
		try {
		return field.get(receiver);
		} catch (IllegalArgumentException e) {
		Log.e(TAG, "Exception in getFieldValue: IllegalArgumentException");
		return defaultValue;
		} catch (IllegalAccessException e) {
		Log.e(TAG, "Exception in getFieldValue: IllegalAccessException");
		return defaultValue;
		} catch (Exception e) {
		Log.e(TAG, "Exception in getFieldValue: " + e.getClass().getSimpleName());
		}
		return defaultValue;
		}

		public static void setFieldValue(Object receiver, Field field, Object value) {
		if (field == null) return;
		try {
		field.set(receiver, value);
		} catch (IllegalArgumentException e) {
		Log.e(TAG, "Exception in setFieldValue: IllegalArgumentException");
		} catch (IllegalAccessException e) {
		Log.e(TAG, "Exception in setFieldValue: IllegalAccessException");
		} catch (Exception e) {
		Log.e(TAG, "Exception in setFieldValue: " + e.getClass().getSimpleName());
		}
		}

java/src/com/android/inputmethod/compat/InputConnectionCompatUtils.java

+2 −13

Original line number	Diff line number	Diff line
		@@ -18,15 +18,12 @@ package com.android.inputmethod.compat;

		import com.android.inputmethod.latin.EditingUtils.SelectedWord;

		import android.util.Log;
		import android.view.inputmethod.InputConnection;

		import java.lang.reflect.Constructor;
		import java.lang.reflect.InvocationTargetException;
		import java.lang.reflect.Method;

		public class InputConnectionCompatUtils {
		private static final String TAG = InputConnectionCompatUtils.class.getSimpleName();
		private static final Class<?> CLASS_CorrectionInfo = CompatUtils
		.getClass("android.view.inputmethod.CorrectionInfo");
		private static final Class<?>[] INPUT_TYPE_CorrectionInfo = new Class<?>[] { int.class,
		@@ -53,18 +50,10 @@ public class InputConnectionCompatUtils {
		return;
		}
		Object[] args = { offset, oldText, newText };
		try {
		Object correctionInfo = CONSTRUCTOR_CorrectionInfo.newInstance(args);
		Object correctionInfo = CompatUtils.newInstance(CONSTRUCTOR_CorrectionInfo, args);
		if (correctionInfo != null) {
		CompatUtils.invoke(ic, null, METHOD_InputConnection_commitCorrection,
		correctionInfo);
		} catch (IllegalArgumentException e) {
		Log.e(TAG, "Error in commitCorrection: IllegalArgumentException");
		} catch (InstantiationException e) {
		Log.e(TAG, "Error in commitCorrection: InstantiationException");
		} catch (IllegalAccessException e) {
		Log.e(TAG, "Error in commitCorrection: IllegalAccessException");
		} catch (InvocationTargetException e) {
		Log.e(TAG, "Error in commitCorrection: InvocationTargetException");
		}
		}

java/src/com/android/inputmethod/compat/SuggestionSpanUtils.java

0 → 100644

+64 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2011 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.compat;

		import com.android.inputmethod.latin.SuggestedWords;

		import android.content.Context;
		import android.text.Spannable;
		import android.text.SpannableString;
		import android.text.Spanned;

		import java.lang.reflect.Constructor;

		public class SuggestionSpanUtils {
		private static final Class<?> CLASS_SuggestionSpan =
		CompatUtils.getClass("android.text.style.SuggestionSpan");
		private static final Class<?>[] INPUT_TYPE_SuggestionSpan = new Class<?>[] {
		Context.class, String[].class, int.class
		};
		private static final Constructor<?> CONSTRUCTOR_SuggestionSpan =
		CompatUtils.getConstructor(CLASS_SuggestionSpan, INPUT_TYPE_SuggestionSpan);

		public static CharSequence getTextWithSuggestionSpan(
		Context context, CharSequence suggestion, SuggestedWords suggestedWords) {
		if (CONSTRUCTOR_SuggestionSpan == null \|\| suggestedWords == null
		\|\| suggestedWords.size() == 0) {
		return suggestion;
		}

		final Spannable spannable;
		if (suggestion instanceof Spannable) {
		spannable = (Spannable) suggestion;
		} else {
		spannable = new SpannableString(suggestion);
		}
		// TODO: Use SUGGESTIONS_MAX_SIZE instead of 5.
		final int N = Math.min(5, suggestedWords.size());
		final String[] suggestionsArray = new String[N];
		for (int i = 0; i < N; ++i) {
		suggestionsArray[i] = suggestedWords.getWord(i).toString();
		}
		final Object[] args = {context, suggestionsArray, 0};
		final Object ss = CompatUtils.newInstance(CONSTRUCTOR_SuggestionSpan, args);
		if (ss == null) {
		return suggestion;
		}
		spannable.setSpan(ss, 0, suggestion.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
		return spannable;
		}
		}

java/src/com/android/inputmethod/latin/LatinIME.java

+10 −7

Original line number	Diff line number	Diff line
		@@ -59,6 +59,7 @@ import com.android.inputmethod.compat.InputConnectionCompatUtils;
		import com.android.inputmethod.compat.InputMethodManagerCompatWrapper;
		import com.android.inputmethod.compat.InputMethodServiceCompatWrapper;
		import com.android.inputmethod.compat.InputTypeCompatUtils;
		import com.android.inputmethod.compat.SuggestionSpanUtils;
		import com.android.inputmethod.deprecated.LanguageSwitcherProxy;
		import com.android.inputmethod.deprecated.VoiceProxy;
		import com.android.inputmethod.deprecated.recorrection.Recorrection;
		@@ -1508,7 +1509,7 @@ public class LatinIME extends InputMethodServiceCompatWrapper implements Keyboar
		if (mBestWord != null && mBestWord.length() > 0) {
		TextEntryState.acceptedDefault(mWord.getTypedWord(), mBestWord, separatorCode);
		mJustAccepted = true;
		pickSuggestion(mBestWord);
		commitBestWord(mBestWord);
		// Add the word to the auto dictionary if it's not a known word
		addToAutoAndUserBigramDictionaries(mBestWord, AutoDictionary.FREQUENCY_FOR_TYPED);
		return true;
		@@ -1575,7 +1576,7 @@ public class LatinIME extends InputMethodServiceCompatWrapper implements Keyboar
		mWord.reset();
		}
		mJustAccepted = true;
		pickSuggestion(suggestion);
		commitBestWord(suggestion);
		// Add the word to the auto dictionary if it's not a known word
		if (index == 0) {
		addToAutoAndUserBigramDictionaries(suggestion, AutoDictionary.FREQUENCY_FOR_PICKED);
		@@ -1632,18 +1633,20 @@ public class LatinIME extends InputMethodServiceCompatWrapper implements Keyboar
		* @param suggestion the suggestion picked by the user to be committed to
		* the text field
		*/
		private void pickSuggestion(CharSequence suggestion) {
		private void commitBestWord(CharSequence bestWord) {
		KeyboardSwitcher switcher = mKeyboardSwitcher;
		if (!switcher.isKeyboardAvailable())
		return;
		InputConnection ic = getCurrentInputConnection();
		if (ic != null) {
		mVoiceProxy.rememberReplacedWord(suggestion, mSettingsValues.mWordSeparators);
		ic.commitText(suggestion, 1);
		mVoiceProxy.rememberReplacedWord(bestWord, mSettingsValues.mWordSeparators);
		SuggestedWords suggestedWords = mCandidateView.getSuggestions();
		ic.commitText(SuggestionSpanUtils.getTextWithSuggestionSpan(
		this, bestWord, suggestedWords), 1);
		}
		mRecorrection.saveRecorrectionSuggestion(mWord, suggestion);
		mRecorrection.saveRecorrectionSuggestion(mWord, bestWord);
		mHasUncommittedTypedChars = false;
		mCommittedLength = suggestion.length();
		mCommittedLength = bestWord.length();
		}

		private static final WordComposer sEmptyWordComposer = new WordComposer();