Examples with InputMethodSubtype android.view.inputmethod.InputMethodSubtype used on opensource projects

Example 6 with InputMethodSubtype

use of android.view.inputmethod.InputMethodSubtype in project android_frameworks_base by ParanoidAndroid.

the class InputMethodManagerService method showInputMethodMenuInternal.

private void showInputMethodMenuInternal(boolean showSubtypes) {
    if (DEBUG)
        Slog.v(TAG, "Show switching menu");
    final Context context = getUiContext();
    final boolean isScreenLocked = isScreenLocked();
    final String lastInputMethodId = mSettings.getSelectedInputMethod();
    int lastInputMethodSubtypeId = mSettings.getSelectedInputMethodSubtypeId(lastInputMethodId);
    if (DEBUG)
        Slog.v(TAG, "Current IME: " + lastInputMethodId);
    synchronized (mMethodMap) {
        final HashMap<InputMethodInfo, List<InputMethodSubtype>> immis = getExplicitlyOrImplicitlyEnabledInputMethodsAndSubtypeListLocked();
        if (immis == null || immis.size() == 0) {
            return;
        }
        hideInputMethodMenuLocked();
        final List<ImeSubtypeListItem> imList = mImListManager.getSortedInputMethodAndSubtypeList(showSubtypes, mInputShown, isScreenLocked);
        if (lastInputMethodSubtypeId == NOT_A_SUBTYPE_ID) {
            final InputMethodSubtype currentSubtype = getCurrentInputMethodSubtypeLocked();
            if (currentSubtype != null) {
                final InputMethodInfo currentImi = mMethodMap.get(mCurMethodId);
                lastInputMethodSubtypeId = InputMethodUtils.getSubtypeIdFromHashCode(currentImi, currentSubtype.hashCode());
            }
        }
        final int N = imList.size();
        mIms = new InputMethodInfo[N];
        mSubtypeIds = new int[N];
        int checkedItem = 0;
        for (int i = 0; i < N; ++i) {
            final ImeSubtypeListItem item = imList.get(i);
            mIms[i] = item.mImi;
            mSubtypeIds[i] = item.mSubtypeId;
            if (mIms[i].getId().equals(lastInputMethodId)) {
                int subtypeId = mSubtypeIds[i];
                if ((subtypeId == NOT_A_SUBTYPE_ID) || (lastInputMethodSubtypeId == NOT_A_SUBTYPE_ID && subtypeId == 0) || (subtypeId == lastInputMethodSubtypeId)) {
                    checkedItem = i;
                }
            }
        }
        final TypedArray a = context.obtainStyledAttributes(null, com.android.internal.R.styleable.DialogPreference, com.android.internal.R.attr.alertDialogStyle, 0);
        mDialogBuilder = new AlertDialog.Builder(context).setOnCancelListener(new OnCancelListener() {

            @Override
            public void onCancel(DialogInterface dialog) {
                hideInputMethodMenu();
            }
        }).setIcon(a.getDrawable(com.android.internal.R.styleable.DialogPreference_dialogTitle));
        a.recycle();
        final LayoutInflater inflater = (LayoutInflater) mContext.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
        final View tv = inflater.inflate(com.android.internal.R.layout.input_method_switch_dialog_title, null);
        mDialogBuilder.setCustomTitle(tv);
        // Setup layout for a toggle switch of the hardware keyboard
        mSwitchingDialogTitleView = tv;
        mSwitchingDialogTitleView.findViewById(com.android.internal.R.id.hard_keyboard_section).setVisibility(mWindowManagerService.isHardKeyboardAvailable() ? View.VISIBLE : View.GONE);
        final Switch hardKeySwitch = ((Switch) mSwitchingDialogTitleView.findViewById(com.android.internal.R.id.hard_keyboard_switch));
        hardKeySwitch.setChecked(mWindowManagerService.isHardKeyboardEnabled());
        hardKeySwitch.setOnCheckedChangeListener(new OnCheckedChangeListener() {

            @Override
            public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
                mWindowManagerService.setHardKeyboardEnabled(isChecked);
                // Ensure that the input method dialog is dismissed when changing
                // the hardware keyboard state.
                hideInputMethodMenu();
            }
        });
        final ImeSubtypeListAdapter adapter = new ImeSubtypeListAdapter(context, com.android.internal.R.layout.simple_list_item_2_single_choice, imList, checkedItem);
        mDialogBuilder.setSingleChoiceItems(adapter, checkedItem, new AlertDialog.OnClickListener() {

            @Override
            public void onClick(DialogInterface dialog, int which) {
                synchronized (mMethodMap) {
                    if (mIms == null || mIms.length <= which || mSubtypeIds == null || mSubtypeIds.length <= which) {
                        return;
                    }
                    InputMethodInfo im = mIms[which];
                    int subtypeId = mSubtypeIds[which];
                    adapter.mCheckedItem = which;
                    adapter.notifyDataSetChanged();
                    hideInputMethodMenu();
                    if (im != null) {
                        if ((subtypeId < 0) || (subtypeId >= im.getSubtypeCount())) {
                            subtypeId = NOT_A_SUBTYPE_ID;
                        }
                        setInputMethodLocked(im.getId(), subtypeId);
                    }
                }
            }
        });
        if (showSubtypes && !isScreenLocked) {
            mDialogBuilder.setPositiveButton(com.android.internal.R.string.configure_input_methods, new DialogInterface.OnClickListener() {

                @Override
                public void onClick(DialogInterface dialog, int whichButton) {
                    showConfigureInputMethods();
                }
            });
        }
        mSwitchingDialog = mDialogBuilder.create();
        mSwitchingDialog.setCanceledOnTouchOutside(true);
        mSwitchingDialog.getWindow().setType(WindowManager.LayoutParams.TYPE_INPUT_METHOD_DIALOG);
        mSwitchingDialog.getWindow().getAttributes().privateFlags |= WindowManager.LayoutParams.PRIVATE_FLAG_SHOW_FOR_ALL_USERS;
        mSwitchingDialog.getWindow().getAttributes().setTitle("Select input method");
        mSwitchingDialog.show();
    }
}

Example 7 with InputMethodSubtype

use of android.view.inputmethod.InputMethodSubtype in project android_frameworks_base by ParanoidAndroid.

the class InputMethodManagerService method switchToLastInputMethod.

@Override
public boolean switchToLastInputMethod(IBinder token) {
    if (!calledFromValidUser()) {
        return false;
    }
    synchronized (mMethodMap) {
        final Pair<String, String> lastIme = mSettings.getLastInputMethodAndSubtypeLocked();
        final InputMethodInfo lastImi;
        if (lastIme != null) {
            lastImi = mMethodMap.get(lastIme.first);
        } else {
            lastImi = null;
        }
        String targetLastImiId = null;
        int subtypeId = NOT_A_SUBTYPE_ID;
        if (lastIme != null && lastImi != null) {
            final boolean imiIdIsSame = lastImi.getId().equals(mCurMethodId);
            final int lastSubtypeHash = Integer.valueOf(lastIme.second);
            final int currentSubtypeHash = mCurrentSubtype == null ? NOT_A_SUBTYPE_ID : mCurrentSubtype.hashCode();
            // defined, there is no need to switch to the last IME.
            if (!imiIdIsSame || lastSubtypeHash != currentSubtypeHash) {
                targetLastImiId = lastIme.first;
                subtypeId = InputMethodUtils.getSubtypeIdFromHashCode(lastImi, lastSubtypeHash);
            }
        }
        if (TextUtils.isEmpty(targetLastImiId) && !InputMethodUtils.canAddToLastInputMethod(mCurrentSubtype)) {
            // This is a safety net. If the currentSubtype can't be added to the history
            // and the framework couldn't find the last ime, we will make the last ime be
            // the most applicable enabled keyboard subtype of the system imes.
            final List<InputMethodInfo> enabled = mSettings.getEnabledInputMethodListLocked();
            if (enabled != null) {
                final int N = enabled.size();
                final String locale = mCurrentSubtype == null ? mRes.getConfiguration().locale.toString() : mCurrentSubtype.getLocale();
                for (int i = 0; i < N; ++i) {
                    final InputMethodInfo imi = enabled.get(i);
                    if (imi.getSubtypeCount() > 0 && InputMethodUtils.isSystemIme(imi)) {
                        InputMethodSubtype keyboardSubtype = InputMethodUtils.findLastResortApplicableSubtypeLocked(mRes, InputMethodUtils.getSubtypes(imi), InputMethodUtils.SUBTYPE_MODE_KEYBOARD, locale, true);
                        if (keyboardSubtype != null) {
                            targetLastImiId = imi.getId();
                            subtypeId = InputMethodUtils.getSubtypeIdFromHashCode(imi, keyboardSubtype.hashCode());
                            if (keyboardSubtype.getLocale().equals(locale)) {
                                break;
                            }
                        }
                    }
                }
            }
        }
        if (!TextUtils.isEmpty(targetLastImiId)) {
            if (DEBUG) {
                Slog.d(TAG, "Switch to: " + lastImi.getId() + ", " + lastIme.second + ", from: " + mCurMethodId + ", " + subtypeId);
            }
            setInputMethodWithSubtypeId(token, targetLastImiId, subtypeId);
            return true;
        } else {
            return false;
        }
    }
}

Example 8 with InputMethodSubtype

use of android.view.inputmethod.InputMethodSubtype in project android_frameworks_base by ParanoidAndroid.

the class TextServicesManagerService method getCurrentSpellCheckerSubtype.

// TODO: Respect allowImplicitlySelectedSubtype
// TODO: Save SpellCheckerSubtype by supported languages by looking at "locale".
@Override
public SpellCheckerSubtype getCurrentSpellCheckerSubtype(String locale, boolean allowImplicitlySelectedSubtype) {
    // TODO: Make this work even for non-current users?
    if (!calledFromValidUser()) {
        return null;
    }
    synchronized (mSpellCheckerMap) {
        final String subtypeHashCodeStr = mSettings.getSelectedSpellCheckerSubtype();
        if (DBG) {
            Slog.w(TAG, "getCurrentSpellCheckerSubtype: " + subtypeHashCodeStr);
        }
        final SpellCheckerInfo sci = getCurrentSpellChecker(null);
        if (sci == null || sci.getSubtypeCount() == 0) {
            if (DBG) {
                Slog.w(TAG, "Subtype not found.");
            }
            return null;
        }
        final int hashCode;
        if (!TextUtils.isEmpty(subtypeHashCodeStr)) {
            hashCode = Integer.valueOf(subtypeHashCodeStr);
        } else {
            hashCode = 0;
        }
        if (hashCode == 0 && !allowImplicitlySelectedSubtype) {
            return null;
        }
        String candidateLocale = null;
        if (hashCode == 0) {
            // Spell checker language settings == "auto"
            final InputMethodManager imm = (InputMethodManager) mContext.getSystemService(Context.INPUT_METHOD_SERVICE);
            if (imm != null) {
                final InputMethodSubtype currentInputMethodSubtype = imm.getCurrentInputMethodSubtype();
                if (currentInputMethodSubtype != null) {
                    final String localeString = currentInputMethodSubtype.getLocale();
                    if (!TextUtils.isEmpty(localeString)) {
                        // 1. Use keyboard locale if available in the spell checker
                        candidateLocale = localeString;
                    }
                }
            }
            if (candidateLocale == null) {
                // 2. Use System locale if available in the spell checker
                candidateLocale = mContext.getResources().getConfiguration().locale.toString();
            }
        }
        SpellCheckerSubtype candidate = null;
        for (int i = 0; i < sci.getSubtypeCount(); ++i) {
            final SpellCheckerSubtype scs = sci.getSubtypeAt(i);
            if (hashCode == 0) {
                final String scsLocale = scs.getLocale();
                if (candidateLocale.equals(scsLocale)) {
                    return scs;
                } else if (candidate == null) {
                    if (candidateLocale.length() >= 2 && scsLocale.length() >= 2 && candidateLocale.startsWith(scsLocale)) {
                        // Fall back to the applicable language
                        candidate = scs;
                    }
                }
            } else if (scs.hashCode() == hashCode) {
                if (DBG) {
                    Slog.w(TAG, "Return subtype " + scs.hashCode() + ", input= " + locale + ", " + scs.getLocale());
                }
                // 3. Use the user specified spell check language
                return scs;
            }
        }
        // spell check languages
        return candidate;
    }
}

Example 9 with InputMethodSubtype

use of android.view.inputmethod.InputMethodSubtype in project platform_frameworks_base by android.

the class InputMethodUtilsTest method testGetImplicitlyApplicableSubtypesLocked.

@SmallTest
public void testGetImplicitlyApplicableSubtypesLocked() throws Exception {
    final InputMethodSubtype nonAutoEnUS = createDummyInputMethodSubtype("en_US", SUBTYPE_MODE_KEYBOARD, !IS_AUX, !IS_OVERRIDES_IMPLICITLY_ENABLED_SUBTYPE, IS_ASCII_CAPABLE, !IS_ENABLED_WHEN_DEFAULT_IS_NOT_ASCII_CAPABLE);
    final InputMethodSubtype nonAutoEnGB = createDummyInputMethodSubtype("en_GB", SUBTYPE_MODE_KEYBOARD, !IS_AUX, !IS_OVERRIDES_IMPLICITLY_ENABLED_SUBTYPE, IS_ASCII_CAPABLE, IS_ENABLED_WHEN_DEFAULT_IS_NOT_ASCII_CAPABLE);
    final InputMethodSubtype nonAutoEnIN = createDummyInputMethodSubtype("en_IN", SUBTYPE_MODE_KEYBOARD, !IS_AUX, !IS_OVERRIDES_IMPLICITLY_ENABLED_SUBTYPE, IS_ASCII_CAPABLE, IS_ENABLED_WHEN_DEFAULT_IS_NOT_ASCII_CAPABLE);
    final InputMethodSubtype nonAutoFrCA = createDummyInputMethodSubtype("fr_CA", SUBTYPE_MODE_KEYBOARD, !IS_AUX, !IS_OVERRIDES_IMPLICITLY_ENABLED_SUBTYPE, IS_ASCII_CAPABLE, IS_ENABLED_WHEN_DEFAULT_IS_NOT_ASCII_CAPABLE);
    final InputMethodSubtype nonAutoFr = createDummyInputMethodSubtype("fr_CA", SUBTYPE_MODE_KEYBOARD, !IS_AUX, !IS_OVERRIDES_IMPLICITLY_ENABLED_SUBTYPE, IS_ASCII_CAPABLE, IS_ENABLED_WHEN_DEFAULT_IS_NOT_ASCII_CAPABLE);
    final InputMethodSubtype nonAutoFil = createDummyInputMethodSubtype("fil", SUBTYPE_MODE_KEYBOARD, !IS_AUX, !IS_OVERRIDES_IMPLICITLY_ENABLED_SUBTYPE, IS_ASCII_CAPABLE, !IS_ENABLED_WHEN_DEFAULT_IS_NOT_ASCII_CAPABLE);
    final InputMethodSubtype nonAutoIn = createDummyInputMethodSubtype("in", SUBTYPE_MODE_KEYBOARD, !IS_AUX, !IS_OVERRIDES_IMPLICITLY_ENABLED_SUBTYPE, IS_ASCII_CAPABLE, IS_ENABLED_WHEN_DEFAULT_IS_NOT_ASCII_CAPABLE);
    final InputMethodSubtype nonAutoId = createDummyInputMethodSubtype("id", SUBTYPE_MODE_KEYBOARD, !IS_AUX, !IS_OVERRIDES_IMPLICITLY_ENABLED_SUBTYPE, IS_ASCII_CAPABLE, IS_ENABLED_WHEN_DEFAULT_IS_NOT_ASCII_CAPABLE);
    final InputMethodSubtype autoSubtype = createDummyInputMethodSubtype("auto", SUBTYPE_MODE_KEYBOARD, !IS_AUX, IS_OVERRIDES_IMPLICITLY_ENABLED_SUBTYPE, IS_ASCII_CAPABLE, !IS_ENABLED_WHEN_DEFAULT_IS_NOT_ASCII_CAPABLE);
    final InputMethodSubtype nonAutoJa = createDummyInputMethodSubtype("ja", SUBTYPE_MODE_KEYBOARD, !IS_AUX, !IS_OVERRIDES_IMPLICITLY_ENABLED_SUBTYPE, !IS_ASCII_CAPABLE, !IS_ENABLED_WHEN_DEFAULT_IS_NOT_ASCII_CAPABLE);
    final InputMethodSubtype nonAutoHi = createDummyInputMethodSubtype("hi", SUBTYPE_MODE_KEYBOARD, !IS_AUX, !IS_OVERRIDES_IMPLICITLY_ENABLED_SUBTYPE, !IS_ASCII_CAPABLE, !IS_ENABLED_WHEN_DEFAULT_IS_NOT_ASCII_CAPABLE);
    final InputMethodSubtype nonAutoSrCyrl = createDummyInputMethodSubtype("sr", "sr-Cyrl", SUBTYPE_MODE_KEYBOARD, !IS_AUX, !IS_OVERRIDES_IMPLICITLY_ENABLED_SUBTYPE, !IS_ASCII_CAPABLE, !IS_ENABLED_WHEN_DEFAULT_IS_NOT_ASCII_CAPABLE);
    final InputMethodSubtype nonAutoSrLatn = createDummyInputMethodSubtype("sr_ZZ", "sr-Latn", SUBTYPE_MODE_KEYBOARD, !IS_AUX, !IS_OVERRIDES_IMPLICITLY_ENABLED_SUBTYPE, IS_ASCII_CAPABLE, !IS_ENABLED_WHEN_DEFAULT_IS_NOT_ASCII_CAPABLE);
    final InputMethodSubtype nonAutoHandwritingEn = createDummyInputMethodSubtype("en", SUBTYPE_MODE_HANDWRITING, !IS_AUX, !IS_OVERRIDES_IMPLICITLY_ENABLED_SUBTYPE, !IS_ASCII_CAPABLE, !IS_ENABLED_WHEN_DEFAULT_IS_NOT_ASCII_CAPABLE);
    final InputMethodSubtype nonAutoHandwritingFr = createDummyInputMethodSubtype("fr", SUBTYPE_MODE_HANDWRITING, !IS_AUX, !IS_OVERRIDES_IMPLICITLY_ENABLED_SUBTYPE, !IS_ASCII_CAPABLE, !IS_ENABLED_WHEN_DEFAULT_IS_NOT_ASCII_CAPABLE);
    final InputMethodSubtype nonAutoHandwritingSrCyrl = createDummyInputMethodSubtype("sr", "sr-Cyrl", SUBTYPE_MODE_HANDWRITING, !IS_AUX, !IS_OVERRIDES_IMPLICITLY_ENABLED_SUBTYPE, !IS_ASCII_CAPABLE, !IS_ENABLED_WHEN_DEFAULT_IS_NOT_ASCII_CAPABLE);
    final InputMethodSubtype nonAutoHandwritingSrLatn = createDummyInputMethodSubtype("sr_ZZ", "sr-Latn", SUBTYPE_MODE_HANDWRITING, !IS_AUX, !IS_OVERRIDES_IMPLICITLY_ENABLED_SUBTYPE, !IS_ASCII_CAPABLE, !IS_ENABLED_WHEN_DEFAULT_IS_NOT_ASCII_CAPABLE);
    final InputMethodSubtype nonAutoEnabledWhenDefaultIsNotAsciiCalableSubtype = createDummyInputMethodSubtype("zz", SUBTYPE_MODE_KEYBOARD, !IS_AUX, !IS_OVERRIDES_IMPLICITLY_ENABLED_SUBTYPE, !IS_ASCII_CAPABLE, IS_ENABLED_WHEN_DEFAULT_IS_NOT_ASCII_CAPABLE);
    final InputMethodSubtype nonAutoEnabledWhenDefaultIsNotAsciiCalableSubtype2 = createDummyInputMethodSubtype("zz", SUBTYPE_MODE_KEYBOARD, !IS_AUX, !IS_OVERRIDES_IMPLICITLY_ENABLED_SUBTYPE, !IS_ASCII_CAPABLE, IS_ENABLED_WHEN_DEFAULT_IS_NOT_ASCII_CAPABLE);
    // Make sure that an automatic subtype (overridesImplicitlyEnabledSubtype:true) is
    // selected no matter what locale is specified.
    {
        final ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();
        subtypes.add(nonAutoEnUS);
        subtypes.add(nonAutoEnGB);
        subtypes.add(nonAutoJa);
        subtypes.add(nonAutoFil);
        // overridesImplicitlyEnabledSubtype == true
        subtypes.add(autoSubtype);
        subtypes.add(nonAutoEnabledWhenDefaultIsNotAsciiCalableSubtype);
        subtypes.add(nonAutoEnabledWhenDefaultIsNotAsciiCalableSubtype2);
        subtypes.add(nonAutoHandwritingEn);
        subtypes.add(nonAutoHandwritingFr);
        final InputMethodInfo imi = createDummyInputMethodInfo("com.android.apps.inputmethod.latin", "com.android.apps.inputmethod.latin", "DummyLatinIme", !IS_AUX, IS_DEFAULT, subtypes);
        final ArrayList<InputMethodSubtype> result = InputMethodUtils.getImplicitlyApplicableSubtypesLocked(getResourcesForLocales(LOCALE_EN_US), imi);
        assertEquals(1, result.size());
        verifyEquality(autoSubtype, result.get(0));
    }
    // Make sure that a subtype whose locale is exactly equal to the specified locale is
    // selected as long as there is no no automatic subtype
    // (overridesImplicitlyEnabledSubtype:true) in the given list.
    {
        final ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();
        // locale == "en_US"
        subtypes.add(nonAutoEnUS);
        subtypes.add(nonAutoEnGB);
        subtypes.add(nonAutoJa);
        subtypes.add(nonAutoFil);
        subtypes.add(nonAutoEnabledWhenDefaultIsNotAsciiCalableSubtype);
        subtypes.add(nonAutoEnabledWhenDefaultIsNotAsciiCalableSubtype2);
        subtypes.add(nonAutoHandwritingEn);
        subtypes.add(nonAutoHandwritingFr);
        final InputMethodInfo imi = createDummyInputMethodInfo("com.android.apps.inputmethod.latin", "com.android.apps.inputmethod.latin", "DummyLatinIme", !IS_AUX, IS_DEFAULT, subtypes);
        final ArrayList<InputMethodSubtype> result = InputMethodUtils.getImplicitlyApplicableSubtypesLocked(getResourcesForLocales(LOCALE_EN_US), imi);
        assertEquals(2, result.size());
        verifyEquality(nonAutoEnUS, result.get(0));
        verifyEquality(nonAutoHandwritingEn, result.get(1));
    }
    // Make sure that a subtype whose locale is exactly equal to the specified locale is
    // selected as long as there is no automatic subtype
    // (overridesImplicitlyEnabledSubtype:true) in the given list.
    {
        final ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();
        subtypes.add(nonAutoEnUS);
        // locale == "en_GB"
        subtypes.add(nonAutoEnGB);
        subtypes.add(nonAutoJa);
        subtypes.add(nonAutoFil);
        subtypes.add(nonAutoEnabledWhenDefaultIsNotAsciiCalableSubtype);
        subtypes.add(nonAutoHandwritingEn);
        subtypes.add(nonAutoHandwritingFr);
        final InputMethodInfo imi = createDummyInputMethodInfo("com.android.apps.inputmethod.latin", "com.android.apps.inputmethod.latin", "DummyLatinIme", !IS_AUX, IS_DEFAULT, subtypes);
        final ArrayList<InputMethodSubtype> result = InputMethodUtils.getImplicitlyApplicableSubtypesLocked(getResourcesForLocales(LOCALE_EN_GB), imi);
        assertEquals(2, result.size());
        verifyEquality(nonAutoEnGB, result.get(0));
        verifyEquality(nonAutoHandwritingEn, result.get(1));
    }
    // If there is no automatic subtype (overridesImplicitlyEnabledSubtype:true) and
    // any subtype whose locale is exactly equal to the specified locale in the given list,
    // try to find a subtype whose language is equal to the language part of the given locale.
    // Here make sure that a subtype (locale: "fr_CA") can be found with locale: "fr".
    {
        final ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();
        // locale == "fr_CA"
        subtypes.add(nonAutoFrCA);
        subtypes.add(nonAutoJa);
        subtypes.add(nonAutoFil);
        subtypes.add(nonAutoEnabledWhenDefaultIsNotAsciiCalableSubtype);
        subtypes.add(nonAutoEnabledWhenDefaultIsNotAsciiCalableSubtype2);
        subtypes.add(nonAutoHandwritingEn);
        subtypes.add(nonAutoHandwritingFr);
        final InputMethodInfo imi = createDummyInputMethodInfo("com.android.apps.inputmethod.latin", "com.android.apps.inputmethod.latin", "DummyLatinIme", !IS_AUX, IS_DEFAULT, subtypes);
        final ArrayList<InputMethodSubtype> result = InputMethodUtils.getImplicitlyApplicableSubtypesLocked(getResourcesForLocales(LOCALE_FR), imi);
        assertEquals(2, result.size());
        verifyEquality(nonAutoFrCA, result.get(0));
        verifyEquality(nonAutoHandwritingFr, result.get(1));
    }
    // Then make sure that a subtype (locale: "fr") can be found with locale: "fr_CA".
    {
        final ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();
        // locale == "fr"
        subtypes.add(nonAutoFr);
        subtypes.add(nonAutoJa);
        subtypes.add(nonAutoFil);
        subtypes.add(nonAutoEnabledWhenDefaultIsNotAsciiCalableSubtype);
        subtypes.add(nonAutoEnabledWhenDefaultIsNotAsciiCalableSubtype2);
        subtypes.add(nonAutoHandwritingEn);
        subtypes.add(nonAutoHandwritingFr);
        final InputMethodInfo imi = createDummyInputMethodInfo("com.android.apps.inputmethod.latin", "com.android.apps.inputmethod.latin", "DummyLatinIme", !IS_AUX, IS_DEFAULT, subtypes);
        final ArrayList<InputMethodSubtype> result = InputMethodUtils.getImplicitlyApplicableSubtypesLocked(getResourcesForLocales(LOCALE_FR_CA), imi);
        assertEquals(2, result.size());
        verifyEquality(nonAutoFrCA, result.get(0));
        verifyEquality(nonAutoHandwritingFr, result.get(1));
    }
    // Make sure that subtypes which have "EnabledWhenDefaultIsNotAsciiCapable" in its
    // extra value is selected if and only if all other selected IMEs are not AsciiCapable.
    {
        final ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();
        subtypes.add(nonAutoEnUS);
        // not ASCII capable
        subtypes.add(nonAutoJa);
        subtypes.add(nonAutoEnabledWhenDefaultIsNotAsciiCalableSubtype);
        subtypes.add(nonAutoEnabledWhenDefaultIsNotAsciiCalableSubtype2);
        subtypes.add(nonAutoHandwritingEn);
        subtypes.add(nonAutoHandwritingFr);
        final InputMethodInfo imi = createDummyInputMethodInfo("com.android.apps.inputmethod.latin", "com.android.apps.inputmethod.latin", "DummyLatinIme", !IS_AUX, IS_DEFAULT, subtypes);
        final ArrayList<InputMethodSubtype> result = InputMethodUtils.getImplicitlyApplicableSubtypesLocked(getResourcesForLocales(LOCALE_JA_JP), imi);
        assertEquals(3, result.size());
        verifyEquality(nonAutoJa, result.get(0));
        verifyEquality(nonAutoEnabledWhenDefaultIsNotAsciiCalableSubtype, result.get(1));
        verifyEquality(nonAutoEnabledWhenDefaultIsNotAsciiCalableSubtype2, result.get(2));
    }
    // Make sure that if there is no subtype that matches the language requested, then we just
    // use the first keyboard subtype.
    {
        final ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();
        subtypes.add(nonAutoHi);
        subtypes.add(nonAutoEnUS);
        subtypes.add(nonAutoHandwritingEn);
        subtypes.add(nonAutoHandwritingFr);
        subtypes.add(nonAutoEnabledWhenDefaultIsNotAsciiCalableSubtype);
        final InputMethodInfo imi = createDummyInputMethodInfo("com.android.apps.inputmethod.latin", "com.android.apps.inputmethod.latin", "DummyLatinIme", !IS_AUX, IS_DEFAULT, subtypes);
        final ArrayList<InputMethodSubtype> result = InputMethodUtils.getImplicitlyApplicableSubtypesLocked(getResourcesForLocales(LOCALE_JA_JP), imi);
        assertEquals(1, result.size());
        verifyEquality(nonAutoHi, result.get(0));
    }
    {
        final ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();
        subtypes.add(nonAutoEnUS);
        subtypes.add(nonAutoHi);
        subtypes.add(nonAutoHandwritingEn);
        subtypes.add(nonAutoHandwritingFr);
        subtypes.add(nonAutoEnabledWhenDefaultIsNotAsciiCalableSubtype);
        final InputMethodInfo imi = createDummyInputMethodInfo("com.android.apps.inputmethod.latin", "com.android.apps.inputmethod.latin", "DummyLatinIme", !IS_AUX, IS_DEFAULT, subtypes);
        final ArrayList<InputMethodSubtype> result = InputMethodUtils.getImplicitlyApplicableSubtypesLocked(getResourcesForLocales(LOCALE_JA_JP), imi);
        assertEquals(1, result.size());
        verifyEquality(nonAutoEnUS, result.get(0));
    }
    {
        final ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();
        subtypes.add(nonAutoHandwritingEn);
        subtypes.add(nonAutoHandwritingFr);
        subtypes.add(nonAutoEnUS);
        subtypes.add(nonAutoHi);
        subtypes.add(nonAutoEnabledWhenDefaultIsNotAsciiCalableSubtype);
        final InputMethodInfo imi = createDummyInputMethodInfo("com.android.apps.inputmethod.latin", "com.android.apps.inputmethod.latin", "DummyLatinIme", !IS_AUX, IS_DEFAULT, subtypes);
        final ArrayList<InputMethodSubtype> result = InputMethodUtils.getImplicitlyApplicableSubtypesLocked(getResourcesForLocales(LOCALE_JA_JP), imi);
        assertEquals(1, result.size());
        verifyEquality(nonAutoEnUS, result.get(0));
    }
    // Make sure that both language and script are taken into account to find the best matching
    // subtype.
    {
        final ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();
        subtypes.add(nonAutoEnUS);
        subtypes.add(nonAutoSrCyrl);
        subtypes.add(nonAutoSrLatn);
        subtypes.add(nonAutoHandwritingEn);
        subtypes.add(nonAutoHandwritingFr);
        subtypes.add(nonAutoHandwritingSrCyrl);
        subtypes.add(nonAutoHandwritingSrLatn);
        final InputMethodInfo imi = createDummyInputMethodInfo("com.android.apps.inputmethod.latin", "com.android.apps.inputmethod.latin", "DummyLatinIme", !IS_AUX, IS_DEFAULT, subtypes);
        final ArrayList<InputMethodSubtype> result = InputMethodUtils.getImplicitlyApplicableSubtypesLocked(getResourcesForLocales(Locale.forLanguageTag("sr-Latn-RS")), imi);
        assertEquals(2, result.size());
        assertThat(nonAutoSrLatn, isIn(result));
        assertThat(nonAutoHandwritingSrLatn, isIn(result));
    }
    {
        final ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();
        subtypes.add(nonAutoEnUS);
        subtypes.add(nonAutoSrCyrl);
        subtypes.add(nonAutoSrLatn);
        subtypes.add(nonAutoHandwritingEn);
        subtypes.add(nonAutoHandwritingFr);
        subtypes.add(nonAutoHandwritingSrCyrl);
        subtypes.add(nonAutoHandwritingSrLatn);
        final InputMethodInfo imi = createDummyInputMethodInfo("com.android.apps.inputmethod.latin", "com.android.apps.inputmethod.latin", "DummyLatinIme", !IS_AUX, IS_DEFAULT, subtypes);
        final ArrayList<InputMethodSubtype> result = InputMethodUtils.getImplicitlyApplicableSubtypesLocked(getResourcesForLocales(Locale.forLanguageTag("sr-Cyrl-RS")), imi);
        assertEquals(2, result.size());
        assertThat(nonAutoSrCyrl, isIn(result));
        assertThat(nonAutoHandwritingSrCyrl, isIn(result));
    }
    // Make sure that secondary locales are taken into account to find the best matching
    // subtype.
    {
        final ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();
        subtypes.add(nonAutoEnUS);
        subtypes.add(nonAutoEnGB);
        subtypes.add(nonAutoSrCyrl);
        subtypes.add(nonAutoSrLatn);
        subtypes.add(nonAutoFr);
        subtypes.add(nonAutoFrCA);
        subtypes.add(nonAutoHandwritingEn);
        subtypes.add(nonAutoHandwritingFr);
        subtypes.add(nonAutoHandwritingSrCyrl);
        subtypes.add(nonAutoHandwritingSrLatn);
        final InputMethodInfo imi = createDummyInputMethodInfo("com.android.apps.inputmethod.latin", "com.android.apps.inputmethod.latin", "DummyLatinIme", !IS_AUX, IS_DEFAULT, subtypes);
        final ArrayList<InputMethodSubtype> result = InputMethodUtils.getImplicitlyApplicableSubtypesLocked(getResourcesForLocales(Locale.forLanguageTag("sr-Latn-RS-x-android"), Locale.forLanguageTag("ja-JP"), Locale.forLanguageTag("fr-FR"), Locale.forLanguageTag("en-GB"), Locale.forLanguageTag("en-US")), imi);
        assertEquals(6, result.size());
        assertThat(nonAutoEnGB, isIn(result));
        assertThat(nonAutoFr, isIn(result));
        assertThat(nonAutoSrLatn, isIn(result));
        assertThat(nonAutoHandwritingEn, isIn(result));
        assertThat(nonAutoHandwritingFr, isIn(result));
        assertThat(nonAutoHandwritingSrLatn, isIn(result));
    }
    // Make sure that 3-letter language code can be handled.
    {
        final ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();
        subtypes.add(nonAutoEnUS);
        subtypes.add(nonAutoFil);
        final InputMethodInfo imi = createDummyInputMethodInfo("com.android.apps.inputmethod.latin", "com.android.apps.inputmethod.latin", "DummyLatinIme", !IS_AUX, IS_DEFAULT, subtypes);
        final ArrayList<InputMethodSubtype> result = InputMethodUtils.getImplicitlyApplicableSubtypesLocked(getResourcesForLocales(LOCALE_FIL_PH), imi);
        assertEquals(1, result.size());
        verifyEquality(nonAutoFil, result.get(0));
    }
    // Make sure that we never end up matching "fi" (finnish) with "fil" (filipino).
    // Also make sure that the first subtype will be used as the last-resort candidate.
    {
        final ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();
        subtypes.add(nonAutoJa);
        subtypes.add(nonAutoEnUS);
        subtypes.add(nonAutoFil);
        final InputMethodInfo imi = createDummyInputMethodInfo("com.android.apps.inputmethod.latin", "com.android.apps.inputmethod.latin", "DummyLatinIme", !IS_AUX, IS_DEFAULT, subtypes);
        final ArrayList<InputMethodSubtype> result = InputMethodUtils.getImplicitlyApplicableSubtypesLocked(getResourcesForLocales(LOCALE_FI), imi);
        assertEquals(1, result.size());
        verifyEquality(nonAutoJa, result.get(0));
    }
    // Make sure that "in" and "id" conversion is taken into account.
    {
        final ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();
        subtypes.add(nonAutoIn);
        subtypes.add(nonAutoEnUS);
        final InputMethodInfo imi = createDummyInputMethodInfo("com.android.apps.inputmethod.latin", "com.android.apps.inputmethod.latin", "DummyLatinIme", !IS_AUX, IS_DEFAULT, subtypes);
        final ArrayList<InputMethodSubtype> result = InputMethodUtils.getImplicitlyApplicableSubtypesLocked(getResourcesForLocales(LOCALE_IN), imi);
        assertEquals(1, result.size());
        verifyEquality(nonAutoIn, result.get(0));
    }
    {
        final ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();
        subtypes.add(nonAutoIn);
        subtypes.add(nonAutoEnUS);
        final InputMethodInfo imi = createDummyInputMethodInfo("com.android.apps.inputmethod.latin", "com.android.apps.inputmethod.latin", "DummyLatinIme", !IS_AUX, IS_DEFAULT, subtypes);
        final ArrayList<InputMethodSubtype> result = InputMethodUtils.getImplicitlyApplicableSubtypesLocked(getResourcesForLocales(LOCALE_ID), imi);
        assertEquals(1, result.size());
        verifyEquality(nonAutoIn, result.get(0));
    }
    {
        final ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();
        subtypes.add(nonAutoId);
        subtypes.add(nonAutoEnUS);
        final InputMethodInfo imi = createDummyInputMethodInfo("com.android.apps.inputmethod.latin", "com.android.apps.inputmethod.latin", "DummyLatinIme", !IS_AUX, IS_DEFAULT, subtypes);
        final ArrayList<InputMethodSubtype> result = InputMethodUtils.getImplicitlyApplicableSubtypesLocked(getResourcesForLocales(LOCALE_IN), imi);
        assertEquals(1, result.size());
        verifyEquality(nonAutoId, result.get(0));
    }
    {
        final ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();
        subtypes.add(nonAutoId);
        subtypes.add(nonAutoEnUS);
        final InputMethodInfo imi = createDummyInputMethodInfo("com.android.apps.inputmethod.latin", "com.android.apps.inputmethod.latin", "DummyLatinIme", !IS_AUX, IS_DEFAULT, subtypes);
        final ArrayList<InputMethodSubtype> result = InputMethodUtils.getImplicitlyApplicableSubtypesLocked(getResourcesForLocales(LOCALE_ID), imi);
        assertEquals(1, result.size());
        verifyEquality(nonAutoId, result.get(0));
    }
    // If there is no automatic subtype (overridesImplicitlyEnabledSubtype:true) and the system
    // provides multiple locales, we try to enable multiple subtypes.
    {
        final ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();
        subtypes.add(nonAutoEnUS);
        subtypes.add(nonAutoFrCA);
        subtypes.add(nonAutoIn);
        subtypes.add(nonAutoJa);
        subtypes.add(nonAutoFil);
        subtypes.add(nonAutoEnabledWhenDefaultIsNotAsciiCalableSubtype);
        subtypes.add(nonAutoEnabledWhenDefaultIsNotAsciiCalableSubtype2);
        final InputMethodInfo imi = createDummyInputMethodInfo("com.android.apps.inputmethod.latin", "com.android.apps.inputmethod.latin", "DummyLatinIme", !IS_AUX, IS_DEFAULT, subtypes);
        final ArrayList<InputMethodSubtype> result = InputMethodUtils.getImplicitlyApplicableSubtypesLocked(getResourcesForLocales(LOCALE_FR, LOCALE_EN_US, LOCALE_JA_JP), imi);
        assertThat(nonAutoFrCA, isIn(result));
        assertThat(nonAutoEnUS, isIn(result));
        assertThat(nonAutoJa, isIn(result));
        assertThat(nonAutoIn, not(isIn(result)));
        assertThat(nonAutoEnabledWhenDefaultIsNotAsciiCalableSubtype, not(isIn(result)));
        assertThat(nonAutoEnabledWhenDefaultIsNotAsciiCalableSubtype, not(isIn(result)));
    }
}

Example 10 with InputMethodSubtype

use of android.view.inputmethod.InputMethodSubtype in project platform_frameworks_base by android.

the class InputMethodUtilsTest method testContainsSubtypeOf.

@SmallTest
public void testContainsSubtypeOf() throws Exception {
    final InputMethodSubtype nonAutoEnUS = createDummyInputMethodSubtype("en_US", SUBTYPE_MODE_KEYBOARD, !IS_AUX, !IS_OVERRIDES_IMPLICITLY_ENABLED_SUBTYPE, IS_ASCII_CAPABLE, !IS_ENABLED_WHEN_DEFAULT_IS_NOT_ASCII_CAPABLE);
    final InputMethodSubtype nonAutoEnGB = createDummyInputMethodSubtype("en_GB", SUBTYPE_MODE_KEYBOARD, !IS_AUX, !IS_OVERRIDES_IMPLICITLY_ENABLED_SUBTYPE, IS_ASCII_CAPABLE, IS_ENABLED_WHEN_DEFAULT_IS_NOT_ASCII_CAPABLE);
    final InputMethodSubtype nonAutoFil = createDummyInputMethodSubtype("fil", SUBTYPE_MODE_KEYBOARD, !IS_AUX, !IS_OVERRIDES_IMPLICITLY_ENABLED_SUBTYPE, IS_ASCII_CAPABLE, !IS_ENABLED_WHEN_DEFAULT_IS_NOT_ASCII_CAPABLE);
    final InputMethodSubtype nonAutoFilPH = createDummyInputMethodSubtype("fil_PH", SUBTYPE_MODE_KEYBOARD, !IS_AUX, !IS_OVERRIDES_IMPLICITLY_ENABLED_SUBTYPE, IS_ASCII_CAPABLE, !IS_ENABLED_WHEN_DEFAULT_IS_NOT_ASCII_CAPABLE);
    final InputMethodSubtype nonAutoIn = createDummyInputMethodSubtype("in", SUBTYPE_MODE_KEYBOARD, !IS_AUX, !IS_OVERRIDES_IMPLICITLY_ENABLED_SUBTYPE, IS_ASCII_CAPABLE, IS_ENABLED_WHEN_DEFAULT_IS_NOT_ASCII_CAPABLE);
    final InputMethodSubtype nonAutoId = createDummyInputMethodSubtype("id", SUBTYPE_MODE_KEYBOARD, !IS_AUX, !IS_OVERRIDES_IMPLICITLY_ENABLED_SUBTYPE, IS_ASCII_CAPABLE, IS_ENABLED_WHEN_DEFAULT_IS_NOT_ASCII_CAPABLE);
    final boolean CHECK_COUNTRY = true;
    {
        final ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();
        subtypes.add(nonAutoEnUS);
        final InputMethodInfo imi = createDummyInputMethodInfo("com.android.apps.inputmethod.latin", "com.android.apps.inputmethod.latin", "DummyLatinIme", !IS_AUX, IS_DEFAULT, subtypes);
        assertTrue(InputMethodUtils.containsSubtypeOf(imi, LOCALE_EN, !CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
        assertFalse(InputMethodUtils.containsSubtypeOf(imi, LOCALE_EN, CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
        assertTrue(InputMethodUtils.containsSubtypeOf(imi, LOCALE_EN_US, !CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
        assertTrue(InputMethodUtils.containsSubtypeOf(imi, LOCALE_EN_US, CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
        assertFalse(InputMethodUtils.containsSubtypeOf(imi, LOCALE_EN_US, !CHECK_COUNTRY, SUBTYPE_MODE_VOICE));
        assertFalse(InputMethodUtils.containsSubtypeOf(imi, LOCALE_EN_US, CHECK_COUNTRY, SUBTYPE_MODE_VOICE));
        assertTrue(InputMethodUtils.containsSubtypeOf(imi, LOCALE_EN_US, !CHECK_COUNTRY, SUBTYPE_MODE_ANY));
        assertTrue(InputMethodUtils.containsSubtypeOf(imi, LOCALE_EN_US, CHECK_COUNTRY, SUBTYPE_MODE_ANY));
        assertTrue(InputMethodUtils.containsSubtypeOf(imi, LOCALE_EN_GB, !CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
        assertFalse(InputMethodUtils.containsSubtypeOf(imi, LOCALE_EN_GB, CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
    }
    // Make sure that 3-letter language code ("fil") can be handled.
    {
        final ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();
        subtypes.add(nonAutoFil);
        final InputMethodInfo imi = createDummyInputMethodInfo("com.android.apps.inputmethod.latin", "com.android.apps.inputmethod.latin", "DummyLatinIme", !IS_AUX, IS_DEFAULT, subtypes);
        assertTrue(InputMethodUtils.containsSubtypeOf(imi, LOCALE_FIL, !CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
        assertTrue(InputMethodUtils.containsSubtypeOf(imi, LOCALE_FIL, CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
        assertTrue(InputMethodUtils.containsSubtypeOf(imi, LOCALE_FIL_PH, !CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
        assertFalse(InputMethodUtils.containsSubtypeOf(imi, LOCALE_FIL_PH, CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
        assertFalse(InputMethodUtils.containsSubtypeOf(imi, LOCALE_FI, !CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
        assertFalse(InputMethodUtils.containsSubtypeOf(imi, LOCALE_FI, CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
        assertFalse(InputMethodUtils.containsSubtypeOf(imi, LOCALE_FI_FI, !CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
        assertFalse(InputMethodUtils.containsSubtypeOf(imi, LOCALE_FI_FI, CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
    }
    // Make sure that 3-letter language code ("fil_PH") can be handled.
    {
        final ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();
        subtypes.add(nonAutoFilPH);
        final InputMethodInfo imi = createDummyInputMethodInfo("com.android.apps.inputmethod.latin", "com.android.apps.inputmethod.latin", "DummyLatinIme", !IS_AUX, IS_DEFAULT, subtypes);
        assertTrue(InputMethodUtils.containsSubtypeOf(imi, LOCALE_FIL, !CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
        assertFalse(InputMethodUtils.containsSubtypeOf(imi, LOCALE_FIL, CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
        assertTrue(InputMethodUtils.containsSubtypeOf(imi, LOCALE_FIL_PH, !CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
        assertTrue(InputMethodUtils.containsSubtypeOf(imi, LOCALE_FIL_PH, CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
        assertFalse(InputMethodUtils.containsSubtypeOf(imi, LOCALE_FI, !CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
        assertFalse(InputMethodUtils.containsSubtypeOf(imi, LOCALE_FI, CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
        assertFalse(InputMethodUtils.containsSubtypeOf(imi, LOCALE_FI_FI, !CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
        assertFalse(InputMethodUtils.containsSubtypeOf(imi, LOCALE_FI_FI, CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
    }
    // Make sure that a subtype whose locale is "in" can be queried with "id".
    {
        final ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();
        subtypes.add(nonAutoIn);
        subtypes.add(nonAutoEnUS);
        final InputMethodInfo imi = createDummyInputMethodInfo("com.android.apps.inputmethod.latin", "com.android.apps.inputmethod.latin", "DummyLatinIme", !IS_AUX, IS_DEFAULT, subtypes);
        assertTrue(InputMethodUtils.containsSubtypeOf(imi, LOCALE_IN, !CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
        assertTrue(InputMethodUtils.containsSubtypeOf(imi, LOCALE_IN, CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
        assertTrue(InputMethodUtils.containsSubtypeOf(imi, LOCALE_ID, !CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
        assertTrue(InputMethodUtils.containsSubtypeOf(imi, LOCALE_ID, CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
    }
    // Make sure that a subtype whose locale is "id" can be queried with "in".
    {
        final ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();
        subtypes.add(nonAutoId);
        subtypes.add(nonAutoEnUS);
        final InputMethodInfo imi = createDummyInputMethodInfo("com.android.apps.inputmethod.latin", "com.android.apps.inputmethod.latin", "DummyLatinIme", !IS_AUX, IS_DEFAULT, subtypes);
        assertTrue(InputMethodUtils.containsSubtypeOf(imi, LOCALE_IN, !CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
        assertTrue(InputMethodUtils.containsSubtypeOf(imi, LOCALE_IN, CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
        assertTrue(InputMethodUtils.containsSubtypeOf(imi, LOCALE_ID, !CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
        assertTrue(InputMethodUtils.containsSubtypeOf(imi, LOCALE_ID, CHECK_COUNTRY, SUBTYPE_MODE_KEYBOARD));
    }
}