diff options
author | Narayan Kamath <narayan@google.com> | 2011-08-18 17:55:41 +0100 |
---|---|---|
committer | Narayan Kamath <narayan@google.com> | 2011-08-23 18:10:01 +0100 |
commit | 0cfbb0f10aca100795169891c9a152d56390a3cf (patch) | |
tree | 89144b4be486a697e1622c40f3c9b8efc318285c /src/com/android/settings/tts | |
parent | 5b5c906b39a03260bab4ce253b90fe8b2752483e (diff) | |
download | packages_apps_Settings-0cfbb0f10aca100795169891c9a152d56390a3cf.zip packages_apps_Settings-0cfbb0f10aca100795169891c9a152d56390a3cf.tar.gz packages_apps_Settings-0cfbb0f10aca100795169891c9a152d56390a3cf.tar.bz2 |
Implement the new TTS settings UI.
bug:5149036
Change-Id: I81a9786d20be3e9bf87550d6a0cc04191409600c
Diffstat (limited to 'src/com/android/settings/tts')
3 files changed, 878 insertions, 0 deletions
diff --git a/src/com/android/settings/tts/TextToSpeechSettings.java b/src/com/android/settings/tts/TextToSpeechSettings.java new file mode 100644 index 0000000..210cb9c --- /dev/null +++ b/src/com/android/settings/tts/TextToSpeechSettings.java @@ -0,0 +1,481 @@ +/* + * Copyright (C) 2011 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.tts; + +import static android.provider.Settings.Secure.TTS_DEFAULT_RATE; +import static android.provider.Settings.Secure.TTS_DEFAULT_SYNTH; + +import com.android.settings.R; +import com.android.settings.SettingsPreferenceFragment; +import com.android.settings.tts.TtsEnginePreference.RadioButtonGroupState; + +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.PreferenceActivity; +import android.preference.PreferenceCategory; +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 android.widget.Checkable; + +import java.util.List; +import java.util.Locale; + +public class TextToSpeechSettings extends SettingsPreferenceFragment implements + Preference.OnPreferenceChangeListener, Preference.OnPreferenceClickListener, + RadioButtonGroupState { + + private static final String TAG = "TextToSpeechSettings"; + private static final boolean DBG = false; + + /** Preference key for the "play TTS example" preference. */ + private static final String KEY_PLAY_EXAMPLE = "tts_play_example"; + + /** Preference key for the TTS rate selection dialog. */ + private static final String KEY_DEFAULT_RATE = "tts_default_rate"; + + /** + * Preference key for the engine selection preference. + */ + private static final String KEY_ENGINE_PREFERENCE_SECTION = + "tts_engine_preference_section"; + + /** + * These look like birth years, but they aren't mine. I'm much younger than this. + */ + private static final int GET_SAMPLE_TEXT = 1983; + private static final int VOICE_DATA_INTEGRITY_CHECK = 1977; + + private PreferenceCategory mEnginePreferenceCategory; + private ListPreference mDefaultRatePref; + private Preference mPlayExample; + + private int mDefaultRate = TextToSpeech.Engine.DEFAULT_RATE; + + /** + * The currently selected engine. + */ + private String mCurrentEngine; + + /** + * The engine checkbox that is currently checked. Saves us a bit of effort + * in deducing the right one from the currently selected engine. + */ + private Checkable mCurrentChecked; + + /** + * The previously selected TTS engine. Useful for rollbacks if the users + * choice is not loaded or fails a voice integrity check. + */ + private String mPreviousEngine; + + private TextToSpeech mTts = null; + private TtsEngines mEnginesHelper = null; + + /** + * The initialization listener used when we are initalizing the settings + * screen for the first time (as opposed to when a user changes his choice + * of engine). + */ + private final TextToSpeech.OnInitListener mInitListener = new TextToSpeech.OnInitListener() { + @Override + public void onInit(int status) { + onInitEngine(status); + } + }; + + /** + * The initialization listener used when the user changes his choice of + * engine (as opposed to when then screen is being initialized for the first + * time). + */ + private final TextToSpeech.OnInitListener mUpdateListener = new TextToSpeech.OnInitListener() { + @Override + public void onInit(int status) { + onUpdateEngine(status); + } + }; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + addPreferencesFromResource(R.xml.tts_settings); + + getActivity().setVolumeControlStream(TextToSpeech.Engine.DEFAULT_STREAM); + + mPlayExample = findPreference(KEY_PLAY_EXAMPLE); + mPlayExample.setOnPreferenceClickListener(this); + + mEnginePreferenceCategory = (PreferenceCategory) findPreference( + KEY_ENGINE_PREFERENCE_SECTION); + mDefaultRatePref = (ListPreference) findPreference(KEY_DEFAULT_RATE); + + mTts = new TextToSpeech(getActivity().getApplicationContext(), mInitListener); + mEnginesHelper = new TtsEngines(getActivity().getApplicationContext()); + + initSettings(); + } + + @Override + public void onDestroy() { + super.onDestroy(); + if (mTts != null) { + mTts.shutdown(); + mTts = null; + } + } + + @Override + public void onPause() { + super.onPause(); + if ((mDefaultRatePref != null) && (mDefaultRatePref.getDialog() != null)) { + mDefaultRatePref.getDialog().dismiss(); + } + } + + private void initSettings() { + final ContentResolver resolver = getContentResolver(); + + // Set up the 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; + } + mDefaultRatePref.setValue(String.valueOf(mDefaultRate)); + mDefaultRatePref.setOnPreferenceChangeListener(this); + + mCurrentEngine = mTts.getCurrentEngine(); + + PreferenceActivity preferenceActivity = null; + if (getActivity() instanceof PreferenceActivity) { + preferenceActivity = (PreferenceActivity) getActivity(); + } else { + throw new IllegalStateException("TextToSpeechSettings used outside a " + + "PreferenceActivity"); + } + + mEnginePreferenceCategory.removeAll(); + + List<EngineInfo> engines = mEnginesHelper.getEngines(); + for (EngineInfo engine : engines) { + TtsEnginePreference enginePref = new TtsEnginePreference(getActivity(), engine, + this, preferenceActivity); + mEnginePreferenceCategory.addPreference(enginePref); + } + + checkVoiceData(mCurrentEngine); + } + + /** + * Ask the current default engine to return a string of sample text to be + * spoken to the user. + */ + private void getSampleText() { + String currentEngine = mTts.getCurrentEngine(); + Locale currentLocale = mTts.getLanguage(); + + if (TextUtils.isEmpty(currentEngine)) currentEngine = mTts.getDefaultEngine(); + + // TODO: This is currently a hidden private API. The intent extras + // and the intent action should be made public if we intend to make this + // a public API. We fall back to using a canned set of strings if this + // doesn't work. + Intent intent = new Intent(TextToSpeech.Engine.ACTION_GET_SAMPLE_TEXT); + + if (currentLocale != null) { + intent.putExtra("language", currentLocale.getLanguage()); + intent.putExtra("country", currentLocale.getCountry()); + intent.putExtra("variant", currentLocale.getVariant()); + } + intent.setPackage(currentEngine); + + try { + if (DBG) Log.d(TAG, "Getting sample text: " + intent.toUri(0)); + startActivityForResult(intent, GET_SAMPLE_TEXT); + } catch (ActivityNotFoundException ex) { + Log.e(TAG, "Failed to get sample text, no activity found for " + intent + ")"); + onSampleTextReceived(TextToSpeech.ERROR, null); + } + } + + /** + * Called when the TTS engine is initialized. + */ + public void onInitEngine(int status) { + if (status == TextToSpeech.SUCCESS) { + updateWidgetState(true); + if (DBG) Log.d(TAG, "TTS engine for settings screen initialized."); + } else { + if (DBG) Log.d(TAG, "TTS engine for settings screen failed to initialize successfully."); + updateWidgetState(false); + } + } + + /** + * Called when voice data integrity check returns + */ + @Override + public void onActivityResult(int requestCode, int resultCode, Intent data) { + if (requestCode == GET_SAMPLE_TEXT) { + onSampleTextReceived(resultCode, data); + } else if (requestCode == VOICE_DATA_INTEGRITY_CHECK) { + onVoiceDataIntegrityCheckDone(data); + } + } + + private String getDefaultSampleString() { + if (mTts != null && mTts.getLanguage() != null) { + final String currentLang = mTts.getLanguage().getISO3Language(); + String[] strings = getActivity().getResources().getStringArray( + R.array.tts_demo_strings); + String[] langs = getActivity().getResources().getStringArray( + R.array.tts_demo_string_langs); + + for (int i = 0; i < strings.length; ++i) { + if (langs[i].equals(currentLang)) { + return strings[i]; + } + } + } + return null; + } + + private void onSampleTextReceived(int resultCode, Intent data) { + String sample = getDefaultSampleString(); + + if (resultCode == TextToSpeech.LANG_AVAILABLE && data != null) { + if (data != null && data.getStringExtra("sampleText") != null) { + sample = data.getStringExtra("sampleText"); + } + if (DBG) Log.d(TAG, "Got sample text: " + sample); + } else { + if (DBG) Log.d(TAG, "Using default sample text :" + sample); + } + + if (sample != null && mTts != null) { + // The engine is guaranteed to have been initialized here + // because this preference is not enabled otherwise. + 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_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); + } + if (DBG) Log.d(TAG, "TTS default rate changed, now " + mDefaultRate); + } catch (NumberFormatException e) { + Log.e(TAG, "could not persist default TTS rate setting", e); + } + } + + return true; + } + + /** + * Called when mPlayExample 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; + } + + return false; + } + + private void updateWidgetState(boolean enable) { + mPlayExample.setEnabled(enable); + mDefaultRatePref.setEnabled(enable); + } + + private void displayDataAlert(final String key) { + Log.i(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, mEnginesHelper.getEngineInfo(key).label)); + builder.setCancelable(true); + builder.setPositiveButton(android.R.string.ok, + new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int which) { + updateDefaultEngine(key); + } + }); + builder.setNegativeButton(android.R.string.cancel, null); + + AlertDialog dialog = builder.create(); + dialog.show(); + } + + private void updateDefaultEngine(String engine) { + if (DBG) Log.d(TAG, "Updating default synth to : " + engine); + + // Disable the "play sample text" preference and the speech + // rate preference while the engine is being swapped. + updateWidgetState(false); + + // Keep track of the previous engine that was being used. So that + // we can reuse the previous engine. + // + // Note that if TextToSpeech#getCurrentEngine is not null, it means at + // the very least that we successfully bound to the engine service. + mPreviousEngine = mTts.getCurrentEngine(); + + // Step 1: Shut down the existing TTS engine. + if (mTts != null) { + try { + mTts.shutdown(); + mTts = null; + } catch (Exception e) { + Log.e(TAG, "Error shutting down TTS engine" + e); + } + } + + // Step 2: Connect to the new TTS engine. + // Step 3 is continued on #onUpdateEngine (below) which is called when + // the app binds successfully to the engine. + if (DBG) Log.d(TAG, "Updating engine : Attempting to connect to engine: " + engine); + mTts = new TextToSpeech(getActivity().getApplicationContext(), mUpdateListener, engine); + } + + /* + * Step 3: We have now bound to the TTS engine the user requested. We will + * attempt to check voice data for the engine if we successfully bound to it, + * or revert to the previous engine if we didn't. + */ + public void onUpdateEngine(int status) { + if (status == TextToSpeech.SUCCESS) { + if (DBG) { + Log.d(TAG, "Updating engine: Successfully bound to the engine: " + + mTts.getCurrentEngine()); + } + checkVoiceData(mTts.getCurrentEngine()); + } else { + if (DBG) Log.d(TAG, "Updating engine: Failed to bind to engine, reverting."); + if (mPreviousEngine != null) { + // This is guaranteed to at least bind, since mPreviousEngine would be + // null if the previous bind to this engine failed. + mTts = new TextToSpeech(getActivity().getApplicationContext(), mInitListener, + mPreviousEngine); + } + mPreviousEngine = null; + } + } + + /* + * Step 4: Check whether the voice data for the engine is ok. + */ + private void checkVoiceData(String engine) { + Intent intent = new Intent(TextToSpeech.Engine.ACTION_CHECK_TTS_DATA); + intent.setPackage(engine); + try { + if (DBG) Log.d(TAG, "Updating engine: Checking voice data: " + intent.toUri(0)); + startActivityForResult(intent, VOICE_DATA_INTEGRITY_CHECK); + } catch (ActivityNotFoundException ex) { + Log.e(TAG, "Failed to check TTS data, no activity found for " + intent + ")"); + } + } + + /* + * Step 5: The voice data check is complete. + */ + private void onVoiceDataIntegrityCheckDone(Intent data) { + final String engine = mTts.getCurrentEngine(); + + if (engine == null) { + Log.e(TAG, "Voice data check complete, but no engine bound"); + return; + } + + if (data == null){ + Log.e(TAG, "Engine failed voice data integrity check (null return)" + + mTts.getCurrentEngine()); + return; + } + + Settings.Secure.putString(getContentResolver(), TTS_DEFAULT_SYNTH, engine); + + final int engineCount = mEnginePreferenceCategory.getPreferenceCount(); + for (int i = 0; i < engineCount; ++i) { + final Preference p = mEnginePreferenceCategory.getPreference(i); + if (p instanceof TtsEnginePreference) { + TtsEnginePreference enginePref = (TtsEnginePreference) p; + if (enginePref.getKey().equals(engine)) { + enginePref.setVoiceDataDetails(data); + break; + } + } + } + + updateWidgetState(true); + } + + private boolean shouldDisplayDataAlert(String engine) { + final EngineInfo info = mEnginesHelper.getEngineInfo(engine); + return !info.system; + } + + @Override + public Checkable getCurrentChecked() { + return mCurrentChecked; + } + + @Override + public String getCurrentKey() { + return mCurrentEngine; + } + + @Override + public void setCurrentChecked(Checkable current) { + mCurrentChecked = current; + } + + @Override + public void setCurrentKey(String key) { + mCurrentEngine = key; + if (shouldDisplayDataAlert(mCurrentEngine)) { + displayDataAlert(mCurrentEngine); + } else { + updateDefaultEngine(mCurrentEngine); + } + } + +} diff --git a/src/com/android/settings/tts/TtsEnginePreference.java b/src/com/android/settings/tts/TtsEnginePreference.java new file mode 100644 index 0000000..b98a239 --- /dev/null +++ b/src/com/android/settings/tts/TtsEnginePreference.java @@ -0,0 +1,197 @@ +/* + * Copyright (C) 2011 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.tts; + +import com.android.settings.R; + +import android.content.Context; +import android.content.Intent; +import android.os.Bundle; +import android.preference.Preference; +import android.preference.PreferenceActivity; +import android.speech.tts.TextToSpeech.EngineInfo; +import android.view.View; +import android.view.ViewGroup; +import android.widget.Checkable; +import android.widget.CompoundButton; +import android.widget.RadioButton; + + +public class TtsEnginePreference extends Preference { + + /** + * Key for the name of the TTS engine passed in to the engine + * settings fragment {@link TtsEngineSettingsFragment}. + */ + static final String FRAGMENT_ARGS_NAME = "name"; + + /** + * Key for the label of the TTS engine passed in to the engine + * settings fragment. This is used as the title of the fragment + * {@link TtsEngineSettingsFragment}. + */ + static final String FRAGMENT_ARGS_LABEL = "label"; + + /** + * Key for the voice data data passed in to the engine settings + * fragmetn {@link TtsEngineSettingsFragment}. + */ + static final String FRAGMENT_ARGS_VOICES = "voices"; + + /** + * The preference activity that owns this preference. Required + * for instantiating the engine specific settings screen. + */ + private final PreferenceActivity mPreferenceActivity; + + /** + * The engine information for the engine this preference represents. + * Contains it's name, label etc. which are used for display. + */ + private final EngineInfo mEngineInfo; + + /** + * The shared radio button state, which button is checked etc. + */ + private final RadioButtonGroupState mSharedState; + + /** + * When true, the change callbacks on the radio button will not + * fire. + */ + private volatile boolean mPreventRadioButtonCallbacks; + + private View mSettingsIcon; + private RadioButton mRadioButton; + private Intent mVoiceCheckData; + + private final CompoundButton.OnCheckedChangeListener mRadioChangeListener = + new CompoundButton.OnCheckedChangeListener() { + @Override + public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) { + onRadioButtonClicked(buttonView, isChecked); + } + }; + + public TtsEnginePreference(Context context, EngineInfo info, RadioButtonGroupState state, + PreferenceActivity prefActivity) { + super(context); + setLayoutResource(R.layout.preference_tts_engine); + + mSharedState = state; + mPreferenceActivity = prefActivity; + mEngineInfo = info; + mPreventRadioButtonCallbacks = false; + + setKey(mEngineInfo.name); + setTitle(mEngineInfo.label); + } + + @Override + public View getView(View convertView, ViewGroup parent) { + if (mSharedState == null) { + throw new IllegalStateException("Call to getView() before a call to" + + "setSharedState()"); + } + + View view = super.getView(convertView, parent); + final RadioButton rb = (RadioButton) view.findViewById(R.id.tts_engine_radiobutton); + rb.setOnCheckedChangeListener(mRadioChangeListener); + + boolean isChecked = getKey().equals(mSharedState.getCurrentKey()); + if (isChecked) { + mSharedState.setCurrentChecked(rb); + } + + mPreventRadioButtonCallbacks = true; + rb.setChecked(isChecked); + mPreventRadioButtonCallbacks = false; + + mRadioButton = rb; + + View textLayout = view.findViewById(R.id.tts_engine_pref_text); + textLayout.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + onRadioButtonClicked(rb, !rb.isChecked()); + } + }); + + mSettingsIcon = view.findViewById(R.id.tts_engine_settings); + // Will be enabled only the engine has passed the voice check, and + // is currently enabled. + mSettingsIcon.setEnabled(isChecked && mVoiceCheckData != null); + mSettingsIcon.setOnClickListener(new View.OnClickListener() { + @Override + public void onClick(View v) { + Bundle args = new Bundle(); + args.putString(FRAGMENT_ARGS_NAME, mEngineInfo.name); + args.putString(FRAGMENT_ARGS_LABEL, mEngineInfo.label); + if (mVoiceCheckData != null) { + args.putParcelable(FRAGMENT_ARGS_VOICES, mVoiceCheckData); + } + + // Note that we use this instead of the (easier to use) + // PreferenceActivity.startPreferenceFragment because the + // title will not be updated correctly in the fragment + // breadcrumb since it isn't inflated from the XML layout. + mPreferenceActivity.startPreferencePanel( + TtsEngineSettingsFragment.class.getName(), + args, 0, mEngineInfo.label, null, 0); + } + }); + + return view; + } + + public void setVoiceDataDetails(Intent data) { + mVoiceCheckData = data; + mSettingsIcon.setEnabled(mRadioButton.isChecked()); + } + + private void onRadioButtonClicked(CompoundButton buttonView, boolean isChecked) { + if (mPreventRadioButtonCallbacks) { + return; + } + + if (isChecked) { + if (mSharedState.getCurrentChecked() != null) { + mSharedState.getCurrentChecked().setChecked(false); + } + mSharedState.setCurrentChecked(buttonView); + mSharedState.setCurrentKey(getKey()); + callChangeListener(mSharedState.getCurrentKey()); + } + + mSettingsIcon.setEnabled(isChecked); + } + + + /** + * Holds all state that is common to this group of radio buttons, such + * as the currently selected key and the currently checked compound button. + * (which corresponds to this key). + */ + public interface RadioButtonGroupState { + String getCurrentKey(); + Checkable getCurrentChecked(); + + void setCurrentKey(String key); + void setCurrentChecked(Checkable current); + } + +} diff --git a/src/com/android/settings/tts/TtsEngineSettingsFragment.java b/src/com/android/settings/tts/TtsEngineSettingsFragment.java new file mode 100644 index 0000000..d78f80d --- /dev/null +++ b/src/com/android/settings/tts/TtsEngineSettingsFragment.java @@ -0,0 +1,200 @@ +/* + * Copyright (C) 2011 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.tts; + +import com.android.settings.R; +import com.android.settings.SettingsPreferenceFragment; + +import android.content.ActivityNotFoundException; +import android.content.Intent; +import android.os.Bundle; +import android.preference.ListPreference; +import android.preference.Preference; +import android.preference.Preference.OnPreferenceChangeListener; +import android.preference.Preference.OnPreferenceClickListener; +import android.preference.PreferenceScreen; +import android.speech.tts.TextToSpeech; +import android.speech.tts.TtsEngines; +import android.text.TextUtils; +import android.util.Log; + +import java.util.ArrayList; +import java.util.Locale; + + +public class TtsEngineSettingsFragment extends SettingsPreferenceFragment implements + OnPreferenceClickListener, OnPreferenceChangeListener { + private static final String TAG = "TtsEngineSettings"; + private static final boolean DBG = false; + + private static final String KEY_ENGINE_LOCALE = "tts_default_lang"; + private static final String KEY_ENGINE_SETTINGS = "tts_engine_settings"; + private static final String KEY_INSTALL_DATA = "tts_install_data"; + + private TtsEngines mEnginesHelper; + private ListPreference mLocalePreference; + private Preference mEngineSettingsPreference; + private Preference mInstallVoicesPreference; + private Intent mEngineSettingsIntent; + + public TtsEngineSettingsFragment() { + super(); + } + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + addPreferencesFromResource(R.xml.tts_engine_settings); + mEnginesHelper = new TtsEngines(getActivity()); + + final PreferenceScreen root = getPreferenceScreen(); + mLocalePreference = (ListPreference) root.findPreference(KEY_ENGINE_LOCALE); + mLocalePreference.setOnPreferenceChangeListener(this); + mEngineSettingsPreference = root.findPreference(KEY_ENGINE_SETTINGS); + mEngineSettingsPreference.setOnPreferenceClickListener(this); + mInstallVoicesPreference = root.findPreference(KEY_INSTALL_DATA); + mInstallVoicesPreference.setOnPreferenceClickListener(this); + + root.setTitle(getEngineLabel()); + root.setKey(getEngineName()); + mEngineSettingsPreference.setTitle(getResources().getString( + R.string.tts_engine_settings_title, getEngineLabel())); + + mEngineSettingsIntent = mEnginesHelper.getSettingsIntent(getEngineName()); + if (mEngineSettingsIntent == null) { + mEngineSettingsPreference.setEnabled(false); + } + mInstallVoicesPreference.setEnabled(false); + + updateVoiceDetails(); + } + + private void updateVoiceDetails() { + final Intent voiceDataDetails = getArguments().getParcelable( + TtsEnginePreference.FRAGMENT_ARGS_VOICES); + if (DBG) Log.d(TAG, "Parsing voice data details, data: " + voiceDataDetails.toUri(0)); + ArrayList<String> available = voiceDataDetails.getStringArrayListExtra( + TextToSpeech.Engine.EXTRA_AVAILABLE_VOICES); + ArrayList<String> unavailable = voiceDataDetails.getStringArrayListExtra( + TextToSpeech.Engine.EXTRA_UNAVAILABLE_VOICES); + + if (available == null || unavailable == null){ + Log.e(TAG, "TTS data check failed (available == null)."); + return; + } + + if (unavailable.size() > 0) { + mInstallVoicesPreference.setEnabled(true); + } + + if (available.size() > 0) { + updateDefaultLocalePref(available); + } else { + final CharSequence[] empty = new CharSequence[0]; + mLocalePreference.setEntries(empty); + mLocalePreference.setEntryValues(empty); + } + } + + private void updateDefaultLocalePref(ArrayList<String> availableLangs) { + String currentLocale = mEnginesHelper.getLocalePrefForEngine( + getEngineName()); + + CharSequence[] entries = new CharSequence[availableLangs.size()]; + CharSequence[] entryValues = new CharSequence[availableLangs.size()]; + + int selectedLanguageIndex = -1; + 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(currentLocale)) { + selectedLanguageIndex = i; + } + } + } + + mLocalePreference.setEntries(entries); + mLocalePreference.setEntryValues(entryValues); + if (selectedLanguageIndex > -1) { + mLocalePreference.setValueIndex(selectedLanguageIndex); + } else { + mLocalePreference.setValueIndex(0); + mEnginesHelper.updateLocalePrefForEngine(getEngineName(), + availableLangs.get(0)); + } + } + + /** + * Ask the current default engine to launch the matching INSTALL_TTS_DATA activity + * so the required TTS files are properly installed. + */ + private void installVoiceData() { + if (TextUtils.isEmpty(getEngineName())) return; + Intent intent = new Intent(TextToSpeech.Engine.ACTION_INSTALL_TTS_DATA); + intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); + intent.setPackage(getEngineName()); + 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 + ")"); + } + } + + @Override + public boolean onPreferenceClick(Preference preference) { + if (preference == mInstallVoicesPreference) { + installVoiceData(); + return true; + } else if (preference == mEngineSettingsPreference) { + startActivity(mEngineSettingsIntent); + return true; + } + + return false; + } + + @Override + public boolean onPreferenceChange(Preference preference, Object newValue) { + if (preference == mLocalePreference) { + mEnginesHelper.updateLocalePrefForEngine(getEngineName(), (String) newValue); + return true; + } + + return false; + } + + private String getEngineName() { + return getArguments().getString(TtsEnginePreference.FRAGMENT_ARGS_NAME); + } + + private String getEngineLabel() { + return getArguments().getString(TtsEnginePreference.FRAGMENT_ARGS_LABEL); + } + +} |