diff options
Diffstat (limited to 'java/src')
17 files changed, 326 insertions, 199 deletions
diff --git a/java/src/com/android/inputmethod/compat/InputMethodManagerCompatWrapper.java b/java/src/com/android/inputmethod/compat/InputMethodManagerCompatWrapper.java index ffed8202d..4bc82d2ec 100644 --- a/java/src/com/android/inputmethod/compat/InputMethodManagerCompatWrapper.java +++ b/java/src/com/android/inputmethod/compat/InputMethodManagerCompatWrapper.java @@ -17,7 +17,6 @@ package com.android.inputmethod.compat; import android.content.Context; -import android.inputmethodservice.InputMethodService; import android.os.IBinder; import android.util.Log; import android.view.inputmethod.InputMethodInfo; @@ -50,9 +49,12 @@ public class InputMethodManagerCompatWrapper { return sInstance; } - public static void init(InputMethodService service) { - sInstance.mImm = (InputMethodManager) service.getSystemService( - Context.INPUT_METHOD_SERVICE); + public static void init(Context context) { + sInstance.mImm = (InputMethodManager)context.getSystemService(Context.INPUT_METHOD_SERVICE); + } + + public void setAdditionalInputMethodSubtypes(String imiId, InputMethodSubtype[] subtypes) { + mImm.setAdditionalInputMethodSubtypes(imiId, subtypes); } public InputMethodSubtype getCurrentInputMethodSubtype() { @@ -86,6 +88,11 @@ public class InputMethodManagerCompatWrapper { onlyCurrentIme); } + public List<InputMethodInfo> getInputMethodList() { + if (mImm == null) return null; + return mImm.getInputMethodList(); + } + public List<InputMethodInfo> getEnabledInputMethodList() { if (mImm == null) return null; return mImm.getEnabledInputMethodList(); diff --git a/java/src/com/android/inputmethod/compat/SuggestionSpanUtils.java b/java/src/com/android/inputmethod/compat/SuggestionSpanUtils.java index 43c19d7eb..d97989d9c 100644 --- a/java/src/com/android/inputmethod/compat/SuggestionSpanUtils.java +++ b/java/src/com/android/inputmethod/compat/SuggestionSpanUtils.java @@ -104,8 +104,9 @@ public class SuggestionSpanUtils { } public static CharSequence getTextWithSuggestionSpan(Context context, - CharSequence pickedWord, SuggestedWords suggestedWords) { - if (TextUtils.isEmpty(pickedWord) || CONSTRUCTOR_SuggestionSpan == null + CharSequence pickedWord, SuggestedWords suggestedWords, boolean dictionaryAvailable) { + if (!dictionaryAvailable || TextUtils.isEmpty(pickedWord) + || CONSTRUCTOR_SuggestionSpan == null || suggestedWords == null || suggestedWords.size() == 0 || OBJ_SUGGESTIONS_MAX_SIZE == null) { return pickedWord; diff --git a/java/src/com/android/inputmethod/keyboard/Keyboard.java b/java/src/com/android/inputmethod/keyboard/Keyboard.java index 58225e95d..d54acf715 100644 --- a/java/src/com/android/inputmethod/keyboard/Keyboard.java +++ b/java/src/com/android/inputmethod/keyboard/Keyboard.java @@ -793,7 +793,7 @@ public class Keyboard { } }; // Null means the current system locale. - final Locale locale = language.equals(SubtypeLocale.NO_LANGUAGE) + final Locale locale = SubtypeLocale.isNoLanguage(params.mId.mSubtype) ? null : params.mId.mLocale; job.runInLocale(mResources, locale); diff --git a/java/src/com/android/inputmethod/keyboard/KeyboardId.java b/java/src/com/android/inputmethod/keyboard/KeyboardId.java index e35081867..b7eb8f69c 100644 --- a/java/src/com/android/inputmethod/keyboard/KeyboardId.java +++ b/java/src/com/android/inputmethod/keyboard/KeyboardId.java @@ -19,9 +19,12 @@ package com.android.inputmethod.keyboard; import android.text.InputType; import android.text.TextUtils; import android.view.inputmethod.EditorInfo; +import android.view.inputmethod.InputMethodSubtype; import com.android.inputmethod.compat.EditorInfoCompatUtils; import com.android.inputmethod.latin.InputTypeUtils; +import com.android.inputmethod.latin.LatinIME; +import com.android.inputmethod.latin.SubtypeLocale; import java.util.Arrays; import java.util.Locale; @@ -53,6 +56,7 @@ public class KeyboardId { private static final int IME_ACTION_CUSTOM_LABEL = EditorInfo.IME_MASK_ACTION + 1; + public final InputMethodSubtype mSubtype; public final Locale mLocale; public final int mOrientation; public final int mWidth; @@ -67,10 +71,11 @@ public class KeyboardId { private final int mHashCode; - public KeyboardId(int elementId, Locale locale, int orientation, int width, int mode, - EditorInfo editorInfo, boolean clobberSettingsKey, boolean shortcutKeyEnabled, + public KeyboardId(int elementId, InputMethodSubtype subtype, int orientation, int width, + int mode, EditorInfo editorInfo, boolean clobberSettingsKey, boolean shortcutKeyEnabled, boolean hasShortcutKey, boolean languageSwitchKeyEnabled) { - mLocale = locale; + mSubtype = subtype; + mLocale = SubtypeLocale.getSubtypeLocale(subtype); mOrientation = orientation; mWidth = width; mMode = mode; @@ -102,7 +107,7 @@ public class KeyboardId { id.mCustomActionLabel, id.navigateNext(), id.navigatePrevious(), - id.mLocale + id.mSubtype }); } @@ -123,7 +128,7 @@ public class KeyboardId { && TextUtils.equals(other.mCustomActionLabel, mCustomActionLabel) && other.navigateNext() == navigateNext() && other.navigatePrevious() == navigatePrevious() - && other.mLocale.equals(mLocale); + && other.mSubtype.equals(mSubtype); } public boolean isAlphabetKeyboard() { @@ -176,9 +181,10 @@ public class KeyboardId { @Override public String toString() { - return String.format("[%s %s %s%d %s %s %s%s%s%s%s%s%s%s]", + return String.format("[%s %s:%s %s%d %s %s %s%s%s%s%s%s%s%s]", elementIdToName(mElementId), mLocale, + mSubtype.getExtraValueOf(LatinIME.SUBTYPE_EXTRA_VALUE_KEYBOARD_LAYOUT_SET), (mOrientation == 1 ? "port" : "land"), mWidth, modeName(mMode), imeAction(), diff --git a/java/src/com/android/inputmethod/keyboard/KeyboardLayoutSet.java b/java/src/com/android/inputmethod/keyboard/KeyboardLayoutSet.java index 803a2948e..35209e0ad 100644 --- a/java/src/com/android/inputmethod/keyboard/KeyboardLayoutSet.java +++ b/java/src/com/android/inputmethod/keyboard/KeyboardLayoutSet.java @@ -32,7 +32,6 @@ import com.android.inputmethod.keyboard.KeyboardLayoutSet.Params.ElementParams; import com.android.inputmethod.latin.InputTypeUtils; import com.android.inputmethod.latin.LatinIME; import com.android.inputmethod.latin.LatinImeLogger; -import com.android.inputmethod.latin.LocaleUtils; import com.android.inputmethod.latin.R; import com.android.inputmethod.latin.StringUtils; import com.android.inputmethod.latin.SubtypeLocale; @@ -45,7 +44,6 @@ import org.xmlpull.v1.XmlPullParserException; import java.io.IOException; import java.lang.ref.SoftReference; import java.util.HashMap; -import java.util.Locale; /** * This class represents a set of keyboard layouts. Each of them represents a different keyboard @@ -61,8 +59,6 @@ public class KeyboardLayoutSet { private static final String TAG_KEYBOARD_SET = "KeyboardLayoutSet"; private static final String TAG_ELEMENT = "Element"; - private static final String DEFAULT_KEYBOARD_LAYOUT_SET = "qwerty"; - private static final char KEYBOARD_LAYOUT_SET_LOCALE_DELIMITER = ':'; private static final String KEYBOARD_LAYOUT_SET_RESOURCE_PREFIX = "keyboard_layout_set_"; private final Context mContext; @@ -112,7 +108,7 @@ public class KeyboardLayoutSet { boolean mVoiceKeyOnMain; boolean mNoSettingsKey; boolean mLanguageSwitchKeyEnabled; - Locale mLocale; + InputMethodSubtype mSubtype; int mOrientation; int mWidth; // KeyboardLayoutSet element id to element's parameters map. @@ -164,14 +160,13 @@ public class KeyboardLayoutSet { } final KeyboardId id = getKeyboardId(keyboardLayoutSetElementId); try { - return getKeyboard(mContext, elementParams, id); + return getKeyboard(elementParams, id); } catch (RuntimeException e) { throw new KeyboardLayoutSetException(e, id); } } - private Keyboard getKeyboard(Context context, ElementParams elementParams, - final KeyboardId id) { + private Keyboard getKeyboard(ElementParams elementParams, final KeyboardId id) { final SoftReference<Keyboard> ref = sKeyboardCache.get(id); Keyboard keyboard = (ref == null) ? null : ref.get(); if (keyboard == null) { @@ -207,38 +202,14 @@ public class KeyboardLayoutSet { final Params params = mParams; final boolean isSymbols = (keyboardLayoutSetElementId == KeyboardId.ELEMENT_SYMBOLS || keyboardLayoutSetElementId == KeyboardId.ELEMENT_SYMBOLS_SHIFTED); - final boolean noLanguage = params.mLocale.getLanguage().equals(SubtypeLocale.NO_LANGUAGE); + final boolean noLanguage = SubtypeLocale.isNoLanguage(params.mSubtype); final boolean voiceKeyEnabled = params.mVoiceKeyEnabled && !noLanguage; final boolean hasShortcutKey = voiceKeyEnabled && (isSymbols != params.mVoiceKeyOnMain); - return new KeyboardId(keyboardLayoutSetElementId, params.mLocale, params.mOrientation, + return new KeyboardId(keyboardLayoutSetElementId, params.mSubtype, params.mOrientation, params.mWidth, params.mMode, params.mEditorInfo, params.mNoSettingsKey, voiceKeyEnabled, hasShortcutKey, params.mLanguageSwitchKeyEnabled); } - private static String getKeyboardLayoutSetName(InputMethodSubtype subtype) { - final String keyboardLayoutSet = subtype.getExtraValueOf( - LatinIME.SUBTYPE_EXTRA_VALUE_KEYBOARD_LAYOUT_SET); - // TODO: Remove this null check when InputMethodManager.getCurrentInputMethodSubtype is - // fixed. - if (keyboardLayoutSet == null) return DEFAULT_KEYBOARD_LAYOUT_SET; - final int pos = keyboardLayoutSet.indexOf(KEYBOARD_LAYOUT_SET_LOCALE_DELIMITER); - return (pos > 0) ? keyboardLayoutSet.substring(0, pos) : keyboardLayoutSet; - } - - public static String getKeyboardLayoutSetLocaleString(InputMethodSubtype subtype) { - final String keyboardLayoutSet = subtype.getExtraValueOf( - LatinIME.SUBTYPE_EXTRA_VALUE_KEYBOARD_LAYOUT_SET); - // TODO: Remove this null check when InputMethodManager.getCurrentInputMethodSubtype is - // fixed. - if (keyboardLayoutSet == null) return subtype.getLocale(); - final int pos = keyboardLayoutSet.indexOf(KEYBOARD_LAYOUT_SET_LOCALE_DELIMITER); - return (pos > 0) ? keyboardLayoutSet.substring(pos + 1) : subtype.getLocale(); - } - - public static Locale getKeyboardLayoutSetLocale(InputMethodSubtype subtype) { - return LocaleUtils.constructLocaleFromString(getKeyboardLayoutSetLocaleString(subtype)); - } - public static class Builder { private final Context mContext; private final String mPackageName; @@ -279,9 +250,9 @@ public class KeyboardLayoutSet { final InputMethodSubtype keyboardSubtype = (forceAscii && !asciiCapable) ? SubtypeSwitcher.getInstance().getNoLanguageSubtype() : subtype; - mParams.mLocale = getKeyboardLayoutSetLocale(keyboardSubtype); + mParams.mSubtype = keyboardSubtype; mParams.mKeyboardLayoutSetName = KEYBOARD_LAYOUT_SET_RESOURCE_PREFIX - + getKeyboardLayoutSetName(keyboardSubtype); + + SubtypeLocale.getKeyboardLayoutSetName(keyboardSubtype); return this; } @@ -306,7 +277,7 @@ public class KeyboardLayoutSet { public KeyboardLayoutSet build() { if (mParams.mOrientation == Configuration.ORIENTATION_UNDEFINED) throw new RuntimeException("Screen geometry is not specified"); - if (mParams.mLocale == null) + if (mParams.mSubtype == null) throw new RuntimeException("KeyboardLayoutSet subtype is not specified"); final String packageName = mResources.getResourcePackageName( R.xml.keyboard_layout_set_qwerty); diff --git a/java/src/com/android/inputmethod/keyboard/LatinKeyboardView.java b/java/src/com/android/inputmethod/keyboard/LatinKeyboardView.java index 7fadb3b8a..341d9bc7a 100644 --- a/java/src/com/android/inputmethod/keyboard/LatinKeyboardView.java +++ b/java/src/com/android/inputmethod/keyboard/LatinKeyboardView.java @@ -35,6 +35,7 @@ import android.view.MotionEvent; import android.view.View; import android.view.ViewConfiguration; import android.view.ViewGroup; +import android.view.inputmethod.InputMethodSubtype; import android.widget.PopupWindow; import com.android.inputmethod.accessibility.AccessibilityUtils; @@ -52,7 +53,6 @@ import com.android.inputmethod.latin.Utils; import com.android.inputmethod.latin.Utils.UsabilityStudyLogUtils; import com.android.inputmethod.latin.define.ProductionFlag; -import java.util.Locale; import java.util.WeakHashMap; /** @@ -80,7 +80,6 @@ public class LatinKeyboardView extends KeyboardView implements PointerTracker.Ke private ObjectAnimator mLanguageOnSpacebarFadeoutAnimator; private static final int ALPHA_OPAQUE = 255; private boolean mNeedsToDisplayLanguage; - private Locale mSpacebarLocale; private int mLanguageOnSpacebarAnimAlpha = ALPHA_OPAQUE; private final float mSpacebarTextRatio; private float mSpacebarTextSize; @@ -468,7 +467,6 @@ public class LatinKeyboardView extends KeyboardView implements PointerTracker.Ke mSpaceIcon = (mSpaceKey != null) ? mSpaceKey.getIcon(keyboard.mIconsSet) : null; final int keyHeight = keyboard.mMostCommonKeyHeight - keyboard.mVerticalGap; mSpacebarTextSize = keyHeight * mSpacebarTextRatio; - mSpacebarLocale = keyboard.mId.mLocale; } /** @@ -904,12 +902,12 @@ public class LatinKeyboardView extends KeyboardView implements PointerTracker.Ke } // Layout locale language name on spacebar. - private String layoutLanguageOnSpacebar(Paint paint, Locale locale, int width, + private String layoutLanguageOnSpacebar(Paint paint, InputMethodSubtype subtype, int width, float origTextSize) { paint.setTextAlign(Align.CENTER); paint.setTypeface(Typeface.DEFAULT); // Estimate appropriate language name text size to fit in maxTextWidth. - String language = SubtypeLocale.getFullDisplayName(locale); + String language = SubtypeLocale.getFullDisplayName(subtype); int textWidth = getTextWidth(paint, language, origTextSize); // Assuming text width and text size are proportional to each other. float textSize = origTextSize * Math.min(width / textWidth, 1.0f); @@ -921,7 +919,7 @@ public class LatinKeyboardView extends KeyboardView implements PointerTracker.Ke final boolean useShortName; if (useMiddleName) { - language = SubtypeLocale.getMiddleDisplayName(locale); + language = SubtypeLocale.getMiddleDisplayName(subtype); textWidth = getTextWidth(paint, language, origTextSize); textSize = origTextSize * Math.min(width / textWidth, 1.0f); useShortName = (textSize / origTextSize < MINIMUM_SCALE_OF_LANGUAGE_NAME) @@ -931,7 +929,7 @@ public class LatinKeyboardView extends KeyboardView implements PointerTracker.Ke } if (useShortName) { - language = SubtypeLocale.getShortDisplayName(locale); + language = SubtypeLocale.getShortDisplayName(subtype); textWidth = getTextWidth(paint, language, origTextSize); textSize = origTextSize * Math.min(width / textWidth, 1.0f); } @@ -944,10 +942,10 @@ public class LatinKeyboardView extends KeyboardView implements PointerTracker.Ke final int width = key.mWidth; final int height = key.mHeight; - // If input subtypes are explicitly selected. + // If input language are explicitly selected. if (mNeedsToDisplayLanguage) { - final String language = layoutLanguageOnSpacebar(paint, mSpacebarLocale, width, - mSpacebarTextSize); + final String language = layoutLanguageOnSpacebar( + paint, getKeyboard().mId.mSubtype, width, mSpacebarTextSize); // Draw language text with shadow // In case there is no space icon, we will place the language text at the center of // spacebar. diff --git a/java/src/com/android/inputmethod/keyboard/PointerTracker.java b/java/src/com/android/inputmethod/keyboard/PointerTracker.java index 24ab54730..37d9b6ac7 100644 --- a/java/src/com/android/inputmethod/keyboard/PointerTracker.java +++ b/java/src/com/android/inputmethod/keyboard/PointerTracker.java @@ -248,6 +248,9 @@ public class PointerTracker { mListener.onPressKey(key.mCode); final boolean keyboardLayoutHasBeenChanged = mKeyboardLayoutHasBeenChanged; mKeyboardLayoutHasBeenChanged = false; + if (!key.altCodeWhileTyping() && !key.isModifier()) { + mTimerProxy.startTypingStateTimer(); + } return keyboardLayoutHasBeenChanged; } return false; @@ -279,9 +282,6 @@ public class PointerTracker { } else if (code != Keyboard.CODE_UNSPECIFIED) { mListener.onCodeInput(code, x, y); } - if (!key.altCodeWhileTyping() && !key.isModifier()) { - mTimerProxy.startTypingStateTimer(); - } } } @@ -734,6 +734,9 @@ public class PointerTracker { public void onRepeatKey(Key key) { if (key != null) { detectAndSendKey(key, key.mX, key.mY); + if (!key.altCodeWhileTyping() && !key.isModifier()) { + mTimerProxy.startTypingStateTimer(); + } } } diff --git a/java/src/com/android/inputmethod/latin/AdditionalSubtype.java b/java/src/com/android/inputmethod/latin/AdditionalSubtype.java new file mode 100644 index 000000000..deb247860 --- /dev/null +++ b/java/src/com/android/inputmethod/latin/AdditionalSubtype.java @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2012 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.latin; + +import android.view.inputmethod.InputMethodSubtype; + +import java.util.HashMap; +import java.util.Locale; + +public class AdditionalSubtype { + public static final String QWERTY = "qwerty"; + public static final String QWERTZ = "qwertz"; + public static final String AZERTY = "azerty"; + + private static final String SUBTYPE_MODE_KEYBOARD = "keyboard"; + private static final String SUBTYPE_EXTRA_VALUE_IS_ADDITIONAL_SUBTYPE = "isAdditionalSubtype"; + + // Keyboard layout to subtype name resource id map. + private static final HashMap<String, Integer> sKeyboardLayoutToNameIdsMap = + new HashMap<String, Integer>(); + + static { + sKeyboardLayoutToNameIdsMap.put(QWERTY, R.string.subtype_generic_qwerty); + sKeyboardLayoutToNameIdsMap.put(QWERTZ, R.string.subtype_generic_qwertz); + sKeyboardLayoutToNameIdsMap.put(AZERTY, R.string.subtype_generic_azerty); + } + + public static boolean isAdditionalSubtype(InputMethodSubtype subtype) { + return subtype.containsExtraValueKey(SUBTYPE_EXTRA_VALUE_IS_ADDITIONAL_SUBTYPE); + } + + public static InputMethodSubtype createAddtionalSubtype( + Locale locale, String keyboardLayoutSet) { + final String extraValue = String.format( + "%s=%s,%s", LatinIME.SUBTYPE_EXTRA_VALUE_KEYBOARD_LAYOUT_SET, keyboardLayoutSet, + SUBTYPE_EXTRA_VALUE_IS_ADDITIONAL_SUBTYPE); + Integer nameId = sKeyboardLayoutToNameIdsMap.get(keyboardLayoutSet); + if (nameId == null) nameId = R.string.subtype_generic; + return new InputMethodSubtype(nameId, R.drawable.ic_subtype_keyboard, + locale.toString(), SUBTYPE_MODE_KEYBOARD, extraValue, false, false); + } +} diff --git a/java/src/com/android/inputmethod/latin/DebugSettings.java b/java/src/com/android/inputmethod/latin/DebugSettings.java index 23d63b42a..af7649863 100644 --- a/java/src/com/android/inputmethod/latin/DebugSettings.java +++ b/java/src/com/android/inputmethod/latin/DebugSettings.java @@ -16,18 +16,19 @@ package com.android.inputmethod.latin; +import android.content.Context; import android.content.SharedPreferences; import android.content.pm.PackageInfo; import android.content.pm.PackageManager.NameNotFoundException; import android.os.Bundle; import android.os.Process; import android.preference.CheckBoxPreference; -import android.preference.PreferenceActivity; +import android.preference.PreferenceFragment; import android.util.Log; import com.android.inputmethod.keyboard.KeyboardSwitcher; -public class DebugSettings extends PreferenceActivity +public class DebugSettings extends PreferenceFragment implements SharedPreferences.OnSharedPreferenceChangeListener { private static final String TAG = DebugSettings.class.getSimpleName(); @@ -38,7 +39,7 @@ public class DebugSettings extends PreferenceActivity private CheckBoxPreference mDebugMode; @Override - protected void onCreate(Bundle icicle) { + public void onCreate(Bundle icicle) { super.onCreate(icicle); addPreferencesFromResource(R.xml.prefs_for_debug); SharedPreferences prefs = getPreferenceManager().getSharedPreferences(); @@ -50,7 +51,7 @@ public class DebugSettings extends PreferenceActivity } @Override - protected void onStop() { + public void onStop() { super.onStop(); if (mServiceNeedsRestart) Process.killProcess(Process.myPid()); } @@ -76,7 +77,9 @@ public class DebugSettings extends PreferenceActivity boolean isDebugMode = mDebugMode.isChecked(); String version = ""; try { - PackageInfo info = getPackageManager().getPackageInfo(getPackageName(), 0); + final Context context = getActivity(); + final String packageName = context.getPackageName(); + PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0); version = "Version " + info.versionName; } catch (NameNotFoundException e) { Log.e(TAG, "Could not find version info."); diff --git a/java/src/com/android/inputmethod/latin/DebugSettingsActivity.java b/java/src/com/android/inputmethod/latin/DebugSettingsActivity.java new file mode 100644 index 000000000..cde20606a --- /dev/null +++ b/java/src/com/android/inputmethod/latin/DebugSettingsActivity.java @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2012 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.latin; + +import android.content.Intent; +import android.os.Bundle; +import android.preference.PreferenceActivity; + +public class DebugSettingsActivity extends PreferenceActivity { + @Override + public Intent getIntent() { + final Intent modIntent = new Intent(super.getIntent()); + modIntent.putExtra(EXTRA_SHOW_FRAGMENT, DebugSettings.class.getName()); + return modIntent; + } + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setTitle(R.string.english_ime_debug_settings); + } +} diff --git a/java/src/com/android/inputmethod/latin/LatinIME.java b/java/src/com/android/inputmethod/latin/LatinIME.java index b587568c9..336929229 100644 --- a/java/src/com/android/inputmethod/latin/LatinIME.java +++ b/java/src/com/android/inputmethod/latin/LatinIME.java @@ -439,6 +439,10 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen loadSettings(); + mImm.setAdditionalInputMethodSubtypes( + SubtypeUtils.getInputMethodId(getPackageName()), + mSettingsValues.getPrefefinedAdditionalSubtypes()); + // TODO: remove the following when it's not needed by updateCorrectionMode() any more mInputAttributes = new InputAttributes(null, false /* isFullscreenMode */); updateCorrectionMode(); @@ -1899,7 +1903,8 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen if (mSettingsValues.mEnableSuggestionSpanInsertion) { final SuggestedWords suggestedWords = mSuggestionsView.getSuggestions(); ic.commitText(SuggestionSpanUtils.getTextWithSuggestionSpan( - this, bestWord, suggestedWords), 1); + this, bestWord, suggestedWords, mSubtypeSwitcher.isDictionaryAvailable()), + 1); } else { ic.commitText(bestWord, 1); } @@ -2225,15 +2230,15 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen } } - protected void launchSettings() { - launchSettingsClass(Settings.class); + private void launchSettings() { + launchSettingsClass(SettingsActivity.class); } public void launchDebugSettings() { - launchSettingsClass(DebugSettings.class); + launchSettingsClass(DebugSettingsActivity.class); } - protected void launchSettingsClass(Class<? extends PreferenceActivity> settingsClass) { + private void launchSettingsClass(Class<? extends PreferenceActivity> settingsClass) { handleClose(); Intent intent = new Intent(); intent.setClass(LatinIME.this, settingsClass); diff --git a/java/src/com/android/inputmethod/latin/Settings.java b/java/src/com/android/inputmethod/latin/Settings.java index 6bc049894..43e7e278f 100644 --- a/java/src/com/android/inputmethod/latin/Settings.java +++ b/java/src/com/android/inputmethod/latin/Settings.java @@ -16,9 +16,7 @@ package com.android.inputmethod.latin; -import android.app.Activity; import android.app.AlertDialog; -import android.app.Fragment; import android.app.backup.BackupManager; import android.content.Context; import android.content.DialogInterface; @@ -33,15 +31,16 @@ import android.preference.Preference; import android.preference.Preference.OnPreferenceClickListener; import android.preference.PreferenceGroup; import android.preference.PreferenceScreen; +import android.view.LayoutInflater; import android.view.View; import android.widget.SeekBar; import android.widget.SeekBar.OnSeekBarChangeListener; import android.widget.TextView; import com.android.inputmethod.latin.define.ProductionFlag; -import com.android.inputmethodcommon.InputMethodSettingsActivity; +import com.android.inputmethodcommon.InputMethodSettingsFragment; -public class Settings extends InputMethodSettingsActivity +public class Settings extends InputMethodSettingsFragment implements SharedPreferences.OnSharedPreferenceChangeListener { public static final boolean ENABLE_EXPERIMENTAL_SETTINGS = false; @@ -103,26 +102,16 @@ public class Settings extends InputMethodSettingsActivity } } - public Activity getActivityInternal() { - Object thisObject = (Object) this; - if (thisObject instanceof Activity) { - return (Activity) thisObject; - } else if (thisObject instanceof Fragment) { - return ((Fragment) thisObject).getActivity(); - } else { - return null; - } - } - @Override public void onCreate(Bundle icicle) { super.onCreate(icicle); setInputMethodSettingsCategoryTitle(R.string.language_selection_title); setSubtypeEnablerTitle(R.string.select_language); + addPreferencesFromResource(R.xml.prefs); + final Resources res = getResources(); - final Context context = getActivityInternal(); + final Context context = getActivity(); - addPreferencesFromResource(R.xml.prefs); mVoicePreference = (ListPreference) findPreference(PREF_VOICE_MODE); mShowCorrectionSuggestionsPreference = (ListPreference) findPreference(PREF_SHOW_SUGGESTIONS_SETTING); @@ -276,7 +265,7 @@ public class Settings extends InputMethodSettingsActivity @Override public void onSharedPreferenceChanged(SharedPreferences prefs, String key) { - (new BackupManager(getActivityInternal())).dataChanged(); + (new BackupManager(getActivity())).dataChanged(); if (key.equals(PREF_POPUP_ON)) { final ListPreference popupDismissDelay = (ListPreference)findPreference(PREF_KEY_PREVIEW_POPUP_DISMISS_DELAY); @@ -318,7 +307,7 @@ public class Settings extends InputMethodSettingsActivity private void refreshEnablingsOfKeypressSoundAndVibrationSettings( SharedPreferences sp, Resources res) { if (mKeypressVibrationDurationSettingsPref != null) { - final boolean hasVibrator = VibratorUtils.getInstance(this).hasVibrator(); + final boolean hasVibrator = VibratorUtils.getInstance(getActivity()).hasVibrator(); final boolean vibrateOn = hasVibrator && sp.getBoolean(Settings.PREF_VIBRATE_ON, res.getBoolean(R.bool.config_default_vibration_enabled)); mKeypressVibrationDurationSettingsPref.setEnabled(vibrateOn); @@ -342,7 +331,7 @@ public class Settings extends InputMethodSettingsActivity private void showKeypressVibrationDurationSettingsDialog() { final SharedPreferences sp = getPreferenceManager().getSharedPreferences(); - final Activity context = getActivityInternal(); + final Context context = getActivity(); final Resources res = context.getResources(); final AlertDialog.Builder builder = new AlertDialog.Builder(context); builder.setTitle(R.string.prefs_keypress_vibration_duration_settings); @@ -361,7 +350,7 @@ public class Settings extends InputMethodSettingsActivity dialog.dismiss(); } }); - final View v = context.getLayoutInflater().inflate( + final View v = LayoutInflater.from(context).inflate( R.layout.vibration_settings_dialog, null); final int currentMs = SettingsValues.getCurrentVibrationDuration( getPreferenceManager().getSharedPreferences(), getResources()); @@ -398,9 +387,9 @@ public class Settings extends InputMethodSettingsActivity } private void showKeypressSoundVolumeSettingDialog() { - final AudioManager am = (AudioManager) getSystemService(Context.AUDIO_SERVICE); + final Context context = getActivity(); + final AudioManager am = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE); final SharedPreferences sp = getPreferenceManager().getSharedPreferences(); - final Activity context = getActivityInternal(); final Resources res = context.getResources(); final AlertDialog.Builder builder = new AlertDialog.Builder(context); builder.setTitle(R.string.prefs_keypress_sound_volume_settings); @@ -420,7 +409,7 @@ public class Settings extends InputMethodSettingsActivity dialog.dismiss(); } }); - final View v = context.getLayoutInflater().inflate( + final View v = LayoutInflater.from(context).inflate( R.layout.sound_effect_volume_dialog, null); final int currentVolumeInt = (int)(SettingsValues.getCurrentKeypressSoundVolume(sp, res) * 100); diff --git a/java/src/com/android/inputmethod/latin/SettingsActivity.java b/java/src/com/android/inputmethod/latin/SettingsActivity.java new file mode 100644 index 000000000..b85a936ad --- /dev/null +++ b/java/src/com/android/inputmethod/latin/SettingsActivity.java @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2012 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.latin; + +import android.content.Intent; +import android.os.Bundle; +import android.preference.PreferenceActivity; + +public class SettingsActivity extends PreferenceActivity { + @Override + public Intent getIntent() { + final Intent modIntent = new Intent(super.getIntent()); + modIntent.putExtra(EXTRA_SHOW_FRAGMENT, Settings.class.getName()); + return modIntent; + } + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + setTitle(R.string.english_ime_settings); + } +} diff --git a/java/src/com/android/inputmethod/latin/SettingsValues.java b/java/src/com/android/inputmethod/latin/SettingsValues.java index 526acf128..8ff644fc5 100644 --- a/java/src/com/android/inputmethod/latin/SettingsValues.java +++ b/java/src/com/android/inputmethod/latin/SettingsValues.java @@ -21,12 +21,14 @@ import android.content.SharedPreferences; import android.content.res.Resources; import android.util.Log; import android.view.inputmethod.EditorInfo; +import android.view.inputmethod.InputMethodSubtype; import com.android.inputmethod.keyboard.internal.KeySpecParser; import com.android.inputmethod.latin.SuggestedWords.SuggestedWordInfo; import java.util.ArrayList; import java.util.Arrays; +import java.util.Locale; /** * When you call the constructor of this class, you may want to change the current system locale by @@ -69,6 +71,7 @@ public class SettingsValues { private final int mVibrationDurationSettingsRawValue; @SuppressWarnings("unused") // TODO: Use this private final float mKeypressSoundVolumeRawValue; + private final InputMethodSubtype[] mPredefinedAdditionalSubtypes; // Deduced settings public final int mKeypressVibrationDuration; @@ -145,6 +148,16 @@ public class SettingsValues { mAutoCorrectionThresholdRawValue); mVoiceKeyEnabled = mVoiceMode != null && !mVoiceMode.equals(voiceModeOff); mVoiceKeyOnMain = mVoiceMode != null && mVoiceMode.equals(voiceModeMain); + + // Predefined additional subtypes + final InputMethodSubtype DE_QWERTY = AdditionalSubtype.createAddtionalSubtype( + Locale.GERMAN, AdditionalSubtype.QWERTY); + final InputMethodSubtype FR_QWERTZ = AdditionalSubtype.createAddtionalSubtype( + Locale.FRENCH, AdditionalSubtype.QWERTZ); + mPredefinedAdditionalSubtypes = new InputMethodSubtype[] { + DE_QWERTY, + FR_QWERTZ, + }; } // Helper functions to create member values. @@ -304,6 +317,11 @@ public class SettingsValues { return res.getBoolean(R.bool.config_use_fullscreen_mode); } + // TODO: Should be able to add/remove/edit. + public InputMethodSubtype[] getPrefefinedAdditionalSubtypes() { + return mPredefinedAdditionalSubtypes; + } + // Accessed from the settings interface, hence public public static float getCurrentKeypressSoundVolume(final SharedPreferences sp, final Resources res) { diff --git a/java/src/com/android/inputmethod/latin/SubtypeLocale.java b/java/src/com/android/inputmethod/latin/SubtypeLocale.java index 2bc22a6f9..37da5e846 100644 --- a/java/src/com/android/inputmethod/latin/SubtypeLocale.java +++ b/java/src/com/android/inputmethod/latin/SubtypeLocale.java @@ -18,20 +18,19 @@ package com.android.inputmethod.latin; import android.content.Context; import android.content.res.Resources; +import android.view.inputmethod.InputMethodSubtype; - +import java.util.HashMap; import java.util.Locale; public class SubtypeLocale { // Special language code to represent "no language". - public static final String NO_LANGUAGE = "zz"; - // Special country code to represent "QWERTY". - /* package for test */ static final String QWERTY = "QY"; - - public static final Locale LOCALE_NO_LANGUAGE_QWERTY = new Locale(NO_LANGUAGE, QWERTY); + private static final String NO_LANGUAGE = "zz"; + public static final Locale LOCALE_NO_LANGUAGE = new Locale(NO_LANGUAGE); - private static String[] sExceptionKeys; - private static String[] sExceptionValues; + // Exceptional locales to display name map. + private static final HashMap<String, String> sExceptionalDisplayNamesMap = + new HashMap<String, String>(); private SubtypeLocale() { // Intentional empty constructor for utility class. @@ -39,70 +38,82 @@ public class SubtypeLocale { public static void init(Context context) { final Resources res = context.getResources(); - sExceptionKeys = res.getStringArray(R.array.subtype_locale_exception_keys); - sExceptionValues = res.getStringArray(R.array.subtype_locale_exception_values); - } - - private static String lookupExceptionalLocale(String key) { - for (int index = 0; index < sExceptionKeys.length; index++) { - if (sExceptionKeys[index].equals(key)) { - return sExceptionValues[index]; - } + final String[] locales = res.getStringArray(R.array.subtype_locale_exception_keys); + final String[] displayNames = res.getStringArray(R.array.subtype_locale_exception_values); + for (int i = 0; i < locales.length; i++) { + sExceptionalDisplayNamesMap.put(locales[i], displayNames[i]); } - return null; } - // Get Locale's full display name in its locale. - // For example: - // "fr_CH" is converted to "Français (Suisse)". - // "de_QY" is converted to "Deutsche (QWERTY)". (Any locale that has country code "QY") - // "zz_QY" is converted to "QWERTY". (The language code "zz" means "No language", thus just - // ends up with the keyboard layout name.) - public static String getFullDisplayName(Locale locale) { - final String key; - if (locale.getLanguage().equals(NO_LANGUAGE)) { - key = locale.getCountry(); - } else if (locale.getCountry().equals(QWERTY)) { - key = "*_" + QWERTY; - } else { - key = locale.toString(); + // Get InputMethodSubtype's display name in its locale. + // isAdditionalSubtype (T=true, F=false) + // locale layout | Short Middle Full + // ------ ------ - ---- --------- ----------------- + // en_US qwerty F En English English (US) exception + // en_GB qwerty F En English English (UK) exception + // fr azerty F Fr Français Français + // fr_CA qwerty F Fr Français Français (Canada) + // de qwertz F De Deutsch Deutsch + // zz qwerty F QWERTY QWERTY + // fr qwertz T Fr Français Français (QWERTZ) + // de qwerty T De Deutsch Deutsch (QWERTY) + // en azerty T En English English (AZERTY) + // zz azerty T AZERTY AZERTY + + // Get InputMethodSubtype's full display name in its locale. + public static String getFullDisplayName(InputMethodSubtype subtype) { + final String value = sExceptionalDisplayNamesMap.get(subtype.getLocale()); + if (value != null) { + return value; } - final String value = lookupExceptionalLocale(key); - if (value == null) { - return StringUtils.toTitleCase(locale.getDisplayName(locale), locale); + + if (isNoLanguage(subtype)) { + return getKeyboardLayoutSetName(subtype).toUpperCase(); } - if (value.indexOf("%s") >= 0) { - final String languageName = StringUtils.toTitleCase(locale.getDisplayLanguage(locale), locale); - return String.format(value, languageName); + + final Locale locale = getSubtypeLocale(subtype); + final String language = StringUtils.toTitleCase(locale.getDisplayLanguage(locale), locale); + if (AdditionalSubtype.isAdditionalSubtype(subtype)) { + return String.format("%s (%s)", + language, getKeyboardLayoutSetName(subtype).toUpperCase()); } - return value; + return StringUtils.toTitleCase(locale.getDisplayName(locale), locale); } - // Get Locale's middle display name in its locale. - // For example: - // "fr_CH" is converted to "Français". - // "de_QY" is converted to "Deutsche". (Any locale that has country code "QY") - // "zz_QY" is converted to "QWERTY". (The language code "zz" means "No language", thus just - // ends up with the keyboard layout name.) - public static String getMiddleDisplayName(Locale locale) { - if (NO_LANGUAGE.equals(locale.getLanguage())) { - return lookupExceptionalLocale(locale.getCountry()); - } else { - return StringUtils.toTitleCase(locale.getDisplayLanguage(locale), locale); + // Get InputMethodSubtype's middle display name in its locale. + public static String getMiddleDisplayName(InputMethodSubtype subtype) { + if (isNoLanguage(subtype)) { + return getKeyboardLayoutSetName(subtype).toUpperCase(); } + final Locale locale = getSubtypeLocale(subtype); + return StringUtils.toTitleCase(locale.getDisplayLanguage(locale), locale); } - // Get Locale's short display name in its locale. - // For example: - // "fr_CH" is converted to "Fr". - // "de_QY" is converted to "De". (Any locale that has country code "QY") - // "zz_QY" is converter to "QY". (The language code "zz" means "No language", thus just ends - // up with the keyboard layout name.) - public static String getShortDisplayName(Locale locale) { - if (NO_LANGUAGE.equals(locale.getLanguage())) { - return locale.getCountry(); - } else { - return StringUtils.toTitleCase(locale.getLanguage(), locale); + // Get InputMethodSubtype's short display name in its locale. + public static String getShortDisplayName(InputMethodSubtype subtype) { + if (isNoLanguage(subtype)) { + return ""; } + final Locale locale = getSubtypeLocale(subtype); + return StringUtils.toTitleCase(locale.getLanguage(), locale); + } + + public static boolean isNoLanguage(InputMethodSubtype subtype) { + final String localeString = subtype.getLocale(); + return localeString.equals(NO_LANGUAGE); + } + + public static Locale getSubtypeLocale(InputMethodSubtype subtype) { + final String localeString = subtype.getLocale(); + return LocaleUtils.constructLocaleFromString(localeString); + } + + public static String getKeyboardLayoutSetName(InputMethodSubtype subtype) { + final String keyboardLayoutSet = subtype.getExtraValueOf( + LatinIME.SUBTYPE_EXTRA_VALUE_KEYBOARD_LAYOUT_SET); + // TODO: Remove this null check when InputMethodManager.getCurrentInputMethodSubtype is + // fixed. + if (keyboardLayoutSet == null) return AdditionalSubtype.QWERTY; + return keyboardLayoutSet; } } diff --git a/java/src/com/android/inputmethod/latin/SubtypeSwitcher.java b/java/src/com/android/inputmethod/latin/SubtypeSwitcher.java index 6612c24cd..3bb3ab4ba 100644 --- a/java/src/com/android/inputmethod/latin/SubtypeSwitcher.java +++ b/java/src/com/android/inputmethod/latin/SubtypeSwitcher.java @@ -31,7 +31,6 @@ import android.view.inputmethod.InputMethodInfo; import android.view.inputmethod.InputMethodSubtype; import com.android.inputmethod.compat.InputMethodManagerCompatWrapper; -import com.android.inputmethod.keyboard.KeyboardLayoutSet; import com.android.inputmethod.keyboard.KeyboardSwitcher; import java.util.ArrayList; @@ -63,6 +62,7 @@ public class SubtypeSwitcher { /*-----------------------------------------------------------*/ // Variants which should be changed only by reload functions. private boolean mNeedsToDisplayLanguage; + private boolean mIsDictionaryAvailable; private boolean mIsSystemLanguageSameAsInputLanguage; private InputMethodInfo mShortcutInputMethodInfo; private InputMethodSubtype mShortcutSubtype; @@ -104,8 +104,8 @@ public class SubtypeSwitcher { mInputLocaleStr = null; mCurrentSubtype = mImm.getCurrentInputMethodSubtype(); mAllEnabledSubtypesOfCurrentInputMethod = null; - mNoLanguageSubtype = SubtypeUtils.findSubtypeByKeyboardLayoutSetLocale( - service, SubtypeLocale.LOCALE_NO_LANGUAGE_QWERTY); + mNoLanguageSubtype = SubtypeUtils.findSubtypeByLocaleAndKeyboardLayoutSet( + service, SubtypeLocale.LOCALE_NO_LANGUAGE, AdditionalSubtype.QWERTY); final NetworkInfo info = mConnectivityManager.getActiveNetworkInfo(); mIsNetworkConnected = (info != null && info.isConnected()); @@ -128,14 +128,14 @@ public class SubtypeSwitcher { // Reload enabledSubtypes from the framework. private void updateEnabledSubtypes() { - final String currentMode = getCurrentSubtypeMode(); + final String currentMode = mCurrentSubtype.getMode(); boolean foundCurrentSubtypeBecameDisabled = true; mAllEnabledSubtypesOfCurrentInputMethod = mImm.getEnabledInputMethodSubtypeList( null, true); mEnabledLanguagesOfCurrentInputMethod.clear(); mEnabledKeyboardSubtypesOfCurrentInputMethod.clear(); for (InputMethodSubtype ims : mAllEnabledSubtypesOfCurrentInputMethod) { - final String locale = KeyboardLayoutSet.getKeyboardLayoutSetLocaleString(ims); + final String locale = ims.getLocale(); final String mode = ims.getMode(); mLocaleSplitter.setString(locale); if (mLocaleSplitter.hasNext()) { @@ -165,8 +165,7 @@ public class SubtypeSwitcher { + (mShortcutInputMethodInfo == null ? "<null>" : mShortcutInputMethodInfo.getId()) + ", " + (mShortcutSubtype == null ? "<null>" : ( - KeyboardLayoutSet.getKeyboardLayoutSetLocaleString(mShortcutSubtype) - + ", " + mShortcutSubtype.getMode()))); + mShortcutSubtype.getLocale() + ", " + mShortcutSubtype.getMode()))); } // TODO: Update an icon for shortcut IME final Map<InputMethodInfo, List<InputMethodSubtype>> shortcuts = @@ -188,16 +187,15 @@ public class SubtypeSwitcher { + (mShortcutInputMethodInfo == null ? "<null>" : mShortcutInputMethodInfo.getId()) + ", " + (mShortcutSubtype == null ? "<null>" : ( - KeyboardLayoutSet.getKeyboardLayoutSetLocaleString(mShortcutSubtype) - + ", " + mShortcutSubtype.getMode()))); + mShortcutSubtype.getLocale() + ", " + mShortcutSubtype.getMode()))); } } // Update the current subtype. LatinIME.onCurrentInputMethodSubtypeChanged calls this function. public void updateSubtype(InputMethodSubtype newSubtype) { - final String newLocale = KeyboardLayoutSet.getKeyboardLayoutSetLocaleString(newSubtype); + final String newLocale = newSubtype.getLocale(); final String newMode = newSubtype.getMode(); - final String oldMode = getCurrentSubtypeMode(); + final String oldMode = mCurrentSubtype.getMode(); if (DBG) { Log.w(TAG, "Update subtype to:" + newLocale + "," + newMode + ", from: " + mInputLocaleStr + ", " + oldMode); @@ -217,7 +215,7 @@ public class SubtypeSwitcher { } mCurrentSubtype = newSubtype; - if (isKeyboardMode()) { + if (KEYBOARD_MODE.equals(mCurrentSubtype.getMode())) { if (modeChanged || languageChanged) { updateShortcutIME(); mService.onRefreshKeyboard(); @@ -232,12 +230,10 @@ public class SubtypeSwitcher { } Log.w(TAG, "Unknown subtype mode: " + newMode + "," + version + ", " + packageName + ". IME is already changed to other IME."); - if (newSubtype != null) { - Log.w(TAG, "Subtype mode:" + newSubtype.getMode()); - Log.w(TAG, "Subtype locale:" + newSubtype.getLocale()); - Log.w(TAG, "Subtype extra value:" + newSubtype.getExtraValue()); - Log.w(TAG, "Subtype is auxiliary:" + newSubtype.isAuxiliary()); - } + Log.w(TAG, "Subtype mode:" + newSubtype.getMode()); + Log.w(TAG, "Subtype locale:" + newSubtype.getLocale()); + Log.w(TAG, "Subtype extra value:" + newSubtype.getExtraValue()); + Log.w(TAG, "Subtype is auxiliary:" + newSubtype.isAuxiliary()); } } @@ -260,6 +256,7 @@ public class SubtypeSwitcher { getInputLocale().getLanguage()); mNeedsToDisplayLanguage = !(getEnabledKeyboardLocaleCount() <= 1 && mIsSystemLanguageSameAsInputLanguage); + mIsDictionaryAvailable = DictionaryFactory.isDictionaryAvailable(mService, mInputLocale); } //////////////////////////// @@ -280,10 +277,11 @@ public class SubtypeSwitcher { if (token == null) { return; } + final InputMethodManagerCompatWrapper imm = mImm; new AsyncTask<Void, Void, Void>() { @Override protected Void doInBackground(Void... params) { - mImm.setInputMethodAndSubtype(token, imiId, subtype); + imm.setInputMethodAndSubtype(token, imiId, subtype); return null; } }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR); @@ -335,7 +333,7 @@ public class SubtypeSwitcher { } public boolean needsToDisplayLanguage(Locale keyboardLocale) { - if (keyboardLocale.equals(SubtypeLocale.LOCALE_NO_LANGUAGE_QWERTY)) { + if (keyboardLocale.equals(SubtypeLocale.LOCALE_NO_LANGUAGE)) { return true; } if (!keyboardLocale.equals(mInputLocale)) { @@ -379,20 +377,8 @@ public class SubtypeSwitcher { } } - // TODO: Remove this method - private boolean isKeyboardMode() { - return KEYBOARD_MODE.equals(getCurrentSubtypeMode()); - } - - // TODO: Remove this method - private String getCurrentSubtypeMode() { - return mCurrentSubtype.getMode(); - } - - // TODO: Remove this method - public boolean currentSubtypeContainsExtraValueKey(String key) { - // If null, return what an empty ExtraValue would return : false. - return mCurrentSubtype.containsExtraValueKey(key); + public boolean isDictionaryAvailable() { + return mIsDictionaryAvailable; } public InputMethodSubtype getCurrentSubtype() { diff --git a/java/src/com/android/inputmethod/latin/SubtypeUtils.java b/java/src/com/android/inputmethod/latin/SubtypeUtils.java index a747c9ad7..4d0f1c262 100644 --- a/java/src/com/android/inputmethod/latin/SubtypeUtils.java +++ b/java/src/com/android/inputmethod/latin/SubtypeUtils.java @@ -21,7 +21,6 @@ import android.view.inputmethod.InputMethodInfo; import android.view.inputmethod.InputMethodSubtype; import com.android.inputmethod.compat.InputMethodManagerCompatWrapper; -import com.android.inputmethod.keyboard.KeyboardLayoutSet; import java.util.Collections; import java.util.List; @@ -125,24 +124,26 @@ public class SubtypeUtils { throw new RuntimeException("Input method manager not found"); } - for (final InputMethodInfo imi : imm.getEnabledInputMethodList()) { + for (final InputMethodInfo imi : imm.getInputMethodList()) { if (imi.getPackageName().equals(packageName)) return imi; } throw new RuntimeException("Can not find input method id for " + packageName); } - public static InputMethodSubtype findSubtypeByKeyboardLayoutSetLocale( - Context context, Locale locale) { + public static InputMethodSubtype findSubtypeByLocaleAndKeyboardLayoutSet( + Context context, Locale locale, String keyoardLayoutSet) { final String localeString = locale.toString(); - final InputMethodInfo imi = SubtypeUtils.getInputMethodInfo(context.getPackageName()); + final InputMethodInfo imi = getInputMethodInfo(context.getPackageName()); final int count = imi.getSubtypeCount(); for (int i = 0; i < count; i++) { final InputMethodSubtype subtype = imi.getSubtypeAt(i); - if (localeString.equals(KeyboardLayoutSet.getKeyboardLayoutSetLocaleString(subtype))) { + final String layout = SubtypeLocale.getKeyboardLayoutSetName(subtype); + if (localeString.equals(subtype.getLocale()) && keyoardLayoutSet.equals(layout)) { return subtype; } } - throw new RuntimeException("Can not find subtype of locale " + localeString); + throw new RuntimeException("Can't find subtype for locale " + localeString + + " and keyboard layout " + keyoardLayoutSet); } } |