Merge "switchToLastInputMethod returns a implicitly enabled subtype in the history" into honeycomb (604363dc) · Commits · e / os / android_frameworks_base

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

+56 −30

Original line number	Diff line number	Diff line
		@@ -490,7 +490,8 @@ public class InputMethodManagerService extends IInputMethodManager.Stub
		statusBar.setIconVisibility("ime", false);

		// mSettings should be created before buildInputMethodListLocked
		mSettings = new InputMethodSettings(context.getContentResolver(), mMethodMap, mMethodList);
		mSettings = new InputMethodSettings(
		mRes, context.getContentResolver(), mMethodMap, mMethodList);
		buildInputMethodListLocked(mMethodList, mMethodMap);
		mSettings.enableAllIMEsIfThereIsNoEnabledIME();

		@@ -575,7 +576,7 @@ public class InputMethodManagerService extends IInputMethodManager.Stub
		if (!allowsImplicitlySelectedSubtypes \|\| enabledSubtypes.size() > 0) {
		return enabledSubtypes;
		} else {
		return getApplicableSubtypesLocked(imi.getSubtypes());
		return getApplicableSubtypesLocked(mRes, imi.getSubtypes());
		}
		}
		}
		@@ -1680,7 +1681,7 @@ public class InputMethodManagerService extends IInputMethodManager.Stub
		ArrayList<String> subtypes = immis.get(i).second;
		if (subtypes != null && subtypes.size() == 0) {
		ArrayList<InputMethodSubtype> applicableSubtypes =
		getApplicableSubtypesLocked(imi.getSubtypes());
		getApplicableSubtypesLocked(mRes, imi.getSubtypes());
		final int numSubtypes = applicableSubtypes.size();
		for (int j = 0; j < numSubtypes; ++j) {
		subtypes.add(String.valueOf(applicableSubtypes.get(j).hashCode()));
		@@ -1977,9 +1978,9 @@ public class InputMethodManagerService extends IInputMethodManager.Stub
		return NOT_A_SUBTYPE_ID;
		}

		private ArrayList<InputMethodSubtype> getApplicableSubtypesLocked(
		List<InputMethodSubtype> subtypes) {
		final String systemLocale = mRes.getConfiguration().locale.toString();
		private static ArrayList<InputMethodSubtype> getApplicableSubtypesLocked(
		Resources res, List<InputMethodSubtype> subtypes) {
		final String systemLocale = res.getConfiguration().locale.toString();
		if (TextUtils.isEmpty(systemLocale)) return new ArrayList<InputMethodSubtype>();
		HashMap<String, InputMethodSubtype> applicableModeAndSubtypesMap =
		new HashMap<String, InputMethodSubtype>();
		@@ -2013,7 +2014,7 @@ public class InputMethodManagerService extends IInputMethodManager.Stub
		applicableModeAndSubtypesMap.values());
		if (!containsKeyboardSubtype) {
		InputMethodSubtype lastResortKeyboardSubtype = findLastResortApplicableSubtypeLocked(
		subtypes, SUBTYPE_MODE_KEYBOARD, systemLocale, true);
		res, subtypes, SUBTYPE_MODE_KEYBOARD, systemLocale, true);
		if (lastResortKeyboardSubtype != null) {
		applicableSubtypes.add(lastResortKeyboardSubtype);
		}
		@@ -2031,14 +2032,14 @@ public class InputMethodManagerService extends IInputMethodManager.Stub
		* it will return the first subtype matched with mode
		* @return the most applicable subtypeId
		*/
		private InputMethodSubtype findLastResortApplicableSubtypeLocked(
		List<InputMethodSubtype> subtypes, String mode, String locale,
		private 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 = mRes.getConfiguration().locale.toString();
		locale = res.getConfiguration().locale.toString();
		}
		final String language = locale.substring(0, 2);
		boolean partialMatchFound = false;
		@@ -2095,29 +2096,29 @@ public class InputMethodManagerService extends IInputMethodManager.Stub
		continue;
		}
		InputMethodSubtype subtype = null;
		final List<InputMethodSubtype> explicitlyEnabledSubtypes =
		mSettings.getEnabledInputMethodSubtypeListLocked(imi);
		// 1. Search by the current subtype's locale from explicitlyEnabledSubtypes.
		final List<InputMethodSubtype> enabledSubtypes =
		getEnabledInputMethodSubtypeList(imi, true);
		// 1. Search by the current subtype's locale from enabledSubtypes.
		if (mCurrentSubtype != null) {
		subtype = findLastResortApplicableSubtypeLocked(
		explicitlyEnabledSubtypes, mode, mCurrentSubtype.getLocale(), false);
		mRes, enabledSubtypes, mode, mCurrentSubtype.getLocale(), false);
		}
		// 2. Search by the system locale from explicitlyEnabledSubtypes.
		// 3. Search the first enabled subtype matched with mode from explicitlyEnabledSubtypes.
		// 2. Search by the system locale from enabledSubtypes.
		// 3. Search the first enabled subtype matched with mode from enabledSubtypes.
		if (subtype == null) {
		subtype = findLastResortApplicableSubtypeLocked(
		explicitlyEnabledSubtypes, mode, null, true);
		mRes, enabledSubtypes, mode, null, true);
		}
		// 4. Search by the current subtype's locale from all subtypes.
		if (subtype == null && mCurrentSubtype != null) {
		subtype = findLastResortApplicableSubtypeLocked(
		imi.getSubtypes(), mode, mCurrentSubtype.getLocale(), false);
		mRes, imi.getSubtypes(), mode, mCurrentSubtype.getLocale(), false);
		}
		// 5. Search by the system locale from all subtypes.
		// 6. Search the first enabled subtype matched with mode from all subtypes.
		if (subtype == null) {
		subtype = findLastResortApplicableSubtypeLocked(
		imi.getSubtypes(), mode, null, true);
		mRes, imi.getSubtypes(), mode, null, true);
		}
		if (subtype != null) {
		if (imiId.equals(mCurMethodId)) {
		@@ -2177,8 +2178,8 @@ public class InputMethodManagerService extends IInputMethodManager.Stub
		// the most applicable subtype from all subtypes whose mode is
		// SUBTYPE_MODE_KEYBOARD. This is an exceptional case, so we will hardcode
		// the mode.
		mCurrentSubtype = findLastResortApplicableSubtypeLocked(imi.getSubtypes(),
		SUBTYPE_MODE_KEYBOARD, null, true);
		mCurrentSubtype = findLastResortApplicableSubtypeLocked(
		mRes, imi.getSubtypes(), SUBTYPE_MODE_KEYBOARD, null, true);
		}
		} else {
		mCurrentSubtype =
		@@ -2256,6 +2257,7 @@ public class InputMethodManagerService extends IInputMethodManager.Stub
		private final TextUtils.SimpleStringSplitter mSubtypeSplitter =
		new TextUtils.SimpleStringSplitter(INPUT_METHOD_SUBTYPE_SEPARATER);

		private final Resources mRes;
		private final ContentResolver mResolver;
		private final HashMap<String, InputMethodInfo> mMethodMap;
		private final ArrayList<InputMethodInfo> mMethodList;
		@@ -2275,8 +2277,9 @@ public class InputMethodManagerService extends IInputMethodManager.Stub
		}

		public InputMethodSettings(
		ContentResolver resolver, HashMap<String, InputMethodInfo> methodMap,
		ArrayList<InputMethodInfo> methodList) {
		Resources res, ContentResolver resolver,
		HashMap<String, InputMethodInfo> methodMap, ArrayList<InputMethodInfo> methodList) {
		mRes = res;
		mResolver = resolver;
		mMethodMap = methodMap;
		mMethodList = methodList;
		@@ -2516,7 +2519,8 @@ public class InputMethodManagerService extends IInputMethodManager.Stub
		// If imeId is empty, returns the first IME and subtype in the history
		if (TextUtils.isEmpty(imeId) \|\| imeInTheHistory.equals(imeId)) {
		final String subtypeInTheHistory = imeAndSubtype.second;
		final String subtypeHashCode = getEnabledSubtypeForInputMethodAndSubtypeLocked(
		final String subtypeHashCode =
		getEnabledSubtypeHashCodeForInputMethodAndSubtypeLocked(
		enabledImes, imeInTheHistory, subtypeInTheHistory);
		if (!TextUtils.isEmpty(subtypeHashCode)) {
		if (DEBUG) {
		@@ -2532,16 +2536,38 @@ public class InputMethodManagerService extends IInputMethodManager.Stub
		return null;
		}

		private String getEnabledSubtypeForInputMethodAndSubtypeLocked(List<Pair<String,
		private String getEnabledSubtypeHashCodeForInputMethodAndSubtypeLocked(List<Pair<String,
		ArrayList<String>>> enabledImes, String imeId, String subtypeHashCode) {
		for (Pair<String, ArrayList<String>> enabledIme: enabledImes) {
		if (enabledIme.first.equals(imeId)) {
		for (String s: enabledIme.second) {
		final ArrayList<String> enabledSubtypes = enabledIme.second;
		if (enabledSubtypes.size() == 0) {
		// If there are no enabled subtypes, applicable subtypes are enabled
		// implicitly.
		InputMethodInfo ime = mMethodMap.get(imeId);
		// If IME is enabled and no subtypes are enabled, applicable subtypes
		// are enabled implicitly, so needs to treat them to be enabled.
		if (ime != null && ime.getSubtypes().size() > 0) {
		List<InputMethodSubtype> implicitlySelectedSubtypes =
		getApplicableSubtypesLocked(mRes, ime.getSubtypes());
		if (implicitlySelectedSubtypes != null) {
		final int N = implicitlySelectedSubtypes.size();
		for (int i = 0; i < N; ++i) {
		final InputMethodSubtype st = implicitlySelectedSubtypes.get(i);
		if (String.valueOf(st.hashCode()).equals(subtypeHashCode)) {
		return subtypeHashCode;
		}
		}
		}
		}
		} else {
		for (String s: enabledSubtypes) {
		if (s.equals(subtypeHashCode)) {
		// If both imeId and subtypeId are enabled, return subtypeId.
		return s;
		}
		}
		}
		// If imeId was enabled but subtypeId was disabled.
		return NOT_A_SUBTYPE_ID_STR;
		}