Refactor utilities for InputMethodManagerSerivce that we want to share with the Settings application
Bug: 7872918 Change-Id: I0bc9954f163a3ec38d08b9ba842a8a31176eb6a6
This commit is contained in:
Satoshi Kataoka
796
core/java/com/android/internal/inputmethod/InputMethodUtils.java
Normal file
796
core/java/com/android/internal/inputmethod/InputMethodUtils.java
Normal file
@@ -0,0 +1,796 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (C) 2013 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.internal.inputmethod;
|
||||||
|
|
||||||
|
import android.content.ContentResolver;
|
||||||
|
import android.content.Context;
|
||||||
|
import android.content.pm.ApplicationInfo;
|
||||||
|
import android.content.pm.PackageManager;
|
||||||
|
import android.content.res.Resources;
|
||||||
|
import android.provider.Settings;
|
||||||
|
import android.provider.Settings.SettingNotFoundException;
|
||||||
|
import android.text.TextUtils;
|
||||||
|
import android.util.Pair;
|
||||||
|
import android.util.Slog;
|
||||||
|
import android.view.inputmethod.InputMethodInfo;
|
||||||
|
import android.view.inputmethod.InputMethodSubtype;
|
||||||
|
|
||||||
|
import java.util.ArrayList;
|
||||||
|
import java.util.HashMap;
|
||||||
|
import java.util.List;
|
||||||
|
import java.util.Locale;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* InputMethodManagerUtils contains some static methods that provides IME informations.
|
||||||
|
* This methods are supposed to be used in both the framework and the Settings application.
|
||||||
|
*/
|
||||||
|
public class InputMethodUtils {
|
||||||
|
public static final boolean DEBUG = false;
|
||||||
|
public static final int NOT_A_SUBTYPE_ID = -1;
|
||||||
|
public static final String SUBTYPE_MODE_KEYBOARD = "keyboard";
|
||||||
|
public static final String SUBTYPE_MODE_VOICE = "voice";
|
||||||
|
private static final String TAG = "InputMethodUtils";
|
||||||
|
private static final Locale ENGLISH_LOCALE = new Locale("en");
|
||||||
|
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";
|
||||||
|
private static final String TAG_ASCII_CAPABLE = "AsciiCapable";
|
||||||
|
|
||||||
|
private InputMethodUtils() {
|
||||||
|
// This utility class is not publicly instantiable.
|
||||||
|
}
|
||||||
|
|
||||||
|
public static boolean isSystemIme(InputMethodInfo inputMethod) {
|
||||||
|
return (inputMethod.getServiceInfo().applicationInfo.flags
|
||||||
|
& ApplicationInfo.FLAG_SYSTEM) != 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
public static boolean isSystemImeThatHasEnglishSubtype(InputMethodInfo imi) {
|
||||||
|
if (!isSystemIme(imi)) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
return containsSubtypeOf(imi, ENGLISH_LOCALE.getLanguage());
|
||||||
|
}
|
||||||
|
|
||||||
|
// TODO: Rename isSystemDefaultImeThatHasCurrentLanguageSubtype
|
||||||
|
public static boolean isValidSystemDefaultIme(
|
||||||
|
boolean isSystemReady, InputMethodInfo imi, Context context) {
|
||||||
|
if (!isSystemReady) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
if (!isSystemIme(imi)) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
if (imi.getIsDefaultResourceId() != 0) {
|
||||||
|
try {
|
||||||
|
Resources res = context.createPackageContext(
|
||||||
|
imi.getPackageName(), 0).getResources();
|
||||||
|
if (res.getBoolean(imi.getIsDefaultResourceId())
|
||||||
|
&& containsSubtypeOf(imi, context.getResources().getConfiguration().
|
||||||
|
locale.getLanguage())) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
} catch (PackageManager.NameNotFoundException ex) {
|
||||||
|
} catch (Resources.NotFoundException ex) {
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (imi.getSubtypeCount() == 0) {
|
||||||
|
Slog.w(TAG, "Found no subtypes in a system IME: " + imi.getPackageName());
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
public static boolean isDefaultEnabledIme(
|
||||||
|
boolean isSystemReady, InputMethodInfo imi, Context context) {
|
||||||
|
return isValidSystemDefaultIme(isSystemReady, imi, context)
|
||||||
|
|| isSystemImeThatHasEnglishSubtype(imi);
|
||||||
|
}
|
||||||
|
|
||||||
|
private static boolean containsSubtypeOf(InputMethodInfo imi, String language) {
|
||||||
|
final int N = imi.getSubtypeCount();
|
||||||
|
for (int i = 0; i < N; ++i) {
|
||||||
|
if (imi.getSubtypeAt(i).getLocale().startsWith(language)) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
public static ArrayList<InputMethodSubtype> getSubtypes(InputMethodInfo imi) {
|
||||||
|
ArrayList<InputMethodSubtype> subtypes = new ArrayList<InputMethodSubtype>();
|
||||||
|
final int subtypeCount = imi.getSubtypeCount();
|
||||||
|
for (int i = 0; i < subtypeCount; ++i) {
|
||||||
|
subtypes.add(imi.getSubtypeAt(i));
|
||||||
|
}
|
||||||
|
return subtypes;
|
||||||
|
}
|
||||||
|
|
||||||
|
public static ArrayList<InputMethodSubtype> getOverridingImplicitlyEnabledSubtypes(
|
||||||
|
InputMethodInfo imi, String mode) {
|
||||||
|
ArrayList<InputMethodSubtype> subtypes = new ArrayList<InputMethodSubtype>();
|
||||||
|
final int subtypeCount = imi.getSubtypeCount();
|
||||||
|
for (int i = 0; i < subtypeCount; ++i) {
|
||||||
|
final InputMethodSubtype subtype = imi.getSubtypeAt(i);
|
||||||
|
if (subtype.overridesImplicitlyEnabledSubtype() && subtype.getMode().equals(mode)) {
|
||||||
|
subtypes.add(subtype);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return subtypes;
|
||||||
|
}
|
||||||
|
|
||||||
|
public static InputMethodInfo getMostApplicableDefaultIME(
|
||||||
|
List<InputMethodInfo> enabledImes) {
|
||||||
|
if (enabledImes != null && enabledImes.size() > 0) {
|
||||||
|
// 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 (InputMethodUtils.isSystemImeThatHasEnglishSubtype(imi)
|
||||||
|
&& !imi.isAuxiliaryIme()) {
|
||||||
|
return imi;
|
||||||
|
}
|
||||||
|
if (firstFoundSystemIme < 0 && InputMethodUtils.isSystemIme(imi)
|
||||||
|
&& !imi.isAuxiliaryIme()) {
|
||||||
|
firstFoundSystemIme = i;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return enabledImes.get(Math.max(firstFoundSystemIme, 0));
|
||||||
|
}
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
public static boolean isValidSubtypeId(InputMethodInfo imi, int subtypeHashCode) {
|
||||||
|
return getSubtypeIdFromHashCode(imi, subtypeHashCode) != NOT_A_SUBTYPE_ID;
|
||||||
|
}
|
||||||
|
|
||||||
|
public 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 ArrayList<InputMethodSubtype> getImplicitlyApplicableSubtypesLocked(
|
||||||
|
Resources res, InputMethodInfo imi) {
|
||||||
|
final List<InputMethodSubtype> subtypes = InputMethodUtils.getSubtypes(imi);
|
||||||
|
final String systemLocale = res.getConfiguration().locale.toString();
|
||||||
|
if (TextUtils.isEmpty(systemLocale)) return new ArrayList<InputMethodSubtype>();
|
||||||
|
final HashMap<String, InputMethodSubtype> applicableModeAndSubtypesMap =
|
||||||
|
new HashMap<String, InputMethodSubtype>();
|
||||||
|
final int N = subtypes.size();
|
||||||
|
for (int i = 0; i < N; ++i) {
|
||||||
|
// scan overriding implicitly enabled subtypes.
|
||||||
|
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<InputMethodSubtype>(applicableModeAndSubtypesMap.values());
|
||||||
|
}
|
||||||
|
for (int i = 0; i < N; ++i) {
|
||||||
|
final InputMethodSubtype subtype = subtypes.get(i);
|
||||||
|
final String locale = subtype.getLocale();
|
||||||
|
final String mode = subtype.getMode();
|
||||||
|
// When system locale starts with subtype's locale, that subtype will be applicable
|
||||||
|
// for system locale
|
||||||
|
// For instance, it's clearly applicable for cases like system locale = en_US and
|
||||||
|
// subtype = en, but it is not necessarily considered applicable for cases like system
|
||||||
|
// locale = en and subtype = en_US.
|
||||||
|
// We just call systemLocale.startsWith(locale) in this function because there is no
|
||||||
|
// need to find applicable subtypes aggressively unlike
|
||||||
|
// findLastResortApplicableSubtypeLocked.
|
||||||
|
if (systemLocale.startsWith(locale)) {
|
||||||
|
final InputMethodSubtype applicableSubtype = applicableModeAndSubtypesMap.get(mode);
|
||||||
|
// If more applicable subtypes are contained, skip.
|
||||||
|
if (applicableSubtype != null) {
|
||||||
|
if (systemLocale.equals(applicableSubtype.getLocale())) continue;
|
||||||
|
if (!systemLocale.equals(locale)) continue;
|
||||||
|
}
|
||||||
|
applicableModeAndSubtypesMap.put(mode, subtype);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
final InputMethodSubtype keyboardSubtype
|
||||||
|
= applicableModeAndSubtypesMap.get(SUBTYPE_MODE_KEYBOARD);
|
||||||
|
final ArrayList<InputMethodSubtype> applicableSubtypes = new ArrayList<InputMethodSubtype>(
|
||||||
|
applicableModeAndSubtypesMap.values());
|
||||||
|
if (keyboardSubtype != null && !keyboardSubtype.containsExtraValueKey(TAG_ASCII_CAPABLE)) {
|
||||||
|
for (int i = 0; i < N; ++i) {
|
||||||
|
final InputMethodSubtype subtype = subtypes.get(i);
|
||||||
|
final String mode = subtype.getMode();
|
||||||
|
if (SUBTYPE_MODE_KEYBOARD.equals(mode) && subtype.containsExtraValueKey(
|
||||||
|
TAG_ENABLED_WHEN_DEFAULT_IS_NOT_ASCII_CAPABLE)) {
|
||||||
|
applicableSubtypes.add(subtype);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (keyboardSubtype == null) {
|
||||||
|
InputMethodSubtype lastResortKeyboardSubtype = findLastResortApplicableSubtypeLocked(
|
||||||
|
res, subtypes, SUBTYPE_MODE_KEYBOARD, systemLocale, true);
|
||||||
|
if (lastResortKeyboardSubtype != null) {
|
||||||
|
applicableSubtypes.add(lastResortKeyboardSubtype);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return applicableSubtypes;
|
||||||
|
}
|
||||||
|
|
||||||
|
private static List<InputMethodSubtype> getEnabledInputMethodSubtypeList(
|
||||||
|
Context context, InputMethodInfo imi, List<InputMethodSubtype> enabledSubtypes,
|
||||||
|
boolean allowsImplicitlySelectedSubtypes) {
|
||||||
|
if (allowsImplicitlySelectedSubtypes && enabledSubtypes.isEmpty()) {
|
||||||
|
enabledSubtypes = InputMethodUtils.getImplicitlyApplicableSubtypesLocked(
|
||||||
|
context.getResources(), imi);
|
||||||
|
}
|
||||||
|
return InputMethodSubtype.sort(context, 0, imi, enabledSubtypes);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* 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
|
||||||
|
*/
|
||||||
|
public 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 = locale.substring(0, 2);
|
||||||
|
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();
|
||||||
|
// 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 && subtypeLocale.startsWith(language)) {
|
||||||
|
// 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;
|
||||||
|
}
|
||||||
|
|
||||||
|
public static boolean canAddToLastInputMethod(InputMethodSubtype subtype) {
|
||||||
|
if (subtype == null) return true;
|
||||||
|
return !subtype.isAuxiliary();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Utility class for putting and getting settings for InputMethod
|
||||||
|
* TODO: Move all putters and getters of settings to this class.
|
||||||
|
*/
|
||||||
|
public static class InputMethodSettings {
|
||||||
|
// The string for enabled input method is saved as follows:
|
||||||
|
// example: ("ime0;subtype0;subtype1;subtype2:ime1:ime2;subtype0")
|
||||||
|
private static final char INPUT_METHOD_SEPARATER = ':';
|
||||||
|
private static final char INPUT_METHOD_SUBTYPE_SEPARATER = ';';
|
||||||
|
private final TextUtils.SimpleStringSplitter mInputMethodSplitter =
|
||||||
|
new TextUtils.SimpleStringSplitter(INPUT_METHOD_SEPARATER);
|
||||||
|
|
||||||
|
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;
|
||||||
|
|
||||||
|
private String mEnabledInputMethodsStrCache;
|
||||||
|
private int mCurrentUserId;
|
||||||
|
|
||||||
|
private static void buildEnabledInputMethodsSettingString(
|
||||||
|
StringBuilder builder, Pair<String, ArrayList<String>> pair) {
|
||||||
|
String id = pair.first;
|
||||||
|
ArrayList<String> subtypes = pair.second;
|
||||||
|
builder.append(id);
|
||||||
|
// Inputmethod and subtypes are saved in the settings as follows:
|
||||||
|
// ime0;subtype0;subtype1:ime1;subtype0:ime2:ime3;subtype0;subtype1
|
||||||
|
for (String subtypeId: subtypes) {
|
||||||
|
builder.append(INPUT_METHOD_SUBTYPE_SEPARATER).append(subtypeId);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
public InputMethodSettings(
|
||||||
|
Resources res, ContentResolver resolver,
|
||||||
|
HashMap<String, InputMethodInfo> methodMap, ArrayList<InputMethodInfo> methodList,
|
||||||
|
int userId) {
|
||||||
|
setCurrentUserId(userId);
|
||||||
|
mRes = res;
|
||||||
|
mResolver = resolver;
|
||||||
|
mMethodMap = methodMap;
|
||||||
|
mMethodList = methodList;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void setCurrentUserId(int userId) {
|
||||||
|
if (DEBUG) {
|
||||||
|
Slog.d(TAG, "--- Swtich the current user from " + mCurrentUserId + " to "
|
||||||
|
+ userId + ", new ime = " + getSelectedInputMethod());
|
||||||
|
}
|
||||||
|
// IMMS settings are kept per user, so keep track of current user
|
||||||
|
mCurrentUserId = userId;
|
||||||
|
}
|
||||||
|
|
||||||
|
public List<InputMethodInfo> getEnabledInputMethodListLocked() {
|
||||||
|
return createEnabledInputMethodListLocked(
|
||||||
|
getEnabledInputMethodsAndSubtypeListLocked());
|
||||||
|
}
|
||||||
|
|
||||||
|
public List<Pair<InputMethodInfo, ArrayList<String>>>
|
||||||
|
getEnabledInputMethodAndSubtypeHashCodeListLocked() {
|
||||||
|
return createEnabledInputMethodAndSubtypeHashCodeListLocked(
|
||||||
|
getEnabledInputMethodsAndSubtypeListLocked());
|
||||||
|
}
|
||||||
|
|
||||||
|
public List<InputMethodSubtype> getEnabledInputMethodSubtypeListLocked(
|
||||||
|
Context context, InputMethodInfo imi, boolean allowsImplicitlySelectedSubtypes) {
|
||||||
|
List<InputMethodSubtype> enabledSubtypes =
|
||||||
|
getEnabledInputMethodSubtypeListLocked(imi);
|
||||||
|
if (allowsImplicitlySelectedSubtypes && enabledSubtypes.isEmpty()) {
|
||||||
|
enabledSubtypes = InputMethodUtils.getImplicitlyApplicableSubtypesLocked(
|
||||||
|
context.getResources(), imi);
|
||||||
|
}
|
||||||
|
return InputMethodSubtype.sort(context, 0, imi, enabledSubtypes);
|
||||||
|
}
|
||||||
|
|
||||||
|
private List<InputMethodSubtype> getEnabledInputMethodSubtypeListLocked(
|
||||||
|
InputMethodInfo imi) {
|
||||||
|
List<Pair<String, ArrayList<String>>> imsList =
|
||||||
|
getEnabledInputMethodsAndSubtypeListLocked();
|
||||||
|
ArrayList<InputMethodSubtype> enabledSubtypes =
|
||||||
|
new ArrayList<InputMethodSubtype>();
|
||||||
|
if (imi != null) {
|
||||||
|
for (Pair<String, ArrayList<String>> imsPair : imsList) {
|
||||||
|
InputMethodInfo info = mMethodMap.get(imsPair.first);
|
||||||
|
if (info != null && info.getId().equals(imi.getId())) {
|
||||||
|
final int subtypeCount = info.getSubtypeCount();
|
||||||
|
for (int i = 0; i < subtypeCount; ++i) {
|
||||||
|
InputMethodSubtype ims = info.getSubtypeAt(i);
|
||||||
|
for (String s: imsPair.second) {
|
||||||
|
if (String.valueOf(ims.hashCode()).equals(s)) {
|
||||||
|
enabledSubtypes.add(ims);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return enabledSubtypes;
|
||||||
|
}
|
||||||
|
|
||||||
|
// At the initial boot, the settings for input methods are not set,
|
||||||
|
// so we need to enable IME in that case.
|
||||||
|
public void enableAllIMEsIfThereIsNoEnabledIME() {
|
||||||
|
if (TextUtils.isEmpty(getEnabledInputMethodsStr())) {
|
||||||
|
StringBuilder sb = new StringBuilder();
|
||||||
|
final int N = mMethodList.size();
|
||||||
|
for (int i = 0; i < N; i++) {
|
||||||
|
InputMethodInfo imi = mMethodList.get(i);
|
||||||
|
Slog.i(TAG, "Adding: " + imi.getId());
|
||||||
|
if (i > 0) sb.append(':');
|
||||||
|
sb.append(imi.getId());
|
||||||
|
}
|
||||||
|
putEnabledInputMethodsStr(sb.toString());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
public List<Pair<String, ArrayList<String>>> getEnabledInputMethodsAndSubtypeListLocked() {
|
||||||
|
ArrayList<Pair<String, ArrayList<String>>> imsList
|
||||||
|
= new ArrayList<Pair<String, ArrayList<String>>>();
|
||||||
|
final String enabledInputMethodsStr = getEnabledInputMethodsStr();
|
||||||
|
if (TextUtils.isEmpty(enabledInputMethodsStr)) {
|
||||||
|
return imsList;
|
||||||
|
}
|
||||||
|
mInputMethodSplitter.setString(enabledInputMethodsStr);
|
||||||
|
while (mInputMethodSplitter.hasNext()) {
|
||||||
|
String nextImsStr = mInputMethodSplitter.next();
|
||||||
|
mSubtypeSplitter.setString(nextImsStr);
|
||||||
|
if (mSubtypeSplitter.hasNext()) {
|
||||||
|
ArrayList<String> subtypeHashes = new ArrayList<String>();
|
||||||
|
// The first element is ime id.
|
||||||
|
String imeId = mSubtypeSplitter.next();
|
||||||
|
while (mSubtypeSplitter.hasNext()) {
|
||||||
|
subtypeHashes.add(mSubtypeSplitter.next());
|
||||||
|
}
|
||||||
|
imsList.add(new Pair<String, ArrayList<String>>(imeId, subtypeHashes));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return imsList;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void appendAndPutEnabledInputMethodLocked(String id, boolean reloadInputMethodStr) {
|
||||||
|
if (reloadInputMethodStr) {
|
||||||
|
getEnabledInputMethodsStr();
|
||||||
|
}
|
||||||
|
if (TextUtils.isEmpty(mEnabledInputMethodsStrCache)) {
|
||||||
|
// Add in the newly enabled input method.
|
||||||
|
putEnabledInputMethodsStr(id);
|
||||||
|
} else {
|
||||||
|
putEnabledInputMethodsStr(
|
||||||
|
mEnabledInputMethodsStrCache + INPUT_METHOD_SEPARATER + id);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Build and put a string of EnabledInputMethods with removing specified Id.
|
||||||
|
* @return the specified id was removed or not.
|
||||||
|
*/
|
||||||
|
public boolean buildAndPutEnabledInputMethodsStrRemovingIdLocked(
|
||||||
|
StringBuilder builder, List<Pair<String, ArrayList<String>>> imsList, String id) {
|
||||||
|
boolean isRemoved = false;
|
||||||
|
boolean needsAppendSeparator = false;
|
||||||
|
for (Pair<String, ArrayList<String>> ims: imsList) {
|
||||||
|
String curId = ims.first;
|
||||||
|
if (curId.equals(id)) {
|
||||||
|
// We are disabling this input method, and it is
|
||||||
|
// currently enabled. Skip it to remove from the
|
||||||
|
// new list.
|
||||||
|
isRemoved = true;
|
||||||
|
} else {
|
||||||
|
if (needsAppendSeparator) {
|
||||||
|
builder.append(INPUT_METHOD_SEPARATER);
|
||||||
|
} else {
|
||||||
|
needsAppendSeparator = true;
|
||||||
|
}
|
||||||
|
buildEnabledInputMethodsSettingString(builder, ims);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (isRemoved) {
|
||||||
|
// Update the setting with the new list of input methods.
|
||||||
|
putEnabledInputMethodsStr(builder.toString());
|
||||||
|
}
|
||||||
|
return isRemoved;
|
||||||
|
}
|
||||||
|
|
||||||
|
private List<InputMethodInfo> createEnabledInputMethodListLocked(
|
||||||
|
List<Pair<String, ArrayList<String>>> imsList) {
|
||||||
|
final ArrayList<InputMethodInfo> res = new ArrayList<InputMethodInfo>();
|
||||||
|
for (Pair<String, ArrayList<String>> ims: imsList) {
|
||||||
|
InputMethodInfo info = mMethodMap.get(ims.first);
|
||||||
|
if (info != null) {
|
||||||
|
res.add(info);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
|
||||||
|
private List<Pair<InputMethodInfo, ArrayList<String>>>
|
||||||
|
createEnabledInputMethodAndSubtypeHashCodeListLocked(
|
||||||
|
List<Pair<String, ArrayList<String>>> imsList) {
|
||||||
|
final ArrayList<Pair<InputMethodInfo, ArrayList<String>>> res
|
||||||
|
= new ArrayList<Pair<InputMethodInfo, ArrayList<String>>>();
|
||||||
|
for (Pair<String, ArrayList<String>> ims : imsList) {
|
||||||
|
InputMethodInfo info = mMethodMap.get(ims.first);
|
||||||
|
if (info != null) {
|
||||||
|
res.add(new Pair<InputMethodInfo, ArrayList<String>>(info, ims.second));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
|
||||||
|
private void putEnabledInputMethodsStr(String str) {
|
||||||
|
Settings.Secure.putStringForUser(
|
||||||
|
mResolver, Settings.Secure.ENABLED_INPUT_METHODS, str, mCurrentUserId);
|
||||||
|
mEnabledInputMethodsStrCache = str;
|
||||||
|
if (DEBUG) {
|
||||||
|
Slog.d(TAG, "putEnabledInputMethodStr: " + str);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private String getEnabledInputMethodsStr() {
|
||||||
|
mEnabledInputMethodsStrCache = Settings.Secure.getStringForUser(
|
||||||
|
mResolver, Settings.Secure.ENABLED_INPUT_METHODS, mCurrentUserId);
|
||||||
|
if (DEBUG) {
|
||||||
|
Slog.d(TAG, "getEnabledInputMethodsStr: " + mEnabledInputMethodsStrCache
|
||||||
|
+ ", " + mCurrentUserId);
|
||||||
|
}
|
||||||
|
return mEnabledInputMethodsStrCache;
|
||||||
|
}
|
||||||
|
|
||||||
|
private void saveSubtypeHistory(
|
||||||
|
List<Pair<String, String>> savedImes, String newImeId, String newSubtypeId) {
|
||||||
|
StringBuilder builder = new StringBuilder();
|
||||||
|
boolean isImeAdded = false;
|
||||||
|
if (!TextUtils.isEmpty(newImeId) && !TextUtils.isEmpty(newSubtypeId)) {
|
||||||
|
builder.append(newImeId).append(INPUT_METHOD_SUBTYPE_SEPARATER).append(
|
||||||
|
newSubtypeId);
|
||||||
|
isImeAdded = true;
|
||||||
|
}
|
||||||
|
for (Pair<String, String> ime: savedImes) {
|
||||||
|
String imeId = ime.first;
|
||||||
|
String subtypeId = ime.second;
|
||||||
|
if (TextUtils.isEmpty(subtypeId)) {
|
||||||
|
subtypeId = NOT_A_SUBTYPE_ID_STR;
|
||||||
|
}
|
||||||
|
if (isImeAdded) {
|
||||||
|
builder.append(INPUT_METHOD_SEPARATER);
|
||||||
|
} else {
|
||||||
|
isImeAdded = true;
|
||||||
|
}
|
||||||
|
builder.append(imeId).append(INPUT_METHOD_SUBTYPE_SEPARATER).append(
|
||||||
|
subtypeId);
|
||||||
|
}
|
||||||
|
// Remove the last INPUT_METHOD_SEPARATER
|
||||||
|
putSubtypeHistoryStr(builder.toString());
|
||||||
|
}
|
||||||
|
|
||||||
|
private void addSubtypeToHistory(String imeId, String subtypeId) {
|
||||||
|
List<Pair<String, String>> subtypeHistory = loadInputMethodAndSubtypeHistoryLocked();
|
||||||
|
for (Pair<String, String> ime: subtypeHistory) {
|
||||||
|
if (ime.first.equals(imeId)) {
|
||||||
|
if (DEBUG) {
|
||||||
|
Slog.v(TAG, "Subtype found in the history: " + imeId + ", "
|
||||||
|
+ ime.second);
|
||||||
|
}
|
||||||
|
// We should break here
|
||||||
|
subtypeHistory.remove(ime);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (DEBUG) {
|
||||||
|
Slog.v(TAG, "Add subtype to the history: " + imeId + ", " + subtypeId);
|
||||||
|
}
|
||||||
|
saveSubtypeHistory(subtypeHistory, imeId, subtypeId);
|
||||||
|
}
|
||||||
|
|
||||||
|
private void putSubtypeHistoryStr(String str) {
|
||||||
|
if (DEBUG) {
|
||||||
|
Slog.d(TAG, "putSubtypeHistoryStr: " + str);
|
||||||
|
}
|
||||||
|
Settings.Secure.putStringForUser(
|
||||||
|
mResolver, Settings.Secure.INPUT_METHODS_SUBTYPE_HISTORY, str, mCurrentUserId);
|
||||||
|
}
|
||||||
|
|
||||||
|
public Pair<String, String> getLastInputMethodAndSubtypeLocked() {
|
||||||
|
// Gets the first one from the history
|
||||||
|
return getLastSubtypeForInputMethodLockedInternal(null);
|
||||||
|
}
|
||||||
|
|
||||||
|
public String getLastSubtypeForInputMethodLocked(String imeId) {
|
||||||
|
Pair<String, String> ime = getLastSubtypeForInputMethodLockedInternal(imeId);
|
||||||
|
if (ime != null) {
|
||||||
|
return ime.second;
|
||||||
|
} else {
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private Pair<String, String> getLastSubtypeForInputMethodLockedInternal(String imeId) {
|
||||||
|
List<Pair<String, ArrayList<String>>> enabledImes =
|
||||||
|
getEnabledInputMethodsAndSubtypeListLocked();
|
||||||
|
List<Pair<String, String>> subtypeHistory = loadInputMethodAndSubtypeHistoryLocked();
|
||||||
|
for (Pair<String, String> imeAndSubtype : subtypeHistory) {
|
||||||
|
final String imeInTheHistory = imeAndSubtype.first;
|
||||||
|
// 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 =
|
||||||
|
getEnabledSubtypeHashCodeForInputMethodAndSubtypeLocked(
|
||||||
|
enabledImes, imeInTheHistory, subtypeInTheHistory);
|
||||||
|
if (!TextUtils.isEmpty(subtypeHashCode)) {
|
||||||
|
if (DEBUG) {
|
||||||
|
Slog.d(TAG, "Enabled subtype found in the history: " + subtypeHashCode);
|
||||||
|
}
|
||||||
|
return new Pair<String, String>(imeInTheHistory, subtypeHashCode);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (DEBUG) {
|
||||||
|
Slog.d(TAG, "No enabled IME found in the history");
|
||||||
|
}
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
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)) {
|
||||||
|
final ArrayList<String> explicitlyEnabledSubtypes = enabledIme.second;
|
||||||
|
final InputMethodInfo imi = mMethodMap.get(imeId);
|
||||||
|
if (explicitlyEnabledSubtypes.size() == 0) {
|
||||||
|
// If there are no explicitly enabled subtypes, applicable subtypes are
|
||||||
|
// enabled implicitly.
|
||||||
|
// If IME is enabled and no subtypes are enabled, applicable subtypes
|
||||||
|
// are enabled implicitly, so needs to treat them to be enabled.
|
||||||
|
if (imi != null && imi.getSubtypeCount() > 0) {
|
||||||
|
List<InputMethodSubtype> implicitlySelectedSubtypes =
|
||||||
|
getImplicitlyApplicableSubtypesLocked(mRes, imi);
|
||||||
|
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: explicitlyEnabledSubtypes) {
|
||||||
|
if (s.equals(subtypeHashCode)) {
|
||||||
|
// If both imeId and subtypeId are enabled, return subtypeId.
|
||||||
|
try {
|
||||||
|
final int hashCode = Integer.valueOf(subtypeHashCode);
|
||||||
|
// Check whether the subtype id is valid or not
|
||||||
|
if (isValidSubtypeId(imi, hashCode)) {
|
||||||
|
return s;
|
||||||
|
} else {
|
||||||
|
return NOT_A_SUBTYPE_ID_STR;
|
||||||
|
}
|
||||||
|
} catch (NumberFormatException e) {
|
||||||
|
return NOT_A_SUBTYPE_ID_STR;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// If imeId was enabled but subtypeId was disabled.
|
||||||
|
return NOT_A_SUBTYPE_ID_STR;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// If both imeId and subtypeId are disabled, return null
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
private List<Pair<String, String>> loadInputMethodAndSubtypeHistoryLocked() {
|
||||||
|
ArrayList<Pair<String, String>> imsList = new ArrayList<Pair<String, String>>();
|
||||||
|
final String subtypeHistoryStr = getSubtypeHistoryStr();
|
||||||
|
if (TextUtils.isEmpty(subtypeHistoryStr)) {
|
||||||
|
return imsList;
|
||||||
|
}
|
||||||
|
mInputMethodSplitter.setString(subtypeHistoryStr);
|
||||||
|
while (mInputMethodSplitter.hasNext()) {
|
||||||
|
String nextImsStr = mInputMethodSplitter.next();
|
||||||
|
mSubtypeSplitter.setString(nextImsStr);
|
||||||
|
if (mSubtypeSplitter.hasNext()) {
|
||||||
|
String subtypeId = NOT_A_SUBTYPE_ID_STR;
|
||||||
|
// The first element is ime id.
|
||||||
|
String imeId = mSubtypeSplitter.next();
|
||||||
|
while (mSubtypeSplitter.hasNext()) {
|
||||||
|
subtypeId = mSubtypeSplitter.next();
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
imsList.add(new Pair<String, String>(imeId, subtypeId));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return imsList;
|
||||||
|
}
|
||||||
|
|
||||||
|
private String getSubtypeHistoryStr() {
|
||||||
|
if (DEBUG) {
|
||||||
|
Slog.d(TAG, "getSubtypeHistoryStr: " + Settings.Secure.getStringForUser(
|
||||||
|
mResolver, Settings.Secure.INPUT_METHODS_SUBTYPE_HISTORY, mCurrentUserId));
|
||||||
|
}
|
||||||
|
return Settings.Secure.getStringForUser(
|
||||||
|
mResolver, Settings.Secure.INPUT_METHODS_SUBTYPE_HISTORY, mCurrentUserId);
|
||||||
|
}
|
||||||
|
|
||||||
|
public void putSelectedInputMethod(String imeId) {
|
||||||
|
if (DEBUG) {
|
||||||
|
Slog.d(TAG, "putSelectedInputMethodStr: " + imeId + ", "
|
||||||
|
+ mCurrentUserId);
|
||||||
|
}
|
||||||
|
Settings.Secure.putStringForUser(
|
||||||
|
mResolver, Settings.Secure.DEFAULT_INPUT_METHOD, imeId, mCurrentUserId);
|
||||||
|
}
|
||||||
|
|
||||||
|
public void putSelectedSubtype(int subtypeId) {
|
||||||
|
if (DEBUG) {
|
||||||
|
Slog.d(TAG, "putSelectedInputMethodSubtypeStr: " + subtypeId + ", "
|
||||||
|
+ mCurrentUserId);
|
||||||
|
}
|
||||||
|
Settings.Secure.putIntForUser(mResolver, Settings.Secure.SELECTED_INPUT_METHOD_SUBTYPE,
|
||||||
|
subtypeId, mCurrentUserId);
|
||||||
|
}
|
||||||
|
|
||||||
|
public String getDisabledSystemInputMethods() {
|
||||||
|
return Settings.Secure.getStringForUser(
|
||||||
|
mResolver, Settings.Secure.DISABLED_SYSTEM_INPUT_METHODS, mCurrentUserId);
|
||||||
|
}
|
||||||
|
|
||||||
|
public String getSelectedInputMethod() {
|
||||||
|
if (DEBUG) {
|
||||||
|
Slog.d(TAG, "getSelectedInputMethodStr: " + Settings.Secure.getStringForUser(
|
||||||
|
mResolver, Settings.Secure.DEFAULT_INPUT_METHOD, mCurrentUserId)
|
||||||
|
+ ", " + mCurrentUserId);
|
||||||
|
}
|
||||||
|
return Settings.Secure.getStringForUser(
|
||||||
|
mResolver, Settings.Secure.DEFAULT_INPUT_METHOD, mCurrentUserId);
|
||||||
|
}
|
||||||
|
|
||||||
|
public boolean isSubtypeSelected() {
|
||||||
|
return getSelectedInputMethodSubtypeHashCode() != NOT_A_SUBTYPE_ID;
|
||||||
|
}
|
||||||
|
|
||||||
|
private int getSelectedInputMethodSubtypeHashCode() {
|
||||||
|
try {
|
||||||
|
return Settings.Secure.getIntForUser(
|
||||||
|
mResolver, Settings.Secure.SELECTED_INPUT_METHOD_SUBTYPE, mCurrentUserId);
|
||||||
|
} catch (SettingNotFoundException e) {
|
||||||
|
return NOT_A_SUBTYPE_ID;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
public int getCurrentUserId() {
|
||||||
|
return mCurrentUserId;
|
||||||
|
}
|
||||||
|
|
||||||
|
public int getSelectedInputMethodSubtypeId(String selectedImiId) {
|
||||||
|
final InputMethodInfo imi = mMethodMap.get(selectedImiId);
|
||||||
|
if (imi == null) {
|
||||||
|
return NOT_A_SUBTYPE_ID;
|
||||||
|
}
|
||||||
|
final int subtypeHashCode = getSelectedInputMethodSubtypeHashCode();
|
||||||
|
return getSubtypeIdFromHashCode(imi, subtypeHashCode);
|
||||||
|
}
|
||||||
|
|
||||||
|
public void saveCurrentInputMethodAndSubtypeToHistory(
|
||||||
|
String curMethodId, InputMethodSubtype currentSubtype) {
|
||||||
|
String subtypeId = NOT_A_SUBTYPE_ID_STR;
|
||||||
|
if (currentSubtype != null) {
|
||||||
|
subtypeId = String.valueOf(currentSubtype.hashCode());
|
||||||
|
}
|
||||||
|
if (canAddToLastInputMethod(currentSubtype)) {
|
||||||
|
addSubtypeToHistory(curMethodId, subtypeId);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user