diff options
Diffstat (limited to 'java/src/com/android/inputmethod/latin')
6 files changed, 149 insertions, 91 deletions
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/LatinIME.java b/java/src/com/android/inputmethod/latin/LatinIME.java index 187252a31..1ab461e3f 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(); 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 05f91688e..37da5e846 100644 --- a/java/src/com/android/inputmethod/latin/SubtypeLocale.java +++ b/java/src/com/android/inputmethod/latin/SubtypeLocale.java @@ -20,23 +20,17 @@ 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; - - private static final String DEFAULT_KEYBOARD_LAYOUT_SET = "qwerty"; - private static final char KEYBOARD_LAYOUT_SET_LOCALE_DELIMITER = ':'; + // 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. @@ -44,95 +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 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 boolean isNoLanguage(InputMethodSubtype subtype) { + final String localeString = subtype.getLocale(); + return localeString.equals(NO_LANGUAGE); } - public static String getKeyboardLayoutSetLocaleString(InputMethodSubtype subtype) { + 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 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)); + 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 2ba742303..3bb3ab4ba 100644 --- a/java/src/com/android/inputmethod/latin/SubtypeSwitcher.java +++ b/java/src/com/android/inputmethod/latin/SubtypeSwitcher.java @@ -105,7 +105,7 @@ public class SubtypeSwitcher { mCurrentSubtype = mImm.getCurrentInputMethodSubtype(); mAllEnabledSubtypesOfCurrentInputMethod = null; mNoLanguageSubtype = SubtypeUtils.findSubtypeByLocaleAndKeyboardLayoutSet( - service, SubtypeLocale.LOCALE_NO_LANGUAGE_QWERTY, "qwerty"); + service, SubtypeLocale.LOCALE_NO_LANGUAGE, AdditionalSubtype.QWERTY); final NetworkInfo info = mConnectivityManager.getActiveNetworkInfo(); mIsNetworkConnected = (info != null && info.isConnected()); @@ -135,7 +135,7 @@ public class SubtypeSwitcher { mEnabledLanguagesOfCurrentInputMethod.clear(); mEnabledKeyboardSubtypesOfCurrentInputMethod.clear(); for (InputMethodSubtype ims : mAllEnabledSubtypesOfCurrentInputMethod) { - final String locale = SubtypeLocale.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>" : ( - SubtypeLocale.getKeyboardLayoutSetLocaleString(mShortcutSubtype) - + ", " + mShortcutSubtype.getMode()))); + mShortcutSubtype.getLocale() + ", " + mShortcutSubtype.getMode()))); } // TODO: Update an icon for shortcut IME final Map<InputMethodInfo, List<InputMethodSubtype>> shortcuts = @@ -188,14 +187,13 @@ public class SubtypeSwitcher { + (mShortcutInputMethodInfo == null ? "<null>" : mShortcutInputMethodInfo.getId()) + ", " + (mShortcutSubtype == null ? "<null>" : ( - SubtypeLocale.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 = SubtypeLocale.getKeyboardLayoutSetLocaleString(newSubtype); + final String newLocale = newSubtype.getLocale(); final String newMode = newSubtype.getMode(); final String oldMode = mCurrentSubtype.getMode(); if (DBG) { @@ -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)) { diff --git a/java/src/com/android/inputmethod/latin/SubtypeUtils.java b/java/src/com/android/inputmethod/latin/SubtypeUtils.java index 4ad72fb9f..4d0f1c262 100644 --- a/java/src/com/android/inputmethod/latin/SubtypeUtils.java +++ b/java/src/com/android/inputmethod/latin/SubtypeUtils.java @@ -143,6 +143,7 @@ public class SubtypeUtils { 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); } } |