src/com/android/settings/inputmethod/InputMethodAndLanguageSettings.java

   1 /*
   2  * Copyright (C) 2008 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.settings.inputmethod;
  18
  19 import android.app.Activity;
  20 import android.app.Fragment;
  21 import android.app.admin.DevicePolicyManager;
  22 import android.content.ComponentName;
  23 import android.content.ContentResolver;
  24 import android.content.Context;
  25 import android.content.Intent;
  26 import android.content.SharedPreferences;
  27 import android.content.pm.ServiceInfo;
  28 import android.content.res.Configuration;
  29 import android.database.ContentObserver;
  30 import android.hardware.input.InputDeviceIdentifier;
  31 import android.hardware.input.InputManager;
  32 import android.hardware.input.KeyboardLayout;
  33 import android.os.Bundle;
  34 import android.os.Handler;
  35 import android.preference.ListPreference;
  36 import android.preference.Preference;
  37 import android.preference.Preference.OnPreferenceClickListener;
  38 import android.preference.PreferenceCategory;
  39 import android.preference.PreferenceManager;
  40 import android.preference.PreferenceScreen;
  41 import android.preference.SwitchPreference;
  42 import android.provider.Settings;
  43 import android.provider.Settings.System;
  44 import android.speech.tts.TtsEngines;
  45 import android.text.TextUtils;
  46 import android.view.InputDevice;
  47 import android.view.inputmethod.InputMethodInfo;
  48 import android.view.inputmethod.InputMethodManager;
  49 import android.view.inputmethod.InputMethodSubtype;
  50 import android.view.textservice.SpellCheckerInfo;
  51 import android.view.textservice.TextServicesManager;
  52
  53 import com.android.internal.app.LocalePicker;
  54 import com.android.internal.logging.MetricsLogger;
  55 import com.android.settings.R;
  56 import com.android.settings.Settings.KeyboardLayoutPickerActivity;
  57 import com.android.settings.SettingsActivity;
  58 import com.android.settings.SettingsPreferenceFragment;
  59 import com.android.settings.SubSettings;
  60 import com.android.settings.UserDictionarySettings;
  61 import com.android.settings.Utils;
  62 import com.android.settings.VoiceInputOutputSettings;
  63 import com.android.settings.search.BaseSearchIndexProvider;
  64 import com.android.settings.search.Indexable;
  65 import com.android.settings.search.SearchIndexableRaw;
  66
  67 import java.text.Collator;
  68 import java.util.ArrayList;
  69 import java.util.Collections;
  70 import java.util.Comparator;
  71 import java.util.HashMap;
  72 import java.util.HashSet;
  73 import java.util.List;
  74 import java.util.Locale;
  75 import java.util.TreeSet;
  76
  77 public class InputMethodAndLanguageSettings extends SettingsPreferenceFragment
  78         implements Preference.OnPreferenceChangeListener, InputManager.InputDeviceListener,
  79         KeyboardLayoutDialogFragment.OnSetupKeyboardLayoutsListener, Indexable,
  80         InputMethodPreference.OnSavePreferenceListener {
  81     private static final String KEY_SPELL_CHECKERS = "spellcheckers_settings";
  82     private static final String KEY_PHONE_LANGUAGE = "phone_language";
  83     private static final String KEY_CURRENT_INPUT_METHOD = "current_input_method";
  84     private static final String KEY_INPUT_METHOD_SELECTOR = "input_method_selector";
  85     private static final String KEY_USER_DICTIONARY_SETTINGS = "key_user_dictionary_settings";
  86     private static final String KEY_PREVIOUSLY_ENABLED_SUBTYPES = "previously_enabled_subtypes";
  87     // false: on ICS or later
  88     private static final boolean SHOW_INPUT_METHOD_SWITCHER_SETTINGS = false;
  89
  90     private int mDefaultInputMethodSelectorVisibility = 0;
  91     private ListPreference mShowInputMethodSelectorPref;
  92     private PreferenceCategory mKeyboardSettingsCategory;
  93     private PreferenceCategory mHardKeyboardCategory;
  94     private PreferenceCategory mGameControllerCategory;
  95     private Preference mLanguagePref;
  96     private final ArrayList<InputMethodPreference> mInputMethodPreferenceList = new ArrayList<>();
  97     private final ArrayList<PreferenceScreen> mHardKeyboardPreferenceList = new ArrayList<>();
  98     private InputManager mIm;
  99     private InputMethodManager mImm;
 100     private boolean mShowsOnlyFullImeAndKeyboardList;
 101     private Handler mHandler;
 102     private SettingsObserver mSettingsObserver;
 103     private Intent mIntentWaitingForResult;
 104     private InputMethodSettingValuesWrapper mInputMethodSettingValues;
 105     private DevicePolicyManager mDpm;
 106
 107     @Override
 108     protected int getMetricsCategory() {
 109         return MetricsLogger.INPUTMETHOD_LANGUAGE;
 110     }
 111
 112     @Override
 113     public void onCreate(Bundle icicle) {
 114         super.onCreate(icicle);
 115
 116         addPreferencesFromResource(R.xml.language_settings);
 117
 118         final Activity activity = getActivity();
 119         mImm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
 120         mInputMethodSettingValues = InputMethodSettingValuesWrapper.getInstance(activity);
 121
 122         try {
 123             mDefaultInputMethodSelectorVisibility = Integer.valueOf(
 124                     getString(R.string.input_method_selector_visibility_default_value));
 125         } catch (NumberFormatException e) {
 126         }
 127
 128         if (activity.getAssets().getLocales().length == 1) {
 129             // No "Select language" pref if there's only one system locale available.
 130             getPreferenceScreen().removePreference(findPreference(KEY_PHONE_LANGUAGE));
 131         } else {
 132             mLanguagePref = findPreference(KEY_PHONE_LANGUAGE);
 133         }
 134         if (SHOW_INPUT_METHOD_SWITCHER_SETTINGS) {
 135             mShowInputMethodSelectorPref = (ListPreference)findPreference(
 136                     KEY_INPUT_METHOD_SELECTOR);
 137             mShowInputMethodSelectorPref.setOnPreferenceChangeListener(this);
 138             // TODO: Update current input method name on summary
 139             updateInputMethodSelectorSummary(loadInputMethodSelectorVisibility());
 140         }
 141
 142         new VoiceInputOutputSettings(this).onCreate();
 143
 144         // Get references to dynamically constructed categories.
 145         mHardKeyboardCategory = (PreferenceCategory)findPreference("hard_keyboard");
 146         mKeyboardSettingsCategory = (PreferenceCategory)findPreference(
 147                 "keyboard_settings_category");
 148         mGameControllerCategory = (PreferenceCategory)findPreference(
 149                 "game_controller_settings_category");
 150
 151         final Intent startingIntent = activity.getIntent();
 152         // Filter out irrelevant features if invoked from IME settings button.
 153         mShowsOnlyFullImeAndKeyboardList = Settings.ACTION_INPUT_METHOD_SETTINGS.equals(
 154                 startingIntent.getAction());
 155         if (mShowsOnlyFullImeAndKeyboardList) {
 156             getPreferenceScreen().removeAll();
 157             getPreferenceScreen().addPreference(mHardKeyboardCategory);
 158             if (SHOW_INPUT_METHOD_SWITCHER_SETTINGS) {
 159                 getPreferenceScreen().addPreference(mShowInputMethodSelectorPref);
 160             }
 161             mKeyboardSettingsCategory.removeAll();
 162             getPreferenceScreen().addPreference(mKeyboardSettingsCategory);
 163         }
 164
 165         // Build hard keyboard and game controller preference categories.
 166         mIm = (InputManager)activity.getSystemService(Context.INPUT_SERVICE);
 167         updateInputDevices();
 168
 169         // Spell Checker
 170         final Preference spellChecker = findPreference(KEY_SPELL_CHECKERS);
 171         if (spellChecker != null) {
 172             // Note: KEY_SPELL_CHECKERS preference is marked as persistent="false" in XML.
 173             InputMethodAndSubtypeUtil.removeUnnecessaryNonPersistentPreference(spellChecker);
 174             final Intent intent = new Intent(Intent.ACTION_MAIN);
 175             intent.setClass(activity, SubSettings.class);
 176             intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT,
 177                     SpellCheckersSettings.class.getName());
 178             intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_TITLE_RESID,
 179                     R.string.spellcheckers_settings_title);
 180             spellChecker.setIntent(intent);
 181         }
 182
 183         mHandler = new Handler();
 184         mSettingsObserver = new SettingsObserver(mHandler, activity);
 185         mDpm = (DevicePolicyManager) (getActivity().
 186                 getSystemService(Context.DEVICE_POLICY_SERVICE));
 187
 188         // If we've launched from the keyboard layout notification, go ahead and just show the
 189         // keyboard layout dialog.
 190         final InputDeviceIdentifier identifier =
 191                 startingIntent.getParcelableExtra(Settings.EXTRA_INPUT_DEVICE_IDENTIFIER);
 192         if (mShowsOnlyFullImeAndKeyboardList && identifier != null) {
 193             showKeyboardLayoutDialog(identifier);
 194         }
 195     }
 196
 197     private void updateInputMethodSelectorSummary(int value) {
 198         String[] inputMethodSelectorTitles = getResources().getStringArray(
 199                 R.array.input_method_selector_titles);
 200         if (inputMethodSelectorTitles.length > value) {
 201             mShowInputMethodSelectorPref.setSummary(inputMethodSelectorTitles[value]);
 202             mShowInputMethodSelectorPref.setValue(String.valueOf(value));
 203         }
 204     }
 205
 206     private void updateUserDictionaryPreference(Preference userDictionaryPreference) {
 207         final Activity activity = getActivity();
 208         final TreeSet<String> localeSet = UserDictionaryList.getUserDictionaryLocalesSet(activity);
 209         if (null == localeSet) {
 210             // The locale list is null if and only if the user dictionary service is
 211             // not present or disabled. In this case we need to remove the preference.
 212             getPreferenceScreen().removePreference(userDictionaryPreference);
 213         } else {
 214             userDictionaryPreference.setOnPreferenceClickListener(
 215                     new OnPreferenceClickListener() {
 216                         @Override
 217                         public boolean onPreferenceClick(Preference arg0) {
 218                             // Redirect to UserDictionarySettings if the user needs only one
 219                             // language.
 220                             final Bundle extras = new Bundle();
 221                             final Class<? extends Fragment> targetFragment;
 222                             if (localeSet.size() <= 1) {
 223                                 if (!localeSet.isEmpty()) {
 224                                     // If the size of localeList is 0, we don't set the locale
 225                                     // parameter in the extras. This will be interpreted by the
 226                                     // UserDictionarySettings class as meaning
 227                                     // "the current locale". Note that with the current code for
 228                                     // UserDictionaryList#getUserDictionaryLocalesSet()
 229                                     // the locale list always has at least one element, since it
 230                                     // always includes the current locale explicitly.
 231                                     // @see UserDictionaryList.getUserDictionaryLocalesSet().
 232                                     extras.putString("locale", localeSet.first());
 233                                 }
 234                                 targetFragment = UserDictionarySettings.class;
 235                             } else {
 236                                 targetFragment = UserDictionaryList.class;
 237                             }
 238                             startFragment(InputMethodAndLanguageSettings.this,
 239                                     targetFragment.getCanonicalName(), -1, -1, extras);
 240                             return true;
 241                         }
 242                     });
 243         }
 244     }
 245
 246     @Override
 247     public void onResume() {
 248         super.onResume();
 249
 250         mSettingsObserver.resume();
 251         mIm.registerInputDeviceListener(this, null);
 252
 253         final Preference spellChecker = findPreference(KEY_SPELL_CHECKERS);
 254         if (spellChecker != null) {
 255             final TextServicesManager tsm = (TextServicesManager) getSystemService(
 256                     Context.TEXT_SERVICES_MANAGER_SERVICE);
 257             final SpellCheckerInfo sci = tsm.getCurrentSpellChecker();
 258             spellChecker.setEnabled(sci != null);
 259             if (tsm.isSpellCheckerEnabled() && sci != null) {
 260                 spellChecker.setSummary(sci.loadLabel(getPackageManager()));
 261             } else {
 262                 spellChecker.setSummary(R.string.switch_off_text);
 263             }
 264         }
 265
 266         if (!mShowsOnlyFullImeAndKeyboardList) {
 267             if (mLanguagePref != null) {
 268                 String localeName = getLocaleName(getActivity());
 269                 mLanguagePref.setSummary(localeName);
 270             }
 271
 272             updateUserDictionaryPreference(findPreference(KEY_USER_DICTIONARY_SETTINGS));
 273             if (SHOW_INPUT_METHOD_SWITCHER_SETTINGS) {
 274                 mShowInputMethodSelectorPref.setOnPreferenceChangeListener(this);
 275             }
 276         }
 277
 278         updateInputDevices();
 279
 280         // Refresh internal states in mInputMethodSettingValues to keep the latest
 281         // "InputMethodInfo"s and "InputMethodSubtype"s
 282         mInputMethodSettingValues.refreshAllInputMethodAndSubtypes();
 283         updateInputMethodPreferenceViews();
 284     }
 285
 286     @Override
 287     public void onPause() {
 288         super.onPause();
 289
 290         mIm.unregisterInputDeviceListener(this);
 291         mSettingsObserver.pause();
 292
 293         if (SHOW_INPUT_METHOD_SWITCHER_SETTINGS) {
 294             mShowInputMethodSelectorPref.setOnPreferenceChangeListener(null);
 295         }
 296         // TODO: Consolidate the logic to InputMethodSettingsWrapper
 297         InputMethodAndSubtypeUtil.saveInputMethodSubtypeList(
 298                 this, getContentResolver(), mInputMethodSettingValues.getInputMethodList(),
 299                 !mHardKeyboardPreferenceList.isEmpty());
 300     }
 301
 302     @Override
 303     public void onInputDeviceAdded(int deviceId) {
 304         updateInputDevices();
 305     }
 306
 307     @Override
 308     public void onInputDeviceChanged(int deviceId) {
 309         updateInputDevices();
 310     }
 311
 312     @Override
 313     public void onInputDeviceRemoved(int deviceId) {
 314         updateInputDevices();
 315     }
 316
 317     @Override
 318     public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
 319         // Input Method stuff
 320         if (Utils.isMonkeyRunning()) {
 321             return false;
 322         }
 323         if (preference instanceof PreferenceScreen) {
 324             if (preference.getFragment() != null) {
 325                 // Fragment will be handled correctly by the super class.
 326             } else if (KEY_CURRENT_INPUT_METHOD.equals(preference.getKey())) {
 327                 final InputMethodManager imm = (InputMethodManager)
 328                         getSystemService(Context.INPUT_METHOD_SERVICE);
 329                 imm.showInputMethodPicker(false /* showAuxiliarySubtypes */);
 330             }
 331         } else if (preference instanceof SwitchPreference) {
 332             final SwitchPreference pref = (SwitchPreference) preference;
 333             if (pref == mGameControllerCategory.findPreference("vibrate_input_devices")) {
 334                 System.putInt(getContentResolver(), Settings.System.VIBRATE_INPUT_DEVICES,
 335                         pref.isChecked() ? 1 : 0);
 336                 return true;
 337             }
 338         }
 339         return super.onPreferenceTreeClick(preferenceScreen, preference);
 340     }
 341
 342     private static String getLocaleName(Context context) {
 343         // We want to show the same string that the LocalePicker used.
 344         // TODO: should this method be in LocalePicker instead?
 345         Locale currentLocale = context.getResources().getConfiguration().locale;
 346         List<LocalePicker.LocaleInfo> locales = LocalePicker.getAllAssetLocales(context, true);
 347         for (LocalePicker.LocaleInfo locale : locales) {
 348             if (locale.getLocale().equals(currentLocale)) {
 349                 return locale.getLabel();
 350             }
 351         }
 352         // This can't happen as long as the locale was one set by Settings.
 353         // Fall back in case a developer is testing an unsupported locale.
 354         return currentLocale.getDisplayName(currentLocale);
 355     }
 356
 357     private void saveInputMethodSelectorVisibility(String value) {
 358         try {
 359             int intValue = Integer.valueOf(value);
 360             Settings.Secure.putInt(getContentResolver(),
 361                     Settings.Secure.INPUT_METHOD_SELECTOR_VISIBILITY, intValue);
 362             updateInputMethodSelectorSummary(intValue);
 363         } catch(NumberFormatException e) {
 364         }
 365     }
 366
 367     private int loadInputMethodSelectorVisibility() {
 368         return Settings.Secure.getInt(getContentResolver(),
 369                 Settings.Secure.INPUT_METHOD_SELECTOR_VISIBILITY,
 370                 mDefaultInputMethodSelectorVisibility);
 371     }
 372
 373     @Override
 374     public boolean onPreferenceChange(Preference preference, Object value) {
 375         if (SHOW_INPUT_METHOD_SWITCHER_SETTINGS) {
 376             if (preference == mShowInputMethodSelectorPref) {
 377                 if (value instanceof String) {
 378                     saveInputMethodSelectorVisibility((String)value);
 379                 }
 380             }
 381         }
 382         return false;
 383     }
 384
 385     private void updateInputMethodPreferenceViews() {
 386         synchronized (mInputMethodPreferenceList) {
 387             // Clear existing "InputMethodPreference"s
 388             for (final InputMethodPreference pref : mInputMethodPreferenceList) {
 389                 mKeyboardSettingsCategory.removePreference(pref);
 390             }
 391             mInputMethodPreferenceList.clear();
 392             List<String> permittedList = mDpm.getPermittedInputMethodsForCurrentUser();
 393             final Context context = getActivity();
 394             final List<InputMethodInfo> imis = mShowsOnlyFullImeAndKeyboardList
 395                     ? mInputMethodSettingValues.getInputMethodList()
 396                     : mImm.getEnabledInputMethodList();
 397             final int N = (imis == null ? 0 : imis.size());
 398             for (int i = 0; i < N; ++i) {
 399                 final InputMethodInfo imi = imis.get(i);
 400                 final boolean isAllowedByOrganization = permittedList == null
 401                         || permittedList.contains(imi.getPackageName());
 402                 final InputMethodPreference pref = new InputMethodPreference(
 403                         context, imi, mShowsOnlyFullImeAndKeyboardList /* hasSwitch */,
 404                         isAllowedByOrganization, this);
 405                 mInputMethodPreferenceList.add(pref);
 406             }
 407             final Collator collator = Collator.getInstance();
 408             Collections.sort(mInputMethodPreferenceList, new Comparator<InputMethodPreference>() {
 409                 @Override
 410                 public int compare(InputMethodPreference lhs, InputMethodPreference rhs) {
 411                     return lhs.compareTo(rhs, collator);
 412                 }
 413             });
 414             for (int i = 0; i < N; ++i) {
 415                 final InputMethodPreference pref = mInputMethodPreferenceList.get(i);
 416                 mKeyboardSettingsCategory.addPreference(pref);
 417                 InputMethodAndSubtypeUtil.removeUnnecessaryNonPersistentPreference(pref);
 418                 pref.updatePreferenceViews();
 419             }
 420         }
 421         updateCurrentImeName();
 422         // TODO: Consolidate the logic with InputMethodSettingsWrapper
 423         // CAVEAT: The preference class here does not know about the default value - that is
 424         // managed by the Input Method Manager Service, so in this case it could save the wrong
 425         // value. Hence we must update the checkboxes here.
 426         InputMethodAndSubtypeUtil.loadInputMethodSubtypeList(
 427                 this, getContentResolver(),
 428                 mInputMethodSettingValues.getInputMethodList(), null);
 429     }
 430
 431     @Override
 432     public void onSaveInputMethodPreference(final InputMethodPreference pref) {
 433         final InputMethodInfo imi = pref.getInputMethodInfo();
 434         if (!pref.isChecked()) {
 435             // An IME is being disabled. Save enabled subtypes of the IME to shared preference to be
 436             // able to re-enable these subtypes when the IME gets re-enabled.
 437             saveEnabledSubtypesOf(imi);
 438         }
 439         final boolean hasHardwareKeyboard = getResources().getConfiguration().keyboard
 440                 == Configuration.KEYBOARD_QWERTY;
 441         InputMethodAndSubtypeUtil.saveInputMethodSubtypeList(this, getContentResolver(),
 442                 mImm.getInputMethodList(), hasHardwareKeyboard);
 443         // Update input method settings and preference list.
 444         mInputMethodSettingValues.refreshAllInputMethodAndSubtypes();
 445         if (pref.isChecked()) {
 446             // An IME is being enabled. Load the previously enabled subtypes from shared preference
 447             // and enable these subtypes.
 448             restorePreviouslyEnabledSubtypesOf(imi);
 449         }
 450         for (final InputMethodPreference p : mInputMethodPreferenceList) {
 451             p.updatePreferenceViews();
 452         }
 453     }
 454
 455     private void saveEnabledSubtypesOf(final InputMethodInfo imi) {
 456         final HashSet<String> enabledSubtypeIdSet = new HashSet<>();
 457         final List<InputMethodSubtype> enabledSubtypes = mImm.getEnabledInputMethodSubtypeList(
 458                 imi, true /* allowsImplicitlySelectedSubtypes */);
 459         for (final InputMethodSubtype subtype : enabledSubtypes) {
 460             final String subtypeId = Integer.toString(subtype.hashCode());
 461             enabledSubtypeIdSet.add(subtypeId);
 462         }
 463         final HashMap<String, HashSet<String>> imeToEnabledSubtypeIdsMap =
 464                 loadPreviouslyEnabledSubtypeIdsMap();
 465         final String imiId = imi.getId();
 466         imeToEnabledSubtypeIdsMap.put(imiId, enabledSubtypeIdSet);
 467         savePreviouslyEnabledSubtypeIdsMap(imeToEnabledSubtypeIdsMap);
 468     }
 469
 470     private void restorePreviouslyEnabledSubtypesOf(final InputMethodInfo imi) {
 471         final HashMap<String, HashSet<String>> imeToEnabledSubtypeIdsMap =
 472                 loadPreviouslyEnabledSubtypeIdsMap();
 473         final String imiId = imi.getId();
 474         final HashSet<String> enabledSubtypeIdSet = imeToEnabledSubtypeIdsMap.remove(imiId);
 475         if (enabledSubtypeIdSet == null) {
 476             return;
 477         }
 478         savePreviouslyEnabledSubtypeIdsMap(imeToEnabledSubtypeIdsMap);
 479         InputMethodAndSubtypeUtil.enableInputMethodSubtypesOf(
 480                 getContentResolver(), imiId, enabledSubtypeIdSet);
 481     }
 482
 483     private HashMap<String, HashSet<String>> loadPreviouslyEnabledSubtypeIdsMap() {
 484         final Context context = getActivity();
 485         final SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
 486         final String imesAndSubtypesString = prefs.getString(KEY_PREVIOUSLY_ENABLED_SUBTYPES, null);
 487         return InputMethodAndSubtypeUtil.parseInputMethodsAndSubtypesString(imesAndSubtypesString);
 488     }
 489
 490     private void savePreviouslyEnabledSubtypeIdsMap(
 491             final HashMap<String, HashSet<String>> subtypesMap) {
 492         final Context context = getActivity();
 493         final SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
 494         final String imesAndSubtypesString = InputMethodAndSubtypeUtil
 495                 .buildInputMethodsAndSubtypesString(subtypesMap);
 496         prefs.edit().putString(KEY_PREVIOUSLY_ENABLED_SUBTYPES, imesAndSubtypesString).apply();
 497     }
 498
 499     private void updateCurrentImeName() {
 500         final Context context = getActivity();
 501         if (context == null || mImm == null) return;
 502         final Preference curPref = getPreferenceScreen().findPreference(KEY_CURRENT_INPUT_METHOD);
 503         if (curPref != null) {
 504             final CharSequence curIme =
 505                     mInputMethodSettingValues.getCurrentInputMethodName(context);
 506             if (!TextUtils.isEmpty(curIme)) {
 507                 synchronized (this) {
 508                     curPref.setSummary(curIme);
 509                 }
 510             }
 511         }
 512     }
 513
 514     private void updateInputDevices() {
 515         updateHardKeyboards();
 516         updateGameControllers();
 517     }
 518
 519     private void updateHardKeyboards() {
 520         mHardKeyboardPreferenceList.clear();
 521         final int[] devices = InputDevice.getDeviceIds();
 522         for (int i = 0; i < devices.length; i++) {
 523             InputDevice device = InputDevice.getDevice(devices[i]);
 524             if (device != null
 525                     && !device.isVirtual()
 526                     && device.isFullKeyboard()) {
 527                 final InputDeviceIdentifier identifier = device.getIdentifier();
 528                 final String keyboardLayoutDescriptor =
 529                     mIm.getCurrentKeyboardLayoutForInputDevice(identifier);
 530                 final KeyboardLayout keyboardLayout = keyboardLayoutDescriptor != null ?
 531                     mIm.getKeyboardLayout(keyboardLayoutDescriptor) : null;
 532
 533                 final PreferenceScreen pref = new PreferenceScreen(getActivity(), null);
 534                 pref.setTitle(device.getName());
 535                 if (keyboardLayout != null) {
 536                     pref.setSummary(keyboardLayout.toString());
 537                 } else {
 538                     pref.setSummary(R.string.keyboard_layout_default_label);
 539                 }
 540                 pref.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {
 541                     @Override
 542                     public boolean onPreferenceClick(Preference preference) {
 543                         showKeyboardLayoutDialog(identifier);
 544                         return true;
 545                     }
 546                 });
 547                 mHardKeyboardPreferenceList.add(pref);
 548             }
 549         }
 550
 551         if (!mHardKeyboardPreferenceList.isEmpty()) {
 552             for (int i = mHardKeyboardCategory.getPreferenceCount(); i-- > 0; ) {
 553                 final Preference pref = mHardKeyboardCategory.getPreference(i);
 554                 if (pref.getOrder() < 1000) {
 555                     mHardKeyboardCategory.removePreference(pref);
 556                 }
 557             }
 558
 559             Collections.sort(mHardKeyboardPreferenceList);
 560             final int count = mHardKeyboardPreferenceList.size();
 561             for (int i = 0; i < count; i++) {
 562                 final Preference pref = mHardKeyboardPreferenceList.get(i);
 563                 pref.setOrder(i);
 564                 mHardKeyboardCategory.addPreference(pref);
 565             }
 566
 567             getPreferenceScreen().addPreference(mHardKeyboardCategory);
 568         } else {
 569             getPreferenceScreen().removePreference(mHardKeyboardCategory);
 570         }
 571     }
 572
 573     private void showKeyboardLayoutDialog(InputDeviceIdentifier inputDeviceIdentifier) {
 574         KeyboardLayoutDialogFragment fragment = new KeyboardLayoutDialogFragment(
 575                 inputDeviceIdentifier);
 576         fragment.setTargetFragment(this, 0);
 577         fragment.show(getActivity().getFragmentManager(), "keyboardLayout");
 578     }
 579
 580     @Override
 581     public void onSetupKeyboardLayouts(InputDeviceIdentifier inputDeviceIdentifier) {
 582         final Intent intent = new Intent(Intent.ACTION_MAIN);
 583         intent.setClass(getActivity(), KeyboardLayoutPickerActivity.class);
 584         intent.putExtra(KeyboardLayoutPickerFragment.EXTRA_INPUT_DEVICE_IDENTIFIER,
 585                 inputDeviceIdentifier);
 586         mIntentWaitingForResult = intent;
 587         startActivityForResult(intent, 0);
 588     }
 589
 590     @Override
 591     public void onActivityResult(int requestCode, int resultCode, Intent data) {
 592         super.onActivityResult(requestCode, resultCode, data);
 593
 594         if (mIntentWaitingForResult != null) {
 595             InputDeviceIdentifier inputDeviceIdentifier = mIntentWaitingForResult
 596                     .getParcelableExtra(KeyboardLayoutPickerFragment.EXTRA_INPUT_DEVICE_IDENTIFIER);
 597             mIntentWaitingForResult = null;
 598             showKeyboardLayoutDialog(inputDeviceIdentifier);
 599         }
 600     }
 601
 602     private void updateGameControllers() {
 603         if (haveInputDeviceWithVibrator()) {
 604             getPreferenceScreen().addPreference(mGameControllerCategory);
 605
 606             SwitchPreference pref = (SwitchPreference)
 607                     mGameControllerCategory.findPreference("vibrate_input_devices");
 608             pref.setChecked(System.getInt(getContentResolver(),
 609                     Settings.System.VIBRATE_INPUT_DEVICES, 1) > 0);
 610         } else {
 611             getPreferenceScreen().removePreference(mGameControllerCategory);
 612         }
 613     }
 614
 615     private static boolean haveInputDeviceWithVibrator() {
 616         final int[] devices = InputDevice.getDeviceIds();
 617         for (int i = 0; i < devices.length; i++) {
 618             InputDevice device = InputDevice.getDevice(devices[i]);
 619             if (device != null && !device.isVirtual() && device.getVibrator().hasVibrator()) {
 620                 return true;
 621             }
 622         }
 623         return false;
 624     }
 625
 626     private class SettingsObserver extends ContentObserver {
 627         private Context mContext;
 628
 629         public SettingsObserver(Handler handler, Context context) {
 630             super(handler);
 631             mContext = context;
 632         }
 633
 634         @Override public void onChange(boolean selfChange) {
 635             updateCurrentImeName();
 636         }
 637
 638         public void resume() {
 639             final ContentResolver cr = mContext.getContentResolver();
 640             cr.registerContentObserver(
 641                     Settings.Secure.getUriFor(Settings.Secure.DEFAULT_INPUT_METHOD), false, this);
 642             cr.registerContentObserver(Settings.Secure.getUriFor(
 643                     Settings.Secure.SELECTED_INPUT_METHOD_SUBTYPE), false, this);
 644         }
 645
 646         public void pause() {
 647             mContext.getContentResolver().unregisterContentObserver(this);
 648         }
 649     }
 650
 651     public static final Indexable.SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
 652             new BaseSearchIndexProvider() {
 653         @Override
 654         public List<SearchIndexableRaw> getRawDataToIndex(Context context, boolean enabled) {
 655             List<SearchIndexableRaw> indexables = new ArrayList<>();
 656
 657             final String screenTitle = context.getString(R.string.language_keyboard_settings_title);
 658
 659             // Locale picker.
 660             if (context.getAssets().getLocales().length > 1) {
 661                 String localeName = getLocaleName(context);
 662                 SearchIndexableRaw indexable = new SearchIndexableRaw(context);
 663                 indexable.key = KEY_PHONE_LANGUAGE;
 664                 indexable.title = context.getString(R.string.phone_language);
 665                 indexable.summaryOn = localeName;
 666                 indexable.summaryOff = localeName;
 667                 indexable.screenTitle = screenTitle;
 668                 indexables.add(indexable);
 669             }
 670
 671             // Spell checker.
 672             SearchIndexableRaw indexable = new SearchIndexableRaw(context);
 673             indexable.key = KEY_SPELL_CHECKERS;
 674             indexable.title = context.getString(R.string.spellcheckers_settings_title);
 675             indexable.screenTitle = screenTitle;
 676             indexable.keywords = context.getString(R.string.keywords_spell_checker);
 677             indexables.add(indexable);
 678
 679             // User dictionary.
 680             if (UserDictionaryList.getUserDictionaryLocalesSet(context) != null) {
 681                 indexable = new SearchIndexableRaw(context);
 682                 indexable.key = "user_dict_settings";
 683                 indexable.title = context.getString(R.string.user_dict_settings_title);
 684                 indexable.screenTitle = screenTitle;
 685                 indexables.add(indexable);
 686             }
 687
 688             // Keyboard settings.
 689             indexable = new SearchIndexableRaw(context);
 690             indexable.key = "keyboard_settings";
 691             indexable.title = context.getString(R.string.keyboard_settings_category);
 692             indexable.screenTitle = screenTitle;
 693             indexable.keywords = context.getString(R.string.keywords_keyboard_and_ime);
 694             indexables.add(indexable);
 695
 696             InputMethodSettingValuesWrapper immValues = InputMethodSettingValuesWrapper
 697                     .getInstance(context);
 698             immValues.refreshAllInputMethodAndSubtypes();
 699
 700             // Current IME.
 701             String currImeName = immValues.getCurrentInputMethodName(context).toString();
 702             indexable = new SearchIndexableRaw(context);
 703             indexable.key = KEY_CURRENT_INPUT_METHOD;
 704             indexable.title = context.getString(R.string.current_input_method);
 705             indexable.summaryOn = currImeName;
 706             indexable.summaryOff = currImeName;
 707             indexable.screenTitle = screenTitle;
 708             indexables.add(indexable);
 709
 710             InputMethodManager inputMethodManager = (InputMethodManager) context.getSystemService(
 711                     Context.INPUT_METHOD_SERVICE);
 712
 713             // All other IMEs.
 714             List<InputMethodInfo> inputMethods = immValues.getInputMethodList();
 715             final int inputMethodCount = (inputMethods == null ? 0 : inputMethods.size());
 716             for (int i = 0; i < inputMethodCount; ++i) {
 717                 InputMethodInfo inputMethod = inputMethods.get(i);
 718
 719                 StringBuilder builder = new StringBuilder();
 720                 List<InputMethodSubtype> subtypes = inputMethodManager
 721                         .getEnabledInputMethodSubtypeList(inputMethod, true);
 722                 final int subtypeCount = subtypes.size();
 723                 for (int j = 0; j < subtypeCount; j++) {
 724                     InputMethodSubtype subtype = subtypes.get(j);
 725                     if (builder.length() > 0) {
 726                         builder.append(',');
 727                     }
 728                     CharSequence subtypeLabel = subtype.getDisplayName(context,
 729                             inputMethod.getPackageName(), inputMethod.getServiceInfo()
 730                                     .applicationInfo);
 731                     builder.append(subtypeLabel);
 732                 }
 733                 String summary = builder.toString();
 734
 735                 ServiceInfo serviceInfo = inputMethod.getServiceInfo();
 736                 ComponentName componentName = new ComponentName(serviceInfo.packageName,
 737                         serviceInfo.name);
 738
 739                 indexable = new SearchIndexableRaw(context);
 740                 indexable.key = componentName.flattenToString();
 741                 indexable.title = inputMethod.loadLabel(context.getPackageManager()).toString();
 742                 indexable.summaryOn = summary;
 743                 indexable.summaryOff = summary;
 744                 indexable.screenTitle = screenTitle;
 745                 indexables.add(indexable);
 746             }
 747
 748             // Hard keyboards
 749             InputManager inputManager = (InputManager) context.getSystemService(
 750                     Context.INPUT_SERVICE);
 751             boolean hasHardKeyboards = false;
 752
 753             final int[] devices = InputDevice.getDeviceIds();
 754             for (int i = 0; i < devices.length; i++) {
 755                 InputDevice device = InputDevice.getDevice(devices[i]);
 756                 if (device == null || device.isVirtual() || !device.isFullKeyboard()) {
 757                     continue;
 758                 }
 759
 760                 hasHardKeyboards = true;
 761
 762                 InputDeviceIdentifier identifier = device.getIdentifier();
 763                 String keyboardLayoutDescriptor =
 764                         inputManager.getCurrentKeyboardLayoutForInputDevice(identifier);
 765                 KeyboardLayout keyboardLayout = keyboardLayoutDescriptor != null ?
 766                         inputManager.getKeyboardLayout(keyboardLayoutDescriptor) : null;
 767
 768                 String summary;
 769                 if (keyboardLayout != null) {
 770                     summary = keyboardLayout.toString();
 771                 } else {
 772                     summary = context.getString(R.string.keyboard_layout_default_label);
 773                 }
 774
 775                 indexable = new SearchIndexableRaw(context);
 776                 indexable.key = device.getName();
 777                 indexable.title = device.getName();
 778                 indexable.summaryOn = summary;
 779                 indexable.summaryOff = summary;
 780                 indexable.screenTitle = screenTitle;
 781                 indexables.add(indexable);
 782             }
 783
 784             if (hasHardKeyboards) {
 785                 // Hard keyboard category.
 786                 indexable = new SearchIndexableRaw(context);
 787                 indexable.key = "builtin_keyboard_settings";
 788                 indexable.title = context.getString(
 789                         R.string.builtin_keyboard_settings_title);
 790                 indexable.screenTitle = screenTitle;
 791                 indexables.add(indexable);
 792             }
 793
 794             // Text-to-speech.
 795             TtsEngines ttsEngines = new TtsEngines(context);
 796             if (!ttsEngines.getEngines().isEmpty()) {
 797                 indexable = new SearchIndexableRaw(context);
 798                 indexable.key = "tts_settings";
 799                 indexable.title = context.getString(R.string.tts_settings_title);
 800                 indexable.screenTitle = screenTitle;
 801                 indexable.keywords = context.getString(R.string.keywords_text_to_speech_output);
 802                 indexables.add(indexable);
 803             }
 804
 805             // Pointer settings.
 806             indexable = new SearchIndexableRaw(context);
 807             indexable.key = "pointer_settings_category";
 808             indexable.title = context.getString(R.string.pointer_settings_category);
 809             indexable.screenTitle = screenTitle;
 810             indexables.add(indexable);
 811
 812             indexable = new SearchIndexableRaw(context);
 813             indexable.key = "pointer_speed";
 814             indexable.title = context.getString(R.string.pointer_speed);
 815             indexable.screenTitle = screenTitle;
 816             indexables.add(indexable);
 817
 818             // Game controllers.
 819             if (haveInputDeviceWithVibrator()) {
 820                 indexable = new SearchIndexableRaw(context);
 821                 indexable.key = "vibrate_input_devices";
 822                 indexable.title = context.getString(R.string.vibrate_input_devices);
 823                 indexable.summaryOn = context.getString(R.string.vibrate_input_devices_summary);
 824                 indexable.summaryOff = context.getString(R.string.vibrate_input_devices_summary);
 825                 indexable.screenTitle = screenTitle;
 826                 indexables.add(indexable);
 827             }
 828
 829             return indexables;
 830         }
 831     };
 832 }