随着从事 Android 开发年限增加，负责的工作项目也从应用层开发逐步过渡到 Android Framework 层开发。虽然一开始就知道 Android 知识体系的庞大，但是当你逐渐从 Application 层向 Framework 层走的时候，你才发现之前懂得认知真是太少。之前更多打交道的 Activity 和 Fragment ，对于 Service 和 Broadcast 涉及的很少，更多注重的是界面的布局、动画、网络请求等，虽然走应用开发的话，后期会关注架构、性能优化、Hybrid等，但是逐渐接触 Framework 层相关模块时候，发现里面的知识点各种错综复杂，就好比讲讲今天分享的主题是 Android TTS 。
话不多说，先来张图，分享大纲如下：
大纲
之前受一篇文章启发，说的是如何讲解好一个技术点知识，可以分为两部分去介绍：外部应用维度和内部设计维度，基本从这两个角度出发，可以把一个技术点讲的透彻。同样，我把这种方式应用到写作中去。
外部应用维度
什么是 TTS
在 Android 中，TTS全称叫做 Text to Speech，从字面就能理解它解决的问题是什么，把文本转为语音服务，意思就是你输入一段文本信息，然后Android 系统可以把这段文字播报出来。这种应用场景目前比较多是在各种语音助手APP上，很多手机系统集成商内部都有内置文本转语音服务，可以读当前页面上的文本信息。同样，在一些阅读类APP上我们也能看到相关服务，打开微信读书，里面就直接可以把当前页面直接用语音方式播放出来，特别适合哪种不方便拿着手机屏幕阅读的场景。
TTS 技术规范
这里主要用到的是TextToSpeech类来完成，使用TextToSpeech的步骤如下：
创建TextToSpeech对象，创建时传入OnInitListener监听器监听示范创建成功。
设置TextToSpeech所使用语言国家选项，通过返回值判断TTS是否支持该语言、国家选项。
调用speak()或synthesizeToFile方法。
关闭TTS，回收资源。
XML文件
Activity文件
public class TtsMainActivity extends AppCompatActivity implements View.OnClickListener,TextToSpeech.OnInitListener {
private static final String TAG = TtsMainActivity.class.getSimpleName();
private static final int THREADNUM = 100; // 测试用的线程数目
private EditText mTestEt1;
private EditText mTestEt2;
private TextToSpeech mTTS; // TTS对象
private XKAudioPolicyManager mXKAudioPolicyManager;
private HashMap mParams = null;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mTestEt1 = (EditText) findViewById(R.id.edit_text1);
mTestEt2 = (EditText) findViewById(R.id.edit_text2);
findViewById(R.id.btn_tts1).setOnClickListener(this);
findViewById(R.id.btn_tts2).setOnClickListener(this);
findViewById(R.id.btn_cycle).setOnClickListener(this);
findViewById(R.id.btn_second).setOnClickListener(this);
init();
}
private void init(){
mTTS = new TextToSpeech(this.getApplicationContext(),this);
mXKAudioPolicyManager = XKAudioPolicyManager.getInstance(this.getApplication());
mParams = new HashMap();
mParams.put(TextToSpeech.Engine.KEY_PARAM_STREAM, "3"); //设置播放类型（音频流类型）
}
@Override
public void onInit(int status) {
if (status == TextToSpeech.SUCCESS) {
int result = mTTS.setLanguage(Locale.ENGLISH);
if (result == TextToSpeech.LANG_MISSING_DATA || result == TextToSpeech.LANG_NOT_SUPPORTED) {
Toast.makeText(this, "数据丢失或不支持", Toast.LENGTH_SHORT).show();
}
}
}
@Override
public void onClick(View v) {
int id = v.getId();
switch (id){
case R.id.btn_tts1:
TtsPlay1();
break;
case R.id.btn_tts2:
TtsPlay2();
break;
case R.id.btn_second:
TtsSecond();
break;
case R.id.btn_cycle:
TtsCycle();
break;
default:
break;
}
}
private void TtsPlay1(){
if (mTTS != null && !mTTS.isSpeaking() && mXKAudioPolicyManager.requestAudioSource()) {
//mTTS.setOnUtteranceProgressListener(new ttsPlayOne());
String text1 = mTestEt1.getText().toString();
Log.d(TAG, "TtsPlay1-----------播放文本内容：" + text1);
//朗读，注意这里三个参数的added in API level 4 四个参数的added in API level 21
mTTS.speak(text1, TextToSpeech.QUEUE_FLUSH, mParams);
}
}
private void TtsPlay2(){
if (mTTS != null && !mTTS.isSpeaking() && mXKAudioPolicyManager.requestAudioSource()) {
//mTTS.setOnUtteranceProgressListener(new ttsPlaySecond());
String text2 = mTestEt2.getText().toString();
Log.d(TAG, "TtsPlay2-----------播放文本内容：" + text2);
// 设置音调，值越大声音越尖（女生），值越小则变成男声,1.0是常规
mTTS.setPitch(0.8f);
//设定语速 ，默认1.0正常语速
mTTS.setSpeechRate(1f);
//朗读，注意这里三个参数的added in API level 4 四个参数的added in API level 21
mTTS.speak(text2, TextToSpeech.QUEUE_FLUSH, mParams);
}
}
private void TtsSecond(){
Intent intent = new Intent(TtsMainActivity.this,TtsSecondAcitivity.class);
startActivity(intent);
}
private void TtsCycle(){
long millis1 = System.currentTimeMillis();
for (int i = 0; i < THREADNUM; i++) {
Thread tempThread = new Thread(new MyRunnable(i, THREADNUM));
tempThread.setName("线程" + i);
tempThread.start();
}
long millis2 = System.currentTimeMillis();
Log.d(TAG, "循环测试发音耗费时间：" + (millis2 - millis1));
}
@Override
protected void onStart() {
super.onStart();
}
@Override
protected void onStop() {
super.onStop();
}
@Override
protected void onDestroy() {
super.onDestroy();
shutDown();
}
private void shutDown(){
if(mTTS != null){
mTTS.stop();
mTTS.shutdown();
}
if(mXKAudioPolicyManager != null){
mXKAudioPolicyManager.releaseAudioSource();
}
}
/**
* 自定义线程可执行处理
* */
class MyRunnable implements Runnable {
private int i; // 第几个线程
private int threadNum; // 总共创建了几个线程
public MyRunnable(int i, int threadNum) {
this.i = i;
this.threadNum = threadNum;
}
@Override
public void run() {
runOnUiThread(new Runnable() {
@Override
public void run() {
Log.d(TAG, "在主线程中执行index：" + i + ",线程总数:" + threadNum);
if(i % 2 == 0){
Log.d(TAG, "TtsPlay1 index：" + i);
TtsPlay1();
}
else{
Log.d(TAG, "TtsPlay2 index：" + i);
TtsPlay2();
}
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
}
public class ttsPlayOne extends UtteranceProgressListener{
@Override
public void onStart(String utteranceId) {
Log.d(TAG, "ttsPlayOne-----------onStart");
}
@Override
public void onDone(String utteranceId) {
Log.d(TAG, "ttsPlayOne-----------onDone");
}
@Override
public void onError(String utteranceId) {
Log.d(TAG, "ttsPlayOne-----------onError");
}
}
public class ttsPlaySecond extends UtteranceProgressListener{
@Override
public void onStart(String utteranceId) {
Log.d(TAG, "ttsPlaySecond-----------onStart");
}
@Override
public void onDone(String utteranceId) {
Log.d(TAG, "ttsPlaySecond-----------onDone");
}
@Override
public void onError(String utteranceId) {
Log.d(TAG, "ttsPlaySecond-----------onError");
}
}
}
加上权限
TTS 最佳实践
由于目前我在公司负责开发的产品是属于语音助手类型，自然这类 TTS 发声的问题和坑日常见的比较多。常见的有如下几种类型：
- 系统自带的 TTS 功能是不支持中文的，想要支持中文的话，需要借助第三方引擎，比如常见的科大讯飞、百度等。
- 如果换成支持中文引擎的话，一旦输入的文本中有夹杂着英文，那么有时候第三方TTS引擎有时候就很不友好，有时候会把英文单词每个字母读出来，英文甚至是发音不了，这里就需要注意下引擎的测试。
- 在设置 TTS 参数的时候，需要注意语速、音高、音调的上限值，有时候参数可能是0-100的范围，有时候有些参数是在0-10的范围，特别需要根据不同引擎参数的值类型去设定。
使用趋势
随着物联网的到来，IoT设备增多，那么对于类似语音助手相关应用也会增多，因为语音是一个很好的入口，现在逐步从显示到去显示的过程，很多智能设备有些是不需要屏幕的，只需要能识别语音和播放声音。因此，随着这类应用的增长，对于TTS 相关的API接口调用频率肯定也是加大，相信谷歌在这方面也会逐步在完善。
内部设计维度
从外部使用角度入手，基本是熟悉API接口和具体项目中应用碰到的问题，然后不断总结出来比较优化的实践方式。了解完外部角度切入，那么我们需要里面内部设计是怎么一回事，毕竟作为一个开发者，知道具体实现原理是一个基本功。
解决目标
Android TTS 目标就是解决文本转化为语音播报的过程。那它到底是怎么实现的呢，我们从TextToSpeech类的构造函数开始分析。
这里我们用Android 6.0版本源码分析为主，主要涉及的相关类和接口文件，在源码中的位置如下：
framework\base\core\java\android\speech\tts\TextToSpeech.java
framework\base/core\java/android\speech\tts\TextToSpeechService.java
external\svox\pico\src\com\svox\pico\PicoService.java
external\svox\pico\compat\src\com\android\tts\compat\CompatTtsService.java
external\svox\pico\compat\src\com\android\tts\compat\SynthProxy.java
external\svox\pico\compat\jni\com_android_tts_compat_SynthProxy.cpp
external\svox\pico\tts\com_svox_picottsengine.cpp
实现原理
初始化角度：先看TextToSpeech类，在使用时，一般TextToSpeech类要进行初始化，它的构造函数有三个，最后真正调用的构造函数代码如下：
/**
* Used by the framework to instantiate TextToSpeech objects with a supplied
* package name, instead of using {@link android.content.Context#getPackageName()}
*
* @hide
*/
public TextToSpeech(Context context, OnInitListener listener, String engine,
String packageName, boolean useFallback) {
mContext = context;
mInitListener = listener;
mRequestedEngine = engine;
mUseFallback = useFallback;
mEarcons = new HashMap();
mUtterances = new HashMap();
mUtteranceProgressListener = null;
mEnginesHelper = new TtsEngines(mContext);
initTts();
}
从构造函数可以看到，调用到initTts操作，我们看下initTts方法里是什么东东，代码如下：
private int initTts() {
// Step 1: Try connecting to the engine that was requested.
if (mRequestedEngine != null) {
if (mEnginesHelper.isEngineInstalled(mRequestedEngine)) {
if (connectToEngine(mRequestedEngine)) {
mCurrentEngine = mRequestedEngine;
return SUCCESS;
} else if (!mUseFallback) {
mCurrentEngine = null;
dispatchOnInit(ERROR);
return ERROR;
}
} else if (!mUseFallback) {
Log.i(TAG, "Requested engine not installed: " + mRequestedEngine);
mCurrentEngine = null;
dispatchOnInit(ERROR);
return ERROR;
}
}
// Step 2: Try connecting to the user's default engine.
final String defaultEngine = getDefaultEngine();
if (defaultEngine != null && !defaultEngine.equals(mRequestedEngine)) {
if (connectToEngine(defaultEngine)) {
mCurrentEngine = defaultEngine;
return SUCCESS;
}
}
// Step 3: Try connecting to the highest ranked engine in the
// system.
final String highestRanked = mEnginesHelper.getHighestRankedEngineName();
if (highestRanked != null && !highestRanked.equals(mRequestedEngine) &&
!highestRanked.equals(defaultEngine)) {
if (connectToEngine(highestRanked)) {
mCurrentEngine = highestRanked;
return SUCCESS;
}
}
// NOTE: The API currently does not allow the caller to query whether
// they are actually connected to any engine. This might fail for various
// reasons like if the user disables all her TTS engines.
mCurrentEngine = null;
dispatchOnInit(ERROR);
return ERROR;
}
这里比较有意思了，第一步先去连接用户请求的TTS引擎服务（这里可以让我们自定义TTS引擎，可以替换系统默认的引擎），如果没找到连接用户的TTS引擎，那么就去连接默认引擎，最后是连接高性能引擎，从代码可以看出高性能引擎优先级最高，默认引擎其次，connectToEngine方法代码如下：
private boolean connectToEngine(String engine) {
Connection connection = new Connection();
Intent intent = new Intent(Engine.INTENT_ACTION_TTS_SERVICE);
intent.setPackage(engine);
boolean bound = mContext.bindService(intent, connection, Context.BIND_AUTO_CREATE);
if (!bound) {
Log.e(TAG, "Failed to bind to " + engine);
return false;
} else {
Log.i(TAG, "Sucessfully bound to " + engine);
mConnectingServiceConnection = connection;
return true;
}
}
这里的Engine.INTENT_ACTION_TTS_SERVICE的值为"android.intent.action.TTS_SERVICE";其连接到的服务为action，为"android.intent.action.TTS_SERVICE"的服务，在external\svox\pico目录中的AndroidManifest.xml文件可以发现：
系统自带的默认连接的服务叫做PicoService，其具体代码如下：其继承于CompatTtsService。
public class PicoService extends CompatTtsService {
private static final String TAG = "PicoService";
@Override
protected String getSoFilename() {
return "libttspico.so";
}
}
我们再来看看CompatTtsService这个类，这个类为抽象类，它的父类为TextToSpeechService,其有一个成员SynthProxy类，该类负责调用TTS的C++层代码。如图：
CompatTtsService代码
我们来看看CompatTtsService的onCreate()方法，该方法中主要对SynthProxy进行了初始化：
@Override
public void onCreate() {
if (DBG) Log.d(TAG, "onCreate()");
String soFilename = getSoFilename();
if (mNativeSynth != null) {
mNativeSynth.stopSync();
mNativeSynth.shutdown();
mNativeSynth = null;
}
// Load the engineConfig from the plugin if it has any special configuration
// to be loaded. By convention, if an engine wants the TTS framework to pass
// in any configuration, it must put it into its content provider which has the URI:
// content://.providers.SettingsProvider
// That content provider must provide a Cursor which returns the String that
// is to be passed back to the native .so file for the plugin when getString(0) is
// called on it.
// Note that the TTS framework does not care what this String data is: it is something
// that comes from the engine plugin and is consumed only by the engine plugin itself.
String engineConfig = "";
Cursor c = getContentResolver().query(Uri.parse("content://" + getPackageName()
+ ".providers.SettingsProvider"), null, null, null, null);
if (c != null){
c.moveToFirst();
engineConfig = c.getString(0);
c.close();
}
mNativeSynth = new SynthProxy(soFilename, engineConfig);
// mNativeSynth is used by TextToSpeechService#onCreate so it must be set prior
// to that call.
// getContentResolver() is also moved prior to super.onCreate(), and it works
// because the super method don't sets a field or value that affects getContentResolver();
// (including the content resolver itself).
super.onCreate();
}
紧接着看看SynthProxy的构造函数都干了什么，我也不知道干了什么，但是里面有个静态代码块，其加载了ttscompat动态库，所以它肯定只是一个代理，实际功能由C++本地方法实现
/**
* Constructor; pass the location of the native TTS .so to use.
*/
public SynthProxy(String nativeSoLib, String engineConfig) {
boolean applyFilter = shouldApplyAudioFilter(nativeSoLib);
Log.v(TAG, "About to load "+ nativeSoLib + ", applyFilter=" + applyFilter);
mJniData = native_setup(nativeSoLib, engineConfig);
if (mJniData == 0) {
throw new RuntimeException("Failed to load " + nativeSoLib);
}
native_setLowShelf(applyFilter, PICO_FILTER_GAIN, PICO_FILTER_LOWSHELF_ATTENUATION,
PICO_FILTER_TRANSITION_FREQ, PICO_FILTER_SHELF_SLOPE);
}
我们可以看到，在构造函数中，调用了native_setup方法来初始化引擎，其实现在C++层(com_android_tts_compat_SynthProxy.cpp)。
nativeSetup代码
我们可以看到ngine->funcs->init(engine, __ttsSynthDoneCB, engConfigString);这句代码比较关键，这个init方法上面在com_svox_picottsengine.cpp中，如下：
/* Google Engine API function implementations */
/** init
* Allocates Pico memory block and initializes the Pico system.
* synthDoneCBPtr - Pointer to callback function which will receive generated samples
* config - the engine configuration parameters, here only contains the non-system path
* for the lingware location
* return tts_result
*/
tts_result TtsEngine::init( synthDoneCB_t synthDoneCBPtr, const char *config )
{
if (synthDoneCBPtr == NULL) {
ALOGE("Callback pointer is NULL");
return TTS_FAILURE;
}
picoMemArea = malloc( PICO_MEM_SIZE );
if (!picoMemArea) {
ALOGE("Failed to allocate memory for Pico system");
return TTS_FAILURE;
}
pico_Status ret = pico_initialize( picoMemArea, PICO_MEM_SIZE, &picoSystem );
if (PICO_OK != ret) {
ALOGE("Failed to initialize Pico system");
free( picoMemArea );
picoMemArea = NULL;
return TTS_FAILURE;
}
picoSynthDoneCBPtr = synthDoneCBPtr;
picoCurrentLangIndex = -1;
// was the initialization given an alternative path for the lingware location?
if ((config != NULL) && (strlen(config) > 0)) {
pico_alt_lingware_path = (char*)malloc(strlen(config));
strcpy((char*)pico_alt_lingware_path, config);
ALOGV("Alternative lingware path %s", pico_alt_lingware_path);
} else {
pico_alt_lingware_path = (char*)malloc(strlen(PICO_LINGWARE_PATH) + 1);
strcpy((char*)pico_alt_lingware_path, PICO_LINGWARE_PATH);
ALOGV("Using predefined lingware path %s", pico_alt_lingware_path);
}
return TTS_SUCCESS;
}
到这里，TTS引擎的初始化就完成了。
再看下TTS调用的角度，一般TTS调用的类是TextToSpeech中的speak()方法，我们来看看其执行流程：
public int speak(final CharSequence text,
final int queueMode,
final Bundle params,
final String utteranceId) {
return runAction(new Action() {
@Override
public Integer run(ITextToSpeechService service) throws RemoteException {
Uri utteranceUri = mUtterances.get(text);
if (utteranceUri != null) {
return service.playAudio(getCallerIdentity(), utteranceUri, queueMode,
getParams(params), utteranceId);
} else {
return service.speak(getCallerIdentity(), text, queueMode, getParams(params),
utteranceId);
}
}
}, ERROR, "speak");
}
主要是看runAction()方法：
private R runAction(Action action, R errorResult, String method,
boolean reconnect, boolean onlyEstablishedConnection) {
synchronized (mStartLock) {
if (mServiceConnection == null) {
Log.w(TAG, method + " failed: not bound to TTS engine");
return errorResult;
}
return mServiceConnection.runAction(action, errorResult, method, reconnect,
onlyEstablishedConnection);
}
}
主要看下mServiceConnection类的runAction方法，
public R runAction(Action action, R errorResult, String method,
boolean reconnect, boolean onlyEstablishedConnection) {
synchronized (mStartLock) {
try {
if (mService == null) {
Log.w(TAG, method + " failed: not connected to TTS engine");
return errorResult;
}
if (onlyEstablishedConnection && !isEstablished()) {
Log.w(TAG, method + " failed: TTS engine connection not fully set up");
return errorResult;
}
return action.run(mService);
} catch (RemoteException ex) {
Log.e(TAG, method + " failed", ex);
if (reconnect) {
disconnect();
initTts();
}
return errorResult;
}
}
}
可以发现最后会回调action.run(mService)方法。接着执行service.playAudio()，这里的service为PicoService，其继承于抽象类CompatTtsService，而CompatTtsService继承于抽象类TextToSpeechService。
所以会执行TextToSpeechService中的playAudio()，该方法位于TextToSpeechService中mBinder中。该方法如下：
@Override
public int playAudio(IBinder caller, Uri audioUri, int queueMode, Bundle params,
String utteranceId) {
if (!checkNonNull(caller, audioUri, params)) {
return TextToSpeech.ERROR;
}
SpeechItem item = new AudioSpeechItemV1(caller,
Binder.getCallingUid(), Binder.getCallingPid(), params, utteranceId, audioUri);
return mSynthHandler.enqueueSpeechItem(queueMode, item);
}
接着执行mSynthHandler.enqueueSpeechItem(queueMode, item),其代码如下：
/**
* Adds a speech item to the queue.
*
* Called on a service binder thread.
*/
public int enqueueSpeechItem(int queueMode, final SpeechItem speechItem) {
UtteranceProgressDispatcher utterenceProgress = null;
if (speechItem instanceof UtteranceProgressDispatcher) {
utterenceProgress = (UtteranceProgressDispatcher) speechItem;
}
if (!speechItem.isValid()) {
if (utterenceProgress != null) {
utterenceProgress.dispatchOnError(
TextToSpeech.ERROR_INVALID_REQUEST);
}
return TextToSpeech.ERROR;
}
if (queueMode == TextToSpeech.QUEUE_FLUSH) {
stopForApp(speechItem.getCallerIdentity());
} else if (queueMode == TextToSpeech.QUEUE_DESTROY) {
stopAll();
}
Runnable runnable = new Runnable() {
@Override
public void run() {
if (isFlushed(speechItem)) {
speechItem.stop();
} else {
setCurrentSpeechItem(speechItem);
speechItem.play();
setCurrentSpeechItem(null);
}
}
};
Message msg = Message.obtain(this, runnable);
// The obj is used to remove all callbacks from the given app in
// stopForApp(String).
//
// Note that this string is interned, so the == comparison works.
msg.obj = speechItem.getCallerIdentity();
if (sendMessage(msg)) {
return TextToSpeech.SUCCESS;
} else {
Log.w(TAG, "SynthThread has quit");
if (utterenceProgress != null) {
utterenceProgress.dispatchOnError(TextToSpeech.ERROR_SERVICE);
}
return TextToSpeech.ERROR;
}
}
主要是看 speechItem.play()方法，代码如下：
/**
* Plays the speech item. Blocks until playback is finished.
* Must not be called more than once.
*
* Only called on the synthesis thread.
*/
public void play() {
synchronized (this) {
if (mStarted) {
throw new IllegalStateException("play() called twice");
}
mStarted = true;
}
playImpl();
}
protected abstract void playImpl();
可以看到主要播放实现方法为playImpl()，那么在TextToSpeechService中的playAudio()中代码可以知道这里的speechitem为SynthesisSpeechItemV1。
因此在play中执行的playimpl()方法为SynthesisSpeechItemV1类中的playimpl()方法，其代码如下：
@Override
protected void playImpl() {
AbstractSynthesisCallback synthesisCallback;
mEventLogger.onRequestProcessingStart();
synchronized (this) {
// stop() might have been called before we enter this
// synchronized block.
if (isStopped()) {
return;
}
mSynthesisCallback = createSynthesisCallback();
synthesisCallback = mSynthesisCallback;
}
TextToSpeechService.this.onSynthesizeText(mSynthesisRequest, synthesisCallback);
// Fix for case where client called .start() & .error(), but did not called .done()
if (synthesisCallback.hasStarted() && !synthesisCallback.hasFinished()) {
synthesisCallback.done();
}
}
在playImpl方法中会执行onSynthesizeText方法，这是个抽象方法，记住其传递了一个synthesisCallback，后面会讲到。哪该方法具体实现是在哪里呢，没错，就是在TextToSpeechService的子类CompatTtsService中。来看看它怎么实现的：
@Override
protected void onSynthesizeText(SynthesisRequest request, SynthesisCallback callback) {
if (mNativeSynth == null) {
callback.error();
return;
}
// Set language
String lang = request.getLanguage();
String country = request.getCountry();
String variant = request.getVariant();
if (mNativeSynth.setLanguage(lang, country, variant) != TextToSpeech.SUCCESS) {
Log.e(TAG, "setLanguage(" + lang + "," + country + "," + variant + ") failed");
callback.error();
return;
}
// Set speech rate
int speechRate = request.getSpeechRate();
if (mNativeSynth.setSpeechRate(speechRate) != TextToSpeech.SUCCESS) {
Log.e(TAG, "setSpeechRate(" + speechRate + ") failed");
callback.error();
return;
}
// Set speech
int pitch = request.getPitch();
if (mNativeSynth.setPitch(pitch) != TextToSpeech.SUCCESS) {
Log.e(TAG, "setPitch(" + pitch + ") failed");
callback.error();
return;
}
// Synthesize
if (mNativeSynth.speak(request, callback) != TextToSpeech.SUCCESS) {
callback.error();
return;
}
}
最终又回到系统提供的pico引擎中，在com_android_tts_compat_SynthProxy.cpp这个文件中，可以看到使用speak方法，代码如下：
static jint
com_android_tts_compat_SynthProxy_speak(JNIEnv *env, jobject thiz, jlong jniData,
jstring textJavaString, jobject request)
{
SynthProxyJniStorage* pSynthData = getSynthData(jniData);
if (pSynthData == NULL) {
return ANDROID_TTS_FAILURE;
}
initializeFilter();
Mutex::Autolock l(engineMutex);
android_tts_engine_t *engine = pSynthData->mEngine;
if (!engine) {
return ANDROID_TTS_FAILURE;
}
SynthRequestData *pRequestData = new SynthRequestData;
pRequestData->jniStorage = pSynthData;
pRequestData->env = env;
pRequestData->request = env->NewGlobalRef(request);
pRequestData->startCalled = false;
const char *textNativeString = env->GetStringUTFChars(textJavaString, 0);
memset(pSynthData->mBuffer, 0, pSynthData->mBufferSize);
int result = engine->funcs->synthesizeText(engine, textNativeString,
pSynthData->mBuffer, pSynthData->mBufferSize, static_cast(pRequestData));
env->ReleaseStringUTFChars(textJavaString, textNativeString);
return (jint) result;
}
至此，TTS的调用就结束了。
TTS 优劣势
从实现原理我们可以看到Android系统原生自带了一个TTS引擎。那么在此，我们就也可以去自定义TTS引擎，只有继承ITextToSpeechService接口即可，实现里面的方法。这就为后续自定义TTS引擎埋下伏笔了，因为系统默认的TTS引擎是不支持中文，那么市场上比较好的TTS相关产品，一般是集成讯飞或者Nuance等第三方供应商。
因此，我们也可以看到TTS优劣势。
优势：接口定义完善，有着完整的API接口方法，同时支持扩展，可根据自身开发业务需求重新打造TTS引擎，并且与原生接口做兼容，可适配。
劣势：原生系统TTS引擎支持的多国语言有限，目前不支持多实例和多通道。
演进趋势
从目前来看，随着语音成为更多Iot设备的入口，那么在语音TTS合成播报方面技术会越来越成熟，特别是对于Android 系统原生相关的接口也会越来越强大。因此，对于TTS后续的发展，应该是冉冉上升。
小结
总的来说，对于一个知识点，前期通过使用文档介绍，到具体实践，然后在实践中优化进行总结，选择一个最佳的实践方案。当然不能满足“知其然而不知其所以然”，所以得去看背后的实现原理是什么。这个知识点优劣势是什么，在哪些场景比较适用，哪些场景不适用，接下来会演进趋势怎么样。通过这么一整套流程，那么对于一个知识点来说，可以算是了然于胸了。