/* * Copyright (C) 2009 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.settings; import static android.provider.Settings.Secure.TTS_USE_DEFAULTS; import static android.provider.Settings.Secure.TTS_DEFAULT_RATE; import static android.provider.Settings.Secure.TTS_DEFAULT_LANG; import static android.provider.Settings.Secure.TTS_DEFAULT_COUNTRY; import static android.provider.Settings.Secure.TTS_DEFAULT_VARIANT; import static android.provider.Settings.Secure.TTS_DEFAULT_SYNTH; import static android.provider.Settings.Secure.TTS_ENABLED_PLUGINS; import android.app.AlertDialog; import android.content.ContentResolver; import android.content.DialogInterface; import android.content.Intent; import android.content.pm.ActivityInfo; import android.content.pm.PackageManager; import android.content.pm.ResolveInfo; import android.os.Bundle; import android.preference.ListPreference; import android.preference.Preference; import android.preference.Preference.OnPreferenceClickListener; import android.preference.PreferenceActivity; import android.preference.PreferenceGroup; import android.preference.PreferenceScreen; import android.preference.CheckBoxPreference; import android.provider.Settings; import android.provider.Settings.SettingNotFoundException; import android.speech.tts.TextToSpeech; import android.util.Log; import java.util.ArrayList; import java.util.List; import java.util.Locale; import java.util.StringTokenizer; public class TextToSpeechSettings extends PreferenceActivity implements Preference.OnPreferenceChangeListener, Preference.OnPreferenceClickListener, TextToSpeech.OnInitListener { private static final String TAG = "TextToSpeechSettings"; private static final String SYSTEM_TTS = "com.svox.pico"; private static final String KEY_TTS_PLAY_EXAMPLE = "tts_play_example"; private static final String KEY_TTS_INSTALL_DATA = "tts_install_data"; private static final String KEY_TTS_USE_DEFAULT = "toggle_use_default_tts_settings"; private static final String KEY_TTS_DEFAULT_RATE = "tts_default_rate"; private static final String KEY_TTS_DEFAULT_LANG = "tts_default_lang"; private static final String KEY_TTS_DEFAULT_COUNTRY = "tts_default_country"; private static final String KEY_TTS_DEFAULT_VARIANT = "tts_default_variant"; private static final String KEY_TTS_DEFAULT_SYNTH = "tts_default_synth"; private static final String KEY_PLUGIN_ENABLED_PREFIX = "ENABLED_"; private static final String KEY_PLUGIN_SETTINGS_PREFIX = "SETTINGS_"; // TODO move default Locale values to TextToSpeech.Engine private static final String DEFAULT_LANG_VAL = "eng"; private static final String DEFAULT_COUNTRY_VAL = "USA"; private static final String DEFAULT_VARIANT_VAL = ""; private static final String LOCALE_DELIMITER = "-"; private static final String FALLBACK_TTS_DEFAULT_SYNTH = TextToSpeech.Engine.DEFAULT_SYNTH; private Preference mPlayExample = null; private Preference mInstallData = null; private CheckBoxPreference mUseDefaultPref = null; private ListPreference mDefaultRatePref = null; private ListPreference mDefaultLocPref = null; private ListPreference mDefaultSynthPref = null; private String mDefaultLanguage = null; private String mDefaultCountry = null; private String mDefaultLocVariant = null; private String mDefaultEng = ""; private int mDefaultRate = TextToSpeech.Engine.DEFAULT_RATE; // Array of strings used to demonstrate TTS in the different languages. private String[] mDemoStrings; // Index of the current string to use for the demo. private int mDemoStringIndex = 0; private boolean mEnableDemo = false; private boolean mVoicesMissing = false; private TextToSpeech mTts = null; private boolean mTtsStarted = false; /** * Request code (arbitrary value) for voice data check through * startActivityForResult. */ private static final int VOICE_DATA_INTEGRITY_CHECK = 1977; private static final int GET_SAMPLE_TEXT = 1983; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); addPreferencesFromResource(R.xml.tts_settings); addEngineSpecificSettings(); mDemoStrings = getResources().getStringArray(R.array.tts_demo_strings); setVolumeControlStream(TextToSpeech.Engine.DEFAULT_STREAM); mEnableDemo = false; mTtsStarted = false; Locale currentLocale = Locale.getDefault(); mDefaultLanguage = currentLocale.getISO3Language(); mDefaultCountry = currentLocale.getISO3Country(); mDefaultLocVariant = currentLocale.getVariant(); mTts = new TextToSpeech(this, this); } @Override protected void onStart() { super.onStart(); if (mTtsStarted){ // whenever we return to this screen, we don't know the state of the // system, so we have to recheck that we can play the demo, or it must be disabled. // TODO make the TTS service listen to "changes in the system", i.e. sd card un/mount initClickers(); updateWidgetState(); checkVoiceData(); } } @Override protected void onDestroy() { super.onDestroy(); if (mTts != null) { mTts.shutdown(); } } @Override protected void onPause() { super.onPause(); if ((mDefaultRatePref != null) && (mDefaultRatePref.getDialog() != null)) { mDefaultRatePref.getDialog().dismiss(); } if ((mDefaultLocPref != null) && (mDefaultLocPref.getDialog() != null)) { mDefaultLocPref.getDialog().dismiss(); } if ((mDefaultSynthPref != null) && (mDefaultSynthPref.getDialog() != null)) { mDefaultSynthPref.getDialog().dismiss(); } } private void addEngineSpecificSettings() { PreferenceGroup enginesCategory = (PreferenceGroup) findPreference("tts_engines_section"); Intent intent = new Intent("android.intent.action.START_TTS_ENGINE"); ResolveInfo[] enginesArray = new ResolveInfo[0]; PackageManager pm = getPackageManager(); enginesArray = pm.queryIntentActivities(intent, 0).toArray(enginesArray); for (int i = 0; i < enginesArray.length; i++) { String prefKey = ""; final String pluginPackageName = enginesArray[i].activityInfo.packageName; if (!enginesArray[i].activityInfo.packageName.equals(SYSTEM_TTS)) { CheckBoxPreference chkbxPref = new CheckBoxPreference(this); prefKey = KEY_PLUGIN_ENABLED_PREFIX + pluginPackageName; chkbxPref.setKey(prefKey); chkbxPref.setTitle(enginesArray[i].loadLabel(pm)); enginesCategory.addPreference(chkbxPref); } if (pluginHasSettings(pluginPackageName)) { Preference pref = new Preference(this); prefKey = KEY_PLUGIN_SETTINGS_PREFIX + pluginPackageName; pref.setKey(prefKey); pref.setTitle(enginesArray[i].loadLabel(pm)); CharSequence settingsLabel = getResources().getString( R.string.tts_engine_name_settings, enginesArray[i].loadLabel(pm)); pref.setSummary(settingsLabel); pref.setOnPreferenceClickListener(new OnPreferenceClickListener(){ public boolean onPreferenceClick(Preference preference){ Intent i = new Intent(); i.setClassName(pluginPackageName, pluginPackageName + ".EngineSettings"); startActivity(i); return true; } }); enginesCategory.addPreference(pref); } } } private boolean pluginHasSettings(String pluginPackageName) { PackageManager pm = getPackageManager(); Intent i = new Intent(); i.setClassName(pluginPackageName, pluginPackageName + ".EngineSettings"); if (pm.resolveActivity(i, PackageManager.MATCH_DEFAULT_ONLY) != null){ return true; } return false; } private void initClickers() { mPlayExample = findPreference(KEY_TTS_PLAY_EXAMPLE); mPlayExample.setOnPreferenceClickListener(this); mInstallData = findPreference(KEY_TTS_INSTALL_DATA); mInstallData.setOnPreferenceClickListener(this); } private void initDefaultSettings() { ContentResolver resolver = getContentResolver(); // Find the default TTS values in the settings, initialize and store the // settings if they are not found. // "Use Defaults" int useDefault = 0; mUseDefaultPref = (CheckBoxPreference) findPreference(KEY_TTS_USE_DEFAULT); try { useDefault = Settings.Secure.getInt(resolver, TTS_USE_DEFAULTS); } catch (SettingNotFoundException e) { // "use default" setting not found, initialize it useDefault = TextToSpeech.Engine.USE_DEFAULTS; Settings.Secure.putInt(resolver, TTS_USE_DEFAULTS, useDefault); } mUseDefaultPref.setChecked(useDefault == 1); mUseDefaultPref.setOnPreferenceChangeListener(this); // Default synthesis engine mDefaultSynthPref = (ListPreference) findPreference(KEY_TTS_DEFAULT_SYNTH); loadEngines(); mDefaultSynthPref.setOnPreferenceChangeListener(this); String engine = Settings.Secure.getString(resolver, TTS_DEFAULT_SYNTH); if (engine == null) { // TODO move FALLBACK_TTS_DEFAULT_SYNTH to TextToSpeech engine = FALLBACK_TTS_DEFAULT_SYNTH; Settings.Secure.putString(resolver, TTS_DEFAULT_SYNTH, engine); } mDefaultEng = engine; // Default rate mDefaultRatePref = (ListPreference) findPreference(KEY_TTS_DEFAULT_RATE); try { mDefaultRate = Settings.Secure.getInt(resolver, TTS_DEFAULT_RATE); } catch (SettingNotFoundException e) { // default rate setting not found, initialize it mDefaultRate = TextToSpeech.Engine.DEFAULT_RATE; Settings.Secure.putInt(resolver, TTS_DEFAULT_RATE, mDefaultRate); } mDefaultRatePref.setValue(String.valueOf(mDefaultRate)); mDefaultRatePref.setOnPreferenceChangeListener(this); // Default language / country / variant : these three values map to a single ListPref // representing the matching Locale mDefaultLocPref = (ListPreference) findPreference(KEY_TTS_DEFAULT_LANG); initDefaultLang(); mDefaultLocPref.setOnPreferenceChangeListener(this); } /** * Ask the current default engine to launch the matching CHECK_TTS_DATA activity * to check the required TTS files are properly installed. */ private void checkVoiceData() { PackageManager pm = getPackageManager(); Intent intent = new Intent(); intent.setAction(TextToSpeech.Engine.ACTION_CHECK_TTS_DATA); List<ResolveInfo> resolveInfos = pm.queryIntentActivities(intent, 0); // query only the package that matches that of the default engine for (int i = 0; i < resolveInfos.size(); i++) { ActivityInfo currentActivityInfo = resolveInfos.get(i).activityInfo; if (mDefaultEng.equals(currentActivityInfo.packageName)) { intent.setClassName(mDefaultEng, currentActivityInfo.name); this.startActivityForResult(intent, VOICE_DATA_INTEGRITY_CHECK); } } } /** * Ask the current default engine to launch the matching INSTALL_TTS_DATA activity * so the required TTS files are properly installed. */ private void installVoiceData() { PackageManager pm = getPackageManager(); Intent intent = new Intent(); intent.setAction(TextToSpeech.Engine.ACTION_INSTALL_TTS_DATA); intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); List<ResolveInfo> resolveInfos = pm.queryIntentActivities(intent, 0); // query only the package that matches that of the default engine for (int i = 0; i < resolveInfos.size(); i++) { ActivityInfo currentActivityInfo = resolveInfos.get(i).activityInfo; if (mDefaultEng.equals(currentActivityInfo.packageName)) { intent.setClassName(mDefaultEng, currentActivityInfo.name); this.startActivity(intent); } } } /** * Ask the current default engine to return a string of sample text to be * spoken to the user. */ private void getSampleText() { PackageManager pm = getPackageManager(); Intent intent = new Intent(); // TODO (clchen): Replace Intent string with the actual // Intent defined in the list of platform Intents. intent.setAction("android.speech.tts.engine.GET_SAMPLE_TEXT"); intent.putExtra("language", mDefaultLanguage); intent.putExtra("country", mDefaultCountry); intent.putExtra("variant", mDefaultLocVariant); List<ResolveInfo> resolveInfos = pm.queryIntentActivities(intent, 0); // query only the package that matches that of the default engine for (int i = 0; i < resolveInfos.size(); i++) { ActivityInfo currentActivityInfo = resolveInfos.get(i).activityInfo; if (mDefaultEng.equals(currentActivityInfo.packageName)) { intent.setClassName(mDefaultEng, currentActivityInfo.name); this.startActivityForResult(intent, GET_SAMPLE_TEXT); } } } /** * Called when the TTS engine is initialized. */ public void onInit(int status) { if (status == TextToSpeech.SUCCESS) { mEnableDemo = true; if (mDefaultLanguage == null) { mDefaultLanguage = Locale.getDefault().getISO3Language(); } if (mDefaultCountry == null) { mDefaultCountry = Locale.getDefault().getISO3Country(); } if (mDefaultLocVariant == null) { mDefaultLocVariant = new String(); } mTts.setLanguage(new Locale(mDefaultLanguage, mDefaultCountry, mDefaultLocVariant)); mTts.setSpeechRate((float)(mDefaultRate/100.0f)); initDefaultSettings(); initClickers(); updateWidgetState(); checkVoiceData(); mTtsStarted = true; Log.v(TAG, "TTS engine for settings screen initialized."); } else { Log.v(TAG, "TTS engine for settings screen failed to initialize successfully."); mEnableDemo = false; } updateWidgetState(); } /** * Called when voice data integrity check returns */ protected void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == VOICE_DATA_INTEGRITY_CHECK) { if (data == null){ // The CHECK_TTS_DATA activity for the plugin did not run properly; // disable the preview and install controls and return. mEnableDemo = false; mVoicesMissing = false; updateWidgetState(); return; } ArrayList<String> available = data.getStringArrayListExtra(TextToSpeech.Engine.EXTRA_AVAILABLE_VOICES); ArrayList<String> unavailable = data.getStringArrayListExtra(TextToSpeech.Engine.EXTRA_UNAVAILABLE_VOICES); if ((available == null) || (unavailable == null)){ // The CHECK_TTS_DATA activity for the plugin did not run properly; // disable the preview and install controls and return. mEnableDemo = false; mVoicesMissing = false; updateWidgetState(); return; } if (available.size() > 0){ if (mTts == null) { mTts = new TextToSpeech(this, this); } ListPreference ttsLanguagePref = (ListPreference) findPreference("tts_default_lang"); CharSequence[] entries = new CharSequence[available.size()]; CharSequence[] entryValues = new CharSequence[available.size()]; int selectedLanguageIndex = -1; String selectedLanguagePref = mDefaultLanguage; if (mDefaultCountry.length() > 0) { selectedLanguagePref = selectedLanguagePref + LOCALE_DELIMITER + mDefaultCountry; } if (mDefaultLocVariant.length() > 0) { selectedLanguagePref = selectedLanguagePref + LOCALE_DELIMITER + mDefaultLocVariant; } for (int i = 0; i < available.size(); i++) { String[] langCountryVariant = available.get(i).split("-"); Locale loc = null; if (langCountryVariant.length == 1){ loc = new Locale(langCountryVariant[0]); } else if (langCountryVariant.length == 2){ loc = new Locale(langCountryVariant[0], langCountryVariant[1]); } else if (langCountryVariant.length == 3){ loc = new Locale(langCountryVariant[0], langCountryVariant[1], langCountryVariant[2]); } if (loc != null){ entries[i] = loc.getDisplayName(); entryValues[i] = available.get(i); if (entryValues[i].equals(selectedLanguagePref)) { selectedLanguageIndex = i; } } } ttsLanguagePref.setEntries(entries); ttsLanguagePref.setEntryValues(entryValues); if (selectedLanguageIndex > -1) { ttsLanguagePref.setValueIndex(selectedLanguageIndex); } mEnableDemo = true; // Make sure that the default language can be used. int languageResult = mTts.setLanguage( new Locale(mDefaultLanguage, mDefaultCountry, mDefaultLocVariant)); if (languageResult < TextToSpeech.LANG_AVAILABLE){ Locale currentLocale = Locale.getDefault(); mDefaultLanguage = currentLocale.getISO3Language(); mDefaultCountry = currentLocale.getISO3Country(); mDefaultLocVariant = currentLocale.getVariant(); languageResult = mTts.setLanguage( new Locale(mDefaultLanguage, mDefaultCountry, mDefaultLocVariant)); // If the default Locale isn't supported, just choose the first available // language so that there is at least something. if (languageResult < TextToSpeech.LANG_AVAILABLE){ parseLocaleInfo(ttsLanguagePref.getEntryValues()[0].toString()); mTts.setLanguage( new Locale(mDefaultLanguage, mDefaultCountry, mDefaultLocVariant)); } ContentResolver resolver = getContentResolver(); Settings.Secure.putString(resolver, TTS_DEFAULT_LANG, mDefaultLanguage); Settings.Secure.putString(resolver, TTS_DEFAULT_COUNTRY, mDefaultCountry); Settings.Secure.putString(resolver, TTS_DEFAULT_VARIANT, mDefaultLocVariant); } } else { mEnableDemo = false; } if (unavailable.size() > 0){ mVoicesMissing = true; } else { mVoicesMissing = false; } updateWidgetState(); } else if (requestCode == GET_SAMPLE_TEXT) { if (resultCode == TextToSpeech.LANG_AVAILABLE) { String sample = getString(R.string.tts_demo); if ((data != null) && (data.getStringExtra("sampleText") != null)) { sample = data.getStringExtra("sampleText"); } if (mTts != null) { mTts.speak(sample, TextToSpeech.QUEUE_FLUSH, null); } } else { // TODO: Display an error here to the user. Log.e(TAG, "Did not have a sample string for the requested language"); } } } public boolean onPreferenceChange(Preference preference, Object objValue) { if (KEY_TTS_USE_DEFAULT.equals(preference.getKey())) { // "Use Defaults" int value = (Boolean)objValue ? 1 : 0; Settings.Secure.putInt(getContentResolver(), TTS_USE_DEFAULTS, value); Log.i(TAG, "TTS use default settings is "+objValue.toString()); } else if (KEY_TTS_DEFAULT_RATE.equals(preference.getKey())) { // Default rate mDefaultRate = Integer.parseInt((String) objValue); try { Settings.Secure.putInt(getContentResolver(), TTS_DEFAULT_RATE, mDefaultRate); if (mTts != null) { mTts.setSpeechRate((float)(mDefaultRate/100.0f)); } Log.i(TAG, "TTS default rate is " + mDefaultRate); } catch (NumberFormatException e) { Log.e(TAG, "could not persist default TTS rate setting", e); } } else if (KEY_TTS_DEFAULT_LANG.equals(preference.getKey())) { // Default locale ContentResolver resolver = getContentResolver(); parseLocaleInfo((String) objValue); Settings.Secure.putString(resolver, TTS_DEFAULT_LANG, mDefaultLanguage); Settings.Secure.putString(resolver, TTS_DEFAULT_COUNTRY, mDefaultCountry); Settings.Secure.putString(resolver, TTS_DEFAULT_VARIANT, mDefaultLocVariant); Log.v(TAG, "TTS default lang/country/variant set to " + mDefaultLanguage + "/" + mDefaultCountry + "/" + mDefaultLocVariant); if (mTts != null) { mTts.setLanguage(new Locale(mDefaultLanguage, mDefaultCountry, mDefaultLocVariant)); } int newIndex = mDefaultLocPref.findIndexOfValue((String)objValue); Log.v("Settings", " selected is " + newIndex); mDemoStringIndex = newIndex > -1 ? newIndex : 0; } else if (KEY_TTS_DEFAULT_SYNTH.equals(preference.getKey())) { mDefaultEng = objValue.toString(); Settings.Secure.putString(getContentResolver(), TTS_DEFAULT_SYNTH, mDefaultEng); if (mTts != null) { mTts.setEngineByPackageName(mDefaultEng); mEnableDemo = false; mVoicesMissing = false; updateWidgetState(); checkVoiceData(); } Log.v("Settings", "The default synth is: " + objValue.toString()); } return true; } /** * Called when mPlayExample or mInstallData is clicked */ public boolean onPreferenceClick(Preference preference) { if (preference == mPlayExample) { // Get the sample text from the TTS engine; onActivityResult will do // the actual speaking getSampleText(); return true; } if (preference == mInstallData) { installVoiceData(); // quit this activity so it needs to be restarted after installation of the voice data finish(); return true; } return false; } @Override public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) { if (Utils.isMonkeyRunning()) { return false; } if (preference instanceof CheckBoxPreference) { final CheckBoxPreference chkPref = (CheckBoxPreference) preference; if (!chkPref.getKey().equals(KEY_TTS_USE_DEFAULT)){ if (chkPref.isChecked()) { chkPref.setChecked(false); AlertDialog d = (new AlertDialog.Builder(this)) .setTitle(android.R.string.dialog_alert_title) .setIcon(android.R.drawable.ic_dialog_alert) .setMessage(getString(R.string.tts_engine_security_warning, chkPref.getTitle())) .setCancelable(true) .setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int which) { chkPref.setChecked(true); loadEngines(); } }) .setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int which) { } }) .create(); d.show(); } else { loadEngines(); } return true; } } return false; } private void updateWidgetState() { mPlayExample.setEnabled(mEnableDemo); mUseDefaultPref.setEnabled(mEnableDemo); mDefaultRatePref.setEnabled(mEnableDemo); mDefaultLocPref.setEnabled(mEnableDemo); mInstallData.setEnabled(mVoicesMissing); } private void parseLocaleInfo(String locale) { StringTokenizer tokenizer = new StringTokenizer(locale, LOCALE_DELIMITER); mDefaultLanguage = ""; mDefaultCountry = ""; mDefaultLocVariant = ""; if (tokenizer.hasMoreTokens()) { mDefaultLanguage = tokenizer.nextToken().trim(); } if (tokenizer.hasMoreTokens()) { mDefaultCountry = tokenizer.nextToken().trim(); } if (tokenizer.hasMoreTokens()) { mDefaultLocVariant = tokenizer.nextToken().trim(); } } /** * Initialize the default language in the UI and in the preferences. * After this method has been invoked, the default language is a supported Locale. */ private void initDefaultLang() { // if there isn't already a default language preference if (!hasLangPref()) { // if the current Locale is supported if (isCurrentLocSupported()) { // then use the current Locale as the default language useCurrentLocAsDefault(); } else { // otherwise use a default supported Locale as the default language useSupportedLocAsDefault(); } } // Update the language preference list with the default language and the matching // demo string (at this stage there is a default language pref) ContentResolver resolver = getContentResolver(); mDefaultLanguage = Settings.Secure.getString(resolver, TTS_DEFAULT_LANG); mDefaultCountry = Settings.Secure.getString(resolver, TTS_DEFAULT_COUNTRY); mDefaultLocVariant = Settings.Secure.getString(resolver, TTS_DEFAULT_VARIANT); // update the demo string mDemoStringIndex = mDefaultLocPref.findIndexOfValue(mDefaultLanguage + LOCALE_DELIMITER + mDefaultCountry); if (mDemoStringIndex > -1){ mDefaultLocPref.setValueIndex(mDemoStringIndex); } } /** * (helper function for initDefaultLang() ) * Returns whether there is a default language in the TTS settings. */ private boolean hasLangPref() { ContentResolver resolver = getContentResolver(); String language = Settings.Secure.getString(resolver, TTS_DEFAULT_LANG); if ((language == null) || (language.length() < 1)) { return false; } String country = Settings.Secure.getString(resolver, TTS_DEFAULT_COUNTRY); if (country == null) { return false; } String variant = Settings.Secure.getString(resolver, TTS_DEFAULT_VARIANT); if (variant == null) { return false; } return true; } /** * (helper function for initDefaultLang() ) * Returns whether the current Locale is supported by this Settings screen */ private boolean isCurrentLocSupported() { String currentLocID = Locale.getDefault().getISO3Language() + LOCALE_DELIMITER + Locale.getDefault().getISO3Country(); return (mDefaultLocPref.findIndexOfValue(currentLocID) > -1); } /** * (helper function for initDefaultLang() ) * Sets the default language in TTS settings to be the current Locale. * This should only be used after checking that the current Locale is supported. */ private void useCurrentLocAsDefault() { Locale currentLocale = Locale.getDefault(); ContentResolver resolver = getContentResolver(); Settings.Secure.putString(resolver, TTS_DEFAULT_LANG, currentLocale.getISO3Language()); Settings.Secure.putString(resolver, TTS_DEFAULT_COUNTRY, currentLocale.getISO3Country()); Settings.Secure.putString(resolver, TTS_DEFAULT_VARIANT, currentLocale.getVariant()); } /** * (helper function for initDefaultLang() ) * Sets the default language in TTS settings to be one known to be supported */ private void useSupportedLocAsDefault() { ContentResolver resolver = getContentResolver(); Settings.Secure.putString(resolver, TTS_DEFAULT_LANG, DEFAULT_LANG_VAL); Settings.Secure.putString(resolver, TTS_DEFAULT_COUNTRY, DEFAULT_COUNTRY_VAL); Settings.Secure.putString(resolver, TTS_DEFAULT_VARIANT, DEFAULT_VARIANT_VAL); } private void loadEngines() { mDefaultSynthPref = (ListPreference) findPreference(KEY_TTS_DEFAULT_SYNTH); // TODO (clchen): Try to see if it is possible to be more efficient here // and not search for plugins again. Intent intent = new Intent("android.intent.action.START_TTS_ENGINE"); ResolveInfo[] enginesArray = new ResolveInfo[0]; PackageManager pm = getPackageManager(); enginesArray = pm.queryIntentActivities(intent, 0).toArray(enginesArray); ArrayList<CharSequence> entries = new ArrayList<CharSequence>(); ArrayList<CharSequence> values = new ArrayList<CharSequence>(); String enabledEngines = ""; for (int i = 0; i < enginesArray.length; i++) { String pluginPackageName = enginesArray[i].activityInfo.packageName; if (pluginPackageName.equals(SYSTEM_TTS)) { entries.add(enginesArray[i].loadLabel(pm)); values.add(pluginPackageName); } else { CheckBoxPreference pref = (CheckBoxPreference) findPreference( KEY_PLUGIN_ENABLED_PREFIX + pluginPackageName); if ((pref != null) && pref.isChecked()){ entries.add(enginesArray[i].loadLabel(pm)); values.add(pluginPackageName); enabledEngines = enabledEngines + pluginPackageName + " "; } } } ContentResolver resolver = getContentResolver(); Settings.Secure.putString(resolver, TTS_ENABLED_PLUGINS, enabledEngines); CharSequence entriesArray[] = new CharSequence[entries.size()]; CharSequence valuesArray[] = new CharSequence[values.size()]; mDefaultSynthPref.setEntries(entries.toArray(entriesArray)); mDefaultSynthPref.setEntryValues(values.toArray(valuesArray)); // Set the selected engine based on the saved preference String selectedEngine = Settings.Secure.getString(getContentResolver(), TTS_DEFAULT_SYNTH); int selectedEngineIndex = mDefaultSynthPref.findIndexOfValue(selectedEngine); if (selectedEngineIndex == -1){ selectedEngineIndex = mDefaultSynthPref.findIndexOfValue(SYSTEM_TTS); } mDefaultSynthPref.setValueIndex(selectedEngineIndex); } }