源码地址：https://github.com/yellowgreatsun/MXTtsEngine

前两篇文章即Android TTS系列一——如何让app具备tts能力和Android TTS系列二——如何开发一款系统级tts引擎？分别分享了如何让app具备tts能力和如何开发tts引擎，这篇文章会分享下speech包源码，我们会更明白speech包接口的来龙去脉。这部分之前在公司内部分享讲过一次，但发现写成文章还是很吃力的，我会尽量讲解清楚。另外，引用的代码我会略去一些不太关键的部分，避免文章太冗长。

为便于理解，我按照这个思路来进行分享：

• speech包的源码结构
• TextToSpeech的接口剖析
• TextToSpeech的接口如何通过TextToSpeechService来实现
• TextToSpeechService的实现如何回调回去

一、speech包的源码结构

speech源码路径：/frameworks/base/core/java/android/speech
先来看一下speech包的源码结构：

speech包源码.jpg

二、TextToSpeech的接口剖析

这里，我们只对构造方法、speck、synthesizeToFile进行剖析，其它的诸如setLanguage、getEngines，看了这篇分享后，会很容易理解的，所以不再写出来。

1.构造方法

构造方法有三个：

• TextToSpeech(Context context, OnInitListener listener)
• TextToSpeech(Context context, OnInitListener listener, String engine)
• TextToSpeech(Context context, OnInitListener listener, String engine,String packageName, boolean useFallback)
  看代码会发现，前两个最终还是调用了第三个。

  public TextToSpeech(Context context, OnInitListener listener, String engine,
            String packageName, boolean useFallback) {
        mContext = context;
        mInitListener = listener;
        mRequestedEngine = engine;
        mUseFallback = useFallback;
        initTts();
    }

前面一些赋值容易明白，关键信息在initTts()里。

  private int initTts() {
        // Step 1: Try connecting to the engine that was requested.
        if (connectToEngine(mRequestedEngine)) {
          mCurrentEngine = mRequestedEngine;
          return SUCCESS;
        }

        // 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;
            }
        }

        mCurrentEngine = null;
        dispatchOnInit(ERROR);
        return ERROR;
    }

看注释也能明白，initTts会按照这样一个顺序：指定的tts引擎（通过包名，构造方法中的参数engine）、默认的tts引擎、最常用的tts引擎。但这些对于我们理解speech源码不是最关键的，关键的在于connectToEngine(engine)，有没有发现，三种创建引擎的方式最终都调它了。如果connectToEngine返回false了，也就通过 dispatchOnInit(ERROR)告诉调用者失败了。那就看下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) {
            return false;
        } else {
            mConnectingServiceConnection = connection;
            return true;
        }
    }

到这里，我们就明白了，哦，原来是bind一个Service呀。指定了action为Engine.INTENT_ACTION_TTS_SERVICE，这就是在第二篇文章中，TextToSpeechService的实现类在mainfest中声明该action的原因。Connection太长，只看onServiceConnected吧。

    @Override
     public void onServiceConnected(ComponentName name, IBinder service) {
            synchronized(mStartLock) {
                mService = ITextToSpeechService.Stub.asInterface(service);
                mServiceConnection = Connection.this;
                mOnSetupConnectionAsyncTask = new SetupConnectionAsyncTask(name);
                mOnSetupConnectionAsyncTask.execute();
            }
     }

在这里，拿到了mService的实例，bind的是远程Service，TextToSpeech的其它接口，也是再调用 ITextToSpeechService下的接口。然后通过mOnSetupConnectionAsyncTask中的dispatchOnInit(result)来回调初始化成功。
构造方法就先说到这里。

2.speak(text,queueMode,params,utteranceId)

看代码会发现，最终调用了service.speak(getCallerIdentity(), text, queueMode, getParams(params),utteranceId)。明白这一点就先可以了。

3.synthesizeToFile(text,params,file,utteranceId)

类似于speak，synthesizeToFile最终调用的service.synthesizeToFileDescriptor(getCallerIdentity(), text,fileDescriptor, getParams(params), utteranceId)。

接下来，我们将进入TextToSpeechService，去探究下service.speak和service.synthesizeToFileDescriptor。

三、TextToSpeech的接口如何通过TextToSpeechService来实现

这部分比较长，我们一点点来看。

1.mBinder

通过对TextToSpeech构造方法的剖析，我们了解了它是通过绑定远程Service来实现的，而远程Service（也就是TTSEngine中的Service，比如我们的MoxiangTtsService）是继承的TextToSpeechService，所以重点看它就行了。首先要看下它的onBind。

    @Override
    public IBinder onBind(Intent intent) {
        if (Engine.INTENT_ACTION_TTS_SERVICE.equals(intent.getAction())) {
            return mBinder;
        }
        return null;
    }

mBinder 的实例化非常长，毕竟要把ITextToSpeechService的各个接口实现完。这里只贴出来我们关心的两个，即speak和synthesizeToFileDescriptor。

    private final ITextToSpeechService.Stub mBinder = new ITextToSpeechService.Stub() {
        
        @Override
        public int speak(IBinder caller, CharSequence text, int queueMode, Bundle params,
                String utteranceId) {
            SpeechItem item = new SynthesisSpeechItemV1(caller,
                    Binder.getCallingUid(), Binder.getCallingPid(), params, utteranceId, text);
            return mSynthHandler.enqueueSpeechItem(queueMode, item);
        }

        @Override
        public int synthesizeToFileDescriptor(IBinder caller, CharSequence text, ParcelFileDescriptor
                fileDescriptor, Bundle params, String utteranceId) {
            final ParcelFileDescriptor sameFileDescriptor = ParcelFileDescriptor.adoptFd(
                    fileDescriptor.detachFd());
            SpeechItem item = new SynthesisToFileOutputStreamSpeechItemV1(caller,
                    Binder.getCallingUid(), Binder.getCallingPid(), params, utteranceId, text,
                    new ParcelFileDescriptor.AutoCloseOutputStream(sameFileDescriptor));
            return mSynthHandler.enqueueSpeechItem(android.speech.tts.TextToSpeech.QUEUE_ADD, item);
        }

        ……
    }

这样，一下子就明白了，speak的实现又调了mSynthHandler.enqueueSpeechItem，mSynthHandler就是一个Handler，字面理解该接口，就是将text的语音合成加入了队列。synthesizeToFileDescriptor的实现竟也是调了mSynthHandler.enqueueSpeechItem，当然了，参数item不同，奥秘，这里有奥秘。

2.speak

上面已经说了，其实现是调mSynthHandler.enqueueSpeechItem，来，继续。

        public int enqueueSpeechItem(int queueMode, final SpeechItem speechItem) {
            
            UtteranceProgressDispatcher utterenceProgress = null;
            if (queueMode == android.speech.tts.TextToSpeech.QUEUE_FLUSH) {
                stopForApp(speechItem.getCallerIdentity());
            } else if (queueMode == android.speech.tts.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);
            msg.obj = speechItem.getCallerIdentity();

            if (sendMessage(msg)) {
                return android.speech.tts.TextToSpeech.SUCCESS;
            } else {
                if (utterenceProgress != null) {
                    utterenceProgress.dispatchOnError(android.speech.tts.TextToSpeech.ERROR_SERVICE);
                }
                return android.speech.tts.TextToSpeech.ERROR;
            }
        }

先看前面的，TextToSpeech的speak接口的参数mode在这里体现了，如果是TextToSpeech.QUEUE_FLUSH，会调用stopForApp停掉其它tts的播放，这里就不把代码贴出来了。我们关注的是speechItem.play()。

    public void play() {
        playImpl();
    }

playImpl，要看SynthesisSpeechItemV1下的实现了。

    @Override
    protected void playImpl() {
            AbstractSynthesisCallback synthesisCallback;
            synchronized (this) {
                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();
            }
    }

哎呦，终于看到了我们熟悉的onSynthesizeText(SynthesisRequest request,SynthesisCallback callback)。reques就是封装的tts合成请求的参数，在SynthesisSpeechItemV1的构造方法中封装的，callback是调用createSynthesisCallback创建的。

    protected AbstractSynthesisCallback createSynthesisCallback() {
        return new PlaybackSynthesisCallback(getAudioParams(),
                    mAudioPlaybackHandler, this, getCallerIdentity(), mEventLogger, false);
    }

3.synthesizeToFileDescriptor

上面我们已经说了，synthesizeToFileDescriptor和speak的区别，就在于SpeechItemV1的子类不同。speak是SynthesisSpeechItemV1，synthesizeToFileDescriptor是SynthesisToFileOutputStreamSpeechItemV1。二者到了playImpl的区别，也主要在于callback的不同，其创建方法是：

    protected AbstractSynthesisCallback createSynthesisCallback() {
        return new FileSynthesisCallback(mFileOutputStream.getChannel(), this, false);
    }

到了这里，我们已经明白了，TextToSpeech的接口是如何通过TextToSpeechService来实现。接下来，我们该关心如何将TextToSpeechService的实现回调回去。

四、TextToSpeechService的实现如何回调回去

1.speak

在第二篇时，我们已经讲解过要通过调用callback的各个接口来回传结果。这里，就看一下PlaybackSynthesisCallback中的start、audioAvailable和done。
关注几个实例：UtteranceProgressDispatcher mDispatcher、AudioPlaybackHandler mAudioTrackHandler和SynthesisPlaybackQueueItem mItem，它们均是在TextToSpeech中实例化的。第一个关系到最终到UtteranceProgressListener的回调，后两个关系到音频的播放。
贴出来三个方法：

    public int start(int sampleRateInHz, int audioFormat, int channelCount) {
        SynthesisPlaybackQueueItem item = new SynthesisPlaybackQueueItem(
                    mAudioParams, sampleRateInHz, audioFormat, channelCount,
                    mDispatcher, mCallerIdentity, mLogger);
        mAudioTrackHandler.enqueue(item);
        mItem = item;
    }

    public int audioAvailable(byte[] buffer, int offset, int length) {
        item = mItem;
        final byte[] bufferCopy = new byte[length];
        item.put(bufferCopy);
    }

    public int done() {
        if (mStatusCode == android.speech.tts.TextToSpeech.SUCCESS) {
            mDispatcher.dispatchOnSuccess();
        } else {
            mDispatcher.dispatchOnError(mStatusCode);
        }

        item = mItem;
        if (statusCode == android.speech.tts.TextToSpeech.SUCCESS) {
            item.done();
        } else {
            item.stop(statusCode);
        }
    }

先说回调，可以在PlaybackSynthesisCallback的done中看到，调用了mDispatcher.dispatchOnSuccess，进一步看是调用了ITextToSpeechCallback.onSuccess，进一步掉用了UtteranceProgressListener的onDone。其它也是也是如此，不再细说。注意的是，onStart不是直接在PlaybackSynthesisCallback中，而是在SynthesisPlaybackQueueItem中，毕竟这时候才是开始播放。
再说播放，AudioPlaybackHandler 虽然不是继承自Handler，但其作用与其类似，是管理各个tts合成请求是的队列。SynthesisPlaybackQueueItem 继承自Runnable的子类，播放是在这完成的，它会创建一个BlockingAudioTrack，具体播放不再叙述。

2.synthesizeToFile

它的callback是FileSynthesisCallback。
大体与PlaybackSynthesisCallback类似，只是它不是播放，而是写入指定的文件。这里面需要关注的实例有：UtteranceProgressDispatcher mDispatcher和FileChannel mFileChannel，后者就是写文件的。
贴出来三个方法：

    public int start(int sampleRateInHz, int audioFormat, int channelCount) {
        mDispatcher.dispatchOnStart();
        fileChannel.write(ByteBuffer.allocate(WAV_HEADER_LENGTH));
    }

    public int audioAvailable(byte[] buffer, int offset, int length) {
        fileChannel.write(ByteBuffer.wrap(buffer,  offset,  length));
    }

    public int done() {
       fileChannel.position(0);
        int dataLength = (int) (fileChannel.size() - WAV_HEADER_LENGTH);
        fileChannel.write(makeWavHeader(sampleRateInHz, audioFormat, channelCount, dataLength));
        mDispatcher.dispatchOnSuccess();
    }

需要注意的是done中的makeWavHeader，它是写入文件头信息。

OK，Android speech包源码剖析就讲到这里。至此，Android Tts系列就基本完成了，虽然还有一些细节没有讲到，比如Locale语言、设置默认引擎，但主体思路算是差不多了。
在这个过程中，一是对Android Tts的来龙去脉有了比较充分的认识；二是Android speech包的架构设计思想，甭管具体的Tts引擎是啥，你都得按照我的规范来（集成Service、实现接口），这样，都可以通过TextToSpeech的接口来调用。