Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 9d69235a authored by Ming-Shin Lu's avatar Ming-Shin Lu
Browse files

Move some InputMethodUtils methods to SubtypeUtils 

Also, left a TODO comment to note the subType list cache or
InputMethodSettings could support mult-users.

Bug: 235661780
Test: build
Test: atest CtsInputMethodTestCases InputMethodUtilsTest
Change-Id: I0d7d2373e7f6d3cda9c8c6fcf4f10826fc04624e
parent df6c7810

services/core/java/com/android/server/inputmethod/InputMethodManagerService.java

+15 −16
Original line number Diff line number Diff line
@@ -4048,7 +4048,7 @@ public final class InputMethodManagerService extends IInputMethodManager.Stub 
            }

            if (subtype != null) {

                setInputMethodWithSubtypeIdLocked(token, id,

                        InputMethodUtils.getSubtypeIdFromHashCode(mMethodMap.get(id),

                        SubtypeUtils.getSubtypeIdFromHashCode(mMethodMap.get(id),

                                subtype.hashCode()));

            } else {

                setInputMethod(token, id);
@@ -4092,7 +4092,7 @@ public final class InputMethodManagerService extends IInputMethodManager.Stub 
                // defined, there is no need to switch to the last IME.

                if (!imiIdIsSame || lastSubtypeHash != currentSubtypeHash) {

                    targetLastImiId = lastIme.first;

                    subtypeId = InputMethodUtils.getSubtypeIdFromHashCode(lastImi, lastSubtypeHash);

                    subtypeId = SubtypeUtils.getSubtypeIdFromHashCode(lastImi, lastSubtypeHash);

                }

            }
@@ -4111,13 +4111,13 @@ public final class InputMethodManagerService extends IInputMethodManager.Stub 
                        final InputMethodInfo imi = enabled.get(i);

                        if (imi.getSubtypeCount() > 0 && imi.isSystem()) {

                            InputMethodSubtype keyboardSubtype =

                                    InputMethodUtils.findLastResortApplicableSubtypeLocked(mRes,

                                            InputMethodUtils.getSubtypes(imi),

                                    SubtypeUtils.findLastResortApplicableSubtypeLocked(mRes,

                                            SubtypeUtils.getSubtypes(imi),

                                            SubtypeUtils.SUBTYPE_MODE_KEYBOARD, locale, true);

                            if (keyboardSubtype != null) {

                                targetLastImiId = imi.getId();

                                subtypeId = InputMethodUtils.getSubtypeIdFromHashCode(

                                        imi, keyboardSubtype.hashCode());

                                subtypeId = SubtypeUtils.getSubtypeIdFromHashCode(imi,

                                        keyboardSubtype.hashCode());

                                if(keyboardSubtype.getLocale().equals(locale)) {

                                    break;

                                }
@@ -4187,8 +4187,8 @@ public final class InputMethodManagerService extends IInputMethodManager.Stub 
            if (lastImi == null) return null;

            try {

                final int lastSubtypeHash = Integer.parseInt(lastIme.second);

                final int lastSubtypeId =

                        InputMethodUtils.getSubtypeIdFromHashCode(lastImi, lastSubtypeHash);

                final int lastSubtypeId = SubtypeUtils.getSubtypeIdFromHashCode(lastImi,

                        lastSubtypeHash);

                if (lastSubtypeId < 0 || lastSubtypeId >= lastImi.getSubtypeCount()) {

                    return null;

                }
@@ -5192,8 +5192,8 @@ public final class InputMethodManagerService extends IInputMethodManager.Stub 
            String subtypeHashCode = mSettings.getLastSubtypeForInputMethodLocked(newDefaultIme);

            if (subtypeHashCode != null) {

                try {

                    lastSubtypeId = InputMethodUtils.getSubtypeIdFromHashCode(

                            imi, Integer.parseInt(subtypeHashCode));

                    lastSubtypeId = SubtypeUtils.getSubtypeIdFromHashCode(imi,

                            Integer.parseInt(subtypeHashCode));

                } catch (NumberFormatException e) {

                    Slog.w(TAG, "HashCode for subtype looks broken: " + subtypeHashCode, e);

                }
@@ -5228,7 +5228,7 @@ public final class InputMethodManagerService extends IInputMethodManager.Stub 
            return null;

        }

        if (!subtypeIsSelected || mCurrentSubtype == null

                || !InputMethodUtils.isValidSubtypeId(imi, mCurrentSubtype.hashCode())) {

                || !SubtypeUtils.isValidSubtypeId(imi, mCurrentSubtype.hashCode())) {

            int subtypeId = mSettings.getSelectedInputMethodSubtypeId(selectedMethodId);

            if (subtypeId == NOT_A_SUBTYPE_ID) {

                // If there are no selected subtypes, the framework will try to find
@@ -5241,17 +5241,16 @@ public final class InputMethodManagerService extends IInputMethodManager.Stub 
                if (explicitlyOrImplicitlyEnabledSubtypes.size() == 1) {

                    mCurrentSubtype = explicitlyOrImplicitlyEnabledSubtypes.get(0);

                } else if (explicitlyOrImplicitlyEnabledSubtypes.size() > 1) {

                    mCurrentSubtype = InputMethodUtils.findLastResortApplicableSubtypeLocked(

                    mCurrentSubtype = SubtypeUtils.findLastResortApplicableSubtypeLocked(

                            mRes, explicitlyOrImplicitlyEnabledSubtypes,

                            SubtypeUtils.SUBTYPE_MODE_KEYBOARD, null, true);

                    if (mCurrentSubtype == null) {

                        mCurrentSubtype = InputMethodUtils.findLastResortApplicableSubtypeLocked(

                                mRes, explicitlyOrImplicitlyEnabledSubtypes, null, null,

                                true);

                        mCurrentSubtype = SubtypeUtils.findLastResortApplicableSubtypeLocked(

                                mRes, explicitlyOrImplicitlyEnabledSubtypes, null, null, true);

                    }

                }

            } else {

                mCurrentSubtype = InputMethodUtils.getSubtypes(imi).get(subtypeId);

                mCurrentSubtype = SubtypeUtils.getSubtypes(imi).get(subtypeId);

            }

        }

        return mCurrentSubtype;

services/core/java/com/android/server/inputmethod/InputMethodMenuController.java

+1 −1
Original line number Diff line number Diff line
@@ -105,7 +105,7 @@ final class InputMethodMenuController { 
                if (currentSubtype != null) {

                    final String curMethodId = mService.getSelectedMethodIdLocked();

                    final InputMethodInfo currentImi = mMethodMap.get(curMethodId);

                    lastInputMethodSubtypeId = InputMethodUtils.getSubtypeIdFromHashCode(

                    lastInputMethodSubtypeId = SubtypeUtils.getSubtypeIdFromHashCode(

                            currentImi, currentSubtype.hashCode());

                }

            }

services/core/java/com/android/server/inputmethod/InputMethodSubtypeSwitchingController.java

+2 −2
Original line number Diff line number Diff line
@@ -241,8 +241,8 @@ final class InputMethodSubtypeSwitchingController { 
    }



    private static int calculateSubtypeId(InputMethodInfo imi, InputMethodSubtype subtype) {

        return subtype != null ? InputMethodUtils.getSubtypeIdFromHashCode(imi,

                subtype.hashCode()) : NOT_A_SUBTYPE_ID;

        return subtype != null ? SubtypeUtils.getSubtypeIdFromHashCode(imi, subtype.hashCode())

                : NOT_A_SUBTYPE_ID;

    }



    private static class StaticRotationList {

services/core/java/com/android/server/inputmethod/InputMethodUtils.java

+5 −230
Original line number Diff line number Diff line
@@ -27,7 +27,6 @@ import android.content.pm.ApplicationInfo; 
import android.content.pm.PackageManager;

import android.content.res.Resources;

import android.os.Build;

import android.os.LocaleList;

import android.os.UserHandle;

import android.provider.Settings;

import android.text.TextUtils;
@@ -40,8 +39,6 @@ import android.view.inputmethod.InputMethodInfo; 
import android.view.inputmethod.InputMethodSubtype;

import android.view.textservice.SpellCheckerInfo;



import com.android.internal.annotations.GuardedBy;

import com.android.internal.annotations.VisibleForTesting;

import com.android.internal.inputmethod.StartInputFlags;

import com.android.server.LocalServices;

import com.android.server.pm.UserManagerInternal;
@@ -51,7 +48,6 @@ import java.io.PrintWriter; 
import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.Locale;

import java.util.function.Predicate;



/**
@@ -67,25 +63,12 @@ final class InputMethodUtils { 
    static final int NOT_A_SUBTYPE_ID = -1;

    private static final String TAG = "InputMethodUtils";

    private static final String NOT_A_SUBTYPE_ID_STR = String.valueOf(NOT_A_SUBTYPE_ID);

    private static final String TAG_ENABLED_WHEN_DEFAULT_IS_NOT_ASCII_CAPABLE =

            "EnabledWhenDefaultIsNotAsciiCapable";



    // The string for enabled input method is saved as follows:

    // example: ("ime0;subtype0;subtype1;subtype2:ime1:ime2;subtype0")

    private static final char INPUT_METHOD_SEPARATOR = ':';

    private static final char INPUT_METHOD_SUBTYPE_SEPARATOR = ';';



    // A temporary workaround for the performance concerns in

    // #getImplicitlyApplicableSubtypesLocked(Resources, InputMethodInfo).

    // TODO: Optimize all the critical paths including this one.

    private static final Object sCacheLock = new Object();

    @GuardedBy("sCacheLock")

    private static LocaleList sCachedSystemLocales;

    @GuardedBy("sCacheLock")

    private static InputMethodInfo sCachedInputMethodInfo;

    @GuardedBy("sCacheLock")

    private static ArrayList<InputMethodSubtype> sCachedResult;



    private InputMethodUtils() {

        // This utility class is not publicly instantiable.

    }
@@ -115,215 +98,6 @@ final class InputMethodUtils { 
    }

    // ----------------------------------------------------------------------



    static ArrayList<InputMethodSubtype> getSubtypes(InputMethodInfo imi) {

        ArrayList<InputMethodSubtype> subtypes = new ArrayList<>();

        final int subtypeCount = imi.getSubtypeCount();

        for (int i = 0; i < subtypeCount; ++i) {

            subtypes.add(imi.getSubtypeAt(i));

        }

        return subtypes;

    }



    static boolean isValidSubtypeId(InputMethodInfo imi, int subtypeHashCode) {

        return getSubtypeIdFromHashCode(imi, subtypeHashCode) != NOT_A_SUBTYPE_ID;

    }



    static int getSubtypeIdFromHashCode(InputMethodInfo imi, int subtypeHashCode) {

        if (imi != null) {

            final int subtypeCount = imi.getSubtypeCount();

            for (int i = 0; i < subtypeCount; ++i) {

                InputMethodSubtype ims = imi.getSubtypeAt(i);

                if (subtypeHashCode == ims.hashCode()) {

                    return i;

                }

            }

        }

        return NOT_A_SUBTYPE_ID;

    }



    private static final LocaleUtils.LocaleExtractor<InputMethodSubtype> sSubtypeToLocale =

            new LocaleUtils.LocaleExtractor<InputMethodSubtype>() {

                @Override

                public Locale get(InputMethodSubtype source) {

                    return source != null ? source.getLocaleObject() : null;

                }

            };



    @VisibleForTesting

    static ArrayList<InputMethodSubtype> getImplicitlyApplicableSubtypesLocked(

            Resources res, InputMethodInfo imi) {

        final LocaleList systemLocales = res.getConfiguration().getLocales();



        synchronized (sCacheLock) {

            // We intentionally do not use InputMethodInfo#equals(InputMethodInfo) here because

            // it does not check if subtypes are also identical.

            if (systemLocales.equals(sCachedSystemLocales) && sCachedInputMethodInfo == imi) {

                return new ArrayList<>(sCachedResult);

            }

        }



        // Note: Only resource info in "res" is used in getImplicitlyApplicableSubtypesLockedImpl().

        // TODO: Refactor getImplicitlyApplicableSubtypesLockedImpl() so that it can receive

        // LocaleList rather than Resource.

        final ArrayList<InputMethodSubtype> result =

                getImplicitlyApplicableSubtypesLockedImpl(res, imi);

        synchronized (sCacheLock) {

            // Both LocaleList and InputMethodInfo are immutable. No need to copy them here.

            sCachedSystemLocales = systemLocales;

            sCachedInputMethodInfo = imi;

            sCachedResult = new ArrayList<>(result);

        }

        return result;

    }



    private static ArrayList<InputMethodSubtype> getImplicitlyApplicableSubtypesLockedImpl(

            Resources res, InputMethodInfo imi) {

        final List<InputMethodSubtype> subtypes = InputMethodUtils.getSubtypes(imi);

        final LocaleList systemLocales = res.getConfiguration().getLocales();

        final String systemLocale = systemLocales.get(0).toString();

        if (TextUtils.isEmpty(systemLocale)) return new ArrayList<>();

        final int numSubtypes = subtypes.size();



        // Handle overridesImplicitlyEnabledSubtype mechanism.

        final ArrayMap<String, InputMethodSubtype> applicableModeAndSubtypesMap = new ArrayMap<>();

        for (int i = 0; i < numSubtypes; ++i) {

            // scan overriding implicitly enabled subtypes.

            final InputMethodSubtype subtype = subtypes.get(i);

            if (subtype.overridesImplicitlyEnabledSubtype()) {

                final String mode = subtype.getMode();

                if (!applicableModeAndSubtypesMap.containsKey(mode)) {

                    applicableModeAndSubtypesMap.put(mode, subtype);

                }

            }

        }

        if (applicableModeAndSubtypesMap.size() > 0) {

            return new ArrayList<>(applicableModeAndSubtypesMap.values());

        }



        final ArrayMap<String, ArrayList<InputMethodSubtype>> nonKeyboardSubtypesMap =

                new ArrayMap<>();

        final ArrayList<InputMethodSubtype> keyboardSubtypes = new ArrayList<>();



        for (int i = 0; i < numSubtypes; ++i) {

            final InputMethodSubtype subtype = subtypes.get(i);

            final String mode = subtype.getMode();

            if (SubtypeUtils.SUBTYPE_MODE_KEYBOARD.equals(mode)) {

                keyboardSubtypes.add(subtype);

            } else {

                if (!nonKeyboardSubtypesMap.containsKey(mode)) {

                    nonKeyboardSubtypesMap.put(mode, new ArrayList<>());

                }

                nonKeyboardSubtypesMap.get(mode).add(subtype);

            }

        }



        final ArrayList<InputMethodSubtype> applicableSubtypes = new ArrayList<>();

        LocaleUtils.filterByLanguage(keyboardSubtypes, sSubtypeToLocale, systemLocales,

                applicableSubtypes);



        if (!applicableSubtypes.isEmpty()) {

            boolean hasAsciiCapableKeyboard = false;

            final int numApplicationSubtypes = applicableSubtypes.size();

            for (int i = 0; i < numApplicationSubtypes; ++i) {

                final InputMethodSubtype subtype = applicableSubtypes.get(i);

                if (subtype.isAsciiCapable()) {

                    hasAsciiCapableKeyboard = true;

                    break;

                }

            }

            if (!hasAsciiCapableKeyboard) {

                final int numKeyboardSubtypes = keyboardSubtypes.size();

                for (int i = 0; i < numKeyboardSubtypes; ++i) {

                    final InputMethodSubtype subtype = keyboardSubtypes.get(i);

                    final String mode = subtype.getMode();

                    if (SubtypeUtils.SUBTYPE_MODE_KEYBOARD.equals(mode)

                            && subtype.containsExtraValueKey(

                            TAG_ENABLED_WHEN_DEFAULT_IS_NOT_ASCII_CAPABLE)) {

                        applicableSubtypes.add(subtype);

                    }

                }

            }

        }



        if (applicableSubtypes.isEmpty()) {

            InputMethodSubtype lastResortKeyboardSubtype = findLastResortApplicableSubtypeLocked(

                    res, subtypes, SubtypeUtils.SUBTYPE_MODE_KEYBOARD, systemLocale, true);

            if (lastResortKeyboardSubtype != null) {

                applicableSubtypes.add(lastResortKeyboardSubtype);

            }

        }



        // For each non-keyboard mode, extract subtypes with system locales.

        for (final ArrayList<InputMethodSubtype> subtypeList : nonKeyboardSubtypesMap.values()) {

            LocaleUtils.filterByLanguage(subtypeList, sSubtypeToLocale, systemLocales,

                    applicableSubtypes);

        }



        return applicableSubtypes;

    }





    /**

     * If there are no selected subtypes, tries finding the most applicable one according to the

     * given locale.

     * @param subtypes this function will search the most applicable subtype in subtypes

     * @param mode subtypes will be filtered by mode

     * @param locale subtypes will be filtered by locale

     * @param canIgnoreLocaleAsLastResort if this function can't find the most applicable subtype,

     * it will return the first subtype matched with mode

     * @return the most applicable subtypeId

     */

    static InputMethodSubtype findLastResortApplicableSubtypeLocked(

            Resources res, List<InputMethodSubtype> subtypes, String mode, String locale,

            boolean canIgnoreLocaleAsLastResort) {

        if (subtypes == null || subtypes.size() == 0) {

            return null;

        }

        if (TextUtils.isEmpty(locale)) {

            locale = res.getConfiguration().locale.toString();

        }

        final String language = LocaleUtils.getLanguageFromLocaleString(locale);

        boolean partialMatchFound = false;

        InputMethodSubtype applicableSubtype = null;

        InputMethodSubtype firstMatchedModeSubtype = null;

        final int N = subtypes.size();

        for (int i = 0; i < N; ++i) {

            InputMethodSubtype subtype = subtypes.get(i);

            final String subtypeLocale = subtype.getLocale();

            final String subtypeLanguage = LocaleUtils.getLanguageFromLocaleString(subtypeLocale);

            // An applicable subtype should match "mode". If mode is null, mode will be ignored,

            // and all subtypes with all modes can be candidates.

            if (mode == null || subtypes.get(i).getMode().equalsIgnoreCase(mode)) {

                if (firstMatchedModeSubtype == null) {

                    firstMatchedModeSubtype = subtype;

                }

                if (locale.equals(subtypeLocale)) {

                    // Exact match (e.g. system locale is "en_US" and subtype locale is "en_US")

                    applicableSubtype = subtype;

                    break;

                } else if (!partialMatchFound && language.equals(subtypeLanguage)) {

                    // Partial match (e.g. system locale is "en_US" and subtype locale is "en")

                    applicableSubtype = subtype;

                    partialMatchFound = true;

                }

            }

        }



        if (applicableSubtype == null && canIgnoreLocaleAsLastResort) {

            return firstMatchedModeSubtype;

        }



        // The first subtype applicable to the system locale will be defined as the most applicable

        // subtype.

        if (DEBUG) {

            if (applicableSubtype != null) {

                Slog.d(TAG, "Applicable InputMethodSubtype was found: "

                        + applicableSubtype.getMode() + "," + applicableSubtype.getLocale());

            }

        }

        return applicableSubtype;

    }



    static boolean canAddToLastInputMethod(InputMethodSubtype subtype) {

        if (subtype == null) return true;

        return !subtype.isAuxiliary();
@@ -457,6 +231,7 @@ final class InputMethodUtils { 
    /**

     * Utility class for putting and getting settings for InputMethod

     * TODO: Move all putters and getters of settings to this class.

     * TODO(b/235661780): Make the setting supports multi-users.

     */

    public static class InputMethodSettings {

        private final TextUtils.SimpleStringSplitter mInputMethodSplitter =
@@ -634,7 +409,7 @@ final class InputMethodUtils { 
            List<InputMethodSubtype> enabledSubtypes =

                    getEnabledInputMethodSubtypeListLocked(imi);

            if (allowsImplicitlySelectedSubtypes && enabledSubtypes.isEmpty()) {

                enabledSubtypes = InputMethodUtils.getImplicitlyApplicableSubtypesLocked(

                enabledSubtypes = SubtypeUtils.getImplicitlyApplicableSubtypesLocked(

                        context.getResources(), imi);

            }

            return InputMethodSubtype.sort(context, 0, imi, enabledSubtypes);
@@ -865,7 +640,7 @@ final class InputMethodUtils { 
                        // are enabled implicitly, so needs to treat them to be enabled.

                        if (imi != null && imi.getSubtypeCount() > 0) {

                            List<InputMethodSubtype> implicitlySelectedSubtypes =

                                    getImplicitlyApplicableSubtypesLocked(mRes, imi);

                                    SubtypeUtils.getImplicitlyApplicableSubtypesLocked(mRes, imi);

                            if (implicitlySelectedSubtypes != null) {

                                final int N = implicitlySelectedSubtypes.size();

                                for (int i = 0; i < N; ++i) {
@@ -883,7 +658,7 @@ final class InputMethodUtils { 
                                try {

                                    final int hashCode = Integer.parseInt(subtypeHashCode);

                                    // Check whether the subtype id is valid or not

                                    if (isValidSubtypeId(imi, hashCode)) {

                                    if (SubtypeUtils.isValidSubtypeId(imi, hashCode)) {

                                        return s;

                                    } else {

                                        return NOT_A_SUBTYPE_ID_STR;
@@ -1003,7 +778,7 @@ final class InputMethodUtils { 
                return NOT_A_SUBTYPE_ID;

            }

            final int subtypeHashCode = getSelectedInputMethodSubtypeHashCode();

            return getSubtypeIdFromHashCode(imi, subtypeHashCode);

            return SubtypeUtils.getSubtypeIdFromHashCode(imi, subtypeHashCode);

        }



        void saveCurrentInputMethodAndSubtypeToHistory(String curMethodId,

services/core/java/com/android/server/inputmethod/SubtypeUtils.java

+230 −1

File changed.

Preview size limit exceeded, changes collapsed.