/*
* Copyright (C) 2009 Google Inc.
*
* 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 android.speech.tts;
import android.speech.tts.ITts;
import android.speech.tts.ITtsCallback;
import android.annotation.SdkConstant;
import android.annotation.SdkConstant.SdkConstantType;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.media.AudioManager;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;
import java.util.HashMap;
import java.util.Locale;
/**
*
* Synthesizes speech from text for immediate playback or to create a sound file.
* <p>A TextToSpeech instance can only be used to synthesize text once it has completed its
* initialization. Implement the {@link TextToSpeech.OnInitListener} to be
* notified of the completion of the initialization.<br>
* When you are done using the TextToSpeech instance, call the {@link #shutdown()} method
* to release the native resources used by the TextToSpeech engine.
*
*/
public class TextToSpeech {
/**
* Denotes a successful operation.
*/
public static final int SUCCESS = 0;
/**
* Denotes a generic operation failure.
*/
public static final int ERROR = -1;
/**
* Queue mode where all entries in the playback queue (media to be played
* and text to be synthesized) are dropped and replaced by the new entry.
*/
public static final int QUEUE_FLUSH = 0;
/**
* Queue mode where the new entry is added at the end of the playback queue.
*/
public static final int QUEUE_ADD = 1;
/**
* Denotes the language is available exactly as specified by the locale.
*/
public static final int LANG_COUNTRY_VAR_AVAILABLE = 2;
/**
* Denotes the language is available for the language and country specified
* by the locale, but not the variant.
*/
public static final int LANG_COUNTRY_AVAILABLE = 1;
/**
* Denotes the language is available for the language by the locale,
* but not the country and variant.
*/
public static final int LANG_AVAILABLE = 0;
/**
* Denotes the language data is missing.
*/
public static final int LANG_MISSING_DATA = -1;
/**
* Denotes the language is not supported.
*/
public static final int LANG_NOT_SUPPORTED = -2;
/**
* Broadcast Action: The TextToSpeech synthesizer has completed processing
* of all the text in the speech queue.
*/
@SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
public static final String ACTION_TTS_QUEUE_PROCESSING_COMPLETED =
"android.speech.tts.TTS_QUEUE_PROCESSING_COMPLETED";
/**
* Interface definition of a callback to be invoked indicating the completion of the
* TextToSpeech engine initialization.
*/
public interface OnInitListener {
/**
* Called to signal the completion of the TextToSpeech engine initialization.
* @param status {@link TextToSpeech#SUCCESS} or {@link TextToSpeech#ERROR}.
*/
public void onInit(int status);
}
/**
* Interface definition of a callback to be invoked indicating the TextToSpeech engine has
* completed synthesizing an utterance with an utterance ID set.
*
*/
public interface OnUtteranceCompletedListener {
/**
* Called to signal the completion of the synthesis of the utterance that was identified
* with the string parameter. This identifier is the one originally passed in the
* parameter hashmap of the synthesis request in
* {@link TextToSpeech#speak(String, int, HashMap)} or
* {@link TextToSpeech#synthesizeToFile(String, HashMap, String)} with the
* {@link TextToSpeech.Engine#KEY_PARAM_UTTERANCE_ID} key.
* @param utteranceId the identifier of the utterance.
*/
public void onUtteranceCompleted(String utteranceId);
}
/**
* Internal constants for the TextToSpeech functionality
*
*/
public class Engine {
// default values for a TTS engine when settings are not found in the provider
/**
* {@hide}
*/
public static final int DEFAULT_RATE = 100; // 1x
/**
* {@hide}
*/
public static final int DEFAULT_PITCH = 100;// 1x
/**
* {@hide}
*/
public static final int USE_DEFAULTS = 0; // false
/**
* {@hide}
*/
public static final String DEFAULT_SYNTH = "com.svox.pico";
// default values for rendering
/**
* Default audio stream used when playing synthesized speech.
*/
public static final int DEFAULT_STREAM = AudioManager.STREAM_MUSIC;
// return codes for a TTS engine's check data activity
/**
* Indicates success when checking the installation status of the resources used by the
* TextToSpeech engine with the {@link #ACTION_CHECK_TTS_DATA} intent.
*/
public static final int CHECK_VOICE_DATA_PASS = 1;
/**
* Indicates failure when checking the installation status of the resources used by the
* TextToSpeech engine with the {@link #ACTION_CHECK_TTS_DATA} intent.
*/
public static final int CHECK_VOICE_DATA_FAIL = 0;
/**
* Indicates erroneous data when checking the installation status of the resources used by
* the TextToSpeech engine with the {@link #ACTION_CHECK_TTS_DATA} intent.
*/
public static final int CHECK_VOICE_DATA_BAD_DATA = -1;
/**
* Indicates missing resources when checking the installation status of the resources used
* by the TextToSpeech engine with the {@link #ACTION_CHECK_TTS_DATA} intent.
*/
public static final int CHECK_VOICE_DATA_MISSING_DATA = -2;
/**
* Indicates missing storage volume when checking the installation status of the resources
* used by the TextToSpeech engine with the {@link #ACTION_CHECK_TTS_DATA} intent.
*/
public static final int CHECK_VOICE_DATA_MISSING_VOLUME = -3;
// intents to ask engine to install data or check its data
/**
* Activity Action: Triggers the platform TextToSpeech engine to
* start the activity that installs the resource files on the device
* that are required for TTS to be operational. Since the installation
* of the data can be interrupted or declined by the user, the application
* shouldn't expect successful installation upon return from that intent,
* and if need be, should check installation status with
* {@link #ACTION_CHECK_TTS_DATA}.
*/
@SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
public static final String ACTION_INSTALL_TTS_DATA =
"android.speech.tts.engine.INSTALL_TTS_DATA";
/**
* Broadcast Action: broadcast to signal the completion of the installation of
* the data files used by the synthesis engine. Success or failure is indicated in the
* {@link #EXTRA_TTS_DATA_INSTALLED} extra.
*/
@SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
public static final String ACTION_TTS_DATA_INSTALLED =
"android.speech.tts.engine.TTS_DATA_INSTALLED";
/**
* Activity Action: Starts the activity from the platform TextToSpeech
* engine to verify the proper installation and availability of the
* resource files on the system. Upon completion, the activity will
* return one of the following codes:
* {@link #CHECK_VOICE_DATA_PASS},
* {@link #CHECK_VOICE_DATA_FAIL},
* {@link #CHECK_VOICE_DATA_BAD_DATA},
* {@link #CHECK_VOICE_DATA_MISSING_DATA}, or
* {@link #CHECK_VOICE_DATA_MISSING_VOLUME}.
* <p> Moreover, the data received in the activity result will contain the following
* fields:
* <ul>
* <li>{@link #EXTRA_VOICE_DATA_ROOT_DIRECTORY} which
* indicates the path to the location of the resource files,</li>
* <li>{@link #EXTRA_VOICE_DATA_FILES} which contains
* the list of all the resource files,</li>
* <li>and {@link #EXTRA_VOICE_DATA_FILES_INFO} which
* contains, for each resource file, the description of the language covered by
* the file in the xxx-YYY format, where xxx is the 3-letter ISO language code,
* and YYY is the 3-letter ISO country code.</li>
* </ul>
*/
@SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
public static final String ACTION_CHECK_TTS_DATA =
"android.speech.tts.engine.CHECK_TTS_DATA";
// extras for a TTS engine's check data activity
/**
* Extra information received with the {@link #ACTION_CHECK_TTS_DATA} intent where
* the TextToSpeech engine specifies the path to its resources.
*/
public static final String EXTRA_VOICE_DATA_ROOT_DIRECTORY = "dataRoot";
/**
* Extra information received with the {@link #ACTION_CHECK_TTS_DATA} intent where
* the TextToSpeech engine specifies the file names of its resources under the
* resource path.
*/
public static final String EXTRA_VOICE_DATA_FILES = "dataFiles";
/**
* Extra information received with the {@link #ACTION_CHECK_TTS_DATA} intent where
* the TextToSpeech engine specifies the locale associated with each resource file.
*/
public static final String EXTRA_VOICE_DATA_FILES_INFO = "dataFilesInfo";
/**
* Extra information received with the {@link #ACTION_CHECK_TTS_DATA} intent where
* the TextToSpeech engine returns an ArrayList<String> of all the available voices.
* The format of each voice is: lang-COUNTRY-variant where COUNTRY and variant are
* optional (ie, "eng" or "eng-USA" or "eng-USA-FEMALE").
*/
public static final String EXTRA_AVAILABLE_VOICES = "availableVoices";
/**
* Extra information received with the {@link #ACTION_CHECK_TTS_DATA} intent where
* the TextToSpeech engine returns an ArrayList<String> of all the unavailable voices.
* The format of each voice is: lang-COUNTRY-variant where COUNTRY and variant are
* optional (ie, "eng" or "eng-USA" or "eng-USA-FEMALE").
*/
public static final String EXTRA_UNAVAILABLE_VOICES = "unavailableVoices";
/**
* Extra information sent with the {@link #ACTION_CHECK_TTS_DATA} intent where the
* caller indicates to the TextToSpeech engine which specific sets of voice data to
* check for by sending an ArrayList<String> of the voices that are of interest.
* The format of each voice is: lang-COUNTRY-variant where COUNTRY and variant are
* optional (ie, "eng" or "eng-USA" or "eng-USA-FEMALE").
*/
public static final String EXTRA_CHECK_VOICE_DATA_FOR = "checkVoiceDataFor";
// extras for a TTS engine's data installation
/**
* Extra information received with the {@link #ACTION_TTS_DATA_INSTALLED} intent.
* It indicates whether the data files for the synthesis engine were successfully
* installed. The installation was initiated with the {@link #ACTION_INSTALL_TTS_DATA}
* intent. The possible values for this extra are
* {@link TextToSpeech#SUCCESS} and {@link TextToSpeech#ERROR}.
*/
public static final String EXTRA_TTS_DATA_INSTALLED = "dataInstalled";
// keys for the parameters passed with speak commands. Hidden keys are used internally
// to maintain engine state for each TextToSpeech instance.
/**
* {@hide}
*/
public static final String KEY_PARAM_RATE = "rate";
/**
* {@hide}
*/
public static final String KEY_PARAM_LANGUAGE = "language";
/**
* {@hide}
*/
public static final String KEY_PARAM_COUNTRY = "country";
/**
* {@hide}
*/
public static final String KEY_PARAM_VARIANT = "variant";
/**
* {@hide}
*/
public static final String KEY_PARAM_ENGINE = "engine";
/**
* {@hide}
*/
public static final String KEY_PARAM_PITCH = "pitch";
/**
* Parameter key to specify the audio stream type to be used when speaking text
* or playing back a file.
* @see TextToSpeech#speak(String, int, HashMap)
* @see TextToSpeech#playEarcon(String, int, HashMap)
*/
public static final String KEY_PARAM_STREAM = "streamType";
/**
* Parameter key to identify an utterance in the
* {@link TextToSpeech.OnUtteranceCompletedListener} after text has been
* spoken, a file has been played back or a silence duration has elapsed.
* @see TextToSpeech#speak(String, int, HashMap)
* @see TextToSpeech#playEarcon(String, int, HashMap)
* @see TextToSpeech#synthesizeToFile(String, HashMap, String)
*/
public static final String KEY_PARAM_UTTERANCE_ID = "utteranceId";
// key positions in the array of cached parameters
/**
* {@hide}
*/
protected static final int PARAM_POSITION_RATE = 0;
/**
* {@hide}
*/
protected static final int PARAM_POSITION_LANGUAGE = 2;
/**
* {@hide}
*/
protected static final int PARAM_POSITION_COUNTRY = 4;
/**
* {@hide}
*/
protected static final int PARAM_POSITION_VARIANT = 6;
/**
* {@hide}
*/
protected static final int PARAM_POSITION_STREAM = 8;
/**
* {@hide}
*/
protected static final int PARAM_POSITION_UTTERANCE_ID = 10;
/**
* {@hide}
*/
protected static final int PARAM_POSITION_ENGINE = 12;
/**
* {@hide}
*/
protected static final int PARAM_POSITION_PITCH = 14;
/**
* {@hide}
*/
protected static final int NB_CACHED_PARAMS = 8;
}
/**
* Connection needed for the TTS.
*/
private ServiceConnection mServiceConnection;
private ITts mITts = null;
private ITtsCallback mITtscallback = null;
private Context mContext = null;
private String mPackageName = "";
private OnInitListener mInitListener = null;
private boolean mStarted = false;
private final Object mStartLock = new Object();
/**
* Used to store the cached parameters sent along with each synthesis request to the
* TTS service.
*/
private String[] mCachedParams;
/**
* The constructor for the TextToSpeech class.
* This will also initialize the associated TextToSpeech engine if it isn't already running.
*
* @param context
* The context this instance is running in.
* @param listener
* The {@link TextToSpeech.OnInitListener} that will be called when the
* TextToSpeech engine has initialized.
*/
public TextToSpeech(Context context, OnInitListener listener) {
mContext = context;
mPackageName = mContext.getPackageName();
mInitListener = listener;
mCachedParams = new String[2*Engine.NB_CACHED_PARAMS]; // store key and value
mCachedParams[Engine.PARAM_POSITION_RATE] = Engine.KEY_PARAM_RATE;
mCachedParams[Engine.PARAM_POSITION_LANGUAGE] = Engine.KEY_PARAM_LANGUAGE;
mCachedParams[Engine.PARAM_POSITION_COUNTRY] = Engine.KEY_PARAM_COUNTRY;
mCachedParams[Engine.PARAM_POSITION_VARIANT] = Engine.KEY_PARAM_VARIANT;
mCachedParams[Engine.PARAM_POSITION_STREAM] = Engine.KEY_PARAM_STREAM;
mCachedParams[Engine.PARAM_POSITION_UTTERANCE_ID] = Engine.KEY_PARAM_UTTERANCE_ID;
mCachedParams[Engine.PARAM_POSITION_ENGINE] = Engine.KEY_PARAM_ENGINE;
mCachedParams[Engine.PARAM_POSITION_PITCH] = Engine.KEY_PARAM_PITCH;
// Leave all defaults that are shown in Settings uninitialized/at the default
// so that the values set in Settings will take effect if the application does
// not try to change these settings itself.
mCachedParams[Engine.PARAM_POSITION_RATE + 1] = "";
mCachedParams[Engine.PARAM_POSITION_LANGUAGE + 1] = "";
mCachedParams[Engine.PARAM_POSITION_COUNTRY + 1] = "";
mCachedParams[Engine.PARAM_POSITION_VARIANT + 1] = "";
mCachedParams[Engine.PARAM_POSITION_STREAM + 1] =
String.valueOf(Engine.DEFAULT_STREAM);
mCachedParams[Engine.PARAM_POSITION_UTTERANCE_ID + 1] = "";
mCachedParams[Engine.PARAM_POSITION_ENGINE + 1] = "";
mCachedParams[Engine.PARAM_POSITION_PITCH + 1] = "100";
initTts();
}
private void initTts() {
mStarted = false;
// Initialize the TTS, run the callback after the binding is successful
mServiceConnection = new ServiceConnection() {
public void onServiceConnected(ComponentName name, IBinder service) {
synchronized(mStartLock) {
mITts = ITts.Stub.asInterface(service);
mStarted = true;
// Cache the default engine and current language
setEngineByPackageName(getDefaultEngine());
setLanguage(getLanguage());
if (mInitListener != null) {
// TODO manage failures and missing resources
mInitListener.onInit(SUCCESS);
}
}
}
public void onServiceDisconnected(ComponentName name) {
synchronized(mStartLock) {
mITts = null;
mInitListener = null;
mStarted = false;
}
}
};
Intent intent = new Intent("android.intent.action.START_TTS_SERVICE");
intent.addCategory("android.intent.category.TTS");
boolean bound = mContext.bindService(intent, mServiceConnection, Context.BIND_AUTO_CREATE);
if (!bound) {
Log.e("TextToSpeech.java", "initTts() failed to bind to service");
if (mInitListener != null) {
mInitListener.onInit(ERROR);
}
} else {
// initialization listener will be called inside ServiceConnection
Log.i("TextToSpeech.java", "initTts() successfully bound to service");
}
// TODO handle plugin failures
}
/**
* Releases the resources used by the TextToSpeech engine.
* It is good practice for instance to call this method in the onDestroy() method of an Activity
* so the TextToSpeech engine can be cleanly stopped.
*/
public void shutdown() {
try {
mContext.unbindService(mServiceConnection);
} catch (IllegalArgumentException e) {
// Do nothing and fail silently since an error here indicates that
// binding never succeeded in the first place.
}
}
/**
* Adds a mapping between a string of text and a sound resource in a
* package. After a call to this method, subsequent calls to
* {@link #speak(String, int, HashMap)} will play the specified sound resource
* if it is available, or synthesize the text it is missing.
*
* @param text
* The string of text. Example: <code>"south_south_east"</code>
*
* @param packagename
* Pass the packagename of the application that contains the
* resource. If the resource is in your own application (this is
* the most common case), then put the packagename of your
* application here.<br/>
* Example: <b>"com.google.marvin.compass"</b><br/>
* The packagename can be found in the AndroidManifest.xml of
* your application.
* <p>
* <code><manifest xmlns:android="..."
* package="<b>com.google.marvin.compass</b>"></code>
* </p>
*
* @param resourceId
* Example: <code>R.raw.south_south_east</code>
*
* @return Code indicating success or failure. See {@link #ERROR} and {@link #SUCCESS}.
*/
public int addSpeech(String text, String packagename, int resourceId) {
synchronized(mStartLock) {
if (!mStarted) {
return ERROR;
}
try {
mITts.addSpeech(mPackageName, text, packagename, resourceId);
return SUCCESS;
} catch (RemoteException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - addSpeech", "RemoteException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (NullPointerException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - addSpeech", "NullPointerException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (IllegalStateException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - addSpeech", "IllegalStateException");
e.printStackTrace();
mStarted = false;
initTts();
}
return ERROR;
}
}
/**
* Adds a mapping between a string of text and a sound file. Using this, it
* is possible to add custom pronounciations for a string of text.
* After a call to this method, subsequent calls to {@link #speak(String, int, HashMap)}
* will play the specified sound resource if it is available, or synthesize the text it is
* missing.
*
* @param text
* The string of text. Example: <code>"south_south_east"</code>
* @param filename
* The full path to the sound file (for example:
* "/sdcard/mysounds/hello.wav")
*
* @return Code indicating success or failure. See {@link #ERROR} and {@link #SUCCESS}.
*/
public int addSpeech(String text, String filename) {
synchronized (mStartLock) {
if (!mStarted) {
return ERROR;
}
try {
mITts.addSpeechFile(mPackageName, text, filename);
return SUCCESS;
} catch (RemoteException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - addSpeech", "RemoteException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (NullPointerException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - addSpeech", "NullPointerException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (IllegalStateException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - addSpeech", "IllegalStateException");
e.printStackTrace();
mStarted = false;
initTts();
}
return ERROR;
}
}
/**
* Adds a mapping between a string of text and a sound resource in a
* package. Use this to add custom earcons.
*
* @see #playEarcon(String, int, HashMap)
*
* @param earcon The name of the earcon.
* Example: <code>"[tick]"</code><br/>
*
* @param packagename
* the package name of the application that contains the
* resource. This can for instance be the package name of your own application.
* Example: <b>"com.google.marvin.compass"</b><br/>
* The package name can be found in the AndroidManifest.xml of
* the application containing the resource.
* <p>
* <code><manifest xmlns:android="..."
* package="<b>com.google.marvin.compass</b>"></code>
* </p>
*
* @param resourceId
* Example: <code>R.raw.tick_snd</code>
*
* @return Code indicating success or failure. See {@link #ERROR} and {@link #SUCCESS}.
*/
public int addEarcon(String earcon, String packagename, int resourceId) {
synchronized(mStartLock) {
if (!mStarted) {
return ERROR;
}
try {
mITts.addEarcon(mPackageName, earcon, packagename, resourceId);
return SUCCESS;
} catch (RemoteException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - addEarcon", "RemoteException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (NullPointerException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - addEarcon", "NullPointerException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (IllegalStateException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - addEarcon", "IllegalStateException");
e.printStackTrace();
mStarted = false;
initTts();
}
return ERROR;
}
}
/**
* Adds a mapping between a string of text and a sound file.
* Use this to add custom earcons.
*
* @see #playEarcon(String, int, HashMap)
*
* @param earcon
* The name of the earcon.
* Example: <code>"[tick]"</code>
* @param filename
* The full path to the sound file (for example:
* "/sdcard/mysounds/tick.wav")
*
* @return Code indicating success or failure. See {@link #ERROR} and {@link #SUCCESS}.
*/
public int addEarcon(String earcon, String filename) {
synchronized (mStartLock) {
if (!mStarted) {
return ERROR;
}
try {
mITts.addEarconFile(mPackageName, earcon, filename);
return SUCCESS;
} catch (RemoteException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - addEarcon", "RemoteException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (NullPointerException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - addEarcon", "NullPointerException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (IllegalStateException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - addEarcon", "IllegalStateException");
e.printStackTrace();
mStarted = false;
initTts();
}
return ERROR;
}
}
/**
* Speaks the string using the specified queuing strategy and speech
* parameters.
*
* @param text
* The string of text to be spoken.
* @param queueMode
* The queuing strategy to use.
* {@link #QUEUE_ADD} or {@link #QUEUE_FLUSH}.
* @param params
* The list of parameters to be used. Can be null if no parameters are given.
* They are specified using a (key, value) pair, where the key can be
* {@link Engine#KEY_PARAM_STREAM} or
* {@link Engine#KEY_PARAM_UTTERANCE_ID}.
*
* @return Code indicating success or failure. See {@link #ERROR} and {@link #SUCCESS}.
*/
public int speak(String text, int queueMode, HashMap<String,String> params)
{
synchronized (mStartLock) {
int result = ERROR;
Log.i("TextToSpeech.java - speak", "speak text of length " + text.length());
if (!mStarted) {
Log.e("TextToSpeech.java - speak", "service isn't started");
return result;
}
try {
if ((params != null) && (!params.isEmpty())) {
String extra = params.get(Engine.KEY_PARAM_STREAM);
if (extra != null) {
mCachedParams[Engine.PARAM_POSITION_STREAM + 1] = extra;
}
extra = params.get(Engine.KEY_PARAM_UTTERANCE_ID);
if (extra != null) {
mCachedParams[Engine.PARAM_POSITION_UTTERANCE_ID + 1] = extra;
}
extra = params.get(Engine.KEY_PARAM_ENGINE);
if (extra != null) {
mCachedParams[Engine.PARAM_POSITION_ENGINE + 1] = extra;
}
}
result = mITts.speak(mPackageName, text, queueMode, mCachedParams);
} catch (RemoteException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - speak", "RemoteException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (NullPointerException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - speak", "NullPointerException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (IllegalStateException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - speak", "IllegalStateException");
e.printStackTrace();
mStarted = false;
initTts();
} finally {
resetCachedParams();
return result;
}
}
}
/**
* Plays the earcon using the specified queueing mode and parameters.
*
* @param earcon
* The earcon that should be played
* @param queueMode
* {@link #QUEUE_ADD} or {@link #QUEUE_FLUSH}.
* @param params
* The list of parameters to be used. Can be null if no parameters are given.
* They are specified using a (key, value) pair, where the key can be
* {@link Engine#KEY_PARAM_STREAM} or
* {@link Engine#KEY_PARAM_UTTERANCE_ID}.
*
* @return Code indicating success or failure. See {@link #ERROR} and {@link #SUCCESS}.
*/
public int playEarcon(String earcon, int queueMode,
HashMap<String,String> params) {
synchronized (mStartLock) {
int result = ERROR;
if (!mStarted) {
return result;
}
try {
if ((params != null) && (!params.isEmpty())) {
String extra = params.get(Engine.KEY_PARAM_STREAM);
if (extra != null) {
mCachedParams[Engine.PARAM_POSITION_STREAM + 1] = extra;
}
extra = params.get(Engine.KEY_PARAM_UTTERANCE_ID);
if (extra != null) {
mCachedParams[Engine.PARAM_POSITION_UTTERANCE_ID + 1] = extra;
}
}
result = mITts.playEarcon(mPackageName, earcon, queueMode, null);
} catch (RemoteException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - playEarcon", "RemoteException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (NullPointerException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - playEarcon", "NullPointerException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (IllegalStateException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - playEarcon", "IllegalStateException");
e.printStackTrace();
mStarted = false;
initTts();
} finally {
resetCachedParams();
return result;
}
}
}
/**
* Plays silence for the specified amount of time using the specified
* queue mode.
*
* @param durationInMs
* A long that indicates how long the silence should last.
* @param queueMode
* {@link #QUEUE_ADD} or {@link #QUEUE_FLUSH}.
* @param params
* The list of parameters to be used. Can be null if no parameters are given.
* They are specified using a (key, value) pair, where the key can be
* {@link Engine#KEY_PARAM_UTTERANCE_ID}.
*
* @return Code indicating success or failure. See {@link #ERROR} and {@link #SUCCESS}.
*/
public int playSilence(long durationInMs, int queueMode, HashMap<String,String> params) {
synchronized (mStartLock) {
int result = ERROR;
if (!mStarted) {
return result;
}
try {
if ((params != null) && (!params.isEmpty())) {
String extra = params.get(Engine.KEY_PARAM_UTTERANCE_ID);
if (extra != null) {
mCachedParams[Engine.PARAM_POSITION_UTTERANCE_ID + 1] = extra;
}
}
result = mITts.playSilence(mPackageName, durationInMs, queueMode, mCachedParams);
} catch (RemoteException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - playSilence", "RemoteException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (NullPointerException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - playSilence", "NullPointerException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (IllegalStateException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - playSilence", "IllegalStateException");
e.printStackTrace();
mStarted = false;
initTts();
} finally {
return result;
}
}
}
/**
* Returns whether or not the TextToSpeech engine is busy speaking.
*
* @return Whether or not the TextToSpeech engine is busy speaking.
*/
public boolean isSpeaking() {
synchronized (mStartLock) {
if (!mStarted) {
return false;
}
try {
return mITts.isSpeaking();
} catch (RemoteException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - isSpeaking", "RemoteException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (NullPointerException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - isSpeaking", "NullPointerException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (IllegalStateException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - isSpeaking", "IllegalStateException");
e.printStackTrace();
mStarted = false;
initTts();
}
return false;
}
}
/**
* Interrupts the current utterance (whether played or rendered to file) and discards other
* utterances in the queue.
*
* @return Code indicating success or failure. See {@link #ERROR} and {@link #SUCCESS}.
*/
public int stop() {
synchronized (mStartLock) {
int result = ERROR;
if (!mStarted) {
return result;
}
try {
result = mITts.stop(mPackageName);
} catch (RemoteException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - stop", "RemoteException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (NullPointerException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - stop", "NullPointerException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (IllegalStateException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - stop", "IllegalStateException");
e.printStackTrace();
mStarted = false;
initTts();
} finally {
return result;
}
}
}
/**
* Sets the speech rate for the TextToSpeech engine.
*
* This has no effect on any pre-recorded speech.
*
* @param speechRate
* The speech rate for the TextToSpeech engine. 1 is the normal speed,
* lower values slow down the speech (0.5 is half the normal speech rate),
* greater values accelerate it (2 is twice the normal speech rate).
*
* @return Code indicating success or failure. See {@link #ERROR} and {@link #SUCCESS}.
*/
public int setSpeechRate(float speechRate) {
synchronized (mStartLock) {
int result = ERROR;
if (!mStarted) {
return result;
}
try {
if (speechRate > 0) {
int rate = (int)(speechRate*100);
mCachedParams[Engine.PARAM_POSITION_RATE + 1] = String.valueOf(rate);
// the rate is not set here, instead it is cached so it will be associated
// with all upcoming utterances.
if (speechRate > 0.0f) {
result = SUCCESS;
} else {
result = ERROR;
}
}
} catch (NullPointerException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - setSpeechRate", "NullPointerException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (IllegalStateException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - setSpeechRate", "IllegalStateException");
e.printStackTrace();
mStarted = false;
initTts();
} finally {
return result;
}
}
}
/**
* Sets the speech pitch for the TextToSpeech engine.
*
* This has no effect on any pre-recorded speech.
*
* @param pitch
* The pitch for the TextToSpeech engine. 1 is the normal pitch,
* lower values lower the tone of the synthesized voice,
* greater values increase it.
*
* @return Code indicating success or failure. See {@link #ERROR} and {@link #SUCCESS}.
*/
public int setPitch(float pitch) {
synchronized (mStartLock) {
int result = ERROR;
if (!mStarted) {
return result;
}
try {
// the pitch is not set here, instead it is cached so it will be associated
// with all upcoming utterances.
if (pitch > 0) {
int p = (int)(pitch*100);
mCachedParams[Engine.PARAM_POSITION_PITCH + 1] = String.valueOf(p);
result = SUCCESS;
}
} catch (NullPointerException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - setPitch", "NullPointerException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (IllegalStateException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - setPitch", "IllegalStateException");
e.printStackTrace();
mStarted = false;
initTts();
} finally {
return result;
}
}
}
/**
* Sets the language for the TextToSpeech engine.
* The TextToSpeech engine will try to use the closest match to the specified
* language as represented by the Locale, but there is no guarantee that the exact same Locale
* will be used. Use {@link #isLanguageAvailable(Locale)} to check the level of support
* before choosing the language to use for the next utterances.
*
* @param loc
* The locale describing the language to be used.
*
* @return code indicating the support status for the locale. See {@link #LANG_AVAILABLE},
* {@link #LANG_COUNTRY_AVAILABLE}, {@link #LANG_COUNTRY_VAR_AVAILABLE},
* {@link #LANG_MISSING_DATA} and {@link #LANG_NOT_SUPPORTED}.
*/
public int setLanguage(Locale loc) {
synchronized (mStartLock) {
int result = LANG_NOT_SUPPORTED;
if (!mStarted) {
return result;
}
if (loc == null) {
return result;
}
try {
String language = loc.getISO3Language();
String country = loc.getISO3Country();
String variant = loc.getVariant();
// Check if the language, country, variant are available, and cache
// the available parts.
// Note that the language is not actually set here, instead it is cached so it
// will be associated with all upcoming utterances.
result = mITts.isLanguageAvailable(language, country, variant, mCachedParams);
if (result >= LANG_AVAILABLE){
mCachedParams[Engine.PARAM_POSITION_LANGUAGE + 1] = language;
if (result >= LANG_COUNTRY_AVAILABLE){
mCachedParams[Engine.PARAM_POSITION_COUNTRY + 1] = country;
} else {
mCachedParams[Engine.PARAM_POSITION_COUNTRY + 1] = "";
}
if (result >= LANG_COUNTRY_VAR_AVAILABLE){
mCachedParams[Engine.PARAM_POSITION_VARIANT + 1] = variant;
} else {
mCachedParams[Engine.PARAM_POSITION_VARIANT + 1] = "";
}
}
} catch (RemoteException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - setLanguage", "RemoteException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (NullPointerException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - setLanguage", "NullPointerException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (IllegalStateException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - setLanguage", "IllegalStateException");
e.printStackTrace();
mStarted = false;
initTts();
} finally {
return result;
}
}
}
/**
* Returns a Locale instance describing the language currently being used by the TextToSpeech
* engine.
* @return language, country (if any) and variant (if any) used by the engine stored in a Locale
* instance, or null is the TextToSpeech engine has failed.
*/
public Locale getLanguage() {
synchronized (mStartLock) {
if (!mStarted) {
return null;
}
try {
// Only do a call to the native synth if there is nothing in the cached params
if (mCachedParams[Engine.PARAM_POSITION_LANGUAGE + 1].length() < 1){
String[] locStrings = mITts.getLanguage();
if ((locStrings != null) && (locStrings.length == 3)) {
return new Locale(locStrings[0], locStrings[1], locStrings[2]);
} else {
return null;
}
} else {
return new Locale(mCachedParams[Engine.PARAM_POSITION_LANGUAGE + 1],
mCachedParams[Engine.PARAM_POSITION_COUNTRY + 1],
mCachedParams[Engine.PARAM_POSITION_VARIANT + 1]);
}
} catch (RemoteException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - getLanguage", "RemoteException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (NullPointerException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - getLanguage", "NullPointerException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (IllegalStateException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - getLanguage", "IllegalStateException");
e.printStackTrace();
mStarted = false;
initTts();
}
return null;
}
}
/**
* Checks if the specified language as represented by the Locale is available and supported.
*
* @param loc
* The Locale describing the language to be used.
*
* @return code indicating the support status for the locale. See {@link #LANG_AVAILABLE},
* {@link #LANG_COUNTRY_AVAILABLE}, {@link #LANG_COUNTRY_VAR_AVAILABLE},
* {@link #LANG_MISSING_DATA} and {@link #LANG_NOT_SUPPORTED}.
*/
public int isLanguageAvailable(Locale loc) {
synchronized (mStartLock) {
int result = LANG_NOT_SUPPORTED;
if (!mStarted) {
return result;
}
try {
result = mITts.isLanguageAvailable(loc.getISO3Language(),
loc.getISO3Country(), loc.getVariant(), mCachedParams);
} catch (RemoteException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - isLanguageAvailable", "RemoteException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (NullPointerException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - isLanguageAvailable", "NullPointerException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (IllegalStateException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - isLanguageAvailable", "IllegalStateException");
e.printStackTrace();
mStarted = false;
initTts();
} finally {
return result;
}
}
}
/**
* Synthesizes the given text to a file using the specified parameters.
*
* @param text
* The String of text that should be synthesized
* @param params
* The list of parameters to be used. Can be null if no parameters are given.
* They are specified using a (key, value) pair, where the key can be
* {@link Engine#KEY_PARAM_UTTERANCE_ID}.
* @param filename
* The string that gives the full output filename; it should be
* something like "/sdcard/myappsounds/mysound.wav".
*
* @return Code indicating success or failure. See {@link #ERROR} and {@link #SUCCESS}.
*/
public int synthesizeToFile(String text, HashMap<String,String> params,
String filename) {
synchronized (mStartLock) {
int result = ERROR;
Log.i("TextToSpeech.java - synthesizeToFile", "synthesizeToFile text of length "
+ text.length());
if (!mStarted) {
Log.e("TextToSpeech.java - synthesizeToFile", "service isn't started");
return result;
}
try {
if ((params != null) && (!params.isEmpty())) {
// no need to read the stream type here
String extra = params.get(Engine.KEY_PARAM_UTTERANCE_ID);
if (extra != null) {
mCachedParams[Engine.PARAM_POSITION_UTTERANCE_ID + 1] = extra;
}
extra = params.get(Engine.KEY_PARAM_ENGINE);
if (extra != null) {
mCachedParams[Engine.PARAM_POSITION_ENGINE + 1] = extra;
}
}
result = mITts.synthesizeToFile(mPackageName, text, mCachedParams, filename) ?
SUCCESS : ERROR;
} catch (RemoteException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - synthesizeToFile", "RemoteException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (NullPointerException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - synthesizeToFile", "NullPointerException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (IllegalStateException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - synthesizeToFile", "IllegalStateException");
e.printStackTrace();
mStarted = false;
initTts();
} finally {
resetCachedParams();
return result;
}
}
}
/**
* Convenience method to reset the cached parameters to the current default values
* if they are not persistent between calls to the service.
*/
private void resetCachedParams() {
mCachedParams[Engine.PARAM_POSITION_STREAM + 1] =
String.valueOf(Engine.DEFAULT_STREAM);
mCachedParams[Engine.PARAM_POSITION_UTTERANCE_ID+ 1] = "";
}
/**
* Sets the OnUtteranceCompletedListener that will fire when an utterance completes.
*
* @param listener
* The OnUtteranceCompletedListener
*
* @return Code indicating success or failure. See {@link #ERROR} and {@link #SUCCESS}.
*/
public int setOnUtteranceCompletedListener(
final OnUtteranceCompletedListener listener) {
synchronized (mStartLock) {
int result = ERROR;
if (!mStarted) {
return result;
}
mITtscallback = new ITtsCallback.Stub() {
public void utteranceCompleted(String utteranceId) throws RemoteException {
if (listener != null) {
listener.onUtteranceCompleted(utteranceId);
}
}
};
try {
result = mITts.registerCallback(mPackageName, mITtscallback);
} catch (RemoteException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - registerCallback", "RemoteException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (NullPointerException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - registerCallback", "NullPointerException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (IllegalStateException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - registerCallback", "IllegalStateException");
e.printStackTrace();
mStarted = false;
initTts();
} finally {
return result;
}
}
}
/**
* Sets the speech synthesis engine to be used by its packagename.
*
* @param enginePackageName
* The packagename for the synthesis engine (ie, "com.svox.pico")
*
* @return Code indicating success or failure. See {@link #ERROR} and {@link #SUCCESS}.
*/
public int setEngineByPackageName(String enginePackageName) {
synchronized (mStartLock) {
int result = TextToSpeech.ERROR;
if (!mStarted) {
return result;
}
try {
result = mITts.setEngineByPackageName(enginePackageName);
if (result == TextToSpeech.SUCCESS){
mCachedParams[Engine.PARAM_POSITION_ENGINE + 1] = enginePackageName;
}
} catch (RemoteException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - setEngineByPackageName", "RemoteException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (NullPointerException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - setEngineByPackageName", "NullPointerException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (IllegalStateException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - setEngineByPackageName", "IllegalStateException");
e.printStackTrace();
mStarted = false;
initTts();
} finally {
return result;
}
}
}
/**
* Gets the packagename of the default speech synthesis engine.
*
* @return Packagename of the TTS engine that the user has chosen as their default.
*/
public String getDefaultEngine() {
synchronized (mStartLock) {
String engineName = "";
if (!mStarted) {
return engineName;
}
try {
engineName = mITts.getDefaultEngine();
} catch (RemoteException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - setEngineByPackageName", "RemoteException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (NullPointerException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - setEngineByPackageName", "NullPointerException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (IllegalStateException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - setEngineByPackageName", "IllegalStateException");
e.printStackTrace();
mStarted = false;
initTts();
} finally {
return engineName;
}
}
}
/**
* Returns whether or not the user is forcing their defaults to override the
* Text-To-Speech settings set by applications.
*
* @return Whether or not defaults are enforced.
*/
public boolean areDefaultsEnforced() {
synchronized (mStartLock) {
boolean defaultsEnforced = false;
if (!mStarted) {
return defaultsEnforced;
}
try {
defaultsEnforced = mITts.areDefaultsEnforced();
} catch (RemoteException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - areDefaultsEnforced", "RemoteException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (NullPointerException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - areDefaultsEnforced", "NullPointerException");
e.printStackTrace();
mStarted = false;
initTts();
} catch (IllegalStateException e) {
// TTS died; restart it.
Log.e("TextToSpeech.java - areDefaultsEnforced", "IllegalStateException");
e.printStackTrace();
mStarted = false;
initTts();
} finally {
return defaultsEnforced;
}
}
}
}
|