目录

Before API development, you need to make necessary development preparations, ensure that the Maven repository address of the HMS Core SDK has been configured in your project, and the SDK of this service has been integrated.

1. Create a TTS engine. You can create a TTS engine using MLTtsConfig.

  1. // Use customized parameter settings to create a TTS engine.
  2. MLTtsConfig mlConfigs = new MLTtsConfig()
  3. // Set the text converted from speech to Chinese.
  4. // MLTtsConstants.TTS_EN_US: converts text to English.
  5. // MLTtsConstants.TTS_ZH_HANS: converts text to Chinese.
  6. // MLTtsConstants.TTS_LAN_ES_ES: converts text to Spanish.
  7. // MLTtsConstants.TTS_LAN_FR_FR: converts text to French.
  8.     .setLanguage(MLTtsConstants.TTS_ZH_HANS)
  9. // Set the Chinese timbre.
  10. // MLTtsConstants.TTS_SPEAKER_FEMALE_ZH: Chinese female voice.
  11. // MLTtsConstants.TTS_SPEAKER_MALE_ZH: Chinese male voice.
  12. // Set the English timbre.
  13. // MLTtsConstants.TTS_SPEAKER_FEMALE_EN: English female voice.
  14. // MLTtsconstants.TTS_SPEAKER_MALE_EN: English male voice.
  15. // MLTtsConstants.TTS_SPEAKER_FEMALE_FR: French female voice.
  16. // MLTtsconstants.TTS_SPEAKER_FEMALE_ES: Spanish female voice.
  17.     .setPerson(MLTtsConstants.TTS_SPEAKER_FEMALE_ZH)
  18. // Set the speech speed. Range: 0–2. 1.0 indicates normal speed.
  19.     .setSpeed(1.0f)
  20. // Set the volume. Range: 0–2. 1.0 indicates normal volume.
  21.     .setVolume(1.0f);
  22. MLTtsEngine mlTtsEngine = new MLTtsEngine(mlConfigs);
  23. // Update the configuration when the engine is running.
  24. mlTtsEngine.updateConfig(mlTtsConfig);

2. Create a TTS callback function to process the audio synthesis result.

  1. MLTtsCallback callback = new MLTtsCallback() {
  2.     @Override
  3.     public void onError(String taskId, MLTtsError err) {
  4. // Processing logic for TTS failure.
  5.     }
  6.     @Override
  7.     public void onWarn(String taskId, MLTtsWarn warn) {
  8. // Alarm handling without affecting service logic.
  9.     }
  10.     @Override 
  11. // Return the mapping between the currently played segment and text. start: start position of the audio segment in the input text; end (excluded): end position of the audio segment in the input text.
  12.     public void onRangeStart(String taskId, int start, int end) {
  13. // Process the mapping between the currently played segment and text.
  14.     }
  15.     @Override
  16. // taskId: ID of an audio synthesis task corresponding to the audio.
  17. // audioFragment: audio data.
  18. // offset: offset of the audio segment to be transmitted in the queue. One audio synthesis task corresponds to an audio synthesis queue.
  19. // range: text area where the audio segment to be transmitted is located; range.first (included): start position; range.second (excluded): end position.
  20.     public void onAudioAvailable(String taskId, MLTtsAudioFragment audioFragment, int offset, Pair<Integer, Integer> range,
  21.         Bundle bundle){
  22. // Audio stream callback API, which is used to return the synthesized audio data to the app.
  23.     }
  24.     @Override
  25.     public void onEvent(String taskId, int eventId, Bundle bundle) {
  26. // Callback method of an audio synthesis event. eventId: event name.
  27.        switch (eventId) {
  28.         case MLTtsConstants.EVENT_PLAY_START:
  29. // Called when playback starts.
  30.                 break;
  31.         case MLTtsConstants.EVENT_PLAY_STOP:
  32. // Called when playback stops.
  33.               boolean isInterrupted = bundle.getBoolean(MLTtsConstants.EVENT_PLAYSTOP_INTERRUPTED);
  34.                 break;
  35.         case MLTtsConstants.EVENT_PLAY_RESUME:
  36. // Called when playback resumes.
  37.                 break;
  38.         case MLTtsConstants.EVENT_PLAY_PAUSE:
  39. // Called when playback pauses.
  40.                 break;
  41.             }
  42. // Pay attention to the following callback events when you focus on only synthesized audio data but do not use the internal player for playback:
  43.         case MLTtsConstants.EVENT_SYNTHESIS_START:
  44. // Called when audio synthesis starts.
  45.                 break;
  46.         case MLTtsConstants.EVENT_SYNTHESIS_END:
  47. // Called when audio synthesis ends.
  48.                 break;
  49.         case MLTtsConstants.EVENT_SYNTHESIS_COMPLETE:
  50. // Audio synthesis is complete. All synthesized audio streams are passed to the app.
  51.             boolean isInterrupted = bundle.getBoolean(MLTtsConstants.EVENT_SYNTHESIS_INTERRUPTED);
  52.                 break;
  53.         default:
  54.                 break;
  55.         }
  56. }

3. Pass the TTS callback to the TTS engine created in step 1 to perform audio synthesis.

  1. mlTtsEngine.setTtsCallback(callback);
  2. /**
  3. *First parameter sourceText: text information to be synthesized. The value can contain a maximum of 500 characters.
  4. * Second parameter indicating the synthesis mode: The format is configA | configB | configC.
  5. *configA:
  6. *    MLTtsEngine.QUEUE_APPEND: After an audio synthesis task is generated, the audio synthesis task is processed as follows: If playback is going on, the task is added to the queue for execution in sequence; if playback pauses, the playback is resumed and the task is added to the queue for execution in sequence; if there is no playback, the audio synthesis task is executed immediately.
  7. *    MLTtsEngine.QUEUE_FLUSH: The ongoing audio synthesis task and playback are stopped immediately, all audio synthesis tasks in the queue are cleared, and the current audio synthesis task is executed immediately and played.
  8. *configB:
  9. *    MLTtsEngine.OPEN_STREAM: The synthesized audio data is output through onAudioAvailable.
  10. *configC:
  11. *    MLTtsEngine.EXTERNAL_PLAYBACK: external playback mode. The player provided by the SDK is shielded. You need to process the audio output by the onAudioAvailable callback API. In this case, the playback-related APIs in the callback APIs become invalid, and only the callback APIs related to audio synthesis can be listened.
  12. */
  13. // Use the built-in player of the SDK to play speech in queuing mode.
  14. String id = mlTtsEngine.speak(sourceText, MLTtsEngine.QUEUE_APPEND); 
  15. // In queuing mode, the synthesized audio stream is output through onAudioAvailable, and the built-in player of the SDK is used to play the speech.
  16. // String id = mlTtsEngine.speak(sourceText, MLTtsEngine.QUEUE_APPEND | MLTtsEngine.OPEN_STREAM); 
  17. // In queuing mode, the synthesized audio stream is output through onAudioAvailable, and the audio stream is not played, but controlled by you.
  18. // String id = mlTtsEngine.speak(sourceText, MLTtsEngine.QUEUE_APPEND | MLTtsEngine.OPEN_STREAM | MLTtsEngine.EXTERNAL_PLAYBACK);

4. Control the playback (valid only when an internal player is used).

  1. // Pause playback.
  2. mlTtsEngine.pause();
  3. // Resume playback.
  4. mlTtsEngine.resume();

5. Stop the current TTS task, clear all tasks (including tasks that are being played and have not been played) in the queue, and retain the TTS engine.

  1. mlTtsEngine.stop();

6. Destroy the TTS engine and release related resources.

  1. if (mlTtsEngine!= null) {
  2.     mlTtsEngine.shutdown();
  3. }