Move InputMethodAndSubtypeEnabler to SettingsLib and port to TV (b8592357) · Commits · e / os / android_frameworks_base

packages/SettingsLib/res/values/strings.xml

+8 −0

Original line number	Diff line number	Diff line
		@@ -903,4 +903,12 @@

		<!-- Glyph to be overlaid atop the battery when the level is extremely low. Do not translate. -->
		<string name="battery_meter_very_low_overlay_symbol">!</string>

		<!-- Title for settings of active input methods in each IME [CHAR LIMIT=35] -->
		<string name="active_input_method_subtypes">Active input methods</string>
		<!-- Title for settings whether or not the framework will select input methods in an IME based
		on the current system locales. (The user can select multiple system locales)
		[CHAR LIMIT=35] -->
		<string name="use_system_language_to_select_input_method_subtypes">Use system languages</string>

		</resources>

packages/SettingsLib/src/com/android/settingslib/inputmethod/InputMethodAndSubtypeEnablerManager.java

0 → 100644

+263 −0

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

		import android.content.Context;
		import android.content.pm.PackageManager;
		import android.content.res.Configuration;
		import android.support.v14.preference.PreferenceFragment;
		import android.support.v7.preference.Preference;
		import android.support.v7.preference.PreferenceCategory;
		import android.support.v7.preference.PreferenceScreen;
		import android.support.v7.preference.TwoStatePreference;
		import android.text.TextUtils;
		import android.view.inputmethod.InputMethodInfo;
		import android.view.inputmethod.InputMethodManager;
		import android.view.inputmethod.InputMethodSubtype;

		import com.android.settingslib.R;

		import java.text.Collator;
		import java.util.ArrayList;
		import java.util.HashMap;
		import java.util.List;

		public class InputMethodAndSubtypeEnablerManager implements Preference.OnPreferenceChangeListener {

		private final PreferenceFragment mFragment;

		private boolean mHaveHardKeyboard;
		private final HashMap<String, List<Preference>> mInputMethodAndSubtypePrefsMap =
		new HashMap<>();
		private final HashMap<String, TwoStatePreference> mAutoSelectionPrefsMap = new HashMap<>();
		private InputMethodManager mImm;
		// TODO: Change mInputMethodInfoList to Map
		private List<InputMethodInfo> mInputMethodInfoList;
		private final Collator mCollator = Collator.getInstance();

		public InputMethodAndSubtypeEnablerManager(PreferenceFragment fragment) {
		mFragment = fragment;
		mImm = fragment.getContext().getSystemService(InputMethodManager.class);

		mInputMethodInfoList = mImm.getInputMethodList();
		}

		public void init(PreferenceFragment fragment, String targetImi, PreferenceScreen root) {
		final Configuration config = fragment.getResources().getConfiguration();
		mHaveHardKeyboard = (config.keyboard == Configuration.KEYBOARD_QWERTY);

		for (final InputMethodInfo imi : mInputMethodInfoList) {
		// Add subtype preferences of this IME when it is specified or no IME is specified.
		if (imi.getId().equals(targetImi) \|\| TextUtils.isEmpty(targetImi)) {
		addInputMethodSubtypePreferences(fragment, imi, root);
		}
		}
		}

		public void refresh(Context context, PreferenceFragment fragment) {
		// Refresh internal states in mInputMethodSettingValues to keep the latest
		// "InputMethodInfo"s and "InputMethodSubtype"s
		InputMethodSettingValuesWrapper
		.getInstance(context).refreshAllInputMethodAndSubtypes();
		InputMethodAndSubtypeUtil.loadInputMethodSubtypeList(fragment, context.getContentResolver(),
		mInputMethodInfoList, mInputMethodAndSubtypePrefsMap);
		updateAutoSelectionPreferences();
		}

		public void save(Context context, PreferenceFragment fragment) {
		InputMethodAndSubtypeUtil.saveInputMethodSubtypeList(fragment, context.getContentResolver(),
		mInputMethodInfoList, mHaveHardKeyboard);
		}

		@Override
		public boolean onPreferenceChange(final Preference pref, final Object newValue) {
		if (!(newValue instanceof Boolean)) {
		return true; // Invoke default behavior.
		}
		final boolean isChecking = (Boolean) newValue;
		for (final String imiId : mAutoSelectionPrefsMap.keySet()) {
		// An auto select subtype preference is changing.
		if (mAutoSelectionPrefsMap.get(imiId) == pref) {
		final TwoStatePreference autoSelectionPref = (TwoStatePreference) pref;
		autoSelectionPref.setChecked(isChecking);
		// Enable or disable subtypes depending on the auto selection preference.
		setAutoSelectionSubtypesEnabled(imiId, autoSelectionPref.isChecked());
		return false;
		}
		}
		// A subtype preference is changing.
		if (pref instanceof InputMethodSubtypePreference) {
		final InputMethodSubtypePreference subtypePref = (InputMethodSubtypePreference) pref;
		subtypePref.setChecked(isChecking);
		if (!subtypePref.isChecked()) {
		// It takes care of the case where no subtypes are explicitly enabled then the auto
		// selection preference is going to be checked.
		updateAutoSelectionPreferences();
		}
		return false;
		}
		return true; // Invoke default behavior.
		}

		private void addInputMethodSubtypePreferences(PreferenceFragment fragment, InputMethodInfo imi,
		final PreferenceScreen root) {
		Context prefContext = fragment.getPreferenceManager().getContext();

		final int subtypeCount = imi.getSubtypeCount();
		if (subtypeCount <= 1) {
		return;
		}
		final String imiId = imi.getId();
		final PreferenceCategory keyboardSettingsCategory =
		new PreferenceCategory(prefContext);
		root.addPreference(keyboardSettingsCategory);
		final PackageManager pm = prefContext.getPackageManager();
		final CharSequence label = imi.loadLabel(pm);

		keyboardSettingsCategory.setTitle(label);
		keyboardSettingsCategory.setKey(imiId);
		// TODO: Use toggle Preference if images are ready.
		final TwoStatePreference autoSelectionPref =
		new SwitchWithNoTextPreference(prefContext);
		mAutoSelectionPrefsMap.put(imiId, autoSelectionPref);
		keyboardSettingsCategory.addPreference(autoSelectionPref);
		autoSelectionPref.setOnPreferenceChangeListener(this);

		final PreferenceCategory activeInputMethodsCategory =
		new PreferenceCategory(prefContext);
		activeInputMethodsCategory.setTitle(R.string.active_input_method_subtypes);
		root.addPreference(activeInputMethodsCategory);

		CharSequence autoSubtypeLabel = null;
		final ArrayList<Preference> subtypePreferences = new ArrayList<>();
		for (int index = 0; index < subtypeCount; ++index) {
		final InputMethodSubtype subtype = imi.getSubtypeAt(index);
		if (subtype.overridesImplicitlyEnabledSubtype()) {
		if (autoSubtypeLabel == null) {
		autoSubtypeLabel = InputMethodAndSubtypeUtil.getSubtypeLocaleNameAsSentence(
		subtype, prefContext, imi);
		}
		} else {
		final Preference subtypePref = new InputMethodSubtypePreference(
		prefContext, subtype, imi);
		subtypePreferences.add(subtypePref);
		}
		}
		subtypePreferences.sort((lhs, rhs) -> {
		if (lhs instanceof InputMethodSubtypePreference) {
		return ((InputMethodSubtypePreference) lhs).compareTo(rhs, mCollator);
		}
		return lhs.compareTo(rhs);
		});
		for (final Preference pref : subtypePreferences) {
		activeInputMethodsCategory.addPreference(pref);
		pref.setOnPreferenceChangeListener(this);
		InputMethodAndSubtypeUtil.removeUnnecessaryNonPersistentPreference(pref);
		}
		mInputMethodAndSubtypePrefsMap.put(imiId, subtypePreferences);
		if (TextUtils.isEmpty(autoSubtypeLabel)) {
		autoSelectionPref.setTitle(
		R.string.use_system_language_to_select_input_method_subtypes);
		} else {
		autoSelectionPref.setTitle(autoSubtypeLabel);
		}
		}

		private boolean isNoSubtypesExplicitlySelected(final String imiId) {
		final List<Preference> subtypePrefs = mInputMethodAndSubtypePrefsMap.get(imiId);
		for (final Preference pref : subtypePrefs) {
		if (pref instanceof TwoStatePreference && ((TwoStatePreference) pref).isChecked()) {
		return false;
		}
		}
		return true;
		}

		private void setAutoSelectionSubtypesEnabled(final String imiId,
		final boolean autoSelectionEnabled) {
		final TwoStatePreference autoSelectionPref = mAutoSelectionPrefsMap.get(imiId);
		if (autoSelectionPref == null) {
		return;
		}
		autoSelectionPref.setChecked(autoSelectionEnabled);
		final List<Preference> subtypePrefs = mInputMethodAndSubtypePrefsMap.get(imiId);
		for (final Preference pref : subtypePrefs) {
		if (pref instanceof TwoStatePreference) {
		// When autoSelectionEnabled is true, all subtype prefs need to be disabled with
		// implicitly checked subtypes. In case of false, all subtype prefs need to be
		// enabled.
		pref.setEnabled(!autoSelectionEnabled);
		if (autoSelectionEnabled) {
		((TwoStatePreference) pref).setChecked(false);
		}
		}
		}
		if (autoSelectionEnabled) {
		InputMethodAndSubtypeUtil.saveInputMethodSubtypeList(
		mFragment, mFragment.getContext().getContentResolver(),
		mInputMethodInfoList, mHaveHardKeyboard);
		updateImplicitlyEnabledSubtypes(imiId);
		}
		}

		private void updateImplicitlyEnabledSubtypes(final String targetImiId) {
		// When targetImiId is null, apply to all subtypes of all IMEs
		for (final InputMethodInfo imi : mInputMethodInfoList) {
		final String imiId = imi.getId();
		final TwoStatePreference autoSelectionPref = mAutoSelectionPrefsMap.get(imiId);
		// No need to update implicitly enabled subtypes when the user has unchecked the
		// "subtype auto selection".
		if (autoSelectionPref == null \|\| !autoSelectionPref.isChecked()) {
		continue;
		}
		if (imiId.equals(targetImiId) \|\| targetImiId == null) {
		updateImplicitlyEnabledSubtypesOf(imi);
		}
		}
		}

		private void updateImplicitlyEnabledSubtypesOf(final InputMethodInfo imi) {
		final String imiId = imi.getId();
		final List<Preference> subtypePrefs = mInputMethodAndSubtypePrefsMap.get(imiId);
		final List<InputMethodSubtype> implicitlyEnabledSubtypes =
		mImm.getEnabledInputMethodSubtypeList(imi, true);
		if (subtypePrefs == null \|\| implicitlyEnabledSubtypes == null) {
		return;
		}
		for (final Preference pref : subtypePrefs) {
		if (!(pref instanceof TwoStatePreference)) {
		continue;
		}
		final TwoStatePreference subtypePref = (TwoStatePreference) pref;
		subtypePref.setChecked(false);
		for (final InputMethodSubtype subtype : implicitlyEnabledSubtypes) {
		final String implicitlyEnabledSubtypePrefKey = imiId + subtype.hashCode();
		if (subtypePref.getKey().equals(implicitlyEnabledSubtypePrefKey)) {
		subtypePref.setChecked(true);
		break;
		}
		}
		}
		}

		private void updateAutoSelectionPreferences() {
		for (final String imiId : mInputMethodAndSubtypePrefsMap.keySet()) {
		setAutoSelectionSubtypesEnabled(imiId, isNoSubtypesExplicitlySelected(imiId));
		}
		updateImplicitlyEnabledSubtypes(null /* targetImiId / / check */);
		}
		}

packages/SettingsLib/src/com/android/settingslib/inputmethod/InputMethodAndSubtypeUtil.java

0 → 100644

+420 −0

File added.

Preview size limit exceeded, changes collapsed.

packages/SettingsLib/src/com/android/settingslib/inputmethod/InputMethodSettingValuesWrapper.java

0 → 100644

+185 −0

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

		import android.app.ActivityManager;
		import android.content.Context;
		import android.os.RemoteException;
		import android.util.Log;
		import android.util.Slog;
		import android.view.inputmethod.InputMethodInfo;
		import android.view.inputmethod.InputMethodManager;
		import android.view.inputmethod.InputMethodSubtype;

		import com.android.internal.inputmethod.InputMethodUtils;
		import com.android.internal.inputmethod.InputMethodUtils.InputMethodSettings;

		import java.util.ArrayList;
		import java.util.HashMap;
		import java.util.HashSet;
		import java.util.List;
		import java.util.Locale;

		/**
		* This class is a wrapper for InputMethodSettings. You need to refresh internal states
		* manually on some events when "InputMethodInfo"s and "InputMethodSubtype"s can be
		* changed.
		*/
		// TODO: Consolidate this with {@link InputMethodAndSubtypeUtil}.
		public class InputMethodSettingValuesWrapper {
		private static final String TAG = InputMethodSettingValuesWrapper.class.getSimpleName();

		private static volatile InputMethodSettingValuesWrapper sInstance;
		private final ArrayList<InputMethodInfo> mMethodList = new ArrayList<>();
		private final HashMap<String, InputMethodInfo> mMethodMap = new HashMap<>();
		private final InputMethodSettings mSettings;
		private final InputMethodManager mImm;
		private final HashSet<InputMethodInfo> mAsciiCapableEnabledImis = new HashSet<>();

		public static InputMethodSettingValuesWrapper getInstance(Context context) {
		if (sInstance == null) {
		synchronized (TAG) {
		if (sInstance == null) {
		sInstance = new InputMethodSettingValuesWrapper(context);
		}
		}
		}
		return sInstance;
		}

		private static int getDefaultCurrentUserId() {
		try {
		return ActivityManager.getService().getCurrentUser().id;
		} catch (RemoteException e) {
		Slog.w(TAG, "Couldn't get current user ID; guessing it's 0", e);
		}
		return 0;
		}

		// Ensure singleton
		private InputMethodSettingValuesWrapper(Context context) {
		mSettings = new InputMethodSettings(context.getResources(), context.getContentResolver(),
		mMethodMap, mMethodList, getDefaultCurrentUserId(), false /* copyOnWrite */);
		mImm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
		refreshAllInputMethodAndSubtypes();
		}

		public void refreshAllInputMethodAndSubtypes() {
		synchronized (mMethodMap) {
		mMethodList.clear();
		mMethodMap.clear();
		final List<InputMethodInfo> imms = mImm.getInputMethodList();
		mMethodList.addAll(imms);
		for (InputMethodInfo imi : imms) {
		mMethodMap.put(imi.getId(), imi);
		}
		updateAsciiCapableEnabledImis();
		}
		}

		// TODO: Add a cts to ensure at least one AsciiCapableSubtypeEnabledImis exist
		private void updateAsciiCapableEnabledImis() {
		synchronized (mMethodMap) {
		mAsciiCapableEnabledImis.clear();
		final List<InputMethodInfo> enabledImis = mSettings.getEnabledInputMethodListLocked();
		for (final InputMethodInfo imi : enabledImis) {
		final int subtypeCount = imi.getSubtypeCount();
		for (int i = 0; i < subtypeCount; ++i) {
		final InputMethodSubtype subtype = imi.getSubtypeAt(i);
		if (InputMethodUtils.SUBTYPE_MODE_KEYBOARD.equalsIgnoreCase(subtype.getMode())
		&& subtype.isAsciiCapable()) {
		mAsciiCapableEnabledImis.add(imi);
		break;
		}
		}
		}
		}
		}

		public List<InputMethodInfo> getInputMethodList() {
		synchronized (mMethodMap) {
		return mMethodList;
		}
		}

		public boolean isAlwaysCheckedIme(InputMethodInfo imi, Context context) {
		final boolean isEnabled = isEnabledImi(imi);
		synchronized (mMethodMap) {
		if (mSettings.getEnabledInputMethodListLocked().size() <= 1 && isEnabled) {
		return true;
		}
		}

		final int enabledValidSystemNonAuxAsciiCapableImeCount =
		getEnabledValidSystemNonAuxAsciiCapableImeCount(context);

		return enabledValidSystemNonAuxAsciiCapableImeCount <= 1
		&& !(enabledValidSystemNonAuxAsciiCapableImeCount == 1 && !isEnabled)
		&& InputMethodUtils.isSystemIme(imi)
		&& isValidSystemNonAuxAsciiCapableIme(imi, context);

		}

		private int getEnabledValidSystemNonAuxAsciiCapableImeCount(Context context) {
		int count = 0;
		final List<InputMethodInfo> enabledImis;
		synchronized (mMethodMap) {
		enabledImis = mSettings.getEnabledInputMethodListLocked();
		}
		for (final InputMethodInfo imi : enabledImis) {
		if (isValidSystemNonAuxAsciiCapableIme(imi, context)) {
		++count;
		}
		}
		if (count == 0) {
		Log.w(TAG, "No \"enabledValidSystemNonAuxAsciiCapableIme\"s found.");
		}
		return count;
		}

		public boolean isEnabledImi(InputMethodInfo imi) {
		final List<InputMethodInfo> enabledImis;
		synchronized (mMethodMap) {
		enabledImis = mSettings.getEnabledInputMethodListLocked();
		}
		for (final InputMethodInfo tempImi : enabledImis) {
		if (tempImi.getId().equals(imi.getId())) {
		return true;
		}
		}
		return false;
		}

		public boolean isValidSystemNonAuxAsciiCapableIme(InputMethodInfo imi, Context context) {
		if (imi.isAuxiliaryIme()) {
		return false;
		}
		final Locale systemLocale = context.getResources().getConfiguration().locale;
		if (InputMethodUtils.isSystemImeThatHasSubtypeOf(imi, context,
		true /* checkDefaultAttribute /, systemLocale, false / checkCountry */,
		InputMethodUtils.SUBTYPE_MODE_ANY)) {
		return true;
		}
		if (mAsciiCapableEnabledImis.isEmpty()) {
		Log.w(TAG, "ascii capable subtype enabled imi not found. Fall back to English"
		+ " Keyboard subtype.");
		return InputMethodUtils.containsSubtypeOf(imi, Locale.ENGLISH, false /* checkCountry */,
		InputMethodUtils.SUBTYPE_MODE_KEYBOARD);
		}
		return mAsciiCapableEnabledImis.contains(imi);
		}
		}

packages/SettingsLib/src/com/android/settingslib/inputmethod/InputMethodSubtypePreference.java

0 → 100644

+91 −0

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

		import android.content.Context;
		import android.support.v14.preference.SwitchPreference;
		import android.support.v7.preference.Preference;
		import android.text.TextUtils;
		import android.view.inputmethod.InputMethodInfo;
		import android.view.inputmethod.InputMethodSubtype;

		import com.android.internal.inputmethod.InputMethodUtils;

		import java.text.Collator;
		import java.util.Locale;

		/**
		* Input method subtype preference.
		*
		* This preference represents a subtype of an IME. It is used to enable or disable the subtype.
		*/
		public class InputMethodSubtypePreference extends SwitchWithNoTextPreference {
		private final boolean mIsSystemLocale;
		private final boolean mIsSystemLanguage;

		public InputMethodSubtypePreference(final Context context, final InputMethodSubtype subtype,
		final InputMethodInfo imi) {
		super(context);
		setPersistent(false);
		setKey(imi.getId() + subtype.hashCode());
		final CharSequence subtypeLabel =
		InputMethodAndSubtypeUtil.getSubtypeLocaleNameAsSentence(subtype, context, imi);
		setTitle(subtypeLabel);
		final String subtypeLocaleString = subtype.getLocale();
		if (TextUtils.isEmpty(subtypeLocaleString)) {
		mIsSystemLocale = false;
		mIsSystemLanguage = false;
		} else {
		final Locale systemLocale = context.getResources().getConfiguration().locale;
		mIsSystemLocale = subtypeLocaleString.equals(systemLocale.toString());
		mIsSystemLanguage = mIsSystemLocale
		\|\| InputMethodUtils.getLanguageFromLocaleString(subtypeLocaleString)
		.equals(systemLocale.getLanguage());
		}
		}

		public int compareTo(final Preference rhs, final Collator collator) {
		if (this == rhs) {
		return 0;
		}
		if (rhs instanceof InputMethodSubtypePreference) {
		final InputMethodSubtypePreference rhsPref = (InputMethodSubtypePreference) rhs;
		if (mIsSystemLocale && !rhsPref.mIsSystemLocale) {
		return -1;
		}
		if (!mIsSystemLocale && rhsPref.mIsSystemLocale) {
		return 1;
		}
		if (mIsSystemLanguage && !rhsPref.mIsSystemLanguage) {
		return -1;
		}
		if (!mIsSystemLanguage && rhsPref.mIsSystemLanguage) {
		return 1;
		}
		final CharSequence t0 = getTitle();
		final CharSequence t1 = rhs.getTitle();
		if (t0 == null && t1 == null) {
		return Integer.compare(hashCode(), rhs.hashCode());
		}
		if (t0 != null && t1 != null) {
		return collator.compare(t0.toString(), t1.toString());
		}
		return t0 == null ? -1 : 1;
		}
		return super.compareTo(rhs);
		}
		}