Merge changes I0d7d2373,I7ebea2d6 (6cd679b4) · Commits · e / os / android_frameworks_base

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

0 → 100644

+332 −0

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

		import static com.android.server.inputmethod.SubtypeUtils.SUBTYPE_MODE_ANY;
		import static com.android.server.inputmethod.SubtypeUtils.SUBTYPE_MODE_KEYBOARD;

		import android.annotation.NonNull;
		import android.annotation.Nullable;
		import android.content.Context;
		import android.provider.Settings;
		import android.text.TextUtils;
		import android.util.ArrayMap;
		import android.util.Slog;
		import android.view.inputmethod.InputMethodInfo;
		import android.view.inputmethod.InputMethodSubtype;

		import java.util.ArrayList;
		import java.util.Arrays;
		import java.util.LinkedHashSet;
		import java.util.List;
		import java.util.Locale;

		/**
		* This class provides utility methods to generate or filter {@link InputMethodInfo} for
		* {@link InputMethodManagerService}.
		*
		* <p>This class is intentionally package-private. Utility methods here are tightly coupled with
		* implementation details in {@link InputMethodManagerService}. Hence this class is not suitable
		* for other components to directly use.</p>
		*/
		final class InputMethodInfoUtils {
		private static final String TAG = "InputMethodInfoUtils";

		/**
		* Used in {@link #getFallbackLocaleForDefaultIme(ArrayList, Context)} to find the fallback IMEs
		* that are mainly used until the system becomes ready. Note that {@link Locale} in this array
		* is checked with {@link Locale#equals(Object)}, which means that {@code Locale.ENGLISH}
		* doesn't automatically match {@code Locale("en", "IN")}.
		*/
		private static final Locale[] SEARCH_ORDER_OF_FALLBACK_LOCALES = {
		Locale.ENGLISH, // "en"
		Locale.US, // "en_US"
		Locale.UK, // "en_GB"
		};
		private static final Locale ENGLISH_LOCALE = new Locale("en");

		private static final class InputMethodListBuilder {
		// Note: We use LinkedHashSet instead of android.util.ArraySet because the enumeration
		// order can have non-trivial effect in the call sites.
		@NonNull
		private final LinkedHashSet<InputMethodInfo> mInputMethodSet = new LinkedHashSet<>();

		InputMethodListBuilder fillImes(ArrayList<InputMethodInfo> imis, Context context,
		boolean checkDefaultAttribute, @Nullable Locale locale, boolean checkCountry,
		String requiredSubtypeMode) {
		for (int i = 0; i < imis.size(); ++i) {
		final InputMethodInfo imi = imis.get(i);
		if (isSystemImeThatHasSubtypeOf(imi, context,
		checkDefaultAttribute, locale, checkCountry, requiredSubtypeMode)) {
		mInputMethodSet.add(imi);
		}
		}
		return this;
		}

		// TODO: The behavior of InputMethodSubtype#overridesImplicitlyEnabledSubtype() should be
		// documented more clearly.
		InputMethodListBuilder fillAuxiliaryImes(ArrayList<InputMethodInfo> imis, Context context) {
		// If one or more auxiliary input methods are available, OK to stop populating the list.
		for (final InputMethodInfo imi : mInputMethodSet) {
		if (imi.isAuxiliaryIme()) {
		return this;
		}
		}
		boolean added = false;
		for (int i = 0; i < imis.size(); ++i) {
		final InputMethodInfo imi = imis.get(i);
		if (isSystemAuxilialyImeThatHasAutomaticSubtype(imi, context,
		true /* checkDefaultAttribute */)) {
		mInputMethodSet.add(imi);
		added = true;
		}
		}
		if (added) {
		return this;
		}
		for (int i = 0; i < imis.size(); ++i) {
		final InputMethodInfo imi = imis.get(i);
		if (isSystemAuxilialyImeThatHasAutomaticSubtype(imi, context,
		false /* checkDefaultAttribute */)) {
		mInputMethodSet.add(imi);
		}
		}
		return this;

		}

		public boolean isEmpty() {
		return mInputMethodSet.isEmpty();
		}

		@NonNull
		public ArrayList<InputMethodInfo> build() {
		return new ArrayList<>(mInputMethodSet);
		}
		}

		private static InputMethodListBuilder getMinimumKeyboardSetWithSystemLocale(
		ArrayList<InputMethodInfo> imis, Context context, @Nullable Locale systemLocale,
		@Nullable Locale fallbackLocale) {
		// Once the system becomes ready, we pick up at least one keyboard in the following order.
		// Secondary users fall into this category in general.
		// 1. checkDefaultAttribute: true, locale: systemLocale, checkCountry: true
		// 2. checkDefaultAttribute: true, locale: systemLocale, checkCountry: false
		// 3. checkDefaultAttribute: true, locale: fallbackLocale, checkCountry: true
		// 4. checkDefaultAttribute: true, locale: fallbackLocale, checkCountry: false
		// 5. checkDefaultAttribute: false, locale: fallbackLocale, checkCountry: true
		// 6. checkDefaultAttribute: false, locale: fallbackLocale, checkCountry: false
		// TODO: We should check isAsciiCapable instead of relying on fallbackLocale.

		final InputMethodListBuilder builder = new InputMethodListBuilder();
		builder.fillImes(imis, context, true /* checkDefaultAttribute */, systemLocale,
		true /* checkCountry */, SUBTYPE_MODE_KEYBOARD);
		if (!builder.isEmpty()) {
		return builder;
		}
		builder.fillImes(imis, context, true /* checkDefaultAttribute */, systemLocale,
		false /* checkCountry */, SUBTYPE_MODE_KEYBOARD);
		if (!builder.isEmpty()) {
		return builder;
		}
		builder.fillImes(imis, context, true /* checkDefaultAttribute */, fallbackLocale,
		true /* checkCountry */, SUBTYPE_MODE_KEYBOARD);
		if (!builder.isEmpty()) {
		return builder;
		}
		builder.fillImes(imis, context, true /* checkDefaultAttribute */, fallbackLocale,
		false /* checkCountry */, SUBTYPE_MODE_KEYBOARD);
		if (!builder.isEmpty()) {
		return builder;
		}
		builder.fillImes(imis, context, false /* checkDefaultAttribute */, fallbackLocale,
		true /* checkCountry */, SUBTYPE_MODE_KEYBOARD);
		if (!builder.isEmpty()) {
		return builder;
		}
		builder.fillImes(imis, context, false /* checkDefaultAttribute */, fallbackLocale,
		false /* checkCountry */, SUBTYPE_MODE_KEYBOARD);
		if (!builder.isEmpty()) {
		return builder;
		}
		Slog.w(TAG, "No software keyboard is found. imis=" + Arrays.toString(imis.toArray())
		+ " systemLocale=" + systemLocale + " fallbackLocale=" + fallbackLocale);
		return builder;
		}

		static ArrayList<InputMethodInfo> getDefaultEnabledImes(
		Context context, ArrayList<InputMethodInfo> imis, boolean onlyMinimum) {
		final Locale fallbackLocale = getFallbackLocaleForDefaultIme(imis, context);
		// We will primarily rely on the system locale, but also keep relying on the fallback locale
		// as a last resort.
		// Also pick up suitable IMEs regardless of the software keyboard support (e.g. Voice IMEs),
		// then pick up suitable auxiliary IMEs when necessary (e.g. Voice IMEs with "automatic"
		// subtype)
		final Locale systemLocale = LocaleUtils.getSystemLocaleFromContext(context);
		final InputMethodListBuilder builder =
		getMinimumKeyboardSetWithSystemLocale(imis, context, systemLocale, fallbackLocale);
		if (!onlyMinimum) {
		builder.fillImes(imis, context, true /* checkDefaultAttribute */, systemLocale,
		true /* checkCountry */, SUBTYPE_MODE_ANY)
		.fillAuxiliaryImes(imis, context);
		}
		return builder.build();
		}

		static ArrayList<InputMethodInfo> getDefaultEnabledImes(
		Context context, ArrayList<InputMethodInfo> imis) {
		return getDefaultEnabledImes(context, imis, false /* onlyMinimum */);
		}

		/**
		* Chooses an eligible system voice IME from the given IMEs.
		*
		* @param methodMap Map from the IME ID to {@link InputMethodInfo}.
		* @param systemSpeechRecognizerPackageName System speech recognizer configured by the system
		* config.
		* @param currentDefaultVoiceImeId IME ID currently set to
		* {@link Settings.Secure#DEFAULT_VOICE_INPUT_METHOD}
		* @return {@link InputMethodInfo} that is found in {@code methodMap} and most suitable for
		* the system voice IME.
		*/
		@Nullable
		static InputMethodInfo chooseSystemVoiceIme(
		@NonNull ArrayMap<String, InputMethodInfo> methodMap,
		@Nullable String systemSpeechRecognizerPackageName,
		@Nullable String currentDefaultVoiceImeId) {
		if (TextUtils.isEmpty(systemSpeechRecognizerPackageName)) {
		return null;
		}
		final InputMethodInfo defaultVoiceIme = methodMap.get(currentDefaultVoiceImeId);
		// If the config matches the package of the setting, use the current one.
		if (defaultVoiceIme != null && defaultVoiceIme.isSystem()
		&& defaultVoiceIme.getPackageName().equals(systemSpeechRecognizerPackageName)) {
		return defaultVoiceIme;
		}
		InputMethodInfo firstMatchingIme = null;
		final int methodCount = methodMap.size();
		for (int i = 0; i < methodCount; ++i) {
		final InputMethodInfo imi = methodMap.valueAt(i);
		if (!imi.isSystem()) {
		continue;
		}
		if (!TextUtils.equals(imi.getPackageName(), systemSpeechRecognizerPackageName)) {
		continue;
		}
		if (firstMatchingIme != null) {
		Slog.e(TAG, "At most one InputMethodService can be published in "
		+ "systemSpeechRecognizer: " + systemSpeechRecognizerPackageName
		+ ". Ignoring all of them.");
		return null;
		}
		firstMatchingIme = imi;
		}
		return firstMatchingIme;
		}

		static InputMethodInfo getMostApplicableDefaultIME(List<InputMethodInfo> enabledImes) {
		if (enabledImes == null \|\| enabledImes.isEmpty()) {
		return null;
		}
		// We'd prefer to fall back on a system IME, since that is safer.
		int i = enabledImes.size();
		int firstFoundSystemIme = -1;
		while (i > 0) {
		i--;
		final InputMethodInfo imi = enabledImes.get(i);
		if (imi.isAuxiliaryIme()) {
		continue;
		}
		if (imi.isSystem() && SubtypeUtils.containsSubtypeOf(imi, ENGLISH_LOCALE,
		false /* checkCountry */, SUBTYPE_MODE_KEYBOARD)) {
		return imi;
		}
		if (firstFoundSystemIme < 0 && imi.isSystem()) {
		firstFoundSystemIme = i;
		}
		}
		return enabledImes.get(Math.max(firstFoundSystemIme, 0));
		}

		private static boolean isSystemAuxilialyImeThatHasAutomaticSubtype(InputMethodInfo imi,
		Context context, boolean checkDefaultAttribute) {
		if (!imi.isSystem()) {
		return false;
		}
		if (checkDefaultAttribute && !imi.isDefault(context)) {
		return false;
		}
		if (!imi.isAuxiliaryIme()) {
		return false;
		}
		final int subtypeCount = imi.getSubtypeCount();
		for (int i = 0; i < subtypeCount; ++i) {
		final InputMethodSubtype s = imi.getSubtypeAt(i);
		if (s.overridesImplicitlyEnabledSubtype()) {
		return true;
		}
		}
		return false;
		}

		@Nullable
		private static Locale getFallbackLocaleForDefaultIme(ArrayList<InputMethodInfo> imis,
		Context context) {
		// At first, find the fallback locale from the IMEs that are declared as "default" in the
		// current locale. Note that IME developers can declare an IME as "default" only for
		// some particular locales but "not default" for other locales.
		for (final Locale fallbackLocale : SEARCH_ORDER_OF_FALLBACK_LOCALES) {
		for (int i = 0; i < imis.size(); ++i) {
		if (isSystemImeThatHasSubtypeOf(imis.get(i), context,
		true /* checkDefaultAttribute */, fallbackLocale,
		true /* checkCountry */, SubtypeUtils.SUBTYPE_MODE_KEYBOARD)) {
		return fallbackLocale;
		}
		}
		}
		// If no fallback locale is found in the above condition, find fallback locales regardless
		// of the "default" attribute as a last resort.
		for (final Locale fallbackLocale : SEARCH_ORDER_OF_FALLBACK_LOCALES) {
		for (int i = 0; i < imis.size(); ++i) {
		if (isSystemImeThatHasSubtypeOf(imis.get(i), context,
		false /* checkDefaultAttribute */, fallbackLocale,
		true /* checkCountry */, SubtypeUtils.SUBTYPE_MODE_KEYBOARD)) {
		return fallbackLocale;
		}
		}
		}
		Slog.w(TAG, "Found no fallback locale. imis=" + Arrays.toString(imis.toArray()));
		return null;
		}

		private static boolean isSystemImeThatHasSubtypeOf(InputMethodInfo imi, Context context,
		boolean checkDefaultAttribute, @Nullable Locale requiredLocale, boolean checkCountry,
		String requiredSubtypeMode) {
		if (!imi.isSystem()) {
		return false;
		}
		if (checkDefaultAttribute && !imi.isDefault(context)) {
		return false;
		}
		if (!SubtypeUtils.containsSubtypeOf(imi, requiredLocale, checkCountry,
		requiredSubtypeMode)) {
		return false;
		}
		return true;
		}
		}

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

+27 −26

Original line number	Diff line number	Diff line
		@@ -1787,7 +1787,7 @@ public final class InputMethodManagerService extends IInputMethodManager.Stub
		if (selectedMethodId != null && !mMethodMap.get(selectedMethodId).isSystem()) {
		return;
		}
		final List<InputMethodInfo> suitableImes = InputMethodUtils.getDefaultEnabledImes(
		final List<InputMethodInfo> suitableImes = InputMethodInfoUtils.getDefaultEnabledImes(
		context, mSettings.getEnabledInputMethodListLocked());
		if (suitableImes.isEmpty()) {
		Slog.i(TAG, "No default found");
		@@ -4049,7 +4049,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);
		@@ -4093,7 +4093,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);
		}
		}

		@@ -4112,13 +4112,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),
		InputMethodUtils.SUBTYPE_MODE_KEYBOARD, locale, true);
		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;
		}
		@@ -4188,8 +4188,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;
		}
		@@ -4868,7 +4868,7 @@ public final class InputMethodManagerService extends IInputMethodManager.Stub

		@GuardedBy("ImfLock.class")
		private boolean chooseNewDefaultIMELocked() {
		final InputMethodInfo imi = InputMethodUtils.getMostApplicableDefaultIME(
		final InputMethodInfo imi = InputMethodInfoUtils.getMostApplicableDefaultIME(
		mSettings.getEnabledInputMethodListLocked());
		if (imi != null) {
		if (DEBUG) {
		@@ -5011,7 +5011,7 @@ public final class InputMethodManagerService extends IInputMethodManager.Stub

		if (resetDefaultEnabledIme \|\| reenableMinimumNonAuxSystemImes) {
		final ArrayList<InputMethodInfo> defaultEnabledIme =
		InputMethodUtils.getDefaultEnabledImes(mContext, mMethodList,
		InputMethodInfoUtils.getDefaultEnabledImes(mContext, mMethodList,
		reenableMinimumNonAuxSystemImes);
		final int N = defaultEnabledIme.size();
		for (int i = 0; i < N; ++i) {
		@@ -5067,7 +5067,7 @@ public final class InputMethodManagerService extends IInputMethodManager.Stub
		final String systemSpeechRecognizer =
		mContext.getString(com.android.internal.R.string.config_systemSpeechRecognizer);
		final String currentDefaultVoiceImeId = mSettings.getDefaultVoiceInputMethod();
		final InputMethodInfo newSystemVoiceIme = InputMethodUtils.chooseSystemVoiceIme(
		final InputMethodInfo newSystemVoiceIme = InputMethodInfoUtils.chooseSystemVoiceIme(
		mMethodMap, systemSpeechRecognizer, currentDefaultVoiceImeId);
		if (newSystemVoiceIme == null) {
		if (DEBUG) {
		@@ -5193,8 +5193,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);
		}
		@@ -5229,7 +5229,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
		@@ -5242,17 +5242,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,
		InputMethodUtils.SUBTYPE_MODE_KEYBOARD, null, true);
		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;
		@@ -6169,8 +6168,8 @@ public final class InputMethodManagerService extends IInputMethodManager.Stub
		setInputMethodEnabledLocked(inputMethodInfo.getId(), false);
		}
		// Re-enable with default enabled IMEs.
		for (InputMethodInfo imi :
		InputMethodUtils.getDefaultEnabledImes(mContext, mMethodList)) {
		for (InputMethodInfo imi : InputMethodInfoUtils.getDefaultEnabledImes(
		mContext, mMethodList)) {
		setInputMethodEnabledLocked(imi.getId(), true);
		}
		updateInputMethodsFromSettingsLocked(true /* enabledMayChange */);
		@@ -6191,8 +6190,10 @@ public final class InputMethodManagerService extends IInputMethodManager.Stub
		mContext.getResources(), mContext.getContentResolver(), methodMap,
		userId, false);

		nextEnabledImes = InputMethodUtils.getDefaultEnabledImes(mContext, methodList);
		nextIme = InputMethodUtils.getMostApplicableDefaultIME(nextEnabledImes).getId();
		nextEnabledImes = InputMethodInfoUtils.getDefaultEnabledImes(mContext,
		methodList);
		nextIme = InputMethodInfoUtils.getMostApplicableDefaultIME(
		nextEnabledImes).getId();

		// Reset enabled IMEs.
		settings.putEnabledInputMethodsStr("");

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 −563

File changed.

Preview size limit exceeded, changes collapsed.