Android TTS 自动发声

http://zxandroid.iteye.com/blog/605978

 

1、首先要tts是否有所需语言的语音数据，如果没有需安装它

Intent checkIntent = new Intent();
checkIntent.setAction(TextToSpeech.Engine.ACTION_CHECK_TTS_DATA);
startActivityForResult(checkIntent, MY_DATA_CHECK_CODE);

private TextToSpeech mTts;
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == MY_DATA_CHECK_CODE) {
        if (resultCode == TextToSpeech.Engine.CHECK_VOICE_DATA_PASS) {
            // success, create the TTS instance
            mTts = new TextToSpeech(this, this);
        } else {
            // missing data, install it
            Intent installIntent = new Intent();
            installIntent.setAction(
                TextToSpeech.Engine.ACTION_INSTALL_TTS_DATA);
            startActivity(installIntent);
        }
    }
}

Intent checkIntent = new Intent();
checkIntent.setAction(TextToSpeech.Engine.ACTION_CHECK_TTS_DATA);
startActivityForResult(checkIntent, MY_DATA_CHECK_CODE);

private TextToSpeech mTts;
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == MY_DATA_CHECK_CODE) {
        if (resultCode == TextToSpeech.Engine.CHECK_VOICE_DATA_PASS) {
            // success, create the TTS instance
            mTts = new TextToSpeech(this, this);
        } else {
            // missing data, install it
            Intent installIntent = new Intent();
            installIntent.setAction(
                TextToSpeech.Engine.ACTION_INSTALL_TTS_DATA);
            startActivity(installIntent);
        }
    }
}

2、设置地区（语言）

mTts.setLanguage(Locale.US);

mTts.setLanguage(Locale.US);

3、判断是否支持某地区的语言

mTts.isLanguageAvailable(Locale.FRANCE))

mTts.isLanguageAvailable(Locale.FRANCE))

或

mTts.isLanguageAvailable(new Locale("spa", "ESP")))

mTts.isLanguageAvailable(new Locale("spa", "ESP")))

或

mTts.isLanguageAvailable(new Locale("spa"))

mTts.isLanguageAvailable(new Locale("spa"))

如果没有语言数据，会返回TextToSpeech.LANG_MISSING_DATA，否则返回ACTION_CHECK_TTS_DATA

4、处理发音

String myText1 = "Did you sleep well?";
String myText2 = "I hope so, because it's time to wake up.";
mTts.speak(myText1, TextToSpeech.QUEUE_FLUSH, null);
mTts.speak(myText2, TextToSpeech.QUEUE_ADD, null);

String myText1 = "Did you sleep well?";
String myText2 = "I hope so, because it's time to wake up.";
mTts.speak(myText1, TextToSpeech.QUEUE_FLUSH, null);
mTts.speak(myText2, TextToSpeech.QUEUE_ADD, null);

5、加参数

HashMap<String, String> myHashAlarm = new HashMap();
myHashAlarm.put(TextToSpeech.Engine.KEY_PARAM_STREAM, String.valueOf(AudioManager.STREAM_ALARM));
mTts.speak(myText1, TextToSpeech.QUEUE_FLUSH, myHashAlarm);
mTts.speak(myText2, TextToSpeech.QUEUE_ADD, myHashAlarm);

HashMap<String, String> myHashAlarm = new HashMap();
myHashAlarm.put(TextToSpeech.Engine.KEY_PARAM_STREAM, String.valueOf(AudioManager.STREAM_ALARM));
mTts.speak(myText1, TextToSpeech.QUEUE_FLUSH, myHashAlarm);
mTts.speak(myText2, TextToSpeech.QUEUE_ADD, myHashAlarm);

6、加完成监听

mTts.setOnUtteranceCompletedListener(this);
myHashAlarm.put(TextToSpeech.Engine.KEY_PARAM_STREAM, String.valueOf(AudioManager.STREAM_ALARM));
mTts.speak(myText1, TextToSpeech.QUEUE_FLUSH, myHashAlarm);
myHashAlarm.put(TextToSpeech.Engine.KEY_PARAM_UTTERANCE_ID, "end of wakeup message ID");
// myHashAlarm now contains two optional parameters
mTts.speak(myText2, TextToSpeech.QUEUE_ADD, myHashAlarm);

public void onUtteranceCompleted(String uttId) {
if (uttId == "end of wakeup message ID") {
    playAnnoyingMusic();
}
}

mTts.setOnUtteranceCompletedListener(this);
myHashAlarm.put(TextToSpeech.Engine.KEY_PARAM_STREAM, String.valueOf(AudioManager.STREAM_ALARM));
mTts.speak(myText1, TextToSpeech.QUEUE_FLUSH, myHashAlarm);
myHashAlarm.put(TextToSpeech.Engine.KEY_PARAM_UTTERANCE_ID, "end of wakeup message ID");
// myHashAlarm now contains two optional parameters
mTts.speak(myText2, TextToSpeech.QUEUE_ADD, myHashAlarm);

public void onUtteranceCompleted(String uttId) {
if (uttId == "end of wakeup message ID") {
    playAnnoyingMusic();
}
}

7、将发音录入文件

HashMap<String, String> myHashRender = new HashMap();
String wakeUpText = "Are you up yet?";
String destFileName = "/sdcard/myAppCache/wakeUp.wav";
myHashRender.put(TextToSpeech.Engine.KEY_PARAM_UTTERANCE_ID, wakeUpText);

mTts.addSpeech(wakeUpText, destFileName);
mTts.speak(wakeUpText, TextToSpeech.QUEUE_ADD, myHashAlarm);

HashMap<String, String> myHashRender = new HashMap();
String wakeUpText = "Are you up yet?";
String destFileName = "/sdcard/myAppCache/wakeUp.wav";
myHashRender.put(TextToSpeech.Engine.KEY_PARAM_UTTERANCE_ID, wakeUpText);

mTts.addSpeech(wakeUpText, destFileName);
mTts.speak(wakeUpText, TextToSpeech.QUEUE_ADD, myHashAlarm);

8、关闭tts

Java代码  

mTts.shutdown();
mTts.synthesizeToFile(wakuUpText, myHashRender, destFileName);

http://www.189works.com/article-599-1.html

 

TextToSpeech简称 TTS，是Android 1.6版本中比较重要的新功能。将所指定的文本转成不同语言音频输出。它可以方便的嵌入到游戏或者应用程序中，增强用户体验。

　　在讲解TTS API和将这项功能应用到你的实际项目中的方法之前，先对这套TTS引擎有个初步的了解。

　　对TTS资源的大体了解：

　　TTS engine依托于当前Android Platform所支持的几种主要的语言：English、French、German、Italian和Spanish五大语言（暂时没有我们伟大的中文，至少Google的科学家们还没有把中文玩到炉火纯青的地步，先易后难也是理所当然。）TTS可以将文本随意的转换成以上任意五种语言的语音输出。与此同时，对于个别的语言版本将取决于不同的时区，例如：对于English，在TTS中可以分别输出美式和英式两种不同的版本（由此看出Google的做事风格真够细致，而正因为如此估计Google不加入中文的另外一种理由是中文的方言太多了）。

　　能支持如此庞大的数据量，TTS 引擎对于资源的优化采取预加载的方法。根据一系列的参数信息（参数的用法将在后边有详细的介绍）从库中提取相应的资源，并加载到当前系统中。

　　尽管当前大部分加载有Android操作系统的设备都通过这套引擎来提供TTS功能，但由于一些设备的存储空间非常有限而影响到TTS无法最大限度的发挥功能，算是当前的一个瓶颈。为此，开发引入了检测模块，让利用这项技术的应用程序或者游戏针对于不同的设备可以有相应的优化调整，从而避免由于此项功能的限制，影响到整个应用程序的使用。比较稳妥的做法是让用户自行选择是否有足够的空间或者需求来加载此项资源，下边给出一个标准的检测方法：

　　Intent checkIntent = new Intent();

　　 checkIntent.setAction(TextToSpeech.Engine.ACTION_C HECK_TTS_DATA);

　　startActivityForResult(checkIntent, MY_DATA_CHECK_CODE);

　　如果当前系统允许创建一个 “android.speech.tts.TextToSpeech” 的彩虹简谱字库 下载Object, 说明已经提供TTS功能的支持，将检测返回结果中给出“ CHECK_VOICE_DATA_PASS ” 的标记。如果系统不支持这项功能，那么用户可以选择是否加载这项功能，从而让设备支持输出多国语言的语音功能“Multi-lingual Talking”。“ACTION_INSTALL_TTS_DATA” intent将用户引入Android market中的TTS下载界面。下载完成后将自动完成安装，下边是实现这一过程的完整代码 (androidres) ：

　　 private TextToSpeech mTts;

　　protected void onActivityResult(

　　int requestCode, int resultCode, Intent data) {

　　if (requestCode == MY_DATA_CHECK_CODE) {

　　if (resultCode == TextToSpeech.Engine.CHECK_VOICE_DATA_PASS) {

　　// sess, create the TTS instance

　　mTts = new TextToSpeech(this, this);

　　} else {

　　// missing data, install it

　　Intent installIntent = new Intent();

　　installIntent.setAction(

　　TextToSpeech.Engine.ACTION_INSTALL_TTS_DATA);

　　 startActivity(installIntent);

　　}

　　}

　　}

　　TextToSpeech实体和OnInitListener都需要引用当前Activity的Context作为构造参数。 OnInitListener（）的用处是通知系统当前TTS Engine已经加载完成，并处于可用状态。

　　根据需求设置语言参数：

　　早在Google I/O大会上，官方给出了一段关于应用这项功能的鲜活体验，将翻译结果直接通过五种不同国家语言的语音输出。加载语言的方法非常简单：

　　mTts.setLanguage(Locale.US);

　　上边代码表示当前TTS实体加载美式英语。其参数并没有指示某种语言的名称，而是利用国家代码来表示，这样做的好处是不但可以确定语言的选择，而且可以根据地区的不同而有所区别。例如：英语作为最广泛被应用的语种，在多个不同的地区都有一定的差别。判断当前系统是否支持某个地区的语言资源，可以通过调用isLanguageAvailable()方法的返回值，根据返回值的描述来选择正确的处理方式。让应用某些绚丽功能的应用程序更加健壮，这个是贯穿整个开发过程都要考虑的技术环节。下边是一些应用实例 (androidres) ：

　　mTts.isLanguageAvailable(Locale.UK))

　　 mTts.isLanguageAvailable(Locale.FRANCE))

　　 mTts.isLanguageAvailable(new Locale("spa", "ESP")))

　　如果返回值是“ TextToSpeech.LANG_COUNTRY_AVAILABLE ” 说明所选择的地区被包含在当前TTS系统中。如果系统中已经创建了TTS实体，那么可以利用isLanguageAvailable()方法来替代 Start “ACTION_CHECK_TTS_DATA ” intent 检测。当无法找到任何可用资源匹配所指定的参数时，将会返回“ TextToSpeech.LANG_MISSING_DATA ”的结果。下边给出另外两个返回其它不同状态信息的例子：

　　 mTts.isLanguageAvailable(Locale.CANADA_FRENCH))

　　 mTts.isLanguageAvailable(new Locale("spa"))

　　两个语句的返回值均为“ TextToSpeech.LANG_AVAILABLE ” 。第一个是检测当前系统是否支持加拿*****语，由于系统在资源库中无法找到这个地区的法语分支，其含义是仅支持这项语言（法语），而不支持当前紫光 v4.0下载地区的语言分支。

　　另外，相比于上面强制用户应用预定的语音设置，更加提倡利用Locale.getDefault() 方法根据用户默认的地区设置来选择合适的语言库。

　　执行Speak的具体方法：

　　根据上边的介绍，基本实现了 TextToSpeech的初始化和参数配置。下面是一个有关闹钟的应用实例，利用Speak()方法可以直接在应用程序中发挥强大的语音功能。没错，用起来就是这么简单：

　　String myText1 = "This Translation is from androidRes";

　　String myText2 = "I hope so, because it's time to wake up.";

　　mTts.speak(myText1, TextToSpeech.QUEUE_FLUSH, null);

　　mTts.speak(myText2, TextToSpeech.QUEUE_ADD, null);

　　TTS Engine的工作原理：

　　每个独立的应用程序都可以单独创建一个TTS实体，而他们需要执行的语音消息列队（Queue）都统一由TTS Engine管理和语音合成。

　　名词解释：

　　synthesize [snθsaz] DJ ['snθsaz] KK：to produce sounds, music or speech using electronic equipment （音响）合成

　　utterances [trns] DJ [trns] KK ：说话方式，语音/语调。

　　每个独立的TTS实例管理语音消息列队请求的优先级和顺序等。当引用 “TextToSpeech.QUEUE_FLUSH” 调用Speak（）方法时，会中断当前实例正在运行的任务（也可以理解为清除当前语音任务，转而执行新的列队任务）。引用 “TextToSpeech.QUEUE_ADD”标签的发音任务将被添加到当前任务列队之后。

　　为语音任务关联Stream Type：

　　在Ａｎｄｒｏｉｄ操作系统中所有的Ａｕｄｉｏ Ｓｔｒｅａｍ任务都是通过ＡｕｄｉｏＭａｎａｇｅｒ类来实现，而它会针对不同的Ｓｔｒｅａｍ Ｔｙｐｅ来改变语音的播放模式。StreamＴｙｐｅ可以理解为语音的播放属性，这个属性是用户根据自己的需要在系统中配置的应用方案。如果将语音任务都清楚的分门别类，可以方便的统一管理相同类别任务的属性。基于上一个Alarm Clock例子的基础上，将Speak()方法的最后一个Null参数替换成具有实际含义的数值。这个参数的类型是HashMap，如果希望将当前的 Stream Type设置为系统中Alarm类型，对上一个例子稍作改动：

　　HashMap myHashAlarm = new HashMap();

　　myHashAlarm.put(TextToSpeech.Engine.KEY_PARAM_STRE AM,

　　String.valueOf(AudioManager.STREAM_ALARM));

　　 mTts.speak(myText1, TextToSpeech.QUEUE_FLUSH, myHashAlarm);

　　 mTts.speak(myText2, TextToSpeech.QUEUE_ADD, myHashAlarm);

　　应用语音功能的Completion Callback：

　　TTS中的Speak()的是异步调用，无论应用QUEUE_FLUSH 或者QUEUE_ADD作为参数都可以通过定义Listener监听当前任务的完成状态。可以利用这个方法追加Speak()执行之后的一些额外操作。下接下来的例子中，当完成第二次Speak()方法调用之后，利用OnUtteranceCompletedListener接口来调用其它方法：

　　mTts.setOnUtteranceCompletedListener(this);

　　 myHashAlarm.put(TextToSpeech.Engine.KEY_PARAM_STRE AM,

　　 String.valueOf(AudioManager.STREAM_ALARM));

　　 mTts.speak(myText1, TextToSpeech.QUEUE_FLUSH, myHashAlarm);

　　 myHashAlarm.put(TextToSpeech.Engine.KEY_PARAM_UTTE RANCE_ID,

　　 "end of wakeup message ID");

　　// myHashAlarm now contains two optional parameters

　　mTts.speak(myText2, TextToSpeech.QUEUE_ADD, myHashAlarm);

　　下边是定义Listener的代码，类似与监听按 CuteFTP Home 8.3.3.0054下载钮或者其它View Events的方法。在这里将会把Speak()中HashMap参数传进Listener中，作为条件的判断依据：

　　public void onUtteranceCompleted(String uttId) {

　　if (uttId == "end of wakeup message ID") {

　　playAnnoyingMusic();

　　}

　　}

　　“烘焙”当前实时的语音数据：

　　看到烘焙两个字，就会让人联想到香喷喷的面包。软件开发要关注于是否可以最大限度的实现资源的复用，特别是针对资源有限的手机应用平台。那么对于TTS这么奢侈的应用如何才能更高效的使用资源呢？这次一起来体验比烘焙面包更加让人激动的功能，将TTS Engine输出的Audio Stream作为永久的音频文件保存在当前的存储空间中(SDCard)。这样可以对需要重复播放的某些语音内容实现快速的回放功能，从而实现国际倡导的 “减排”目的，能省就省吧！在下边的例子用通过TTS的synthesizeToFile方法，将合成的语音Stream保存在参数所指定的地址中。

　　HashMap myHashRender = new HashMap();

　　String wakeUpText = "Are you up yet?";

　　String destFileName = "/sdcard/myAppCache/wakeUp.wav";

　　 myHashRender.put(TextToSpeech.Engine.KEY_PARAM_UTT ERANCE_ID, wakeUpText);

　　mTts.synthesizeToFile(wakuUpText, myHashRender, destFileName);

　　当完成以上操作之后会收到系统的完成通知，同时可以像其它音频资源一样，通过 android.media.MediaPlayer方法来播放。但这有悖于TextToSpeech的应用流程，可以将刚刚输出的语音资源通过 addSpeech()的方法将其语音和文字描述一同存储于TTS库中。

　　mTts.addSpeech(wakeUpText, destFileName);

　　在当前的TTS Instance中，任何利用Speak()方法执行相同内容的调用都将复用刚刚所生成的音频文件。如果资源丢失或者SDCard等存储设备移除，那么系统将再次通过TTS Engine合成所指定的语音内容。

　　mTts.speak(wakeUpText, TextToSpeech.QUEUE_ADD, myHashAlarm);

　　回收TTS：

　　当确定应用程序不再需要TTS的相关功能后，可以在Activity的OnDestroy()方法中调用shutDown()释放当前TTS实体所占用的资源。<!-- -->

 

http://mobile.51cto.com/android-266424.htm

 

Android TTS技术，也就是Text-to-speech技术。TTS技术对文本文件进行实时转换，转换时间之短可以秒计算。在其特有智能语音控制器作用下，文本输出的语音音律流畅，使得听者在听取信息时感觉自然，毫无机器语音输出的冷漠与生涩感。TTS语音合成技术即将覆盖国标一、二级汉字，具有英文接口，自动识别中、英文，支持中英文混读。所有声音采用真人普通话为标准发音，实现了120-150个汉字/秒的快速语音合成，朗读速度达3-4个汉字/秒，使用户可以听到清晰悦耳的音质和连贯流畅的语调。

下面我们来看看这是如何实现的：

第一步：检查TTS数据是否可用：

java代码：

//检查TTS数据是否已经安装并且可用
Intent checkIntent = new Intent();
checkIntent.setAction(TextToSpeech.Engine.ACTION_CHECK_TTS_DATA);
startActivityForResult(checkIntent, REQ_TTS_STATUS_CHECK);
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if(requestCode == REQ_TTS_STATUS_CHECK)
{
switch (resultCode) {
case TextToSpeech.Engine.CHECK_VOICE_DATA_PASS:
//这个返回结果表明TTS Engine可以用
{
mTts = new TextToSpeech(this, this);
Log.v(TAG, "TTS Engine is installed!");
}
break;
case TextToSpeech.Engine.CHECK_VOICE_DATA_BAD_DATA:
//需要的语音数据已损坏
case TextToSpeech.Engine.CHECK_VOICE_DATA_MISSING_DATA:
//缺少需要语言的语音数据
case TextToSpeech.Engine.CHECK_VOICE_DATA_MISSING_VOLUME:
//缺少需要语言的发音数据
{
//这三种情况都表明数据有错,重新下载安装需要的数据
Log.v(TAG, "Need language stuff:"+resultCode);
Intent dataIntent = new Intent();
dataIntent.setAction(TextToSpeech.Engine.ACTION_INSTALL_TTS_DATA);
startActivity(dataIntent);
}
break;
case TextToSpeech.Engine.CHECK_VOICE_DATA_FAIL:
//检查失败
default:
Log.v(TAG, "Got a failure. TTS apparently not available");
break;
}
}
else
{
//其他Intent返回的结果
}
}

下一步，初始化TTS。

java代码：

//实现TTS初始化接口
@Override
public void onInit(int status) {
// TODO Auto-generated method stub
//TTS Engine初始化完成
if(status == TextToSpeech.SUCCESS)
{
int result = mTts.setLanguage(Locale.US);
//设置发音语言
if(result == TextToSpeech.LANG_MISSING_DATA || result == TextToSpeech.LANG_NOT_SUPPORTED)
//判断语言是否可用
{
Log.v(TAG, "Language is not available");
speakBtn.setEnabled(false);
}
else
{
mTts.speak("This is an example of speech synthesis.", TextToSpeech.QUEUE_ADD, null);
speakBtn.setEnabled(true);
}
}
}

接下来，设置发音语言

java代码：

public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
// TODO Auto-generated method stub
int pos = langSelect.getSelectedItemPosition();
int result = -1;
switch (pos) {
case 0:
{
inputText.setText("I love you");
result = mTts.setLanguage(Locale.US);
}
break;
case 1:
{
inputText.setText("Je t'aime");
result = mTts.setLanguage(Locale.FRENCH);
}
break;
case 2:
{
inputText.setText("Ich liebe dich");
result = mTts.setLanguage(Locale.GERMAN);
}
break;
case 3:
{
inputText.setText("Ti amo");
result = mTts.setLanguage(Locale.ITALIAN);
}
break;
case 4:
{
inputText.setText("Te quiero");
result = mTts.setLanguage(new Locale("spa", "ESP"));
}
break;
default:
break;
}
//设置发音语言
if(result == TextToSpeech.LANG_MISSING_DATA || result == TextToSpeech.LANG_NOT_SUPPORTED)
//判断语言是否可用
{
Log.v(TAG, "Language is not available");
speakBtn.setEnabled(false);
}
else
{
speakBtn.setEnabled(true);
}
}

最后点击Button按钮发音：

java代码：

public void onClick(View v) {
// TODO Auto-generated method stub
mTts.speak(inputText.getText().toString(), TextToSpeech.QUEUE_ADD, null);
//朗读输入框里的内容
}

 

http://hi.baidu.com/shixying/item/e0c024db9be6f9eb54347ff8

 

 

Android1.6后在模拟器中加入TTS引擎 Pico，进行TextToSpeech处理。该引擎支持德语，法语，英语，意大利语，西班牙语等不支持汉语。如果想对汉语进行TTS处理，需要下载汉语的TTS引擎，Google Play上可以进行下载。

下面将具体实现方式进行简要介绍。其代码如下：

 

import java.util.HashMap;

import java.util.StringTokenizer;

import android.app.Activity;

import android.content.Intent;

import android.os.Bundle;

import android.speech.tts.TextToSpeech;

import android.speech.tts.TextToSpeech.OnInitListener;

import android.speech.tts.TextToSpeech.OnUtteranceCompletedListener;

import android.util.Log;

import android.view.View;

import android.widget.Button;

import android.widget.EditText;

public class TTSProActivity extends Activity implements OnInitListener,OnUtteranceCompletedListener{

    private EditText wordsToSpeak=null;

    private Button btnSpeak=null;

    private TextToSpeech tts=null;

    private int utterance=-1;

    private int uttCount=0;

    private HashMap<String,String> params=new HashMap<String, String>();

    private static final int REQ_CODE=100;

    private static final String TAG="------TTSProActivity----";

    @Override

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.main);

        wordsToSpeak=(EditText)findViewById(R.id.wordsToSpeak);

        btnSpeak=(Button)findViewById(R.id.btnSpeak);

        //TTS is exists

        Intent intent=new Intent();

        intent.setAction(TextToSpeech.Engine.ACTION_CHECK_TTS_DATA);

        startActivityForResult(intent, REQ_CODE);

        Log.v(TAG,"onCreate is called!");

    }

    @Override

    protected void onActivityResult(int requestCode, int resultCode, Intent data) {

    // TODO Auto-generated method stub

    super.onActivityResult(requestCode, resultCode, data);

    if(requestCode==REQ_CODE){

    switch (resultCode) {

case TextToSpeech.Engine.CHECK_VOICE_DATA_PASS:

tts=new TextToSpeech(this,this);

break;

case TextToSpeech.Engine.CHECK_VOICE_DATA_BAD_DATA:

case TextToSpeech.Engine.CHECK_VOICE_DATA_MISSING_VOLUME:

case TextToSpeech.Engine.CHECK_VOICE_DATA_MISSING_DATA:

   Intent intent=new Intent();

   intent.setAction(TextToSpeech.Engine.ACTION_INSTALL_TTS_DATA);

   startActivity(intent);

break;

default:

break;

}

    }

    }

@Override

public void onInit(int status) {

Log.d(TAG,"onInit");

//TTS engine ready

if(status==TextToSpeech.SUCCESS){

btnSpeak.setEnabled(true);

tts.setOnUtteranceCompletedListener(this);

}

}

@Override

protected void onPause() {

// TODO Auto-generated method stub

super.onPause();

if(tts!=null){

tts.stop();

}

}

@Override

protected void onDestroy() {

// TODO Auto-generated method stub

super.onDestroy();

if(tts!=null){

tts.shutdown();

}

}

public void ttsStart(View view){

StringTokenizer st=new StringTokenizer(wordsToSpeak.getText().toString(),",.");

while(st.hasMoreTokens()){

   params.put(TextToSpeech.Engine.KEY_PARAM_UTTERANCE_ID,String.valueOf(uttCount++));

tts.speak(st.nextToken(), TextToSpeech.QUEUE_ADD,params);

}

}

@Override

public void onUtteranceCompleted(String utteranceId) {

// TODO Auto-generated method stub

Log.d(TAG,"utteranceId:"+utteranceId);

utterance=Integer.parseInt(utteranceId);

}

}

在此解释一下，该Activity实现 OnInitListener,OnUtteranceCompletedListener两个接口，其中OnUtteranceCompletedListener是可选择的。该接口主要是为了进行keep track，记录TTS朗读的位置，该接口详解可参见API文档。

值得一提的是需要在onPause及onDestroy方法中对于TextToSpeech进行处理。

 

http://my.oschina.net/u/251121/blog/58107

 

一、概述

      TextToSpeech，就是将文本内容转换成语音，在其他的一些应用中经常可以看到。这个功能还是挺强大的，但是用户利用它来编写应用却很简单。

二、要求

     能够将文本内容转换成语音并朗读出来；可以一次全部朗读出来，也可以边写边读；可以将文本保存为语音文件。

三、实现

     新建工程MySpeak，修改/res/layout/main.xml文件，在里面添加一个EditText，两个Button和一个CheckBox，完整的main.xml文件如下：

 1 <?xml version="1.0" encoding="utf-8"?>

 2 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

 3     android:layout_width="fill_parent"

 4     android:layout_height="fill_parent"

 5     android:orientation="vertical" >

 6 

 7     <EditText 

 8         android:id="@+id/edittext"

 9         android:layout_width="fill_parent"

10         android:layout_height="wrap_content"

11         />

12     

13     <Button 

14         android:id="@+id/rbutton"

15         android:layout_width="fill_parent"

16         android:layout_height="wrap_content"

17         android:text="朗读"

18         />

19     

20     <Button 

21         android:id="@+id/sbutton"

22         android:layout_width="fill_parent"

23         android:layout_height="wrap_content"

24         android:text="保存"

25         />

26     

27     <CheckBox 

28         android:id="@+id/checkbox"

29         android:layout_width="fill_parent"

30         android:layout_height="wrap_content"

31         android:text="边写边读"

32         android:checked="true"

33         /> 

34         

35 

36 </LinearLayout>

修改MySpeakActivity.java文件，设置两个Button按钮的监听和EditText的内容变化监听，完整的MySpeakActivity.java内容如下：

 

  1 package com.nan.speak;

  2 

  3 import java.util.Locale;

  4 

  5 import android.app.Activity;

  6 import android.os.Bundle;

  7 import android.speech.tts.TextToSpeech;

  8 import android.text.Editable;

  9 import android.text.TextWatcher;

 10 import android.view.View;

 11 import android.widget.Button;

 12 import android.widget.CheckBox;

 13 import android.widget.EditText;

 14 import android.widget.Toast;

 15 

 16 

 17 public class MySpeakActivity extends Activity 

 18 {

 19     private EditText mEditText = null;

 20     private Button readButton = null;

 21     private Button saveButton = null;

 22     private CheckBox mCheckBox = null;

 23     private TextToSpeech mTextToSpeech = null;

 24     

 25     /** Called when the activity is first created. */

 26     @Override

 27     public void onCreate(Bundle savedInstanceState) 

 28     {

 29         super.onCreate(savedInstanceState);

 30         setContentView(R.layout.main);

 31         

 32         mEditText = (EditText)this.findViewById(R.id.edittext);

 33         readButton = (Button)this.findViewById(R.id.rbutton);

 34         saveButton = (Button)this.findViewById(R.id.sbutton);

 35         mCheckBox = (CheckBox)this.findViewById(R.id.checkbox);

 36         //实例并初始化TTS对象

 37         mTextToSpeech = new TextToSpeech(this,new TextToSpeech.OnInitListener()

 38         {

 39 

 40             @Override

 41             public void onInit(int status) 

 42             {

 43                 // TODO Auto-generated method stub

 44                 if(status == TextToSpeech.SUCCESS)

 45                 {

 46                     //设置朗读语言

 47                     int supported = mTextToSpeech.setLanguage(Locale.US);

 48                     if((supported != TextToSpeech.LANG_AVAILABLE)&&(supported != TextToSpeech.LANG_COUNTRY_AVAILABLE))

 49                     {

 50                         displayToast("不支持当前语言！");

 51                     }

 52                 }

 53             }

 54             

 55         });     

 56         //朗读按钮监听

 57         readButton.setOnClickListener(new View.OnClickListener() 

 58         {

 59             

 60             @Override

 61             public void onClick(View v) 

 62             {

 63                 // TODO Auto-generated method stub

 64                 //朗读EditText里的内容

 65                 mTextToSpeech.speak(mEditText.getText().toString(), TextToSpeech.QUEUE_FLUSH, null);

 66             }

 67         });

 68         //保存按钮监听

 69         saveButton.setOnClickListener(new View.OnClickListener() 

 70         {

 71             

 72             @Override

 73             public void onClick(View v) 

 74             {

 75                 // TODO Auto-generated method stub

 76                 

 77                 //将EditText里的内容保存为语音文件

 78                 int r = mTextToSpeech.synthesizeToFile(mEditText.getText().toString(), null, "/mnt/sdcard/speak.wav");

 79                 if(r == TextToSpeech.SUCCESS)

 80                     displayToast("保存成功！");                

 81             }

 82         });

 83         //EditText内容变化监听

 84         mEditText.addTextChangedListener(mTextWatcher);

 85         

 86     }

 87     

 88     

 89     private TextWatcher mTextWatcher = new TextWatcher()

 90     {

 91 

 92         @Override

 93         public void afterTextChanged(Editable s) 

 94         {

 95             // TODO Auto-generated method stub

 96             //如果是边写边读

 97             if(mCheckBox.isChecked()&&(s.length()!=0))

 98             {

 99                 //获得EditText的所有内容

100                 String t = s.toString();        

101                 mTextToSpeech.speak(t.substring(s.length()-1), TextToSpeech.QUEUE_FLUSH, null);

102             }

103         }

104 

105         @Override

106         public void beforeTextChanged(CharSequence s, int start, int count,

107                 int after) 

108         {

109             // TODO Auto-generated method stub

110             

111         }

112 

113         @Override

114         public void onTextChanged(CharSequence s, int start, int before,

115                 int count) 

116         {

117             // TODO Auto-generated method stub

118             

119         }

120     }; 

121       

122     //显示Toast函数

123     private void displayToast(String s)

124     {

125         Toast.makeText(MySpeakActivity.this, s, Toast.LENGTH_SHORT).show();

126     }

127     

128     

129     @Override

130     public void onDestroy()

131     {

132         super.onDestroy();

133         

134         if(mTextToSpeech != null)

135             mTextToSpeech.shutdown();//关闭TTS

136     }

137     

138 }

最后，在AndroidManifest.xml文件中加入权限：

 

1 <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

好了，运行该程序：

http://lib.open-open.com/view/open1333356529733.html