/* * 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_DEFAULT_COUNTRY; import static android.provider.Settings.Secure.TTS_DEFAULT_LANG; import static android.provider.Settings.Secure.TTS_DEFAULT_RATE; import static android.provider.Settings.Secure.TTS_DEFAULT_SYNTH; import static android.provider.Settings.Secure.TTS_DEFAULT_VARIANT; import static android.provider.Settings.Secure.TTS_USE_DEFAULTS; import android.app.AlertDialog; import android.content.ActivityNotFoundException; import android.content.ContentResolver; import android.content.DialogInterface; import android.content.Intent; import android.os.Bundle; import android.preference.ListPreference; import android.preference.Preference; import android.preference.Preference.OnPreferenceClickListener; import android.provider.Settings; import android.provider.Settings.SettingNotFoundException; import android.speech.tts.TextToSpeech; import android.speech.tts.TextToSpeech.EngineInfo; import android.speech.tts.TtsEngines; import android.text.TextUtils; import android.util.Log; import java.util.ArrayList; import java.util.List; import java.util.Locale; import java.util.StringTokenizer; public class TextToSpeechSettings extends SettingsPreferenceFragment implements Preference.OnPreferenceChangeListener, Preference.OnPreferenceClickListener, TextToSpeech.OnInitListener { private static final String TAG = "TextToSpeechSettings"; 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_TTS_ENGINE_SETTINGS = "tts_engine_settings"; 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 Preference mPlayExample = null; private ListPreference mDefaultRatePref = null; private ListPreference mDefaultLocPref = null; private ListPreference mDefaultSynthPref = null; private Preference mInstallData = null; private Preference mEngineSettings = null; private String mDefaultLanguage = null; private String mDefaultCountry = null; private String mDefaultLocVariant = null; private int mDefaultRate = TextToSpeech.Engine.DEFAULT_RATE; // 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 TtsEngines mEnginesHelper = 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 public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); addPreferencesFromResource(R.xml.tts_settings); getActivity().setVolumeControlStream(TextToSpeech.Engine.DEFAULT_STREAM); mEnableDemo = false; mTtsStarted = false; Locale currentLocale = Locale.getDefault(); mDefaultLanguage = currentLocale.getISO3Language(); mDefaultCountry = currentLocale.getISO3Country(); mDefaultLocVariant = currentLocale.getVariant(); mPlayExample = findPreference(KEY_TTS_PLAY_EXAMPLE); mPlayExample.setOnPreferenceClickListener(this); mInstallData = findPreference(KEY_TTS_INSTALL_DATA); mInstallData.setOnPreferenceClickListener(this); mDefaultSynthPref = (ListPreference) findPreference(KEY_TTS_DEFAULT_SYNTH); mDefaultRatePref = (ListPreference) findPreference(KEY_TTS_DEFAULT_RATE); mDefaultLocPref = (ListPreference) findPreference(KEY_TTS_DEFAULT_LANG); mEngineSettings = findPreference(KEY_TTS_ENGINE_SETTINGS); mEngineSettings.setEnabled(false); mTts = new TextToSpeech(getActivity().getApplicationContext(), this); mEnginesHelper = new TtsEngines(getActivity().getApplicationContext()); initDefaultSettings(); initEngineSpecificSettings(); } @Override public 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 updateWidgetState(); checkVoiceData(); } } @Override public void onDestroy() { super.onDestroy(); if (mTts != null) { mTts.shutdown(); } } @Override public 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 initEngineSpecificSettings() { final String engineName = mEnginesHelper.getDefaultEngine(); final EngineInfo engine = mEnginesHelper.getEngineInfo(engineName); mEngineSettings.setTitle(getResources().getString(R.string.tts_engine_settings_title, engine.label)); final Intent settingsIntent = mEnginesHelper.getSettingsIntent(engineName); if (settingsIntent != null) { mEngineSettings.setOnPreferenceClickListener(new OnPreferenceClickListener() { public boolean onPreferenceClick(Preference preference) { startActivity(settingsIntent); return true; } }); mEngineSettings.setEnabled(true); } else { mEngineSettings.setEnabled(false); } } private void initDefaultSettings() { ContentResolver resolver = getContentResolver(); // Find the default TTS values in the settings, initialize and store the // settings if they are not found. // Default synthesis engine loadEngines(); mDefaultSynthPref.setOnPreferenceChangeListener(this); // 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 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() { String defaultEngine = mTts.getDefaultEngine(); if (TextUtils.isEmpty(defaultEngine)) return; Intent intent = new Intent(TextToSpeech.Engine.ACTION_CHECK_TTS_DATA); intent.setPackage(defaultEngine); try { Log.v(TAG, "Checking voice data: " + intent.toUri(0)); startActivityForResult(intent, VOICE_DATA_INTEGRITY_CHECK); } catch (ActivityNotFoundException ex) { Log.e(TAG, "Failed to check TTS data, no acitivty found for " + intent + ")"); } } /** * Ask the current default engine to launch the matching INSTALL_TTS_DATA activity * so the required TTS files are properly installed. */ private void installVoiceData() { String defaultEngine = mTts.getDefaultEngine(); if (TextUtils.isEmpty(defaultEngine)) return; Intent intent = new Intent(TextToSpeech.Engine.ACTION_INSTALL_TTS_DATA); intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); intent.setPackage(defaultEngine); try { Log.v(TAG, "Installing voice data: " + intent.toUri(0)); startActivity(intent); } catch (ActivityNotFoundException ex) { Log.e(TAG, "Failed to install TTS data, no acitivty found for " + intent + ")"); } } /** * Ask the current default engine to return a string of sample text to be * spoken to the user. */ private void getSampleText() { String defaultEngine = mTts.getDefaultEngine(); if (TextUtils.isEmpty(defaultEngine)) return; Intent intent = new Intent(TextToSpeech.Engine.ACTION_GET_SAMPLE_TEXT); intent.putExtra("language", mDefaultLanguage); intent.putExtra("country", mDefaultCountry); intent.putExtra("variant", mDefaultLocVariant); intent.setPackage(defaultEngine); try { Log.v(TAG, "Getting sample text: " + intent.toUri(0)); startActivityForResult(intent, GET_SAMPLE_TEXT); } catch (ActivityNotFoundException ex) { Log.e(TAG, "Failed to get sample text, no acitivty found for " + intent + ")"); } } /** * 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)); 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 */ @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == VOICE_DATA_INTEGRITY_CHECK) { onVoiceDataIntegrityCheckDone(data); } else if (requestCode == GET_SAMPLE_TEXT) { onSampleTextReceived(resultCode, data); } } private void onVoiceDataIntegrityCheckDone(Intent data) { if (data == null){ Log.e(TAG, "TTS data check failed 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; } Log.v(TAG, "TTS data check completed, data = " + data.toUri(0)); ArrayList available = data.getStringArrayListExtra(TextToSpeech.Engine.EXTRA_AVAILABLE_VOICES); ArrayList unavailable = data.getStringArrayListExtra(TextToSpeech.Engine.EXTRA_UNAVAILABLE_VOICES); if (available == null || unavailable == null){ Log.e(TAG, "TTS data check failed (available == == 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(getActivity(), this); } updateDefaultLocPref(available); 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(mDefaultLocPref.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(); } private void updateDefaultLocPref(ArrayList availableLangs) { CharSequence[] entries = new CharSequence[availableLangs.size()]; CharSequence[] entryValues = new CharSequence[availableLangs.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 < availableLangs.size(); i++) { String[] langCountryVariant = availableLangs.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] = availableLangs.get(i); if (entryValues[i].equals(selectedLanguagePref)) { selectedLanguageIndex = i; } } } mDefaultLocPref.setEntries(entries); mDefaultLocPref.setEntryValues(entryValues); if (selectedLanguageIndex > -1) { mDefaultLocPref.setValueIndex(selectedLanguageIndex); } } private void onSampleTextReceived(int resultCode, Intent data) { if (resultCode == TextToSpeech.LANG_AVAILABLE) { String sample = getActivity().getString(R.string.tts_demo); if (data != null && data.getStringExtra("sampleText") != null) { sample = data.getStringExtra("sampleText"); } Log.v(TAG, "Got sample text: " + sample); 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 changed, now " + value); } 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(mDefaultRate / 100.0f); } Log.v(TAG, "TTS default rate changed, now " + 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(TAG, " selected is " + newIndex); mDemoStringIndex = newIndex > -1 ? newIndex : 0; } else if (KEY_TTS_DEFAULT_SYNTH.equals(preference.getKey())) { final String name = objValue.toString(); final EngineInfo info = mEnginesHelper.getEngineInfo(name); if (info.system) { // For system engines, do away with the alert dialog. updateDefaultEngine(name); initEngineSpecificSettings(); } else { // For all other engines, display a warning message before // turning them on. displayDataAlert(preference, name); } // We'll deal with updating the UI ourselves. return false; } 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; } else if (preference == mInstallData) { installVoiceData(); // quit this activity so it needs to be restarted after installation of the voice data finish(); return true; } return false; } private void updateWidgetState() { mPlayExample.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 (locale != null) { String[] components = locale.split(LOCALE_DELIMITER); if (components.length > 0) { mDefaultLanguage = components[0]; } if (components.length > 1) { mDefaultCountry = components[1]; } if (components.length > 2) { mDefaultLocVariant = components[2]; } } } /** * 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() { List engines = mEnginesHelper.getEngines(); CharSequence entries[] = new CharSequence[engines.size()]; CharSequence values[] = new CharSequence[engines.size()]; final int count = engines.size(); for (int i = 0; i < count; ++i) { final EngineInfo engine = engines.get(i); entries[i] = engine.label; values[i] = engine.name; } mDefaultSynthPref.setEntries(entries); mDefaultSynthPref.setEntryValues(values); // 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( mEnginesHelper.getHighestRankedEngineName()); } if (selectedEngineIndex >= 0) { mDefaultSynthPref.setValueIndex(selectedEngineIndex); } } private void displayDataAlert(Preference pref, final String key) { Log.v(TAG, "Displaying data alert for :" + key); AlertDialog.Builder builder = new AlertDialog.Builder(getActivity()); builder.setTitle(android.R.string.dialog_alert_title); builder.setIcon(android.R.drawable.ic_dialog_alert); builder.setMessage(getActivity().getString( R.string.tts_engine_security_warning, pref.getTitle())); builder.setCancelable(true); builder.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int which) { updateDefaultEngine(key); loadEngines(); initEngineSpecificSettings(); } }); builder.setNegativeButton(android.R.string.cancel, null); AlertDialog dialog = builder.create(); dialog.show(); } private void updateDefaultEngine(String engine) { Log.v(TAG, "Updating default synth to : " + engine); if (mTts != null) { try { mTts.shutdown(); mTts = null; } catch (Exception e) { Log.e(TAG, "Error shutting down TTS engine" + e); } } mTts = new TextToSpeech(getActivity().getApplicationContext(), this, engine); mEnableDemo = false; mVoicesMissing = false; // Persist this value to settings and update the UI before we check // voice data because if the TTS class connected without any exception, "engine" // will be the default engine irrespective of whether the voice check // passes or not. Settings.Secure.putString(getContentResolver(), TTS_DEFAULT_SYNTH, engine); mDefaultSynthPref.setValue(engine); updateWidgetState(); checkVoiceData(); Log.v(TAG, "The default synth is now: " + engine); } }